Seletor de saída

O Output Switcher é um recurso do SDK do Google Cast que permite a transferência perfeita entre a reprodução local e remota de conteúdo a partir do Android 13. O objetivo é ajudar os apps de envio a controlar de maneira fácil e rápida onde o conteúdo está sendo reproduzido. O Output Switcher usa a biblioteca MediaRouter para alternar a reprodução de conteúdo entre o alto-falante do smartphone, dispositivos Bluetooth pareados e dispositivos remotos com Google Cast. Os casos de uso podem ser divididos nos seguintes cenários:

• Local para remoto
• De remoto para local
• Remoto-remoto

Faça o download e use o app de exemplo CastVideos-android como referência para saber como implementar o Output Switcher no seu app.

Termo importante: neste guia, o termo local se refere a qualquer dispositivo Bluetooth pareado ou dispositivo móvel (como smartphones e tablets) em que o app está sendo iniciado, e o termo remoto se refere a qualquer dispositivo com suporte a transmissão.

O Output Switcher precisa estar ativado para oferecer suporte a conexões local-remota, remota-local e remota-remota usando as etapas descritas neste guia. Não há outras etapas necessárias para oferecer suporte à transferência entre os alto-falantes do dispositivo local e os dispositivos Bluetooth pareados.

Interface do seletor de saída

O Output Switcher mostra os dispositivos locais e remotos disponíveis e os estados atuais do dispositivo, incluindo se o dispositivo está selecionado, se está se conectando e o nível de volume atual. Se houver outros dispositivos além do atual, clique em "Outro dispositivo" para transferir a reprodução de mídia para o dispositivo selecionado.

Problemas conhecidos

• As sessões de mídia criadas para reprodução local serão dispensadas e recriadas ao mudar para a notificação do SDK do Cast.

Pontos de entrada

Notificação de mídia

Se um app postar uma notificação de mídia com MediaSession para reprodução local, o canto superior direito da notificação de mídia vai mostrar um ícone de notificação com o nome do dispositivo (como alto-falante do smartphone) em que o conteúdo está sendo reproduzido. Tocar no ícone de notificação abre a interface do sistema da caixa de diálogo do Output Switcher.

Configurações de volume

A interface do sistema de diálogo do Output Switcher também pode ser acionada clicando nos botões físicos de volume no dispositivo, tocando no ícone de configurações na parte de baixo e no texto "Play <App Name> on <Cast Device>".

Resumo das etapas

• Verifique se os pré-requisitos foram atendidos
• Ativar o seletor de saída no AndroidManifest.xml
• Atualização do SessionManagerListener para transmissão em segundo plano
• Adicionar suporte para a conexão remota
• Definir a flag setRemoteToLocalEnabled
• Continuar a reprodução localmente

Pré-requisitos

1. Migrar seu app Android atual para o AndroidX.
2. Atualize o build.gradle do app para usar a versão mínima necessária do SDK do remetente do Android para o seletor de saída:

   dependencies {
     ...
     implementation 'com.google.android.gms:play-services-cast-framework:21.2.0'
     ...
   }

3. O app oferece suporte a notificações de mídia.
4. Dispositivo com o Android 13.

Configurar notificações de mídia

Para usar o comutador de saída, os apps audio e video precisam criar uma notificação de mídia para mostrar o status de reprodução e os controles da mídia para reprodução local. Isso exige a criação de um MediaSession, a configuração do MediaStyle com o token de MediaSession e a configuração dos controles de mídia na notificação.

Se você não estiver usando um MediaStyle e um MediaSession, o snippet abaixo mostra como configurá-los. Também há guias disponíveis para configurar os callbacks de sessão de mídia para apps de áudio e vídeo:

KotlinJava

// Create a media session. NotificationCompat.MediaStyle
// PlayerService is your own Service or Activity responsible for media playback.
val mediaSession = MediaSessionCompat(this, "PlayerService")

// Create a MediaStyle object and supply your media session token to it.
val mediaStyle = Notification.MediaStyle().setMediaSession(mediaSession.sessionToken)

// Create a Notification which is styled by your MediaStyle object.
// This connects your media session to the media controls.
// Don't forget to include a small icon.
val notification = Notification.Builder(this@PlayerService, CHANNEL_ID)
    .setStyle(mediaStyle)
    .setSmallIcon(R.drawable.ic_app_logo)
    .build()

