Media3 ExoPlayer का इस्तेमाल करके, एक बेसिक मीडिया प्लेयर ऐप्लिकेशन बनाएं

Jetpack Media3, Player इंटरफ़ेस तय करता है. इसमें वीडियो और ऑडियो फ़ाइलों को चलाने की बुनियादी सुविधाओं के बारे में बताया गया है. Media3 में इस इंटरफ़ेस को लागू करने का डिफ़ॉल्ट तरीका ExoPlayer है. हमारा सुझाव है कि आप ExoPlayer का इस्तेमाल करें. इसमें कई सुविधाएं मिलती हैं, जो वीडियो चलाने के ज़्यादातर उदाहरणों को कवर करती हैं. साथ ही, इसे अपनी ज़रूरत के हिसाब से बनाया जा सकता है, ताकि आपके अन्य उदाहरणों को भी मैनेज किया जा सके. ExoPlayer, डिवाइस और ओएस के फ़्रैगमेंटेशन को भी हटा देता है, ताकि आपका कोड पूरे Android नेटवर्क पर एक जैसा काम करता रहे. ExoPlayer में ये शामिल हैं:

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

इस पेज पर, वीडियो चलाने वाला ऐप्लिकेशन बनाने के कुछ अहम चरणों के बारे में बताया गया है. ज़्यादा जानकारी के लिए, Media3 ExoPlayer के बारे में हमारी पूरी गाइड देखें.

शुरू करना

शुरू करने के लिए, Jetpack Media3 के ExoPlayer, यूज़र इंटरफ़ेस (यूआई), और सामान्य मॉड्यूल पर डिपेंडेंसी जोड़ें:

implementation "androidx.media3:media3-exoplayer:1.4.1"
implementation "androidx.media3:media3-ui:1.4.1"
implementation "androidx.media3:media3-common:1.4.1"

इस्तेमाल के उदाहरण के आधार पर, आपको Media3 के अन्य मॉड्यूल की भी ज़रूरत पड़ सकती है. जैसे, DASH फ़ॉर्मैट में स्ट्रीम चलाने के लिए exoplayer-dash.

1.4.1 को लाइब्रेरी के अपने पसंदीदा वर्शन से बदलना न भूलें. नया वर्शन देखने के लिए, रिलीज़ नोट देखें.

मीडिया प्लेयर बनाना

Media3 की मदद से, Player इंटरफ़ेस, ExoPlayer के लागू किए गए वर्शन का इस्तेमाल किया जा सकता है या फिर अपनी पसंद के मुताबिक इंटरफ़ेस बनाया जा सकता है.

ExoPlayer बनाना

ExoPlayer इंस्टेंस बनाने का सबसे आसान तरीका यह है:

val player = ExoPlayer.Builder(context).build()

ExoPlayer player = new ExoPlayer.Builder(context).build();

मीडिया प्लेयर को onCreate() लाइफ़साइकल के तरीके से, Activity, Fragment या Service में बनाया जा सकता है.

Builder में, अपनी पसंद के मुताबिक बनाने के कई विकल्प शामिल होते हैं. जैसे:

• setAudioAttributes() ऑडियो फ़ोकस को मैनेज करने की सुविधा को कॉन्फ़िगर करने के लिए
• setHandleAudioBecomingNoisy() ऑडियो आउटपुट डिवाइस के डिसकनेक्ट होने पर, प्लेबैक के व्यवहार को कॉन्फ़िगर करने के लिए
• setTrackSelector() ट्रैक चुनने की सुविधा को कॉन्फ़िगर करने के लिए

Media3, PlayerView यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट उपलब्ध कराता है. इसे अपने ऐप्लिकेशन की लेआउट फ़ाइल में शामिल किया जा सकता है. इस कॉम्पोनेंट में प्लेबैक कंट्रोल के लिए PlayerControlView, सबटाइटल दिखाने के लिए SubtitleView, और वीडियो रेंडर करने के लिए Surface शामिल होता है.

प्लेयर को तैयार करना

