Dodawanie podstawowych funkcji do odbiornika Android TV

Ta strona zawiera fragmenty kodu i opisy funkcji umożliwiających dostosowanie aplikacji odbiornika Android TV.

Konfigurowanie bibliotek

Aby udostępnić interfejsy Cast Connect API w aplikacji na Androida TV:

Android
  1. Otwórz plik build.gradle w katalogu modułu aplikacji.
  2. Sprawdź, czy google() znajduje się na liście repositories. 
      repositories {
    google()
  }
  3. W zależności od typu urządzenia docelowego aplikacji dodaj do zależności najnowsze wersje bibliotek:
    • W przypadku aplikacji Android Receiver: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast-tv:21.1.0'
    implementation 'com.google.android.gms:play-services-cast:21.5.0'
  }
    • W przypadku aplikacji Android Sender: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast:21.1.0'
    implementation 'com.google.android.gms:play-services-cast-framework:21.5.0'
  }
    Pamiętaj, aby aktualizować ten numer wersji przy każdej aktualizacji usług.
  4. Zapisz zmiany i kliknij Sync Project with Gradle Files na pasku narzędzi.
iOS
  1. Upewnij się, że Podfile jest kierowana na google-cast-sdk w wersji 4.8.1 lub nowszej
  2. być kierowana na system iOS 14 lub nowszy, Więcej informacji znajdziesz w informacjach o wersji. 
      platform: ios, '14'

  def target_pods
     pod 'google-cast-sdk', '~>4.8.1'
  end
Sieć
  1. Wymaga przeglądarki Chromium M87 lub nowszej.
  2. Dodaj bibliotekę interfejsu Web Sender API do projektu 
      <script src="//www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"></script>

Wymagania dotyczące AndroidaX

Nowe wersje Usług Google Play wymagają aktualizacji aplikacji tak, aby korzystały z przestrzeni nazw androidx. Wykonaj instrukcje migracji na AndroidaX.

Aplikacja na Androida TV – wymagania wstępne

Aby obsługiwać Cast Connect w aplikacji na Androida TV, musisz tworzyć zdarzenia z sesji multimediów i obsługiwać je. Dane dostarczone przez sesję multimediów zawierają podstawowe informacje o stanie multimediów – takie jak pozycja czy stan odtwarzania. Sesja multimediów jest też wykorzystywana przez bibliotekę Cast Connect do sygnalizowania, że otrzymała określone wiadomości od nadawcy, np. opcję wstrzymania.

Więcej informacji o sesji multimediów i inicjowaniu takiej sesji znajdziesz w przewodniku po pracy z multimediami.

Cykl życia sesji multimediów

Aplikacja powinna utworzyć sesję multimediów w momencie rozpoczęcia odtwarzania i zwolnić ją, gdy nie będzie już można nią sterować. Jeśli na przykład Twoja aplikacja służy do odtwarzania filmów, musisz ją zwolnić, gdy użytkownik zakończy odtwarzanie – wybierając „Wstecz”, by przeglądać inne treści, lub uruchamiając aplikację w tle. Jeśli Twoja aplikacja to aplikacja muzyczna, zwolnij ją, gdy aplikacja nie będzie już odtwarzać żadnych multimediów.

Aktualizuję stan sesji

Dane w sesji multimediów powinny być na bieżąco aktualizowane wraz ze stanem odtwarzacza. Gdy na przykład odtwarzanie jest wstrzymane, należy zaktualizować stan odtwarzania oraz listę obsługiwanych działań. W tabelach poniżej znajdziesz informacje o stanach, które musisz aktualizować.

MediaMetadataCompat

Pole metadanych Opis
METADATA_KEY_TITLE (wymagany) Tytuł multimediów.
METADATA_KEY_DISPLAY_SUBTITLE Podtytuł.
METADATA_KEY_DISPLAY_ICON_URI Adres URL ikony.
METADATA_KEY_DURATION (wymagane) Czas trwania multimediów.
METADATA_KEY_MEDIA_URI Content ID
METADATA_KEY_ARTIST Wykonawca
METADATA_KEY_ALBUM Album.

PlaybackStateCompat

Wymagana metoda Opis
setActions() Ustawia obsługiwane polecenia multimedialne.
setState() Ustaw stan odtwarzania i bieżącą pozycję.

MediaSessionCompat

Wymagana metoda Opis
setRepeatMode() Ustawia tryb powtarzania.
setShuffleMode() Ustawia tryb odtwarzania losowego.
setMetadata() Ustawia metadane multimediów.
setPlaybackState() Ustawia stan odtwarzania.
Kotlin
private fun updateMediaSession() {
    val metadata = MediaMetadataCompat.Builder()
         .putString(MediaMetadataCompat.METADATA_KEY_TITLE, "title")
         .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, "subtitle")
         .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI, mMovie.getCardImageUrl())
         .build()

    val playbackState = PlaybackStateCompat.Builder()
         .setState(
             PlaybackStateCompat.STATE_PLAYING,
             player.getPosition(),
             player.getPlaybackSpeed(),
             System.currentTimeMillis()
        )
         .build()

    mediaSession.setMetadata(metadata)
    mediaSession.setPlaybackState(playbackState)
}
Java
private void updateMediaSession() {
  MediaMetadataCompat metadata =
      new MediaMetadataCompat.Builder()
          .putString(MediaMetadataCompat.METADATA_KEY_TITLE, "title")
          .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, "subtitle")
          .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI,mMovie.getCardImageUrl())
          .build();

  PlaybackStateCompat playbackState =
      new PlaybackStateCompat.Builder()
          .setState(
               PlaybackStateCompat.STATE_PLAYING,
               player.getPosition(),
               player.getPlaybackSpeed(),
               System.currentTimeMillis())
          .build();

  mediaSession.setMetadata(metadata);
  mediaSession.setPlaybackState(playbackState);
}

Obsługa kontroli transportu

Aplikacja powinna wdrożyć wywołanie zwrotne kontroli transportu sesji multimediów. W tabeli poniżej podano, jakie działania sterujące transportem muszą obsługiwać:

MediaSessionCompat.Callback

