הפעלת העברה (cast) של אפליקציה ל-Android TV

1. סקירה כללית

ה-Codelab הזה ילמד איך לשנות אפליקציה קיימת ל-Android TV כך שתתמוך בהעברה (cast) ובתקשורת מהאפליקציות הקיימות של שולחי Cast.

מה זה Google Cast ו-Cast Connect?

מערכת Google Cast מאפשרת למשתמשים להעביר תוכן מטלפון נייד לטלוויזיה. סשן אופייני של Google Cast מורכב משני רכיבים – אפליקציית שולח ואפליקציית נמען. אפליקציות שולח, כמו אפליקציה לנייד או אתר כמו YouTube.com, מאפשרות ליזום ולשלוט בהפעלה של אפליקציה של מקלט שממנו רוצים להפעיל Cast. אפליקציות לאפליקציות Cast הן אפליקציות HTML 5 שפועלות במכשירי Chromecast ו-Android TV.

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

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

מה אנחנו מתכוונים לבנות?

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

מה תלמדו

• איך להוסיף את ספריית Cast Connect לאפליקציית ATV לדוגמה.
• איך לחבר שולח Cast ולהפעיל את אפליקציית ATV.
• איך להתחיל הפעלת מדיה באפליקציית ATV מאפליקציה של שולח Cast.
• איך לשלוח סטטוס מדיה מאפליקציית ATV לאפליקציות של שולחי Cast.

מה נדרש

• הגרסה העדכנית ביותר של Android SDK.
• הגרסה העדכנית ביותר של Android Studio. באופן ספציפי, גרסה Chipmunk | 2021.2.1 ואילך.
• מכשיר Android TV שהופעלה בו אפשרויות למפתחים וניפוי באגים ב-USB.
• טלפון Android שהופעלו בו אפשרויות למפתחים וניפוי באגים ב-USB.
• כבל נתונים USB שבעזרתו ניתן לחבר את טלפון ה-Android ואת מכשירי Android TV למחשב הפיתוח.
• ידע בסיסי בפיתוח אפליקציות ל-Android באמצעות Kotlin.

2. לקבלת הקוד לדוגמה

אפשר להוריד את כל הקוד לדוגמה למחשב...

file_downloadלהורדת קוד המקור

ופורקים את קובץ ה-ZIP שהורדתם.

3. הרצת האפליקציה לדוגמה

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

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

כדי להפעיל את היכולות של Cast Connect לפיתוח אפליקציות, צריך לרשום את המספר הסידורי של מכשיר ה-Chromecast המובנה של מכשיר Android TV שבו אתם מתכוונים להשתמש ב-Cast Console. המספר הסידורי מופיע בהגדרות > העדפות מכשיר > Chromecast Built-In > המספר הסידורי ב-Android TV. המספר הזה שונה מהמספר הסידורי של המכשיר הפיזי. המספר הזה חייב להיות מתקבל בשיטה שמתוארת למעלה.

ללא רישום, Cast Connect יפעל רק באפליקציות שהותקנו מחנות Google Play מטעמי אבטחה. חלפו 15 דקות מתחילת תהליך הרישום, הפעילו מחדש את המכשיר.

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

כדי לבדוק שליחת בקשות ממכשיר נייד, סיפקנו אפליקציית שולח פשוטה שנקראת Cast 'סרטונים' כקובץ mobile-sender-0629.apk בקובץ ה-ZIP של קוד המקור. אנחנו נשתמש ב-ADB כדי להתקין את ה-APK. אם כבר התקנת גרסה אחרת של Cast videos, עליך להסיר את הגרסה הזו מכל הפרופילים במכשיר לפני המשך הפעולה.

1. מפעילים אפשרויות למפתחים וניפוי באגים ב-USB בטלפון Android.
2. מחברים כבל נתונים בחיבור USB כדי לחבר את טלפון Android למחשב הפיתוח.
3. מתקינים את mobile-sender-0629.apk בטלפון Android.

