Dodawanie podstawowych funkcji do odbiornika Android TV

Ta strona zawiera fragmenty kodu i opisy funkcji dostępnych do dostosowywania aplikacji odbiornika Android TV.

Konfiguruję biblioteki

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

Android
  1. Otwórz plik build.gradle w katalogu modułu aplikacji.
  2. Sprawdź, czy google() jest uwzględniony 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 Odbiornik na Androida:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast-tv:21.0.1'
          implementation 'com.google.android.gms:play-services-cast:21.4.0'
        }
    • W przypadku aplikacji nadawcy na Androida:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast:21.0.1'
          implementation 'com.google.android.gms:play-services-cast-framework:21.4.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 obejmuje kierowanie na system google-cast-sdk w wersji 4.8.0 lub nowszej
  2. Kierowanie na system iOS w wersji 13 lub nowszej. Więcej szczegółów znajdziesz w informacjach o wersji.
      platform: ios, '13'
    
      def target_pods
         pod 'google-cast-sdk', '~>4.8.0'
      end
Sieć
  1. Wymaga przeglądarki Chromium w wersji 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ą zaktualizowania aplikacji, tak aby korzystała z przestrzeni nazw androidx. Postępuj zgodnie z instrukcjami migracji na AndroidaX.

Aplikacja na Androida TV – wymagania wstępne

Aby obsługiwać Cast Connect w aplikacji na Androida TV, musisz tworzyć i obsługiwać zdarzenia z sesji multimediów. Dane dostarczane przez sesję multimediów zawierają podstawowe informacje o stanie multimediów, np. pozycję, stan odtwarzania itp. Twoja sesja multimediów jest też wykorzystywana przez bibliotekę Cast Connect do zasygnalizowania otrzymania określonych wiadomości od nadawcy, na przykład wstrzymania.

Więcej informacji o sesji multimediów i inicjowaniu sesji multimediów znajdziesz w przewodniku po sesji multimediów.

Cykl życia sesji multimediów

Aplikacja powinna utworzyć sesję multimediów po rozpoczęciu odtwarzania i zwolnić ją, gdy nie można już sterować odtwarzaniem. Jeśli na przykład aplikacja to aplikacja wideo, należy zwolnić sesję po zakończeniu odtwarzania przez użytkownika – klikając „Wstecz”, aby przeglądać inne treści, lub uruchamiając aplikację w tle. Jeśli aplikacja jest aplikacją muzyczną, należy ją opublikować wtedy, gdy aplikacja nie odtwarza już żadnych multimediów.

Aktualizuję stan sesji

Dane w sesji multimediów powinny być na bieżąco ze stanem odtwarzacza. Na przykład, gdy odtwarzanie jest wstrzymane, musisz zaktualizować stan odtwarzania oraz obsługiwane działania. W tabelach poniżej znajdziesz listę stanów, za które odpowiadasz.

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 (wymagany) Czas trwania multimediów.
METADATA_KEY_MEDIA_URI Identyfikator treści
METADATA_KEY_ARTIST Wykonawca.
METADATA_KEY_ALBUM Album.

PlaybackStateCompat

Wymagana metoda Opis
setActions() Ustawia obsługiwane polecenia dotyczące multimediów.
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 transportu

Aplikacja powinna implementować wywołanie zwrotne kontroli transportu sesji multimedialnych. W tabeli poniżej znajdziesz działania związane z kontrolą transportu, które muszą wykonać:

MediaSessionCompat.Callback

Działania Opis
onPlay() Wznów
onPause() Wstrzymaj
onSeekTo() Wyszukiwanie do 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 nadawcy wysyła żądanie uruchomienia, tworzona jest intencja z przestrzenią nazw aplikacji. Twoja aplikacja odpowiada za jego obsługę i utworzenie instancji obiektu CastReceiverContext przy uruchamianiu aplikacji TV. Obiekt CastReceiverContext jest potrzebny do interakcji z funkcją Cast, gdy uruchomiona jest aplikacja na telewizor. Ten obiekt umożliwia aplikacji TV akceptowanie wiadomości multimedialnych Cast 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ć zamiar uruchomienia 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ć 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 AndroidManifest:

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

ReceiverOptionsProvider służy do podawania CastReceiverOptions przy zainicjowaniu CastReceiverContext.

Kontekst odbiornika

Zainicjuj CastReceiverContext podczas tworzenia aplikacji:

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

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

  ...
}

Uruchom CastReceiverContext, gdy aplikacja zostanie przeniesiona na pierwszy plan:

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

Wywołaj metodę stop() CastReceiverContext po przejściu aplikacji 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 stop() na urządzeniu CastReceiverContext, gdy aplikacja przestanie się odtwarzać w tle.

Zdecydowanie zalecamy korzystanie z funkcji LifecycleObserver z biblioteki androidx.lifecycle do zarządzania wywołaniami CastReceiverContext.start() i CastReceiverContext.stop(), zwłaszcza jeśli aplikacja natywna ma wiele aktywności. Pozwala to uniknąć warunków wyścigu, gdy wywołujesz funkcje start() i stop() z 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 MediaSession z MediaManagerem

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

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

