Intégration de contenus avec les chaînes de l'écran d'accueil Android TV (Kotlin)

Dans cet atelier de programmation, vous apprendrez à créer une application qui ajoute des chaînes et des programmes à l'écran d'accueil Android TV à l'aide des bibliothèques Kotlin et AndroidX. L'écran d'accueil comporte des fonctionnalités qui ne sont pas abordées dans cet atelier de programmation. Consultez nos documents de référence pour découvrir toutes les fonctionnalités de l'écran d'accueil.

Remarque : Pour les appareils fonctionnant sous Android O ou une version antérieure, consultez la section Recommandations dans l'atelier de programmation Leanback.

Concepts

L'interface utilisateur de l'écran d'accueil Android TV affiche des contenus recommandés sous la forme d'un tableau de chaînes et de programmes. Chaque ligne correspond à une chaîne. Une chaîne contient des fiches pour chacun des programmes qu'elle propose. Votre appli peut proposer un nombre illimité de chaînes que l'utilisateur peut ajouter à son écran d'accueil. Chaque chaîne doit généralement être sélectionnée et approuvée par l'utilisateur pour s'afficher sur l'écran d'accueil.

Chaque application peut créer une chaîne par défaut. La chaîne par défaut est spéciale, car elle s'affiche automatiquement sur l'écran d'accueil sans intervention explicite de l'utilisateur.

Aperçu

Cet atelier de programmation montre comment créer, ajouter et mettre à jour des chaînes et des programmes sur l'écran d'accueil. Il utilise une base de données fictive constituée de collections et de films. Pour plus de simplicité, la même liste de films est utilisée pour tous les abonnements.

Cloner les éléments du projet de démarrage

Cet atelier de programmation utilise Android Studio, un IDE conçu pour le développement des applis Android.

Si ce n'est pas déjà fait, veuillez le télécharger et l'installer.

Son code source est disponible sur le dépôt GitHub :

git clone https://github.com/googlecodelabs/tv-recommendations-kotlin.git

Vous pouvez également le télécharger sous forme de fichier ZIP.

Télécharger le fichier ZIP

Ouvrez Android Studio, puis cliquez sur File > Open (Fichier > Ouvrir) dans la barre de menu, ou Open a Existing Android Studio Project (Ouvrir un projet Android Studio existant) sur l'écran d'accueil, puis sélectionnez le dossier cloné récemment.

Comprendre le projet de démarrage

Ce projet comporte quatre étapes. À chaque étape, vous ajoutez du code à l'application. Après avoir suivi les instructions de chaque section, vous pouvez comparer le résultat avec le code de l'étape suivante.

Les principaux composants de l'application sont les suivants :

• MainActivity correspond à l'activité d'entrée du projet.
• model/TvMediaBackground est un objet pour les images en arrière-plan lors du parcours de films.
• model/TvMediaCollection est un objet destiné aux collections de films.
• model/TvMediaMetadata est un objet permettant de stocker des informations sur les films.
• model/TvMediaDatabase héberge la base de données et sert de point d'accès principal pour les données des films enregistrées.
• fragments/NowPlayingFragment lance la lecture des films.
• fragments/MediaBrowserFragment correspond au fragment du navigateur multimédia.
• workers/TvMediaSynchronizer est une classe de synchronisation de données qui contient du code permettant de récupérer des flux, de créer des objets et de mettre à jour des chaînes.
• utils/TvLauncherUtils est une classe d'assistance qui permet de gérer les chaînes et les programmes d'aperçus à l'aide de la bibliothèque AndroidX et des fournisseurs de services TV.

Exécuter le projet de démarrage

Essayez d'exécuter le projet. Si vous rencontrez des problèmes, consultez nos documents de référence pour découvrir comment procéder.

1. Connectez votre Android TV ou démarrez l'émulateur.

Remarque : Si vous exécutez l'émulateur, veillez à sélectionner l'image de l'appareil Android TV pour Android O ou une version ultérieure :

2. Sélectionnez la configuration step_1, puis votre appareil Android. Appuyez sur le bouton run dans la barre de menu.
3. Vous devriez voir un exemple d'application TV basique avec trois collections de vidéos.

Connaissances acquises

