Guide de démarrage rapide de Hello, tvOS

Ce guide vous guide tout au long de la création de votre première application Xamarin.tvOS et de sa chaîne d’outils de développement. Il présente également le Concepteur Xamarin, qui expose les contrôles d’interface utilisateur au code et montre comment générer, exécuter et tester une application Xamarin.tvOS.

Avertissement

Le concepteur iOS a été déconseillé dans Visual Studio 2019 version 16.8 et Visual Studio 2019 pour Mac version 8.8, et supprimé dans Visual Studio 2019 version 16.9 et Visual Studio pour Mac version 8.9. La méthode recommandée pour créer des interfaces utilisateur iOS est directement sur un Mac exécutant le Générateur d’interface de Xcode. Pour plus d’informations, consultez Conception d’interfaces utilisateur avec Xcode.

Apple a publié la 5ème génération d’Apple TV, apple TV 4K, qui exécute tvOS 11.

La plateforme Apple TV est ouverte aux développeurs, ce qui leur permet de créer des applications riches, immersives et de les publier via l’App Store intégré d’Apple TV.

Si vous êtes familiarisé avec le développement Xamarin.iOS, vous devez trouver la transition vers tvOS assez simple. La plupart des API et fonctionnalités sont identiques, mais de nombreuses API courantes ne sont pas disponibles (telles que WebKit). En outre, l’utilisation de Siri Remote pose certains défis de conception qui ne sont pas présents dans les appareils iOS basés sur l’écran tactile.

Ce guide présente l’utilisation de tvOS dans une application Xamarin. Pour plus d’informations sur tvOS, consultez la documentation d’Apple TV 4K .

Vue d’ensemble

Xamarin.tvOS vous permet de développer des applications Apple TV entièrement natives en C# et .NET à l’aide des mêmes bibliothèques et contrôles d’interface OS X utilisés lors du développement dans Swift (ou Objective-C) et Xcode.

En outre, étant donné que les applications Xamarin.tvOS sont écrites en C# et .NET, le code principal commun peut être partagé avec les applications Xamarin.iOS, Xamarin.Android et Xamarin.Mac ; tout en offrant une expérience native sur chaque plateforme.

Cet article vous présente les concepts clés nécessaires à la création d’une application Apple TV à l’aide de Xamarin.tvOS et de Visual Studio en vous promenant tout au long du processus de création d’une application Hello, tvOS de base qui compte le nombre de fois où un bouton a été cliqué :

Nous aborderons les concepts suivants :

• Visual Studio pour Mac : présentation du Visual Studio pour Mac et comment créer des applications Xamarin.tvOS avec celle-ci.
• Anatomie d’une application Xamarin.tvOS : présentation d’une application Xamarin.tvOS.
• Création d’une interface utilisateur : comment utiliser Xamarin Designer pour iOS pour créer une interface utilisateur.
• Déploiement et test : comment exécuter et tester votre application dans le simulateur tvOS et sur du matériel tvOS réel.

Démarrage d’une nouvelle application Xamarin.tvOS dans Visual Studio pour Mac

Comme indiqué ci-dessus, nous allons créer une application Apple TV appelée Hello-tvOS qui ajoute un bouton unique et une étiquette à l’écran principal. Quand vous cliquez sur le bouton, l’étiquette affiche le nombre de clics effectués.

Pour commencer, procédons comme suit :

1. Démarrez Visual Studio pour Mac :

   

2. Cliquez sur le lien Nouvelle solution... dans le coin supérieur gauche de l’écran pour ouvrir la boîte de dialogue Nouveau projet .

3. Sélectionnez l’application en mode unique de l’application> tvOS>, puis cliquez sur le bouton Suivant :

   

4. Entrez le nom de l’application, entrez Hello, tvOS l’identificateur de votre organisation, puis cliquez sur le bouton Suivant :

   

5. Entrez Hello_tvOS le nom du projet, puis cliquez sur le bouton Créer :

   

Visual Studio pour Mac créez la nouvelle application Xamarin.tvOS et affichez les fichiers par défaut qui sont ajoutés à la solution de votre application :

utilisations de Visual Studio pour MacSolutions et projets, exactement de la même façon que Visual Studio. Une solution est un conteneur qui peut contenir un ou plusieurs projets ; les projets peuvent inclure des applications, des bibliothèques de prise en charge, des applications de test, etc. Dans ce cas, Visual Studio pour Mac a créé une solution et un projet d’application pour vous.

