सूचना बनाएं

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

इस पेज पर मौजूद कोड, AndroidX लाइब्रेरी के NotificationCompat एपीआई का इस्तेमाल करता है. इन एपीआई की मदद से, Android के नए वर्शन पर उपलब्ध सुविधाएं जोड़ी जा सकती हैं. साथ ही, Android 9 (एपीआई लेवल 28) के साथ काम करने की सुविधा भी मिलती है. हालांकि, कुछ सुविधाएं, जैसे कि इनलाइन जवाब देने की सुविधा, पुराने वर्शन पर काम नहीं करती.

बुनियादी सूचना बनाना

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

पहली इमेज. एक सूचना, जिसमें आइकॉन, टाइटल, और कुछ टेक्स्ट शामिल है.

सूचना के हर हिस्से के बारे में ज़्यादा जानने के लिए, सूचना की बनावट के बारे में पढ़ें.

रनटाइम की अनुमति का एलान करना

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

आपको अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल में जिस अनुमति का एलान करना है वह यहां दिए गए कोड स्निपेट में दिखती है:

<manifest ...>
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
    <application ...>
        ...
    </application>
</manifest>

रनटाइम की अनुमतियों के बारे में ज़्यादा जानने के लिए, सूचना के लिए रनटाइम की अनुमति लेख पढ़ें.

सूचना का कॉन्टेंट सेट करना

शुरू करने के लिए, NotificationCompat.Builder ऑब्जेक्ट का इस्तेमाल करके, सूचना का कॉन्टेंट और चैनल सेट करें. यहां दिए गए उदाहरण में, सूचना बनाने का तरीका बताया गया है. इसमें ये चीज़ें शामिल हैं:

  • एक छोटा आइकॉन, जिसे setSmallIcon() ने सेट किया है. यह उपयोगकर्ता को दिखने वाला एकमात्र ज़रूरी कॉन्टेंट है.

  • एक टाइटल, जिसे setContentTitle() ने सेट किया है.

  • मुख्य टेक्स्ट, जिसे setContentText() ने सेट किया है.

  • सूचना की प्राथमिकता, जिसे setPriority() ने सेट किया है. Android 7.1 और इससे पहले के वर्शन में, प्राथमिकता से यह तय होता है कि सूचना कितनी दखल देने वाली है. Android 8.0 और इसके बाद के वर्शन के लिए, चैनल की अहमियत सेट करें. इसके बारे में अगले सेक्शन में बताया गया है.

val textTitle = "Title"
val textContent = "Content"
val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle(textTitle)
    .setContentText(textContent)
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)

NotificationCompat.Builder कंस्ट्रक्टर के लिए, आपको चैनल आईडी देना होगा. यह Android 8.0 (एपीआई लेवल 26) और इसके बाद के वर्शन के साथ काम करने के लिए ज़रूरी है. हालांकि, इससे पहले के वर्शन में इसे अनदेखा कर दिया जाता है.

डिफ़ॉल्ट रूप से, सूचना के टेक्स्ट कॉन्टेंट को छोटा करके एक लाइन में दिखाया जाता है. बड़ी की जा सकने वाली सूचना बनाकर, ज़्यादा जानकारी दिखाई जा सकती है.

दूसरी इमेज. बड़ा होने वाली सूचना, छोटे और बड़े किए गए फ़ॉर्म में.

अगर आपको सूचना को बड़ा करना है, तो setStyle() का इस्तेमाल करके स्टाइल टेंप्लेट जोड़कर, सूचना को बड़ा करने की सुविधा चालू की जा सकती है. उदाहरण के लिए, इस कोड से बड़ा टेक्स्ट एरिया बनता है:

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Much longer text that cannot fit one line...")
    .setStyle(NotificationCompat.BigTextStyle()
        .bigText("Much longer text that cannot fit one line..."))
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)

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

चैनल बनाना और उसकी अहमियत सेट करना

Android 8.0 और इसके बाद के वर्शन पर सूचनाएं भेजने से पहले, अपने ऐप्लिकेशन के सूचना चैनल को सिस्टम के साथ रजिस्टर करें. इसके लिए, NotificationChannel के इंस्टेंस को createNotificationChannel() पर पास करें. नीचे दिए गए कोड को SDK_INT वर्शन पर किसी शर्त की वजह से ब्लॉक किया गया है:

fun createNotificationChannel(context: Context) {
    // Create the NotificationChannel, but only on API 26+ because
    // the NotificationChannel class is not in the Support Library.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val name = context.getString(R.string.channel_name)
        val descriptionText = context.getString(R.string.channel_description)
        val importance = NotificationManager.IMPORTANCE_DEFAULT
        val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
            description = descriptionText
        }
        // Register the channel with the system.
        val notificationManager: NotificationManager =
            context.getSystemService(NotificationManager::class.java) as NotificationManager
        notificationManager.createNotificationChannel(channel)
    }
}

Android 8.0 और इसके बाद के वर्शन पर सूचनाएं पोस्ट करने से पहले, आपको सूचना चैनल बनाना होगा. इसके लिए, ऐप्लिकेशन शुरू होने पर यह कोड चलाएं. इस तरीके को बार-बार कॉल करना सुरक्षित है, क्योंकि किसी मौजूदा चैनल को बनाने से कुछ नहीं होता.

NotificationChannel कंस्ट्रक्टर के लिए, NotificationManager कॉन्सटैंट का इस्तेमाल करके, ज़रूरी होने का लेवल तय करना ज़रूरी है. इससे यह तय होता है कि उपयोगकर्ता को कैसे इंटरप्ट करना है. Android 7.1 और इससे पहले के वर्शन पर काम करने के लिए, setPriority() के साथ प्राथमिकता भी सेट करें, जैसा कि पिछले उदाहरण में दिखाया गया है.

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

अलग-अलग लेवल का क्या मतलब है, इस बारे में ज़्यादा जानने के लिए, सूचना की अहमियत के लेवल के बारे में पढ़ें.

सूचना पर टैप करने पर होने वाली कार्रवाई सेट करना

हर सूचना पर टैप करने से कोई कार्रवाई होनी चाहिए. आम तौर पर, सूचना पर टैप करने से आपके ऐप्लिकेशन में कोई गतिविधि खुलती है. इसके लिए, PendingIntent ऑब्जेक्ट के साथ तय किए गए कॉन्टेंट इंटेंट की जानकारी दें और उसे setContentIntent() को पास करें.

यहां दिए गए स्निपेट से पता चलता है कि जब उपयोगकर्ता सूचना पर टैप करता है, तो किसी गतिविधि को खोलने के लिए बुनियादी इंटेंट कैसे बनाया जाता है:

// Create an explicit intent for an Activity in your app.
val intent = Intent(context, AlertDetails::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}
val pendingIntent: PendingIntent =
    PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_IMMUTABLE)

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Hello World!")
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
    // Set the intent that fires when the user taps the notification.
    .setContentIntent(pendingIntent)
    .setAutoCancel(true)

यह कोड setAutoCancel() को कॉल करता है. इससे उपयोगकर्ता के टैप करने पर, सूचना अपने-आप हट जाती है.

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

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

  • ऐसी गतिविधि जो आपके ऐप्लिकेशन के सामान्य फ़्लो में मौजूद हो. इस मामले में, गतिविधि शुरू करने से पिछली गतिविधियां बनती हैं, ताकि वापस जाएं और ऊपर जाएं बटन के लिए उपयोगकर्ता की उम्मीदें बनी रहें.

सूचना दिखाना

सूचना दिखाने के लिए, NotificationManagerCompat.notify() को कॉल करें. साथ ही, सूचना के लिए एक यूनीक आईडी और NotificationCompat.Builder.build() का नतीजा पास करें. इसे यहां दिए गए उदाहरण में दिखाया गया है:

with(NotificationManagerCompat.from(context)) {
    if (ActivityCompat.checkSelfPermission(
            context,
            Manifest.permission.POST_NOTIFICATIONS
        ) != PackageManager.PERMISSION_GRANTED
    ) {
        // TODO: Consider calling ActivityCompat#requestPermissions here
        // to request the missing permissions, and then overriding
        // public fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>,
        //                                        grantResults: IntArray)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.

        return@with
    }
    // notificationId is a unique int for each notification that you must define.
    notify(notificationId, builder.build())

NotificationManagerCompat.notify() को पास किया गया सूचना आईडी सेव करें, क्योंकि सूचना को अपडेट करने या हटाने के लिए आपको इसकी ज़रूरत पड़ेगी.

इसके अलावा, Android 13 और इसके बाद के वर्शन वाले डिवाइसों पर बुनियादी सूचनाओं की जांच करने के लिए, सूचनाएं पाने की सुविधा को मैन्युअल तरीके से चालू करें या सूचनाओं का अनुरोध करने के लिए कोई डायलॉग बॉक्स बनाएं.

ऐक्शन बटन जोड़ना

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

तीसरी इमेज. एक ऐक्शन बटन वाली सूचना.

कोई ऐक्शन बटन जोड़ने के लिए, addAction() तरीके में PendingIntent पास करें. यह सूचना के लिए डिफ़ॉल्ट टैप ऐक्शन सेट अप करने जैसा है. हालांकि, कोई गतिविधि लॉन्च करने के बजाय, अन्य काम किए जा सकते हैं. जैसे, बैकग्राउंड में काम करने वाली BroadcastReceiver शुरू करना, ताकि पहले से खुले हुए ऐप्लिकेशन में कोई रुकावट न आए.

उदाहरण के लिए, यहां दिए गए कोड से पता चलता है कि किसी खास रिसीवर को ब्रॉडकास्ट कैसे भेजा जाता है:

val ACTION_SNOOZE = "snooze"
val snoozeIntent = Intent(context, MyBroadcastReceiver::class.java).apply {
    action = ACTION_SNOOZE
    putExtra(EXTRA_NOTIFICATION_ID, 0)
}
val snoozePendingIntent: PendingIntent =
    PendingIntent.getBroadcast(context, 0, snoozeIntent, PendingIntent.FLAG_IMMUTABLE)
val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Hello World!")
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
    .setContentIntent(pendingIntent)
    .addAction(R.drawable.snooze, context.getString(R.string.snooze),
        snoozePendingIntent)

बैकग्राउंड में काम करने के लिए BroadcastReceiver बनाने के बारे में ज़्यादा जानने के लिए, ब्रॉडकास्ट की खास जानकारी देखें.

अगर आपको मीडिया प्लेबैक बटन वाली सूचना बनानी है, जैसे कि ट्रैक को रोकने और स्किप करने के लिए, तो मीडिया कंट्रोल वाली सूचना बनाने का तरीका देखें.

सीधे जवाब देने की कार्रवाई जोड़ना

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

चौथी इमेज. "जवाब दें" बटन पर टैप करने से, टेक्स्ट इनपुट खुलता है.

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

'जवाब दें' बटन जोड़ना

सीधे जवाब देने की सुविधा वाली सूचना कार्रवाई बनाने के लिए, यह तरीका अपनाएं:

RemoteInput.Builder का एक इंस्टेंस बनाएं, जिसे सूचना पर की जाने वाली कार्रवाई में जोड़ा जा सके. इस क्लास का कंस्ट्रक्टर, एक स्ट्रिंग स्वीकार करता है. सिस्टम, इस स्ट्रिंग को टेक्स्ट इनपुट के लिए कुंजी के तौर पर इस्तेमाल करता है. आपका ऐप्लिकेशन बाद में उस कुंजी का इस्तेमाल करके, इनपुट का टेक्स्ट वापस लाता है.

// Key for the string that's delivered in the action's intent.
val replyLabel: String = context.resources.getString(R.string.reply_label)
val remoteInput: RemoteInput = RemoteInput.Builder(KEY_TEXT_REPLY).run {
    setLabel(replyLabel)
    build()
}

जवाब देने की कार्रवाई के लिए, PendingIntent बनाएं.

// Build a PendingIntent for the reply action to trigger.
val replyPendingIntent: PendingIntent =
    PendingIntent.getBroadcast(context,
        conversationId,
        getMessageReplyIntent(conversationId),
        PendingIntent.FLAG_MUTABLE)

addRemoteInput() का इस्तेमाल करके, RemoteInput ऑब्जेक्ट को किसी कार्रवाई से अटैच करें.

// Create the reply action and add the remote input.
val action: NotificationCompat.Action =
    NotificationCompat.Action.Builder(R.drawable.reply,
        context.getString(R.string.reply_label), replyPendingIntent)
        .addRemoteInput(remoteInput)
        .build()

किसी सूचना पर कार्रवाई लागू करें और सूचना जारी करें.

// Build the notification and add the action.
val newMessageNotification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_message)
    .setContentTitle(context.getString(R.string.title))
    .setContentText(context.getString(R.string.content))
    .addAction(action)
    .build()

// Issue the notification.
NotificationManagerCompat.from(context).notify(notificationId, newMessageNotification)

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

जवाब से उपयोगकर्ता का इनपुट पाना

सूचना के जवाब वाले यूज़र इंटरफ़ेस (यूआई) से उपयोगकर्ता का इनपुट पाने के लिए, RemoteInput.getResultsFromIntent() को कॉल करें. साथ ही, इसे BroadcastReceiver को मिले Intent को पास करें:

private fun getMessageText(intent: Intent): CharSequence? {
    return RemoteInput.getResultsFromIntent(intent)?.getCharSequence(KEY_TEXT_REPLY)
}

टेक्स्ट को प्रोसेस करने के बाद, सूचना को अपडेट करें. इसके लिए, उसी आईडी और टैग के साथ NotificationManagerCompat.notify() को कॉल करें. सीधे जवाब देने वाले यूज़र इंटरफ़ेस (यूआई) को छिपाने और उपयोगकर्ता को यह पुष्टि करने के लिए कि उसका जवाब मिल गया है और उसे सही तरीके से प्रोसेस किया गया है, यह ज़रूरी है.

// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
val repliedNotification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.message)
    .setContentText(context.getString(R.string.replied))
    .build()

// Issue the new notification.
NotificationManagerCompat.from(context).notify(notificationId, repliedNotification)

अन्य डेटा वापस पाना

अन्य तरह के डेटा को मैनेज करने का तरीका भी RemoteInput के साथ काम करता है. यहां दिए गए उदाहरण में, इनपुट के तौर पर इमेज का इस्तेमाल किया गया है.

val replyLabel: String = context.resources.getString(R.string.reply_label)
val remoteInput: RemoteInput = RemoteInput.Builder(KEY_REPLY).run {
    setLabel(replyLabel)
    // Allow for image data types in the input.
    // This method can be used again to allow for other data types.
    setAllowDataType("image/*", true)
    build()
}

RemoteInput#getDataResultsFromIntent को कॉल करें और उससे जुड़ा डेटा एक्सट्रैक्ट करें.

class ReplyReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val dataResults = RemoteInput.getDataResultsFromIntent(intent, KEY_REPLY)
        val imageUri: Uri? = dataResults?.get("image/*") as? Uri

        if (imageUri != null) {
            // Extract the image
            context.contentResolver.openInputStream(imageUri)?.use { inputStream ->
                val bitmap = BitmapFactory.decodeStream(inputStream)
                // Display the image
                // ...
            }
        }
    }

    companion object {
        const val KEY_REPLY = "key_reply"
        const val KEY_TEXT_REPLY = "key_text_reply"
    }
}

इस नई सूचना के साथ काम करते समय, उस कॉन्टेक्स्ट का इस्तेमाल करें जिसे रिसीवर के onReceive() तरीके में पास किया गया है.

setRemoteInputHistory() को कॉल करके, सूचना के सबसे नीचे जवाब जोड़ें. हालांकि, अगर आपको कोई मैसेजिंग ऐप्लिकेशन बनाना है, तो मैसेजिंग स्टाइल वाली सूचना बनाएं और बातचीत में नया मैसेज जोड़ें.

मैसेजिंग ऐप्लिकेशन से मिलने वाली सूचनाओं के बारे में ज़्यादा सलाह पाने के लिए, मैसेजिंग ऐप्लिकेशन के लिए सबसे सही तरीके सेक्शन देखें.

कोई ज़रूरी मैसेज दिखाना

ऐसा हो सकता है कि आपके ऐप्लिकेशन को कोई ज़रूरी और समय के हिसाब से संवेदनशील मैसेज दिखाना पड़े. जैसे, कोई इनकमिंग फ़ोन कॉल या बजता हुआ अलार्म. ऐसे मामलों में, सूचना के साथ फ़ुल-स्क्रीन इंटेंट को जोड़ा जा सकता है.

सूचना मिलने पर, उपयोगकर्ताओं को डिवाइस के लॉक स्टेटस के आधार पर, इनमें से कोई एक विकल्प दिखता है:

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

नीचे दिए गए कोड स्निपेट में, सूचना को फ़ुल-स्क्रीन इंटेंट से जोड़ने का तरीका बताया गया है:

val fullScreenIntent = Intent(context, ImportantActivity::class.java)
val fullScreenPendingIntent = PendingIntent.getActivity(context, 0,
    fullScreenIntent, PendingIntent.FLAG_IMMUTABLE)

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Hello World!")
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
    .setFullScreenIntent(fullScreenPendingIntent, true)

लॉक स्क्रीन पर सूचनाएं दिखने की सेटिंग सेट करना

