Ausgabeauswahl

Der Ausgabe-Umschalter ist eine Funktion des Cast SDK, die ab Android 13 eine nahtlose Übertragung zwischen lokaler und Remote-Wiedergabe von Inhalten ermöglicht. Ziel ist es, dass Sender-Apps einfach und schnell steuern können, wo die Inhalte wiedergegeben werden. Die Ausgabewechsel-Funktion verwendet die MediaRouter-Bibliothek, um die Wiedergabe von Inhalten zwischen dem Smartphone-Lautsprecher, gekoppelten Bluetooth-Geräten und für Google Cast optimierten Remote-Geräten zu wechseln. Anwendungsfälle können in die folgenden Szenarien unterteilt werden:

• Lokal zu Remote
• Remote-zu-Lokal
• Remote-to-Remote

Lade die CastVideos-android-Beispiel-App herunter und verwende sie als Referenz für die Implementierung der Ausgabewechsel-Funktion in deiner App.

Wichtiger Begriff: In diesem Leitfaden bezieht sich der Begriff lokal auf alle gekoppelten Bluetooth-Geräte oder Mobilgeräte (z. B. Smartphones und Tablets), auf denen die App gestartet wird. Der Begriff remote bezieht sich auf alle für Google Cast optimierten Geräte.

Die Ausgabeauswahl sollte aktiviert sein, um die Übertragung von lokal zu remote, von remote zu lokal und von remote zu remote zu unterstützen. Folgen Sie dazu der Anleitung in diesem Leitfaden. Es sind keine zusätzlichen Schritte erforderlich, um die Übertragung zwischen den Lautsprechern des lokalen Geräts und gekoppelten Bluetooth-Geräten zu unterstützen.

Ausgabeauswahl-UI

In der Ausgabeauswahl werden die verfügbaren lokalen und Remote-Geräte sowie die aktuellen Gerätestatus angezeigt, einschließlich der Information, ob das Gerät ausgewählt ist, ob eine Verbindung hergestellt wird und wie hoch die aktuelle Lautstärke ist. Wenn neben dem aktuellen Gerät noch andere Geräte vorhanden sind, kannst du durch Klicken auf ein anderes Gerät die Medienwiedergabe auf das ausgewählte Gerät übertragen.

Bekannte Probleme

• Mediensitzungen, die für die lokale Wiedergabe erstellt wurden, werden beim Wechsel zur Cast SDK-Benachrichtigung verworfen und neu erstellt.

Einstiegspunkte

Medienbenachrichtigung

Wenn eine App eine Medienbenachrichtigung mit MediaSession für die lokale Wiedergabe (lokale Wiedergabe) postet, wird in der oberen rechten Ecke der Medienbenachrichtigung ein Benachrichtigungschip mit dem Gerätenamen (z. B. Smartphone-Lautsprecher) angezeigt, auf dem der Inhalt gerade wiedergegeben wird. Wenn du auf den Benachrichtigungs-Chip tippst, wird die System-UI für den Dialog „Ausgabeauswahl“ geöffnet.

Lautstärkeeinstellungen

Die System-UI des Dialogfelds für die Ausgabewechsel kann auch durch Klicken auf die physischen Lautstärketasten am Gerät, Tippen auf das Einstellungssymbol unten und Tippen auf den Text „<App-Name> auf <Übertragungsgerät> wiedergeben“ aufgerufen werden.

Zusammenfassung der Schritte

• Voraussetzungen erfüllen
• Ausgabeauswahl in AndroidManifest.xml aktivieren
• SessionManagerListener für das Streamen im Hintergrund aktualisieren
• Unterstützung für Remote-zu-Remote hinzufügen
• Flag „setRemoteToLocalEnabled“ festlegen
• Wiedergabe lokal fortsetzen

Vorbereitung

1. Migrieren Sie Ihre vorhandene Android-App zu AndroidX.
2. Aktualisiere die build.gradle deiner App, um die mindestens erforderliche Version des Android Sender SDK für die Ausgabewechsel-Funktion zu verwenden:

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

3. Die App unterstützt Medienbenachrichtigungen.
4. Gerät mit Android 13

