Ajouter des fonctionnalités essentielles à votre récepteur Android TV

Cette page contient des extraits de code et une description des fonctionnalités disponibles pour personnaliser une application Android TV Receiver.

Remarque:Nous vous recommandons d'essayer les solutions suivantes: <ph type="x-smartling-placeholder">

</ph>
• Atelier de programmation "Caster Android TV" tutoriel - Découvrez pas à pas comment créer une application Android TV Receiver compatible Cast à l'aide du SDK Google Cast, qui peut recevoir des diffusions vidéo.
• <ph type="x-smartling-placeholder"></ph> Application exemple CastAndroidTvReceiver (GitHub) - Exécutez, parcourez et affichez cet exemple d'application de référence conforme aux Consignes relatives à l'expérience utilisateur Checklist de conception
• <ph type="x-smartling-placeholder"></ph> Applications exemples d'envoi CastVideos (GitHub) - Effectuez un test à l'aide d'applications exemples d'expéditeurs compatibles Cast Connect.

Configurer des bibliothèques

Pour que les API Cast Connect soient disponibles dans votre application Android TV, procédez comme suit:

<ph type="x-smartling-placeholder">

</ph>

Sur Android

1. Ouvrez le fichier build.gradle dans le répertoire du module de votre application.
   Remarque:Les projets Android Studio contiennent un build.gradle de premier niveau et un fichier build.gradle pour chaque module. Assurez-vous que pour modifier le fichier du module d'application. Voir <ph type="x-smartling-placeholder"></ph> "Compiler votre projet avec Gradle" pour en savoir plus sur Gradle.
2. Vérifiez que google() est inclus dans la liste repositories.

     repositories {
       google()
     }

3. Selon le type d'appareil cible de votre appli, ajoutez les dernières versions des bibliothèques à vos dépendances: <ph type="x-smartling-placeholder">
   </ph>
   • Pour l'application Android Receiver:

       dependencies {
         implementation 'com.google.android.gms:play-services-cast-tv:21.1.0'
         implementation 'com.google.android.gms:play-services-cast:21.5.0'
       }

   • Pour l'application Android Sender:

       dependencies {
         implementation 'com.google.android.gms:play-services-cast:21.1.0'
         implementation 'com.google.android.gms:play-services-cast-framework:21.5.0'
       }

   Veillez à mettre à jour ce numéro de version chaque fois que les services sont mis à jour.
4. Enregistrez les modifications, puis cliquez sur Sync Project with Gradle Files. dans la barre d'outils.

<ph type="x-smartling-placeholder">

</ph>

iOS

1. Assurez-vous que Podfile cible google-cast-sdk 4.8.3 ou supérieur
2. Ciblez iOS 14 ou version ultérieure. Consultez les notes de version. pour en savoir plus.

     platform: ios, '14'
   
     def target_pods
        pod 'google-cast-sdk', '~>4.8.3'
     end

<ph type="x-smartling-placeholder">

</ph>

Web

1. Nécessite le navigateur Chromium version M87 ou ultérieure.
2. Ajouter la bibliothèque de l'API Web Sender à votre projet

     <script src="//www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"></script>

Exigence AndroidX

Les nouvelles versions des services Google Play nécessitent la mise à jour d'une application pour pouvoir être utilisée l'espace de noms androidx. Suivez les instructions pour migrer vers AndroidX.

Conditions préalables à l'utilisation de l'application Android TV

Pour utiliser Cast Connect dans votre application Android TV, vous devez créer et pour les événements d'une session multimédia. Données fournies par votre session multimédia fournit les informations de base (position, état de lecture, etc.) pour l'état de votre contenu multimédia. Votre session multimédia est également utilisée par la bibliothèque Cast Connect pour signaler l'arrivée de certains messages d'un expéditeur, par exemple en pause.

Pour en savoir plus sur les sessions multimédias et découvrir comment les initialiser, consultez les avec un guide de session multimédia.

Cycle de vie d'une session multimédia

Votre application doit créer une session multimédia au début de la lecture et la publier lorsque elle ne peut plus être contrôlée. Par exemple, si votre application est une application vidéo, vous doit libérer la session lorsque l'utilisateur quitte l'activité de lecture, sélectionner "retour" pour parcourir d'autres contenus ou mettre l'application en arrière-plan. Si votre est une application musicale, vous devez la publier lorsqu'elle n'est plus en cours de lecture médias.

Mise à jour de l'état de la session...

Remarque :Si vous utilisez Exoplayer, consultez les Utiliser Exoplayer avec Cast Connect pour découvrir comment mettre à jour automatiquement votre session multimédia.

Les données de votre session multimédia doivent être actualisées en fonction de l'état de votre joueur. Par exemple, lorsque la lecture est en pause, vous devez mettre à jour ainsi que les actions acceptées. Les tableaux suivants répertorient ce qui indique vous êtes responsable de la mise à jour.

MediaMetadataCompat

Champ de métadonnées	Description
METADATA_KEY_TITLE (obligatoire)	Titre du contenu multimédia.
METADATA_KEY_DISPLAY_SUBTITLE	Le sous-titre.
METADATA_KEY_DISPLAY_ICON_URI	URL de l'icône.
METADATA_KEY_DURATION (obligatoire)	Durée du contenu multimédia.
METADATA_KEY_MEDIA_URI	l'ID de contenu ;
METADATA_KEY_ARTIST	L'artiste.
METADATA_KEY_ALBUM	L'album.

PlaybackStateCompat

Méthode obligatoire	Description
setActions()	Définit les commandes multimédias compatibles.
setState()	Définissez l'état de lecture et la position actuelle.

MediaSessionCompat

Méthode obligatoire	Description
setRepeatMode()	Définit le mode de répétition.
setShuffleMode()	Définit le mode aléatoire.
setMetadata()	Définit les métadonnées multimédias.
setPlaybackState()	Définit l'état de lecture.

Kotlin

private fun updateMediaSession() {
    val metadata = MediaMetadataCompat.Builder()
         .putString(MediaMetadataCompat.METADATA_KEY_TITLE, "title")
         .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, "subtitle")
         .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI, mMovie.getCardImageUrl())
         .build()

    val playbackState = PlaybackStateCompat.Builder()
         .setState(
             PlaybackStateCompat.STATE_PLAYING,
             player.getPosition(),
             player.getPlaybackSpeed(),
             System.currentTimeMillis()
        )
         .build()

    mediaSession.setMetadata(metadata)
    mediaSession.setPlaybackState(playbackState)
}

