הוספת תכונות ליבה למקלט Android TV

בדף הזה יש קטעי קוד ותיאורים של התכונות שזמינות להתאמה אישית של אפליקציית מקלט Android TV.

הגדרת ספריות

כדי להפוך את ממשקי ה-API של Cast Connect לזמינים באפליקציה ל-Android TV:

Android
  1. פותחים את הקובץ build.gradle בתוך ספריית מודול האפליקציה.
  2. מוודאים ש-google() נכלל ב-repositories שמופיעים ברשימה. 
      repositories {
    google()
  }
  3. בהתאם לסוג מכשיר היעד של האפליקציה, מוסיפים את הגרסאות האחרונות של הספריות לתלות:
    • באפליקציית Android Receiver: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast-tv:21.1.1'
    implementation 'com.google.android.gms:play-services-cast:22.3.1'
  }
    • באפליקציית השולט ל-Android: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast:21.1.1'
    implementation 'com.google.android.gms:play-services-cast-framework:22.3.1'
  }
    חשוב לעדכן את מספר הגרסה הזה בכל פעם שהשירותים מתעדכנים.
  4. שומרים את השינויים ולוחצים על Sync Project with Gradle Files בסרגל הכלים.
iOS
  1. מוודאים ש-Podfile מטרגט ל-google-cast-sdk 4.8.6 ומעלה
  2. לטרגט ל-iOS מגרסה 16 ואילך. פרטים נוספים מופיעים בהערות המוצר. 
      platform: ios, '16'

  def target_pods
     pod 'google-cast-sdk', '~>4.8.6'
  end
באינטרנט
  1. נדרשת גרסה M87 ואילך של דפדפן Chromium.
  2. הוספה של ספריית Web Sender API לפרויקט 
      <script src="//www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"></script>

דרישה ל-AndroidX

בגרסאות חדשות של Google Play Services, כדי להשתמש במרחב השמות androidx, צריך לעדכן את האפליקציה. פועלים לפי ההוראות למעבר ל-AndroidX.

אפליקציה ל-Android TV – דרישות מוקדמות

כדי לתמוך ב-Cast Connect באפליקציה ל-Android TV, צריך ליצור אירועים ממדיה סשן ולתמוך בהם. הנתונים שסופקו על ידי סשן המדיה מספקים את המידע הבסיסי – לדוגמה, מיקום, מצב הפעלה וכו' – לגבי סטטוס המדיה. ספריית Cast Connect משתמשת גם בסשן המדיה כדי לסמן מתי היא קיבלה הודעות מסוימות משולח, כמו השהיה.

מידע נוסף על סשן מדיה ועל אופן ההפעלה של סשן מדיה זמין במדריך לעבודה עם סשן מדיה.

מחזור החיים של סשן מדיה

האפליקציה צריכה ליצור סשן מדיה כשההפעלה מתחילה ולשחרר אותו כשאי אפשר יותר לשלוט בהפעלה. לדוגמה, אם האפליקציה שלכם היא אפליקציית וידאו, אתם צריכים לשחרר את הסשן כשהמשתמש יוצא מפעילות ההפעלה – או על ידי בחירה באפשרות 'חזרה' כדי לעיין בתוכן אחר, או על ידי העברת האפליקציה לרקע. אם האפליקציה שלכם היא אפליקציית מוזיקה, אתם צריכים לשחרר את הסשן כשהאפליקציה כבר לא מפעילה מדיה.

מתבצע עדכון של סטטוס הסשן

הנתונים בסשן המדיה צריכים להיות עדכניים ולשקף את הסטטוס של נגן המדיה. לדוגמה, כשמשהים את ההפעלה, צריך לעדכן גם את מצב ההפעלה וגם את הפעולות הנתמכות. בטבלאות הבאות מפורטים המצבים שאתם אחראים לעדכן.

MediaMetadataCompat

