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

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

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

अपने Android TV ऐप्लिकेशन में Cast Connect एपीआई उपलब्ध कराने के लिए:

Android
  1. अपनी ऐप्लिकेशन मॉड्यूल डायरेक्ट्री में build.gradle फ़ाइल खोलें.
  2. पुष्टि करें कि google(), repositories की सूची में शामिल है. 
      repositories {
    google()
  }
  3. अपने ऐप्लिकेशन के लिए टारगेट किए गए डिवाइस टाइप के आधार पर, अपनी डिपेंडेंसी में लाइब्रेरी के नए वर्शन जोड़ें:
    • Android रिसीवर ऐप्लिकेशन के लिए: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast-tv:21.0.1'
    implementation 'com.google.android.gms:play-services-cast:21.4.0'
  }
    • Android सेंडर ऐप्लिकेशन के लिए: 
        dependencies {
    implementation 'com.google.android.gms:play-services-cast:21.0.1'
    implementation 'com.google.android.gms:play-services-cast-framework:21.4.0'
  }
    पक्का करें कि हर बार सेवाएं अपडेट होने पर, इस वर्शन नंबर को अपडेट किया जाए.
  4. आपने जो बदलाव किए हैं उन्हें सेव करें और टूलबार में Sync Project with Gradle Files पर क्लिक करें.
iOS के लिए
  1. पक्का करें कि Podfile ने google-cast-sdk 4.8.0 या उसके बाद के वर्शन को टारगेट किया हो
  2. iOS 13 या उसके बाद के वर्शन को टारगेट करता हो. ज़्यादा जानकारी के लिए, प्रॉडक्ट की जानकारी देखें. 
      platform: ios, '13'

  def target_pods
     pod 'google-cast-sdk', '~>4.8.0'
  end
वेब
  1. इसके लिए, Chromium ब्राउज़र के M87 या इसके बाद वाले वर्शन की ज़रूरत होती है.
  2. अपने प्रोजेक्ट 
      <script src="//www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"></script>
    में Web Sender API लाइब्रेरी जोड़ें

AndroidX की ज़रूरी शर्तें

Google Play services के नए वर्शन के लिए, यह ज़रूरी है कि androidx नेमस्पेस का इस्तेमाल करने के लिए, ऐप्लिकेशन को अपडेट किया जाए. AndroidX पर माइग्रेट करने के लिए, दिए गए निर्देशों का पालन करें.

Android TV ऐप्लिकेशन—ज़रूरी शर्तें

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

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

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

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

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

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

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

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 को लागू करना होगा:

कोटलिन
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" />

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

कास्ट किए जाने वाले डिवाइस का कॉन्टेक्स्ट

ऐप्लिकेशन बनने के बाद, CastReceiverContext को शुरू करें:

कोटलिन
override fun onCreate() {
  CastReceiverContext.initInstance(this)

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

  ...
}

जब आपका ऐप्लिकेशन फ़ोरग्राउंड में चले जाए, तब CastReceiverContext को शुरू करें:

कोटलिन
CastReceiverContext.getInstance().start()
Java
CastReceiverContext.getInstance().start();

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

कोटलिन
// Player has stopped.
CastReceiverContext.getInstance().stop()
Java
// Player has stopped.
CastReceiverContext.getInstance().stop();

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

हमारा सुझाव है कि आप कॉल करने की सुविधा को मैनेज करने के लिए, androidx.lifecycle लाइब्रेरी के Lifecycle ट्रैफ़िकर का इस्तेमाल करें CastReceiverContext.start() और CastReceiverContext.stop() को मैनेज करें. खास तौर पर तब, जब आपके नेटिव ऐप्लिकेशन में कई गतिविधियां हों. इससे, अलग-अलग गतिविधियों के लिए start() और stop() को कॉल करने पर, दौड़ की स्थितियों से बचा जा सकता है.

कोटलिन
// 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 टोकन भी देना होगा. इससे यह पता चल पाएगा कि कमांड कहां भेजने हैं और मीडिया प्लेबैक स्टेटस को फिर से पाना है:

कोटलिन
val mediaManager: MediaManager = receiverContext.getMediaManager()
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken())
Java
MediaManager mediaManager = receiverContext.getMediaManager();
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());

जब प्लेबैक बंद होने की वजह से अपना MediaSession रिलीज़ किया जाता है, तब आपको MediaManager पर शून्य टोकन सेट करना चाहिए:

कोटलिन
myPlayer.stop()
mediaSession.release()
mediaManager.setSessionCompatToken(null)
Java
myPlayer.stop();
mediaSession.release();
mediaManager.setSessionCompatToken(null);

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

कोटलिन
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 का इस्तेमाल, setMediaButtonEventHandler(MediaButtonEventHandler) को कॉल करके MediaButton इवेंट को मैनेज करने के लिए किया जा सकता है. अगर ऐसा नहीं है, तो डिफ़ॉल्ट रूप से MediaSessionCompat.Callback इन्हें मैनेज करता है.

