Dodawanie podstawowych funkcji do odbiornika Android TV

Ta strona zawiera fragmenty kodu i opisy funkcji dostępnych dla dostosować aplikację 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. Dodaj najnowsze wersje aplikacji w zależności od typu urządzenia docelowego. bibliotek do zależności:
    • 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 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 4.8.3 lub więcej
  2. być kierowana na system iOS 14 lub nowszy, Zobacz informacje o wersji. .
      platform: ios, '14'
    
      def target_pods
         pod 'google-cast-sdk', '~>4.8.3'
      end
.
Sieć
  1. Wymaga przeglądarki Chromium M87 lub nowszej.
  2. Dodawanie biblioteki 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

Aby można było korzystać z nowych wersji Usług Google Play, musisz zaktualizować aplikację przestrzeni nazw androidx. Postępuj zgodnie z instrukcjami dotyczącymi przejście na AndroidaX.

Aplikacja na Androida TV – wymagania wstępne

Aby obsługiwać Cast Connect w aplikacji na Androida TV, musisz utworzyć zdarzeń związanych z obsługą z sesji multimediów. Dane dostarczane przez Twoją sesję multimediów zawiera podstawowe informacje – takie jak pozycja, stan odtwarzania itd. – dotyczące stanu multimediów. Sesja multimediów jest też używana przez bibliotekę Cast Connect , aby zasygnalizować, że otrzymała określone wiadomości od nadawcy, np. wstrzymać.

Więcej informacji o sesji multimediów i jej zainicjowaniu znajdziesz zobacz jak korzystać z przewodnika po sesjach z mediami.

Cykl życia sesji multimediów

Aplikacja powinna utworzyć sesję multimediów w momencie rozpoczęcia odtwarzania i zwolnić ją, gdy nie da się jej więcej kontrolować. Na przykład jeśli Twoja aplikacja to wideo, powinna zwolnić sesję, gdy użytkownik zakończy odtwarzanie – przez wybierając „Wstecz” aby przeglądać inne treści lub włączyć aplikację w tle. Jeśli aplikacja jest aplikacją muzyczną. Opublikuj ją, gdy aplikacja przestanie odtwarzać multimediów.

Aktualizuję stan sesji

Dane w sesji multimedialnej powinny być na bieżąco aktualizowany . Na przykład po wstrzymaniu odtwarzania trzeba zaktualizować stan, a także obsługiwane działania. W poniższych tabelach podano stany Twoim obowiązkiem jest zapewnienie aktualności.

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 implementować wywołanie zwrotne kontroli transportu sesji multimediów. W tej tabeli znajdziesz informacje o działaniach związanych z transportem, które 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, tworzona jest intencja z przestrzenią nazw aplikacji. Za rozpatrzenie aplikacji odpowiada Twoja aplikacja i utworzenie instancji CastReceiverContext po uruchomieniu aplikacji TV. Obiekt CastReceiverContext jest wymagany aby korzystać z funkcji Cast w aplikacji TV. Ten obiekt włącza telewizor do akceptowania 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ć uruchomienie intencję 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ć ReceiverOptionsProvider aby podać 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, gdy Zainicjowano CastReceiverContext.

Kontekst odbiornika

Zainicjuj CastReceiverContext podczas tworzenia aplikacji:

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

Zadzwoń do nas stop() w CastReceiverContext gdy aplikacja będzie działać w tle w przypadku aplikacji wideo lub, które nie obsługują odtwarzanie 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, zadzwoń pod stop() na urządzeniu CastReceiverContext, gdy przestaje odtwarzać się w tle.

Zdecydowanie zalecamy korzystanie z LifecycleObserver androidx.lifecycle biblioteka do zarządzania połączeniami CastReceiverContext.start() oraz CastReceiverContext.stop() zwłaszcza jeśli aplikacja natywna zawiera wiele aktywności. To omija wyścig przy wywołaniu funkcji 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 sesji MediaSession i MediaManager

Gdy tworzysz MediaSession, musisz też podać aktualny token MediaSession CastReceiverContext aby wie, dokąd wysłać polecenia i pobrać stan odtwarzania:

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 włączony 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, połączeń CastReceiverContext.stop() jeśli aplikacja jest wysyłana w tle, należy wywoływać ją tylko wtedy, gdy aplikacja jest 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 używasz Exoplayer, możesz użyć funkcji MediaSessionConnector do automatycznego podtrzymywania sesji i wszystkich powiązanych informacji, w tym odtwarzania bez ręcznego śledzenia zmian.

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

