Aggiungi funzionalità principali al ricevitore Android TV

Questa pagina contiene snippet di codice e descrizioni delle funzionalità disponibili per personalizzare un'app di ricezione Android TV.

Nota: ti consigliamo di provare quanto segue:

• Tutorial del codelab di trasmissione su Android TV - Scopri passo passo come creare un'app di ricezione Android TV compatibile con la trasmissione utilizzando l'SDK Google Cast in grado di ricevere trasmissioni video.
• App di esempio CastAndroidTvReceiver (GitHub) - Esegui, naviga e visualizza questa app di esempio di riferimento conforme alle linee guida UX e alla lista di controllo del design.
• App di esempio per i mittenti di CastVideos (GitHub) - Esegui il test utilizzando le app di esempio di riferimento per i mittenti compatibili con Cast Connect.

Configurazione delle librerie

Per rendere disponibili le API Cast Connect per la tua app per Android TV:

Android

1. Apri il file build.gradle all'interno della directory del modulo dell'applicazione.
   Nota: i progetti Android Studio contengono un file build.gradle di primo livello e un file build.gradle per ogni modulo. Assicurati di modificare il file per il modulo dell'applicazione. Per ulteriori informazioni su Gradle, consulta Creazione del progetto con Gradle.
2. Verifica che google() sia incluso in repositories elencato.

     repositories {
       google()
     }

3. A seconda del tipo di dispositivo di destinazione per la tua app, aggiungi le versioni più recenti delle librerie alle dipendenze:
   • Per l'app di ricezione Android:

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

   • Per l'app Mittente Android:

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

   Assicurati di aggiornare questo numero di versione ogni volta che i servizi vengono aggiornati.
4. Salva le modifiche e fai clic su Sync Project with Gradle Files nella barra degli strumenti.

iOS

1. Assicurati che Podfile abbia come target google-cast-sdk 4.8.3 o versioni successive
2. Scegli come target iOS 14 o versioni successive. Per ulteriori dettagli, consulta le note di rilascio.

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

Web

1. È richiesta la versione M87 o successive del browser Chromium.
2. Aggiungere la libreria dell'API Web Sender al progetto

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

Requisito AndroidX

Le nuove versioni di Google Play Services richiedono che un'app sia stata aggiornata per poter utilizzare il nome spazio androidx. Segui le istruzioni per la migrazione ad AndroidX.

App per Android TV: prerequisiti

Per supportare Cast Connect nella tua app per Android TV, devi creare e supportare gli eventi da una sessione multimediale. I dati forniti dalla sessione multimediale forniscono le informazioni di base, ad esempio posizione, stato di riproduzione e così via, per lo stato dei contenuti multimediali. La sessione multimediale viene utilizzata anche dalla libreria Cast Connect per indicare quando ha ricevuto determinati messaggi da un mittente, ad esempio la messa in pausa.

Per ulteriori informazioni sulla sessione multimediale e su come inizializzarla, consulta la guida all'utilizzo di una sessione multimediale.

Ciclo di vita della sessione multimediale

L'app deve creare una sessione multimediale all'avvio della riproduzione e rilasciarla quando non può più essere controllata. Ad esempio, se la tua app è un'app video, devi rilasciare la sessione quando l'utente esce dall'attività di riproduzione selezionando "Indietro" per sfogliare altri contenuti o mettendo l'app in background. Se la tua app è un'app di musica, devi rilasciarla quando non riproduce più contenuti multimediali.

Aggiornamento dello stato della sessione

Nota: se utilizzi Exoplayer, consulta la sezione Utilizzare Exoplayer con Cast Connect per scoprire come aggiornare automaticamente la sessione multimediale.

I dati nella sessione multimediale devono essere aggiornati in base allo stato del media player. Ad esempio, quando la riproduzione è in pausa, devi aggiornare lo stato della riproduzione e le azioni supportate. Le tabelle seguenti elencano gli stati che devi mantenere aggiornati.

MediaMetadataCompat