<ph type="x-smartling-placeholder">

</ph>

Java

private void updateMediaSession() {
  MediaMetadataCompat metadata =
      new MediaMetadataCompat.Builder()
          .putString(MediaMetadataCompat.METADATA_KEY_TITLE, "title")
          .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, "subtitle")
          .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI,mMovie.getCardImageUrl())
          .build();

  PlaybackStateCompat playbackState =
      new PlaybackStateCompat.Builder()
          .setState(
               PlaybackStateCompat.STATE_PLAYING,
               player.getPosition(),
               player.getPlaybackSpeed(),
               System.currentTimeMillis())
          .build();

  mediaSession.setMetadata(metadata);
  mediaSession.setPlaybackState(playbackState);
}

Gérer le contrôle du transport

Votre application doit implémenter le rappel de commande de transport de session multimédia. La Le tableau suivant présente les actions de contrôle du transport qu'il doit gérer:

MediaSessionCompat.Callback

Actions	Description
onPlay()	Reprendre
onPause()	Pause
onSeekTo()	Rechercher un lieu
onStop()	Arrêter la lecture du contenu multimédia en cours

<ph type="x-smartling-placeholder">

</ph>

Kotlin

class MyMediaSessionCallback : MediaSessionCompat.Callback() {
  override fun onPause() {
    // Pause the player and update the play state.
    ...
  }

  override fun onPlay() {
    // Resume the player and update the play state.
    ...
  }

  override fun onSeekTo (long pos) {
    // Seek and update the play state.
    ...
  }
  ...
}

mediaSession.setCallback( MyMediaSessionCallback() );

<ph type="x-smartling-placeholder">

</ph>

Java

public MyMediaSessionCallback extends MediaSessionCompat.Callback {
  public void onPause() {
    // Pause the player and update the play state.
    ...
  }

  public void onPlay() {
    // Resume the player and update the play state.
    ...
  }

  public void onSeekTo (long pos) {
    // Seek and update the play state.
    ...
  }
  ...
}

mediaSession.setCallback(new MyMediaSessionCallback());

Configurer la compatibilité avec Cast

Lorsqu'une requête de lancement est envoyée par une application émettrice, un intent est créé avec un espace de noms d'application. Votre application se charge de sa gestion et la création d'une instance CastReceiverContext lors du lancement de l'application TV. L'objet CastReceiverContext est nécessaire d'interagir avec Cast pendant que l'appli TV est en cours d'exécution. Cet objet active votre téléviseur pour accepter les messages multimédias Cast provenant de n'importe quel expéditeur connecté.

Configuration d'Android TV

Ajouter un filtre d'intent de lancement

Ajoutez un filtre d'intent à l'activité dont vous souhaitez gérer le lancement. intent à partir de votre application émettrice:

<activity android:name="com.example.activity">
  <intent-filter>
      <action android:name="com.google.android.gms.cast.tv.action.LAUNCH" />
      <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

Spécifier le fournisseur d'options du récepteur

Vous devez implémenter ReceiverOptionsProvider pour fournir CastReceiverOptions:

Kotlin

class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
          .setStatusText("My App")
          .build()
    }
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        .setStatusText("My App")
        .build();
  }
}

Remarque: Si vous ne définissez pas setStatusText, il est automatiquement extrait android:label dans votre fichier manifeste Android TV.

Spécifiez ensuite le fournisseur d'options dans AndroidManifest:

 <meta-data
    android:name="com.google.android.gms.cast.tv.RECEIVER_OPTIONS_PROVIDER_CLASS_NAME"
    android:value="com.example.mysimpleatvapplication.MyReceiverOptionsProvider" />

ReceiverOptionsProvider permet de fournir le CastReceiverOptions lorsque CastReceiverContext est initialisé.

Contexte du récepteur Cast

Initialiser le CastReceiverContext lors de la création de votre application:

Kotlin

override fun onCreate() {
  CastReceiverContext.initInstance(this)

  ...
}

<ph type="x-smartling-placeholder">

</ph>

Java

@Override
public void onCreate() {
  CastReceiverContext.initInstance(this);

  ...
}

Démarrez CastReceiverContext lorsque votre application passe au premier plan:

Kotlin

CastReceiverContext.getInstance().start()

<ph type="x-smartling-placeholder">

</ph>

Java

CastReceiverContext.getInstance().start();

Appeler stop() le CastReceiverContext après la mise en arrière-plan pour les applications vidéo ou les applications non compatibles lecture en arrière-plan:

Kotlin

// Player has stopped.
CastReceiverContext.getInstance().stop()

<ph type="x-smartling-placeholder">

</ph>

Java

// Player has stopped.
CastReceiverContext.getInstance().stop();

De plus, si votre application est compatible avec la lecture en arrière-plan, appelez stop(). sur le CastReceiverContext lorsque la lecture s'arrête en arrière-plan.

Nous vous recommandons vivement d'utiliser LifecycleObserver androidx.lifecycle pour gérer les appels CastReceiverContext.start() et CastReceiverContext.stop() surtout si votre application native comporte plusieurs activités. Cela permet d'éviter une course lorsque vous appelez start() et stop() à partir de différentes activités.

Kotlin

// Create a LifecycleObserver class.
class MyLifecycleObserver : DefaultLifecycleObserver {
  override fun onStart(owner: LifecycleOwner) {
    // App prepares to enter foreground.
    CastReceiverContext.getInstance().start()
  }

  override fun onStop(owner: LifecycleOwner) {
    // App has moved to the background or has terminated.
    CastReceiverContext.getInstance().stop()
  }
}

// Add the observer when your application is being created.
class MyApplication : Application() {
  fun onCreate() {
    super.onCreate()

    // Initialize CastReceiverContext.
    CastReceiverContext.initInstance(this /* android.content.Context */)

    // Register LifecycleObserver
    ProcessLifecycleOwner.get().lifecycle.addObserver(
        MyLifecycleObserver())
  }
}

<ph type="x-smartling-placeholder">

</ph>

Java

// Create a LifecycleObserver class.
public class MyLifecycleObserver implements DefaultLifecycleObserver {
  @Override
  public void onStart(LifecycleOwner owner) {
    // App prepares to enter foreground.
    CastReceiverContext.getInstance().start();
  }

  @Override
  public void onStop(LifecycleOwner owner) {
    // App has moved to the background or has terminated.
    CastReceiverContext.getInstance().stop();
  }
}

