Android Auto पर मैसेज की सूचनाएं पाना

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

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

इससे जुड़े डिज़ाइन के दिशा-निर्देशों के लिए, Design for Driving साइट पर मैसेजिंग ऐप्लिकेशन देखें.

अहम जानकारी: नए और मौजूदा मैसेजिंग ऐप्लिकेशन को सीधे तौर पर, Android Automotive OS पर ड्राइवर के लिए ऑप्टिमाइज़ किए गए ऐप्लिकेशन के तौर पर इंस्टॉल नहीं किया जा सकता. इन्हें सिर्फ़ Android Auto के ज़रिए डिस्ट्रिब्यूट किया जा सकता है. ज़्यादा जानकारी के लिए, ऐप्लिकेशन की कैटगरी देखें.

शुरू करें

Auto डिवाइसों के लिए मैसेजिंग सेवा उपलब्ध कराने के लिए, आपके ऐप्लिकेशन को मेनिफ़ेस्ट में Android Auto के साथ काम करने की जानकारी देनी होगी. साथ ही, उसे ये काम करने होंगे:

• जवाब और 'पढ़ा गया' के तौर पर मार्क करने वाले Action ऑब्जेक्ट वाले NotificationCompat.MessagingStyle ऑब्जेक्ट बनाएं और भेजें.
• Service का इस्तेमाल करके, किसी बातचीत का जवाब दें और उसे 'पढ़ी गई' के तौर पर मार्क करें.

कॉन्सेप्ट और ऑब्जेक्ट

ऐप्लिकेशन डिज़ाइन करने से पहले, यह समझना ज़रूरी है कि Android Auto मैसेजिंग की सुविधा को कैसे मैनेज करता है.

बातचीत के हर हिस्से को मैसेज कहा जाता है. इसे MessagingStyle.Message क्लास से दिखाया जाता है. किसी मैसेज में, मैसेज भेजने वाले का नाम, मैसेज का कॉन्टेंट, और मैसेज भेजे जाने का समय होता है.

उपयोगकर्ताओं के बीच बातचीत को बातचीत कहा जाता है. इसे MessagingStyle ऑब्जेक्ट से दिखाया जाता है. किसी बातचीत या MessagingStyle में टाइटल, मैसेज, और यह जानकारी शामिल होती है कि बातचीत उपयोगकर्ताओं के किसी ग्रुप के बीच हो रही है या नहीं.

किसी बातचीत में हुए अपडेट के बारे में उपयोगकर्ताओं को सूचना देने के लिए, ऐप्लिकेशन Android सिस्टम को Notification पोस्ट करते हैं. जैसे, कोई नया मैसेज. यह Notification, MessagingStyle ऑब्जेक्ट का इस्तेमाल करता है, ताकि सूचना पैनल में मैसेजिंग से जुड़ा यूज़र इंटरफ़ेस (यूआई) दिखाया जा सके. Android प्लैटफ़ॉर्म भी इस Notification को Android Auto को पास करता है. इसके बाद, Notification को निकालकर, कार के डिसप्ले पर सूचना पोस्ट करने के लिए इस्तेमाल किया जाता है.MessagingStyle

Android Auto के लिए, ऐप्लिकेशन को Notification में Action ऑब्जेक्ट जोड़ने की भी ज़रूरत होती है. इससे उपयोगकर्ता, सूचना पैनल से ही किसी मैसेज का तुरंत जवाब दे सकता है या उसे 'पढ़ा गया' के तौर पर मार्क कर सकता है.

संक्षेप में, एक बातचीत को Notification ऑब्जेक्ट के तौर पर दिखाया जाता है. इसे MessagingStyle ऑब्जेक्ट के साथ स्टाइल किया जाता है. MessagingStyle में, उस बातचीत के सभी मैसेज एक या उससे ज़्यादा MessagingStyle.Message ऑब्जेक्ट में शामिल होते हैं. Android Auto के साथ काम करने के लिए, किसी ऐप्लिकेशन को Action ऑब्जेक्ट में जवाब देने और पढ़े गए के तौर पर मार्क करने वाले Action ऑब्जेक्ट अटैच करने होंगे.Notification

