Android TV App für Google Cast aktivieren

1. Übersicht

In diesem Codelab erfährst du, wie du eine bestehende Android TV App so änderst, dass sie die Übertragung und die Kommunikation mit deinen bestehenden Cast-Absender-Apps unterstützt.

Was ist 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 Absenderanwendung und einer Empfängeranwendung. Absenderanwendungen wie eine mobile App oder eine Website wie YouTube.com initiieren und steuern die Wiedergabe einer Cast-Receiver-App. Cast Receiver-Apps sind HTML 5-Apps, die auf Chromecast- und Android TV-Geräten ausgeführt werden können.

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

Cast Connect baut auf dieser Infrastruktur auf, wobei die Android TV App als Empfänger fungiert. Mit der Cast Connect-Bibliothek kann Ihre Android TV App Nachrichten empfangen und den Medienstatus von Übertragungsmedien empfangen, als wäre es eine Anwendung zum Streamen von Inhalten.

Ziele

Wenn Sie das Codelab abgeschlossen haben, können Sie Cast-Absender-Apps verwenden, um Videos an eine Android TV-App zu übertragen. Die Android TV App kann auch mit Absender-Apps über das Cast-Protokoll kommunizieren.

Lerninhalte

• Hier erfahren Sie, wie Sie die Cast Connect-Bibliothek in eine ATV-Beispiel-App einfügen.
• Informationen zum Verbinden eines Cast-Absenders und zum Starten der ATV-App.
• Informationen zum Starten der Medienwiedergabe in der ATV-App über eine Cast-Absender-App
• Informationen zum Senden des Medienstatus von der ATV-App an die Cast-Absender-Apps

Voraussetzungen

• Das neueste Android SDK.
• Die neueste Version von Android Studio Insbesondere die Versionen Chipmunk | 2021.2.1 oder höher.
• Ein Android TV-Gerät, auf dem Entwickleroptionen und USB-Debugging aktiviert sind
• Ein Android-Smartphone mit Entwickleroptionen und USB-Debugging.
• Ein USB-Datenkabel zum Verbinden Ihres Android-Smartphones und Ihrer Android TV-Geräte mit Ihrem Entwicklungscomputer
• Grundkenntnisse in der Entwicklung von Android-Anwendungen mit Kotlin.

2. Beispielcode abrufen

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

Quellcode herunterladen

und entpacken Sie die heruntergeladene ZIP-Datei.

Das cast-connect-atv-Codelab umfasst zwei Beispielprojekte und eine mobile Absender-APK:

• app-start: Der Startcode, den Sie auf diesem Codelab aufbauen.
• app-done: Der vollständige Code der fertigen ATV-Beispielanwendung.
• mobile-sender.apk: Die Android-Absenderanwendung, die in diesem Codelab verwendet werden soll.

3. Beispiel-App ausführen

Sehen wir uns zuerst an, wie die ausgefüllte Beispiel-App aussieht. Die Android TV App verwendet die Leanback-UI 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 können Nutzer auch Videos über 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 Chromecast mit Android TV registrieren, den Sie in der Cast-Entwicklerkonsole verwenden möchten. Sie finden die Seriennummer auf Ihrem Android TV unter Einstellungen > Geräteeinstellungen > Chromecast-Integration > Seriennummer. Diese ist nicht identisch mit der Seriennummer Ihres physischen Geräts und muss mit der oben beschriebenen Methode abgerufen werden.

Ohne Registrierung funktioniert Cast Connect aus Sicherheitsgründen nur für Apps, die über den Google Play Store installiert wurden. Starten Sie das Gerät 15 Minuten nach Beginn der Registrierung neu.

Android-Absender-App installieren

