Android – Desabilitar o desligamento automático de tela (Disable screen sleep)

Cópia fiel de: http://zarelli.wordpress.com/

– Não permitir que a tela durma
– Disable screen timeout
– Disable screen turning off
– Disable screen automatically turns off
– Disabling screen sleep
– Disable screen sleep
– Disable sleep activity
– Disable turn off activity

Esse é um termo muito difícil de se encontrar (pelo menos para min), acho que é o post mais complicado de se dar um titulo, afinal como desabilitar o desligamento automatico da tela em sua activity?

Existe somente uma maneira (correta) sem a necessidade de mexer nas configurações do visor. Veja como.

Ou você define no XML da tela ou no código fonte:

android:keepScreenOn=”true”
ou
setKeepScreenOn(true);

Exemplo:

No XML (maneira mais simples e acredito que a melhor):

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:keepScreenOn="true"
    >
<TextView  
    android:layout_width="match_parent" 
    android:layout_height="wrap_content" 
    android:text="Hello World, MainActivity"
    />
</LinearLayout>

no codigo fonte (lembre-se de ter definido o id na tag root do layout):

@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    findViewById(R.id.main).setKeepScreenOn(true);
}

Pronto, sua tela/activity não vai mais dormir/desligar.

Fonte:http://developer.android.com/reference/android/view/View.html#setKeepScreenOn%28boolean%29

Anúncios

Buscando dispositivos bluetooth no Android

Cópia fiel de: http://zarelli.wordpress.com/

Bluetooth

A plataforma Android inclui suporte para a pilha de rede Bluetooth, que permite que um dispositivo troque dados com outros dispositivos Bluetooth. A estrutura do framework fornece acesso à funcionalidade Bluetooth através do Bluetooth Android APIs. Essas APIs permitem que as aplicações estabeleção comunicação sem fio com outros dispositivos Bluetooth.

Usando as APIs de Bluetooth, uma aplicação Android pode executar o seguinte:

  • Verificar se há outros dispositivos Bluetooth
  • Consultar o adaptador Bluetooth local para dispositivos Bluetooth emparelhados
  • Estabelecer canais RFCOMM
  • Conectar a outros dispositivos através do serviço de descoberta
  • Transferir dados para e de outros dispositivos
  • Gerenciar conexões múltiplas

Abaixo vamos mostrar algumas funcionalidades como a busca de dispositivos.

Buscando dispositivos

Antes de tudo, lembre-se de inserir as permissões no seu Manifest.xml. A primeira permissão é para a busca de dispositivos e outras coisas relacionadas ao bluetooth (como transferência). A segunda permissão é utilizada para controle do dispositivo, ex: ativar o bluetooth.

android:name="android.permission.BLUETOOTH"/>
android:name="android.permission.BLUETOOTH_ADMIN"/>

Como o exemplo vai ser bem simples, vamos mostrar os itens em um ListView, assim teremos apenas um Layout “main.xml”

<!--?xml <span class="hiddenSpellError" pre="xml "-->version="1.0" encoding="utf-8"?>
xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
>
    <ListView
        android:id="@+idMain/listview"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
    />
</LinearLayout>

Agora vamos mostrar a classe responsável por TUDO a Bluetooth.java, essa classe extende BroadcastReceiver porque ela vai ser um receiver do sistema, vamos definir alguns filtros sobre o que ela vai “ouvir” e implementar o que vamos fazer com isso. Caso você não saiba o que é um Broadcast tentem ler algo sobre pois vai facilitar o entendimento.

public class Bluetooth extends BroadcastReceiver
{
    [...]
    private BluetoothListener listener;
    private ArrayList lista;
    private BluetoothAdapter dispositivo;

    private Bluetooth(BluetoothListener listener)
    {
        this.listener = listener;
        lista = new ArrayList();
    }
    [...]
}

Como a classe é muito grande vou explica-la por partes para nao ficar muito confuso. No final do topico vou inserir um link do projeto também.

Tudo que irei mostrar vai estar dentro da classe Bluetooth.
Abaixo defini um listener que vai ser responsável em informar as ações da busca.

public static interface BluetoothListener
{
        public static final String ACTION_DISCOVERY_STARTED = BluetoothAdapter.ACTION_DISCOVERY_STARTED;
        public static final String ACTION_FOUND = BluetoothDevice.ACTION_FOUND;
        public static final String ACTION_DISCOVERY_FINISHED = BluetoothAdapter.ACTION_DISCOVERY_FINISHED;

        public void action(String action);
}

No método abaixo é realizado o registro dos broadcast para ler as ações do bluetooth e iniciar a busca.

