Seletor de saída

O seletor de saída é um recurso do SDK do Cast que permite transferências perfeitas entre a reprodução local e remota de conteúdo no Android 13 e versões mais recentes. Meta é ajudar os apps remetentes a controlar com facilidade e rapidez onde o conteúdo é reproduzido. O seletor de saída usa o Biblioteca MediaRouter para alternar a reprodução do conteúdo entre o alto-falante do smartphone, dispositivos Bluetooth pareados e dispositivos compatíveis com Cast. Os casos de uso podem ser divididos nas seguintes cenários:

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

.

Termo-chave :neste guia, o termo local refere-se a qualquer dispositivo Bluetooth pareado ou no dispositivo móvel (como smartphones e tablets) em que o app está sendo iniciado. o termo remoto refere-se a qualquer dispositivo compatível com Cast.

O switch de saída precisa ser ativado para oferecer suporte ao local para remoto e do remoto ao local e remoto para remoto usando as etapas abordadas neste guia. Não há etapas adicionais necessárias para permitir a transferência entre o dispositivo local alto-falantes e dispositivos Bluetooth pareados.

interface do seletor de saída

O seletor de saída mostra os dispositivos locais e remotos disponíveis além dos estados atuais do dispositivo, incluindo se ele está selecionado, está conectando: o nível de volume atual. Se houver outros dispositivos ao dispositivo atual. Clique em outro dispositivo para transferir a mídia a reprodução no 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 (reproduzindo localmente), o canto superior direito da notificação de mídia exibe um ícone de notificação com o nome do dispositivo (como alto-falante do smartphone) que em que o conteúdo está sendo reproduzido. Tocar no ícone de notificação abre a IU do sistema da caixa de diálogo do switch de saída.

Configurações de volume

A interface do sistema da caixa de diálogo do switch de saída também pode ser acionada ao clicar no botões de volume físicos do dispositivo, tocando no ícone de configurações na parte inferior e tocar no botão "Jogar <App Name> em <Dispositivo de transmissão>" em textos.

Resumo das etapas

• Verificar se os pré-requisitos foram atendidos
• Ativar o seletor de saída no AndroidManifest.xml
• Atualizar o SessionManagerListener para transmissão em segundo plano
• Adicionar suporte ao protocolo remoto
• Definir a flag setRemoteToLocalEnabled
• Continuar a reprodução localmente

Pré-requisitos

1. Migre seu app Android para o AndroidX.
2. Atualize a build.gradle do app para usar a versão mínima necessária do SDK do Android Sender 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 seletor de saída, audio e Apps de vídeo precisam criar uma notificação de mídia para exibir o status de reprodução e e controles de mídia para reprodução local. Isso requer a criação de um MediaSession, definindo MediaStyle com o token de MediaSession e definir os controles de mídia no notificação.

Se você não estiver usando MediaStyle e MediaSession, o snippet abaixo mostra como fazer a configuração e guias estão disponíveis para configurar a mídia callbacks de sessão para audio e vídeo aplicativos:

Kotlin

.

// 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)

Java

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 para sua mídia, você precisará adicionar metadados e estado de reprodução ao MediaSession.

Para adicionar metadados ao MediaSession, use setMetaData() e fornecer todas as informações Constantes MediaMetadata para sua mídia na MediaMetadataCompat.Builder().

Kotlin

.

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()
)

Java

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 à MediaSession, use setPlaybackState() e fornecer todas as informações PlaybackStateCompat constantes para sua mídia no PlaybackStateCompat.Builder().

Kotlin

.

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()
)

Java

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 de notificação de app de vídeo

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

• Postar a notificação de mídia quando a mídia estiver aberta localmente e o app estiver em primeiro plano.
• Pausar a reprodução local e dispensar a notificação quando o app estiver no plano de fundo.
• Quando o app voltar para o primeiro plano, a reprodução local será retomada e a notificação será postada de novo.

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á ativada e a sinalização de recurso remoto para local também será inválida.

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

A MediaTransferReceiver é um broadcast receiver que permite a transferência de mídia entre dispositivos com sistemas de ML pela UI. Consulte a documentação do MediaTransferReceiver Referência para mais informações.

Local para remoto

Quando o usuário alterna a reprodução do local para o remoto, o SDK do Cast é iniciado a sessão de transmissão automaticamente. No entanto, os apps precisam lidar com a mudança do local para o remoto. Por exemplo, interromper a reprodução local e carregue a mídia no dispositivo de transmissão. Os apps precisam ouvir a transmissão SessionManagerListener, usando o método onSessionStarted() e onSessionEnded() callbacks e processar a ação ao receber a transmissão SessionManager . Os apps precisam garantir que esses callbacks ainda estejam ativos quando a caixa de diálogo do seletor de saída é aberta e o app não está em primeiro plano.

Atualizar o SessionManagerListener para transmissão em segundo plano

