Ajouter les principales fonctionnalités à votre récepteur Android TV

Cette page contient des extraits de code et des descriptions des fonctionnalités disponibles pour personnaliser une application réceptrice Android TV.

Configurer des bibliothèques

Pour rendre les API Cast Connect disponibles pour votre application Android TV:

Android
  1. Ouvrez le fichier build.gradle dans le répertoire du module de votre application.
  2. Vérifiez que google() est inclus dans la liste repositories.
      repositories {
        google()
      }
  3. En fonction du type d'appareil que vous ciblez pour votre application, ajoutez les dernières versions des bibliothèques à vos dépendances :
    • Pour l'application Android Receiver :
        dependencies {
          implementation 'com.google.android.gms:play-services-cast-tv:20.0.0'
          implementation 'com.google.android.gms:play-services-cast:21.2.0'
        }
    • Pour l'application Android Sender :
        dependencies {
          implementation 'com.google.android.gms:play-services-cast:20.0.0'
          implementation 'com.google.android.gms:play-services-cast-framework:21.2.0'
        }
    Veillez à mettre à jour ce numéro de version chaque fois que les services sont mis à jour.
  4. Enregistrez les modifications et cliquez sur Sync Project with Gradle Files dans la barre d'outils.
iOS
  1. Assurez-vous que Podfile cible google-cast-sdk 4.7.0 ou une version ultérieure
  2. Ciblez iOS 12 ou une version ultérieure. Pour en savoir plus, consultez les notes de version.
      platform: ios, '12'
    
      def target_pods
         pod 'google-cast-sdk', '~>4.7.0'
      end
Web
  1. Nécessite la version M87 ou une version ultérieure du navigateur Chromium.
  2. Ajoutez 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>

Configuration requise pour AndroidX

Les nouvelles versions des services Google Play nécessitent la mise à jour d'une application pour qu'elle utilise l'espace de noms androidx. Suivez les instructions pour migrer vers AndroidX.

Application Android TV : conditions préalables

Pour utiliser Cast Connect dans votre application Android TV, vous devez créer et gérer des événements à partir d'une session multimédia. Les données fournies par votre session multimédia fournissent les informations de base (position, état de lecture, etc.) correspondant à l'état de votre contenu multimédia. Votre bibliothèque multimédia est également utilisée par la bibliothèque Cast Connect pour signaler quand elle a reçu certains messages d'un expéditeur, par exemple une pause.

Pour en savoir plus sur les sessions multimédias et sur l'initialisation d'une session multimédia, consultez le guide d'utilisation d'une session multimédia.

Cycle de vie d'une session multimédia

Votre application doit créer une session multimédia au démarrage de la lecture et la libérer lorsqu'elle ne peut plus être contrôlée. Par exemple, si votre application est une application vidéo, vous devez libérer la session lorsque l'utilisateur quitte l'activité de lecture, soit en sélectionnant "back-to-back" pour parcourir d'autres contenus, soit en arrière-plan. S'il s'agit d'une application musicale, vous devez la libérer lorsque votre application ne lit plus de support.

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

Les données de votre session multimédia doivent être à jour en fonction de l'état de votre lecteur. Par exemple, lorsque la lecture est suspendue, vous devez mettre à jour l'état de la lecture ainsi que les actions compatibles. Les tableaux suivants répertorient les états que vous devez maintenir à jour.

MediaMetadataCompat

Champ de métadonnées Description
METADATA_KEY_TITLE (obligatoire) Titre du contenu multimédia.
METADATA_KEY_DISPLAY_SUBTITLE 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 Content ID
METADATA_KEY_ARTIST L'artiste.
METADATA_KEY_ALBUM Album.

PlaybackStateCompat

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

SessionSessionCompat

Méthode requise Description
setRépéterMode() Définit le mode de répétition.
setShuffleMode(). Active 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)
}
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 mettre en œuvre un rappel de contrôle de transport de session multimédia. Le tableau suivant indique les actions de contrôle du transport qu'il doit gérer:

MediaSessionCompat.Callback