Gdy zwolnisz MediaSession z powodu nieaktywnego odtwarzania, ustaw pusty token dla MediaManager:

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

Jeśli aplikacja obsługuje odtwarzanie multimediów, gdy działa w tle, to zamiast wywoływać metodę CastReceiverContext.stop(), gdy aplikacja jest przesyłana w tle, należy wywoływać ją tylko wtedy, gdy aplikacja działa w tle i nie odtwarza już 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 używasz Exoplayer, możesz za pomocą MediaSessionConnector automatycznie utrzymywać sesję i wszystkie powiązane informacje, w tym stan odtwarzania, zamiast śledzić zmiany ręcznie.

Parametr MediaSessionConnector.MediaButtonEventHandler może służyć do obsługi zdarzeń MediaButton przez wywołanie metody setMediaButtonEventHandler(MediaButtonEventHandler), które są obsługiwane domyślnie przez MediaSessionCompat.Callback.

Aby zintegrować MediaSessionConnector z aplikacją, dodaj te elementy do klasy aktywności odtwarzacza lub do innego miejsca, w którym 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 nadawcy pod kątem obsługi Cast Connect możesz zadeklarować jej gotowość, ustawiając flagę androidReceiverCompatible na LaunchOptions na „true”.

Android

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

Flaga androidReceiverCompatible jest ustawiona w regionie 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 systemu google-cast-sdk w wersji v4.4.8 lub nowszej.

Flaga androidReceiverCompatible jest ustawiona w regionie 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 Cast Developer Console

Konfigurowanie aplikacji Android TV

Dodaj nazwę pakietu aplikacji na Androida TV w konsoli programisty obsługującej Cast, by powiązać ją z identyfikatorem aplikacji Cast.

Rejestrowanie urządzeń programistów

W konsoli programisty obsługującej Cast zarejestruj numer seryjny urządzenia z Androidem TV, którego będziesz używać do programowania.

Ze względów bezpieczeństwa Cast Connect bez rejestracji będzie działać tylko w aplikacjach zainstalowanych ze Sklepu Google Play.

Więcej informacji o rejestrowaniu urządzenia przesyłającego lub urządzenia z Androidem TV na potrzeby programowania Cast znajdziesz na stronie rejestracji.

Wczytuję multimedia

Jeśli w aplikacji na Androida TV masz już wdrożoną obsługę precyzyjnych linków, w pliku manifestu Androida TV musisz skonfigurować podobną definicję:

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

W przypadku nadawców możesz przekazać precyzyjny link, ustawiając entity w informacjach o multimediach dla żądania wczytania:

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 zawierającej precyzyjny link i nazwę pakietu zdefiniowaną w konsoli programisty.

Ustawianie danych logowania do ATV u nadawcy

Aplikacja Web pickupa i aplikacja na Androida TV mogą obsługiwać różne precyzyjne linki i credentials (np. jeśli uwierzytelnianie na obu platformach wygląda inaczej). Aby rozwiązać ten problem, podaj alternatywne urządzenia entity i credentials na 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 Receivedr jest uruchamiana, używa w żądaniu wczytania elementów entity i credentials. Jeśli jednak Twoja aplikacja na Androida TV zostanie wprowadzona, pakiet SDK zastępuje entity i credentials Twoimi atvEntity i atvCredentials (jeśli są określone).

Wczytywanie przez Content ID lub MediaQueueData

Jeśli nie używasz entity ani atvEntity i w informacjach o multimediach używasz systemu Content ID lub adresu URL treści albo korzystasz z 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 opcji load by encji, możesz utworzyć żądanie wczytania z informacjami o Twojej treści i wywołać metodę 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, musisz w swojej aktywności uwzględnić 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 niej obiekt MediaLoadRequestData i wywoła metodę MediaLoadCommandCallback.onLoad(). Aby móc obsługiwać żądanie wczytania, musisz zastąpić tę metodę. Wywołanie zwrotne musi zostać zarejestrowane przed wywołaniem funkcji MediaManager.onNewIntent() (zalecamy użycie metody onCreate() dotyczącej aktywności 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ę wczytywania, możesz przeanalizować ją w zdefiniowanych przez nas strukturach danych (w przypadku żądań wczytywania MediaLoadRequestData).

Obsługa poleceń multimedialnych

Obsługa podstawowych elementów sterujących odtwarzaniem

Podstawowe polecenia integracji zawierają polecenia 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żesz to już robić).

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ń sterowania przesyłaniem

Niektóre polecenia przesyłania są niedostępne w MediaSession, np. skipAd() lub setActiveMediaTracks(). Konieczne jest tu też zaimplementowanie niektórych poleceń związanych z kolejką, 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ślanie obsługiwanych poleceń dotyczących multimediów