4. ניתן למצוא את אפליקציית השולח הפעלת Cast של סרטונים בטלפון Android.

התקנת האפליקציה ל-Android TV

בהוראות הבאות מוסבר איך לפתוח ולהפעיל את האפליקציה לדוגמה שהושלמה ב-Android Studio:

1. בוחרים באפשרות Import Project (ייבוא פרויקט) במסך הפתיחה או ולוחצים על File > (קובץ >) חדש > אפשרויות התפריט 'ייבוא פרויקט...'.
2. בוחרים את הספרייה app-done מתיקיית הקוד לדוגמה ולוחצים על 'אישור'.
3. לוחצים על קובץ > סנכרון הפרויקט עם קובצי Gradle
4. מפעילים אפשרויות למפתחים וניפוי באגים ב-USB במכשיר Android TV.
5. כשמחברים את ADB למכשיר Android TV, המכשיר אמור להופיע ב-Android Studio.
6. לוחצים על הלחצן Run (הפעלה). אפליקציית ATV בשם Cast Connect Codelab אמורה להופיע אחרי כמה שניות.

רוצה להפעיל Cast Connect עם אפליקציית ATV?

1. עוברים אל מסך הבית של Android TV.
2. פותחים את אפליקציית השולח של הסרטונים בטלפון Android. לוחצים על הלחצן להפעלת Cast ובוחרים את מכשיר ה-ATV.
3. אפליקציית Cast Connect של Codelab ATV תופעל ב-ATV ולחצן הפעלת Cast אצל השולח יציין שהיא מחוברת .
4. בוחרים סרטון מאפליקציית ATV, והסרטון יתחיל לפעול ב-ATV.
5. עכשיו ניתן לראות מיני-בקר בחלק התחתון של אפליקציית השולח בטלפון הנייד. אפשר להשתמש בלחצן ההפעלה וההשהיה כדי לשלוט בהפעלה.
6. בוחרים סרטון מהטלפון הנייד ומפעילים. הסרטון יתחיל לפעול ב-ATV והבקר המורחב יוצג במכשיר הנייד של השולח.
7. תוכלו לנעול את הטלפון, וכשמבטלים את הנעילה שלו אמורה להופיע התראה במסך הנעילה, עם הרשאה לשלוט בהפעלת המדיה או להפסיק את הפעלת ה-Cast.

4. מכינים את הפרויקט לתחילת העבודה

עכשיו, לאחר שאימתנו את שילוב Cast Connect של האפליקציה שהושלם, עלינו להוסיף תמיכה ב-Cast Connect לאפליקציית ההפעלה שהורדת. עכשיו אתם מוכנים להתחיל להשתמש בפרויקט לתחילת העבודה באמצעות Android Studio:

1. בוחרים באפשרות Import Project (ייבוא פרויקט) במסך הפתיחה או ולוחצים על File > (קובץ >) חדש > אפשרויות התפריט 'ייבוא פרויקט...'.
2. בוחרים את הספרייה app-start מתיקיית הקוד לדוגמה ולוחצים על 'אישור'.
3. לוחצים על קובץ > סנכרון הפרויקט עם קובצי Gradle
4. בוחרים מכשיר ATV ולוחצים על הלחצן Run כדי להפעיל את האפליקציה ולחקור את ממשק המשתמש.

עיצוב אפליקציות

האפליקציה מספקת רשימה של סרטונים שהמשתמשים יכולים לעיין בהם. המשתמשים יכולים לבחור סרטון להפעלה ב-Android TV. האפליקציה מורכבת משתי פעילויות עיקריות: MainActivity ו-PlaybackActivity.

MainActivity

פעילות זו מכילה מקטע (MainFragment). רשימת הסרטונים והמטא-נתונים המשויכים אליהם מוגדרים במחלקה MovieList, וה-method setupMovies() מופעלת ליצירת רשימה של Movie אובייקטים.