// Specify any actions which your users can perform, such as pausing and skipping to the next track.
val pauseAction: Notification.Action = Notification.Action.Builder(
        pauseIcon, "Pause", pauseIntent
    ).build()
notification.addAction(pauseAction)

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    // Create a media session. NotificationCompat.MediaStyle
    // PlayerService is your own Service or Activity responsible for media playback.
    MediaSession mediaSession = new MediaSession(this, "PlayerService");

    // Create a MediaStyle object and supply your media session token to it.
    Notification.MediaStyle mediaStyle = new Notification.MediaStyle().setMediaSession(mediaSession.getSessionToken());

    // Specify any actions which your users can perform, such as pausing and skipping to the next track.
    Notification.Action pauseAction = Notification.Action.Builder(pauseIcon, "Pause", pauseIntent).build();

    // Create a Notification which is styled by your MediaStyle object.
    // This connects your media session to the media controls.
    // Don't forget to include a small icon.
    String CHANNEL_ID = "CHANNEL_ID";
    Notification notification = new Notification.Builder(this, CHANNEL_ID)
        .setStyle(mediaStyle)
        .setSmallIcon(R.drawable.ic_app_logo)
        .addAction(pauseAction)
        .build();
}

Além disso, para preencher a notificação com as informações da mídia, é necessário adicionar os metadados e o estado de reprodução da mídia ao MediaSession.

Para adicionar metadados ao MediaSession, use setMetaData() e forneça todas as constantes MediaMetadata relevantes para sua mídia no MediaMetadataCompat.Builder().

KotlinJava

mediaSession.setMetadata(MediaMetadataCompat.Builder()
    // Title
    .putString(MediaMetadata.METADATA_KEY_TITLE, currentTrack.title)

    // Artist
    // Could also be the channel name or TV series.
    .putString(MediaMetadata.METADATA_KEY_ARTIST, currentTrack.artist)

    // Album art
    // Could also be a screenshot or hero image for video content
    // The URI scheme needs to be "content", "file", or "android.resource".
    .putString(
        MediaMetadata.METADATA_KEY_ALBUM_ART_URI, currentTrack.albumArtUri)
    )

    // Duration
    // If duration isn't set, such as for live broadcasts, then the progress
    // indicator won't be shown on the seekbar.
    .putLong(MediaMetadata.METADATA_KEY_DURATION, currentTrack.duration)

    .build()
)

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    mediaSession.setMetadata(
        new MediaMetadataCompat.Builder()
        // Title
        .putString(MediaMetadata.METADATA_KEY_TITLE, currentTrack.title)

        // Artist
        // Could also be the channel name or TV series.
        .putString(MediaMetadata.METADATA_KEY_ARTIST, currentTrack.artist)

        // Album art
        // Could also be a screenshot or hero image for video content
        // The URI scheme needs to be "content", "file", or "android.resource".
        .putString(MediaMetadata.METADATA_KEY_ALBUM_ART_URI, currentTrack.albumArtUri)

        // Duration
        // If duration isn't set, such as for live broadcasts, then the progress
        // indicator won't be shown on the seekbar.
        .putLong(MediaMetadata.METADATA_KEY_DURATION, currentTrack.duration)

        .build()
    );
}

Para adicionar o estado de reprodução ao MediaSession, use setPlaybackState() e forneça todas as constantes PlaybackStateCompat relevantes para a mídia no PlaybackStateCompat.Builder().

KotlinJava

mediaSession.setPlaybackState(
    PlaybackStateCompat.Builder()
        .setState(
            PlaybackStateCompat.STATE_PLAYING,

            // Playback position
            // Used to update the elapsed time and the progress bar.
            mediaPlayer.currentPosition.toLong(),

            // Playback speed
            // Determines the rate at which the elapsed time changes.
            playbackSpeed
        )

        // isSeekable
        // Adding the SEEK_TO action indicates that seeking is supported
        // and makes the seekbar position marker draggable. If this is not
        // supplied seek will be disabled but progress will still be shown.
        .setActions(PlaybackStateCompat.ACTION_SEEK_TO)
        .build()
)

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    mediaSession.setPlaybackState(
        new PlaybackStateCompat.Builder()
            .setState(
                 PlaybackStateCompat.STATE_PLAYING,

                // Playback position
                // Used to update the elapsed time and the progress bar.
                mediaPlayer.currentPosition.toLong(),

                // Playback speed
                // Determines the rate at which the elapsed time changes.
                playbackSpeed
            )

        // isSeekable
        // Adding the SEEK_TO action indicates that seeking is supported
        // and makes the seekbar position marker draggable. If this is not
        // supplied seek will be disabled but progress will still be shown.
        .setActions(PlaybackStateCompat.ACTION_SEEK_TO)
        .build()
    );
}