שדה מטא-נתונים תיאור
‫METADATA_KEY_TITLE (חובה) שם המדיה.
METADATA_KEY_DISPLAY_SUBTITLE כותרת המשנה.
METADATA_KEY_DISPLAY_ICON_URI כתובת ה-URL של הסמל.
‫METADATA_KEY_DURATION (חובה) משך המדיה.
METADATA_KEY_MEDIA_URI מזהה התוכן.
METADATA_KEY_ARTIST האומן.
METADATA_KEY_ALBUM האלבום.

PlaybackStateCompat

שיטה נדרשת תיאור
setActions() מגדירה את פקודות המדיה הנתמכות.
setState() הגדרת מצב ההפעלה והמיקום הנוכחי.

MediaSessionCompat

שיטה נדרשת תיאור
setRepeatMode() הגדרת מצב הפעלה חוזרת.
setShuffleMode() הגדרת מצב ההפעלה האקראית.
setMetadata() מגדירה את המטא-נתונים של המדיה.
setPlaybackState() הגדרת מצב ההפעלה.
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);
}

טיפול בבקרת תחבורה

באפליקציה צריך להטמיע קריאה חוזרת (callback) לשליטה בהעברה של סשן מדיה. בטבלה הבאה מוצגות פעולות השליטה בהעברה שהם צריכים לטפל בהן:

MediaSessionCompat.Callback

פעולות תיאור
onPlay() המשך
onPause() השהיה
onSeekTo() דילוג למיקום מסוים
onStop() הפסקת המדיה הנוכחית
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());

הגדרת תמיכה ב-Cast

כשיישום שולח בקשה להפעלה, נוצרת כוונה עם מרחב שמות של היישום. האפליקציה אחראית לטפל בזה וליצור מופע של האובייקט CastReceiverContext כשמפעילים את האפליקציה לטלוויזיה. האובייקט CastReceiverContext נדרש כדי לקיים אינטראקציה עם Cast בזמן שאפליקציית הטלוויזיה פועלת. האובייקט הזה מאפשר לאפליקציית הטלוויזיה לקבל הודעות מדיה של Cast מכל השולחים המחוברים.

הגדרת Android TV

הוספת מסנן Intent להפעלה

מוסיפים מסנן Intent חדש לפעילות שרוצים שתטפל ב-Intent להפעלת האפליקציה מאפליקציית השולח:

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

ציון ספק של אפשרויות למקלט

צריך להטמיע ReceiverOptionsProvider כדי לספק 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();
  }
}

לאחר מכן מציינים את ספק האפשרויות ב-AndroidManifest:

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

המאפיין ReceiverOptionsProvider משמש להגדרת CastReceiverOptions כשמאתחלים את CastReceiverContext.

ההקשר של מקלט Cast

מאתחלים את CastReceiverContext כשהאפליקציה נוצרת:

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

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

  ...
}

הפעלת CastReceiverContext כשהאפליקציה עוברת לחזית:

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

להתקשר stop() בCastReceiverContext אחרי שהאפליקציה עוברת לרקע באפליקציות וידאו או באפליקציות שלא תומכות בהפעלה ברקע:

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

בנוסף, אם האפליקציה תומכת בהפעלה ברקע, צריך לקרוא ל-stop() ב-CastReceiverContext כשההפעלה נפסקת ברקע.

מומלץ מאוד להשתמש ב-LifecycleObserver מהספרייה androidx.lifecycle כדי לנהל את הקריאות CastReceiverContext.start() ו-CastReceiverContext.stop(), במיוחד אם לאפליקציית הנייטיב יש כמה Activity. כך נמנעים מצבי מירוץ כשקוראים ל-start() ול-stop() מפעילויות שונות.

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">

קישור MediaSession ל-MediaManager

כשיוצרים MediaSession, צריך גם לספק את אסימון MediaSession הנוכחי ל-CastReceiverContext כדי שהאסימון ידע לאן לשלוח את הפקודות ולאחזר את מצב הפעלת המדיה:

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