मैसेजिंग फ़्लो

इस सेक्शन में, आपके ऐप्लिकेशन और Android Auto के बीच मैसेजिंग के सामान्य फ़्लो के बारे में बताया गया है.

1. आपके ऐप्लिकेशन को एक मैसेज मिलता है.
2. आपका ऐप्लिकेशन, जवाब देने और पढ़े गए के तौर पर मार्क करने के लिए Action ऑब्जेक्ट के साथ MessagingStyle सूचना जनरेट करता है.
3. Android Auto को Android सिस्टम से “नई सूचना” इवेंट मिलता है. इसके बाद, वह जवाब Action, जवाब दें Action, और पढ़े के तौर पर मार्क करें Action ढूंढता है.MessagingStyle
4. Android Auto, कार में एक सूचना जनरेट करता है और उसे दिखाता है.
5. अगर उपयोगकर्ता, कार के डिसप्ले पर सूचना पर टैप करता है, तो Android Auto, पढ़े गए के तौर पर मार्क करने की सुविधा Action को ट्रिगर करता है.
   • बैकग्राउंड में, आपके ऐप्लिकेशन को 'पढ़ा गया' के तौर पर मार्क करने वाले इस इवेंट को मैनेज करना होगा.
6. अगर उपयोगकर्ता आवाज़ का इस्तेमाल करके सूचना का जवाब देता है, तो Android Auto, उपयोगकर्ता के जवाब को ट्रांसक्राइब करके जवाब Action में डाल देता है. इसके बाद, उसे ट्रिगर करता है.
   • बैकग्राउंड में, आपके ऐप्लिकेशन को इस जवाब वाले इवेंट को मैनेज करना होगा.

शुरुआती अनुमान

इस पेज पर, पूरा मैसेजिंग ऐप्लिकेशन बनाने के बारे में जानकारी नहीं दी गई है. कोड के इस सैंपल में, कुछ ऐसी चीज़ें शामिल हैं जिनकी ज़रूरत आपके ऐप्लिकेशन को Android Auto के साथ मैसेजिंग की सुविधा शुरू करने से पहले होती है:

data class YourAppConversation(
        val id: Int,
        val title: String,
        val recipients: MutableList<YourAppUser>,
        val icon: Bitmap) {
    companion object {
        /** Fetches [YourAppConversation] by its [id]. */
        fun getById(id: Int): YourAppConversation = // ...
    }

    /** Replies to this conversation with the given [message]. */
    fun reply(message: String) {}

    /** Marks this conversation as read. */
    fun markAsRead() {}

    /** Retrieves all unread messages from this conversation. */
    fun getUnreadMessages(): List<YourAppMessage> { return /* ... */ }
}
data class YourAppUser(val id: Int, val name: String, val icon: Uri)
data class YourAppMessage(
    val id: Int,
    val sender: YourAppUser,
    val body: String,
    val timeReceived: Long)

Android Auto के साथ काम करने की सुविधा के बारे में जानकारी देना

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

<application>
    ...
    <meta-data
        android:name="com.google.android.gms.car.application"
        android:resource="@xml/automotive_app_desc"/>
    ...
</application>

मेनिफ़ेस्ट की यह एंट्री, किसी दूसरी एक्सएमएल फ़ाइल के बारे में बताती है. आपको यह फ़ाइल, इस पाथ पर बनानी होगी: YourAppProject/app/src/main/res/xml/automotive_app_desc.xml. automotive_app_desc.xml में, Android Auto की उन सुविधाओं के बारे में बताएं जिन्हें आपका ऐप्लिकेशन सपोर्ट करता है. उदाहरण के लिए, सूचनाएं पाने की सुविधा के लिए सहायता का एलान करने के लिए, यह कोड शामिल करें:

<automotiveApp>
    <uses name="notification" />