public static Bluetooth startFindDevices(Context context, BluetoothListener listener) throws IOException
{
    Bluetooth bluetooth = new Bluetooth(listener);

    //Pego o adapter
    bluetooth.dispositivo = BluetoothAdapter.getDefaultAdapter();

    // verifico se o bluetooth esta desabilitado, se tiver habilito
    //retorno null pois esta ação demora para ser concluida. (tratar)
    if (!bluetooth.dispositivo.isEnabled())
    {
        bluetooth.dispositivo.enable();
        return null;
    }

     // Registro os Broadcast necessarios para a busca de dispositivos
    IntentFilter filter = new IntentFilter(BluetoothListener.ACTION_FOUND);
    IntentFilter filter2 = new IntentFilter(BluetoothListener.ACTION_DISCOVERY_FINISHED);
    IntentFilter filter3 = new IntentFilter(BluetoothListener.ACTION_DISCOVERY_STARTED);
    context.registerReceiver(bluetooth, filter);
    context.registerReceiver(bluetooth, filter2);
    context.registerReceiver(bluetooth, filter3);

    //inicio a busca e retorno o objeto que vai ter alista de dispositivos
    bluetooth.dispositivo.startDiscovery();
    return bluetooth;
}

Beleza, estamos iniciando a busca, mas como vamos descubrir o que está chegando? você deve sobrescrever o método onReceive do BroadcastReceiver. Abaixo vamos tratar cada Broadcast que foi registrado e chamar o listener para informar o que está acontecendo.

@Override
public void onReceive(Context context, Intent intent)
{
    String action = intent.getAction();

    //caso encontre um dispositivo:
    if ( action.compareTo(BluetoothDevice.ACTION_FOUND) == 0 )
    {
        //pega as o dispositivo encontrado:
        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

        //se a lista já tiver esse dispositivo eu retorno para o proximo
        //isso permite que sejá mostrado somente uma vez meu dispositivo
        //problema muito comum em exemplos
        if ( lista.contains(device) )
        {
            return;
        }

        //adiciono o dispositivo na minha lista:
        lista.add(device);
    }
    else if ( action.compareTo(BluetoothAdapter.ACTION_DISCOVERY_FINISHED) == 0 )
    {
        //caso o discovery chegue ao fim eu desregistro meus broadcasts
        //SEMPRE FAÇA ISSO quando terminar de usar um broadcast
        //(aqueles IntentFilter que criei anteriormente)
        context.unregisterReceiver(this);
    }

    if (listener != null)
    {
        //se foi definido o listener eu aviso a quem ta gerenciando.
        listener.action(action);
    }
}

Pronto, agora como usar essa classe ?
abaixo temos a Main do projeto:
Resumindo, implementei o Listener da classe Bluetooth para que podemos ler a ação, no onCreate damos o start na busca e definimos um adapter para o listview.
no método do listener (action) vamos tratar as ações do Bluetooth. quando chega no fim da busca pegamos os dispositivos da classe bluetooth e exibimos no listview.

public class MainActivity extends Activity implements Bluetooth.BluetoothListener
{
    private static final String TAG = "BuscaBluetooth";
    private Bluetooth bluetooth;
    private ArrayAdapter arrayAdapter;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        try
        {
            bluetooth = Bluetooth.startFindDevices(this, this);
        }
        catch (Exception e)
        {
            Log.e(TAG, "Erro: ", e);
        }

        arrayAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1);
        ListView listView = (ListView) findViewById(R.idMain.listview);
        listView.setAdapter(arrayAdapter);
    }

    public void action(String action)
    {
        if ( action.compareTo(ACTION_DISCOVERY_STARTED) == 0 )
        {
            arrayAdapter.add("-Busca iniciada");
        }
        else if ( action.compareTo(ACTION_DISCOVERY_FINISHED) == 0 )
        {
            preencherLista();
            arrayAdapter.add("-Fim de busca.");
        }
    }

    private void preencherLista()
    {
        for (BluetoothDevice device : bluetooth.getDispositivos())
        {
            arrayAdapter.add(device.getName() + "\n" + device.getAddress());
        }
    }
}

Se rodarmos a aplicação veremos algo como:
busca-bluetooth
Como opcional inseri um método na classe Bluetooth que pega os dispositivos já pareados.

public static Bluetooth getBondedDevices(Context applicationContext) throws IOException
{
    Bluetooth bluetooth = new Bluetooth(null);

    // Pega o dispositivo
    bluetooth.dispositivo = BluetoothAdapter.getDefaultAdapter();

    if ( !bluetooth.dispositivo.isEnabled() )
    {
        bluetooth.dispositivo.enable();
    }

    // Pega a lista de dispositivos pareados
    Set pairedDevices = bluetooth.dispositivo.getBondedDevices();

    // Adiciono na lista e depois retorno a mesma.
    if ( pairedDevices.size() > 0 )
    {
        for (BluetoothDevice device : pairedDevices)
        {
            bluetooth.lista.add(device);
        }
    }

    return bluetooth;
}