כשמפסיקים את ההפעלה של MediaSession בגלל חוסר פעילות, צריך להגדיר אסימון null ב-MediaManager:

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

אם האפליקציה תומכת בהפעלת מדיה כשהיא ברקע, במקום להפעיל את CastReceiverContext.stop() כשהאפליקציה עוברת לרקע, צריך להפעיל אותה רק כשהאפליקציה ברקע ולא מפעילה יותר מדיה. לדוגמה:

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

שימוש ב-ExoPlayer עם Cast Connect

אם אתם משתמשים ב-Exoplayer, אתם יכולים להשתמש ב-MediaSessionConnector כדי לשמור באופן אוטומטי על הסשן ועל כל המידע שקשור אליו, כולל מצב ההפעלה, במקום לעקוב אחרי השינויים באופן ידני.

אפשר להשתמש ב-MediaSessionConnector.MediaButtonEventHandler כדי לטפל באירועים של MediaButton על ידי קריאה ל-setMediaButtonEventHandler(MediaButtonEventHandler), שאחרת מטופלים על ידי MediaSessionCompat.Callback כברירת מחדל.

כדי לשלב את MediaSessionConnector באפליקציה, מוסיפים את הקוד הבא למחלקה של פעילות הנגן או למיקום שבו מנהלים את סשן המדיה:

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);
    ...
  }
}

הגדרה של אפליקציית השולח

הפעלת התמיכה ב-Cast Connect

אחרי שמעדכנים את אפליקציית השולח עם תמיכה ב-Cast Connect, אפשר להצהיר על מוכנותה על ידי הגדרת הדגל androidReceiverCompatible ב-LaunchOptions לערך true.

Android

נדרשת גרסה play-services-cast-framework‏ 19.0.0 ואילך.

הדגל androidReceiverCompatible מוגדר ב-LaunchOptions (שהוא חלק מ-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

נדרשת גרסה google-cast-sdk v4.4.8 ואילך.

הדגל androidReceiverCompatible מוגדר ב-GCKLaunchOptions (שהוא חלק מ-GCKCastOptions):

let options = GCKCastOptions(discoveryCriteria: GCKDiscoveryCriteria(applicationID: kReceiverAppID))
...
let launchOptions = GCKLaunchOptions()
launchOptions.androidReceiverCompatible = true
options.launchOptions = launchOptions
GCKCastContext.setSharedInstanceWith(options)
אתר

נדרשת גרסה M87 ואילך של דפדפן Chromium.

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

הגדרה של Cast Developer Console

הגדרת אפליקציה ל-Android TV

מוסיפים את שם החבילה של אפליקציה ל-Android TV ב-Cast Developer Console כדי לשייך אותה למזהה אפליקציית Cast.

רישום מכשירים למפתחים

צריך לרשום את המספר הסידורי של מכשיר Android TV שבו תשתמשו לפיתוח ב-Cast Developer Console.

מטעמי אבטחה, בלי הרשמה, Cast Connect יפעל רק באפליקציות שהותקנו מ-Google Play Store.

מידע נוסף על רישום מכשיר Cast או מכשיר Android TV לפיתוח Cast זמין בדף הרישום.

המדיה בטעינה

אם כבר הטמעתם תמיכה בקישורי עומק באפליקציה ל-Android TV, אמורה להיות לכם הגדרה דומה בקובץ המניפסט של Android TV:

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

טעינה לפי ישות אצל השולח

בצד השולח, אפשר להעביר את קישור העומק על ידי הגדרת entity בפרטי המדיה של בקשת הטעינה:

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)
אתר

נדרשת גרסה M87 ואילך של דפדפן Chromium.

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

פקודת הטעינה נשלחת באמצעות intent עם קישור העומק ושם החבילה שהגדרתם ב-Developer Console.

הגדרת פרטי כניסה של ATV בשולח

