Criando notificao es no Android

Sempre interessante alertar o usurio sobre alguma atualizao de um determinado app, pois

nem sempre o usurio est de posse do aparelho celular. Para isso, devemos criar notificaes

para alertar o usurio sobre algum evento.

Criar projeto no ADT: prjNotificacao

O activity_main.xml dever semelhante ao apesentado a seguir:

Renomear o pacote principal para com.notificacao.view.

Criar classe com.notificacao.view.MensagemAlerta:

public class MensagemAlerta { private CharSequence title; private CharSequence body; private CharSequence subTitle; public MensagemAlerta(CharSequence title, CharSequence body, CharSequence subTitle) { this.title = title; this.body = body; this.subTitle = subTitle; } public CharSequence getTitle() { return title; } public void setTitle(CharSequence title) { this.title = title; } public CharSequence getBody() { return body; }

public void setBody(CharSequence body) { this.body = body; } public CharSequence getSubTitle() { return subTitle; } public void setSubTitle(CharSequence subTitle) { this.subTitle = subTitle; }

}

A classe com. notificacao.view.MainActivity, iremos deixar como a seguir:

package com.noticacao.prjnotificacao;

import android.app.Activity;

import android.app.Notification;

import android.app.NotificationManager;

import android.app.PendingIntent;

import android.content.Context;

import android.content.Intent;

import android.net.Uri;

import android.os.Bundle;

import android.provider.MediaStore.Audio;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

public class MainActivity extends Activity implements OnClickListener {

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

Button button = (Button) findViewById(R.id.btnNotificacao);

button.setOnClickListener(this);

}

@Override

public void onClick(View v) {

// 1 parmetro - titulo

// 2 parmetro - corpo da mensagem

// 3 parmetro - subtitulo

criarNotificacao(getApplicationContext(), new MensagemAlerta(

"Ttulo da noficao", "Corpo da notificao",

"SubTtulo da notificao"), MainActivity.class);

}

// Exibe a notifico

protected void criarNotificacao(Context context,

MensagemAlerta messagesAlerts, Class activity) {

// Recupera o servio do NotificationManager

NotificationManager notificationManager = (NotificationManager)

getSystemService(NOTIFICATION_SERVICE);

Notification notificaction = new Notification(R.drawable.ic_launcher,

messagesAlerts.getTitle(), System.currentTimeMillis());

notificaction.sound =

Uri.withAppendedPath(Audio.Media.INTERNAL_CONTENT_URI, "6");

// notification.sound = Uri.parse("file:///sdcard/recording33490.3gpp");

// Flag que vibra e emite um sinal sonoro at o usurio clicar na

// notificao

notificaction.flags |= Notification.FLAG_INSISTENT;

// Flag utilizada para remover a notificao da toolbar quando usurio

// tiver clicado nela.

notificaction.flags |= Notification.FLAG_AUTO_CANCEL;

// PendingIntent para executar a Activity se o usurio selecionar a

// notifico

PendingIntent p = PendingIntent.getActivity(this, 0,

new Intent(this.getApplicationContext(), MainActivity.class),

0);

// Informaes

notificaction.setLatestEventInfo(this, messagesAlerts.getSubTitle(),

messagesAlerts.getBody(), p);

// espera 100ms e vibra por 1000ms, depois espera por 1000 ms e vibra

// por

// 1000ms.

notificaction.vibrate = new long[] { 100, 1000, 1000, 1000 };

// id que identifica esta notifio

notificationManager.notify(R.string.app_name, notificaction); }

}

Rodar o projeto na mquina virtual.

Criando servios no Android

Um servio um componente da aplicao que pode realizar operaes de longa durao em

modo background e no prove interface de usurio. Outro componente de aplicao pode iniciar o

servio e ele vai continuar rodando no background mesmo que o usurio mude para outra

aplicao. Adicionalmente, um componente pode fazer o bind para um servio para interagir com

ele e inclusive realizar processos de comunicao entre processo (IPC na sigla em ingls que

significa Inter-Process communication). Por exemplo, um servio pode querer manusear

transaes de rede, tocar msica, fazer uma troca de arquivo (processo de I/O) ou interagir com

um content provider, tudo em modo background.

Um servio essencialmente tem duas formas:

Started

Um servio est iniciado quando um componente de aplicao (como uma atividade) inicia-o

chamando startService(). Uma vez iniciado, o servio pode rodar em modo background

indefinidamente, mesmo que o componente que o iniciou seja destrudo. Usualmente, um servio

iniciado realiza uma tarefa nica e no retorna o resultado para quem o chamou. Por exemplo,

voc pode fazer o download ou upload de arquivos em uma rede. Quando a operao for

terminada, o servio termina sem a necessidade de interao do usurio.

Bound