Zum Senden von Anfragen über ein Mobilgerät haben wir im ZIP-Download des Quellcodes eine einfache Absenderanwendung namens „Videos streamen“ als Datei „mobile-sender-0629.apk“ zur Verfügung gestellt. Wir verwenden ADB, um das APK zu installieren. Wenn Sie bereits eine andere Version von Cast-Videos installiert haben, deinstallieren Sie diese Version vor dem Fortfahren aus allen Profilen auf dem Gerät.

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

4. Du findest die Absender-App Videos streamen auf deinem Android-Smartphone.

Android TV App installieren

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

1. Wählen Sie auf dem Willkommensbildschirm die Option Import Project (Projekt importieren) oder die Menüoption File > New > Import Project... aus.
2. Wählen Sie das Verzeichnis app-done aus dem Ordner mit dem Beispielcode aus und klicken Sie auf „OK“.
3. Klicken Sie auf File > Sync Project with Gradle Files.
4. Aktiviere Entwickleroptionen und USB-Debugging auf deinem Android TV-Gerät.
5. ADB muss eine Verbindung zu Ihrem Android TV-Gerät herstellen und es sollte in Android Studio zu sehen sein.
6. Klicken Sie auf Ausführen. Nach einigen Sekunden sollte die ATV-App Cast Connect Codelab angezeigt werden.

★ Hinweis:

Wenn Ihr Android TV-Gerät in Android Studio nicht angezeigt wird, lesen Sie die Anleitung zur Fehlerbehebung bei Verbindungen, um es als Zielgerät für die Entwicklung auszuwählen.

Cast Connect mit ATV-App spielen

1. Rufen Sie den Startbildschirm von Android TV auf.
2. Öffne auf deinem Android-Smartphone die Absender-App für gestreamte Videos. Klicke auf das Cast-Symbol und wähle dein ATV-Gerät aus.
3. Die Cast Connect-Codelab-ATV-App wird auf deinem ATV gestartet und das Cast-Symbol bei deinem Absender zeigt an, dass es mit verbunden ist.
4. Wähle ein Video in der ATV-App aus. Das Video wird dann auf deinem ATV abgespielt.
5. Auf deinem Smartphone ist jetzt unten in der Absender-App ein Mini-Controller zu sehen. Über die Schaltfläche zum Abspielen und Pausieren kannst du die Wiedergabe steuern.
6. Wähle auf dem Smartphone ein Video aus und starte die Wiedergabe. Das Video wird auf deinem ATV abgespielt und der erweiterte Controller wird auf dem Absender deines Mobilgeräts angezeigt.
7. Sperren Sie Ihr Smartphone. Wenn Sie es entsperren, sollten Sie auf dem Sperrbildschirm eine Benachrichtigung sehen, mit der Sie die Medienwiedergabe steuern und das Streamen beenden können.

★ Fehlerbehebung:

Wenn Sie die Ergebnisse aus den obigen Schritten nicht reproduzieren können, prüfen Sie, ob alle Anforderungen erfüllt sind. Falls weiterhin Probleme auftreten, lesen Sie den Abschnitt zur Fehlerbehebung in dieser Integration auf der Entwicklerwebsite.

4. Startprojekt vorbereiten

Nachdem wir die abgeschlossene Cast Connect-Integration geprü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 Startprojekt aufbauen:

1. Wählen Sie auf dem Willkommensbildschirm die Option Import Project (Projekt importieren) oder die Menüoption File > New > Import Project... aus.
2. Wählen Sie das Verzeichnis app-start aus dem Ordner mit dem Beispielcode aus und klicken Sie auf „OK“.
3. Klicken Sie auf File > Sync Project with Gradle Files.
4. Wählen Sie ein ATV-Gerät aus und klicken Sie auf die Schaltfläche Ausführen, um die App auszuführen und die Benutzeroberfläche kennenzulernen.

App-Design

Die App bietet eine Liste der Videos, die der Nutzer durchsuchen kann. Nutzer können ein Video für die 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 MovieList-Klasse konfiguriert und die Methode setupMovies() aufgerufen, um eine Liste von Movie-Objekten zu erstellen.

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

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