Comportamento da notificação do app de vídeo

Apps de vídeo ou áudio que não oferecem suporte à reprodução local em segundo plano precisam ter um comportamento específico para notificações de mídia para evitar problemas com o envio de comandos de mídia em situações em que a reprodução não é compatível:

• Publica a notificação de mídia ao abrir mídia localmente e o app está em primeiro plano.
• Pausar a reprodução local e dispensar a notificação quando o app estiver em segundo plano.
• Quando o app volta ao primeiro plano, a reprodução local é retomada e a notificação é repostada.

Ativar o seletor de saída no AndroidManifest.xml

Para ativar o seletor de saída, o MediaTransferReceiver precisa ser adicionado ao AndroidManifest.xml do app. Se não estiver, o recurso não será ativado e a flag de recurso remoto para local também será inválida.

<application>
    ...
    <receiver
         android:name="androidx.mediarouter.media.MediaTransferReceiver"
         android:exported="true">
    </receiver>
    ...
</application>

O MediaTransferReceiver é um broadcast receiver que permite a transferência de mídia entre dispositivos com a interface do sistema. Consulte a referência MediaTransferReceiver para mais informações.

Local para controle remoto

Quando o usuário alterna a reprodução do local para o remoto, o SDK do Google Cast inicia a sessão do Google Cast automaticamente. No entanto, os apps precisam processar a mudança de local para remoto, por exemplo, interromper a reprodução local e carregar a mídia no dispositivo de transmissão. Os apps precisam detectar o SessionManagerListener do Google Cast, usando os callbacks onSessionStarted() e onSessionEnded() e processar a ação ao receber os callbacks SessionManager do Google Cast. Os apps precisam garantir que esses callbacks ainda estejam ativos quando a caixa de diálogo do Output Switcher for aberta e o app não estiver em primeiro plano.

Atualização do SessionManagerListener para transmissão em segundo plano

Cuidado: devido ao ciclo de vida das atividades, recomenda-se que os apps que oferecem suporte à reprodução em segundo plano (apps de áudio) usem um serviço em vez de uma atividade para callbacks SessionManagerListener para evitar que os callbacks necessários sejam cancelados quando uma atividade é interrompida.

A experiência legada do Google Cast já oferece suporte a local-para-remoto quando o app está em primeiro plano. Uma experiência típica do Google Cast começa quando os usuários clicam no ícone do Google Cast no app e escolhem um dispositivo para transmitir mídia. Nesse caso, o app precisa se registrar no SessionManagerListener, em onCreate() ou onStart() e cancelar o registro do listener em onStop() ou onDestroy() da atividade do app.

Com a nova experiência de transmissão usando o comutador de saída, os apps podem começar a transmitir quando estão em segundo plano. Isso é especialmente útil para apps de áudio que postam notificações quando tocam em segundo plano. Os apps podem registrar os listeners SessionManager no onCreate() do serviço e cancelar o registro no onDestroy() do serviço. Os apps sempre precisam receber os callbacks locais para remotos (como onSessionStarted) quando estiverem em segundo plano.

Se o app usa o MediaBrowserService, é recomendável registrar o SessionManagerListener nele.

KotlinJava

class MyService : Service() {
    private var castContext: CastContext? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext
            .getSessionManager()
            .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext
                .getSessionManager()
                .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
        }
    }
}

public class MyService extends Service {
  private CastContext castContext;

  @Override
  protected void onCreate() {
     castContext = CastContext.getSharedInstance(this);
     castContext
        .getSessionManager()
        .addSessionManagerListener(sessionManagerListener, CastSession.class);
  }

  @Override
  protected void onDestroy() {
    if (castContext != null) {
       castContext
          .getSessionManager()
          .removeSessionManagerListener(sessionManagerListener, CastSession.class);
    }
  }
}

Com essa atualização, a transmissão local para remota funciona da mesma forma que a transmissão convencional quando o app está em segundo plano e não é necessário fazer mais nada para alternar entre dispositivos Bluetooth e dispositivos Cast.

