Przełącznik wyjścia

Przełącznik wyjścia to funkcja pakietu Cast SDK, która umożliwia płynne przełączanie się między odtwarzaniem treści lokalnie i zdalnie, począwszy od Androida 13. Jej celem jest ułatwienie aplikacjom wysyłającym łatwego i szybkiego sterowania miejscem odtwarzania treści. Przełącznik wyjścia używa biblioteki MediaRouter, aby przełączać odtwarzanie treści między głośnikiem telefonu, sparowanymi urządzeniami Bluetooth i zdalnymi urządzeniami obsługującymi Cast. Przypadki użycia można podzielić na te scenariusze:

• lokalnie – zdalnie,
• zdalnie – lokalnie,
• zdalnie – zdalnie.

Aby dowiedzieć się, jak zaimplementować przełącznik wyjścia w aplikacji, pobierz i użyj **przykładowej aplikacji CastVideos-android**.

Ważne pojęcie: w tym przewodniku termin lokalnie odnosi się do dowolnego sparowanego urządzenia Bluetooth lub urządzenia mobilnego (np. telefonu lub tabletu), na którym uruchamiana jest aplikacja, a termin zdalnie odnosi się do dowolnego urządzenia obsługującego Cast.

Aby obsługiwać przełączanie między odtwarzaniem lokalnym i zdalnym oraz między odtwarzaniem zdalnym i lokalnym, musisz włączyć przełącznik wyjścia, wykonując czynności opisane w tym przewodniku. Nie musisz wykonywać żadnych dodatkowych czynności, aby obsługiwać przełączanie między głośnikami urządzenia lokalnego a sparowanymi urządzeniami Bluetooth.

Interfejs przełącznika wyjścia

Przełącznik wyjścia wyświetla urządzenia lokalne i zdalne, które są dostępne, oraz bieżące stany urządzeń, w tym informacje o tym, czy urządzenie jest wybrane, czy się łączy, oraz o bieżącym poziomie głośności. Jeśli oprócz bieżącego urządzenia są dostępne inne urządzenia, kliknięcie innego urządzenia umożliwia przeniesienie odtwarzania multimediów na wybrane urządzenie.

Znane problemy

• Sesje multimediów utworzone na potrzeby odtwarzania lokalnego zostaną zamknięte i utworzone ponownie po przełączeniu się na powiadomienie pakietu Cast SDK.

Punkty wejścia

Powiadomienie o multimediach

Jeśli aplikacja opublikuje powiadomienie o multimediach z MediaSession na potrzeby odtwarzania lokalnego (odtwarzania na urządzeniu lokalnym), w prawym górnym rogu powiadomienia o multimediach pojawi się chip powiadomienia z nazwą urządzenia (np. głośnik telefonu), na którym aktualnie odtwarzane są treści. Kliknięcie chipa powiadomienia otwiera okno dialogowe przełącznika wyjścia w interfejsie systemu.

Ustawienia głośności

Okno dialogowe przełącznika wyjścia w interfejsie systemu można też otworzyć, klikając fizyczne przyciski głośności na urządzeniu, klikając ikonę ustawień u dołu i klikając tekst „Odtwarzaj <nazwa aplikacji> na <urządzenie przesyłające>”.

Podsumowanie kroków

• Sprawdź, czy zostały spełnione wymagania wstępne.
• Włącz przełącznik wyjścia w pliku AndroidManifest.xml.
• Zaktualizuj SessionManagerListener na potrzeby przesyłania w tle.
• Dodaj obsługę przełączania między odtwarzaniem zdalnym.
• Ustaw flagę setRemoteToLocalEnabled.
• Kontynuuj odtwarzanie lokalnie.

Wymagania wstępne

1. Przeprowadź migrację dotychczasowej aplikacji na Androida do AndroidaX.
2. Zaktualizuj plik build.gradle aplikacji, aby używać minimalnej wymaganej wersji pakietu Android Sender SDK na potrzeby przełącznika wyjścia:

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

3. Aplikacja obsługuje powiadomienia o multimediach.
4. Urządzenie z Androidem 13.

