Iniciar uma atividade a partir de uma notificação

Ao iniciar uma atividade a partir de uma notificação, é necessário preservar a senha do usuário experiência de navegação esperada. Tocar no botão "Voltar" precisa levar o usuário de volta pelo fluxo de trabalho normal do app para a tela inicial e abrir a guia tela precisa mostrar a atividade como uma tarefa separada. Para preservar a navegação experiência, inicie a atividade em uma nova tarefa.

A abordagem básica para definir o comportamento de toque para sua notificação está descrita em Crie um notificação. Nesta página, descrevemos como configurar PendingIntent para sua para criar uma nova tarefa e voltar pilha. Como fazer isso depende do tipo de atividade que você está iniciando:

Atividade comum

Essa é uma atividade que existe como parte do fluxo de UX normal do app. Quando o usuário chegar na atividade a partir da notificação, a nova tarefa deverá incluir uma backstack completa, permitindo que o usuário toque no botão "Voltar" para navegar para cima na hierarquia de apps.

Atividade especial

O usuário só verá essa atividade se ela for iniciada a partir de uma notificação. Em um essa atividade estende a interface de notificação, fornecendo informações que é difícil de exibir na própria notificação. Essa atividade não precisa da back stack.

Configurar uma atividade comum PendingIntent

Para iniciar uma atividade regular pela notificação, configure o PendingIntent usando TaskStackBuilder para que ele crie uma nova backstack, conforme mostrado a seguir.

Definir a hierarquia de atividades do app

Defina a hierarquia natural de suas atividades adicionando o android:parentActivityName para cada <activity> no arquivo de manifesto do app. Confira este exemplo:

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

Criar um PendingIntent com uma pilha de retorno

Para iniciar uma atividade que inclua uma backstack de atividades, crie uma instância de TaskStackBuilder e chamar addNextIntentWithParentStack(), passando o Intent do atividade que deseja iniciar.

Contanto que você defina a atividade mãe para cada atividade conforme descrito antes, chame getPendingIntent() para receber um PendingIntent que inclui toda a backstack.

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

Se necessário, é possível adicionar argumentos a objetos Intent na pilha chamando TaskStackBuilder.editIntentAt(). Às vezes, isso é necessário para garantir que uma atividade na backstack exibe dados significativos quando o usuário navega até eles.

Em seguida, transmita o PendingIntent para a notificação normalmente:

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

Configurar uma atividade especial PendingIntent

Porque uma atividade especial que começa a partir de uma notificação não precisa de um retorno pilha, crie a PendingIntent chamando getActivity(). No entanto, defina as opções de tarefa apropriadas no manifesto.

1. No manifesto, adicione os seguintes atributos ao <activity>.

   android:taskAffinity=""

   Combinado com o FLAG_ACTIVITY_NEW_TASK usada no código, defina esse atributo em branco para garantir essa atividade não vai para a tarefa padrão do app. Qualquer um tarefas existentes que têm a afinidade padrão do app não são afetadas.

   android:excludeFromRecents="true"

   Exclui a nova tarefa da tela "Recentes" para que o usuário não volte a ela sem querer.

   Isso é mostrado neste exemplo:

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

2. Crie e emita a notificação:
   1. Crie um Intent que inicie o Activity.
   2. Defina o Activity para iniciar em uma tarefa nova e vazia ao chamar setFlags() com as sinalizações FLAG_ACTIVITY_NEW_TASK e FLAG_ACTIVITY_CLEAR_TASK.
   3. Crie um PendingIntent chamando getActivity().

   Isso é mostrado neste exemplo:

   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. Transmita o PendingIntent para a notificação como de costume:

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

Para mais informações sobre as várias opções de tarefas e como a backstack funciona, consulte Tarefas e a backstack.