Działania Opis
onPlay() Wznów
onPause() Wstrzymaj
onSeekTo(), Szukaj pozycji
onStop() Zatrzymaj bieżące multimedia
Kotlin
class MyMediaSessionCallback : MediaSessionCompat.Callback() {
  override fun onPause() {
    // Pause the player and update the play state.
    ...
  }

  override fun onPlay() {
    // Resume the player and update the play state.
    ...
  }

  override fun onSeekTo (long pos) {
    // Seek and update the play state.
    ...
  }
  ...
}

mediaSession.setCallback( MyMediaSessionCallback() );
Java
public MyMediaSessionCallback extends MediaSessionCompat.Callback {
  public void onPause() {
    // Pause the player and update the play state.
    ...
  }

  public void onPlay() {
    // Resume the player and update the play state.
    ...
  }

  public void onSeekTo (long pos) {
    // Seek and update the play state.
    ...
  }
  ...
}

mediaSession.setCallback(new MyMediaSessionCallback());

Konfigurowanie obsługi przesyłania

Gdy aplikacja wysyłająca wysyła żądanie uruchomienia, intencja tworzona jest z przestrzenią nazw aplikacji. Twoja aplikacja odpowiada za jej obsługę i utworzenie instancji obiektu CastReceiverContext po uruchomieniu aplikacji TV. Obiekt CastReceiverContext jest potrzebny do interakcji z przesyłaniem podczas działania aplikacji TV. Ten obiekt umożliwia aplikacji telewizyjnej akceptowanie wiadomości multimedialnych przesyłanych od wszystkich połączonych nadawców.

Konfiguracja Androida TV

Dodawanie filtra intencji uruchomienia

Dodaj nowy filtr intencji do działania, które ma obsługiwać intencję uruchomienia z aplikacji nadawcy:

<activity android:name="com.example.activity">
  <intent-filter>
      <action android:name="com.google.android.gms.cast.tv.action.LAUNCH" />
      <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

Określ dostawcę opcji odbiorcy

Musisz zaimplementować obiekt ReceiverOptionsProvider, aby udostępnić CastReceiverOptions:

Kotlin
class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
          .setStatusText("My App")
          .build()
    }
}
Java
public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        .setStatusText("My App")
        .build();
  }
}

Następnie określ dostawcę opcji w pliku AndroidManifest:

 <meta-data
    android:name="com.google.android.gms.cast.tv.RECEIVER_OPTIONS_PROVIDER_CLASS_NAME"
    android:value="com.example.mysimpleatvapplication.MyReceiverOptionsProvider" />

ReceiverOptionsProvider jest używany do podawania CastReceiverOptions po zainicjowaniu CastReceiverContext.

Kontekst odbiornika

Po utworzeniu aplikacji zainicjuj CastReceiverContext:

Kotlin
override fun onCreate() {
  CastReceiverContext.initInstance(this)

  ...
}
Java
@Override
public void onCreate() {
  CastReceiverContext.initInstance(this);

  ...
}

Uruchom zdarzenie CastReceiverContext, gdy aplikacja przejdzie na pierwszy plan:

Kotlin
CastReceiverContext.getInstance().start()
Java
CastReceiverContext.getInstance().start();

Wywołaj stop() CastReceiverContext, gdy aplikacja przejdzie w tle w przypadku aplikacji wideo lub aplikacji, które nie obsługują odtwarzania w tle:

Kotlin
// Player has stopped.
CastReceiverContext.getInstance().stop()
Java
// Player has stopped.
CastReceiverContext.getInstance().stop();

Jeśli Twoja aplikacja obsługuje odtwarzanie w tle, wywołaj na urządzeniu CastReceiverContext stop(), gdy odtwarzanie w tle przestanie się odtwarzać.

Zdecydowanie zalecamy korzystanie z LifecycleObserver z biblioteki androidx.lifecycle do zarządzania wywołaniami CastReceiverContext.start() i CastReceiverContext.stop(), zwłaszcza jeśli aplikacja natywna ma wiele działań. Pozwala to uniknąć warunków wyścigu, gdy wywołujesz start() i stop() w przypadku różnych aktywności.

Kotlin
// Create a LifecycleObserver class.
class MyLifecycleObserver : DefaultLifecycleObserver {
  override fun onStart(owner: LifecycleOwner) {
    // App prepares to enter foreground.
    CastReceiverContext.getInstance().start()
  }

  override fun onStop(owner: LifecycleOwner) {
    // App has moved to the background or has terminated.
    CastReceiverContext.getInstance().stop()
  }
}

// Add the observer when your application is being created.
class MyApplication : Application() {
  fun onCreate() {
    super.onCreate()

    // Initialize CastReceiverContext.
    CastReceiverContext.initInstance(this /* android.content.Context */)

    // Register LifecycleObserver
    ProcessLifecycleOwner.get().lifecycle.addObserver(
        MyLifecycleObserver())
  }
}
Java
// Create a LifecycleObserver class.
public class MyLifecycleObserver implements DefaultLifecycleObserver {
  @Override
  public void onStart(LifecycleOwner owner) {
    // App prepares to enter foreground.
    CastReceiverContext.getInstance().start();
  }

  @Override
  public void onStop(LifecycleOwner owner) {
    // App has moved to the background or has terminated.
    CastReceiverContext.getInstance().stop();
  }
}

// Add the observer when your application is being created.
public class MyApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();

    // Initialize CastReceiverContext.
    CastReceiverContext.initInstance(this /* android.content.Context */);

    // Register LifecycleObserver
    ProcessLifecycleOwner.get().getLifecycle().addObserver(
        new MyLifecycleObserver());
  }
}
// In AndroidManifest.xml set MyApplication as the application class
<application
    ...
    android:name=".MyApplication">

Łączenie sesji MediaSession i MediaManager

Podczas tworzenia obiektu MediaSession musisz też podać bieżący token MediaSession usłudze CastReceiverContext, aby wiedział, dokąd wysłać polecenia i pobrać stan odtwarzania multimediów:

Kotlin
val mediaManager: MediaManager = receiverContext.getMediaManager()
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken())
Java
MediaManager mediaManager = receiverContext.getMediaManager();
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());

Po zwolnieniu MediaSession z powodu nieaktywnego odtwarzania ustaw dla MediaManager token o wartości null:

Kotlin
myPlayer.stop()
mediaSession.release()
mediaManager.setSessionCompatToken(null)
Java
myPlayer.stop();
mediaSession.release();
mediaManager.setSessionCompatToken(null);

Jeśli Twoja aplikacja obsługuje odtwarzanie multimediów, gdy działa w tle, zamiast wywoływać metodę CastReceiverContext.stop() w przypadku przesyłania w tle, używaj jej tylko wtedy, gdy działa w tle i nie odtwarza multimediów. Na przykład:

Kotlin
class MyLifecycleObserver : DefaultLifecycleObserver {
  ...
  // App has moved to the background.
  override fun onPause(owner: LifecycleOwner) {
    mIsBackground = true
    myStopCastReceiverContextIfNeeded()
  }
}

// Stop playback on the player.
private fun myStopPlayback() {
  myPlayer.stop()

  myStopCastReceiverContextIfNeeded()
}

// Stop the CastReceiverContext when both the player has
// stopped and the app has moved to the background.
private fun myStopCastReceiverContextIfNeeded() {
  if (mIsBackground && myPlayer.isStopped()) {
    CastReceiverContext.getInstance().stop()
  }
}
Java
public class MyLifecycleObserver implements DefaultLifecycleObserver {
  ...
  // App has moved to the background.
  @Override
  public void onPause(LifecycleOwner owner) {
    mIsBackground = true;

    myStopCastReceiverContextIfNeeded();
  }
}

// Stop playback on the player.
private void myStopPlayback() {
  myPlayer.stop();

  myStopCastReceiverContextIfNeeded();
}

// Stop the CastReceiverContext when both the player has
// stopped and the app has moved to the background.
private void myStopCastReceiverContextIfNeeded() {
  if (mIsBackground && myPlayer.isStopped()) {
    CastReceiverContext.getInstance().stop();
  }
}

Używanie odtwarzacza Exoplayer z funkcją Cast Connect

Jeśli korzystasz z metody Exoplayer, możesz za pomocą MediaSessionConnector automatycznie utrzymywać sesję i wszystkie powiązane z nią informacje, w tym stan odtwarzania, zamiast śledzić zmiany ręcznie.

Obiekt MediaSessionConnector.MediaButtonEventHandler może być używany do obsługi zdarzeń MediaButton przez wywołanie setMediaButtonEventHandler(MediaButtonEventHandler), które w innym przypadku są obsługiwane domyślnie przez MediaSessionCompat.Callback.

Aby zintegrować narzędzie MediaSessionConnector ze swoją aplikacją, dodaj ten kod do klasy aktywności odtwarzacza lub w miejscu, gdzie zarządzasz sesją multimediów:

Kotlin
class PlayerActivity : Activity() {
  private var mMediaSession: MediaSessionCompat? = null
  private var mMediaSessionConnector: MediaSessionConnector? = null
  private var mMediaManager: MediaManager? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    ...
    mMediaSession = MediaSessionCompat(this, LOG_TAG)
    mMediaSessionConnector = MediaSessionConnector(mMediaSession!!)
    ...
  }

  override fun onStart() {
    ...
    mMediaManager = receiverContext.getMediaManager()
    mMediaManager!!.setSessionCompatToken(currentMediaSession.getSessionToken())
    mMediaSessionConnector!!.setPlayer(mExoPlayer)
    mMediaSessionConnector!!.setMediaMetadataProvider(mMediaMetadataProvider)
    mMediaSession!!.isActive = true
    ...
  }

  override fun onStop() {
    ...
    mMediaSessionConnector!!.setPlayer(null)
    mMediaSession!!.release()
    mMediaManager!!.setSessionCompatToken(null)
    ...
  }
}
Java
public class PlayerActivity extends Activity {
  private MediaSessionCompat mMediaSession;
  private MediaSessionConnector mMediaSessionConnector;
  private MediaManager mMediaManager;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    ...
    mMediaSession = new MediaSessionCompat(this, LOG_TAG);
    mMediaSessionConnector = new MediaSessionConnector(mMediaSession);
    ...
  }

  @Override
  protected void onStart() {
    ...
    mMediaManager = receiverContext.getMediaManager();
    mMediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());

    mMediaSessionConnector.setPlayer(mExoPlayer);
    mMediaSessionConnector.setMediaMetadataProvider(mMediaMetadataProvider);
    mMediaSession.setActive(true);
    ...
  }

  @Override
  protected void onStop() {
    ...
    mMediaSessionConnector.setPlayer(null);
    mMediaSession.release();
    mMediaManager.setSessionCompatToken(null);
    ...
  }
}

Konfiguracja aplikacji nadawcy

Włącz obsługę Cast Connect

Po zaktualizowaniu aplikacji wysyłającej o obsługę Cast Connect możesz zadeklarować jej gotowość, ustawiając wartość flagi androidReceiverCompatible na LaunchOptions na prawda.

Android

Wymaga play-services-cast-framework w wersji 19.0.0 lub nowszej.

Flaga androidReceiverCompatible jest ustawiona w LaunchOptions (który jest częścią CastOptions):

Kotlin
class CastOptionsProvider : OptionsProvider {
  override fun getCastOptions(context: Context?): CastOptions {
    val launchOptions: LaunchOptions = Builder()
          .setAndroidReceiverCompatible(true)
          .build()
    return CastOptions.Builder()
          .setLaunchOptions(launchOptions)
          ...
          .build()
    }
}
Java
public class CastOptionsProvider implements OptionsProvider {
  @Override
  public CastOptions getCastOptions(Context context) {
    LaunchOptions launchOptions = new LaunchOptions.Builder()
              .setAndroidReceiverCompatible(true)
              .build();
    return new CastOptions.Builder()
        .setLaunchOptions(launchOptions)
        ...
        .build();
  }
}
iOS

Wymaga google-cast-sdk w wersji v4.4.8 lub nowszej.

Flaga androidReceiverCompatible jest ustawiona w GCKLaunchOptions (który jest częścią GCKCastOptions):

let options = GCKCastOptions(discoveryCriteria: GCKDiscoveryCriteria(applicationID: kReceiverAppID))
...
let launchOptions = GCKLaunchOptions()
launchOptions.androidReceiverCompatible = true
options.launchOptions = launchOptions
GCKCastContext.setSharedInstanceWith(options)
Sieć