Konfigurowanie powiadomień o multimediach

Aby korzystać z przełącznika wyjścia, aplikacje audio i wideo muszą utworzyć powiadomienie o multimediach, które będzie wyświetlać stan odtwarzania i elementy sterujące multimediami na potrzeby odtwarzania lokalnego. Wymaga to utworzenia MediaSession, ustawienia MediaStyle z tokenem MediaSession's i ustawienia elementów sterujących multimediami w powiadomieniu.

Jeśli obecnie nie używasz MediaStyle i MediaSession, poniższy fragment kodu pokazuje, jak je skonfigurować. Dostępne są też przewodniki dotyczące konfigurowania wywołań zwrotnych sesji multimediów w aplikacjach audio i video:

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

Aby wypełnić powiadomienie informacjami o multimediach, musisz też dodać metadane multimediów i stan odtwarzania do MediaSession.

Aby dodać metadane do MediaSession, użyj setMetaData() i podaj wszystkie odpowiednie MediaMetadata stałe dla swoich multimediów w MediaMetadataCompat.Builder().

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

Aby dodać stan odtwarzania do MediaSession, użyj setPlaybackState() i podaj wszystkie odpowiednie PlaybackStateCompat stałe dla swoich multimediów w PlaybackStateCompat.Builder().

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

Działanie powiadomień w aplikacji wideo

Aplikacje wideo lub audio, które nie obsługują odtwarzania lokalnego w tle, powinny mieć określone działanie w przypadku powiadomień o multimediach, aby uniknąć problemów z wysyłaniem poleceń multimediów w sytuacjach, w których odtwarzanie nie jest obsługiwane:

• Publikuj powiadomienie o multimediach, gdy odtwarzasz multimedia lokalnie, a aplikacja działa na pierwszym planie.
• Wstrzymaj odtwarzanie lokalne i zamknij powiadomienie, gdy aplikacja działa w tle.
• Gdy aplikacja wróci na pierwszy plan, odtwarzanie lokalne powinno zostać wznowione, a powiadomienie powinno zostać opublikowane ponownie.

Włącz przełącznik wyjścia w pliku AndroidManifest.xml

Aby włączyć przełącznik wyjścia, musisz dodać MediaTransferReceiver do pliku AndroidManifest.xml aplikacji. Jeśli tego nie zrobisz, funkcja nie zostanie włączona, a flaga funkcji przełączania między odtwarzaniem zdalnym i lokalnym będzie nieprawidłowa.

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

The MediaTransferReceiver to odbiornik transmisji, który umożliwia przesyłanie multimediów między urządzeniami z interfejsem systemu. Więcej informacji znajdziesz w dokumentacji MediaTransferReceiver reference.

Lokalnie – zdalnie

Gdy użytkownik przełączy odtwarzanie z lokalnego na zdalne, pakiet Cast SDK automatycznie rozpocznie sesję Cast. Aplikacje muszą jednak obsługiwać przełączanie z odtwarzania lokalnego na zdalne, np. zatrzymywać odtwarzanie lokalne i wczytywać multimedia na urządzeniu przesyłającym. Aplikacje powinny nasłuchiwać Cast SessionManagerListener, za pomocą wywołań zwrotnych onSessionStarted() i onSessionEnded() oraz obsługiwać działanie po otrzymaniu wywołań zwrotnych Cast SessionManager. Aplikacje powinny mieć pewność, że te wywołania zwrotne są nadal aktywne, gdy otwarte jest okno dialogowe przełącznika wyjścia, a aplikacja nie działa na pierwszym planie.

Zaktualizuj SessionManagerListener na potrzeby przesyłania w tle

Uwaga: ze względu na cykl życia aktywności, aplikacje, które obsługują odtwarzanie w tle (aplikacje audio), powinny używać usługi zamiast aktywności na potrzeby SessionManagerListener wywołań zwrotnych, aby zapobiec wyrejestrowaniu niezbędnych wywołań zwrotnych po zatrzymaniu aktywności.

