Selettore di uscita

Selettore di output è 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. L'obiettivo è aiutare le app dei mittenti 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:

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

Scarica e utilizza l'app di esempio per Android CastVideo. per informazioni su come implementare il selettore di output nella tua app.

Termine chiave: in questa guida, il termine locale si riferisce a qualsiasi dispositivo Bluetooth accoppiato o dispositivo mobile (ad esempio smartphone e tablet) su cui viene lanciata l'app; e il termine telecomando si riferisce a qualsiasi dispositivo compatibile con Google Cast.

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 presenti ulteriori passaggi necessari per supportare il trasferimento tra il dispositivo locale altoparlanti e dispositivi Bluetooth accoppiati.

UI del selettore di output

Il selettore di output visualizza i dispositivi locali e remoti disponibili e sugli stati correnti del dispositivo, ad esempio se il dispositivo è selezionato, è in corso la connessione, 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 ignorate e ricreate. quando passi 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

• Assicurarsi che i prerequisiti siano soddisfatti
• Abilita il selettore di output in AndroidManifest.xml
• Aggiornare SessionManagerListener per la trasmissione in background
• Aggiungere il supporto della funzionalità Da remoto a remoto
• Impostare il flag setRemoteToLocalEnabled
• Continuare la riproduzione localmente

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, audio e app video per creare una notifica per i contenuti multimediali per visualizzare lo stato della riproduzione e controlli 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, usa setPlaybackState() e fornire tutte le informazioni pertinenti PlaybackStateCompat costanti per i tuoi contenuti multimediali 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

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

• Pubblica la notifica dei contenuti multimediali quando riproduci contenuti multimediali localmente e l'app è in 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, dovrebbe riprendere la riproduzione locale. la notifica deve essere ripubblicata.

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

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

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 registrati nel SessionManagerListener, tra onCreate() o onStart() e annulla la registrazione del listener 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, si consiglia di 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.

Nota: per garantire una transizione senza problemi dalla gestione locale a quella remota, è consigliabile interrompere la riproduzione sul dispositivo locale durante la onSessionStarted dopo che l'SDK Cast si è connesso al ricevitore. Questo assicura che la riproduzione locale venga interrotta solo dopo la ripresa della riproduzione il dispositivo remoto e avere problemi di tempistica dovuti alla latenza.

Da remoto a locale

Il selettore di output consente di passare dalla riproduzione remota l'altoparlante del telefono o un dispositivo Bluetooth locale. Questa operazione può essere abilitata impostando setRemoteToLocalEnabled per 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

La CastOptions.Builder fornisce un setRemoteToLocalEnabled per mostrare o nascondere l'altoparlante del telefono e i dispositivi Bluetooth locali durante il trasferimento target nella finestra di dialogo 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 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 che l'app ha annullato la registrazione del relativo 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 (di solito le app video), ha consigliato di ascoltare onTransferred e riprendi 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

Importante: nonostante sia supportata l'espansione da remoto a remoto con altoparlanti automaticamente dalla piattaforma Cast, le app potrebbero dover aggiornare le relative UI con i nomi dei gruppi di speaker. Le app devono seguire le istruzioni riportate nell'articolo Test da remoto a remoto per assicurarsi che l'app funzioni correttamente.

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 nome del nuovo gruppo espanso durante un'espansione dello streaming: registra un Cast.Listener utilizzando 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.