אובייקט Movie מייצג ישות וידאו עם כותרת, תיאור, תמונה ממוזערת וכתובת URL של סרטון. כל אובייקט Movie מקושר ל-CardPresenter כדי להציג את התמונה הממוזערת של הסרטון עם כותרת ופורמט ומועבר אל ArrayObjectAdapter.

כשבוחרים פריט, האובייקט Movie התואם מועבר אל PlaybackActivity.

PlaybackActivity

הפעילות הזו מכילה מקטע (PlaybackVideoFragment) שמארח VideoView עם ExoPlayer, פקדי מדיה מסוימים ואזור טקסט להצגת התיאור של הסרטון שנבחר ומאפשר למשתמש להפעיל את הסרטון ב-Android TV. המשתמש יכול להשתמש בשלט הרחוק כדי להפעיל/להשהות סרטונים, או כדי לחפש הפעלה של סרטונים.

דרישות מוקדמות ל-Cast Connect

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

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

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

יחסי תלות

מעדכנים את קובץ האפליקציה build.gradle כך שיכלול את יחסי התלות הנדרשים של הספרייה:

dependencies {
    ....

    // Cast Connect libraries
    implementation 'com.google.android.gms:play-services-cast-tv:20.0.0'
    implementation 'com.google.android.gms:play-services-cast:21.1.0'
}

צריך לסנכרן את הפרויקט כדי לאשר את פיתוח גרסת ה-build של הפרויקט ללא שגיאות.

אתחול

CastReceiverContext הוא אובייקט Singleton לתיאום כל האינטראקציות של Cast. עליך להטמיע את הממשק של ReceiverOptionsProvider כדי לספק את ה-CastReceiverOptions עם אתחול של CastReceiverContext.

יוצרים קובץ CastReceiverOptionsProvider.kt ומוסיפים את המחלקה הבאה לפרויקט:

package com.google.sample.cast.castconnect

import android.content.Context
import com.google.android.gms.cast.tv.ReceiverOptionsProvider
import com.google.android.gms.cast.tv.CastReceiverOptions

class CastReceiverOptionsProvider : ReceiverOptionsProvider {
    override fun getOptions(context: Context): CastReceiverOptions {
        return CastReceiverOptions.Builder(context)
                .setStatusText("Cast Connect Codelab")
                .build()
    }
}

לאחר מכן צריך לציין את הספק של אפשרויות הנמען בתוך התג <application> של האפליקציה AndroidManifest.xml:

<application>
  ...
  <meta-data
    android:name="com.google.android.gms.cast.tv.RECEIVER_OPTIONS_PROVIDER_CLASS_NAME"
    android:value="com.google.sample.cast.castconnect.CastReceiverOptionsProvider" />
</application>

כדי להתחבר לאפליקציית ATV משולח ההעברה, בוחרים את הפעילות שרוצים להפעיל. ב-Codelab הזה, נשיק את MainActivity של האפליקציה כשיתחיל סשן Cast. בקובץ AndroidManifest.xml, מוסיפים את המסנן של כוונת ההפעלה בMainActivity.

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

מחזור החיים של הקשר של מקלט שממנו רוצים להפעיל Cast

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

פותחים את הקובץ MyApplication.kt ומפעילים את ההקשר של הפעלת Cast על ידי קריאה ל-initInstance() בשיטה onCreate באפליקציה. במחלקה AppLifeCycleObserver, start(), CastReceiverContext כשממשיכים את הבקשה ו-stop() כשהאפליקציה מושהית:

package com.google.sample.cast.castconnect

import com.google.android.gms.cast.tv.CastReceiverContext
...

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        CastReceiverContext.initInstance(this)
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
    }

    class AppLifecycleObserver : DefaultLifecycleObserver {
        override fun onResume(owner: LifecycleOwner) {
            Log.d(LOG_TAG, "onResume")
            CastReceiverContext.getInstance().start()
        }

        override fun onPause(owner: LifecycleOwner) {
            Log.d(LOG_TAG, "onPause")
            CastReceiverContext.getInstance().stop()
        }
    }
}

מתבצע חיבור של MediaSession ל-MediaManager

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

