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

1. Omówienie

W tym laboratorium programistycznym dowiesz się, jak zmodyfikować istniejącą aplikację na Androida TV, aby obsługiwała przesyłanie i komunikację z dotychczasowymi aplikacjami przesyłającymi.

Co to jest Google Cast i Cast Connect?

Google Cast umożliwia użytkownikom przesyłanie treści z urządzenia mobilnego na telewizor. Typowa sesja Google Cast składa się z 2 komponentów: aplikacji nadawcy i aplikacji odbiorcy. Aplikacje nadawców, takie jak aplikacja mobilna lub strona internetowa, np. Youtube.com, inicjują odtwarzanie w aplikacji odbiornika Cast i kontrolują je. Aplikacje odbiornika przesyłania treści to aplikacje HTML 5, które działają na Chromecastach i urządzeniach z Androidem TV.

Prawie wszystkie dane dotyczące stanu sesji Cast są przechowywane w aplikacji odbiorczej. Gdy stan się zmieni, na przykład gdy zostanie załadowany nowy element multimedialny, stan multimediów zostanie przesłany do wszystkich nadawców. Te transmisje zawierają bieżący stan sesji przesyłania. Aplikacje nadawcy używają tego stanu multimediów do wyświetlania informacji o odtwarzaniu w interfejsie.

Cast Connect opiera się na tej infrastrukturze, a aplikacja na Androida TV pełni rolę odbiornika. Biblioteka Cast Connect umożliwia aplikacji na Androida TV odbieranie wiadomości i stanów transmisji multimediów tak, jakby była aplikacją odbiorczą Google Cast.

Co będziemy budować?

Po ukończeniu tego ćwiczenia w programowaniu możesz używać aplikacji przesyłających Cast, aby przesyłać filmy do aplikacji na Androida TV. Aplikacja na Androida TV może też komunikować się z aplikacjami nadawców za pomocą protokołu Cast.

Czego się nauczysz

• Jak dodać bibliotekę Cast Connect do przykładowej aplikacji ATV
• Jak połączyć urządzenie przesyłające treści i uruchomić aplikację na Apple TV.
• Jak rozpocząć odtwarzanie multimediów w aplikacji ATV z aplikacji przesyłającej treści do Chromecasta.
• Jak wysyłać stan multimediów z aplikacji ATV do aplikacji przesyłających treści do Chromecasta

Czego potrzebujesz

• najnowszy pakiet SDK na Androida;
• najnowsze Android Studio, Dotyczy to wersji Chipmunk | 2021.2.1 lub nowszych.
• urządzenie Android TV z włączonymi opcjami dla programistów i debugowaniem przez USB.
• telefon z Androidem z włączonymi opcjami programisty i debugowaniem przez USB.
• Kabel USB do przesyłania danych, który umożliwia podłączenie telefonu z Androidem i urządzeń Android TV do komputera programisty.
• podstawowa znajomość tworzenia aplikacji na Androida za pomocą Kotlina;

2. Pobieranie przykładowego kodu

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

file_downloadPobierz kod źródłowy

i rozpakuj pobrany plik ZIP.

3. Uruchamianie przykładowej aplikacji

Najpierw zobaczmy, jak wygląda gotowa przykładowa aplikacja. Aplikacja na Androida TV korzysta z interfejsu Leanback i podstawowego odtwarzacza wideo. Użytkownik może wybrać film z listy, który po jego wybraniu będzie odtwarzany na telewizorze. Użytkownik może też przesłać film do aplikacji na Androida TV za pomocą odpowiedniej aplikacji mobilnej.

Rejestrowanie urządzeń dewelopera

Aby móc korzystać z funkcji Cast Connect podczas tworzenia aplikacji, musisz w konsoli programisty Cast zarejestrować numer seryjny wbudowanego Chromecasta w urządzeniu z Androidem TV. Numer seryjny znajdziesz w ustawieniach Androida TV, wybierając Ustawienia > Ustawienia urządzenia > Chromecast wbudowany > Numer seryjny. Numer seryjny różni się od numeru seryjnego urządzenia fizycznego i należy go uzyskać za pomocą opisanej powyżej metody.

