O que é o Android?

    O Android é um conjunto de softwares que possuem foco 
em dispositivos móveis, sendo eles smartphones, tablets, 
smartbooks ou netbooks. 

Este conjunto de softwares fornecem:
• Sistema Operacional (Linux)
• Middleware
• Aplicações principais (Agenda, Contatos, Telefone...)
Aplicações Principais

    O Android vem com um conjunto de aplicações principais 
todas escritas em Java.

• Cliente de E-Mail
• SMS
• Calendário
• Mapas
• Navegador (Webkit)
• Contatos
Android Runtime e Dalvik VM

    Cada aplicação no Android roda em um processo diferente 
no linux, e em cada processo é criada uma instância da 
máquina virtual Dalvik.

    As classes compiladas da aplicação são transformadas para 
o formato .dex (Dalvik Executable) que é a otimização para 
uma mínima utilização da memória.

    A Dalvik VM interage diretamente com o kernel Linux para 
execução de funcionalidades subjacentes como threading e 
gerenciamento de memória de baixo nível.
    
    
Ambiente de Desenvolvimento

• Eclipse (Galileo)
• Android SDK
• ADT Plugin para Eclipse
• Windows, Linux ou Mac OS X.

Referência:
http://developer.android.com/sdk/index.html
Android Virtual Device (AVD)

    São como emuladores que podem ser configurados para 
cada versão do SDK ou cópia de especificações determinadas 
por um fabricante em um dispositivo.

Exercício:
• Criar uma AVD da versão 1.5 do SDK, API 3.
• Criar uma AVD com mais Memória RAM.
• Criar uma AVD sem touchscreen.
• Iniciar cada uma das AVDs acima.
• Verificar funcionamento das aplicações principais.
Aplication Components

• Activity
o Formulários.
o Listas.
o Views.
• Service
o Sem interface visual.
o Roda em Background (Música).
• Broadcast Receiver
o Download concluído.
o Bateria fraca.
• Content Provider
o Banco de Dados.
o Acesso a conteúdos externos.
Criação do Projeto

O ADT fornece um wizard para a criação do projeto Android.

Exercício:
• Criar o projeto com nome: Contatos.
• Activity: ContatoEdicaoActivity.

Com o projeto criado:
• Rodar o projeto no emulador.
Estrutura do projeto

• / - Raiz do projeto.
o src/ - Classes Java
o gen/ - Código Java gerado automaticamente.
o res/ - Recursos da aplicação
 drawable/ - Imagens
 layout/ - Layouts de telas/formulários.
 values/ - Arquivos de variáveis.
o AndroidManifest.xml - Configuração do projeto.
AndroidManifest.xml

    Arquivo de configuração dos recursos disponíveis na 
aplicação.
• Nome e ícone da aplicação.
• Activity, Broadcast, Content Provider e Service.
• Permissões de acesso a recursos do dispositivo:
o GPS
o Conexão com internet
o Acesso a dados pessoais (Contatos, Ligações ...)
• Compatibilidade mínima com a SDK do Android.
Layout - main.xml

    O arquivo XML de layout de tela 
declara os componentes e suas 
propriedades para uso da aplicação.

Exercício:
• Modificar o conteúdo da tela 
main.xml, criando tela similar a que 
está ao lado.
Edição de Contato

x
Exercício:
1. Criar novo layout em xml: 
edicao_contato.xml
– Adicionar as Views para os 
campos:
o Nome
o Telefone
o E-Mail
o Data Nascimento
Mapear os componentes no Java

    Os componentes serão manipulados pelas classes Java, 
então será necessário ligá-los a variáveis na Activity para, por 
exemplo:
• Adicionar ações aos botões.
• Adquirir o valor preenchido no campo.
• Atribuir valores aos campos.

    Para encontrar um componente usar o método findViewById 
da classe Activity.
    O parâmetro passado neste método deve estar listado na 
classe R.id.
    Exercício:
• Mapear os campos do layout de Edição na Activity.
Listas - ListActivity

    A subclasse de Activity, ListActivity é um helper para 
manipulação de listas, tanto para popular os dados na tela 
quanto para tratar as ações do usuário.

Exercício:
• Criar nova Activity: ContatoListActivity subclasse de 
ListActivity.
• Criar layout para cada item da lista: contato_item.xml
• Criar Adapter da lista para Array de String: ArrayAdapter.
• Habilitar filtro por digitação:
o getListView().setTextFilterEnabled(true);
Banco de Dados - SQLite

    A API do Android fornece suporte para criação e 
manipulação de bancos de dados SQLite.

Exercício:
• Criar classe ContatoDbAdapter.
• Crias constantes de configuração do banco de dados e 
tabela de Contatos.
o DATABASE_NAME
o CONTATO_TABLE_NAME
o DATABASE_VERSION
• Criar classe Contato com constantes dos campos.
o KEY_ID, KEY_NOME, KEY_TELEFONE, KEY_EMAIL, 
KEY_DATANASCIMENTO.
SQLiteOpenHelper

