Ausgabeauswahl

Die Ausgabeauswahl ist eine Funktion des Cast SDK, mit der ab Android 13 nahtlos zwischen der lokalen und der Remote-Wiedergabe von Inhalten gewechselt werden kann. Ziel ist es, Sender-Apps die einfache und schnelle Steuerung der Wiedergabe von Inhalten zu ermöglichen. Die Ausgabeauswahl verwendet die MediaRouter-Bibliothek, um die Wiedergabe von Inhalten zwischen dem Lautsprecher des Smartphones, gekoppelten Bluetooth-Geräten und für Google Cast optimierten Remote-Geräten zu wechseln. Anwendungsfälle lassen sich in die folgenden Szenarien unterteilen:

• Lokal zu Remote
• Remote zu lokal
• Remote zu Remote

Laden Sie die CastVideos-Android-Beispiel-App herunter und verwenden Sie sie als Referenz für die Implementierung der Ausgabeauswahl in Ihrer 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. Für die Übertragung zwischen den Lautsprechern des lokalen Geräts und gekoppelten Bluetooth-Geräten sind keine zusätzlichen Schritte erforderlich.

UI der Ausgabeauswahl

In der Ausgabeauswahl werden die verfügbaren lokalen und Remote-Geräte sowie die aktuellen Gerätestatus angezeigt, z. B. ob das Gerät ausgewählt ist, ob eine Verbindung hergestellt wird und die aktuelle Lautstärke. Wenn neben dem aktuellen Gerät noch andere Geräte vorhanden sind, können Sie durch Klicken auf das andere Gerät die Medienwiedergabe auf das ausgewählte Gerät übertragen.

Bekannte Probleme

• Für die lokale Wiedergabe erstellte Mediensitzungen werden geschlossen und neu erstellt, wenn zur Cast SDK-Benachrichtigung gewechselt wird.

Einstiegspunkte

Medienbenachrichtigung

Wenn eine App eine Medienbenachrichtigung mit MediaSession für die lokale Wiedergabe (Wiedergabe lokal) postet, wird in der oberen rechten Ecke der Medienbenachrichtigung ein Benachrichtigungs-Chip mit dem Namen des Geräts (z. B. Lautsprecher des Smartphones) angezeigt, auf dem die Inhalte derzeit wiedergegeben werden. Wenn Sie auf den Benachrichtigungs-Chip tippen, wird die System-UI der Ausgabeauswahl geöffnet.

Lautstärkeeinstellungen

Die System-UI der Ausgabeauswahl kann auch ausgelöst werden, indem Sie auf die physischen Lautstärketasten auf dem Gerät klicken, unten auf das Symbol für die Einstellungen tippen und auf den Text „<App-Name> auf <Cast-Gerät> wiedergeben“ tippen.

Zusammenfassung der Schritte

• Voraussetzungen prüfen
• Ausgabeauswahl in AndroidManifest.xml aktivieren
• SessionManagerListener für Hintergrundübertragung 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. Aktualisieren Sie die Datei build.gradle Ihrer App, um die mindestens erforderliche Version des Android Sender SDK für die Ausgabeauswahl 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

Um die Ausgabeauswahl zu verwenden, Audio und Video-Apps müssen eine Medienbenachrichtigung erstellen, um den Wiedergabestatus und die Steuerelemente für ihre Medien für die lokale Wiedergabe anzuzeigen. Dazu müssen Sie eine MediaSession erstellen, MediaStyle mit dem MediaSession Token festlegen und die Mediensteuerelemente in der Benachrichtigung festlegen.

Wenn Sie derzeit keine MediaStyle und MediaSession verwenden, zeigt der folgende Code-Snippet, wie Sie sie einrichten. Außerdem finden Sie Anleitungen zum Einrichten der Media Session-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 müssen Sie der MediaSession die Metadaten und den Wiedergabestatus Ihrer Medien hinzufügen, um die Benachrichtigung mit den Informationen für Ihre Medien zu füllen.

Verwenden Sie setMetaData() , um der MediaSession Metadaten hinzuzufügen, und geben Sie alle relevanten MediaMetadata-Konstanten für Ihre Medien in der 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()
    );
}

Verwenden Sie setPlaybackState() , um der MediaSession den Wiedergabestatus hinzuzufügen, und geben Sie alle relevanten PlaybackStateCompat -Konstanten für Ihre Medien in der 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 die lokale Wiedergabe im Hintergrund nicht 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:

• Posten Sie die Medienbenachrichtigung, wenn Medien lokal wiedergegeben werden und die App im Vordergrund ausgeführt wird.
• Pausieren Sie die lokale Wiedergabe und schließen Sie die Benachrichtigung, wenn die App im Hintergrund ausgeführt wird.
• Wenn die App wieder in den Vordergrund wechselt, sollte die lokale Wiedergabe fortgesetzt und die Benachrichtigung neu gepostet werden.

Ausgabeauswahl in AndroidManifest.xml aktivieren

Um die Ausgabeauswahl zu aktivieren, muss der MediaTransferReceiver der Datei AndroidManifest.xml der App hinzugefügt werden. Andernfalls wird die Funktion nicht aktiviert und das Feature-Flag für die Übertragung von Remote zu lokal ist ebenfalls ungültig.

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

Der MediaTransferReceiver ist ein Broadcast-Receiver, der die Medienübertragung zwischen Geräten mit System UI ermöglicht. Weitere Informationen finden Sie in der MediaTransferReceiver Referenz.

Lokal zu Remote

Wenn der Nutzer die Wiedergabe von lokal zu Remote wechselt, startet das Cast SDK die Cast-Sitzung automatisch. Apps müssen jedoch den Wechsel von lokal zu Remote verarbeiten, z. B. die lokale Wiedergabe beenden und die Medien auf das Cast-Gerät laden. Apps sollten auf den Cast SessionManagerListener hören und die Callbacks onSessionStarted() und onSessionEnded() verwenden, um die Aktion zu verarbeiten, wenn sie die Cast SessionManager-Callbacks empfangen. Apps sollten dafür sorgen, dass diese Callbacks weiterhin aktiv sind, wenn das Dialogfeld der Ausgabeauswahl geöffnet wird und die App nicht im Vordergrund ausgeführt wird.

SessionManagerListener für Hintergrundübertragung aktualisieren

Achtung: Aufgrund des Lebenszyklus von Aktivitäten, wird empfohlen, dass Apps, die die Hintergrundwiedergabe unterstützen (Audio-Apps), einen Dienst anstelle einer Aktivität für SessionManagerListener Callbacks verwenden, um zu verhindern, dass erforderliche Callbacks abgemeldet werden, wenn eine Aktivität beendet wird.

Die bisherige Cast-Funktion unterstützt bereits die Übertragung von lokal zu Remote, wenn die App im Vordergrund ausgeführt wird. Eine typische Cast-Funktion beginnt, wenn Nutzer in der App auf das Cast-Symbol klicken und ein Gerät auswählen, um Medien zu streamen. In diesem Fall muss sich die App in onCreate() oder onStart() für den SessionManagerListener registrieren und den Listener in onStop() oder onDestroy() der Aktivität der App abmelden.

Mit der neuen Funktion zur Übertragung mit der Ausgabeauswahl können Apps die Übertragung starten, wenn sie im Hintergrund ausgeführt werden. Dies 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 abmelden. Apps sollten immer die Callbacks für die Übertragung von lokal zu Remote (z. B. onSessionStarted) empfangen, wenn die App im Hintergrund ausgeführt wird.

Wenn die App den 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 Übertragung von lokal zu Remote genauso wie die herkömmliche Übertragung, wenn die App im Hintergrund ausgeführt wird. Für den Wechsel von Bluetooth-Geräten zu Cast-Geräten ist keine zusätzliche Arbeit erforderlich.

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

Remote zu lokal

Die Ausgabeauswahl bietet die Möglichkeit, von der Remote-Wiedergabe zum Lautsprecher des Smartphones oder zu einem lokalen Bluetooth-Gerät zu wechseln. Sie können diese Funktion aktivieren, indem Sie das setRemoteToLocalEnabled Flag auf true in den CastOptionssetzen.

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 onTransferred Callback von SessionTransferCallback verwenden, um den SessionStatezu prüfen.

Flag „setRemoteToLocalEnabled“ festlegen

Der CastOptions.Builder bietet eine setRemoteToLocalEnabled-Funktion, mit der der Lautsprecher des Smartphones und lokale Bluetooth-Geräte als Ziele für die Übertragung im Dialogfeld der Ausgabeauswahl angezeigt oder ausgeblendet werden können, wenn eine aktive Cast-Sitzung vorhanden 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 lokal unterstützen, sollten den SessionTransferCallback registrieren, um benachrichtigt zu werden, wenn das Ereignis eintritt. So können sie prüfen, ob die Übertragung von Medien zulässig ist, und die Wiedergabe lokal fortsetzen.

