Selettore di uscita

Output Switcher è una funzionalità dell'SDK Cast che consente il trasferimento senza interruzioni tra la riproduzione locale e quella remota dei contenuti a partire da Android 13. Lo scopo è aiutare le app di invio a controllare facilmente e rapidamente dove vengono riprodotti i contenuti. Il selettore di output utilizza MediaRouter libreria per alternare la riproduzione dei contenuti sull'altoparlante dello smartphone, sui dispositivi Bluetooth accoppiati e dispositivi remoti compatibili con Google Cast. I casi d'uso possono essere suddivisi in scenari aggiuntivi:

Scarica e utilizza l'app di esempio CastVideos-android come riferimento per implementare il selettore di output nella tua app.

Il selettore di output deve essere abilitato per supportare il trasferimento da locale a remoto e da remoto a locale e da remoto a remoto seguendo i passaggi descritti in questa guida. Non sono necessari passaggi aggiuntivi per supportare il trasferimento tra gli altoparlanti del dispositivo locale e i dispositivi Bluetooth accoppiati.

UI del selettore di output

Il selettore di output mostra i dispositivi locali e remoti disponibili nonché gli stati attuali dei dispositivi, ad esempio se il dispositivo è selezionato, è in corso di connessione e il livello di volume attuale. Se sono presenti altri dispositivi al dispositivo corrente, se fai clic su altro dispositivo puoi trasferire i contenuti multimediali la riproduzione sul dispositivo selezionato.

Problemi noti

  • Le sessioni multimediali create per la riproduzione locale verranno chiuse e ricreate quando si passa alla notifica dell'SDK Cast.

Entry point

Notifica multimediale

Se un'app pubblica una notifica di contenuti multimediali con MediaSession per riproduzione locale (riproduzione in locale), nell'angolo in alto a destra della notifica relativa ai contenuti multimediali mostra un chip di notifica con il nome del dispositivo (ad esempio l'altoparlante dello smartphone) che su cui sono attualmente riprodotti i contenuti. Si apre il tocco sul chip di notifica all'interfaccia utente di sistema del Selettore di output.

Impostazioni relative al volume

L'interfaccia utente di sistema del selettore di output può essere attivata anche facendo clic sul pulsanti fisici del volume del dispositivo, toccando l'icona delle impostazioni in basso e toccando il pulsante "Riproduci <nome app> su <dispositivo di trasmissione>" testo.

Riepilogo dei passaggi

Prerequisiti

  1. Esegui la migrazione della tua app per Android attuale ad AndroidX.
  2. Aggiorna il build.gradle dell'app per utilizzare la versione minima richiesta del SDK Android Sender per il selettore di output: 
    dependencies {
  ...
  implementation 'com.google.android.gms:play-services-cast-framework:21.2.0'
  ...
}
  3. L'app supporta le notifiche multimediali.
  4. Dispositivo con Android 13.

Configurare le notifiche per i contenuti multimediali

Per utilizzare il selettore di output, le app di contenuti audio e video devono creare una notifica multimediale per visualizzare lo stato di riproduzione e i controlli dei contenuti multimediali per la riproduzione locale. Ciò richiede la creazione di un MediaSession, l'impostazione MediaStyle con il token di MediaSession e impostando i controlli multimediali sulla notifica.

Se al momento non utilizzi MediaStyle e MediaSession, lo snippet di seguito mostra come configurarli e sono disponibili guide per la configurazione dei contenuti multimediali di sessione audio e video app:

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

Inoltre, per completare la notifica con le informazioni relative ai tuoi contenuti multimediali, dovrai aggiungere i tuoi contenuti multimediali metadati e stato di riproduzione in MediaSession.

Per aggiungere metadati a MediaSession, utilizza setMetaData() e fornire tutte le informazioni pertinenti MediaMetadata costanti per i tuoi contenuti multimediali 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()
    );
}

