Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

आउटपुट स्विचर

आउटपुट स्विचर, Cast SDK की एक सुविधा है. इसकी मदद से, Android 13 से शुरू होने वाले वर्शन पर, कॉन्टेंट को स्थानीय और रिमोट डिवाइस पर आसानी से ट्रांसफ़र किया जा सकता है. इसका मकसद, भेजने वाले ऐप्लिकेशन को यह आसानी से और तेज़ी से कंट्रोल करने में मदद करना है कि कॉन्टेंट कहां चल रहा है. आउटपुट स्विचर, MediaRouter लाइब्रेरी का इस्तेमाल करके, फ़ोन के स्पीकर, जोड़े गए ब्लूटूथ डिवाइसों, और Cast की सुविधा वाले रिमोट डिवाइसों के बीच कॉन्टेंट के प्लेबैक को स्विच करता है. इस्तेमाल के उदाहरणों को इन स्थितियों में बांटा जा सकता है:

स्थानीय डिवाइस से रिमोट डिवाइस पर
रिमोट डिवाइस से स्थानीय डिवाइस पर
एक रिमोट डिवाइस से दूसरे रिमोट डिवाइस पर

अपने ऐप्लिकेशन में आउटपुट स्विचर को लागू करने के तरीके के बारे में जानने के लिए, **CastVideos-android सैंपल ऐप्लिकेशन** डाउनलोड करें और उसका इस्तेमाल करें.

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

आउटपुट स्विचर का यूज़र इंटरफ़ेस (यूआई)

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

ज्ञात समस्याएं

स्थानीय डिवाइस पर प्लेबैक के लिए बनाए गए मीडिया सेशन, Cast SDK की सूचना पर स्विच करने पर खारिज कर दिए जाएंगे और फिर से बनाए जाएंगे.

एंट्री पॉइंट

मीडिया की सूचना

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

वॉल्यूम की सेटिंग

डिवाइस पर मौजूद वॉल्यूम बटन पर क्लिक करके, सबसे नीचे मौजूद सेटिंग आइकॉन पर टैप करके, और "<Cast Device> पर <App Name> चलाएं" टेक्स्ट पर टैप करके भी, आउटपुट स्विचर डायलॉग सिस्टम का यूज़र इंटरफ़ेस (यूआई) खोला जा सकता है.

चरणों से जुड़ी खास जानकारी

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

अपने मौजूदा Android ऐप्लिकेशन को AndroidX पर माइग्रेट करें.
आउटपुट स्विचर के लिए, Android Sender SDK के ज़रूरी वर्शन का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन के build.gradle को अपडेट करें:
```
dependencies {
  ...
  implementation 'com.google.android.gms:play-services-cast-framework:21.2.0'
  ...
}
```
ऐप्लिकेशन, मीडिया की सूचनाएं दिखाने की सुविधा के साथ काम करता हो.
डिवाइस, Android 13 पर काम करता हो.

मीडिया की सूचनाएं सेट अप करना

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

अगर फ़िलहाल MediaStyle और MediaSession का इस्तेमाल नहीं किया जा रहा है, तो नीचे दिया गया स्निपेट दिखाता है कि इन्हें कैसे सेट अप किया जाए. साथ ही, ऑडियो और वीडियो ऐप्लिकेशन के लिए, मीडिया सेशन के कॉलबैक सेट अप करने के लिए गाइड उपलब्ध हैं:

Kotlin

// Create a media session. NotificationCompat.MediaStyle
// PlayerService is your own Service or Activity responsible for media playback.
val mediaSession = MediaSessionCompat(this, "PlayerService")

// Create a MediaStyle object and supply your media session token to it.
val mediaStyle = Notification.MediaStyle().setMediaSession(mediaSession.sessionToken)

// Create a Notification which is styled by your MediaStyle object.
// This connects your media session to the media controls.
// Don't forget to include a small icon.
val notification = Notification.Builder(this@PlayerService, CHANNEL_ID)
    .setStyle(mediaStyle)
    .setSmallIcon(R.drawable.ic_app_logo)
    .build()

// Specify any actions which your users can perform, such as pausing and skipping to the next track.
val pauseAction: Notification.Action = Notification.Action.Builder(
        pauseIcon, "Pause", pauseIntent
    ).build()
notification.addAction(pauseAction)

