Für Google Cast optimierte Android TV-App

1. Übersicht

In diesem Codelab erfährst du, wie du eine vorhandene Android TV-App so änderst, dass sie das Streamen und die Kommunikation von deinen bestehenden Cast-Sender-Apps unterstützt.

Was sind Google Cast und Cast Connect?

Mit Google Cast können Nutzer Inhalte von einem Mobilgerät auf einen Fernseher streamen. Eine typische Google Cast-Sitzung besteht aus zwei Komponenten: einer Sender- und einer Empfänger-App. Senderanwendungen wie eine mobile App oder eine Website wie YouTube.com initiieren und steuern die Wiedergabe einer Cast-Empfängeranwendung. Apps für Chromecast-Empfänger sind HTML5-Apps, die auf Chromecast- und Android TV-Geräten ausgeführt werden.

Fast der gesamte Status in einer Cast-Sitzung wird in der Empfängeranwendung gespeichert. Wenn der Status aktualisiert wird, beispielsweise wenn ein neues Medienelement geladen wird, wird ein Medienstatus an alle Absender gesendet. Diese Übertragungen enthalten den aktuellen Status der Übertragungssitzung. Senderanwendungen verwenden diesen Medienstatus, um Wiedergabeinformationen in ihrer Benutzeroberfläche anzuzeigen.

Cast Connect baut auf dieser Infrastruktur auf und Ihre Android TV App fungiert als Empfänger. Mit der Cast Connect-Mediathek kann Ihre Android TV-App Nachrichten empfangen und den Medienstatus übertragen, als wäre es eine Cast-Empfängeranwendung.

Ziele

Wenn Sie dieses Codelab abgeschlossen haben, können Sie mit Cast-Sender-Apps Videos auf eine Android TV-App streamen. Die Android TV-App kann auch über das Cast-Protokoll mit Sender-Apps kommunizieren.

Lerninhalte

• So fügen Sie einer Beispiel-ATV-App die Cast Connect-Bibliothek hinzu.
• Einen Chromecast-Sender verbinden und die ATV-App starten
• So startest du die Medienwiedergabe in der ATV App über eine Cast-Sender-App.
• So senden Sie den Medienstatus von der ATV App an Apps, die Inhalte streamen.

Voraussetzungen

• Das neueste Android SDK.
• Die neueste Version von Android Studio. Insbesondere Version Chipmunk | 2021.2.1 oder höher.
• Ein Android TV-Gerät, auf dem die Entwickleroptionen und das USB-Debugging aktiviert sind.
• Ein Android-Smartphone, auf dem die Entwickleroptionen und das USB-Debugging aktiviert sind.
• Ein USB-Datenkabel, um Ihr Android-Smartphone und Android TV-Geräte mit Ihrem Entwicklungscomputer zu verbinden
• Grundkenntnisse zur Entwicklung von Android-Apps mit Kotlin

2. Beispielcode abrufen

Sie können den gesamten Beispielcode auf Ihren Computer herunterladen…

file_downloadQuellcode herunterladen

und entpacken Sie die heruntergeladene ZIP-Datei.

3. Beispiel-App ausführen

Sehen wir uns zuerst an, wie die fertige Beispiel-App aussieht. Die Android TV-App nutzt die Leanback-Benutzeroberfläche und einen einfachen Videoplayer. Der Nutzer kann ein Video aus einer Liste auswählen, das dann auf dem Fernseher abgespielt wird. Mit der zugehörigen mobilen Sender-App kann ein Nutzer auch ein Video auf die Android TV App streamen.

Entwicklergeräte registrieren

Wenn Sie die Cast Connect-Funktionen für die Anwendungsentwicklung aktivieren möchten, müssen Sie die Seriennummer des integrierten Chromecasts des Android TV-Geräts, das Sie verwenden möchten, in der Cast Developer Console registrieren. Gehen Sie dazu auf Ihrem Android TV-Gerät zu Einstellungen > Geräteeinstellungen > Integrierte Chromecast-Technologie > Seriennummer. Diese Nummer unterscheidet sich von der Seriennummer Ihres physischen Geräts und muss mit der oben beschriebenen Methode abgerufen werden.

