Ausgabeschalter

Die Ausgabeauswahl ist eine Funktion des Cast SDK, die eine nahtlose Übertragung zwischen lokaler und Remote-Wiedergabe von Inhalten ab Android 13. Ziel soll Absender-Apps dabei helfen, schnell und einfach zu steuern, wo Inhalte wiedergegeben werden. Die Ausgabeauswahl verwendet die MediaRouter-Bibliothek für Wiedergabe von Inhalten zwischen Smartphone-Lautsprechern, gekoppelten Bluetooth-Geräten, und für Google Cast optimierte Remote-Geräte. Anwendungsfälle können in folgende Kategorien unterteilt werden: Szenarien:

Die Ausgabeauswahl sollte aktiviert sein, um Lokal-zu-Remote und Remote-zu-Lokal zu unterstützen und Remote-zu-Remote-Zugriff mit den in diesem Leitfaden beschriebenen Schritten. Es sind keine Zusätzliche Schritte für die Übertragung zwischen lokalen Geräten Lautsprechern und gekoppelten Bluetooth-Geräten.

Benutzeroberfläche für die Ausgabeauswahl

In der Ausgabeauswahl werden die lokalen und Remote-Geräte angezeigt, die verfügbar sind. sowie den aktuellen Gerätestatus, z. B. ob das Gerät ausgewählt ist, Verbindung herstellt: der aktuelle Lautstärkepegel. Wenn es noch andere Geräte gibt, auf das aktuelle Gerät übertragen. Wenn du auf ein anderes Gerät klickst, kannst du die Medien übertragen. auf dem ausgewählten Gerät wiedergegeben.

Bekannte Probleme

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

Einstiegspunkte

Medienbenachrichtigung

Wenn eine App eine Medienbenachrichtigung mit MediaSession für lokale Wiedergabe (lokale Wiedergabe), oben rechts in der Medienbenachrichtigung einen Benachrichtigungs-Chip mit dem Gerätenamen (z. B. Telefonlautsprecher) anzeigt, auf denen der Inhalt gerade wiedergegeben wird. Tippen auf den Benachrichtigungs-Chip wird geöffnet der Benutzeroberfläche des Dialogfelds „Ausgabeauswahl“.

Lautstärkeeinstellungen

Die Ausgabeauswahl-Dialogsystem-Benutzeroberfläche kann auch durch Klicken auf die Lautstärketasten am Gerät, tippen Sie unten auf das Symbol für die Einstellungen, und tippen Sie auf die Schaltfläche „Play <App Name>“, auf <Cast-Gerät>“ Text.

Zusammenfassung der Schritte

Vorbereitung

  1. Migriere deine bestehende Android-App zu AndroidX.
  2. Aktualisiere die build.gradle deiner App auf die erforderliche Mindestversion der Android Sender SDK für die Ausgabeauswahl: 
    dependencies {
  ...
  implementation 'com.google.android.gms:play-services-cast-framework:21.2.0'
  ...
}
  3. Die App unterstützt Medienbenachrichtigungen.
  4. Gerät mit Android 13.

Medienbenachrichtigungen einrichten

Um die Ausgabeauswahl zu verwenden, audio und Video-Apps sind erforderlich, um eine Medienbenachrichtigung zu erstellen, in der der Wiedergabestatus und für ihre Medien für die lokale Wiedergabe. Dazu muss ein MediaSession, das Festlegen der MediaStyle mit dem Token von MediaSession und legen die Mediensteuerelemente auf dem Benachrichtigung.

Wenn Sie derzeit weder MediaStyle noch MediaSession verwenden, wird das Snippet Unten sehen Sie, wie Sie sie einrichten. Außerdem sind Leitfäden für die Einrichtung der Medien verfügbar. Sitzungs-Callbacks für audio und Video Apps:

<ph type="x-smartling-placeholder">
</ph>
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();
}

Um die Benachrichtigung mit den Informationen zu Ihren Medien zu füllen, müssen Sie die Metadaten und Wiedergabestatus zu MediaSession.

