Ausgabeschalter

Der Ausgabeschalter ist eine Funktion des Cast SDK, die ab Android 13 eine nahtlose Übertragung zwischen der lokalen und der Remote-Wiedergabe von Inhalten ermöglicht. Ziel ist es, Sender-Apps dabei zu helfen, schnell und einfach festzulegen, wo die Inhalte wiedergegeben werden. Der Ausgabe-Schalter verwendet die MediaRouter-Mediathek, um die Wiedergabe von Inhalten zwischen dem Lautsprecher des Smartphones, gekoppelten Bluetooth-Geräten und Remote-Geräten mit Cast-Funktion zu wechseln. Anwendungsfälle können in die folgenden Szenarien unterteilt werden:

• Lokales Gerät zu Remote-Gerät
• Remote-zu-lokal
• Remote-zu-Remote

Laden Sie die Beispiel-App „CastVideos-android“ herunter und verwenden Sie sie als Referenz, um den Ausgabeschalter in Ihrer App zu implementieren.

Schlüsselbegriff :In diesem Leitfaden bezieht sich der Begriff lokal auf jedes gekoppelte Bluetooth-Gerät oder Mobilgerät (z. B. Smartphones und Tablets), auf dem die App gestartet wird. Der Begriff Remote bezieht sich auf jedes Cast-fähige Gerät.

Der Output-Schalter 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.

Benutzeroberfläche der Ausgabeauswahl

In der Ausgabeumschalter werden die verfügbaren lokalen und Remote-Geräte sowie die aktuellen Gerätestatus angezeigt, z. B. ob das Gerät ausgewählt ist, eine Verbindung herstellt oder die aktuelle Lautstärke. Wenn Sie zusätzlich zum aktuellen Gerät noch andere Geräte haben, können Sie die Medienwiedergabe auf das ausgewählte Gerät übertragen, indem Sie auf „Anderes Gerät“ klicken.

Bekannte Probleme

• Mediensitzungen, die für die lokale Wiedergabe erstellt wurden, werden geschlossen und neu erstellt, wenn zur Benachrichtigung des Cast SDK gewechselt wird.

Einstiegspunkte

Medienbenachrichtigung

Wenn eine App eine Medienbenachrichtigung mit MediaSession für die lokale Wiedergabe sendet, wird rechts oben in der Medienbenachrichtigung ein Benachrichtigungs-Chip mit dem Namen des Geräts angezeigt (z. B. „Lautsprecher des Smartphones“), auf dem die Inhalte gerade wiedergegeben werden. Wenn Sie auf den Benachrichtigungs-Chip tippen, wird die Benutzeroberfläche des Dialogfelds „Output switcher“ geöffnet.

Lautstärkeeinstellungen

Die Benutzeroberfläche des Dialogfelds für die Ausgabe kann auch durch Klicken auf die physischen Lautstärketasten auf dem Gerät, Tippen auf das Einstellungssymbol unten und Tippen auf den Text „<App-Name> auf <Streaminggerät> wiedergeben“ ausgelöst werden.

Zusammenfassung der Schritte

• Voraussetzungen prüfen
• Ausgabeauswahl in AndroidManifest.xml aktivieren
• SessionManagerListener für die Hintergrundübertragung aktualisieren
• Unterstützung für Remote-zu-Remote-Verbindungen 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, damit die für den Ausgabeschalter erforderliche Mindestversion des Android Sender SDK verwendet wird:

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

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

Medienbenachrichtigungen einrichten

Wenn Sie den Ausgabeschalter verwenden möchten, müssen Audio- und Video-Apps eine Medienbenachrichtigung erstellen, um den Wiedergabestatus und die Steuerelemente für die Medien für die lokale Wiedergabe anzuzeigen. Dazu musst du ein MediaSession erstellen, das MediaStyle mit dem Token von MediaSession festlegen und die Mediensteuerungen in der Benachrichtigung festlegen.