// Add the observer when your application is being created.
public class MyApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();

    // Initialize CastReceiverContext.
    CastReceiverContext.initInstance(this /* android.content.Context */);

    // Register LifecycleObserver
    ProcessLifecycleOwner.get().getLifecycle().addObserver(
        new MyLifecycleObserver());
  }
}

// In AndroidManifest.xml set MyApplication as the application class
<application
    ...
    android:name=".MyApplication">

Connecter MediaSession à MediaManager

Lorsque vous créez un MediaSession vous devez également fournir le jeton MediaSession actuel CastReceiverContext pour qu'il sache où envoyer les commandes et récupérer l'état de lecture du contenu multimédia:

Kotlin

val mediaManager: MediaManager = receiverContext.getMediaManager()
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken())

<ph type="x-smartling-placeholder">

</ph>

Java

MediaManager mediaManager = receiverContext.getMediaManager();
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());

Lorsque vous relâchez votre MediaSession pour cause de lecture inactive, vous devez définir un jeton nul activé MediaManager:

Kotlin

myPlayer.stop()
mediaSession.release()
mediaManager.setSessionCompatToken(null)

<ph type="x-smartling-placeholder">

</ph>

Java

myPlayer.stop();
mediaSession.release();
mediaManager.setSessionCompatToken(null);

Si votre application est compatible avec la lecture de contenus multimédias en arrière-plan, d'appel CastReceiverContext.stop() lorsque votre application est envoyée en arrière-plan, vous ne devez l'appeler que lorsque votre application est exécutée en arrière-plan et ne lit plus les contenus multimédias. Exemple :

Kotlin

class MyLifecycleObserver : DefaultLifecycleObserver {
  ...
  // App has moved to the background.
  override fun onPause(owner: LifecycleOwner) {
    mIsBackground = true
    myStopCastReceiverContextIfNeeded()
  }
}

// Stop playback on the player.
private fun myStopPlayback() {
  myPlayer.stop()

  myStopCastReceiverContextIfNeeded()
}

// Stop the CastReceiverContext when both the player has
// stopped and the app has moved to the background.
private fun myStopCastReceiverContextIfNeeded() {
  if (mIsBackground && myPlayer.isStopped()) {
    CastReceiverContext.getInstance().stop()
  }
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyLifecycleObserver implements DefaultLifecycleObserver {
  ...
  // App has moved to the background.
  @Override
  public void onPause(LifecycleOwner owner) {
    mIsBackground = true;

    myStopCastReceiverContextIfNeeded();
  }
}

// Stop playback on the player.
private void myStopPlayback() {
  myPlayer.stop();

  myStopCastReceiverContextIfNeeded();
}

// Stop the CastReceiverContext when both the player has
// stopped and the app has moved to the background.
private void myStopCastReceiverContextIfNeeded() {
  if (mIsBackground && myPlayer.isStopped()) {
    CastReceiverContext.getInstance().stop();
  }
}

Utiliser Exoplayer avec Cast Connect

Si vous utilisez Exoplayer, vous pouvez utiliser la MediaSessionConnector pour gérer automatiquement la session et toutes les informations associées, y compris les l'état de lecture au lieu de suivre les modifications manuellement.

MediaSessionConnector.MediaButtonEventHandler peut être utilisée pour gérer les événements MediaButton en appelant setMediaButtonEventHandler(MediaButtonEventHandler) qui sont autrement gérés par MediaSessionCompat.Callback par défaut.

Pour intégrer MediaSessionConnector dans votre application, ajoutez les éléments suivants à votre classe d'activité de joueur ou à tout endroit où vous gérer votre session multimédia:

Kotlin

class PlayerActivity : Activity() {
  private var mMediaSession: MediaSessionCompat? = null
  private var mMediaSessionConnector: MediaSessionConnector? = null
  private var mMediaManager: MediaManager? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    ...
    mMediaSession = MediaSessionCompat(this, LOG_TAG)
    mMediaSessionConnector = MediaSessionConnector(mMediaSession!!)
    ...
  }

  override fun onStart() {
    ...
    mMediaManager = receiverContext.getMediaManager()
    mMediaManager!!.setSessionCompatToken(currentMediaSession.getSessionToken())
    mMediaSessionConnector!!.setPlayer(mExoPlayer)
    mMediaSessionConnector!!.setMediaMetadataProvider(mMediaMetadataProvider)
    mMediaSession!!.isActive = true
    ...
  }

  override fun onStop() {
    ...
    mMediaSessionConnector!!.setPlayer(null)
    mMediaSession!!.release()
    mMediaManager!!.setSessionCompatToken(null)
    ...
  }
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class PlayerActivity extends Activity {
  private MediaSessionCompat mMediaSession;
  private MediaSessionConnector mMediaSessionConnector;
  private MediaManager mMediaManager;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    ...
    mMediaSession = new MediaSessionCompat(this, LOG_TAG);
    mMediaSessionConnector = new MediaSessionConnector(mMediaSession);
    ...
  }

  @Override
  protected void onStart() {
    ...
    mMediaManager = receiverContext.getMediaManager();
    mMediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());

    mMediaSessionConnector.setPlayer(mExoPlayer);
    mMediaSessionConnector.setMediaMetadataProvider(mMediaMetadataProvider);
    mMediaSession.setActive(true);
    ...
  }

  @Override
  protected void onStop() {
    ...
    mMediaSessionConnector.setPlayer(null);
    mMediaSession.release();
    mMediaManager.setSessionCompatToken(null);
    ...
  }
}

Configuration de l'application de l'expéditeur

Activer la compatibilité avec Cast Connect

Une fois que vous avez mis à jour votre application émettrice pour qu'elle soit compatible avec Cast Connect, vous pouvez déclarer en définissant le paramètre androidReceiverCompatible indicateur activé LaunchOptions sur "true".

<ph type="x-smartling-placeholder">

</ph>

Sur Android

Nécessite la version play-services-cast-framework 19.0.0 ou version ultérieure.

L'option androidReceiverCompatible est définie LaunchOptions (qui fait partie de CastOptions):

<ph type="x-smartling-placeholder">

</ph>

Kotlin