मीडिया आइटम को प्लेलिस्ट में जोड़ें, ताकि उन्हें setMediaItem() और addMediaItem() जैसे तरीकों से चलाया जा सके. इसके बाद, मीडिया लोड करने और ज़रूरी संसाधन हासिल करने के लिए, prepare() को कॉल करें.

ऐप्लिकेशन के फ़ोरग्राउंड में आने से पहले, आपको ये चरण नहीं करने चाहिए. अगर आपका प्लेयर Activity या Fragment में है, तो इसका मतलब है कि प्लेयर को एपीआई लेवल 24 और उसके बाद के वर्शन पर onStart() लाइफ़साइकल वाले तरीके या एपीआई लेवल 23 और उससे पहले के वर्शन पर onResume() लाइफ़साइकल वाले तरीके के हिसाब से तैयार करना है. Service में मौजूद किसी खिलाड़ी के लिए, उसे onCreate() में तैयार किया जा सकता है.

प्लेयर को कंट्रोल करना

प्लेयर तैयार होने के बाद, प्लेयर पर दिए गए तरीकों का इस्तेमाल करके वीडियो चलाया जा सकता है. जैसे:

• वीडियो चलाने और उसे रोकने के लिए, play() और pause() का इस्तेमाल करें
• मौजूदा मीडिया आइटम में किसी जगह पर जाने के लिए, seekTo()
• प्लेलिस्ट में नेविगेट करने के लिए, seekToNextMediaItem() और seekToPreviousMediaItem() का इस्तेमाल करें

PlayerView या PlayerControlView जैसे यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट, प्लेयर से बंधे होने पर, उसी हिसाब से अपडेट हो जाएंगे.

प्लेयर को रिलीज़ करना

वीडियो चलाने के लिए, सीमित संसाधनों की ज़रूरत पड़ सकती है. जैसे, वीडियो डिकोडर. इसलिए, जब प्लेयर की ज़रूरत न हो, तो उसके संसाधनों को खाली करने के लिए, अपने प्लेयर पर release() को कॉल करना ज़रूरी है.

अगर आपका प्लेयर Activity या Fragment में है, तो एपीआई लेवल 24 और उसके बाद के वर्शन पर, प्लेयर को onStop() लाइफ़साइकल वाले तरीके से या एपीआई लेवल 23 और उससे पहले के वर्शन पर, onPause() वाले तरीके से रिलीज़ करें. Service में मौजूद किसी खिलाड़ी के लिए, उसे onDestroy() में रिलीज़ किया जा सकता है.

मीडिया सेशन की मदद से प्लेबैक मैनेज करना

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

मीडिया सेशन का इस्तेमाल करने के लिए, Media3 सेशन मॉड्यूल पर डिपेंडेंसी जोड़ें:

implementation "androidx.media3:media3-session:1.4.1"

मीडिया सेशन बनाना

प्लेयर को शुरू करने के बाद, MediaSession इस तरह बनाया जा सकता है:

val player = ExoPlayer.Builder(context).build()
val mediaSession = MediaSession.Builder(context, player).build()

ExoPlayer player = new ExoPlayer.Builder(context).build();
MediaSession mediaSession = new MediaSession.Builder(context, player).build();

Media3, Player की स्थिति को MediaSession की स्थिति के साथ अपने-आप सिंक करता है. यह Player के किसी भी लागू होने वाले वर्शन के साथ काम करता है. जैसे, ExoPlayer, CastPlayer या पसंद के मुताबिक लागू किया गया वर्शन.

दूसरे क्लाइंट को कंट्रोल देना

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

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

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

दूसरे कॉलबैक तरीकों की मदद से, पसंद के मुताबिक प्लेबैक निर्देश और प्लेलिस्ट में बदलाव करने के अनुरोधों को मैनेज किया जा सकता है. इन कॉलबैक में भी ControllerInfo ऑब्जेक्ट शामिल होता है, ताकि आप हर अनुरोध के आधार पर ऐक्सेस कंट्रोल तय कर सकें.

बैकग्राउंड में मीडिया चलाना

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

MediaSessionService लागू करना