Talvez para leigos(ou nao) fica um pouco complicado para entender o conceito do listener dos Broadcasts e da minha pouca explicação, no link abaixo coloquei o projeto completo.

LINK DO PROJETO (DropBox)

Fonte: http://goo.gl/D7ekO

AsyncTask – Executando tarefas em segundo plano

Cópia fiel de: http://zarelli.wordpress.com/

Android AsyncTask

AsyncTask um Substituto de Threads e Handles

Como todo desenvolvedor Android sabe, é bem chato mexer com Threads, ainda mais quando há necessidade de atualizar a interface, para isso atualmente usamos a famosa ThreadUI ou Handler.

Pesquisando, encontrei uma maneira de trabalhar com essas Threads distintas facilmente utilizando a classe AsyncTask, com ela nos não precisamos nos preocupar com o tal de Handler. Nela executamos qualquer processo paralelamente e temos um método responsável por atualizar a interface.

Quando estendemos a AsyncTask ele nos obriga a definir três tipos de classes:

(defini esses tipos como exemplo)

extends AsyncTask<string, object, integer>

    1. O primeiro tipo ira definir o tipo que será passado para o método doInBackground(String… paramss), esses parâmetros vão ser passados ao executarmos o processo.
    2. O segundo tipo ira definir o tipo que será passado para o método onProgressUpdate(Object… values).
    3. O terceiro tipo ira definir o retorno do método doInBackground, assim que termina a execução do doInBackground esse tipo será retornado para o método onPostExecute(Integer… values).

Ao implementar uma classe que extend a AsyncTask podemos sobrescrever os seguintes métodos:

1 – onPreExecute.

É chamado antes de executar o processo (doInBackground), Podemos utilizar para criarmos um ProgressDialogo. Este método roda em Thread de interface.

2 – doInBackground

É responsável pelo processo. ex: uma busca em um webservice, algum download, qualquer processo que demanda tempo e processamento.

Não podemos utilizar este método para atualizarmos nossa interface, para isso temos a onProgressUpdate, MAS NÃO CHAMAREMOS ELA DIRETAMENTE para isso temos o métodopublishProgress que fica responsável por chamar a onProgressUpdate.

3 – onPostExecute

Este método recebera um parâmetro do doInBackground, ele é responsável em terminar a execução do processo, por exemplo finalizar um ProgressDialogo.

4 – onProgressUpdate

Este método é responsável em atualizar nossa interface. Chamamos ele atravéz do método publishProgress

Na pratica isso facilita e muito, acabando com os problemas de atualizar interface fora de um handler! mensagem de erro muito comum acredito!.