Campo metadati	Descrizione
METADATA_KEY_TITLE (obbligatorio)	Il titolo del contenuto multimediale.
METADATA_KEY_DISPLAY_SUBTITLE	Il sottotitolo.
METADATA_KEY_DISPLAY_ICON_URI	L'URL dell'icona.
METADATA_KEY_DURATION (obbligatorio)	Durata dei contenuti multimediali.
METADATA_KEY_MEDIA_URI	L'ID Content.
METADATA_KEY_ARTIST	L'artista.
METADATA_KEY_ALBUM	L'album.

PlaybackStateCompat

Metodo obbligatorio	Descrizione
setActions()	Imposta i comandi multimediali supportati.
setState()	Imposta lo stato di riproduzione e la posizione corrente.

MediaSessionCompat

Metodo obbligatorio	Descrizione
setRepeatMode()	Imposta la modalità di ripetizione.
setShuffleMode()	Imposta la modalità di riproduzione casuale.
setMetadata()	Imposta i metadati dei contenuti multimediali.
setPlaybackState()	Imposta lo stato di riproduzione.

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

Gestire il controllo del trasporto

L'app deve implementare il callback del controllo del trasporto della sessione multimediale. La tabella seguente mostra le azioni di controllo del trasporto che devono essere gestite:

MediaSessionCompat.Callback

Azioni	Descrizione
onPlay()	Riprendi
onPause()	Metti in pausa
onSeekTo()	Andare a una posizione
onStop()	Interrompere i contenuti multimediali in riproduzione

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

Configurare il supporto di Trasmissione

Quando una richiesta di avvio viene inviata da un'applicazione mittente, viene creato un intento con uno spazio dei nomi dell'applicazione. L'applicazione è responsabile della gestione e della creazione di un'istanza dell'oggetto CastReceiverContext al momento dell'avvio dell'app TV. L'oggetto CastReceiverContext è necessario per interagire con Google Cast mentre l'app TV è in esecuzione. Questo oggetto consente all'applicazione TV di accettare i messaggi multimediali di trasmissione provenienti da qualsiasi mittente connesso.

Configurazione di Android TV

Aggiunta di un filtro per intent di lancio

Aggiungi un nuovo filtro per intent all'attività in cui vuoi gestire l'intent di lancio dall'app mittente:

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

Specifica il fornitore di opzioni per i destinatari

Devi implementare un ReceiverOptionsProvider per fornire 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();
  }
}

Nota: se non imposti setStatusText, questo viene estratto automaticamente da android:label nel file manifest di Android TV.

Quindi, specifica il fornitore di opzioni in AndroidManifest:

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

ReceiverOptionsProvider viene utilizzato per fornire CastReceiverOptions quando viene inizializzato CastReceiverContext.

Contesto del ricevitore di trasmissione

Inizializza CastReceiverContext quando viene creata l'app:

Kotlin

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

  ...
}

Java

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

  ...
}

Avvia CastReceiverContext quando l'app passa in primo piano:

Kotlin

CastReceiverContext.getInstance().start()

Java

CastReceiverContext.getInstance().start();

Chiama stop() sul CastReceiverContext dopo che l'app passa in background per le app video o le app che non supportano la riproduzione in background:

Kotlin

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

Java

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

Inoltre, se la tua app supporta la riproduzione in background, chiama stop() su CastReceiverContext quando la riproduzione si interrompe in background.

Ti consigliamo vivamente di utilizzare LifecycleObserver dalla biblioteca androidx.lifecycle per gestire le chiamate CastReceiverContext.start() e CastReceiverContext.stop(), soprattutto se la tua app nativa ha più attività. In questo modo si evitano condizioni di gara quando chiami start() e stop() da attività diverse.

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

Collegamento di MediaSession a MediaManager

Quando crei un MediaSession, devi anche fornire il token MediaSession corrente a CastReceiverContext in modo che sappia dove inviare i comandi e recuperare lo stato di riproduzione dei contenuti multimediali:

Kotlin

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

Java

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

Quando rilasci il MediaSession a causa di una riproduzione non attiva, devi impostare un token null su MediaManager:

Kotlin

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

Java

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

Se la tua app supporta la riproduzione di contenuti multimediali quando è in background, anziché chiamare CastReceiverContext.stop() quando l'app viene inviata in background, devi chiamarla solo quando l'app è in background e non riproduce più contenuti multimediali. Ad esempio:

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

Utilizzare Exoplayer con Cast Connect