Ohne Registrierung funktioniert Cast Connect aus Sicherheitsgründen nur mit Apps, die über den Google Play Store installiert wurden. Starten Sie Ihr Gerät 15 Minuten nach Beginn des Registrierungsvorgangs neu.

Android-Sender-App installieren

Zum Testen des Sendens von Anfragen von einem Mobilgerät haben wir im ZIP-Download des Quellcodes eine einfache Senderanwendung namens „Cast Videos“ als mobile-sender-0629.apk-Datei bereitgestellt. Wir verwenden ADB, um das APK zu installieren. Wenn du bereits eine andere Version von Cast Videos installiert hast, deinstalliere diese Version aus allen Profilen auf dem Gerät, bevor du fortfährst.

1. Aktivieren Sie die Entwickleroptionen und das USB-Debugging auf Ihrem Android-Smartphone.
2. Schließen Sie ein USB-Datenkabel an, um Ihr Android-Smartphone mit Ihrem Entwicklungscomputer zu verbinden.
3. Installiere mobile-sender-0629.apk auf deinem Android-Smartphone.

4. Die Sender-App Cast Videos finden Sie auf Ihrem Android-Smartphone.

Android TV App installieren

In der folgenden Anleitung wird beschrieben, wie Sie die fertige Beispiel-App in Android Studio öffnen und ausführen:

1. Wählen Sie auf dem Begrüßungsbildschirm Projekt importieren oder die Menüoption File > New > Import Project... (Datei > Neu > Projekt importieren...) aus.
2. Wählen Sie im Ordner mit dem Beispielcode das Verzeichnis app-done aus und klicken Sie auf „OK“.
3. Klicken Sie auf File (Datei) > Sync Project with Gradle Files (Projekt mit Gradle-Dateien synchronisieren).
4. Aktivieren Sie die Entwickleroptionen und das USB-Debugging auf Ihrem Android TV-Gerät.
5. Stellen Sie eine ADB-Verbindung zu Ihrem Android TV-Gerät her. Das Gerät sollte in Android Studio angezeigt werden.
6. Klicken Sie auf die Schaltfläche Ausführen. Nach einigen Sekunden sollte die ATV-App Cast Connect Codelab angezeigt werden.

Lass uns Cast Connect mit der ATV App abspielen

1. Rufe den Android TV-Startbildschirm auf.
2. Öffne die Sender-App „Videos streamen“ auf deinem Android-Smartphone. Klicke auf die Schaltfläche „Streamen“  und wähle dein ATV-Gerät aus.
3. Die Cast Connect Codelab ATV App wird auf deinem ATV gestartet und die Schaltfläche „Streamen“ auf deinem Sender zeigt an, dass eine Verbindung besteht .
4. Wählen Sie in der Quad-App ein Video aus. Das Video wird auf Ihrem Quad wiedergegeben.
5. Auf deinem Smartphone wird jetzt unten in der Sender-App ein Mini-Controller angezeigt. Mit der Wiedergabe-/Pause-Schaltfläche kannst du die Wiedergabe steuern.
6. Wählen Sie ein Video auf dem Smartphone aus und spielen Sie es ab. Das Video wird auf deinem ATV wiedergegeben und die erweiterte Fernbedienung wird auf deinem Mobilgerät angezeigt.
7. Sperren Sie Ihr Smartphone und entsperren Sie es dann. Sie sollten dann eine Benachrichtigung auf dem Sperrbildschirm sehen, mit der Sie die Medienwiedergabe steuern oder das Streaming beenden können.

4. Startprojekt vorbereiten

Nachdem wir die Cast Connect-Integration der fertigen App überprüft haben, müssen wir der heruntergeladenen Start-App die Unterstützung für Cast Connect hinzufügen. Jetzt können Sie mit Android Studio auf dem Starterprojekt aufbauen:

1. Wählen Sie auf dem Begrüßungsbildschirm Projekt importieren oder im Menü Datei > Neu > Projekt importieren… aus.
2. Wählen Sie im Ordner mit dem Beispielcode das Verzeichnis app-start aus und klicken Sie auf „OK“.
3. Klicken Sie auf Datei > Projekt mit Gradle-Dateien synchronisieren.
4. Wähle das ATV-Gerät aus und klicke auf die Schaltfläche Ausführen, um die App auszuführen und die Benutzeroberfläche zu testen.

App-Design

Die App stellt dem Nutzer eine Liste mit Videos zur Verfügung. Nutzer können ein Video auswählen, das auf Android TV wiedergegeben werden soll. Die App besteht aus zwei Hauptaktivitäten: MainActivity und PlaybackActivity.

MainActivity

Diese Aktivität enthält ein Fragment (MainFragment). Die Liste der Videos und die zugehörigen Metadaten werden in der Klasse MovieList konfiguriert und die Methode setupMovies() wird aufgerufen, um eine Liste von Movie-Objekten zu erstellen.

Ein Movie-Objekt steht für eine Videoentität mit Titel, Beschreibung, Bild-Thumbnails und Video-URL. Jedes Movie-Objekt ist an ein CardPresenter gebunden, um das Video-Thumbnail mit Titel und Studio zu präsentieren und an ArrayObjectAdapter übergeben.

Wenn ein Element ausgewählt wird, wird das entsprechende Movie-Objekt an die PlaybackActivity übergeben.

PlaybackActivity

Diese Aktivität enthält ein Fragment (PlaybackVideoFragment), das ein VideoView mit ExoPlayer, einige Mediensteuerelemente und ein Textfeld enthält, in dem die Beschreibung des ausgewählten Videos angezeigt wird. Außerdem kann der Nutzer das Video auf Android TV abspielen. Der Nutzer kann die Wiedergabe von Videos mit der Fernbedienung abspielen/pausieren oder springen.

Voraussetzungen für Cast Connect

Für Cast Connect werden neue Versionen der Google Play-Dienste verwendet. Damit diese funktionieren, muss deine ATV-App auf den Namespace AndroidX aktualisiert werden.

Wenn Sie Cast Connect in Ihrer Android TV-App unterstützen möchten, müssen Sie Ereignisse aus einer Mediasitzung erstellen und unterstützen. Die Cast Connect-Bibliothek generiert den Medienstatus basierend auf dem Status der Mediensitzung. Die Mediensitzung wird auch von der Cast Connect-Bibliothek verwendet, um anzuzeigen, dass bestimmte Nachrichten von einem Absender empfangen wurden, z. B. „Pause“.

5. Cast-Unterstützung konfigurieren

Abhängigkeiten

Aktualisieren Sie die build.gradle-Datei der App, um die erforderlichen Bibliotheksabhängigkeiten aufzunehmen:

dependencies {
    ....

    // Cast Connect libraries
    implementation 'com.google.android.gms:play-services-cast-tv:20.0.0'
    implementation 'com.google.android.gms:play-services-cast:21.1.0'
}

Synchronisieren Sie das Projekt, um sicherzustellen, dass es ohne Fehler erstellt wird.

Initialisierung

CastReceiverContext ist ein Singleton-Objekt, das alle Cast-Interaktionen koordiniert. Sie müssen die ReceiverOptionsProvider-Schnittstelle implementieren, um CastReceiverOptions anzugeben, wenn CastReceiverContext initialisiert wird.

Erstellen Sie die Datei CastReceiverOptionsProvider.kt und fügen Sie dem Projekt die folgende Klasse hinzu:

package com.google.sample.cast.castconnect

import android.content.Context
import com.google.android.gms.cast.tv.ReceiverOptionsProvider
import com.google.android.gms.cast.tv.CastReceiverOptions

class CastReceiverOptionsProvider : ReceiverOptionsProvider {
    override fun getOptions(context: Context): CastReceiverOptions {
        return CastReceiverOptions.Builder(context)
                .setStatusText("Cast Connect Codelab")
                .build()
    }
}