Observação: para garantir uma transição suave do local para o remoto, é recomendável interromper a reprodução no dispositivo local durante o callback onSessionStarted, depois que o SDK do Cast se conectar ao receptor. Isso garante que a reprodução local seja interrompida somente depois de ser retomada no dispositivo remoto e ter problemas de tempo devido à latência.

Remoto para local

O seletor de saída permite transferir a reprodução remota para o alto-falante do smartphone ou o dispositivo Bluetooth local. Para ativar essa opção, defina a flag setRemoteToLocalEnabled como true no CastOptions.

Para casos em que o dispositivo de envio atual se junta a uma sessão com vários remetentes e o app precisa verificar se a mídia atual pode ser transferida localmente, os apps precisam usar o callback onTransferred do SessionTransferCallback para verificar o SessionState.

Definir a flag setRemoteToLocalEnabled

O CastOptions.Builder oferece um setRemoteToLocalEnabled para mostrar ou ocultar o alto-falante do smartphone e os dispositivos Bluetooth locais como alvos de transferência na caixa de diálogo do seletor de saída quando há uma sessão de transmissão ativa.

KotlinJava

class CastOptionsProvider : OptionsProvider {
    fun getCastOptions(context: Context?): CastOptions {
        ...
        return Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
    }
}

public class CastOptionsProvider implements OptionsProvider {
    @Override
    public CastOptions getCastOptions(Context context) {
        ...
        return new CastOptions.Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
  }
}

Continuar a reprodução localmente

Os apps que oferecem suporte à transferência remota para local precisam registrar o SessionTransferCallback para receber uma notificação quando o evento ocorrer. Assim, eles podem verificar se a mídia pode ser transferida e continuar a reprodução localmente.

CastContext#addSessionTransferCallback(SessionTransferCallback) permite que um app registre o SessionTransferCallback e ouça callbacks onTransferred e onTransferFailed quando um remetente é transferido para a reprodução local.

Depois que o app desregistrar o SessionTransferCallback, ele não vai mais receber SessionTransferCallback s.

O SessionTransferCallback é uma extensão dos callbacks SessionManagerListener existentes e é acionado após o onSessionEnded. A ordem dos callbacks remotos para locais é a seguinte:

1. onTransferring
2. onSessionEnding
3. onSessionEnded
4. onTransferred

Como o comutador de saída pode ser aberto pelo ícone de notificação de mídia quando o app está em segundo plano e transmitindo, os apps precisam processar a transferência para o local de forma diferente, dependendo se eles oferecem suporte à reprodução em segundo plano ou não. No caso de uma transferência com falha, o onTransferFailed será acionado sempre que o erro ocorrer.

Apps compatíveis com a reprodução em segundo plano

Para apps que oferecem suporte à reprodução em segundo plano (geralmente apps de áudio), é recomendado usar um Service (por exemplo, MediaBrowserService). Os serviços precisam detectar o callback onTransferred e retomar a reprodução localmente quando o app estiver em primeiro ou segundo plano.

KotlinJava

