Criando notificaes no Android

  • Published on
    18-Dec-2015

  • View
    5

  • Download
    1

DESCRIPTION

Criando notificaes no Android

Transcript

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