Für Google Cast optimierte Android TV-App

1. Übersicht

In diesem Codelab erfährst du, wie du eine vorhandene Android TV-App so anpassen kannst, 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 Mobilgeräten auf einen Fernseher streamen. Eine typische Google Cast-Sitzung besteht aus zwei Komponenten: einer Sender- und einer Empfänger-App. Absender-Apps, z. B. mobile Apps oder Websites wie YouTube.com, starten und steuern die Wiedergabe einer Cast-Receiver-App. Cast-Receiver-Apps sind HTML5-Apps, die auf Chromecast- und Android TV-Geräten ausgeführt werden.

Fast der gesamte Status einer Übertragungssitzung wird in der Empfänger-App gespeichert. Wenn der Status aktualisiert wird, z. B. wenn ein neues Medienelement geladen wird, wird ein Medienstatus an alle Absender gesendet. Diese Übertragungen enthalten den aktuellen Status der Übertragungssitzung. Absenderanwendungen verwenden diesen Medienstatus, um Informationen zur Wiedergabe auf ihrer Benutzeroberfläche anzuzeigen.

Cast Connect baut auf dieser Infrastruktur auf, wobei deine Android TV-App als Receiver fungiert. Mithilfe der Cast Connect-Bibliothek kann Ihre Android TV App Nachrichten empfangen und den Medienstatus so übertragen, als wäre sie eine Übertragungsempfänger-App.

Ziele

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

Lerninhalte

• Cast Connect-Bibliothek zu einer ATV-Beispiel-App hinzufügen
• So verbindest du einen Cast-Sender und startest die ATV App
• So starten Sie die Medienwiedergabe in der ATV App über eine Cast Sender App.
• Informationen zum Senden des Medienstatus von der ATV App an Sender-Apps von Google Cast

Voraussetzungen

• Das neueste Android SDK
• Die aktuelle Version von Android Studio. Insbesondere Chipmunk | 2021.2.1 oder höhere Versionen.
• Ein Android TV-Gerät, auf dem Entwickleroptionen und USB-Debugging aktiviert sind.
• Ein Android-Smartphone mit Entwickleroptionen und USB-Debugging.
• Ein USB-Datenkabel, um Ihr Android-Smartphone und Android TV-Geräte mit dem Entwicklungscomputer zu verbinden
• Grundkenntnisse in der 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 zunächst 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 wiedergegeben wird. Mit der zugehörigen App „Mobile Sender“ können Nutzer auch ein Video an die Android TV App streamen.

Entwicklergeräte registrieren

Um Cast Connect-Funktionen für die App-Entwicklung zu aktivieren, müssen Sie die Seriennummer des integrierten Chromecast des Android TV-Geräts registrieren, das Sie in der Cast-Entwicklerkonsole verwenden möchten. Sie finden die Seriennummer unter Einstellungen > Geräteeinstellungen > Integrierte Chromecast-Technologie > Seriennummer auf Ihrem Android TV. Beachten Sie, dass diese sich von der Seriennummer Ihres physischen Geräts unterscheidet und über die oben beschriebene Methode bezogen werden muss.

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

Android Sender App installieren

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

1. Aktiviere Entwickleroptionen und USB-Debugging auf deinem 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. Sie finden die Absender-App Videos streamen 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 Option File > 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 Datei > Projekt mit Gradle-Dateien synchronisieren.
4. Aktiviere die Entwickleroptionen und das USB-Debugging auf deinem Android TV-Gerät.
5. ADB-Verbindung mit deinem Android TV-Gerät herstellen, sollte das Gerät 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. Rufen Sie den Android TV-Startbildschirm auf.
2. Öffne die Sender-App „Videos streamen“ auf deinem Android-Smartphone. Klicke auf das Cast-Symbol und wähle dein ATV-Gerät aus.
3. Die Cast Connect Codelab ATV App wird auf deinem Quad gestartet. Das Cast-Symbol auf deinem Sender zeigt an, dass es verbunden ist .
4. Wählen Sie in der Quad-App ein Video aus. Das Video wird auf Ihrem Quad wiedergegeben.
5. Auf Ihrem Smartphone wird jetzt unten in der Absender-App ein Mini-Controller angezeigt. Mit der Schaltfläche für Wiedergabe/Pause können Sie die Wiedergabe steuern.
6. Wähle ein Video auf dem Smartphone aus und starte die Wiedergabe. Das Video wird auf deinem Quad wiedergegeben und der erweiterte Controller wird auf dem Sender deines Mobilgeräts angezeigt.
7. Sperren Sie Ihr Smartphone. Wenn Sie es entsperren, sollte auf dem Sperrbildschirm eine Benachrichtigung angezeigt werden, über die Sie die Medienwiedergabe steuern oder das Streamen beenden können.