Si vous le souhaitez, vous pouvez créer un ou plusieurs projets de bibliothèque de code qui contiennent du code commun et partagé. Ces projets de bibliothèque peuvent être consommés par le projet d’application ou partagés avec d’autres projets d’application Xamarin.tvOS (ou Xamarin.iOS, Xamarin.Android et Xamarin.Mac basés sur le type de code), comme vous le feriez si vous générez une application .NET standard.

Anatomie d’une application Xamarin.tvOS

Si vous êtes familiarisé avec la programmation iOS, vous remarquerez beaucoup de similitudes ici. En fait, tvOS 9 est un sous-ensemble d’iOS 9, donc beaucoup de concepts vont traverser ici.

Examinons les fichiers du projet :

• Main.cs : ce fichier contient le point d’entrée principal de l’application. Quand l’application est lancée, il contient la toute première classe et la méthode qui est exécutée.
• AppDelegate.cs : ce fichier contient la classe d’application principale responsable de l’écoute des événements du système d’exploitation.
• Info.plist : ce fichier contient des propriétés d’application telles que le nom de l’application, les icônes, etc.
• ViewController.cs : il s’agit de la classe qui représente la fenêtre principale et contrôle le cycle de vie de celui-ci.
• ViewController.designer.cs : ce fichier contient du code de plomberie qui vous permet d’intégrer l’interface utilisateur de l’écran principal.
• Main.storyboard : interface utilisateur de la fenêtre principale. Ce fichier peut être créé et géré par le Concepteur Xamarin pour iOS.

Dans les sections suivantes, nous allons examiner rapidement certains de ces fichiers. Nous allons les explorer plus en détail plus tard, mais il est judicieux de comprendre leurs principes de base maintenant.

Main.cs

Le Main.cs fichier contient une méthode statique Main qui crée une instance d’application Xamarin.tvOS et transmet le nom de la classe qui gère les événements de système d’exploitation, qui, dans notre cas, est la AppDelegate classe :

using UIKit;

namespace Hello_tvOS
{
    public class Application
    {
        // This is the main entry point of the application.
        static void Main (string[] args)
        {
            // if you want to use a different Application Delegate class from "AppDelegate"
            // you can specify it here.
            UIApplication.Main (args, null, "AppDelegate");
        }
    }
}

AppDelegate.cs

Le AppDelegate.cs fichier contient notre AppDelegate classe, qui est responsable de la création de notre fenêtre et de l’écoute des événements de système d’exploitation :

using Foundation;
using UIKit;

namespace Hello_tvOS
{
    // The UIApplicationDelegate for the application. This class is responsible for launching the
    // User Interface of the application, as well as listening (and optionally responding) to application events from iOS.
    [Register ("AppDelegate")]
    public class AppDelegate : UIApplicationDelegate
    {
        // class-level declarations

        public override UIWindow Window {
            get;
            set;
        }

        public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
        {
            // Override point for customization after application launch.
            // If not required for your application you can safely delete this method

            return true;
        }

        public override void OnResignActivation (UIApplication application)
        {
            // Invoked when the application is about to move from active to inactive state.
            // This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message)
            // or when the user quits the application and it begins the transition to the background state.
            // Games should use this method to pause the game.
        }

        public override void DidEnterBackground (UIApplication application)
        {
            // Use this method to release shared resources, save user data, invalidate timers and store the application state.
            // If your application supports background execution this method is called instead of WillTerminate when the user quits.
        }

        public override void WillEnterForeground (UIApplication application)
        {
            // Called as part of the transition from background to active state.
            // Here you can undo many of the changes made on entering the background.
        }

        public override void OnActivated (UIApplication application)
        {
            // Restart any tasks that were paused (or not yet started) while the application was inactive.
            // If the application was previously in the background, optionally refresh the user interface.
        }

        public override void WillTerminate (UIApplication application)
        {
            // Called when the application is about to terminate. Save data, if needed. See also DidEnterBackground.
        }
    }
}

Ce code n’est probablement pas familier, sauf si vous avez créé une application iOS avant, mais c’est assez simple. Examinons les lignes importantes.

Tout d’abord, examinons la déclaration de variable au niveau de la classe :

public override UIWindow Window {
            get;
            set;
        }

La Window propriété fournit l’accès à la fenêtre principale. tvOS utilise ce qu’on appelle le modèle MVC (Model View Controller ). En règle générale, pour chaque fenêtre que vous créez (et pour de nombreuses autres choses dans les fenêtres), il existe un contrôleur, qui est responsable du cycle de vie de la fenêtre, comme son affichage, l’ajout de nouvelles vues (contrôles) à celui-ci, etc.

