Für Google Cast optimierte Android TV-App

1. Übersicht

In diesem Codelab erfahren Sie, wie Sie eine vorhandene Android TV-App so ändern, dass sie das Streaming und die Kommunikation von Ihren vorhandenen Cast-Sender-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 Sender-App und einer Receiver-App. Senderanwendungen wie eine mobile App oder eine Website wie YouTube.com starten und steuern die Wiedergabe einer Cast-Empfängeranwendung. Cast-Empfängeranwendungen 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 sich der Status ändert, z. B. wenn ein neues Media-Element geladen wird, wird ein Media-Status an alle Absender gesendet. Diese Broadcasts enthalten den aktuellen Status der Cast-Sitzung. Absenderanwendungen verwenden diesen Medienstatus, um Wiedergabeinformationen in ihrer Benutzeroberfläche anzuzeigen.

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

Ziele

Nach Abschluss dieses Codelabs können Sie mit Cast-Sender-Apps Videos auf eine Android TV-App übertragen. Die Android TV-App kann auch über das Cast-Protokoll mit Sender-Apps kommunizieren.

Lerninhalte

• So fügen Sie die Cast Connect-Bibliothek einer Beispiel-ATV-App hinzu.
• So verbindest du einen Cast-Absender und startest die ATV-App.
• So wird die Medienwiedergabe in der ATV-App über eine Cast-Sender-App gestartet.
• So senden Sie den Medienstatus von der ATV-App an Cast-Absender-Apps.

Voraussetzungen

• Das aktuelle Android SDK.
• Die aktuelle Version von Android Studio. Insbesondere Chipmunk | 2021.2.1 oder höher.
• Ein Android TV-Gerät, auf dem Entwickleroptionen und USB-Debugging aktiviert sind.
• Ein Android-Smartphone, auf dem Entwickleroptionen und USB-Debugging aktiviert sind.
• Ein USB-Datenkabel zum Verbinden Ihres Android-Smartphones und Ihrer Android TV-Geräte mit Ihrem Entwicklercomputer.
• 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 Codelab „cast-connect-atv“ enthält zwei Beispielprojekte und eine mobile Sender-APK:

• app-start: Der Startcode, auf dem Sie in diesem Codelab aufbauen.
• app-done: Das ist der vollständige Code der fertigen ATV-Beispiel-App.
• mobile-sender.apk: Die Android-Senderanwendung, die in diesem Codelab verwendet werden soll.

3. Beispiel-App ausführen

Sehen wir uns zuerst an, wie die fertige Beispiel-App aussieht. Die Android TV App verwendet 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 an die Android TV-App streamen.

Entwicklergeräte registrieren

Wenn Sie Cast Connect-Funktionen für die App-Entwicklung aktivieren möchten, müssen Sie die Seriennummer des Google Cast-Geräts für Android TV, das Sie verwenden möchten, in der Cast Developer Console registrieren. Du findest die Seriennummer auf deinem Android TV unter Einstellungen > Geräteeinstellungen > Google Cast > Seriennummer. Diese unterscheidet sich von der Seriennummer Ihres physischen Geräts und muss über die oben beschriebene Methode abgerufen werden.

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

Android-Sender-App installieren

Um das Senden von Anfragen von einem Mobilgerät aus zu testen, haben wir eine einfache Senderanwendung namens „Cast Videos as mobile-sender-0629.apk file“ im ZIP-Download des Quellcodes bereitgestellt. Wir verwenden ADB, um das APK zu installieren. Wenn Sie bereits eine andere Version von „Videos streamen“ installiert haben, deinstallieren Sie diese Version bitte aus allen Profilen auf dem Gerät, bevor Sie fortfahren.

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 Entwicklercomputer zu verbinden.
3. Installieren Sie mobile-sender-0629.apk auf Ihrem Android-Smartphone.

4. Die Sender-App Videos streamen findest du auf deinem 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 Import Project oder die Menüoptionen 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 Datei >  Projekt mit Gradle-Dateien synchronisieren.
4. Aktiviere die Entwickleroptionen und das USB‑Debugging auf deinem Android TV-Gerät.
5. Stelle eine ADB-Verbindung zu deinem 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 mit dem Namen Cast Connect Codelab angezeigt werden.

★ Hinweis:

Wenn Ihr Android TV-Gerät in Android Studio nicht angezeigt wird, finden Sie hier eine Anleitung zur Fehlerbehebung, damit Sie es als Zielgerät für die Entwicklung auswählen können.

