अपने Android TV रिसीवर में मुख्य सुविधाएं जोड़ना

इस पेज पर, Android TV रिसीवर ऐप्लिकेशन को पसंद के मुताबिक बनाने के लिए उपलब्ध सुविधाओं के कोड स्निपेट और उनके ब्यौरे दिए गए हैं.

ध्यान दें: हमारा सुझाव है कि आप ये काम आज़माएं:

• Android TV के लिए कास्ट करने की सुविधा से जुड़ा कोडलैब ट्यूटोरियल - Google Cast SDK टूल का इस्तेमाल करके, कास्ट की सुविधा वाले Android TV रिसीवर ऐप्लिकेशन को बनाने का तरीका, सिलसिलेवार निर्देशों के साथ जानें. इस ऐप्लिकेशन से वीडियो कास्ट किए जा सकते हैं.
• CastAndroidTvReceiver का सैंपल ऐप्लिकेशन (GitHub) - इस सैंपल ऐप्लिकेशन को चलाएं, नेविगेट करें, और देखें. यह ऐप्लिकेशन, यूज़र एक्सपीरियंस (UX) के दिशा-निर्देशों और डिज़ाइन चेकलिस्ट का पालन करता है.
• CastVideos Sender के सैंपल ऐप्लिकेशन (GitHub) - Cast Connect की सुविधा वाले, सैंपल के तौर पर उपलब्ध Sender ऐप्लिकेशन का इस्तेमाल करके जांच करें.

लाइब्रेरी कॉन्फ़िगर करना

अपने Android TV ऐप्लिकेशन के लिए, Cast Connect API उपलब्ध कराने के लिए:

Android

1. अपने ऐप्लिकेशन मॉड्यूल डायरेक्ट्री में build.gradle फ़ाइल खोलें.
   ध्यान दें: Android Studio प्रोजेक्ट में, टॉप-लेवल की build.gradle फ़ाइल और हर मॉड्यूल के लिए एक build.gradle फ़ाइल होती है. अपने ऐप्लिकेशन मॉड्यूल के लिए, फ़ाइल में बदलाव करना न भूलें. Gradle के बारे में ज़्यादा जानकारी के लिए, Gradle की मदद से अपना प्रोजेक्ट बनाना देखें.
2. पुष्टि करें कि google(), सूची में शामिल repositories में शामिल है.

     repositories {
       google()
     }

3. अपने ऐप्लिकेशन के लिए टारगेट किए गए डिवाइस के टाइप के हिसाब से, अपनी डिपेंडेंसी में लाइब्रेरी के सबसे नए वर्शन जोड़ें:
   • Android रिसीवर ऐप्लिकेशन के लिए:

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

   • Android Sender ऐप्लिकेशन के लिए:

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

   सेवाओं को हर बार अपडेट करने पर, इस वर्शन नंबर को अपडेट करना न भूलें.
4. बदलावों को सेव करें और टूलबार में Sync Project with Gradle Files पर क्लिक करें.

iOS

1. पक्का करें कि आपका Podfile, google-cast-sdk 4.8.3 या इसके बाद के वर्शन को टारगेट कर रहा हो
2. iOS 14 या इसके बाद के वर्शन को टारगेट करें. ज़्यादा जानकारी के लिए, रिलीज़ नोट देखें.

     platform: ios, '14'
   
     def target_pods
        pod 'google-cast-sdk', '~>4.8.3'
     end

वेब

1. इसके लिए, Chromium ब्राउज़र का M87 या उसके बाद का वर्शन ज़रूरी है.
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 ऐप्लिकेशन—ज़रूरी शर्तें

अपने Android TV ऐप्लिकेशन में Cast Connect की सुविधा इस्तेमाल करने के लिए, आपको मीडिया सेशन से इवेंट बनाने होंगे और उन्हें इस्तेमाल करना होगा. आपके मीडिया सेशन से मिले डेटा से, मीडिया के स्टेटस के बारे में बुनियादी जानकारी मिलती है. जैसे, पोज़िशन, वीडियो चलाने की स्थिति वगैरह. Cast Connect लाइब्रेरी, आपके मीडिया सेशन का इस्तेमाल यह सिग्नल देने के लिए भी करती है कि उसे किसी व्यक्ति से कुछ मैसेज मिले हैं. जैसे, रोकें.

