Przełącznik wyjścia

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Przełącznik wyjścia to funkcja pakietu Cast SDK, która umożliwia płynne przełączanie się między lokalnym a zdalnym odtwarzaniem treści (od Androida 13). Celem jest ułatwienie aplikacjom nadawcy szybkiego i łatwego kontrolowania, gdzie odtwarzane są treści. Przełącznik wyjścia korzysta z biblioteki MediaRouter, aby przełączać odtwarzanie treści między głośnikiem telefonu, sparowanymi urządzeniami Bluetooth i urządzeniami zdalnymi z możliwością przesyłania. Przypadki użycia można podzielić na te scenariusze:

• Lokalny do zdalnego
• Zdalnie do lokalnego
• Zdalnie do zdalnego

Aby dowiedzieć się, jak zaimplementować przełącznik wyjścia w aplikacji, pobierz i użyj próbnej aplikacji CastVideos na Androida.

Przełącznik wyjścia powinien być włączony, aby obsługiwać połączenia lokalno-zdalne, zdalnie-lokalne i zdalnie-zdalne, zgodnie z instrukcjami podanymi w tym przewodniku. Nie trzeba wykonywać żadnych dodatkowych czynności, aby umożliwić przesyłanie danych między głośnikami lokalnego urządzenia i sparowanymi urządzeniami Bluetooth.

Interfejs przełącznika wyjścia

Przełącznik wyjścia wyświetla dostępne urządzenia lokalne i zdalne, a także ich stany, w 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ą jeszcze inne, kliknięcie innego urządzenia umożliwia przeniesienie odtwarzania multimediów na wybrane urządzenie.

Znane problemy

• Sesje multimediów utworzone do odtwarzania lokalnego zostaną zamknięte i powtórnie utworzone, gdy przełączysz się na powiadomienie pakietu SDK Cast.

Punkty wejścia

Powiadomienie o multimediach

Jeśli aplikacja wyświetla powiadomienie o mediach z MediaSession na potrzeby lokalnego odtwarzania (odtwarzania na urządzeniu), w prawym górnym rogu powiadomienia o mediach wyświetla się element z nazwą urządzenia (np. głośnik telefonu), na którym obecnie odtwarzane są treści. Kliknięcie elementu powiadomienia powoduje otwarcie interfejsu systemu w oknie przełącznika wyjścia.

Ustawienia głośności

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

Podsumowanie kroków

• Sprawdź, czy są spełnione wymagania wstępne
• Włącz przełącznik wyjścia w pliku AndroidManifest.xml
• Aktualizowanie klasy SessionManagerListener na potrzeby przesyłania w tle
• Dodanie obsługi połączenia zdalnego z innym urządzeniem
• Ustaw flagę setRemoteToLocalEnabled
• Kontynuowanie odtwarzania lokalnie

Wymagania wstępne

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

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

3. Aplikacja obsługuje powiadomienia o mediach.
4. urządzenie z Androidem 13,

Konfigurowanie powiadomień o multimediach

Aby korzystać z przełącznika wyjścia, aplikacje dźwięku i obrazu muszą utworzyć powiadomienie multimedialne, aby wyświetlić stan odtwarzania i sterowanie multimediami na potrzeby odtwarzania lokalnego. Wymaga to utworzenia MediaSession, skonfigurowania MediaStyle za pomocą tokena MediaSession oraz skonfigurowania elementów sterujących multimediami w powiadomieniu.

Jeśli nie używasz obecnie MediaStyle ani MediaSession, w fragmentach kodu poniżej znajdziesz instrukcje ich konfigurowania. Dostępne są też przewodniki dotyczące konfigurowania wywołań sesji multimediów w aplikacjach audio i wideo:

// 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)

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 dodatkowo wypełnić powiadomienie informacjami o multimediach, musisz dodać MediaSession metadane i stan odtwarzania multimediów.

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

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

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

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

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

Zachowanie powiadomień z aplikacji wideo

Aplikacje do odtwarzania filmów lub dźwięku, które nie obsługują odtwarzania lokalnego w tle, powinny mieć określone zachowanie w przypadku powiadomień o mediach, aby uniknąć problemów z wysyłaniem poleceń dotyczących multimediów w sytuacjach, w których odtwarzanie nie jest obsługiwane:

• publikowanie powiadomienia o multimediach podczas odtwarzania multimediów lokalnie i działania aplikacji na pierwszym planie;
• Wstrzymaj lokalne odtwarzanie 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ć ponownie wysłane.

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

Aby włączyć przełącznik wyjścia, musisz dodać do aplikacji AndroidManifest.xml komponent MediaTransferReceiver. Jeśli nie, funkcja nie będzie włączona, a flaga funkcji zdalnej do lokalnej też nie będzie ważna.

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

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

Lokalny do zdalnego

Gdy użytkownik przełączy odtwarzanie z lokalnego na zdalne, pakiet SDK Google Cast automatycznie uruchomi sesję Cast. Aplikacje muszą jednak obsługiwać przełączanie z odtwarzania lokalnego na zdalne, na przykład zatrzymywanie odtwarzania lokalnego i wczytywanie multimediów na urządzeniu z Cast. Aplikacje powinny nasłuchiwać wywołań zwrotnych przesyłacza SessionManagerListener za pomocą wywołań zwrotnych onSessionStarted() i onSessionEnded() oraz obsługiwać działanie po otrzymaniu wywołań zwrotnych przesyłacza SessionManager. Aplikacje powinny zadbać o to, aby te funkcje były nadal aktywne, gdy otwiera się okno przełącznika danych wyjściowych, a aplikacja nie jest na pierwszym planie.

Aktualizacja interfejsu SessionManagerListener na potrzeby przesyłania w tle

Starsza wersja przesyłania treści obsługuje już przesyłanie z urządzenia lokalnego na urządzenie zdalne, gdy aplikacja jest na pierwszym planie. Typowe przesyłanie strumieniowe rozpoczyna się, gdy użytkownicy klikają ikonę przesyłania w aplikacji i wybierają urządzenie, na którym mają odtwarzać multimedia. W tym przypadku aplikacja musi zarejestrować się w SessionManagerListener, w onCreate() lub onStart() oraz zarejestrować detektor w onStop() lub onDestroy() aktywności aplikacji.

Dzięki nowej funkcji przesyłania treści za pomocą przełącznika wyjścia aplikacje mogą rozpocząć przesyłanie, gdy są w tle. Jest to szczególnie przydatne w przypadku aplikacji muzycznych, które wysyłają powiadomienia podczas odtwarzania w tle. Aplikacje mogą rejestrować SessionManager odbiorców w onCreate() usługi i odwoływać rejestrację w onDestroy() usługi. Aplikacje powinny zawsze otrzymywać wywołania zwrotne z poziomu lokalnego na zdalny (takie jak onSessionStarted), gdy działają w tle.

Jeśli aplikacja korzysta z MediaBrowserService, zalecamy zarejestrowanie jej w SessionManagerListener.

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

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 funkcja przesyłania z urządzenia lokalnego na urządzenie zdalne działa tak samo jak zwykłe przesyłanie, gdy aplikacja jest w tle. Nie trzeba też wykonywać dodatkowych czynności, aby przełączyć się z urządzeń Bluetooth na urządzenia z Chromecastem.

Zdalne do lokalne

Przełącznik wyjścia umożliwia przeniesienie odtwarzania zdalnego na głośnik telefonu lub lokalne urządzenie Bluetooth. Aby włączyć tę funkcję, ustaw flagę setRemoteToLocalEnabled na CastOptions.true

W przypadku, gdy bieżące urządzenie nadawcze dołącza do istniejącej sesji z większą liczbą nadawców, a aplikacja musi sprawdzić, czy bieżące media mogą być przesyłane lokalnie, aplikacje powinny użyć wywołania zwrotnego onTransferred funkcji SessionTransferCallback, aby sprawdzić SessionState.

Ustaw flagę setRemoteToLocalEnabled

CastOptions.Builder pozwala setRemoteToLocalEnabled wyświetlać lub ukrywać głośnik telefonu i lokalne urządzenia Bluetooth jako cele przesyłania w oknie przełącznika wyjścia podczas aktywnej sesji przesyłania.