Per aggiungere lo stato di riproduzione a MediaSession, utilizza setPlaybackState() e fornisci tutte le costanti PlaybackStateCompat pertinenti per i tuoi contenuti multimediali in 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 delle notifiche dell'app video

Le app video o audio che non supportano la riproduzione locale in background devono avere un comportamento specifico per le notifiche multimediali per evitare problemi con l'invio di comandi multimediali in situazioni in cui la riproduzione non è supportata:

  • Pubblica la notifica multimediale quando riproduci contenuti multimediali localmente e l'app è in primo piano.
  • Metti in pausa la riproduzione locale e ignora la notifica quando l'app è in sfondo.
  • Quando l'app torna in primo piano, la riproduzione locale dovrebbe riprendere e la notifica dovrebbe essere inviata di nuovo.

Attiva il selettore di output in AndroidManifest.xml

Per attivare il selettore di output, MediaTransferReceiver deve essere aggiunto al AndroidManifest.xml dell'app. In caso contrario, la funzionalità e il flag di caratteristica remote-to-local non sarà abilitato.

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

La MediaTransferReceiver è un broadcast receiver che consente il trasferimento di contenuti multimediali tra dispositivi con sistema nell'interfaccia utente. Vedi il campo MediaTransferReceiver riferimento per ulteriori informazioni.

Da locale a remoto

Quando l'utente passa dalla riproduzione locale a quella remota, viene avviato l'SDK Cast. automaticamente la sessione di trasmissione. Tuttavia, le app devono gestire il passaggio da locale a remoto, ad esempio interrompe la riproduzione locale e carica i contenuti multimediali sul dispositivo di trasmissione. Le app devono ascoltare i contenuti SessionManagerListener, utilizzando onSessionStarted() e onSessionEnded() richiamate e gestire l'azione quando si riceve SessionManager i callback. Le app devono garantire che questi callback siano ancora attivi quando si apre la finestra di dialogo Selettore di output e l'app non è in primo piano.

Aggiornamento di SessionManagerListener per trasmissione in background

La versione precedente di Google Cast supporta già la trasmissione da locale a remoto quando l'app è in primo piano. Una tipica esperienza di trasmissione inizia quando gli utenti fanno clic sull'icona Trasmetti. nell'app e scegli un dispositivo su cui riprodurre in streaming contenuti multimediali. In questo caso, l'app deve registrarsi al servizio SessionManagerListener in onCreate() o onStart() e annullare la registrazione dell'ascoltatore in onStop() o onDestroy() dell'attività dell'app.

Con la nuova esperienza di trasmissione mediante il Selettore di output, le app possono iniziare trasmettere quando sono in background. Ciò è particolarmente utile per gli audio app che pubblicano notifiche quando vengono riprodotte in background. Le app possono registrarsi SessionManager listener nel onCreate() del servizio e annullare la registrazione in onDestroy() del servizio. Le app devono sempre ricevere i callback da locale a remoto (ad esempio come onSessionStarted) quando l'app è in background.

Se l'app utilizza MediaBrowserService, è consigliabile registrare il SessionManagerListener lì.

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

Con questo aggiornamento, la trasmissione locale a telecomando funziona allo stesso modo della trasmissione convenzionale quando sia in background e non è richiesto lavoro aggiuntivo per il passaggio da Dispositivi Bluetooth ai dispositivi di trasmissione.

Da remoto a locale

Il selettore di output consente di passare dalla riproduzione remota l'altoparlante del telefono o un dispositivo Bluetooth locale. Questa opzione può essere attivata impostando il setRemoteToLocalEnabled flag su true in CastOptions.

Nei casi in cui il dispositivo attuale del mittente si unisce a una sessione esistente con mittenti e l'app deve verificare se i contenuti multimediali attuali possono essere trasferiti localmente, le app devono utilizzare onTransferred callback del SessionTransferCallback per controllare SessionState.

Imposta il flag setRemoteToLocalEnabled