मीडिया सेशन और उसे शुरू करने के तरीके के बारे में ज़्यादा जानने के लिए, मीडिया सेशन गाइड के साथ काम करना देखें.

मीडिया सेशन का लाइफ़साइकल

वीडियो चलने के दौरान, आपके ऐप्लिकेशन को मीडिया सेशन बनाना चाहिए. साथ ही, जब वीडियो को कंट्रोल नहीं किया जा सकता, तब उसे रिलीज़ करना चाहिए. उदाहरण के लिए, अगर आपका ऐप्लिकेशन वीडियो ऐप्लिकेशन है, तो उपयोगकर्ता के वीडियो चलाने की गतिविधि से बाहर निकलने पर, आपको सेशन को रिलीज़ करना चाहिए. ऐसा करने के लिए, उपयोगकर्ता को दूसरे कॉन्टेंट को ब्राउज़ करने के लिए 'वापस जाएं' चुनना होगा या ऐप्लिकेशन को बैकग्राउंड में भेजना होगा. अगर आपका ऐप्लिकेशन संगीत ऐप्लिकेशन है, तो जब आपका ऐप्लिकेशन कोई मीडिया न चला रहा हो, तब आपको उसे रिलीज़ करना चाहिए.

सेशन की स्थिति अपडेट की जा रही है

ध्यान दें: अगर Exoplayer का इस्तेमाल किया जा रहा है, तो अपने मीडिया सेशन को अपने-आप अपडेट करने का तरीका जानने के लिए, Cast Connect के साथ Exoplayer का इस्तेमाल करना लेख पढ़ें.

आपके मीडिया सेशन का डेटा, प्लेयर की स्थिति के हिसाब से अप-टू-डेट होना चाहिए. उदाहरण के लिए, जब प्लेबैक रोका जाता है, तो आपको प्लेबैक की स्थिति के साथ-साथ, काम करने वाली कार्रवाइयों को भी अपडेट करना चाहिए. यहां दी गई टेबल में उन राज्यों की सूची दी गई है जिनके लिए आपको जानकारी अप-टू-डेट रखनी होगी.

MediaMetadataCompat

मेटाडेटा फ़ील्ड	ब्यौरा
METADATA_KEY_TITLE (ज़रूरी है)	मीडिया का टाइटल.
METADATA_KEY_DISPLAY_SUBTITLE	सबटाइटल.
METADATA_KEY_DISPLAY_ICON_URI	आइकॉन का यूआरएल.
METADATA_KEY_DURATION (ज़रूरी है)	मीडिया का कुल समय.
METADATA_KEY_MEDIA_URI	Content ID.
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);
}

ट्रांसपोर्ट कंट्रोल को मैनेज करना

आपके ऐप्लिकेशन में मीडिया सेशन ट्रांसपोर्ट कंट्रोल कॉलबैक लागू होना चाहिए. नीचे दी गई टेबल में बताया गया है कि उन्हें ट्रांसपोर्ट कंट्रोल की कौनसी कार्रवाइयां मैनेज करनी होंगी:

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 के साथ इंटरैक्ट किया जा सके. इस ऑब्जेक्ट की मदद से, आपके टीवी ऐप्लिकेशन को कनेक्ट किए गए किसी भी डिवाइस से भेजे गए मीडिया मैसेज स्वीकार करने की सुविधा मिलती है.

Android TV का सेटअप

लॉन्च इंटेंट फ़िल्टर जोड़ना

उस गतिविधि में नया इंटेंट फ़िल्टर जोड़ें जिसके लिए आपको अपने ईमेल भेजने वाले ऐप्लिकेशन से लॉन्च इंटेंट मैनेज करना है:

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

ईमेल पाने के विकल्पों की सेवा देने वाली कंपनी की जानकारी देना

CastReceiverOptions की सुविधा देने के लिए, आपको ReceiverOptionsProvider को लागू करना होगा:

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

ध्यान दें: अगर setStatusText को सेट नहीं किया जाता है, तो यह आपके Android TV मेनिफ़ेस्ट में मौजूद android:label से अपने-आप खींचा जाता है.