Segue um exemplo de como implementar um processo que demanda tempo, sempre atualizando a interface.

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Bundle;

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

        /** Chamando o Processo AsyncTask
         *  Os parametros passado no método execute, vão para o método
         *  doInBackground(Integer... params).
         */
        Processo processo = new Processo(this);
        processo.execute(3000, 2000, 4000);
    }

    public class Processo extends AsyncTask<integer, string,="" integer="">
    {

        private ProgressDialog progress;
        private Context context;

        public Processo(Context context)
        {
            this.context = context;
        }

        @Override
        protected void onPreExecute()
        {
            //Cria novo um ProgressDialogo e exibe
            progress = new ProgressDialog(context);
            progress.setMessage("Aguarde...");
            progress.show();
        }

        @Override
        protected Integer doInBackground(Integer... paramss)
        {
            for (int i = 0; i < paramss.length; i++)
            {
                try
                {
                    //Simula processo...
                    Thread.sleep(paramss[i]);
                    //Atualiza a interface através do onProgressUpdate
                    publishProgress(i + "...");
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
            return 1;
        }

        @Override
        protected void onPostExecute(Integer result)
        {
            //Cancela progressDialogo
            progress.dismiss();
        }

        @Override
        protected void onProgressUpdate(String... values)
        {
            //Atualiza mensagem
            progress.setMessage(values[0]);
        }
    }
}

Android Criando um ListView Personalizado

Cópia fiel de: http://zarelli.wordpress.com/

Custom ListView

Para criar um listView personalizado não é difícil porem é um trabalho chato de se fazer.
O conceito é, preencher uma lista de objetos que contem os dados de seu item e passar essa lista para um adapter que irá preencher o ListView, através desse adapter nós poderemos ter o controle sobre a lista, podendo remover item adicionar e pegar o selecionado.

Primeiro crie o layout de onde ficara seu listView, para isso criei o “main.xml”:

<?xml version="1.0" encoding="UTF-8"?>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:background="#FFFFFFFF"
>
        <ListView
        android:id="@+id/list"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:divider="#ECECEC"
        android:dividerHeight="1sp"
        />
</LinearLayout>

Após a criação do layout de apresentação criaremos o Item, vou criar um item bem simples, com uma texto e uma imagem. “item_listview.xml”:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal">
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:padding="5sp">
        <ImageView
            android:id="@+id/imagemview"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            />

        <TextView
            android:id="@+id/text"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_marginLeft="5sp"
            android:gravity="center_vertical"
            android:textColor="#FF000000"
        />
    </LinearLayout>
</LinearLayout>

Pronto a parte do XML está feita! agora vamos implementar no código.

Primeiramente criaremos nosso Objeto de acordo com nosso item.

public class ItemListView
{
    private String texto;
    private int iconeRid;

    public ItemListView()
    {
    }

    public ItemListView(String texto, int iconeRid)
    {
        this.texto = texto;
        this.iconeRid = iconeRid;
    }

    public int getIconeRid()
    {
        return iconeRid;
    }

    public void setIconeRid(int iconeRid)
    {
        this.iconeRid = iconeRid;
    }

    public String getTexto()
    {
        return texto;
    }

    public void setTexto(String texto)
    {
        this.texto = texto;
    }
}

Após criado o Objeto vamos criar o Adapter, o coração do ListView.
Vejá como é simples:

public class AdapterListView extends BaseAdapter
{
    private LayoutInflater mInflater;
    private ArrayList<ItemListView> itens;

    public AdapterListView(Context context, ArrayList<ItemListView> itens)
    {
        //Itens que preencheram o listview
        this.itens = itens;
        //responsavel por pegar o Layout do item.
        mInflater = LayoutInflater.from(context);
    }

    /**
     * Retorna a quantidade de itens
     *
     * @return
     */
    public int getCount()
    {
        return itens.size();
    }

    /**
     * Retorna o item de acordo com a posicao dele na tela.
     *
     * @param position
     * @return
     */
    public ItemListView getItem(int position)
    {
        return itens.get(position);
    }

    /**
     * Sem implementação
     *
     * @param position
     * @return
     */
    public long getItemId(int position)
    {
        return position;
    }

    public View getView(int position, View view, ViewGroup parent)
    {
        //Pega o item de acordo com a posção.
        ItemListView item = itens.get(position);
        //infla o layout para podermos preencher os dados
        view = mInflater.inflate(R.layout.item_list, null);

        //atravez do layout pego pelo LayoutInflater, pegamos cada id relacionado
        //ao item e definimos as informações.
        ((TextView) view.findViewById(R.id.text)).setText(item.getTexto());
        ((ImageView) view.findViewById(R.id.imagemview)).setImageResource(item.getIconeRid());

        return view;
    }
}

Pronto. Toda estrutura está feita, agora vamos colocar para funcionar.
Segue o código de implementação na nossa Activity principal:

public class MainActivity extends Activity implements OnItemClickListener
{
    private ListView listView;
    private AdapterListView adapterListView;
    private ArrayList<ItemListView> itens;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        //carrega o layout onde contem o ListView
        setContentView(R.layout.main);

        //Pega a referencia do ListView
        listView = (ListView) findViewById(R.id.list);
        //Define o Listener quando alguem clicar no item.
        listView.setOnItemClickListener(this);

        createListView();
    }

    private void createListView()
    {
        //Criamos nossa lista que preenchera o ListView
        itens = new ArrayList<ItemListView>();
        ItemListView item1 = new ItemListView("Guilherme Biff", R.drawable.biff);
        ItemListView item2 = new ItemListView("Lucas Volgarini", R.drawable.volgarini);
        ItemListView item3 = new ItemListView("Eduardo Ricoldi", R.drawable.ricoldi);
        ItemListView item4 = new ItemListView("Felipe Panngo", R.drawable.panngo);

        itens.add(item1);
        itens.add(item2);
        itens.add(item3);
        itens.add(item4);

        //Cria o adapter
        adapterListView = new AdapterListView(this, itens);

        //Define o Adapter
        listView.setAdapter(adapterListView);
        //Cor quando a lista é selecionada para ralagem.
        listView.setCacheColorHint(Color.TRANSPARENT);
    }

    public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3)
    {
        //Pega o item que foi selecionado.
        ItemListView item = adapterListView.getItem(arg2);
        //Demostração
        Toast.makeText(this, "Você Clicou em: " + item.getTexto(), Toast.LENGTH_LONG).show();
    }
}

Observação: As imagens foram inseridas na pasta res/drawable/ para quem não saiba, após inserida as imagens lá podemos pegar sua referencia pelo ResId.

Para quem quiser o projeto:
http://dl.dropbox.com/u/15643399/CustomListView.zip

