En esta página, se incluyen fragmentos de código y descripciones de las funciones disponibles para personalizar una app receptora de Android TV.
Configura bibliotecas
Para que las APIs de Cast Connect estén disponibles en la app de Android TV, haz lo siguiente:
-
Abre el archivo
build.gradle
dentro del directorio del módulo de tu aplicación. -
Verifica que
google()
esté incluido en elrepositories
enumerado.repositories { google() }
-
Según el tipo de dispositivo de destino de tu app, agrega las versiones más recientes de las bibliotecas a tus dependencias:
-
Para la app receptora de Android:
dependencies { implementation 'com.google.android.gms:play-services-cast-tv:21.0.1' implementation 'com.google.android.gms:play-services-cast:21.4.0' }
-
Para la app de 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' }
-
Para la app receptora de Android:
-
Guarda los cambios y haz clic en
Sync Project with Gradle Files
en la barra de herramientas.
-
Asegúrate de que
Podfile
tenga como objetivogoogle-cast-sdk
4.8.0 o una versión posterior. -
Orienta la app a iOS 13 o versiones posteriores. Consulta las Notas de la versión para obtener más detalles.
platform: ios, '13' def target_pods pod 'google-cast-sdk', '~>4.8.0' end
- Se requiere la versión M87 o posterior del navegador Chromium.
-
Agrega la biblioteca de la API de Web Sender al proyecto
<script src="//www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"></script>
Requisito de AndroidX
Las versiones nuevas de los Servicios de Google Play requieren que se actualice una app para que use el espacio de nombres androidx
. Sigue las instrucciones para migrar a AndroidX.
App para Android TV: Requisitos previos
Para que tu app de Android TV sea compatible con Cast Connect, debes crear y admitir eventos de una sesión multimedia. Los datos que proporciona tu sesión multimedia proporcionan la información básica (por ejemplo, la posición, el estado de reproducción, etc.) sobre el estado del contenido multimedia. La biblioteca de Cast Connect también usa la sesión multimedia para indicar cuando recibió ciertos mensajes de un remitente, por ejemplo, de pausa.
Para obtener más información sobre una sesión multimedia y cómo inicializarla, consulta la guía para trabajar con una sesión multimedia.
Ciclo de vida de la sesión multimedia
Tu app debe crear una sesión multimedia cuando se inicia la reproducción y liberarla cuando ya no se pueda controlar. Por ejemplo, si tu app es una app de video, debes liberar la sesión cuando el usuario abandone la actividad de reproducción, ya sea seleccionando "atrás" para explorar otro contenido o poniéndola en segundo plano. Si tu app es de música, debes lanzarla cuando ya no reproduzca contenido multimedia.
Actualizando el estado de la sesión
Los datos de tu sesión multimedia deben mantenerse actualizados con el estado de tu reproductor. Por ejemplo, cuando se pausa la reproducción, debes actualizar el estado de reproducción y las acciones admitidas. En las siguientes tablas, se enumeran los estados que debes mantener actualizados.
MediaMetadataCompat
Campo de metadatos | Descripción |
---|---|
METADATA_KEY_TITLE (obligatorio) | Es el título del contenido multimedia. |
METADATA_KEY_DISPLAY_SUBTITLE | El subtítulo. |
METADATA_KEY_DISPLAY_ICON_URI | La URL del ícono. |
METADATA_KEY_DURATION (obligatorio) | Duración del contenido multimedia. |
METADATA_KEY_MEDIA_URI | Content ID |
METADATA_KEY_ARTIST | El artista. |
METADATA_KEY_ALBUM | El álbum. |
PlaybackStateCompat
Método obligatorio | Descripción |
---|---|
setActions() | Establece los comandos de contenido multimedia compatibles. |
setState() | Establece el estado de reproducción y la posición actual. |
MediaSessionCompat
Método obligatorio | Descripción |
---|---|
setRepeatMode() | Establece el modo de repetición. |
setShuffleMode() | Establece el modo aleatorio. |
setMetadata() | Establece los metadatos del contenido multimedia. |
setPlaybackState() | Establece el estado de reproducción. |
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); }
Cómo administrar el control de transporte
Tu app debe implementar la devolución de llamada de control de transporte de la sesión multimedia. En la siguiente tabla, se muestran las acciones de control de transporte que deben realizar:
MediaSessionCompat.Callback
Acciones | Descripción |
---|---|
onPlay() | Reanudar |
onPause() | Pausar |
onSeekTo() | Saltar a una posición |
onStop() | Detener el contenido multimedia actual |
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());
Cómo configurar la compatibilidad con Cast
Cuando una aplicación emisora envía una solicitud de inicio, se crea un intent con un espacio de nombres de aplicación. Tu aplicación es responsable de controlarla y crear una instancia del objeto CastReceiverContext
cuando se inicie la app para TV. Se necesita el objeto CastReceiverContext
para interactuar con Cast mientras se ejecuta la app para TV. Este objeto permite que tu aplicación de TV acepte mensajes multimedia de transmisión de cualquier remitente conectado.
Configuración de Android TV
Agrega un filtro de intents de inicio
Agrega un filtro de intents nuevo a la actividad que deseas que controle el intent de inicio desde tu app emisora:
<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>
Especifica el proveedor de opciones del receptor
Debes implementar un ReceiverOptionsProvider
para proporcionar 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(); } }
Luego, especifica el proveedor de opciones en tu AndroidManifest
:
<meta-data
android:name="com.google.android.gms.cast.tv.RECEIVER_OPTIONS_PROVIDER_CLASS_NAME"
android:value="com.example.mysimpleatvapplication.MyReceiverOptionsProvider" />
ReceiverOptionsProvider
se usa para proporcionar la CastReceiverOptions
cuando se inicializa CastReceiverContext
.
Contexto del receptor de transmisión
Inicializa CastReceiverContext
cuando se cree tu app:
override fun onCreate() { CastReceiverContext.initInstance(this) ... }
@Override public void onCreate() { CastReceiverContext.initInstance(this); ... }
Inicia el CastReceiverContext
cuando la app pase al primer plano:
CastReceiverContext.getInstance().start()
CastReceiverContext.getInstance().start();
Llama a stop()
en CastReceiverContext
después de que la app pasa a segundo plano para apps de video o apps que no admiten la reproducción en segundo plano:
// Player has stopped. CastReceiverContext.getInstance().stop()
// Player has stopped. CastReceiverContext.getInstance().stop();
Además, si tu app admite la reproducción en segundo plano, llama a stop()
en CastReceiverContext
cuando deje de reproducirse mientras está en segundo plano.
Te recomendamos que uses LifecycleObserver de la biblioteca androidx.lifecycle
para administrar las llamadas a CastReceiverContext.start()
y CastReceiverContext.stop()
, en especial si tu app nativa tiene varias actividades. Esto evita las condiciones de carrera cuando llamas a start()
y stop()
desde diferentes actividades.
// 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">
Cómo conectar MediaSession a MediaManager
Cuando creas un MediaSession
, también debes proporcionar el token de MediaSession
actual a CastReceiverContext
para que sepa a dónde enviar los comandos y recuperar el estado de reproducción de contenido multimedia:
val mediaManager: MediaManager = receiverContext.getMediaManager() mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken())
MediaManager mediaManager = receiverContext.getMediaManager(); mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());
Cuando liberes tu MediaSession
debido a una reproducción inactiva, debes establecer un token nulo en MediaManager
:
myPlayer.stop() mediaSession.release() mediaManager.setSessionCompatToken(null)
myPlayer.stop(); mediaSession.release(); mediaManager.setSessionCompatToken(null);
Si tu app admite la reproducción de contenido multimedia mientras está en segundo plano, en lugar de llamar a CastReceiverContext.stop()
cuando se envía a segundo plano, debes llamarlo solo cuando esté en segundo plano y ya no reproduzca contenido multimedia. Por ejemplo:
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(); } }
Cómo usar Exoplayer con Cast Connect
Si usas Exoplayer
, puedes usar MediaSessionConnector
para mantener automáticamente la sesión y toda la información relacionada, incluido el estado de reproducción, en lugar de hacer un seguimiento de los cambios de forma manual.
Se puede usar MediaSessionConnector.MediaButtonEventHandler
para controlar eventos MediaButton llamando a setMediaButtonEventHandler(MediaButtonEventHandler)
, que, de lo contrario, se controlan mediante MediaSessionCompat.Callback
de forma predeterminada.
Para integrar MediaSessionConnector
en tu app, agrega lo siguiente a tu clase de actividad del jugador o a donde administres tu sesión multimedia:
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); ... } }
Configuración de la app del remitente
Habilitar la compatibilidad con Cast Connect
Una vez que hayas actualizado la app emisora de tu app emisora con Cast Connect, podrás declarar si está lista si configuras la marca androidReceiverCompatible
de LaunchOptions
como verdadera.
Requiere play-services-cast-framework
versión
19.0.0
o posterior.
La marca androidReceiverCompatible
se establece en LaunchOptions
(que forma parte de 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(); } }
Requiere google-cast-sdk
versión v4.4.8
o
posterior.
La marca androidReceiverCompatible
se establece en GCKLaunchOptions
(que forma parte de GCKCastOptions
):
let options = GCKCastOptions(discoveryCriteria: GCKDiscoveryCriteria(applicationID: kReceiverAppID)) ... let launchOptions = GCKLaunchOptions() launchOptions.androidReceiverCompatible = true options.launchOptions = launchOptions GCKCastContext.setSharedInstanceWith(options)
Se requiere la versión M87
del navegador Chromium o una posterior.
const context = cast.framework.CastContext.getInstance(); const castOptions = new cast.framework.CastOptions(); castOptions.receiverApplicationId = kReceiverAppID; castOptions.androidReceiverCompatible = true; context.setOptions(castOptions);
Configuración de la consola para desarrolladores de Cast
Cómo configurar la app de Android TV
Agrega el nombre del paquete de tu app de Android TV a la consola para desarrolladores de Cast a fin de asociarla con el ID de tu app de Cast.
Cómo registrar los dispositivos de desarrollador
Registra el número de serie del dispositivo Android TV que usarás para el desarrollo en Cast Developer Console.
Por motivos de seguridad, sin el registro, Cast Connect solo funcionará para apps instaladas desde Google Play Store.
Si quieres obtener más información para registrar un dispositivo de transmisión o Android TV para el desarrollo de Cast, consulta la página de registro.
Carga de contenido multimedia
Si ya implementaste la compatibilidad con vínculos directos en tu app para Android TV, deberías tener una definición similar configurada en tu manifiesto de 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>
Carga por entidad en el remitente
En los remitentes, puedes pasar el vínculo directo si configuras entity
en la información multimedia de la solicitud de carga:
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)
Se requiere la versión M87
del navegador Chromium o una posterior.
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);
El comando de carga se envía a través de un intent con tu vínculo directo y el nombre del paquete que definiste en Play Console.
Configura credenciales de ATV en el remitente
Es posible que las apps de Web Receiver y Android TV admitan diferentes vínculos directos y credentials
(por ejemplo, si controlas la autenticación de manera diferente en ambas plataformas). Para solucionar este problema, puedes proporcionar entity
y credentials
alternativos para 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)
Se requiere la versión M87
del navegador Chromium o una posterior.
let mediaInfo = new chrome.cast.media.MediaInfo('some-id"', 'video/mp4'); mediaInfo.entity = 'https://example.com/watch/some-id'; mediaInfo.atvEntity = 'myscheme://example.com/atv/some-id'; ... let request = new chrome.cast.media.LoadRequest(mediaInfo); request.credentials = 'user-credentials'; request.atvCredentials = 'atv-user-credentials'; ... cast.framework.CastContext.getInstance().getCurrentSession().loadMedia(request);
Si se inicia la app de Web Receiver, esta usa entity
y credentials
en la solicitud de carga. Sin embargo, si se inicia tu app para Android TV, el SDK anula entity
y credentials
con tu atvEntity
y atvCredentials
(si se especifica).
Carga por Content ID o MediaQueueData
Si no usas entity
ni atvEntity
, y usas Content ID o Content URL en tu información multimedia, o bien usas datos más detallados de solicitudes de carga de contenido multimedia, debes agregar el siguiente filtro de intents predefinido en la app de 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>
En el lado del remitente, al igual que carga por entidad, puedes crear una solicitud de carga con la información de tu contenido y llamar a 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)
Se requiere la versión M87
del navegador Chromium o una posterior.
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);
Cómo controlar las solicitudes de carga
En tu actividad, para controlar estas solicitudes de carga, debes controlar los intents en las devoluciones de llamada del ciclo de vida de la actividad:
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. ... } }
Si MediaManager
detecta que el intent es de carga, extrae un objeto MediaLoadRequestData
del intent y, luego, invoca MediaLoadCommandCallback.onLoad()
.
Debes anular este método para controlar la solicitud de carga. Se debe registrar la devolución de llamada antes de que se llame a MediaManager.onNewIntent()
(se recomienda usar un método onCreate()
de Activity o Application).
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); }
Para procesar el intent de carga, puedes analizarlo en las estructuras de datos que definimos (MediaLoadRequestData
para las solicitudes de carga).
Cómo brindar compatibilidad con comandos multimedia
Compatibilidad básica con el control de reproducción
Los comandos de integración básicos incluyen aquellos compatibles con la sesión multimedia. Estos comandos reciben notificaciones a través de devoluciones de llamada de sesiones multimedia. Debes registrar una devolución de llamada a la sesión multimedia para admitir esto (es posible que ya estés haciéndolo).
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());
Cómo brindar compatibilidad con comandos de control de Cast
Hay algunos comandos de transmisión que no están disponibles en MediaSession
, como skipAd()
o setActiveMediaTracks()
.
Además, algunos comandos de cola se deben implementar aquí, ya que la cola de transmisión no es del todo compatible con la cola 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());
Cómo especificar los comandos multimedia compatibles
Al igual que con el receptor de Cast, tu app de Android TV debe especificar qué comandos son compatibles, de modo que los remitentes puedan habilitar o inhabilitar ciertos controles de la IU. Para los comandos que forman parte de MediaSession
, especifica los comandos en PlaybackStateCompat
.
Los comandos adicionales se deben especificar en el 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);
Ocultar botones no compatibles
Si tu app de Android TV solo admite control multimedia básico, pero la app de Receptor web admite controles más avanzados, debes asegurarte de que la app emisora se comporte de manera correcta cuando transmite a la app de Android TV. Por ejemplo, si tu app de Android TV no admite cambiar la velocidad de reproducción mientras la app de Receptor web lo hace, deberías configurar correctamente las acciones admitidas en cada plataforma y asegurarte de que la app emisora renderice correctamente la IU.
Cómo modificar MediaStatus
Para admitir funciones avanzadas, como segmentos, anuncios, transmisiones en vivo y filas, tu app de Android TV debe proporcionar información adicional que no se puede determinar mediante MediaSession
.
Para que lo logres, te proporcionamos la clase MediaStatusModifier
. MediaStatusModifier
siempre operará en el MediaSession
que estableciste en CastReceiverContext
.
Para crear y transmitir MediaStatus
, haz lo siguiente:
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();
Nuestra biblioteca cliente obtendrá la MediaStatus
base de MediaSession
, tu app para Android TV puede especificar un estado adicional y anular el estado a través de un modificador MediaStatus
.
Algunos estados y metadatos se pueden establecer tanto en MediaSession
como en MediaStatusModifier
. Te recomendamos que solo las configures en MediaSession
. Aún puedes usar el modificador para anular los estados en MediaSession
. Esto no es recomendable, ya que el estado del modificador siempre tiene una prioridad más alta que los valores que proporciona MediaSession
.
Cómo interceptar el MediaStatus antes de enviar un mensaje
Al igual que el SDK de Web Receiver, si quieres realizar algunos toques finales antes del envío, puedes especificar un MediaStatusInterceptor
para procesar el MediaStatus
que se enviará. Pasamos un MediaStatusWriter
para manipular el MediaStatus
antes de que se envíe.
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\"}")); } });
Administra las credenciales de usuario
Es posible que tu app para Android TV solo permita que ciertos usuarios inicien la sesión de la app o se unan a ella. Por ejemplo, solo permite que un remitente inicie o se una si se cumplen las siguientes condiciones:
- La app emisora accedió a la misma cuenta y perfil que la app de ATV.
- La app emisora accedió a la misma cuenta, pero tiene un perfil diferente que la app de ATV.
Si tu app puede controlar usuarios múltiples o anónimos, puedes permitir que cualquier usuario adicional se una a la sesión de ATV. Si el usuario proporciona credenciales, tu app de ATV debe manejar sus credenciales para que se pueda realizar un seguimiento adecuado de su progreso y otros datos del usuario.
Cuando la app emisora se inicia o se une a tu app para Android TV, esta debe proporcionar las credenciales que representan quién se une a la sesión.
Antes de que un remitente inicie tu app para Android TV y se una a ella, puedes especificar un verificador de lanzamiento para ver si se permiten las credenciales de remitente. De lo contrario, el SDK de Cast Connect recurre a iniciar tu receptor web.
Datos de credenciales de inicio de la app del remitente
En el lado del remitente, puedes especificar el CredentialsData
para representar quién se une a la sesión.
El credentials
es una cadena que puede definir el usuario, siempre que tu app de ATV pueda comprenderla. El credentialsType
define de qué plataforma proviene CredentialsData
o puede ser un valor personalizado. De forma predeterminada, se establece en la plataforma desde la que se envía.
El CredentialsData
solo se pasa a la app de Android TV durante el inicio o la unión. Si lo vuelves a configurar mientras tienes conexión, no se pasará a la app para Android TV. Si la persona que envía el contenido cambia de perfil mientras está conectado, puedes permanecer en la sesión o llamar a SessionManager.endCurrentCastSession(boolean stopCasting)
si crees que el perfil nuevo no es compatible con ella.
El CredentialsData
de cada remitente se puede recuperar con getSenders
en el CastReceiverContext
para obtener el SenderInfo
, getCastLaunchRequest()
para obtener el CastLaunchRequest
y, luego, el getCredentialsData()
.
Requiere play-services-cast-framework
versión
19.0.0
o posterior.
CastContext.getSharedInstance().setLaunchCredentialsData( CredentialsData.Builder() .setCredentials("{\"userId\": \"abc\"}") .build() )
CastContext.getSharedInstance().setLaunchCredentialsData( new CredentialsData.Builder() .setCredentials("{\"userId\": \"abc\"}") .build());
Requiere google-cast-sdk
versión v4.8.0
o
posterior.
Se puede llamar en cualquier momento después de configurar las opciones: GCKCastContext.setSharedInstanceWith(options)
.
GCKCastContext.sharedInstance().setLaunch( GCKCredentialsData(credentials: "{\"userId\": \"abc\"}")
Se requiere la versión M87
del navegador Chromium o una posterior.
Se puede llamar en cualquier momento después de configurar las opciones: cast.framework.CastContext.getInstance().setOptions(options);
.
let credentialsData = new chrome.cast.CredentialsData("{\"userId\": \"abc\"}"); cast.framework.CastContext.getInstance().setLaunchCredentialsData(credentialsData);
Cómo implementar el verificador de solicitudes de lanzamiento de ATV
El objeto CredentialsData
se pasa a la app para Android TV cuando un remitente intenta iniciar o unirse. Puedes implementar un LaunchRequestChecker
.
para permitir o rechazar la solicitud.
Si se rechaza una solicitud, el receptor web se carga en lugar de iniciarse de forma nativa en la app de ATV. Debes rechazar una solicitud si tu ATV no puede manejar el usuario que solicita iniciarse o unirse. Por ejemplo, cuando un usuario accede a la app de ATV es diferente al que lo solicita y tu app no puede controlar el cambio de credenciales, o bien que no hay un usuario conectado a la app de ATV en este momento.
Si se permite una solicitud, se inicia la app de ATV. Puedes personalizar este comportamiento en función de si tu app admite el envío de solicitudes de carga cuando un usuario no accedió a la app de ATV o si el usuario no coincide. Este comportamiento se puede personalizar por completo en LaunchRequestChecker
.
Crea una clase que implemente la interfaz 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; }
Luego, configúrala en tu 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 resolución de true
en LaunchRequestChecker
inicia la app de ATV y false
inicia la app de Web Receiver.
Cómo enviar y recibir mensajes personalizados
El protocolo de transmisión te permite enviar mensajes de cadena personalizados entre los remitentes y la aplicación receptora. Debes registrar un espacio de nombres (canal) para enviar mensajes antes de inicializar tu CastReceiverContext
.
Android TV: especifica un espacio de nombres personalizado
Debes especificar los espacios de nombres admitidos en tu CastReceiverOptions
durante la configuración:
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: Cómo enviar mensajes
// 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: recibe mensajes de espacio de nombres personalizados
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());