Integracja MediaSessionConnector dodaj ten element do swojej klasy aktywności lub w dowolnym miejscu zarządzaj 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 i obsłudze Cast Connect możesz zadeklarować swoją gotowość, ustawiając androidReceiverCompatible flaga włączona LaunchOptions na wartość true (prawda).

Android

Wymaga wersji play-services-cast-framework 19.0.0 lub więcej.

Flaga androidReceiverCompatible jest ustawiona w: LaunchOptions (która 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 wyższe.

Flaga androidReceiverCompatible jest ustawiona w GCKLaunchOptions (która 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 wersji przeglądarki Chromium M87 lub więcej.

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 polu Konsola programisty Cast by powiązać ją z identyfikatorem aplikacji Cast.

Rejestrowanie urządzeń dewelopera

Zarejestruj numer seryjny urządzenia z Androidem TV, którego będziesz używać w dziedzinie rozwoju Konsola programisty Cast

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

Więcej informacji o rejestrowaniu funkcji Cast na urządzeniu przesyłającym lub urządzeniu z Androidem TV 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 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

W przypadku nadawców możesz przekazać precyzyjny link, ustawiając entity w multimediach. informacje 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 wersji przeglądarki Chromium M87 lub więcej.

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 pośrednictwem intencji z precyzyjnym linkiem i nazwą pakietu. zdefiniowane 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 credentials (np. jeśli zajmujesz się uwierzytelnianiem w przypadku obu platform). Aby rozwiązać ten problem, możesz podać 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 wersji przeglądarki Chromium M87 lub więcej.

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, używa funkcji entity i credentials w żądanie wczytania. Jeśli jednak Twoja aplikacja na Androida TV zostanie wprowadzona na rynek, pakiet SDK zastąpi entity i credentials z urządzeniami atvEntity i atvCredentials (jeśli określono).

Wczytywanie według Content ID lub MediaQueueData

Jeśli nie używasz entity ani atvEntity i korzystasz z Content ID lub Adres URL treści w Informacjach o multimediach lub użyj bardziej szczegółowego parametru Wczytanie multimediów Żądaj danych, musisz dodać ten wstępnie zdefiniowany filtr intencji w w aplikacji na Androida TV:

<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 wczytywania według elementu, może 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 wersji przeglądarki Chromium M87 lub więcej.

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 wczytywania 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 wykrywa intencję wczytywania, wyodrębnia MediaLoadRequestData z intencji i wywołaj MediaLoadCommandCallback.onLoad(). Zastąp tę metodę, aby obsłużyć żądanie wczytywania. Wywołanie zwrotne musi zarejestrować się przed MediaManager.onNewIntent() (zaleca się korzystanie z Aktywności lub aplikacji onCreate() ).

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ę w struktury danych zdefiniowaliśmy (MediaLoadRequestData) dla żądań wczytywania).

Obsługa poleceń multimedialnych

Podstawowe funkcje sterowania odtwarzaniem

Podstawowe polecenia integracji obejmują polecenia zgodne z multimediami . Te polecenia są powiadamiane przez wywołania zwrotne sesji multimediów. Czynności, które musisz wykonać zarejestruj wywołanie zwrotne do sesji multimediów, aby to obsłużyć (możliwe, że jest to ).

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, na przykład skipAd() lub setActiveMediaTracks(). Musisz też zaimplementować niektóre polecenia związane z kolejką przesyłania, Usługa 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

Tak jak w przypadku odbiornika Cast, aplikacja na Androida TV powinna określać, które polecenia są obsługiwane, więc nadawcy mogą włączać i wyłączać określone elementy interfejsu. Dla: poleceń, które są częścią MediaSession, podaj polecenia w PlaybackStateCompat Dodatkowe polecenia należy podać w sekcji 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 aplikacja na Androida TV obsługuje tylko podstawowe sterowanie multimediami, ale odbiornik internetowy zapewnia bardziej zaawansowaną kontrolę, upewnij się, że aplikacja nadawcy działa podczas przesyłania do aplikacji na Androida TV. Jeśli na przykład urządzenie z Androidem TV ale aplikacja Web Receiver nie obsługuje zmiany szybkości odtwarzania, ustaw obsługiwane działania na każdej platformie i upewnij się, aplikacja nadawcy poprawnie renderuje interfejs użytkownika.

Modyfikowanie stanu MediaStatus

Aby obsługiwać zaawansowane funkcje, takie jak ścieżki, reklamy, transmisje na żywo i kolejkowanie, Aplikacja na telewizor musi podawać dodatkowe informacje, których nie można ustalić za pomocą MediaSession

Udostępniamy MediaStatusModifier aby to osiągnąć. MediaStatusModifier będzie zawsze działać w MediaSession, które ustawiono w CastReceiverContext.

Do tworzenia i transmitowania 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 otrzyma podstawową MediaStatus z MediaSession, Aplikacja na Androida TV może określać dodatkowy stan i zastępować stan za pomocą Modyfikator MediaStatus.

Niektóre stany i metadane można ustawiać zarówno w polu MediaSession, jak i w MediaStatusModifier Zdecydowanie zalecamy stosowanie ich MediaSession Nadal możesz używać modyfikatora, aby zastąpić stany w MediaSession – odradzamy takie rozwiązanie, ponieważ stan w modyfikatorze jest zawsze mają wyższy priorytet niż wartości podane przez MediaSession.

Przechwytywanie stanu MediaStatus przed wysłaniem

Tak samo jak w pakiecie SDK odbiornika, jeśli chcesz wprowadzić ostatnie poprawki, możesz określić MediaStatusInterceptor do przetwarzania MediaStatus do które można wysłać. Przechodzimy MediaStatusWriter manipulowania MediaStatus przed 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 jej 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ć na dodatkowe do dołączenia do sesji ATV. Jeśli użytkownik poda dane logowania, Twoja aplikacja ATV musi obsługiwać swoje dane logowania, aby możliwe było śledzenie postępów i innych danych użytkownika poprawnie śledzone.

Gdy aplikacja nadawcy uruchomi aplikację na Androida TV lub dołączy do niej, aplikacja nadawcy należy podać dane logowania, które określają, kto dołącza do sesji.

Możesz określić, zanim nadawca uruchomi Twoją aplikację na Androida TV i do niej dołączy. uruchomić narzędzie do sprawdzania, czy dane logowania nadawcy są dozwolone. Jeśli nie, funkcja Cast Connect SDK uruchamia odbiornik internetowy.

Dane logowania do uruchomienia aplikacji nadawcy

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

Ciąg credentials może być zdefiniowany przez użytkownika, o ile jest w stanie ją zrozumieć. Pole credentialsType określa, która platforma Wartość CredentialsData pochodzi z wartości lub może być wartością niestandardową. Domyślnie jest ono ustawione na platformę, z której jest wysyłany.

Wartość CredentialsData jest przekazywana do aplikacji na Androida TV tylko podczas jej uruchamiania lub czasu dołączenia. Jeśli ustawisz je ponownie po nawiązaniu połączenia, nie zostanie ono przekazane do w aplikacji na Androida TV. Jeśli nadawca przełączy profil podczas połączenia, mogą pozostać w tej sesji lub zadzwonić 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 otrzymać SenderInfo, getCastLaunchRequest() aby uzyskać CastLaunchRequest, a potem getCredentialsData().

Android

Wymaga wersji play-services-cast-framework 19.0.0 lub więcej.

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.3 lub wyższe.

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

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

Wymaga wersji przeglądarki Chromium M87 lub więcej.

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ć. Dostępne opcje zaimplementuj LaunchRequestChecker aby zaakceptować lub odrzucić tę prośbę.

W przypadku odrzucenia żądania odbiornik internetowy jest wczytywany, a nie uruchamiany. do aplikacji ATV. Odrzuć prośbę, jeśli Twój quad nie może i obsługi użytkownika. Przykładem może być to, użytkownik jest zalogowany w aplikacji ATV, niż o to prosi, i aplikacja nie może obsługi danych logowania do przełączania lub żaden użytkownik nie jest obecnie zalogowany Aplikacja ATV.

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

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

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

Przetwarzam: true w LaunchRequestChecker. uruchamia aplikację ATV, a false uruchamia Twoją aplikację odbiornika internetowego.

Wysyłanie & Odbieranie wiadomości niestandardowych

Protokół Cast umożliwia wysyłanie niestandardowych ciągów tekstowych między nadawcami a w aplikacji odbiornika. Aby wysyłać, musisz zarejestrować przestrzeń nazw (kanał) wiadomości przed zainicjowaniem CastReceiverContext

Android TV – określ niestandardową przestrzeń nazw

Musisz określić obsługiwane przestrzenie nazw w CastReceiverOptions podczas konfiguracji:

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