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

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

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

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

Android
  1. अपनी ऐप्लिकेशन मॉड्यूल डायरेक्ट्री में build.gradle फ़ाइल खोलें.
  2. पुष्टि करें कि google() को सूची repositories में शामिल किया गया है.
      repositories {
        google()
      }
  3. अपने ऐप्लिकेशन के टारगेट डिवाइस टाइप के हिसाब से, ऐप्लिकेशन के नए वर्शन जोड़ें पर निर्भर करता है:
    • Android रिसीवर ऐप्लिकेशन के लिए:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast-tv:21.1.0'
          implementation 'com.google.android.gms:play-services-cast:21.5.0'
        }
      अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
    • Android सेंडर ऐप्लिकेशन के लिए:
        dependencies {
          implementation 'com.google.android.gms:play-services-cast:21.1.0'
          implementation 'com.google.android.gms:play-services-cast-framework:21.5.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 सेंडर एपीआई लाइब्रेरी जोड़ना
      <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 लाइब्रेरी पर भी किया जाता है का इस्तेमाल तब किया जाता है, जब उसे भेजने वाले से कुछ मैसेज मिले हों, जैसे कि रोकना.

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

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

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

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

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

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

रिसीवर के लिए विकल्प उपलब्ध कराने वाली कंपनी का नाम दें

आपको लागू करना होगा ReceiverOptionsProvider उपलब्ध कराने के लिए CastReceiverOptions:

Kotlin
class MyReceiverOptionsProvider : ReceiverOptionsProvider {
  override fun getOptions(context: Context?): CastReceiverOptions {
    return CastReceiverOptions.Builder(context)
          .setStatusText("My App")
          .build()
    }
}
जावा
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" />

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

कास्ट किए जाने वाले डिवाइस से जुड़ी जानकारी

शुरू करें CastReceiverContext जब आपका ऐप्लिकेशन बन जाता है:

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

  ...
}
जावा
@Override
public void onCreate() {
  CastReceiverContext.initInstance(this);

  ...
}

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

Kotlin
CastReceiverContext.getInstance().start()
जावा
CastReceiverContext.getInstance().start();

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

Kotlin
// Player has stopped.
CastReceiverContext.getInstance().stop()
जावा
// Player has stopped.
CastReceiverContext.getInstance().stop();

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

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

Kotlin
// Create a LifecycleObserver class.
class MyLifecycleObserver : DefaultLifecycleObserver {
  override fun onStart(owner: LifecycleOwner) {
    // App prepares to enter foreground.
    CastReceiverContext.getInstance().start()
  }

  override fun onStop(owner: LifecycleOwner) {
    // App has moved to the background or has terminated.
    CastReceiverContext.getInstance().stop()
  }
}

// Add the observer when your application is being created.
class MyApplication : Application() {
  fun onCreate() {
    super.onCreate()

    // Initialize CastReceiverContext.
    CastReceiverContext.initInstance(this /* android.content.Context */)

    // Register LifecycleObserver
    ProcessLifecycleOwner.get().lifecycle.addObserver(
        MyLifecycleObserver())
  }
}
जावा
// Create a LifecycleObserver class.
public class MyLifecycleObserver implements DefaultLifecycleObserver {
  @Override
  public void onStart(LifecycleOwner owner) {
    // App prepares to enter foreground.
    CastReceiverContext.getInstance().start();
  }

  @Override
  public void onStop(LifecycleOwner owner) {
    // App has moved to the background or has terminated.
    CastReceiverContext.getInstance().stop();
  }
}

// Add the observer when your application is being created.
public class MyApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();

    // Initialize CastReceiverContext.
    CastReceiverContext.initInstance(this /* android.content.Context */);

    // Register LifecycleObserver
    ProcessLifecycleOwner.get().getLifecycle().addObserver(
        new MyLifecycleObserver());
  }
}
// In AndroidManifest.xml set MyApplication as the application class
<application
    ...
    android:name=".MyApplication">

Mediasession को MediaManager से कनेक्ट किया जा रहा है

जब आप MediaSession, आपको मौजूदा MediaSession टोकन भी देना होगा, ताकि CastReceiverContext ताकि इसे पता चल सके कि निर्देश कहां भेजने हैं और मीडिया चलाने की स्थिति क्या है:

Kotlin
val mediaManager: MediaManager = receiverContext.getMediaManager()
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken())
जावा
MediaManager mediaManager = receiverContext.getMediaManager();
mediaManager.setSessionCompatToken(currentMediaSession.getSessionToken());

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

Kotlin
myPlayer.stop()
mediaSession.release()
mediaManager.setSessionCompatToken(null)
जावा
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()
  }
}
जावा
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)
    ...
  }
}
जावा
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()
    }
}
जावा
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 Developer Console इसे अपने Cast ऐप्लिकेशन आईडी से संबद्ध करें.

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

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

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
जावा
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)
जावा
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 या Media QueData से लोड हो रहा है

अगर आप 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
Kotlin
val mediaToLoad = MediaInfo.Builder("some-id").build()
val loadRequest = MediaLoadRequestData.Builder()
    .setMediaInfo(mediaToLoad)
    .setCredentials("user-credentials")
    ...
    .build()
