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

पिछले 3 वर्षों में Google के आंकड़ों के अनुसार, एंड्रॉइड टीवी पर उपकरणों की संख्या 4 गुना बढ़ गई है, और विनिर्माण भागीदारों की संख्या पहले ही सौ से अधिक हो गई है: "स्मार्ट" टीवी, स्पीकर, सेट-टॉप बॉक्स। ये सभी Chromecast का समर्थन करते हैं। लेकिन बाजार में अभी भी कई अनुप्रयोग हैं जो स्पष्ट रूप से इसके साथ एकीकरण की कमी रखते हैं।

इस लेख में, मैं मीडिया सामग्री खेलने के लिए एंड्रॉइड एप्लिकेशन में क्रोमकास्ट को एकीकृत करने के अपने अनुभव को साझा करना चाहता हूं।

यह कैसे काम करता है

यदि यह आपका पहली बार "Chromecast" शब्द सुन रहा है, तो मैं आपको संक्षेप में बताने की कोशिश करूंगा। उपयोग के संदर्भ में, यह कुछ इस तरह दिखता है:

1. उपयोगकर्ता एक एप्लिकेशन या वेबसाइट के माध्यम से संगीत सुनता है या वीडियो देखता है।
2. Chromecast डिवाइस स्थानीय नेटवर्क पर दिखाई देता है।
3. खिलाड़ी के इंटरफेस में एक संबंधित बटन दिखाई देना चाहिए।
4. उस पर क्लिक करके, उपयोगकर्ता सूची से वांछित डिवाइस का चयन करता है। यह एक नेक्सस प्लेयर, एंड्रॉइड टीवी या एक स्मार्ट स्पीकर हो सकता है।
5. इस डिवाइस के साथ आगे प्लेबैक जारी है।

तकनीकी रूप से, निम्न जैसा कुछ होता है:

1. Google सेवा प्रसारण के माध्यम से स्थानीय नेटवर्क पर Chromecast उपकरणों की उपस्थिति की निगरानी करती है।
2. यदि MediaRouter आपके एप्लिकेशन से जुड़ा है, तो आपको इस बारे में एक घटना प्राप्त होगी।
3. जब कोई उपयोगकर्ता एक कास्ट डिवाइस का चयन करता है और उससे कनेक्ट होता है, तो एक नया मीडिया सत्र (CastSession) खुलता है।
4. पहले से ही बनाए गए सत्र में, हम प्लेबैक के लिए सामग्री स्थानांतरित करेंगे।
   यह बहुत सरल लगता है।

एकीकरण

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

प्रारंभ

सबसे पहले हमें कास्ट एप्लिकेशन फ्रेमवर्क और मीडिया राउटर को जोड़ने की आवश्यकता है:

implementation "com.google.android.gms:play-services-cast-framework:16.1.0" implementation "androidx.mediarouter:mediarouter:1.0.0" 

फिर कास्ट फ्रेमवर्क को एप्लिकेशन पहचानकर्ता (उस पर बाद में), और समर्थित मीडिया सामग्री के प्रकार प्राप्त करना चाहिए। यही है, अगर हमारा आवेदन केवल वीडियो चलाता है, तो Google होम कॉलम पर कास्टिंग करना असंभव होगा, और यह उपकरणों की सूची में नहीं होगा। ऐसा करने के लिए, OptionsProvider का कार्यान्वयन बनाएं:

 class CastOptionsProvider: OptionsProvider { override fun getCastOptions(context: Context): CastOptions { return CastOptions.Builder() .setReceiverApplicationId(BuildConfig.CHROMECAST_APP_ID) .build() } override fun getAdditionalSessionProviders(context: Context): MutableList<SessionProvider>? { return null } } 

और इसे घोषणापत्र में घोषित करें:

 <meta-data android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME" android:value="your.app.package.CastOptionsProvider" /> 

आवेदन रजिस्टर करें