Um Metadaten zum MediaSession hinzuzufügen, verwenden Sie setMetaData() und alle relevanten MediaMetadata-Konstanten für Ihre Medien in den MediaMetadataCompat.Builder()

<ph type="x-smartling-placeholder">
</ph>
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()
    );
}

Um den Wiedergabestatus zum MediaSession hinzuzufügen, verwenden Sie setPlaybackState() und alle relevanten PlaybackStateCompat für Ihre Medien in der PlaybackStateCompat.Builder()

<ph type="x-smartling-placeholder">
</ph>
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()
    );
}

App-Benachrichtigungsverhalten

Video-Apps oder Audio-Apps, die die lokale Wiedergabe im Hintergrund nicht unterstützen sollte ein bestimmtes Verhalten für Medienbenachrichtigungen haben, um Probleme mit Senden von Medienbefehlen in Situationen, in denen die Wiedergabe nicht unterstützt wird:

  • Medienbenachrichtigung posten, wenn Medien lokal wiedergegeben werden und die App aktiviert ist im Vordergrund.
  • Lokale Wiedergabe pausieren und Benachrichtigung schließen, wenn die App im Hintergrund.
  • Wenn die App wieder in den Vordergrund wechselt, sollte die lokale Wiedergabe fortgesetzt und sollte die Benachrichtigung erneut veröffentlicht werden.

Ausgabeauswahl in AndroidManifest.xml aktivieren

Zum Aktivieren der Ausgabeauswahl MediaTransferReceiver muss zur AndroidManifest.xml der App hinzugefügt werden. Ist dies nicht der Fall, wird nicht aktiviert und auch das Funktions-Flag für Remote-zu-Local ist ungültig.

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

Die MediaTransferReceiver ist ein Übertragungsempfänger, der die Medienübertragung zwischen Geräten mit Systemfunktion ermöglicht. UI. Weitere Informationen im Artikel MediaTransferReceiver Referenz .

Lokal-zu-Remote

Wenn der Nutzer die Wiedergabe von der lokalen Wiedergabe zur Remote-Wiedergabe wechselt, wird das Cast SDK gestartet. automatisch übertragen. Apps müssen jedoch in der Lage sein, Lokal zu Fernbedienung, z. B. die lokale Wiedergabe beenden und laden Sie die Medien auf das Übertragungsgerät. Apps sollten das Cast-Signal hören SessionManagerListener, mithilfe der onSessionStarted() und onSessionEnded() und die Aktion beim Empfang der SessionManager Callbacks angegeben werden. Apps sollten sicherstellen, dass diese Callbacks weiterhin aktiv sind, wenn Das Dialogfeld „Ausgabeauswahl“ wird geöffnet und die App wird nicht im Vordergrund ausgeführt.

SessionManagerListener für das Streamen im Hintergrund aktualisieren

Das alte Cast-Erlebnis unterstützt die Lokal-zu-Remote-Verbindung bereits, wenn die App im Vordergrund. Das Streaming beginnt, wenn Nutzer auf das Cast-Symbol klicken in der App und wählen Sie ein Gerät zum Streamen von Medien aus. In diesem Fall muss die App registrieren Sie sich SessionManagerListener, in onCreate() oder onStart() und heben Sie die Registrierung des Listeners onStop() oder onDestroy(). der App-Aktivität.

Dank der neuen Streamingfunktion über die Ausgabeauswahl können Apps wenn sie im Hintergrund laufen. Dies ist besonders nützlich für Audioanzeigen, Apps, die Benachrichtigungen posten, wenn sie im Hintergrund laufen. Apps können registriert werden SessionManager Listener in der onCreate() des Dienstes und heben die Registrierung in der onDestroy() auf. der Dienstleistung. Apps sollten immer die Local-to-Remote-Callbacks empfangen (z. B. als onSessionStarted) wenn die App im Hintergrund ausgeführt wird.

Wenn die App das MediaBrowserService, wird empfohlen, SessionManagerListener zu registrieren .

<ph type="x-smartling-placeholder">
</ph>
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);
    }
  }
}

