Uma notificação de sistema possibilita que seu
aplicativo mantenha o usuário informado sobre eventos, como uma nova mensagem
de um chat ou um evento de calendário. Pense em notificações como um novo canal
que alerta o usuário para importantes eventos enquanto eles ocorrerem, ou um
registro que narra eventos enquanto o usuário não está prestando atenção.
O layout de
uma notificação é mostrado abaixo:
No mínimo,
todas as notificações possuem um layout base, incluindo:
- Ícone de notificação do pedido de envio, ou a foto do remetente.
- Título de notificação e mensagem.
- Uma hora ou data.
- Um ícone secundário para identificar a aplicação de envio quando a imagem do remetente for mostrada no ícone principal.
Notificações
também são conhecidas como “Push Notifications”.
Criando notificações simples
A partir da API 17 (Android 4.2, Jelly Bean),
as notificações mudaram. Até está versão, as notificações eram bem mais
simples. A partir da API 17, as notificações passaram a ter mais de um ícone, e
à mostrar mais informações.
Para mostrar tais mudanças, criaremos um
exemplo de notificações em Android, que utiliza basicamente duas telas e uma
classe utilitária de Notificações.
Na primeira tela, temos basicamente a chamada
para a classe utilitária de notificações, que de fato cria a notificação.
Quando a notificação for clicada pelo usuário, chamaremos a segunda tela. Logo,
teremos a tela que chama a notificação, e a tela que é chamada pelo clique da
notificação. E entre elas, uma classe que implementa a chamada da notificação.
Em nossa
tela principal, temos:
No evento onCreate(),
preparamos o título, mensagem e tickerText da notificação, e chamamos o método createNotification(). Nele, verificamos a versão da nossa API, e
chamamos o utilitário NotificationHelper,
e o método que implementa a notificação para a versão corrente.
O quarto argumento do método createsNotification() é uma Activity. Repare que no método createsNotification() esta Activity é inserida em uma Intent, que por sua vez, nos métodos da
classe NotificationHelper, será
utilizada para redirecionar o fluxo da nossa aplicação. Ou seja, quando
clicarmos na notificação, será aberta esta Activity
(que é o 4º argumento citado acima).
Isso será melhor explicado ao longo deste
capítulo.
Parte da implementação da NotificationHelper é mostrada abaixo:
O método createSimpleNotification()
cria notificações simples (mais comumente usado em API’s inferiores à 17).
Notificações simples possuem apenas um ícone, um título, um texto de
notificação, e o horário em que ela foi chamada.
Repare como este método é personalizado:
dependendo da API do dispositivo Android, a criação da uma notificação é feita
de forma específica. Porém, alguns método como setContentTitle(), setContentText(),
setSmallIcon() e setContentIntent() são comuns à todas as API’s. E, é claro, a PendingIntent, que é o componente que
nos redirecionará para outra tela quando clicarmos na notificação.
Podemos ver na nossa NotificationHelper uma constante chamada NOTIFICATION_ID (que é a constante que identificará o ID da nossa
notificação), um atributo chamado mBigText
(que será usado mais adiante), e o método já citado acima.
A chamada do método createSimpleNotification() gera o seguinte resultado:
Ao clicarmos na notificação, seremos
redirecionado à tela ExecuteNotificationActivity.
É neste tela que cancelaremos a notificação acima (senão ela será mostrada
eternamente).
Eis a tela ExecuteNotificationActivity:
Ela apenas cancela a notificação, e seta um
texto na tela.
O método de cancelamento de uma notificação
(que é implementado na NotificationHelper)
é mostrado abaixo:
Este método funciona para qualquer tipo de
notificação (“simples” ou “sofisticada”), e para qualquer tipo de API.
Já o método createImprovedNotification(),
que cria uma notificação “sofisticada”, implementa as novas propriedades de notificações
que foram introduzidas na versão 4.2. Dentre elas, podemos citar setLargeIcon(), setProgress() e o método Notification.InboxStyle,
que é completado através do método setStyle().
Adicionando ícones às notificações
Para adicionar um ícone à uma notificação,
precisamos declarar um NotificationBuilder,
e setar as propriedades setSmallIcon()
e setLargeIcon(). A primeira recebe
como argumento um int, que representa
um id de Drawable. A segunda recebe
como argumento um Bitmap.
Notificações sofisticadas
Executando agora o método createImprovedNotification(), também constante na NotificationHelper, criamos uma
notificação que só rodará em dispositivos Android com API igual ou superior à
4.2.
Podemos notar neste método que utilizamos a Notification.InboxStyle, e colocamos
nela algumas linhas de texto. O resultado da execução deste método é mostrado
abaixo, onde temos duas imagens: na primeira, temos a notificação com as linhas
mostradas, e na segunda temos estas linhas minimizadas.
Para minimizar as linhas, basta utilizarmos um
double touchscreen, onde um dos dedos ficaria acima das linhas, e o outro, como
um compasso, empurrariam-nas para cima.
Esta minimização é mostrada logo abaixo.
Podemos ver abaixo, também, um ícone grande e
um ícone pequeno, além do estilo e da barra de progresso, que é chamada pelo
método: builder.setProgress(0, 0, true)
Com certeza, nossa notificação se tornou bem
mais sofisticada!
Em nosso próximo exemplo, também usaremos uma
notificação sofisticada. Porém, aprofundaremos mais um pouco o uso da
propriedade builder.setProgress().
Simulando um download
Agora, será mostrado um outro exemplo de
notificação. Neste exemplo, simularemos o download de uma imagem. Ao fim deste
“download”, será mudado o título da notificação, e também a barra de progresso.
Podemos ver que a lógica toda fica na Thread parelela: ao fim do processamento
simulado pelo comando For e
pelocomando Thread.sleep(), atualizamos
o conteúdo da notificação (setContextText())
e seu progresso (setProgress()).
Abaixo é mostrada a notificação em “processo de
download”, e a notificação “ao fim do download”.
Notificações com botões
Por fim, será mostrado como incluir botões em uma notificação.
Para isto, basicamente precisamos utilizar a
propriedade addAction() do Notification.Builder.
Acima vemos que a propriedade addAction() é utilizada duas vezes, para
incluir os botões “View” e “Edit”. A primeira possui um ícone
(R.drawable.ic_google), e a segunda, não possui (então setamos seu atributo com
o valor “0”).
O último argumento desta propriedade é a Intent que abriremos caso os botões
sejam clicados. Repare que podemos abrir três diferentes Intent’s com esta notificação: clicando nela, clicando no botão
“View”, e clicando no botão “Edit”.
O que podemos notar acima, também, é a inclusão
de um som quando a notificação tocar, através do propriedade setSound().
Abaixo do comentário “Calls the notification”
temos três diferentes construtores de “notification”. Abaixo demonstramos três
diferentes execuções, com cada um dos construtores:
- Notification notification = builder.build();
- Notification
notification = builder.setStyle(new
Notification.BigTextStyle().bigText(
mBigText.toString())).build(); - Notification
notification = new
Notification.BigPictureStyle(builder).bigPicture(
BitmapFactory.decodeResource(context.getResources(), R.drawable.ic_google)).build();
Por fim, repare que em quase todos os exemplos
deste capítulo utilizamos a tag notification.vibrate().
Com ela, podemos fazer o celular vibrar.
Para isto, precisamos declarar uma tag
específica em nosso AndroidManifest.xml,
como é mostrado abaixo.
E isto é tudo! Com este capítulo, conseguimos
criar quase todos os tipos de notificações que uma aplicação em Android vá
necessitar.
-----
Caso alguém tenha uma dúvida, crítica ou sugestão, sinta-se à vontade.