Démarrer une activité à partir d'une notification

Lorsque vous démarrez une activité à partir d'une notification, vous devez conserver les expérience de navigation attendue. Appuyer sur le bouton Retour doit faire revenir l'utilisateur le flux de travail normal de l'application jusqu'à l'écran d'accueil, puis en ouvrant la page l'écran doit afficher l'activité en tant que tâche distincte. Pour conserver cette navigation démarrer l'activité dans une nouvelle tâche.

L'approche de base pour définir le comportement d'appui sur une notification est décrite dans la section Créer un tableau de bord notification. Cette page explique comment configurer un PendingIntent pour votre l'action d'une notification afin qu'elle crée une tâche nouvelle et une nouvelle pile. Comment procéder ? dépend du type d'activité que vous démarrez:

Activité régulière

Il s'agit d'une activité qui fait partie du flux d'expérience utilisateur normal de votre application. Quand ? l'utilisateur arrive dans l'activité à partir de la notification, la nouvelle tâche doit inclure une pile "Retour" complète, ce qui permet à l'utilisateur d'appuyer sur le bouton Retour pour naviguer dans la hiérarchie de l'application.

Activité spéciale

L'utilisateur ne voit cette activité que si elle a été lancée à partir d'une notification. Dans un cette activité étend l'UI des notifications en fournissant des informations dans la notification elle-même. Cette activité n'a pas besoin pile "Retour".

Configurer un PendingIntent d'activité standard

Pour démarrer une activité standard à partir de la notification, configurez le PendingIntent avec TaskStackBuilder afin de créer une pile "Retour" comme suit.

Définir la hiérarchie des activités de votre application

Définissez la hiérarchie naturelle de vos activités en ajoutant le paramètre android:parentActivityName à chaque <activity> dans le fichier manifeste de votre application. Consultez l'exemple suivant :

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

Créer un PendingIntent avec une pile "Retour"

Pour démarrer une activité qui inclut une pile "Retour" d'activités, créez une une instance de TaskStackBuilder et appeler addNextIntentWithParentStack(), en lui transmettant le Intent l'activité que vous souhaitez commencer.

Tant que vous définissez l'activité parente pour chaque activité, comme décrit auparavant, vous pouvez appeler getPendingIntent() pour recevoir un PendingIntent incluant l'intégralité de la pile "Retour".

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

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

Si nécessaire, vous pouvez ajouter des arguments aux objets Intent de la pile en appelant TaskStackBuilder.editIntentAt() Cela est parfois nécessaire pour s'assurer qu'une activité dans la pile "Retour" affiche des données pertinentes lorsque l'utilisateur y accède.

Vous pouvez ensuite transmettre PendingIntent à la notification comme d'habitude:

val builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {
    setContentIntent(resultPendingIntent)
    ...
}
with(NotificationManagerCompat.from(this)) {
    notify(NOTIFICATION_ID, builder.build())
}

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);
builder.setContentIntent(resultPendingIntent);
...
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(NOTIFICATION_ID, builder.build());

Configurer un PendingIntent d'activité spéciale

Parce qu'une activité spéciale qui commence par une notification n'a pas besoin d'être posée la pile, vous pouvez créer le PendingIntent en appelant getActivity() Toutefois, définissez les options de tâche appropriées dans le fichier manifeste.

1. Dans votre fichier manifeste, ajoutez les attributs suivants au fichier Élément <activity>.

   android:taskAffinity=""

   Combiné avec le FLAG_ACTIVITY_NEW_TASK que vous utilisez dans le code, laissez cet attribut vide pour vous assurer cette activité n'entre pas dans la tâche par défaut de l'application. N'importe quelle valeur les tâches existantes qui présentent l'affinité par défaut de l'application concernés.

   android:excludeFromRecents="true"

   Exclut la nouvelle tâche de l'écran "Recents" (Éléments récents) afin que l'utilisateur vous ne pourrez pas y revenir accidentellement.

   Ce processus est illustré dans l'exemple suivant :

   <activity
       android:name=".ResultActivity"
       android:launchMode="singleTask"
       android:taskAffinity=""
       android:excludeFromRecents="true">
   </activity>

2. Créez et émettez la notification: <ph type="x-smartling-placeholder">
   </ph>
   1. Créez un élément Intent qui lance le Activity
   2. Définissez Activity pour qu'il démarre dans une nouvelle tâche vide en Appel en cours setFlags() avec les options FLAG_ACTIVITY_NEW_TASK et FLAG_ACTIVITY_CLEAR_TASK
   3. Créez un PendingIntent en appelant getActivity()

   Ce processus est illustré dans l'exemple suivant :

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

3. Transmettez PendingIntent à la notification comme d'habitude:

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

Pour en savoir plus sur les différentes options de tâches et sur la façon dont la pile "Retour" consultez la section Tâches et pile "Retour".