Medienbenachrichtigungen einrichten

Damit die Ausgabeauswahl verwendet werden kann, müssen Audio- und Video-Apps eine Medienbenachrichtigung erstellen, um den Wiedergabestatus und die Steuerelemente für ihre Medien für die lokale Wiedergabe anzuzeigen. Dazu musst du eine MediaSession erstellen, die MediaStyle mit dem Token der MediaSession festlegen und die Mediensteuerung für die Benachrichtigung einrichten.

Wenn du derzeit keine MediaStyle und keine MediaSession verwendest, zeigt das Snippet unten, wie du sie einrichtest. Außerdem findest du Anleitungen zum Einrichten der Medien-Sitzungs-Callbacks für Audio- und Video-Apps:

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

Außerdem musst du die Metadaten und den Wiedergabestatus deiner Medien zum MediaSession hinzufügen, damit die Benachrichtigung mit den Informationen für deine Medien gefüllt wird.

Wenn du dem MediaSession Metadaten hinzufügen möchtest, verwende setMetaData() und gib alle relevanten MediaMetadata-Konstanten für deine Medien im MediaMetadataCompat.Builder() an.

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

Wenn du den Wiedergabestatus zum MediaSession hinzufügen möchtest, verwende setPlaybackState() und gib alle relevanten PlaybackStateCompat-Konstanten für deine Medien im PlaybackStateCompat.Builder() an.

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

Benachrichtigungsverhalten von Video-Apps

Video- oder Audio-Apps, die keine lokale Wiedergabe im Hintergrund unterstützen, sollten ein bestimmtes Verhalten für Medienbenachrichtigungen haben, um Probleme beim Senden von Medienbefehlen in Situationen zu vermeiden, in denen die Wiedergabe nicht unterstützt wird:

• Poste die Medienbenachrichtigung, wenn Medien lokal wiedergegeben werden und die App im Vordergrund ist.
• Pausieren Sie die lokale Wiedergabe und schließen Sie die Benachrichtigung, wenn sich die App im Hintergrund befindet.
• Wenn die App wieder in den Vordergrund wechselt, sollte die lokale Wiedergabe fortgesetzt und die Benachrichtigung noch einmal angezeigt werden.

Ausgabeauswahl in AndroidManifest.xml aktivieren

Damit die Ausgangsauswahl aktiviert werden kann, muss MediaTransferReceiver der AndroidManifest.xml der App hinzugefügt werden. Andernfalls wird die Funktion nicht aktiviert und das Funktions-Flag „remote-to-local“ ist ebenfalls ungültig.

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

Der MediaTransferReceiver ist ein Übertragungsempfänger, der die Medienübertragung zwischen Geräten mit System-UI ermöglicht. Weitere Informationen findest du in der Referenz zu MediaTransferReceiver.

Lokal zu Remote

Wenn der Nutzer die Wiedergabe von lokal auf remote umschaltet, startet das Cast SDK die Cast-Sitzung automatisch. Apps müssen jedoch den Wechsel von der lokalen zur Remote-Wiedergabe verarbeiten, z. B. die lokale Wiedergabe beenden und die Medien auf das Übertragungsgerät laden. Apps sollten auf den Cast-SessionManagerListener mit den Callbacks onSessionStarted() und onSessionEnded() warten und die Aktion verarbeiten, wenn sie die Cast-SessionManager-Callbacks erhalten. Apps sollten dafür sorgen, dass diese Callbacks noch aktiv sind, wenn das Dialogfeld für die Ausgangsauswahl geöffnet wird und die App nicht im Vordergrund ausgeführt wird.

SessionManagerListener für das Streamen im Hintergrund aktualisieren

Achtung : Aufgrund des Lebenszyklus von Aktivitäten wird für Apps, die die Hintergrundwiedergabe unterstützen (Audio-Apps), empfohlen, für SessionManagerListener-Callbacks einen Dienst anstelle einer Aktivität zu verwenden. So wird verhindert, dass die Registrierung erforderlicher Callbacks aufgehoben wird, wenn eine Aktivität beendet wird.