Starsza wersja Cast obsługuje już przełączanie z odtwarzania lokalnego na zdalne, gdy aplikacja działa na pierwszym planie. Typowe działanie Cast rozpoczyna się, gdy użytkownicy klikną ikonę Cast w aplikacji i wybiorą urządzenie do przesyłania strumieniowego multimediów. W takim przypadku aplikacja musi zarejestrować się w SessionManagerListener, w onCreate() lub onStart() i wyrejestrować odbiornik w onStop() lub onDestroy() aktywności aplikacji.

Dzięki nowej funkcji przesyłania za pomocą przełącznika wyjścia aplikacje mogą rozpocząć przesyłanie, gdy działają w tle. Jest to szczególnie przydatne w przypadku aplikacji audio, które publikują powiadomienia podczas odtwarzania w tle. Aplikacje mogą rejestrować odbiorniki SessionManager w onCreate() usługi i wyrejestrowywać je w onDestroy() usługi. Aplikacje powinny zawsze otrzymywać wywołania zwrotne dotyczące przełączania z odtwarzania lokalnego na zdalne (takie jak onSessionStarted) gdy aplikacja działa w tle.

Jeśli aplikacja używa MediaBrowserService, zalecamy zarejestrowanie w niej SessionManagerListener.

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

Dzięki tej aktualizacji przełączanie z odtwarzania lokalnego na zdalne działa tak samo jak zwykłe przesyłanie, gdy aplikacja działa w tle, i nie wymaga dodatkowych działań w przypadku przełączania się z urządzeń Bluetooth na urządzenia obsługujące Cast.

Uwaga: aby zapewnić płynne przejście z odtwarzania lokalnego na zdalne, zalecamy zatrzymanie odtwarzania na urządzeniu lokalnym podczas wywołania zwrotnego onSessionStarted, gdy pakiet Cast SDK pomyślnie połączy się z odbiornikiem. Dzięki temu odtwarzanie lokalne zostanie zatrzymane dopiero po wznowieniu odtwarzania na urządzeniu zdalnym, a problemy z synchronizacją spowodowane opóźnieniem zostaną wyeliminowane.

Zdalnie – lokalnie

Przełącznik wyjścia umożliwia przełączanie się z odtwarzania zdalnego na głośnik telefonu lub lokalne urządzenie Bluetooth. Można to włączyć, ustawiając flagę setRemoteToLocalEnabled na true w CastOptions.

W przypadkach, gdy bieżące urządzenie wysyłające dołącza do istniejącej sesji z wieloma urządzeniami wysyłającymi, a aplikacja musi sprawdzić, czy można przenieść bieżące multimedia lokalnie, aplikacje powinny używać onTransferred wywołania zwrotnego w SessionTransferCallback , aby sprawdzić SessionState.

Ustaw flagę setRemoteToLocalEnabled

CastOptions.Builder udostępnia setRemoteToLocalEnabled, aby pokazywać lub ukrywać głośnik telefonu i lokalne urządzenia Bluetooth jako cele przełączania w oknie dialogowym przełącznika wyjścia, gdy aktywna jest sesja Cast.

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

Kontynuuj odtwarzanie lokalnie

Aplikacje, które obsługują przełączanie z odtwarzania zdalnego na lokalne, powinny zarejestrować SessionTransferCallback aby otrzymywać powiadomienia o wystąpieniu zdarzenia. Dzięki temu mogą sprawdzić, czy można przenieść multimedia i kontynuować odtwarzanie lokalnie.

CastContext#addSessionTransferCallback(SessionTransferCallback) umożliwia aplikacji zarejestrowanie SessionTransferCallback i nasłuchiwanie wywołań zwrotnych onTransferred i onTransferFailed, gdy urządzenie wysyłające zostanie przełączone na odtwarzanie lokalne.

Gdy aplikacja wyrejestruje SessionTransferCallback, nie będzie już otrzymywać wywołań zwrotnych SessionTransferCallback.

SessionTransferCallback jest rozszerzeniem istniejących SessionManagerListener wywołań zwrotnych i jest wywoływany po wywołaniu onSessionEnded. Kolejność wywołań zwrotnych dotyczących przełączania z odtwarzania zdalnego na lokalne jest następująca:

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