4. Startprojekt vorbereiten

Nachdem die Cast Connect-Integration der App abgeschlossen ist, müssen wir Cast Connect der heruntergeladenen Start-App hinzufügen. Jetzt können Sie mit Android Studio auf dem Startprojekt aufbauen:

1. Wählen Sie auf dem Begrüßungsbildschirm Projekt importieren oder die Option File > 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ählen Sie das ATV-Gerät aus und klicken Sie auf die Schaltfläche Ausführen, um die App auszuführen und sich mit der Benutzeroberfläche vertraut zu machen.

App-Design

Die App stellt dem Nutzer eine Liste mit Videos zur Verfügung. Nutzer können ein Video zur Wiedergabe auf Android TV auswählen. 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 repräsentiert 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 PlaybackActivity übergeben.

PlaybackActivity

Diese Aktivität enthält ein Fragment (PlaybackVideoFragment), das ein VideoView mit ExoPlayer, einigen Mediensteuerelementen und einem Textbereich enthält, in dem die Beschreibung des ausgewählten Videos angezeigt wird und dem Nutzer ermöglicht, das Video auf Android TV abzuspielen. Nutzer können die Fernbedienung verwenden, um Videos abzuspielen, anzuhalten oder in einer anderen Reihenfolge zu suchen.

Voraussetzungen für Cast Connect

Cast Connect verwendet neue Versionen der Google Play-Dienste, für die Ihre ATV App für die Verwendung des AndroidX-Namespace aktualisiert wurde.

Damit Cast Connect in Ihrer Android TV App unterstützt wird, müssen Sie Ereignisse aus einer Mediensitzung 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 zu signalisieren, dass bestimmte Nachrichten von einem Absender empfangen wurden, z. B. das Pausieren.

5. Cast-Unterstützung konfigurieren

Abhängigkeiten

Aktualisieren Sie die build.gradle-Datei der Anwendung so, dass sie die erforderlichen Bibliotheksabhängigkeiten enthält:

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 zu prüfen, ob die Projekt-Builds fehlerfrei sind.

Initialisierung

CastReceiverContext ist ein Singleton-Objekt zur Koordination aller Cast-Interaktionen. Sie müssen die Schnittstelle ReceiverOptionsProvider implementieren, um den CastReceiverOptions bereitzustellen, 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-Datei AndroidManifest.xml 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>

Um von Ihrem Cast-Sender eine Verbindung zur ATV-App herzustellen, wählen Sie eine Aktivität aus, die Sie starten möchten. In diesem Codelab starten wir die MainActivity der App, wenn ein Stream gestartet wird. Fügen Sie in der Datei AndroidManifest.xml den Start-Intent-Filter unter MainActivity hinzu.

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

Kontext-Lebenszyklus für Cast Receiver

Du solltest CastReceiverContext starten, wenn deine App gestartet wird, und CastReceiverContext beenden, wenn deine App in den Hintergrund verschoben wird. Wir empfehlen, die LifecycleObserver aus der androidx.lifecycle-Bibliothek zu verwenden, um Anrufe bei CastReceiverContext.start() und CastReceiverContext.stop() zu verwalten