Die alte Cast-Version unterstützt bereits die Wiedergabe von lokalen Inhalten auf einem Remote-Gerät, wenn die App im Vordergrund ist. Eine typische Cast-Sitzung beginnt, wenn Nutzer in der App auf das Cast-Symbol klicken und ein Gerät zum Streamen von Medien auswählen. In diesem Fall muss die App in onCreate() oder onStart() beim SessionManagerListener registriert werden. Die Registrierung des Listeners muss in onStop() oder onDestroy() der Aktivität der App aufgehoben werden.

Mit der neuen Funktion zum Streamen über die Ausgabewechsel-Funktion können Apps das Streamen starten, wenn sie im Hintergrund ausgeführt werden. Das ist besonders nützlich für Audio-Apps, die Benachrichtigungen posten, wenn sie im Hintergrund wiedergegeben werden. Apps können die SessionManager-Listener in der onCreate() des Dienstes registrieren und in der onDestroy() des Dienstes die Registrierung aufheben. Apps sollten immer die Local-to-Remote-Callbacks (z. B. onSessionStarted) erhalten, wenn die App im Hintergrund ausgeführt wird.

Wenn die App die MediaBrowserService verwendet, wird empfohlen, die SessionManagerListener dort zu registrieren.

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

Mit diesem Update verhält sich die lokale Wiedergabe auf einem Remote-Gerät genauso wie das herkömmliche Streamen, wenn die App im Hintergrund ausgeführt wird. Es ist kein zusätzlicher Aufwand erforderlich, um von Bluetooth-Geräten zu Cast-Geräten zu wechseln.

Hinweis: Damit der Übergang von der lokalen zur Remote-Wiedergabe reibungslos verläuft, wird empfohlen, die Wiedergabe auf dem lokalen Gerät während des Callbacks onSessionStarted zu beenden, nachdem das Cast SDK erfolgreich eine Verbindung zum Empfänger hergestellt hat. So wird sichergestellt, dass die lokale Wiedergabe erst beendet wird, wenn die Wiedergabe auf dem Remote-Gerät fortgesetzt wurde, und dass es keine Timing-Probleme aufgrund von Latenz gibt.

Remote-zu-lokal

Mit der Ausgangsauswahl kannst du von der Remote-Wiedergabe zum Smartphone-Lautsprecher oder lokalen Bluetooth-Gerät wechseln. Dies kann aktiviert werden, indem das Flag setRemoteToLocalEnabled in der CastOptions auf true gesetzt wird.

Wenn das aktuelle Sendergerät einer vorhandenen Sitzung mit mehreren Sendern beitritt und die App prüfen muss, ob die aktuellen Medien lokal übertragen werden dürfen, sollten Apps den Callback onTransferred von SessionTransferCallback verwenden, um SessionState zu prüfen.

Flag „setRemoteToLocalEnabled“ festlegen

Die CastOptions.Builder bietet eine setRemoteToLocalEnabled, mit der der Smartphone-Lautsprecher und lokale Bluetooth-Geräte als Übertragungsziele im Dialogfeld „Ausgabewechsel“ ein- oder ausgeblendet werden können, wenn eine Übertragungssitzung aktiv ist.

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

Wiedergabe lokal fortsetzen

Apps, die die Übertragung von Remote- zu lokalen Geräten unterstützen, sollten SessionTransferCallback registrieren, um benachrichtigt zu werden, wenn das Ereignis eintritt. So können sie prüfen, ob die Medien übertragen und lokal wiedergegeben werden dürfen.

Mit CastContext#addSessionTransferCallback(SessionTransferCallback) kann eine App ihren SessionTransferCallback registrieren und auf onTransferred- und onTransferFailed-Callbacks warten, wenn ein Sender zur lokalen Wiedergabe übertragen wird.

Nachdem die App die Registrierung ihrer SessionTransferCallback aufgehoben hat, empfängt sie keine SessionTransferCallbacks mehr.

SessionTransferCallback ist eine Erweiterung der vorhandenen SessionManagerListener-Callbacks und wird nach onSessionEnded ausgelöst. Die Reihenfolge der Remote-zu-Lokal-Callbacks ist:

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