Android – Criando uma notificação

Cópia fiel de: http://zarelli.wordpress.com/

A notificação no android é muito utilizada, quando temos uma aplicação rodando em segundo plano por exemplo e essa aplicação necessita informar algo para o usuário a melhor maneira é exibindo uma notificação, nós não podemos simplesmente abrir uma tela na frente, pois pode atrapalhar o que o usuário está fazendo no momento.

Abaixo segue um exemplo prático de como implementar uma aplicação que execute uma notificação.
Criei essa classe para controlar a criação das minhas notificações.

package br.gui;

import android.app.Activity;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Intent;

/**
 *
 * @author guilherme
 */
public class Notificacao
{

    public static final int TIPO_ACTIVITY = 1;
    public static final int TIPO_BROADCAST = 2;
    public static final int TIPO_SERVICE = 3;
    public static final String INTENT_STRING_MSG_STATUS = "MSGs";
    public static final String INTENT_STRING_MSG = "MSG";
    public static final String INTENT_STRING_TITULO = "titu";
    public static final String INTENT_LONG_QUANDO = "WHEN";
    public static final String INTENT_INT_ICONE = "icone";
    public static final String INTENT_INT_FLAGS = "FLS";

    /**
     *
     * @param activity Atividade
     * @param param Parametros da notificacao
     * @param acao Ação quando é selecionado a notificacao
     * @param tipo Tipo da ação /broadcast/atividade/serviço/
     * @return Notification
     */
    public static Notification criarNotificacao(Activity activity, Intent param, Intent acao, int tipo)
    {
        //cria a notificacao
        Notification n = new Notification(param.getIntExtra(INTENT_INT_ICONE, 0),
                param.getStringExtra(INTENT_STRING_MSG_STATUS),
                param.getLongExtra(INTENT_LONG_QUANDO, System.currentTimeMillis()));

        //Responsavel pela acao caso o usuario selecione a notificacao;
        PendingIntent p;
        if (tipo == TIPO_ACTIVITY)
        {
            p = PendingIntent.getActivity(activity, 0, acao, param.getIntExtra(INTENT_INT_FLAGS, 0));
        }
        else if (tipo == TIPO_BROADCAST)
        {
            p = PendingIntent.getBroadcast(activity, 0, acao, param.getIntExtra(INTENT_INT_FLAGS, 0));
        }
        else if (tipo == TIPO_SERVICE)
        {
            p = PendingIntent.getService(activity, 0, acao, param.getIntExtra(INTENT_INT_FLAGS, 0));
        }
        else
        {
            throw new IllegalArgumentException("tipo indefinido");
        }

        //Vincula o PendingIntent com a notificacao
        n.setLatestEventInfo(activity, param.getStringExtra(INTENT_STRING_TITULO), param.getStringExtra(INTENT_STRING_MSG), p);

        //Define valores default para a notificacao ex. som,vibra.
        n.defaults = Notification.DEFAULT_ALL;

        return n;
    }

    /**
     *
     * @param activity Atividade
     * @param notification Notificação a ser exibida
     * @param id Identificador unico da notificacao
     * @return  NotificationManager
     */
    public static NotificationManager notificar(Activity activity, Notification notification, int id)
    {
        //pega serviço de notificacao
        NotificationManager nm = (NotificationManager) activity.getSystemService(Activity.NOTIFICATION_SERVICE);
        //exibe a notificacao
        nm.notify(id, notification);
        return nm;
    }
}

No código acima, após a criação do notificação definimos um PedingIntent de acordo com o tipo passado no método. O PedingIntent contém as ações que devem ser tomadas caso o usuário selecione a notificação, os métodos diferente de chamada são para distintas decisões, por exemplo, o getActivty é responsável em abrir uma atividade, o getBroadcast é responsável por transmitir a intent pelo S.O (mensagem de broadcast), e o getService é responsável por chamar um serviço.

Veja o exemplo que utiliza esta classe para realizar a notificação:

package br.gui;

import android.app.Activity;
import android.app.Notification;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;

public class MainActivity extends Activity
{
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        //define a intent responsavel por passar os parametros necessarios para
        //criar uma notificacao.
        Intent it = new Intent();
        it.putExtra(Notificacao.INTENT_STRING_MSG, "Meu teste de notificacao.");
        it.putExtra(Notificacao.INTENT_STRING_MSG_STATUS, "Olá");
        it.putExtra(Notificacao.INTENT_STRING_TITULO, "Titulo da notificação");
        it.putExtra(Notificacao.INTENT_LONG_QUANDO, System.currentTimeMillis());
        it.putExtra(Notificacao.INTENT_INT_ICONE, android.R.drawable.ic_menu_week);
        //Intente de ação/ou seja/ao clicar na notificação, o sistema irá abrir
        //uma pagina com o seguinte endereco
        String url = "http://www.example.com";
        Intent i = new Intent(Intent.ACTION_VIEW);
        i.setData(Uri.parse(url));
        //Cria a notificação.
        Notification notf = Notificacao.criarNotificacao(this, it, i, Notificacao.TIPO_ACTIVITY);
        //Manda notificar.
        Notificacao.notificar(this, notf, 550);

    }
}

