Ausgabeschalter

Die Ausgabeauswahl ist eine Funktion des Cast SDK, mit der Inhalte ab Android 13 nahtlos zwischen lokaler und Remote-Wiedergabe übertragen werden können. Wir möchten Absender-Apps dabei helfen, schnell und einfach zu steuern, wo die Inhalte wiedergegeben werden. Die Ausgabeauswahl verwendet die MediaRouter-Bibliothek, um die Inhaltswiedergabe zwischen dem Smartphone-Lautsprecher, gekoppelten Bluetooth-Geräten und Remote-fähigen Geräten zu wechseln. Anwendungsfälle lassen sich in folgende Szenarien unterteilen:

• Lokal und remote
• Remote-zu-Lokal

Laden Sie das Beispiel unten herunter und verwenden Sie es als Referenz zur Implementierung der Ausgabeauswahl in Ihrer Audio-App. Eine Anleitung zum Ausführen des Beispiels finden Sie in der enthaltenen README.md.

Beispiel herunterladen

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 Fernbedienung bezieht sich auf alle für Google Cast optimierten Geräte.

Die Ausgabeauswahl sollte aktiviert werden, um die lokale Datenübertragung und Remote-zu-Lokal-Migration mithilfe der in diesem Leitfaden beschriebenen Schritte zu unterstützen. Für die Übertragung zwischen den Lautsprechern der lokalen Geräte und den gekoppelten Bluetooth-Geräten sind keine zusätzlichen Schritte erforderlich.

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

Benutzeroberfläche für die Ausgabeauswahl

In der Ausgabeauswahl werden die lokalen und Remote-Geräte angezeigt, die verfügbar sind. Außerdem wird der aktuelle Gerätestatus angegeben, einschließlich, wenn das Gerät ausgewählt ist, die Verbindung. Wenn es neben dem aktuellen Gerät noch weitere Geräte gibt, kannst du die Medienwiedergabe auf das ausgewählte Gerät übertragen, wenn du auf „Anderes Gerät“ klickst.

Bekannte Probleme

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

Einstiegspunkte

Medienbenachrichtigung

Wenn eine App eine Medienbenachrichtigung mit MediaSession für die lokale Wiedergabe (lokal wiedergegeben) postet, wird rechts oben in der Medienbenachrichtigung ein Benachrichtigungs-Chip mit dem Gerätenamen (z. B. Smartphone-Lautsprecher) angezeigt, auf dem der Inhalt gerade wiedergegeben wird. Durch Tippen auf den Benachrichtigungs-Chip wird die Benutzeroberfläche des Dialogfelds „Ausgabeauswahl“ geöffnet.

Lautstärkeeinstellungen

Die Benutzeroberfläche des Dialogfelds „Ausgabeauswahl“ kann auch durch Klicken auf die physische Lautstärketasten des Geräts, Tippen auf das Symbol „Einstellungen“ und dann auf „Text <App-Name> auf <Cast-Gerät>“ tippen.

Zusammenfassung der Schritte

• Voraussetzungen erfüllen
• Ausgabeauswahl in AndroidManifest.xml aktivieren
• SessionManagerListener aktualisieren
• Flag „setRemoteToLocalEnabled“ festlegen
• Wiedergabe lokal fortsetzen

Voraussetzungen

1. Migrieren Sie Ihre vorhandene Android-App zu AndroidX.
2. Aktualisieren Sie die 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

Zur Verwendung der Ausgabeauswahl müssen Audio- und Video-Apps eine Medienbenachrichtigung erstellen, mit der der Wiedergabestatus und die Steuerelemente der Medien für die lokale Wiedergabe angezeigt werden. Dazu müssen Sie eine MediaSession erstellen, MediaStyle mit dem Token MediaSession festlegen und die Mediensteuerelemente für die Benachrichtigung festlegen.

