יצירת התראה

התראות מספקות מידע קצר ועדכני על אירועים באפליקציה בזמן שהיא לא בשימוש. במאמר הזה מוסבר איך ליצור התראה עם תכונות שונות. בסקירה הכללית על התראות מוסבר איך ההתראות מופיעות ב-Android. הקוד לדוגמה של SociaLite ב-GitHub כולל שימוש בהתראות.

הקוד בדף הזה משתמש בממשקי ה-API של NotificationCompat מספריית AndroidX. ממשקי ה-API האלה מאפשרים להוסיף תכונות שזמינות רק בגרסאות חדשות יותר של Android, ועדיין לספק תאימות לאחור ל-Android 9 (רמת API‏ 28). עם זאת, תכונות מסוימות, כמו פעולת התשובה המהירה, לא פועלות בגרסאות קודמות.

יצירת התראה בסיסית

התראה בצורה הבסיסית והקומפקטית ביותר שלה – שנקראת גם התראה מכווצת – מציגה סמל, כותרת וכמות קטנה של תוכן טקסט. בקטע הזה מוסבר איך ליצור התראה שהמשתמש יכול ללחוץ עליה כדי להפעיל פעילות באפליקציה.

איור 1. התראה עם סמל, כותרת וטקסט.

לפרטים נוספים על כל חלק בהתראה, קראו על מבנה ההתראה.

הצהרה על ההרשאה בתחילת ההפעלה

ב-Android מגרסה 13 (רמת API‏ 33) ואילך יש תמיכה בהרשאה בתחילת ההפעלה לפרסום התראות לא פטורות (כולל שירותים שפועלים בחזית (FGS)) מאפליקציה.

ההרשאה שצריך להצהיר עליה בקובץ המניפסט של האפליקציה מופיעה בקטע הקוד הבא:

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

ה-constructor של NotificationCompat.Builder מחייב לספק מזהה ערוץ. ההגדרה הזו נדרשת כדי שהאפליקציה תהיה תואמת ל-Android מגרסה 8.0 (רמת API‏ 26) ואילך, אבל גרסאות קודמות מתעלמות ממנה.

כברירת מחדל, תוכן הטקסט של ההתראה נחתך כדי להתאים לשורה אחת. כדי להציג מידע נוסף, אפשר ליצור התראה שניתן להרחיב.

איור 2. התראה שניתן להרחיב, במצב מכווץ ובמצב מורחב.

אם רוצים שההתראה תהיה ארוכה יותר, אפשר להפעיל התראה שניתנת להרחבה על ידי הוספת תבנית סגנון באמצעות 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)

במאמר יצירת התראה שניתן להרחיב מוסבר איך להשתמש בסגנונות אחרים של התראות גדולות, כולל איך להוסיף תמונה ורכיבי UI להפעלה.

יצירת ערוץ והגדרת החשיבות שלו

כדי שתוכלו להציג את ההתראה ב-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 ומעלה, צריך ליצור את ערוץ ההתראות לפני שמפרסמים התראות, ולכן צריך להריץ את הקוד הזה כשהאפליקציה מופעלת. אפשר להפעיל את הפונקציה שוב ושוב, כי יצירת ערוץ קיים לא עושה כלום.

ה-constructor של NotificationChannel דורש רמת חשיבות באמצעות קבוע של NotificationManager. הפרמטר הזה קובע איך להפריע למשתמש. כדי לתמוך ב-Android מגרסה 7.1 ומטה, צריך להגדיר את העדיפות גם באמצעות setPriority(), כמו בדוגמה שלמעלה.

למרות שצריך להגדיר את החשיבות או העדיפות, המערכת לא מבטיחה את אופן הפעולה של ההתראה. המערכת עשויה לשנות אותה על סמך גורמים אחרים, והמשתמש תמיד יכול להתאים אישית את רמת החשיבות של הערוץ.

למידע נוסף על המשמעות של הרמות השונות, קראו על רמות החשיבות של התראות.

הגדרת הפעולה שמתבצעת כשלוחצים על ההתראה

כל התראה צריכה להגיב ללחיצה, בדרך כלל כדי לפתוח פעילות באפליקציה שתואמת להתראה. כדי לעשות את זה, מציינים כוונת תוכן שמוגדרת באמצעות אובייקט PendingIntent ומעבירים אותה אל setContentIntent().

קטע הקוד הבא מראה איך ליצור Intent בסיסי לפתיחת פעילות כשהמשתמש מקיש על ההתראה:

// 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(), שמסיר את ההתראה באופן אוטומטי כשהמשתמש מקיש עליה.