Tak jak w przypadku odbiornika przesyłania, 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 należą do MediaSession, określ je w PlaybackStateCompat. Dodatkowe polecenia powinny być określone 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, a aplikacja Web Odbiorca płatności, obsługuje bardziej zaawansowane opcje, sprawdź, czy aplikacja nadawcy podczas przesyłania treści do aplikacji Android TV działa prawidłowo. Jeśli np. aplikacja na Androida TV nie obsługuje zmiany szybkości odtwarzania, a aplikacja Web Recipient, musisz ustawić obsługiwane działania prawidłowo na każdej platformie i upewnić się, że aplikacja nadawcy prawidłowo renderuje interfejs użytkownika.

Modyfikowanie stanu mediów

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

Aby to zrobić, udostępniamy klasę MediaStatusModifier. MediaStatusModifier zawsze będzie działać na elemencie MediaSession ustawionym w CastReceiverContext.

Aby utworzyć i przesłać 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 podstawowy stan MediaStatus z elementu MediaSession, a Twoja aplikacja na Androida TV może określać dodatkowy stan i zastępować stan za pomocą modyfikatora MediaStatus.

Niektóre stany i metadane można określać zarówno w przypadku MediaSession, jak i MediaStatusModifier. Zdecydowanie zalecamy, aby ustawić je tylko w interfejsie MediaSession. Nadal możesz używać modyfikatora do zastępowania stanów w elemencie MediaSession. Odradzamy to, ponieważ stan modyfikatora ma zawsze wyższy priorytet niż wartości podane przez funkcję MediaSession.

Przechwytywanie MediaStatusu przed wysłaniem

Tak samo jak w przypadku pakietu Web Receivedr SDK, jeśli przed wysłaniem wiadomości chcesz wprowadzić ostatnie poprawki, możesz określić MediaStatusInterceptor, aby przetwarzał wysyłany MediaStatus. Przekazujemy obiekt MediaStatusWriter, by manipulować wartością MediaStatus przed jej 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

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

  • Aplikacja nadawcy jest zalogowana na to samo konto i w tym samym profilu co aplikacja ATV.
  • Aplikacja nadawcy jest zalogowana na to samo konto, ale na innym profilu niż w przypadku aplikacji ATV.

Jeśli Twoja aplikacja może obsługiwać wielu użytkowników lub anonimowych użytkowników, możesz zezwolić na dołączenie do sesji ATV dodatkowym użytkownikom. Jeśli użytkownik poda dane logowania, aplikacja ATV musi obsługiwać jego dane logowania, aby umożliwić prawidłowe śledzenie postępów i innych danych użytkownika.

Gdy aplikacja nadawcy jest uruchamiana lub dołącza do niej, aplikacja nadawcy powinna podać dane logowania, które określają, kto dołącza do sesji.

Zanim nadawca uruchomi Twoją aplikację na Androida TV i dołączy do niej, możesz określić narzędzie do sprawdzania, czy można używać danych logowania nadawcy. Jeśli nie, pakiet SDK Cast może ponownie uruchomić odbiornik internetowy.

Dane logowania do uruchamiania aplikacji nadawcy

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

credentials to ciąg znaków, który można definiować przez użytkownika, pod warunkiem że jest on zrozumiały dla aplikacji ATV. 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.

Element CredentialsData jest przekazywany do aplikacji na Androida TV tylko podczas jej uruchamiania lub dołączania. Jeśli ustawisz go ponownie po połączeniu, nie zostanie on przekazany do aplikacji na Androida TV. Jeśli nadawca przełączy 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 z nią niezgodny.

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

Android

Wymaga systemu 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 systemu google-cast-sdk w wersji v4.8.0 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);

Implementacja narzędzia do sprawdzania próśb o wprowadzenie ATV

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

W przypadku odrzucenia żądania odbiornik internetowy jest wczytywany, a nie natywny w aplikacji ATV. Odrzuć żądanie, jeśli ATV nie obsługuje użytkownika, który prosi o uruchomienie lub dołączenie. Może się tak zdarzyć, jeśli w aplikacji ATV jest zalogowany inny użytkownik, niż tego zażądała, a aplikacja nie może obsługiwać przełączania danych logowania lub w aplikacji nie jest obecnie zalogowany żaden użytkownik.

Jeśli żądanie jest dozwolone, uruchamia się aplikacja ATV. Możesz dostosować to działanie w zależności od tego, czy Twoja aplikacja obsługuje wysyłanie żądań wczytania, gdy użytkownik nie jest zalogowany w aplikacji ATV, lub czy występuje niezgodność danych o użytkownikach. To zachowanie można w pełni dostosować w interfejsie LaunchRequestChecker.

Utwórz zajęcia implementujące 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 true w LaunchRequestChecker powoduje uruchomienie aplikacji ATV, a false – aplikacji Web Recipient.

Wysyłanie i odbieranie wiadomości niestandardowych

Protokół Cast umożliwia wysyłanie niestandardowych ciągów znaków między nadawcami a aplikacją odbierającą. Przed zainicjowaniem CastReceiverContext musisz zarejestrować przestrzeń nazw (kanał), do której mają być wysyłane wiadomości.

Android TV – określ niestandardową przestrzeń nazw

Podczas konfiguracji musisz podać obsługiwane przestrzenie nazw w CastReceiverOptions:

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 z niestandardowego obszaru 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());