class CastOptionsProvider : OptionsProvider {
    fun getCastOptions(context: Context?): CastOptions {
        ...
        return Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
    }
}

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ą przesyłanie z dalszego urządzenia na lokalne, powinny zarejestrować SessionTransferCallback, aby otrzymywać powiadomienia o wystąpieniu zdarzenia. Dzięki temu mogą sprawdzić, czy należy zezwolić na przesyłanie multimediów i kontynuowanie odtwarzania na urządzeniu lokalnym.

CastContext#addSessionTransferCallback(SessionTransferCallback) pozwala aplikacji zarejestrować SessionTransferCallback i odsłuchiwać wywołań zwrotnych onTransferred i onTransferFailed, gdy nadawca jest przenoszony do odtwarzania lokalnego.

Gdy aplikacja zarejestruje SessionTransferCallback, przestanie otrzymywać SessionTransferCallback.

SessionTransferCallback to rozszerzenie istniejących wywołań zwrotnych SessionManagerListener, które jest wywoływane po wywołaniu onSessionEnded. Kolejność wywołań zwrotnych z dalszych do lokalnych to:

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

Przełącznik wyjścia może być otwierany przez element powiadomienia o multimediach, gdy aplikacja działa w tle i przesyła treści, dlatego aplikacje muszą inaczej obsługiwać przenoszenie na urządzenie lokalne w zależności od tego, czy obsługują odtwarzanie w tle. W przypadku nieudanego transferu funkcja onTransferFailed zostanie wywołana w dowolnym momencie, gdy wystąpi błąd.

Aplikacje obsługujące odtwarzanie w tle

W przypadku aplikacji, które obsługują odtwarzanie w tle (zazwyczaj aplikacji audio), zalecamy użycie Service (na przykład MediaBrowserService). Usługi powinny nasłuchiwać wywołania zwrotnego onTransferred i wznawiać odtwarzanie lokalnie zarówno wtedy, gdy aplikacja jest na pierwszym planie, jak i w tle.

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

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 (zazwyczaj aplikacji wideo), zalecamy nasłuchiwanie wywołania zwrotnego onTransferred i wznawianie odtwarzania lokalnie, jeśli aplikacja jest na pierwszym planie.

Jeśli aplikacja działa w tle, powinna wstrzymać odtwarzanie i przechowywać niezbędne informacje z SessionState (np. metadane multimediów i pozycję odtwarzania). Gdy aplikacja zostanie przeniesiona z tła do pierwszego planu, odtwarzanie na urządzeniu powinno być kontynuowane z wykorzystaniem zapisanych informacji.

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

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 do zdalnego

Przełącznik wyjścia obsługuje możliwość rozszerzenia na wiele głośników z możliwością przesyłania treści przez Chromecasta w przypadku aplikacji audio korzystających z rozszerzenia strumienia.

Aplikacje audio to aplikacje, które obsługują Google Cast na potrzeby audio w ustawieniach aplikacji odbiorczej w Konsoli programisty pakietu SDK Google Cast.

Rozszerzenie strumienia z głośnikami

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 Cast za pomocą rozszerzenia strumienia.

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żywany jest niestandardowy interfejs użytkownika, aplikacja powinna go zaktualizować, aby odzwierciedlał fakt, że przesyłanie odbywa się do grupy.

Aby uzyskać nową rozwiniętą nazwę grupy podczas rozszerzania strumienia, zarejestruj Cast.Listener za pomocą CastSession#addCastListener. Następnie zadzwoń pod numerCastSession#getCastDevice()podczas onDeviceNameChangedpołączenia zwrotnego.

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

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 zdalnego z dalnym

Aby przetestować tę funkcję:

1. Przesyłaj treści na urządzenie obsługujące Cast za pomocą zwykłego przesyłania lub przesyłania lokalnego na urządzenie zdalne.
2. Otwórz przełącznik wyjścia, korzystając z jednego z punktów wejścia.
3. Kliknij inne urządzenie z obsługą Google Cast, a aplikacje odtwarzaczy dźwięku rozszerzą zawartość na to dodatkowe urządzenie, tworząc grupę dynamiczną.
4. Ponownie kliknij urządzenie z wsparciem przesyłania, aby usunąć je z grupy dynamicznej.