Criar classe DatabaseAdapter:

Construtor
• SQLiteOpenHelper(Context context, String name, 
SQLiteDatabase.CursorFactory factory, int version);

Método onCreate()
• Executado quando o banco de dados é criado pela primeira 
vez.

Método onUpgrade()
• Executado quando o banco de dados precisa ser 
atualizado.
SimpleCursorAdapter

    A classe SimpleCursorAdapter faz a ligação entre a 
ListActivity e o Cursor do SQLite.

Exercício:
• Criar método de consulta retornando um Cursor (Próximo 
slide).
• Adicionar este cursor a ListActivity.
• Atribuir uma nova instância de SimpleCursorAdapter a 
ListActivity pelo método setListAdapter().
Consultas no SQLite

    A classe SQLiteDatabase fornece o método query() para 
efetuar queries SQL na base de dados.

    SQLDatabase.query( String nomeTabela, String[ ] colunas,

String whereStatement, String[ ] whereArgs,
String groupBy, String having, String orderBy);

PreparedStatement: O parâmetro whereArgs irá preencher 
com os seus valores as ocorrências de ? no parâmetro 
whereStatement.

Exercício:
• Criar um método que consulte por todos Contatos da base.
Options Menu

    O menu de opções é mostrado quando a 
tecla Menu do dispositivo é acionado.
     Trazendo as opções da tela disponíveis 
para o usuário.

Exercício:
• Criar opção Novo Contato na tela de lista 
de Contatos.
Intent

    Existem 3 componentes principais de uma aplicação que 
são ativados por Intents - Activity, Service e Broadcast 
Receiver. As Intents são mensagens que apenas guardam as 
informações para uma operação ser realizada.

    Intent intent = new Intent(this, ContatoEdicaoActivity.class);

startActivityForResult(intent, NOVO_CONTATO);
Retorno da Activity

    Uma activity pode enviar um Intent de volta para o recurso 
que a executou.

    Activity.setResult(RESULT_OK, intent);
Activity.finish();

    Mais informações podem ser passadas pelo Intent com a 
atribuição de um objeto do tipo Bundle.

    bundle.putString(Contato.KEY_NOME, "João Galli");

intent.setExtras(bundle);
Inserindo registros no SQLite

    A classe SQLiteDatabase fornece o método insert() para a 
inserção de novos registros no banco de dados.

    SQLiteDatabase.insert( String nomeTabela, null,

ContentValues cv);

    A classe de tipo ContentValues mapeia as colunas com 
seus valores para a inserção.
    
    ContentValues cv = new ContentValues();
cv.put(Contato.KEY_NOME, "João Galli");
Edição de Contato

    Exercício:
• Implementar o método: ListActivity.onListItemClick() para 
abrir a tela de edição de Contato quando um item da lista 
for selecionado.

• Passar pela Intent os valores do Contato selecionado para 
popular a tela de edição.

• Retornar os novos valores do Contato para a ListActivity 
informando que a operação é de Edição de um contato 
existente.
Update no SQLite

    Outro método fornecido pela classe SQLDatabase é o 
update() que realiza uma operação SQL de update em um 
registro já existente.

    SQLDatabase.update( String nomeTabela,

ContentValues cv,
String whereStatement,
String[ ] whereArgs);

Este método retorna um int com o número de objetos 
modificados.
Notificações - Toast

    Toast são notificações simples na tela do dispositivo, 
possuem apenas uma mensagem textual.

    Toast toast = Toast.makeText(Context c, String mensagem,
        int duração);
    toast.show();

Duração: 
• Toast.LENGHT_LONG
• Toast.LENGHT_SHORT

Exercício:
• Notificar usuário quando o contato é gravado com sucesso.
Context Menu

    O Context Menu é ativado sempre que um item da lista for 
selecionado pressionando a tela por uma longa duração.

Exercício:
• Registrar a ListView da ListActivity para o ContextMenu.
• Implementar o método onCreateContextMenu() para 
adicionar opções ao menu.
Excluindo registros no SQLite

    Para excluir registros no SQLite utilizar método delete().

    SQLDatabase.delete( String nomeTabela,
        String whereStatement,
        String[ ] whereArgs);

    Exercício:
• Criar método que exclui contato a partir do ID.
Dialog

    Dialogs são pequenas janelas mostradas em cima de uma Activity 
para interação com o usuário. Existem diversos modelos de dialogs 
prontos, como:
Alert Dialog

Exercício:
• Criar um dialog de confirmação para exclusão de contato.

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Título do Dialog")
      .setCancelable(false)
      .setPositiveButton("Sim", new DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int id) {
               // Executar ação de exclusão do contato.
          }
      })
      .setNegativeButton("Não", new DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int id) {
               dialog.cancel();
          }
      });
AlertDialog alert = builder.create();
 João Eduardo Galli
joaogalli@gmail.com

Agradeço pela atenção.