Diese Seite wurde von der Cloud Translation API übersetzt.

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:

Local-to-remote
Remote-zu-lokal
Remote-zu-Remote-Verbindung

Laden Sie die Beispiel-App „CastVideos-android“ herunter und verwenden Sie sie. als Referenz zur Implementierung der Ausgabeauswahl in Ihrer App.

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. Wenn Sie auf den Benachrichtigungs-Chip tippen, wird die Benutzeroberfläche des Dialogfelds „Ausgabe-Umschalter“ geöffnet.

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

Migrieren Sie Ihre vorhandene Android-App zu AndroidX.
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'
  ...
}
```
Die App unterstützt Medienbenachrichtigungen.
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:

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

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

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

Wenn du die Ausgangsauswahl aktivieren möchtest, musst du dem AndroidManifest.xml der App die MediaTransferReceiver hinzufügen. Andernfalls wird die Funktion nicht aktiviert und das Flag für die Remote-zu-Lokales-Funktion ist ebenfalls 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 den Wechsel von der lokalen zur Remote-Wiedergabe verarbeiten, z. B. die lokale Wiedergabe beenden und die Medien auf dem Streaminggerät laden. 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 sich bei SessionManagerListener, onCreate() oder onStart() registrieren und die Registrierung des Listeners in onStop() oder onDestroy() der Aktivität der App aufheben.

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 lokalen Callbacks (z. B. onSessionStarted) erhalten, wenn die App im Hintergrund ausgeführt wird.

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

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“ setzen

Über das Dreipunkt-Menü CastOptions.Builder können Sie im Dialogfeld „Ausgabe umschalten“ die Option setRemoteToLocalEnabled aktivieren oder deaktivieren, um den Lautsprecher des Smartphones und lokale Bluetooth-Geräte als Ziele für die Übertragung anzuzeigen oder auszublenden, wenn eine aktive Übertragungssitzung läuft.

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 an die lokale 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:

onTransferring
onSessionEnding
onSessionEnded
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.

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.

Wenn sich die App im Hintergrund befindet, sollte sie die Wiedergabe pausieren und die erforderlichen Informationen von SessionState speichern (z. B. Medienmetadaten und Wiedergabeposition). Wenn die App aus dem Hintergrund in den Vordergrund geholt wird, sollte die lokale Wiedergabe mit den gespeicherten Informationen fortgesetzt werden.

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 Ausgangsauswahl unterstützt die Möglichkeit, die Wiedergabe für Audio-Apps mithilfe der Stream-Ausweitung auf mehrere für Google Cast optimierte Lautsprechergeräte auszuweiten.

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

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 Benutzeroberfläche verwendet wird, sollte die App die Benutzeroberfläche aktualisieren, um anzuzeigen, dass die App auf eine Gruppe streamt.

Wenn du den neuen maximierten Gruppennamen während einer Streamerweiterung abrufen möchtest, registriere eine Cast.Listener mithilfe der CastSession#addCastListener. Rufen Sie dann CastSession#getCastDevice() während des onDeviceNameChanged-Callbacks.

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:

Streamen Sie Ihre Inhalte mit konventionellem Streaming oder mit local-to-remote:
Öffne den Ausgabeschalter über einen der Einstiegspunkte.
Tippen Sie auf ein für Google Cast optimiertes Gerät. Die Inhalte der Audio-Apps werden auf die zusätzlichem Gerät erstellen, sodass eine dynamische Gruppe erstellt wird.
Tippen Sie noch einmal auf das für Google Cast optimierte Gerät. Es wird aus der dynamischen Gruppe.

Zurück

Teilnahmeabsicht

Weiter

Zusätzliche Funktionen