יכול להיות שאפליקציית Web Receiver ואפליקציה ל-Android TV תומכות בקישורים עמוקים שונים ובcredentials (לדוגמה, אם אתם מטפלים באימות באופן שונה בשתי הפלטפורמות). כדי לפתור את הבעיה, אפשר לספק חלופות ל-entity ול-credentials ב-Android 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)
אתר

נדרשת גרסה M87 ואילך של דפדפן Chromium.

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

אם אפליקציית Web Receiver מופעלת, היא משתמשת ב-entity וב-credentials בבקשת הטעינה. עם זאת, אם האפליקציה ל-Android TV מופעלת, ה-SDK מבטל את entity ואת credentials ומחליף אותם ב-atvEntity וב-atvCredentials (אם צוינו).

טעינה באמצעות Content ID או MediaQueueData

אם אתם לא משתמשים ב-entity או ב-atvEntity, ואתם משתמשים ב-Content ID או בכתובת URL של תוכן בפרטי המדיה שלכם, או אם אתם משתמשים בנתונים מפורטים יותר של בקשת טעינת מדיה, אתם צריכים להוסיף את מסנן Intent המוגדר מראש הבא באפליקציה ל-Android 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>

בצד השולח, בדומה לטעינה לפי ישות, אפשר ליצור בקשת טעינה עם פרטי התוכן ולקרוא ל-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)
אתר

נדרשת גרסה M87 ואילך של דפדפן Chromium.

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

טיפול בבקשות טעינה

כדי לטפל בבקשות הטעינה האלה בפעילות, צריך לטפל ב-intents בקריאות החוזרות של מחזור החיים של הפעילות:

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.
    ...
  }
}

אם MediaManager מזהה שהכוונה היא כוונה לטעינה, הוא מחלץ אובייקט MediaLoadRequestData מהכוונה ומפעיל את MediaLoadCommandCallback.onLoad(). צריך לבטל את השיטה הזו כדי לטפל בבקשת הטעינה. צריך לרשום את הקריאה החוזרת לפני שמבצעים קריאה ל-MediaManager.onNewIntent() (מומלץ להשתמש בשיטה Activity או Application 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);
}

כדי לעבד את כוונת הטעינה, אפשר לנתח את הכוונה למבני הנתונים שהגדרנו (MediaLoadRequestData לבקשות טעינה).

תמיכה בפקודות מדיה

תמיכה בסיסית בשליטה בהפעלה

פקודות בסיסיות לשילוב כוללות את הפקודות שתואמות להפעלת מדיה. ההודעות על הפקודות האלה מועברות באמצעות קריאות חוזרות (callback) של סשן המדיה. כדי לתמוך בזה, צריך לרשום קריאה חוזרת לסשן המדיה (יכול להיות שאתם כבר עושים את זה).

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

תמיכה בפקודות לשליטה ב-Cast

יש פקודות Cast שלא זמינות ב-MediaSession, כמו skipAd() או setActiveMediaTracks(). בנוסף, צריך להטמיע כאן כמה פקודות בתור כי התור של Cast לא תואם באופן מלא לתור של 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());

ציון פקודות מדיה נתמכות

בדומה למקלט Cast, באפליקציה ל-Android TV צריך לציין אילו פקודות נתמכות, כדי שהשולחים יוכלו להפעיל או להשבית אמצעי בקרה מסוימים בממשק המשתמש. לפקודות ששייכות ל-MediaSession, מציינים את הפקודות ב-PlaybackStateCompat. צריך לציין פקודות נוספות בתג 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);

הסתרת כפתורים שלא נתמכים

אם אפליקציה ל-Android TV תומכת רק בשליטה בסיסית במדיה, אבל אפליקציית Web Receiver תומכת בשליטה מתקדמת יותר, צריך לוודא שאפליקציית השולח מתנהגת בצורה תקינה כשמפעילים Cast לאפליקציה ל-Android TV. לדוגמה, אם אפליקציה ל-Android TV לא תומכת בשינוי מהירות ההפעלה, אבל אפליקציית Web Receiver כן תומכת, צריך להגדיר את הפעולות הנתמכות בצורה נכונה בכל פלטפורמה ולוודא שאפליקציית השולח מעבדת את ממשק המשתמש בצורה תקינה.

