Włączanie przesyłania w aplikacji na Androida TV

1. Opis

Logo Google Cast

Dzięki tym ćwiczeniom z programowania dowiesz się, jak zmodyfikować istniejącą aplikację na Androida TV, aby obsługiwała przesyłanie i komunikację z tych aplikacji.

Co to są Google Cast i Cast Connect?

Google Cast pozwala użytkownikom przesyłać treści z urządzenia mobilnego na telewizor. Typowa sesja Google Cast składa się z 2 komponentów: aplikacji nadawcy i odbiornika. Aplikacje nadawcy (np. aplikacja mobilna lub strona internetowa (np. YouTube.com)) inicjują i sterują odtwarzaniem w aplikacji odbierającej Cast. Aplikacje odbiornika to aplikacje HTML5, które działają na Chromecastach i urządzeniach z Androidem TV.

Niemal cały stan sesji przesyłania jest przechowywany w aplikacji odbiorcy. Gdy stan jest aktualizowany, na przykład po wczytaniu nowego elementu multimedialnego, do wszystkich nadawców wysyłany jest stan multimediów. Komunikaty te zawierają aktualny stan sesji przesyłania. Aplikacje nadawcy używają tego stanu multimediów, aby wyświetlać w swoim interfejsie informacje o odtwarzaniu.

Na bazie tej infrastruktury działa Cast Connect, a aplikacja na Androida TV działa jako odbiornik. Biblioteka Cast Connect pozwala aplikacji na Androida TV odbierać wiadomości i przesyłać informacje o stanie multimediów tak, jakby była to aplikacja odbiornika.

Co będziemy tworzyć?

Po ukończeniu tych ćwiczeń z programowania możesz używać aplikacji nadawców przesyłających, aby przesyłać filmy do aplikacji na Androida TV. Aplikacja na Androida TV może też komunikować się z aplikacjami nadawców przez protokół Cast.

Czego się nauczysz

  • Jak dodać bibliotekę Cast Connect do przykładowej aplikacji ATV
  • Jak połączyć nadawcę przesyłającego i uruchomić aplikację ATV.
  • Jak włączyć odtwarzanie multimediów w aplikacji ATV z aplikacji nadawcy przesyłającego.
  • Jak przesyłać stan multimediów z aplikacji ATV do aplikacji nadawców przesyłających.

Czego potrzebujesz

2. Pobieranie przykładowego kodu

Możesz pobrać cały przykładowy kod na komputer...

i rozpakuj pobrany plik ZIP.

3. Uruchamianie przykładowej aplikacji

Zobaczmy najpierw, jak wygląda kompletna przykładowa aplikacja. Aplikacja na Androida TV korzysta z interfejsu użytkownika funkcji TalkBack i podstawowego odtwarzacza wideo. Użytkownik może wybrać z listy film, który zostanie odtworzony na telewizorze po ich wybraniu. Za pomocą towarzyszącej aplikacji mobilnej nadawcy użytkownik może też przesyłać film do aplikacji na Androida TV.

Grafika przedstawiająca serię miniatur filmów (z których jedna jest podświetlona) nakładającą się na pełnoekranowy podgląd filmu. W prawym górnym rogu widać napis „Cast Connect”

Rejestrowanie urządzeń dla programistów

Aby włączyć funkcje Cast Connect na potrzeby tworzenia aplikacji, musisz zarejestrować w konsoli programisty Cast numer seryjny wbudowanego Chromecasta w urządzeniu z Androidem TV, którego będziesz używać. Aby znaleźć numer seryjny, na Androidzie TV wybierz Ustawienia > Ustawienia urządzenia > Wbudowany Chromecast > Numer seryjny. Pamiętaj, że różni się on od numeru seryjnego urządzenia fizycznego i trzeba go uzyskać metodą opisaną powyżej.

Obraz ekranu Androida TV, na którym widać ekran „Wbudowany Chromecast” oraz numer wersji i numer seryjny