ऐसी क्लास बनाएं जो MediaSessionService को एक्सटेंड करती हो और onCreate() लाइफ़साइकल वाले तरीके में अपने MediaSession को इंस्टैंशिएट करती हो.

class PlaybackService : MediaSessionService() {
    private var mediaSession: MediaSession? = null

    // Create your Player and MediaSession in the onCreate lifecycle event
    override fun onCreate() {
        super.onCreate()
        val player = ExoPlayer.Builder(this).build()
        mediaSession = MediaSession.Builder(this, player).build()
    }

    // Remember to release the player and media session in onDestroy
    override fun onDestroy() {
        mediaSession?.run {
            player.release()
            release()
            mediaSession = null
        }
        super.onDestroy()
    }
}

public class PlaybackService extends MediaSessionService {
    private MediaSession mediaSession = null;

    @Override
    public void onCreate() {
        super.onCreate();
        ExoPlayer player = new ExoPlayer.Builder(this).build();
        mediaSession = new MediaSession.Builder(this, player).build();
    }

    @Override
    public void onDestroy() {
        mediaSession.getPlayer().release();
        mediaSession.release();
        mediaSession = null;
        super.onDestroy();
    }
}

अपनी मेनिफ़ेस्ट फ़ाइल में, MediaSessionService इंटेंट फ़िल्टर वाली Service क्लास और फ़ोरग्राउंड सेवा चलाने के लिए FOREGROUND_SERVICE अनुमति का अनुरोध करें:

<service
    android:name=".PlaybackService"
    android:foregroundServiceType="mediaPlayback"
    android:exported="true">
    <intent-filter>
        <action android:name="androidx.media3.session.MediaSessionService"/>
    </intent-filter>
</service>

<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

आखिर में, आपने जो क्लास बनाई है उसमें onGetSession() तरीके को बदलें, ताकि आपके मीडिया सेशन का क्लाइंट ऐक्सेस कंट्रोल किया जा सके. कनेक्शन का अनुरोध स्वीकार करने के लिए MediaSession दिखाएं या अनुरोध अस्वीकार करने के लिए null दिखाएं.

// This example always accepts the connection request
override fun onGetSession(
    controllerInfo: MediaSession.ControllerInfo
): MediaSession? = mediaSession

@Override
public MediaSession onGetSession(MediaSession.ControllerInfo controllerInfo) {
  // This example always accepts the connection request
  return mediaSession;
}

आपके यूज़र इंटरफ़ेस से कनेक्ट करना

अब आपका मीडिया सेशन, Activity या Fragment से अलग Service में है, जहां आपके प्लेयर का यूज़र इंटरफ़ेस (यूआई) मौजूद है. इन्हें एक साथ जोड़ने के लिए, MediaController का इस्तेमाल किया जा सकता है. अपने यूज़र इंटरफ़ेस (यूआई) के साथ Activity या Fragment के onStart() तरीके में, अपने MediaSession के लिए एक SessionToken बनाएं. इसके बाद, MediaController बनाने के लिए SessionToken का इस्तेमाल करें. MediaController बनाना, एक साथ नहीं होता.

override fun onStart() {
  val sessionToken = SessionToken(this, ComponentName(this, PlaybackService::class.java))
  val controllerFuture = MediaController.Builder(this, sessionToken).buildAsync()
  controllerFuture.addListener(
    {
        // Call controllerFuture.get() to retrieve the MediaController.
        // MediaController implements the Player interface, so it can be
        // attached to the PlayerView UI component.
        playerView.setPlayer(controllerFuture.get())
      },
    MoreExecutors.directExecutor()
  )
}

@Override
public void onStart() {
  SessionToken sessionToken =
    new SessionToken(this, new ComponentName(this, PlaybackService.class));
  ListenableFuture<MediaController> controllerFuture =
    new MediaController.Builder(this, sessionToken).buildAsync();
  controllerFuture.addListener(() -> {
    // Call controllerFuture.get() to retrieve the MediaController.
    // MediaController implements the Player interface, so it can be
    // attached to the PlayerView UI component.
    playerView.setPlayer(controllerFuture.get());
  }, MoreExecutors.directExecutor())
}