Se utilizzi Exoplayer, puoi utilizzare MediaSessionConnector per gestire automaticamente la sessione e tutte le informazioni correlate, incluso lo stato della riproduzione, anziché monitorare le modifiche manualmente.

MediaSessionConnector.MediaButtonEventHandler può essere utilizzato per gestire gli eventi MediaButton chiamando setMediaButtonEventHandler(MediaButtonEventHandler) che altrimenti vengono gestiti da MediaSessionCompat.Callback per impostazione predefinita.

Per integrare MediaSessionConnector nella tua app, aggiungi quanto segue alla classe dell'attività del player o al punto in cui gestisci la sessione multimediale:

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

Configurazione dell'app mittente

Attivare il supporto di Cast Connect

Dopo aver aggiornato l'app mittente con il supporto di Cast Connect, puoi dichiararne la disponibilità impostando il flag androidReceiverCompatible su LaunchOptions su true.

Android

Richiede play-services-cast-framework versione 19.0.0 o successive.

Il flag androidReceiverCompatible è impostato in LaunchOptions (che fa parte di 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

Richiede google-cast-sdk versione v4.4.8 o superiore.

Il flag androidReceiverCompatible è impostato in GCKLaunchOptions (che fa parte di GCKCastOptions):

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

Web

Richiede il browser Chromium versioneM87 o successive.

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

Configurazione della Console per gli sviluppatori di Google Cast

Configurare l'app Android TV

Aggiungi il nome del pacchetto della tua app per Android TV in Console per sviluppatori Google Cast per associarla al tuo ID app Google Cast.

Registra i dispositivi degli sviluppatori

Registra il numero di serie del dispositivo Android TV che utilizzerai per lo sviluppo in Cast Developer Console.

Nota: ai dispositivi Android TV (ATV) sono associati più numeri di serie. Devi utilizzare il numero di serie del software (Cast) del dispositivo ATV. Per informazioni dettagliate su come trovarlo, consulta la sezione Determinare il numero di serie di un dispositivo ATV.

Per motivi di sicurezza, senza registrazione Cast Connect funzionerà solo per le app installate dal Google Play Store.

Per ulteriori informazioni sulla registrazione di un dispositivo Google Cast o Android TV per lo sviluppo di Cast, consulta la pagina di registrazione.

Caricamento dei contenuti multimediali

Se hai già implementato il supporto dei link diretti nella tua app per Android TV, dovresti avere una definizione simile configurata nel file manifest di 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>

Caricamento per entità sul mittente

Sui mittenti, puoi passare il link diretto impostando entity nelle informazioni sui contenuti multimediali per la richiesta di caricamento:

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

Richiede il browser Chromium versioneM87 o successive.

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

Il comando di caricamento viene inviato tramite un'intent con il link diretto e il nome del pacchetto che hai definito nella Console per gli sviluppatori.

Impostazione delle credenziali ATV sul mittente

È possibile che l'app Web Receiver e l'app Android TV supportino diversi link diretti e credentials (ad esempio se gestisci l'autenticazione in modo diverso sulle due piattaforme). Per risolvere il problema, puoi fornire entity e credentials alternativi per 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

Richiede il browser Chromium versioneM87 o successive.

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

Se l'app Web Receiver è avviata, utilizza entity e credentials nella richiesta di caricamento. Tuttavia, se l'app per Android TV viene lanciata, l'SDK sostituisce entity e credentials con atvEntity e atvCredentials (se specificati).

Caricamento tramite Content ID o MediaQueueData

Se non utilizzi entity o atvEntity e utilizzi Content ID o URL dei contenuti nelle informazioni multimediali o i dati della richiesta di caricamento dei contenuti più dettagliati, devi aggiungere il seguente filtro intent predefinito nella tua app per 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>

Sul lato del mittente, in modo simile al caricamento per entità, puoi creare una richiesta di caricamento con le informazioni sui tuoi contenuti e chiamare 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

Richiede il browser Chromium versioneM87 o successive.

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

Gestione delle richieste di caricamento

Nella tua attività, per gestire queste richieste di caricamento, devi gestire le intenzioni nei callback del ciclo di vita dell'attività:

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

Se MediaManager rileva che l'intenzione è un'intenzione di caricamento, estrae un MediaLoadRequestData oggetto dall'intenzione e invoca MediaLoadCommandCallback.onLoad(). Devi sostituire questo metodo per gestire la richiesta di caricamento. Il callback deve essere registrato prima della chiamata di MediaManager.onNewIntent() (è consigliabile che si trovi in un metodo onCreate() di attività o applicazione).

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

Per elaborare l'intent di caricamento, puoi analizzarlo nelle strutture di dati che abbiamo definito (MediaLoadRequestData per le richieste di caricamento).

Supporto dei comandi multimediali

Supporto di base per i controlli di riproduzione

I comandi di integrazione di base includono i comandi compatibili con la sessione media. Questi comandi vengono notificati tramite i callback della sessione multimediale. Per supportare questa funzionalità, devi registrare un callback alla sessione multimediale (potrebbe essere già abilitato).

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

Supporto dei comandi di controllo di Google Cast

Alcuni comandi di trasmissione non sono disponibili in MediaSession, come skipAd() o setActiveMediaTracks(). Inoltre, alcuni comandi di coda devono essere implementati qui perché la coda di trasmissione non è completamente compatibile con la coda MediaSession.

Kotlin

class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onSkipAd(requestData: RequestData?): Task<Void?> {
        // 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());

Specificare i comandi multimediali supportati

Come per il ricevitore di trasmissione, l'app Android TV deve specificare quali comandi sono supportati, in modo che i mittenti possano attivare o disattivare determinati controlli dell'interfaccia utente. Per i comandi che fanno parte di MediaSession, specifica i comandi in PlaybackStateCompat. I comandi aggiuntivi devono essere specificati in 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);

Nascondere i pulsanti non supportati

Se la tua app per Android TV supporta solo il controllo multimediale di base, ma l'app Web Receiver supporta un controllo più avanzato, devi assicurarti che l'app di invio funzioni correttamente durante la trasmissione all'app per Android TV. Ad esempio, se la tua app per Android TV non supporta la modifica della velocità di riproduzione, ma l'app Web Receiver sì, devi impostare correttamente le azioni supportate su ogni piattaforma e assicurarti che l'app di invio visualizzi correttamente l'interfaccia utente.

Modifica di MediaStatus

Per supportare funzionalità avanzate come canali, annunci, live streaming e coda, la tua app Android TV deve fornire informazioni aggiuntive che non possono essere accertate tramite MediaSession.

Per aiutarti a raggiungere questo obiettivo, forniamo la classe MediaStatusModifier. MediaStatusModifier opererà sempre su MediaSession che hai impostato in CastReceiverContext.

Per creare e trasmettere 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();

La nostra libreria client riceverà il valore base MediaStatus da MediaSession, mentre la tua app Android TV può specificare uno stato aggiuntivo e sostituire lo stato tramite un modificatore MediaStatus.

Alcuni stati e metadati possono essere impostati sia in MediaSession che MediaStatusModifier. Ti consigliamo vivamente di impostarle solo in MediaSession. Puoi comunque utilizzare il modificatore per sostituire gli stati in MediaSession. Questa operazione è sconsigliata perché lo stato nel modificatore ha sempre prioritariamente un valore superiore rispetto ai valori forniti da MediaSession.

Nota: devi chiamare broadcastMediaStatus() solo se hai modificato o aggiornato un MediaStatusModifier. Le modifiche a MediaSession vengono trasmesse automaticamente.

Intercettazione di MediaStatus prima dell'invio

Come per l'SDK Web Receiver, se vuoi apportare alcune modifiche prima di inviare, puoi specificare un MediaStatusInterceptor per elaborare il MediaStatus da inviare. Passiamo un MediaStatusWriter per manipolare il MediaStatus prima che venga inviato.

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\"}"));
    }
});