Ze względów bezpieczeństwa bez rejestracji Cast Connect będzie działać tylko w aplikacjach zainstalowanych ze Sklepu Google Play. Po 15 minutach od rozpoczęcia procesu rejestracji ponownie uruchom urządzenie.

Zainstaluj aplikację nadawcy na Androida

Aby przetestować wysyłanie żądań z urządzenia mobilnego, udostępniliśmy prostą aplikację nadawcy o nazwie Prześlij filmy w pliku mobile-sender-0629.apk w pliku ZIP z kodem źródłowym. Wykorzystamy ADB do zainstalowania pliku APK. Jeśli masz już zainstalowaną inną wersję Cast Video, zanim przejdziesz dalej, odinstaluj ją ze wszystkich profili znajdujących się na urządzeniu.

  1. Na telefonie z Androidem włącz opcje programisty i debugowanie USB.
  2. Podłącz kabel USB do transmisji danych, aby połączyć telefon z Androidem z komputerem, z którego korzystasz.
  3. Zainstaluj aplikację mobile-sender-0629.apk na telefonie z Androidem.

Obraz okna terminala uruchamiającego polecenie instalacji adb w celu instalacji mobile-sender.apk

  1. Aplikację nadawcy Przesyłaj filmy znajdziesz na telefonie z Androidem. Ikona aplikacji nadawcy przesyłania filmów

Obraz przedstawiający aplikację nadawcy przesyłania filmów, która działa na ekranie telefonu z Androidem

Zainstaluj aplikację Android TV

Poniżej znajdziesz instrukcje otwierania i uruchamiania ukończonej przykładowej aplikacji w Android Studio:

  1. Wybierz Importuj projekt na ekranie powitalnym lub opcje menu Plik > Nowy > Importuj projekt...
  2. Wybierz katalog ikona folderuapp-done z folderu z przykładowym kodem i kliknij OK.
  3. Kliknij Plik > Projekt synchronizacji w Android App Studio z przyciskiem Gradle Synchronizuj projekt z plikami Gradle.
  4. Na urządzeniu z Androidem TV włącz opcje programisty i debugowanie USB.
  5. Połącz się przez ADB z urządzeniem z Androidem TV, urządzenie powinno być widoczne w Android Studio. Obraz przedstawiający urządzenie z Androidem TV na pasku narzędzi Android Studio
  6. Kliknij przycisk Przycisk Android Studio Run i zielony trójkąt skierowany w prawoUruchom. Aplikacja ATV o nazwie Cast Connect Codelab powinna się pojawić po kilku sekundach.

Zagrajmy w Cast Connect w aplikacji ATV

  1. Otwórz ekran główny Androida TV.
  2. Na telefonie z Androidem otwórz aplikację nadawcy przesyłających filmy. Kliknij przycisk Cast Ikona przycisku Cast i wybierz swoje urządzenie ATV.
  3. Aplikacja Cast Connect Codelab ATV zostanie uruchomiona na Twoim ATV, a przycisk Cast u nadawcy będzie oznaczał połączenie z siecią Ikona przycisku przesyłania w odwróconych kolorach.
  4. Wybierz film z aplikacji ATV, a rozpocznie się jego odtwarzanie.
  5. Na telefonie komórkowym minikontroler jest teraz widoczny w dolnej części aplikacji nadawcy. Odtwarzaniem możesz sterować przyciskiem odtwarzania/wstrzymywania.
  6. Wybierz film z telefonu komórkowego i odtwórz go. Rozpocznie się odtwarzanie filmu na urządzeniu ATV, a rozwinięty kontroler pojawi się na urządzeniu nadawcy.
  7. Zablokuj telefon, a po jego odblokowaniu powinno pojawić się powiadomienie na ekranie blokady umożliwiające sterowanie odtwarzaniem multimediów lub zatrzymanie przesyłania.