लॉक स्क्रीन पर दिखने वाली सूचना में जानकारी के लेवल को कंट्रोल करने के लिए, setVisibility() को कॉल करें और इनमें से कोई एक वैल्यू डालें:

  • VISIBILITY_PUBLIC: सूचना का पूरा कॉन्टेंट, लॉक स्क्रीन पर दिखता है.

  • VISIBILITY_SECRET: लॉक स्क्रीन पर सूचना का कोई भी हिस्सा नहीं दिखता.

  • VISIBILITY_PRIVATE: लॉक स्क्रीन पर सिर्फ़ बुनियादी जानकारी दिखती है. जैसे, सूचना का आइकॉन और कॉन्टेंट का टाइटल. सूचना का पूरा कॉन्टेंट नहीं दिखता.

VISIBILITY_PRIVATE सेट करने पर, सूचना के कॉन्टेंट का एक वैकल्पिक वर्शन भी दिया जा सकता है. इसमें कुछ जानकारी छिपाई जा सकती है. उदाहरण के लिए, कोई एसएमएस ऐप्लिकेशन ऐसी सूचना दिखा सकता है जिसमें "आपको तीन नए मैसेज मिले हैं" लिखा हो. हालांकि, इसमें मैसेज का कॉन्टेंट और भेजने वाले की जानकारी छिपी हो. यह वैकल्पिक सूचना देने के लिए, पहले सामान्य तरीके से NotificationCompat.Builder की मदद से वैकल्पिक सूचना बनाएं. इसके बाद, setPublicVersion() का इस्तेमाल करके, सामान्य सूचना के साथ वैकल्पिक सूचना अटैच करें.

ध्यान रखें कि उपयोगकर्ता के पास हमेशा यह कंट्रोल होता है कि उसकी सूचनाएं लॉक स्क्रीन पर दिखें या नहीं. साथ ही, वह आपके ऐप्लिकेशन के सूचना चैनलों के आधार पर उन्हें कंट्रोल कर सकता है.

सूचना अपडेट करना

सूचना जारी करने के बाद उसे अपडेट करने के लिए, NotificationManagerCompat.notify() को फिर से कॉल करें. इसके लिए, वही आईडी पास करें जिसका इस्तेमाल आपने पहले किया था. अगर पिछली सूचना खारिज कर दी जाती है, तो उसकी जगह एक नई सूचना बनाई जाती है.

आपके पास setOnlyAlertOnce() को कॉल करने का विकल्प है, ताकि आपकी सूचना उपयोगकर्ता को आवाज़, वाइब्रेशन या विज़ुअल क्लू के साथ सिर्फ़ पहली बार सूचना दिखने पर ही इंटरप्ट करे, न कि बाद के अपडेट के लिए.

कोई सूचना हटाना

सूचनाएं तब तक दिखती रहती हैं, जब तक इनमें से कोई एक कार्रवाई नहीं होती:

  • उपयोगकर्ता, सूचना को खारिज कर देता है.
  • उपयोगकर्ता सूचना पर टैप करता है. ऐसा तब होता है, जब सूचना बनाते समय setAutoCancel() को कॉल किया जाता है.
  • किसी खास सूचना आईडी के लिए, cancel() को कॉल किया जाता है. इस तरीके से, बैकग्राउंड में जारी गतिविधि की सूचनाएं भी मिट जाती हैं.
  • cancelAll() को कॉल किया जाता है. इससे, पहले जारी की गई सभी सूचनाएं हट जाती हैं.
  • अगर आपने setTimeoutAfter() का इस्तेमाल करके, सूचना बनाते समय टाइम आउट सेट किया है, तो तय की गई अवधि खत्म हो जाती है. अगर ज़रूरी हो, तो तय की गई समयसीमा खत्म होने से पहले, सूचना को रद्द किया जा सकता है.

मैसेजिंग ऐप्लिकेशन के लिए सबसे सही तरीके

मैसेजिंग और चैट ऐप्लिकेशन के लिए सूचनाएं बनाते समय, यहां दिए गए सबसे सही तरीकों को अपनाएं.

MessagingStyle का इस्तेमाल करना

Android 7.0 (एपीआई लेवल 24) और इसके बाद के वर्शन में, Android खास तौर पर मैसेजिंग कॉन्टेंट के लिए सूचना स्टाइल टेंप्लेट उपलब्ध कराता है. NotificationCompat.MessagingStyle क्लास का इस्तेमाल करके, सूचना पर दिखने वाले कई लेबल बदले जा सकते हैं. इनमें बातचीत का टाइटल, अन्य मैसेज, और सूचना के लिए कॉन्टेंट व्यू शामिल हैं.