class CastOptionsProvider : OptionsProvider {
  override fun getCastOptions(context: Context?): CastOptions {
    val launchOptions: LaunchOptions = Builder()
          .setAndroidReceiverCompatible(true)
          .build()
    return CastOptions.Builder()
          .setLaunchOptions(launchOptions)
          ...
          .build()
    }
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class CastOptionsProvider implements OptionsProvider {
  @Override
  public CastOptions getCastOptions(Context context) {
    LaunchOptions launchOptions = new LaunchOptions.Builder()
              .setAndroidReceiverCompatible(true)
              .build();
    return new CastOptions.Builder()
        .setLaunchOptions(launchOptions)
        ...
        .build();
  }
}

<ph type="x-smartling-placeholder">

</ph>

iOS

Nécessite google-cast-sdk version v4.4.8 ou plus élevée.

L'option androidReceiverCompatible est définie GCKLaunchOptions (qui fait partie de GCKCastOptions):

let options = GCKCastOptions(discoveryCriteria: GCKDiscoveryCriteria(applicationID: kReceiverAppID))
...
let launchOptions = GCKLaunchOptions()
launchOptions.androidReceiverCompatible = true
options.launchOptions = launchOptions
GCKCastContext.setSharedInstanceWith(options)

<ph type="x-smartling-placeholder">

</ph>

Web

Version du navigateur Chromium requise M87 ou version ultérieure.

const context = cast.framework.CastContext.getInstance();
const castOptions = new cast.framework.CastOptions();
castOptions.receiverApplicationId = kReceiverAppID;
castOptions.androidReceiverCompatible = true;
context.setOptions(castOptions);

Configuration de la console développeur de Cast

Configurer l'application Android TV

Ajoutez le nom de package de votre appli Android TV dans Console développeur Cast pour l'associer à l'ID de votre application Cast.

Enregistrer des appareils de développeur

Enregistrez le numéro de série de l'appareil Android TV que vous allez utiliser. pour le développement Console développeur Cast

Remarque:Les appareils Android TV disposent de plusieurs numéros de série qui leur sont associés. Vous devez utiliser le logiciel (Cast) de l'appareil Android TV. numéro de série. Voir déterminer le numéro de série d'un appareil Android TV pour savoir comment le trouver.

Sans enregistrement, Cast Connect ne fonctionne que pour les applications installées depuis l'application Google Play Store pour des raisons de sécurité.

En savoir plus sur l'enregistrement d'un appareil Cast ou Android TV pour Cast développement d'applications, consultez la page d'inscription.

Chargement de contenu multimédia

Si vous avez déjà implémenté les liens profonds dans votre application Android TV, vous devriez avoir une définition similaire configurée dans votre fichier manifeste Android TV:

<activity android:name="com.example.activity">
  <intent-filter>
     <action android:name="android.intent.action.VIEW" />
     <category android:name="android.intent.category.DEFAULT" />
     <data android:scheme="https"/>
     <data android:host="www.example.com"/>
     <data android:pathPattern=".*"/>
  </intent-filter>
</activity>

Charger par entité sur l'expéditeur

Sur les expéditeurs, vous pouvez transmettre le lien profond en définissant entity dans le fichier multimédia pour la requête de chargement:

<ph type="x-smartling-placeholder">

</ph>

Kotlin

val mediaToLoad = MediaInfo.Builder("some-id")
    .setEntity("https://example.com/watch/some-id")
    ...
    .build()
val loadRequest = MediaLoadRequestData.Builder()
    .setMediaInfo(mediaToLoad)
    .setCredentials("user-credentials")
    ...
    .build()
remoteMediaClient.load(loadRequest)

<ph type="x-smartling-placeholder">

</ph>

Sur Android

<ph type="x-smartling-placeholder">

</ph>

Java

MediaInfo mediaToLoad =
    new MediaInfo.Builder("some-id")
        .setEntity("https://example.com/watch/some-id")
        ...
        .build();
MediaLoadRequestData loadRequest =
    new MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        ...
        .build();
remoteMediaClient.load(loadRequest);

<ph type="x-smartling-placeholder">

</ph>

iOS

let mediaInfoBuilder = GCKMediaInformationBuilder(entity: "https://example.com/watch/some-id")
...
mediaInformation = mediaInfoBuilder.build()

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
mediaLoadRequestDataBuilder.mediaInformation = mediaInformation
mediaLoadRequestDataBuilder.credentials = "user-credentials"
...
let mediaLoadRequestData = mediaLoadRequestDataBuilder.build()

remoteMediaClient?.loadMedia(with: mediaLoadRequestData)

<ph type="x-smartling-placeholder">

</ph>

Web

Version du navigateur Chromium requise M87 ou version ultérieure.

let mediaInfo = new chrome.cast.media.MediaInfo('some-id"', 'video/mp4');
mediaInfo.entity = 'https://example.com/watch/some-id';
...

let request = new chrome.cast.media.LoadRequest(mediaInfo);
request.credentials = 'user-credentials';
...

cast.framework.CastContext.getInstance().getCurrentSession().loadMedia(request);

La commande de chargement est envoyée via un intent avec votre lien profond et le nom du package. que vous avez définies dans la Play Console.

Définir les identifiants ATV sur l'expéditeur

Il est possible que votre application Web Receiver et votre application Android TV soient compatibles avec des les liens profonds et credentials (par exemple, si vous gérez l'authentification différemment sur les deux plates-formes). Pour résoudre ce problème, vous pouvez fournir entity et credentials pour Android TV:

<ph type="x-smartling-placeholder">

</ph>

Sur Android

<ph type="x-smartling-placeholder">

</ph>

Kotlin

val mediaToLoad = MediaInfo.Builder("some-id")
        .setEntity("https://example.com/watch/some-id")
        .setAtvEntity("myscheme://example.com/atv/some-id")
        ...
        .build()
val loadRequest = MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        .setAtvCredentials("atv-user-credentials")
        ...
        .build()
remoteMediaClient.load(loadRequest)

<ph type="x-smartling-placeholder">

</ph>

Java

MediaInfo mediaToLoad =
    new MediaInfo.Builder("some-id")
        .setEntity("https://example.com/watch/some-id")
        .setAtvEntity("myscheme://example.com/atv/some-id")
        ...
        .build();
MediaLoadRequestData loadRequest =
    new MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        .setAtvCredentials("atv-user-credentials")
        ...
        .build();
remoteMediaClient.load(loadRequest);

<ph type="x-smartling-placeholder">

</ph>

iOS

let mediaInfoBuilder = GCKMediaInformationBuilder(entity: "https://example.com/watch/some-id")
mediaInfoBuilder.atvEntity = "myscheme://example.com/atv/some-id"
...
mediaInformation = mediaInfoBuilder.build()

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
mediaLoadRequestDataBuilder.mediaInformation = mediaInformation
mediaLoadRequestDataBuilder.credentials = "user-credentials"
mediaLoadRequestDataBuilder.atvCredentials = "atv-user-credentials"
...
let mediaLoadRequestData = mediaLoadRequestDataBuilder.build()

remoteMediaClient?.loadMedia(with: mediaLoadRequestData)

<ph type="x-smartling-placeholder">

</ph>

Web

Version du navigateur Chromium requise M87 ou version ultérieure.

let mediaInfo = new chrome.cast.media.MediaInfo('some-id"', 'video/mp4');
mediaInfo.entity = 'https://example.com/watch/some-id';
mediaInfo.atvEntity = 'myscheme://example.com/atv/some-id';
...

let request = new chrome.cast.media.LoadRequest(mediaInfo);
request.credentials = 'user-credentials';
request.atvCredentials = 'atv-user-credentials';
...

cast.framework.CastContext.getInstance().getCurrentSession().loadMedia(request);

Si l'application Web Receiver est lancée, elle utilise entity et credentials dans la requête de chargement. Toutefois, si votre appli Android TV est lancée, le SDK remplace les entity et credentials avec votre atvEntity et votre atvCredentials ; (si spécifié).

Chargement par Content ID ou MediaQueueData

Si vous n'utilisez pas entity ni atvEntity, et que vous utilisez Content ID ou URL de contenu dans vos informations multimédias ou utilisez l'option Charge de média plus détaillée vous devez ajouter le filtre d'intent prédéfini suivant votre application Android TV:

<activity android:name="com.example.activity">
  <intent-filter>
     <action android:name="com.google.android.gms.cast.tv.action.LOAD"/>
     <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

Côté expéditeur, comme avec l'option Charger par entité, vous peut créer une requête de chargement avec les informations relatives à votre contenu et appeler load().

<ph type="x-smartling-placeholder">

</ph>

Sur Android

<ph type="x-smartling-placeholder">

</ph>

Kotlin

val mediaToLoad = MediaInfo.Builder("some-id").build()
val loadRequest = MediaLoadRequestData.Builder()
    .setMediaInfo(mediaToLoad)
    .setCredentials("user-credentials")
    ...
    .build()
remoteMediaClient.load(loadRequest)

<ph type="x-smartling-placeholder">

</ph>

Java

MediaInfo mediaToLoad =
    new MediaInfo.Builder("some-id").build();
MediaLoadRequestData loadRequest =
    new MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        ...
        .build();
remoteMediaClient.load(loadRequest);

<ph type="x-smartling-placeholder">

</ph>

iOS

let mediaInfoBuilder = GCKMediaInformationBuilder(contentId: "some-id")
...
mediaInformation = mediaInfoBuilder.build()

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
mediaLoadRequestDataBuilder.mediaInformation = mediaInformation
mediaLoadRequestDataBuilder.credentials = "user-credentials"
...
let mediaLoadRequestData = mediaLoadRequestDataBuilder.build()

remoteMediaClient?.loadMedia(with: mediaLoadRequestData)

<ph type="x-smartling-placeholder">

</ph>

Web

Version du navigateur Chromium requise M87 ou version ultérieure.

let mediaInfo = new chrome.cast.media.MediaInfo('some-id"', 'video/mp4');
...

let request = new chrome.cast.media.LoadRequest(mediaInfo);
...

cast.framework.CastContext.getInstance().getCurrentSession().loadMedia(request);

Traiter les requêtes de chargement

Dans votre activité, pour gérer ces requêtes de chargement, vous devez gérer les intents dans vos rappels de cycle de vie d'activité:

Kotlin

class MyActivity : Activity() {
  override fun onStart() {
    super.onStart()
    val mediaManager = CastReceiverContext.getInstance().getMediaManager()
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(intent)) {
        // If the SDK recognizes the intent, you should early return.
        return
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }

  // For some cases, a new load intent triggers onNewIntent() instead of
  // onStart().
  override fun onNewIntent(intent: Intent) {
    val mediaManager = CastReceiverContext.getInstance().getMediaManager()
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(intent)) {
        // If the SDK recognizes the intent, you should early return.
        return
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyActivity extends Activity {
  @Override
  protected void onStart() {
    super.onStart();
    MediaManager mediaManager =
        CastReceiverContext.getInstance().getMediaManager();
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(getIntent())) {
      // If the SDK recognizes the intent, you should early return.
      return;
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }

  // For some cases, a new load intent triggers onNewIntent() instead of
  // onStart().
  @Override
  protected void onNewIntent(Intent intent) {
    MediaManager mediaManager =
        CastReceiverContext.getInstance().getMediaManager();
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(intent)) {
      // If the SDK recognizes the intent, you should early return.
      return;
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }
}

Si MediaManager détecte que l'intent est un intent de chargement, il extrait MediaLoadRequestData à partir de l'intent, puis à appeler MediaLoadCommandCallback.onLoad() Vous devez remplacer cette méthode pour gérer la requête de chargement. Le rappel doit être enregistrées avant MediaManager.onNewIntent() est appelé (il est recommandé d'utiliser une onCreate() d'activité ou d'application ).

Kotlin

class MyActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val mediaManager = CastReceiverContext.getInstance().getMediaManager()
        mediaManager.setMediaLoadCommandCallback(MyMediaLoadCommandCallback())
    }
}

class MyMediaLoadCommandCallback : MediaLoadCommandCallback() {
  override fun onLoad(
        senderId: String?,
        loadRequestData: MediaLoadRequestData
  ): Task {
      return Tasks.call {
        // Resolve the entity into your data structure and load media.
        val mediaInfo = loadRequestData.getMediaInfo()
        if (!checkMediaInfoSupported(mediaInfo)) {
            // Throw MediaException to indicate load failure.
            throw MediaException(
                MediaError.Builder()
                    .setDetailedErrorCode(DetailedErrorCode.LOAD_FAILED)
                    .setReason(MediaError.ERROR_REASON_INVALID_REQUEST)
                    .build()
            )
        }
        myFillMediaInfo(MediaInfoWriter(mediaInfo))
        myPlayerLoad(mediaInfo.getContentUrl())

        // Update media metadata and state (this clears all previous status
        // overrides).
        castReceiverContext.getMediaManager()
            .setDataFromLoad(loadRequestData)
        ...
        castReceiverContext.getMediaManager().broadcastMediaStatus()

        // Return the resolved MediaLoadRequestData to indicate load success.
        return loadRequestData
     }
  }

  private fun myPlayerLoad(contentURL: String) {
    myPlayer.load(contentURL)

    // Update the MediaSession state.
    val playbackState: PlaybackStateCompat = Builder()
        .setState(
            player.getState(), player.getPosition(), System.currentTimeMillis()
        )
        ...
        .build()
    mediaSession.setPlaybackState(playbackState)
  }

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyActivity extends Activity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    MediaManager mediaManager =
        CastReceiverContext.getInstance().getMediaManager();
    mediaManager.setMediaLoadCommandCallback(new MyMediaLoadCommandCallback());
  }
}

public class MyMediaLoadCommandCallback extends MediaLoadCommandCallback {
  @Override
  public Task onLoad(String senderId, MediaLoadRequestData loadRequestData) {
    return Tasks.call(() -> {
        // Resolve the entity into your data structure and load media.
        MediaInfo mediaInfo = loadRequestData.getMediaInfo();
        if (!checkMediaInfoSupported(mediaInfo)) {
          // Throw MediaException to indicate load failure.
          throw new MediaException(
              new MediaError.Builder()
                  .setDetailedErrorCode(DetailedErrorCode.LOAD_FAILED)
                  .setReason(MediaError.ERROR_REASON_INVALID_REQUEST)
                  .build());
        }
        myFillMediaInfo(new MediaInfoWriter(mediaInfo));
        myPlayerLoad(mediaInfo.getContentUrl());

        // Update media metadata and state (this clears all previous status
        // overrides).
        castReceiverContext.getMediaManager()
            .setDataFromLoad(loadRequestData);
        ...
        castReceiverContext.getMediaManager().broadcastMediaStatus();

        // Return the resolved MediaLoadRequestData to indicate load success.
        return loadRequestData;
    });
}

private void myPlayerLoad(String contentURL) {
  myPlayer.load(contentURL);

  // Update the MediaSession state.
  PlaybackStateCompat playbackState =
      new PlaybackStateCompat.Builder()
          .setState(
              player.getState(), player.getPosition(), System.currentTimeMillis())
          ...
          .build();
  mediaSession.setPlaybackState(playbackState);
}

Pour traiter l'intent de chargement, vous pouvez l'analyser dans les structures de données nous avons défini (MediaLoadRequestData) pour les requêtes de chargement).

Compatibilité avec les commandes multimédias

Compatibilité de base avec les commandes de lecture

Les commandes d'intégration de base incluent les commandes compatibles avec les contenus multimédias session. Ces commandes sont notifiées via des rappels de session multimédia. Vous devez enregistrez un rappel à la session multimédia pour effectuer cette opération. déjà).

Kotlin

private class MyMediaSessionCallback : MediaSessionCompat.Callback() {
  override fun onPause() {
    // Pause the player and update the play state.
    myPlayer.pause()
  }

  override fun onPlay() {
    // Resume the player and update the play state.
    myPlayer.play()
  }

  override fun onSeekTo(pos: Long) {
    // Seek and update the play state.
    myPlayer.seekTo(pos)
  }
    ...
 }

mediaSession.setCallback(MyMediaSessionCallback())

<ph type="x-smartling-placeholder">

</ph>

Java

private class MyMediaSessionCallback extends MediaSessionCompat.Callback {
  @Override
  public void onPause() {
    // Pause the player and update the play state.
    myPlayer.pause();
  }
  @Override
  public void onPlay() {
    // Resume the player and update the play state.
    myPlayer.play();
  }
  @Override
  public void onSeekTo(long pos) {
    // Seek and update the play state.
    myPlayer.seekTo(pos);
  }

  ...
}

mediaSession.setCallback(new MyMediaSessionCallback());

Compatibilité avec les commandes Cast

Certaines commandes Cast ne sont pas disponibles dans MediaSession tels que skipAd() ou setActiveMediaTracks() En outre, certaines commandes de file d'attente doivent être implémentées ici, car la file d'attente Cast n'est pas totalement compatible avec la file d'attente MediaSession.

Kotlin

class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onSkipAd(requestData: RequestData?): Task {
        // Skip your ad
        ...
        return Tasks.forResult(null)
    }
}

val mediaManager = CastReceiverContext.getInstance().getMediaManager()
mediaManager.setMediaCommandCallback(MyMediaCommandCallback())

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyMediaCommandCallback extends MediaCommandCallback {
  @Override
  public Task onSkipAd(RequestData requestData) {
    // Skip your ad
    ...
    return Tasks.forResult(null);
  }
}

MediaManager mediaManager =
    CastReceiverContext.getInstance().getMediaManager();
mediaManager.setMediaCommandCallback(new MyMediaCommandCallback());

Spécifier les commandes multimédias compatibles

Comme pour votre récepteur Cast, votre application Android TV doit spécifier les commandes sont pris en charge, les expéditeurs peuvent donc activer ou désactiver certaines commandes d'interface utilisateur. Pour qui font partie MediaSession spécifier les commandes dans PlaybackStateCompat D'autres commandes doivent être spécifiées dans la section MediaStatusModifier

Kotlin

// Set media session supported commands
val playbackState: PlaybackStateCompat = PlaybackStateCompat.Builder()
    .setActions(PlaybackStateCompat.ACTION_PLAY or PlaybackStateCompat.ACTION_PAUSE)
    .setState(PlaybackStateCompat.STATE_PLAYING)
    .build()

mediaSession.setPlaybackState(playbackState)

// Set additional commands in MediaStatusModifier
val mediaManager = CastReceiverContext.getInstance().getMediaManager()
mediaManager.getMediaStatusModifier()
    .setMediaCommandSupported(MediaStatus.COMMAND_QUEUE_NEXT)

<ph type="x-smartling-placeholder">

</ph>

Java

// Set media session supported commands
PlaybackStateCompat playbackState =
    new PlaybackStateCompat.Builder()
        .setActions(PlaybackStateCompat.ACTION_PLAY | PlaybackStateCompat.ACTION_PAUSE)
        .setState(PlaybackStateCompat.STATE_PLAYING)
        .build();

mediaSession.setPlaybackState(playbackState);

// Set additional commands in MediaStatusModifier
MediaManager mediaManager = CastReceiverContext.getInstance().getMediaManager();
mediaManager.getMediaStatusModifier()
            .setMediaCommandSupported(MediaStatus.COMMAND_QUEUE_NEXT);

Masquer les boutons non compatibles

Si votre application Android TV n'est compatible qu'avec les commandes multimédias de base, mais que votre Web Receiver prend en charge un contrôle plus avancé, vous devez vous assurer que l'application émettrice se comporte lorsque vous castez du contenu vers l'application Android TV. Par exemple, si votre Android TV ne permet pas de modifier la vitesse de lecture, contrairement à votre application Web Receiver. vous devez définir correctement les actions acceptées sur chaque plate-forme et vous assurer l'application émettrice affiche l'UI correctement.

Modifier MediaStatus

Pour prendre en charge les fonctionnalités avancées comme les titres, les annonces, le direct et la mise en file d'attente, votre Android L'appli TV doit fournir des informations supplémentaires qui ne peuvent pas être déterminées via MediaSession

Nous fournissons MediaStatusModifier pour y parvenir. MediaStatusModifier fonctionnera toujours sur le MediaSession que vous avez défini CastReceiverContext

Pour créer et diffuser MediaStatus:

Kotlin

val mediaManager: MediaManager = castReceiverContext.getMediaManager()
val statusModifier: MediaStatusModifier = mediaManager.getMediaStatusModifier()

statusModifier
    .setLiveSeekableRange(seekableRange)
    .setAdBreakStatus(adBreakStatus)
    .setCustomData(customData)

mediaManager.broadcastMediaStatus()

<ph type="x-smartling-placeholder">

</ph>

Java

MediaManager mediaManager = castReceiverContext.getMediaManager();
MediaStatusModifier statusModifier = mediaManager.getMediaStatusModifier();

statusModifier
    .setLiveSeekableRange(seekableRange)
    .setAdBreakStatus(adBreakStatus)
    .setCustomData(customData);

mediaManager.broadcastMediaStatus();

Notre bibliothèque cliente obtiendra l'élément MediaStatus de base à partir de MediaSession, votre L'application Android TV peut spécifier un état supplémentaire et le remplacer via un Modificateur MediaStatus.

Certains états et métadonnées peuvent être définis à la fois dans MediaSession et MediaStatusModifier Nous vous recommandons fortement de ne les configurer MediaSession Vous pouvez toujours utiliser le modificateur pour remplacer les états dans MediaSession : cette action est déconseillée, car l'état du modificateur ont une priorité plus élevée que les valeurs fournies par MediaSession.

Remarque :Il vous suffit d'appeler broadcastMediaStatus() si vous avez modifié ou mis à jour un MediaStatusModifier. Modifications apportées à Les MediaSession sont automatiquement diffusées.

Intercepter MediaStatus avant l'envoi

Identique au SDK Web Receiver, si vous souhaitez apporter des touches finales avant vous pouvez spécifier MediaStatusInterceptor pour traiter MediaStatus jusqu'à être envoyé. Nous transmettons MediaStatusWriter pour manipuler le MediaStatus avant qu'il ne soit envoyé.

Kotlin

mediaManager.setMediaStatusInterceptor(object : MediaStatusInterceptor {
    override fun intercept(mediaStatusWriter: MediaStatusWriter) {
      // Perform customization.
        mediaStatusWriter.setCustomData(JSONObject("{data: \"my Hello\"}"))
    }
})

<ph type="x-smartling-placeholder">

</ph>

Java

mediaManager.setMediaStatusInterceptor(new MediaStatusInterceptor() {
    @Override
    public void intercept(MediaStatusWriter mediaStatusWriter) {
        // Perform customization.
        mediaStatusWriter.setCustomData(new JSONObject("{data: \"my Hello\"}"));
    }
});

Gérer les identifiants utilisateur

Il est possible que votre appli Android TV n'autorise que certains utilisateurs à la lancer ou à la rejoindre session. Par exemple, n'autorisez un expéditeur à participer à un événement ou à un lancement que si:

• L'application émettrice est connectée au même compte et au même profil que l'application Android TV.
• L'application émettrice est connectée au même compte, mais avec un profil différent de celui de l'application Android TV.

Si votre application peut gérer plusieurs utilisateurs ou des utilisateurs anonymes, vous pouvez autoriser d'autres à rejoindre la session ATV. Si l'utilisateur fournit des identifiants, votre application Android TV doit gérer ses identifiants pour que sa progression et d'autres données utilisateur correctement suivis.

Lorsque l'application émettrice se lance ou rejoint votre application Android TV, elle doit fournir les identifiants qui représentent la personne qui rejoint la session.

Avant qu'un expéditeur lance et rejoint votre appli Android TV, vous pouvez spécifier un lancer le vérificateur pour voir si les identifiants de l’expéditeur sont autorisés. Si ce n'est pas le cas, la fonctionnalité Cast Le SDK Connect lance votre Web Receiver.

Données des identifiants pour le lancement de l'application émettrice

Côté expéditeur, vous pouvez spécifier l'CredentialsData pour représenter qui est pour rejoindre la session.

Le credentials est une chaîne qui peut être définie par l'utilisateur, à condition que votre téléviseur Android TV l'application puisse le comprendre. credentialsType définit la plate-forme sur laquelle CredentialsData provient de ou peut être une valeur personnalisée. Par défaut, il est défini à la plateforme d'où elles sont envoyées.

Le CredentialsData n'est transmis à votre appli Android TV que lors du lancement. l'heure de connexion. Si vous le définissez de nouveau alors que vous êtes connecté, il ne sera pas transmis à votre application Android TV. Si l'expéditeur change de profil alors que vous êtes connecté, vous peuvent soit rester dans la session, soit appeler SessionManager.endCurrentCastSession(boolean stopCasting) si vous pensez que le nouveau profil est incompatible avec la session.

La CredentialsData pour chaque expéditeur peuvent être récupérées getSenders le CastReceiverContext pour obtenir le SenderInfo, getCastLaunchRequest(). pour obtenir CastLaunchRequest, puis getCredentialsData().

<ph type="x-smartling-placeholder">

</ph>

Sur Android

Nécessite la version play-services-cast-framework 19.0.0 ou version ultérieure.

<ph type="x-smartling-placeholder">

</ph>

Kotlin

CastContext.getSharedInstance().setLaunchCredentialsData(
    CredentialsData.Builder()
        .setCredentials("{\"userId\": \"abc\"}")
        .build()
)

<ph type="x-smartling-placeholder">

</ph>

Java

CastContext.getSharedInstance().setLaunchCredentialsData(
    new CredentialsData.Builder()
        .setCredentials("{\"userId\": \"abc\"}")
        .build());

<ph type="x-smartling-placeholder">

</ph>

iOS

Nécessite google-cast-sdk version v4.8.3 ou plus élevée.

Vous pouvez l'appeler à tout moment une fois les options définies: GCKCastContext.setSharedInstanceWith(options)

GCKCastContext.sharedInstance().setLaunch(
    GCKCredentialsData(credentials: "{\"userId\": \"abc\"}")

<ph type="x-smartling-placeholder">

</ph>

Web

Version du navigateur Chromium requise M87 ou version ultérieure.

Vous pouvez l'appeler à tout moment une fois les options définies: cast.framework.CastContext.getInstance().setOptions(options);

let credentialsData =
    new chrome.cast.CredentialsData("{\"userId\": \"abc\"}");
cast.framework.CastContext.getInstance().setLaunchCredentialsData(credentialsData);

Implémenter l'outil de vérification des demandes de lancement ATV

La CredentialsData est transmis à votre application Android TV lorsqu'un expéditeur tente de lancer ou de rejoindre un cours. Vous pouvez implémenter une LaunchRequestChecker pour autoriser ou refuser cette demande.

Si une requête est rejetée, Web Receiver est chargé au lieu d'être lancé nativement dans l'application Android TV. Vous devez rejeter une demande si votre véhicule tout-terrain n'est pas en mesure de gérer l'utilisateur qui demande un lancement ou une inscription. Il peut s'agir, par exemple, qu'un autre l'utilisateur est connecté à l'application Android TV que celle qui l'a demandée et votre application ne peut pas gérer les identifiants de changement d'adresse, ou si aucun utilisateur n'est actuellement connecté Application Android TV.

Si une requête est autorisée, l'application Android TV se lance. Vous pouvez personnaliser ce paramètre selon que votre application est compatible ou non avec l'envoi de requêtes de chargement lorsqu'un utilisateur n'est pas connecté à l'application Android TV ou en cas de non-concordance de l'utilisateur. Ce comportement est entièrement personnalisable dans LaunchRequestChecker.

Créez une classe implémentant la classe CastReceiverOptions.LaunchRequestChecker interface:

Kotlin

class MyLaunchRequestChecker : LaunchRequestChecker {
  override fun checkLaunchRequestSupported(launchRequest: CastLaunchRequest): Task {
    return Tasks.call {
      myCheckLaunchRequest(
           launchRequest
      )
    }
  }
}

private fun myCheckLaunchRequest(launchRequest: CastLaunchRequest): Boolean {
  val credentialsData = launchRequest.getCredentialsData()
     ?: return false // or true if you allow anonymous users to join.

  // The request comes from a mobile device, e.g. checking user match.
  return if (credentialsData.credentialsType == CredentialsData.CREDENTIALS_TYPE_ANDROID) {
     myCheckMobileCredentialsAllowed(credentialsData.getCredentials())
  } else false // Unrecognized credentials type.
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyLaunchRequestChecker
    implements CastReceiverOptions.LaunchRequestChecker {
  @Override
  public Task checkLaunchRequestSupported(CastLaunchRequest launchRequest) {
    return Tasks.call(() -> myCheckLaunchRequest(launchRequest));
  }
}

private boolean myCheckLaunchRequest(CastLaunchRequest launchRequest) {
  CredentialsData credentialsData = launchRequest.getCredentialsData();
  if (credentialsData == null) {
    return false;  // or true if you allow anonymous users to join.
  }

  // The request comes from a mobile device, e.g. checking user match.
  if (credentialsData.getCredentialsType().equals(CredentialsData.CREDENTIALS_TYPE_ANDROID)) {
    return myCheckMobileCredentialsAllowed(credentialsData.getCredentials());
  }

  // Unrecognized credentials type.
  return false;
}

Ensuite, configurez-le dans votre ReceiverOptionsProvider:

Kotlin

class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
        ...
        .setLaunchRequestChecker(MyLaunchRequestChecker())
        .build()
  }
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        ...
        .setLaunchRequestChecker(new MyLaunchRequestChecker())
        .build();
  }
}