כשיוצרים MediaSession, צריך גם לספק את האסימון הנוכחי של MediaSession ל-MediaManager כדי שהוא ידע לאן לשלוח את הפקודות ולאחזר את מצב ההפעלה של המדיה. בקובץ PlaybackVideoFragment.kt, צריך לוודא שה-MediaSession מופעל לפני שמגדירים את האסימון בתור MediaManager.

import com.google.android.gms.cast.tv.CastReceiverContext
import com.google.android.gms.cast.tv.media.MediaManager
...

class PlaybackVideoFragment : VideoSupportFragment() {
    private var castReceiverContext: CastReceiverContext? = null
    ...

    private fun initializePlayer() {
        if (mPlayer == null) {
            ...
            mMediaSession = MediaSessionCompat(getContext(), LOG_TAG)
            ...
            castReceiverContext = CastReceiverContext.getInstance()
            if (castReceiverContext != null) {
                val mediaManager: MediaManager = castReceiverContext!!.getMediaManager()
                mediaManager.setSessionCompatToken(mMediaSession!!.getSessionToken())
            }

        }
    }
}

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

private fun releasePlayer() {
    mMediaSession?.release()
    castReceiverContext?.mediaManager?.setSessionCompatToken(null)
    ...
}

עכשיו נריץ את האפליקציה לדוגמה

לוחצים על הלחצן הפעלה כדי לפרוס את האפליקציה במכשיר ה-ATV, לסגור אותה ולחזור למסך הבית של ATV. אצל השולח, לוחצים על לחצן הפעלת Cast ובוחרים את מכשיר ה-ATV. אפשר לראות שאפליקציית ATV מופעלת במכשיר ה-ATV ומצב הלחצן להפעלת Cast מחובר.

6. המדיה בטעינה

פקודת הטעינה נשלחת באמצעות Intent עם שם החבילה שהגדרתם ב-Developer Console. כדי לציין את פעילות היעד שמקבלת את Intent, צריך להוסיף את מסנן ה-Intent המוגדר מראש הבא באפליקציה ל-Android TV. בקובץ AndroidManifest.xml, מוסיפים את מסנן Intent הטעינה אל PlayerActivity:

<activity android:name="com.google.sample.cast.castconnect.PlaybackActivity"
          android:launchMode="singleTask"
          android:exported="true">
  <intent-filter>
     <action android:name="com.google.android.gms.cast.tv.action.LOAD"/>
     <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

הטיפול בבקשות עומס ב-Android TV

עכשיו, כשהפעילות מוגדרת לקבל את הכוונה הזו שמכילה בקשת טעינה, נצטרך לטפל בה.

כשהפעילות מתחילה, האפליקציה מפעילה שיטה פרטית שנקראת processIntent. השיטה הזו מכילה את הלוגיקה לעיבוד Intents נכנסים. כדי לטפל בבקשת טעינה, אנחנו נשנה את השיטה הזו ונשלח את הכוונה להמשך עיבוד על ידי קריאה ל-method onNewIntent של המכונה של MediaManager. אם MediaManager מזהה שהכוונה היא בקשת טעינה, הוא מחלץ את האובייקט MediaLoadRequestData מה-Intent ומפעיל את MediaLoadCommandCallback.onLoad(). צריך לשנות את ה-method processIntent בקובץ PlaybackVideoFragment.kt כדי לטפל ב-Intent שמכיל את בקשת הטעינה:

fun processIntent(intent: Intent?) {
    val mediaManager: MediaManager = CastReceiverContext.getInstance().getMediaManager()
    // Pass intent to Cast SDK
    if (mediaManager.onNewIntent(intent)) {
        return
    }

    // Clears all overrides in the modifier.
    mediaManager.getMediaStatusModifier().clear()

    // If the SDK doesn't recognize the intent, handle the intent with your own logic.
    ...
}