इसके बाद, AndroidManifest में विकल्प देने वाली कंपनी की जानकारी दें:

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

CastReceiverContext को शुरू करने पर, ReceiverOptionsProvider का इस्तेमाल CastReceiverOptions को उपलब्ध कराने के लिए किया जाता है.

कास्ट रिसीवर का कॉन्टेक्स्ट

ऐप्लिकेशन बनाने के बाद, 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();

वीडियो ऐप्लिकेशन या बैकग्राउंड में वीडियो चलाने की सुविधा के बिना काम करने वाले ऐप्लिकेशन के बैकग्राउंड में जाने के बाद, CastReceiverContext पर stop() को कॉल करें:

Kotlin

// Player has stopped.
CastReceiverContext.getInstance().stop()

Java

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

इसके अलावा, अगर आपका ऐप्लिकेशन बैकग्राउंड में वीडियो चलाने की सुविधा देता है, तो बैकग्राउंड में वीडियो चलने के दौरान रुकने पर, stop() पर CastReceiverContext को कॉल करें.

हमारा सुझाव है कि आप CastReceiverContext.start() और CastReceiverContext.stop() को कॉल करने के लिए, androidx.lifecycle लाइब्रेरी में मौजूद LifecycleObserver का इस्तेमाल करें. ऐसा खास तौर पर तब करें, जब आपके नेटिव ऐप्लिकेशन में कई गतिविधियां हों. इससे अलग-अलग गतिविधियों से 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 बनाते समय, आपको CastReceiverContext को मौजूदा MediaSession टोकन भी देना होगा, ताकि वह यह जान सके कि निर्देश कहां भेजने हैं और मीडिया चलाने की स्थिति कैसे वापस लानी है:

Kotlin

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

Java

MediaManager mediaManager = receiverContext.getMediaManager();
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());

अगर वीडियो चलाए जाने की कोई गतिविधि न होने की वजह से, MediaSession को रिलीज़ किया जाता है, तो आपको 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();
  }
}

Cast Connect के साथ Exoplayer का इस्तेमाल करना

अगर 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 पर सेट करके, उसे 'सही' पर सेट करें.

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)

वेब

इसके लिए, Chromium ब्राउज़र का M87 या इसके बाद का वर्शन ज़रूरी है.

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 ऐप्लिकेशन आईडी से जोड़ने के लिए, Cast डेवलपर कंसोल में ऐप्लिकेशन के पैकेज का नाम जोड़ें.

डेवलपर डिवाइसों को रजिस्टर करना

Cast Developer Console में, उस Android TV डिवाइस का सीरियल नंबर रजिस्टर करें जिसका इस्तेमाल आपको ऐप्लिकेशन डेवलप करने के लिए करना है.

ध्यान दें: Android TV (ATV) डिवाइसों के कई सीरियल नंबर होते हैं. आपको ATV डिवाइस के सॉफ़्टवेयर (Cast) के सीरियल नंबर का इस्तेमाल करना होगा. इसे ढूंढने का तरीका जानने के लिए, ATV डिवाइस का सीरियल नंबर पता करना लेख पढ़ें.

रजिस्टर किए बिना, Cast Connect सिर्फ़ Google Play Store से इंस्टॉल किए गए ऐप्लिकेशन के लिए काम करेगा. ऐसा सुरक्षा से जुड़ी वजहों से किया गया है.

Cast के लिए डेवलपमेंट के मकसद से, Cast या Android TV डिवाइस को रजिस्टर करने के बारे में ज़्यादा जानकारी के लिए, रजिस्टर करने का पेज देखें.

मीडिया लोड हो रहा है

अगर आपने अपने 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)

वेब

इसके लिए, Chromium ब्राउज़र का M87 या इसके बाद का वर्शन ज़रूरी है.

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

लोड करने का निर्देश, आपके डीप लिंक और डेवलपर कंसोल में तय किए गए पैकेज के नाम के साथ इंटेंट के ज़रिए भेजा जाता है.

ईमेल भेजने वाले के लिए ATV के क्रेडेंशियल सेट करना

