Aggiungere funzionalità di base al ricevitore Android TV

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questa pagina contiene snippet di codice e descrizioni delle funzionalità disponibili per la personalizzazione di un'app Android TV Receiver.

Configurazione delle librerie

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

Android
  1. Apri il file build.gradle all'interno della directory del modulo dell'applicazione.
  2. Verifica che google() sia incluso nell'elenco repositories elencato.
      repositories {
        google()
      }
  3. A seconda del tipo di dispositivo di destinazione per la tua app, aggiungi le ultime versioni delle librerie alle tue dipendenze:
    • Per l'app ricevitore Android:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast-tv:21.0.0'
          implementation 'com.google.android.gms:play-services-cast:21.3.0'
        }
    • Per l'app Mittente Android:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast:21.0.0'
          implementation 'com.google.android.gms:play-services-cast-framework:21.3.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.7.0 o versioni successive
  2. Scegli come target iOS 12 o versioni successive. Per ulteriori dettagli, consulta le Note di rilascio.
      platform: ios, '12'
    
      def target_pods
         pod 'google-cast-sdk', '~>4.7.0'
      end
Web
  1. Richiede la versione M87 o successiva del browser Chromium.
  2. Aggiungi la libreria dell'API Web Sender al tuo 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 l'aggiornamento di un'app per utilizzare lo spazio dei nomi androidx. Segui le istruzioni per la migrazione ad AndroidX.

App Android TV: prerequisiti

Per supportare Cast Connect nella tua app Android TV, devi creare e supportare 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 tua sessione multimediale viene usata anche dalla libreria di Cast Connect per segnalare quando ha ricevuto determinati messaggi da un mittente, ad esempio la pausa.

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

Ciclo di vita di una sessione multimediale

La tua app dovrebbe creare una sessione multimediale quando viene avviata la riproduzione e rilasciarla quando non può più essere controllata. Ad esempio, se l'app è un'app di video, devi rilasciare la sessione quando l'utente esce dall'attività di riproduzione: seleziona "Indietro" per sfogliare altri contenuti oppure esegui l'app in background. Se l'app è di musica, dovresti rilasciarla quando l'app non riproduce più contenuti multimediali.

Aggiornamento stato della sessione in corso...

I dati della sessione multimediale devono essere aggiornati con lo stato del player. Ad esempio, quando la riproduzione è in pausa, devi aggiornare lo stato della riproduzione e le azioni supportate. Nelle tabelle seguenti sono elencati gli stati in cui sei responsabile di mantenerti aggiornato.

Comprensione dei metadati

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

RiproduzioneStatoComparato

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

Competizione sessione multimediale

Metodo obbligatorio Descrizione
ImpostaRipetizioniModalità() Imposta la modalità di ripetizione.
setShuffleMode() Imposta la modalità di riproduzione casuale.
setMetadati() Imposta i metadati dei contenuti multimediali.
setRiproduzioneStato() 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);
}

Gestione dei controlli di trasporto

La tua app deve implementare il callback di controllo del trasporto per la sessione multimediale. La tabella seguente mostra le azioni di controllo del trasporto che devono gestire:

MediaSessionCompat.Callback

Azioni Descrizione
suPlay() Ripristina
onPausa() Metti in pausa
onSeekTo() Vai a una posizione
onStop() Interrompi i contenuti multimediali correnti
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());

Configurazione del supporto per la trasmissione

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

Configurazione di Android TV

Aggiungere un filtro per intenzione di lancio

Aggiungi un nuovo filtro per intent all'attività che vuoi gestire nell'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 di opzioni di ricezione

Devi implementare una proprietà 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();
  }
}

Specifica quindi 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 all'inizializzazione di CastReceiverContext.

Contesto di ricezione Cast

Inizializza CastReceiverContext quando viene creata la tua 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() su CastReceiverContext dopo che l'app è stata utilizzata in background per le app video o che non supportano la riproduzione in background:

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

Inoltre, se la riproduzione in background è supportata dalla tua app, chiama stop() su CastReceiverContext quando interrompi la riproduzione.

Ti consigliamo vivamente di utilizzare LifecycleObserver dalla libreria androidx.lifecycle per gestire le chiamate CastReceiverContext.start() e CastReceiverContext.stop(), soprattutto se la tua app nativa ha più attività. Questo evita le 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 attuale 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 MediaSession a causa di una riproduzione inattiva, devi impostare un token nullo su MediaManager:

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