CastOptions.Builder fornisce un setRemoteToLocalEnabled per mostrare o nascondere lo speaker dello smartphone e i dispositivi Bluetooth locali come target di trasferimento nella finestra di dialogo Dispositivo di uscita quando è attiva una sessione di Trasmetti.

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

Continuare la riproduzione localmente

Le app che supportano remote-to-local devono registrare il file SessionTransferCallback di ricevere una notifica quando si verifica l'evento, in modo da poter controllare se i contenuti multimediali devono autorizzati a trasferire e continuare la riproduzione localmente.

CastContext#addSessionTransferCallback(SessionTransferCallback) consente a un'app di registrare la sua SessionTransferCallback e resta in ascolto dei callback onTransferred e onTransferFailed quando un mittente trasferiti alla riproduzione locale.

Dopo la registrazione dell'SessionTransferCallback, l'app non riceverà più SessionTransferCallback.

La SessionTransferCallback è un'estensione della classe SessionManagerListener esistente e viene attivato dopo l'attivazione di onSessionEnded. L'ordine di da remoto a locale è:

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

Poiché il selettore di output può essere aperto dal chip di notifica dei contenuti multimediali quando sia in background che sta trasmettendo, le app devono gestire il trasferimento in modo diverso a seconda che supportano o meno la riproduzione in background. Nel caso di un trasferimento non riuscito, onTransferFailed si attiverà in qualsiasi momento in cui si verifica l'errore.

App che supportano la riproduzione in background

Per le app che supportano la riproduzione in background (di solito le app audio), ti consigliamo di utilizzare Service (ad esempio MediaBrowserService). Servizi dovresti ascoltare onTransferred e riprendi la riproduzione localmente sia quando l'app è in primo piano sfondo.

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

App che non supportano la riproduzione in background

Per le app che non supportano la riproduzione in background (in genere le app video), è consigliabile ascoltare il callback onTransferred e riprendere la riproduzione localmente se l'app è in primo piano.

Se l'app è in background, la riproduzione deve essere messa in pausa e viene memorizzata le informazioni necessarie da SessionState (ad esempio, metadati dei contenuti multimediali e posizione di riproduzione). Quando l'app è in primo piano sullo sfondo, la riproduzione locale dovrebbe continuare con informazioni archiviate.

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

Da remoto a telecomando

Il selettore di output supporta la possibilità di espandersi a più dispositivi compatibili con Google Cast. altoparlanti per app audio che utilizzano l'espansione dello streaming.

Le app audio supportano Google Cast per l'audio nell'app ricevitore. impostazioni nelle impostazioni per gli sviluppatori dell'SDK Google Cast console

Espansione dello streaming con gli speaker

Le app audio che utilizzano il selettore di output hanno la possibilità di espandere l'audio a più altoparlanti compatibili con Google Cast durante una sessione di trasmissione utilizzando la funzionalità Stream Espansione.

Questa funzionalità è supportata dalla piattaforma Cast e non richiede ulteriori informazioni. cambia se l'app usa l'UI predefinita. Se si utilizza una UI personalizzata, l'app aggiorna la UI per indicare che l'app sta trasmettendo a un gruppo.

Per ottenere il nuovo nome del gruppo espanso durante un'espansione dello stream, registra un Cast.Listener utilizzando il CastSession#addCastListener. Quindi chiama CastSession#getCastDevice() durante il 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);
    }
}

Test da remoto a remoto in corso...

Per testare la funzionalità:

  1. Trasmetti i tuoi contenuti a un dispositivo compatibile con Google Cast utilizzando la trasmissione convenzionale o con da locale a remoto.
  2. Apri il selettore di output utilizzando uno dei punti di ingresso.
  3. Se tocchi un altro dispositivo compatibile con Google Cast, le app audio amplieranno i contenuti nell' dispositivo aggiuntivo, creando un gruppo dinamico.
  4. Tocca di nuovo il dispositivo compatibile con Google Cast; verrà rimosso dalla scheda dinamica. gruppo.
Indietro
Intenzione di partecipare
Avanti
Altre caratteristiche