CastContext#addSessionTransferCallback(SessionTransferCallback) ermöglicht einer App, ihren SessionTransferCallback zu registrieren und auf onTransferred und onTransferFailed Callbacks zu warten, wenn ein Sender zur lokalen Wiedergabe übertragen wird.

Nachdem die App die Registrierung ihres SessionTransferCallback, aufgehoben hat, empfängt sie keine SessionTransferCallback s mehr.

Der SessionTransferCallback ist eine Erweiterung der vorhandenen SessionManagerListener -Callbacks und wird ausgelöst, nachdem onSessionEnded ausgelöst wurde. Die Reihenfolge der Callbacks für die Übertragung von Remote zu lokal ist:

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

Da die Ausgabeauswahl über den Chip der Medienbenachrichtigung geöffnet werden kann, wenn die App im Hintergrund ausgeführt wird und Inhalte übertragen werden, müssen Apps die Übertragung zu lokal unterschiedlich verarbeiten, je nachdem, ob sie die Hintergrundwiedergabe unterstützen oder nicht. Bei einer fehlgeschlagenen Übertragung wird onTransferFailed immer dann ausgelöst, wenn der Fehler auftritt.

Apps, die die Hintergrundwiedergabe unterstützen

Für Apps, die die Wiedergabe im Hintergrund unterstützen (in der Regel Audio-Apps), wird empfohlen, einen Service (z. B. MediaBrowserService) zu verwenden. Dienste sollten auf den onTransferred Callback hören und die Wiedergabe lokal fortsetzen, sowohl wenn die App im Vordergrund als auch im Hintergrund ausgeführt wird.

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

Für Apps, die die Hintergrundwiedergabe nicht unterstützen (in der Regel Video-Apps), wird empfohlen, auf den onTransferred Callback zu hören und die Wiedergabe lokal fortzusetzen, wenn die App im Vordergrund ausgeführt wird.

Wenn die App im Hintergrund ausgeführt wird, sollte die Wiedergabe pausiert und die erforderlichen Informationen aus SessionState gespeichert werden (z. B. Metadaten und Wiedergabeposition). Wenn die App aus dem 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 Ausgabeauswahl unterstützt die Möglichkeit, die Wiedergabe mit der Stream-Ausweitung auf mehrere für Google Cast optimierte Lautsprechergeräte zu erweitern.

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

Stream-Ausweitung mit Lautsprechern

Wichtig: Obwohl die Remote-zu-Remote-Ausweitung mit Lautsprechern automatisch von der Cast-Plattform unterstützt wird, müssen Apps möglicherweise ihre UIs mit den Namen der Lautsprechergruppen aktualisieren. Apps sollten die Schritte unter Remote-zu-Remote testen ausführen, um sicherzustellen, dass ihre App ordnungsgemäß funktioniert.

Audio-Apps, die die Ausgabeauswahl verwenden, können die Audioausgabe während einer Cast-Sitzung mit der Stream-Ausweitung auf mehrere für Google Cast optimierte Lautsprechergeräte erweitern.

Diese Funktion wird von der Cast-Plattform unterstützt und erfordert keine weiteren Änderungen, wenn die Standard-UI verwendet wird. Wenn eine benutzerdefinierte UI verwendet wird, sollte die App die UI aktualisieren, um widerzuspiegeln, dass die App auf eine Gruppe überträgt.

Um den neuen erweiterten Gruppennamen während einer Stream-Ausweitung zu erhalten, registrieren Sie einen Cast.Listener mit 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 testen

So testen Sie die Funktion:

1. Übertragen Sie Ihre Inhalte mit der herkömmlichen Übertragung oder mit der Übertragung von lokal zu Remote auf ein für Google Cast optimiertes Gerät.
2. Öffnen Sie die Ausgabeauswahl über einen der Einstiegspunkte.
3. Tippen Sie auf ein anderes für Google Cast optimiertes Gerät. Audio-Apps erweitern die Inhalte auf das zusätzliche Gerät und erstellen eine dynamische Gruppe.
4. Tippen Sie noch einmal auf das für Google Cast optimierte Gerät. Es wird aus der dynamischen Gruppe entfernt.