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, np. 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 działa jako odbiornik. Biblioteka Cast Connect umożliwia aplikacji na Androida TV odbieranie wiadomości i stanu transmisji multimediów tak, jakby była aplikacją odbiorczą Google Cast.
Co będziemy budować?
Po ukończeniu tego ćwiczenia będziesz mieć możliwość korzystania z aplikacji przesyłających treści Cast do przesyłania filmów do aplikacji Android TV. Aplikacja Android TV może też komunikować się z aplikacją przesyłającą treści 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.
- Jak wysyłać stan multimediów z aplikacji ATV do aplikacji przesyłających treści za pomocą Google Cast.
Czego potrzebujesz
- najnowszy pakiet SDK na Androida;
- najnowsza wersja Android Studio; Dotyczy to wersji
Chipmunk | 2021.2.1lub 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...
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 następnie odtwarza się 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 włączyć funkcje Cast Connect na potrzeby tworzenia aplikacji, musisz zarejestrować numer seryjny urządzenia Google Cast na Androidzie TV, którego chcesz używać, w Konsoli programisty Cast. Numer seryjny znajdziesz w ustawieniach Androida TV, wybierając Ustawienia > Ustawienia urządzenia > Google Cast > Numer seryjny. Pamiętaj, że jest on inny niż numer seryjny Twojego fizycznego urządzenia i musisz 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 zrestartuj urządzenie.
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. Do zainstalowania pliku 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.
- Włącz opcje programisty i debugowanie USB na telefonie z Androidem.
- Podłącz telefon z Androidem do komputera programistycznego za pomocą kabla USB.
- Zainstaluj
mobile-sender-0629.apkna telefonie z Androidem.
- Aplikację do przesyłania filmów znajdziesz na telefonie z Androidem.
Instalowanie aplikacji Android TV
Aby otworzyć i uruchomić gotową przykładową aplikację w Android Studio, wykonaj te instrukcje:
- Na ekranie powitalnym wybierz Importuj projekt lub kliknij Plik > Nowy > Importuj projekt….
- W folderze z przykładowym kodem wybierz katalog
app-donei kliknij OK. - Kliknij Plik >
Synchronizuj projekt z plikami Gradle. - Włącz opcje programisty i debugowanie USB na urządzeniu z Androidem TV.
- Połącz się z urządzeniem Android TV za pomocą ADB. Urządzenie powinno być widoczne w Android Studio.
- Kliknij przycisk
Uruchom. Po kilku sekundach powinna pojawić się aplikacja ATV o nazwie Cast Connect Codelab.
Zagrajmy w aplikację Cast Connect z ATV
- Otwórz ekran główny Androida TV.
- Otwórz na telefonie z Androidem aplikację do przesyłania filmów za pomocą Google Cast. Kliknij przycisk przesyłania
i wybierz urządzenie ATV. - 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.
- Wybierz film w aplikacji ATV, a następnie rozpocznie się jego odtwarzanie na urządzeniu ATV.
- Na telefonie na dole aplikacji nadawczej będzie widoczny minikontroler. Możesz sterować odtwarzaniem za pomocą przycisku odtwarzania/wstrzymywania.
- 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.
- 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 tworzyć aplikację na podstawie projektu startowego w Android Studio:
- Na ekranie powitalnym wybierz Importuj projekt lub kliknij Plik > Nowy > Importuj projekt….
- W folderze z przykładowym kodem wybierz katalog
app-starti kliknij OK. - Kliknij Plik > Synchronizuj projekt z plikami Gradle.
- Wybierz urządzenie ATV i kliknij przycisk Uruchom, aby uruchomić aplikację i poznać interfejs użytkownika.
Projektowanie aplikacji
Aplikacja zawiera listę filmów, które użytkownik może przeglądać. Użytkownicy mogą wybrać film do odtworzenia na Android 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ązanych z nimi metadanych jest konfigurowana w klasie MovieList, a metoda setupMovies() jest wywoływana w celu utworzenia listy obiektów Movie.
Obiekt Movie reprezentuje element filmu z tytułem, opisem, miniaturami i adresem URL filmu. Każdy obiekt Movie jest powiązany z obiektem CardPresenter, aby wyświetlać miniaturę filmu z tytułem i studiem, i przekazywany do obiektu 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 podczas inicjowania CastReceiverContext udostępnić wartość CastReceiverOptions, 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 z wysyłacza, 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 uruchomienia w sekcji 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łaniami 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() jest CastReceiverContext, gdy aplikacja jest wznawiana, i stop(), gdy jest wstrzymywana:
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 to właściwość klasy singleton CastReceiverContext, która zarządza stanem multimediów, obsługuje intencję wczytania, tłumaczy wiadomości z przestrzeni nazw multimediów od nadawców na polecenia dotyczące multimediów i przesyła stan multimediów z powrotem do nadawców.
Podczas tworzenia MediaSession musisz też podać bieżący token MediaSession do usługi MediaManager, aby wiedziała, dokąd wysyłać polecenia i pobierać 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 zwolniony 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 on połączony.
6. Wczytywanie multimediów
Polecenie wczytania jest wysyłane za pomocą intencji z nazwą pakietu zdefiniowaną w konsoli dewelopera. 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
Teraz, gdy aktywność jest skonfigurowana tak, aby odbierać ten zamiar zawierający żądanie wczytania, musimy go 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 wczytania, 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(). Zmień 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. W pliku PlaybackVideoFragment.kt utwórz 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())
}
}
}
Uruchamianie przykładowej aplikacji
Kliknij przycisk Uruchom, aby wdrożyć aplikację na urządzeniu ATV. Na urządzeniu nadawcy kliknij przycisk przesyłania i wybierz urządzenie ATV. Aplikacja ATV zostanie uruchomiona na urządzeniu 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 MyMediaCommandCallback do instancji MediaManager za pomocą funkcji setMediaCommandCallback, gdy odtwarzacz zostanie zainicjowany:
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 z 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ą elementu 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 funkcji MessageInterceptor w SDK odbiornika internetowego możesz w funkcji MediaManager podać wartość MediaStatusWriter, aby wprowadzić dodatkowe zmiany w danych MediaStatus, zanim zostaną one przesłane do połączonych nadawców.
Możesz na przykład ustawić dane niestandardowe w sekcji MediaStatus przed wysłaniem do nadawców z urządzeń mobilnych:
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
Teraz już wiesz, jak włączyć przesyłanie aplikacji na Androida TV za pomocą biblioteki Cast Connect.
Więcej informacji znajdziesz w przewodniku dla programistów: /cast/docs/android_tv_receiver.