Questa pagina contiene snippet di codice e descrizioni delle funzionalità disponibili per la personalizzazione di un'app Android TV ricevitore.
Configurazione delle librerie
Per rendere disponibili le API Cast Connect nella tua app Android TV:
-
Apri il file
build.gradle
nella directory del modulo dell'applicazione. -
Verifica che
google()
sia incluso nell'elencorepositories
.repositories { google() }
-
A seconda del tipo di dispositivo di destinazione per la tua app, aggiungi le versioni più recenti
delle librerie alle dipendenze:
-
Per l'app Android Ricevir:
dependencies { implementation 'com.google.android.gms:play-services-cast-tv:21.0.1' implementation 'com.google.android.gms:play-services-cast:21.4.0' }
-
Per l'app Android Sender:
dependencies { implementation 'com.google.android.gms:play-services-cast:21.0.1' implementation 'com.google.android.gms:play-services-cast-framework:21.4.0' }
-
Per l'app Android Ricevir:
-
Salva le modifiche e fai clic su
Sync Project with Gradle Files
nella barra degli strumenti.
-
Assicurati che
Podfile
abbia come targetgoogle-cast-sdk
4.8.1 o versioni successive -
Scegli come target iOS 14 o versioni successive. Consulta le note di rilascio per maggiori dettagli.
platform: ios, '14' def target_pods pod 'google-cast-sdk', '~>4.8.1' end
- Richiede il browser Chromium versione M87 o successive.
-
Aggiungi la libreria 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 che un'app sia stata aggiornata in modo da utilizzare
lo spazio dei nomi androidx
. Segui le istruzioni per la migrazione ad AndroidX.
App Android TV: prerequisiti
Per poter supportare Cast Connect nella tua app Android TV, devi creare e supportare eventi di una sessione multimediale. I dati forniti dalla sessione multimediale forniscono le informazioni di base, ad esempio posizione, stato di riproduzione e così via, relative allo stato dei contenuti multimediali. La sessione multimediale viene utilizzata anche dalla raccolta di Cast Connect per segnalare la ricezione di determinati messaggi da un mittente, ad esempio una pausa.
Per ulteriori informazioni sulla sessione multimediale e su come inizializzarla, consulta la guida sull'utilizzo di una sessione multimediale.
Ciclo di vita di una sessione multimediale
L'app dovrebbe creare una sessione multimediale all'avvio della riproduzione e rilasciarla quando non è più possibile controllarla. Ad esempio, se la tua app è un'app video, devi rilasciare la sessione quando l'utente esce dall'attività di riproduzione, selezionando "Indietro" per sfogliare altri contenuti o eseguendo l'esecuzione in background dell'app. Se la tua app è un'app di musica, dovresti rilasciarla quando l'app non sta più riproducendo contenuti multimediali.
Aggiornamento dello stato della sessione
I dati della sessione multimediale devono essere sempre aggiornati con lo stato del player. Ad esempio, quando la riproduzione è in pausa, devi aggiornare lo stato di riproduzione e le azioni supportate. Nelle seguenti tabelle sono elencati gli stati che devi mantenere aggiornati.
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() | Imposta la modalità di riproduzione casuale. |
setMetadata() | Imposta i metadati dei contenuti multimediali. |
setPlaybackState() | Imposta lo stato di riproduzione. |
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) }
private void updateMediaSession() { MediaMetadataCompat metadata = new MediaMetadataCompat.Builder() .putString(MediaMetadataCompat.METADATA_KEY_TITLE, "title") .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, "subtitle") .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI,mMovie.getCardImageUrl()) .build(); PlaybackStateCompat playbackState = new PlaybackStateCompat.Builder() .setState( PlaybackStateCompat.STATE_PLAYING, player.getPosition(), player.getPlaybackSpeed(), System.currentTimeMillis()) .build(); mediaSession.setMetadata(metadata); mediaSession.setPlaybackState(playbackState); }
Gestire il controllo dei trasporti
L'app deve implementare il callback di controllo del trasporto della sessione multimediale. La tabella seguente mostra quali azioni di controllo del trasporto devono gestire:
MediaSessionCompat.Callback
Azioni | Descrizione |
---|---|
onPlay() | Ripristina |
onPause() | Metti in pausa |
OnSeekTo() | Vai a una posizione |
onStop() | Interrompi i contenuti multimediali correnti |
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() );
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 Google Cast
Quando un'applicazione del mittente invia una richiesta di avvio, viene creato un intent con uno spazio dei nomi dell'applicazione. È responsabilità dell'applicazione gestirla
e creare un'istanza dell'oggetto
CastReceiverContext
quando viene avviata l'app TV. L'oggetto CastReceiverContext
è necessario
per interagire con Cast mentre l'app TV è in esecuzione. Questo oggetto consente all'applicazione TV di accettare messaggi multimediali trasmessi da qualsiasi mittente connesso.
Configurazione di Android TV
Aggiunta di un filtro per intent di lancio
Aggiungi un nuovo filtro per intent all'attività che vuoi gestire l'intent di lancio dall'app mittente:
<activity android:name="com.example.activity">
<intent-filter>
<action android:name="com.google.android.gms.cast.tv.action.LAUNCH" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
Specifica il provider delle opzioni del destinatario
Devi implementare un
ReceiverOptionsProvider
per fornire
CastReceiverOptions
:
class MyReceiverOptionsProvider : ReceiverOptionsProvider { override fun getOptions(context: Context?): CastReceiverOptions { return CastReceiverOptions.Builder(context) .setStatusText("My App") .build() } }
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 il valore CastReceiverOptions
quando
CastReceiverContext
viene inizializzato.
Contesto del ricevitore di trasmissione
Inizializza CastReceiverContext
quando viene creata l'app:
override fun onCreate() { CastReceiverContext.initInstance(this) ... }
@Override public void onCreate() { CastReceiverContext.initInstance(this); ... }
Avvia CastReceiverContext
quando l'app passa in primo piano:
CastReceiverContext.getInstance().start()
CastReceiverContext.getInstance().start();
Chiama
stop()
sul
CastReceiverContext
dopo che l'app è passata in background per le app video o per le app che non supportano
la riproduzione in background:
// Player has stopped. CastReceiverContext.getInstance().stop()
// Player has stopped. CastReceiverContext.getInstance().stop();
Inoltre, se la tua app non supporta la riproduzione in background, chiama stop()
sul CastReceiverContext
quando la riproduzione si interrompe in background.
Ti consigliamo vivamente di utilizzare LifecycleObservationr dalla libreria di
androidx.lifecycle
per gestire le chiamate
CastReceiverContext.start()
e
CastReceiverContext.stop()
,
soprattutto se la tua app nativa ha più attività. In questo modo si evitano racecondition quando chiami start()
e stop()
da attività diverse.
// 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()) } }
// 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 elemento
MediaSession
,
devi anche fornire l'attuale token MediaSession
a
CastReceiverContext
in modo che sappia dove inviare i comandi e recuperare lo stato di riproduzione dei contenuti multimediali:
val mediaManager: MediaManager = receiverContext.getMediaManager() mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken())
MediaManager mediaManager = receiverContext.getMediaManager(); mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());
Quando rilasci il tuo MediaSession
a causa di una riproduzione inattiva, devi impostare un token null su MediaManager
:
myPlayer.stop() mediaSession.release() mediaManager.setSessionCompatToken(null)
myPlayer.stop(); mediaSession.release(); mediaManager.setSessionCompatToken(null);
Se la tua app supporta la riproduzione di contenuti multimediali mentre l'app è in background, anziché chiamare CastReceiverContext.stop()
quando l'app viene inviata in background, devi chiamare solo quando l'app è in background e non sta più riproducendo contenuti multimediali. Ad esempio:
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() } }
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 usi Exoplayer
, puoi utilizzare MediaSessionConnector
per gestire automaticamente la sessione e tutte le informazioni correlate, incluso lo stato di riproduzione, anziché monitorare le modifiche manualmente.
MediaSessionConnector.MediaButtonEventHandler
può essere utilizzato per gestire gli eventi MediaButton chiamando
setMediaButtonEventHandler(MediaButtonEventHandler)
che sono altrimenti gestiti da
MediaSessionCompat.Callback
per impostazione predefinita.
Per integrare MediaSessionConnector
nella tua app, aggiungi quanto segue alla classe di attività del player o alla posizione in cui gestisci la tua sessione multimediale:
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) ... } }
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 app mittente
Attiva il supporto di Cast Connect
Dopo aver aggiornato l'app mittente con il supporto di Cast Connect, puoi dichiararne l'idoneità impostando il flag androidReceiverCompatible
su LaunchOptions
su true.
Richiede play-services-cast-framework
versione
19.0.0
o successiva.
Il flag androidReceiverCompatible
è impostato in
LaunchOptions
(che fa parte di CastOptions
):
class CastOptionsProvider : OptionsProvider { override fun getCastOptions(context: Context?): CastOptions { val launchOptions: LaunchOptions = Builder() .setAndroidReceiverCompatible(true) .build() return CastOptions.Builder() .setLaunchOptions(launchOptions) ... .build() } }
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(); } }
Richiede google-cast-sdk
versione 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)
Richiede il browser Chromium versione 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 nella Console per gli sviluppatori di Google Cast per associarla al tuo ID app Google Cast.
Registrare i dispositivi degli sviluppatori
Registra il numero di serie del dispositivo Android TV che utilizzerai per lo sviluppo nella Console per gli sviluppatori di Cast.
Senza registrazione, Cast Connect funziona solo per le app installate dal Google Play Store per motivi di sicurezza.
Per ulteriori informazioni sulla registrazione di un dispositivo di trasmissione o Android TV per lo sviluppo di Google Cast, visita la pagina di registrazione.
Caricamento dei contenuti multimediali in corso...
Se hai già implementato il supporto dei link diretti nell'app Android TV, dovresti avere una definizione simile configurata nel 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>
Caricamento per entità sul mittente
Sui mittenti, puoi passare il link diretto impostando entity
nelle informazioni multimediali per la richiesta di caricamento:
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)
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);
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)
Richiede il browser Chromium versione 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 l'app Web ricevitore e l'app Android TV supportino i link diretti e credentials
diversi (ad esempio se gestisci l'autenticazione in modo diverso sulle due piattaforme). Per risolvere questo problema, puoi fornire dati alternativi
entity
e credentials
per Android TV:
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)
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);
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)
Richiede il browser Chromium versione 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 ricevitore viene avviata, utilizza entity
e credentials
nella richiesta di caricamento. Tuttavia, se la tua app Android TV viene lanciata, l'SDK esegue l'override di entity
e credentials
con i tuoi atvEntity
e atvCredentials
(se specificati).
Caricamento tramite Content ID o MediaQueueData
Se non usi entity
o atvEntity
, Content ID o
URL dei contenuti nelle Informazioni sui contenuti multimediali o i dati più dettagliati della richiesta di caricamento
dei contenuti multimediali, devi aggiungere il seguente filtro per intent predefinito nell'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>
Sul lato mittente, come in Carica per entità, puoi creare una richiesta di caricamento con le informazioni sui tuoi contenuti e chiamare load()
.
val mediaToLoad = MediaInfo.Builder("some-id").build() val loadRequest = MediaLoadRequestData.Builder() .setMediaInfo(mediaToLoad) .setCredentials("user-credentials") ... .build() remoteMediaClient.load(loadRequest)
MediaInfo mediaToLoad = new MediaInfo.Builder("some-id").build(); MediaLoadRequestData loadRequest = new MediaLoadRequestData.Builder() .setMediaInfo(mediaToLoad) .setCredentials("user-credentials") ... .build(); remoteMediaClient.load(loadRequest);
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)
Richiede il browser Chromium versione 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 nei callback del ciclo di vita delle attività:
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. ... } }
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 oggetto MediaLoadRequestData
dall'intent e richiama MediaLoadCommandCallback.onLoad()
.
Devi eseguire l'override di questo metodo per gestire la richiesta di carico. Il callback deve essere registrato prima della chiamata di MediaManager.onNewIntent()
(è consigliabile utilizzare un metodo Attività o Applicazione onCreate()
).
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) }
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 TaskonLoad(String senderId, MediaLoadRequestData loadRequestData) { return Tasks.call(() -> { // Resolve the entity into your data structure and load media. MediaInfo mediaInfo = loadRequestData.getMediaInfo(); if (!checkMediaInfoSupported(mediaInfo)) { // Throw MediaException to indicate load failure. throw new MediaException( new MediaError.Builder() .setDetailedErrorCode(DetailedErrorCode.LOAD_FAILED) .setReason(MediaError.ERROR_REASON_INVALID_REQUEST) .build()); } myFillMediaInfo(new MediaInfoWriter(mediaInfo)); myPlayerLoad(mediaInfo.getContentUrl()); // Update media metadata and state (this clears all previous status // overrides). castReceiverContext.getMediaManager() .setDataFromLoad(loadRequestData); ... castReceiverContext.getMediaManager().broadcastMediaStatus(); // Return the resolved MediaLoadRequestData to indicate load success. return loadRequestData; }); } private void myPlayerLoad(String contentURL) { myPlayer.load(contentURL); // Update the MediaSession state. PlaybackStateCompat playbackState = new PlaybackStateCompat.Builder() .setState( player.getState(), player.getPosition(), System.currentTimeMillis()) ... .build(); mediaSession.setPlaybackState(playbackState); }
Per elaborare l'intent di caricamento, puoi analizzarlo nelle strutture di dati che abbiamo definito (MediaLoadRequestData
per le richieste di caricamento).
Supporto dei comandi multimediali
Supporto del controllo di riproduzione di base
I comandi di integrazione di base includono quelli compatibili con le sessioni multimediali. Questi comandi vengono avvisati tramite callback delle sessioni multimediali. Devi registrare un callback a una sessione multimediale per supportare questa funzionalità (potresti già farlo).
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())
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
, ad esempio skipAd()
o setActiveMediaTracks()
.
Inoltre, alcuni comandi in coda devono essere implementati qui perché la coda di trasmissione non è completamente compatibile con la coda MediaSession
.
class MyMediaCommandCallback : MediaCommandCallback() { override fun onSkipAd(requestData: RequestData?): Task{ // Skip your ad ... return Tasks.forResult(null) } } val mediaManager = CastReceiverContext.getInstance().getMediaManager() mediaManager.setMediaCommandCallback(MyMediaCommandCallback())
public class MyMediaCommandCallback extends MediaCommandCallback { @Override public TaskonSkipAd(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 di trasmissione, anche l'app Android TV deve specificare quali comandi
supportare, 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
.
È necessario specificare i comandi aggiuntivi nel
MediaStatusModifier
.
// 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)
// 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 multimediale di base, ma l'app Web ricevitore supporta un controllo più avanzato, devi assicurarti che l'app del mittente si comporti correttamente quando trasmetti all'app Android TV. Ad esempio, se l'app per Android TV non supporta la modifica della velocità di riproduzione mentre l'app Web receiver supporta, devi impostare le azioni supportate correttamente su ogni piattaforma e assicurarti che l'app del mittente esegua il rendering della UI correttamente.
Modifica di MediaStatus
Per supportare funzionalità avanzate come tracce, annunci, live streaming e coda, l'app Android TV deve fornire informazioni aggiuntive che non possono essere verificate tramite MediaSession
.
Ti offriamo la classe MediaStatusModifier
per raggiungere questo obiettivo. MediaStatusModifier
funzionerà sempre sul MediaSession
che hai impostato in CastReceiverContext
.
Per creare e trasmettere
MediaStatus
:
val mediaManager: MediaManager = castReceiverContext.getMediaManager() val statusModifier: MediaStatusModifier = mediaManager.getMediaStatusModifier() statusModifier .setLiveSeekableRange(seekableRange) .setAdBreakStatus(adBreakStatus) .setCustomData(customData) mediaManager.broadcastMediaStatus()
MediaManager mediaManager = castReceiverContext.getMediaManager(); MediaStatusModifier statusModifier = mediaManager.getMediaStatusModifier(); statusModifier .setLiveSeekableRange(seekableRange) .setAdBreakStatus(adBreakStatus) .setCustomData(customData); mediaManager.broadcastMediaStatus();
La nostra libreria client riceverà gli MediaStatus
di base da MediaSession
. La tua app Android TV può specificare uno stato aggiuntivo e sovrascrivere lo stato 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 eseguire l'override degli stati in MediaSession
. Questa operazione è sconsigliata perché lo stato nel modificatore ha sempre una priorità più elevata rispetto ai valori forniti da MediaSession
.
Intercettazione di MediaStatus prima dell'invio
Come per l'SDK Web receiver, se vuoi fare gli ultimi ritocchi prima di inviare l'elemento, puoi specificare un elemento MediaStatusInterceptor
per elaborare l'MediaStatus
da inviare. Trasmettiamo un MediaStatusWriter
per manipolare MediaStatus
prima che venga inviato.
mediaManager.setMediaStatusInterceptor(object : MediaStatusInterceptor { override fun intercept(mediaStatusWriter: MediaStatusWriter) { // Perform customization. mediaStatusWriter.setCustomData(JSONObject("{data: \"my Hello\"}")) } })
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 a determinati utenti di avviare o partecipare alla sessione dell'app. Ad esempio, consenti a un mittente di avviare o partecipare solo se:
- L'app del mittente ha eseguito l'accesso allo stesso account e allo stesso profilo dell'app ATV.
- L'app del mittente è collegata allo stesso account, ma a un profilo diverso dell'app ATV.
Se la tua app è in grado di gestire più utenti o utenti anonimi, puoi consentire ad altri utenti di partecipare alla sessione ATV. Se l'utente fornisce le credenziali, l'app ATV deve gestirne le credenziali in modo che i suoi progressi e altri dati utente possano essere monitorati correttamente.
Quando l'app del mittente viene avviata o si unisce alla tua app Android TV, l'app del mittente dovrebbe fornire le credenziali che rappresentano chi partecipa alla sessione.
Prima che un mittente avvii e acceda alla tua 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 esegue di nuovo l'avvio del ricevitore web.
Dati delle credenziali di avvio dell'app del mittente
Sul lato mittente, puoi specificare il CredentialsData
per rappresentare chi partecipa alla sessione.
credentials
è una stringa che può essere definita dall'utente, purché la tua app ATV
sia in grado di comprenderla. credentialsType
definisce la piattaforma da cui proviene
CredentialsData
o può essere un valore personalizzato. Per impostazione predefinita, è impostata
sulla piattaforma da cui viene inviata.
Il valore CredentialsData
viene trasmesso alla tua app Android TV solo durante l'orario di avvio o di partecipazione. Se lo imposti di nuovo mentre la connessione è attiva, non verrà trasmesso all'app Android TV. Se il mittente cambia il profilo mentre la connessione è attiva, potresti rimanere nella sessione o chiamare SessionManager.endCurrentCastSession(boolean stopCasting)
se ritieni che il nuovo profilo non sia compatibile con la sessione.
Il
CredentialsData
per ogni mittente può essere recuperato utilizzando
getSenders
sul
CastReceiverContext
per ricevere il SenderInfo
,
getCastLaunchRequest()
per prendere il
CastLaunchRequest
e poi
getCredentialsData()
.
Richiede play-services-cast-framework
versione
19.0.0
o successiva.
CastContext.getSharedInstance().setLaunchCredentialsData( CredentialsData.Builder() .setCredentials("{\"userId\": \"abc\"}") .build() )
CastContext.getSharedInstance().setLaunchCredentialsData( new CredentialsData.Builder() .setCredentials("{\"userId\": \"abc\"}") .build());
Richiede google-cast-sdk
versione v4.8.1
o
successiva.
Puoi chiamare in qualsiasi momento dopo aver impostato le opzioni:
GCKCastContext.setSharedInstanceWith(options)
.
GCKCastContext.sharedInstance().setLaunch( GCKCredentialsData(credentials: "{\"userId\": \"abc\"}")
Richiede il browser Chromium versione M87
o successiva.
Puoi chiamare 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);
Implementazione dello strumento Controllo richieste di lancio ATV
L'elemento CredentialsData
viene trasmesso alla tua app Android TV quando un mittente prova ad avviare o a partecipare. Puoi
implementare un
LaunchRequestChecker
.
di consentire o rifiutare la richiesta.
Se una richiesta viene rifiutata, il ricevitore web viene caricato anziché essere avviato in modo nativo nell'app ATV. Devi rifiutare una richiesta se il tuo ATV non è in grado di gestire l'utente che richiede di avviare o partecipare. Alcuni esempi potrebbero essere che un utente diverso ha eseguito l'accesso all'app ATV da quello richiesto e che l'app non è in grado di gestire il cambio di credenziali o che al momento non esiste un utente che ha eseguito l'accesso all'app ATV.
Se la richiesta è 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 si verifica una mancata corrispondenza dell'utente. Questo comportamento è
completamente cusomizzabile in LaunchRequestChecker
.
Crea un corso per implementare l'interfaccia CastReceiverOptions.LaunchRequestChecker
:
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. }
public class MyLaunchRequestChecker implements CastReceiverOptions.LaunchRequestChecker { @Override public TaskcheckLaunchRequestSupported(CastLaunchRequest launchRequest) { return Tasks.call(() -> myCheckLaunchRequest(launchRequest)); } } private boolean myCheckLaunchRequest(CastLaunchRequest launchRequest) { CredentialsData credentialsData = launchRequest.getCredentialsData(); if (credentialsData == null) { return false; // or true if you allow anonymous users to join. } // The request comes from a mobile device, e.g. checking user match. if (credentialsData.getCredentialsType().equals(CredentialsData.CREDENTIALS_TYPE_ANDROID)) { return myCheckMobileCredentialsAllowed(credentialsData.getCredentials()); } // Unrecognized credentials type. return false; }
Quindi, impostala in
ReceiverOptionsProvider
:
class MyReceiverOptionsProvider : ReceiverOptionsProvider { override fun getOptions(context: Context?): CastReceiverOptions { return CastReceiverOptions.Builder(context) ... .setLaunchRequestChecker(MyLaunchRequestChecker()) .build() } }
public class MyReceiverOptionsProvider implements ReceiverOptionsProvider { @Override public CastReceiverOptions getOptions(Context context) { return new CastReceiverOptions.Builder(context) ... .setLaunchRequestChecker(new MyLaunchRequestChecker()) .build(); } }
La risoluzione di true
in
LaunchRequestChecker
avvia l'app ATV e false
avvia l'app Web receiver.
Invio e ricezione di messaggi personalizzati
Il protocollo Cast consente di inviare messaggi stringa personalizzati tra mittenti e
l'applicazione del destinatario. Devi registrare uno spazio dei nomi (canale) per l'invio dei messaggi prima di inizializzare CastReceiverContext
.
Android TV: specifica lo spazio dei nomi personalizzato
Devi specificare gli spazi dei nomi supportati in CastReceiverOptions
durante la configurazione:
class MyReceiverOptionsProvider : ReceiverOptionsProvider { override fun getOptions(context: Context?): CastReceiverOptions { return CastReceiverOptions.Builder(context) .setCustomNamespaces( Arrays.asList("urn:x-cast:com.example.cast.mynamespace") ) .build() } }
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
// If senderId is null, then the message is broadcasted to all senders. CastReceiverContext.getInstance().sendMessage( "urn:x-cast:com.example.cast.mynamespace", senderId, customString)
// 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 per lo spazio dei nomi
class MyCustomMessageListener : MessageReceivedListener { override fun onMessageReceived( namespace: String, senderId: String?, message: String ) { ... } } CastReceiverContext.getInstance().setMessageReceivedListener( "urn:x-cast:com.example.cast.mynamespace", new MyCustomMessageListener());
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());