Diese Seite wurde von der Cloud Translation API übersetzt.

Ausgabeauswahl

Die Funktion „Ausgabewähler“ ist eine Funktion des Cast SDK, die ab Android 13 einen nahtlosen Wechsel zwischen der lokalen und der Remote-Wiedergabe von Inhalten ermöglicht. Ziel ist es, Sender-Apps dabei zu unterstützen, schnell und einfach zu steuern, wo die Inhalte wiedergegeben werden. Der Output Switcher verwendet die MediaRouter-Bibliothek, um die Wiedergabe von Inhalten zwischen dem Smartphone-Lautsprecher, gekoppelten Bluetooth-Geräten und Remote-Geräten, die für Google Cast optimiert sind, zu wechseln. Anwendungsfälle lassen sich in die folgenden Szenarien unterteilen:

Lokal zu Remote
Remote-to-Local
Von Fernbedienung zu Fernbedienung

Laden Sie die CastVideos-android-Beispiel-App herunter und verwenden Sie sie als Referenz für die Implementierung des Output Switcher in Ihrer App.

Der Output Switcher muss aktiviert sein, um die Modi „Lokal zu Remote“, „Remote zu Lokal“ und „Remote zu Remote“ zu unterstützen. Folgen Sie dazu der Anleitung in diesem Artikel. 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.

Benutzeroberfläche der Ausgabeauswahl

In der Ausgabewahl werden die lokalen und Remote-Geräte angezeigt, die verfügbar sind, sowie die aktuellen Gerätestatus, z. B. ob das Gerät ausgewählt ist, ob es gerade eine Verbindung herstellt oder wie hoch die aktuelle Lautstärke ist. Wenn es neben dem aktuellen Gerät noch andere Geräte gibt, 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 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 auf dem Gerät) postet, wird in der oberen rechten Ecke der Medienbenachrichtigung ein Benachrichtigungs-Chip mit dem Gerätenamen (z. B. „Lautsprecher des Smartphones“) angezeigt, auf dem die Inhalte gerade wiedergegeben werden. Wenn Sie auf den Benachrichtigungs-Chip tippen, wird die System-UI des Dialogfelds „Ausgabeauswahl“ geöffnet.

Lautstärkeeinstellungen

Die System-UI des Dialogfelds „Ausgabewähler“ kann auch durch Klicken auf die physischen Lautstärketasten auf dem Gerät, durch Tippen auf das Symbol für die Einstellungen unten und durch Tippen auf den Text „[App-Name] auf [Cast-Gerät] wiedergeben“ aufgerufen werden.

Zusammenfassung der Schritte

Vorbereitung

Vorhandene Android-App zu AndroidX migrieren
Aktualisieren Sie das build.gradle Ihrer App, um die mindestens erforderliche Version des Android Sender SDK für den Output Switcher zu verwenden:
```
dependencies {
  ...
  implementation 'com.google.android.gms:play-services-cast-framework:21.2.0'
  ...
}
```
Die App unterstützt Medienbenachrichtigungen.
Gerät mit Android 13.

Medienbenachrichtigungen einrichten

Für die Ausgabewahl sind Audio- und Video-Apps erforderlich, um eine Medienbenachrichtigung zu erstellen, in der der Wiedergabestatus und die Steuerelemente für die Medien für die lokale Wiedergabe angezeigt werden. Dazu müssen Sie ein MediaSession erstellen, die MediaStyle mit dem Token von MediaSession festlegen und die Media-Steuerelemente in der Benachrichtigung festlegen.

Wenn Sie derzeit keine MediaStyle und MediaSession verwenden, sehen Sie im Snippet unten, wie Sie sie einrichten. Außerdem finden Sie Anleitungen zum Einrichten der Media-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();
}

Damit die Benachrichtigung mit den Informationen zu Ihren Medien gefüllt wird, müssen Sie außerdem die Metadaten und den Wiedergabestatus Ihrer Medien dem MediaSession hinzufügen.

Um Metadaten zum MediaSession hinzuzufügen, verwenden Sie setMetaData() und geben Sie alle relevanten MediaMetadata-Konstanten für Ihre Media 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 dem 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 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:

Die Medienbenachrichtigung wird gesendet, wenn Medien lokal wiedergegeben werden und die App im Vordergrund ausgeführt wird.
Die lokale Wiedergabe wird pausiert und die Benachrichtigung wird geschlossen, wenn sich die App im Hintergrund befindet.
Wenn die App wieder in den Vordergrund wechselt, sollte die lokale Wiedergabe fortgesetzt und die Benachrichtigung neu gesendet werden.

Ausgabeauswahl in AndroidManifest.xml aktivieren

Damit die Ausgangsauswahl aktiviert werden kann, muss der MediaTransferReceiver dem AndroidManifest.xml der App hinzugefügt werden. Andernfalls wird die Funktion nicht aktiviert und das Remote-to-Local-Funktionsflag ist ebenfalls ungültig.

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

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

Lokal zu Remote

Wenn der Nutzer die Wiedergabe von lokal auf remote umstellt, wird die Cast-Sitzung automatisch vom Cast SDK gestartet. Apps müssen jedoch den Wechsel von der lokalen zur Remote-Wiedergabe verarbeiten können, z. B. die lokale Wiedergabe beenden und die Medien auf das Cast-Gerät laden. Apps sollten mit den Callbacks onSessionStarted() und onSessionEnded() auf den Cast-SessionManagerListener warten und die Aktion verarbeiten, wenn die Cast-Callbacks SessionManager empfangen werden. Apps sollten dafür sorgen, dass diese Callbacks weiterhin aktiv sind, wenn das Dialogfeld „Ausgangsauswahl“ geöffnet wird und die App nicht im Vordergrund ausgeführt wird.