Atenção: devido às ciclo de vida das atividades, aplicativos que oferecem suporte à reprodução em segundo plano (aplicativos de áudio) devem usar um em vez de uma atividade SessionManagerListener callbacks necessários para evitar que o registro dos callbacks necessários seja cancelado quando um atividade é interrompida.

A experiência legada do Google Cast já oferece suporte do local para o 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 Transmitir no app e escolha um dispositivo para fazer streaming de mídia. Nesse caso, o app precisa se registrar no SessionManagerListener, em onCreate() ou onStart() cancelar o registro do listener onStop() ou onDestroy() da atividade do app.

Com a nova experiência de transmissão usando o seletor de saída, os apps podem iniciar transmitindo quando estão em segundo plano. Isso é particularmente útil para áudios de apps que postam notificações durante a reprodução em segundo plano. Apps podem ser registrados SessionManager listeners no onCreate() do serviço e cancelar o registro na onDestroy() do serviço. Os aplicativos sempre devem receber os callbacks locais para remotos (como como onSessionStarted) quando o app está em segundo plano.

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

Kotlin

.

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)
        }
    }
}

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, o modo local para remoto atua da mesma forma que a transmissão convencional quando o app fica em segundo plano e não exige trabalho extra para mudar do Dispositivos Bluetooth para dispositivos de transmissão.

Observação :para garantir uma transição tranquila do local para o remoto, recomendamos Parar a reprodução no dispositivo local durante a onSessionStarted depois que o SDK do Cast for conectado ao receptor. Isso garante que a reprodução local seja interrompida somente depois que a reprodução for retomada em ao dispositivo remoto e tiver problemas de tempo devido à latência.

Remoto para local

O Output Switcher proporciona a capacidade de transferir da reprodução remota para o alto-falante do smartphone ou dispositivo Bluetooth local. Isso pode ser ativado definindo o setRemoteToLocalEnabled flag para true no CastOptions.

Nos casos em que o dispositivo remetente atual entra em uma sessão com vários remetentes e o app precisa verificar se a mídia atual tem permissão para são transferidos localmente, os apps devem usar o onTransferred callback 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 transferência para na caixa de diálogo do seletor de saída quando há uma sessão ativa de transmissão.

Kotlin

.

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

Java

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

Continuar a reprodução localmente

Apps que oferecem suporte ao modo remoto para local precisam registrar o SessionTransferCallback sejam notificados quando o evento ocorrer para que possam verificar se a mídia deve ser têm permissão para transferir e continuar a reprodução localmente.

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

Depois que o app cancelar o registro do SessionTransferCallback, o app não vai mais receber SessionTransferCallback s.

O SessionTransferCallback é uma extensão do SessionManagerListener existente e é acionado depois que onSessionEnded é acionado. A ordem de os callbacks remotos para o local são:

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

Como o seletor de saída pode ser aberto pelo ícone de notificação de mídia quando o está em segundo plano e transmitindo, os apps precisam lidar com a transferência para locais de maneira diferente, dependendo de eles oferecerem ou não suporte à reprodução em segundo plano. No caso de uma transferência com falha, onTransferFailed será disparado sempre que o erro ocorrer.

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

Para aplicativos com suporte para reprodução em segundo plano (geralmente aplicativos de áudio), é recomendado usar um Service (por exemplo, MediaBrowserService). Serviços você deve ouvir onTransferred e retome a reprodução localmente quando o app estiver em primeiro plano ou plano de fundo.

Kotlin

.

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.
        }
    }
}

Java

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 são compatíveis com a reprodução em segundo plano

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

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

Kotlin

.

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.
        }
    }
}

Java

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.
    }
  }
}

De remoto para remoto

O seletor de saída é compatível com a expansão para várias opções compatíveis com Cast alto-falantes para apps de áudio usando a expansão de stream.

Apps de áudio são apps compatíveis com o Google Cast para áudio no App receptor no SDK do Google Cast para desenvolvedores console

Expansão de stream com alto-falantes

Importante :embora a expansão do controle remoto para o remoto com alto-falantes seja compatível automaticamente pela plataforma do Google Cast, talvez os apps precisem atualizar as interfaces com o nomes de grupos de alto-falantes. Os apps precisam seguir as instruções em Como testar do controle remoto para o remoto para garantir que o app funcione corretamente.

Apps de áudio que usam o seletor de saída podem expandir o áudio para vários alto-falantes compatíveis com Cast durante uma sessão de transmissão usando o recurso "Transmitir" Expansão.

Este recurso é compatível com a plataforma de transmissão e não precisa mais de muda se o app estiver usando a interface padrão. Se uma IU personalizada for usada, o aplicativo precisa atualizar a IU para refletir que o app está transmitindo para um grupo.

Para receber o novo nome do grupo expandido durante uma expansão de stream, faça o seguinte: registrar um Cast.Listener usando o método CastSession#addCastListener Em seguida, chame CastSession#getCastDevice() durante o callback onDeviceNameChanged.

Kotlin

.

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)
    }
}

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);
    }
}

Como testar dispositivos remotos

Para testar o recurso:

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