Résolution de true dans le LaunchRequestChecker lance l'application Android TV et false lance votre application Web Receiver.

Envoi et Recevoir des messages personnalisés

Le protocole Cast vous permet d'envoyer des messages sous forme de chaîne personnalisée entre des expéditeurs et votre application réceptrice. Vous devez enregistrer un espace de noms (canal) pour envoyer messages avant d'initialiser CastReceiverContext

Android TV : spécifier un espace de noms personnalisé

Vous devez spécifier les espaces de noms compatibles dans votre CastReceiverOptions pendant la configuration:

Kotlin

class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
        .setCustomNamespaces(
            Arrays.asList("urn:x-cast:com.example.cast.mynamespace")
        )
        .build()
  }
}

<ph type="x-smartling-placeholder">

</ph>

Java

public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        .setCustomNamespaces(
              Arrays.asList("urn:x-cast:com.example.cast.mynamespace"))
        .build();
  }
}

Remarque: Les espaces de noms doivent commencer par le préfixe urn:x-cast:.

Android TV : envoi de messages

Kotlin

// If senderId is null, then the message is broadcasted to all senders.
CastReceiverContext.getInstance().sendMessage(
    "urn:x-cast:com.example.cast.mynamespace", senderId, customString)

<ph type="x-smartling-placeholder">

</ph>

Java

// If senderId is null, then the message is broadcasted to all senders.
CastReceiverContext.getInstance().sendMessage(
    "urn:x-cast:com.example.cast.mynamespace", senderId, customString);

Android TV : recevoir des messages dans l'espace de noms personnalisé

Kotlin

class MyCustomMessageListener : MessageReceivedListener {
    override fun onMessageReceived(
        namespace: String, senderId: String?, message: String ) {
        ...
    }
}

CastReceiverContext.getInstance().setMessageReceivedListener(
    "urn:x-cast:com.example.cast.mynamespace", new MyCustomMessageListener());

<ph type="x-smartling-placeholder">

</ph>

Java

class MyCustomMessageListener implements CastReceiverContext.MessageReceivedListener {
  @Override
  public void onMessageReceived(
      String namespace, String senderId, String message) {
    ...
  }
}

CastReceiverContext.getInstance().setMessageReceivedListener(
    "urn:x-cast:com.example.cast.mynamespace", new MyCustomMessageListener());