Ensuite, nous avons la FinishedLaunching méthode. Cette méthode s’exécute une fois que l’application a été instanciée et qu’elle est chargée de créer réellement la fenêtre de l’application et de commencer le processus d’affichage dans celui-ci. Étant donné que notre application utilise un Storyboard pour définir son interface utilisateur, aucun code supplémentaire n’est requis ici.

Il existe de nombreuses autres méthodes fournies dans le modèle, telles que DidEnterBackground et WillEnterForeground. Celles-ci peuvent être supprimées en toute sécurité si les événements d’application ne sont pas utilisés dans votre application.

ViewController.cs

La ViewController classe est le contrôleur de notre fenêtre principale. Cela signifie qu’il est responsable du cycle de vie de la fenêtre principale. Nous allons examiner cela plus en détail plus tard, pour l’instant, examinons-le rapidement :

using System;
using Foundation;
using UIKit;

namespace Hello_tvOS
{
    public partial class ViewController : UIViewController
    {
        public ViewController (IntPtr handle) : base (handle)
        {
        }

        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();
            // Perform any additional setup after loading the view, typically from a nib.
        }

        public override void DidReceiveMemoryWarning ()
        {
            base.DidReceiveMemoryWarning ();
            // Release any cached data, images, etc that aren't in use.
        }
    }
}

ViewController.Designer.cs

Le fichier de concepteur de la classe Main Window est vide pour l’instant, mais il sera automatiquement rempli par Visual Studio pour Mac lors de la création de notre interface utilisateur avec le Concepteur iOS :

using Foundation;

namespace HellotvOS
{
    [Register ("ViewController")]
    partial class ViewController
    {
        void ReleaseDesignerOutlets ()
        {
        }
    }
}

Nous ne sommes généralement pas préoccupés par les fichiers de concepteur, car ils sont simplement gérés automatiquement par Visual Studio pour Mac et fournissent simplement le code de plomberie requis qui permet d’accéder aux contrôles que nous ajoutons à n’importe quelle fenêtre ou vue dans notre application.

Maintenant que nous avons créé notre application Xamarin.tvOS et que nous avons une compréhension de base de ses composants, examinons la création de l’interface utilisateur.

Création de l’interface utilisateur

Vous n’avez pas besoin d’utiliser Xamarin Designer pour iOS pour créer l’interface utilisateur de votre application Xamarin.tvOS, l’interface utilisateur peut être créée directement à partir du code C#, mais cela dépasse l’étendue de cet article. Par souci de simplicité, nous allons utiliser le Concepteur iOS pour créer notre interface utilisateur tout au long du reste de ce tutoriel.

Pour commencer à créer votre interface utilisateur, double-cliquez sur le Main.storyboard fichier dans le Explorateur de solutions pour l’ouvrir pour modification dans le Concepteur iOS :

Cela doit lancer le Concepteur et ressembler à ce qui suit :

Pour plus d’informations sur le Concepteur iOS et sur son fonctionnement, reportez-vous au guide d’introduction au concepteur Xamarin pour iOS .

Nous pouvons maintenant commencer à ajouter des contrôles à l’aire de conception de notre application Xamarin.tvOS.

Effectuez les actions suivantes :

1. Recherchez la boîte à outils, qui doit se trouver à droite de l’aire de conception :

   

   Si vous ne pouvez pas le localiser ici, accédez à La boîte à outils Afficher > les pavés > pour l’afficher.

2. Faites glisser une étiquette de la boîte à outils vers l’aire de conception :

   

3. Cliquez sur la propriété Title dans le panneau Propriétés et remplacez le titre Hello, tvOS du bouton par et définissez la taille de police sur 128 :

   

4. Redimensionnez l’étiquette afin que tous les mots soient visibles et placez-le centré en haut de la fenêtre :

   

5. L’étiquette doit maintenant être contrainte à sa position, afin qu’elle apparaisse comme prévu. quelle que soit la taille de l’écran. Pour ce faire, cliquez sur l’étiquette jusqu’à ce que la poignée en forme de T apparaisse :

   

6. Pour limiter l’étiquette horizontalement, sélectionnez le carré central et faites-le glisser vers la ligne en pointillé verticalement :

   

   L’étiquette doit tourner en orange.

7. Sélectionnez la poignée T en haut de l’étiquette, puis faites-la glisser vers le bord supérieur de la fenêtre :

   