Java

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    // Create a media session. NotificationCompat.MediaStyle
    // PlayerService is your own Service or Activity responsible for media playback.
    MediaSession mediaSession = new MediaSession(this, "PlayerService");

    // Create a MediaStyle object and supply your media session token to it.
    Notification.MediaStyle mediaStyle = new Notification.MediaStyle().setMediaSession(mediaSession.getSessionToken());

    // Specify any actions which your users can perform, such as pausing and skipping to the next track.
    Notification.Action pauseAction = Notification.Action.Builder(pauseIcon, "Pause", pauseIntent).build();

    // Create a Notification which is styled by your MediaStyle object.
    // This connects your media session to the media controls.
    // Don't forget to include a small icon.
    String CHANNEL_ID = "CHANNEL_ID";
    Notification notification = new Notification.Builder(this, CHANNEL_ID)
        .setStyle(mediaStyle)
        .setSmallIcon(R.drawable.ic_app_logo)
        .addAction(pauseAction)
        .build();
}

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

MediaSession में मेटाडेटा जोड़ने के लिए, setMetaData() का इस्तेमाल करें. साथ ही, MediaMetadataCompat.Builder() में अपने मीडिया के लिए, MediaMetadata के सभी काम के कॉन्स्टैंट उपलब्ध कराएं.

Kotlin

mediaSession.setMetadata(MediaMetadataCompat.Builder()
    // Title
    .putString(MediaMetadata.METADATA_KEY_TITLE, currentTrack.title)

    // Artist
    // Could also be the channel name or TV series.
    .putString(MediaMetadata.METADATA_KEY_ARTIST, currentTrack.artist)

    // Album art
    // Could also be a screenshot or hero image for video content
    // The URI scheme needs to be "content", "file", or "android.resource".
    .putString(
        MediaMetadata.METADATA_KEY_ALBUM_ART_URI, currentTrack.albumArtUri)
    )

    // Duration
    // If duration isn't set, such as for live broadcasts, then the progress
    // indicator won't be shown on the seekbar.
    .putLong(MediaMetadata.METADATA_KEY_DURATION, currentTrack.duration)

    .build()
)

Java

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    mediaSession.setMetadata(
        new MediaMetadataCompat.Builder()
        // Title
        .putString(MediaMetadata.METADATA_KEY_TITLE, currentTrack.title)

        // Artist
        // Could also be the channel name or TV series.
        .putString(MediaMetadata.METADATA_KEY_ARTIST, currentTrack.artist)

        // Album art
        // Could also be a screenshot or hero image for video content
        // The URI scheme needs to be "content", "file", or "android.resource".
        .putString(MediaMetadata.METADATA_KEY_ALBUM_ART_URI, currentTrack.albumArtUri)

        // Duration
        // If duration isn't set, such as for live broadcasts, then the progress
        // indicator won't be shown on the seekbar.
        .putLong(MediaMetadata.METADATA_KEY_DURATION, currentTrack.duration)

        .build()
    );
}

MediaSession में प्लेबैक की स्थिति जोड़ने के लिए, setPlaybackState() का इस्तेमाल करें. साथ ही, PlaybackStateCompat.Builder() में अपने मीडिया के लिए, PlaybackStateCompat के सभी काम के कॉन्स्टैंट उपलब्ध कराएं.

Kotlin

mediaSession.setPlaybackState(
    PlaybackStateCompat.Builder()
        .setState(
            PlaybackStateCompat.STATE_PLAYING,

            // Playback position
            // Used to update the elapsed time and the progress bar.
            mediaPlayer.currentPosition.toLong(),

            // Playback speed
            // Determines the rate at which the elapsed time changes.
            playbackSpeed
        )

        // isSeekable
        // Adding the SEEK_TO action indicates that seeking is supported
        // and makes the seekbar position marker draggable. If this is not
        // supplied seek will be disabled but progress will still be shown.
        .setActions(PlaybackStateCompat.ACTION_SEEK_TO)
        .build()
)

Java

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    mediaSession.setPlaybackState(
        new PlaybackStateCompat.Builder()
            .setState(
                 PlaybackStateCompat.STATE_PLAYING,

                // Playback position
                // Used to update the elapsed time and the progress bar.
                mediaPlayer.currentPosition.toLong(),

                // Playback speed
                // Determines the rate at which the elapsed time changes.
                playbackSpeed
            )

        // isSeekable
        // Adding the SEEK_TO action indicates that seeking is supported
        // and makes the seekbar position marker draggable. If this is not
        // supplied seek will be disabled but progress will still be shown.
        .setActions(PlaybackStateCompat.ACTION_SEEK_TO)
        .build()
    );
}