</automotiveApp>

अगर आपके ऐप्लिकेशन को डिफ़ॉल्ट एसएमएस हैंडलर के तौर पर सेट किया जा सकता है, तो पक्का करें कि आपने यहां दिया गया <uses> एलिमेंट शामिल किया हो. ऐसा न करने पर, Android Auto में पहले से मौजूद डिफ़ॉल्ट हैंडलर का इस्तेमाल, आने वाले एसएमएस या मल्टीमीडिया मैसेज (एमएमएस) को मैनेज करने के लिए किया जाएगा. ऐसा तब होगा, जब आपके ऐप्लिकेशन को डिफ़ॉल्ट एसएमएस हैंडलर के तौर पर सेट किया गया हो. इससे डुप्लीकेट सूचनाएं मिल सकती हैं.

<automotiveApp>
    ...
    <uses name="sms" />
</automotiveApp>

AndroidX कोर लाइब्रेरी इंपोर्ट करें

Auto डिवाइसों के साथ इस्तेमाल करने के लिए सूचनाएं बनाने के लिए, AndroidX कोर लाइब्रेरी की ज़रूरत होती है. लाइब्रेरी को अपने प्रोजेक्ट में इस तरह इंपोर्ट करें:

1. टॉप-लेवल की build.gradle फ़ाइल में, Google के Maven रिपॉज़िटरी पर निर्भरता शामिल करें. इसका उदाहरण यहां दिया गया है:

Groovy

allprojects {
    repositories {
        google()
    }
}

Kotlin

allprojects {
    repositories {
        google()
    }
}

1. अपने ऐप्लिकेशन मॉड्यूल की build.gradle फ़ाइल में, AndroidX Core लाइब्रेरी की डिपेंडेंसी शामिल करें. इसका उदाहरण यहां दिया गया है:

Groovy

dependencies {
    // If your app is written in Java
    implementation 'androidx.core:core:1.17.0'

    // If your app is written in Kotlin
    implementation 'androidx.core:core-ktx:1.17.0'
}

Kotlin

dependencies {
    // If your app is written in Java
    implementation("androidx.core:core:1.17.0")

    // If your app is written in Kotlin
    implementation("androidx.core:core-ktx:1.17.0")
}

उपयोगकर्ता की कार्रवाइयों को मैनेज करना

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

चेतावनी: किसी Action को हैंडल करने के लिए, Activity या Fragment का इस्तेमाल न करें. ये न सिर्फ़ फ़ोरग्राउंड में चलते हैं, बल्कि इनसे यूज़र इंटरफ़ेस (यूआई) से जुड़ी समस्याएं भी होती हैं. इन समस्याओं की वजह से, आपके ऐप्लिकेशन को Android Auto पर ब्लॉक किया जा सकता है.

इंटेंट ऐक्शन तय करना

Intent ऐक्शन, सामान्य स्ट्रिंग होते हैं. इनसे यह पता चलता है कि Intent किस काम के लिए है. एक ही सेवा कई तरह के इंटेंट को हैंडल कर सकती है. इसलिए, कई IntentService कॉम्पोनेंट तय करने के बजाय, कई ऐक्शन स्ट्रिंग तय करना आसान होता है.

इस गाइड में दिए गए उदाहरण के तौर पर इस्तेमाल किए गए मैसेजिंग ऐप्लिकेशन में, दो ज़रूरी तरह की कार्रवाइयां हैं: जवाब देना और पढ़े गए के तौर पर मार्क करना. इन्हें यहां दिए गए कोड सैंपल में दिखाया गया है.

private const val ACTION_REPLY = "com.example.REPLY"
private const val ACTION_MARK_AS_READ = "com.example.MARK_AS_READ"

सेवा बनाना

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

private const val EXTRA_CONVERSATION_ID_KEY = "conversation_id"
private const val REMOTE_INPUT_RESULT_KEY = "reply_input"

/**
 * An [IntentService] that handles reply and mark-as-read actions for
 * [YourAppConversation]s.
 */