Cast Connect mit der ATV-App

1. Rufen Sie den Android TV-Startbildschirm auf.
2. Öffne auf deinem Android-Smartphone die Sender-App für das Streamen von 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 in deinem Sender zeigt an, dass eine Verbindung besteht .
4. Wähle ein Video in der ATV-App aus. Das Video wird dann auf deinem ATV abgespielt.
5. Auf Ihrem Smartphone wird jetzt unten in der Sender-App eine Mini-Steuerung angezeigt. Mit der Schaltfläche „Wiedergabe/Pause“ können Sie die Wiedergabe steuern.
6. Wählen Sie ein Video auf dem Smartphone aus und spielen Sie es ab. Die Videowiedergabe beginnt auf deinem Apple TV und der erweiterte Controller wird auf deinem Mobilgerät angezeigt.
7. Sperre dein Smartphone. Wenn du es entsperrst, solltest du auf dem Sperrbildschirm eine Benachrichtigung sehen, über die du die Medienwiedergabe steuern oder die Übertragung beenden kannst.

★ Fehlerbehebung:

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

4. Startprojekt vorbereiten

Nachdem wir die Cast Connect-Integration der fertigen App bestätigt haben, müssen wir die Unterstützung für Cast Connect in der heruntergeladenen Start-App hinzufügen. Jetzt können Sie das Starterprojekt in Android Studio verwenden:

1. Wählen Sie auf dem Begrüßungsbildschirm Import Project oder die Menüoptionen 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 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 die Benutzeroberfläche zu testen.

App-Design

Die App bietet dem Nutzer eine Liste von Videos zum Durchsuchen. Nutzer können ein Video auswählen, das auf dem Android TV abgespielt 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 der zugehörigen Metadaten wird in der Klasse MovieList konfiguriert. Die Methode setupMovies() wird aufgerufen, um eine Liste von Movie-Objekten zu erstellen.

Ein Movie-Objekt stellt eine Videoentität mit Titel, Beschreibung, Bild-Thumbnails und Video-URL dar. Jedes Movie-Objekt ist an ein CardPresenter gebunden, um das Videothumbnail mit Titel und Studio zu präsentieren und an das ArrayObjectAdapter zu ü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 Media-Steuerelementen und einem Textbereich zum Anzeigen der Beschreibung des ausgewählten Videos enthält. Außerdem kann der Nutzer das Video auf dem Android TV abspielen. Der Nutzer kann die Wiedergabe von Videos mit der Fernbedienung starten/pausieren oder zu einer anderen Stelle im Video springen.

Voraussetzungen für Cast Connect

Cast Connect verwendet neue Versionen der Google Play-Dienste, für die Ihre ATV-App aktualisiert werden muss, damit der AndroidX-Namespace verwendet wird.

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 Medienstatus basierend auf dem Status der Mediensitzung. Ihre Mediensitzung wird auch von der Cast Connect-Bibliothek verwendet, um zu signalisieren, wann sie bestimmte Nachrichten von einem Absender empfangen hat, z. B. „Pause“.

★ Hinweis:

In diesem Codelab haben wir diese Voraussetzungen für Sie hinzugefügt. Wenn Sie die Integration in Ihre eigene ATV-App vornehmen möchten, sehen Sie sich die Dokumentation unten an.

Referenzen:

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

5. Cast-Unterstützung konfigurieren

Abhängigkeiten

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

Initialisierung

CastReceiverContext ist ein Singleton-Objekt, mit dem alle Cast-Interaktionen koordiniert werden. Sie müssen die ReceiverOptionsProvider-Schnittstelle implementieren, um 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 von 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>

Wenn du eine Verbindung zu deiner ATV-App über deinen Cast-Absender 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 Cast-Sitzung gestartet wird. Fügen Sie in der Datei AndroidManifest.xml den Start-Intent-Filter in 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 CastReceiverContext starten, wenn Ihre App gestartet wird, und 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 Cast-Kontext, indem Sie initInstance() in der Methode onCreate der Anwendung aufrufen. In der Klasse AppLifeCycleObserver start() wird CastReceiverContext aufgerufen, 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 eine Eigenschaft des CastReceiverContext-Singletons. Sie verwaltet den Media-Status, verarbeitet die Ladeabsicht, übersetzt die Nachrichten des Media-Namespace von Absendern in Media-Befehle und sendet den Media-Status zurück an die Absender.