SessionManagerListener für das Übertragen im Hintergrund aktualisieren

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

Mit der neuen Funktion zum Übertragen über die Ausgabewahl können Apps die Übertragung starten, wenn sie im Hintergrund ausgeführt werden. Das ist besonders nützlich für Audio-Apps, die Benachrichtigungen senden, wenn sie im Hintergrund wiedergegeben werden. Apps können die Listener SessionManager im onCreate() des Dienstes registrieren und im 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, empfiehlt es sich, 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 funktioniert die lokale zu Remote-Übertragung genauso wie das herkömmliche Streaming, wenn sich die App im Hintergrund befindet. Außerdem ist kein zusätzlicher Aufwand erforderlich, um von Bluetooth-Geräten zu Cast-Geräten zu wechseln.

Remote-zu-lokal

Mit der Ausgangsauswahl können Sie die Wiedergabe von einem Remote-Gerät auf den Smartphone-Lautsprecher oder ein lokales Bluetooth-Gerät übertragen. Sie können diese Funktion aktivieren, indem Sie das Flag setRemoteToLocalEnabled auf true in der CastOptions setzen.

Wenn das aktuelle Absendergerät einer bestehenden Sitzung mit mehreren Absendern 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 SessionState zu prüfen.

Flag „setRemoteToLocalEnabled“ setzen

Die CastOptions.Builder bietet eine setRemoteToLocalEnabled, um den Smartphone-Lautsprecher und lokale Bluetooth-Geräte als Übertragungsziele im Dialogfeld „Ausgabe auswählen“ anzuzeigen oder auszublenden, 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 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 fortgesetzt werden soll.

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

Nachdem die App die Registrierung ihres SessionTransferCallback aufgehoben hat, erhält sie keine SessionTransferCallback mehr.

Der SessionTransferCallback ist eine Erweiterung der vorhandenen SessionManagerListener-Callbacks und wird nach dem Auslösen von onSessionEnded ausgelöst. Die Reihenfolge der Remote-to-Local-Callbacks ist:

onTransferring
onSessionEnding
onSessionEnded
onTransferred

Da die Ausgabewahl über den Media-Benachrichtigungs-Chip geöffnet werden kann, wenn die App im Hintergrund ausgeführt wird und Inhalte streamt, müssen Apps die Übertragung auf das lokale Gerät unterschiedlich handhaben, 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 die Verwendung von Service (z. B. MediaBrowserService) empfohlen. Dienste sollten auf den onTransferred-Callback reagieren und die Wiedergabe lokal fortsetzen, wenn die App im Vordergrund oder 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

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

Wenn sich die App im Hintergrund befindet, sollte die Wiedergabe pausiert und die erforderlichen Informationen aus SessionState (z. B. Medienmetadaten und Wiedergabeposition) gespeichert werden. Wenn die App aus dem Hintergrund in den Vordergrund geholt wird, 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-to-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 für Empfänger-Apps in der Google Cast SDK Developer Console unterstützen.

Stream-Ausweitung mit Lautsprechern

Audio-Apps, die den Output Switcher verwenden, können das Audio während einer Cast-Sitzung mithilfe der Stream-Erweiterung auf mehrere für Google Cast optimierte Lautsprechergeräte ausgeben.

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 aktualisieren, um anzuzeigen, dass die App auf eine Gruppe streamt.

Wenn Sie den neuen erweiterten Gruppennamen während einer Streamerweiterung abrufen möchten, registrieren Sie einen Cast.Listener mit CastSession#addCastListener. Rufen Sie dann CastSession#getCastDevice() während des onDeviceNameChanged-Callbacks 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-to-Remote-Tests

So testen Sie die Funktion:

Du kannst Inhalte über das herkömmliche Streaming oder über Local-to-Remote auf ein für Google Cast optimiertes Gerät streamen.
Öffnen Sie die Ausgabewahl über einen der Einstiegspunkte.
Tippe auf ein anderes für Google Cast optimiertes Gerät. Die Audio-Apps werden die Inhalte auf das zusätzliche Gerät ausweiten und so eine dynamische Gruppe erstellen.
Tippen Sie noch einmal auf das für Google Cast optimierte Gerät. Es wird aus der dynamischen Gruppe entfernt.

Zurück

Teilnahmeabsicht

Weiter

Zusätzliche Funktionen

Ausgabeauswahl Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Benutzeroberfläche der Ausgabeauswahl

Bekannte Probleme

Einstiegspunkte

Medienbenachrichtigung

Lautstärkeeinstellungen

Zusammenfassung der Schritte

Vorbereitung

Medienbenachrichtigungen einrichten

Benachrichtigungsverhalten von Video-Apps

Ausgabeauswahl in AndroidManifest.xml aktivieren

Lokal zu Remote

SessionManagerListener für das Übertragen im Hintergrund aktualisieren

Remote-zu-lokal

Flag „setRemoteToLocalEnabled“ setzen

Wiedergabe lokal fortsetzen

Apps, die die Hintergrundwiedergabe unterstützen

Apps, die die Hintergrundwiedergabe nicht unterstützen

Remote-to-Remote

Stream-Ausweitung mit Lautsprechern

Remote-to-Remote-Tests

Ausgabeauswahl