Aggiungi funzionalità principali al ricevitore Android TV

Questa pagina contiene snippet di codice e descrizioni delle funzioni disponibili per personalizzare un'app Android TV Ricevitore.

Configurazione delle librerie

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

Android
  1. Apri il file build.gradle nella directory del modulo dell'applicazione.
  2. Verifica che google() sia incluso nei repositories elencati.
      repositories {
        google()
      }
  3. Aggiungi le versioni più recenti a seconda del tipo di dispositivo target della tua app delle librerie alle tue dipendenze:
    • Per l'app Android Ricevitore:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast-tv:21.1.0'
          implementation 'com.google.android.gms:play-services-cast:21.5.0'
        }
    • Per l'app Android Sender:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast:21.1.0'
          implementation 'com.google.android.gms:play-services-cast-framework:21.5.0'
        }
    di Gemini Advanced. Assicurati di aggiornare questo numero di versione ogni volta che vengono aggiornati i servizi.
  4. Salva le modifiche e fai clic su Sync Project with Gradle Files nella barra degli strumenti.
di Gemini Advanced.
.
.
iOS
  1. Assicurati che Podfile abbia come target google-cast-sdk 4.8.3 o successiva
  2. Scegli come target iOS 14 o versioni successive. Vedi le note di rilascio per ulteriori dettagli.
      platform: ios, '14'
    
      def target_pods
         pod 'google-cast-sdk', '~>4.8.3'
      end
di Gemini Advanced.
.
.
Web
  1. Richiede il browser Chromium M87 o versioni successive.
  2. Aggiungi 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

Per poter utilizzare le nuove versioni di Google Play Services è necessario aggiornare un'app lo spazio dei nomi androidx. Segui le istruzioni per eseguire la migrazione ad AndroidX.

App per Android TV: prerequisiti

Per supportare Cast Connect nella tua app Android TV, devi creare e eventi di supporto di una sessione multimediale. I dati forniti dalla tua sessione multimediale fornisce 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 raccolta Cast Connect per segnalare quando ha ricevuto determinati messaggi da un mittente, ad esempio "metti in pausa".

Per ulteriori informazioni su una sessione multimediale e su come inizializzarla, vedi il lavorare con una guida per le sessioni multimediali.

Ciclo di vita della sessione multimediale

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

Aggiornamento stato sessione

I dati della sessione multimediale devono essere sempre aggiornati con lo stato del tuo un player. Ad esempio, quando la riproduzione è in pausa, devi aggiornare la riproduzione così come le azioni supportate. Le tabelle seguenti elencano gli stati che è tua responsabilità tenerti al corrente.

MediaMetadataCompat

Campo metadati Descrizione
METADATA_KEY_TITLE (obbligatorio) Il titolo dell'elemento 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 Content ID.
METADATA_KEY_ARTIST L'artista.
METADATA_KEY_ALBUM L'album.

PlaybackStateCompat

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

MediaSessionCompat

Metodo richiesto Descrizione
setRepeatMode() Imposta la modalità di ripetizione.
setShuffleMode() Consente di impostare la modalità casuale.
setMetadata() Imposta i metadati multimediali.
setPlaybackState() Imposta lo stato di riproduzione.
Kotlin
di Gemini Advanced.
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);
}

Gestione del controllo del trasporto

L'app deve implementare il callback di controllo del trasporto delle sessioni multimediali. La la seguente tabella mostra quali azioni di controllo del trasporto devono gestire:

MediaSessionCompat.Callback

Azioni Descrizione
onPlay() Riprendi
onPause() Metti in pausa
onSeekTo() Vai a una posizione
onStop() Interrompere i contenuti multimediali correnti
Kotlin
di Gemini Advanced.
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());

Configurazione del supporto di Cast

Quando una richiesta di avvio viene inviata da un'applicazione mittente, viene creato un intent. con uno spazio dei nomi dell'applicazione. La tua applicazione è responsabile della sua gestione e la creazione di un'istanza CastReceiverContext all'avvio dell'app TV. L'oggetto CastReceiverContext è necessario per interagire con Google Cast mentre è in esecuzione l'app TV. Questo oggetto abilita la TV per accettare messaggi multimediali di trasmissione provenienti da mittenti connessi.

Configurazione di Android TV

Aggiunta di un filtro per intent di avvio