Wenn Sie ein MediaSession erstellen, müssen Sie auch das aktuelle MediaSession-Token für MediaManager angeben, damit MediaManager weiß, wohin die Befehle gesendet werden sollen und wo der Status der Medienwiedergabe abgerufen werden kann. Achten Sie darauf, dass in der Datei PlaybackVideoFragment.kt die MediaSession-Variable initialisiert wird, bevor das Token auf MediaManager gesetzt wird.

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 dein MediaSession aufgrund von Inaktivität freigibst, solltest du in MediaManager ein Null-Token festlegen:

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

Beispiel-App ausführen

Klicken Sie auf die Schaltfläche Run (Ausführen), um die App auf Ihrem ATV-Gerät bereitzustellen, die App zu schließen und zum ATV-Startbildschirm zurückzukehren. Klicke auf dem Sendergerät auf das Cast-Symbol  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“.

★ Hinweis:

In diesem Codelab verwenden wir eine Beispiel-Cast-App-ID und einen Beispiel-Android TV-Paketnamen, um Cast Connect auszuführen. Wenn Sie Cast Connect mit Ihrer eigenen Android TV-App aktivieren möchten, müssen Sie den Paketnamen Ihrer Android TV-App in der Cast Developer Console hinzufügen, um sie mit Ihrer Cast-App-ID zu verknüpfen.

6. Medien werden geladen

Der Ladebefehl wird über einen Intent mit dem Paketnamen gesendet, den Sie in der Entwicklerkonsole definiert haben. Sie müssen Ihrer Android TV-App den folgenden vordefinierten Intent-Filter hinzufügen, um die Zielaktivität anzugeben, die diesen Intent empfängt. Fügen Sie in der Datei AndroidManifest.xml den Load-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 bearbeiten

Nachdem die Aktivität so konfiguriert wurde, dass sie diesen Intent mit einer Ladeanfrage empfängt, müssen wir ihn verarbeiten.

Die App ruft beim Start 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 bearbeiten, ändern wir diese Methode und senden die Absicht zur weiteren Verarbeitung, indem wir die onNewIntent-Methode der MediaManager-Instanz aufrufen. Wenn MediaManager erkennt, dass es sich bei der Intention um eine Ladeanfrage handelt, wird das MediaLoadRequestData-Objekt aus der Intention 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 abgespielt. Die MediaManager wird dann mit der MediaLoadRequest aktualisiert und die MediaStatus wird an die verbundenen Sender ü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, muss er für MediaManager registriert werden. Der Callback muss registriert werden, bevor MediaManager.onNewIntent() aufgerufen wird. Fügen Sie 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 Run (Ausführen), um die App auf Ihrem ATV-Gerät bereitzustellen. Klicke auf dem Sendergerät 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. Die Wiedergabe des Videos beginnt auf dem Apple TV. Prüfe, ob du auf deinem Smartphone eine Benachrichtigung mit Wiedergabesteuerelementen erhältst. Versuche, die Steuerelemente wie „Pause“ zu verwenden. Das Video auf dem ATV-Gerät sollte pausiert werden.

7. Unterstützung von Cast-Steuerbefehlen

Die aktuelle Anwendung unterstützt jetzt grundlegende Befehle, die mit einer Mediensitzung kompatibel sind, z. B. „Wiedergabe“, „Pause“ und „Suchen“. Einige Cast-Steuerungsbefehle sind jedoch nicht in der Mediensitzung verfügbar. Sie müssen ein MediaCommandCallback registrieren, um diese Cast-Steuerbefehle zu unterstützen.

Fügen Sie der MediaManager-Instanz MyMediaCommandCallback 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 die MyMediaCommandCallback-Klasse, um die Methoden wie onQueueUpdate() zu überschreiben und 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 dem Media-Status arbeiten

Medienstatus ändern

Cast Connect ruft den grundlegenden Medienstatus aus der Media Session ab. Zur Unterstützung erweiterter Funktionen kann Ihre Android TV-App zusätzliche Statuseigenschaften über ein 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 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
        })
    }
}

MediaStatus vor dem Senden abfangen

Ähnlich wie beim MessageInterceptor des Web Receiver SDK kannst du in deinem MediaManager ein MediaStatusWriter angeben, um zusätzliche Änderungen an deinem MediaStatus vorzunehmen, bevor es an die verbundenen Sender übertragen wird.

Sie können beispielsweise benutzerdefinierte Daten in 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

Sie wissen jetzt, wie Sie eine Android TV-App mithilfe der Cast Connect-Bibliothek für Google Cast optimieren.

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