Z powodów bezpieczeństwa funkcja Cast Connect będzie działać tylko w przypadku aplikacji zainstalowanych ze Sklepu Google Play. Po 15 minutach od rozpoczęcia procesu rejestracji uruchom urządzenie ponownie.

Instalowanie aplikacji nadawcy na Androida

Aby przetestować wysyłanie żądań z urządzenia mobilnego, udostępniliśmy prostą aplikację nadawczą o nazwie Cast Videos jako plik mobile-sender-0629.apk w pobieranym archiwum kodu źródłowego. Aby zainstalować plik APK, użyjemy narzędzia ADB. Jeśli masz już zainstalowaną inną wersję aplikacji Cast Videos, przed kontynuacją odinstaluj tę wersję ze wszystkich profili na urządzeniu.

1. Włącz opcje programisty i debugowanie USB na telefonie z Androidem.
2. Podłącz telefon z Androidem do komputera programistycznego za pomocą kabla USB.
3. Zainstaluj mobile-sender-0629.apk na telefonie z Androidem.

4. Aplikację do przesyłania filmów znajdziesz na telefonie z Androidem.

Instalowanie aplikacji Android TV

W tych instrukcjach dowiesz się, jak otworzyć i uruchomić gotową przykładową aplikację w Android Studio:

1. Na ekranie powitalnym wybierz Importuj projekt lub kliknij Plik > Nowy > Importuj projekt….
2. W folderze z przykładowym kodem wybierz katalog app-done i kliknij OK.
3. Kliknij Plik > Synchronizuj projekt z plikami Gradle.
4. Włącz opcje programisty i debugowanie USB na urządzeniu z Androidem TV.
5. Połącz się z urządzeniem Android TV za pomocą ADB. Urządzenie powinno być widoczne w Android Studio.
6. Kliknij przycisk Uruchom. Po kilku sekundach powinna się pojawić aplikacja ATV o nazwie Cast Connect Codelab.

Zagraj w Cast Connect w aplikacji ATV

1. Otwórz ekran główny Androida TV.
2. Na telefonie z Androidem otwórz aplikację dla nadawców filmów Cast. Kliknij przycisk przesyłania  i wybierz urządzenie ATV.
3. Na telewizorze ATV uruchomi się aplikacja Cast Connect Codelab ATV, a przycisk przesyłania na urządzeniu nadawczym będzie wskazywać, że połączenie zostało nawiązane.
4. Wybierz film w aplikacji ATV, a następnie rozpocznie się jego odtwarzanie na urządzeniu.
5. Na telefonie komórkowym u dołu aplikacji nadawczej będzie widoczny minikontroler. Możesz nim sterować odtwarzaniem, używając przycisku odtwarzania/wstrzymywania.
6. Wybierz film z telefonu i odtwórz go. Film zacznie się odtwarzać na urządzeniu ATV, a na urządzeniu mobilnym wyświetli się rozszerzony kontroler.
7. Zablokuj telefon, a gdy go odblokujesz, na ekranie blokady powinno pojawić się powiadomienie umożliwiające sterowanie odtwarzaniem multimediów lub zatrzymanie przesyłania.

4. Przygotowanie projektu startowego

Po zweryfikowaniu integracji Cast Connect w ukończonej aplikacji musimy dodać obsługę Cast Connect do pobranej aplikacji startowej. Teraz możesz zacząć tworzyć projekt początkowy przy użyciu Android Studio:

1. Na ekranie powitalnym wybierz Importuj projekt lub kliknij Plik > Nowy > Importuj projekt….
2. W folderze z przykładowym kodem wybierz katalog app-start i kliknij OK.
3. Kliknij Plik > Synchronizuj projekt z plikami Gradle.
4. Wybierz urządzenie ATV i kliknij przycisk Uruchom, aby uruchomić aplikację i poznać interfejs.

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 działań: MainActivity i PlaybackActivity.

MainActivity

Ta aktywność zawiera fragment (MainFragment). Lista filmów i powiązane z nimi metadane są skonfigurowane w klasie MovieList, a metoda setupMovies() jest wywoływana w celu utworzenia listy obiektów Movie.

Obiekt Movie reprezentuje element wideo z tytułem, opisem, miniaturami obrazu i adresem URL filmu. Każdy obiekt Movie jest powiązany z elementem CardPresenter, który przedstawia miniaturę filmu z tytułem i studiem, a następnie przekazywany do ArrayObjectAdapter.