Actions Description
onPlay() Réactiver
onPause() Pause
onSeekTo() Atteindre une position
onStop() Arrêter le contenu multimédia en cours
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() );
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é 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 est chargée de la gérer et de créer une instance de l'objet CastReceiverContext lorsque l'application TV est lancée. L'objet CastReceiverContext est nécessaire pour interagir avec Cast lorsque l'application TV est en cours d'exécution. Cet objet permet à votre application TV d'accepter les messages multimédias Cast provenant de tout 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 l'intent de lancement depuis votre application d'expéditeur:

<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>

Indiquer le fournisseur d'options destinataires

Vous devez implémenter un ReceiverOptionsProvider pour fournir un CastReceiverOptions :

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

Ensuite, spécifiez le fournisseur d'options dans votre 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 CastReceiverOptions lors de l'initialisation de CastReceiverContext.

Contexte du récepteur Cast

Initialisez CastReceiverContext lors de la création de votre application:

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

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

  ...
}

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

Kotlin
CastReceiverContext.getInstance().start()
Java
CastReceiverContext.getInstance().start();

Appelez stop() sur le CastReceiverContext une fois l'application exécutée en arrière-plan pour les applications vidéo ou les applications non compatibles avec la lecture en arrière-plan:

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

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

Nous vous recommandons vivement d'utiliser LifecycleObserver de la bibliothèque androidx.lifecycle pour gérer les appels CastReceiverContext.start() et CastReceiverContext.stop(), en particulier si votre application native comporte plusieurs activités. Cela évite les conditions de concurrence lorsque vous appelez start() et stop() à partir d'activités différentes.

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())
  }
}
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 afin qu'il sache où envoyer les commandes et récupérer l'état de la lecture du contenu multimédia:

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

Lorsque vous publiez votre MediaSession en raison d'une lecture inactive, vous devez définir un jeton nul sur MediaManager:

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

Si votre application est compatible avec la lecture de contenus multimédias en arrière-plan, au lieu d'appeler CastReceiverContext.stop() lorsqu'elle est envoyée en arrière-plan, vous ne devez l'appeler que lorsqu'elle est en arrière-plan et qu'elle ne lit plus de 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()
  }
}
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 MediaSessionConnector pour gérer automatiquement la session et toutes les informations associées, y compris l'état de lecture, au lieu de suivre manuellement les modifications.

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

Pour intégrer MediaSessionConnector à votre application, ajoutez le code suivant à votre classe d'activité du lecteur ou à l'emplacement où vous gérez 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)
    ...
  }
}
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'appli de l'expéditeur

Activer la compatibilité avec Cast Connect

Une fois que vous avez mis à jour votre application émettrice avec la compatibilité Cast Connect, vous pouvez déclarer son état de préparation en définissant l'option androidReceiverCompatible sur LaunchOptions sur "true".

Android

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

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

Kotlin
class CastOptionsProvider : OptionsProvider {
  override fun getCastOptions(context: Context?): CastOptions {
    val launchOptions: LaunchOptions = Builder()
          .setAndroidReceiverCompatible(true)
          .build()
    return CastOptions.Builder()
          .setLaunchOptions(launchOptions)
          ...
          .build()
    }
}
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();
  }
}
iOS

Requiert google-cast-sdk version v4.4.8 ou ultérieure.

L'option androidReceiverCompatible est définie dans 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)
Web

Nécessite la version M87 ou ultérieure du navigateur Chromium.

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

Configuration de la Developers Console

Configurer l'application Android TV

Ajoutez le nom de package de votre application Android TV dans la console développeur Cast afin de 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 dans la console de développement Cast.

Sans enregistrement, Cast Connect ne fonctionnera que pour les applications installées à partir du Google Play Store pour des raisons de sécurité.

Pour savoir comment enregistrer un appareil Cast ou Android TV pour le développement Cast, 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 l'entité par l'expéditeur

Sur les expéditeurs, vous pouvez transmettre le lien profond en définissant entity dans les informations sur les médias de la requête de chargement:

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)
Android
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);
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)
Web

Nécessite la version M87 ou ultérieure du navigateur Chromium.

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 de package que vous avez défini dans la console développeur.

Définir des identifiants Android TV sur l'expéditeur

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

Android
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)
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);
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)
Web

Nécessite la version M87 ou ultérieure du navigateur Chromium.

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 application Android TV est lancée, le SDK remplace entity et credentials par 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 Content URL dans vos informations multimédias, ou si vous utilisez les données de requête de chargement multimédia plus détaillées, vous devez ajouter le filtre d'intention prédéfini suivant dans 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 pour le chargement par entité, vous pouvez créer une requête de chargement avec vos informations de contenu et appeler load().