वीडियो ऐप्लिकेशन की सूचना का व्यवहार

वीडियो ऐप्लिकेशन या ऑडियो ऐप्लिकेशन, जो बैकग्राउंड में स्थानीय डिवाइस पर प्लेबैक की सुविधा के साथ काम नहीं करते, उनके लिए मीडिया की सूचनाओं का खास व्यवहार होना चाहिए. इससे, ऐसी स्थितियों में मीडिया के निर्देश भेजने में आने वाली समस्याओं से बचा जा सकेगा जहां प्लेबैक की सुविधा उपलब्ध नहीं है:

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

AndroidManifest.xml में आउटपुट स्विचर की सुविधा चालू करें

आउटपुट स्विचर की सुविधा चालू करने के लिए, the MediaTransferReceiver को ऐप्लिकेशन के AndroidManifest.xml में जोड़ा जाना चाहिए. अगर ऐसा नहीं किया जाता है, तो यह सुविधा चालू नहीं होगी. साथ ही, रिमोट डिवाइस से स्थानीय डिवाइस पर कॉन्टेंट ट्रांसफ़र करने की सुविधा का फ़ीचर फ़्लैग भी अमान्य हो जाएगा.

<application>
    ...
    <receiver
         android:name="androidx.mediarouter.media.MediaTransferReceiver"
         android:exported="true">
    </receiver>
    ...
</application>

MediaTransferReceiver एक ब्रॉडकास्ट रिसीवर है. इसकी मदद से, सिस्टम यूज़र इंटरफ़ेस (यूआई) वाले डिवाइसों के बीच मीडिया ट्रांसफ़र किया जा सकता है. ज़्यादा जानकारी के लिए, MediaTransferReceiver रेफ़रंस देखें.

स्थानीय डिवाइस से रिमोट डिवाइस पर

जब उपयोगकर्ता, स्थानीय डिवाइस से रिमोट डिवाइस पर प्लेबैक स्विच करता है, तो Cast SDK, Cast सेशन अपने-आप शुरू कर देगा. हालांकि, ऐप्लिकेशन को स्थानीय डिवाइस से रिमोट डिवाइस पर स्विच करने की सुविधा को हैंडल करना होगा. उदाहरण के लिए, स्थानीय डिवाइस पर प्लेबैक रोकें और Cast डिवाइस पर मीडिया लोड करें. ऐप्लिकेशन को Cast के SessionManagerListenerको सुनना चाहिए. इसके लिए, onSessionStarted() और onSessionEnded() कॉलबैक का इस्तेमाल करें. साथ ही, Cast के SessionManager कॉलबैक मिलने पर कार्रवाई करें. ऐप्लिकेशन को यह पक्का करना चाहिए कि आउटपुट स्विचर डायलॉग खुलने और ऐप्लिकेशन के फ़ोरग्राउंड में न होने पर भी, ये कॉलबैक चालू रहें.

बैकग्राउंड में कास्ट करने के लिए, SessionManagerListener को अपडेट करें

चेतावनी: ऐक्टिविटी के लाइफ़साइकल की वजह से, ऐसे ऐप्लिकेशन (ऑडियो ऐप्लिकेशन) जो बैकग्राउंड में प्लेबैक की सुविधा के साथ काम करते हैं उनके लिए, `SessionManagerListener` SessionManagerListener कॉलबैक के लिए ऐक्टिविटी के बजाय किसी सेवा का इस्तेमाल करने का सुझाव दिया जाता है. इससे, ऐक्टिविटी बंद होने पर, ज़रूरी कॉलबैक का रजिस्ट्रेशन रद्द होने से रोका जा सकेगा.

Cast की पुरानी सुविधा में, ऐप्लिकेशन के फ़ोरग्राउंड में होने पर, स्थानीय डिवाइस से रिमोट डिवाइस पर कॉन्टेंट ट्रांसफ़र करने की सुविधा पहले से उपलब्ध है. Cast की सुविधा का इस्तेमाल करने के लिए, आम तौर पर उपयोगकर्ता ऐप्लिकेशन में Cast आइकॉन पर क्लिक करते हैं और मीडिया स्ट्रीम करने के लिए कोई डिवाइस चुनते हैं. इस मामले में, ऐप्लिकेशन को SessionManagerListenerके लिए onCreate() या onStart()में रजिस्टर करना होगा. साथ ही, ऐप्लिकेशन की ऐक्टिविटी के onStop()या onDestroy()में लिसनर का रजिस्ट्रेशन रद्द करना होगा.