מתבצע שינוי של MediaStatus

כדי לתמוך בתכונות מתקדמות כמו רצועות, מודעות, שידורים חיים והוספה לתור, אפליקציית Android TV צריכה לספק מידע נוסף שלא ניתן לקבל באמצעות MediaSession.

אנחנו מספקים את המחלקה MediaStatusModifier כדי לעזור לכם להשיג את זה. ‫MediaStatusModifier תמיד יפעל על MediaSession שהגדרתם ב-CastReceiverContext.

כדי ליצור ולשדר 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();

ספריית הלקוח שלנו תקבל את הבסיס MediaStatus מ-MediaSession, ואפליקציה ל-Android TV שלכם יכולה לציין סטטוס נוסף ולשנות את הסטטוס באמצעות משנה MediaStatus.

אפשר להגדיר חלק מהמצבים והמטא-נתונים גם ב-MediaSession וגם ב-MediaStatusModifier. מומלץ מאוד להגדיר אותם רק ב-MediaSession. עדיין אפשר להשתמש במאפיין לשינוי כדי לשנות את המצבים ב-MediaSession – אבל לא מומלץ לעשות את זה כי למצב במאפיין לשינוי תמיד יש עדיפות גבוהה יותר מהערכים שמוגדרים ב-MediaSession.

יירוט של MediaStatus לפני השליחה

בדומה ל-Web Receiver SDK, אם רוצים לבצע שינויים אחרונים לפני השליחה, אפשר לציין MediaStatusInterceptor כדי לעבד את MediaStatus שיישלח. אנחנו מעבירים את MediaStatusWriter כדי לשנות את MediaStatus לפני שהוא נשלח.

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\"}"));
    }
});

טיפול בפרטי כניסה של משתמשים

יכול להיות שבאפליקציה שלכם ל-Android TV רק משתמשים מסוימים יוכלו להפעיל את סשן האפליקציה או להצטרף אליו. לדוגמה, אפשר לאפשר לשולח להתחיל שיחה או להצטרף אליה רק אם:

  • באפליקציית השולח מחוברים לאותו חשבון ולאותו פרופיל כמו באפליקציית ATV.
  • אפליקציית השולח מחוברת לאותו חשבון, אבל לפרופיל שונה מאפליקציית ATV.

אם האפליקציה יכולה לטפל בכמה משתמשים או במשתמשים אנונימיים, אתם יכולים לאפשר לכל משתמש נוסף להצטרף לסשן של ATV. אם המשתמש מספק פרטי כניסה, אפליקציית ה-ATV צריכה לטפל בפרטי הכניסה שלו כדי לעקוב בצורה תקינה אחרי ההתקדמות שלו ונתוני משתמש אחרים.

כשאפליקציית השולח מופעלת או מצטרפת לאפליקציה ל-Android TV, היא צריכה לספק את פרטי הכניסה שמייצגים את מי שמצטרף להפעלה.

לפני שהשולח מפעיל את האפליקציה שלכם ל-Android TV ומצטרף אליה, אתם יכולים לציין בודק הפעלה כדי לראות אם פרטי הכניסה של השולח מורשים. אם לא, ה-SDK של Cast Connect יחזור להפעיל את Web Receiver.

נתונים של פרטי כניסה להפעלת אפליקציית השולח

בצד השולח, אפשר לציין את השדה CredentialsData כדי לייצג את מי שמצטרף לסשן.

‫credentials הוא מחרוזת שאפשר להגדיר אותה לפי הצורך, כל עוד אפליקציית ה-ATV יכולה להבין אותה. הערך credentialsType מגדיר מאיזו פלטפורמה מגיע הערך CredentialsData, או שהוא יכול להיות ערך מותאם אישית. כברירת מחדל, הערך שמוגדר הוא הפלטפורמה שממנה נשלח האימייל.