Wiedergabeaktivität

Diese Aktivität enthält ein Fragment (PlaybackVideoFragment), das ein VideoView mit ExoPlayer, einige Mediensteuerelemente und einen Textbereich hostet, um die Beschreibung des ausgewählten Videos anzuzeigen und es dem Nutzer zu ermöglichen, das Video auf Android TV abzuspielen. Der Nutzer kann die Fernbedienung nutzen, um Videos anzusehen oder zu pausieren oder um die Wiedergabe zu starten.

Voraussetzungen für Cast Connect

Für Cast Connect werden neue Versionen der Google Play-Dienste verwendet, bei denen die ATV-App auf den AndroidX-Namespace aktualisiert wurde.

Wenn Sie Cast Connect in Ihrer Android TV App unterstützen möchten, müssen Sie Ereignisse in einer Mediensitzung erstellen und unterstützen. Die Cast Connect-Bibliothek generiert den Medienstatus basierend auf dem Status der Mediensitzung. Ihre Mediensitzung wird auch von der Cast Connect-Bibliothek verwendet, um zu signalisieren, wenn sie bestimmte Nachrichten von einem Absender erhalten hat, z. B. Pause.

★ Hinweis:

In diesem Codelab haben wir diese Voraussetzungen für Sie ergänzt. Informationen zur Integration Ihrer eigenen ATV-App finden Sie in der Dokumentation unten.

Referenzen:

• Zu AndroidX migrieren
• Mit Mediensitzungen arbeiten
• Die MediaSession-Erweiterung für ExoPlayer

5. Cast-Unterstützung konfigurieren

Abhängigkeiten

Aktualisieren Sie die Datei build.gradle der Anwendung, 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 zu bestätigen, dass es fehlerfrei erstellt wird.

Initialisierung

CastReceiverContext ist ein Singleton-Objekt zur Koordination aller Cast-Interaktionen. Du musst die Schnittstelle ReceiverOptionsProvider implementieren, um die 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 Empfängeroptionen-Anbieter 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>

Wähle zum Verbinden deiner ATV-App über den Cast-Sender eine Aktivität aus, die du starten möchtest. In diesem Codelab starten wir die MainActivity der App, wenn eine Cast-Sitzung gestartet wird. Fügen Sie in der Datei AndroidManifest.xml den Filter für den Einführungs-Intent in 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 für Cast Receiver-Kontext

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

Öffnen Sie die Datei MyApplication.kt und initialisieren Sie den Cast-Kontext. Rufen Sie dazu initInstance() in der Methode onCreate der Anwendung auf. Führen Sie in der AppLifeCycleObserver-Klasse start() den CastReceiverContext-Wert aus, wenn die Anwendung fortgesetzt wird, und die stop(), wenn sie pausiert ist:

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 CastReceiverContext-Singleton-Elements, verwaltet den Medienstatus, verarbeitet den Intent für das Laden, wandelt die Medien-Namespace-Nachrichten von Absendern in Medienbefehle um und sendet den Medienstatus an die Absender zurück.

Wenn Sie ein MediaSession erstellen, müssen Sie auch das aktuelle MediaSession-Token an MediaManager übergeben, damit es weiß, wohin die Befehle gesendet und der Medienwiedergabestatus abgerufen werden soll. Achten Sie in der Datei PlaybackVideoFragment.kt darauf, dass MediaSession initialisiert wird, 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 MediaSession wegen inaktiver Wiedergabe loslässt, solltest du für MediaManager ein Nulltoken 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 bei deinem Absender auf das Cast-Symbol und wähle dein ATV-Gerät aus. Du siehst, dass die ATV App auf dem ATV-Gerät gestartet wurde und das Cast-Symbol verbunden ist.

★ Hinweis:

Für dieses Codelab nutzen wir ein Beispiel für eine Cast App-ID und einen Beispielnamen für Android TV, um Cast Connect auszuführen. Wenn Sie Cast Connect mit Ihrer eigenen ATV-App aktivieren möchten, müssen Sie den Paketnamen der Android TV App in der Cast Developer Console hinzufügen und mit Ihrer Cast App-ID verknüpfen.

6. Medien werden geladen

Der Befehl zum Laden wird über einen Intent mit dem Paketnamen gesendet, den Sie in der Entwicklerkonsole definiert haben. Fügen Sie der Android TV App den folgenden vordefinierten Intent-Filter hinzu, um die Zielaktivität anzugeben, die diesen Intent erhalten soll. Fügen Sie in der Datei AndroidManifest.xml den Filter für den Load-Intent in PlayerActivity ein:

<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 Sie die Aktivität so konfiguriert haben, dass sie diesen Intent mit einer Ladeanfrage empfängt, müssen wir ihn verarbeiten.

Die App ruft eine private Methode mit dem Namen processIntent auf, wenn die Aktivität beginnt. Diese Methode enthält die Logik für die Verarbeitung eingehender Intents. Zur Verarbeitung einer Ladeanfrage ändern wir diese Methode und senden den Intent für die weitere Verarbeitung, indem die Methode onNewIntent der MediaManager-Instanz aufgerufen wird. 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, um den Intent mit der Ladeanfrage zu verarbeiten:

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 wandelt sie in ein Movie-Objekt um. Nach der Konvertierung wird der Film vom lokalen Player wiedergegeben. MediaManager wird dann mit MediaLoadRequest aktualisiert und MediaStatus wird an die verbundenen Absender übertragen. Erstellen Sie in der Datei PlaybackVideoFragment.kt eine verschachtelte private Klasse mit dem Namen 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 beim 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 ATV-Gerät bereitzustellen. Klicke bei deinem Absender auf das Cast-Symbol 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 Quad abgespielt. Prüfen Sie, ob Sie auf Ihrem Smartphone eine Benachrichtigung mit Steuerelementen für die Wiedergabe erhalten. Versuche, die Steuerelemente wie „Pause“ oder „Video“ auf dem ATV-Gerät zu pausieren.

7. Cast-Befehle unterstützen

Die aktuelle Anwendung unterstützt jetzt grundlegende Befehle, die mit einer Mediensitzung kompatibel sind, z. B. Wiedergabe, Pause und Suche. Es gibt jedoch einige Cast-Steuerbefehle, die in der Mediensitzung nicht verfügbar sind. Du musst ein MediaCommandCallback registrieren, um diese Cast-Steuerbefehle zu unterstützen.

Fügen Sie der Instanz MyMediaCommandCallback MediaManager mit setMediaCommandCallback 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. Mit Medienstatus arbeiten

Medienstatus ändern

Cast Connect erhält den Basismedienstatus aus der Mediensitzung. Zur Unterstützung erweiterter Funktionen kann die Android TV App zusätzliche Statuseigenschaften über eine MediaStatusModifier angeben und überschreiben. MediaStatusModifier wird immer auf der MediaSession ausgeführt, die Sie in CastReceiverContext festgelegt haben.

So geben Sie beispielsweise setMediaCommandSupported an, wenn der Callback onLoad 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
        })
    }
}

Vor dem Senden „MediaStatus“ abfangen

Ähnlich wie beim MessageInterceptor des Web Receiver SDK können Sie einen MediaStatusWriter in Ihrem MediaManager angeben, um zusätzliche Änderungen an Ihrem MediaStatus vorzunehmen, bevor er an die verbundenen Absender übertragen wird.

Beispielsweise können Sie in MediaStatus benutzerdefinierte Daten 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 eine Android TV App mithilfe der Cast Connect-Bibliothek für Google Cast aktivieren.

Weitere Informationen finden Sie im Entwicklerleitfaden: /cast/docs/android_tv_Receiver.