Chromecast को हमारे एप्लिकेशन के साथ काम करने के लिए, इसे Google कास्ट एसडीके डेवलपर्स कंसोल में पंजीकृत होना चाहिए। इसके लिए Chromecast डेवलपर खाते (Google Play डेवलपर खाते के साथ भ्रमित न होना) की आवश्यकता होती है। पंजीकरण करते समय, आपको $ 5 का एक बार शुल्क देना होगा। क्रोमकास्ट एप्लिकेशन को प्रकाशित करने के बाद, आपको थोड़ा इंतजार करने की आवश्यकता है।
कंसोल में, आप स्क्रीन के साथ उपकरणों के लिए कास्ट प्लेयर की उपस्थिति को बदल सकते हैं और एप्लिकेशन के भीतर कास्टिंग एनालिटिक्स देख सकते हैं।

मीडिया राउटर

MediaRouteFramework एक तंत्र है जो आपको उपयोगकर्ता के पास सभी दूरस्थ प्लेबैक उपकरणों को खोजने की अनुमति देता है। यह न केवल क्रोमकास्ट हो सकता है, बल्कि तीसरे पक्ष के प्रोटोकॉल का उपयोग करके दूरस्थ डिस्प्ले और स्पीकर भी हो सकता है। लेकिन हमारे पास Chromecast की कितनी रुचि है।

MediaRouteFramework में एक दृश्य है जो मीडिया स्कूटर की स्थिति को दर्शाता है। इसे जोड़ने के दो तरीके हैं:

1) मेनू के माध्यम से:

 <?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto"> ... <item android:id="@+id/menu_media_route" android:title="@string/cast" app:actionProviderClass="androidx.mediarouter.app.MediaRouteActionProvider" app:showAsAction="always"/> ... </menu> 

2) वाया लेआउट:

 <androidx.mediarouter.app.MediaRouteButton android:id="@+id/mediaRouteButton" android:layout_width="wrap_content" android:layout_height="wrap_content" android:mediaRouteTypes="user"/> 

और कोड से आपको बस CastButtonFactory में बटन को पंजीकृत करने की आवश्यकता है। तब मीडिया स्कूटर की वर्तमान स्थिति को इसमें डाला जाएगा:

 CastButtonFactory.setUpMediaRouteButton(applicationContext, view.mediaRouteButton) 

अब जब एप्लिकेशन पंजीकृत हो गया है और MediaRouter कॉन्फ़िगर किया गया है, तो आप क्रोमकास्ट डिवाइसों से कनेक्ट कर सकते हैं और उन्हें सत्र खोल सकते हैं।

मीडिया सामग्री कास्टिंग

क्रोमकास्ट तीन मुख्य प्रकार की सामग्री का समर्थन करता है:

• ऑडियो;
• वीडियो;
• फोटो।

खिलाड़ी की सेटिंग्स, जैसे कि मीडिया सामग्री और कास्ट डिवाइस के आधार पर, खिलाड़ी का इंटरफ़ेस भिन्न हो सकता है।

CastSession