class MyService : Service() {
    private var castContext: CastContext? = null
    private var sessionTransferCallback: SessionTransferCallback? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
        sessionTransferCallback = MySessionTransferCallback()
        castContext.addSessionTransferCallback(sessionTransferCallback)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback)
            }
        }
    }

    class MySessionTransferCallback : SessionTransferCallback() {
        fun onTransferring(@SessionTransferCallback.TransferType transferType: Int) {
            // Perform necessary steps prior to onTransferred
        }

        fun onTransferred(@SessionTransferCallback.TransferType transferType: Int,
                          sessionState: SessionState?) {
            if (transferType == SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        fun onTransferFailed(@SessionTransferCallback.TransferType transferType: Int,
                             @SessionTransferCallback.TransferFailedReason transferFailedReason: Int) {
            // Handle transfer failure.
        }
    }
}

public class MyService extends Service {
    private CastContext castContext;
    private SessionTransferCallback sessionTransferCallback;

    @Override
    protected void onCreate() {
        castContext = CastContext.getSharedInstance(this);
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession.class);
        sessionTransferCallback = new MySessionTransferCallback();
        castContext.addSessionTransferCallback(sessionTransferCallback);
    }

    @Override
    protected void onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession.class);
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback);
            }
        }
    }

    public static class MySessionTransferCallback extends SessionTransferCallback {
        public MySessionTransferCallback() {}

        @Override
        public void onTransferring(@SessionTransferCallback.TransferType int transferType) {
            // Perform necessary steps prior to onTransferred
        }

        @Override
        public void onTransferred(@SessionTransferCallback.TransferType int transferType,
                                  SessionState sessionState) {
            if (transferType==SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        @Override
        public void onTransferFailed(@SessionTransferCallback.TransferType int transferType,
                                     @SessionTransferCallback.TransferFailedReason int transferFailedReason) {
            // Handle transfer failure.
        }
    }
}

Apps que não oferecem suporte à reprodução em segundo plano

Para apps que não oferecem suporte à reprodução em segundo plano (geralmente apps de vídeo), é recomendado detectar o callback onTransferred e retomar a reprodução localmente se o app estiver em primeiro plano.

Se o app estiver em segundo plano, ele vai pausar a reprodução e armazenar as informações necessárias de SessionState (por exemplo, metadados de mídia e posição de reprodução). Quando o app é exibido em primeiro plano, a reprodução local precisa continuar com as informações armazenadas.

KotlinJava

class MyActivity : AppCompatActivity() {
    private var castContext: CastContext? = null
    private var sessionTransferCallback: SessionTransferCallback? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
        sessionTransferCallback = MySessionTransferCallback()
        castContext.addSessionTransferCallback(sessionTransferCallback)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback)
            }
        }
    }

    class MySessionTransferCallback : SessionTransferCallback() {
        fun onTransferring(@SessionTransferCallback.TransferType transferType: Int) {
            // Perform necessary steps prior to onTransferred
        }

        fun onTransferred(@SessionTransferCallback.TransferType transferType: Int,
                          sessionState: SessionState?) {
            if (transferType == SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.

                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        fun onTransferFailed(@SessionTransferCallback.TransferType transferType: Int,
                             @SessionTransferCallback.TransferFailedReason transferFailedReason: Int) {
            // Handle transfer failure.
        }
    }
}

public class MyActivity extends AppCompatActivity {
  private CastContext castContext;
  private SessionTransferCallback sessionTransferCallback;

  @Override
  protected void onCreate() {
     castContext = CastContext.getSharedInstance(this);
     castContext
        .getSessionManager()
        .addSessionManagerListener(sessionManagerListener, CastSession.class);
     sessionTransferCallback = new MySessionTransferCallback();
     castContext.addSessionTransferCallback(sessionTransferCallback);
  }

  @Override
  protected void onDestroy() {
    if (castContext != null) {
       castContext
          .getSessionManager()
          .removeSessionManagerListener(sessionManagerListener, CastSession.class);
      if (sessionTransferCallback != null) {
         castContext.removeSessionTransferCallback(sessionTransferCallback);
      }
    }
  }

  public static class MySessionTransferCallback extends SessionTransferCallback {
    public MySessionTransferCallback() {}

    @Override
    public void onTransferring(@SessionTransferCallback.TransferType int transferType) {
        // Perform necessary steps prior to onTransferred
    }

    @Override
    public void onTransferred(@SessionTransferCallback.TransferType int transferType,
                               SessionState sessionState) {
      if (transferType==SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
        // Remote stream is transferred to the local device.

        // Retrieve information from the SessionState to continue playback on the local player.
      }
    }

    @Override
    public void onTransferFailed(@SessionTransferCallback.TransferType int transferType,
                                 @SessionTransferCallback.TransferFailedReason int transferFailedReason) {
      // Handle transfer failure.
    }
  }
}

Remoto para remoto

O seletor de saída oferece suporte à expansão para vários dispositivos de alto-falante com suporte a transmissão para apps de áudio que usam a expansão de stream.

Os apps de áudio são aqueles que oferecem suporte ao Google Cast para áudio nas configurações do app receptor no Play Console do SDK do Google Cast.

Expansão de stream com alto-falantes

Importante: embora a expansão de controle remoto para controle remoto com alto-falantes seja aceita automaticamente pela plataforma Cast, talvez seja necessário atualizar as interfaces dos apps com os nomes dos grupos de alto-falantes. Os apps precisam seguir as etapas de teste remoto-a-remoto para garantir que funcionem corretamente.

Os apps de áudio que usam o Output Switcher podem expandir o áudio para vários dispositivos de alto-falante compatíveis com o Google Cast durante uma sessão do Google Cast usando a expansão de stream.

Esse recurso tem suporte da plataforma Cast e não requer mais mudanças se o app estiver usando a interface padrão. Se uma interface personalizada for usada, o app precisa atualizar a interface para refletir que está transmitindo para um grupo.

Para receber o novo nome do grupo expandido durante uma expansão de transmissão, registre um Cast.Listener usando o CastSession#addCastListener. Em seguida, chame CastSession#getCastDevice() durante o callback onDeviceNameChanged.

KotlinJava

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 val mCastListener = CastListener()

    private inner class SessionManagerListenerImpl : SessionManagerListener<CastSession?> {
        override fun onSessionStarting(session: CastSession?) {}

        override fun onSessionStarted(session: CastSession?, sessionId: String) {
            addCastListener(session)
        }

        override fun onSessionStartFailed(session: CastSession?, error: Int) {}

        override fun onSessionSuspended(session: CastSession?, reason Int) {
            removeCastListener()
        }

        override fun onSessionResuming(session: CastSession?, sessionId: String) {}

        override fun onSessionResumed(session: CastSession?, wasSuspended: Boolean) {
            addCastListener(session)
        }

        override fun onSessionResumeFailed(session: CastSession?, error: Int) {}

        override fun onSessionEnding(session: CastSession?) {}

        override fun onSessionEnded(session: CastSession?, error: Int) {
            removeCastListener()
        }
    }

    private inner class CastListener : Cast.Listener() {
        override fun onDeviceNameChanged() {
            mCastSession?.let {
                val castDevice = it.castDevice
                val deviceName = castDevice.friendlyName
                // Update UIs with the new cast device name.
            }
        }
    }

    private fun addCastListener(castSession: CastSession) {
        mCastSession = castSession
        mCastSession?.addCastListener(mCastListener)
    }

    private fun removeCastListener() {
        mCastSession?.removeCastListener(mCastListener)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mCastContext = CastContext.getSharedInstance(this)
        mSessionManager = mCastContext.sessionManager
        mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession::class.java)
    }

    override fun onDestroy() {
        super.onDestroy()
        mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession::class.java)
    }
}