Geben Sie dann den Anbieter der Empfängeroptionen im <application>-Tag der App-AndroidManifest.xml-Datei an:

<application>
  ...
  <meta-data
    android:name="com.google.android.gms.cast.tv.RECEIVER_OPTIONS_PROVIDER_CLASS_NAME"
    android:value="com.google.sample.cast.castconnect.CastReceiverOptionsProvider" />
</application>

Wenn du eine Verbindung von deinem Cast-Sender zu deiner ATV-App herstellen möchtest, wähle eine Aktivität aus, die du starten möchtest. In diesem Codelab starten wir die MainActivity der App, wenn eine Streamingsitzung gestartet wird. Fügen Sie in der Datei AndroidManifest.xml den Filter für den Startabsicht in den MainActivity ein.

<activity android:name=".MainActivity">
  ...
  <intent-filter>
    <action android:name="com.google.android.gms.cast.tv.action.LAUNCH" />
    <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

Lebenszyklus des Cast Receiver-Kontexts

Sie sollten die CastReceiverContext starten, wenn Ihre App gestartet wird, und sie beenden, wenn Ihre App in den Hintergrund verschoben wird.CastReceiverContext Wir empfehlen, die LifecycleObserver aus der androidx.lifecycle-Bibliothek zu verwenden, um den Aufruf von CastReceiverContext.start() und CastReceiverContext.stop() zu verwalten.

Öffnen Sie die Datei MyApplication.kt und initialisieren Sie den Übertragungskontext, indem Sie initInstance() in der Methode onCreate der Anwendung aufrufen. In der Klasse AppLifeCycleObserver wird start() CastReceiverContext, wenn die Anwendung fortgesetzt wird, und stop(), wenn die Anwendung pausiert wird:

package com.google.sample.cast.castconnect

import com.google.android.gms.cast.tv.CastReceiverContext
...

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        CastReceiverContext.initInstance(this)
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
    }

    class AppLifecycleObserver : DefaultLifecycleObserver {
        override fun onResume(owner: LifecycleOwner) {
            Log.d(LOG_TAG, "onResume")
            CastReceiverContext.getInstance().start()
        }

        override fun onPause(owner: LifecycleOwner) {
            Log.d(LOG_TAG, "onPause")
            CastReceiverContext.getInstance().stop()
        }
    }
}

MediaSession mit MediaManager verbinden

MediaManager ist ein Attribut des Singleton-Elements CastReceiverContext. Es verwaltet den Medienstatus, verarbeitet den Lade-Intent, übersetzt die Medien-Namespace-Nachrichten von Absendern in Medienbefehle und sendet den Medienstatus zurück an die Absender.

Wenn du eine MediaSession erstellst, musst du MediaManager auch das aktuelle MediaSession-Token mitteilen, damit es weiß, wohin die Befehle gesendet werden sollen und den Status der Medienwiedergabe abrufen kann. Achten Sie darauf, dass in der Datei PlaybackVideoFragment.kt die MediaSession initialisiert ist, bevor Sie das Token auf MediaManager festlegen.

import com.google.android.gms.cast.tv.CastReceiverContext
import com.google.android.gms.cast.tv.media.MediaManager
...

class PlaybackVideoFragment : VideoSupportFragment() {
    private var castReceiverContext: CastReceiverContext? = null
    ...

    private fun initializePlayer() {
        if (mPlayer == null) {
            ...
            mMediaSession = MediaSessionCompat(getContext(), LOG_TAG)
            ...
            castReceiverContext = CastReceiverContext.getInstance()
            if (castReceiverContext != null) {
                val mediaManager: MediaManager = castReceiverContext!!.getMediaManager()
                mediaManager.setSessionCompatToken(mMediaSession!!.getSessionToken())
            }

        }
    }
}

Wenn du deine MediaSession aufgrund inaktiver Wiedergabe freigibst, solltest du ein Null-Token für MediaManager festlegen:

private fun releasePlayer() {
    mMediaSession?.release()
    castReceiverContext?.mediaManager?.setSessionCompatToken(null)
    ...
}

