Android - Notificações

UMA notificationé uma mensagem que você pode exibir ao usuário fora da IU normal do aplicativo. Quando você instrui o sistema a emitir uma notificação, ela primeiro aparece como um ícone na área de notificação. Para ver os detalhes da notificação, o usuário abre a gaveta de notificação. Tanto a área de notificação quanto a gaveta de notificação são áreas controladas pelo sistema que o usuário pode visualizar a qualquer momento.

Android Toast A classe fornece uma maneira prática de mostrar alertas aos usuários, mas o problema é que esses alertas não são persistentes, o que significa que o alerta pisca na tela por alguns segundos e depois desaparece.

Para ver os detalhes da notificação, você terá que selecionar o ícone que exibirá a gaveta de notificação com detalhes sobre a notificação. Ao trabalhar com o emulador com dispositivo virtual, você terá que clicar e arrastar para baixo a barra de status para expandi-la, que fornecerá os detalhes a seguir. Isso vai ser apenas64 dp alto e chamado de visão normal.

A forma expandida acima pode ter um Big Viewque terá detalhes adicionais sobre a notificação. Você pode adicionar até seis linhas adicionais na notificação. A captura de tela a seguir mostra essa notificação.

Criar e enviar notificações

Você tem uma maneira simples de criar uma notificação. Siga as etapas a seguir em seu aplicativo para criar uma notificação -

Etapa 1 - Criar Construtor de Notificação

A primeira etapa é criar um construtor de notificação usando NotificationCompat.Builder.build () . Você usará o Notification Builder para definir várias propriedades de notificação, como seus ícones pequenos e grandes, título, prioridade, etc.

NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)

Etapa 2 - Definir propriedades de notificação

Uma vez que você tenha Builder, você pode definir suas propriedades de Notificação usando o objeto Builder de acordo com sua necessidade. Mas isso é obrigatório para definir pelo menos o seguinte -

Um pequeno ícone, definido por setSmallIcon()
Um título, definido por setContentTitle()
Texto detalhado, definido por setContentText()

mBuilder.setSmallIcon(R.drawable.notification_icon);
mBuilder.setContentTitle("Notification Alert, Click Me!");
mBuilder.setContentText("Hi, This is Android Notification Detail!");

Você tem muitas propriedades opcionais que pode definir para sua notificação. Para saber mais sobre eles, consulte a documentação de referência para NotificationCompat.Builder.

Etapa 3 - Anexar ações

Esta é uma parte opcional e necessária se você deseja anexar uma ação à notificação. Uma ação permite aos usuários ir diretamente da notificação para umActivity em seu aplicativo, onde eles podem ver um ou mais eventos ou trabalhar mais.

A ação é definida por um PendingIntent contendo um Intentque inicia uma atividade em seu aplicativo. Para associar o PendingIntent a um gesto, chame o método apropriado de NotificationCompat.Builder . Por exemplo, se você deseja iniciar a Atividade quando o usuário clica no texto da notificação na gaveta de notificação, você adiciona o PendingIntent chamandosetContentIntent().

Um objeto PendingIntent ajuda você a executar uma ação em nome de seus aplicativos, geralmente mais tarde, sem se preocupar se o aplicativo está ou não em execução.

Recebemos ajuda do objeto stack builder que conterá uma pilha de retorno artificial para a Activity iniciada. Isso garante que a navegação para trás a partir da Activity conduza de seu aplicativo à tela inicial.

Intent resultIntent = new Intent(this, ResultActivity.class);
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
stackBuilder.addParentStack(ResultActivity.class);

// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT);
mBuilder.setContentIntent(resultPendingIntent);

Etapa 4 - Emita a notificação

Por fim, você passa o objeto Notification para o sistema chamando NotificationManager.notify () para enviar sua notificação. Certifique-se de ligarNotificationCompat.Builder.build()método no objeto construtor antes de notificá-lo. Este método combina todas as opções que foram definidas e retorna um novoNotification objeto.

NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    
// notificationID allows you to update the notification later on.
mNotificationManager.notify(notificationID, mBuilder.build());

A classe NotificationCompat.Builder

A classe NotificationCompat.Builder permite um controle mais fácil sobre todos os sinalizadores, bem como ajuda a construir os layouts de notificação típicos. A seguir estão alguns métodos importantes e usados com mais frequência disponíveis como parte da classe NotificationCompat.Builder.