בשלב הבא נרחיב את המחלקה המופשטת MediaLoadCommandCallback שתבטל את שיטת onLoad() שנקראה על ידי MediaManager. השיטה הזו מקבלת את הנתונים של בקשת הטעינה וממירה אותם לאובייקט Movie. לאחר ההמרה, הנגן המקומי יפעיל את הסרט. אחר כך מתבצע עדכון של MediaManager עם ה-MediaLoadRequest, וה-MediaStatus משודר לשולחים המחוברים. יוצרים מחלקה פרטית בתוך הקובץ בשם MyMediaLoadCommandCallback בקובץ PlaybackVideoFragment.kt:

import com.google.android.gms.cast.MediaLoadRequestData
import com.google.android.gms.cast.MediaInfo
import com.google.android.gms.cast.MediaMetadata
import com.google.android.gms.cast.MediaError
import com.google.android.gms.cast.tv.media.MediaException
import com.google.android.gms.cast.tv.media.MediaCommandCallback
import com.google.android.gms.cast.tv.media.QueueUpdateRequestData
import com.google.android.gms.cast.tv.media.MediaLoadCommandCallback
import com.google.android.gms.tasks.Task
import com.google.android.gms.tasks.Tasks
import android.widget.Toast
...

private inner class MyMediaLoadCommandCallback :  MediaLoadCommandCallback() {
    override fun onLoad(
        senderId: String?, mediaLoadRequestData: MediaLoadRequestData): Task<MediaLoadRequestData> {
        Toast.makeText(activity, "onLoad()", Toast.LENGTH_SHORT).show()
        return if (mediaLoadRequestData == null) {
            // Throw MediaException to indicate load failure.
            Tasks.forException(MediaException(
                MediaError.Builder()
                    .setDetailedErrorCode(MediaError.DetailedErrorCode.LOAD_FAILED)
                    .setReason(MediaError.ERROR_REASON_INVALID_REQUEST)
                    .build()))
        } else Tasks.call {
            play(convertLoadRequestToMovie(mediaLoadRequestData)!!)
            // Update media metadata and state
            val mediaManager = castReceiverContext!!.mediaManager
            mediaManager.setDataFromLoad(mediaLoadRequestData)
            mediaLoadRequestData
        }
    }
}

private fun convertLoadRequestToMovie(mediaLoadRequestData: MediaLoadRequestData?): Movie? {
    if (mediaLoadRequestData == null) {
        return null
    }
    val mediaInfo: MediaInfo = mediaLoadRequestData.getMediaInfo() ?: return null
    var videoUrl: String = mediaInfo.getContentId()
    if (mediaInfo.getContentUrl() != null) {
        videoUrl = mediaInfo.getContentUrl()
    }
    val metadata: MediaMetadata = mediaInfo.getMetadata()
    val movie = Movie()
    movie.videoUrl = videoUrl
    movie.title = metadata?.getString(MediaMetadata.KEY_TITLE)
    movie.description = metadata?.getString(MediaMetadata.KEY_SUBTITLE)
    if(metadata?.hasImages() == true) {
        movie.cardImageUrl = metadata.images[0].url.toString()
    }
    return movie
}

עכשיו, אחרי שהגדרת הקריאה החוזרת, עלינו לרשום אותה בMediaManager. חובה לרשום את הקריאה החוזרת לפני התקשרות אל MediaManager.onNewIntent(). הוספת setMediaLoadCommandCallback כשהנגן מופעל:

private fun initializePlayer() {
    if (mPlayer == null) {
        ...
        mMediaSession = MediaSessionCompat(getContext(), LOG_TAG)
        ...
        castReceiverContext = CastReceiverContext.getInstance()
        if (castReceiverContext != null) {
            val mediaManager: MediaManager = castReceiverContext.getMediaManager()
            mediaManager.setSessionCompatToken(mMediaSession.getSessionToken())
            mediaManager.setMediaLoadCommandCallback(MyMediaLoadCommandCallback())
        }
    }
}

עכשיו נריץ את האפליקציה לדוגמה

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

7. תמיכה בפקודות של בקרת Cast

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