class MessagingService : IntentService("MessagingService") {
    override fun onHandleIntent(intent: Intent?) {
        // Fetches internal data.
        val conversationId = intent!!.getIntExtra(EXTRA_CONVERSATION_ID_KEY, -1)

        // Searches the database for that conversation.
        val conversation = YourAppConversation.getById(conversationId)

        // Handles the action that was requested in the intent. The TODOs
        // are addressed in a later section.
        when (intent.action) {
            ACTION_REPLY -> TODO()
            ACTION_MARK_AS_READ -> TODO()
        }
    }
}

अहम जानकारी: एपीआई 30 के बाद से, IntentService का इस्तेमाल नहीं किया जा सकता. हालांकि, यह अब भी इस गाइड में बताए गए Android Auto के इस्तेमाल के उदाहरणों के लिए काम करता है. IntentService, सूचना से मिले PendingIntent के जवाब में शुरू होता है. इसलिए, सिस्टम आपके ऐप्लिकेशन को अनुमति वाली सूची में शामिल करता है. इससे बैकग्राउंड सेवा को शुरू और लागू करने की अनुमति मिलती है. ज़्यादा जानकारी के लिए, बैकग्राउंड में चलने वाली सेवा से जुड़ी पाबंदियां देखें.

इस सेवा को अपने ऐप्लिकेशन से जोड़ने के लिए, आपको अपने ऐप्लिकेशन के मेनिफ़ेस्ट में सेवा को रजिस्टर करना होगा. इसका उदाहरण यहां दिया गया है:

<application>
    <service android:name="com.example.MessagingService" />
    ...
</application>

इंटेंट जनरेट करना और उन्हें मैनेज करना

Android Auto के साथ-साथ अन्य ऐप्लिकेशन के पास भी Intent पाने का कोई तरीका नहीं है, जो MessagingService को ट्रिगर करता है. ऐसा इसलिए, क्योंकि Intent को अन्य ऐप्लिकेशन में PendingIntent के ज़रिए पास किया जाता है. इस सीमा की वजह से, आपको RemoteInput ऑब्जेक्ट बनाना होगा, ताकि अन्य ऐप्लिकेशन आपके ऐप्लिकेशन को जवाब का टेक्स्ट वापस दे सकें. इसका उदाहरण यहां दिया गया है:

/**
 * Creates a [RemoteInput] that lets remote apps provide a response string
 * to the underlying [Intent] within a [PendingIntent].
 */
fun createReplyRemoteInput(context: Context): RemoteInput {
    // RemoteInput.Builder accepts a single parameter: the key to use to store
    // the response in.
    return RemoteInput.Builder(REMOTE_INPUT_RESULT_KEY).build()
    // Note that the RemoteInput has no knowledge of the conversation. This is
    // because the data for the RemoteInput is bound to the reply Intent using
    // static methods in the RemoteInput class.
}

/** Creates an [Intent] that handles replying to the given [appConversation]. */
fun createReplyIntent(
        context: Context, appConversation: YourAppConversation): Intent {
    // Creates the intent backed by the MessagingService.
    val intent = Intent(context, MessagingService::class.java)

    // Lets the MessagingService know this is a reply request.
    intent.action = ACTION_REPLY

    // Provides the ID of the conversation that the reply applies to.
    intent.putExtra(EXTRA_CONVERSATION_ID_KEY, appConversation.id)

    return intent
}

MessagingService में मौजूद ACTION_REPLY स्विच क्लॉज़ में से, जवाब Intent में शामिल की जाने वाली जानकारी निकालें. इसके लिए, यहां दिया गया उदाहरण देखें:

ACTION_REPLY -> {
    // Extracts reply response from the intent using the same key that the
    // RemoteInput uses.
    val results: Bundle = RemoteInput.getResultsFromIntent(intent)
    val message = results.getString(REMOTE_INPUT_RESULT_KEY)

    // This conversation object comes from the MessagingService.
    conversation.reply(message)
}