הדגלים של ה-Intent בדוגמה הקודמת שומרים על חוויית הניווט הצפויה של המשתמש אחרי שהוא פותח את האפליקציה באמצעות ההתראה. יכול להיות שתרצו להשתמש בו בהתאם לסוג הפעילות שאתם מתחילים, שיכול להיות אחד מהבאים:

  • פעילות שקיימת רק כדי להגיב להתראה. אין סיבה שהמשתמש ינווט לפעילות הזו במהלך שימוש רגיל באפליקציה, ולכן הפעילות מתחילה משימה חדשה במקום להתווסף למשימה ולמקבץ הפעילויות הקודמות (back stack) הקיימים של האפליקציה. זהו סוג ה-intent שנוצר בדוגמה שלמעלה.

  • פעילות שקיימת בתהליך הרגיל של האפליקציה. במקרה כזה, הפעלת הפעילות יוצרת מקבץ פעילויות קודמות (back stack) כדי לשמר את הציפיות של המשתמש לגבי הלחצנים "הקודם" ו"למעלה".

הצגת ההתראה

כדי שההתראה תופיע, צריך להפעיל את הפונקציה 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 ומעלה, צריך להפעיל את ההתראות באופן ידני או ליצור תיבת דו-שיח לבקשת התראות.

הוספת כפתורי פעולה

התראה יכולה להציע עד שלושה כפתורי פעולה שמאפשרים למשתמש להגיב במהירות, למשל להפעיל נודניק לתזכורת או להשיב להודעת SMS. אבל אסור שכפתורי הפעולה האלה ישכפלו את הפעולה שמתבצעת כשהמשתמש לוחץ על ההתראה.

איור 3. התראה עם כפתור פעולה אחד.

כדי להוסיף כפתור פעולה, מעבירים PendingIntent ל-method‏ addAction(). זה דומה להגדרה של פעולת ברירת המחדל בלחיצה על ההתראה, אבל במקום להפעיל פעילות, אפשר לבצע פעולות אחרות כמו הפעלת 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 (רמת API ‏24), מאפשרת למשתמשים להזין טקסט ישירות בהתראה. הטקסט נשלח לאפליקציה בלי לפתוח פעילות. לדוגמה, אתם יכולים להשתמש בפעולת תשובה ישירה כדי לאפשר למשתמשים להשיב להודעות SMS או לעדכן רשימות של משימות מתוך ההתראה.

איור 4. לחיצה על הכפתור "תשובה" פותחת את שדה הטקסט.

פעולת התשובה הישירה מופיעה כלחצן נוסף בהתראה, שפותח שדה להזנת טקסט. כשהמשתמש מסיים להקליד, המערכת מצרפת את התגובה בטקסט ל-Intent שציינתם לפעולת ההתראה ושולחת את ה-Intent לאפליקציה.

הוספת כפתור התשובה

כדי ליצור פעולת התראה שתומכת בתשובה ישירה, פועלים לפי השלבים הבאים:

יוצרים מופע של RemoteInput.Builder שאפשר להוסיף לפעולת ההתראה. ה-constructor של המחלקה הזו מקבל מחרוזת שהמערכת משתמשת בה כמפתח להזנת הטקסט. לאחר מכן, האפליקציה משתמשת במפתח הזה כדי לאחזר את הטקסט של הקלט.

// 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)

מצרפים את האובייקט RemoteInput לפעולה באמצעות addRemoteInput().

// 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)

המערכת מבקשת מהמשתמש להזין תשובה כשהוא מפעיל את פעולת ההתראה, כמו שמוצג באיור 4.

אחזור קלט של משתמש מהתשובה

כדי לקבל קלט מהמשתמש מממשק המשתמש של התשובה להתראה, צריך להפעיל את RemoteInput.getResultsFromIntent() ולהעביר אליו את ה-Intent שהתקבל על ידי ה-BroadcastReceiver:

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"
    }
}

כשעובדים עם ההתראה החדשה הזו, צריך להשתמש בהקשר שמועבר ל-method‏ onReceive() של המקבל.

מצרפים את התשובה לתחתית ההתראה באמצעות קריאה ל-setRemoteInputHistory(). עם זאת, אם אתם מפתחים אפליקציית הודעות, צרו התראה בסגנון הודעה והוסיפו את ההודעה החדשה לשיחה.

לטיפים נוספים בנושא התראות מאפליקציות להעברת הודעות, עיינו בקטע בנושא שיטות מומלצות לאפליקציות להעברת הודעות.

הצגת הודעה דחופה

יכול להיות שהאפליקציה שלכם תצטרך להציג הודעה דחופה ורגישה לזמן, כמו שיחת טלפון נכנסת או שעון מעורר שמצלצל. במצבים כאלה, אתם יכולים לשייך להתראה Intent במסך מלא.

כשההתראה מופעלת, המשתמשים רואים את אחת מהאפשרויות הבאות, בהתאם לסטטוס הנעילה של המכשיר:

  • אם המכשיר של המשתמש נעול, מופיעה פעילות במסך מלא שמכסה את מסך הנעילה.
  • אם המכשיר של המשתמש לא נעול, ההתראה מופיעה בצורה מורחבת שכוללת אפשרויות לטיפול בהתראה או לסגירה שלה.