यहां दिए गए कोड स्निपेट से पता चलता है कि MessagingStyle क्लास का इस्तेमाल करके, सूचना की स्टाइल को पसंद के मुताबिक कैसे बनाया जा सकता है.

val message1 = NotificationCompat.MessagingStyle.Message(
    messages[0].text,
    messages[0].time,
    messages[0].sender
)
val message2 = NotificationCompat.MessagingStyle.Message(
    messages[1].text,
    messages[1].time,
    messages[1].sender
)
notification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setStyle(
        NotificationCompat.MessagingStyle(Person.Builder().setName("Me").build())
            .addMessage(message1)
            .addMessage(message2)
    )
    .build()

Android 9.0 (एपीआई लेवल 28) से, सूचना और उसके अवतारों को बेहतर तरीके से रेंडर करने के लिए, Person क्लास का इस्तेमाल करना भी ज़रूरी है.

NotificationCompat.MessagingStyle का इस्तेमाल करते समय, ये काम करें:

  • दो से ज़्यादा लोगों के साथ की जाने वाली ग्रुप चैट का टाइटल सेट करने के लिए, MessagingStyle.setConversationTitle() को कॉल करें. बातचीत का अच्छा टाइटल, ग्रुप चैट का नाम हो सकता है. अगर ग्रुप चैट का कोई नाम नहीं है, तो बातचीत में हिस्सा लेने वाले लोगों की सूची को टाइटल के तौर पर इस्तेमाल किया जा सकता है. इसके बिना, मैसेज को गलती से बातचीत में सबसे हाल ही के मैसेज भेजने वाले व्यक्ति के साथ वन-टू-वन बातचीत का हिस्सा माना जा सकता है.
  • इमेज जैसे मीडिया मैसेज शामिल करने के लिए, MessagingStyle.setData() तरीके का इस्तेमाल करें. image/* पैटर्न वाले एमआईएमई टाइप इस्तेमाल किए जा सकते हैं.

सीधे नोटिफ़िकेशन से ही जवाब देने की सुविधा का इस्तेमाल करना

Direct Reply की सुविधा से, उपयोगकर्ता किसी मैसेज का इनलाइन जवाब दे सकता है.

  • जब कोई उपयोगकर्ता इनलाइन जवाब देने की कार्रवाई का इस्तेमाल करके जवाब देता है, तो MessagingStyle सूचना को अपडेट करने के लिए MessagingStyle.addMessage() का इस्तेमाल करें. साथ ही, सूचना को वापस न लें या रद्द न करें. सूचना को रद्द न करने पर, उपयोगकर्ता सूचना से कई जवाब भेज सकता है.
  • इनलाइन जवाब देने की कार्रवाई को Wear OS के साथ काम करने लायक बनाने के लिए, Action.WearableExtender.setHintDisplayInlineAction(true) को कॉल करें.
  • addHistoricMessage() मेथड का इस्तेमाल करके, सीधे नोटिफ़िकेशन से ही जवाब देने की सुविधा वाले कन्वर्सेशन को कॉन्टेक्स्ट दें. इसके लिए, नोटिफ़िकेशन में पुराने मैसेज जोड़ें.

स्मार्ट जवाब की सुविधा चालू करना

  • स्मार्ट जवाब की सुविधा चालू करने के लिए, जवाब देने की कार्रवाई पर setAllowGeneratedResponses(true) को कॉल करें. इस वजह से, जब सूचना को Wear OS डिवाइस पर ब्रिज किया जाता है, तो उपयोगकर्ताओं को स्मार्ट जवाब की सुविधा मिलती है. स्मार्ट जवाब की सुविधा से मिलने वाले जवाब, पूरी तरह से स्मार्टवॉच पर मौजूद मशीन लर्निंग मॉडल से जनरेट होते हैं. इसके लिए, NotificationCompat.MessagingStyle सूचना में दिए गए कॉन्टेक्स्ट का इस्तेमाल किया जाता है. साथ ही, जवाब जनरेट करने के लिए, इंटरनेट पर कोई डेटा अपलोड नहीं किया जाता.

सूचना का मेटाडेटा जोड़ना

  • सूचना का मेटाडेटा असाइन करें, ताकि सिस्टम को यह पता चल सके कि डिवाइस के परेशान न करें मोड में होने पर, आपके ऐप्लिकेशन की सूचनाओं को कैसे मैनेज करना है. उदाहरण के लिए, 'परेशान न करें' सुविधा को ओवरराइड करने के लिए, addPerson() या setCategory(Notification.CATEGORY_MESSAGE) तरीके का इस्तेमाल करें.