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

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

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

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

शुरू करना

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

implementation("androidx.media3:media3-exoplayer:1.11.1")
implementation("androidx.media3:media3-ui:1.11.1")
implementation("androidx.media3:media3-common:1.11.1")

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

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

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

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

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

ExoPlayer बनाना

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

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

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

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

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

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

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

प्लेयर को तैयार किया जा रहा है

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

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

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

प्लेयर तैयार होने के बाद, प्लेयर पर मौजूद तरीकों को कॉल करके प्लेबैक को कंट्रोल किया जा सकता है. जैसे:

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

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

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

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

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

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

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

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

implementation("androidx.media3:media3-session:1.11.1")

implementation "androidx.media3:media3-session:1.11.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 API को एक्सटेंड करता है, ताकि कॉन्टेंट ब्राउज़ करने वाले एपीआई जोड़े जा सकें. MediaSession कॉलबैक की तुलना में, MediaLibrarySession कॉलबैक में ये तरीके जोड़े जाते हैं:

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

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