Durch dieses Update funktioniert die Funktion „Lokal-zu-Remote-Streaming“ wie beim herkömmlichen Streamen, wenn App läuft im Hintergrund und für den Wechsel von Bluetooth-Geräte mit Übertragungsgeräten

Remote-zu-Lokal

Mit der Ausgabeauswahl können Sie zwischen der Remote-Wiedergabe und dem Smartphone-Lautsprecher oder lokales Bluetooth-Gerät. Dies kann durch Festlegen des setRemoteToLocalEnabled Flag zu true am CastOptions.

Wenn das aktuelle Absendergerät an einer bestehenden Sitzung mit mehrere Absender senden, und die App muss prüfen, ob die aktuellen Medien lokal übertragen werden sollen, müssen Apps den onTransferred verwenden. Callback des SessionTransferCallback um die SessionState zu prüfen.

Flag „setRemoteToLocalEnabled“ festlegen

Die CastOptions.Builder bietet eine setRemoteToLocalEnabled, mit der der Telefonlautsprecher und lokale Bluetooth-Geräte als Übertragung an ein- oder ausgeblendet werden können. Ziele im Dialogfeld "Ausgabeauswahl" angezeigt, wenn eine Streamingsitzung aktiv ist.

<ph type="x-smartling-placeholder">
</ph>
Kotlin
class CastOptionsProvider : OptionsProvider {
    fun getCastOptions(context: Context?): CastOptions {
        ...
        return Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
    }
}
Java
public class CastOptionsProvider implements OptionsProvider {
    @Override
    public CastOptions getCastOptions(Context context) {
        ...
        return new CastOptions.Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
  }
}

Wiedergabe lokal fortsetzen

Apps, die Remote-zu-Lokal-Verbindungen unterstützen, sollten die SessionTransferCallback registrieren um sich über das Ereignis benachrichtigen zu lassen, damit sie prüfen können, ob die Medien übertragen und die Wiedergabe lokal fortsetzen.

CastContext#addSessionTransferCallback(SessionTransferCallback) ermöglicht einer App, ihre SessionTransferCallback zu registrieren und auf onTransferred- und onTransferFailed-Callbacks warten, wenn ein Absender zur lokalen Wiedergabe übertragen.

Nachdem die App die Registrierung von SessionTransferCallback aufgehoben hat, die App erhält SessionTransferCallback nicht mehr n.

Die SessionTransferCallback ist eine Erweiterung der vorhandenen SessionManagerListener und wird ausgelöst, nachdem onSessionEnded ausgelöst wurde. Die Reihenfolge der Remote-zu-Local-Callbacks sind:

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

Da die Ausgabeauswahl über den Medienbenachrichtigungs-Chip geöffnet werden kann, wenn der App im Hintergrund läuft und streamt, müssen Apps die Übertragung auf lokale je nachdem, ob sie eine Hintergrundwiedergabe unterstützen oder nicht. Im Fall nach einer fehlgeschlagenen Übertragung: onTransferFailed wird ausgelöst, wenn der Fehler auftritt.

Apps, die die Hintergrundwiedergabe unterstützen

Bei Apps, die die Wiedergabe im Hintergrund unterstützen, wie in der Regel Audio-Apps, ist es wird empfohlen, einen Service zu verwenden (z. B. MediaBrowserService). Dienste sollte sich onTransferred anhören zurückrufen und die Wiedergabe lokal fortsetzen, wenn die App im Vordergrund Hintergrund.