Gestione delle credenziali utente

La tua app per Android TV potrebbe consentire solo a determinati utenti di avviare o partecipare alla sessione dell'app. Ad esempio, consenti a un mittente di avviare o partecipare solo se:

• L'app mittente ha eseguito l'accesso allo stesso account e profilo dell'app ATV.
• L'app mittente ha eseguito l'accesso allo stesso account, ma con un profilo diverso rispetto all'app ATV.

Se la tua app può gestire più utenti o utenti anonimi, puoi consentire a qualsiasi altro utente di partecipare alla sessione ATV. Se l'utente fornisce le credenziali, la tua app per TV Android deve gestirle in modo che i suoi progressi e altri dati utente possano essere monitorati correttamente.

Quando l'app mittente viene lanciata o si connette all'app Android TV, deve fornire le credenziali che rappresentano chi partecipa alla sessione.

Prima che un mittente avvii e si unisca alla tua app per Android TV, puoi specificare un controllo di lancio per verificare se le credenziali del mittente sono consentite. In caso contrario, l'SDK Cast Connect esegue il fallback all'avvio del ricevitore web.

Dati delle credenziali di lancio dell'app mittente

Sul lato del mittente, puoi specificare CredentialsData per indicare chi partecipa alla sessione.

credentials è una stringa che può essere definita dall'utente, a condizione che l'app ATV possa comprenderla. credentialsType definisce la piattaforma da cui proviene CredentialsData o può essere un valore personalizzato. Per impostazione predefinita, è impostato sulla piattaforma da cui viene inviato.