आउटपुट स्विचर का इस्तेमाल करके कास्ट करने की नई सुविधा की मदद से, ऐप्लिकेशन बैकग्राउंड में होने पर भी कास्ट किया जा सकता है. यह ऑडियो ऐप्लिकेशन के लिए खास तौर पर काम की है. ये ऐप्लिकेशन, बैकग्राउंड में चलने पर सूचनाएं पोस्ट करते हैं. ऐप्लिकेशन, सेवा के onCreate() में SessionManager लिसनर रजिस्टर कर सकते हैं और सेवा के onDestroy() में रजिस्ट्रेशन रद्द कर सकते हैं. ऐप्लिकेशन के बैकग्राउंड में होने पर, ऐप्लिकेशन को हमेशा स्थानीय डिवाइस से रिमोट डिवाइस पर कॉन्टेंट ट्रांसफ़र करने के कॉलबैक (जैसे onSessionStarted) मिलने चाहिए.

अगर ऐप्लिकेशन, MediaBrowserService का इस्तेमाल करता है, तो SessionManagerListener को वहां रजिस्टर करने का सुझाव दिया जाता है.

Kotlin

class MyService : Service() {
    private var castContext: CastContext? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext
            .getSessionManager()
            .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext
                .getSessionManager()
                .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
        }
    }
}

Java

public class MyService extends Service {
  private CastContext castContext;

  @Override
  protected void onCreate() {
     castContext = CastContext.getSharedInstance(this);
     castContext
        .getSessionManager()
        .addSessionManagerListener(sessionManagerListener, CastSession.class);
  }

  @Override
  protected void onDestroy() {
    if (castContext != null) {
       castContext
          .getSessionManager()
          .removeSessionManagerListener(sessionManagerListener, CastSession.class);
    }
  }
}

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

ध्यान दें: स्थानीय डिवाइस से रिमोट डिवाइस पर आसानी से स्विच करने के लिए, स्थानीय डिवाइस पर प्लेबैक रोकने का सुझाव दिया जाता है. यह onSessionStarted कॉलबैक के दौरान किया जाना चाहिए, जब Cast SDK, रिसीवर से सफलतापूर्वक कनेक्ट हो गया हो. इससे यह पक्का होता है कि स्थानीय डिवाइस पर प्लेबैक, रिमोट डिवाइस पर प्लेबैक फिर से शुरू होने के बाद ही रोका जाए. साथ ही, इसमें इंतज़ार के समय की वजह से होने वाली किसी भी समस्या से बचा जा सके.

रिमोट डिवाइस से स्थानीय डिवाइस पर

आउटपुट स्विचर की मदद से, रिमोट डिवाइस पर प्लेबैक को फ़ोन के स्पीकर या स्थानीय ब्लूटूथ डिवाइस पर ट्रांसफ़र किया जा सकता है. CastOptions पर, setRemoteToLocalEnabled फ़्लैग को true पर सेट करके, इस सुविधा को चालू किया जा सकता है.

ऐसे मामलों में जहां मौजूदा भेजने वाला डिवाइस, एक से ज़्यादा भेजने वालों के साथ किसी मौजूदा सेशन में शामिल होता है और ऐप्लिकेशन को यह जांच करनी होती है कि मौजूदा मीडिया को स्थानीय तौर पर ट्रांसफ़र किया जा सकता है या नहीं, ऐप्लिकेशन को SessionState की जांच करने के लिए, SessionTransferCallback के onTransferred कॉलबैक का इस्तेमाल करना चाहिए.

setRemoteToLocalEnabled फ़्लैग सेट करें

CastOptions.Builder setRemoteToLocalEnabled की सुविधा देता है. इससे, Cast सेशन चालू होने पर, आउटपुट स्विचर डायलॉग में, फ़ोन के स्पीकर और स्थानीय ब्लूटूथ डिवाइसों को ट्रांसफ़र करने के टारगेट के तौर पर दिखाया या छिपाया जा सकता है.

Kotlin

class CastOptionsProvider : OptionsProvider {
    fun getCastOptions(context: Context?): CastOptions {
        ...
        return Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
    }
}

