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 na urządzeniach z Androidem 13 lub nowszym. Celem jest ułatwienie i przyspieszenie kontrolowania przez aplikacje wysyłające, gdzie są odtwarzane 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:

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

Przełącznik wyjścia powinien być włączony, aby obsługiwać przełączanie z lokalnego na zdalne, ze zdalnego na lokalne i ze zdalnego na zdalne zgodnie z instrukcjami podanymi w tym przewodniku. Nie musisz wykonywać żadnych dodatkowych czynności, aby umożliwić przenoszenie dźwięku między głośnikami urządzenia lokalnego a sparowanymi urządzeniami Bluetooth.

Interfejs przełącznika wyjścia

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

Znane problemy

  • Sesje multimedialne utworzone na potrzeby odtwarzania lokalnego zostaną odrzucone i utworzone ponownie po przełączeniu na powiadomienie Cast SDK.

Punkty wejścia

Powiadomienie o multimediach

Jeśli aplikacja wyświetla powiadomienie o multimediach z MediaSession w przypadku odtwarzania lokalnego, w prawym górnym rogu powiadomienia o multimediach wyświetla się element powiadomienia z nazwą urządzenia (np. głośnik telefonu), na którym aktualnie odtwarzane są treści. Kliknięcie elementu powiadomienia otwiera interfejs systemowy okna przełącznika wyjścia.

Ustawienia głośności

Interfejs systemu okna dialogowego przełącznika wyjścia można też wywołać, klikając fizyczne przyciski głośności na urządzeniu, klikając ikonę ustawień u dołu i klikając tekst „Odtwórz <nazwa aplikacji> na <urządzenie przesyłające>”.

Podsumowanie kroków

Wymagania wstępne

  1. Przenieś istniejącą aplikację na Androida do AndroidX.
  2. Zaktualizuj 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 odtwarzaniem lokalnym. Wymaga to utworzenia MediaSession, ustawienia MediaStyle z tokenem MediaSession i ustawienia opcji sterowania multimediami w powiadomieniu.

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

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 dodać do MediaSession metadane i stan odtwarzania multimediów.

Aby dodać metadane do MediaSession, użyj setMetaData() i podaj wszystkie odpowiednie stałe MediaMetadata dla 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 stałe PlaybackStateCompat dla 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ń z aplikacji wideo

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

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

Włączanie przełącznika wyjścia w pliku AndroidManifest.xml

Aby włączyć przełącznik wyjścia, musisz dodać MediaTransferReceiver do pliku AndroidManifest.xml aplikacji. Jeśli nie, funkcja nie zostanie włączona, a flaga funkcji zdalnej na lokalną również będzie nieprawidłowa.

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

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

Z lokalnego na zdalny

Gdy użytkownik przełączy odtwarzanie z lokalnego na zdalne, pakiet Cast SDK automatycznie rozpocznie sesję przesyłania. Aplikacje muszą jednak obsługiwać przełączanie z lokalnego na zdalne, na przykład zatrzymywać odtwarzanie lokalne i ładować multimedia na urządzeniu Cast. Aplikacje powinny nasłuchiwać Cast SessionManagerListener, używając wywołań zwrotnych onSessionStarted() i onSessionEnded(), i obsługiwać działanie po otrzymaniu wywołań zwrotnych Cast SessionManager. Aplikacje powinny dbać o to, aby te wywołania zwrotne były nadal aktywne, gdy okno przełącznika wyjścia jest otwarte, a aplikacja nie jest na pierwszym planie.

Aktualizowanie SessionManagerListener na potrzeby przesyłania w tle

Starsza wersja Cast obsługuje już przesyłanie z urządzenia lokalnego na zdalne, gdy aplikacja działa na pierwszym planie. Typowe przesyłanie rozpoczyna się, gdy użytkownik kliknie ikonę Cast w aplikacji i wybierze urządzenie do strumieniowego przesyłania multimediów. W takim przypadku aplikacja musi zarejestrować się w SessionManagerListener w onCreate() lub onStart() i wyrejestrować detektor 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 wyświetlają powiadomienia podczas odtwarzania w tle. Aplikacje mogą rejestrować detektory SessionManager w metodzie onCreate() usługi i wyrejestrowywać je w metodzie onDestroy() usługi. Aplikacje powinny zawsze otrzymywać wywołania zwrotne z urządzenia lokalnego na zdalne (takie jak onSessionStarted), gdy działają w tle.

