Este guia do desenvolvedor descreve como adicionar suporte ao Google Cast ao seu app de remetente do Android usando o SDK do Android Sender.
O dispositivo móvel ou laptop é o remetente que controla a reprodução, e o dispositivo com Google Cast é o Receptor que exibe o conteúdo na TV.
O framework do remetente se refere ao binário da biblioteca de classes do Cast e aos recursos associados presentes no momento da execução no remetente. O app remetente ou app Cast se refere a um app que também está sendo executado no remetente. O app Receptor da Web refere-se ao aplicativo HTML em execução no dispositivo compatível com Cast.
O framework do remetente usa um design de callback assíncrono para informar eventos ao app remetente e fazer a transição entre vários estados do ciclo de vida do app Google Cast.
Fluxo de aplicativos
As etapas a seguir descrevem o fluxo de execução de alto nível típico de um app Android de remetente:
- O framework do Cast inicia automaticamente a descoberta de dispositivos
MediaRoutercom base no ciclo de vida daActivity. - Quando o usuário clica no botão Transmitir, o framework apresenta a caixa de diálogo "Transmitir" com a lista de dispositivos de transmissão descobertos.
- Quando o usuário seleciona um dispositivo de transmissão, o framework tenta iniciar o app Receptor da Web no dispositivo de transmissão.
- O framework invoca callbacks no app remetente para confirmar que o app Receptor da Web foi iniciado.
- O framework cria um canal de comunicação entre o remetente e os apps do receptor da Web.
- O framework usa o canal de comunicação para carregar e controlar a reprodução de mídia no receptor da Web.
- O framework sincroniza o estado de reprodução de mídia entre o remetente e o receptor da Web: quando o usuário realiza ações na interface do remetente, o framework transmite essas solicitações de controle de mídia para o receptor da Web e, quando ele envia atualizações de status de mídia, o framework atualiza o estado da interface do remetente.
- Quando o usuário clica no botão Transmitir para se desconectar do dispositivo de transmissão, o framework desconecta o app remetente do receptor da Web.
Para ver uma lista abrangente de todas as classes, métodos e eventos no SDK do Google Cast para Android, consulte a Referência da API Google Cast Sender para Android. As seções a seguir abordam as etapas para adicionar o Google Cast ao seu app Android.
Configurar o manifesto do Android
O arquivo AndroidManifest.xml do app exige que você configure os seguintes elementos para o SDK do Cast:
uses-sdk
Defina os níveis mínimos e desejados da API do Android compatíveis com o SDK do Cast. Atualmente, o nível mínimo da API é 21, e o objetivo é o nível 28 da API.
<uses-sdk
android:minSdkVersion="21"
android:targetSdkVersion="28" />
android:theme
Defina o tema do app com base na versão mínima do SDK do Android. Por exemplo, se
você não estiver implementando seu próprio tema, use uma variante de
Theme.AppCompat ao segmentar uma versão mínima do SDK do Android que seja
anterior ao Lollipop.
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/Theme.AppCompat" >
...
</application>
Inicializar o contexto de transmissão
O framework tem um objeto Singleton global, o CastContext, que coordena
todas as interações dele.
Seu app precisa implementar a interface
OptionsProvider
para fornecer as opções necessárias para inicializar o
singleton
CastContext. OptionsProvider fornece uma instância de
CastOptions
com opções que afetam o comportamento do framework. O mais
importante é o ID do aplicativo do receptor da Web, que é usado para filtrar
os resultados da descoberta e iniciar o app quando uma sessão do Cast é
iniciada.
class CastOptionsProvider : OptionsProvider {
override fun getCastOptions(context: Context): CastOptions {
return Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.build()
}
override fun getAdditionalSessionProviders(context: Context): List<SessionProvider>? {
return null
}
}
public class CastOptionsProvider implements OptionsProvider {
@Override
public CastOptions getCastOptions(Context context) {
CastOptions castOptions = new CastOptions.Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.build();
return castOptions;
}
@Override
public List<SessionProvider> getAdditionalSessionProviders(Context context) {
return null;
}
}
Você precisa declarar o nome totalmente qualificado do OptionsProvider implementado
como um campo de metadados no arquivo AndroidManifest.xml do app remetente:
<application>
...
<meta-data
android:name=
"com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
android:value="com.foo.CastOptionsProvider" />
</application>
CastContext é inicializado lentamente quando CastContext.getSharedInstance() é chamado.
class MyActivity : FragmentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
val castContext = CastContext.getSharedInstance(this)
}
}
public class MyActivity extends FragmentActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
CastContext castContext = CastContext.getSharedInstance(this);
}
}
Os widgets de UX do Google Cast
O framework do Google Cast oferece os widgets que obedecem à lista de verificação de design do Cast:
Sobreposição introdutória: o framework fornece uma visualização personalizada,
IntroductoryOverlay, que é mostrada ao usuário para chamar a atenção para o botão Transmitir na primeira vez que um receptor estiver disponível. O app Sender pode personalizar o texto e a posição do texto do título.Botão Transmitir: esse botão fica visível independentemente da disponibilidade dos dispositivos de transmissão. Quando o usuário clica no botão Transmitir pela primeira vez, uma caixa de diálogo é exibida, listando os dispositivos descobertos. Quando o usuário clica no botão Transmitir com o dispositivo conectado, ele exibe os metadados de mídia atuais, como título, nome do estúdio de gravação e uma imagem em miniatura, ou permite que o usuário se desconecte do dispositivo de transmissão. O "botão Transmitir" às vezes é chamado de "ícone Transmitir".
Minicontrole: quando o usuário está transmitindo conteúdo e saiu da página de conteúdo atual ou do controle expandido para outra tela no app remetente, o minicontrole será exibido na parte de baixo da tela para permitir que o usuário confira os metadados de mídia em transmissão no momento e controle a reprodução.
Controle expandido: quando o usuário estiver transmitindo conteúdo, se ele clicar na notificação de mídia ou no minicontrole, o controle expandido será iniciado, exibindo os metadados de mídia em reprodução e fornecendo vários botões para controlar a mídia.
Notificação: somente para Android. Quando o usuário está transmitindo conteúdo e sai do app remetente, uma notificação de mídia é exibida, mostrando os metadados e controles de mídia transmitidos no momento.
Tela de bloqueio: somente para Android. Quando o usuário está transmitindo conteúdo e navega (ou o dispositivo expira) para a tela de bloqueio, é exibido um controle de tela de bloqueio de mídia que mostra os metadados e os controles de mídia da transmissão no momento.
O guia a seguir inclui descrições de como adicionar esses widgets ao seu app.
Adicionar um botão Transmitir
As APIs
MediaRouter
do Android foram projetadas para permitir a exibição e a reprodução de mídia em dispositivos secundários.
Os apps Android que usam a API MediaRouter precisam incluir um botão "Transmitir" como parte
da interface do usuário para permitir que os usuários selecionem um roteamento de mídia para reproduzir mídia em
um dispositivo secundário, como um dispositivo de transmissão.
O framework facilita muito a adição de um
MediaRouteButton
como um
Cast button. Primeiro, adicione um item de menu ou um MediaRouteButton no arquivo
xml que define o menu e use
CastButtonFactory
para conectá-lo ao framework.
// To add a Cast button, add the following snippet.
// menu.xml
<item
android:id="@+id/media_route_menu_item"
android:title="@string/media_route_menu_title"
app:actionProviderClass="androidx.mediarouter.app.MediaRouteActionProvider"
app:showAsAction="always" />
// Then override the onCreateOptionMenu() for each of your activities.
// MyActivity.kt
override fun onCreateOptionsMenu(menu: Menu): Boolean {
super.onCreateOptionsMenu(menu)
menuInflater.inflate(R.menu.main, menu)
CastButtonFactory.setUpMediaRouteButton(
applicationContext,
menu,
R.id.media_route_menu_item
)
return true
}
// Then override the onCreateOptionMenu() for each of your activities.
// MyActivity.java
@Override public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
getMenuInflater().inflate(R.menu.main, menu);
CastButtonFactory.setUpMediaRouteButton(getApplicationContext(),
menu,
R.id.media_route_menu_item);
return true;
}
Então, caso seu Activity herde de
FragmentActivity,
você poderá adicionar um
MediaRouteButton
ao layout.
// activity_layout.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_vertical"
android:orientation="horizontal" >
<androidx.mediarouter.app.MediaRouteButton
android:id="@+id/media_route_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="1"
android:mediaRouteTypes="user"
android:visibility="gone" />
</LinearLayout>
// MyActivity.kt
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_layout)
mMediaRouteButton = findViewById<View>(R.id.media_route_button) as MediaRouteButton
CastButtonFactory.setUpMediaRouteButton(applicationContext, mMediaRouteButton)
mCastContext = CastContext.getSharedInstance(this)
}
// MyActivity.java
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_layout);
mMediaRouteButton = (MediaRouteButton) findViewById(R.id.media_route_button);
CastButtonFactory.setUpMediaRouteButton(getApplicationContext(), mMediaRouteButton);
mCastContext = CastContext.getSharedInstance(this);
}
Para definir a aparência do botão Transmitir usando um tema, consulte Personalizar o botão Transmitir.
Configurar a descoberta de dispositivos
A descoberta de dispositivos é completamente gerenciada pelo
CastContext.
Ao inicializar o CastContext, o app remetente especifica o ID do aplicativo do receptor da Web
e, opcionalmente, pode solicitar a filtragem de namespace definindo
supportedNamespaces em
CastOptions.
CastContext mantém uma referência ao MediaRouter internamente e iniciará
o processo de descoberta nas seguintes condições:
- Com base em um algoritmo projetado para equilibrar a latência de descoberta do dispositivo e o uso da bateria, a descoberta será iniciada automaticamente quando o app remetente entrar em primeiro plano.
- A caixa de diálogo "Transmitir" está aberta.
- O SDK do Cast está tentando recuperar uma sessão do Google Cast.
O processo de descoberta será interrompido quando a caixa de diálogo "Transmitir" for fechada ou o app remetente entrar em segundo plano.
class CastOptionsProvider : OptionsProvider {
companion object {
const val CUSTOM_NAMESPACE = "urn:x-cast:custom_namespace"
}
override fun getCastOptions(appContext: Context): CastOptions {
val supportedNamespaces: MutableList<String> = ArrayList()
supportedNamespaces.add(CUSTOM_NAMESPACE)
return CastOptions.Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.setSupportedNamespaces(supportedNamespaces)
.build()
}
override fun getAdditionalSessionProviders(context: Context): List<SessionProvider>? {
return null
}
}
class CastOptionsProvider implements OptionsProvider {
public static final String CUSTOM_NAMESPACE = "urn:x-cast:custom_namespace";
@Override
public CastOptions getCastOptions(Context appContext) {
List<String> supportedNamespaces = new ArrayList<>();
supportedNamespaces.add(CUSTOM_NAMESPACE);
CastOptions castOptions = new CastOptions.Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.setSupportedNamespaces(supportedNamespaces)
.build();
return castOptions;
}
@Override
public List<SessionProvider> getAdditionalSessionProviders(Context context) {
return null;
}
}
Como funciona o gerenciamento de sessões
O SDK do Cast apresenta o conceito de uma sessão do Google Cast. Esse estabelecimento combina as etapas de conexão a um dispositivo, inicialização (ou associação) de um app receptor da Web, conexão a esse app e inicialização de um canal de controle de mídia. Consulte o Guia do ciclo de vida do aplicativo para mais informações sobre as sessões do Google Cast e o ciclo de vida do receptor da Web.
As sessões são gerenciadas pela classe
SessionManager,
que seu app pode acessar via
CastContext.getSessionManager().
Sessões individuais são representadas por subclasses da classe
Session.
Por exemplo,
CastSession
representa sessões com dispositivos de transmissão. Seu app pode acessar a sessão do Google Cast
ativa no momento via
SessionManager.getCurrentCastSession().
Seu app pode usar a classe
SessionManagerListener
para monitorar eventos de sessão, como criação, suspensão, retomada e
encerramento. O framework tenta retomar automaticamente a partir de um encerramento anormal/abrupto enquanto uma sessão estava ativa.
As sessões são criadas e eliminadas automaticamente em resposta a gestos do usuário
nas caixas de diálogo MediaRouter.
Para entender melhor os erros de inicialização do Google Cast, os apps podem usar
CastContext#getCastReasonCodeForCastStatusCode(int)
para converter o erro de inicialização de sessão para
CastReasonCodes.
Alguns erros de início de sessão (por exemplo, CastReasonCodes#CAST_CANCELLED) são comportamentos intencionais e não podem ser registrados como erros.
Caso você precise estar ciente das mudanças de estado da sessão, implemente
um SessionManagerListener. Este exemplo detecta a disponibilidade de um
CastSession em um Activity.
class MyActivity : Activity() {
private var mCastSession: CastSession? = null
private lateinit var mCastContext: CastContext
private lateinit var mSessionManager: SessionManager
private val mSessionManagerListener: SessionManagerListener<CastSession> =
SessionManagerListenerImpl()
private inner class SessionManagerListenerImpl : SessionManagerListener<CastSession?> {
override fun onSessionStarting(session: CastSession?) {}
override fun onSessionStarted(session: CastSession?, sessionId: String) {
invalidateOptionsMenu()
}
override fun onSessionStartFailed(session: CastSession?, error: Int) {
val castReasonCode = mCastContext.getCastReasonCodeForCastStatusCode(error)
// Handle error
}
override fun onSessionSuspended(session: CastSession?, reason Int) {}
override fun onSessionResuming(session: CastSession?, sessionId: String) {}
override fun onSessionResumed(session: CastSession?, wasSuspended: Boolean) {
invalidateOptionsMenu()
}
override fun onSessionResumeFailed(session: CastSession?, error: Int) {}
override fun onSessionEnding(session: CastSession?) {}
override fun onSessionEnded(session: CastSession?, error: Int) {
finish()
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
mCastContext = CastContext.getSharedInstance(this)
mSessionManager = mCastContext.sessionManager
}
override fun onResume() {
super.onResume()
mCastSession = mSessionManager.currentCastSession
mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession::class.java)
}
override fun onPause() {
super.onPause()
mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession::class.java)
mCastSession = null
}
}
public class MyActivity extends Activity {
private CastContext mCastContext;
private CastSession mCastSession;
private SessionManager mSessionManager;
private SessionManagerListener<CastSession> mSessionManagerListener =
new SessionManagerListenerImpl();
private class SessionManagerListenerImpl implements SessionManagerListener<CastSession> {
@Override
public void onSessionStarting(CastSession session) {}
@Override
public void onSessionStarted(CastSession session, String sessionId) {
invalidateOptionsMenu();
}
@Override
public void onSessionStartFailed(CastSession session, int error) {
int castReasonCode = mCastContext.getCastReasonCodeForCastStatusCode(error);
// Handle error
}
@Override
public void onSessionSuspended(CastSession session, int reason) {}
@Override
public void onSessionResuming(CastSession session, String sessionId) {}
@Override
public void onSessionResumed(CastSession session, boolean wasSuspended) {
invalidateOptionsMenu();
}
@Override
public void onSessionResumeFailed(CastSession session, int error) {}
@Override
public void onSessionEnding(CastSession session) {}
@Override
public void onSessionEnded(CastSession session, int error) {
finish();
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mCastContext = CastContext.getSharedInstance(this);
mSessionManager = mCastContext.getSessionManager();
}
@Override
protected void onResume() {
super.onResume();
mCastSession = mSessionManager.getCurrentCastSession();
mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession.class);
}
@Override
protected void onPause() {
super.onPause();
mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession.class);
mCastSession = null;
}
}
Transferência de stream
A preservação do estado da sessão é a base da transferência de stream, em que os usuários podem mover os streams de áudio e vídeo existentes entre dispositivos usando comandos de voz, o app Google Home ou smart displays. A mídia é interrompida em um dispositivo (a origem) e continua em outro (o destino). Qualquer dispositivo de transmissão com o firmware mais recente pode servir como origens ou destinos em uma transferência por stream.
Para ter o novo dispositivo de destino durante uma expansão ou transferência de stream,
registre um
Cast.Listener
usando o
CastSession#addCastListener.
Em seguida, chame
CastSession#getCastDevice()
durante o callback onDeviceNameChanged.
Consulte Transferência de stream no receptor da Web para mais informações.
Reconexão automática
O framework fornece um
ReconnectionService,
que pode ser ativado pelo app remetente para processar a reconexão em muitos casos específicos
sutis, como:
- Recuperar-se de uma perda temporária de Wi-Fi
- Recuperar-se do modo de inatividade do dispositivo
- Recuperar-se do app em segundo plano
- Fazer a recuperação em caso de falha do app
Esse serviço é ativado por padrão e pode ser desativado em
CastOptions.Builder.
Esse serviço poderá ser integrado automaticamente ao manifesto do app se a mesclagem automática estiver ativada no arquivo do Gradle.
O framework inicia o serviço quando há uma sessão de mídia e o interrompe quando a sessão termina.
Como funciona o controle de mídia
O framework do Cast descontinua a classe
RemoteMediaPlayer
do Cast 2.x em favor de uma nova classe
RemoteMediaClient,
que oferece a mesma funcionalidade em um conjunto de APIs mais convenientes e
evita a transmissão de um GoogleApiClient.
Quando o app estabelecer um
CastSession
com um app receptor da Web que oferece suporte ao namespace de mídia, uma instância de
RemoteMediaClient será criada automaticamente pelo framework. Seu app pode
acessá-la chamando o método getRemoteMediaClient() na instância
CastSession.
Todos os métodos de RemoteMediaClient que emitem solicitações ao Web Receiver retornarão um objeto PendingResult que pode ser usado para rastrear essa solicitação.
Espera-se que a instância de RemoteMediaClient seja compartilhada por
várias partes do app e, na verdade, por alguns componentes internos do
framework, como os minicontroles persistentes e
o serviço de notificação.
Para isso, ela aceita o registro de várias instâncias de
RemoteMediaClient.Listener.
Definir metadados de mídia
A classe
MediaMetadata
representa as informações sobre um item de mídia que você quer transmitir. O
exemplo a seguir cria uma nova instância MediaMetadata de um filme e define o
título, subtítulo e duas imagens.
val movieMetadata = MediaMetadata(MediaMetadata.MEDIA_TYPE_MOVIE) movieMetadata.putString(MediaMetadata.KEY_TITLE, mSelectedMedia.getTitle()) movieMetadata.putString(MediaMetadata.KEY_SUBTITLE, mSelectedMedia.getStudio()) movieMetadata.addImage(WebImage(Uri.parse(mSelectedMedia.getImage(0)))) movieMetadata.addImage(WebImage(Uri.parse(mSelectedMedia.getImage(1))))
MediaMetadata movieMetadata = new MediaMetadata(MediaMetadata.MEDIA_TYPE_MOVIE); movieMetadata.putString(MediaMetadata.KEY_TITLE, mSelectedMedia.getTitle()); movieMetadata.putString(MediaMetadata.KEY_SUBTITLE, mSelectedMedia.getStudio()); movieMetadata.addImage(new WebImage(Uri.parse(mSelectedMedia.getImage(0)))); movieMetadata.addImage(new WebImage(Uri.parse(mSelectedMedia.getImage(1))));
Consulte Seleção de imagens sobre o uso de imagens com metadados de mídia.
Carregar mídia
Seu app pode carregar um item de mídia, conforme mostrado no código a seguir. Primeiro, use
MediaInfo.Builder
com os metadados da mídia para criar uma
instância
MediaInfo. Acesse o
RemoteMediaClient
do CastSession atual e carregue o MediaInfo nesse
RemoteMediaClient. Use RemoteMediaClient para tocar, pausar e controlar
um app de player de mídia em execução no receptor da Web.
val mediaInfo = MediaInfo.Builder(mSelectedMedia.getUrl())
.setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
.setContentType("videos/mp4")
.setMetadata(movieMetadata)
.setStreamDuration(mSelectedMedia.getDuration() * 1000)
.build()
val remoteMediaClient = mCastSession.getRemoteMediaClient()
remoteMediaClient.load(MediaLoadRequestData.Builder().setMediaInfo(mediaInfo).build())
MediaInfo mediaInfo = new MediaInfo.Builder(mSelectedMedia.getUrl())
.setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
.setContentType("videos/mp4")
.setMetadata(movieMetadata)
.setStreamDuration(mSelectedMedia.getDuration() * 1000)
.build();
RemoteMediaClient remoteMediaClient = mCastSession.getRemoteMediaClient();
remoteMediaClient.load(new MediaLoadRequestData.Builder().setMediaInfo(mediaInfo).build());
Consulte também a seção sobre como usar faixas de mídia.
Formato de vídeo 4K
Para conferir qual é o formato de vídeo da sua mídia, use
getVideoInfo()
no MediaStatus para acessar a instância atual de
VideoInfo.
Essa instância contém o tipo de formato de TV HDR e a altura
e a largura da tela em pixels. As variantes do formato 4K são indicadas por constantes
HDR_TYPE_*.
Notificações de controle remoto para vários dispositivos
Quando um usuário está transmitindo, outros dispositivos Android na mesma rede recebem uma notificação que também permite controlar a reprodução. Qualquer pessoa cujo dispositivo receba essas notificações poderá desativá-las no app Configurações em Google > Google Cast > Mostrar notificações de controle remoto. As notificações incluem um atalho para o aplicativo Configurações. Para mais detalhes, consulte Notificações de controle remoto do Google Cast.
Adicionar minicontrole
De acordo com a Lista de verificação de design de transmissão, um app remetente precisa fornecer um controle persistente, conhecido como mini controlador, que aparece quando o usuário sai da página de conteúdo atual para outra parte do app remetente. O minicontrole fornece um lembrete visível ao usuário da sessão atual do Google Cast. Ao tocar no minicontrole, o usuário pode retornar à visualização do controlador expandida em tela cheia do Google Cast.
O framework fornece uma visualização personalizada, MiniControllerFragment, que você pode adicionar à parte de baixo do arquivo de layout de cada atividade em que você quer mostrar o minicontrole.
<fragment
android:id="@+id/castMiniController"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:visibility="gone"
class="com.google.android.gms.cast.framework.media.widget.MiniControllerFragment" />
Quando o app remetente estiver reproduzindo uma transmissão ao vivo de vídeo ou áudio, o SDK exibe automaticamente um botão "Play/Stop" no lugar do botão "Play/pause" no minicontrole.
Para definir a aparência de texto do título e do subtítulo dessa visualização personalizada e escolher botões, consulte Personalizar minicontrole.
Adicionar controle expandido
A Lista de verificação de design do Google Cast exige que um app remetente forneça um controlador expandido para a mídia que está sendo transmitida. O controle expandido é uma versão em tela cheia do minicontrole.
O SDK do Cast fornece um widget para o controle expandido chamado
ExpandedControllerActivity.
Essa é uma classe abstrata que você precisa transformar em subclasse para adicionar um botão "Transmitir".
Primeiro, crie um novo arquivo de recurso de menu para o controle expandido para fornecer o botão Transmitir:
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item
android:id="@+id/media_route_menu_item"
android:title="@string/media_route_menu_title"
app:actionProviderClass="androidx.mediarouter.app.MediaRouteActionProvider"
app:showAsAction="always"/>
</menu>
Crie uma nova classe que estenda ExpandedControllerActivity.
class ExpandedControlsActivity : ExpandedControllerActivity() {
override fun onCreateOptionsMenu(menu: Menu): Boolean {
super.onCreateOptionsMenu(menu)
menuInflater.inflate(R.menu.expanded_controller, menu)
CastButtonFactory.setUpMediaRouteButton(this, menu, R.id.media_route_menu_item)
return true
}
}
public class ExpandedControlsActivity extends ExpandedControllerActivity {
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
getMenuInflater().inflate(R.menu.expanded_controller, menu);
CastButtonFactory.setUpMediaRouteButton(this, menu, R.id.media_route_menu_item);
return true;
}
}
Agora, declare a nova atividade no manifesto do app dentro da tag application:
<application>
...
<activity
android:name=".expandedcontrols.ExpandedControlsActivity"
android:label="@string/app_name"
android:launchMode="singleTask"
android:theme="@style/Theme.CastVideosDark"
android:screenOrientation="portrait"
android:parentActivityName="com.google.sample.cast.refplayer.VideoBrowserActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
</intent-filter>
</activity>
...
</application>
Edite o CastOptionsProvider e mude NotificationOptions e
CastMediaOptions para definir a atividade de destino como a nova atividade:
override fun getCastOptions(context: Context): CastOptions? {
val notificationOptions = NotificationOptions.Builder()
.setTargetActivityClassName(ExpandedControlsActivity::class.java.name)
.build()
val mediaOptions = CastMediaOptions.Builder()
.setNotificationOptions(notificationOptions)
.setExpandedControllerActivityClassName(ExpandedControlsActivity::class.java.name)
.build()
return CastOptions.Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.setCastMediaOptions(mediaOptions)
.build()
}
public CastOptions getCastOptions(Context context) {
NotificationOptions notificationOptions = new NotificationOptions.Builder()
.setTargetActivityClassName(ExpandedControlsActivity.class.getName())
.build();
CastMediaOptions mediaOptions = new CastMediaOptions.Builder()
.setNotificationOptions(notificationOptions)
.setExpandedControllerActivityClassName(ExpandedControlsActivity.class.getName())
.build();
return new CastOptions.Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.setCastMediaOptions(mediaOptions)
.build();
}
Atualize o método loadRemoteMedia do LocalPlayerActivity para exibir a
nova atividade quando a mídia remota for carregada:
private fun loadRemoteMedia(position: Int, autoPlay: Boolean) {
val remoteMediaClient = mCastSession?.remoteMediaClient ?: return
remoteMediaClient.registerCallback(object : RemoteMediaClient.Callback() {
override fun onStatusUpdated() {
val intent = Intent(this@LocalPlayerActivity, ExpandedControlsActivity::class.java)
startActivity(intent)
remoteMediaClient.unregisterCallback(this)
}
})
remoteMediaClient.load(
MediaLoadRequestData.Builder()
.setMediaInfo(mSelectedMedia)
.setAutoplay(autoPlay)
.setCurrentTime(position.toLong()).build()
)
}
private void loadRemoteMedia(int position, boolean autoPlay) {
if (mCastSession == null) {
return;
}
final RemoteMediaClient remoteMediaClient = mCastSession.getRemoteMediaClient();
if (remoteMediaClient == null) {
return;
}
remoteMediaClient.registerCallback(new RemoteMediaClient.Callback() {
@Override
public void onStatusUpdated() {
Intent intent = new Intent(LocalPlayerActivity.this, ExpandedControlsActivity.class);
startActivity(intent);
remoteMediaClient.unregisterCallback(this);
}
});
remoteMediaClient.load(new MediaLoadRequestData.Builder()
.setMediaInfo(mSelectedMedia)
.setAutoplay(autoPlay)
.setCurrentTime(position).build());
}
Quando o app remetente estiver reproduzindo uma transmissão ao vivo de vídeo ou áudio, o SDK exibe automaticamente um botão "Play/Stop" no lugar daquele no controle expandido.
Para definir a aparência usando temas, escolha quais botões serão exibidos e adicione botões personalizados, consulte Personalizar controle expandido.
Controle do volume
O framework gerencia automaticamente o volume do app remetente. Ele sincroniza automaticamente os apps do remetente e do receptor da Web para que a interface do remetente sempre informe o volume especificado por ele.
Controle de volume do botão físico
No Android, os botões físicos no dispositivo remetente podem ser usados para mudar o volume da sessão do Google Cast no receptor da Web por padrão em qualquer dispositivo que use o Jelly Bean ou uma versão mais recente.
Controle de volume do botão físico antes do Jelly Bean
Para usar as teclas de volume físicas a fim de controlar o volume do dispositivo receptor da Web em
dispositivos Android mais antigos que o Jelly Bean, o app remetente precisa substituir
dispatchKeyEvent
nas atividades e chamar
CastContext.onDispatchVolumeKeyEventBeforeJellyBean():
class MyActivity : FragmentActivity() {
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
return (CastContext.getSharedInstance(this)
.onDispatchVolumeKeyEventBeforeJellyBean(event)
|| super.dispatchKeyEvent(event))
}
}
class MyActivity extends FragmentActivity {
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
return CastContext.getSharedInstance(this)
.onDispatchVolumeKeyEventBeforeJellyBean(event)
|| super.dispatchKeyEvent(event);
}
}
Adicionar controles de mídia às notificações e à tela de bloqueio
Somente no Android, a Lista de verificação de design do Google Cast exige que um app remetente
implemente controles de mídia em uma
notificação
e na tela
de bloqueio,
em que o remetente está transmitindo, mas o app remetente não está em foco. O
framework oferece
MediaNotificationService
e
MediaIntentReceiver
para ajudar o app remetente a criar controles de mídia em uma notificação e na tela
de bloqueio.
O MediaNotificationService é executado quando o remetente está transmitindo e mostra uma
notificação com uma miniatura de imagem e informações sobre o item de transmissão
atual, além de um botão "Reproduzir/pausar" e "Parar".
MediaIntentReceiver é uma BroadcastReceiver que processa as ações do usuário na
notificação.
Seu app pode configurar notificações e controle de mídia na tela de bloqueio por meio de
NotificationOptions.
Seu app pode configurar quais botões de controle serão exibidos na notificação e
qual Activity será aberto quando o usuário tocar na notificação. Se as ações
não forem fornecidas explicitamente, os valores padrão
MediaIntentReceiver.ACTION_TOGGLE_PLAYBACK e
MediaIntentReceiver.ACTION_STOP_CASTING serão usados.
// Example showing 4 buttons: "rewind", "play/pause", "forward" and "stop casting".
val buttonActions: MutableList<String> = ArrayList()
buttonActions.add(MediaIntentReceiver.ACTION_REWIND)
buttonActions.add(MediaIntentReceiver.ACTION_TOGGLE_PLAYBACK)
buttonActions.add(MediaIntentReceiver.ACTION_FORWARD)
buttonActions.add(MediaIntentReceiver.ACTION_STOP_CASTING)
// Showing "play/pause" and "stop casting" in the compat view of the notification.
val compatButtonActionsIndices = intArrayOf(1, 3)
// Builds a notification with the above actions. Each tap on the "rewind" and "forward" buttons skips 30 seconds.
// Tapping on the notification opens an Activity with class VideoBrowserActivity.
val notificationOptions = NotificationOptions.Builder()
.setActions(buttonActions, compatButtonActionsIndices)
.setSkipStepMs(30 * DateUtils.SECOND_IN_MILLIS)
.setTargetActivityClassName(VideoBrowserActivity::class.java.name)
.build()
// Example showing 4 buttons: "rewind", "play/pause", "forward" and "stop casting".
List<String> buttonActions = new ArrayList<>();
buttonActions.add(MediaIntentReceiver.ACTION_REWIND);
buttonActions.add(MediaIntentReceiver.ACTION_TOGGLE_PLAYBACK);
buttonActions.add(MediaIntentReceiver.ACTION_FORWARD);
buttonActions.add(MediaIntentReceiver.ACTION_STOP_CASTING);
// Showing "play/pause" and "stop casting" in the compat view of the notification.
int[] compatButtonActionsIndices = new int[]{1, 3};
// Builds a notification with the above actions. Each tap on the "rewind" and "forward" buttons skips 30 seconds.
// Tapping on the notification opens an Activity with class VideoBrowserActivity.
NotificationOptions notificationOptions = new NotificationOptions.Builder()
.setActions(buttonActions, compatButtonActionsIndices)
.setSkipStepMs(30 * DateUtils.SECOND_IN_MILLIS)
.setTargetActivityClassName(VideoBrowserActivity.class.getName())
.build();
A exibição dos controles de mídia da notificação e da tela de bloqueio é ativada por
padrão e pode ser desativada chamando
setNotificationOptions
com nulo em
CastMediaOptions.Builder.
Atualmente, o recurso de tela de bloqueio fica ativado, desde que a notificação esteja
ativada.
// ... continue with the NotificationOptions built above
val mediaOptions = CastMediaOptions.Builder()
.setNotificationOptions(notificationOptions)
.build()
val castOptions: CastOptions = Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.setCastMediaOptions(mediaOptions)
.build()
// ... continue with the NotificationOptions built above
CastMediaOptions mediaOptions = new CastMediaOptions.Builder()
.setNotificationOptions(notificationOptions)
.build();
CastOptions castOptions = new CastOptions.Builder()
.setReceiverApplicationId(context.getString(R.string.app_id))
.setCastMediaOptions(mediaOptions)
.build();
Quando o app remetente está reproduzindo uma transmissão ao vivo de vídeo ou áudio, o SDK exibe automaticamente um botão "Reproduzir/Parar" no lugar do botão "Reproduzir/pausar" no controle de notificações, mas não no controle da tela de bloqueio.
Observação: para mostrar os controles da tela de bloqueio em dispositivos com versões anteriores ao Lollipop,
o RemoteMediaClient vai solicitar automaticamente a seleção de áudio em seu nome.
Solucionar erros
É muito importante que os apps remetentes processem todos os callbacks de erro e decidam a melhor resposta para cada estágio do ciclo de vida do Cast. O app pode exibir caixas de diálogo de erro ao usuário ou pode decidir encerrar a conexão com o Receptor da Web.