ऐसा हो सकता है कि आपका वेब रिसीवर ऐप्लिकेशन और Android TV ऐप्लिकेशन, अलग-अलग डीप लिंक और credentials के साथ काम करते हों. उदाहरण के लिए, अगर दोनों प्लैटफ़ॉर्म पर पुष्टि करने का तरीका अलग-अलग है. इसे ठीक करने के लिए, Android TV के लिए वैकल्पिक entity और credentials दिए जा सकते हैं:

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)

वेब

इसके लिए, Chromium ब्राउज़र का M87 या इसके बाद का वर्शन ज़रूरी है.

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

अगर वेब रिसीवर ऐप्लिकेशन लॉन्च किया जाता है, तो वह लोड रिक्वेस्ट में entity और credentials का इस्तेमाल करता है. हालांकि, अगर आपका Android TV ऐप्लिकेशन लॉन्च किया जाता है, तो SDK टूल, entity और credentials को आपके atvEntity और atvCredentials (अगर तय किया गया है) से बदल देता है.

Content ID या MediaQueueData के हिसाब से लोड करना

अगर entity या atvEntity का इस्तेमाल नहीं किया जा रहा है और मीडिया की जानकारी में कॉन्टेंट आईडी या कॉन्टेंट यूआरएल का इस्तेमाल किया जा रहा है या ज़्यादा जानकारी वाले मीडिया लोड करने के अनुरोध के डेटा का इस्तेमाल किया जा रहा है, तो आपको अपने 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)

वेब

इसके लिए, Chromium ब्राउज़र का M87 या इसके बाद का वर्शन ज़रूरी है.

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

लोड करने के अनुरोधों को मैनेज करना

अपनी गतिविधि में, इन लोड अनुरोधों को मैनेज करने के लिए, आपको अपनी गतिविधि के लाइफ़साइकल कॉलबैक में इंटेंट मैनेज करने होंगे:

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() को कॉल करने से पहले, कॉलबैक को रजिस्टर करना ज़रूरी है. हमारा सुझाव है कि इसे किसी गतिविधि या ऐप्लिकेशन 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 हैं.

मीडिया से जुड़े निर्देशों की सुविधा

प्लेबैक कंट्रोल की बुनियादी सुविधाएं

बुनियादी इंटिग्रेशन निर्देशों में वे निर्देश शामिल होते हैं जो मीडिया सेशन के साथ काम करते हैं. इन निर्देशों की सूचना, मीडिया सेशन कॉलबैक के ज़रिए दी जाती है. इसके लिए, आपको मीडिया सेशन के लिए कॉलबैक रजिस्टर करना होगा. ऐसा हो सकता है कि आपने पहले ही ऐसा कर लिया हो.

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 ऐप्लिकेशन सिर्फ़ मीडिया को बुनियादी तरीके से कंट्रोल करने की सुविधा देता है, लेकिन आपका वेब रिसीवर ऐप्लिकेशन ज़्यादा बेहतर तरीके से कंट्रोल करने की सुविधा देता है, तो आपको यह पक्का करना चाहिए कि Android TV ऐप्लिकेशन पर कास्ट करते समय, आपका भेजने वाला ऐप्लिकेशन सही तरीके से काम करे. उदाहरण के लिए, अगर आपका Android TV ऐप्लिकेशन, वीडियो चलाने की स्पीड में बदलाव करने की सुविधा नहीं देता है, लेकिन आपका वेब रिसीवर ऐप्लिकेशन ऐसा करता है, तो आपको हर प्लैटफ़ॉर्म पर काम करने वाली कार्रवाइयों को सही तरीके से सेट करना चाहिए. साथ ही, यह पक्का करना चाहिए कि आपका भेजने वाला ऐप्लिकेशन यूज़र इंटरफ़ेस (यूआई) को सही तरीके से रेंडर करे.

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

हमारी क्लाइंट लाइब्रेरी को MediaSession से बुनियादी MediaStatus मिलेगा. आपका Android TV ऐप्लिकेशन, MediaStatus मॉडिफ़ायर की मदद से अतिरिक्त स्थिति तय कर सकता है और स्थिति को बदल सकता है.