Se l'app supporta la riproduzione di contenuti multimediali in background, anziché chiamare CastReceiverContext.stop() quando l'app viene inviata in background, dovresti chiamarla solo quando l'app è in background e non più in riproduzione. 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();
  }
}

Usare l'ExoPlayer con Cast Connect

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

MediaSessionConnector.MediaButtonEventHandler può essere utilizzato per gestire gli eventi MediaButton chiamando setMediaButtonEventHandler(MediaButtonEventHandler), che in caso contrario vengono gestiti per impostazione predefinita MediaSessionCompat.Callback.

Per integrare MediaSessionConnector nella tua app, aggiungi quanto segue alla classe dell'attività del player o a qualsiasi 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 del mittente

Attiva il supporto per Cast Connect

Una volta aggiornata l'app del mittente con il supporto di Cast Connect, puoi dichiararne l'idoneità impostando il flag androidReceiverCompatible su LaunchOptions su true.

Android

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

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 la versione google-cast-sdk v4.4.8 o successiva.

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 la versione del browser Chromium M87 o successiva.

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 Android TV in Console per gli sviluppatori di Google Cast per associarlo al tuo ID app di trasmissione.

Registra dispositivi sviluppatore

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

Senza registrazione, Cast Connect funzionerà soltanto per app installate dal Google Play Store per motivi di sicurezza.

Per ulteriori informazioni sulla registrazione di un dispositivo di trasmissione o Android TV allo sviluppo di Google Cast, visita la pagina di registrazione.

Caricamento dell'elemento multimediale in corso...

Se hai già implementato il supporto dei link diretti nella tua app Android TV, dovresti avere una definizione simile configurata nel tuo file manifest 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 passare il link diretto impostando entity nelle informazioni 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 la versione del browser Chromium M87 o successiva.

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 definito nella console per gli sviluppatori.

Impostazione delle credenziali ATV sul mittente

