इस पेज का अनुवाद Cloud Translation API से किया गया है.

Android Auto के लिए मैसेजिंग ऐप्लिकेशन बनाएं

मैसेजिंग कैटगरी को बड़ा किया जा रहा है, ताकि इसमें नई सुविधाओं के लिए सहायता शामिल की जा सके. इनमें मैसेज का इतिहास और कॉल करने की सुविधाएं शामिल हैं

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

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

इस गाइड में, किसी ऐसे ऐप्लिकेशन को एक्सटेंंड करने का तरीका बताया गया है जो उपयोगकर्ता को मैसेज दिखाता है और चैट ऐप्लिकेशन की तरह, उपयोगकर्ता के जवाब भी स्वीकार करता है. इससे, मैसेज दिखाने और जवाब की रसीद को ऑटो डिवाइस को भेजने में मदद मिलती है. डिज़ाइन से जुड़े दिशा-निर्देशों के लिए, 'ड्राइविंग के लिए डिज़ाइन' साइट पर मैसेजिंग ऐप्लिकेशन देखें.

शुरू करें

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

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

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

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

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

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

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

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

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

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

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

आपके ऐप्लिकेशन को कोई मैसेज मिलता है.
आपका ऐप्लिकेशन, जवाब दें और 'पढ़ा गया' के तौर पर मार्क करें Action ऑब्जेक्ट के साथ MessagingStyle सूचना जनरेट करता है.
Android Auto को Android सिस्टम से “नई सूचना” इवेंट मिलता है और MessagingStyle, जवाब दें Action, और पढ़ा गया के तौर पर मार्क करें Action मिलता है.
Android Auto, कार में सूचना जनरेट करता है और उसे दिखाता है.
अगर उपयोगकर्ता कार के डिसप्ले पर सूचना पर टैप करता है, तो Android Auto, 'पढ़ा गया' के तौर पर मार्क करने की सुविधा Action को ट्रिगर करता है.
- बैकग्राउंड में, आपके ऐप्लिकेशन को 'पढ़ा गया' के तौर पर मार्क करने वाले इस इवेंट को मैनेज करना होगा.
अगर उपयोगकर्ता, बोलकर सूचना का जवाब देता है, तो 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 की मुख्य लाइब्रेरी की ज़रूरत होती है. लाइब्रेरी को अपने प्रोजेक्ट में इस तरह इंपोर्ट करें:

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

Groovy

allprojects {
    repositories {
        google()
    }
}

Kotlin

allprojects {
    repositories {
        google()
    }
}

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

Groovy

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

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

Kotlin

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

    // If your app is written in Kotlin
    implementation("androidx.core:core-ktx:1.15.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 को ट्रिगर करता है. इसकी वजह यह है कि 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)
}

अन्य संसाधन

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

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

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

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