Dans cette introduction, vous avez acquis des connaissances sur les aspects suivants :

• L'écran d'accueil de la télévision et ses chaînes
• La structure du code du projet et les principales classes utilisées dans cet atelier de programmation

Et ensuite ?

Ajouter des chaînes à l'écran d'accueil

Commencez par ajouter des chaînes à l'écran d'accueil. Une fois les chaînes créées, vous pouvez y ajouter des programmes. Les utilisateurs peuvent découvrir vos chaînes dans le panneau de configuration de la chaîne et sélectionner celles qu'ils souhaitent afficher dans l'UI de la page d'accueil. Cet atelier de programmation crée des chaînes pour chacune des collections multimédias :

• Films historiques
• Longs métrages des années 1910
• Collection Charlie Chaplin

La section suivante explique comment charger des données et les utiliser pour les chaînes.

La méthode synchronize() dans TvMediaSynchronizer effectue les opérations suivantes :

1. Elle récupère le flux multimédia, qui comprend les images d'arrière-plan, les collections multimédias et les métadonnées des vidéos. Ces informations sont définies dans assets/media-feed.json.
2. Elle met à jour l'instance TvMediaDatabase, qui stocke les images d'arrière-plan, les collections multimédias et les données vidéo dans ses objets respectifs.
3. Elle utilise TvLauncherUtils pour créer ou mettre à jour des chaînes et des programmes

Ne vous préoccupez pas du chargement des données dans cet atelier de programmation. Votre objectif est ici de comprendre comment utiliser la bibliothèque AndroidX pour créer des chaînes. Pour ce faire, vous ajouterez du code à quelques méthodes de la classe TvLauncherUtils.

Créer une chaîne

Après avoir récupéré les données multimédias et les avoir enregistrées dans une base de données locale, le code du projet convertit un élément multimédia Collection en chaîne. Ce code crée et met à jour les chaînes dans la méthode upsertChannel() de la classe TvLauncherUtils.

1. Créez une instance de PreviewChannel.Builder(). Pour éviter les doublons, cet atelier de programmation vérifie si une chaîne existe déjà et ne la met à jour que si c'est le cas. Chaque collection de vidéos est associée à un identifiant. Vous pouvez l'utiliser comme l'élément internalProviderId d'une chaîne. Pour identifier une chaîne existante, comparez son internalProviderId à l'identifiant de collection. Copiez le code suivant et collez-le dans upsertChannel() au niveau du commentaire de code // TODO: Step 1 create or find an existing channel..

val channelBuilder = if (existingChannel == null) {
   PreviewChannel.Builder()
} else {
   PreviewChannel.Builder(existingChannel)
}

2. Définissez des attributs dans l'élément Builder d'une chaîne (par exemple, son nom et son logo ou icône). Le nom à afficher apparaît sur l'écran d'accueil, sous l'icône de la chaîne. Android TV utilise l'élément appLinkIntentUri pour orienter les utilisateurs lorsqu'ils cliquent sur l'icône d'une chaîne. L'atelier de programmation utilise cet URI pour diriger les utilisateurs vers la collection souhaitée dans l'application. Copiez et collez le code suivant dans le commentaire du code // TODO: Step 2 add collection metadata and build channel object (À FAIRE : Étape 2 ajouter les métadonnées de collection et créer l'objet chaîne).

val updatedChannel = channelBuilder
       .setInternalProviderId(collection.id)
       .setLogo(channelLogoUri)
       .setAppLinkIntentUri(appUri)
       .setDisplayName(collection.title)
       .setDescription(collection.description)
       .build()

3. Appelez des fonctions dans la classe PreviewChannelHelper pour insérer la chaîne dans le fournisseur de services TV ou l'actualiser. L'appel à l'élément publishChannel() insère les valeurs des contenus de la chaîne dans le fournisseur de services TV. updatePreviewChannel met à jour les chaînes existantes. Insérez le code suivant au niveau du commentaire de code // TODO: Step 3.1 update an existing channel (À FAIRE : Étape 3.1 mettre à jour une chaîne existante).

PreviewChannelHelper(context)
       .updatePreviewChannel(existingChannel.id, updatedChannel)
Log.d(TAG, "Updated channel ${existingChannel.id}")