Wymaga przeglądarki Chromium w wersji M87 lub nowszej.

const context = cast.framework.CastContext.getInstance();
const castOptions = new cast.framework.CastOptions();
castOptions.receiverApplicationId = kReceiverAppID;
castOptions.androidReceiverCompatible = true;
context.setOptions(castOptions);

Konfiguracja konsoli programisty przesyłania

Konfigurowanie aplikacji na Androida TV

Dodaj nazwę pakietu aplikacji na Androida TV w Konsoli programisty Cast, by powiązać ją z identyfikatorem aplikacji Cast.

Rejestrowanie urządzeń dewelopera

Zarejestruj w konsoli programisty Cast numer seryjny urządzenia z Androidem TV, którego będziesz używać do programowania.

Jeśli nie zarejestrujesz się, Cast Connect będzie działać tylko w aplikacjach zainstalowanych ze Sklepu Google Play ze względów bezpieczeństwa.

Więcej informacji o rejestrowaniu urządzeń przesyłających lub urządzeń z Androidem TV na potrzeby programowania przesyłania znajdziesz na stronie rejestracji.

Wczytuję multimedia

Jeśli obsługa precyzyjnych linków została już wdrożona w aplikacji na Androida TV, w pliku manifestu Androida TV powinna być skonfigurowana podobna definicja:

<activity android:name="com.example.activity">
  <intent-filter>
     <action android:name="android.intent.action.VIEW" />
     <category android:name="android.intent.category.DEFAULT" />
     <data android:scheme="https"/>
     <data android:host="www.example.com"/>
     <data android:pathPattern=".*"/>
  </intent-filter>
</activity>

Wczytywanie według elementu u nadawcy

Nadawcy możesz przekazać precyzyjny link, ustawiając właściwość entity w informacjach o multimediach dla żądania wczytywania:

Kotlin
val mediaToLoad = MediaInfo.Builder("some-id")
    .setEntity("https://example.com/watch/some-id")
    ...
    .build()
val loadRequest = MediaLoadRequestData.Builder()
    .setMediaInfo(mediaToLoad)
    .setCredentials("user-credentials")
    ...
    .build()
remoteMediaClient.load(loadRequest)
Android
Java
MediaInfo mediaToLoad =
    new MediaInfo.Builder("some-id")
        .setEntity("https://example.com/watch/some-id")
        ...
        .build();
MediaLoadRequestData loadRequest =
    new MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        ...
        .build();
remoteMediaClient.load(loadRequest);
iOS
let mediaInfoBuilder = GCKMediaInformationBuilder(entity: "https://example.com/watch/some-id")
...
mediaInformation = mediaInfoBuilder.build()

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
mediaLoadRequestDataBuilder.mediaInformation = mediaInformation
mediaLoadRequestDataBuilder.credentials = "user-credentials"
...
let mediaLoadRequestData = mediaLoadRequestDataBuilder.build()

remoteMediaClient?.loadMedia(with: mediaLoadRequestData)
Sieć

Wymaga przeglądarki Chromium w wersji M87 lub nowszej.

let mediaInfo = new chrome.cast.media.MediaInfo('some-id"', 'video/mp4');
mediaInfo.entity = 'https://example.com/watch/some-id';
...

let request = new chrome.cast.media.LoadRequest(mediaInfo);
request.credentials = 'user-credentials';
...

cast.framework.CastContext.getInstance().getCurrentSession().loadMedia(request);

Polecenie wczytywania jest wysyłane za pomocą intencji z precyzyjnym linkiem i nazwą pakietu zdefiniowaną w konsoli programisty.

Ustawianie danych logowania do ATV w przypadku nadawcy

Możliwe, że aplikacja Odbiornik internetowy i aplikacja na Androida TV obsługują różne precyzyjne linki i zasadę credentials (np. jeśli inaczej na obu platformach korzystasz z uwierzytelniania inaczej). Aby rozwiązać ten problem, możesz podać alternatywny kod entity i credentials w Androidzie TV:

Android
Kotlin
val mediaToLoad = MediaInfo.Builder("some-id")
        .setEntity("https://example.com/watch/some-id")
        .setAtvEntity("myscheme://example.com/atv/some-id")
        ...
        .build()
val loadRequest = MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        .setAtvCredentials("atv-user-credentials")
        ...
        .build()
remoteMediaClient.load(loadRequest)
Java
MediaInfo mediaToLoad =
    new MediaInfo.Builder("some-id")
        .setEntity("https://example.com/watch/some-id")
        .setAtvEntity("myscheme://example.com/atv/some-id")
        ...
        .build();
MediaLoadRequestData loadRequest =
    new MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        .setAtvCredentials("atv-user-credentials")
        ...
        .build();
remoteMediaClient.load(loadRequest);
iOS
let mediaInfoBuilder = GCKMediaInformationBuilder(entity: "https://example.com/watch/some-id")
mediaInfoBuilder.atvEntity = "myscheme://example.com/atv/some-id"
...
mediaInformation = mediaInfoBuilder.build()

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
mediaLoadRequestDataBuilder.mediaInformation = mediaInformation
mediaLoadRequestDataBuilder.credentials = "user-credentials"
mediaLoadRequestDataBuilder.atvCredentials = "atv-user-credentials"
...
let mediaLoadRequestData = mediaLoadRequestDataBuilder.build()

remoteMediaClient?.loadMedia(with: mediaLoadRequestData)
Sieć

Wymaga przeglądarki Chromium w wersji M87 lub nowszej.

let mediaInfo = new chrome.cast.media.MediaInfo('some-id"', 'video/mp4');
mediaInfo.entity = 'https://example.com/watch/some-id';
mediaInfo.atvEntity = 'myscheme://example.com/atv/some-id';
...

let request = new chrome.cast.media.LoadRequest(mediaInfo);
request.credentials = 'user-credentials';
request.atvCredentials = 'atv-user-credentials';
...

cast.framework.CastContext.getInstance().getCurrentSession().loadMedia(request);

Jeśli aplikacja Web Odbiornik jest uruchomiona, w żądaniu wczytywania używa tych funkcji: entity i credentials. Jeśli jednak Twoja aplikacja na Androida TV zostanie wprowadzona, pakiet SDK zastąpi entity i credentials parametrami atvEntity i atvCredentials (jeśli zostały określone).

