O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Iniciar uma atividade a partir de uma notificação

Ao iniciar uma atividade em uma notificação, é preciso preservar a experiência de navegação que o usuário espera. O toque em Voltar deve levar o usuário de volta no fluxo de trabalho normal do app até a tela inicial, e a abertura da tela Recentes deve mostrar a atividade como uma tarefa separada. Para preservar essa experiência de navegação, inicie a atividade em uma nova tarefa.

Embora a abordagem básica para definir o comportamento de toque da notificação esteja descrita em Criar uma notificação, esta página descreve como configurar um PendingIntent para a ação da notificação, para que ela crie uma nova tarefa e uma pilha de retorno. No entanto, a maneira exata de fazer isso depende do tipo da atividade iniciada:

Atividade comum
Essa é uma atividade que existe como parte do fluxo de UX normal do app. Assim, quando o usuário chega até a atividade a partir da notificação, a nova tarefa precisa incluir uma pilha de retorno completa, permitindo que ele pressione Voltar e navegue na hierarquia do app.
Atividade especial
O usuário só verá essa atividade se ela for iniciada a partir de uma notificação. De certa forma, essa atividade estende a IU da notificação, disponibilizando informações difíceis de serem exibidas na própria notificação. Por isso, não é necessário incluir uma pilha de retorno nesse caso.

Configurar uma atividade normal PendingIntent

Para iniciar uma "atividade normal" a partir da sua notificação, configure o PendingIntent usando TaskStackBuilder para que ele crie uma nova pilha de retorno, conforme mostrado a seguir.

Definir a hierarquia de atividades do app

Defina a hierarquia natural das suas atividades adicionando o atributo android:parentActivityName a cada elemento <activity> no arquivo de manifesto do app. Por 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 pilha de retorno de atividades, é necessário criar uma instância de TaskStackBuilder e chamar addNextIntentWithParentStack(), passando a ele a Intent da atividade que você quer iniciar.

Contanto que você tenha definido a atividade pai de cada atividade, conforme descrito acima, pode chamar getPendingIntent() para receber uma PendingIntent que inclui toda a pilha de retorno.

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

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

Se necessário, você pode adicionar argumentos a objetos Intent na pilha chamando TaskStackBuilder.editIntentAt(). Em alguns casos, isso é necessário para garantir que uma atividade na pilha de retorno mostre dados significativos quando o usuário navegar até ela.

Em seguida, você pode passar PendingIntent para a notificação como de costume:

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

Configurar uma atividade especial PendingIntent

Como uma "atividade especial" iniciada a partir de uma notificação não precisa de uma pilha de retorno, é possível criar PendingIntent chamando getActivity(). No entanto, verifique se você definiu as opções de tarefa apropriadas no manifesto.

  1. No manifesto, adicione os atributos a seguir ao elemento <activity>.
    android:taskAffinity=""
    Combinada com a sinalização FLAG_ACTIVITY_NEW_TASK que você usará no código, a configuração desse atributo em branco garante que essa atividade não entre na tarefa padrão do app. As tarefas existentes que tiverem a afinidade padrão do app não serão afetadas.
    android:excludeFromRecents="true"
    Exclui a nova tarefa de Recentes, para que o usuário não navegue por engano de volta a ela.

    Por exemplo:

        <activity
            android:name=".ResultActivity"
            android:launchMode="singleTask"
            android:taskAffinity=""
            android:excludeFromRecents="true">
        </activity>
        
  2. Compilar e emitir a notificação:
    1. Crie uma Intent que inicie a Activity.
    2. Defina a Activity para iniciar em uma tarefa nova e vazia, chamando setFlags() com os sinalizadores FLAG_ACTIVITY_NEW_TASK e FLAG_ACTIVITY_CLEAR_TASK.
    3. Crie um PendingIntent chamando getActivity().

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

    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
        );
        
  3. Em seguida, passe o PendingIntent para a notificação normalmente:

    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 tarefa e sobre como a pilha de retorno funciona, leia Tarefas e pilha de retorno. Para ver o exemplo de código que usa notificações, consulte o Exemplo de notificações do Android (em inglês).