Obraz sekcji ekranu telefonu z Androidem z miniodtwarzaczem odtwarzającym film

4. Przygotuj projekt początkowy

Po sprawdzeniu integracji Cast Connect możemy dodać obsługę Cast Connect do pobranej aplikacji startowej. Możesz teraz utworzyć kampanię wykorzystującą projekt początkowy w Android Studio:

  1. Wybierz Importuj projekt na ekranie powitalnym lub opcje menu Plik > Nowy > Importuj projekt...
  2. Wybierz katalog ikona folderuapp-start z folderu z przykładowym kodem i kliknij OK.
  3. Kliknij Plik > Projekt synchronizacji w Android Studio z przyciskiem Gradle Synchronizuj projekt z plikami Gradle.
  4. Wybierz urządzenie ATV i kliknij przycisk Przycisk Uruchom w Android Studio, zielony trójkąt skierowany w prawoUruchom, aby uruchomić aplikację i poznać interfejs. Pasek narzędzi Android Studio przedstawiający wybrane urządzenie z Androidem TV

Grafika przedstawiająca serię miniatur filmów (z których jedna jest podświetlona) nakładającą się na pełnoekranowy podgląd filmu. W prawym górnym rogu widać napis „Cast Connect”

Projektowanie aplikacji

Aplikacja zawiera listę filmów, które użytkownik może przeglądać. Użytkownicy mogą wybrać film do obejrzenia na Androidzie TV. Aplikacja składa się z 2 głównych aktywności: MainActivity i PlaybackActivity.

MainActivity

To działanie zawiera fragment (MainFragment). Lista filmów i powiązane z nimi metadane są skonfigurowane w klasie MovieList, a metoda setupMovies() zostaje wywołana do utworzenia listy obiektów Movie.

Obiekt Movie reprezentuje element filmu z tytułem, opisem, miniaturami obrazu i adresem URL filmu. Każdy obiekt Movie jest powiązany z obiektem CardPresenter, który umożliwia prezentowanie miniatury filmu z tytułem i studio oraz przekazywany do ArrayObjectAdapter.

Po wybraniu elementu odpowiedni obiekt Movie jest przekazywany do PlaybackActivity.

PlaybackActivity

Ta aktywność zawiera fragment (PlaybackVideoFragment), który hostuje element VideoView z elementem ExoPlayer, niektóre elementy sterujące multimediami oraz obszar tekstowy pozwalający pokazać opis wybranego filmu i umożliwiać użytkownikowi jego odtworzenie na Androidzie TV. Użytkownik może włączać i wstrzymywać odtwarzanie oraz przewijać film za pomocą pilota.

Wymagania wstępne dotyczące Cast Connect

Cast Connect korzysta z nowych wersji Usług Google Play, które wymagają zaktualizowania aplikacji ATV tak, aby używała przestrzeni nazw AndroidX.

Aby obsługiwać Cast Connect w aplikacji na Androida TV, musisz tworzyć i obsługiwać zdarzenia z sesji multimedialnych. Biblioteka Cast Connect generuje stan multimediów na podstawie stanu sesji multimediów. Sesja multimedialna jest też używana przez bibliotekę Cast Connect do zasygnalizowania, że otrzymała określone wiadomości od nadawcy (np. wstrzymanie).

5. Konfigurowanie obsługi przesyłania

Zależności

Zaktualizuj plik build.gradle aplikacji, aby zawierał niezbędne zależności biblioteki:

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

Zsynchronizuj projekt, aby sprawdzić, czy kompilacje projektu nie zawierają błędów.

Zdarzenie inicjujące

CastReceiverContext to pojedynczy obiekt do koordynowania wszystkich interakcji Cast. Musisz zaimplementować interfejs ReceiverOptionsProvider, aby udostępnić CastReceiverOptions po zainicjowaniu CastReceiverContext.