Insérez le code ci-dessous pour créer une chaîne au niveau du commentaire de code // À FAIRE : Étape 3.2 publier une chaîne.

val channelId = PreviewChannelHelper(context).publishChannel(updatedChannel)
Log.d(TAG, "Published channel $channelId")
channelId

4. Consultez la méthode upsertChannel() pour découvrir comment créer des chaînes ou les mettre à jour.

Rendre visible la chaîne par défaut

Lorsque vous ajoutez des chaînes au fournisseur de services TV, ces chaînes sont invisibles. Une chaîne ne s'affiche sur l'écran d'accueil que lorsque l'utilisateur le demande. Une chaîne doit généralement être sélectionnée et approuvée par l'utilisateur pour s'afficher sur l'écran d'accueil. Chaque application a la possibilité de créer une chaîne par défaut. Cette chaîne par défaut est spéciale, car elle s'affiche automatiquement sur l'écran d'accueil sans qu'une approbation explicite de l'utilisateur soit nécessaire.

Ajoutez le code suivant à la méthode upsertChannel() (au niveau du commentaire TODO: step 4 make default channel visible [À FAIRE : Étape 4 rendre visible la chaîne par défaut]) :

if(allChannels.none { it.isBrowsable }) {
   TvContractCompat.requestChannelBrowsable(context, channelId)
}

Si vous appelez l'élément requestChannelBrowsable() pour des chaînes autres que celles par défaut, une boîte de dialogue s'affichera pour vous demander l'autorisation de l'utilisateur.

Planifier les mises à jour de chaînes

Après avoir ajouté le code de création ou de mise à jour de la chaîne, les développeurs doivent appeler la méthode synchronize() pour créer la chaîne ou la mettre à jour.

Le meilleur moment pour créer les chaînes de votre application est juste après l'installation de celle-ci par l'utilisateur. Vous pouvez créer un broadcast receiver pour réagir au message de diffusion android.media.tv.action.INITIALIZE_PROGRAMS. Ce message est envoyé une fois que l'utilisateur a installé l'application TV et que les développeurs peuvent y initialiser des programmes.

Consultez le fichier AndroidManifest.xml dans l'exemple de code et localisez la section du broadcast receiver. Essayez d'identifier le nom de classe correspondant au broadcast receiver (ce sujet sera abordé dans l'étape suivante).

<action
   android:name="android.media.tv.action.INITIALIZE_PROGRAMS" />

Ouvrez la classe TvLauncherReceiver et examinez le bloc de code suivant pour comprendre comment l'application fournie crée les chaînes de l'écran d'accueil.

TvContractCompat.ACTION_INITIALIZE_PROGRAMS -> {
   Log.d(TAG, "Handling INITIALIZE_PROGRAMS broadcast")
   // Synchronizes all program and channel data
   WorkManager.getInstance(context).enqueue(
           OneTimeWorkRequestBuilder<TvMediaSynchronizer>().build())
}

Nous vous conseillons de mettre à jour vos chaînes régulièrement. Cet atelier de programmation crée des tâches en arrière-plan à l'aide de la bibliothèque WorkManager. Dans la classe MainActivity, TvMediaSynchronizer permet de planifier des mises à jour régulières de la chaîne.

// Syncs the home screen channels hourly
// NOTE: It's very important to keep our content fresh in the user's home screen
WorkManager.getInstance(baseContext).enqueue(
       PeriodicWorkRequestBuilder<TvMediaSynchronizer>(1, TimeUnit.HOURS)
               .setInitialDelay(1, TimeUnit.HOURS)
               .setConstraints(Constraints.Builder()
                       .setRequiredNetworkType(NetworkType.CONNECTED)
                       .build())
               .build())

Exécuter l'application

Exécutez l'application. Accédez à l'écran d'accueil. La chaîne par défaut (My TV App Default) s'affiche, mais ne présente aucun programme. Si vous exécutez le code sur un appareil réel plutôt que sur un émulateur, il est possible que la chaîne ne s'affiche pas.

Remarque : Si vous utilisez l'émulateur dans Android Studio, cette chaîne est intitulée TV Classics. Sélectionnez le menu contextuel (bouton représentant des points de suspension), puis Directional Pad (Pavé directionnel). Utilisez le bloc-notes pour sélectionner la chaîne afin d'afficher le nom My TV App Default.

Ajouter d'autres chaînes

Le flux contient trois collections. Dans la classe TvMediaSynchronizer, ajoutez d'autres chaînes pour ces collections (au niveau du commentaire TODO: step 5 add more channels [À FAIRE : étape 5 ajouter d'autres chaînes]).