8. Ensuite, cliquez sur la largeur, puis sur la poignée d’os de hauteur, comme illustré ci-dessous :

   

   Lorsque chaque poignée d’os est cliquée, sélectionnez Largeur et Hauteur respectivement pour définir des dimensions fixes.

9. Une fois terminées, vos contraintes doivent ressembler à celles de l’onglet Disposition du panneau Propriétés :

   

10. Faites glisser un bouton à partir de la boîte à outils et placez-le sous l’étiquette.

11. Cliquez sur la propriété Title dans le panneau Propriétés et remplacez le titre Click Medu bouton par :

    

12. Répétez les étapes 5 à 8 ci-dessus pour limiter le bouton dans la fenêtre tvOS. Toutefois, au lieu de faire glisser la poignée T vers le haut de la fenêtre (comme à l’étape 7), faites-la glisser vers le bas de l’étiquette :

    

13. Faites glisser une autre étiquette sous le bouton, taillez-la de la même largeur que la première étiquette et définissez son alignement sur Centre :

    

14. Comme la première étiquette et le bouton, définissez cette étiquette sur centrer et épinglez-la à l’emplacement et à la taille :

    

15. Enregistrez vos modifications dans l’interface utilisateur.

Au fur et à mesure que vous redimensionnez et déplacez des contrôles, vous devriez avoir remarqué que le concepteur vous donne des conseils d’ancrage utiles basés sur les instructions d’interface humaine Apple TV. Ces instructions vous aideront à créer des applications de haute qualité qui auront une apparence familière pour les utilisateurs d’Apple TV.

Si vous regardez dans la section Plan du document, notez comment la disposition et la hiérarchie des éléments qui composent notre interface utilisateur sont affichées :

À partir de là, vous pouvez sélectionner des éléments à modifier ou faire glisser pour réorganiser les éléments de l’interface utilisateur si nécessaire. Par exemple, si un élément d’interface utilisateur était couvert par un autre élément, vous pouvez le faire glisser vers le bas de la liste pour le rendre le plus grand élément de la fenêtre.

Maintenant que nous avons créé notre interface utilisateur, nous devons exposer les éléments d’interface utilisateur afin que Xamarin.tvOS puisse y accéder et interagir avec eux dans le code C#.

Accès aux contrôles dans le code-behind

Il existe deux façons principales d’accéder aux contrôles que vous avez ajoutés dans le concepteur iOS à partir du code :

• Création d’un gestionnaire d’événements sur un contrôle.
• Donner au contrôle un nom, afin que nous puissions le référencer ultérieurement.

Lorsque l’un de ces éléments est ajouté, la classe partielle dans la ViewController.designer.cs classe sera mise à jour pour refléter les modifications. Cela vous permettra d’accéder ensuite aux contrôles dans le contrôleur d’affichage.

Création d’un gestionnaire d’événements

Dans cet exemple d’application, lorsque le bouton est cliqué, nous voulons qu’un événement se produise, un gestionnaire d’événements doit donc être ajouté à un événement spécifique sur le bouton. Pour configurer cette opération, procédez comme suit :

1. Dans le Concepteur Xamarin iOS, sélectionnez le bouton sur le contrôleur de vue.

2. Dans le panneau Propriétés, sélectionnez l’onglet Événements :

   

3. Recherchez l’événement TouchUpInside et attribuez-lui un gestionnaire d’événements nommé Clicked:

   

4. Lorsque vous appuyez sur Entrée, le fichier ViewController.cs s’ouvre, ce qui suggère des emplacements pour votre gestionnaire d’événements dans le code. Utilisez les touches de direction de votre clavier pour définir l’emplacement :

   

5. Cela crée une méthode partielle, comme indiqué ci-dessous :

   

Nous sommes maintenant prêts à commencer à ajouter du code pour autoriser le bouton à fonctionner.

Affectation d’un nom à un contrôle

Lorsque le bouton est cliqué, l’étiquette doit être mise à jour en fonction du nombre de clics. Pour ce faire, nous devons accéder à l’étiquette dans le code. Pour ce faire, donnez-lui un nom. Effectuez les actions suivantes :

1. Ouvrez le Storyboard, puis sélectionnez l’étiquette en bas du contrôleur d’affichage.

2. Dans le panneau Propriétés, sélectionnez l’onglet Widget :

   

3. Sous Nom de l’identité>, ajoutez ClickedLabel:

   

