יצירת התראה

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

הקוד בדף הזה משתמש בממשקי ה-API‏ NotificationCompat מהספרייה AndroidX. ממשקי ה-API האלה מאפשרים להוסיף תכונות שזמינות רק בגרסאות חדשות יותר של Android, תוך שמירה על תאימות לגרסה 9 של Android (רמת 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)

הקונסטרוקטור 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)

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

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

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

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

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

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

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

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

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

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

איור 4. הקשה על הלחצן 'תשובה' פותחת את הזנת הטקסט.

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

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

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

יוצרים מופע של 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)

מצרפים את האובייקט 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"
    }
}

כשעובדים עם ההתראה החדשה הזו, צריך להשתמש בהקשר שמועבר לשיטה 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() כדי להגדיר שם לצ'אטים קבוצתיים עם יותר משני אנשים. שם טוב לשיחה יכול להיות השם של הצ'אט הקבוצתי, או אם אין לו שם, רשימה של המשתתפים בשיחה. בלי זה, יכול להיות שההודעה תזוהה בטעות כהודעה בשיחה ישירה עם השולח של ההודעה האחרונה בשיחה.
  • משתמשים בשיטה MessagingStyle.setData() כדי לכלול הודעות מדיה כמו תמונות. יש תמיכה בסוגי MIME של תמונת הדפוס image/*.

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

התכונה 'תשובה ישירה' מאפשרת למשתמשים להוסיף תשובה בשרשור.

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

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

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

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