Sr. Não.	Constantes e Descrição
1	Notification build() Combine todas as opções que foram definidas e retorne um novo objeto Notificação.
2	NotificationCompat.Builder setAutoCancel (boolean autoCancel) Definir este sinalizador fará com que a notificação seja automaticamente cancelada quando o usuário clicar nele no painel.
3	NotificationCompat.Builder setContent (RemoteViews views) Forneça um RemoteViews personalizado para usar em vez do padrão.
4	NotificationCompat.Builder setContentInfo (CharSequence info) Defina o texto grande no lado direito da notificação.
5	NotificationCompat.Builder setContentIntent (PendingIntent intent) Forneça um PendingIntent para enviar quando a notificação for clicada.
6	NotificationCompat.Builder setContentText (CharSequence text) Defina o texto (segunda linha) da notificação, em uma notificação padrão.
7	NotificationCompat.Builder setContentTitle (CharSequence title) Defina o texto (primeira linha) da notificação, em uma notificação padrão.
8	NotificationCompat.Builder setDefaults (int defaults) Defina as opções de notificação padrão que serão usadas.
9	NotificationCompat.Builder setLargeIcon (Bitmap icon) Defina o ícone grande que é mostrado no ticker e na notificação.
10	NotificationCompat.Builder setNumber (int number) Defina o número grande no lado direito da notificação.
11	NotificationCompat.Builder setOngoing (boolean ongoing) Defina se esta é uma notificação em andamento.
12	NotificationCompat.Builder setSmallIcon (int icon) Defina o ícone pequeno para usar nos layouts de notificação.
13	NotificationCompat.Builder setStyle (NotificationCompat.Style style) Adicione um estilo de notificação rico a ser aplicado no momento da construção.
14	NotificationCompat.Builder setTicker (CharSequence tickerText) Defina o texto que é exibido na barra de status quando a notificação chega pela primeira vez.
15	NotificationCompat.Builder setVibrate (long[] pattern) Defina o padrão de vibração a ser usado.
16	NotificationCompat.Builder setWhen (long when) Defina a hora em que o evento ocorreu. As notificações no painel são classificadas por este tempo.

Exemplo

O exemplo a seguir mostra a funcionalidade de uma notificação do Android usando um NotificationCompat.Builder Classe que foi introduzida no Android 4.1.

Degrau	Descrição
1	Você usará o Android Studio IDE para criar um aplicativo Android e nomeá-lo como tutorialspoint em um pacote com.example.notificationdemo .
2	Modifique o arquivo src / MainActivity.java e adicione o código para notificar (""), se o usuário clicar no botão, ele chamará o serviço de notificação do Android.
3	Crie um novo arquivo Java src / NotificationView.java , que será usado para exibir o novo layout como parte de uma nova atividade que será iniciada quando o usuário clicar em qualquer uma das notificações
4	Modifique o arquivo XML de layout res / layout / activity_main.xml para adicionar o botão Notificação no layout relativo.
5	Crie um novo arquivo XML de layout res / layout / notification.xml . Isso será usado como arquivo de layout para uma nova atividade que começará quando o usuário clicar em qualquer uma das notificações.
6	Não há necessidade de alterar as constantes de string padrão. Android Studio cuida das constantes de string padrão
7	Execute o aplicativo para iniciar o emulador Android e verifique o resultado das alterações feitas no aplicativo.

A seguir está o conteúdo do arquivo de atividade principal modificado src/com.example.notificationdemo/MainActivity.java. Este arquivo pode incluir cada um dos métodos fundamentais do ciclo de vida.

package com.example.notificationdemo;

import android.app.Activity;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.support.v4.app.NotificationCompat;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends Activity {
   Button b1;
   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      b1 = (Button)findViewById(R.id.button);
      b1.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View v) {
            addNotification();
         }
      });
   }

   private void addNotification() {
      NotificationCompat.Builder builder =
         new NotificationCompat.Builder(this)
         .setSmallIcon(R.drawable.abc)
         .setContentTitle("Notifications Example")
         .setContentText("This is a test notification");

      Intent notificationIntent = new Intent(this, MainActivity.class);
      PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent,
         PendingIntent.FLAG_UPDATE_CURRENT);
      builder.setContentIntent(contentIntent);

      // Add as notification
      NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
      manager.notify(0, builder.build());
   }
}

A seguir estará o conteúdo de res/layout/notification.xml arquivo -

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="vertical"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent" >
   
   <TextView
      android:layout_width="fill_parent"
      android:layout_height="400dp"
      android:text="Hi, Your Detailed notification view goes here...." />
</LinearLayout>

A seguir está o conteúdo do arquivo de atividade principal modificado src/com.example.notificationdemo/NotificationView.java.

package com.example.notificationdemo;

import android.os.Bundle;
import android.app.Activity;

public class NotificationView extends Activity{
   @Override
   public void onCreate(Bundle savedInstanceState){
      super.onCreate(savedInstanceState);
      setContentView(R.layout.notification);
   }
}