feed.collections.subList(1, feed.collections.size).forEach {
   TvLauncherUtils.upsertChannel(
           context, it, database.metadata().findByCollection(it.id))
}

Exécuter à nouveau l'application

Vérifiez que les trois chaînes ont été créées. Cliquez sur le bouton Customize Channels (Personnaliser les chaînes), puis sur TV Classics. Cliquez sur le bouton "Masquer/Afficher" dans le panneau des chaînes pour masquer ou afficher celles-ci sur l'écran d'accueil.

Supprimer une chaîne

Si l'application ne gère plus une chaîne, vous pouvez la supprimer de l'écran d'accueil.

Remarque : NE SUPPRIMEZ UNE CHAÎNE QU'EN DERNIER RECOURS. Cette pratique peut nuire à l'expérience utilisateur et doit donc être évitée dans la mesure du possible. Essayez de modifier le contenu de la chaîne si possible. Cet atelier de programmation vous indique comment supprimer une chaîne à des fins d'instruction uniquement.

Recherchez l'étape 6 et trouvez la fonction removeChannel. Ajoutez-y la section suivante (au niveau du commentaire TODO: step 6 remove a channel [À FAIRE : étape 6 supprimer une chaîne]). Pour voir comment ce code fonctionne, supprimez la collection "Charlie Chaplin Collection" dans media-feed.json (veillez à supprimer l'intégralité de cette collection). Exécutez de nouveau l'application et vérifiez que la chaîne a bien été supprimée après quelques secondes.

// First, get all the channels added to the home screen
val allChannels = PreviewChannelHelper(context).allChannels

// Now find the channel with the matching content ID for our collection
val foundChannel = allChannels.find { it.internalProviderId == collection.id }
if (foundChannel == null) Log.e(TAG, "No channel with ID ${collection.id}")

// Use the found channel's ID to delete it from the content resolver
return foundChannel?.let {
   PreviewChannelHelper(context).deletePreviewChannel(it.id)
   Log.d(TAG, "Channel successfully removed from home screen")

   // Remove all of the channel programs as well
   val channelPrograms =
           TvContractCompat.buildPreviewProgramsUriForChannel(it.id)
   context.contentResolver.delete(channelPrograms, null, null)

   // Return the ID of the channel removed
   it.id
}

Une fois que vous avez suivi toutes les instructions ci-dessus, vous pouvez comparer le code d'application avec celui de l'étape step_2.

Connaissances acquises

• Comment effectuer une requête pour des chaînes
• Comment ajouter ou supprimer des chaînes à partir de l'écran d'accueil
• Comment définir un logo ou un titre pour une chaîne
• Comment rendre visible une chaîne par défaut
• Planifier une bibliothèque WorkManager pour mettre à jour des chaînes

Et ensuite ?

La section suivante montre comment ajouter des programmes à une chaîne.

L'ajout d'un programme à une chaîne est comparable à la création d'une chaîne. Utilisez PreviewProgram.Builder à la place de PreviewChannel.Builder.

Vous travaillerez toujours avec la méthode upsertChannel() de la classe TvLauncherUtils.

Créer un programme d'aperçu

Nous ajouterons du code à l'étape step_2 dans la section suivante. N'oubliez pas de modifier les fichiers source de ce module dans le projet Android Studio.

Après avoir vérifié que la chaîne est visible, créez un objet PreviewProgram à l'aide d'objets Metadata avec PreviewProgram.Builder. Comme nous l'avons vu, il n'est pas conseillé d'insérer le même programme deux fois dans une chaîne. Notre exemple attribue donc l'identifiant metadata.id à contentId du programme d'aperçu PreviewProgram à des fins de déduplication. Ajoutez le code suivant à l'étape TODO: Step 7 create or find a existing preview program (À FAIRE : Étape 7 créer ou trouver un programme d'aperçu existant).

val existingProgram = existingProgramList.find { it.contentId == metadata.id }
val programBuilder = if (existingProgram == null) {
   PreviewProgram.Builder()
} else {
   PreviewProgram.Builder(existingProgram)
}

Créez le compilateur à l'aide des métadonnées des contenus multimédias, puis publiez-le ou mettez-le à jour sur la chaîne. (TODO: Step 8 build preview program and publish. [À FAIRE : Étape 8 créer le programme d'aperçu et le publier])