Wczytywanie według Content ID lub MediaQueueData

Jeśli nie używasz entity ani atvEntity i używasz systemu Content ID lub adresu URL treści w informacjach o multimediach albo używasz bardziej szczegółowych danych żądania wczytania multimediów, musisz dodać do aplikacji na Androida TV ten wstępnie zdefiniowany filtr intencji:

<activity android:name="com.example.activity">
  <intent-filter>
     <action android:name="com.google.android.gms.cast.tv.action.LOAD"/>
     <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

Po stronie nadawcy, podobnie jak w przypadku ładowania według elementu, możesz utworzyć żądanie wczytywania z informacjami o treści i wywołać load().

Android
Kotlin
val mediaToLoad = MediaInfo.Builder("some-id").build()
val loadRequest = MediaLoadRequestData.Builder()
    .setMediaInfo(mediaToLoad)
    .setCredentials("user-credentials")
    ...
    .build()
remoteMediaClient.load(loadRequest)
Java
MediaInfo mediaToLoad =
    new MediaInfo.Builder("some-id").build();
MediaLoadRequestData loadRequest =
    new MediaLoadRequestData.Builder()
        .setMediaInfo(mediaToLoad)
        .setCredentials("user-credentials")
        ...
        .build();
remoteMediaClient.load(loadRequest);
iOS
let mediaInfoBuilder = GCKMediaInformationBuilder(contentId: "some-id")
...
mediaInformation = mediaInfoBuilder.build()

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
mediaLoadRequestDataBuilder.mediaInformation = mediaInformation
mediaLoadRequestDataBuilder.credentials = "user-credentials"
...
let mediaLoadRequestData = mediaLoadRequestDataBuilder.build()

remoteMediaClient?.loadMedia(with: mediaLoadRequestData)
Sieć

Wymaga przeglądarki Chromium w wersji M87 lub nowszej.

let mediaInfo = new chrome.cast.media.MediaInfo('some-id"', 'video/mp4');
...

let request = new chrome.cast.media.LoadRequest(mediaInfo);
...

cast.framework.CastContext.getInstance().getCurrentSession().loadMedia(request);

Obsługa żądań obciążenia

Aby obsługiwać te żądania obciążenia w swojej aktywności, musisz obsługiwać intencje w wywołaniach zwrotnych cyklu życia aktywności:

Kotlin
class MyActivity : Activity() {
  override fun onStart() {
    super.onStart()
    val mediaManager = CastReceiverContext.getInstance().getMediaManager()
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(intent)) {
        // If the SDK recognizes the intent, you should early return.
        return
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }

  // For some cases, a new load intent triggers onNewIntent() instead of
  // onStart().
  override fun onNewIntent(intent: Intent) {
    val mediaManager = CastReceiverContext.getInstance().getMediaManager()
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(intent)) {
        // If the SDK recognizes the intent, you should early return.
        return
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }
}
Java
public class MyActivity extends Activity {
  @Override
  protected void onStart() {
    super.onStart();
    MediaManager mediaManager =
        CastReceiverContext.getInstance().getMediaManager();
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(getIntent())) {
      // If the SDK recognizes the intent, you should early return.
      return;
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }

  // For some cases, a new load intent triggers onNewIntent() instead of
  // onStart().
  @Override
  protected void onNewIntent(Intent intent) {
    MediaManager mediaManager =
        CastReceiverContext.getInstance().getMediaManager();
    // Pass the intent to the SDK. You can also do this in onCreate().
    if (mediaManager.onNewIntent(intent)) {
      // If the SDK recognizes the intent, you should early return.
      return;
    }
    // If the SDK doesn't recognize the intent, you can handle the intent with
    // your own logic.
    ...
  }
}

Jeśli MediaManager wykryje intencję wczytywania, wyodrębni z intencji obiekt MediaLoadRequestData i wywoła metodę MediaLoadCommandCallback.onLoad(). Zastąp tę metodę, aby obsłużyć żądanie wczytywania. Wywołanie zwrotne musi zostać zarejestrowane przed wywołaniem metody MediaManager.onNewIntent() (zaleca się użycie metody onCreate() działania lub aplikacji).

Kotlin
class MyActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val mediaManager = CastReceiverContext.getInstance().getMediaManager()
        mediaManager.setMediaLoadCommandCallback(MyMediaLoadCommandCallback())
    }
}

class MyMediaLoadCommandCallback : MediaLoadCommandCallback() {
  override fun onLoad(
        senderId: String?,
        loadRequestData: MediaLoadRequestData
  ): Task {
      return Tasks.call {
        // Resolve the entity into your data structure and load media.
        val mediaInfo = loadRequestData.getMediaInfo()
        if (!checkMediaInfoSupported(mediaInfo)) {
            // Throw MediaException to indicate load failure.
            throw MediaException(
                MediaError.Builder()
                    .setDetailedErrorCode(DetailedErrorCode.LOAD_FAILED)
                    .setReason(MediaError.ERROR_REASON_INVALID_REQUEST)
                    .build()
            )
        }
        myFillMediaInfo(MediaInfoWriter(mediaInfo))
        myPlayerLoad(mediaInfo.getContentUrl())

        // Update media metadata and state (this clears all previous status
        // overrides).
        castReceiverContext.getMediaManager()
            .setDataFromLoad(loadRequestData)
        ...
        castReceiverContext.getMediaManager().broadcastMediaStatus()

        // Return the resolved MediaLoadRequestData to indicate load success.
        return loadRequestData
     }
  }

  private fun myPlayerLoad(contentURL: String) {
    myPlayer.load(contentURL)

    // Update the MediaSession state.
    val playbackState: PlaybackStateCompat = Builder()
        .setState(
            player.getState(), player.getPosition(), System.currentTimeMillis()
        )
        ...
        .build()
    mediaSession.setPlaybackState(playbackState)
  }
Java
public class MyActivity extends Activity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    MediaManager mediaManager =
        CastReceiverContext.getInstance().getMediaManager();
    mediaManager.setMediaLoadCommandCallback(new MyMediaLoadCommandCallback());
  }
}

