Selettore di output

Il selettore di output è una funzionalità dell'SDK Cast che consente il trasferimento senza interruzioni tra la riproduzione locale e remota dei contenuti a partire da Android 13. L'obiettivo è aiutare le app mittente a controllare in modo semplice e rapido dove vengono riprodotti i contenuti. Il selettore di output utilizza la libreria MediaRouter per passare dalla riproduzione dei contenuti tra l'altoparlante dello smartphone, i dispositivi Bluetooth accoppiati e i dispositivi remoti compatibili con Google Cast. I casi d'uso possono essere suddivisi nei seguenti scenari:

• Da locale a remoto
• Da remoto a locale
• Da remoto a remoto

Scarica e utilizza l'app di esempio CastVideos-android come riferimento per l'implementazione del Selettore di output nella tua app.

Termine chiave: in questa guida, il termine locale si riferisce a qualsiasi dispositivo Bluetooth o dispositivo mobile accoppiato (come smartphone e tablet) su cui viene avviata l'app, mentre il termine remoto si riferisce a qualsiasi dispositivo compatibile con Google Cast.

Il Selettore di output deve essere attivato per supportare il passaggio da locale a remoto, da remoto a locale e da remoto a remoto seguendo i passaggi descritti in questa guida. Non sono necessari ulteriori passaggi per supportare il trasferimento tra gli speaker del dispositivo locale e i dispositivi Bluetooth accoppiati.

UI del selettore di output

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

Problemi noti

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

Entry point

Notifica dei contenuti multimediali