Java

public class CastOptionsProvider implements OptionsProvider {
    @Override
    public CastOptions getCastOptions(Context context) {
        ...
        return new CastOptions.Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
  }
}

स्थानीय डिवाइस पर प्लेबैक जारी रखें

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

CastContext#addSessionTransferCallback(SessionTransferCallback) की मदद से, कोई ऐप्लिकेशन अपना SessionTransferCallback रजिस्टर कर सकता है. साथ ही, जब किसी भेजने वाले डिवाइस से स्थानीय डिवाइस पर प्लेबैक ट्रांसफ़र किया जाता है, तो onTransferred और onTransferFailed कॉलबैक के लिए सुना जा सकता है.

ऐप्लिकेशन के SessionTransferCallback का रजिस्ट्रेशन रद्द करने के बाद, ऐप्लिकेशन को SessionTransferCallback नहीं मिलेंगे.

SessionTransferCallback , मौजूदा SessionManagerListener कॉलबैक का एक्सटेंशन है. यह onSessionEnded ट्रिगर होने के बाद ट्रिगर होता है. रिमोट डिवाइस से स्थानीय डिवाइस पर कॉन्टेंट ट्रांसफ़र करने के कॉलबैक का क्रम यह है:

onTransferring
onSessionEnding
onSessionEnded
onTransferred

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

ऐसे ऐप्लिकेशन जो बैकग्राउंड में प्लेबैक की सुविधा के साथ काम करते हैं

ऐसे ऐप्लिकेशन जो बैकग्राउंड में प्लेबैक की सुविधा के साथ काम करते हैं (आम तौर पर ऑडियो ऐप्लिकेशन) उनके लिए, यह सुझाव दिया जाता है कि आप Service (उदाहरण के लिए MediaBrowserService) का इस्तेमाल करें. सेवाओं को onTransferred कॉलबैक सुनना चाहिए और ऐप्लिकेशन के फ़ोरग्राउंड या बैकग्राउंड में होने पर, स्थानीय डिवाइस पर प्लेबैक फिर से शुरू करना चाहिए.

Kotlin