È possibile che la tua app Ricevitore web e la tua app Android TV supportino link diretti e credentials diversi (ad esempio, se gestisci l'autenticazione in modo diverso sulle due piattaforme). Per risolvere questo 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 la versione del browser Chromium M87 o successiva.

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 viene avviata, usa entity e credentials nella richiesta di caricamento. Tuttavia, se l'app Android TV viene lanciata, 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 utilizzi Content ID o URL dei contenuti nelle tue informazioni multimediali o se utilizzi dati più dettagliati per la richiesta di caricamento media, devi aggiungere il seguente filtro per intent predefinito nella tua 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>

Come per il caricamento per entità, puoi creare una richiesta di caricamento con le informazioni sui contenuti e chiamare il numero 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 la versione del browser Chromium M87 o successiva.

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 carico, devi gestire gli intent nel 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'intent è di carico, estrae un oggetto MediaLoadRequestData dall'intent e richiama MediaLoadCommandCallback.onLoad(). Per gestire la richiesta di carico, devi sostituire questo metodo. Il callback deve essere registrato prima che MediaManager.onNewIntent() venga richiamato (è consigliabile utilizzare un metodo Attività o Applicazione onCreate()).

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 da noi definite (MediaLoadRequestData per le richieste di caricamento).

Supporto dei comandi multimediali

Supporto di base del controllo della riproduzione

I comandi di integrazione di base includono quelli compatibili con la sessione multimediale. Questi comandi vengono avvisati tramite callback di sessioni multimediali. Per supportare questa operazione devi registrare un callback alla sessione multimediale (probabilmente lo stai già facendo).

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

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 {
        // 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 per il ricevitore Cast, 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 nella 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);

Nascondi pulsanti non supportati

Se la tua app Android TV supporta solo il controllo dei contenuti multimediali di base, ma l'app Ricevitore web supporta un controllo più avanzato, assicurati che l'app del mittente si comporti correttamente durante la trasmissione all'app Android TV. Ad esempio, se l'app Android TV non supporta la modifica della velocità di riproduzione rispetto all'app Ricevitore web, dovresti impostare correttamente le azioni supportate su ogni piattaforma e assicurarti che l'app del mittente mostri correttamente la UI.

Modificare lo stato dei contenuti multimediali

Per supportare funzionalità avanzate come tracce, annunci, dal vivo e in coda, la tua app Android TV deve fornire informazioni aggiuntive che non possono essere identificate tramite MediaSession.

Ti offriamo il corso MediaStatusModifier per raggiungere questo obiettivo. MediaStatusModifier funzionerà sempre sul 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à la base MediaStatus da MediaSession. L'app Android TV può specificare uno stato aggiuntivo e sostituirlo tramite un modificatore MediaStatus.

Alcuni stati e metadati possono essere impostati sia in MediaSession sia in MediaStatusModifier. Ti consigliamo vivamente di impostarle solo in MediaSession. Puoi comunque utilizzare il modificatore per eseguire l'override degli stati in MediaSession, sconsigliamo di farlo perché lo stato nel modificatore ha sempre una priorità maggiore rispetto ai valori forniti da MediaSession.

Intercettazione dello stato dei contenuti multimediali prima dell'invio

Come l'SDK Web Receiver, se vuoi apportare degli ultimi ritocchi prima di inviare il messaggio, puoi specificare un elemento MediaStatusInterceptor per elaborare 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

L'app Android TV potrebbe consentire solo ad alcuni utenti di avviare o partecipare alla sessione. Ad esempio, consenti l'avvio o la partecipazione a un mittente 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 ha un profilo diverso rispetto all'app ATV.

Se la tua app può gestire più utenti anonimi o multipli, puoi consentire a qualsiasi utente aggiuntivo di partecipare alla sessione ATV. Se l'utente fornisce le credenziali, l'app ATV deve gestirle per far sì che i relativi progressi e altri dati utente possano essere monitorati correttamente.

Quando l'app del mittente si avvia o partecipa alla tua app Android TV, l'app deve fornire le credenziali che rappresentano chi partecipa alla sessione.

Prima che un mittente si avvii e entri a far parte dell'app Android TV, puoi specificare un controllo di avvio per verificare se le credenziali del mittente sono consentite. In caso contrario, l'SDK Cast Connect torna al lancio del ricevitore web.

Dati delle credenziali di avvio dell'app del mittente

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

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

Il canale CredentialsData viene trasmesso alla tua app Android TV soltanto al momento del lancio o all'ora di partecipazione. Se lo imposti di nuovo durante la connessione, non verrà trasmesso all'app Android TV. Se il mittente cambia profilo mentre è connesso, potresti rimanere nella sessione o chiamare SessionManager.endCurrentCastSession(boolean stopCasting) se ritieni che il nuovo profilo non sia compatibile con la sessione.

È possibile recuperare il CredentialsData per ciascun mittente utilizzando getSenders su CastReceiverContext per ottenere SenderInfo, getCastLaunchRequest() per ottenere CastLaunchRequest, e poi getCredentialsData().

Android

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

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

Richiede la versione google-cast-sdk v4.7.0 o successiva.

Puoi chiamarlo in qualsiasi momento dopo aver impostato le opzioni: GCKCastContext.setSharedInstanceWith(options).

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

Richiede la versione del browser Chromium M87 o successiva.

Puoi chiamarlo in qualsiasi momento dopo aver impostato le opzioni: cast.framework.CastContext.getInstance().setOptions(options);.

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

Implementare il controllo delle richieste di lancio di ATV

CredentialsData viene passato alla tua app Android TV quando un mittente tenta di avviarlo o di collegarsi. Puoi implementare un LaunchRequestChecker. per consentire o rifiutare la richiesta.

Se una richiesta viene rifiutata, il ricevitore web viene caricato anziché avviarsi in modo nativo nell'app ATV. Devi rifiutare una richiesta se l'ATV non è in grado di gestire l'utente che richiede il lancio o la partecipazione. Ad esempio, un utente diverso ha effettuato l'accesso all'app ATV rispetto a quanto richiesto e l'app non è in grado di gestire le credenziali di cambio o non è presente alcun utente che abbia effettuato l'accesso all'app ATV.

Se una richiesta viene consentita, viene avviata l'app ATV. Puoi personalizzare questo comportamento a seconda che la tua app supporti l'invio di richieste di carico quando un utente non ha eseguito l'accesso all'app ATV o se l'utente non corrisponde. Questo comportamento è completamente cusamizable nel LaunchRequestChecker.

Crea un corso implementando 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;
}

Poi 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 la tua app Web Receiver.

Inviare e ricevere messaggi personalizzati

Il protocollo di trasmissione consente di inviare messaggi di stringa personalizzati tra i mittenti e l'applicazione del destinatario. Devi registrare uno spazio dei nomi (canale) per inviare i messaggi prima di inizializzare CastReceiverContext.

Android TV: specifica uno spazio dei nomi personalizzato

Durante la configurazione, devi specificare gli spazi dei nomi supportati nella pagina CastReceiverOptions:

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

Android TV: 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: ricevi messaggi dello 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());