בקטע הקוד הבא אפשר לראות איך משייכים את ההתראה ל-Intent במסך מלא:

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, אפשר גם לספק גרסה חלופית של תוכן ההתראה שמסתירה פרטים מסוימים. לדוגמה, אפליקציית סמס יכולה להציג התראה עם הכיתוב "יש לך 3 הודעות SMS חדשות", אבל להסתיר את תוכן ההודעות ואת השולחים. כדי לספק את ההתראה החלופית הזו, קודם צריך ליצור את ההתראה החלופית באמצעות NotificationCompat.Builder כרגיל. אחר כך, מצרפים את ההתראה החלופית להתראה הרגילה באמצעות setPublicVersion().

חשוב לזכור שהמשתמשים תמיד יכולים לקבוע אם ההתראות יוצגו במסך הנעילה, והם יכולים לשלוט בהן בהתאם לערוצי ההתראות של האפליקציה.

עדכון התראה

כדי לעדכן התראה אחרי שהיא הונפקה, צריך להפעיל שוב את NotificationManagerCompat.notify() ולהעביר לה את אותו מזהה שבו השתמשתם קודם. אם ההתראה הקודמת נסגרה, נוצרת התראה חדשה במקומה.

אפשר גם להפעיל את setOnlyAlertOnce() כדי שההתראה תפריע למשתמש – באמצעות צליל, רטט או רמזים חזותיים – רק בפעם הראשונה שההתראה מופיעה ולא בעדכונים הבאים.

הסרת התראה

ההתראות נשארות גלויות עד שקורה אחד מהדברים הבאים:

  • המשתמש סוגר את ההתראה.
  • המשתמש מקיש על ההתראה, אם מפעילים את setAutoCancel() כשיוצרים את ההתראה.
  • אתם קוראים ל-cancel() בשביל מזהה התראה ספציפי. השיטה הזו גם מוחקת התראות מתמשכות.
  • אתם קוראים ל-cancelAll(), שמסיר את כל ההתראות שהנפקתם בעבר.
  • משך הזמן שצוין חלף, אם הגדרתם זמן קצוב לתפוגה כשאתם יוצרים את ההתראה באמצעות setTimeoutAfter(). במקרה הצורך, אפשר לבטל התראה לפני שחולף משך הזמן הקצוב שצוין.

שיטות מומלצות לאפליקציות הודעות

כשאתם יוצרים התראות לאפליקציות של הודעות וצ'אט, כדאי לפעול לפי השיטות המומלצות שמפורטות כאן.

שימוש ב-MessagingStyle

החל מ-Android 7.0 (רמת API‏ 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 (רמת API‏ 28), צריך גם להשתמש במחלקה Person כדי לקבל עיבוד אופטימלי של ההתראה והדמויות שלה.

כשמשתמשים ב-NotificationCompat.MessagingStyle, צריך לבצע את הפעולות הבאות:

  • אפשר להפעיל את MessagingStyle.setConversationTitle() כדי לתת שם לצ'אטים קבוצתיים עם יותר משני אנשים. כותרת טובה לשיחה יכולה להיות השם של הצ'אט הקבוצתי, או אם אין לו שם, רשימה של המשתתפים בשיחה. בלי זה, יכול להיות שההודעה תזוהה בטעות כשייכת לשיחה אישית עם השולח של ההודעה האחרונה בשיחה.
  • כדי לכלול הודעות מדיה כמו תמונות, משתמשים ב-method‏ MessagingStyle.setData(). יש תמיכה בסוגי MIME בתבנית image/* ‎.

איך משתמשים בתשובה ישירה

התכונה "תשובה ישירה" מאפשרת למשתמשים לענות להודעה בשרשור.

  • אחרי שמשתמש משיב באמצעות פעולת התשובה המוטבעת, צריך להשתמש ב-MessagingStyle.addMessage() כדי לעדכן את ההתראה של MessagingStyle, ולא לבטל את ההתראה. אם לא מבטלים את ההתראה, המשתמש יכול לשלוח כמה תשובות מההתראה.
  • כדי שפעולת התשובה המהירה תהיה תואמת ל-Wear OS, צריך להפעיל את Action.WearableExtender.setHintDisplayInlineAction(true).
  • משתמשים ב-method‏ addHistoricMessage() כדי לספק הקשר לשיחה עם תשובה ישירה, על ידי הוספת הודעות היסטוריות להתראה.

הפעלת התכונה "תשובה מהירה"

  • כדי להפעיל את התכונה "תשובה מהירה", מפעילים את setAllowGeneratedResponses(true) בפעולת התשובה. כך המשתמשים יכולים להשתמש בתשובות מהירות כשההתראה מועברת למכשיר Wear OS. התשובות המהירות נוצרות על ידי מודל למידת מכונה שפועל כולו בשעון, על סמך ההקשר שסופק בהתראה של NotificationCompat.MessagingStyle. לא מועלים נתונים לאינטרנט כדי ליצור את התשובות.

הוספת מטא-נתונים של התראות