Dodawanie podstawowych funkcji do odbiornika Android TV

Ta strona zawiera fragmenty kodu i opisy funkcji, które można wykorzystać do dostosowania aplikacji odbiornika Android TV.

Konfigurowanie bibliotek

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

Android
  1. Otwórz plik build.gradle w katalogu modułu aplikacji.
  2. Sprawdź, czy google() znajduje się na liście repositories. 
      repositories {
    google()
  }
  3. W zależności od typu urządzenia docelowego aplikacji dodaj do zależności najnowsze wersje bibliotek:
    • W przypadku aplikacji odbiornika na Androida: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast-tv:21.1.1'
    implementation 'com.google.android.gms:play-services-cast:23.0.0'
  }
    • W przypadku aplikacji nadawcy na Androida: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast:21.1.1'
    implementation 'com.google.android.gms:play-services-cast-framework:23.0.0'
  }
    Pamiętaj, aby aktualizować ten numer wersji za każdym razem, gdy aktualizujesz usługi.
  4. Zapisz zmiany i kliknij Sync Project with Gradle Files na pasku narzędzi.
iOS
  1. Upewnij się, że Podfile jest kierowany na google-cast-sdk w wersji 4.8.6 lub nowszej
  2. Kieruj na iOS 16 lub nowszy. Więcej informacji znajdziesz w informacjach o wersji. 
      platform: ios, '16'

  def target_pods
     pod 'google-cast-sdk', '~>4.8.6'
  end
Sieć
  1. Wymagana jest przeglądarka Chromium w wersji M87 lub nowszej.
  2. Dodawanie biblioteki Web Sender API do projektu 
      <script src="//www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"></script>

Wymaganie dotyczące AndroidX

Nowe wersje Usług Google Play wymagają, aby aplikacja została zaktualizowana i używała przestrzeni nazw androidx. Postępuj zgodnie z instrukcjami migracji na AndroidX.

Aplikacja na Androida TV – wymagania wstępne

Aby obsługiwać Cast Connect w aplikacji na Androida TV, musisz utworzyć i obsługiwać zdarzenia z sesji multimedialnej. Dane dostarczane przez sesję multimedialną zawierają podstawowe informacje o stanie multimediów, takie jak pozycja, stan odtwarzania itp. Sesja multimedialna jest też używana przez bibliotekę Cast Connect do sygnalizowania, kiedy otrzymała określone wiadomości od nadawcy, np. o wstrzymaniu.

Więcej informacji o sesji multimedialnej i jej inicjowaniu znajdziesz w przewodniku po sesjach multimedialnych.

Cykl życia sesji multimedialnej

Aplikacja powinna utworzyć sesję multimedialną po rozpoczęciu odtwarzania i zwolnić ją, gdy nie będzie już można nią sterować. Jeśli na przykład Twoja aplikacja jest aplikacją wideo, sesję należy zwolnić, gdy użytkownik zakończy odtwarzanie – wybierając „wstecz”, aby przeglądać inne treści, lub przełączając aplikację do działania w tle. Jeśli Twoja aplikacja jest aplikacją muzyczną, należy ją zwolnić, gdy nie odtwarza już żadnych multimediów.

Aktualizuję stan sesji

Dane w sesji multimedialnej powinny być aktualizowane zgodnie ze stanem odtwarzacza. Na przykład po wstrzymaniu odtwarzania należy zaktualizować stan odtwarzania i obsługiwane działania. W tabelach poniżej znajdziesz informacje o tym, które stany musisz aktualizować.

MediaMetadataCompat

Pole metadanych Opis
METADATA_KEY_TITLE (wymagany) Tytuł multimediów.
METADATA_KEY_DISPLAY_SUBTITLE Podtytuł.
METADATA_KEY_DISPLAY_ICON_URI URL ikony.
METADATA_KEY_DURATION (wymagany) Czas trwania multimediów.
METADATA_KEY_MEDIA_URI Content ID.
METADATA_KEY_ARTIST Artysta.
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 sterowania transportem

Aplikacja powinna implementować wywołanie zwrotne sterowania transportem sesji multimedialnej. W tabeli poniżej znajdziesz działania związane ze sterowaniem odtwarzaniem, które muszą obsługiwać:

MediaSessionCompat.Callback

Działania Opis
onPlay() Wznów
onPause() Wstrzymaj
onSeekTo() Przewijanie 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 Cast

Gdy aplikacja nadawcy wysyła żądanie uruchomienia, tworzona jest intencja z przestrzenią nazw aplikacji. Twoja aplikacja odpowiada za obsługę tego zdarzenia i utworzenie instancji obiektu CastReceiverContext po uruchomieniu aplikacji TV. Obiekt CastReceiverContext jest potrzebny do interakcji z Cast, gdy aplikacja TV jest uruchomiona. Ten obiekt umożliwia aplikacji telewizyjnej akceptowanie wiadomości multimedialnych Cast pochodzących od dowolnych połączonych nadawców.

Konfiguracja Androida TV

Dodawanie filtra intencji uruchomienia

Dodaj nowy filtr intencji do aktywności, która ma obsługiwać intencję uruchomienia z aplikacji nadawcy:

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

Określ dostawcę opcji odbiornika

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 pliku 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 dostarczania CastReceiverOptions podczas inicjowania CastReceiverContext.

Kontekst odbiornika Cast

Zainicjuj CastReceiverContext po utworzeniu aplikacji:

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

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

  ...
}

Uruchom CastReceiverContext, gdy aplikacja przejdzie na pierwszy plan:

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

Wywołaj metodę stop() w CastReceiverContext, gdy aplikacja przejdzie do działania w tle (dotyczy 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 aplikacja obsługuje odtwarzanie w tle, wywołaj stop() w CastReceiverContext, gdy odtwarzanie w tle zostanie zatrzymane.

Zdecydowanie zalecamy używanie 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ąć sytuacji wyścigu, gdy wywołujesz metody 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 MediaManager

Podczas tworzenia MediaSession musisz też podać bieżący token MediaSession dla CastReceiverContext, aby usługa wiedziała, gdzie wysyłać polecenia i skąd 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 braku aktywności, ustaw token null w 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 w tle, zamiast wywoływać metodę CastReceiverContext.stop(), gdy aplikacja jest wysyłana do działania w tle, wywołuj 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();
  }
}

Korzystanie z Exoplayera z Cast Connect

Jeśli używasz Exoplayer, możesz użyć MediaSessionConnector, aby automatycznie utrzymywać sesję i wszystkie powiązane informacje, w tym stan odtwarzania, zamiast ręcznie śledzić zmiany.

MediaSessionConnector.MediaButtonEventHandler można używać do obsługi zdarzeń MediaButton przez wywołanie setMediaButtonEventHandler(MediaButtonEventHandler), które w przeciwnym razie są domyślnie obsługiwane przez MediaSessionCompat.Callback.

Aby zintegrować MediaSessionConnector w aplikacji, dodaj poniższy kod do klasy aktywności odtwarzacza lub do miejsca, w którym zarządzasz sesją multimedialną:

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łączanie obsługi Cast Connect

Po zaktualizowaniu aplikacji nadawcy, aby obsługiwała Cast Connect, możesz zadeklarować jej gotowość, ustawiając flagę androidReceiverCompatible w LaunchOptions na wartość „true”.

Android

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

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

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

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

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

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

Wymagana jest przeglądarka Chromium w wersji M87 lub nowszej.

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

Konfiguracja konsoli Cast Developer Console

Konfigurowanie aplikacji na Androida TV

Dodaj nazwę pakietu aplikacji na Androida TV w Konsoli programisty Cast, aby 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ć do programowania, w Konsoli Google Cast dla deweloperów.

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

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

Wczytuję multimedia

Jeśli w aplikacji na Androida TV masz już skonfigurowaną obsługę precyzyjnych linków, w pliku manifestu Androida TV powinna znajdować się 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>

Obciążenie według encji u nadawcy

Na urządzeniach nadawczych możesz przekazać precyzyjny link, ustawiając entity w informacjach o multimediach w żądaniu 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ć

Wymagana jest przeglądarka 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 wczytania jest wysyłane za pomocą intencji z precyzyjnym linkiem i nazwą pakietu zdefiniowaną w konsoli programisty.

Konfigurowanie danych logowania ATV na urządzeniu nadawczym