Beispiel-App ausführen

Klicke auf die Schaltfläche Ausführen, um die App auf deinem ATV-Gerät bereitzustellen, schließe die App und kehre zum ATV-Startbildschirm zurück. Klicke auf deinem Sender auf die Schaltfläche „Streamen“  und wähle dein ATV-Gerät aus. Die ATV-App wird auf dem ATV-Gerät gestartet und der Status der Cast-Schaltfläche ist „Verbunden“.

6. Medien werden geladen

Der Befehl „load“ wird über einen Intent mit dem Paketnamen gesendet, den Sie in der Entwicklerkonsole definiert haben. Du musst den folgenden vordefinierten Intent-Filter in deiner Android TV App hinzufügen, um die Zielaktivität anzugeben, die diesen Intent erhalten soll. Fügen Sie in der Datei AndroidManifest.xml den Lade-Intent-Filter zu PlayerActivity hinzu:

<activity android:name="com.google.sample.cast.castconnect.PlaybackActivity"
          android:launchMode="singleTask"
          android:exported="true">
  <intent-filter>
     <action android:name="com.google.android.gms.cast.tv.action.LOAD"/>
     <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

Ladeanfragen auf Android TV verarbeiten

Nachdem die Aktivität so konfiguriert ist, dass sie diesen Intent mit einer Ladeanfrage empfängt, muss sie verarbeitet werden.

Die App ruft beim Starten der Aktivität eine private Methode namens processIntent auf. Diese Methode enthält die Logik für die Verarbeitung eingehender Intents. Um eine Ladeanfrage zu verarbeiten, ändern wir diese Methode und senden den Intent zur weiteren Verarbeitung, indem wir die Methode onNewIntent der MediaManager-Instanz aufrufen. Wenn MediaManager erkennt, dass der Intent eine Ladeanfrage ist, wird das MediaLoadRequestData-Objekt aus dem Intent extrahiert und MediaLoadCommandCallback.onLoad() aufgerufen. Ändern Sie die processIntent-Methode in der Datei PlaybackVideoFragment.kt so, dass der Intent mit der Ladeanfrage verarbeitet wird:

fun processIntent(intent: Intent?) {
    val mediaManager: MediaManager = CastReceiverContext.getInstance().getMediaManager()
    // Pass intent to Cast SDK
    if (mediaManager.onNewIntent(intent)) {
        return
    }

    // Clears all overrides in the modifier.
    mediaManager.getMediaStatusModifier().clear()

    // If the SDK doesn't recognize the intent, handle the intent with your own logic.
    ...
}

Als Nächstes erweitern wir die abstrakte Klasse MediaLoadCommandCallback, um die von MediaManager aufgerufene Methode onLoad() zu überschreiben. Diese Methode empfängt die Daten der Ladeanfrage und konvertiert sie in ein Movie-Objekt. Nach der Konvertierung wird der Film vom lokalen Player abgespielt. Die MediaManager wird dann mit der MediaLoadRequest aktualisiert und überträgt die MediaStatus an die verbundenen Absender. Erstellen Sie in der Datei PlaybackVideoFragment.kt eine verschachtelte private Klasse namens MyMediaLoadCommandCallback:

import com.google.android.gms.cast.MediaLoadRequestData
import com.google.android.gms.cast.MediaInfo
import com.google.android.gms.cast.MediaMetadata
import com.google.android.gms.cast.MediaError
import com.google.android.gms.cast.tv.media.MediaException
import com.google.android.gms.cast.tv.media.MediaCommandCallback
import com.google.android.gms.cast.tv.media.QueueUpdateRequestData
import com.google.android.gms.cast.tv.media.MediaLoadCommandCallback
import com.google.android.gms.tasks.Task
import com.google.android.gms.tasks.Tasks
import android.widget.Toast
...