इसलिए, उपयोगकर्ता ने वांछित डिवाइस का चयन किया, CastFramework ने एक नया सत्र खोला। अब हमारा काम इस पर प्रतिक्रिया देना और प्लेबैक के लिए डिवाइस को जानकारी देना है।
सत्र की वर्तमान स्थिति का पता लगाने और इस स्थिति को अपडेट करने के लिए साइन अप करें, SessionManager ऑब्जेक्ट का उपयोग करें:

 private val mediaSessionListener = object : SessionManagerListener<CastSession> { override fun onSessionStarted(session: CastSession, sessionId: String) { currentSession = session //  ,      checkAndStartCasting() } override fun onSessionEnding(session: CastSession) { stopCasting() } override fun onSessionResumed(session: CastSession, wasSuspended: Boolean) { currentSession = session checkAndStartCasting() } override fun onSessionStartFailed(session: CastSession, p1: Int) { stopCasting() } override fun onSessionEnded(session: CastSession, p1: Int) { // do nothing } override fun onSessionResumeFailed(session: CastSession, p1: Int) { // do nothing } override fun onSessionSuspended(session: CastSession, p1: Int) { // do nothing } override fun onSessionStarting(session: CastSession) { // do nothing } override fun onSessionResuming(session: CastSession, sessionId: String) { // do nothing } } val sessionManager = CastContext.getSharedInstance(context).sessionManager sessionManager.addSessionManagerListener(mediaSessionListener, CastSession::class.java) 

और हम यह भी पता लगा सकते हैं कि क्या इस समय एक खुला सत्र है:

 val currentSession: CastSession? = sessionManager.currentCastSession 

हमारे पास दो मुख्य शर्तें हैं जिनके तहत हम कास्टिंग शुरू कर सकते हैं:

1. सत्र पहले से ही खुला है।
2. कास्टिंग के लिए सामग्री है।

इन दो घटनाओं में से प्रत्येक पर, हम स्थिति की जांच कर सकते हैं, और यदि सब कुछ क्रम में है, तो कास्टिंग शुरू करें।

ढलाई

अब जब हमारे पास क्या डालना है और कहां डालना है, हम सबसे महत्वपूर्ण बात पर आगे बढ़ सकते हैं। अन्य बातों के अलावा, CastSession में एक RemoteMediaClient ऑब्जेक्ट है जो मीडिया सामग्री की प्लेबैक स्थिति के लिए ज़िम्मेदार है। हम उसके साथ काम करेंगे।

चलिए MediaMetadata बनाते हैं, जहाँ लेखक, एल्बम, आदि के बारे में जानकारी संग्रहीत की जाएगी। यह बहुत हद तक वैसा ही है जैसा हम स्थानीय प्लेबैक शुरू करने पर MediaSession को हस्तांतरित करते हैं।

 val mediaMetadata = MediaMetadata(MediaMetadata.MEDIA_TYPE_MUSIC_TRACK ).apply { putString(MediaMetadata.KEY_TITLE, “In C”) putString(MediaMetadata.KEY_ARTIST, “Terry Riley”) mediaContent?.metadata?.posterUrl?.let { poster -> addImage(WebImage(Uri.parse(“https://habrastorage.org/webt/wk/oi/pf/wkoipfkdyy2ctoa5evnd8vhxtem.png”))) } } 

MediaMetadata में बहुत सारे पैरामीटर हैं, और उन्हें प्रलेखन में देखना बेहतर है। मुझे सुखद आश्चर्य हुआ कि आप बिटमैप के माध्यम से नहीं, बल्कि WebImage के अंदर लिंक द्वारा एक छवि जोड़ सकते हैं।

MediaInfo ऑब्जेक्ट सामग्री मेटाडेटा के बारे में जानकारी रखता है और इस बारे में बात करेगा कि मीडिया सामग्री कहाँ से आती है, यह किस प्रकार की है, इसे कैसे खेलें:

 val mediaInfo = MediaInfo.Builder(“https://you-address.com/in_c.mp3”) .setContentType(“audio/mp3”) .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED) .setMetadata(mediaMetadata) .build() 

आपको याद दिला दूं कि MIME विनिर्देशन के अनुसार contentType एक प्रकार की सामग्री है।
आप विज्ञापन प्रविष्टि को MediaInfo में भी स्थानांतरित कर सकते हैं:

• setAdBreakClips - AdBreakClipInfo विज्ञापनों की सूची को सामग्री, शीर्षक, समय और उस लिंक के साथ स्वीकार करता है जिसके माध्यम से विज्ञापन छोड़ा जाता है।
• setAdBreaks - विज्ञापन आवेषण के लेआउट और समय के बारे में जानकारी।

MediaLoadOptions में हम वर्णन करते हैं कि हम मीडिया स्ट्रीम (गति, प्रारंभिक स्थिति) को कैसे संसाधित करेंगे। प्रलेखन यह भी कहता है कि setCredentials के माध्यम से आप प्राधिकरण के लिए अनुरोध शीर्ष लेख पास कर सकते हैं, लेकिन Chromecast के मेरे अनुरोधों में प्राधिकरण के लिए घोषित फ़ील्ड शामिल नहीं थे।

 val mediaLoadOptions = MediaLoadOptions.Builder() .setPlayPosition(position!!) .setAutoplay(true) .setPlaybackRate(playbackSpeed) .setCredentials(context.getString(R.string.bearer_token, authGateway.authState.accessToken!!)) .setCredentialsType(context.getString(R.string.authorization_header_key)) .build() 

एक बार सब कुछ तैयार हो जाने पर, हम सभी डेटा को RemoteMediaClient को दे सकते हैं, और Chromecast खेलना शुरू कर देगा। स्थानीय प्लेबैक को रोकना महत्वपूर्ण है।

 val remoteMediaClient = currentSession!!.remoteMediaClient remoteMediaClient.load(mediaInfo, mediaLoadOptions) 

इवेंट हैंडलिंग

वीडियो चलना शुरू हुआ और फिर क्या? यदि उपयोगकर्ता टीवी को रोक देता है तो क्या होगा? Chromecast की ओर से घटनाओं के बारे में जानने के लिए, RemoteMediaClient में कॉलबैक हैं:

 private val castStatusCallback = object : RemoteMediaClient.Callback() { override fun onStatusUpdated() { // check and update current state } } remoteMediaClient.registerCallback(castStatusCallback) 

वर्तमान प्रगति को जानना भी सरल है:

 val periodMills = 1000L remoteMediaClient.addProgressListener( RemoteMediaClient.ProgressListener { progressMills, durationMills -> // show progress in your UI }, periodMills ) 

मौजूदा खिलाड़ी के साथ एकीकरण का अनुभव

जिस एप्लिकेशन पर मैं काम कर रहा था, उसमें पहले से तैयार मीडिया प्लेयर था। लक्ष्य इसमें Chromecast समर्थन को एकीकृत करना था। मीडिया प्लेयर स्टेट मशीन पर आधारित था, और पहला विचार एक नए राज्य को जोड़ना था: "कास्टिंगस्टैट"। लेकिन इस विचार को तुरंत अस्वीकार कर दिया गया था, क्योंकि प्रत्येक खिलाड़ी राज्य प्लेबैक स्थिति को दर्शाता है, और इससे कोई फर्क नहीं पड़ता कि ExoPlayer या ChromeCast के कार्यान्वयन के रूप में क्या कार्य करता है।
फिर खिलाड़ी के "जीवन चक्र" की प्राथमिकता और प्रसंस्करण के साथ प्रतिनिधियों की एक निश्चित प्रणाली बनाने के लिए विचार आया। सभी प्रतिनिधियों को खिलाड़ी का दर्जा प्राप्त हो सकता है: प्ले, पॉज़ आदि। - लेकिन केवल प्रमुख प्रतिनिधि मीडिया सामग्री को खेलेंगे।

हमारे पास इस खिलाड़ी इंटरफ़ेस जैसा कुछ है:

 interface Player { val isPlaying: Boolean val isReleased: Boolean val duration: Long var positionInMillis: Long var speed: Float var volume: Float var loop: Boolean fun addListener(listener: PlayerCallback) fun removeListener(listener: PlayerCallback): Boolean fun getListeners(): MutableSet<PlayerCallback> fun prepare(mediaContent: MediaContent) fun play() fun pause() fun release() interface PlayerCallback { fun onPlaying(currentPosition: Long) fun onPaused(currentPosition: Long) fun onPreparing() fun onPrepared() fun onLoadingChanged(isLoading: Boolean) fun onDurationChanged(duration: Long) fun onSetSpeed(speed: Float) fun onSeekTo(fromTimeInMillis: Long, toTimeInMillis: Long) fun onWaitingForNetwork() fun onError(error: String?) fun onReleased() fun onPlayerProgress(currentPosition: Long) } } 

इसके अंदर इतने सारे राज्यों के साथ एक स्टेट मशीन होगी:

• खाली - प्रारंभिक अवस्था में प्रारंभिक होने से पहले।
• तैयारी - खिलाड़ी मीडिया सामग्री के प्लेबैक की शुरुआत करता है।
• तैयार - मीडिया अपलोड है और खेलने के लिए तैयार है।
• बजाना
• रोका गया
• प्रतीक्षारत नेटवर्क
• त्रुटि

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

 abstract class PlayingDelegate( protected val playerCallback: Player.PlayerCallback, var isLeading: Boolean = false ) : Player { fun setIsLeading(isLeading: Boolean, positionMills: Long, isPlaying: Boolean) { this.isLeading = isLeading if (isLeading) { onLeading(positionMills, isPlaying) } else { onDormant() } } final override fun addListener(listener: Player.PlayerCallback) { // do nothing } final override fun removeListener(listener: Player.PlayerCallback): Boolean { return false } final override fun getListeners(): MutableSet<Player.PlayerCallback> { return mutableSetOf() } /** *    */ open fun netwarkIsRestored() { // do nothing } /** *      */ abstract fun onLeading(positionMills: Long, isPlaying: Boolean) /** *      */ abstract fun onIdle() /** *     . *      , *       . */ abstract fun readyForLeading(): Boolean } 

उदाहरण के लिए, मैंने इंटरफेस को सरल बनाया। वास्तव में, कुछ और घटनाएँ हैं।
प्रजनन प्रतिनिधि के रूप में कई प्रतिनिधि हो सकते हैं। Chromecast प्रतिनिधि कुछ इस तरह दिख सकता है:

 class ChromeCastDelegate( private val context: Context, private val castCallback: ChromeCastListener, playerCallback: Player.PlayerCallback ) : PlayingDelegate(playerCallback) { companion object { private const val CONTENT_TYPE_VIDEO = "videos/mp4" private const val CONTENT_TYPE_AUDIO = "audio/mp3" private const val PROGRESS_DELAY_MILLS = 500L } interface ChromeCastListener { fun onCastStarted() fun onCastStopped() } private var sessionManager: SessionManager? = null private var currentSession: CastSession? = null private var mediaContent: MediaContent? = null private var currentPosition: Long = 0 private val mediaSessionListener = object : SessionManagerListener<CastSession> { override fun onSessionStarted(session: CastSession, sessionId: String) { currentSession = session castCallback.onCastStarted() } override fun onSessionEnding(session: CastSession) { currentPosition = session.remoteMediaClient?.approximateStreamPosition ?: currentPosition stopCasting() } override fun onSessionResumed(session: CastSession, wasSuspended: Boolean) { currentSession = session castCallback.onCastStarted() } override fun onSessionStartFailed(session: CastSession, p1: Int) { stopCasting() } override fun onSessionEnded(session: CastSession, p1: Int) { // do nothing } override fun onSessionResumeFailed(session: CastSession, p1: Int) { // do nothing } override fun onSessionSuspended(session: CastSession, p1: Int) { // do nothing } override fun onSessionStarting(session: CastSession) { // do nothing } override fun onSessionResuming(session: CastSession, sessionId: String) { // do nothing } } private val castStatusCallback = object : RemoteMediaClient.Callback() { override fun onStatusUpdated() { if (currentSession == null) return val playerState = currentSession!!.remoteMediaClient.playerState when (playerState) { MediaStatus.PLAYER_STATE_PLAYING -> playerCallback.onPlaying(positionInMillis) MediaStatus.PLAYER_STATE_PAUSED -> playerCallback.onPaused(positionInMillis) } } } private val progressListener = RemoteMediaClient.ProgressListener { progressMs, durationMs -> playerCallback.onPlayerProgress(progressMs) } // Playing delegate override val isReleased: Boolean = false override var loop: Boolean = false override val isPlaying: Boolean get() = currentSession?.remoteMediaClient?.isPlaying ?: false override val duration: Long get() = currentSession?.remoteMediaClient?.streamDuration ?: 0 override var positionInMillis: Long get() { currentPosition = currentSession?.remoteMediaClient?.approximateStreamPosition ?: currentPosition return currentPosition } set(value) { currentPosition = value checkAndStartCasting() } override var speed: Float = SpeedProvider.default() set(value) { field = value checkAndStartCasting() } override var volume: Float get() = currentSession?.volume?.toFloat() ?: 0F set(value) { currentSession?.volume = value.toDouble() } override fun prepare(mediaContent: MediaContent) { sessionManager = CastContext.getSharedInstance(context).sessionManager sessionManager?.addSessionManagerListener(mediaSessionListener, CastSession::class.java) currentSession = sessionManager?.currentCastSession this.mediaContent = mediaContent playerCallback.onPrepared() } override fun play() { if (isLeading) { currentSession?.remoteMediaClient?.play() } } override fun pause() { if (isLeading) { currentSession?.remoteMediaClient?.pause() } } override fun release() { stopCasting(true) } override fun onLeading(positionMills: Long, isPlaying: Boolean) { currentPosition = positionMills checkAndStartCasting() } override fun onIdle() { // TODO } override fun readyForLeading(): Boolean { return currentSession != null } // internal private fun checkAndStartCasting() { if (currentSession != null && mediaContent?.metadata != null && isLeading) { val mediaMetadata = MediaMetadata(getMetadataType(mediaContent!!.type)).apply { putString(MediaMetadata.KEY_TITLE, mediaContent?.metadata?.title.orEmpty()) putString(MediaMetadata.KEY_ARTIST, mediaContent?.metadata?.author.orEmpty()) mediaContent?.metadata?.posterUrl?.let { poster -> addImage(WebImage(Uri.parse(poster))) } } val mediaInfo = MediaInfo.Builder(mediaContent!!.contentUri.toString()) .setContentType(getContentType(mediaContent!!.type)) .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED) .setMetadata(mediaMetadata) .build() val mediaLoadOptions = MediaLoadOptions.Builder() .setPlayPosition(currentPosition) .setAutoplay(true) .setPlaybackRate(speed.toDouble()) .build() val remoteMediaClient = currentSession!!.remoteMediaClient remoteMediaClient.unregisterCallback(castStatusCallback) remoteMediaClient.load(mediaInfo, mediaLoadOptions) remoteMediaClient.registerCallback(castStatusCallback) remoteMediaClient.addProgressListener(progressListener, PROGRESS_DELAY_MILLS) } } private fun stopCasting(removeListener: Boolean = false) { if (removeListener) { sessionManager?.removeSessionManagerListener(mediaSessionListener, CastSession::class.java) } currentSession?.remoteMediaClient?.unregisterCallback(castStatusCallback) currentSession?.remoteMediaClient?.removeProgressListener(progressListener) currentSession?.remoteMediaClient?.stop() currentSession = null if (isLeading) { castCallback.onCastStopped() } } private fun getContentType(mediaType: MediaContent.Type) = when (mediaType) { MediaContent.Type.AUDIO -> CONTENT_TYPE_AUDIO MediaContent.Type.VIDEO -> CONTENT_TYPE_VIDEO } private fun getMetadataType(mediaType: MediaContent.Type) = when (mediaType) { MediaContent.Type.AUDIO -> MediaMetadata.MEDIA_TYPE_MUSIC_TRACK MediaContent.Type.VIDEO -> MediaMetadata.MEDIA_TYPE_MOVIE } } 

प्रजनन के बारे में एक आदेश देने से पहले, हमें अग्रणी प्रतिनिधि पर निर्णय लेने की आवश्यकता है। ऐसा करने के लिए, उन्हें खिलाड़ी की प्राथमिकता के क्रम में जोड़ा जाता है, और उनमें से प्रत्येक रेडीफ्लोरिंग () विधि में अपनी तत्परता की स्थिति दे सकता है। पूरा नमूना कोड GitHub पर देखा जा सकता है ।

क्या क्रोमकास्ट के बाद जीवन है

जब मैंने एप्लिकेशन में क्रोमकास्ट समर्थन को एकीकृत किया, तो मेरे लिए घर पर आना और हेडफोन के माध्यम से न केवल Google पुस्तकों के माध्यम से, बल्कि ऑडियो पुस्तकों का आनंद लेना अधिक सुखद हो गया। वास्तुकला के लिए, विभिन्न अनुप्रयोगों में खिलाड़ियों का कार्यान्वयन भिन्न हो सकता है, इसलिए यह दृष्टिकोण हर जगह उचित नहीं होगा। लेकिन हमारी वास्तुकला के लिए, यह ऊपर आया। मुझे उम्मीद है कि यह लेख उपयोगी था, और निकट भविष्य में और अधिक एप्लिकेशन होंगे जो डिजिटल वातावरण के साथ एकीकृत कर सकते हैं!