Aggiungi un nuovo filtro per intent all'attività che vuoi gestire il lancio intent dall'app del 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 provider opzioni ricevitore

Devi implementare un ReceiverOptionsProvider per fornire CastReceiverOptions:

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

Quindi, specifica il fornitore di opzioni nel tuo 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 CastReceiverContext è stato inizializzato.

Contesto ricevitore di trasmissione

Inizializza CastReceiverContext quando viene creata l'app:

Kotlin
di Gemini Advanced.
override fun onCreate() {
  CastReceiverContext.initInstance(this)

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

  ...
}

Avvia CastReceiverContext quando la tua app passa in primo piano:

Kotlin
di Gemini Advanced.
CastReceiverContext.getInstance().start()
Java
CastReceiverContext.getInstance().start();

Chiama stop() il CastReceiverContext Dopo che l'app è passata in background per le app video o le app che non supportano Riproduzione in background:

Kotlin
di Gemini Advanced.
// 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 interrompe la riproduzione in background.

Ti consigliamo vivamente di utilizzare LifecycleObserver dal androidx.lifecycle libreria per gestire le chiamate CastReceiverContext.start() e CastReceiverContext.stop(), soprattutto se la tua app nativa ha più attività. Questo evita il gruppo etnico condizioni quando chiami start() e stop() da attività diverse.

Kotlin
di Gemini Advanced.
// 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">

Connessione di MediaSession a MediaManager

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

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

Quando rilasci MediaSession per riproduzione inattiva, devi impostare un token nullo MediaManager:

Kotlin
di Gemini Advanced.
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 mentre è in background, delle chiamate CastReceiverContext.stop() quando la tua app viene inviata in background, dovresti chiamarla soltanto quando la tua app è in background e non riproduce più contenuti multimediali. Ad esempio:

Kotlin
di Gemini Advanced.
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 mantenere automaticamente la sessione e tutte le informazioni correlate, tra cui lo stato di riproduzione anziché monitorare le modifiche manualmente.

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

Per l'integrazione MediaSessionConnector nella tua app, aggiungi quanto segue alla tua classe attività giocatore o dovunque gestire la sessione multimediale:

Kotlin
di Gemini Advanced.
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

Attiva il supporto di Cast Connect

Dopo aver aggiornato l'app del mittente con il supporto di Cast Connect, puoi dichiarare per l'idoneità impostando il parametro androidReceiverCompatible segnala su LaunchOptions su true.

Android

Richiede la versione play-services-cast-framework 19.0.0 o superiore.

Il flag androidReceiverCompatible è impostato in LaunchOptions (che fa parte di CastOptions):

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

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

È necessaria la versione del browser Chromium M87 o superiore.

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

Configurazione di Cast Console per gli sviluppatori

Configurare l'app Android TV

Aggiungi il nome del pacchetto della tua app Android TV in Console per gli sviluppatori di Google Cast per associarlo all'ID dell'app Google Cast.

Registra dispositivi per sviluppatori

Registra il numero di serie del dispositivo Android TV che intendi utilizzare. per lo sviluppo Console per gli sviluppatori di Google Cast.

Senza registrazione, Cast Connect funziona solo per le app installate da Google Play Store per motivi di sicurezza.

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

Caricamento dei contenuti multimediali in corso...

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

Carica per entità sul mittente

Sui mittenti, puoi trasmettere il link diretto impostando il entity nei contenuti multimediali informazioni per la richiesta di caricamento:

Kotlin
di Gemini Advanced.
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
di Gemini Advanced.
.
Java
di Gemini Advanced.
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
di Gemini Advanced.
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

È necessaria la versione del browser Chromium M87 o superiore.

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 tuo link diretto e il nome del pacchetto che hai definito nella Developer Console.

Impostazione delle credenziali ATV sul mittente