'पढ़ा गया' के तौर पर मार्क करने की सुविधा Intent को भी इसी तरह से हैंडल किया जाता है. हालांकि, इसके लिए RemoteInput की ज़रूरत नहीं होती. जैसा कि इस उदाहरण में दिखाया गया है:

/** Creates an [Intent] that handles marking the [appConversation] as read. */
fun createMarkAsReadIntent(
        context: Context, appConversation: YourAppConversation): Intent {
    val intent = Intent(context, MessagingService::class.java)
    intent.action = ACTION_MARK_AS_READ
    intent.putExtra(EXTRA_CONVERSATION_ID_KEY, appConversation.id)
    return intent
}

MessagingService में मौजूद ACTION_MARK_AS_READ स्विच क्लॉज़ में किसी और लॉजिक की ज़रूरत नहीं होती है. इसे यहां दिए गए उदाहरण में दिखाया गया है:

// Marking as read has no other logic.
ACTION_MARK_AS_READ -> conversation.markAsRead()

उपयोगकर्ताओं को मैसेज की सूचना देना

बातचीत से जुड़ी कार्रवाई को हैंडल करने की प्रोसेस पूरी होने के बाद, अगला चरण Android Auto के साथ काम करने वाली सूचनाएं जनरेट करना है.

कार्रवाइयां बनाना

Action ऑब्जेक्ट को Notification का इस्तेमाल करके, दूसरे ऐप्लिकेशन में पास किया जा सकता है. इससे ओरिजनल ऐप्लिकेशन में तरीकों को ट्रिगर किया जा सकता है. इस तरह, Android Auto किसी बातचीत को 'पढ़ी गई' के तौर पर मार्क कर सकता है या उसका जवाब दे सकता है.

Action बनाने के लिए, Intent से शुरुआत करें. इस उदाहरण में, "जवाब" Intent बनाने का तरीका दिखाया गया है:

fun createReplyAction(
        context: Context, appConversation: YourAppConversation): Action {
    val replyIntent: Intent = createReplyIntent(context, appConversation)
    // ...

इसके बाद, इस Intent को PendingIntent में रैप करें. इससे यह बाहरी ऐप्लिकेशन में इस्तेमाल करने के लिए तैयार हो जाएगा. PendingIntent, रैप किए गए Intent के सभी ऐक्सेस को लॉक कर देता है. ऐसा सिर्फ़ कुछ ऐसे तरीके दिखाकर किया जाता है जिनकी मदद से, ऐप्लिकेशन पाने वाला ऐप्लिकेशन Intent को ट्रिगर कर सकता है या ऐप्लिकेशन बनाने वाले ऐप्लिकेशन के पैकेज का नाम पा सकता है. बाहरी ऐप्लिकेशन, मौजूदा Intent या उसमें मौजूद डेटा को कभी भी ऐक्सेस नहीं कर सकता.

    // ...
    val replyPendingIntent = PendingIntent.getService(
        context,
        createReplyId(appConversation), // Method explained later.
        replyIntent,
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE)
    // ...

जवाब देने की सुविधा Action सेट अप करने से पहले, ध्यान रखें कि Android Auto पर जवाब देने की सुविधा Action के लिए, तीन ज़रूरी शर्तें हैं:

• सिमैंटिक ऐक्शन को Action.SEMANTIC_ACTION_REPLY पर सेट किया जाना चाहिए.
• Action से यह पता चलना चाहिए कि ट्रिगर होने पर, यह कोई भी यूज़र इंटरफ़ेस नहीं दिखाएगा.
• Action में सिर्फ़ एक RemoteInput होना चाहिए.

यहां दिए गए कोड के सैंपल में, जवाब Action को सेट अप किया गया है. इसमें ऊपर दी गई ज़रूरी शर्तों को पूरा किया गया है:

    // ...
    val replyAction = Action.Builder(R.drawable.reply, "Reply", replyPendingIntent)
        // Provides context to what firing the Action does.
        .setSemanticAction(Action.SEMANTIC_ACTION_REPLY)

        // The action doesn't show any UI, as required by Android Auto.
        .setShowsUserInterface(false)

        // Don't forget the reply RemoteInput. Android Auto will use this to
        // make a system call that will add the response string into
        // the reply intent so it can be extracted by the messaging app.
        .addRemoteInput(createReplyRemoteInput(context))
        .build()

    return replyAction
}