Jeśli aplikacja korzysta z MediaBrowserService, zalecamy zarejestrowanie tam 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 przesyłanie lokalne działa tak samo jak konwencjonalne przesyłanie, gdy aplikacja działa w tle, i nie wymaga dodatkowych działań przy przełączaniu się z urządzeń Bluetooth na urządzenia Cast.

Zdalne na lokalne

Przełącznik wyjścia umożliwia przełączenie 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 nadawcami, a aplikacja musi sprawdzić, czy bieżące multimedia mogą być przesyłane lokalnie, aplikacje powinny używać wywołania zwrotnego onTransferred interfejsu SessionTransferCallback, aby sprawdzić SessionState.

Ustawianie flagi setRemoteToLocalEnabled

CastOptions.Builder udostępnia setRemoteToLocalEnabled, który pozwala wyświetlać lub ukrywać głośnik telefonu i lokalne urządzenia Bluetooth jako urządzenia docelowe w oknie przełącznika wyjścia, gdy trwa aktywna sesja przesyłania.

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 obsługujące przesyłanie z urządzenia zdalnego na lokalne powinny zarejestrować SessionTransferCallback, aby otrzymywać powiadomienia o wystąpieniu zdarzenia i móc sprawdzić, czy multimedia powinny zostać przesłane i czy odtwarzanie powinno być kontynuowane lokalnie.

CastContext#addSessionTransferCallback(SessionTransferCallback) umożliwia aplikacji zarejestrowanie obiektu SessionTransferCallback i nasłuchiwanie wywołań zwrotnych onTransferred i onTransferFailed, gdy nadawca jest przenoszony do odtwarzania lokalnego.

Po wyrejestrowaniu SessionTransferCallback aplikacja nie będzie już otrzymywać SessionTransferCallback.

SessionTransferCallback to rozszerzenie istniejących wywołań zwrotnych SessionManagerListener, które jest aktywowane po wywołaniu onSessionEnded. Kolejność wywołań zwrotnych z urządzenia zdalnego na lokalne:

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

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

aplikacje obsługujące 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 do odtwarzania filmów), 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 wykorzystaniem zapisanych informacji.

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

Zdalne na zdalne

Przełącznik wyjścia obsługuje możliwość rozszerzenia odtwarzania na wiele głośników obsługujących Cast w przypadku aplikacji audio korzystających 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 na głośniki

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

Ta funkcja jest obsługiwana przez platformę Cast i nie wymaga żadnych dalszych zmian, jeśli aplikacja korzysta z domyślnego interfejsu użytkownika. Jeśli używany jest niestandardowy interfejs, aplikacja powinna go zaktualizować, aby odzwierciedlić, że przesyła treści do grupy.

Aby uzyskać nową nazwę rozszerzonej grupy podczas rozszerzania odtwarzania, zarejestruj Cast.Listener za pomocą CastSession#addCastListener. Następnie zadzwoń pod numer CastSession#getCastDevice() podczas oddzwaniania 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 połączenia między 2 urządzeniami zdalnymi

Aby przetestować tę funkcję:

  1. Przesyłaj treści na urządzenie obsługujące Cast za pomocą tradycyjnego przesyłania lub lokalnie do zdalnie.
  2. Otwórz przełącznik wyjścia, korzystając z jednego z punktów wejścia.
  3. Kliknij inne urządzenie obsługujące Cast, a aplikacje audio rozszerzą treści na dodatkowe urządzenie, tworząc grupę dynamiczną.
  4. Kliknij ponownie urządzenie obsługujące Cast, aby usunąć je z grupy dynamicznej.
Wstecz
Podobne zamiar
Dalej
Dodatkowe funkcje