É uma aplicação bem simples, executa uma notificação e quando você a seleciona é aberto uma pagina em seu navegador. Nota-se que na linha que eu notifico eu passo um id, esse id é o identificador da notificação, caso eu queira cancelar a mesma eu utilizo o método .cancel(550) da classe NotificationManager.

ex:

NotificationManager nm = Notificacao.notificar(this, notf, 550);
nm.cancel(550);

Pronto. Não é necessário mais nada para estar exibindo uma notificação na tela. Caso queira personalizar ainda mais sua notificação verifique a documentação no site do android:

http://developer.android.com/reference/android/app/Notification.html

Ainda é possível definir um áudio diferente, vibrar, acender a luz de fundo etc.

Exibindo mensagens no Android com a classe Toast

Retirado de: http://zarelli.wordpress.com/

Introdução

O Toast fornece um feedback simples e rápido ao usuário em uma pequena janela. Essa janela é exibida na quantidade de espaço necessário para a mensagem que lhe foi determinada, permanecendo visível por um tempo limite. Por exemplo, ao sair de um e-mail antes de enviá-lo, será exibido um Toast “Rascunho salvo”, para lhe informar que será possível retornar ao e-mail.

Este recurso não tem interação com o usuário, serve somente para dar informações rápidas. Para uma interação há recursos como Alertas e Notificação.

Toast básico

Exemplo básico de Toast

Figura 1: Exemplo básico de Toast

A utilização do Toast é bem simples e não exige um maior nível de conhecimento no Android para aplicá-la. Na maioria das vezes vamos utilizar a construção básica do Toast que se resume em poucas linhas de código ou apenas uma.

Para instanciar o objeto, utilizaremos o método makeToast() ele precisa somente de três parâmetros: contexto, mensagem e duração. A duração é uma constante existente na classe Toast, tendo como opção LENGTH_SHORT para curto tempo ou LENGHT_LONG para longo. Para exibir vamos chamar o método show(). Abaixo segue o exemplo de construção de uma simples mensagem.

Listagem 1: Exemplo básico de exibição de um Toast

Context contexto = getApplicationContext();
String texto = "exemplo toast";
int duracao = Toast.LENGTH_SHORT;
 
Toast toast = Toast.makeText(contexto, texto,duracao);
toast.show();

Podemos resumir esse código em apenas uma linha para evitar que o objeto Toast seja guardado sem necessidade.

Listagem 2: Exemplo resumido de exibição de um Toast

Toast.makeText(getApplicationContext(), “Exemplo Toast”, Toast.LENGTH_SHORT).show();

Por padrão o Toast é exibido no canto inferior da tela centralizado horizontalmente, podemos mudar isso com o método setGravity(), que aceita três parâmetros: a constante de Gravity, a posição do offset de x e de y. O valor do offset permitirá você mover o Toast para direita alterando o segundo parâmetro, ou para baixo alterando o terceiro parâmetro.

Na listagem abaixo mostraremos como centralizar a mensagem Toast horizontalmente e verticalmente.

Listagem 3: Uso do setGravity()

Toast toast = Toast.makeText(this, texto, Toast.LENGTH_LONG);
toast.setGravity(Gravity.CENTER_HORIZONTAL | Gravity.CENTER_VERTICAL, 0, 0);
toast.show();

Toast customizado

Toast Customizado

Figura 2: Toast Customizado

Um Toast customizado já exige um pouco mais de conhecimento, pois faz uso de layout para isso. Ele aceita como parâmetro uma View, podendo ser definida pelo método setView(), permitindo-nos definir qualquer layout customizado. Podemos definir um layout tanto por XML quanto por código.

Em nosso exemplo vamos utilizar o arquivo XML salvo como toast.xml. Definiremos uma imagem que se encontra na pasta drawable, um texto que vamos definir seu valor por código e três outros textos fixos para exemplo.

Listagem 4: Layout customizado toast

<?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"
              android:id="@+id/toast_layout_root"
              android:padding="8dp"
             android:background="#DAAA"
>
    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/icon"
        />
     
    <TextView 
        android:id="@+id/texto"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
    />
    <TextView 
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Exemplo 1"
        android:textSize="10sp"
        android:layout_marginTop="10sp"
    />
    <TextView 
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Exemplo 2"
        android:textSize="15sp"
    />
    <TextView 
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Exemplo 3"
        android:textSize="20sp"
    />