val updatedProgram = programBuilder.also { metadata.copyToBuilder(it) }
       // Set the same channel ID in all programs
       .setChannelId(channelId)
       // This must match the desired intent filter in the manifest for VIEW action
       .setIntentUri(Uri.parse("https://$host/program/${metadata.id}"))
       // Build the program at once
       .build()

Remarque : La méthode copyToBuilder des métadonnées copie toutes les informations utiles dans PreviewProgram.

Voici quelques points à noter :

1. Notre exemple de code associe les métadonnées au programme d'aperçu via son identifiant contentId.
2. Le programme d'aperçu est inséré dans une chaîne en appelant setChannelId() sur PreviewProgram.Builder().
3. Le système Android TV lance l'URI intentUri d'un programme lorsqu'un utilisateur sélectionne un programme dans une chaîne. L'élément Uri doit inclure l'identifiant du programme afin que l'application puisse trouver et lire le contenu multimédia de la base de données lorsque l'utilisateur sélectionne le programme.

Ajouter des programmes

Cet atelier de programmation utilise l'élément PreviewChannelHelper de la bibliothèque AndroidX pour insérer des programmes dans les chaînes.

Utilisez PreviewChannelHelper.publishPreviewProgram() ou PreviewChannelHelper.updatePreviewProgram() pour enregistrer le programme sur la chaîne (à l'étape TODO: Step 9 add preview program to channel [À FAIRE : Étape 9 ajouter un programme d'aperçu à une chaîne]).

try {
   if (existingProgram == null) {
       PreviewChannelHelper(context).publishPreviewProgram(updatedProgram)
       Log.d(TAG, "Inserted program into channel: $updatedProgram")
   } else {
       PreviewChannelHelper(context)
               .updatePreviewProgram(existingProgram.id, updatedProgram)
       Log.d(TAG, "Updated program in channel: $updatedProgram")
   }
} catch (exc: IllegalArgumentException) {
   Log.e(TAG, "Unable to add program: $updatedProgram", exc)
}

Félicitations ! L'application peut désormais ajouter des programmes à des chaînes. Vous pouvez comparer le code avec celui de l'étape step_3.

Exécuter l'application

Sélectionnez "step_2" dans la configuration et exécutez l'application.

Lorsque l'application s'exécute, cliquez sur le bouton Customize Channels (Personnaliser les chaînes) en bas de l'écran d'accueil, puis cherchez notre application, "TV Classics". Activez les trois chaînes et consultez les journaux pour analyser les opérations en cours. La création de chaînes et de programmes s'effectue en arrière-plan. N'hésitez pas à ajouter des instructions de journalisation pour faciliter le suivi des événements déclenchés.

Connaissances acquises

• Comment ajouter des programmes à une chaîne
• Comment mettre à jour les attributs d'un programme

Et ensuite ?

Ajouter des programmes à la chaîne Watch Next

Cette chaîne se situe dans la partie supérieure de l'écran d'accueil, sous les applications et au-dessus des autres chaînes.

Remarque : Sur l'écran d'accueil, la chaîne Watch Next porte le libellé Ma sélection, mais dans la bibliothèque d'API, les classes utilisent toujours le nom WatchNext.

Concepts

La chaîne Watch Next vous permet d'inciter l'utilisateur à interagir avec votre application. Votre application peut ajouter les programmes suivants à cette chaîne : les programmes désignés comme intéressants par l'utilisateur, les programmes que l'utilisateur n'a pas terminé de regarder ou les programmes ayant un lien avec le contenu regardé par l'utilisateur (comme l'épisode suivant ou la saison suivante d'une série, par exemple). Il existe quatre types de cas d'utilisation pour la chaîne Watch Next :