MediaController, Player इंटरफ़ेस को लागू करता है, ताकि वीडियो चलाने या रोकने के लिए, play() और pause() जैसे तरीकों का इस्तेमाल किया जा सके. अन्य कॉम्पोनेंट की तरह ही, जब MediaController की ज़रूरत न हो, तब उसे रिलीज़ करना न भूलें. जैसे, Activity के onStop() लाइफ़साइकल मेथड को रिलीज़ करने के लिए, MediaController.releaseFuture() को कॉल करें.

सूचना पब्लिश करना

फ़ोरग्राउंड सेवाओं को चालू होने के दौरान सूचना पब्लिश करनी होती है. MediaSessionService, आपके लिए MediaNotification के तौर पर, MediaStyle सूचना अपने-आप बना देगा. पसंद के मुताबिक सूचना देने के लिए, DefaultMediaNotificationProvider.Builder के साथ MediaNotification.Provider बनाएं या सेवा देने वाले के इंटरफ़ेस को पसंद के मुताबिक बनाएं. setMediaNotificationProvider का इस्तेमाल करके, सेवा देने वाली कंपनी को अपने MediaSession में जोड़ें.

अपनी कॉन्टेंट लाइब्रेरी का विज्ञापन करना

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

MediaLibraryService को लागू करना, MediaSessionService को लागू करने जैसा ही है. हालांकि, onGetSession() में आपको MediaSession के बजाय MediaLibrarySession दिखाना चाहिए. MediaSession.Callback की तुलना में, MediaLibrarySession.Callback में ऐसे अतिरिक्त तरीके शामिल होते हैं जिनकी मदद से ब्राउज़र क्लाइंट, आपकी लाइब्रेरी सेवा के ज़रिए उपलब्ध कराए गए कॉन्टेंट पर नेविगेट कर सकता है.

MediaSessionService की तरह ही, अपनी मेनिफ़ेस्ट फ़ाइल में MediaLibraryService की जानकारी दें. साथ ही, फ़ोरग्राउंड सेवा को चलाने के लिए FOREGROUND_SERVICE की अनुमति का अनुरोध करें:

<service
    android:name=".PlaybackService"
    android:foregroundServiceType="mediaPlayback"
    android:exported="true">
    <intent-filter>
        <action android:name="androidx.media3.session.MediaLibraryService"/>
        <action android:name="android.media.browse.MediaBrowserService"/>
    </intent-filter>
</service>

<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

ऊपर दिए गए उदाहरण में, MediaLibraryService और पुराने सिस्टम के साथ काम करने की सुविधा के लिए, लेगसी MediaBrowserService, दोनों के लिए इंटेंट फ़िल्टर शामिल है. अतिरिक्त इंटेंट फ़िल्टर की मदद से, MediaBrowserCompat एपीआई का इस्तेमाल करने वाले क्लाइंट ऐप्लिकेशन, आपके Service को पहचान सकते हैं.

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

MediaLibrarySession बनाना

कॉन्टेंट ब्राउज़ करने वाले एपीआई जोड़ने के लिए, MediaLibrarySession MediaSession एपीआई को बढ़ाता है. MediaSession कॉलबैक की तुलना में, MediaLibrarySession कॉलबैक में ये तरीके जोड़े गए हैं:

• onGetLibraryRoot() जब कोई क्लाइंट, कॉन्टेंट ट्री के रूट MediaItem का अनुरोध करता है
• onGetChildren() जब कोई क्लाइंट, कॉन्टेंट ट्री में MediaItem के बच्चों का अनुरोध करता है, तब
• onGetSearchResult() जब कोई क्लाइंट किसी क्वेरी के लिए कॉन्टेंट ट्री से खोज के नतीजों का अनुरोध करता है

काम के कॉलबैक तरीकों में, LibraryParams ऑब्जेक्ट शामिल होगा. इसमें, उस कॉन्टेंट ट्री के बारे में अतिरिक्त सिग्नल होंगे जिसमें क्लाइंट ऐप्लिकेशन की दिलचस्पी है.