private inner class MyMediaLoadCommandCallback :  MediaLoadCommandCallback() {
    override fun onLoad(
        senderId: String?, mediaLoadRequestData: MediaLoadRequestData): Task<MediaLoadRequestData> {
        Toast.makeText(activity, "onLoad()", Toast.LENGTH_SHORT).show()
        return if (mediaLoadRequestData == null) {
            // Throw MediaException to indicate load failure.
            Tasks.forException(MediaException(
                MediaError.Builder()
                    .setDetailedErrorCode(MediaError.DetailedErrorCode.LOAD_FAILED)
                    .setReason(MediaError.ERROR_REASON_INVALID_REQUEST)
                    .build()))
        } else Tasks.call {
            play(convertLoadRequestToMovie(mediaLoadRequestData)!!)
            // Update media metadata and state
            val mediaManager = castReceiverContext!!.mediaManager
            mediaManager.setDataFromLoad(mediaLoadRequestData)
            mediaLoadRequestData
        }
    }
}

private fun convertLoadRequestToMovie(mediaLoadRequestData: MediaLoadRequestData?): Movie? {
    if (mediaLoadRequestData == null) {
        return null
    }
    val mediaInfo: MediaInfo = mediaLoadRequestData.getMediaInfo() ?: return null
    var videoUrl: String = mediaInfo.getContentId()
    if (mediaInfo.getContentUrl() != null) {
        videoUrl = mediaInfo.getContentUrl()
    }
    val metadata: MediaMetadata = mediaInfo.getMetadata()
    val movie = Movie()
    movie.videoUrl = videoUrl
    movie.title = metadata?.getString(MediaMetadata.KEY_TITLE)
    movie.description = metadata?.getString(MediaMetadata.KEY_SUBTITLE)
    if(metadata?.hasImages() == true) {
        movie.cardImageUrl = metadata.images[0].url.toString()
    }
    return movie
}

Nachdem der Callback definiert wurde, müssen wir ihn bei der MediaManager registrieren. Der Rückruf muss registriert werden, bevor MediaManager.onNewIntent() aufgerufen wird. Füge setMediaLoadCommandCallback hinzu, wenn der Player initialisiert wird:

private fun initializePlayer() {
    if (mPlayer == null) {
        ...
        mMediaSession = MediaSessionCompat(getContext(), LOG_TAG)
        ...
        castReceiverContext = CastReceiverContext.getInstance()
        if (castReceiverContext != null) {
            val mediaManager: MediaManager = castReceiverContext.getMediaManager()
            mediaManager.setSessionCompatToken(mMediaSession.getSessionToken())
            mediaManager.setMediaLoadCommandCallback(MyMediaLoadCommandCallback())
        }
    }
}

Beispiel-App ausführen

Klicke auf die Schaltfläche Ausführen, um die App auf deinem ATV-Gerät bereitzustellen. Klicke auf deinem Sender auf die Schaltfläche „Streamen“  und wähle dein ATV-Gerät aus. Die ATV-App wird auf dem ATV-Gerät gestartet. Wenn du ein Video auf einem Mobilgerät auswählst, wird es auf dem ATV abgespielt. Prüfen Sie, ob Sie auf Ihrem Smartphone eine Benachrichtigung mit Wiedergabesteuerungen erhalten. Versuche, die Steuerelemente wie „Pausieren“ zu verwenden. Das Video auf dem ATV-Gerät sollte pausiert werden.

7. Unterstützte Befehle für die Übertragungssteuerung

Die aktuelle Anwendung unterstützt jetzt grundlegende Befehle, die mit einer Mediensitzung kompatibel sind, z. B. „Wiedergabe“, „Pause“ und „Suchen“. Es gibt jedoch einige Befehle zur Übertragungssteuerung, die in der Mediensitzung nicht verfügbar sind. Sie müssen eine MediaCommandCallback registrieren, um diese Steuerbefehle für die Übertragung zu unterstützen.

Füge der MediaManager-Instanz mit setMediaCommandCallback MyMediaCommandCallback hinzu, wenn der Player initialisiert wird:

private fun initializePlayer() {
    ...
    castReceiverContext = CastReceiverContext.getInstance()
    if (castReceiverContext != null) {
        val mediaManager = castReceiverContext!!.mediaManager
        ...
        mediaManager.setMediaCommandCallback(MyMediaCommandCallback())
    }
}