public class MyMediaLoadCommandCallback extends MediaLoadCommandCallback {
  @Override
  public Task onLoad(String senderId, MediaLoadRequestData loadRequestData) {
    return Tasks.call(() -> {
        // Resolve the entity into your data structure and load media.
        MediaInfo mediaInfo = loadRequestData.getMediaInfo();
        if (!checkMediaInfoSupported(mediaInfo)) {
          // Throw MediaException to indicate load failure.
          throw new MediaException(
              new MediaError.Builder()
                  .setDetailedErrorCode(DetailedErrorCode.LOAD_FAILED)
                  .setReason(MediaError.ERROR_REASON_INVALID_REQUEST)
                  .build());
        }
        myFillMediaInfo(new MediaInfoWriter(mediaInfo));
        myPlayerLoad(mediaInfo.getContentUrl());

        // Update media metadata and state (this clears all previous status
        // overrides).
        castReceiverContext.getMediaManager()
            .setDataFromLoad(loadRequestData);
        ...
        castReceiverContext.getMediaManager().broadcastMediaStatus();

        // Return the resolved MediaLoadRequestData to indicate load success.
        return loadRequestData;
    });
}

private void myPlayerLoad(String contentURL) {
  myPlayer.load(contentURL);

  // Update the MediaSession state.
  PlaybackStateCompat playbackState =
      new PlaybackStateCompat.Builder()
          .setState(
              player.getState(), player.getPosition(), System.currentTimeMillis())
          ...
          .build();
  mediaSession.setPlaybackState(playbackState);
}

Aby przetworzyć intencję obciążenia, możesz przeanalizować intencję do zdefiniowanych przez nas struktur danych (MediaLoadRequestData w przypadku żądań wczytywania).

Obsługa poleceń multimedialnych

Podstawowe funkcje sterowania odtwarzaniem

Podstawowe polecenia integracji obejmują polecenia, które są zgodne z sesją multimediów. Te polecenia są powiadamiane przez wywołania zwrotne sesji multimediów. Aby to zrobić, musisz zarejestrować wywołanie zwrotne do sesji multimediów (możliwe, że już to robisz).

Kotlin
private class MyMediaSessionCallback : MediaSessionCompat.Callback() {
  override fun onPause() {
    // Pause the player and update the play state.
    myPlayer.pause()
  }

  override fun onPlay() {
    // Resume the player and update the play state.
    myPlayer.play()
  }

  override fun onSeekTo(pos: Long) {
    // Seek and update the play state.
    myPlayer.seekTo(pos)
  }
    ...
 }

mediaSession.setCallback(MyMediaSessionCallback())
Java
private class MyMediaSessionCallback extends MediaSessionCompat.Callback {
  @Override
  public void onPause() {
    // Pause the player and update the play state.
    myPlayer.pause();
  }
  @Override
  public void onPlay() {
    // Resume the player and update the play state.
    myPlayer.play();
  }
  @Override
  public void onSeekTo(long pos) {
    // Seek and update the play state.
    myPlayer.seekTo(pos);
  }

  ...
}

mediaSession.setCallback(new MyMediaSessionCallback());

Obsługa poleceń sterujących Cast

Niektóre polecenia Cast są niedostępne w MediaSession, np. skipAd() czy setActiveMediaTracks(). Musisz też wdrożyć w tym miejscu niektóre polecenia dotyczące kolejki, ponieważ kolejka przesyłania nie jest w pełni zgodna z kolejką MediaSession.

Kotlin
class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onSkipAd(requestData: RequestData?): Task {
        // Skip your ad
        ...
        return Tasks.forResult(null)
    }
}

val mediaManager = CastReceiverContext.getInstance().getMediaManager()
mediaManager.setMediaCommandCallback(MyMediaCommandCallback())
Java
public class MyMediaCommandCallback extends MediaCommandCallback {
  @Override
  public Task onSkipAd(RequestData requestData) {
    // Skip your ad
    ...
    return Tasks.forResult(null);
  }
}

MediaManager mediaManager =
    CastReceiverContext.getInstance().getMediaManager();
mediaManager.setMediaCommandCallback(new MyMediaCommandCallback());

Określ obsługiwane polecenia multimedialne

Podobnie jak w przypadku odbiornika Cast aplikacja na Androida TV powinna określać obsługiwane polecenia, aby nadawcy mogli włączać i wyłączać określone elementy interfejsu. W przypadku poleceń, które są częścią MediaSession, określ je w zadaniu PlaybackStateCompat. Dodatkowe polecenia należy określić w MediaStatusModifier.

Kotlin
// Set media session supported commands
val playbackState: PlaybackStateCompat = PlaybackStateCompat.Builder()
    .setActions(PlaybackStateCompat.ACTION_PLAY or PlaybackStateCompat.ACTION_PAUSE)
    .setState(PlaybackStateCompat.STATE_PLAYING)
    .build()

mediaSession.setPlaybackState(playbackState)

// Set additional commands in MediaStatusModifier
val mediaManager = CastReceiverContext.getInstance().getMediaManager()
mediaManager.getMediaStatusModifier()
    .setMediaCommandSupported(MediaStatus.COMMAND_QUEUE_NEXT)
Java
// Set media session supported commands
PlaybackStateCompat playbackState =
    new PlaybackStateCompat.Builder()
        .setActions(PlaybackStateCompat.ACTION_PLAY | PlaybackStateCompat.ACTION_PAUSE)
        .setState(PlaybackStateCompat.STATE_PLAYING)
        .build();

mediaSession.setPlaybackState(playbackState);

// Set additional commands in MediaStatusModifier
MediaManager mediaManager = CastReceiverContext.getInstance().getMediaManager();
mediaManager.getMediaStatusModifier()
            .setMediaCommandSupported(MediaStatus.COMMAND_QUEUE_NEXT);

Ukryj nieobsługiwane przyciski

Jeśli Twoja aplikacja na Androida TV obsługuje tylko podstawowe sterowanie multimediami, ale aplikacja Web Receiver obsługuje bardziej zaawansowane funkcje, sprawdź, czy aplikacja nadawcy działa prawidłowo podczas przesyłania treści do aplikacji na Androida TV. Jeśli na przykład Twoja aplikacja na Androida TV nie obsługuje zmiany szybkości odtwarzania, a aplikacja Web Receiver, ustaw obsługiwane działania na każdej platformie i upewnij się, że aplikacja nadawcy prawidłowo renderuje się interfejs użytkownika.