public class MyActivity extends Activity {
    private CastContext mCastContext;
    private CastSession mCastSession;
    private SessionManager mSessionManager;
    private SessionManagerListener<CastSession> mSessionManagerListener =
            new SessionManagerListenerImpl();
    private Cast.Listener mCastListener = new CastListener();

    private class SessionManagerListenerImpl implements SessionManagerListener<CastSession> {
        @Override
        public void onSessionStarting(CastSession session) {}
        @Override
        public void onSessionStarted(CastSession session, String sessionId) {
            addCastListener(session);
        }
        @Override
        public void onSessionStartFailed(CastSession session, int error) {}
        @Override
        public void onSessionSuspended(CastSession session, int reason) {
            removeCastListener();
        }
        @Override
        public void onSessionResuming(CastSession session, String sessionId) {}
        @Override
        public void onSessionResumed(CastSession session, boolean wasSuspended) {
            addCastListener(session);
        }
        @Override
        public void onSessionResumeFailed(CastSession session, int error) {}
        @Override
        public void onSessionEnding(CastSession session) {}
        @Override
        public void onSessionEnded(CastSession session, int error) {
            removeCastListener();
        }
    }

    private class CastListener extends Cast.Listener {
         @Override
         public void onDeviceNameChanged() {
             if (mCastSession == null) {
                 return;
             }
             CastDevice castDevice = mCastSession.getCastDevice();
             String deviceName = castDevice.getFriendlyName();
             // Update UIs with the new cast device name.
         }
    }

    private void addCastListener(CastSession castSession) {
        mCastSession = castSession;
        mCastSession.addCastListener(mCastListener);
    }

    private void removeCastListener() {
        if (mCastSession != null) {
            mCastSession.removeCastListener(mCastListener);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mCastContext = CastContext.getSharedInstance(this);
        mSessionManager = mCastContext.getSessionManager();
        mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession.class);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession.class);
    }
}

Teste remoto-a-remoto

Para testar o recurso:

1. Transmita seu conteúdo para um dispositivo compatível com o Google Cast usando a transmissão convencional ou local-para-remoto.
2. Abra o comutador de saída usando um dos pontos de entrada.
3. Toque em outro dispositivo compatível com o Google Cast. Os apps de áudio vão expandir o conteúdo para o dispositivo extra, criando um grupo dinâmico.
4. Toque novamente no dispositivo compatível com o Google Cast. Ele será removido do grupo dinâmico.