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

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

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

इससे जुड़े डिज़ाइन के दिशा-निर्देशों के लिए, Cars के लिए डिज़ाइन किए गए हब में कम्यूनिकेशन ऐप्लिकेशन देखें.

शुरू करें

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

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

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

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

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

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

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

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

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

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

  1. आपके ऐप्लिकेशन को एक मैसेज मिलता है.
  2. आपका ऐप्लिकेशन, जवाब देने और पढ़े गए के तौर पर मार्क करने Action वाले ऑब्जेक्ट के साथ MessagingStyle सूचना जनरेट करता है.
  3. Android Auto को Android सिस्टम से "नई सूचना" इवेंट मिलता है. इसके बाद, Android Auto को MessagingStyle, जवाब Action, और पढ़े के तौर पर मार्क करें Action का पता चलता है.
  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>

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

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

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

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

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

Android 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 का इस्तेमाल करके, इन अनुरोधों को मैनेज करें. इससे आपको बैकग्राउंड में, संभावित रूप से महंगे कॉल को मैनेज करने की सुविधा मिलती है. साथ ही, आपके ऐप्लिकेशन का मुख्य थ्रेड खाली हो जाता है.

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

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()
        }
    }
}

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

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

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

Android Auto जैसे अन्य ऐप्लिकेशन, Intent हासिल नहीं कर सकते. इससे MessagingService ट्रिगर होता है, क्योंकि इंटेंट को 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 से शुरुआत करें. यहां दिए गए उदाहरण में, पिछले सेक्शन में दिए गए createReplyIntent() तरीके का इस्तेमाल करके, "जवाब दें" 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 को सेट अप करने का तरीका बताया गया है. यह 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 later.
            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)
}

अन्य संसाधन

Android Auto पर मैसेजिंग से जुड़ी सूचनाओं की समस्या की शिकायत करना

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

नई समस्या दर्ज करने का तरीका

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