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:

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

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 trzeba 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 bieżący poziom 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 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śnika 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

Wymagania wstępne

  1. Przeprowadź migrację dotychczasowej aplikacji na Androida do AndroidX.
  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 stylu MediaStyle z tokenem MediaSession's i ustawienia elementów sterujących multimediami w powiadomieniu.

Jeśli obecnie nie używasz MediaStyle ani 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 aplikacjach 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łączanie przełącznika wyjścia w pliku AndroidManifest.xml

Aby włączyć przełącznik wyjścia, element MediaTransferReceiver musi zostać dodany 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>

Element 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ć wywołań zwrotnych Cast SessionManagerListener, używając 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.

Aktualizowanie SessionManagerListener na potrzeby przesyłania w tle

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 metodzie onCreate() lub onStart() i wyrejestrować odbiornik w metodzie 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 metodzie onCreate() usługi i wyrejestrowywać je w metodzie onDestroy() usługi. Aplikacje powinny zawsze otrzymywać wywołania zwrotne przełączania z odtwarzania lokalnego na zdalne (np. takie jak onSessionStarted) gdy aplikacja działa w tle.

Jeśli aplikacja używa usługi MediaBrowserService, zalecamy zarejestrowanie w niej odbiornika 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 między urządzeniami Bluetooth a urządzeniami przesyłającymi.

Zdalnie – lokalnie

Przełącznik wyjścia umożliwia przełączanie odtwarzania zdalnego na głośnik telefonu lub lokalne urządzenie Bluetooth. Możesz 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 bieżące multimedia można przenieść lokalnie, aplikacje powinny używać wywołania zwrotnego onTransferred w SessionTransferCallback , aby sprawdzić SessionState.

Ustawianie flagi setRemoteToLocalEnabled

Metoda CastOptions.Builder udostępnia metodę setRemoteToLocalEnabled, która umożliwia wyświetlanie lub ukrywanie głośnika telefonu i lokalnych urządzeń Bluetooth jako celów 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()
  }
}

Kontynuowanie odtwarzania 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 wywołania zwrotnego 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 swoje SessionTransferCallback, nie będzie już otrzymywać wywołań zwrotnych SessionTransferCallback.

SessionTransferCallback jest rozszerzeniem istniejących wywołań zwrotnych SessionManagerListener i jest wywoływane po wywołaniu zwrotnym onSessionEnded. Kolejność wywołań zwrotnych 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 lokalne, 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 lokalnego, 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 odtwarzania na wiele urządzeń głośnikowych obsługujących Cast w przypadku aplikacji audio, które korzystają z funkcji 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

Aplikacje audio, które korzystają z przełącznika wyjścia, mogą rozszerzyć odtwarzanie dźwięku na wiele urządzeń głośnikowych obsługujących Cast podczas sesji Cast za pomocą funkcji 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, zaktualizuj go, aby odzwierciedlał, że aplikacja przesyła treści do grupy.

Aby uzyskać nową nazwę rozszerzonej grupy podczas rozszerzania 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ą odtwarzanie 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.
Wstecz
Podobne zamiar
Dalej
Dodatkowe funkcje