Um servio est bound quando um componente de aplicao faz um bind para ele chamando

bindService(). Um servio bound oferece uma interface cliente servidor que permite ao

componente interagir com o servio, enviar requisies, obter resulados e mesmo fazer alguns

processos com comunicao entre processos (IPC). Um servio bound roda apenas enquanto o

componente da aplicao estiver ligado a ele. Multiplos componentes podem ser ligados a um

servio ao mesmo tempo mas quando todos eles se desligarem dele, o servio ser destrudo.

Apesar dessa documentao geralmente discutir esses dois tipos de servio separadamente, seu

servio pode trabalhar das duas formas - ele pode ser inicializado (para rodar indefinidamente) e

tambm permitir que seja feito um bind para ele. simplesmente uma questo de se voc

implementar dois mtodos callback(): onStartCommand() para permitir que os componentes o

inicializem e onBind() para permitir que seja feito um bind para ele.

Independente de se a sua aplicao foi iniciada, ligada a uma atividade ou ambas maneiras,

qualquer componente de aplicao pode usar o servio (mesmo de uma aplicao separada) da

mesma maneira que qualquer componente pode usar uma atividade - quando iniciada por um

Intent. Contudo, voc pode declarar o servio como privado no arquivo de manifesto e bloquear o

acesso a ele a partir de outras aplicaes.

Cuidado: Um servio roda na thread principal do processo hospedeiro - o servio no cria seu

prprio thread e no roda em um processo separado (a no ser que voc especifique em

contrrio). Isso significa que se seu servio est usando muita CPU ou bloqueando operaes

(como playback de MP3 ou servios de rede), voc deve criar uma nova thread dentro do servio

para fazer o trabalho. Usando uma thread separada, voc reduzir o risco de erros do tipo

Application Not Responding (ANR) e a thread principal da aplicao pode remanescer dedicada

exclusivamente com a interao do usurio em suas atividades.

Devo usar um servio ou uma thread?

Um servio simplesmente um componente que roda em background mesmo quando o usurio

no est interagindo com a aplicao. Ou seja, voc s dever criar um servio se realmente

necessitar.

Se voc precisar realizar trabalhos fora da thread principal, mas apenas enquanto o usurio est

interagindo com sua aplicao, ento voc deve provavelmente criar uma nova thread e no um

servio. Por exemplo, se voc quer tocar msica mas apenas enquanto a atividade estiver

rodando, voc deve criar uma thread em onCreate(), inici-la com onStart() e ento parar usando

onStop(). Considere tambm usar AsyncTask ou HandlerThread ao invs da classe tradicional

Thread. Quando falarmos de processos e threads esse conceito ficar mais claro.

Lembre-se que se voc usar um servio ele vai rodar na thread principal da sua aplicao por

default, ento voc deve criar uma nova thread dentro do servio se ele realiza operaes

intensivas e que bloqueiam outras operaes.

O bsico

Para criar um servio, voc deve criar uma subclasse de Service (ou uma de suas subclasses

existentes). Em sua implementao, voc precisar fazer o override de algums mtodos callback

para manusear aspectos chaves de seu ciclo de vida e prover um mecanismo para componentes

fazerem o bind a ele, se apropriado. Os mais importantes mtodos callback que voc dever

fazer o override so:

onStartCommand()

O sistema chama esse mtodo quando outro componente, como uma atividade, faz a requisio

para que o servio seja iniciado chamando startService(). Uma vez que esse mtodo

executado, o servio iniciado e pode roda em background indefinidamente. Se voc

implementar isso sua responsabilidade parar o servio uma vez que o trabalho est feito,

chamando stopSelf() ou stopService(). Se voc quiser prover apenas o binding, no necessrio

implementar esse mtodo.

onBind()

O sistema chama o mtodo quando outro componente quer fazer o bind com o servio (para

realizar um Remote Procedure Call - RPC) chamando bindService(). Em sua implementao

desse mtodo voc deve prover uma interface que os clientes usaro para comunicar com o

servio, retornando um IBinder. Voc deve sempre implementar esse mtodo mas se voc no

quer permitir o binding, ento deve retornar null.

onCreate()

O sistema chama esse mtodo quando o servio criado pela primeira vez, para realizar

procedimentos de configurao iniciais (antes mesmo de chamar ou o onStartCommand() ou

onBind()). Se o servio j est rodando, esse mtodo no chamado.

onDestroy()

O sistema chama esse mtodo quando o servio no est mais sendo usado e est sendo

destrudo. Seu servio deve implementar esse mtodo para limpar os recursos como threads,

listeners registrados, receivers, etc. Esse a ltima chamada que o servio recebe.

Se um componente inicia um servio chamando startService() (que resulta em uma chamada

para onStartCommand()), ento o servio permanece rodando at ser parado com stopSelf() ou