Il token CredentialsData viene passato all'app per Android TV solo durante il lancio o il momento di iscrizione. Se lo imposti di nuovo mentre sei connesso, non verrà trasmesso all'app Android TV. Se il mittente cambia profilo mentre è connesso, puoi rimanere nella sessione o chiamare SessionManager.endCurrentCastSession(boolean stopCasting) se ritieni che il nuovo profilo non sia compatibile con la sessione.

Il valore CredentialsData per ogni mittente può essere recuperato utilizzando getSenders sul CastReceiverContext per ottenere SenderInfo, getCastLaunchRequest() per ottenere CastLaunchRequest, e poi getCredentialsData().

Android

Richiede play-services-cast-framework versione 19.0.0 o successive.

Kotlin

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

Java

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

iOS

Richiede google-cast-sdk versione v4.8.3 o superiore.

Può essere chiamato in qualsiasi momento dopo l'impostazione delle opzioni: GCKCastContext.setSharedInstanceWith(options).

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

Web

Richiede il browser Chromium versioneM87 o successive.

Può essere chiamato in qualsiasi momento dopo l'impostazione delle opzioni: cast.framework.CastContext.getInstance().setOptions(options);.

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

Implementazione del controllo delle richieste di lancio di ATV

Il valore CredentialsData viene passato all'app per Android TV quando un mittente tenta di avviare o partecipare. Puoi implementare un LaunchRequestChecker. per consentire o rifiutare questa richiesta.

Se una richiesta viene rifiutata, viene caricato il ricevitore web anziché avviare l'app ATV in modo nativo. Devi rifiutare una richiesta se la tua ATV non è in grado di gestire l'utente che richiede di avviare o partecipare. Ad esempio, un utente diverso da quello che effettua la richiesta ha eseguito l'accesso all'app ATV e la tua app non è in grado di gestire il passaggio delle credenziali oppure non è presente un utente attualmente connesso all'app ATV.

Se una richiesta è consentita, viene avviata l'app ATV. Puoi personalizzare questo comportamento a seconda che la tua app supporti l'invio di richieste di caricamento quando un utente non ha eseguito l'accesso all'app ATV o se si verifica una mancata corrispondenza dell'utente. Questo comportamento è completamente personalizzabile in LaunchRequestChecker.

Crea una classe che implementi l'interfaccia 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;
}

Quindi impostalo in 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 risoluzione di true in LaunchRequestChecker avvia l'app ATV e false avvia l'app Web Receiver.

Invio e ricezione di messaggi personalizzati

Il protocollo Cast ti consente di inviare messaggi di stringa personalizzati tra i mittenti e la tua applicazione di ricezione. Devi registrare uno spazio dei nomi (canale) per inviare messaggi prima di inizializzare CastReceiverContext.

Android TV: specifica lo spazio dei nomi personalizzato

Devi specificare gli spazi dei nomi supportati in CastReceiverOptions durante la configurazione:

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

Nota: gli spazi dei nomi devono iniziare con il prefisso urn:x-cast:.

Android TV: invio di messaggi

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: ricezione di messaggi con spazio dei nomi personalizzato

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