</LinearLayout>

Abaixo inflaremos o layout que criamos através do LayoutInflater pelo método inflate(). O método inflate precisa de dois parâmetros: o primeiro é nosso layout e o segundo é o componente root de exibição, ou seja, nosso LinearLayout, onde foi definido um id para isso. Agora que temos a View, utilizaremos dela para pegar o TextView ‘id/texto’ e definiremos um texto para o mesmo. Após a configuração de nosso layout inflado, vamos criar o Toast através de seu construtor publico e definiremos o layout inflado em nosso Toast através do método setView().

Nota-se que só devemos utilizar o construtor público do Toast se utilizarmos o recurso setView().

Listagem 5: Exibição do Toast customizado

LayoutInflater layoutInflater = getLayoutInflater();
 
int layout = R.layout.toast;
ViewGroup viewGroup = (ViewGroup) findViewById(R.id.toast_layout_root);
View view = layoutInflater.inflate(layout, viewGroup);
 
TextView tv_texto = (TextView) view.findViewById(R.id.texto);
tv_texto.setText(texto);
 
Toast toast = new Toast(this);
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(view);
toast.show();

Conclusão

Verificamos neste artigo como o Toast é simples de se utilizar e como a sua utilidade em um sistema é essencial para que o usuário tenha um feedback completo de alguma ação, sem a necessidade de estar criando telas ou avisos para isso. O Toast é um recurso nativo do sistema Android que permite um desenvolvimento ágil pela sua simplicidade, tornando-se algo bem flexível e customizado, sem perder a usabilidade de uma aplicação.
Com isso finalizo esse artigo. Em anexo segue o projeto que foi utilizado como exemplo. Até o próximo, um grande abraço e obrigado.

Leia mais em: Exibindo mensagens no Android com a classe Toast http://www.devmedia.com.br/exibindo-mensagens-no-android-com-a-classe-toast/26668#ixzz2NFdEvWpT

Exibindo caixas de diálogos no Android com AlertDialog

Retirado de: http://zarelli.wordpress.com/

Introdução

Uma caixa de diálogo é uma pequena janela que solicita ao usuário tomar uma decisão ou inserir informações adicionais. Um diálogo não preenche toda a tela e é normalmente utilizado para eventos modais, requerendo aos usuários uma interação antes de prosseguir.

Um AlertDialog pode mostrar um título, até três botões, uma lista de itens selecionáveis ou não, ou um layout personalizado. Vamos ver ao decorrer deste artigo todas essas opções.

Diálogo básico

Exemplo de um diálogo básico

Figura 1: Exemplo de um diálogo básico

No exemplo básico vamos criar um diálogo como a imagem acima, um título, mensagem e dois botões.

É importante sabermos que ao criarmos o diálogo utilizando os recursos padrões ele será automaticamente desfeita ao pressionar qualquer dos botões.

A criação é simples e em todos os exemplos vamos utilizar o mesmo recurso para a criação do objeto AlertDialog. Utilizaremos a classe AlertDialog.Builder, vamos instanciá-la e configurar o que será exibido (título, mensagem, botões, etc…) após isso vamos pegar o AlertDialog do Builder e mandar exibir o diálogo.

Listagem 1: Exemplo AlertDialog básico

//atributo da classe.
private AlertDialog alerta;
 
private void exemplo_simples() {
    //Cria o gerador do AlertDialog
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    //define o titulo
    builder.setTitle("Titulo");
    //define a mensagem
    builder.setMessage("Qualifique este software");
    //define um botão como positivo
    builder.setPositiveButton("Positivo", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface arg0, int arg1) {
            Toast.makeText(MainActivity.this, "positivo=" + arg1, Toast.LENGTH_SHORT).show();
        }
    });
    //define um botão como negativo.
    builder.setNegativeButton("Negativo", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface arg0, int arg1) {
            Toast.makeText(MainActivity.this, "negativo=" + arg1, Toast.LENGTH_SHORT).show();
        }
    });
    //cria o AlertDialog
    alerta = builder.create();
    //Exibe
    alerta.show();
}

Exemplo de um diálogo customizado

Figura 2: Exemplo de um diálogo customizado

Seguindo os passos da criação de nosso diálogo básico, agora vamos criar um layout customizado, primeiramente será feita a construção do nosso arquivo XML chamado de ‘alerta.xml’, nele vamos inserir um ImageView e um Button dentro de um LinearLayout.

Listagem 2: Arquivo alerta.xml utilizado no diálogo customizado

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
>
    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:src="@drawable/imagem_teste"
/>
    <Button
        android:id="@+id/bt" 
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Dismiss"
/>
</LinearLayout>