Se un'app pubblica una notifica multimediale con MediaSession per la riproduzione locale (riproduzione locale), nell'angolo in alto a destra della notifica multimediale viene visualizzato un chip di notifica con il nome del dispositivo (ad esempio l'altoparlante dello smartphone) su cui vengono attualmente riprodotti i contenuti. Toccando l'icona di notifica si apre la UI di sistema della finestra di dialogo del selettore di output.

Impostazioni relative al volume

La UI di sistema della finestra di dialogo del selettore di output può essere attivata anche facendo clic sui tasti del volume fisici sul dispositivo, toccando l'icona delle impostazioni in basso e toccando il testo "Riproduci <nome app> su <dispositivo di trasmissione>".

Riepilogo dei passaggi

• Assicurati che i prerequisiti siano soddisfatti
• Attiva il Selettore di output in AndroidManifest.xml
• Aggiorna SessionManagerListener per la trasmissione in background
• Aggiungi il supporto per Remote-to-Remote
• Imposta il flag setRemoteToLocalEnabled
• Continua la riproduzione localmente

Prerequisiti

1. Esegui la migrazione della tua app per Android esistente ad AndroidX.
2. Aggiorna il file build.gradle della tua app per utilizzare la versione minima richiesta dell'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.

Configura le notifiche dei contenuti multimediali

Per utilizzare il selettore di output, le app audio e video devono creare una notifica multimediale per mostrare lo stato di riproduzione e i controlli per i contenuti multimediali per la riproduzione locale. Per farlo, devi creare un MediaSession, impostare MediaStyle con il token di MediaSession e impostare i controlli multimediali nella notifica.

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

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 compilare la notifica con le informazioni relative ai tuoi contenuti multimediali, dovrai aggiungere i metadati e lo stato di riproduzione dei contenuti multimediali a MediaSession.

Per aggiungere metadati a MediaSession, utilizza setMetaData() e fornisci tutte le costanti MediaMetadata pertinenti per i tuoi contenuti multimediali in 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 delle app video

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

• Pubblica la notifica dei contenuti multimediali quando i contenuti vengono riprodotti localmente e l'app è in primo piano.
• Mettere in pausa la riproduzione locale e ignorare la notifica quando l'app è in background.
• Quando l'app torna in primo piano, la riproduzione locale dovrebbe riprendere e la notifica dovrebbe essere ripubblicata.

Attiva il Selettore di output in AndroidManifest.xml

Per attivare il selettore di output, è necessario aggiungere MediaTransferReceiver al file AndroidManifest.xml dell'app. In caso contrario, la funzionalità non verrà attivata e anche il flag di funzionalità da remoto a locale non sarà valido.

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

MediaTransferReceiver è un broadcast receiver che consente il trasferimento di contenuti multimediali tra dispositivi con l'UI di sistema. Per saperne di più, consulta il riferimento di MediaTransferReceiver.

Da locale a remoto

Quando l'utente passa dalla riproduzione locale a quella remota, l'SDK Cast avvia automaticamente la sessione di trasmissione. Tuttavia, le app devono gestire il passaggio dalla riproduzione locale a quella remota, ad esempio interrompendo la riproduzione locale e caricando i contenuti multimediali sul dispositivo di trasmissione. Le app devono ascoltare il comando Cast SessionManagerListener, utilizzando i callback onSessionStarted() e onSessionEnded(), e gestire l'azione quando ricevono i callback Cast SessionManager. Le app devono assicurarsi che questi callback siano ancora attivi quando la finestra di dialogo del selettore di output viene aperta e l'app non è in primo piano.

Aggiorna SessionManagerListener per la trasmissione in background

Attenzione: a causa del ciclo di vita delle attività, per le app che supportano la riproduzione in background (app audio) è consigliabile utilizzare un servizio anziché un'attività per i callback SessionManagerListener per evitare che i callback necessari vengano annullati quando un'attività viene interrotta.

L'esperienza di trasmissione precedente supporta già la transizione 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 scelgono un dispositivo per riprodurre in streaming i contenuti multimediali. In questo caso, l'app deve registrarsi al SessionManagerListener, in onCreate() o onStart() e annullare la registrazione del listener in onStop() o onDestroy() dell'attività dell'app.

Con la nuova esperienza di trasmissione tramite il selettore di output, le app possono avviare la trasmissione quando sono in background. Ciò è particolarmente utile per le app audio che pubblicano notifiche durante la riproduzione in background. Le app possono registrare i listener SessionManager in onCreate() del servizio e annullare la registrazione in onDestroy() del servizio. Le app devono sempre ricevere i callback da locale a remoto (come onSessionStarted) quando sono in background.

Se l'app utilizza MediaBrowserService, ti consigliamo di registrare 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 funzionalità da locale a remoto si comporta come la trasmissione convenzionale quando l'app è in background e non è necessario alcun lavoro aggiuntivo per passare dai dispositivi Bluetooth ai dispositivi di trasmissione.

Nota: Per garantire una transizione fluida dal locale al remoto, si consiglia di interrompere la riproduzione sul dispositivo locale duranteonSessionStarted callback, dopo che Cast SDK si è connesso correttamente al ricevitore. In questo modo, la riproduzione locale viene interrotta solo dopo che è stata ripresa sul dispositivo remoto e vengono evitati eventuali problemi di sincronizzazione dovuti alla latenza.

Da remoto a locale

Il selettore di output consente di trasferire la riproduzione remota allo speaker dello smartphone o al dispositivo Bluetooth locale. Puoi attivare questa funzionalità impostando il flag setRemoteToLocalEnabled su true in CastOptions.

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

Imposta il flag setRemoteToLocalEnabled

CastOptions.Builder fornisce un setRemoteToLocalEnabled per mostrare o nascondere l'altoparlante dello smartphone e i dispositivi Bluetooth locali come target di trasferimento nella finestra di dialogo del Selettore di output quando è attiva una sessione di trasmissione.

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

Continua la riproduzione localmente

Le app che supportano la funzionalità da remoto a locale devono registrare SessionTransferCallback per ricevere una notifica quando si verifica l'evento, in modo da poter verificare se i contenuti multimediali devono essere autorizzati a trasferire e continuare la riproduzione localmente.

CastContext#addSessionTransferCallback(SessionTransferCallback) consente a un'app di registrare il proprio SessionTransferCallback e di ascoltare i callback onTransferred e onTransferFailed quando un mittente viene trasferito alla riproduzione locale.

Dopo che l'app annulla la registrazione di SessionTransferCallback, non riceverà più SessionTransferCallback.

SessionTransferCallback è un'estensione dei callback SessionManagerListener esistenti e viene attivato dopo l'attivazione di onSessionEnded. L'ordine dei callback da remoto a locale è il seguente:

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

Poiché il selettore di output può essere aperto dal chip di notifica dei contenuti multimediali quando l'app è in background e trasmette, le app devono gestire il trasferimento alla riproduzione locale in modo diverso a seconda che supportino o meno la riproduzione in background. In caso di trasferimento non riuscito, onTransferFailed viene attivato ogni volta che si verifica l'errore.

App che supportano la riproduzione in background

Per le app che supportano la riproduzione in background (in genere app audio), è consigliabile utilizzare un Service (ad esempio MediaBrowserService). I servizi devono ascoltare il callback onTransferred e riprendere la riproduzione localmente sia quando l'app è in primo piano sia quando è in background.

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, deve mettere in pausa la riproduzione e archiviare le informazioni necessarie da SessionState (ad esempio, i metadati dei contenuti multimediali e la posizione di riproduzione). Quando l'app viene portata in primo piano dallo sfondo, la riproduzione locale deve continuare con le informazioni memorizzate.

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 remoto

Il selettore di output supporta la possibilità di espandere l'audio ad altri speaker compatibili con Google Cast per le app audio utilizzando l'espansione dello streaming.

Le app audio sono app che supportano Google Cast for Audio nelle impostazioni dell'app ricevitore in Google Cast SDK Developer Console

Espansione dello streaming con gli speaker

Importante: Sebbene l'espansione da remoto a remoto con altoparlanti sia supportata automaticamente dalla piattaforma Cast, le app potrebbero dover aggiornare le proprie interfacce utente con i nomi dei gruppi di altoparlanti. Le app devono seguire i passaggi descritti in Test della connessione da remoto a remoto per garantire il corretto funzionamento dell'app.

Le app audio che utilizzano il selettore di output hanno la possibilità di espandere l'audio a più speaker compatibili con Google Cast durante una sessione di trasmissione utilizzando l'espansione dello stream.

Questa funzionalità è supportata dalla piattaforma Cast e non richiede ulteriori modifiche se l'app utilizza la UI predefinita. Se viene utilizzata una UI personalizzata, l'app deve aggiornarla per indicare che sta trasmettendo a un gruppo.

Per ottenere il nuovo nome del gruppo espanso durante un'espansione dello stream, registra un Cast.Listener utilizzando CastSession#addCastListener. Poi 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

Per testare la funzionalità:

1. Trasmetti i tuoi contenuti a un dispositivo compatibile con Google Cast utilizzando la trasmissione convenzionale o con la funzionalità da locale a remoto.
2. Apri il selettore di output utilizzando uno dei punti di contatto.
3. Tocca un altro dispositivo compatibile con Google Cast. Le app audio espanderanno i contenuti al dispositivo aggiuntivo, creando un gruppo dinamico.
4. Tocca di nuovo il dispositivo compatibile con Google Cast per rimuoverlo dal gruppo dinamico.