अपने ऐप्लिकेशन में MediaSessionConnector इंटिग्रेट करने के लिए, इन्हें प्लेयर गतिविधि क्लास में या ऐसी किसी भी जगह जोड़ें जहां मीडिया सेशन मैनेज किया जा रहा है:

कोटलिन
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 का हिस्सा है):

कोटलिन
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 Developer Console में अपने Android TV ऐप्लिकेशन के पैकेज का नाम जोड़ें.

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

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

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

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 सेट करके, भेजने वालों को डीप लिंक पास किया जा सकता है:

कोटलिन
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
जावा
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
कोटलिन
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 या MediaQueue डेटा के हिसाब से लोड हो रहा है

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

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

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

कोटलिन
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() तरीके का इस्तेमाल करें.

कोटलिन
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) में पार्स किया जा सकता है.

मीडिया कमांड के साथ काम करने वाला ऐप्लिकेशन

वीडियो चलाने के कंट्रोल से जुड़ी सामान्य सहायता

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

कोटलिन
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());

कास्ट कंट्रोल के निर्देशों के साथ काम करना

कुछ कास्ट करने के निर्देश ऐसे हैं जो MediaSession में उपलब्ध नहीं हैं, जैसे कि skipAd() या setActiveMediaTracks(). साथ ही, कुछ सूची निर्देशों को यहां लागू करने की ज़रूरत होती है, क्योंकि कास्ट करने की सूची, MediaSession सूची के साथ पूरी तरह से काम नहीं करती.

कोटलिन
class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onSkipAd(requestData: RequestData?): Task {
        // 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());

इस्तेमाल किए जा सकने वाले मीडिया निर्देश तय करें

कास्ट किए जाने वाले डिवाइस की तरह ही, आपके Android TV ऐप्लिकेशन को यह तय करना चाहिए कि कौनसे निर्देश काम करते हैं, ताकि भेजने वाले कुछ यूज़र इंटरफ़ेस (यूआई) कंट्रोल को चालू या बंद कर सकें. जो निर्देश MediaSession का हिस्सा हैं उनके लिए PlaybackStateCompat में दिए गए निर्देशों की जानकारी दें. अन्य निर्देशों के बारे में MediaStatusModifier में बताया जाना चाहिए.

कोटलिन
// 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:

कोटलिन
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 से मिली वैल्यू से ज़्यादा होती है.

मैसेज भेजने से पहले MediaStatus को ब्लॉक करें

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

कोटलिन
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 ऐप्लिकेशन को उसके क्रेडेंशियल मैनेज करने होंगे. इससे ऐप्लिकेशन की प्रोग्रेस और उपयोगकर्ता के अन्य डेटा को सही तरीके से ट्रैक किया जा सकेगा.

जब भेजने वाला ऐप्लिकेशन लॉन्च होता है या Android TV ऐप्लिकेशन से जुड़ता है, तो भेजने वाले ऐप्लिकेशन को क्रेडेंशियल देने चाहिए जिनसे यह पता चलता हो कि सेशन में कौन शामिल हो रहा है.

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

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

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

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

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

भेजने वाले CredentialsData की जानकारी पाने के लिए, getSenders CastReceiverContext पर क्लिक करें, getCastLaunchRequest(), CastLaunchRequest, और getCredentialsData().SenderInfo

Android

इसके लिए, play-services-cast-framework वर्शन 19.0.0 या इसके बाद का वर्शन होना ज़रूरी है.

कोटलिन
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.0 या इसके बाद का वर्शन होना ज़रूरी है.

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

एटीवी के लॉन्च अनुरोध की जांच करने वाले टूल को लागू करना

CredentialsData आपके Android TV ऐप्लिकेशन में तब पास किया जाता है, जब कोई व्यक्ति कॉल भेजने या शामिल होने की कोशिश करता है. आपके पास LaunchRequestChecker को लागू करने का विकल्प है. इस अनुरोध को स्वीकार या अस्वीकार करें.

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

अनुरोध की अनुमति मिलने पर, ATV ऐप्लिकेशन लॉन्च हो जाता है. इस सेटिंग को इस हिसाब से तय किया जा सकता है कि आपके ऐप्लिकेशन पर कॉन्टेंट लोड करने के अनुरोध भेजने की सुविधा काम करती है या नहीं. ऐसा तब किया जा सकता है, जब उपयोगकर्ता ने एटीवी ऐप्लिकेशन में लॉग इन न किया हो या उसमें उपयोगकर्ता की जानकारी मैच न कर रही हो. इस व्यवहार को LaunchRequestChecker में पूरी तरह पूरा किया जा सकता है.

CastReceiverOptions.LaunchRequestChecker इंटरफ़ेस को लागू करने के लिए क्लास बनाएं:

कोटलिन
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 में सेट करें:

कोटलिन
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 में काम करने वाले नेमस्पेस के बारे में बताना होगा:

कोटलिन
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—मैसेज भेजना

कोटलिन
// 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—पसंद के मुताबिक नेमस्पेस मैसेज पाएं

कोटलिन
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());
पीछे जाएं
खास जानकारी
आगे बढ़ें
ट्रैक