Nous sommes maintenant prêts à commencer à mettre à jour l’étiquette !

Accès aux contrôles

Si vous sélectionnez le ViewController.designer.csExplorateur de solutions vous pourrez voir comment l’étiquette ClickedLabel et le Clicked gestionnaire d’événements ont été mappés à un point de sortie et à une action en C# :

Vous pouvez également remarquer qu’il ViewController.designer.cs s’agit d’une classe partielle, afin que Visual Studio pour Mac n’ait pas à modifier ViewController.cs ce qui remplacerait les modifications que nous avons apportées à la classe.

L’exposition des éléments d’interface utilisateur de cette façon vous permet d’y accéder dans le contrôleur de vue.

Normalement, vous n’aurez jamais besoin de vous ouvrir vous-même ViewController.designer.cs , il a été présenté ici uniquement à des fins éducatives.

Écriture du code

Avec notre interface utilisateur créée et ses éléments d’interface utilisateur exposés au code via des points de vente et des actions, nous sommes enfin prêts à écrire le code pour fournir la fonctionnalité du programme.

Dans notre application, chaque fois que le premier bouton est cliqué, nous allons mettre à jour notre étiquette pour afficher le nombre de fois où le bouton a été cliqué. Pour ce faire, nous devons ouvrir le ViewController.cs fichier pour modification en double-cliquant dessus dans le panneau Solution :

Tout d’abord, nous devons créer une variable de niveau classe dans notre ViewController classe pour suivre le nombre de clics qui se sont produits. Modifiez la définition de classe pour qu’elle ressemble à ce qui suit :

using System;
using Foundation;
using UIKit;