कुछ स्थितियां और मेटाडेटा, MediaSession और MediaStatusModifier, दोनों में सेट किए जा सकते हैं. हमारा ज़ोरदार सुझाव है कि आप इन्हें सिर्फ़ MediaSession में सेट करें. MediaSession में मौजूद स्थितियों को बदलने के लिए, अब भी मॉडिफ़ायर का इस्तेमाल किया जा सकता है. हालांकि, ऐसा करने का सुझाव नहीं दिया जाता, क्योंकि मॉडिफ़ायर में मौजूद स्थिति की प्राथमिकता, MediaSession की दी गई वैल्यू से हमेशा ज़्यादा होती है.

ध्यान दें: MediaStatusModifier में बदलाव करने या उसे अपडेट करने के बाद ही, आपको broadcastMediaStatus() को कॉल करना होगा. MediaSession में किए गए बदलाव, अपने-आप ब्रॉडकास्ट हो जाते हैं.

भेजने से पहले MediaStatus को इंटरसेप्ट करना

वेब रिसीवर SDK की तरह ही, अगर आपको भेजने से पहले कुछ बदलाव करने हैं, तो भेजे जाने वाले MediaStatus को प्रोसेस करने के लिए, MediaStatusInterceptor तय किया जा सकता है. हम MediaStatus को भेजने से पहले, उसमें बदलाव करने के लिए MediaStatusWriter डालते हैं.

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 आपके वेब रिसीवर को लॉन्च कर देता है.

ईमेल भेजने वाले के ऐप्लिकेशन लॉन्च क्रेडेंशियल का डेटा

सेशन में शामिल होने वाले व्यक्ति की जानकारी देने के लिए, भेजने वाले की ओर से CredentialsData का इस्तेमाल किया जा सकता है.

credentials एक स्ट्रिंग है, जिसे उपयोगकर्ता तय कर सकता है. हालांकि, यह ज़रूरी है कि आपका ATV ऐप्लिकेशन इसे समझ सके. credentialsType से पता चलता है कि CredentialsData किस प्लैटफ़ॉर्म से आ रहा है या यह कस्टम वैल्यू हो सकती है. डिफ़ॉल्ट रूप से, यह उस प्लैटफ़ॉर्म पर सेट होता है जिससे ईमेल भेजा जा रहा है.

CredentialsData को सिर्फ़ लॉन्च या शामिल होने के समय, आपके Android TV ऐप्लिकेशन को भेजा जाता है. अगर कनेक्ट रहने के दौरान इसे फिर से सेट किया जाता है, तो यह आपके Android TV ऐप्लिकेशन पर नहीं भेजा जाएगा. अगर मैसेज भेजने वाला व्यक्ति कनेक्ट रहने के दौरान प्रोफ़ाइल बदलता है, तो आपके पास सेशन में बने रहने का विकल्प होता है. अगर आपको लगता है कि नई प्रोफ़ाइल सेशन के साथ काम नहीं करती, तो SessionManager.endCurrentCastSession(boolean stopCasting) को कॉल करें.

पैसे भेजने वाले हर व्यक्ति के लिए, CredentialsData का डेटा, SenderInfo पाने के लिए CastReceiverContext पर getSenders का इस्तेमाल करके, CastLaunchRequest पाने के लिए getCastLaunchRequest() का इस्तेमाल करके, और फिर 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.3 या इससे नया वर्शन ज़रूरी है.

विकल्प सेट होने के बाद, इसे कभी भी कॉल किया जा सकता है: GCKCastContext.setSharedInstanceWith(options).

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

वेब

इसके लिए, Chromium ब्राउज़र का M87 या इसके बाद का वर्शन ज़रूरी है.

विकल्प सेट होने के बाद, इसे कभी भी कॉल किया जा सकता है: 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();
  }
}

LaunchRequestChecker में true को ठीक करने पर, ATV ऐप्लिकेशन लॉन्च होता है और false से आपका वेब रिसीवर ऐप्लिकेशन लॉन्च होता है.

पसंद के मुताबिक मैसेज भेजना और पाना

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

ध्यान दें: नेमस्पेस, urn:x-cast: प्रीफ़िक्स से शुरू होने चाहिए.

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