Wenn Sie derzeit kein MediaStyle und MediaSession verwenden, wird im folgenden Snippet gezeigt, wie sie eingerichtet werden, und es gibt Anleitungen für die Einrichtung von Callbacks für die Mediensitzung 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();
}

Wenn Sie die Benachrichtigung mit den Informationen für Ihre Medien füllen möchten, müssen Sie außerdem den Metadaten- und Wiedergabestatus Ihrer Medien zu MediaSession hinzufügen.

Wenn Sie dem MediaSession Metadaten hinzufügen möchten, verwenden Sie setMetaData() und geben Sie alle relevanten MediaMetadata-Konstanten für die 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()
    );
}

Wenn Sie den Wiedergabestatus zu MediaSession hinzufügen möchten, verwenden Sie setPlaybackState() 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 der Video-App

Bei Video- oder Audio-Apps, die die lokale Wiedergabe im Hintergrund nicht unterstützen, sollte für Medienbenachrichtigungen ein spezielles Verhalten festgelegt werden, damit in bestimmten Situationen, in denen die Wiedergabe nicht unterstützt wird, Probleme beim Senden von Medienbefehlen auftreten:

• Die Medienbenachrichtigung posten, wenn Medien lokal abgespielt 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 zurück in den Vordergrund verschoben wird, sollte die lokale Wiedergabe fortgesetzt und die Benachrichtigung noch einmal gesendet werden.

Ausgabeauswahl in AndroidManifest.xml aktivieren

Zum Aktivieren der Ausgabeauswahl muss MediaTransferReceiver dem AndroidManifest.xml der Anwendung hinzugefügt werden. Ist dies nicht der Fall, ist das Feature nicht aktiviert und das Flag für die Remote-zu-Lokal-Funktion ist ebenfalls ungültig.

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

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

Lokal zu Remote

Wenn der Nutzer die Wiedergabe von „Lokal“ zu „Remote“ ändert, startet das Cast SDK automatisch die Streamingsitzung. Apps müssen jedoch den Wechsel von lokal zu entfernen, beispielsweise die lokale Wiedergabe beenden und Medien auf dem Übertragungsgerät laden. Apps sollten die Cast-SessionManagerListener mithilfe der onSessionStarted()- und onSessionEnded()-Callbacks erfassen und die Aktion beim Empfangen der Cast-SessionManager-Callbacks verarbeiten. Apps sollten sicherstellen, dass diese Callbacks noch aktiv sind, wenn das Dialogfeld für die Ausgabeauswahl geöffnet wird und die App nicht im Vordergrund ausgeführt wird.

SessionManagerListener aktualisieren, um Inhalte im Hintergrund zu streamen

Achtung :Aufgrund des Lebenszykluss von Aktivitäten wird für Apps, die die Hintergrundwiedergabe unterstützen (Audio-Apps), empfohlen, einen Dienst und keine Aktivität für SessionManagerListener-Callbacks zu verwenden. So wird verhindert, dass erforderliche Callbacks abgemeldet werden, wenn eine Aktivität beendet wird.

Die alte Cast-Version unterstützt Local-to-Remote bereits, wenn die App im Vordergrund ausgeführt wird. Ein typisches Cast-Erlebnis beginnt, wenn Nutzer in der App auf das Cast-Symbol klicken und ein Gerät zum Streamen von Medien auswählen. In diesem Fall muss sich die Anwendung beim SessionManagerListener in onCreate() oder onStart() registrieren und die Registrierung des Listeners in onStop() oder onDestroy() der App-Aktivität aufheben.

Mit der neuen Funktion können Sie Apps mithilfe des Ausgabeauswahltools im Hintergrund streamen. Dies ist besonders nützlich für Audio-Apps, die Benachrichtigungen im Hintergrund posten. Apps können die SessionManager-Listener im onCreate() des Dienstes registrieren und die Registrierung im onDestroy() des Dienstes aufheben. Auf diese Weise sollten Apps immer die Local-to-Remote-Callbacks (z. B. onSessionStarted) empfangen, wenn die App im Hintergrund ausgeführt wird.