Wenn Sie derzeit keine MediaStyle und MediaSession verwenden, zeigt das folgende Snippet, wie Sie sie einrichten. Außerdem sind Anleitungen zum Einrichten der Media-Sitzungs-Callbacks für Audio- und Video-Apps verfügbar:

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 die Informationen zu deinen Medien enthält, musst du der MediaSession außerdem die Metadaten und den Wiedergabestatus deiner Medien hinzufügen.

Wenn du MediaSession Metadaten hinzufügen möchtest, verwende setMetaData() und gib alle relevanten MediaMetadata-Konstanten für deine Medien in 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 der MediaSession hinzufügen möchtest, verwende setPlaybackState() und gib alle relevanten Konstanten für deine Medien in PlaybackStateCompat.Builder() an.PlaybackStateCompat

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

Verhalten von Benachrichtigungen 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.
• Pausiere die lokale Wiedergabe und schließe die Benachrichtigung, wenn die App im Hintergrund läuft.
• Wenn die App wieder in den Vordergrund wechselt, sollte die lokale Wiedergabe fortgesetzt und die Benachrichtigung noch einmal gepostet werden.

Ausgabeauswahl in AndroidManifest.xml aktivieren

Wenn du die Ausgangsauswahl aktivieren möchtest, musst du dem AndroidManifest.xml der App die MediaTransferReceiver hinzufügen. Andernfalls wird die Funktion nicht aktiviert und das Flag für die Remote-zu-Lokales-Funktion ist ebenfalls ungültig.

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

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 zu remote umstellt, startet das Cast SDK die Übertragungssitzung automatisch. Apps müssen jedoch den Wechsel von lokal zu remote verarbeiten, z. B. die lokale Wiedergabe beenden und die Medien auf dem Streaminggerät laden. Apps sollten mit den Callbacks onSessionStarted() und onSessionEnded() auf die Übertragung SessionManagerListener achten und die Aktion beim Empfangen der Callbacks SessionManager verarbeiten. Apps müssen dafür sorgen, dass diese Rückrufe noch aktiv sind, wenn das Dialogfeld „Ausgangsauswahl“ geöffnet wird und die App nicht im Vordergrund ist.

SessionManagerListener für die Hintergrundübertragung 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, um zu verhindern, dass erforderliche Callbacks deregistriert werden, wenn eine Aktivität beendet wird.

Die bisherige Übertragungsfunktion unterstützt bereits die Übertragung von lokal zu remote, wenn die App im Vordergrund ausgeführt wird. Normalerweise klicken Nutzer in der App auf das Übertragungssymbol und wählen ein Gerät zum Streamen von Medien aus. In diesem Fall muss die App sich bei SessionManagerListener, onCreate() oder onStart() registrieren und die Registrierung des Listeners in onStop() oder onDestroy() der Aktivität der App aufheben.

Mit der neuen Funktion zum Streamen über die Ausgabeauswahl können Apps auch dann streamen, wenn sie im Hintergrund ausgeführt werden. Das ist besonders nützlich für Audio-Apps, die Benachrichtigungen senden, wenn sie im Hintergrund laufen. Apps können die SessionManager-Listener im onCreate() des Dienstes registrieren und im onDestroy() des Dienstes wieder abmelden. Apps sollten immer Callback-Nachrichten vom Typ „Lokales Gerät an Remote-Server“ (z. B. onSessionStarted) erhalten, wenn die App im Hintergrund ausgeführt wird.

Wenn die App 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 funktioniert die Übertragung von lokal zu remote genauso wie das herkömmliche Streamen, wenn die App im Hintergrund läuft. Außerdem ist kein zusätzlicher Aufwand erforderlich, um von Bluetooth-Geräten zu Cast-Geräten zu wechseln.

Hinweis: Damit die Umstellung von der lokalen zur Remote-Wiedergabe reibungslos funktioniert, wird empfohlen, die Wiedergabe auf dem lokalen Gerät während des Callbacks onSessionStarted zu beenden, nachdem das Cast SDK eine Verbindung zum Empfänger hergestellt hat. So wird sichergestellt, dass die lokale Wiedergabe erst angehalten wird, nachdem die Wiedergabe auf dem Remotegerät fortgesetzt wurde, und es keine Zeitprobleme aufgrund von Latenz gibt.