Modyfikowanie stanu MediaStatus

Aby obsługiwać funkcje zaawansowane, takie jak ścieżki, reklamy, transmisje na żywo i kolejkowanie, aplikacja na Androida TV musi udostępniać dodatkowe informacje, których nie można sprawdzić w MediaSession.

Udostępniamy klasę MediaStatusModifier, która pozwoli Ci to zrobić. MediaStatusModifier będzie zawsze działać na podstawie MediaSession ustawionego w CastReceiverContext.

Aby utworzyć i transmitować MediaStatus:

Kotlin
val mediaManager: MediaManager = castReceiverContext.getMediaManager()
val statusModifier: MediaStatusModifier = mediaManager.getMediaStatusModifier()

statusModifier
    .setLiveSeekableRange(seekableRange)
    .setAdBreakStatus(adBreakStatus)
    .setCustomData(customData)

mediaManager.broadcastMediaStatus()
Java
MediaManager mediaManager = castReceiverContext.getMediaManager();
MediaStatusModifier statusModifier = mediaManager.getMediaStatusModifier();

statusModifier
    .setLiveSeekableRange(seekableRange)
    .setAdBreakStatus(adBreakStatus)
    .setCustomData(customData);

mediaManager.broadcastMediaStatus();

Nasza biblioteka klienta pobierze podstawową MediaStatus z MediaSession, aplikacja na Androida TV może określić dodatkowy stan i zastąpić go za pomocą modyfikatora MediaStatus.

Niektóre stany i metadane można ustawiać zarówno w zasadzie MediaSession, jak i w MediaStatusModifier. Zdecydowanie zalecamy ustawianie ich tylko w polu MediaSession. Nadal możesz używać modyfikatora do zastępowania stanów w polu MediaSession – odradzamy to, ponieważ stan modyfikatora zawsze ma wyższy priorytet niż wartości podane przez MediaSession.

Przechwytywanie stanu MediaStatus przed wysłaniem

Tak samo jak w przypadku pakietu SDK odbiornika internetowego, jeśli przed wysłaniem chcesz wprowadzić kilka ostatnich poprawek, możesz określić MediaStatusInterceptor, który przetwarza przesyłany plik MediaStatus. Przekazujemy obiekt MediaStatusWriter, aby manipulować w obiekcie MediaStatus przed jego wysłaniem.

Kotlin
mediaManager.setMediaStatusInterceptor(object : MediaStatusInterceptor {
    override fun intercept(mediaStatusWriter: MediaStatusWriter) {
      // Perform customization.
        mediaStatusWriter.setCustomData(JSONObject("{data: \"my Hello\"}"))
    }
})
Java
mediaManager.setMediaStatusInterceptor(new MediaStatusInterceptor() {
    @Override
    public void intercept(MediaStatusWriter mediaStatusWriter) {
        // Perform customization.
        mediaStatusWriter.setCustomData(new JSONObject("{data: \"my Hello\"}"));
    }
});

Obsługa danych logowania użytkownika

Aplikacja na Androida TV może zezwalać tylko niektórym użytkownikom na uruchamianie sesji w aplikacji lub dołączanie do niej. Na przykład zezwól nadawcy na uruchomienie lub dołączenie tylko wtedy, gdy:

  • Aplikacja nadawcy jest zalogowany na tym samym koncie i profilu co aplikacja ATV.
  • Aplikacja nadawcy jest zalogowany na to samo konto, ale inny profil co aplikacja ATV.

Jeśli aplikacja może obsługiwać wielu lub anonimowych użytkowników, możesz zezwolić dodatkowym użytkownikom na dołączenie do sesji ATV. Jeśli użytkownik poda dane logowania, aplikacja ATV musi obsługiwać jego dane logowania, aby można było odpowiednio śledzić postępy użytkownika i inne dane.

Gdy aplikacja nadawcy uruchomi Twoją aplikację na Androida TV lub dołączy do niej, powinna ona podać dane logowania, które umożliwią dołączanie do sesji.

Zanim nadawca uruchomi Twoją aplikację na Androida TV i dołączy do niej, możesz ustawić narzędzie do sprawdzania uruchamiania, aby sprawdzić, czy dane logowania nadawcy są dozwolone. Jeśli nie, pakiet SDK Cast Connect uruchamia odbiornik internetowy.

Dane logowania do uruchomienia aplikacji nadawcy

Po stronie nadawcy możesz określić, kto dołącza do sesji, używając pola CredentialsData.

credentials to ciąg znaków, który może być zdefiniowany przez użytkownika, o ile tylko aplikacja ATV go rozumie. Pole credentialsType określa platformę, z której pochodzi CredentialsData, lub może być wartością niestandardową. Domyślnie jest ustawiony na platformę, z której jest wysyłany.

CredentialsData jest przekazywany do aplikacji na Androida TV tylko podczas uruchamiania lub dołączania do niej. Jeśli ustawisz je ponownie po nawiązaniu połączenia, profil nie zostanie przekazany do aplikacji na Androida TV. Jeśli nadawca zmieni profil podczas połączenia, możesz pozostać w sesji lub zadzwonić pod numer SessionManager.endCurrentCastSession(boolean stopCasting), jeśli uważasz, że nowy profil jest niezgodny z sesją.

CredentialsData dla każdego nadawcy można pobrać za pomocą getSenders w CastReceiverContext, aby pobrać SenderInfo, getCastLaunchRequest(), aby uzyskać CastLaunchRequest, a następnie getCredentialsData().

Android

Wymaga play-services-cast-framework w wersji 19.0.0 lub nowszej.

Kotlin
CastContext.getSharedInstance().setLaunchCredentialsData(
    CredentialsData.Builder()
        .setCredentials("{\"userId\": \"abc\"}")
        .build()
)
Java
CastContext.getSharedInstance().setLaunchCredentialsData(
    new CredentialsData.Builder()
        .setCredentials("{\"userId\": \"abc\"}")
        .build());
iOS

Wymaga google-cast-sdk w wersji v4.8.1 lub nowszej.