A seguir estará o conteúdo de res/layout/activity_main.xml arquivo -

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:paddingBottom="@dimen/activity_vertical_margin"
   android:paddingLeft="@dimen/activity_horizontal_margin"
   android:paddingRight="@dimen/activity_horizontal_margin"
   android:paddingTop="@dimen/activity_vertical_margin"
   tools:context="MainActivity">
   
   <TextView
      android:id="@+id/textView1"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Notification Example"
      android:layout_alignParentTop="true"
      android:layout_centerHorizontal="true"
      android:textSize="30dp" />
      
   <TextView
      android:id="@+id/textView2"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Tutorials point "
      android:textColor="#ff87ff09"
      android:textSize="30dp"
      android:layout_below="@+id/textView1"
      android:layout_centerHorizontal="true"
      android:layout_marginTop="48dp" />
      
   <ImageButton
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:id="@+id/imageButton"
      android:src="@drawable/abc"
      android:layout_below="@+id/textView2"
      android:layout_centerHorizontal="true"
      android:layout_marginTop="42dp" />
      
   <Button
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Notification"
      android:id="@+id/button"
      android:layout_marginTop="62dp"
      android:layout_below="@+id/imageButton"
      android:layout_centerHorizontal="true" />
      
</RelativeLayout>

A seguir estará o conteúdo de res/values/strings.xml para definir duas novas constantes -

<?xml version="1.0" encoding="utf-8"?>
<resources>
   <string name="action_settings">Settings</string>
   <string name="app_name">tutorialspoint </string>  
</resources>

A seguir está o conteúdo padrão de AndroidManifest.xml -

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.notificationdemo" >
   
   <application
      android:allowBackup="true"
      android:icon="@drawable/ic_launcher"
      android:label="@string/app_name"
      android:theme="@style/AppTheme" >
      
      <activity
         android:name="com.example.notificationdemo.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>
      
      <activity android:name=".NotificationView"
         android:label="Details of notification"
         android:parentActivityName=".MainActivity">
         <meta-data
         android:name="android.support.PARENT_ACTIVITY"
         android:value=".MainActivity"/>
      </activity>
      
   </application>
</manifest>

Vamos tentar executar o seu tutorialspointinscrição. Suponho que você tenha criado o seuAVDao fazer a configuração do ambiente. Para executar o APP do Android Studio, abra um dos arquivos de atividade do seu projeto e clique no ícone Executar na barra de ferramentas. O Android Studio instala o aplicativo em seu AVD e o inicia e, se tudo estiver certo com sua configuração e aplicativo, ele será exibido na janela do emulador seguinte

Agora clique button, você verá na parte superior uma mensagem "Alerta de nova mensagem!" será exibido momentaneamente e depois disso você terá a seguinte tela com um pequeno ícone no canto superior esquerdo.

Agora vamos expandir a visualização, dê um clique longo no ícone pequeno, depois de um segundo ele exibirá informações de data e este é o momento em que você deve arrastar a barra de status para baixo sem soltar o mouse. Você verá que a barra de status se expandirá e terá a seguinte tela -

Notificação do Big View

O fragmento de código a seguir demonstra como alterar a notificação criada no fragmento anterior para usar o estilo de visualização grande da Caixa de entrada. Vou atualizar o método de modificação displayNotification () para mostrar esta funcionalidade -

protected void displayNotification() {
   Log.i("Start", "notification");

   /* Invoking the default notification service */
   NotificationCompat.Builder  mBuilder = new NotificationCompat.Builder(this);
   
   mBuilder.setContentTitle("New Message");
   mBuilder.setContentText("You've received new message.");
   mBuilder.setTicker("New Message Alert!");
   mBuilder.setSmallIcon(R.drawable.woman);
   
   /* Increase notification number every time a new notification arrives */
   mBuilder.setNumber(++numMessages);
   
   /* Add Big View Specific Configuration */
   NotificationCompat.InboxStyle inboxStyle = new NotificationCompat.InboxStyle();
   
   String[] events = new String[6];
   events[0] = new String("This is first line....");
   events[1] = new String("This is second line...");
   events[2] = new String("This is third line...");
   events[3] = new String("This is 4th line...");
   events[4] = new String("This is 5th line...");
   events[5] = new String("This is 6th line...");
   
   // Sets a title for the Inbox style big view
   inboxStyle.setBigContentTitle("Big Title Details:");
   
   // Moves events into the big view
   for (int i=0; i < events.length; i++) {
      inboxStyle.addLine(events[i]);
   }
   
   mBuilder.setStyle(inboxStyle);
   
   /* Creates an explicit intent for an Activity in your app */
   Intent resultIntent = new Intent(this, NotificationView.class);
   
   TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
   stackBuilder.addParentStack(NotificationView.class);

   /* Adds the Intent that starts the Activity to the top of the stack */
   stackBuilder.addNextIntent(resultIntent);
   PendingIntent resultPendingIntent =stackBuilder.getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT);
   
   mBuilder.setContentIntent(resultPendingIntent);
   mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
   
   /* notificationID allows you to update the notification later on. */
   mNotificationManager.notify(notificationID, mBuilder.build());
}

Agora, se você tentar executar seu aplicativo, encontrará o seguinte resultado na forma expandida da visualização -

↰ Previous page Next page ↱