Ponieważ przełącznik wyjścia można otworzyć za pomocą chipa powiadomienia o multimediach, gdy aplikacja działa w tle i przesyła treści, aplikacje muszą obsługiwać przełączanie na odtwarzanie lokalne w różny sposób w zależności od tego, czy obsługują odtwarzanie w tle. W przypadku nieudanego przełączania onTransferFailed zostanie wywołane w dowolnym momencie wystąpienia błędu.

Aplikacje, które obsługują odtwarzanie w tle

W przypadku aplikacji, które obsługują odtwarzanie w tle (zwykle aplikacji audio), zalecamy używanie Service (np. MediaBrowserService). Usługi powinny nasłuchiwać wywołania zwrotnego onTransferred i wznawiać odtwarzanie lokalnie, gdy aplikacja działa na pierwszym planie lub w tle.

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

Aplikacje, które nie obsługują odtwarzania w tle

W przypadku aplikacji, które nie obsługują odtwarzania w tle (zwykle aplikacji wideo), zalecamy nasłuchiwanie wywołania zwrotnego onTransferred i wznawianie odtwarzania lokalnie, jeśli aplikacja działa na pierwszym planie.

Jeśli aplikacja działa w tle, powinna wstrzymać odtwarzanie i zapisać niezbędne informacje z SessionState (np. metadane multimediów i pozycję odtwarzania). Gdy aplikacja zostanie przeniesiona z tła na pierwszy plan, odtwarzanie lokalne powinno być kontynuowane z zapisanymi informacjami.

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

Zdalnie – zdalnie

Przełącznik wyjścia obsługuje możliwość rozszerzenia na wiele urządzeń głośnikowych obsługujących Cast w przypadku aplikacji audio, które korzystają z rozszerzenia odtwarzania.

Aplikacje audio to aplikacje, które obsługują Google Cast for Audio w ustawieniach aplikacji odbiornika w konsoli programisty Google Cast SDK.

Rozszerzenie odtwarzania za pomocą głośników

Ważne: chociaż rozszerzenie odtwarzania zdalnego za pomocą głośników jest automatycznie obsługiwane przez platformę Cast, aplikacje mogą wymagać zaktualizowania interfejsu użytkownika o nazwy grup głośników. Aby mieć pewność, że aplikacja będzie działać prawidłowo, powinna postępować zgodnie z instrukcjami dotyczącymi testowania przełączania między odtwarzaniem zdalnym.

Aplikacje audio, które korzystają z przełącznika wyjścia, mogą rozszerzać dźwięk na wiele urządzeń głośnikowych obsługujących Cast podczas sesji Cast za pomocą rozszerzenia odtwarzania.

Ta funkcja jest obsługiwana przez platformę Cast i nie wymaga żadnych dodatkowych zmian, jeśli aplikacja używa domyślnego interfejsu użytkownika. Jeśli używasz niestandardowego interfejsu użytkownika, aplikacja powinna go zaktualizować, aby odzwierciedlał, że przesyła treści do grupy.

Aby uzyskać nową nazwę rozszerzonej grupy podczas rozszerzenia odtwarzania, zarejestruj Cast.Listener za pomocą CastSession#addCastListener. Następnie wywołaj CastSession#getCastDevice() podczas wywołania zwrotnego onDeviceNameChanged.

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

Testowanie przełączania między odtwarzaniem zdalnym

Aby przetestować tę funkcję:

1. Prześlij treści na urządzenie obsługujące Cast za pomocą zwykłego przesyłania lub z przełączania z odtwarzania lokalnego na zdalne.
2. Otwórz przełącznik wyjścia za pomocą jednego z punktów wejścia.
3. Kliknij inne urządzenie obsługujące Cast. Aplikacje audio rozszerzą treści na dodatkowe urządzenie, tworząc grupę dynamiczną.
4. Ponownie kliknij urządzenie obsługujące Cast. Zostanie ono usunięte z grupy dynamicznej.