'पढ़ा गया के तौर पर मार्क करें' कार्रवाई को हैंडल करने का तरीका एक जैसा होता है. हालांकि, इसमें RemoteInput नहीं होता है. इसलिए, Android Auto के लिए, 'पढ़ा गया' के तौर पर मार्क करने की सुविधा Action के लिए दो ज़रूरी शर्तें हैं:

• सिमैंटिक ऐक्शन को Action.SEMANTIC_ACTION_MARK_AS_READ पर सेट किया गया है.
• इस कार्रवाई से पता चलता है कि ट्रिगर होने पर, यह कोई यूज़र इंटरफ़ेस नहीं दिखाएगी.

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

fun createMarkAsReadAction(
        context: Context, appConversation: YourAppConversation): Action {
    val markAsReadIntent = createMarkAsReadIntent(context, appConversation)
    val markAsReadPendingIntent = PendingIntent.getService(
            context,
            createMarkAsReadId(appConversation), // Method explained below.
            markAsReadIntent,
            PendingIntent.FLAG_UPDATE_CURRENT  or PendingIntent.FLAG_IMMUTABLE)
    val markAsReadAction = Action.Builder(
            R.drawable.mark_as_read, "Mark as Read", markAsReadPendingIntent)
        .setSemanticAction(Action.SEMANTIC_ACTION_MARK_AS_READ)
        .setShowsUserInterface(false)
        .build()
    return markAsReadAction
}

लंबित इंटेंट जनरेट करते समय, दो तरीकों का इस्तेमाल किया जाता है: createReplyId() और createMarkAsReadId(). ये तरीके, हर PendingIntent के लिए अनुरोध कोड के तौर पर काम करते हैं. इनका इस्तेमाल Android, मौजूदा लंबित इंटेंट को कंट्रोल करने के लिए करता है. create() तरीकों को हर बातचीत के लिए यूनीक आईडी देने होंगे. हालांकि, एक ही बातचीत के लिए बार-बार किए गए कॉल को पहले से जनरेट किया गया यूनीक आईडी देना होगा.

दो बातचीत, A और B का उदाहरण देखें: बातचीत A के जवाब का आईडी 100 है और 'पढ़ा गया' के तौर पर मार्क करने का आईडी 101 है. बातचीत B के जवाब का आईडी 102 है और 'पढ़ा गया' के तौर पर मार्क करने का आईडी 103 है. अगर बातचीत A को अपडेट किया जाता है, तो जवाब देने और पढ़े गए के तौर पर मार्क करने के आईडी अब भी 100 और 101 हैं. ज़्यादा जानकारी के लिए, PendingIntent.FLAG_UPDATE_CURRENT देखें.

MessagingStyle ऑब्जेक्ट बनाना

MessagingStyle मैसेजिंग की जानकारी देने वाला ऐप्लिकेशन है. Android Auto, बातचीत में शामिल हर मैसेज को तेज़ आवाज़ में पढ़ने के लिए इसका इस्तेमाल करता है.

सबसे पहले, डिवाइस के उपयोगकर्ता को Person ऑब्जेक्ट के तौर पर तय किया जाना चाहिए. जैसा कि इस उदाहरण में दिखाया गया है:

fun createMessagingStyle(
        context: Context, appConversation: YourAppConversation): MessagingStyle {
    // Method defined by the messaging app.
    val appDeviceUser: YourAppUser = getAppDeviceUser()

    val devicePerson = Person.Builder()
        // The display name (also the name that's read aloud in Android auto).
        .setName(appDeviceUser.name)

        // The icon to show in the notification shade in the system UI (outside
        // of Android Auto).
        .setIcon(appDeviceUser.icon)

        // A unique key in case there are multiple people in this conversation with
        // the same name.
        .setKey(appDeviceUser.id)
        .build()
    // ...

इसके बाद, MessagingStyle ऑब्जेक्ट बनाया जा सकता है और बातचीत के बारे में कुछ जानकारी दी जा सकती है.

    // ...
    val messagingStyle = MessagingStyle(devicePerson)

    // Sets the conversation title. If the app's target version is lower
    // than P, this will automatically mark the conversation as a group (to
    // maintain backward compatibility). Use `setGroupConversation` after
    // setting the conversation title to explicitly override this behavior. See
    // the documentation for more information.
    messagingStyle.setConversationTitle(appConversation.title)

    // Group conversation means there is more than 1 recipient, so set it as such.
    messagingStyle.setGroupConversation(appConversation.recipients.size > 1)
    // ...

आखिर में, वे मैसेज जोड़ें जिन्हें आपने नहीं पढ़ा है.

    // ...
    for (appMessage in appConversation.getUnreadMessages()) {
        // The sender is also represented using a Person object.
        val senderPerson = Person.Builder()
            .setName(appMessage.sender.name)
            .setIcon(appMessage.sender.icon)
            .setKey(appMessage.sender.id)
            .build()

        // Adds the message. More complex messages, like images,
        // can be created and added by instantiating the MessagingStyle.Message
        // class directly. See documentation for details.
        messagingStyle.addMessage(
                appMessage.body, appMessage.timeReceived, senderPerson)
    }

    return messagingStyle
}

सूचना को पैकेज करें और पुश करें

Action और MessagingStyle ऑब्जेक्ट जनरेट करने के बाद, Notification बनाया और पोस्ट किया जा सकता है.

fun notify(context: Context, appConversation: YourAppConversation) {
    // Creates the actions and MessagingStyle.
    val replyAction = createReplyAction(context, appConversation)
    val markAsReadAction = createMarkAsReadAction(context, appConversation)
    val messagingStyle = createMessagingStyle(context, appConversation)

    // Creates the notification.
    val notification = NotificationCompat.Builder(context, channel)
        // A required field for the Android UI.
        .setSmallIcon(R.drawable.notification_icon)

        // Shows in Android Auto as the conversation image.
        .setLargeIcon(appConversation.icon)

        // Adds MessagingStyle.
        .setStyle(messagingStyle)

        // Adds reply action.
        .addAction(replyAction)

        // Makes the mark-as-read action invisible, so it doesn't appear
        // in the Android UI but the app satisfies Android Auto's
        // mark-as-read Action requirement. Both required actions can be made
        // visible or invisible; it is a stylistic choice.
        .addInvisibleAction(markAsReadAction)

        .build()

    // Posts the notification for the user to see.
    val notificationManagerCompat = NotificationManagerCompat.from(context)
    notificationManagerCompat.notify(appConversation.id, notification)
}

अन्य संसाधन

• Google Design for Driving: Messaging apps
• सूचनाओं की खास जानकारी

Android Auto पर मैसेज सेवा से जुड़ी किसी समस्या की शिकायत करना

अगर आपको Android Auto के लिए मैसेजिंग ऐप्लिकेशन डेवलप करते समय कोई समस्या आती है, तो इसकी शिकायत Google Issue Tracker का इस्तेमाल करके की जा सकती है. समस्या के टेंप्लेट में मांगी गई पूरी जानकारी भरें.

नई समस्या बनाना

नई समस्या की शिकायत करने से पहले, यह देख लें कि क्या वह समस्या पहले से ही समस्याओं की सूची में मौजूद है. ट्रैकर में किसी समस्या के लिए स्टार पर क्लिक करके, उसकी सदस्यता ली जा सकती है और उसके लिए वोट किया जा सकता है. ज़्यादा जानकारी के लिए, किसी समस्या को सब्सक्राइब करना लेख पढ़ें.