Android
Kotlin
val mediaToLoad = MediaInfo.Builder("some-id").build()
val loadRequest = MediaLoadRequestData.Builder()
    .setMediaInfo(mediaToLoad)
    .setCredentials("user-credentials")
    ...
    .build()
remoteMediaClient.load(loadRequest)
Java
MediaInfo mediaToLoad =
    new MediaInfo.Builder("some-id").build();
MediaLoadRequestData loadRequest =
    new MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        ...
        .build();
remoteMediaClient.load(loadRequest);
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)
Web

Nécessite la version M87 ou ultérieure du navigateur Chromium.

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);

Gérer les requêtes de chargement

Dans votre activité, pour gérer ces requêtes de chargement, vous devez gérer les intents dans les rappels de cycle de vie de l'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.
    ...
  }
}
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 charge, il extrait un objet MediaLoadRequestData de cet intent et appelle MediaLoadCommandCallback.onLoad(). Vous devez remplacer cette méthode pour gérer la requête de chargement. Le rappel doit être enregistré avant que MediaManager.onNewIntent() ne soit appelé (nous recommandons de l'utiliser sur une méthode 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)
  }
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 que nous avons définies (MediaLoadRequestData pour les requêtes de chargement).

Commandes multimédias compatibles

Compatibilité de base avec les commandes de lecture

Les commandes d'intégration de base incluent les commandes compatibles avec la session multimédia. Ces commandes sont notifiées via des rappels de session multimédia. Pour ce faire, vous devez enregistrer un rappel vers une session multimédia (vous le faites peut-être 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())
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());

Commandes de diffusion compatibles

Certaines commandes Cast ne sont pas disponibles dans MediaSession, telles 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 entièrement 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())
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 compatibles afin que les expéditeurs puissent activer ou désactiver certaines commandes de l'interface utilisateur. Pour les commandes faisant partie de MediaSession, spécifiez les commandes dans PlaybackStateCompat. Des commandes supplémentaires doivent être spécifiées dans 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)
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 un contrôle multimédia de base, mais que votre application Web Receiver est compatible avec un contrôle plus avancé, assurez-vous que l'application émetteur se comporte correctement lorsque vous castez du contenu vers l'application Android TV. Par exemple, si votre application Android TV ne permet pas de modifier la vitesse de lecture alors que votre application Web Receiver le permet, vous devez définir correctement les actions compatibles sur chaque plate-forme et vous assurer que l'application expéditeur affiche correctement l'interface utilisateur.

Modification de MediaStatus

Pour accepter les fonctionnalités avancées, telles que les titres, les annonces, les diffusions en direct et la mise en file d'attente, votre application Android TV doit fournir des informations supplémentaires qui ne peuvent pas être vérifiées via MediaSession.

Pour ce faire, nous vous fournissons la classe MediaStatusModifier. MediaStatusModifier fonctionnera toujours sur le MediaSession que vous avez défini dans 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()
Java
MediaManager mediaManager = castReceiverContext.getMediaManager();
MediaStatusModifier statusModifier = mediaManager.getMediaStatusModifier();

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

mediaManager.broadcastMediaStatus();

Notre bibliothèque cliente obtiendra le code MediaStatus de base à partir de MediaSession. Votre application Android TV peut spécifier un état supplémentaire et remplacer l'état via un modificateur MediaStatus.

Certains états et métadonnées peuvent être définis à la fois dans MediaSession et MediaStatusModifier. Nous vous recommandons vivement de ne les définir que dans MediaSession. Vous pouvez toujours utiliser le modificateur pour remplacer les états de MediaSession. Nous vous le déconseillons, car l'état du modificateur a toujours une priorité supérieure aux valeurs fournies par MediaSession.

Intercepter l'état MediaStatus avant l'envoi

Comme pour le SDK Récepteur Web, si vous souhaitez apporter des touches finales avant d'envoyer votre message, vous pouvez spécifier un MediaStatusInterceptor pour traiter l'objet MediaStatus à envoyer. Nous transmettons un MediaStatusWriter pour manipuler le MediaStatus avant son envoi.