Öffnen Sie die Datei MyApplication.kt und initialisieren Sie den Umwandlungskontext, indem Sie initInstance() in der onCreate-Methode der App aufrufen. In der AppLifeCycleObserver-Klasse start() die CastReceiverContext, wenn die Anwendung fortgesetzt wird, und stop() sie, wenn die Anwendung angehalten 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 Sie ein MediaSession erstellen, müssen Sie auch das aktuelle MediaSession Token an MediaManager bereitstellen, damit es weiß, wohin die Befehle gesendet und der Status der Medienwiedergabe abgerufen werden soll. Achten Sie darauf, dass MediaSession in der Datei PlaybackVideoFragment.kt initialisiert ist, bevor Sie das Token auf MediaManager setzen.

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 MediaSession aufgrund einer inaktiven Wiedergabe freigibst, solltest du für MediaManager ein Null-Token festlegen:

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

Beispiel-App ausführen

Klicken Sie auf die Schaltfläche Ausführen, um die App auf Ihrem Quad-Gerät bereitzustellen, schließen Sie sie und kehren Sie zum ATV-Startbildschirm zurück. Klicke beim Absender auf das Cast-Symbol und wähle dein ATV-Gerät aus. Die ATV-App wird auf dem Quad-Gerät gestartet und das Cast-Symbol ist verbunden.

6. Medien werden geladen

Der Ladebefehl 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 bei Android TV verarbeiten

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

Die App ruft eine private Methode namens processIntent auf, wenn die Aktivität beginnt. Diese Methode enthält die Logik zum Verarbeiten eingehender Intents. Zur Verarbeitung einer Ladeanfrage ändern wir diese Methode und senden den Intent durch Aufrufen der onNewIntent-Methode der MediaManager-Instanz zur weiteren Verarbeitung. Wenn MediaManager erkennt, dass der Intent eine Ladeanfrage ist, wird das MediaLoadRequestData-Objekt aus dem Intent extrahiert und MediaLoadCommandCallback.onLoad() aufgerufen. Ändern Sie die Methode processIntent 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, die die von MediaManager aufgerufene Methode onLoad() überschreibt. Diese Methode empfängt die Daten der Ladeanfrage und konvertiert sie in ein Movie-Objekt. Nach der Konvertierung wird der Film im lokalen Player abgespielt. Die MediaManager wird dann mit dem MediaLoadRequest aktualisiert und sendet 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 MediaManager registrieren. Der Callback 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

Klicken Sie auf die Schaltfläche Ausführen, um die App auf Ihrem Quad-Gerät bereitzustellen. Klicke beim Absender auf das Cast-Symbol und wähle dein ATV-Gerät aus. Die ATV-App wird auf dem ATV-Gerät gestartet. Wähle auf einem Mobilgerät ein Video aus. Das Video wird auf dem Geländefahrzeug abgespielt. Prüfen Sie, ob Sie auf Ihrem Smartphone eine Benachrichtigung erhalten, wenn Sie die Wiedergabesteuerung nutzen. Versuche, die Steuerelemente wie Pause, Video auf dem Quad-Gerät zu pausieren.

7. Unterstützung für Cast-Steuerungsbefehle

Die aktuelle App unterstützt jetzt grundlegende Befehle, die mit einer Mediensitzung kompatibel sind, wie „Wiedergabe“, „Pause“ und „Spulen“. Es gibt jedoch einige Befehle für die Cast-Steuerung, die in Mediensitzungen nicht verfügbar sind. Du musst eine MediaCommandCallback registrieren, um diese Cast-Steuerungsbefehle zu unterstützen.

Fügen Sie 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())
    }
}

Erstellen Sie eine MyMediaCommandCallback-Klasse, um die Methoden zu überschreiben, z. B. onQueueUpdate(), um diese Cast-Steuerbefehle 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. Arbeiten 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 wird immer auf der MediaSession ausgeführt, die du in CastReceiverContext festgelegt hast.

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 sie an mobile Absender senden:

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

Jetzt wissen Sie, wie Sie Android TV-Apps mithilfe der Cast Connect-Bibliothek für Google Cast aktivieren.

Weitere Informationen findest du im Entwicklerleitfaden: /cast/docs/android_tv_receiver.