namespace Hello_tvOS
{
    public partial class ViewController : UIViewController
    {
        private int numberOfTimesClicked = 0;
        ...

Ensuite, dans la même classe (ViewController), nous devons remplacer la méthode ViewDidLoad et ajouter du code pour définir le message initial de notre étiquette :

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    // Set the initial value for the label
    ClickedLabel.Text = "Button has not been clicked yet.";
}

Nous devons utiliser ViewDidLoad, au lieu d’une autre méthode telle que Initialize, car ViewDidLoad elle est appelée après le chargement et l’instanciation de l’interface utilisateur à partir du .storyboard fichier. Si nous avons essayé d’accéder au contrôle d’étiquette avant que le .storyboard fichier n’ait été entièrement chargé et instancié, nous obtenons une NullReferenceException erreur car le contrôle d’étiquette n’est pas encore créé.

Ensuite, nous devons ajouter le code pour répondre à l’utilisateur en cliquant sur le bouton. Ajoutez ce qui suit à la classe partielle à laquelle nous avons créé :

partial void Clicked (UIButton sender)
{
    ClickedLabel.Text = string.Format("The button has been clicked {0} time{1}.", ++numberOfTimesClicked, (numberOfTimesClicked

Ce code sera appelé chaque fois que l’utilisateur clique sur notre bouton.

Avec tout ce qui est en place, nous sommes maintenant prêts à créer et tester notre application Xamarin.tvOS.

Test de l’application

Il est temps de générer et d’exécuter notre application pour s’assurer qu’elle s’exécute comme prévu. Nous pouvons générer et exécuter tout en une seule étape, ou nous pouvons le générer sans l’exécuter.

Chaque fois que nous créons une application, nous pouvons choisir le type de build souhaité :

• Débogage : une build de débogage est compilée dans un fichier « » (application) avec des métadonnées supplémentaires qui nous permettent de déboguer ce qui se passe pendant l’exécution de l’application.
• Version : une build de mise en production crée également un fichier « », mais il n’inclut pas d’informations de débogage. Il est donc plus petit et s’exécute plus rapidement.

Vous pouvez sélectionner le type de build dans le sélecteur de configuration en haut à gauche de l’écran Visual Studio pour Mac :

Génération de l'application

Dans notre cas, nous voulons simplement une build de débogage. Nous allons donc vérifier que le débogage est sélectionné. Commençons par générer notre application en appuyant sur ⌘B, ou dans le menu Générer, choisissez Générer tout.

S’il n’y avait pas d’erreurs, un message de génération réussi s’affiche dans la barre d’état de Visual Studio pour Mac. Si des erreurs se sont produites, passez en revue votre projet et vérifiez que vous avez suivi correctement les étapes. Commencez par confirmer que votre code (à la fois dans Xcode et dans Visual Studio pour Mac) correspond au code du didacticiel.

Exécution de l’application

Pour exécuter l’application, nous avons trois options :

• Appuyez sur ⌘+Entrée.
• Dans le menu Exécuter, choisissez Déboguer.
• Cliquez sur le bouton Play (Lire) dans la barre d’outils Visual Studio pour Mac (juste au-dessus de l’Explorateur de solutions).

L’application génère (s’il n’a pas déjà été créé), démarre en mode débogage, le simulateur tvOS démarre et l’application démarre et affiche sa fenêtre d’interface principale :

Dans le menu Matériel , sélectionnez Afficher Apple TV Remote pour pouvoir contrôler le simulateur.

À l’aide de la télécommande du simulateur, si vous cliquez sur le bouton quelques fois, l’étiquette doit être mise à jour avec le nombre :

Félicitations ! Nous avons abordé beaucoup de terrain ici, mais si vous avez suivi ce tutoriel du début à la fin, vous devriez maintenant avoir une solide compréhension des composants d’une application Xamarin.tvOS ainsi que les outils utilisés pour les créer.

Où se passe-t-il ensuite ?

Le développement d’applications Apple TV présente quelques défis en raison de la déconnexion entre l’utilisateur et l’interface (il se trouve dans la salle non dans la main) et les limitations des emplacements tvOS sur la taille et le stockage de l’application.

Par conséquent, nous vous suggérons vivement de lire les documents suivants avant de passer à la conception d’une application Xamarin.tvOS :

• Présentation de tvOS 9 : cet article présente toutes les API et fonctionnalités nouvelles et modifiées disponibles dans tvOS 9 pour les développeurs Xamarin.tvOS.
• Utilisation de la navigation et du focus : les utilisateurs de votre application Xamarin.tvOS n’interagissent pas directement avec son interface comme avec iOS où ils appuient sur des images sur l’écran de l’appareil, mais indirectement depuis l’ensemble de la salle à l’aide de Siri Remote. Cet article décrit le concept de Focus et la façon dont il est utilisé pour gérer la navigation dans l’interface utilisateur d’une application Xamarin.tvOS.
• Contrôleurs Siri Remote et Bluetooth : la façon principale pour les utilisateurs d’interagir avec Apple TV et votre application Xamarin.tvOS est via siri Remote inclus. Si votre application est un jeu, vous pouvez éventuellement créer une prise en charge pour les contrôleurs de jeu Bluetooth Made For iOS (MFI) dans votre application. Cet article traite de la prise en charge des nouveaux contrôleurs de jeu Siri Remote et Bluetooth dans vos applications Xamarin.tvOS.
• Ressources et données Stockage : contrairement aux appareils iOS, la nouvelle Apple TV ne fournit pas de stockage local persistant pour les applications tvOS. Par conséquent, si votre application Xamarin.tvOS doit conserver des informations (telles que les préférences utilisateur), elle doit stocker et récupérer ces données à partir d’iCloud. Cet article traite de l’utilisation des ressources et du stockage de données persistants dans une application Xamarin.tvOS.
• Utilisation d’icônes et d’images : la création d’icônes et d’images captivantes fait partie intégrante du développement d’une expérience utilisateur immersive pour vos applications Apple TV. Ce guide décrit les étapes requises pour créer et inclure les ressources graphiques nécessaires pour vos applications Xamarin.tvOS.
• Interface utilisateur : couverture générale de l’expérience utilisateur (UX), y compris les contrôles Interface utilisateur (UI), utilisez le Générateur d’interface de Xcode et les principes de conception de l’expérience utilisateur lors de l’utilisation de Xamarin.tvOS.
• Déploiement et test : cette section traite des rubriques utilisées pour tester une application et comment la distribuer. Les rubriques suivantes incluent des éléments tels que les outils utilisés pour le débogage, le déploiement sur des testeurs et la publication d’une application dans l’App Store Apple TV.

Si vous rencontrez des problèmes avec Xamarin.tvOS, consultez notre documentation de résolution des problèmes pour obtenir la liste des problèmes et des solutions.

Résumé

Cet article a fourni un guide de démarrage rapide pour développer des applications pour tvOS avec Visual Studio pour Mac en créant une application Hello, tvOS simple. Il a abordé les principes de base de l’approvisionnement d’appareils tvOS, de la création d’interface, du codage pour tvOS et des tests sur le simulateur tvOS.

Liens associés

• tvOS
• Guides de l’interface humaine tvOS
• Guide de programmation d’applications pour tvOS
• Création d’applications pour tvOS avec Xamarin (vidéo)