outro componente chamando stopService().

Se um componente chama o bindService() para criar o servio (e o onStartCommand() no foi

chamado) ento o servio roda apenas enquanto o componente estiver ligado a ele. Uma vez que

o servio foi desligado de todos os seus clientes, o sistema o destri.

O sistema Android vai forar a parada de um servio apenas quando a memria do dispositivo

estiver muito baixa e ele precisar recuperar recursos para uma atividade que est em foco para o

usurio. Se o servio est ligado a uma atividade que tem o foco, ento menos provvel que ele

seja morto e se o servio est declarado para rodar em tela (item discutido em posts futuros),

ento bem provvel que ele nunca seja morto. De outra maneira, se o servio foi iniciado e est

rodando um processo longo, ento o sistema vai diminuir sua posio na lista de processos em

background e pode se tornar suscetvel a ser morto pelo sistema.

Declarando um servio no manifesto

Como uma atividade (e outros componentes), voc deve declarar todos os servios no arquivo de

manifesto da aplicao.

Para declarar seu servio, adicione um elemento como filho de um elemento

.

...

...

Existem outros atributos que voc pode incluir no elemento que definem propriedades

como permisses requeridas para a inicializao de tal servio e o processo no qual o servio

pode rodar.

Assim como uma atividade, um servio pode definir intent filters que permitem outros

componentes chamarem o servio usando intents implicitos. Declarando intent filters, os

componentes de qualquer aplicao instalada no dispositivo podem potencialmente iniciar seu

servio se seu servio declara um intent filter que igual ao intent que outra aplicao passou

para o startService().

Se voc planeja usar seu servio apenas de modo local (outras aplicaes no podem us-lo),

ento no necessrio (e voc no deveria) suprir quaisquer intent filters. Sem um intent filter

voc deve iniciar o servio usando um intent que explicitamente nomeie a classe do servio.

Adicionalmente, voc pode assegurar que seu servio seja privado para sua aplicao apenas

incluindo o atributo android:exported e set-lo como false. Isso efetivo mesmo que o servio

fornea intent filters.

Criar projeto no ADT: prjServico

O activity_main.xml dever semelhante ao apesentado a seguir:

Agora iremos definir a criao do servio no manifesto (AndroidManifest.xml).

Renomear o pacote principal para com.servico.view.

A classe com. notificacao.view.MainActivity, iremos deixar como a seguir:

package com.servico.view; import android.content.Intent; import android.os.Bundle; import android.support.v7.app.ActionBarActivity; import android.view.Menu; import android.view.View; import android.widget.Button; import android.widget.TextView;

public class MainActivity extends ActionBarActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // obtema a referncia do boto criado. Button init = (Button) findViewById(R.id.btnIniciar); // Seta um texto TextView text = (TextView) findViewById(R.id.tvTexto); text.setText("Iniciando um Servio"); init.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { startService(new Intent("INICIAR_SERVICO")); } }); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.main, menu); return true; } }

Criando a classe Servio

Para criar uma classe Service tambm simples. Devemos criar uma classe .Java e herde de

Service do pacote android.app.Service obrigatoriamente preciso implementar o mdoto IBinder,

no vamos utilizar este mtodo neste post. Em nvel de conhecimento, este mtodo serve para

um processo se comunicar com outro processo. D um override no mtodo onStart() da classe

que herda Service. Dentro do mtodo onStart(), chame o mtodo incremento() que ir executar o

processo de incrementao de valores. Para parar um servio, preciso chamar o mtodo

stopSelf(). Caso voc no utilize o mtodo stopSelf() o servio vai ficar criado at o sistema

operacional necessitar de memria. O mtodo onStart() faz parte do ciclo de vida de um Service,

que eu pretendo criar um post sobre o mesmo.

O mtodo incremento

O mtodo incremento criado para acompanhar a execuo do servio criado. Este mtodo, ele

recebe um nmero como parmetro e executa-o 100 vezes. O mtodo sleeping de Thread

passando como parmetro 1000 milissegundo.

Crie uma classe camada com.servico.view.Servico:

package com.servico.view; import android.app.Service; import android.content.Intent; import android.os.IBinder; import android.util.Log; public class Servico extends Service { public static final String CATEGORIA = "servico"; @Override public void onStart(Intent intent, int startId) { incremento(0); stopSelf(); } private void incremento(int result) { for (int i = 0; i < 100; i++) { try { Thread.sleep(1000); result++; Log.i(CATEGORIA, "incremento " + result); } catch (InterruptedException e) { Log.i(CATEGORIA, "erro " + e); } } } @Override public IBinder onBind(Intent intent) { // TODO Auto-generated method stub return null; }

}

Rode o projeto na mquina virtual.