Remote-zu-lokal

Mit der Ausgangsauswahl können Sie von der Remote-Wiedergabe zum Lautsprecher des Smartphones oder zu einem lokalen Bluetooth-Gerät wechseln. Das ist möglich, indem du das Flag setRemoteToLocalEnabled auf CastOptions auf true festlegst.

Wenn das aktuelle Sendergerät einer bestehenden 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 der SessionTransferCallback verwenden, um den SessionState zu prüfen.

Flag „setRemoteToLocalEnabled“ setzen

Über das Dreipunkt-Menü CastOptions.Builder können Sie im Dialogfeld „Ausgabe umschalten“ die Option setRemoteToLocalEnabled aktivieren oder deaktivieren, um den Lautsprecher des Smartphones und lokale Bluetooth-Geräte als Ziele für die Übertragung anzuzeigen oder auszublenden, wenn eine aktive Übertragungssitzung besteht.

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 Medien unterstützen, sollten SessionTransferCallback registrieren, um benachrichtigt zu werden, wenn das Ereignis eintritt. So können sie prüfen, ob Medien übertragen und die Wiedergabe lokal fortgesetzt werden dürfen.

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

Nachdem die App ihre SessionTransferCallback abgemeldet hat, erhält sie keine SessionTransferCallback mehr.

SessionTransferCallback ist eine Erweiterung der vorhandenen SessionManagerListener-Callbacks und wird ausgelöst, nachdem onSessionEnded ausgelöst wurde. Die Reihenfolge der Remote-zu-LokalkCallbacks ist:

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

Da der Ausgabeschalter vom Chip für Medienbenachrichtigungen geöffnet werden kann, wenn die App im Hintergrund ausgeführt wird und streamt, müssen Apps die Übertragung auf die lokale Wiedergabe unterschiedlich handhaben, je nachdem, ob sie die Hintergrundwiedergabe unterstützen oder nicht. Bei einer fehlgeschlagenen Übertragung wird onTransferFailed jedes Mal 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, eine Service (z. B. MediaBrowserService) zu verwenden. Dienste sollten den onTransferred-Callback abhören und die Wiedergabe sowohl im Vordergrund als auch im Hintergrund lokal fortsetzen.

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 keine Hintergrundwiedergabe unterstützen (in der Regel Video-Apps), wird empfohlen, den onTransferred-Callback zu hören 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 von SessionState speichern (z. B. Medienmetadaten und Wiedergabeposition). 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-zu-Remote

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

Audio-Apps sind Apps, die Google Cast für 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 Lautsprechern über eine Fernbedienung wird zwar automatisch von der Cast-Plattform unterstützt, aber Apps müssen möglicherweise ihre Benutzeroberflächen mit den Namen der Lautsprechergruppen aktualisieren. Entwickler sollten die Schritte zum Testen von Remote-zu-Remote-Verbindungen ausführen, um sicherzustellen, dass ihre App ordnungsgemäß funktioniert.

Audio-Apps, die den Ausgabeschalter verwenden, können die Audioausgabe während einer Übertragungssitzung mithilfe der Streamerweiterung 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-Benutzeroberfläche 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 maximierten Gruppennamen während einer Streamerweiterung abrufen möchtest, registriere eine Cast.Listener mit der CastSession#addCastListener. Rufe 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. Sie können Inhalte per herkömmlichem 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. Wenn Sie auf ein anderes für Google Cast optimiertes Gerät tippen, werden die Inhalte in Audio-Apps auf das zusätzliche Gerät erweitert und eine dynamische Gruppe erstellt.
4. Tippen Sie noch einmal auf das für Google Cast optimierte Gerät. Es wird aus der dynamischen Gruppe entfernt.