Możliwe, że aplikacja odbiornika internetowego i aplikacja na Androida TV obsługują różne precyzyjne linki i credentials (np. jeśli uwierzytelnianie jest obsługiwane inaczej na obu platformach). Aby rozwiązać ten problem, możesz podać alternatywne entity i credentials na Androida 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ć

Wymagana jest przeglądarka 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 odbiornika internetowego zostanie uruchomiona, użyje parametrów entity i credentials w żądaniu wczytania. Jeśli jednak aplikacja na Androida TV zostanie uruchomiona, pakiet SDK zastąpi parametry entity i credentials parametrami atvEntity i atvCredentials (jeśli zostały określone).

Wczytywanie według identyfikatora treści lub MediaQueueData

Jeśli nie używasz entity ani atvEntity, a używasz Content ID lub adresu URL treści w informacjach o multimediach albo bardziej szczegółowych danych żądania wczytania multimediów, musisz dodać ten wstępnie zdefiniowany filtr intencji 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 encji, możesz utworzyć żądanie wczytania 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ć

Wymagana jest przeglądarka 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ń wczytania

Aby obsłużyć te żądania wczytywania, musisz obsłużyć intencje w wywołaniach zwrotnych cyklu życia działania:

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, że intencja jest intencją wczytywania, wyodrębnia z niej obiekt MediaLoadRequestData i wywołuje MediaLoadCommandCallback.onLoad(). Aby obsłużyć żądanie wczytania, musisz zastąpić tę metodę. Wywołanie zwrotne musi być zarejestrowane przed wywołaniem MediaManager.onNewIntent() (zalecamy, aby było to w metodzie onCreate() 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ą pod kątem struktur danych, które zdefiniowaliśmy (MediaLoadRequestData w przypadku żądań wczytywania).

Obsługuje polecenia multimedialne

Obsługa podstawowych elementów sterujących odtwarzaniem

Podstawowe polecenia integracji obejmują polecenia zgodne z sesją multimedialną. Te polecenia są przekazywane za pomocą wywołań zwrotnych sesji multimedialnej. Aby to umożliwić, musisz zarejestrować wywołanie zwrotne w sesji multimedialnej (być może już to robisz).

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

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

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

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

  ...
}

mediaSession.setCallback(new MyMediaSessionCallback());

Obsługa poleceń sterowania przesyłaniem

Niektóre polecenia przesyłania nie są dostępne w MediaSession, np. skipAd() czy setActiveMediaTracks(). Należy tu też zaimplementować niektóre polecenia kolejki, ponieważ kolejka Cast nie jest w pełni zgodna z kolejką MediaSession.

Kotlin
class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onSkipAd(requestData: RequestData?): Task<Void?> {
        // 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ń multimedialnych

Podobnie jak w przypadku odbiornika Cast, aplikacja na Androida TV powinna określać, które polecenia są obsługiwane, aby nadawcy mogli włączać lub wyłączać określone elementy sterujące interfejsu. W przypadku poleceń, które są częścią MediaSession, określ polecenia w PlaybackStateCompat. Dodatkowe polecenia należy określić w pliku 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, a aplikacja odbiornika internetowego obsługuje bardziej zaawansowane sterowanie, upewnij się, że aplikacja nadawcy działa prawidłowo podczas przesyłania do aplikacji na Androida TV. Jeśli na przykład aplikacja na Androida TV nie obsługuje zmiany szybkości odtwarzania, a aplikacja odbiornika internetowego obsługuje tę funkcję, musisz prawidłowo ustawić obsługiwane działania na każdej platformie i upewnić się, że aplikacja nadawcy prawidłowo renderuje interfejs.

Modyfikowanie MediaStatus

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

Aby to umożliwić, udostępniamy klasę MediaStatusModifier. MediaStatusModifier będzie zawsze działać w MediaSession ustawionej w CastReceiverContext.

Aby utworzyć i wysł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 MediaSession, a Twoja aplikacja na Androida TV może określić dodatkowy stan i zastąpić stan za pomocą modyfikatora MediaStatus.

Niektóre stany i metadane można ustawić zarówno w MediaSession, jak i MediaStatusModifier. Zdecydowanie zalecamy ustawianie ich tylko w MediaSession. Nadal możesz używać modyfikatora, aby zastąpić stany w MediaSession – nie jest to zalecane, ponieważ stan w modyfikatorze zawsze ma wyższy priorytet niż wartości podane przez MediaSession.

Przechwytywanie MediaStatus przed wysłaniem

Podobnie jak w przypadku pakietu SDK odbiornika internetowego, jeśli chcesz wprowadzić ostatnie poprawki przed wysłaniem, możesz określić MediaStatusInterceptor, aby przetworzyć wysyłany obiekt MediaStatus. Przekazujemy MediaStatusWriter, aby zmodyfikować 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 sesji aplikacji lub dołączanie do niej. Możesz na przykład zezwolić nadawcy na uruchamianie sesji lub dołączanie do niej tylko wtedy, gdy:

  • Aplikacja nadawcy jest zalogowana na to samo konto i profil co aplikacja ATV.
  • Aplikacja nadawcy jest zalogowana na to samo konto, ale na inny profil niż aplikacja ATV.

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

Gdy aplikacja nadawcy uruchamia aplikację na Androida TV lub do niej dołącza, powinna podać dane logowania, które reprezentują osobę dołączającą do sesji.

Zanim nadawca uruchomi aplikację na Androida TV i do niej dołączy, możesz określić moduł sprawdzający uruchamianie, aby sprawdzić, czy dane logowania nadawcy są dozwolone. Jeśli nie, pakiet SDK Cast Connect uruchomi odbiornik internetowy.

Dane logowania do aplikacji nadawcy

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

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

CredentialsData jest przekazywany do aplikacji na Androida TV tylko podczas uruchamiania lub dołączania. Jeśli ustawisz go ponownie, gdy będziesz mieć połączenie, nie zostanie on przekazany do aplikacji na Androida TV. Jeśli nadawca przełączy profil, gdy będzie połączony, możesz pozostać w sesji lub wywołać metodę 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 na CastReceiverContext, aby uzyskać SenderInfo, getCastLaunchRequest(), aby uzyskać CastLaunchRequest, a następnie getCredentialsData().

Android

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

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

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

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

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

Wymagana jest przeglądarka Chromium w wersji M87 lub nowszej.

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

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

Wdrażanie narzędzia do sprawdzania żądań uruchomienia ATV

Gdy nadawca próbuje uruchomić aplikację na Androida TV lub do niej dołączyć, przekazywany jest do niej parametr CredentialsData. Możesz wdrożyć LaunchRequestChecker. aby zezwolić na tę prośbę lub ją odrzucić.

Jeśli żądanie zostanie odrzucone, zamiast uruchomienia aplikacji ATV zostanie wczytany odbiornik internetowy. Żądanie należy odrzucić, jeśli aplikacja ATV nie może obsłużyć użytkownika, który chce uruchomić aplikację lub do niej dołączyć. Może się tak zdarzyć, gdy w aplikacji ATV jest zalogowany inny użytkownik niż ten, który wysyła żądanie, a aplikacja nie może obsłużyć przełączania danych logowania, lub gdy w aplikacji ATV nie jest obecnie zalogowany żaden użytkownik.

Jeśli żądanie zostanie zaakceptowane, aplikacja ATV zostanie uruchomiona. Możesz dostosować to zachowanie w zależności od tego, czy aplikacja obsługuje wysyłanie żądań wczytywania, gdy użytkownik nie jest zalogowany w aplikacji ATV lub gdy występuje niezgodność użytkowników. To zachowanie można w pełni dostosować w LaunchRequestChecker.

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

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

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

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

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

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

  // Unrecognized credentials type.
  return false;
}

Następnie ustaw go w pliku 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 uruchamia aplikację ATV, a false uruchamia aplikację odbiornika internetowego.

Wysyłanie i odbieranie wiadomości niestandardowych

Protokół Cast umożliwia wysyłanie niestandardowych wiadomości tekstowych między nadawcami a aplikacją odbiornika. Zanim zainicjujesz CastReceiverContext, musisz zarejestrować przestrzeń nazw (kanał), aby wysyłać wiadomości.

Android TV – określanie niestandardowej przestrzeni nazw

Podczas konfiguracji musisz określić obsługiwane przestrzenie nazw w pliku 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 niestandardowej przestrzeni nazw

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

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

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