Po wybraniu elementu do obiektu PlaybackActivity przekazywany jest odpowiedni obiekt Movie.

PlaybackActivity

Ta aktywność zawiera fragment (PlaybackVideoFragment), który hostuje VideoView z ExoPlayer, niektóre elementy sterujące multimediami oraz obszar tekstowy do wyświetlania opisu wybranego filmu. Umożliwia też użytkownikowi odtworzenie filmu na Android TV. Użytkownik może używać pilota do odtwarzania/wstrzymywania lub przewijania filmów.

Wymagania wstępne Cast Connect

Cast Connect używa nowych wersji Usług Google Play, które wymagają zaktualizowania aplikacji ATV, aby można było używać przestrzeni nazw AndroidX.

Aby obsługiwać Cast Connect w aplikacji na Androida TV, musisz utworzyć i obsługiwać zdarzenia z sesji multimedialnej. Biblioteka Cast Connect generuje stan multimediów na podstawie stanu sesji multimediów. Twoja sesja multimediów jest też używana przez bibliotekę Cast Connect do sygnalizowania, że otrzymała określone wiadomości od nadawcy, np. o wstrzymaniu.

5. Konfigurowanie obsługi przesyłania

Zależności

Zaktualizuj plik build.gradle aplikacji, aby uwzględnić 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 kompilacja przebiega bez błędów.

Zdarzenie inicjujące

CastReceiverContext to obiekt typu singleton służący do koordynowania wszystkich interakcji z Cast. Aby udostępnić CastReceiverOptions po uruchomieniu CastReceiverContext, musisz zaimplementować interfejs ReceiverOptionsProvider.

Utwórz plik CastReceiverOptionsProvider.kt i dodaj do projektu tę klasę:

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 w tagu <application> pliku aplikacji AndroidManifest.xml określ dostawcę opcji odbiornika:

<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 za pomocą nadawcy Cast, wybierz aktywność, którą chcesz uruchomić. W tym laboratorium kodu uruchomimy MainActivity aplikacji, gdy rozpocznie się sesja przesyłania. W pliku AndroidManifest.xml dodaj filtr intencji uruchamiania w pliku 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 przesyłania

CastReceiverContext należy uruchomić, gdy aplikacja zostanie uruchomiona, a CastReceiverContext – gdy przejdzie ona do działania w tle. Aby zarządzać wywoływaniem funkcji CastReceiverContext.start() i CastReceiverContext.stop(), zalecamy użycie funkcji LifecycleObserver z biblioteki androidx.lifecycle.

Otwórz plik MyApplication.kt, zainicjuj kontekst przesyłania, wywołując funkcję initInstance() w metodzie onCreate aplikacji. W klasie AppLifeCycleObserver start() obiekt CastReceiverContext po wznowieniu aplikacji oraz 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 MediaSession z MediaManager

MediaManager jest właściwością elementu jednokrotnego CastReceiverContext, który zarządza stanem multimediów, obsługuje intencję wczytywania, tłumaczy wiadomości z przestrzeni nazw multimediów od nadawców na polecenia multimedialne oraz wysyła stan multimediów z powrotem do nadawców.

Podczas tworzenia MediaSession musisz też podać organizacji MediaManager bieżący token MediaSession, aby wiedział, dokąd wysłać polecenia i pobrać stan odtwarzania multimediów. W pliku PlaybackVideoFragment.kt sprawdź, czy zmienna MediaSession została zainicjowana, zanim ustawisz token 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 MediaSession zostanie zwolnione z powodu braku aktywności, należy ustawić w nim token null:MediaManager

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

Uruchamianie przykładowej aplikacji

Kliknij przycisk Uruchom, aby wdrożyć aplikację na urządzeniu ATV, zamknąć aplikację i wrócić do ekranu głównego ATV. Na urządzeniu nadawcy kliknij przycisk przesyłania  i wybierz urządzenie ATV. Na urządzeniu ATV uruchomi się aplikacja ATV, a stan przycisku Cast będzie wskazywać, że jest ono połączone.

6. Wczytywanie multimediów