• Reprendre la lecture d'une vidéo que l'utilisateur n'a pas terminée.
• Suggérer la vidéo suivante à regarder. Par exemple, si l'utilisateur a fini de regarder l'épisode 1, vous pouvez suggérer l'épisode 2.
• Mettre en valeur des nouveaux contenus pour inciter les utilisateurs à y réagir.
• Conserver une liste de vidéos intéressantes ajoutées par l'utilisateur.

Cette leçon explique comment utiliser la chaîne Watch Next pour reprendre la lecture d'une vidéo. Plus précisément, vous y découvrirez comment inclure automatiquement une vidéo mise en pause par l'utilisateur dans cette chaîne. La vidéo doit être supprimée de cette chaîne une fois sa lecture terminée.

Mettre à jour la position de lecture

Plusieurs options s'offrent à vous pour déterminer la position de lecture d'un contenu. Cet atelier de programmation utilise un thread pour enregistrer régulièrement la dernière position de lecture dans la base de données et actualiser les métadonnées du programme Watch Next. Veuillez ouvrir l'étape step_3 et suivre les instructions ci-dessous pour ajouter ce code.

Dans NowPlayingFragment, ajoutez le code suivant dans la méthode run() de updateMetadataTask. (au niveau du commentaire TODO: step 10 update progress [À FAIRE : étape 10 mettre à jour la position de lecture]) :

val contentDuration = player.duration
val contentPosition = player.currentPosition

// Updates metadata state
val metadata = args.metadata.apply {
   playbackPositionMillis = contentPosition
}

Le code n'enregistre des métadonnées que lorsque la position de lecture est inférieure à 95 % de la durée totale du contenu.

Ajoutez le code suivant (au niveau du commentaire TODO: step 11 update metadata to database [À FAIRE : étape 11] mettre à jour les métadonnées dans la base de données) :.

val programUri = TvLauncherUtils.upsertWatchNext(requireContext(), metadata)
lifecycleScope.launch(Dispatchers.IO) {
   database.metadata().update(
           metadata.apply { if (programUri != null) watchNext = true })
}

Si la position de lecture de la vidéo a dépassé 95 % de sa durée, le programme Watch Next la supprime en faveur d'autres contenus.

Dans NowPlayingFragment, ajoutez le code suivant pour supprimer la vidéo terminée de la ligne "Watch Next" (au niveau du commentaire TODO: step 12 remove watch next [À FAIRE : étape 12 supprimer watch next]).

val programUri = TvLauncherUtils.removeFromWatchNext(requireContext(), metadata)
if (programUri != null) lifecycleScope.launch(Dispatchers.IO) {
   database.metadata().update(metadata.apply { watchNext = false })
}

Remarque : Les méthodes upsertWatchNext et removeFromWatchNext de TvLauncherUtils sont appelées pour cette opération. Ces méthodes interagissent avec les fournisseurs de services TV et la bibliothèque AndroidX pour insérer les données associées à Watch Next.

La tâche updateMetadataTask s'active toutes les 10 secondes pour assurer le suivi de la dernière position de lecture. Cette planification est lancée avec onResume() et suspendue avec onPause() dans NowPlayingFragment. Par conséquent, les données sont mises à jour uniquement lorsque l'utilisateur regarde une vidéo.

Ajouter/Mettre à jour un programme Watch Next

La classe TvLauncherUtils interagit avec le fournisseur de services TV. À l'étape précédente, removeFromWatchNext et upsertWatchNext dans TvLauncherUtils sont appelés. Il vous reste à implémenter ces deux méthodes. La bibliothèque AndroidX fournit la classe PreviewChannelHelper qui simplifie cette tâche.

Commencez par créer ou rechercher une instance existante de WatchNextProgram.Builder, puis mettez à jour l'objet avec les dernières métadonnées de lecturemetadata. Ajoutez le code suivant dans la méthode upsertWatchNext() (au niveau du commentaire TODO: step 13 build watch next program [À FAIRE : étape 13 créer un programme watch next]) :

programBuilder.setLastEngagementTimeUtcMillis(System.currentTimeMillis())

