मैसेज के ज़रिए लोगों से जुड़े रहना, कई ड्राइवर के लिए अहम होता है. चैट ऐप्लिकेशन, उपयोगकर्ताओं को जानें कि क्या किसी बच्चे को पिक अप करने की ज़रूरत है या डिनर की जगह बदल दी गई है. Android फ़्रेमवर्क की मदद से, मैसेजिंग ऐप्लिकेशन में ट्रांसफ़र करने की सुविधा मिलती है. इस स्टैंडर्ड यूज़र इंटरफ़ेस का इस्तेमाल करके, ड्राइवर अपने पर निर्भर कर रहा है.
मैसेजिंग की सुविधा वाले ऐप्लिकेशन, मैसेज की सूचनाओं की अवधि को बढ़ा सकते हैं. इससे Android Auto जब Auto चल रहा हो, तब उनका इस्तेमाल करें. ये सूचनाएं 'अपने-आप' टैब में दिखती हैं. इससे लोगों को ये सूचनाएं मिलती हैं मैसेज पढ़ने और उनका जवाब देने के लिए, एक जैसे इंटरफ़ेस का इस्तेमाल करें. और जब आप इसका इस्तेमाल MessageStyle API, आपको सभी Android के लिए ऑप्टिमाइज़ किए गए मैसेज की सूचनाएं मिलती हैं जैसे, 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
सूचना को कार के डिसप्ले पर देखा जा सकता है.
Android Auto को इस्तेमाल करने के लिए, ऐप्लिकेशन को Notification में Action ऑब्जेक्ट जोड़ना भी ज़रूरी है
उपयोगकर्ता को किसी मैसेज का तुरंत जवाब देने या उसे सीधे
नोटिफ़िकेशन शेड पर टैप करें.
खास जानकारी में, किसी एक बातचीत को Notification से दिखाया जाता है
ऐसा ऑब्जेक्ट है जिसे MessagingStyle ऑब्जेक्ट से स्टाइल किया गया है. MessagingStyle
उस बातचीत के सभी मैसेज एक या एक से ज़्यादा
MessagingStyle.Message ऑब्जेक्ट. Android Auto की नीतियों का पालन करने के लिए, यह एक ऐप्लिकेशन
Notification में जवाब दें और पढ़ा गया के तौर पर मार्क करें Action ऑब्जेक्ट अटैच करना होगा.
मैसेज की सुविधा
इस सेक्शन में, आपके ऐप्लिकेशन और Android Auto के बीच मैसेज भेजने के सामान्य फ़्लो के बारे में बताया गया है.
- आपके ऐप्लिकेशन को एक मैसेज मिलता है.
- आपका ऐप्लिकेशन, जवाब के साथ
MessagingStyleसूचना जनरेट करता है और 'पढ़ा गया' के तौर पर मार्क करेंActionऑब्जेक्ट. - 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 की कोर लाइब्रेरी इंपोर्ट करें
अपने-आप काम करने वाले डिवाइसों के साथ इस्तेमाल करने के लिए, सूचनाएं बनाने के लिए ज़रूरी है कि AndroidX की मुख्य लाइब्रेरी. लाइब्रेरी को अपने इस तरह प्रोजेक्ट किया जाता है:
- टॉप-लेवल
build.gradleफ़ाइल में, Google की Maven पर डिपेंडेंसी शामिल करें डेटा संग्रह स्थान, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:
ग्रूवी
allprojects {
repositories {
google()
}
}
Kotlin
allprojects {
repositories {
google()
}
}
- अपने ऐप्लिकेशन मॉड्यूल की
build.gradleफ़ाइल में, AndroidX Core को शामिल करें लाइब्रेरी डिपेंडेंसी, जैसा कि इस उदाहरण में दिखाया गया है:
ग्रूवी
dependencies {
// If your app is written in Java
implementation 'androidx.core:core:1.13.1'
// If your app is written in Kotlin
implementation 'androidx.core:core-ktx:1.13.1'
}
Kotlin
dependencies {
// If your app is written in Java
implementation("androidx.core:core:1.13.1")
// If your app is written in Kotlin
implementation("androidx.core:core-ktx:1.13.1")
}
उपयोगकर्ता की कार्रवाइयों को मैनेज करना
आपके मैसेजिंग ऐप्लिकेशन को
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 की नीतियों के मुताबिक सूचनाएं जनरेट की जा सकती हैं.
कार्रवाइयां बनाएं
Notification का इस्तेमाल करके Action ऑब्जेक्ट को दूसरे ऐप्लिकेशन को पास किया जा सकता है
ट्रिगर करने के तरीके बताए गए हैं. 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 नहीं है.
इसलिए, 'पढ़ा गया के तौर पर मार्क करें' Action के लिए, Android Auto की दो ज़रूरी शर्तें हैं:
- सिमैंटिक कार्रवाई
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 के साथ शेयर किया गया है. Android
इस सुविधा का इस्तेमाल करके, किसी बातचीत के हर मैसेज को अपने-आप पढ़कर सुनाया जाता है.
सबसे पहले, डिवाइस के उपयोगकर्ता को
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 समस्या को ट्रैक करने वाला टूल. समस्या वाले टेंप्लेट में मांगी गई पूरी जानकारी भरना न भूलें.
नई समस्या दर्ज करने से पहले, देख लें कि क्या समस्याओं में उसकी शिकायत पहले से की गई है सूची. आप इसमें मौजूद समस्या के लिए स्टार पर क्लिक करके सदस्यता ले सकते हैं और समस्याओं के लिए वोट कर सकते हैं का पता लगाने के लिए किया जा सकता है. ज़्यादा जानकारी के लिए, यह देखें किसी समस्या के लिए सदस्यता लेना.