Polecenie wczytywania jest wysyłane za pomocą intencji z nazwą pakietu określoną przez Ciebie w konsoli programisty. Aby określić docelową aktywność, która będzie odbierać tę intencję, musisz dodać w aplikacji na Androida TV podany poniżej wstępnie zdefiniowany filtr intencji. W pliku AndroidManifest.xml dodaj do PlayerActivity filtr intencji wczytywania:

<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ń wczytywania na Androidzie TV

Działania są teraz skonfigurowane tak, aby odbierać ten zamiar zawierający żądanie wczytania. Musimy teraz je obsłużyć.

Gdy aktywność się rozpoczyna, aplikacja wywołuje prywatną metodę o nazwie processIntent. Ta metoda zawiera logikę przetwarzania przychodzących intencji. Aby obsłużyć żądanie załadowania, zmodyfikujemy tę metodę i wyślemy intencję do dalszego przetwarzania, wywołując metodę onNewIntent instancji MediaManager. Jeśli MediaManager wykryje, że intencja jest żądaniem załadowania, wyodrębnia z niej obiekt MediaLoadRequestData i wywołuje MediaLoadCommandCallback.onLoad(). Zmodyfikuj metodę processIntent w pliku PlaybackVideoFragment.kt, aby obsłużyć 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 abstrakcyjną klasę MediaLoadCommandCallback, która zastąpi metodę onLoad() wywoływaną przez MediaManager. Ta metoda otrzymuje dane żądania wczytania i konwertuje je na obiekt Movie. Po przekonwertowaniu film jest odtwarzany przez lokalny odtwarzacz. Następnie MediaManager jest aktualizowany za pomocą MediaLoadRequest i przesyła MediaStatus do połączonych nadawców. Utwórz w pliku PlaybackVideoFragment.kt zagnieżdżoną klasę prywatną o nazwie 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
}

Teraz, gdy wywołanie zwrotne zostało zdefiniowane, musimy zarejestrować je w MediaManager. Wywołanie zwrotne musi zostać zarejestrowane przed wywołaniem funkcji MediaManager.onNewIntent(). Dodaj setMediaLoadCommandCallback, gdy odtwarzacz zostanie zainicjowany:

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 Uruchom, aby wdrożyć aplikację na urządzeniu ATV. Od nadawcy kliknij przycisk Cast i wybierz swoje urządzenie ATV. Aplikacja ATV zostanie uruchomiona na urządzeniach ATV. Wybierz film na urządzeniu mobilnym, a zacznie się on odtwarzać na urządzeniu ATV. Sprawdź, czy na telefonie, na którym masz elementy sterujące odtwarzaniem, pojawia się powiadomienie. Spróbuj użyć elementów sterujących, takich jak wstrzymanie. Film na urządzeniu ATV powinien zostać wstrzymany.

7. Obsługa poleceń sterowania przesyłaniem

Obecna aplikacja obsługuje teraz podstawowe polecenia zgodne z sesją multimedialną, takie jak odtwarzanie, wstrzymywanie i przewijanie. Niektóre polecenia sterowania przesyłaniem nie są jednak dostępne podczas sesji multimedialnej. Aby obsługiwać te polecenia sterowania Cast, musisz zarejestrować MediaCommandCallback.

Dodaj element MyMediaCommandCallback do instancji MediaManager przy użyciu 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(), i obsługiwać te polecenia sterowania Cast:

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 uzyskuje podstawowy stan 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ą MediaStatusModifier. MediaStatusModifier będzie zawsze działać na podstawie MediaSession ustawionego w CastReceiverContext.

Aby na przykład określić wartość setMediaCommandSupported, gdy zostanie wywołane 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 stanu multimediów przed wysłaniem

Podobnie jak w przypadku MessageInterceptor w SDK odbiornika internetowego, w MediaManager możesz określić MediaStatusWriter, aby wprowadzić dodatkowe zmiany w MediaStatus, zanim zostanie ono przesłane do połączonych nadawców.

Na przykład przed wysłaniem wiadomości do nadawców korzystających z urządzeń mobilnych możesz ustawić dane niestandardowe w MediaStatus:

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 na potrzeby aplikacji na Androida TV, korzystając z biblioteki Cast Connect.

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