Utwórz plik CastReceiverOptionsProvider.kt i dodaj do projektu te klasy:

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

Następnie określ dostawcę opcji odbiorcy w tagu <application> w pliku AndroidManifest.xml aplikacji:

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

Aby połączyć się z aplikacją ATV od nadawcy przesyłającego, wybierz aktywność, którą chcesz uruchomić. W ramach tego ćwiczenia z programowania po rozpoczęciu sesji przesyłania uruchomimy aplikację MainActivity. W pliku AndroidManifest.xml dodaj filtr intencji uruchamiania w elemencie MainActivity.

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

Cykl życia kontekstu odbiornika Cast

Uruchomienie CastReceiverContext po uruchomieniu aplikacji i zatrzymanie CastReceiverContext, gdy aplikacja przejdzie w tle. Do zarządzania wywoływaniem CastReceiverContext.start() i CastReceiverContext.stop() zalecamy korzystanie z aplikacji LifecycleObserver z biblioteki androidx.lifecycle

Otwórz plik MyApplication.kt i zainicjuj kontekst przesyłania, wywołując initInstance() w metodzie onCreate aplikacji. W klasie start() w klasie AppLifeCycleObserver: CastReceiverContext, gdy aplikacja jest wznawiana, i stop(), gdy aplikacja jest wstrzymana:

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

Łączenie obiektów MediaSession z Menedżerem mediów

MediaManager jest właściwością singletonu CastReceiverContext, zarządza stanem multimediów, obsługuje intencję wczytywania, przekształca wiadomości z przestrzeni nazw multimediów od nadawców na polecenia związane z multimediami i wysyła stan multimediów z powrotem do nadawców.

Gdy tworzysz element MediaSession, musisz też podać bieżący token MediaSession organizacji MediaManager, aby wiedział, dokąd ma wysłać polecenia i pobrać stan odtwarzania multimediów. W pliku PlaybackVideoFragment.kt upewnij się, że MediaSession został zainicjowany przed ustawieniem tokena na MediaManager.

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

        }
    }
}

Gdy zwolnisz MediaSession z powodu nieaktywnego odtwarzania, ustaw token o wartości null w MediaManager:

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

Uruchom przykładową aplikację

Kliknij przycisk Przycisk Uruchom w Android Studio, zielony trójkąt skierowany w prawoUruchom, aby wdrożyć aplikację na urządzeniu ATV, ją zamknąć i wrócić do ekranu głównego ATV. Nadawca kliknij przycisk przesyłania Ikona przycisku przesyłania i wybierz swoje urządzenie ATV. Aplikacja ATV zostanie uruchomiona na urządzeniu ATV, a stan przycisku przesyłania będzie podłączony.

6. Wczytuję multimedia

Polecenie wczytywania jest wysyłane przez intencję o nazwie pakietu określonej w konsoli programisty. Aby określić aktywność docelową, która otrzyma tę intencję, w aplikacji na Androida TV musisz dodać ten wstępnie zdefiniowany filtr intencji. W pliku AndroidManifest.xml dodaj filtr intencji wczytywania do elementu PlayerActivity:

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

Obsługa żądań obciążenia na Androidzie TV

Skoro działanie jest skonfigurowane tak, aby odbierało tę intencję zawierającą żądanie wczytania, musimy ją obsłużyć.

Po rozpoczęciu aktywności aplikacja wywołuje prywatną metodę o nazwie processIntent. Ta metoda zawiera logikę przetwarzania przychodzących intencji. Aby obsłużyć żądanie wczytania, zmodyfikujemy tę metodę i wyślemy intencję do dalszego przetworzenia, wywołując metodę onNewIntent instancji MediaManager. Jeśli MediaManager wykryje, że intencja jest żądaniem wczytania, wyodrębnia obiekt MediaLoadRequestData z intencji i wywołuje MediaLoadCommandCallback.onLoad(). Zmodyfikuj metodę processIntent w pliku PlaybackVideoFragment.kt, aby obsługiwać intencję zawierającą żądanie wczytania:

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

