התחלת פעילות מהתראה
קל לארגן דפים בעזרת אוספים
אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
כשמתחילים פעילות מהתראה, צריך לשמור את
חוויית הניווט הצפויה. הקשה על לחצן 'הקודם' חייבת להחזיר את המשתמש
דרך תהליך העבודה הרגיל של האפליקציה למסך הבית, ופתיחת הקטע 'אחרונים'
צריכה להציג את הפעילות כמשימה נפרדת. כדי לשמור את הניווט הזה
להתחיל את הפעילות במשימה חדשה.
הגישה הבסיסית להגדרת התנהגות ההקשה להתראה מתוארת ב
יצירת רכיב בסיסי
התראה.
בדף הזה נסביר איך מגדירים
PendingIntent
עבור
פעולת ההתראה, כדי שהיא תיצור משימה חדשה וחזרה
סטאק. איך עושים את זה
תלוי בסוג הפעילות שאתם מתחילים:
- פעילות רגילה
- זו פעילות שקיימת כחלק מהתהליך הרגיל של חוויית המשתמש באפליקציה. מתי
המשתמש מגיע בפעילות מההתראה, המשימה החדשה חייבת
לכלול מקבץ חזרה שלם, וכך לאפשר למשתמש להקיש על לחצן 'הקודם' כדי לנווט
בהיררכיית האפליקציות.
- פעילות מיוחדת
- המשתמש רואה את הפעילות הזו רק אם היא מתחילה מהתראה. תוך שימוש
פעילות זו מרחיבה את ממשק ההתראה על ידי מתן מידע
קשה להציג את זה בהודעה עצמה. לפעילות הזו אין צורך
מקבץ חזרה.
הגדרה של PendingIntent של פעילות רגילה
כדי להתחיל פעילות רגילה מההתראה, צריך להגדיר את PendingIntent
באמצעות TaskStackBuilder
כדי שהוא ייצור מקבץ חזרה חדש באופן הבא.
הגדרה של היררכיית הפעילות באפליקציה
כדי להגדיר את ההיררכיה הטבעית של הפעילויות, צריך להוסיף את
android:parentActivityName
לכל מאפיין <activity>
בקובץ המניפסט של האפליקציה. מקרה לדוגמה:
<activity
android:name=".MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!-- MainActivity is the parent for ResultActivity. -->
<activity
android:name=".ResultActivity"
android:parentActivityName=".MainActivity" />
...
</activity>
פיתוח PendingIntent עם מקבץ אחורי
כדי להתחיל פעילות שכוללת מקבץ של פעילויות, צריך ליצור
מופע של TaskStackBuilder
וקריאה
addNextIntentWithParentStack()
,
להעביר לו את Intent
הפעילות שאתם רוצים להתחיל.
כל עוד מגדירים את פעילות ההורה של כל פעילות כפי שמתואר
קודם אפשר להתקשר
getPendingIntent()
כדי לקבל PendingIntent
שכולל את כל המקבץ האחורי.
Kotlin
// Create an Intent for the activity you want to start.
val resultIntent = Intent(this, ResultActivity::class.java)
// Create the TaskStackBuilder.
val resultPendingIntent: PendingIntent? = TaskStackBuilder.create(this).run {
// Add the intent, which inflates the back stack.
addNextIntentWithParentStack(resultIntent)
// Get the PendingIntent containing the entire back stack.
getPendingIntent(0,
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
}
Java
// Create an Intent for the activity you want to start.
Intent resultIntent = new Intent(this, ResultActivity.class);
// Create the TaskStackBuilder and add the intent, which inflates the back
// stack.
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
stackBuilder.addNextIntentWithParentStack(resultIntent);
// Get the PendingIntent containing the entire back stack.
PendingIntent resultPendingIntent =
stackBuilder.getPendingIntent(0,
PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
אם צריך, אפשר להוסיף ארגומנטים ל-Intent
אובייקטים במקבץ באמצעות שליחת קריאה
TaskStackBuilder.editIntentAt()
.
לפעמים זה נחוץ כדי לוודא שפעילות במקבץ האחורי
מציגה נתונים משמעותיים כשהמשתמש מנווט אליהם.
לאחר מכן אפשר להעביר את PendingIntent
להתראה כרגיל:
Kotlin
val builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {
setContentIntent(resultPendingIntent)
...
}
with(NotificationManagerCompat.from(this)) {
notify(NOTIFICATION_ID, builder.build())
}
Java
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);
builder.setContentIntent(resultPendingIntent);
...
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(NOTIFICATION_ID, builder.build());
הגדרה של פעילות מיוחדת PendingIntent
כי פעילות מיוחדת שמתחילה בהתראה לא מחייבת החזרה
אפשר ליצור את PendingIntent
באמצעות
getActivity()
.
עם זאת, צריך להגדיר את האפשרויות המתאימות למשימה במניפסט.
-
במניפסט, יש להוסיף את המאפיינים הבאים אל
רכיב
<activity>
.
-
android:taskAffinity=""
-
בשילוב עם
FLAG_ACTIVITY_NEW_TASK
שבו אתם משתמשים בקוד, מגדירים את המאפיין הזה ריק כדי לוודא
הפעילות הזו לא נכללת במשימת ברירת המחדל של האפליקציה. כלשהו
משימות קיימות עם תחום עניין משותף שמוגדר כברירת מחדל לאפליקציה, לא
הושפעו.
-
android:excludeFromRecents="true"
-
לא כולל את המשימה החדשה במסך 'אחרונים', כדי שהמשתמש
לא ניתן לנווט חזרה אליו בטעות.
אפשר לראות זאת בדוגמה הבאה:
<activity
android:name=".ResultActivity"
android:launchMode="singleTask"
android:taskAffinity=""
android:excludeFromRecents="true">
</activity>
-
יוצרים ושולחים את ההתראה:
-
יוצרים
Intent
שמתחיל את
Activity
.
-
צריך להגדיר את
Activity
כך שיתחיל במשימה חדשה ריקה לפי
שיחות
setFlags()
עם הדגלים FLAG_ACTIVITY_NEW_TASK
FLAG_ACTIVITY_CLEAR_TASK
-
יצירת
PendingIntent
בשיחות
getActivity()
.
אפשר לראות זאת בדוגמה הבאה:
Kotlin
val notifyIntent = Intent(this, ResultActivity::class.java).apply {
flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}
val notifyPendingIntent = PendingIntent.getActivity(
this, 0, notifyIntent,
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
)
Java
Intent notifyIntent = new Intent(this, ResultActivity.class);
// Set the Activity to start in a new, empty task.
notifyIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
| Intent.FLAG_ACTIVITY_CLEAR_TASK);
// Create the PendingIntent.
PendingIntent notifyPendingIntent = PendingIntent.getActivity(
this, 0, notifyIntent,
PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
);
- מעבירים את
PendingIntent
אל ההתראה כרגיל:
Kotlin
val builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {
setContentIntent(notifyPendingIntent)
...
}
with(NotificationManagerCompat.from(this)) {
notify(NOTIFICATION_ID, builder.build())
}
Java
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);
builder.setContentIntent(notifyPendingIntent);
...
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(NOTIFICATION_ID, builder.build());
כדי לקבל מידע נוסף על האפשרויות השונות לביצוע משימות ועל האופן שבו נעשה שימוש במקבץ האחורי
שעובדות, כדאי לעיין במאמר Tasks ומקבץ אחורי.
דוגמאות התוכן והקוד שבדף הזה כפופות לרישיונות המפורטים בקטע רישיון לתוכן. Java ו-OpenJDK הם סימנים מסחריים או סימנים מסחריים רשומים של חברת Oracle ו/או של השותפים העצמאיים שלה.
עדכון אחרון: 2025-07-27 (שעון UTC).
[[["התוכן קל להבנה","easyToUnderstand","thumb-up"],["התוכן עזר לי לפתור בעיה","solvedMyProblem","thumb-up"],["סיבה אחרת","otherUp","thumb-up"]],[["חסרים לי מידע או פרטים","missingTheInformationINeed","thumb-down"],["התוכן מורכב מדי או עם יותר מדי שלבים","tooComplicatedTooManySteps","thumb-down"],["התוכן לא עדכני","outOfDate","thumb-down"],["בעיה בתרגום","translationIssue","thumb-down"],["בעיה בדוגמאות/בקוד","samplesCodeIssue","thumb-down"],["סיבה אחרת","otherDown","thumb-down"]],["עדכון אחרון: 2025-07-27 (שעון UTC)."],[],[],null,["# Start an Activity from a Notification\n\nWhen you start an activity from a notification, you must preserve the user's\nexpected navigation experience. Tapping the Back button must take the user back\nthrough the app's normal work flow to the Home screen, and opening the Recents\nscreen must show the activity as a separate task. To preserve this navigation\nexperience, start the activity in a fresh task.\n\nThe basic approach to set the tap behavior for your notification is described in\n[Create a basic\nnotification](/develop/ui/views/notifications/build-notification#SimpleNotification).\nThis page describes how to set up a\n[`PendingIntent`](/reference/android/app/PendingIntent) for your\nnotification's action so it creates a fresh [task and back\nstack](/guide/components/activities/tasks-and-back-stack). How you do this\ndepends on which type of activity you're starting:\n\nRegular activity\n: This is an activity that exists as a part of your app's normal UX flow. When\n the user arrives in the activity from the notification, the new task must\n include a complete back stack, letting the user tap the Back button to navigate\n up the app hierarchy.\n\nSpecial activity\n: The user only sees this activity if it's started from a notification. In a\n sense, this activity extends the notification UI by providing information that\n is difficult to display in the notification itself. This activity doesn't need a\n back stack.\n\nSet up a regular activity PendingIntent\n---------------------------------------\n\nTo start a regular activity from your notification, set up the `PendingIntent`\nusing [`TaskStackBuilder`](/reference/androidx/core/app/TaskStackBuilder)\nso that it creates a new back stack as follows.\n\n### Define your app's Activity hierarchy\n\nDefine the natural hierarchy for your activities by adding the\n[`android:parentActivityName`](/guide/topics/manifest/activity-element#parent)\nattribute to each [`\u003cactivity\u003e`](/guide/topics/manifest/activity-element)\nelement in your app manifest file. See the following example: \n\n```xml\n\u003cactivity\n android:name=\".MainActivity\"\n android:label=\"@string/app_name\" \u003e\n \u003cintent-filter\u003e\n \u003caction android:name=\"android.intent.action.MAIN\" /\u003e\n \u003ccategory android:name=\"android.intent.category.LAUNCHER\" /\u003e\n \u003c/intent-filter\u003e\n\u003c/activity\u003e\n\u003c!-- MainActivity is the parent for ResultActivity. --\u003e\n\u003cactivity\n android:name=\".ResultActivity\"\n android:parentActivityName=\".MainActivity\" /\u003e\n ...\n\u003c/activity\u003e\n```\n\n### Build a PendingIntent with a back stack\n\nTo start an activity that includes a back stack of activities, create an\ninstance of `TaskStackBuilder` and call\n[`addNextIntentWithParentStack()`](/reference/androidx/core/app/TaskStackBuilder#addNextIntentWithParentStack(android.content.Intent)),\npassing it the [`Intent`](/reference/android/content/Intent) for the\nactivity you want to start.\n\nAs long as you define the parent activity for each activity as described\nearlier, you can call\n[`getPendingIntent()`](/reference/androidx/core/app/TaskStackBuilder#getPendingIntent(int,int))\nto receive a `PendingIntent` that includes the entire back stack. \n\n### Kotlin\n\n```kotlin\n// Create an Intent for the activity you want to start.\nval resultIntent = Intent(this, ResultActivity::class.java)\n// Create the TaskStackBuilder.\nval resultPendingIntent: PendingIntent? = TaskStackBuilder.create(this).run {\n // Add the intent, which inflates the back stack.\n addNextIntentWithParentStack(resultIntent)\n // Get the PendingIntent containing the entire back stack.\n getPendingIntent(0,\n PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)\n}\n```\n\n### Java\n\n```java\n// Create an Intent for the activity you want to start.\nIntent resultIntent = new Intent(this, ResultActivity.class);\n// Create the TaskStackBuilder and add the intent, which inflates the back\n// stack.\nTaskStackBuilder stackBuilder = TaskStackBuilder.create(this);\nstackBuilder.addNextIntentWithParentStack(resultIntent);\n// Get the PendingIntent containing the entire back stack.\nPendingIntent resultPendingIntent =\n stackBuilder.getPendingIntent(0,\n PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);\n```\n\nIf necessary, you can add arguments to `Intent` objects in the stack by calling\n[`TaskStackBuilder.editIntentAt()`](/reference/androidx/core/app/TaskStackBuilder#editIntentAt(int)).\nThis is sometimes necessary to ensure that an activity in the back stack\ndisplays meaningful data when the user navigates to it.\n\nThen you can pass the `PendingIntent` to the notification as usual: \n\n### Kotlin\n\n```kotlin\nval builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {\n setContentIntent(resultPendingIntent)\n ...\n}\nwith(NotificationManagerCompat.from(this)) {\n notify(NOTIFICATION_ID, builder.build())\n}\n```\n\n### Java\n\n```java\nNotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);\nbuilder.setContentIntent(resultPendingIntent);\n...\nNotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);\nnotificationManager.notify(NOTIFICATION_ID, builder.build());\n```\n\nSet up a special activity PendingIntent\n---------------------------------------\n\nBecause a special activity that starts from a notification doesn't need a back\nstack, you can create the `PendingIntent` by calling\n[`getActivity()`](/reference/android/app/PendingIntent#getActivity(android.content.Context,%20int,%20android.content.Intent,%20int)).\nHowever, define the appropriate task options in the manifest.\n\n1. In your manifest, add the following attributes to the `\u003cactivity\u003e` element.\n\n\n [android:taskAffinity](/guide/topics/manifest/activity-element#aff)`=\"\"`\n :\n Combined with the\n [FLAG_ACTIVITY_NEW_TASK](/reference/android/content/Intent#FLAG_ACTIVITY_NEW_TASK)\n flag that you use in code, set this attribute blank to ensure\n this activity doesn't go into the app's default task. Any\n existing tasks that have the app's default affinity aren't\n affected.\n\n\n [android:excludeFromRecents](/guide/topics/manifest/activity-element#exclude)`=\"true\"`\n :\n Excludes the new task from the Recents screen so that the user\n can't accidentally navigate back to it.\n\n\n This is shown in the following example: \n\n ```xml\n \u003cactivity\n android:name=\".ResultActivity\"\n android:launchMode=\"singleTask\"\n android:taskAffinity=\"\"\n android:excludeFromRecents=\"true\"\u003e\n \u003c/activity\u003e\n ```\n2. Build and issue the notification:\n 1. Create an `Intent` that starts the [Activity](/reference/android/app/Activity).\n 2. Set the `Activity` to start in a new, empty task by calling [setFlags()](/reference/android/content/Intent#setFlags(int)) with the flags `FLAG_ACTIVITY_NEW_TASK` and [FLAG_ACTIVITY_CLEAR_TASK](/reference/android/content/Intent#FLAG_ACTIVITY_CLEAR_TASK).\n 3. Create a `PendingIntent` by calling `getActivity()`.\n\n\n This is shown in the following example: \n\n ### Kotlin\n\n ```kotlin\n val notifyIntent = Intent(this, ResultActivity::class.java).apply {\n flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK\n }\n val notifyPendingIntent = PendingIntent.getActivity(\n this, 0, notifyIntent,\n PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE\n )\n ```\n\n ### Java\n\n ```java\n Intent notifyIntent = new Intent(this, ResultActivity.class);\n // Set the Activity to start in a new, empty task.\n notifyIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK\n | Intent.FLAG_ACTIVITY_CLEAR_TASK);\n // Create the PendingIntent.\n PendingIntent notifyPendingIntent = PendingIntent.getActivity(\n this, 0, notifyIntent,\n PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE\n );\n ```\n3. Pass the `PendingIntent` to the notification as usual: \n\n ### Kotlin\n\n ```kotlin\n val builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {\n setContentIntent(notifyPendingIntent)\n ...\n }\n with(NotificationManagerCompat.from(this)) {\n notify(NOTIFICATION_ID, builder.build())\n }\n ```\n\n ### Java\n\n ```java\n NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);\n builder.setContentIntent(notifyPendingIntent);\n ...\n NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);\n notificationManager.notify(NOTIFICATION_ID, builder.build());\n ```\n\nFor more information about the various task options and how the back stack\nworks, see [Tasks and the back stack](/guide/components/activities/tasks-and-back-stack)."]]