È possibile che l'app WebRicevitore e l'app Android TV supportino diverse Link diretti e credentials (ad esempio se gestisci l'autenticazione in modo diverso sulle due piattaforme). Per risolvere questo problema, puoi fornire alternative entity e credentials per Android TV:

Android
di Gemini Advanced.
.
Kotlin
di Gemini Advanced.
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
di Gemini Advanced.
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
di Gemini Advanced.
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

È necessaria la versione del browser Chromium M87 o superiore.

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 Ricevitore viene avviata, utilizza entity e credentials in la richiesta di caricamento. Tuttavia, se la tua app per Android TV viene avviata, l'SDK sostituisce entity e credentials con atvEntity e atvCredentials (se specificato).

Caricamento tramite Content ID o MediaQueueData

Se non utilizzi entity o atvEntity e usi Content ID o URL dei contenuti nelle informazioni sui contenuti multimediali oppure utilizza il campo Caricamento multimediale più dettagliato Richiedi dati, devi aggiungere il seguente filtro per intent predefinito in l'app 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>

Dal lato mittente, come per Carica per entità, può creare una richiesta di caricamento con le informazioni sui tuoi contenuti e chiamare load().

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

È necessaria la versione del browser Chromium M87 o superiore.

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 carico

Nella tua attività, per gestire queste richieste di caricamento, devi gestire gli intent nei callback del ciclo di vita delle attività:

Kotlin
di Gemini Advanced.
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'intent è un intent di caricamento, estrae un MediaLoadRequestData l'oggetto dall'intent e richiamare MediaLoadCommandCallback.onLoad() Devi eseguire l'override di questo metodo per gestire la richiesta di caricamento. Il callback deve la registrazione prima del giorno MediaManager.onNewIntent() (è consigliabile utilizzare un'attività o un'applicazione onCreate() ).

Kotlin
di Gemini Advanced.
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 analizzare l'intent nelle strutture di dati abbiamo definito (MediaLoadRequestData) per le richieste di caricamento).

Supporto dei comandi multimediali

Supporto del controllo di riproduzione di base

I comandi di integrazione di base includono i comandi compatibili con i contenuti multimediali durante la sessione. Questi comandi vengono informati tramite callback delle sessioni multimediali. Devi registrare un callback a una sessione multimediale a supporto (l'operazione potrebbe essere già esistente).

Kotlin
di Gemini Advanced.
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 della trasmissione

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

Kotlin
di Gemini Advanced.
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());

Specifica i comandi multimediali supportati

Come nel caso del ricevitore di trasmissione, l'app Android TV deve specificare i comandi sono supportati, pertanto i mittenti possono attivare o disattivare determinati controlli dell'interfaccia utente. Per che fanno parte MediaSession, e specificare i comandi PlaybackStateCompat. È necessario specificare altri comandi nel MediaStatusModifier

Kotlin
di Gemini Advanced.
// 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);

Nascondi pulsanti non supportati

Se l'app Android TV supporta soltanto il controllo multimediale di base, ma il ricevitore web supporta un controllo più avanzato, devi assicurarti che l'app del mittente si comporti correttamente durante la trasmissione all'app Android TV. Ad esempio, se il tuo dispositivo Android TV non supporta la modifica della velocità di riproduzione a differenza dell'app WebRicevitore, devi impostare correttamente le azioni supportate su ogni piattaforma e assicurarti l'app del mittente esegue correttamente il rendering dell'UI.

Modifica di MediaStatus

Per supportare funzionalità avanzate come tracce, annunci, live streaming e coda, il tuo Android L'app TV deve fornire informazioni aggiuntive che non possono essere stabilite tramite MediaSession

Forniamo i MediaStatusModifier per raggiungere questo obiettivo. MediaStatusModifier funzionerà sempre su MediaSession che hai impostato in CastReceiverContext

Per creare e trasmettere MediaStatus:

Kotlin
di Gemini Advanced.
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à MediaStatus di base da MediaSession, il tuo L'app per Android TV può specificare uno stato aggiuntivo ed eseguire l'override tramite un Modificatore MediaStatus.

Alcuni stati e metadati possono essere impostati sia in MediaSession che in MediaStatusModifier. Ti consigliamo vivamente di impostarli solo in MediaSession. Puoi comunque utilizzare il modificatore per sostituire gli stati MediaSession: questa azione è sconsigliata perché lo stato nel modificatore è sempre hanno una priorità più alta rispetto ai valori forniti da MediaSession.

Intercettazione di MediaStatus prima dell'invio

Come l'SDK WebRicevir, se vuoi fare gli ultimi ritocchi prima puoi specificare MediaStatusInterceptor per elaborare MediaStatus a inviate. Passiamo in MediaStatusWriter per manipolare MediaStatus prima che venga inviato.

Kotlin
di Gemini Advanced.
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 all'app durante la sessione. Ad esempio, consenti a un mittente di avviare o partecipare solo se:

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

Se la tua app può gestire più utenti o utenti anonimi, puoi consentire qualsiasi a partecipare alla sessione ATV. Se l'utente fornisce le credenziali, l'app ATV deve gestire le sue credenziali in modo che i suoi progressi e altri dati utente possano essere adeguatamente tracciate.

Quando l'app del mittente avvia o partecipa alla tua app per Android TV, l'app del mittente Deve fornire le credenziali che rappresentano gli utenti che partecipano alla sessione.

Prima che un mittente avvii e partecipi alla tua app per Android TV, puoi specificare un avvia il controllo per vedere se le credenziali del mittente sono consentite. In caso contrario, l'app Google Cast Connect SDK esegue l'avvio del ricevitore web.

Dati delle credenziali di lancio dell'app mittente

Per quanto riguarda il mittente, puoi specificare il CredentialsData per rappresentare chi partecipare alla sessione.

credentials è una stringa che può essere definita dall'utente, purché il tuo ATV che l'app riesca a comprenderlo. credentialsType definisce su quale piattaforma CredentialsData proviene da o può essere un valore personalizzato. Per impostazione predefinita, alla piattaforma da cui vengono inviati.

Il CredentialsData viene trasmesso alla tua app Android TV soltanto durante l'avvio o è ora di partecipare. Se lo imposti di nuovo mentre la connessione è attiva, non verrà trasmesso a l'app per Android TV. Se il mittente cambia profilo mentre è connesso, rimanere nella sessione o chiamare SessionManager.endCurrentCastSession(boolean stopCasting) se ritieni che il nuovo profilo non sia compatibile con la sessione.

La CredentialsData per ciascun mittente possono essere recuperati utilizzando getSenders il CastReceiverContext per ottenere SenderInfo, getCastLaunchRequest() per ottenere CastLaunchRequest, e poi getCredentialsData().

Android

Richiede la versione play-services-cast-framework 19.0.0 o superiore.

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

Richiede google-cast-sdk versione v4.8.3 o in alto.

Dopo aver impostato le opzioni, puoi chiamarla in qualsiasi momento: GCKCastContext.setSharedInstanceWith(options).

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

È necessaria la versione del browser Chromium M87 o superiore.

Dopo aver impostato le opzioni, puoi chiamarla in qualsiasi momento: cast.framework.CastContext.getInstance().setOptions(options);.

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

Implementazione dello strumento di controllo richiesta di lancio ATV

La CredentialsData viene trasmesso alla tua app 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, il ricevitore web viene caricato invece di avviare in modo nativo nell'app ATV. Dovresti rifiutare una richiesta se il tuo ATV non riesce a gestire l'utente che richiede di avviare o partecipare. Un esempio potrebbe essere che un altro l'utente ha eseguito l'accesso all'app ATV rispetto a quanto richiesto e la tua app non è in grado di gestire le credenziali di passaggio oppure al momento non esiste un utente che abbia eseguito l'accesso App ATV.

Se la richiesta è consentita, viene avviata l'app ATV. Puoi personalizzare a seconda che la tua app supporti l'invio di richieste di carico quando un utente non abbia effettuato l'accesso all'app ATV o in caso di mancata corrispondenza degli utenti. Questo comportamento è completamente cusolabile in LaunchRequestChecker.

Crea un corso che implementa CastReceiverOptions.LaunchRequestChecker dell'interfaccia:

Kotlin
di Gemini Advanced.
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;
}

Poi impostalo nel tuo ReceiverOptionsProvider:

Kotlin
di Gemini Advanced.
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();
  }
}

Risoluzione di true in LaunchRequestChecker avvia l'app ATV e false avvia l'app Web Ricevitore.

Invio & Ricezione di messaggi personalizzati

Il protocollo Cast consente di inviare messaggi di tipo stringa personalizzata tra mittenti e l'applicazione ricevitore. Devi registrare uno spazio dei nomi (canale) da inviare dei messaggi prima di inizializzare CastReceiverContext

Android TV: specifica lo spazio dei nomi personalizzato

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

Kotlin
di Gemini Advanced.
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
di Gemini Advanced.
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: invio di messaggi

Kotlin
di Gemini Advanced.
// 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 personalizzati dello spazio dei nomi

Kotlin
di Gemini Advanced.
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());