remoteMediaClient.load(loadRequest)
जावा
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.
    ...
  }
}
जावा
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)
  }
जावा
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())
जावा
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 निर्देश हैं, जो इनमें उपलब्ध नहीं हैं MediaSession, जैसे कि skipAd() या setActiveMediaTracks(). साथ ही, यहां कुछ क्यू कमांड लागू करने होंगे, क्योंकि कास्ट क्यू MediaSession क्यू के साथ पूरी तरह से काम नहीं करता है.

Kotlin
class MyMediaCommandCallback : MediaCommandCallback() {
    override fun onSkipAd(requestData: RequestData?): Task {
        // Skip your ad
        ...
        return Tasks.forResult(null)
    }
}

val mediaManager = CastReceiverContext.getInstance().getMediaManager()
mediaManager.setMediaCommandCallback(MyMediaCommandCallback())
जावा
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)
जावा
// 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 पर ऐप्लिकेशन पर वीडियो चलाने की स्पीड बदलने की सुविधा काम नहीं करती, जबकि आपका वेब रिसीवर ऐप्लिकेशन ऐसा करता है, आपको हर प्लैटफ़ॉर्म पर काम करने वाली कार्रवाइयों को सही तरीके से सेट करना चाहिए. साथ ही, भेजने वाला ऐप्लिकेशन, यूज़र इंटरफ़ेस (यूआई) को ठीक से रेंडर करता है.

MediaStatus में बदलाव किया जा रहा है

ट्रैक, विज्ञापन, लाइव स्ट्रीम, और सूची बनाने जैसी बेहतर सुविधाओं के लिए, अपने Android डिवाइस पर टीवी ऐप्लिकेशन को ऐसी अतिरिक्त जानकारी देनी होगी जिसका पता नहीं लगाया जा सकता 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()
जावा
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 टूल की तरह ही है नहीं भेज रहे हैं, तो आप MediaStatusInterceptor प्रोसेस करने के लिए MediaStatus से भेजा नहीं जाएगा. हम इस जांच के MediaStatusWriter भेजने से पहले MediaStatus में बदलाव करने के लिए.

Kotlin
mediaManager.setMediaStatusInterceptor(object : MediaStatusInterceptor {
    override fun intercept(mediaStatusWriter: MediaStatusWriter) {
      // Perform customization.
        mediaStatusWriter.setCustomData(JSONObject("{data: \"my Hello\"}"))
    }
})
जावा
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 ऐप्लिकेशन को लॉन्च करे और उसमें शामिल हो, आप भेजने वाले के क्रेडेंशियल की अनुमति है या नहीं, यह देखने के लिए चेकर लॉन्च करें. अगर ऐसा नहीं है, तो कास्ट करें Connect SDK टूल, वेब रिसीवर को लॉन्च करने के दौरान वापस आ जाता है.

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

भेजने वाले की ओर, आप यह बताने के लिए CredentialsData तय कर सकते हैं कि कौन है सेशन में शामिल हो रहे हैं.

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

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

कॉन्टेंट बनाने CredentialsData का इस्तेमाल करके, getSenders पूरी तरह कैसे CastReceiverContext SenderInfo पाने के लिए, getCastLaunchRequest() पाने के लिए CastLaunchRequest, और इसके बाद getCredentialsData().

Android

play-services-cast-framework वर्शन की ज़रूरत है 19.0.0 या उसके बाद के वर्शन.

Kotlin
CastContext.getSharedInstance().setLaunchCredentialsData(
    CredentialsData.Builder()
        .setCredentials("{\"userId\": \"abc\"}")
        .build()
)
जावा
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);

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

कॉन्टेंट बनाने CredentialsData जब कोई व्यक्ति आपके Android TV ऐप्लिकेशन को लॉन्च करता है या उसमें शामिल होने की कोशिश करता है, तो इसे आपके 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.
}
जावा
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()
  }
}
जावा
public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        ...
        .setLaunchRequestChecker(new MyLaunchRequestChecker())
        .build();
  }
}

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

भेजें और कस्टम मैसेज मिल रहे हैं

कास्ट प्रोटोकॉल की मदद से, आपका रिसीवर ऐप्लिकेशन. भेजने के लिए आपको नेमस्पेस (चैनल) रजिस्टर करना होगा अपने Gmail विज्ञापनों को सक्रिय करने से पहले 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()
  }
}
जावा
public class MyReceiverOptionsProvider implements ReceiverOptionsProvider {
  @Override
  public CastReceiverOptions getOptions(Context context) {
    return new CastReceiverOptions.Builder(context)
        .setCustomNamespaces(
              Arrays.asList("urn:x-cast:com.example.cast.mynamespace"))
        .build();
  }
}

Android TV—मैसेज भेजना

Kotlin
// If senderId is null, then the message is broadcasted to all senders.
CastReceiverContext.getInstance().sendMessage(
    "urn:x-cast:com.example.cast.mynamespace", senderId, customString)
जावा
// 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());
जावा
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());