Następnie rozszerzymy klasę abstrakcyjną MediaLoadCommandCallback, która zastąpi metodę onLoad() wywołaną przez MediaManager. Ta metoda odbiera dane żądania wczytania i konwertuje je na obiekt Movie. Po przekonwertowaniu film jest odtwarzany w lokalnym odtwarzaczu. Następnie MediaManager zostaje zaktualizowany przy użyciu MediaLoadRequest i rozpowszechnia MediaStatus do połączonych nadawców. Utwórz zagnieżdżoną klasę prywatną o nazwie MyMediaLoadCommandCallback w pliku PlaybackVideoFragment.kt:

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
}

Po zdefiniowaniu wywołania zwrotnego musimy je zarejestrować w: MediaManager. Wywołanie zwrotne musi zostać zarejestrowane przed wywołaniem funkcji MediaManager.onNewIntent(). Dodaj setMediaLoadCommandCallback po zainicjowaniu odtwarzacza:

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

Uruchom przykładową aplikację

Kliknij przycisk Przycisk Uruchom w Android Studio, zielony trójkąt skierowany w prawoUruchom, aby wdrożyć aplikację na urządzeniu ATV. Nadawca kliknij przycisk przesyłania Ikona przycisku Cast i wybierz swoje urządzenie ATV. Aplikacja ATV zostanie uruchomiona na urządzeniu ATV. Wybierz film na urządzeniu mobilnym. Rozpocznie się odtwarzanie filmu na ATV. Sprawdź, czy na telefonie pojawiło się powiadomienie z elementami sterującymi odtwarzaniem. Użyj elementów sterujących, takich jak Wstrzymaj, Wstrzymaj film na urządzeniu ATV.

7. Obsługa poleceń sterowania przesyłaniem

Bieżąca aplikacja obsługuje teraz podstawowe polecenia, takie jak odtwarzanie, wstrzymywanie i przewijanie, które są zgodne z sesją multimediów. Niektóre polecenia sterowania przesyłaniem są jednak niedostępne w sesji multimediów. Musisz zarejestrować MediaCommandCallback, by obsługiwać te polecenia sterowania przesyłaniem.

Dodaj MyMediaCommandCallback do instancji MediaManager za pomocą polecenia setMediaCommandCallback po zainicjowaniu odtwarzacza:

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

Utwórz klasę MyMediaCommandCallback, aby zastąpić metody, takie jak onQueueUpdate() do obsługi tych poleceń sterujących przesyłaniem:

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. Praca ze stanem multimediów

Modyfikowanie stanu multimediów

Cast Connect pobiera stan podstawowych multimediów z sesji multimediów. Aby obsługiwać funkcje zaawansowane, aplikacja na Androida TV może określać i zastępować dodatkowe właściwości stanu za pomocą polecenia MediaStatusModifier. MediaStatusModifier zawsze będzie działać na MediaSession ustawionym w sekcji CastReceiverContext.

Aby np. określić wartość setMediaCommandSupported po wywołaniu wywołania zwrotnego onLoad:

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

Przechwytywanie MediaStatusu przed wysłaniem

Podobnie jak w przypadku pakietu MessageInterceptor pakietu SDK odbiorcy internetowego, możesz określić obiekt MediaStatusWriter w MediaManager, aby wprowadzić dodatkowe zmiany w pakiecie MediaStatus, zanim zostanie on rozesłany do połączonych nadawców.

Zanim wyślesz wiadomość do nadawców na urządzenia mobilne, możesz na przykład ustawić w komórce MediaStatus niestandardowe dane:

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

Wiesz już, jak włączyć przesyłanie w aplikacji na Androida TV za pomocą biblioteki Cast Connect.

Więcej informacji znajdziesz w przewodniku dla programistów: /cast/docs/android_tv_receiver.