<ph type="x-smartling-placeholder">
</ph>
Kotlin
class MyService : Service() {
    private var castContext: CastContext? = null
    private var sessionTransferCallback: SessionTransferCallback? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
        sessionTransferCallback = MySessionTransferCallback()
        castContext.addSessionTransferCallback(sessionTransferCallback)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback)
            }
        }
    }

    class MySessionTransferCallback : SessionTransferCallback() {
        fun onTransferring(@SessionTransferCallback.TransferType transferType: Int) {
            // Perform necessary steps prior to onTransferred
        }

        fun onTransferred(@SessionTransferCallback.TransferType transferType: Int,
                          sessionState: SessionState?) {
            if (transferType == SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        fun onTransferFailed(@SessionTransferCallback.TransferType transferType: Int,
                             @SessionTransferCallback.TransferFailedReason transferFailedReason: Int) {
            // Handle transfer failure.
        }
    }
}
Java
public class MyService extends Service {
    private CastContext castContext;
    private SessionTransferCallback sessionTransferCallback;

    @Override
    protected void onCreate() {
        castContext = CastContext.getSharedInstance(this);
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession.class);
        sessionTransferCallback = new MySessionTransferCallback();
        castContext.addSessionTransferCallback(sessionTransferCallback);
    }

    @Override
    protected void onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession.class);
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback);
            }
        }
    }

    public static class MySessionTransferCallback extends SessionTransferCallback {
        public MySessionTransferCallback() {}

        @Override
        public void onTransferring(@SessionTransferCallback.TransferType int transferType) {
            // Perform necessary steps prior to onTransferred
        }

        @Override
        public void onTransferred(@SessionTransferCallback.TransferType int transferType,
                                  SessionState sessionState) {
            if (transferType==SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        @Override
        public void onTransferFailed(@SessionTransferCallback.TransferType int transferType,
                                     @SessionTransferCallback.TransferFailedReason int transferFailedReason) {
            // Handle transfer failure.
        }
    }
}

Apps, die keine Hintergrundwiedergabe unterstützen

Bei Apps, die keine Hintergrundwiedergabe unterstützen, wie in der Regel Video-Apps, empfohlen, sich onTransferred anzuhören -Rückruf zurück und setze die Wiedergabe lokal fort, wenn die App im Vordergrund ausgeführt wird.

Befindet sich die App im Hintergrund, sollte die Wiedergabe pausiert und die erforderliche Informationen von SessionState (z. B. Medienmetadaten und Wiedergabeposition). Wenn die App im Vordergrund ausgeführt werden soll, sollte die lokale Wiedergabe mit dem gespeicherten Informationen.

<ph type="x-smartling-placeholder">
</ph>
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.
    }
  }
}

Remote-zu-Remote

Die Ausgabeauswahl ermöglicht die Erweiterung auf mehrere für Google Cast optimierte Lautsprecher für Audio-Apps mit Streamerweiterung

Audio-Apps sind Apps, die Google Cast für Audio in der Receiver App unterstützen. Einstellungen im Google Cast SDK für Entwickler Konsole

Stream-Ausweitung mit Lautsprechern

Audio-Apps, bei denen die Ausgabeauswahl verwendet wird, können die Audioausgabe vergrößern während eines Streams über den Stream auf mehrere für Google Cast optimierte Lautsprecher Ausweitung.

Diese Funktion wird von der Cast-Plattform unterstützt und erfordert keine weiteren ändert sich, wenn die App die Standard-UI verwendet. Wenn eine benutzerdefinierte UI verwendet wird, sollte die Benutzeroberfläche aktualisieren, um anzuzeigen, dass die App an eine Gruppe streamt.

So rufen Sie den neuen Namen der erweiterten Gruppe bei der Maximierung des Streams ab: registrieren Cast.Listener mithilfe der CastSession#addCastListener Rufen Sie dann CastSession#getCastDevice() während des onDeviceNameChanged-Callbacks.

<ph type="x-smartling-placeholder">
</ph>
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);
    }
}

Remote-zu-Remote-Tests

So testen Sie die Funktion:

  1. Streamen Sie Ihre Inhalte auf ein für Google Cast optimiertes Gerät mit konventionellem Streaming oder local-to-remote:
  2. Öffnen Sie die Ausgabeauswahl über einen der Einstiegspunkte.
  3. Tippen Sie auf ein für Google Cast optimiertes Gerät. Die Inhalte der Audio-Apps werden auf die zusätzlichem Gerät, wodurch eine dynamische Gruppe erstellt wird.
  4. Tippen Sie noch einmal auf das für Google Cast optimierte Gerät. Es wird aus den dynamischen Gruppe.
Zurück
Teilnahmeabsicht
Weiter
Zusätzliche Funktionen