Da die Ausgabeauswahl über den Chip für Medienbenachrichtigungen geöffnet werden kann, wenn die App im Hintergrund ausgeführt wird und Inhalte streamt, müssen Apps die Übertragung auf die lokale Wiedergabe unterschiedlich handhaben, je nachdem, ob sie die Hintergrundwiedergabe unterstützen oder nicht. Im Falle einer fehlgeschlagenen Übertragung wird onTransferFailed ausgelöst, wenn der Fehler auftritt.

Apps, die die Hintergrundwiedergabe unterstützen

Für Apps, die die Wiedergabe im Hintergrund unterstützen (normalerweise Audio-Apps), wird empfohlen, einen Service (z. B. MediaBrowserService) zu verwenden. Dienste sollten auf den Callback onTransferred warten und die Wiedergabe lokal fortsetzen, sowohl wenn sich die App im Vordergrund als auch im Hintergrund befindet.

Kotlin

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

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

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

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

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

Java

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

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

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

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

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

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

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

Apps, die die Hintergrundwiedergabe nicht unterstützen

Bei Apps, die die Hintergrundwiedergabe nicht unterstützen (in der Regel Video-Apps), wird empfohlen, auf den Callback onTransferred zu warten und die Wiedergabe lokal fortzusetzen, wenn sich die App im Vordergrund befindet.

Wenn sich die App im Hintergrund befindet, sollte sie die Wiedergabe pausieren und die erforderlichen Informationen aus SessionState speichern, z. B. Medienmetadaten und Wiedergabeposition. Wenn die App vom Hintergrund in den Vordergrund wechselt, sollte die lokale Wiedergabe mit den gespeicherten Informationen fortgesetzt werden.

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

Remote-zu-Remote

Die Ausgangsauswahl unterstützt die Möglichkeit, die Wiedergabe von Audio-Apps mithilfe der Stream-Ausweitung auf mehrere für Google Cast optimierte Lautsprechergeräte auszuweiten.

Audio-Apps sind Apps, die Google Cast for Audio in den Einstellungen der Empfänger-App in der Google Cast SDK Developer Console unterstützen.

Stream-Ausweitung mit Lautsprechern

Wichtig: Die Erweiterung von Remote-zu-Remote mit Lautsprechern wird zwar automatisch von der Cast-Plattform unterstützt, aber die Benutzeroberflächen von Apps müssen möglicherweise mit den Namen der Lautsprechergruppen aktualisiert werden. Apps sollten die Schritte unter Remote-zu-Remote-Tests befolgen, um sicherzustellen, dass sie ordnungsgemäß funktionieren.

Audio-Apps, die die Ausgabewechsel-Funktion verwenden, können die Audiowiedergabe während einer Cast-Sitzung mithilfe der Stream-Erweiterung auf mehrere für Google Cast optimierte Lautsprechergeräte ausweiten.

Diese Funktion wird von der Cast-Plattform unterstützt und erfordert keine weiteren Änderungen, wenn die App die Standard-UI verwendet. Wenn eine benutzerdefinierte Benutzeroberfläche verwendet wird, sollte die App die Benutzeroberfläche so aktualisieren, dass angezeigt wird, dass die App auf eine Gruppe streamt.

Wenn du den neuen erweiterten Gruppennamen während einer Stream-Erweiterung abrufen möchtest, registriere einen Cast.Listener mit dem CastSession#addCastListener. Rufen Sie dann während des onDeviceNameChanged-Callbacks CastSession#getCastDevice() auf.

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

Remote-zu-Remote-Tests

So testen Sie die Funktion:

1. Du kannst deine Inhalte über herkömmliches Streaming oder mit Local-to-Remote auf ein für Google Cast optimiertes Gerät streamen.
2. Öffne die Ausgabeauswahl über einen der Einstiegspunkte.
3. Tippe auf ein anderes für Google Cast optimiertes Gerät. Die Audio-Apps erweitern die Wiedergabe auf das zusätzliche Gerät und erstellen eine dynamische Gruppe.
4. Tippe noch einmal auf das für Google Cast optimierte Gerät, um es aus der dynamischen Gruppe zu entfernen.