הפרמטר CredentialsData מועבר לאפליקציה שלכם ל-Android TV רק בזמן ההפעלה או ההצטרפות. אם תגדירו אותו מחדש בזמן שאתם מחוברים, הוא לא יועבר לאפליקציה ל-Android TV. אם השולח יחליף את הפרופיל בזמן שאתם מחוברים, תוכלו להישאר בסשן או להתקשר אל SessionManager.endCurrentCastSession(boolean stopCasting) אם לדעתכם הפרופיל החדש לא תואם לסשן.

אפשר לאחזר את CredentialsData של כל שולח באמצעות getSenders ב-CastReceiverContext כדי לקבל את SenderInfo,‏ getCastLaunchRequest() כדי לקבל את CastLaunchRequest, ואז getCredentialsData().

Android

נדרשת גרסה play-services-cast-framework‏ 19.0.0 ואילך.

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

נדרשת גרסה google-cast-sdk v4.8.6 ואילך.

אפשר לקרוא לפונקציה הזו בכל שלב אחרי הגדרת האפשרויות: GCKCastContext.setSharedInstanceWith(options).

GCKCastContext.sharedInstance().setLaunch(
    GCKCredentialsData(credentials: "{\"userId\": \"abc\"}")
אתר

נדרשת גרסה M87 ואילך של דפדפן Chromium.

אפשר לקרוא לפונקציה הזו בכל שלב אחרי הגדרת האפשרויות: cast.framework.CastContext.getInstance().setOptions(options);. 

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

הטמעה של כלי לבדיקת בקשות להפעלת ATV

הערך של CredentialsData מועבר לאפליקציה ל-Android TV כששולח מנסה להפעיל או להצטרף. אפשר להטמיע LaunchRequestChecker. כדי לאשר או לדחות את הבקשה הזו.

אם בקשה נדחית, Web Receiver נטען במקום להפעיל את האפליקציה של ATV באופן מקורי. כדאי לדחות בקשה אם מכשיר ה-ATV לא יכול לטפל בבקשה של המשתמש להפעיל או להצטרף. לדוגמה, משתמש אחר מחובר לאפליקציית ATV מהמשתמש שמבצע את הבקשה, והאפליקציה לא יכולה לטפל בהחלפת פרטי הכניסה, או שאין משתמש שמחובר כרגע לאפליקציית ATV.

אם הבקשה מורשית, אפליקציית ATV מופעלת. אפשר להתאים אישית את ההתנהגות הזו בהתאם לשאלה אם האפליקציה תומכת בשליחת בקשות טעינה כשמשתמש לא מחובר לאפליקציית ATV או אם יש אי התאמה בין המשתמשים. אפשר להתאים את ההתנהגות הזו באופן מלא בLaunchRequestChecker.

יוצרים מחלקה שמטמיעה את הממשק 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;
}

ואז מגדירים אותו ב-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();
  }
}

פתרון true ב-LaunchRequestChecker מפעיל את אפליקציית ATV, ופתרון false מפעיל את אפליקציית Web Receiver.

שליחה וקבלה של הודעות מותאמות אישית

פרוטוקול Cast מאפשר לכם לשלוח הודעות מחרוזת בהתאמה אישית בין השולחים לבין אפליקציית המקלט שלכם. כדי לשלוח הודעות בין ערוצים, צריך לרשום מרחב שמות (ערוץ) לפני שמפעילים את CastReceiverContext.

‫Android TV – ציון מרחב שמות מותאם אישית

במהלך ההגדרה, צריך לציין את מרחבי השמות הנתמכים ב-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 – שליחת הודעות

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 – קבלת הודעות של מרחב שמות בהתאמה אישית

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());
הקודם
סקירה כללית
הבא
טראקים