Można ją wywołać w dowolnym momencie po ustawieniu opcji: GCKCastContext.setSharedInstanceWith(options).

GCKCastContext.sharedInstance().setLaunch(
    GCKCredentialsData(credentials: "{\"userId\": \"abc\"}")
Sieć

Wymaga przeglądarki Chromium w wersji M87 lub nowszej.

Można ją wywołać w dowolnym momencie po ustawieniu opcji: cast.framework.CastContext.getInstance().setOptions(options);. 

let credentialsData =
    new chrome.cast.CredentialsData("{\"userId\": \"abc\"}");
cast.framework.CastContext.getInstance().setLaunchCredentialsData(credentialsData);

Wdrażanie narzędzia do sprawdzania próśb o uruchomienie quada

CredentialsData jest przekazywany do aplikacji na Androida TV, gdy nadawca próbuje ją uruchomić lub do niej dołączyć. Możesz zaimplementować LaunchRequestChecker. aby zaakceptować lub odrzucić tę prośbę.

Jeśli żądanie zostanie odrzucone, odbiornik internetowy nie będzie uruchamiał się natywnie w aplikacji ATV. Odrzuć żądanie, jeśli quad nie obsługuje użytkownika, który prosi o uruchomienie lub dołączenie. Przykładem może być to, że w aplikacji ATV jest zalogowany inny użytkownik niż prosił o to aplikacja, a aplikacja nie obsługuje przełączania danych uwierzytelniających lub że żaden użytkownik nie jest obecnie zalogowany w aplikacji ATV.

Jeśli żądanie jest dozwolone, aplikacja ATV uruchamia się. Możesz dostosować to działanie w zależności od tego, czy Twoja aplikacja obsługuje wysyłanie żądań wczytywania, gdy użytkownik nie jest zalogowany w aplikacji ATV, lub od niezgodności użytkowników. Takie zachowanie jest w pełni dopasowane w interfejsie LaunchRequestChecker.

Utwórz klasę implementującą interfejs CastReceiverOptions.LaunchRequestChecker:

Kotlin
class MyLaunchRequestChecker : LaunchRequestChecker {
  override fun checkLaunchRequestSupported(launchRequest: CastLaunchRequest): Task {
    return Tasks.call {
      myCheckLaunchRequest(
           launchRequest
      )
    }
  }
}

private fun myCheckLaunchRequest(launchRequest: CastLaunchRequest): Boolean {
  val credentialsData = launchRequest.getCredentialsData()
     ?: return false // or true if you allow anonymous users to join.

  // The request comes from a mobile device, e.g. checking user match.
  return if (credentialsData.credentialsType == CredentialsData.CREDENTIALS_TYPE_ANDROID) {
     myCheckMobileCredentialsAllowed(credentialsData.getCredentials())
  } else false // Unrecognized credentials type.
}
Java
public class MyLaunchRequestChecker
    implements CastReceiverOptions.LaunchRequestChecker {
  @Override
  public Task checkLaunchRequestSupported(CastLaunchRequest launchRequest) {
    return Tasks.call(() -> myCheckLaunchRequest(launchRequest));
  }
}

private boolean myCheckLaunchRequest(CastLaunchRequest launchRequest) {
  CredentialsData credentialsData = launchRequest.getCredentialsData();
  if (credentialsData == null) {
    return false;  // or true if you allow anonymous users to join.
  }

  // The request comes from a mobile device, e.g. checking user match.
  if (credentialsData.getCredentialsType().equals(CredentialsData.CREDENTIALS_TYPE_ANDROID)) {
    return myCheckMobileCredentialsAllowed(credentialsData.getCredentials());
  }

  // Unrecognized credentials type.
  return false;
}

Następnie ustaw go w ReceiverOptionsProvider:

Kotlin
class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
        ...
        .setLaunchRequestChecker(MyLaunchRequestChecker())
        .build()
  }
}
Java
public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        ...
        .setLaunchRequestChecker(new MyLaunchRequestChecker())
        .build();
  }
}

Rozwiązanie problemu true w LaunchRequestChecker powoduje uruchomienie aplikacji ATV, a false uruchomi aplikację Web Receiver.

Wysyłanie i odbieranie wiadomości niestandardowych

Protokół Cast umożliwia wysyłanie niestandardowych ciągów znaków między nadawcami a aplikacją odbiornika. Zanim zainicjujesz CastReceiverContext, musisz zarejestrować przestrzeń nazw (kanał), do której będą wysyłane wiadomości.

Android TV – określ niestandardową przestrzeń nazw

Podczas konfiguracji musisz w CastReceiverOptions określić obsługiwane przestrzenie nazw:

Kotlin
class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
        .setCustomNamespaces(
            Arrays.asList("urn:x-cast:com.example.cast.mynamespace")
        )
        .build()
  }
}
Java
public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        .setCustomNamespaces(
              Arrays.asList("urn:x-cast:com.example.cast.mynamespace"))
        .build();
  }
}

Android TV – wysyłanie wiadomości

Kotlin
// If senderId is null, then the message is broadcasted to all senders.
CastReceiverContext.getInstance().sendMessage(
    "urn:x-cast:com.example.cast.mynamespace", senderId, customString)
Java
// If senderId is null, then the message is broadcasted to all senders.
CastReceiverContext.getInstance().sendMessage(
    "urn:x-cast:com.example.cast.mynamespace", senderId, customString);

Android TV – odbieranie wiadomości niestandardowych przestrzeni nazw

Kotlin
class MyCustomMessageListener : MessageReceivedListener {
    override fun onMessageReceived(
        namespace: String, senderId: String?, message: String ) {
        ...
    }
}

CastReceiverContext.getInstance().setMessageReceivedListener(
    "urn:x-cast:com.example.cast.mynamespace", new MyCustomMessageListener());
Java
class MyCustomMessageListener implements CastReceiverContext.MessageReceivedListener {
  @Override
  public void onMessageReceived(
      String namespace, String senderId, String message) {
    ...
  }
}

CastReceiverContext.getInstance().setMessageReceivedListener(
    "urn:x-cast:com.example.cast.mynamespace", new MyCustomMessageListener());
Wstecz
Przegląd
Dalej
Utwory