class MyService : Service() {
    private var castContext: CastContext? = null
    private var sessionTransferCallback: SessionTransferCallback? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
        sessionTransferCallback = MySessionTransferCallback()
        castContext.addSessionTransferCallback(sessionTransferCallback)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback)
            }
        }
    }

    class MySessionTransferCallback : SessionTransferCallback() {
        fun onTransferring(@SessionTransferCallback.TransferType transferType: Int) {
            // Perform necessary steps prior to onTransferred
        }

        fun onTransferred(@SessionTransferCallback.TransferType transferType: Int,
                          sessionState: SessionState?) {
            if (transferType == SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        fun onTransferFailed(@SessionTransferCallback.TransferType transferType: Int,
                             @SessionTransferCallback.TransferFailedReason transferFailedReason: Int) {
            // Handle transfer failure.
        }
    }
}

Java

public class MyService extends Service {
    private CastContext castContext;
    private SessionTransferCallback sessionTransferCallback;

    @Override
    protected void onCreate() {
        castContext = CastContext.getSharedInstance(this);
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession.class);
        sessionTransferCallback = new MySessionTransferCallback();
        castContext.addSessionTransferCallback(sessionTransferCallback);
    }

    @Override
    protected void onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession.class);
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback);
            }
        }
    }

    public static class MySessionTransferCallback extends SessionTransferCallback {
        public MySessionTransferCallback() {}

        @Override
        public void onTransferring(@SessionTransferCallback.TransferType int transferType) {
            // Perform necessary steps prior to onTransferred
        }

        @Override
        public void onTransferred(@SessionTransferCallback.TransferType int transferType,
                                  SessionState sessionState) {
            if (transferType==SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        @Override
        public void onTransferFailed(@SessionTransferCallback.TransferType int transferType,
                                     @SessionTransferCallback.TransferFailedReason int transferFailedReason) {
            // Handle transfer failure.
        }
    }
}

ऐसे ऐप्लिकेशन जो बैकग्राउंड में प्लेबैक की सुविधा के साथ काम नहीं करते

ऐसे ऐप्लिकेशन जो बैकग्राउंड में प्लेबैक की सुविधा के साथ काम नहीं करते (आम तौर पर वीडियो ऐप्लिकेशन) उनके लिए, यह सुझाव दिया जाता है कि आप onTransferred कॉलबैक सुनें और ऐप्लिकेशन के फ़ोरग्राउंड में होने पर, स्थानीय डिवाइस पर प्लेबैक फिर से शुरू करें.

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

Kotlin

class MyActivity : AppCompatActivity() {
    private var castContext: CastContext? = null
    private var sessionTransferCallback: SessionTransferCallback? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
        sessionTransferCallback = MySessionTransferCallback()
        castContext.addSessionTransferCallback(sessionTransferCallback)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback)
            }
        }
    }

    class MySessionTransferCallback : SessionTransferCallback() {
        fun onTransferring(@SessionTransferCallback.TransferType transferType: Int) {
            // Perform necessary steps prior to onTransferred
        }

        fun onTransferred(@SessionTransferCallback.TransferType transferType: Int,
                          sessionState: SessionState?) {
            if (transferType == SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.

                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        fun onTransferFailed(@SessionTransferCallback.TransferType transferType: Int,
                             @SessionTransferCallback.TransferFailedReason transferFailedReason: Int) {
            // Handle transfer failure.
        }
    }
}

Java

public class MyActivity extends AppCompatActivity {
  private CastContext castContext;
  private SessionTransferCallback sessionTransferCallback;

  @Override
  protected void onCreate() {
     castContext = CastContext.getSharedInstance(this);
     castContext
        .getSessionManager()
        .addSessionManagerListener(sessionManagerListener, CastSession.class);
     sessionTransferCallback = new MySessionTransferCallback();
     castContext.addSessionTransferCallback(sessionTransferCallback);
  }

  @Override
  protected void onDestroy() {
    if (castContext != null) {
       castContext
          .getSessionManager()
          .removeSessionManagerListener(sessionManagerListener, CastSession.class);
      if (sessionTransferCallback != null) {
         castContext.removeSessionTransferCallback(sessionTransferCallback);
      }
    }
  }

  public static class MySessionTransferCallback extends SessionTransferCallback {
    public MySessionTransferCallback() {}

    @Override
    public void onTransferring(@SessionTransferCallback.TransferType int transferType) {
        // Perform necessary steps prior to onTransferred
    }

    @Override
    public void onTransferred(@SessionTransferCallback.TransferType int transferType,
                               SessionState sessionState) {
      if (transferType==SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
        // Remote stream is transferred to the local device.

        // Retrieve information from the SessionState to continue playback on the local player.
      }
    }

    @Override
    public void onTransferFailed(@SessionTransferCallback.TransferType int transferType,
                                 @SessionTransferCallback.TransferFailedReason int transferFailedReason) {
      // Handle transfer failure.
    }
  }
}

एक रिमोट डिवाइस से दूसरे रिमोट डिवाइस पर

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

ऑडियो ऐप्लिकेशन, ऐसे ऐप्लिकेशन होते हैं जो Google Cast for Audio की सुविधा के साथ काम करते हैं. यह सुविधा, Google Cast SDK डेवलपर रिसीवर ऐप्लिकेशन सेटिंग में, Google Cast SDK डेवलपर कंसोल में उपलब्ध है

स्पीकर के साथ स्ट्रीम एक्सपैंशन

अहम जानकारी: Cast प्लैटफ़ॉर्म, स्पीकर के साथ एक रिमोट डिवाइस से दूसरे रिमोट डिवाइस पर कॉन्टेंट ट्रांसफ़र करने की सुविधा को अपने-आप चालू करता है. हालांकि, ऐप्लिकेशन को अपने यूज़र इंटरफ़ेस (यूआई) को स्पीकर ग्रुप के नामों के साथ अपडेट करना पड़ सकता है. ऐप्लिकेशन को यह पक्का करने के लिए, एक रिमोट डिवाइस से दूसरे रिमोट डिवाइस पर कॉन्टेंट ट्रांसफ़र करने की सुविधा की जांच करने के चरणों का पालन करना चाहिए कि उनका ऐप्लिकेशन ठीक से काम करेगा.

आउटपुट स्विचर का इस्तेमाल करने वाले ऑडियो ऐप्लिकेशन, Cast सेशन के दौरान, स्ट्रीम एक्सपैंशन का इस्तेमाल करके, Cast की सुविधा वाले एक से ज़्यादा स्पीकर डिवाइसों पर ऑडियो चला सकते हैं.

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

स्ट्रीम एक्सपैंशन के दौरान, नए एक्सपैंड किए गए ग्रुप का नाम पाने के लिए, का इस्तेमाल करके, Cast.Listener रजिस्टर करें. CastSession#addCastListener. इसके बाद, onDeviceNameChanged कॉलबैक के दौरान, CastSession#getCastDevice() को कॉल करें.

Kotlin

class MyActivity : Activity() {
    private var mCastSession: CastSession? = null
    private lateinit var mCastContext: CastContext
    private lateinit var mSessionManager: SessionManager
    private val mSessionManagerListener: SessionManagerListener<CastSession> =
        SessionManagerListenerImpl()
    private val mCastListener = CastListener()

    private inner class SessionManagerListenerImpl : SessionManagerListener<CastSession?> {
        override fun onSessionStarting(session: CastSession?) {}

        override fun onSessionStarted(session: CastSession?, sessionId: String) {
            addCastListener(session)
        }

        override fun onSessionStartFailed(session: CastSession?, error: Int) {}

        override fun onSessionSuspended(session: CastSession?, reason Int) {
            removeCastListener()
        }

        override fun onSessionResuming(session: CastSession?, sessionId: String) {}

        override fun onSessionResumed(session: CastSession?, wasSuspended: Boolean) {
            addCastListener(session)
        }

        override fun onSessionResumeFailed(session: CastSession?, error: Int) {}

        override fun onSessionEnding(session: CastSession?) {}

        override fun onSessionEnded(session: CastSession?, error: Int) {
            removeCastListener()
        }
    }

    private inner class CastListener : Cast.Listener() {
        override fun onDeviceNameChanged() {
            mCastSession?.let {
                val castDevice = it.castDevice
                val deviceName = castDevice.friendlyName
                // Update UIs with the new cast device name.
            }
        }
    }

    private fun addCastListener(castSession: CastSession) {
        mCastSession = castSession
        mCastSession?.addCastListener(mCastListener)
    }

    private fun removeCastListener() {
        mCastSession?.removeCastListener(mCastListener)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mCastContext = CastContext.getSharedInstance(this)
        mSessionManager = mCastContext.sessionManager
        mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession::class.java)
    }

    override fun onDestroy() {
        super.onDestroy()
        mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession::class.java)
    }
}