Wenn die Anwendung MediaBrowserService verwendet, wird empfohlen, 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);
    }
  }
}

Nach diesem Update funktioniert Local-to-Remote genauso wie beim herkömmlichen Streamen, wenn die App im Hintergrund ausgeführt wird und keine zusätzlichen Schritte für den Wechsel von Bluetooth- zu Übertragungsgeräten erforderlich sind.

Hinweis: Damit der Übergang von der lokalen zur Fernbedienung reibungslos verläuft, sollte die Wiedergabe auf dem lokalen Gerät während des onSessionStarted-Callbacks beendet werden, nachdem das Cast SDK erfolgreich mit dem Empfänger verbunden wurde. Auf diese Weise wird sichergestellt, dass die lokale Wiedergabe erst dann beendet wird, wenn die Wiedergabe auf dem Remote-Gerät fortgesetzt wurde und aufgrund der Latenz Zeitprobleme auftreten.

Remote-zu-Lokal

Mit der Ausgabeauswahl können Sie von der Remote-Wiedergabe auf den Telefonlautsprecher oder das lokale Bluetooth-Gerät übertragen. Aktivieren Sie dazu das Flag setRemoteToLocalEnabled für CastOptions in true.

Wenn das aktuelle Absendergerät einer bestehenden Sitzung mit mehreren Absendern beitritt und die App prüfen muss, ob das aktuelle Medium lokal übertragen werden darf, sollten Apps den onTransferred-Callback von SessionTransferCallback verwenden, um SessionState zu prüfen.

Flag „setRemoteToLocalEnabled“ festlegen

CastOptions bietet einen setRemoteToLocalEnabled zum Ein- oder Ausblenden des Telefonlautsprechers und der lokalen Bluetooth-Geräte als Ziel für die Übertragung im Ausgabeauswahl-Dialogfeld, 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

Bei Apps, die Remote-zu-Lokal unterstützen, sollte SessionTransferCallback registriert werden, um benachrichtigt zu werden, wenn das Ereignis auftritt. So kann geprüft werden, ob Medien übertragen und die Wiedergabe lokal fortgesetzt werden können.

Mit CastContext#addSessionTransferCallback(SessionTransferCallback) kann eine App ihre SessionTransferCallback registrieren und auf Callbacks von onTransferred und onTransferFailed warten, wenn ein Absender auf die lokale Wiedergabe übertragen wird.

Nachdem die Registrierung ihrer SessionTransferCallback aufgehoben wurde, erhält die Anwendung keine SessionTransferCallbacks mehr.

SessionTransferCallback ist eine Erweiterung der vorhandenen SessionManagerListener-Callbacks, die nach dem Auslösen von onSessionEnded ausgelöst wird. Die Reihenfolge der Remote-zu-Lokal-Callbacks lautet daher:

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

Da die Ausgabeauswahl vom Medienbenachrichtigungschip geöffnet werden kann, wenn die App im Hintergrund ausgeführt wird und Inhalte streamen, müssen Apps an die lokale Übertragung übergeben werden, je nachdem, ob sie die Hintergrundwiedergabe unterstützen oder nicht. Bei einer fehlgeschlagenen Übertragung wird onTransferFailed jederzeit 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 zu verwenden (z. B. MediaBrowserService). Dienste sollten den onTransferred-Callback beobachten und die Wiedergabe lokal fortsetzen, wenn die App im Vordergrund oder 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

Bei Apps, die die Hintergrundwiedergabe nicht unterstützen (in der Regel Videoanzeigen), empfiehlt es sich, den onTransferred-Callback zu beobachten 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 werden und die erforderlichen Informationen von SessionState gespeichert werden, z.B. Medienmetadaten und die Wiedergabeposition. Wenn die App im Vordergrund ausgeführt wird, sollte die lokale Wiedergabe mit den gespeicherten Informationen fortfahren.

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