‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

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

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

הגדרת ספריות

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

Android

פותחים את הקובץ build.gradle בספריית המודולים של האפליקציה.
הערה: פרויקטים ב-Android Studio מכילים קובץ build.gradle ברמה העליונה וקובץ build.gradle לכל מודול. חשוב לערוך את הקובץ של מודול האפליקציה. מידע נוסף על Gradle זמין במאמר בניית הפרויקט באמצעות Gradle.
מוודאים שהערך google() נכלל ב-repositories שמופיע ברשימה.
```
  repositories {
    google()
  }
```

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

באפליקציית Android Receiver:

  dependencies {
    implementation 'com.google.android.gms:play-services-cast-tv:21.1.1'
    implementation 'com.google.android.gms:play-services-cast:23.0.0'
  }

באפליקציית השליחה ל-Android:

  dependencies {
    implementation 'com.google.android.gms:play-services-cast:21.1.1'
    implementation 'com.google.android.gms:play-services-cast-framework:23.0.0'
  }

חשוב לעדכן את מספר הגרסה בכל פעם שהשירותים מתעדכנים.

שומרים את השינויים ולוחצים על Sync Project with Gradle Files בסרגל הכלים.

iOS

צריך לוודא ש-Podfile מטרגט ל-google-cast-sdk בגרסה 4.8.6 או בגרסה חדשה יותר
מטרגטים ל-iOS 16 ואילך. פרטים נוספים מופיעים בנתוני הגרסה.
```
  platform: ios, '16'

  def target_pods
     pod 'google-cast-sdk', '~>4.8.6'
  end
```

אתר

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

הוספת ספריית 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

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

נדרשת גרסה 19.0.0 ומעלה של play-services-cast-framework.

הדגל 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

נדרשת גרסה v4.4.8 ומעלה של google-cast-sdk.

הדגל 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.

מידע נוסף על רישום מכשיר 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 עם קישור העומק ושם החבילה שהגדרתם ב-Play 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 או ב-Content URL ב-Media Information או משתמשים ב-Media Load Request Data המפורט יותר, אתם צריכים להוסיף את מסנן ה-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);

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

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

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 מזהה שה-intent הוא load intent, הוא מחלץ אובייקט MediaLoadRequestData מה-intent ומפעיל את 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);
}

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

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

תמיכה בסיסית ברכיבי UI להפעלה

פקודות השילוב הבסיסיות כוללות את הפקודות שתואמות לפעולת המדיה. הפקודות האלה נשלחות באמצעות קריאות חוזרות (callbacks) של סשן המדיה. כדי לתמוך בזה, צריך לרשום קריאה חוזרת (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 תומכת בממשק מתקדם יותר, חשוב לוודא שהאפליקציה השולחת פועלת בצורה תקינה כשמעבירים תוכן לאפליקציה ל-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. עדיין אפשר להשתמש ב-modifier כדי לשנות את המצבים ב-MediaSession, אבל לא מומלץ לעשות את זה כי לסטטוס ב-modifier תמיד יש עדיפות גבוהה יותר מהערכים שסופקו על ידי 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 ומצטרף אליה, אתם יכולים להגדיר בודק הפעלה כדי לבדוק אם פרטי הכניסה של השולח מורשים. אם לא, Cast Connect SDK יחזור להפעלת Web Receiver.

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

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

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

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

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

Android

נדרשת גרסה 19.0.0 ומעלה של play-services-cast-framework.

Kotlin

CastContext.getSharedInstance().setLaunchCredentialsData(
    CredentialsData.Builder()
        .setCredentials("{\"userId\": \"abc\"}")
        .build()
)

Java

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

iOS

נדרשת גרסה v4.8.6 ומעלה של google-cast-sdk.

אפשר להפעיל את הפונקציה בכל שלב אחרי הגדרת האפשרויות: 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. כדי לאשר או לדחות את הבקשה הזו.

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

סקירה כללית

טראקים

הוספת תכונות ליבה למקלט Android TV קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

הגדרת ספריות

דרישה ל-AndroidX

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

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

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

MediaMetadataCompat

PlaybackStateCompat

MediaSessionCompat

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

MediaSessionCompat.Callback

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

הגדרת Android TV

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

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

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

חיבור MediaSession ל-MediaManager

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

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

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

הגדרת Cast Developer Console

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

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

המדיה בטעינה

עומס לפי ישות אצל השולח

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

טעינה לפי Content ID או MediaQueueData

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

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

תמיכה בסיסית ברכיבי UI להפעלה

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

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

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

שינוי MediaStatus

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

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

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

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

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

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

‫Android TV – שליחת הודעות

‫Android TV – קבלת הודעות ממרחב שמות בהתאמה אישית

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