Pausas publicitarias
El SDK de remitente de Android proporciona compatibilidad con pausas publicitarias y anuncios complementarios dentro de una transmisión de contenido multimedia determinada.
Consulta la Descripción general de las pausas publicitarias del receptor web para obtener más información sobre el funcionamiento de las pausas publicitarias.
Si bien se pueden especificar pausas tanto en el emisor como en el receptor, se recomienda hacerlo en el receptor web y en el receptor de Android TV para mantener un comportamiento coherente en todas las plataformas.
En Android, especifica las pausas publicitarias en un comando de carga con AdBreakClipInfo
y AdBreakInfo
:
val breakClip1: AdBreakClipInfo = AdBreakClipInfo.Builder("bc0") .setTitle("Clip title") .setPosterUrl("https://www.some.url") .setDuration(60000) .setWhenSkippableInMs(5000) // Set this field so that the ad is skippable .build() val breakClip2: AdBreakClipInfo = … val breakClip3: AdBreakClipInfo = … val break1: AdBreakClipInfo = AdBreakInfo.Builder(/* playbackPositionInMs= */ 10000) .setId("b0") .setBreakClipIds({"bc0","bc1","bc2"}) … .build() val mediaInfo: MediaInfo = MediaInfo.Builder() … .setAdBreaks({break1}) .setAdBreakClips({breakClip1, breakClip2, breakClip3}) .build() val mediaLoadRequestData: MediaLoadRequestData = MediaInfo.Builder() … .setMediaInfo(mediaInfo) .build() remoteMediaClient.load(mediaLoadRequestData)
AdBreakClipInfo breakClip1 = new AdBreakClipInfo.Builder("bc0") .setTitle("Clip title") .setPosterUrl("https://www.some.url") .setDuration(60000) .setWhenSkippableInMs(5000) // Set this field so that the ad is skippable .build(); AdBreakClipInfo breakClip2 = … AdBreakClipInfo breakClip3 = … AdBreakInfo break1 = new AdBreakInfo.Builder(/* playbackPositionInMs= */ 10000) .setId("b0") .setBreakClipIds({"bc0","bc1","bc2"}) … .build(); MediaInfo mediaInfo = new MediaInfo.Builder() … .setAdBreaks({break1}) .setAdBreakClips({breakClip1, breakClip2, breakClip3}) .build(); MediaLoadRequestData mediaLoadRequestData = new MediaInfo.Builder() … .setMediaInfo(mediaInfo) .build(); remoteMediaClient.load(mediaLoadRequestData);
Agrega acciones personalizadas
Una app emisora puede extender MediaIntentReceiver
para administrar acciones personalizadas o anular su comportamiento. Si implementaste tu propio MediaIntentReceiver
, debes agregarlo al manifiesto y establecer su nombre en CastMediaOptions
. En este ejemplo, se proporcionan acciones personalizadas que anulan el cambio y la reproducción remota de contenido multimedia, la presión del botón multimedia y otros tipos de acciones.
// In AndroidManifest.xml
<receiver android:name="com.example.MyMediaIntentReceiver" />
// In your OptionsProvider var mediaOptions = CastMediaOptions.Builder() .setMediaIntentReceiverClassName(MyMediaIntentReceiver::class.java.name) .build() // Implementation of MyMediaIntentReceiver internal class MyMediaIntentReceiver : MediaIntentReceiver() { override fun onReceiveActionTogglePlayback(currentSession: Session) { } override fun onReceiveActionMediaButton(currentSession: Session, intent: Intent) { } override fun onReceiveOtherAction(context: Context?, action: String, intent: Intent) { } }
// In your OptionsProvider CastMediaOptions mediaOptions = new CastMediaOptions.Builder() .setMediaIntentReceiverClassName(MyMediaIntentReceiver.class.getName()) .build(); // Implementation of MyMediaIntentReceiver class MyMediaIntentReceiver extends MediaIntentReceiver { @Override protected void onReceiveActionTogglePlayback(Session currentSession) { } @Override protected void onReceiveActionMediaButton(Session currentSession, Intent intent) { } @Override protected void onReceiveOtherAction(Context context, String action, Intent intent) { } }
Agregar un canal personalizado
Para que la app emisora se comunique con la app receptora, tu app debe crear un canal personalizado. El remitente puede usar el canal personalizado para enviar mensajes de cadena al receptor. Cada canal personalizado está definido por un espacio de nombres único y debe comenzar con el prefijo urn:x-cast:
, por ejemplo, urn:x-cast:com.example.custom
. Es posible tener varios canales personalizados, cada uno con un espacio de nombres único. La app receptora también puede enviar y recibir mensajes con el mismo espacio de nombres.
El canal personalizado se implementa con la interfaz Cast.MessageReceivedCallback
:
class HelloWorldChannel : MessageReceivedCallback { val namespace: String get() = "urn:x-cast:com.example.custom" override fun onMessageReceived(castDevice: CastDevice, namespace: String, message: String) { Log.d(TAG, "onMessageReceived: $message") } }
class HelloWorldChannel implements Cast.MessageReceivedCallback { public String getNamespace() { return "urn:x-cast:com.example.custom"; } @Override public void onMessageReceived(CastDevice castDevice, String namespace, String message) { Log.d(TAG, "onMessageReceived: " + message); } }
Una vez que la app emisora está conectada a la app receptora, se puede crear el canal personalizado con el método setMessageReceivedCallbacks
:
try { mCastSession.setMessageReceivedCallbacks( mHelloWorldChannel.namespace, mHelloWorldChannel) } catch (e: IOException) { Log.e(TAG, "Exception while creating channel", e) }
try { mCastSession.setMessageReceivedCallbacks( mHelloWorldChannel.getNamespace(), mHelloWorldChannel); } catch (IOException e) { Log.e(TAG, "Exception while creating channel", e); }
Una vez que se crea el canal personalizado, el remitente puede usar el método sendMessage
para enviar mensajes de cadena al receptor a través de ese canal:
private fun sendMessage(message: String) { if (mHelloWorldChannel != null) { try { mCastSession.sendMessage(mHelloWorldChannel.namespace, message) .setResultCallback { status -> if (!status.isSuccess) { Log.e(TAG, "Sending message failed") } } } catch (e: Exception) { Log.e(TAG, "Exception while sending message", e) } } }
private void sendMessage(String message) { if (mHelloWorldChannel != null) { try { mCastSession.sendMessage(mHelloWorldChannel.getNamespace(), message) .setResultCallback( status -> { if (!status.isSuccess()) { Log.e(TAG, "Sending message failed"); } }); } catch (Exception e) { Log.e(TAG, "Exception while sending message", e); } } }
Compatibilidad con la reproducción automática
Consulta la sección API de reproducción automática y fila de elementos en cola.
Anular la selección de imágenes para los widgets de UX
Varios componentes del framework (p. ej., el diálogo de Cast, el minicontrol y el UIMediaController, si está configurado) mostrarán el material gráfico del contenido multimedia que se esté transmitiendo. Por lo general, las URLs del material gráfico de la imagen se incluyen en MediaMetadata
para el contenido multimedia, pero la app emisora puede tener una fuente alternativa para las URLs.
La clase ImagePicker
define un medio para seleccionar una imagen adecuada de la lista de imágenes en un MediaMetadata
según el uso de la imagen, por ejemplo, la miniatura de la notificación o el fondo de pantalla completa. La implementación predeterminada de ImagePicker
siempre elige la primera imagen o muestra un resultado nulo si no hay ninguna imagen disponible en MediaMetadata
. Tu app puede crear una subclase de ImagePicker
y anular el método onPickImage(MediaMetadata, ImageHints)
para proporcionar una implementación alternativa y, luego, seleccionar esa subclase con el método setImagePicker
de CastMediaOptions.Builder
.
ImageHints
proporciona sugerencias a un ImagePicker
sobre el tipo y el tamaño de una imagen que se seleccionará para mostrarla en la IU.
Cómo personalizar los diálogos de transmisión
Cómo administrar el ciclo de vida de la sesión
SessionManager
es el lugar central para administrar el ciclo de vida de la sesión. SessionManager
escucha los cambios de estado de selección de ruta MediaRouter
de Android al iniciar, reanudar y finalizar sesiones. Cuando se selecciona una ruta, SessionManager
crea un objeto Session
y trata de iniciarlo o reanudarlo. Cuando no se selecciona una ruta, SessionManager
finalizará la sesión actual.
Por lo tanto, para asegurarte de que SessionManager
administre los ciclos de vida de las sesiones de forma correcta, debes asegurarte de lo siguiente:
- En el diálogo del selector de rutas, llama a
MediaRouter.selectRoute(MediaRouter.RouteInfo)
cuando un usuario seleccione un dispositivo. - En el diálogo del controlador de ruta (ya sea en estado de conexión o en estado de transmisión), llama a
MediaRouter.unselect(int)
cuando el usuario deje de transmitir.
Según cómo crees los diálogos de transmisión, es posible que se deban realizar acciones adicionales:
- Si creas diálogos de transmisión con
MediaRouteChooserDialog
yMediaRouteControllerDialog
, se actualizará automáticamente la selección de ruta enMediaRouter
, por lo que no es necesario hacer nada. - Si configuras el botón para transmitir con
CastButtonFactory.setUpMediaRouteButton(Context, Menu, int)
oCastButtonFactory.setUpMediaRouteButton(Context, MediaRouteButton)
, los diálogos se crean conMediaRouteChooserDialog
yMediaRouteControllerDialog
, por lo que tampoco es necesario realizar ninguna acción. - Para otros casos, crearás diálogos personalizados de transmisión, por lo que deberás seguir las instrucciones anteriores para actualizar el estado de selección de ruta en
MediaRouter
.
Estado sin dispositivos
Si creas diálogos personalizados de transmisión, tu MediaRouteChooserDialog
personalizado debería manejar correctamente el caso de que no se encuentren dispositivos. El diálogo debe tener indicadores que aclaren a los usuarios cuándo la app aún intenta encontrar dispositivos y cuándo el intento de descubrimiento ya no está activo.
Si usas el MediaRouteChooserDialog
predeterminado, ya se controla el estado cero de los dispositivos.
Próximos pasos
Con esto concluye las funciones que puedes agregar a tu app de Android Sender. Ahora puedes compilar una app emisora para otra plataforma (iOS o Web), o bien compilar una app receptora web.