Agora vamos inserir esse layout no diálogo e tratar a ação do botão. Lembre-se que o AlertDialog está como variável da classe, assim como no primeiro exemplo.

Listagem 3: Exemplo AlertDialog customizado

private void exemplo_layout() {
    //LayoutInflater é utilizado para inflar nosso layout em uma view.
    //-pegamos nossa instancia da classe
    LayoutInflater li = getLayoutInflater();
     
    //inflamos o layout alerta.xml na view
    View view = li.inflate(R.layout.alerta, null);
    //definimos para o botão do layout um clickListener
    view.findViewById(R.id.bt).setOnClickListener(new View.OnClickListener() {
        public void onClick(View arg0) {
            //exibe um Toast informativo.
            Toast.makeText(MainActivity.this, "alerta.dismiss()", Toast.LENGTH_SHORT).show();
            //desfaz o alerta.
            alerta.dismiss();
        }
    });
     
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle("Titulo");
    builder.setView(view);
    alerta = builder.create();
    alerta.show();
}

Diálogos de lista de seleção simples

Também com base nos exemplos anteriores, fazer uma lista nada mais é do que você definir um vetor de informações e inseri-las no Builder do diálogo.

Diálogo de seleção simples

Figura 3: Diálogo de seleção simples

Neste exemplo foi utilizado um ListAdapter para gerar a lista, para isso foi criado um layout para os itens.

Listagem 4: Item que contem o TextView da lista

<?xml version="1.0" encoding="utf-8"?>
<TextView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textSize="20sp"
    android:textColor="#FF000000"
    android:padding="10sp"
/>

Como vimos, nosso item é só um TextView, veja na listagem abaixo como construir o adaptador e inserir no AlertDialog.

Listagem 5: Implementação do AlertDialog em lista

private void exemplo_lista_single() {
    //Lista de itens
    ArrayList<String> itens = new ArrayList<String>();
    itens.add("Ruim");
    itens.add("Mediano");
    itens.add("Bom");
    itens.add("Ótimo");
     
    //adapter utilizando um layout customizado (TextView)
    ArrayAdapter adapter = new ArrayAdapter(this, R.layout.item_alerta, itens);
 
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle("Qualifique este software:");
    //define o diálogo como uma lista, passa o adapter.
    builder.setSingleChoiceItems(adapter, 0, new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface arg0, int arg1) {
            Toast.makeText(MainActivity.this, "posição selecionada=" + arg1, Toast.LENGTH_SHORT).show();
            alerta.dismiss();
        }
    });
 
    alerta = builder.create();
    alerta.show();
}

Diálogo de lista com várias seleções

Os itens da lista do diálogo de seleções múltiplas se resumem em um componente de texto e um CheckBox.

Diálogo de seleção múltipla

Figura 4: Diálogo de seleção múltipla

Neste exemplo, o que temos de diferente são dois vetores, um de CharSequence[] onde serão armazenados os textos, e um vetor de boolean[] onde ficarão armazenadas as informações de habilitado ou desabilitado de cada item. Por isso que é muito importante construir esse vetor de acordo com o tamanho do vetor do CharSequence[]. Na listagem abaixo será mostrado como implementar e utilizar essa lista.

Listagem 6: Implementação do AlertDialog em lista

private void exemplo_lista_multi() {
    CharSequence[] charSequences = new CharSequence[]{"Filmes", "Dormir","Sair"};
    final boolean[] checados = new boolean[charSequences.length];
 
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle("O que você gosta?");
    builder.setMultiChoiceItems(charSequences, checados, new DialogInterface.OnMultiChoiceClickListener() {
        public void onClick(DialogInterface arg0, int arg1, boolean arg2) {
            checados[arg1] = arg2;
        }
    });
 
    builder.setPositiveButton("Confirmar", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface arg0, int arg1) {
            StringBuilder texto = new StringBuilder("Checados: ");
            for (boolean ch : checados) {
                texto.append(ch).append("; ");
            }
            Toast.makeText(MainActivity.this, texto.toString(), Toast.LENGTH_SHORT).show();
        }
    });
 
    alerta = builder.create();
    alerta.show();
}

Observe que o listener do setMultiChoiceItems é diferente pois utilizamos a interface OnMultiChoiceClickListener() que nos retornara a posição e o estado do botão.

Conclusão

O AlertDialog é uma classe essencial no desenvolvimento de aplicações Android, permitindo ao usuário uma caixa simples para a seleção de opções.

Como todo componente do Android, o AlertDialog é totalmente customizável, permitindo o uso de um layout personalizado, com seus próprios botões e informações. Seu uso além de simples e viável deve ser estudado para atender ao usuário. Lembre-se sempre de pesquisar na documentação do Android como utilizar cada recurso da melhor maneira possível.