programBuilder.setWatchNextType(metadata.playbackPositionMillis?.let { position ->
   if (position > 0 && metadata.playbackDurationMillis?.let { it > 0 } == true) {
       Log.d(TAG, "Inferred watch next type: CONTINUE")
       TvContractCompat.WatchNextPrograms.WATCH_NEXT_TYPE_CONTINUE
   } else {
       Log.d(TAG, "Inferred watch next type: UNKNOWN")
       WatchNextProgram.WATCH_NEXT_TYPE_UNKNOWN
   }
} ?: TvContractCompat.WatchNextPrograms.WATCH_NEXT_TYPE_NEXT)

// This must match the desired intent filter in the manifest for VIEW intent action
programBuilder.setIntentUri(Uri.parse(
       "https://${context.getString(R.string.host_name)}/program/${metadata.id}"))

// Build the program with all the metadata
val updatedProgram = programBuilder.build()

Après avoir appelé la méthode build( sur un WatchNextProgram.Builder, un programme WatchNextProgam est créé. Vous pouvez le publier sur la ligne "Watch Next" avec PreviewChannelHelper.

Ajoutez le code suivant (au niveau du commentaire TODO: step 14.1 create watch next program [À FAIRE : étape 14.1 créer un programme watch next]) :

val programId = PreviewChannelHelper(context)
       .publishWatchNextProgram(updatedProgram)
Log.d(TAG, "Added program to watch next row: $updatedProgram")
programId

Si le programme existe, mettez-le à jour (au niveau du commentaire TODO: step 14.2 update watch next program [À FAIRE : étape 14.2 mettre à jour un programme watch next]).

PreviewChannelHelper(context)
       .updateWatchNextProgram(updatedProgram, existingProgram.id)
Log.d(TAG, "Updated program in watch next row: $updatedProgram")
existingProgram.id

Remarque : Une fois que vous avez mis à jour un programme Watch Next, ce nouveau programme s'affiche en début de chaîne.

Supprimer un programme Watch Next

Lorsqu'un utilisateur termine la lecture de la vidéo, il faut nettoyer la chaîne Watch Next. Cette opération est presque identique à la suppression d'un programmePreviewProgram.

Utilisez buildWatchNextProgramUri() pour créer un Uri qui effectue une suppression. (Il n'existe aucune API pouvant être utilisée dans PreviewChannelHelper pour supprimer un programme Watch Next.)

Remplacez le code existant dans la méthode removeFromWatchNext() de la classe TvLauncherUtils à l'aide des instructions ci-dessous (au niveau du commentaire TODO: step 15 remove program [À FAIRE : étape 15 : supprimer le programme]) :

val programUri = TvContractCompat.buildWatchNextProgramUri(it.id)
val deleteCount = context.contentResolver.delete(
       programUri, null, null)

Exécuter l'application

Sélectionnez "step_3" dans la configuration, puis exécutez l'application.

Regardez une vidéo de l'une de vos collections pendant quelques secondes, puis mettez le lecteur en pause (en appuyant sur la barre d'espace si vous utilisez l'émulateur). Lorsque vous revenez à l'écran d'accueil, vous devriez voir que le film a été ajouté à la chaîne Watch Next. Sélectionnez le même film sur la chaîne Watch Next : sa lecture devrait reprendre au point où vous l'avez laissée. Une fois que vous aurez regardé l'intégralité du film, il devrait être automatiquement supprimé de la chaîne Watch Next. Effectuez des tests avec différents scénarios d'utilisation sur la chaîne Watch Next.

Remarque : Si vous utilisez le simulateur dans Android Studio, pour mettre en pause une vidéo et afficher des commandes de lecture dans l'émulateur, vous pouvez également sélectionner le menu contextuel (bouton représentant des points de suspension), puis sélectionner Directional Pad (Pavé directionnel).

Connaissances acquises

• Comment ajouter des programmes à la chaîne Watch Next pour éveiller l'intérêt des utilisateurs
• Comment mettre à jour un programme sur la chaîne Watch Next.
• Comment supprimer un programme de la chaîne Watch Next.

Et ensuite ?

Une fois l'atelier de programmation terminé, modifiez l'application pour l'adapter à vos besoins. Remplacez le flux média et les modèles de données par les vôtres, puis convertissez-les en chaînes et en programmes pour le fournisseur de services TV désiré.

Pour en savoir plus, consultez nos documents de référence.