מוסיפים את MyMediaCommandCallback למכונה של MediaManager באמצעות setMediaCommandCallback כשהנגן מופעל:

private fun initializePlayer() {
    ...
    castReceiverContext = CastReceiverContext.getInstance()
    if (castReceiverContext != null) {
        val mediaManager = castReceiverContext!!.mediaManager
        ...
        mediaManager.setMediaCommandCallback(MyMediaCommandCallback())
    }
}

יוצרים מחלקה של MyMediaCommandCallback כדי לשנות את השיטות, כמו onQueueUpdate() כדי לתמוך בפקודות האלה של בקרת Cast:

private inner class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onQueueUpdate(
        senderId: String?,
        queueUpdateRequestData: QueueUpdateRequestData
    ): Task<Void> {
        Toast.makeText(getActivity(), "onQueueUpdate()", Toast.LENGTH_SHORT).show()
        // Queue Prev / Next
        if (queueUpdateRequestData.getJump() != null) {
            Toast.makeText(
                getActivity(),
                "onQueueUpdate(): Jump = " + queueUpdateRequestData.getJump(),
                Toast.LENGTH_SHORT
            ).show()
        }
        return super.onQueueUpdate(senderId, queueUpdateRequestData)
    }
}

8. עבודה עם סטטוס מדיה

שינוי סטטוס מדיה

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

לדוגמה, כדי לציין setMediaCommandSupported כשמופעלת קריאה חוזרת onLoad:

import com.google.android.gms.cast.MediaStatus
...
private class MyMediaLoadCommandCallback : MediaLoadCommandCallback() {
    fun onLoad(
        senderId: String?,
        mediaLoadRequestData: MediaLoadRequestData
    ): Task<MediaLoadRequestData> {
        Toast.makeText(getActivity(), "onLoad()", Toast.LENGTH_SHORT).show()
        ...
        return Tasks.call({
            play(convertLoadRequestToMovie(mediaLoadRequestData)!!)
            ...
            // Use MediaStatusModifier to provide additional information for Cast senders.
            mediaManager.getMediaStatusModifier()
                .setMediaCommandSupported(MediaStatus.COMMAND_QUEUE_NEXT, true)
                .setIsPlayingAd(false)
            mediaManager.broadcastMediaStatus()
            // Return the resolved MediaLoadRequestData to indicate load success.
            mediaLoadRequestData
        })
    }
}

יירוט מדיה לפני שליחה

בדומה ל-MessageInterceptor של ה-SDK של משדר האינטרנט, אפשר לציין MediaStatusWriter ב-MediaManager כדי לבצע שינויים נוספים ב-MediaStatus לפני שהוא ישודר לשולחים המחוברים.

לדוגמה, אפשר להגדיר נתונים מותאמים אישית בMediaStatus לפני ששולחים לשולחים בנייד:

import com.google.android.gms.cast.tv.media.MediaManager.MediaStatusInterceptor
import com.google.android.gms.cast.tv.media.MediaStatusWriter
import org.json.JSONObject
import org.json.JSONException
...

private fun initializePlayer() {
    if (mPlayer == null) {
        ...
        if (castReceiverContext != null) {
            ...
            val mediaManager: MediaManager = castReceiverContext.getMediaManager()
            ...
            // Use MediaStatusInterceptor to process the MediaStatus before sending out.
            mediaManager.setMediaStatusInterceptor(
                MediaStatusInterceptor { mediaStatusWriter: MediaStatusWriter ->
                    try {
                        mediaStatusWriter.setCustomData(JSONObject("{myData: 'CustomData'}"))
                    } catch (e: JSONException) {
                        Log.e(LOG_TAG,e.message,e);
                    }
            })
        }
    }
}        

9. מזל טוב

עכשיו אתם יודעים איך להפעיל Cast של אפליקציה ל-Android TV באמצעות ספריית Cast Connect.

לפרטים נוספים, אפשר לעיין במדריך למפתחים: /cast/docs/android_tv_receiver.