Java

public class MyActivity extends Activity {
    private CastContext mCastContext;
    private CastSession mCastSession;
    private SessionManager mSessionManager;
    private SessionManagerListener<CastSession> mSessionManagerListener =
            new SessionManagerListenerImpl();
    private Cast.Listener mCastListener = new CastListener();

    private class SessionManagerListenerImpl implements SessionManagerListener<CastSession> {
        @Override
        public void onSessionStarting(CastSession session) {}
        @Override
        public void onSessionStarted(CastSession session, String sessionId) {
            addCastListener(session);
        }
        @Override
        public void onSessionStartFailed(CastSession session, int error) {}
        @Override
        public void onSessionSuspended(CastSession session, int reason) {
            removeCastListener();
        }
        @Override
        public void onSessionResuming(CastSession session, String sessionId) {}
        @Override
        public void onSessionResumed(CastSession session, boolean wasSuspended) {
            addCastListener(session);
        }
        @Override
        public void onSessionResumeFailed(CastSession session, int error) {}
        @Override
        public void onSessionEnding(CastSession session) {}
        @Override
        public void onSessionEnded(CastSession session, int error) {
            removeCastListener();
        }
    }

    private class CastListener extends Cast.Listener {
         @Override
         public void onDeviceNameChanged() {
             if (mCastSession == null) {
                 return;
             }
             CastDevice castDevice = mCastSession.getCastDevice();
             String deviceName = castDevice.getFriendlyName();
             // Update UIs with the new cast device name.
         }
    }

    private void addCastListener(CastSession castSession) {
        mCastSession = castSession;
        mCastSession.addCastListener(mCastListener);
    }

    private void removeCastListener() {
        if (mCastSession != null) {
            mCastSession.removeCastListener(mCastListener);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mCastContext = CastContext.getSharedInstance(this);
        mSessionManager = mCastContext.getSessionManager();
        mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession.class);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession.class);
    }
}

एक रिमोट डिवाइस से दूसरे रिमोट डिवाइस पर कॉन्टेंट ट्रांसफ़र करने की सुविधा की जांच करना

इस सुविधा की जांच करने के लिए:

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