Erstelle die Klasse MyMediaCommandCallback, um die Methoden zu überschreiben, z. B. onQueueUpdate(), um die folgenden Befehle zur Übertragungssteuerung zu unterstützen:

private inner class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onQueueUpdate(
        senderId: String?,
        queueUpdateRequestData: QueueUpdateRequestData
    ): Task<Void> {
        Toast.makeText(getActivity(), "onQueueUpdate()", Toast.LENGTH_SHORT).show()
        // Queue Prev / Next
        if (queueUpdateRequestData.getJump() != null) {
            Toast.makeText(
                getActivity(),
                "onQueueUpdate(): Jump = " + queueUpdateRequestData.getJump(),
                Toast.LENGTH_SHORT
            ).show()
        }
        return super.onQueueUpdate(senderId, queueUpdateRequestData)
    }
}

8. Umgang mit dem Medienstatus

Medienstatus ändern

Cast Connect ruft den Basismedienstatus aus der Mediensitzung ab. Zur Unterstützung erweiterter Funktionen kann deine Android TV App zusätzliche Statuseigenschaften über eine MediaStatusModifier angeben und überschreiben. MediaStatusModifier verwendet immer die MediaSession, die Sie in CastReceiverContext festgelegt haben.

So geben Sie beispielsweise setMediaCommandSupported an, wenn der onLoad-Callback ausgelöst wird:

import com.google.android.gms.cast.MediaStatus
...
private class MyMediaLoadCommandCallback : MediaLoadCommandCallback() {
    fun onLoad(
        senderId: String?,
        mediaLoadRequestData: MediaLoadRequestData
    ): Task<MediaLoadRequestData> {
        Toast.makeText(getActivity(), "onLoad()", Toast.LENGTH_SHORT).show()
        ...
        return Tasks.call({
            play(convertLoadRequestToMovie(mediaLoadRequestData)!!)
            ...
            // Use MediaStatusModifier to provide additional information for Cast senders.
            mediaManager.getMediaStatusModifier()
                .setMediaCommandSupported(MediaStatus.COMMAND_QUEUE_NEXT, true)
                .setIsPlayingAd(false)
            mediaManager.broadcastMediaStatus()
            // Return the resolved MediaLoadRequestData to indicate load success.
            mediaLoadRequestData
        })
    }
}

Abfangen von MediaStatus vor dem Senden

Ähnlich wie bei der MessageInterceptor des Web Receiver SDK können Sie eine MediaStatusWriter in Ihrer MediaManager angeben, um zusätzliche Änderungen an Ihrer MediaStatus vorzunehmen, bevor sie an die verbundenen Absender gesendet wird.

Sie können beispielsweise benutzerdefinierte Daten in der MediaStatus festlegen, bevor sie an mobile Absender gesendet werden:

import com.google.android.gms.cast.tv.media.MediaManager.MediaStatusInterceptor
import com.google.android.gms.cast.tv.media.MediaStatusWriter
import org.json.JSONObject
import org.json.JSONException
...

private fun initializePlayer() {
    if (mPlayer == null) {
        ...
        if (castReceiverContext != null) {
            ...
            val mediaManager: MediaManager = castReceiverContext.getMediaManager()
            ...
            // Use MediaStatusInterceptor to process the MediaStatus before sending out.
            mediaManager.setMediaStatusInterceptor(
                MediaStatusInterceptor { mediaStatusWriter: MediaStatusWriter ->
                    try {
                        mediaStatusWriter.setCustomData(JSONObject("{myData: 'CustomData'}"))
                    } catch (e: JSONException) {
                        Log.e(LOG_TAG,e.message,e);
                    }
            })
        }
    }
}        

9. Glückwunsch

Sie wissen jetzt, wie Sie eine Android TV-App mit der Cast Connect-Bibliothek für das Streaming mit Google Cast aktivieren.

Weitere Informationen finden Sie im Entwicklerleitfaden unter /cast/docs/android_tv_receiver.