Kotlin
mediaManager.setMediaStatusInterceptor(object : MediaStatusInterceptor {
    override fun intercept(mediaStatusWriter: MediaStatusWriter) {
      // Perform customization.
        mediaStatusWriter.setCustomData(JSONObject("{data: \"my Hello\"}"))
    }
})
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 application Android TV n'autorise que certains utilisateurs à lancer ou à rejoindre la session de l'application. Par exemple, autorisez un expéditeur à lancer ou rejoindre une réunion uniquement 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 à un profil différent de l'application Android TV.

Si votre application peut gérer plusieurs utilisateurs ou des utilisateurs anonymes, vous pouvez autoriser d'autres utilisateurs à participer à la session tout-terrain. Si l'utilisateur fournit des identifiants, votre application Android TV doit les gérer afin que leur progression et les autres données utilisateur puissent être correctement suivies.

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

Avant qu'un expéditeur lance et rejoigne votre application Android TV, vous pouvez spécifier un vérificateur de lancement pour vérifier si les identifiants de l'expéditeur sont autorisés. Si ce n'est pas le cas, le SDK Cast Connect revient au lancement de votre récepteur Web.

Données des identifiants de lancement d'application de l'expéditeur

Du côté de l'expéditeur, vous pouvez spécifier le CredentialsData pour représenter le participant à la session.

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

L'identifiant CredentialsData n'est transmis à votre application Android TV qu'au moment du lancement ou de la connexion. Si vous le configurez à nouveau lorsque vous êtes connecté, il ne sera pas transmis à votre application Android TV. Si l'expéditeur change de profil pendant la connexion, vous pouvez rester dans la session ou appeler SessionManager.endCurrentCastSession(boolean stopCasting) si vous pensez que le nouveau profil n'est pas compatible avec la session.

L'élément CredentialsData de chaque expéditeur peut être récupéré à l'aide de getSenders sur CastReceiverContext pour obtenir l'élément SenderInfo, getCastLaunchRequest() pour obtenir l'élément CastLaunchRequest, puis getCredentialsData().

Android

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

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

Requiert google-cast-sdk version v4.7.0 ou ultérieure.

Vous pouvez appeler cette méthode à tout moment une fois les options définies : GCKCastContext.setSharedInstanceWith(options).

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

Nécessite la version M87 ou ultérieure du navigateur Chromium.

Vous pouvez appeler cette méthode à 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 pour véhicules tout-terrain

Le CredentialsData est transmis à votre application Android TV lorsqu'un expéditeur tente de se lancer ou de rejoindre la réunion. Vous pouvez implémenter un LaunchRequestChecker. pour autoriser ou refuser cette demande.

Si une requête est refusée, le récepteur Web est chargé au lieu de se lancer de manière native dans l'application Android TV. Vous devez rejeter une requête si votre véhicule ATV ne peut pas gérer l'utilisateur qui demande à lancer ou rejoindre la réunion. Il est possible qu'un autre utilisateur soit connecté à l'application Android TV et que celle-ci ne soit pas en mesure de gérer les identifiants de transfert, ou qu'aucun utilisateur ne soit actuellement connecté à l'application Android TV.

Si une requête est autorisée, l'application Android TV s'ouvre. Vous pouvez personnaliser ce comportement selon que votre application accepte l'envoi de requêtes de charge 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 gérable dans le LaunchRequestChecker.

Créez une classe mettant en œuvre l'interface CastReceiverOptions.LaunchRequestChecker:

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.
}
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;
}

Définissez-la ensuite dans votre ReceiverOptionsProvider :

Kotlin
class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
        ...
        .setLaunchRequestChecker(MyLaunchRequestChecker())
        .build()
  }
}
Java
public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        ...
        .setLaunchRequestChecker(new MyLaunchRequestChecker())
        .build();
  }
}

La résolution de true dans LaunchRequestChecker lance l'application Android TV et false lance votre application Récepteur Web.

Envoyer des messages personnalisés

Le protocole Cast vous permet d'envoyer des messages de chaîne personnalisés entre les expéditeurs et votre application destinataire. Vous devez enregistrer un espace de noms (canal) vers lequel envoyer les messages avant d'initialiser votre CastReceiverContext.

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

Vous devez spécifier les espaces de noms acceptés dans votre CastReceiverOptions lors de 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()
  }
}
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();
  }
}

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)
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());
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());