Desenvolvimento Android Basico

Desenvolvimento Android
Bsico
(por Maurcio Salamon - http://mauriciosalamon.com.br)
Android
Contedo
1. Introduo plataforma Java ................................................................................................................. 4
1.1. Comandos bsicos ........................................................................................................................ 6
1.2. Tipos de dados .............................................................................................................................. 7
1.3. Operadores ................................................................................................................................... 8
1.4. Operadores relacionais ................................................................................................................. 9
1.5. Comentrios ............................................................................................................................... 10
1.6. Pacotes, Classes e Objetos ......................................................................................................... 11
1.7. Modificadores de acesso e encapsulamento ............................................................................... 17
1.8. Colees ..................................................................................................................................... 19
1.9. Padro de projeto Observer, Eventos e Listeners ....................................................................... 21
1.10.
Threads e Excees ................................................................................................................ 25
2. Introduo ao sistema operacional Android ......................................................................................... 28

2.1. Desenvolvimento Android ............................................................................................................ 30
2.2. Preparao do Ambiente de Desenvolvimento ............................................................................. 32
2.3. HelloWorld! .................................................................................................................................. 34
2.4. Estrutura de um projeto e XML .................................................................................................... 36
2.5. Compilao, execuo e depurao .............................................................................................. 39
2.6. Empacotamento, publicao e instalao do app .......................................................................... 45
3. Conceitos Bsicos ................................................................................................................................. 49
3.1. Activity, Intent e IntentFilter......................................................................................................... 50
3.2. Service ........................................................................................................................................... 54
3.3. ContentProvider ............................................................................................................................ 58
3.4. Processo e Thread ......................................................................................................................... 61
3.5. Manifesto....................................................................................................................................... 63
4. Interface Grfica................................................................................................................................... 65
4.1. Layouts .......................................................................................................................................... 67
4.2. Componentes de tela ..................................................................................................................... 74
4.3. Menus ............................................................................................................................................ 81
4.4. Janelas de Dilogo......................................................................................................................... 84
4.5. Notificaes ................................................................................................................................... 86
4.6. Drag and Drop ............................................................................................................................... 91
4.7. Recursos ........................................................................................................................................ 94
5. Conceitos Avanados ........................................................................................................................... 96
5.1. Permisses e Segurana ................................................................................................................ 97
5.2. Preferncias de Usurio............................................................................................................... 100
Android
5.3. Persistncia em Banco de Dados (SQLite) ................................................................................. 102

5.4. Cmera e Arquivos ...................................................................................................................... 105
5.5. GPS e Mapas ............................................................................................................................... 108
5.6. Bluetooth ..................................................................................................................................... 111
5.7. Sensores....................................................................................................................................... 114
5.8. OpenGL, games, redes sociais e tendncias ................................................................................ 117
4. Exerccios ............................................................................................................................................ 120
Anotaes ................................................................................................................................................ 123
Android
1. Introduo plataforma Java

Java mais que uma linguagem de programao, uma plataforma. Partindo
deste conceito, consegue-se analisar o histrico, as principais utilidades, vantagens e
desvantagens de trabalhar com o Java, utilizando exemplos de cdigo e explorando os
principais comandos.
Criada no incio dos anos 90 pela Sun Microsystems com o objetivo de ser uma
linguagem independente de plataforma de execuo, Java segue os paradigmas de
linguagem Orientada a Objetos (OO), o que era uma tendncia no desenvolvimento de
software na poca de seu surgimento. Diferentemente de outras linguagens, cujos
cdigos eram compilados para cdigo-nativo, Java compilado em bytecode, sendo este
interpretado e executado por uma mquina virtual, no caso a JVM (Java Virtual
Machine). Isto permite que o mesmo programa desenvolvido em Java seja executado em
sistemas operacionais diferentes (como Windows e Linux, por exemplo).
A Sun disponibiliza a maioria das extenses e distribuies Java de forma gratuita,

obtendo receita com softwares especializados e mais robustos. Dentre as diversas
extenses e distribuies Java, pode-se destacar:
JSE (Standard Edition): a plataforma Java de utilizao mais comum,
possui todos os recursos para o desenvolvimento de uma aplicao de
ambiente de trabalho completa, como bibliotecas de cdigo, compilador,
mquina virtual e ferramentas e APIs auxiliares;
JEE (Enterprise Edition): a plataforma Java mais completa, possui todos
os recursos da JSE e mais ferramentas e recursos especficos para o
ambiente coorporativo (servidores) e web, como novas APIs de acesso a
dados e segurana;
Android
JME (Micro Edition): a plataforma Java mais reduzida, especfica para

utilizao em sistemas embarcados e mveis, contm menos recursos que a
JSE, mas com APIs especficas, como de gerenciamento de MIDIs,
Bluetooth, Wireless, GPS, etc;
JSP (Server Pages): a tecnologia utilizada para a criao de pginas web,
tem um comportamento semelhante ao ASP da Microsoft e o PHP e
normalmente utilizada em combinao com o JEE (com Servlets,
componentes de integrao Java, HTML e XML);
JRE (Runtime Edition): o conjunto de ferramentas necessrias para a
execuo de aplicaes Java, como a JVM (mquina virtual), algumas
bibliotecas de execuo e outros utilitrios;
Em 2006, Java foi parcialmente liberado como software livre sob a licena GNU
(General Public License), sendo completamente licenciado como livre em 2007. A Sun foi
comprada pela Oracle em 2009, o que no interferiu na licena de distribuio Java.
Dessa forma, Java possui uma comunidade muito grande de desenvolvedores, o que d
linguagem a vantagem de possuir uma enorme gama de frameworks (alguns pagos, mas
a maioria gratuita), teis para diversas ocasies de desenvolvimento, e IDEs (Integrated
Development Environment), ou seja, ambientes de desenvolvimento. A ferramenta mais
utilizada para o desenvolvimento Java at 2011 o IDE Eclipse.
Orientado ao desenvolvimento baseado em plugins, o Eclipse uma ferramenta de
cdigo-fonte livre robusta, capaz de executar as principais operaes de produo de
software (codificao, compilao, depurao, modelagem, persistncia, teste,
publicao, etc.). Os diversos plugins disponveis do ao Eclipse a capacidade de
produzir cdigos no s Java, mas tambm PHP, Python, Ruby, Action Script, dentre
outros, alm de agregar funcionalidades diversas na codificao dessas linguagens. Um
dos plugins mais conhecidos do Eclipse o ADT (Android Development Tools), que
combinado com o SDK (Standard Development Kit), biblioteca de desenvolvimento
Android disponibilizada de forma gratuita pela Google, d ao desenvolvedor o poder de
no s programar Java para Android, mas tambm emular dispositivos para testes e
depurao.
As verses mais robustas de Java possuem bibliotecas de suporte interface
grfica, como a Swing, que possui elementos de controle de layout (em tabela, em
camadas, etc.) e componentes de tela, alm de suporte a controle de eventos para
tratamento desses componentes.
Android
1.1. Comandos bsicos

A capacitao Android focada no desenvolvimento a partir de Java. Assim,
importante o conhecimento dos principais comandos utilizados na linguagem, sendo aqui
apresentados de forma sintetizada.
Ao estudar Java, fala-se de Classes e Objetos. Resumidamente, Classe a
generalizao de uma espcie e objeto um representante nico desta espcie. Classes
possuem atributos (informaes/propriedades) e mtodos (aes/funes).
Exemplo de cdigo Java:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Toda classe Java, quando executada diretamente, iniciada atravs do mtodo

main. Desta forma, no exemplo acima, ao executar a classe HelloWorld, o
programa exibir em console, atravs do mtodo System.out.println();, a frase
Hello, World!.
Android
1.2. Tipos de dados
Tipo
Bits
Bytes
Mnimo
Mximo
Ex.:
byte
-27
27-1
99
short
16
-215
215-1
9999
int
32
-231
231-1
999999999
long
64
-263
263-1
99999999999999
float
32
99999999.99
double
64
- 9999999999999.99
verdadeiro/falso true/false
True
boolean
char
String
caractere
caracteres
abc
O tipo String no um tipo primitivo, mas sim uma Classe. Diferentemente de

outras Classes, String no necessita de instanciao (uso do comando new), apenas
atribuio normal. Porm, ao ser atribudo, um String pode ser modificado apenas
pela utilizao de mtodos ou alguns operadores especficos.
Android
1.3. Operadores
Operador
Descrio
Ex.:
Atribuio
int x = 1; // x 1
Adio
int x = 9+1; // x 10
Subtrao
int x = 4-3; // x -1
Diviso
int x = 4/2; // x 2
Multiplicao
int x = 1*5; // x 5
Mdulo
int x = 4%2; // x 0
+=
Adio seguida de atribuio
int x = 1;
x+= 10; // x 11
-=
Subtrao seguida de atribuio
int x = 10;
x-= 5; // x 5
++
Adio prpria
int x = 1;
x++; // x 2
--
Subtrao prpria
int x = 1;
x--; // x 0
Android
1.4. Operadores relacionais
Operador
Descrio
Ex.:
==
Igual
if(x == 1)
!= ou <>
Diferente
if(x != 1) ou if(x <> 1)
&&
if(x != 1 && x != 0)
||
Ou
if(x != 1 || x == 0)
<
Menor
if(x < 1)
>
Maior
if(x > 1)
<=
Menor ou igual
if(x <= 1)
>=
Maior ou igual
if(x <= 1)
Para comparao de String, necessria a utilizao de mtodos especficos da

prpria classe, como o equals. Ex.:
String x = abc;
if (x.equals(abc)) {
System.out.println(" abc.");
}
Android
1.5. Comentrios
Os comentrios em Java podem ser escritos em linha:
// isto um comentrio
Ou em blocos:
/* este um comentrio em blocos
* utilizado para comentrios longos
* ou gerao de documentao automtica */
Os comentrios em Java podem ser teis para documentao automtica de cdigo

(Javadoc). Para isso, deve ser respeitado um modelo de comentrio em blocos e este
adicionado antes de declaraes de Classes, atributos e mtodos. Ex.:
/**
*
* Valida a incluso de um pedido.
*
* @param numeroPedido Nmero do pedido a ser finalizado
* @param valor
Valor total to pedido
* @param codigoCliente Referencia ao cliente do pedido
* @param data
Data do pedido
*
* @return verdadeiro se o pedido foi includo e falso se houve erro
*
* @author
Joo Primeiro
* @author
Z Segundo
*
**/
boolean finalizaPedido (int numeroPedido, double valor, int
codigoCliente, Date data)
{
}
10
Android
1.6. Pacotes, Classes e Objetos

O conceito de Classes e Objetos define que uma Classe define um conjunto de
elementos com caractersticas em comum. Cada um desses elementos possui uma
identidade prpria, assim como suas caractersticas peculiares, sendo chamados de
Objetos. Cada Classe possui, alm das caractersticas (atributos), mtodos, que
representam o comportamento, as aes e funes realizadas pelos Objetos.
Objetos, ento, so a interpretao em programao de um elemento do mundo
real, sendo ele representante pertencente de uma Classe em especfico. Cada objeto
possui valores de caractersticas prprios, conforme o conjunto de caractersticas
definido em sua Classe. Por exemplo, seguindo a anlise do cdigo abaixo:
public class
public
public
public
public
Pessoa {
String nome;
int idade;
float altura;
float peso;
// construtor padro
public Pessoa(){}
// construtor atribuindo nome
public Pessoa(String nome) {
this.nome = nome;
}
public void falar() {
System.out.println(Ol, meu nome + this.nome + .);
}
}
A classe Pessoa define um conjunto de atributos e aes em comum entre todos

os representantes deste grupo (Objetos). Alm disso, esto definidos dois mtodos
construtores. Para criar uma nova instncia de objeto do tipo Pessoa, utilizado o
comando new. Este commando realiza uma chamada ao mtodo construtor definido
conforme os parmetros passados a ele. Caso no sejam passados parmetros,
realizada a chamada ao construtor padro.
11
Android
public class Main {

Pessoa pessoa1 = new Pessoa();
pessoa1.nome = Jo;
pessoa1.falar();
// exibe no console Ol, meu nome Jo.
}
}
ou
public class Main {
Pessoa pessoa1 = new Pessoa(Jo);
pessoa1.falar();
// exibe no console Ol, meu nome Jo.
}
}
importante observar que Java case-sensitive, ou seja, h diferenciao de

cdigo entre letras minsculas e maisculas. O padro de escrita de cdigo utilizado
deve ser o adotado pela equipe de desenvolvimento do programa. Nesta apostila, foi
adotada a conveno sugerida pela Sun:
Mtodos e Atributos: iniciam com letra minscula e palavras compostas utilizam
letra maiscula para troca. No devem ser utilizados espaos nem acentos e caracteres
especiais, alm de no ser comum utilizar artigos e preposies. Ex.: nome, idade,
nomePai, quantidadeItens, realizaCompra(), finalizaPedido();
Variveis e Classes: todas palavras iniciam com letra maiscula, inclusive na
troca para palavras compostas. No devem ser utilizados espaos nem acentos e
caracteres especiais, alm de no ser comum utilizar artigos e preposies. Ex.: Pessoa,
Animal, Pedido, ItemPedido, CarinhoCompras.
Pacotes, por sua vez, so colees de Classes e cdigos responsveis por conceitos
em especfico. Por exemplo, alguns dos Pacotes utilizados em Java so:
12
Android
java.lang; - inclui no cdigo referncias s Classes principais para codificao,

como String, Math, Thread, Object, etc.;
java.util; - inclui no cdigo referncias s principais Classes auxiliares para
codificao, como Collection, List, Date, etc.;
A chamada de incluso de Pacotes feita sempre no incio do arquivo de cdigo,
nas primeiras linhas, podendo ser includas Classes e divises especficas de um Pacote,
ou o Pacote inteiro. Ex.:
import java.io.*; // importa todo o pacote java.io;
import java.util.regex.*;
// importa toda a diviso regex do pacote java.util;
Dentre as principais Classes Java pode-se considerar:

String: classe responsvel pela construo e manipulao de textos. Seus
principais mtodos so:
- charAt(): Obtm o caracter localizado na posio especificada;
- startsWith(): informa se o texto inicia com o prefixo fornecido;
- endsWith(): informa se o texto termina com o sufixo fornecido;
- equals() : Compara contedo, caracter-a-caracter;
- equalsIgnoreCase() : Compara contedo, caracter-a-caracter
ignorando o aspecto maiscolo/minscolo
- indexOf(): obtm a posio da primeira ocorrncia do argumento;
- intern(): retorna uma referncia para um objeto String correspondente
armazenado no "pool";
- lastIndexOf(): obtm a posio da ltima ocorrncia do argumento;
- length(): obtm a quantidade de caracteres;
- substring(): obtm o trecho desejado;
- split(): quebra o texto em pedaos;
- toLowerCase(): obtm o texto equivalente em letras minsculas;
- toUpperCase(): obtm o texto equivalente em letras maisculas;
- trim(): obtm o texto equivalente sem espaos laterais;
- valueOf(): obTm o valor textual do dado de tipo primitivo fornecido.
13
Android
Math: classe responsvel pela construo e manipulao de equaces e clculos

matemticos;
Array: principal classe responsvel pela construo e manipulao de colees de
objetos (funcionamento semelhante a listas e vetores);
Thread: classe responsvel pela construo e manipulao de processamentos
paralelos;
System: classe responsvel pela manipulao e exibio de comportamentos de
sistema, como trabalhos com data e hora, propriedades de sistema, etc.;
Existe em Java, tambm, a abstrao de Classes. Uma Classe Abstrata uma
classe que serve de modelo para as classes filhas na sua hierarquia, com estas herdando
mtodos e atributos da Abstrata pai. Por exemplo, pode-se ter uma Classe abstrata
Eletrodomestico com os atributos bsicos em comum entre todos os eletrodomsticos,
assim como seus mtodos, e ter as classes respectivas a cada tipo de eletrodomstico,
como TV, contendo dados referentes aos mesmos. Classes abstratas no podem ser
instanciadas diretamente (atravs do new). O mesmo vale para mtodos abstratos,
valem as declaraes realizadas nas classes filhas.
public abstract class Eletrodomestico {

public boolean ligado;
public int voltagem;
// obrigatriamente implementados nas classes derivadas
14
Android
public abstract void ligar();

public abstract void desligar();
}
public class TV extends Eletrodomestico {
public int tamanho;
public int canal;
public void ligar(){
this.ligado = true; }
public void desligar(){
this.ligado = false;}
}
Java conta, tambm, com Interface, um tipo de Classe que no possui contedo
implementado, apenas chamadas de declaraes. Interfaces so, em partes, uma soluo
encontrada para a emulao de herana mltipla, recurso no implementado em Java.
Dessa forma, uma Casse Java pode herdar itens da Classe pai e ainda possuir itens de
uma outra Classe modelo. A Interface mais comum utilizada em Java a Runnable,
utilizada em threads e que possui a chamada de mtodo run(), implementado na classe
implementada. Por exemplo:
public class Relogio implements Runnable {
// mtodo de implementao obrigatria derivado do Runnable
public void run(){
// passa as horas
}
}
Por fim, existem ainda as Classes Internas, declaradas internamente a outras

classes, com acesso a atributos e mtodos da externa e no instanciveis diretamente.
Por exemplo:
15
Android
public class Externa {

public class Interna {
public void mostraReferencia() {
System.out.println(A referncia + this);
}
}
}
public static void main(String [] args)

{
Externa ex = new Externa();
Externa.Interna i = ex.new Interna();
i.mostraReferencia();
}
16
Android
1.7. Modificadores de acesso e encapsulamento

Trabalhar com Classes na Orientao a Objetos torna-se mais interessante
quando utiliza-se o encapsulamento. Esta tcnica consiste em agrupar e proteger trechos
de cdigo a fim de adicionar maior integridade de dados e do programa, alm de manter
uma organizao de cdigo e dados conforme padres de desenvolvimento.
O exemplo mais comum de encapsulamento em Java a utilizao de mtodos
get e set para acesso a atributos com modificadores no pblicos. Os principais
modificadores de atributos so:
public: utilizado de forma livre para atribuio ou chamada pelas instncias da
Classe;
protected: tem atribuio ou chamada realizadas apenas nas classes derivadas;
private: tem atribuio ou chamada realizadas apenas na instncia da prpria
classe ou atravs da utilizao de mtodos get e set;
static: define um nico armazenamento em memria de um valor ou chamada de
mtodo, no podendo ser alterado;
final: define o primeiro valor atribudo como o ultimo, no podendo ser alterado,
mais utilizado como definio de constantes;
public class Pessoa {

public String nome;
private float peso;
// construtor padro
public Pessoa(){}
// construtor atribuindo nome
public Pessoa(String nome) {
this.nome = nome;}
public void setPeso(float peso) {
this.peso = peso;}
public float getPeso(){
17
Android
return this.peso;}
}
public class Main {
Pessoa pessoa1 = new Pessoa();
pessoa1.nome = Jo;
//pessoa1.peso = 70; - no funciona
pessoa1.setPeso(70); // funciona
System.out.println(Ol, meu peso +
pessoa1.getPeso().toString() + .);
}
}
18
Android
1.8. Colees
Tipo de Coleo
Classe
Tipo de Mtodo
Mtodo
Genrico
Collection
Adio
Remoo
Acesso
Pesquisa
Atributos
add(Object elemento)
remove(Object elemento)
clear()
iterator()
contains(Object elemento)
size()
Adio
add(int index, Object elemento)
Remoo
Acesso
remove(int index)
get(index)
listIterator
(iterador que pode andar para trs)
indexOf(Object elemento)
Lista
Vector
ArrayList
LinkedList
Pesquisa
Conjunto
Mapa
HashSet
TreeSet
HashMap
TreeMap
Nenhum mtodo a mais

Adio
put(Object key, Object value)
Remoo
remove(Object key)
clear()
get(Object key)
(Isso tambm "pesquisa")
Set entrySet()
(retorna os itens como conjunto)
Set keySet()
(retorna as chaves como conjunto)
Collection values()
(retorna os valores como Collection)
get(Object key)
(Isso tambm "acesso")
Acesso
Pesquisa
Existem alguns tipos de colees em Java que se aplicam melhor a situaes

especficas. Pode-se destacar as Listas, os Conjuntos e os Mapas.
Listas: uma lista uma arrumao de elementos em uma ordem linear, podendo os
elementos serem facilmente ordenados e reorganizados. Pode ser utilizado em formato
de vetor ou de lista encadeada.
19
Android
Conjuntos: so arrumaes de elementos em forma no linear e no ordenadas,

porm sem elementos duplicados. As formas mais comuns de utilizao so como tabelas
hash ou rvores.
Mapas: so arrumaes de elementos em forma de pares (chave e valor),
chamados itens. O grande destaque dos Mapas em Java que tanto os valores quanto as
chaves podem ser de qualquer tipo. Mapas so normalmente utilizados para pesquisa
rpida em grande quantidade de dados.
20
Android
1.9. Padro de projeto Observer, Eventos e Listeners

A utilizao do padro Observer tem como objetivo realizar a conversao
de objetos em tempo real (tempo de execuo) sem a necessidade de prever tal
comportamento em tempo de compilao. Para isso, necessria a utilizao de alguns
elementos em Java.
Source: o Objeto responsvel pela alterao a ser notificada para os Objetos
interessados (listener);
Listener: so os objetos interessados nas modificaes ocorridas no Objeto de
interesse (source).
Como exemplo, identificar uma caixa de e-mails. Imagina-se que um remetente

deseja saber quando seu e-mail chegou na caixa de entrada do destinatrio e este deseja
ser avisado quando h novos e-mails no lidos. Identifica-se um Source (e-mail) e dois
Listeners (remetente e destinatrio). Primeiramente, deve ser criada uma Classe para
o evento de modificao.
21
Android
public class EmailEvent extends EventObject {

public EmailEvent(Object source){
super(source);
}
}
Em seguida, necessria a criao de uma Classe que ir receber as notificaes

de alterao e ser implementada pelos interessados, no caso remetente e destinatrio.
public interface EmailListener {
public void emailRecebido (EmailEvent emailEvent){}
public void emailLido (EmailEvent emailEvent){}
}
Depois, criada a Classe do Objeto a ser modificado.

public class Email {
private Collection<EmailListener> emailListener = new
ArrayList<EmailListener>();
public void enviar(){
disparaEmailRecebido();
disparaEmailLido();
}
public void emailRecebido(){
this.disparaEmailRecebido();
}
public void emailLido(){
this.disparaEmailLido();
}
public synchronized void addEmailListener(EmailListener
emailListener) {
this.emailListeners.add(emailListener);
}
public synchronized void removeEmailListener(EmailListener
emailListener) {
this.emailListeners.remove(emailListener);
}
private void disparaEmailLido(){
22
Android
EmailEvent event = new EmailEvent(this);

for(EmailListener listener : emailListeners) {
listener.emailLido(event);
}
}
private void disparaEmailRecebido(){
EmailEvent event = new EmailEvent(this);
for(EmailListener listener : emailListeners) {
listener.emailRecebido(event);
}
}
}
Em seguida, as classes responsveis pelo remetente e pelo destinatrio devem

implementar a classe de escuta das modificaes.
public class Destinatario implements EmailListener {
public void emailLido (EmailEvent emailEvent){
Email email = (Email) emailEvent.getSource();
System.out.println(Voc acabou de ler o e-mail!);
}
public void emailRecebido (EmailEvent emailEvent){
System.out.println(Voc acabou de receber o e-mail!);
}
}
public class Remetente implements EmailListener {

public void emailLido (EmailEvent emailEvent){
System.out.println(O e-mail + email + acabou de ser
lido!);
}
public void emailRecebido (EmailEvent emailEvent){
System.out.println((O e-mail + email + acabou de ser
recebido!);
}
}
23
Android
Para simular a execuo, cria-se uma classe gerenciadora da caixa de entrada.

public class CaixaEntrada {
public static void main(String[] args){
Email email1 = new Email();
Email email2 = new Email();
Destinatario destinatario = new Destinatario();
Remetente remetente = new Remetente();
email1.addEmailListener(destinatario);
email1.addEmailListener(remetente);
email2.addEmailListener(destinatario);
email2.addEmailListener(remetente);
// aes de modificao a serem notificadas aos
interessados
email1.enviar();
email2.emailRecebido();
}
}
O tratamento de Eventos em Java funciona de maneira semelhante. Atravs de

Listeners, ou seja, handlers que ficam esperando por notificaes de evento, estes so
disparados e executam as aes previstas no cdigo.
24
Android
1.10. Threads e Excees

Um dos grandes diferenciais do Java a qualidade do trabalho com programao
concorrente, as Threads. Em Java muito simples criar concorrncia com bom
gerenciamento de memria e rpido processamento.
Basicamente, existem duas formas de se trabalhar com Threads em Java.

A primeira, consiste em criar uma Classe filha da Classe nativa Thread. Em
seguida, devem ser criados mtodos (ou utilizados comandos avulsos) a serem chamados
dentro do mtodo derivado run().
A segunda forma consiste em, ao invs de extender a Classe nativa Thread,
implementar a Interface nativa Runnable. Desta forma, permitido que seja realizado
um trabalho com Classes derivadas de uma hierarquia e estas possuam trabalhos
concorrentes (lembrando que Java no possui herana mltipla).
A grande diferena de codificao que, aps instanciar uma Runnable, deve
ser criado um objeto do tipo Thread para execuo, passando como parmetro a
referncia quela.
25
Android
public class ExemploRunnable implements Runnable {

public void run() {
int total = 0;
while ((int)(Math.random()*100) != 50){
total++;
}
}
}
public class Main {

ExemploRunnable r = new ExemploRunnable();
Thread t = new Thread(r, "Thread 1");
t.start();
}
}
Dessa forma, a API Java referente a Threads se encarregar de fazer a

execuo concorrente a partir de chamadas como start(), stop(), interrupt(),
suspend(), yield() e resume().
O tratamento de Excees em Java tambm realizado de forma simples. Baseado
no conceito try-catch, onde um comando executado com erro dispara uma informao
de exceo e esta recuperada por um techo de cdigo, possvel criar tratamentos de
exceo especficos para cada caso ou utilizar os tratamentos genricos.
public class Calculadora {
public int divide(int a, int b) throws DivisaoZero {
if (b == 0) throw new DivisaoZero();
return a/b;
}
}
No exemplo acima, foi implementada a funo de diviso de uma calculadora. No

mtodo responsvel pelo clculo, testado se o segundo parmetro zero e, caso
positivo, dispara a exceo DivisaoZero. Esta, uma Classe personalizada, que
deriva da Classe nativa Exception e sobrescreve o mtodo toString().
26
Android
public class DivisaoZero extends Exception {

public String toString() {
return "Diviso por zero.";
}
}
Para utilizar esta exceo, basta realizar a chamada ao mtodo dentro do bloco
try e o cdigo de tratamento dentro do bloco catch.
Calc calc = new Calc();

try {
int div = calc.div(x, y);
System.out.println(div);
} catch (DivisaoZero e) {
System.out.println(e);
}
Java dispe, tambm, do comando finally, responsvel por executar o bloco

mesmo aps o tratamento da exceo.
27
Android
2. Introduo ao sistema operacional Android

A Android Inc. uma empresa adquirida pela Google em 2005. Naquela poca, a
empresa possua a ideia em papel de um sistema operacional para dispositivos mveis,
posteriormente realizado pela compradora.
Android o Sistema Operacional para smartphones e tablets colocado em prtica
e continuado pela Google, em comunidade com a Open Handset Alliance, conjunto de
mais de trinta empresas, dentre elas operadoras de telefonia e fabricantes de
dispositivos. Alm disso, a Google fornece uma biblioteca gratuita para desenvolvimento
de aplicativos Android em Java, cuja comunidade muito grande, o que possibilita uma
grande variedade de aplicativos no Google Play. Esta, por sua vez, a loja e
distribuidora oficial de aplicativos Android, tambm gerenciada pela Google.
Em dezembro de 2011, o Android chegou incrvel marca de mais de 700 mil
aparelhos ativados por dia, ou seja, est em uma crescente de utilizadores, nmeros que
devem aumentar a partir da finalizao da compra parcial da Motorola (uma das
principais fabricantes de aparelhos com Android) pela Google, iniciada em agosto de
2011. Esta presena de uma comunidade forte e o crescente interesse das fabricantes no
sistema operacional o grande diferencial do Android contra os fortes concorrentes da
atualidade (iOS e Windows Phone). Mais aplicativos diferenciados, interfaces
customizadas por operadora e fabricante agradam novos consumidores e at mesmo os
hardcore.
Tecnicamente falando, Android construdo sobre o ncleo Linux. Por ser uma
plataforma em cdigo aberto, possui distribuies em kernel diferentes, o que deixa o
sistema operacional mais personalizvel. Alm disso, um sistema muito robusto,
possuindo recursos nativos como a mquina virtual Dalvik (baseada na JVM), banco de
dados SQLite, touch screen, GPS, grficos 3D, acelermetro, giroscpio e outros.
28
Android
At dezembro de 2011, foram desenvolvidas 7 verses de Android, tendo o

percentual de ativaes conforme o quadro a seguir:
1.5 Cupcake
1,1%
1.6 Donut
1,4%
2.1 Eclair
11,7%
2.2 Froyo
45,3%
2.3.x Gingerbread
38,7%
3.x.x Honeycomb
1,8%
4.0 Ice Cream Sandwich
0%
As verses 3 e 4 so oficialmente licensiadas para tablets.

O mercado tende mobilidade e esta age cada vez mais integrada com a web, com
produtos e servios de empresas, atuando como um mediador e uma nova ferramenta de
comunicao. cada vez mais comum aplicativos com interfaces grficas melhores,
compatveis com diversos dispositivos com recursos de tela diferentes, e a arte para
aplicaes mveis uma das reas de tecnologia e comunicao que mais crescem.
29
Android
2.1. Desenvolvimento Android

Por ser uma plataforma de cdigo aberto codificada em C++ e Java, Android
possui bibliotecas de desenvolvimento oficiais nessas linguagens e outras formas de
desenvolvimento criadas pela comunidade. A grande parte dos aplicativos Android hoje
so desenvolvidos em Java atravs do SDK (Standard Development Kit) e do plugin
oficial para o IDE Eclipse, o ADT, fornecidos gratuitamente pela Google.
http://developer.android.com/sdk/index.html
Apesar disso, a Google oferece, ainda, o NDK (Native Development Kit),
biblioteca de desenvolvimento em cdigo nativo (C/C++), utilizado para desenvolver
aplicativos que requerem maior manipulao dos recursos fornecidos pela GPU Android
e que no so suportados no SDK (como OpenGL).
http://developer.android.com/sdk/ndk/index.html
Aplicativos desenvolvido para Android so compilados e convertidos em um
pacote APK (Android Application Package). Este pacote um arquivo compactado
(como ZIP) baseado no formato JAR (Java Archive, pacote de execuo Java), que
possui arquivos de referncia, de estrutura e arquivos DEX (Dalvik Executable), capazes
de serem executados pela mquina virtual do Android (a Dalvik).
O Android possui, ainda, um navegador de Internet nativo, construdo em cima da
plataforma Webkit (Chrome, Safari). Por isso, possvel construir aplicativos em
HTML5, executados diretamente no navegador. Existem alguns frameworks, como o
PhoneGap que utilizam tags HTML e as converte e em elementos grficos do prprio
SDK, tornando, assim, o desenvolvimento HTML para Android mais robusto e
compatvel com o Google Play (o framework capaz de gerar um APK com um elemento
navegador web interno na aplicao). No entando, este desenvolvimento ainda no
homologado pela Google e no oferecido suporte pela mesma.
Nos links acima, est includa a documentao completa do SDK Android, que
usado como base para o estudo nesta apostila.
30
Android
31
Android
2.2. Preparao do Ambiente de Desenvolvimento

Para iniciar o desenvolvimento Android em Java em ambiente Windows so
necessrias trs ferramentas. importante observar que, ao atualizar cada ferramenta,
pode ser necessrio atualizar as demais.
IDE Eclipse: http://www.eclipse.org/downloads/packages/eclipse-ide-javadevelopers/indigor
Android SDK: http://developer.android.com/sdk/index.html
Plugin ADT: http://developer.android.com/sdk/eclipse-adt.html
Primeiramente, necessrio instalar o SDK. Aps a instalao, necessrio
entrar na pasta onde foi instalado e executar o SDK Manager.exe.
32
Android
Nesta tela possvel escolher quais pacotes sero baixados e instalados.

recomendvel baixar todos, pois em momentos especficos pode ser necessrio
desenvolver aplicaes para aparelhos mais antigos, que no suportam as API novas.
Alm do que, existem pacotes de exemplos e add-ons de outros fornecedores.
Aps esta instalao possvel, no menu Tools -> Manage AVDs, configurar
um emulador, selecionando opes de configurao como tipo e tamanho de tela e outros
componentes hardware, ou selecionando um emulador pr-definido.
No Eclipse, no menu de ajuda, existe a opo de instalar novos recursos. Basta
inserir o link para procura disponibilizado pela Google e instalar o pacote completo.
https://dl-ssl.google.com/android/eclipse/
33
Android
2.3. HelloWorld!
Como primeiro projeto e para ambientao no Eclipse, cria-se o projeto padro
Hello World. Na rea esquerda do ambiente existe o explorador de projetos. Basta
abrir o menu flutuante do projeto e selecionar a opo New -> Android Project.
Em seguida, coloca-se o nome do projeto (no caso HelloWorld) e seleciona-se,

em Build Target a verso de API a ser utilizada (no caso, mais atual). interessante
observar que para cada verso de API existe uma opo bsica e uma opo Google
API, que inclui cdigos de integrao entre servios Google.
Na seo Properties, necessrio preencher o nome da aplicao
(HelloWorld), o nome do pacote (hello.world), a principal Activity
(HelloWorldActivity) e a verso mnima de API (a mesma selecionada no Build
Target, como por exemplo 8). Por fim, basta finalizar a criao.
34
Android
Conforme configurado, o prprio SDK se encarrega de criar a atividade principal

(HelloWorld Activity), cujo cdigo pode-se conferir em src -> hello -> world ->
HelloWorldActivity.java.
Uma Activity (atividade) , basicamente, uma Classe com escopo de execuo.

Possui o mtodo onCreate que responsvel por executar o primeiro cdigo da
Classe. Dessa forma, quando define-se uma Activity principal de incio, executa-se sua
criao em primeiro lugar.
35
Android
2.4. Estrutura de um projeto e XML

Conforme pode-se analisar no navegador de projetos do Eclipse, uma aplicao
Java para Android dividida em diversos componentes. Cada pasta e sub-pacotes do
projeto responsvel por alguma funo na aplicao e pode-se destacar alguns
elementos:
assets: a pasta utilizada para armazenamento de mdias diversas, como imagens,

vdeos, msicas, que no so utilizadas como elementos de layout, mas de contedo;
bin: pasta onde fica armazenado o cdigo compilado das classes Java;
gen: pasta de arquivos gerados automaticamente pelo SDK. Esta pasta, assim
como seus arquivos, no deve ser modificada, pois qualquer alterao pode
comprometer a integridade do cdigo gerado automaticamente. A Classe R muito
importante, pois ela armazena referncias hexadecimais a todos componentes globais da
aplicao, como elementos de layout;
36
Android
res: pasta de recursos. Possui subpastas drawable-* responsvel por armazenar

as imagens para elementos de tela (layout) em diversas resolues (ldpi, mdpi e
hdpi referenciam baixa, mdia e alta qualidade, respectivamente). A pasta layout
possui os arquivos XML de layout, onde cada um destes arquivos formado por tags que
respresentam os elementos de tela (como campos de texto, botes e grades de
alinhamento) e so utilizados em Classes Activity. Por fim, h a pasta values, que
por sua vez possui arquivos XML diversos, mais utilizados para definies de constantes
globais, como o strings.xml;
src: pasta responsvel por armazenar todas as classes do projeto, podendo ser
separadas por pacotes secundrios ou no.
Existe, ainda, o arquivo AndroidManifest.xml, responsvel pelas principais
definies da aplicao, como nmero da verso de cdigo, verso de SDK, referncias
a cone e nome da aplicao, permisses de acesso e recursos necessrios, declarao
de atividades, servios e demais componentes da aplicao, etc.
Para melhor interpretao da estrutura de arquivos de uma aplicao Java para
Android, interessante conhecer o funcionamento da linguagem XML. Extensible
Markup Language (Lnguagem de Marcao Extensvel) um recurso recomendado pela
W3C (consrcio internacional regulamentador da web) para manipulao de dados de
forma especfica. Com o XML, possvel montar estruturas de dados baseadas em tags,
realizando agrupamentos de tags e adicionando atributos e valores a elas. Dessa forma,
possvel compartilhar dados especficos, com uma quantidade ilimitada de tags
diferentes, em uma linguagem compreensvel tanto por computadores quanto por
humanos.
Exemplo de cdigo XML:
<?xml version="1.0" encoding="ISO-8859-1"?>
<receita nome="po" tempo_de_preparo="5 minutos"
tempo_de_cozimento="1 hora">
<titulo>Po simples</titulo>
<ingredientes>
<ingrediente quantidade="3"
unidade="xcaras">Farinha</ingrediente>
<ingrediente quantidade="7"
unidade="gramas">Fermento</ingrediente>
<ingrediente quantidade="1.5" unidade="xcaras"
estado="morna">gua</ingrediente>
<ingrediente quantidade="1" unidade="colheres de
ch">Sal</ingrediente>
37
Android
</ingredientes>
<instrucoes>
<passo>Misture todos os ingredientes, e dissolva
bem.</passo>
<passo>Cubra com um pano e deixe por uma hora em um local
morno.</passo>
<passo>Misture novamente, coloque numa bandeja e asse num
forno.</passo>
</instrucoes>
</receita>
A partir de um arquivo XML possvel construir um interpretador em diversas

linguagens, muitas das quais possuem API com suporte especfico a leitura deste tipo de
arquivo. Assim, diversas aplicaes podem partilhar de uma mesma fonte de dados. O
grande exemplo a utilizao de arquivos XML em WebServices (recursos de
compartilhamento de informaes e integraes entre servios na web), como o
fornecimento de dados do Twitter.
38
Android
2.5. Compilao, execuo e depurao

O SDK Android conta com um emulador de plataformas Android, chamado de AVD
(Android Virtual Device). No diretrio de instalao do SDK existe um programa
chamado AVD Manager.exe, onde possvel configurar diversos emuladores, para as
diversas verses do sistema Android.
Na tela principal, possvel visualizar, modificar, remover ou inicializar um
dispositivo.
Nas opes de criao ou modificao de um dispositivo existente, possvel

configurar opes bastante flexveis para emulao, como tamanho da tela, tamanho de
espao para o carto SD (carto de memria), modelo do processador, etc.
39
Android
Assim, possvel emular praticamente qualquer dispositivo lanado oficialmente

no mercado, tanto smartphones quanto tablets.
No ambiente Eclipse, possvel compilar e executar uma aplicao Android
diretamente nos emuladores criados pelo AVD Manager. No menu flutuante do projeto,
em Run As -> Run Configurations... possvel gerenciar a execuo da aplicao. Na
opo de criar uma nova configurao, possvel selecionar na aba Android o projeto
a ser executado e a Activity a ser executada (inicialmente seleciona a Activity
padro, definida no AndroidManifest.xml ou na criao do projeto). Na aba Target,
selecionado qual o dispositivo emulado a ser executado e algumas opes para ele,
como a alocao de banda de Internet disponvel para ele. O ideal manter o padro
para selecionar o dispositivo manualmente no momento da execuo do app (aplicativo).
Por fim, na aba Commons existem configuraes diversas, como o endereo de
armazenamento da configurao, configuraes de I/O e execuo.
40
Android
Feito isso, basta utilizar a opo Run ou finalizar e selecionar a partir do menu
suspenso, em Run As, a configurao recm criada.
41
Android
Alm do dispositivo emulado, pode-se trabalhar com um dispositivo real conectado

via porta USB. Para isso, o dispositivo deve estar configurado com a opo Depurao
USB ativada e ele aparecer na tela de seleo de destino de execuo (mesma dos
emuladores) do app.
O projeto compilado automaticamente no momento da execuo e o IDE acusar
no console uma informao de erro no cdigo, quando houver. Para apenas compilao
manual, necessrio utilizar a opo do menu principal Project -> Build Project.
interessante observar que, quando ocorrem muitas incluses de arquivos internos e
modificaes de cdigo seguidas sem compilao, pode ocorrer uma m formao dos
arquivos gerados automaticamente. Para corrigir isso, basta utilizar a opo do menu
principal Project -> Clean... e, logo aps, executar ou utilizar o Build no projeto.
O processo de depurao muito semelhante ao de execuo. Ao invs de utilizar
o menu Run As, utiliza-se o Debug As. O processo de depurao monta a mquina
virtual com opes para execuo passo-a-passo, o que ajuda muito no diagnstico de
problemas runtime (em tempo de execuo). Os erros de cdigo so filtrados em tempo
de compilao, ao realizar o Build do projeto, porm os erros lgicos no tratados
podem gerar falhas em tempo real de execuo (como o caso da diviso por zero). Neste
caso, pode-se observar no console a linha de cdigo responsvel pela mensagem de
falha. Com o cursor marcado nesta linha de cdigo da Classe especfica, pode-se utilizar
os comandos de debug, encontrados no menu principal Run -> Toogle Breakpoint. Ao
executar a aplicao, na parte referente ao trecho de cdigo sinalizado, a mquina
virtual realizar uma pausa e o IDE redireciona para o ambiente de depurao, onde
possvel realizar alteraes ou sinalizar novas paradas.
42
Android
Neste ambiente, possvel analisar os processos realizados pela mquina virtual

na interpretao do programa, analisar variveis e propriedades atribudas da mesma
maneira que em um teste de mesa, visualizar o console e visualizar passo a passo a
interpretao do cdigo.
Os principais comandos de depurao so encontrados no menu principal Run:
Step Into: avana para a primeira linha de processamento aps a linha atual,
considerando a entrada em mtodos, ou seja, caso a linha atual seja uma chamada de
mtodo, o depurador avana para a primeira linha do escopo deste mtodo;
Step Return: avana para a primeira linha de processamento aps sair do mtodo
atual, frequentemente utilizado para sair de um Step Into;
Step Over: avana para a primeira linha de processamento aps a linha atual, sem
entrar no mtodo chamado, quando for o caso.
Para depurao mais avanada, como anlise de gerenciamento de memria,
armazenamento e processamento, existe o ambiente DDMS (Dalvik Debug Monitor
Service). Todos ambientes disponibilizados no IDE podem ser alternados pelos seus
botes de atalho (por definio no canto superior direito) ou atravs do menu principal
Window -> Open Perspective.
43
Android
Com a utilizao do DDMS possvel enviar para o emulador, mudanas de sinal

(como, por exemplo, a perda de conexo de dados 3G), mudana de localizao GPS,
simulao de entrada de chamada, etc. importante entender que este funcionamento
est relacionado apenas dispositivos emulados, e no funciona com dispositivos reais
conectados e depurados. Alm disso, na guia Allocation Tracker, possvel monitorar
a alocao de objetos em memria, selecionando na guia Devices qual o aplicativo a
ser monitorado (no caso, o HelloWorld). Atravs do File Explorer, possvel
controlar a entrada e sada de elementos no sistema de arquivo do emulador, assim
como do seu carto SD simulado, o que pode ser muito til em aplicaes que gerenciam
arquivos (por exemplo, uma cmera). Por fim, pode-se analisar o LogCat, responsvel
pela exibio de mensagens de mais baixo nvel, diretamente da mquina virtual, com a
possibilidade de realizar filtros de busca.
44
Android
2.6. Empacotamento, publicao e instalao do app

Aps uma aplicao Android ser bem arquitetada, codificada, enfim produzida,
necessrio realizar o empacotamento para instalao nos dispositivos, alm da
publicao no Google Play. Um arquivo executvel de uma aplicao Android
exportado em formato APK, que compacta as informaes necessrias para
interpretao do programa.
Para gerar um APK a partir do Eclipse relativamente simples. Com o menu
suspenso Android Tools -> Export Application Package possvel escolher entre duas
opes, Signed ou Unsigned. Para eventuais testes e distribuio no oficial (como
verses beta), possvel gerar um pacote no assinado (unsigned). J para publicao
no Google Play, obrigatrio que o aplicativo seja digitalmente assinado (signed). Para
isso, necessrio criar uma chave de assinatura digital criptografada, contendo um
encapsulamento por usurio e senha e dados informativos, como validade do certificado
e nome e localizao da empresa produtora do app.
45
Android
Com o APK gerado e digitalmente assinado, possvel envi-lo para publicao

no Google Play.
https://play.google.com/apps/publish/
Acessando o endereo acima, devidamente autenticado com uma conta Google,
possvel enviar um arquivo APK, informando dados de publicao, como nome do app,
verso atual, descritivo do produto, categoria, vdeos e imagens de divulgao, logo, etc.
46
Android
47
Android
interessante observar algumas opes disponveis na publicao. A principal

delas a opo de proteger o aplicativo contra cpias, o que faz com que o aplicativo
tenha que ser baixado atravs do Play, no podendo ser copiado para outros
dispositivos. Em uma aplicao gratuita onde a necessidade a distribuio em larga
escala, pode ser um bom recurso a desativao da proteo contra cpias.
possvel, ainda, definir um valor de venda do aplicativo. O recebimento dos
valores realizado atravs da conta Google configurada no Google Checkout, o
mesmo sistema de recebimentos utilizado pelo Google AdSense. A Google realiza
pagamentos acima de U$ 100,00, atravs de transferncia por bancos internacionais,
portanto necessrio ter uma conta que suporte tal recebimento.
Aps a aprovao dos regulamentos e diretrizes impostas pela Google, o
aplicativo est imediatamente disponvel nos pases optados atravs do cadastro. Outro
diferencial do sistema da Google sobre os concorrentes a publicao, onde a avaliao
de integridade realizada aps a publicao, fazendo com que esta seja instantnea.
48
Android
3. Conceitos Bsicos
Para construir um aplicativo alm do HelloWorld necessrio conhecer um
pouco mais sobre os componentes fundamentais do Android.
Activities: classes (Activity) responsveis pelo cdigo back-end de uma
interface grfica, onde tudo comea na aplicao;
Services: classes (Service) responsveis por cdigos a serem executados por
tempo maior, em segundo plano, sem a necessidade de interveno por parte do usurio;
Content Provider: no Android, no possvel acessar contedo de outros
aplicativos diretamente a partir de um aplicativo terceiro. Para resolver isso, existe esta
classe que fornece os contedos como, por exemplo, o acesso galeria de fotos ou
agenda de contatos, atravs de chamadas e URI (Uniform Resource Identifier)
especficos. possvel, ainda, implementar provedores de contedo prprios para acesso
externo;
Intent e IntentFilter: a classe Intent funciona (como nome sugere, inteno)
como uma chamada permisso de execuo de ao. Toda ao solicitada ao Android
para executar um Intent, como a transio entre Activity, realizao de uma
chamada telefnica ou acesso a um ContentProvider. IntentFilter, por sua vez,
serve para predefinir chamadas para Intents especficos atravs de constantes,
indicando quais recursos a atividade tem interesse em utilizar;
Processos e Threads: por padro, o sistema Android gerencia toda a aplicao em
um nico processo. Em alguns momentos pode ser interessante criar processos
separados para algumas atividades, a fim de que a quebra dela no interfira na quebra
do sistema. J a concorrncia de cdigo (Thread) funciona como uma nica
concorrncia de interface, podendo ser necessrio separar alguns processamentos dela.
49
Android
3.1. Activity, Intent e IntentFilter

Partindo do conceito de que uma atividade (Activity) Android funciona como
um gerenciador back-end de uma interface grfica, pode-se entender que esta possui
um ciclo de vida, e que cada fase deste ciclo possui suas prprias funes e
caractersticas.
50
Android
Pode-se notar que a utilizao de chamadas de espera (pause) de uma atividade

para exibio de outra um processo muito comum e prtico, porm importante
observar que o gerenciamento de memria em uma aplicao mvel bastante delicado.
necessrio possuir a certeza de que o processo no ser interrompido ao executar uma
espera, caso contrrio o contedo do processo anterior poder ser perdido.
Quando realiza-se a transio entre atividades (e esta pode ser feita com suporte a
transies grficas de UI, User Interface), a atividade nova passa ao estado de
execuo, enquanto a anterior passa ao estado de espera, caso no haja despejo de
memria. Desta forma, a atividade em execuo consegue se comunicar com a atividade
em espera. A maneira mais comum de realizar transio entre atividades a partir da
criao de um Intent.
public class Main extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
final Button addButton = (Button)findViewById(R.id.bAdd);
addButton.setOnClickListener(add_listener);
}
OnClickListener add_listener = new OnClickListener() {
@Override
public void onClick(android.view.View v) {
Intent myIntent = new
Intent(getApplicationContext(),AddClass.class);
myIntent.putExtra("id_item", 0);
startActivity(myIntent);
}
}
}
Vale pena observar o tratamento de eventos em uma interface Android. No

exemplo acima, foi criado um Objeto OnClickListener e atribudo ao boto
addButton. Desta forma, ao acion-lo na aplicao, criado um novo Intent
referente Activity AddClass, passado um parmetro de referncia id_item
como 0 (em uma edio, pode-se passar o ID do item, por exemplo) e iniciada a
atividade.
Outro cdigo importante referente criao do boto addButton. possvel
notar que o parmetro passado ao mtodo findViewById R.id.bAdd. Isso porque a
51
Android
classe R, responsvel por armazenar referncias em hexadecimal dos elementos de

layout possui subclasses, dentre elas a id, responsvel por referenciar diretamente
elementos grficos. Imaginado que existe um arquivo de layout correspondente
atividade (no caso, R.layout.main representa o arquivo main.xml), entende-se que
existe um elemento com ID bAdd, neste arquivo.
Aps a utilizao do putExtra() para passar parmetros ao Intent, possvel,
na inicializao da atividade chamada recuperar estes parmetros atravs do seguinte
cdigo.
Bundle extras = getIntent().getExtras();
int id_item = extras.getInt(id_item);
possvel buscar o contedo do armazenamento de parmetros a partir de

mtodos como getInt(), tambm utilizado com String (getString()) ou qualquer tipo
primitivo, dependendo do parmetro passado no putExtra().
Dentre os principais mtodos da classe Activity, pode-se destacar:
onCreate() - o primeiro mtodo a ser executada quando uma Activity
instanciada. Geralmente o mtodo responsvel por carregar os layouts (XML).
executada somente uma vez durante o ciclo de vida;
onStart() - chamado imediatamente aps a criao, mas tambm quando uma
Activity em background volta a ter foco;
onResume() - assim como onStart(), chamado na inicializao e na
reinicializao da Activity. A diferena que onStart() s chamado quando a
Activity no mais visvel na tela volta a ter foco, enquanto onResume() sempre
chamado;
onPause() - o primeiro mtodo a ser invocado quando a Activity perde o foco
(ou seja, uma outra Activity entrou em execuo);
onStop() - anloga onPause(), s chamada quando a Activity fica
completamente encoberta por outra Activity (no mais visvel).
onDestroy() ltimo mtodo do ciclo de vida a ser executado. Depois, a
Activity considerada morta, ou seja, no podendo ser reiniciada;
onRestart() - chamado imediatamente antes de onStart(), quando uma
Activity volta a ter o foco aps estar em background.
52
Android
Como j visto anteriormente e utilizado no exemplo, um Intent (no sentido

literrio, inteno), a informao de chamada de execuo especfica do sistema a
realizar. Na anlise do cdigo, nota-se o uso simples de um Intent, utilizando o
contexto atual da aplicao e passando a referncia de uma Classe a ser utilizada como
atividade. Isso faz com que a atividade chamada entre em plano principal.
Com a utilizao de IntentFilter possvel informar quais recursos estaro
disponveis para a atividade (no confundir com permisses) para que esta possa ser
mais enxuta possvel. Para cada atividade, necessrio definir no manifesto a utilizao
deste filtro, assim como criar as categorias disponveis (ao menos uma necessria).
Dentro da tag <application/>, devem ser definidas todas as atividades do
programa (sempre) e os filtros de intenes das respectivas atividades.
<activity
android:name=".Main"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"
/>
</intent-filter>
</activity>
No caso, a atividade referente classe Main possui os interesses em ser a

principal atividade (MAIN) e poder ser inicializada pelo app launcher
(LAUNCHER).
A lista completa de filtros pode ser encontrada no endereo:
http://developer.android.com/reference/android/content/Intent.html
53
Android
3.2. Service
Um servio (Service), semelhantemente a uma atividade, tambm possui um
ciclo de vida, porm este vlido at o sistema necessitar de memria, caso no haja um
pedido de interrupo previsto.
Servios so utilizados normalmente para executar algum processo em segundo

plano, onde no seja necessria a interveno por parte do usurio. Um exemplo comum
o download de apps do Google Play. Ao solicitar o download, criado um cone na
barra de notificao que indica que o app est sendo baixado. Este processo de
download executado em segundo plano e no necessita interveno por parte do
usurio para ser concludo.
Existem dois tipos de servios, os locais e os remotos. Servios locais so aqueles
executados dentro do processo da aplicao, sem necessidade de nenhuma interferncia
remota. Poderiam ser substitudos por Thread, porm, em processamentos mais
complexos, uma Thread pode gerar problemas, enquanto um Service tem
propriedades especficas de processamentos mais complexos. J os servios remotos so
executados em um processamento em separado da aplicao principal, totalmente
independente, podendo ser executado em segundo plano sem a aplicao principal estar
em execuo (como uma quebra de memria). Geralmente, so utilizados para
construo de webservices, onde a dependncia de uma conexo de Internet alta e
torna-se interessante a excluso do processamento. O que diferencia estes dois tipos
sua declarao no manifesto (AndroidManifest.xml).
54
Android
Alm disso, existem dois tipos de implementao de um servio Android. A

primeira consiste no Unbounded ou Started, onde o servio iniciado e somente
ser interrompido quando for solicitada sua parada atravs de cdigo prprio ou de
outra aplicao que tenha poder de interferncia nele (o que declarado no manifesto).
A segunda consiste no Bounded, onde o servio fica permanentemente amarrado
aplicao que o iniciou, sendo o servio finalizado por cdigo explicitou ou
encerramento da aplicao que o iniciou. A diferena est nos mtodos utilizados para
codificao. Enquanto um servio Started executado a partir do startService(),
um servio Bounded iniciado pelo bindService().
55
Android
public class HelloServico

int mStartMode;
IBinder mBinder;
boolean mAllowRebind;
extends Service {
// indica o comportamento do servio
// interface para os clientes amarrados
// indica que o service pode ser amarrado
@Override
public void onCreate() {
// servio criado
}
@Override
public int onStartCommand(Intent intent, int flags, int startId)
{
// service iniciado pelo startService()
return mStartMode;
}
@Override
public IBinder onBind(Intent intent) {
// cliente conectado ao servio pelo bindService()
return mBinder;
}
@Override
public boolean onUnbind(Intent intent) {
// todos os clientes so desamarrados pelo unbindService()
return mAllowRebind;
}
@Override
public void onRebind(Intent intent) {
// cliente conectado ao servio novamente atravs do
bindService(), depois que o onUnbind() foi chamado
}
@Override
public void onDestroy() {
// o service finalizado e destrudo
}
}
Dentre os principais mtodos de Service, pode-se destacar:
56
Android
onStartCommand() - mtodo chamado quando outro componente, como uma

atividade, faz a requisio para que o servio seja iniciado chamando startService().
O servio iniciado e pode rodar em background indefinidamente. Se for implementado
isso, responsabilidade do cdigo parar o servio, uma vez que o trabalho feito
chamando stopSelf() ou stopService();
onBind() - mtodo chamado quando outro componente quer fazer o bind com o
servio (para realizar um RPC, Remote Procedure Call) chamando bindService(). Na
implementao deste mtodo, deve ser provida uma interface onde os clientes podero
comunicar-se com o servio, retornando um IBinder;
onCreate() - mtodo chamado quando o servio criado pela primeira vez, para
realizar procedimentos de configurao iniciais (antes mesmo de executar ou o
onStartCommand() ou onBind());
onDestroy() - mtodo chamado quando o servio est sendo destrudo. Mtodo que
deve ser implementado para limpar os recursos instanciados, como threads, listeners
registrados, receivers, etc. a ltima chamada que o servio recebe.
57
Android
3.3. ContentProvider
ContentProvider uma das partes mais importantes no estudo de arquitetura
de aplicaes Android, pois ele responsvel pela comunicao saudvel entre apps. O
sistema operacional da Google foi construdo com base em algumas normas de boas
prticas, dentre as quais consta que o ideal que a persistncia de um programa seja
transparente, tanto ao cdigo-fonte de negcio do prprio programa quanto a
programas externos. Dessa forma, no possvel acessar um banco de dados de uma
aplicao externa diretamente e a que entram os provedores de contedo.
A comunicao entre aplicaes e provedores de contedo se torna simples,

realizada a partir de um endereo URI, onde possvel realizar aes como incluso,
excluso e, principalmente, consulta de dados. Cada Content Provider possui uma
estrutura de URI prpria, baseada na estrutura geral. Por exemplo, para acessar o
contedo da caixa de mensagens de texto, possvel solicitar o ContentProvider
compartilhado do aplicativo de mensagens atravs a URI content://sms/inbox.
possvel ainda realizar a passagem de parmetros para esta URI.
content://pacote.app.nomeDoCP/nomeEntidade/ID
Da mesma forma que o utilizado por Activity e Service, para criar um
provedor de contedo, basta derivar uma Classe da ContentProvider, implementando
seus mtodos, e realizar a incluso referente no manifesto.
58
Android
public class HelloProvider extends ContentProvider {

public static final Uri CONTENT_URI = Uri
.parse("content://hello.world.helloprovider");
@Override
public int delete(Uri uri, String selection, String[]
selectionArgs) {
return 0;
}
@Override
public String getType(Uri uri) {
return null;
}
@Override
public Uri insert(Uri uri, ContentValues values) {
return null;
}
@Override
public boolean onCreate() {
return false;
}
@Override
public Cursor query(Uri uri, String[] projection, String
selection,
String[] selectionArgs, String sortOrder) {
return null;
}
@Override
public int update(Uri uri, ContentValues values, String
selection,
String[] selectionArgs) {
return 0;
}
}
Dessa, forma possvel realizar a chamada de contedo a partir de outro app,

atravs da URI content://hello.world.helloprovider.
Dentre os principais mtodos da classe ContentProvider, pode-se destacar:
query() - usado para recuperar dados;
59
Android
insert() usado para inserir dados;

update() usado para atualizar dados;
delete() - usado para excluir dados;
getType() usado para obter o MIME type de certo dado;
60
Android
3.4. Processo e Thread

Cada aplicao possui um processo nico de execuo e todos os elementos prdefinidos dela so executados dentro deste processo. Em alguns casos, pode ocorrer
sobrecarga de memria e processamento. Para resolver isso, existem algumas
artimanhas, como a utilizao de servios remotos (visto anteriormente). J para
processamentos em menor escala, mas que necessitam de execuo concorrente, pode
ser utilizada uma implementao da classe Thread (ou Runnable), como uma
aplicao Java comum.
public class ProgressDialogExample extends Activity implements
Runnable {
private String pi_string;
private TextView tv;
private ProgressDialog pd;
@Override
tv = (TextView) this.findViewById(R.id.main);
tv.setText("Press any key to start calculation");
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
pd = ProgressDialog.show(this, "Working..",
"Calculating Pi", true,false);
Thread thread = new Thread(this);
thread.start();
return super.onKeyDown(keyCode, event);
}
public void run() {
pi_string = Pi.computePi(800).toString();
handler.sendEmptyMessage(0);
}
private Handler handler = new Handler() {
61
Android
@Override
public void handleMessage(Message msg) {
pd.dismiss();
tv.setText(pi_string);
}
};
}
O exemplo acima calcula o valor do PI com 800 comutaes e o escreve na tela. O

processo disparado por um simples aperto de tecla (caso teclado fsico, seno toque) e,
caso o evento de tecla ocorra durante o processamento, disparada uma mensagem
informando o no trmino dele.
O objeto Handler muito importante, pois ele que faz a comunicao entre os
processos concorrentes.
http://developer.android.com/reference/android/os/Handler.html
62
Android
3.5. Manifesto
Conhecidos os principais elementos de uma estrutura de cdigo Android, pode-se
estudar o arquivo de manifesto da aplicao. Este arquivo responsvel por definir as
informaes vitais para o app, como identificadores, verses, permisses de acesso
externo e definir quais elementos so presentes nesta aplicao, como atividades,
servios, provedores de contedo e filtros de intenes.
<?xml version="1.0" encoding="utf-8"?>
<manifest>
<uses-permission />
<permission />
<permission-tree />
<permission-group />
<instrumentation />
<uses-sdk />
<uses-configuration />
<uses-feature />
<supports-screens />
<compatible-screens />
<supports-gl-texture />
<application>
<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>
<activity-alias>
<intent-filter> . . . </intent-filter>
<meta-data />
</activity-alias>
<service>
<meta-data/>
</service>
<receiver>
<meta-data />
63
Android
</receiver>
<provider>
<grant-uri-permission />
<meta-data />
</provider>
<uses-library />
</application>
</manifest>
Cada tag de utilizao prevista no AndroidManifest.xml possui diversos

atributos que podem ser utilizados e sofrem constantes mudanas devido s novas
verses do Android. A relao completa de atributos mais atual pode ser encontrada
seguinte endereo:
http://developer.android.com/guide/topics/manifest/manifest-intro.html
Como exemplo de um manifesto de aplicao HelloWorld, tem-se:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="hello.world"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="15" />
<application
android:icon="@drawable/ic_launcher"
<activity
android:name=".HelloWorldActivity"
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
64
Android
4. Interface Grfica
Com os aplicativos de smartphones e tablets cada vez mais integrados web, a
catlogos e ao conceito de armazenamento de informaes em nuvem, um dos principais
elementos de um app a apresentao grfica. Tanto em jogos, quanto em catlogos e
em aplicativos coorporativos ou de produtividade, a direo de arte converge para
elementos mais limpos e de navegao mais intuitiva, atingindo diversos nveis de
usurios, desde os mais novatos aos mais experientes.
O Android SDK combinado com o ADT possui recursos e bibliotecas de enorme
qualidade para construo de uma arquitetura de layout moderna e representativa. A
construo a partir destes recursos como uma mistura entre as interfaces Swing e
HTML (web), suportando a construo de layouts em tabela, em camadas e atributos de
posicionamento, controle de bordas, imagens, cores, e diversos componentes visuais.
Como j visto, a arquitetura de um aplicativo Android Java possui elementos de
layout em XML, carregados, geralmente, a partir de uma atividade. Ao editar um
arquivo desse tipo com o Eclipse, com o ADT, possvel visualizar tanto o cdigo texto
(XML), quanto a edio visual, onde possvel adicionar componentes e controlar os
layouts a partir de drag and drop.
65
Android
possvel notar basicamente trs blocos principais para arquitetura de tela no ADT.
A parte principal, o editor, composta de uma aba para edio visual (Graphic
Layout) e outra de cdigo (nomeDoArquivo.xml). Na guia de edio visual,
possvel observar uma barra de componentes visuais e uma rea de montagem de tela.
possvel, ento, arrastar um componente para a rea de montagem. Cada modificao
feita no editor visual automaticamente carregada no editor de texto e vice e versa.
Alm disso, possvel observar uma barra lateral contendo a exibio de hierarquia
de componentes em rvore e um bloco, talvez o principal, de edio de propriedades do
componente. Ao selecionar um componente especfico, so exibidas neste bloco as
propriedades referentes a ele, como alinhamento, posicionamento, cores, textos e o ID do
componente.
Por padro, a propriedade ID do componente composta de um valor em sequncia
(ex.: @+id/button1). importante manter o valor at a primeira barra (/),
alterando apenas o contedo final, o ID em si ( button1, no caso). Isto faz com que, no
componente de referncias gerado automaticamente (R.class), seja adicionada uma
referncia a este objeto, podendo ser utilizada a chamada direta (como R.id.button1).
Cada componente de layout derivado de View(widgets) ou ViewGroup, sendo
que um ViewGroup pode ser composto de View ou de outros ViewGroup, na
quantidade que for necessria para construir um layout.
66
Android
4.1. Layouts
Existem diversos tipos de arquitetura de layouts em Java e em HTML, e algumas
das principais esto presentes no desenvolvimento Android.Os containers de layout so
componentes derivados de ViewGroup. Dentre os principais tipos de layout de uma
arquitetura de tela Android, pode-se destacar os seguintes:
LinearLayout o layout utilizado por padro nos componentes XML criados.
Seu principal objetivo montar os elementos em forma corrente, sendo da esquerda para
a direita em layout horizontal e de cima para baixo em layout vertical. A orientao do
layout definida pela propriedade orientation.
Este estilo de layout pode ser til em casos de design de tela simples, com
elementos ocupando reas completas de largura ou altura (dependendo da orientao
especificada), pois ele respeita automaticamente as margens e os alinhamentos perante
outras View. possvel definir o alinhamento dos componentes na edio dos layouts
Android, atravs da propriedade gravity. Atravs da propriedade layout_weight
possvel organizar os elementos por pesos (prioridades), a fim de algumas Views
ocuparem maior ou menor espaamento em tela (o padro 0).
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:layout_height="wrap_content"
android:text="@string/hello" />
<Button
android:id="@+id/bAdd"
android:layout_width="wrap_content"
67
Android
android:text="Iniciar Thread" android:layout_weight="0"/>
<TextView
android:id="@+id/tv"
android:text="" />
</LinearLayout>
FrameLayout - organiza o elemento em pilhas conforme sua adio, onde os

elementos adicionados por ltimo so mostrados na camada mais acima, podendo estes
elementos ser reordenados atravs da rvore de hierarquias. normalmente utilizado
como container para troca de componentes de mesmo tipo. Por exemplo se existe uma
imagem a ser trocada temporariamente (ou em algum evento especfico, como um toque
em um boto), possvel colocar todas as imagens em um FrameLayout, ocultando as
inutilizadas a partir da propriedade visibility.

<FrameLayout
android:id="@+id/frameLayout1"
android:layout_width="match_parent"
android:layout_height="fill_parent" >
<Button
android:id="@+id/button1"
android:text="Button 1" android:visibility="invisible"/>
<Button
68
Android
android:text="Button 2" android:visibility="invisible"/>
<Button
android:text="Button 3" />
</FrameLayout>
AbsoluteLayout - este container derivado da programao HTML, onde

possvel definir camadas de posicionamento x,y absoluto sobre outros elementos,
como um plano cartesiano. A coordenada x medida da esquerda para a direita e a
camada y de cima para baixo. Por padro, os elementos adicionados em um
AbsoluteLayout possuem coordenadas (0,0), ficando no topo esquerdo da tela. Este
tipo de layout comum na exibio de mensagens personalizadas sobre a tela (e sobre
outros componentes). importante cuidar ao construir um layout absoluto, pois alm de
elementos poderem ser sobrepostos por descuido no posicionamento, possvel que
ocorra muita diferena entre resolues diferentes (as medidas so absolutas).

<AbsoluteLayout
android:id="@+id/absoluteLayout1"
<EditText
android:id="@+id/editText1"
android:layout_width="248dp"
69
Android
android:layout_x="39dp"
android:layout_y="58dp" >
<requestFocus />
</EditText>
<Button
android:layout_x="208dp"
android:layout_y="119dp"
android:text="Button" />
</AbsoluteLayout>
Apesar de possuir vantagens, as falhas devido m construo fizeram com que o

layout absoluto fosse depreciado no Android, tendo sua implementao descontinuada.
RelativeLayout - os layouts relativos servem para posicionar componentes com
relacionamentos entre eles, podendo um elemento ser posicionado abaixo de outro, por
exemplo.
o tipo de container mais utilizado e recomendado, pois com ele possvel

realizar amarraes de elementos s bordas da tela, ficando o layout ntegro e
robusto, independente da resoluo. Alm disso, possvel definir posicionamentos
relativos outros elementos do layout, podendo ser especificada uma margem a partir
da amarrao, novamente mantendo o layout ntegro e robusto.
<RelativeLayout
android:id="@+id/relativeLayout1"
70
Android
<TimePicker
android:id="@+id/timePicker1"
android:layout_alignParentLeft="true"
android:layout_alignParentRight="true"
android:layout_alignParentTop="true" />
<TextView
android:id="@+id/textView1"
android:layout_below="@+id/timePicker1"
android:text="TextView" />
<EditText
android:layout_below="@+id/textView1" >
<requestFocus />
</EditText>
<Button
android:layout_below="@+id/editText1"
</RelativeLayout>
TableLayout - este container utilizado da mesma forma que tabelas em HTML ou

que o container de tabelas em Swing. A partir dele, podem ser criados TableRow,
que funcionam, basicamente, como o LinearLayout. Cada View adicionado
considerado uma clula e o nmero de colunas da tabela definido pela linha que
contem mais clulas.
71
Android

<TableLayout
android:orientation="vertical"
android:layout_height="fill_parent">
<TableRow>
<TextView android:text="Nome:" />
<EditText android:text="" />
</TableRow>
<TableRow>
<TextView android:text="Data Nasc.:" />
<EditText android:text="" />
</TableRow>
<TableRow>
<Button android:text="Cadastrar" />
</TableRow>
</TableLayout>
A partir dos diversos tipos de layout existentes, possvel realizar diversos

aninhamentos, a fim de realizar a melhor arquitetura de tela para a aplicao.
importante que um designer de interface tenha conhecimentos, alm das suas
ferramentas, do funcionamento dos containers de layout, para poder agregar os
elementos da melhor forma possvel e no complicar o trabalho dos engenheiros de
software.
Alm da utilizao padro dos arquivos de layout, referenciados no contexto da
atividade a ser executada, possvel a utilizao de um componente chamado
LayoutInflater, utilizado para a criao de layouts personalizados em objetos com
visualizao padro de componente. Um exemplo muito comum a utilizao do
72
Android
LayoutInflater para a criao de notificaes, como visto na seo de notificaes e

Toaster desta apostila.
A documentao completa do LayoutInflater pode ser encontrada em:
http://developer.android.com/reference/android/view/LayoutInflater.html
73
Android
4.2. Componentes de tela

Os componentes visuais disponibilizados pelo SDK Android so derivados de
View e, por isso, possuem propriedades em comum, alm de suas especficas. Dentre
as principais propriedades em comum, pode-se destacar as referentes ao layout, como
posicionamento, tamanho em largura e altura (x,y) e margens.
O objetivo desta apostila apresentar as possibilidades de componentes existentes
no Android SDK e como podem ser utilizados entre si. A documentao completa da
biblioteca de componentes visuais pode ser encontrada no seguinte endereo:
http://developer.android.com/guide/topics/ui/index.html
Existem alguns componentes que so aninhamentos de containers de layout,
pronto para executarem alguma funo especfica.
Componente
Gallery
GridView
ListView
ScrollView
Spinner
SurfaceView
TabHost
ViewFlipper /
ViewSwitcher
Descrio
Contm uma lista de imagens (suportando roalgem para direita e
esquerda)
Contm uma grade com rolagem e esta contm linhas e colunas
Possui uma lista de View (coluna nica)
Coluna nica de elementos (View ou ViewGroups) com rolagem
vertical
Semelhante uma caixa de seleo, realiza rolagem horizontal ou
vertical, exibindo um nico item por vez, como uma linha de texto
Container semelhante a uma superfcie de desenho, utilizado para
desenhar pixels ao invs de widgets, mesmo assim suportando
componentes dispostos acima
Componente armazenador de abas, pronto para receb-lascom
suporte a eventos das mesmas
Lista de exibio nica (um item por vez) que pode ser configurado
para trocar componentes, como um slideshow
muito interessante este tipo de componente, pois, mesmo sendo agrupadores de

outros componentes, tem dependncia total e podem ser facilmente implementados. Por
exemplo, para criar uma lista de planetas selecionvel, pode ser utilizado um Spinner.
No arquivo de layout:
<Spinner
74
Android
android:id="@+id/spinner1"
android:layout_alignParentTop="true"/>
No arquivo de constantes (strings.xml):

<string name="planet_prompt">Selecione</string>
<string-array name="planets_array">
<item>Mercrio</item>
<item>Vnus</item>
<item>Terra</item>
<item>Marte</item>
<item>Jpiter</item>
<item>Saturno</item>
<item>Urano</item>
<item>Netuno</item>
</string-array>
No cdigo da atividade que utilize o layout contendo o Spinner:

Spinner spinner = (Spinner) findViewById(R.id.spinner1);
ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(
this, R.array.planets_array,
android.R.layout.simple_spinner_item);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropd
own_item);
spinner.setAdapter(adapter);
O resultado apresentado ser algo como:
75
Android
interessante observar no cdigo da atividade a utilizao de uma referncia ao

tipo de layout utilizado para o Spinner. A lista completa e atualizada das contantes de
layout que podem ser utilizadas pode ser encontrada em:
http://developer.android.com/reference/android/R.layout.html
Mas estes componentes descritos na grade acima so os chamados componentes
avanados. Dentre os bsicos do desenvolvimento visual para Android pode-se
destacar:
TextView responsvel pela exibio de texto em tela, possui caractersticas
como cor de fundo, de texto, tamanho de texto;
Button responsvel pela exibio de um boto padro de texto simples, possui
caractersticas como cor de fundo, de texto, tamanho de texto;
ImageButton semelhante ao Button, com a possibilidade de utilizar uma
imagem (res) como fundo;
76
Android
EditText campo editor de texto, a partir de qual possvel o usurio colocar

informaes, pode ser configurado como uma rea de texto, adicionando suporte a
quebras de linha;
CheckBox caixa de marcao mltipla, por padro acompanhada de um texto
de etiqueta ao lado;
RadioButton caixa de marcao nica, por padro acompanhada de um texto
de etiqueta ao lado;
RadioGroup agrupamento de RadioButton;
ToggleButton boto com identificador de ligado/desligado, pode ser utilizado
semelhante a um CheckBox, porm sem valor fixo de seleo.

<RelativeLayout
android:id="@+id/relativeLayout1"
<TextView
android:id="@+id/textView1"
77
Android
android:layout_alignParentTop="true"
android:text="TextView" />
<Button
android:layout_below="@+id/textView1"
<ImageButton
android:id="@+id/imageButton1"
android:layout_below="@+id/button1"
android:src="@android:drawable/btn_star_big_off" />
<EditText
android:layout_below="@+id/imageButton1" >
<requestFocus />
</EditText>
<CheckBox
android:id="@+id/checkBox1"
android:layout_below="@+id/editText1"
android:text="CheckBox" />
<RadioButton
android:id="@+id/radioButton1"
78
Android
android:layout_below="@+id/checkBox1"
android:text="RadioButton" />
<RadioGroup
android:id="@+id/radioGroup1"
android:layout_below="@+id/radioButton1" >
<RadioButton
android:id="@+id/radio0"
android:checked="true"
<RadioButton
<RadioButton
</RadioGroup>
<ToggleButton
android:id="@+id/toggleButton1"
android:layout_below="@+id/radioGroup1"
android:text="ToggleButton" />
</RelativeLayout>
As principais propriedades que podem ser utilizadas nos componentes de tela so:
id - identificador do componente, usado para cham-lo a partir de referncias;
79
Android
layout_width definio de como ser a largura do componente. Para preencher a

tela inteira utilizado fill_parent, caso a necessidade de adaptao ao tamanho do
contedo, wrap_content;
layout_heigh similar ao layout_width, porm, definio de altura do
componente;
text - propriedade que corresponde ao texto exibido no componente;
src endereo de localizao da imagem a ser carregada no componente;
style - local onde definido o estilo do boto;
orientation definio em um ViewGroup (como o RadioGroup) de como ser
distribudas as View, verticalmente ou horizontalmente;
textOn - atributo do ToggleButton que define o texto a ser exibido quando a flag
estiver marcada;
textOff - atributo do ToggleButton que define o texto a ser exibido quando a flag
estiver desmarcada;
gravity define como a distribuio de alinhamento do componente perante seu pai
(centralizado, topo, rodap).
A documentao completa pode ser encontrada em:
http://developer.android.com/guide/topics/ui/index.html
80
Android
4.3. Menus
Existem trs tipos de menus para aplicaes Android. O menu de opes aberto
ao utilizar o boto correspondente abertura do menu (geralmente boto fsico) e
referente ao menu principal da atividade em execuo. J o menu de contexto aberto
ao tocar e manter pressionado sobre um componente. O menu suspenso semelhante ao
menu de contexto, mas aberto automaticamente ao simples toque em um componente
que o executa (como visto no exemplo, utilizado pelo Spinner).
Para criar um menu de opes, podem ser feitas duas implementaes. A primeira,
a partir de um menu gerado em XML (armazenado em res/menu/) e amarrado
atividade a partir do comando inflate().
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/new_game"
android:icon="@drawable/ic_new_game"
android:title="@string/new_game" />
<item android:id="@+id/help"
android:icon="@drawable/ic_help"
android:title="@string/help" />
</menu>
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.game_menu, menu);
return true;
}
Observa-se a utilizao de trs elementos principais no item de menu declarado no

XML. O id utilizado para referenciar na Classe R (no cdigo na atividade
possvel observar a utilizao), icon referente imagem em res/drawable/ nas
diferentes qualidades de resoluo e title referente ao texto exibido.
Para mapear a seleo de um item, pode ser utilizado o seguinte cdigo, tambm
na atividade em execuo:
@Override
81
Android
public boolean onOptionsItemSelected(MenuItem item) {

// Handle item selection
switch (item.getItemId()) {
case R.id.new_game:
newGame();
return true;
case R.id.help:
showHelp();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
A outra forma de criar um menu de opes (principal) diretamente a partir da

atividade, sem a manuteno do arquivo XML, porm isso torna mais complicada a
referncia, comprometendo a referncia externa, caso necessrio.
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
// Create and add new menu items.
MenuItem itemAdd = menu.add(0, ADD_NEW, Menu.NONE,
R.string.add_new);
MenuItem itemRem = menu.add(0, REMOVE, Menu.NONE,
R.string.remove);
// Assign icons
itemAdd.setIcon(R.drawable.add);
itemRem.setIcon(R.drawable.remove);
// Allocate shortcuts to each of them.
itemAdd.setShortcut('0', 'a');
itemRem.setShortcut('1', 'r');
return true;
}
A criao de um menu de contexto realizada de forma semelhante, mudando

apenas as chamadas de mtodo;
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, v, menuInfo);
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.context_menu, menu);
82
Android
}
@Override
public boolean onContextItemSelected(MenuItem item) {
AdapterContextMenuInfo info = (AdapterContextMenuInfo)
item.getMenuInfo();
switch (item.getItemId()) {
case R.id.edit:
editNote(info.id);
return true;
case R.id.delete:
deleteNote(info.id);
return true;
default:
return super.onContextItemSelected(item);
}
}
Os menus de contexto no suportam cones ou teclas de atalho.

possvel, ainda, a criao de sub-menus. Para isso, pode-se criar tags
<menu/> recursivas no XML referente.
A documentao completa pode ser encontrada em:
http://developer.android.com/guide/topics/ui/menus.html
83
Android
4.4. Janelas de Dilogo

Janelas de dilogo so aquelas que permitem ao usurio tomar uma deciso
especfica ou apenas ser informado de alguma mensagem. No Android, assim com o em
Java para desktop, muito simples de criar estas interfaces. Atravs de uma Classe
construtora de dilogos, com mtodos prontos para receber a personalizao, torna-se
bastante rpido e intuitivo incluir um dilogo na aplicao.
Da mesma maneira como criado um listener de evento de clique, pode ser
criado para a janela de dilogo.
DialogInterface.OnClickListener dialogClickListener = new
DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
switch (which){
case DialogInterface.BUTTON_POSITIVE:
//boto SIM clicado
break;
case DialogInterface.BUTTON_NEGATIVE:
//boto NO clicado
break;
}
}
};
Este o cdigo referente manipulao da deciso do usurio ao tocar em algum

dos botes. Depois, preciso inserir o cdigo de chamada de criao da janela de
dilogo, que pode ser inserido no evento de clique de algum elemento, por exemplo.
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Confirma operao?").setPositiveButton("Sim",
dialogClickListener).setNegativeButton("No",
dialogClickListener).show();
84
Android
Este modelo de janela de dilogo consiste em utiliza a interface padro da verso

do sistema Android (como outros componentes de layout funcionam). Pode-se analisar os
principais mtodos das Classes de dilogo para criao de uma caixa de dilogo
padro:
setIcon() mtodo onde definido um cone para a caixa de dilogo;

setMessage() mtodo onde definida a mensagem exibida na caixa de dilogo;
setTitle() mtodo onde definido o ttulo da caixa de dilogo;
setNeutralButton() definio de um boto neutro (normalmente rotulado com o
ttulo OK) e seu evento de ao;
setPositiveButton() - definio de um boto positivo (normalmente rotulado com o
ttulo Sim ouYes) e seu evento de ao;
setNegativeButton() - definio de um boto negativo (normalmente rotulado com
o ttulo No ouNo) e seu evento de ao.
Caso seja necessrio utilizar um layout especfico para uma janela de dilogo, o
mesmo pode ser criado na pasta res/layout/ e associado a um dilogo na atividade
especfica.
Dialog dialog = new Dialog(main.this);
dialog.setContentView(R.layout.meuDialogo);
dialog.setTitle("Ttulo da janela");
dialog.setCancelable(true); // fornece a opo de cancelar a partir
de uma ao (como um boto)
dialog.show();
85
Android
4.5. Notificaes
Uma das vantagens do sistema operacional Android a qualidade da sua
multitarefa. Para melhor controle das tarefas, a interface contm uma barra de tarefas
(tambm chamada de barra de status), por padro situada na parte superior da tela.
Com um gesto de deslize com o dedo para baixo, possvel expandir esta barra e
visualizar os detalhes das aplicaes abertas. Os elementos na barra de status do
Android so chamados de notificaes e servem para, dentre outras coisas, alertar o
usurio sobre alguma pendncia em alguma aplicao, ou simplesmente avisar sobre
alguma novidade.
Utiliza-se notificao ao invs de janelas de dilogo quando uma aplicao,
rodando em segundo plano, deseja comunicar-se com o usurio sem interromper a
atividade dele no momento, dando a ele a liberdade de responder aplicao dona da
notificao no momento em que desejar.
O mtodo mais simples de criar uma notificao totalmente customizvel a partir

da criao de uma classe helper especfica, contendo variveis e constantes prdefinidas (algumas mutveis) para auxiliar a criao da notificao sem a necessidade
de preocupao com os diversos parmetros utilizados, realizando assim o
encapsulamento.
public class Notificacao {
86
Android
public
public
public
public
public
public
public
public
public
static
static
static
static
static
static
static
static
static
final
final
final
final
final
final
final
final
final
int TIPO_ACTIVITY = 1;
int TIPO_BROADCAST = 2;
int TIPO_SERVICE = 3;
String INTENT_STRING_MSG_STATUS = "MSGs";
String INTENT_STRING_MSG = "MSG";
String INTENT_STRING_TITULO = "titu";
String INTENT_LONG_QUANDO = "WHEN";
String INTENT_INT_ICONE = "icone";
String INTENT_INT_FLAGS = "FLS";
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,
} else if (tipo == TIPO_SERVICE) {
p = PendingIntent.getService(activity, 0, acao,
} 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;
}
87
Android
public static NotificationManager notificar(Activity activity,

Notification notification, int id) {
//pega servio de notificacao
NotificationManager nm = (NotificationManager)
activity.getSystemService(Activity.NOTIFICATION_SERVICE);
//exibe a notificacao
nm.notify(id, notification);
return nm;
}
}
interessante analisar a utilizao do Objeto PendingIntent, que indica a

dependncia de uma chamada via Intent. Este objeto tem o poder de aguardar a
utilizao de um Intent a partir de uma atividade ou um servio, realizando
recebimentos e chamadas de parmetros.
Aps isso, basta na atividade ou servio desejado instanciar o helper e realizar
a chamada de notificao.
Intent it = new Intent();
it.putExtra(Notificacao.INTENT_STRING_MSG, "HelloWorld em
execuo!");
it.putExtra(Notificacao.INTENT_STRING_MSG_STATUS, "HelloWorld!");
it.putExtra(Notificacao.INTENT_STRING_TITULO, "HelloWorld!");
it.putExtra(Notificacao.INTENT_LONG_QUANDO,
System.currentTimeMillis());
it.putExtra(Notificacao.INTENT_INT_ICONE,
android.R.drawable.ic_dialog_alert);
String url = "http://www.uzzye.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
Notification notf = Notificacao.criarNotificacao(this, it, i,
Notificacao.TIPO_ACTIVITY);
Notificacao.notificar(this, notf, 550);
Analisando o cdigo, pode-se observar a passagem de parmetros para o

Intent, como a mensagem para a barra de status, o ttulo da notificao, quando a
notificao deve ser executada, o cone (utilizado o padro de alerta), alm da
configurao de ao utilizada ao tocar na notificao.
88
Android
Para cancelar a exibio, pode ser utilizado o mtodo cancel() da notificao.

Outro mtodo de notificao de usurio muito comum em Android atravs do
componente Toast. Toast um facilitador de mensagens rpidas, contendo somente
texto, com exibio e ocultamento automticos, sem interferncia do usurio. O cdigo
bastante simples e de fcil implementao.
Context context = getApplicationContext();
CharSequence text = "Hello toast!";
int duration = Toast.LENGTH_SHORT;
Toast toast = Toast.makeText(context, text, duration);
toast.show();
toast.setGravity(Gravity.TOP|Gravity.LEFT, 0, 0); // para posicionar
possvel, ainda, montar um Toast personalizado, com um layout pr-definido a

partir de cdigo XML e da utilizao do componente de layout LayoutInflater.
LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.toast_layout,
(ViewGroup)
findViewById(R.id.toast_layout_root));
ImageView image = (ImageView) layout.findViewById(R.id.image);
89
Android
image.setImageResource(R.drawable.android);
TextView text = (TextView) layout.findViewById(R.id.text);
text.setText("Este um Toast personalizado!");
Toast toast = new Toast(getApplicationContext());
toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(layout);
toast.show();
toast.show();
A documentao completa do Toast pode ser encontrada em:

http://developer.android.com/guide/topics/ui/notifiers/toasts.html
90
Android
4.6. Drag and Drop

O sistema operacional Android possui uma interface muito responsiva a toques,
capaz de realizar operaes de arrastar e soltar e at de mltiplos toques (mais de um
dedo), a fim de melhorar a experincia de usurio em aplicaes mais robustas. Como
exemplo, a galeria de fotos padro do Android, em verso acima de 2.1, suporta o
comando de pina com dois dedos para aproximar ou afastar a imagem (zoom) e o
navegador de Internet possui a navegao pela janela a partir de arrastar e soltar.
Obviamente, o hardware deve ter suporte em tela a mltiplos toques para executar a
pina e ser sensitivo a toque para executar o mesmo.
A verso de biblioteca de arrastar e soltar para desenvolvedores Android foi
disponibilizada apenas em 2011, o que gerou suporte apenas para verses superiores
2.1 do Android, no podendo ser utilizado em dispositivos com o sistema operacional em
verso mais antiga.
A utilizao deste framework um tanto quanto complicada, pois requer muito estudo
de posicionamento e das diversas situaes do toque, desde o iniciado at o finalizado.
possvel realizar um simples movimento de arrastar e soltar componentes em tela e at
criar containers como reas de recepo de elementos arrastados, podendo assim criar,
por exemplo, listas personalizadas a partir destes elementos.
A referncia completa pode ser encontrada em:
http://developer.android.com/guide/topics/ui/drag-drop.html
Como exemplo prtico, pode ser criado um simples Drag and Drop pela tela. Para
isso, cria-se um container no layout e uma View para ser arrastada.
<LinearLayout
android:id="@+id/linearLayout1"
<ImageView
android:id="@+id/imageView1"
android:layout_height="90dp"
android:src="@android:drawable/dialog_holo_light_frame"
/>
91
Android
</LinearLayout>
Aps isso, necessrio criar um controlador de arrastar e soltar, derivando do

ViewGroup especfico utilizado como container e contendo o mtodo
onInterceptTouchEvent().
public class TouchInterceptor extends LinearLayout {
public TouchInterceptor(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
return super.onInterceptTouchEvent(ev);
}
}
Na atividade a ser utilizado o arrastar e soltar necessrio referenciar ao

controlador criado, o que pode ser feito diretamente no onCreate().
ViewGroup container = (ViewGroup)findViewById(R.id.linearLayout1);
container.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
switch(event.getActionMasked())
{
case MotionEvent.ACTION_MOVE:
int x = (int)event.getX() - offset_x;
int y = (int)event.getY() - offset_y;
int w =
getWindowManager().getDefaultDisplay().getWidth() - 100;
int h =
getWindowManager().getDefaultDisplay().getHeight() - 100;
if(x > w)
x = w;
if(y > h)
y = h;
LinearLayout.LayoutParams lp = new
LinearLayout.LayoutParams(
new ViewGroup.MarginLayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT,
LinearLayout.LayoutParams.WRAP_CONTENT)
);
92
Android
lp.setMargins(x, y, 0, 0);
selected_item.setLayoutParams(lp);
break;
default:
break;
}
return true;
}
});
ImageView img = (ImageView)findViewById(R.id.imageView1);
img.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
switch(event.getActionMasked())
{
case MotionEvent.ACTION_DOWN:
offset_x = (int)event.getX();
offset_y = (int)event.getY();
selected_item = v;
break;
default:
break;
}
// retorna falso para evitar indesejados MotionEvents
// e dar ao pai a chance de utilizar MotionEvent
return false;
}
});
A partir deste cdigo, podem ser utilizados outros mtodos de toque, medio de
coordenadas, alm de definir outros containers, definir sobreposio e gerar
componentes melhores de UX (User Experience), como listas em duas colunas com
atribuio por arrastar e soltar.
93
Android
4.7. Recursos
Em todos os elementos de layout utilizados at agora, no back-end possvel realizar
acesso direto atravs da classe de referncias R.class. Esta classe chamada de
Resource, pois referencia todos os elementos XML utilizados na aplicao. Estes
elementos so armazenados dentro do diretrio res/.
Aps o salvamento de um arquivo XML ou compilao do projeto, a Classe R

gerada novamente, realizando as mudanas necessrias nas referncias. Caso um
elemento adicionado em um XML no conste nesta Classe, pode ser necessrio realizar o
Clean e o rebuild do projeto.
public final class R {
public static final class attr {
}
public static final class drawable {
public static final int ic_launcher=0x7f020000;
}
public static final class id {
public static final int imageView1=0x7f050001;
public static final int linearLayout1=0x7f050000;
}
public static final class layout {
public static final int main=0x7f030000;
}
public static final class string {
public static final int app_name=0x7f040001;
public static final int hello=0x7f040000;
}
}
A Classe de recursos composta de subclasses, algumas das quais so referentes s

pastas internas do diretrio res/.
94
Android
drawable responsvel pelos elementos da pasta drawable. detectada

automaticamente a qualidade de resoluo do dispositivo (ou forado atravs de cdigo).
Dessa forma, a referncia tambm realizada automaticamente, atravs da chamada
drawable, sem especificao de qual subpasta utilizar;
layout define as referncias diretas aos arquivos XML dentro da pasta layout;
string define as referncias aos elementos declarados nos arquivos XML contidos
na pasta values;
id define as referncias diretas a todos os componentes visuais declarados nos
arquivos XML de layout. Referncia esta definida atravs do valor da propriedade id
do componente. Ex.: @+id/button1, criar a referncia button1.
Para utilizar as referncias, de qualquer Classe pode ser realizada a chamada
R.subclasse.referncia, como por exemplo R.layout.main.
95
Android
5. Conceitos Avanados
Aps o aprendizado sobre o desenvolvimento bsico em Android, pode-se
aprofundar nos conhecimentos mais avanados.
Dentre as principais execues que podem ser realizadas em Android, dependendo
do dispositivo anfitrio da verso do sistema, deve ser considerado o uso do
acelermetro e do giroscpio (sistemas de controle de posicionamento e angulao do
dispositivo), o suporte a GPS (Global Positioning System), o suporte nativo a banco de
dados SQL (Structured Query Language), no caso o SQLite, etc.
Nos itens a seguir, o detalhamento destes principais recursos.
96
Android
5.1. Permisses e Segurana

Ao realizar um download de aplicativo no Google Play, solicitada a confirmao
de segurana, que consiste em descrever para serem aceitos todos os recursos exigidos
pelo app.
No decorrer desta apostila, foram analisados vrios recursos, incluindo de
integrao com outros apps, coletas de dados, utilizao de recursos do prprio
dispositivo onde o sistema est embarcado e armazenamento. Para cada recurso
estranho ao app utilizado necessrio realizar um registro de permisso, caso
contrrio o sistema poder parar inesperadamente e no conseguir finalizar sua
execuo corretamente.
Este registro de solicitao de permisso feito no manifesto e pode ser alterado a
qualquer momento, porm novas alteraes implicam em novas aceitaes de solicitao
de permisso ao usurio baixar o aplicativo no Play.
No exemplo acima, o app requer que sejam acessadas informaes de contato, que
tenha acesso Internet completo, que possa gerenciar contedo no carto de memria
SD, que possa modificar o estado do telefone (como com rede, sem rede e ocupado), e
escrever um novo nome de Access Point.
importante entender que, ao usurio aceitar as permisses de acesso de um app
ao realizar o download, ele est automaticamente isentando a Google de qualquer culpa
em problemas gerados por ele. Por exemplo, se um aplicativo realiza ligaes telefnicas
em segundo plano e o usurio aceitou essas permisses (contanto que estivessem
97
Android
explcitas como na imagem acima), a Google no tem responsabilidade sobre os custos

gerados por essas ligaes. Exatamente por isso existe este sistema de controle de
permisso e segurana. Para monitorar melhor o que os apps fazem em um dispositivo,
pode ser interessante utilizar antivrus, disponveis inclusive no Play.
Para definir uma solicitao de permisso de um aplicativo, basta incluir o
seguinte cdigo no Manifesto (diferentemente das outras declaraes, como de
atividades ou intenes, as de permisses e funcionalidades devem ser feitas fora da tag
<application/>, mas ainda dentro da <manifest/>).
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission
android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-feature android:name="android.hardware.camera.autofocus"
android:required="false" />
A diferena entre declarao de permisso (permission) e de funcionalidade

(feature) que estas tendem a ser mais especficas e no comprometem a segurana do
usurio, sendo geralmente algum recurso interno de algum item do dispositivo (como o
autofoco da cmera).
Ao definir uma permisso simples, como no exemplo acima, a descrio e o nvel
de segurana utilizados so os padres. Para customizar, possvel utilizar atributos
especficos das tags.
android:label define o ttulo da solicitao.
android:description define o texto de contedo da solicitao.
android:permissionGroup define o grupo que a solicitao pretence. Exemplo:
"android.permission-group.COST_MONEY";
android:protectionLevel define o nvel de proteo da permisso.
Exemplo:"dangerous" .
interessante lembrar que, para utilizao de atributos customizados, podem ser

utilizadas constantes definidas no diretrio de recursos values, utilizando a chamada
@string/nomeDaConstante.
98
Android
A lista completa de permisses pr-definidas, grupos e nveis de proteo para

serem utilizados no manifesto, pode ser encontrada em:
http://developer.android.com/guide/topics/security/security.html
99
Android
5.2. Preferncias de Usurio

Em um website que requer autenticao, como um portal ou uma rea restrita,
geralmente existe uma opo para mantermos o ltimo usurio e at mesmo a senha de
login. Muitas vezes, o prprio navegador web realiza isso. Geralmente, esse
armazenamento de preferncia realizado com um recurso chamado Cookie, presente
em todos os navegadores modernos e de grande utilidade para rpida navegao.
Em Android, tambm existem objetos capazes de realizar o armazenamento e a
recuperao das preferncias de usurios, como o SharedPreferences.
De forma bem simples para codificao, semelhante ao uso de Cookies na web,
um gerenciamento de preferncias pode ser programado da seguinte forma. Como
atributo da atividade, necessrio criar um objeto de preferncias compartilhadas.
private SharedPreferences sharedPreferences;
Em seguida, pode ser implementado um mtodo para armazenamento das

preferncias com o seguinte cdigo.
sharedPreferences = getSharedPreferences(PREFS_PRIVATE,
Context.MODE_PRIVATE);
Editor prefsPrivateEditor = sharedPreferences.edit();
prefsPrivateEditor.putString("nome", Joo);
prefsPrivateEditor.putString("email", joao@meuemail.com.br);
prefsPrivateEditor.putString("apelido", Jo);
prefsPrivateEditor.commit();
Por fim, para realizar a recuperao das preferncias, pode-se implementar um

mtodo com o seguinte cdigo.
sharedPreferences = getSharedPreferences(PREFS_PRIVATE,
Context.MODE_PRIVATE);
String nome = sharedPreferences.getString("nome", "");
String email = sharedPreferences.getString("email", "");
String apelido = sharedPreferences.getString("apelido", "");
sharedPreferences = null; // utilizado somente em caso de necessidade
de limpar as preferncias salvas
100
Android
interessante observar a utilizao do parmetro PREFS_PRIVATE, que

define uma string de referncia ao arquivo utilizado para armazenamento das
preferncias, e o Context.MODE_PRIVATE, que define que somente a aplicao atual
pode ter acesso s preferncias. Para permitir o acesso a partir de outras aplicaes,
pode-se usar MODE_WORLD_READABLE, que permite apenas leitura, ou
MODE_WORLD_WRITEABLE, que permite apenas escrita, alm de estas poderem
ser concatenadas com o operador de String, +.
Outro ponto a observar a utilizao de getString e putString para controle
dos parmetros. Pode ser utilizado qualquer tipo primitivo, alm do objeto String, como
putInt, ou getBoolean.
101
Android
5.3. Persistncia em Banco de Dados (SQLite)

O gerenciamento de preferncias de usurio muito til em caso de controle
rpido e simples, porm, em aplicaes maiores faz-se necessrio o uso de uma
arquitetura de dados mais completa. Para isso, Android conta com um excelente banco
de dados exclusivo para plataformas mveis e embarcadas.
Baseado na linguagem estruturada SQL, comum em bancos de dados como
MySQL e Oracle, o SQLite uma plataforma com recursos resumidos, mas segura e
capaz de executar praticamente qualquer necessidade de persistncia que uma aplicao
complexa pode ter. Uma aplicao que requer uso de banco de dados no necessita de
solicitao de permisses explcita, uma vez que SQLite um recurso integrado e seguro
por si s. Ao criar um banco de dados a partir de um app, o seguinte caminho fsico
criado no sistema de arquivos do Android.
DATA/data/APP_NAME/databases/FILENAME
A maneira mais fcil e robusta de construir uma aplicao com SQLite integrado
utilizando um helper para conexo de dados, semelhante ao que feito em aplicaes
Java com JDBC.
public class DataBaseHelper extends SQLiteOpenHelper {
private static final String DBNAME = "meuDB";
private DataBaseHelper myDBHelper;
private SQLiteDatabase myDB;
private final Context myContext;
public DataBaseHelper(Context context) {
super(context, DBNAME, null, 2);
this.myContext = context;
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int
newVersion) {
}
public DataBaseHelper open() throws SQLException {
102
Android
myDBHelper = new DataBaseHelper(myContext);

myDB = myDBHelper.getWritableDatabase();
return this;
}
public void close() throws SQLException {
this.myDB.close();
}
public SQLiteDatabase getDB()
{
return this.myDB;
}
}
A partir desta Classe auxiliar, pode-se realizar uma chamada simples de instncia
execuo de comandos para o SQLite.
DataBaseHelper dbHelper = new DataBaseHelper(this);
dbHelper.open();
SQLiteDatabase dbCon = dbHelper.getDB();
int id = 999;
Cursor cursor = dbCon.rawQuery("SELECT * FROM nomeTabela WHERE (id =
?)",new String[]{String.valueOf(id)});
startManagingCursor(cursor);
if(cursor.getCount()>0)
{
cursor.moveToFirst();
String valorColuna =
cursor.getString(cursor.getColumnIndex("nomeColuna"));
}
Neste exemplo, realizado um comando SELECT para recuperao de dados

de uma entidade (tabela), a partir da comparao de uma coluna especfica (no caso a
id). A passagem de parmetros SQL em Java pode ser feita atravs de uma lista de
String ordenada conforme a apario das solicitaes (?). Para trabalhar com
recuperao de dados SQL em Android/Java utilizado o conceito de cursores, onde o
cursor posicionado em linhas dentro da tabela de retorno de resultado e pode ser
posicionado livremente, avanando ou recuando.
J para insero de dados, por exemplo, pode ser utilizado o seguinte cdigo:
103
Android
DataBaseHelper dbHelper = new DataBaseHelper(v.getContext());

dbHelper.open();
SQLiteDatabase dbCon = dbHelper.getDB();
String sqlCmd = "INSERT INTO nomeTabela (coluna1, coluna2) VALUES
(?,datetime('now'))";
dbCon.execSQL(sqlCmd,new String[] { Joo });
importante sempre depois de utilizar uma conexo com o banco de dados fechla, o que pode ser realizado com o comando dbHelper.close();.
Como em outras plataformas de desenvolvimento SQL, tambm possvel realizar
a manuteno do banco de dados visualmente, atravs da visualizao de uma tabela,
com linhas e colunas representando a estrutura e os registros de uma entidade no banco
de dados (http://www.softsland.com/sqlite_expert_personal.html), atravs de linha de
cdigo em Shell com o ADB (Android Debug Bridge,
http://developer.android.com/guide/developing/tools/adb.html), ou at mesmo atravs de
um aplicativo instalado diretamente no dispositivo
(https://play.google.com/store/apps/details?id=com.speedsoftware.sqleditor&hl=pt_BR).
A documentao completa do SQLite em Android pode ser encontrada em:
http://developer.android.com/reference/android/database/sqlite/packagesummary.html
A documentao completa dos comandos SQL pode ser encontrada em:
http://www.sqlite.org/lang.html
104
Android
5.4. Cmera e Arquivos

Algumas vezes, dependendo do estilo de aplicativo que se est desenvolvendo,
pode ser necessria (ou apenas um recurso interessante) a incorporao de uma cmera
ao cdigo. A melhor maneira de fazer isso atravs da chamada de inteno.
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
startActivityForResult(intent, TIRAR_FOTO);
Onde a constante TIRAR_FOTO apenas um nmero inteiro identificador de

requisio. Ela usada para identificar o resultado da ao aps a execuo da cmera.
@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {
if (requestCode == TIRAR_FOTO) {
if (resultCode == RESULT_OK) {
Bitmap bitmap = (Bitmap) data.getExtras().get("data");
} else if (resultCode == RESULT_CANCELED) {
} else {
}
}
}
Com o cdigo acima, podemos identificar a difinio de ao aps executar um

resultado especfico, como o TIRAR_FOTO, constante definida anteriormente. A
partir disso, possvel verificar se a atividade foi concluda corretamente, cancelada ou
simplesmente finalizada.
Depois de termos um Objeto do tipo Bitmap criado a partir da cmera, pode-se
realizar o salvamento do arquivo em disco.
String externalStoragePath =
Environment.getExternalStorageDirectory().getAbsolutePath()+"/downloa
d";
File sdImageMainDirectory = new File(externalStoragePath);
FileOutputStream fileOutputStream = null;
String nameFile;
try {
fileOutputStream = new FileOutputStream(
sdImageMainDirectory.toString() +"/image.jpg");
BufferedOutputStream bos = new BufferedOutputStream(
fileOutputStream);
bitmap.compress(CompressFormat.JPEG, quality, bos);
105
Android
bos.flush();
bos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Basicamente, so utilizadas constantes pr-definidas para manuteno de arquivos

a partir de Stream. Aps isso, importante referenciar no manifesto a utilizao tanto
da cmera quanto do gerenciamento de arquivos.
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission
android:name="android.permission. INTERNET" />
Um exemplo de cdigo interessante o de upload de uma imagem tirada da

cmera para a web.
String serverUrl = "http://www.uzzye.com/android/";
String urlString = serverUrl + "android_file_upload.php";
try {
InputStream
fis=this.getContentResolver().openInputStream(externalStoragePath +
/image.jpg);
HttpFileUploader htfu = new HttpFileUploader(urlString,"",
SELECTED_IMAGE.toString(),imageName);
htfu.doStart(fis);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
Para realizar postagem de contedo em formato de texto para uma pgina web
(atravs de mtodos POST/GET), utiliza-se os componentes HttpClient e HttpPost.
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(serverUrl + "android_post.php");
try {
List<BasicNameValuePair> nameValuePairs = new
ArrayList<BasicNameValuePair>(2);
nameValuePairs.add(new BasicNameValuePair("id",0));
106
Android
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
// Execute HTTP Post Request
HttpResponse response = httpclient.execute(httppost);
} catch (ClientProtocolException e) {
} catch (IOException e) {
}
107
Android
5.5. GPS e Mapas

Dentre as API disponibilizadas pela Google juntamente ao SDK, existe uma muito
comum, a do Google Maps. possvel combinar a utilizao dos mapas com o sistema
de posicionamento global (GPS), a fim de aprimorar a experincia de usurio e fornecer
localidades prximas, ou o posicionamento exato de algum objeto. Um exemplo de
utilizao comum , alm do prprio aplicativo Google Maps, aplicativos de marcao
de presena (checkin), como o Foursquare. Mesmo assim, os componentes para
utilizao de GPS so independentes e podem ser utilizados sem a combinao com
mapas.
A utilizao do GPS requer a seguinte definio de uma solicitao de permisso.
<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION" />
Para monitorar a mudana de localizao a partir de comandos de GPS,

necessrio utilizar o componente LocationManager.
public class GPS extends Activity
{
private LocationManager lm;
private LocationListener locationListener;
/** Called when the activity is first created. */
@Override
//---use the LocationManager class to obtain GPS locations--lm = (LocationManager)
getSystemService(Context.LOCATION_SERVICE);
locationListener = new MyLocationListener();
lm.requestLocationUpdates(
LocationManager.GPS_PROVIDER,
0,
0,
locationListener);
}
}
108
Android
Atravs da solicitao do mtodo requestLocationUpdates() criado um

listener responsvel por pegar todas as informaes de mudana de posio
geogrfica. Pode-se notar o uso do provedor padro de posicionamento, interno do
prprio dispositivo, podendo ser configurado um GPS externo, caso necessrio. Aps,
necessrio realizar a implementao da Classe listener utilizada.
private class MyLocationListener implements LocationListener
{
@Override
public void onLocationChanged(Location loc) {
if (loc != null) {
Toast.makeText(getBaseContext(),
"Location changed : Lat: " + loc.getLatitude() +
" Lng: " + loc.getLongitude(),
Toast.LENGTH_SHORT).show();
// aqui pode ser inserido um cdigo de Maps
}
}
@Override
public void onProviderDisabled(String provider) {
// TODO Auto-generated method stub
}
@Override
public void onProviderEnabled(String provider) {
}
@Override
public void onStatusChanged(String provider, int status,
Bundle extras) {
}
}
J para a utilizao do Maps como recurso no Android requerida a seguinte

definio de uma solicitao de permisso no manifesto.
<uses-permission
android:name="android.permission. INTERNET" />
Ainda no manifesto, dentro da tag <application/>, necessrio especificar o

uso da biblioteca de mapas da API.
109
Android
<uses-library android:name="com.google.android.maps" />
No arquivo de layout da atividade, necessrio utilizar um componente de

visualizao de mapas (MapView).
<com.google.android.maps.MapView
android:id="@+id/mapview1"
android:layout_height="fill_parent"
android:enabled="true"
android:clickable="true"
android:apiKey="apisamples" />
possvel, no perfil de usurio desenvolvedor da Google, registrar uma chave de

API para utilizao do Maps e anlise de dados utilizada pela aplicao. Essa chave
de API pode ser utilizada na propriedade apiKey do componente de layout.
No cdigo da Classe de atividade, possvel utilizar o controlador de mapa do
componente visual e trabalhar com as propriedades dele.
MapView mapView = (MapView) findViewById(R.id.mapview1);
MapController mc = mapView.getController();
Integrando o Maps com o cdigo anterior referente utilizao de GPS,

possvel realizar a movimentao do mapa a partir do posicionamento geogrfico do
usurio.
GeoPoint p = new GeoPoint(
(int) (loc.getLatitude() * 1E6),
(int) (loc.getLongitude() * 1E6));
mc.animateTo(p);
mc.setZoom(16);
mapView.invalidate();
Para simular a troca de posicionament possvel, na guia DDMS do Eclipse,

aba Emulator Controls -> Location Controls, modificar atributos de localizao em
tempo de execuo e envi-los ao emulador. O mesmo no vlido para depurao em
dispositivos reais.
110
Android
5.6. Bluetooth
Em algumas aplicaes, pode ser necessria a transmio de dados entre
dispositivos, seja uma transferncia de arquivo ou apenas texto. Isto pode ser realizado
ativando o recurso de Bluetooth do Android, que tambm conta com uma biblioteca de
Classes especficas para este tipo de transferncias.
A utilizao do bluetooth como recurso no Android requer a seguinte definio de
uma solicitao de permisso no manifesto.
<uses-permission
android:name="android.permission. BLUETOOTH" />
O primeiro passo para a utilizao do bluetooth verificar que o dispositivo

possui o suporte necessrio e se o recurso est ativado.
BluetoothAdapter mBluetoothAdapter =
BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter == null) {
// Device does not support Bluetooth
} else {
if (!mBluetoothAdapter.isEnabled()) {
Intent enableBtIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}
}
Com o bluetooth do dispositivo ativo, necessrio verificar o pareamento, que

consiste em um dispositivo servidor da conexo receber e permitir a entrada de outro
dispositivo nela.
Set<BluetoothDevice> devices = adapter.getBondedDevices();
// Servidor Bluetooth
BluetoothDevice server = null;
String servername = "NomeDoServidor";
// Pesquisa o Servidor Pareado
for (BluetoothDevice device : devices) { // Lao de Busca
if (servername.equals(device.getName())) { // Nomes Idnticos?
server = device; // Dispositivo Encontrado e Selecionado
}
}
if (server == null) {
111
Android
// Mensagem de Erro ao Usurio

alert("Servidor no Pareado");
finish();
}
No exemplo acima, a procura foi pelo nome do servidor bluetooth, que pode no
ser nico. Por isso, o ideal realizar a busca pelo endereo MAC do dispositivo do
servidor. Com o servidor pareado, necessrio realizar o cdigo de comunicao
bluetooth dentro de uma Thread, pois este tipo de conexo bloquevel e depende de
respostas do servidor. Para acessar o dispositivo atravs da Thread, necessrio
definir uma varivel como final, recebendo o dispositivo pareado.
final BluetoothDevice computer = server;
Thread connector = new Thread(){
public void run() {
// Identificador nico do Servidor
UUID ident = UUID.fromString("879c3537-ae66-4013-a6779b7e5339d13c");
try {
// Socket de Conexo
BluetoothSocket s =
// Conexo a Partir do Identificador nico
computer.createRfcommSocketToServiceRecord(ident);
} catch (IOException e) { // Erro de Entrada e Sada de Dados
// Mensagem de Erro ao Usurio
alert("Erro de Conexo");
finish();
}
// Conectar ao Servidor
s.connect(); // Execuo Bloqueante
// Fluxos de Entrada e Sada de Dados
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
}
};
A criao de um socket necessria para a comunicao e esta realizada

atravs de um identificador nico utilizado no servidor. Tanto o socket quanto os objetos
de streaming devem ser armazenados em variveis globais da atividade, para acesso
em outros mtodos. Aps estes cdigos, possvel manipular a transferncia de dados,
como, por exemplo, utilizando um mtodo chamado no clique de um boto.
final String conteudo = Mensagem enviada para o servidor.;
Thread sender = new Thread(){
112
Android
public void run() {

byte content[] = conteudo.getBytes();
try { // Possibilidade de Erro
output.write(content.length);
output.write(content);
alert("Texto Enviado");
} catch (IOException e) { // Erro Encontrado
alert("Erro na Transferncia");
}
}
};
sender.start(); // Inicializao
Com os cdigos acima possvel realizar uma conexo bluetooth em qualquer

servidor de identificadores conhecido e a criao destes pode ser realizada em diversas
linguagens, com diversos dispositivos.
113
Android
5.7. Sensores
O sistema operacional Android, assim como muitos dos dispositivos que o possuem
instalado, suporta alguns recursos de sensores, dentre os quais pode-se destacar o
acelermetro (responsvel pela medio de acelerao aplicada a movimentos) e o
giroscpio (responsvel pela medio de movimentos de giro/inclinao). Estes sensores
so utilizados para diversas aplicaes, como jogos, ajustes de tela, melhorias de
usabilidade, etc.
No Java para Android, a captao do giroscpcio realizada atravs de

listener de eventos.
private void hookupSensorListener() {
SensorManager sm =
(SensorManager)getSystemService(Context.SENSOR_SERVICE);
sm.registerListener(sel,
sm.getDefaultSensor(Sensor.TYPE_GYROSCOPE),
SensorManager.SENSOR_DELAY_UI);
}
private final SensorEventListener sel = new SensorEventListener() {
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
updateOrientation(event.values[0], event.values[1],
event.values[2]);
}
114
Android
}
public void onAccuracyChanged(Sensor sensor, int accuracy) {}
};
private void updateOrientation(float heading, float pitch, float
roll) {
// Update the UI
}
Como nem todo dispositivo possui o suporte a giroscpio, possvel identificar

esse suporte atravs do seguinte cdigo.
PackageManager paM = getPackageManager();
boolean gyroExists =
paM.hasSystemFeature(PackageManager.FEATURE_SENSOR_GYROSCOPE);
De qualquer forma, necessrio especificar uma solicitao de permisso para

utilizao do giroscpio, o que atualmente filtra downloads no Google Play para os
dispositivos suportados.
<uses-feature android:name="android.hardware.sensor.gyroscope"/>
Para utilizao de acelermetro, possvel utilizar a Classe SensorManager,

responsvel por mtodos e atributos especficos de controle do recurso.
public class SensorActivity extends Activity, implements
SensorEventListener {
private final SensorManager mSensorManager;
private final Sensor mAccelerometer;
public SensorActivity() {
mSensorManager =
(SensorManager)getSystemService(SENSOR_SERVICE);
mAccelerometer =
mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
}
protected void onResume() {
super.onResume();
mSensorManager.registerListener(this, mAccelerometer,
SensorManager.SENSOR_DELAY_NORMAL);
}
protected void onPause() {
super.onPause();
mSensorManager.unregisterListener(this);
115
Android
}
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
public void onSensorChanged(SensorEvent event) {
}
}
A manuteno de dados obtidos pelos mtodos recuperadores da sensibilidade

requer algum conhecimento de fsica, pois os movimentos so realizados em um plano
tridimensional, com coordenadas obtidas a partir de matrizes e definio de vetores. A
documentao completa pode ser encontrada no seguinte endereo.
http://developer.android.com/reference/android/hardware/SensorManager.html
116
Android
5.8. OpenGL, games, redes sociais e tendncias

Com todos os principais recursos e facilidades disponibilizadas pelo Android
estudados, possvel desenvolver uma aplicao completa e disponibiliz-la no Google
Play. Mesmo assim, possvel incrementar ainda mais uma aplicao com recursos cada
vez mais utilizados e em constante evoluo. Um exemplo disso o mercado de jogos. O
nmero de games para Android cresce cada vez mais e com ele os recursos para
produo desses jogos. Pode-se encontrar em distribuies livres muitos recursos, alm
de engines (motores de execuo) de fsica, montadas sobre a codificao crua do
OpenGL, recurso de licena aberta para produo de elementos tridimencionais em
interface grfica.
possvel obter mais informaes sobre OpenGL no site oficial:
http://www.opengl.org/
Alm de estudar OpenGL, interessante analisar o cdigo-fonte das principais
bibliotecas de engines de fsica gratuitas, para entender melhor a integrao e o
funcionamento do OpenGL com outros recursos.
AndEngine principal engine de fsica gratuita para Android, contm uma
biblioteca de exemplo com aplicativos de demonstrao e blog de atualizao e suporte.
http://www.andengine.org/
Cocos2D engine em andamento, migrada da verso oficial iOS para Android, fez
muito sucesso nos dispositivos da Apple e tenta ganhar seu espao no sistema da Google.
http://code.google.com/p/cocos2d-android/
A documentao completa do OpenGL para Android pode ser encontrada no
seguinte endereo.
http://developer.android.com/guide/topics/graphics/opengl.html
Com os games, surgiram as necessidades de novos recursos para entretenimento, e
a competitividade tornou-se o principal. Como nos jogos de outrora, onde os melhores
jogadores eram identificados pelos recordes em pontuaes, nos jogos para plataformas
mveis muitas vezes possvel compartilhar os resultados nas redes sociais. Esta
integrao muito comum, principalmente quando fala-se em Facebook. Dentre as
principais integraes com a plataforma, esto o compartilhamento de conquistas e
117
Android
resultados e colaborao de amigos. Nos jogos da gigante Zynga, comum a

necessidade da participao de amigos na evoluo do jogo de um usurio. No CityVille,
por exemplo, o usurio precisa solicitar recursos aos amigos que, colaborando, acabam
ganhando bnus em retorno. Tanto na verso incorporada no Facebook, quanto na
verso mvel do jogo Zynga Poker, o jogador pode jogar contra amigos do Facebook ou
contra outros usurios do mundo inteiro que possuem conta na rede social, alm de
poder fornecer prmios para eles.
No s de integraes com jogos vivem as redes sociais nos aplicativos mveis.
Aplicativos como o Cardio Trainer, por exemplo, utilizam compartilhamento de treinos
programados e executados no Twitter e Facebook, com direito a informaes detalhadas
do treino e mapa de execuo. Outros aplicativos, como o TweetDeck, utilizam das redes
sociais para o principal objetivo do aplicativo, integrar as redes em um nico formato de
informaes.
A Facebook oferece um excelente portal de desenvolvimento para desenvolvedores
de vrias plataformas, com documentao completa das bibliotecas (com exemplos de
cdigo) e frum de discusso.
http://developers.facebook.com/?ref=pf
http://developers.facebook.com/docs/guides/mobile/
A Twitter segue o mesmo exemplo e fornece uma plataforma bem completa.
https://dev.twitter.com/
Ambas as redes sociais fornecem recursos para usurios domsticos e
coorporativos, portanto, a integrao entre aplicativos mveis e redes sociais pode fazer
uma grande diferena nas estratgias de marketing digital.
Outras plataformas sociais oferecem recursos para desenvolvedores mveis e
podem facilmente serem implantadas, fornecendo maior abertura na construo de
novas ideias. LinkedIn, Foursquare, Instagr.am, so exemplos de plataformas sociais
com recursos que podem agregar muito valor aos aplicativos a serem disponibilizados
no Google Play.
Estas, alis, so as principais tendncias de mercado para as prximas geraes
de dispositivos e verses do Android. Sero vistos cada vez mais jogos utilizando
recursos de hardware e conexes sem fio, utilizao de multi-toque, aplicativos de
produo e estilo de vida conectados com plataformas sociais, informaes armazenadas
em nuvem e, principalmente motivados pela Google, produtores independentes de boas
aplicaes mveis. Graas abertura a desenvolvedores e ao suporte com boa e clara
118
Android
documentao, a Google conquista cada vez mais um espao maior entre os dispositivos
mveis, sejam smartphones ou tablets, alm de mais usurios utilizarem de forma mais
profunda seu sistema operacional e desenvolvedores se interessarem pela plataforma
perante os considerados rivais de mercado.
Android j uma tima opo de desenvolvimento, tornando-se uma ferramenta
mais necessria a cada dia, tanto para usurios domsticos que procuram muitas opes
de produtividade e entretenimento para seu dia-a-dia, quanto para grandes corporaes
que buscam novas estratgias de marketing. Conquistando mais fabricantes de
dispositivos, adaptando-se s tendncias de mercado e conquistando novos
desenvolvedores, o Android uma ferramenta poderosa que vale muito a pena ser
estudada.
119
Android
4. Exerccios
Este captulo da apostila contm os exerccios para estudo e fixao referentes aos
demais respectivos captulos.
1) Introduo Java
1.1)
Configurar ambiente de desenvolvimento Java.

a) Seguir as instrues de instalao e configurao do Java SDK;
b) Seguir as instrues de instalao e configurao da IDE Eclipse;
1.2) Criar um projeto Hello World Java.

a) Criar um novo projeto Java;
b) Inserir um cdigo de escrita Hello World;
c) Criar um perfil de execuo de projeto e executar;
d) Criar um perfil de depurao de projeto e executar;
2) Introduo Android
2.1) Configurar ambiente de desenvolvimento Android.
a) Seguir as instrues de instalao e configurao do Android SDK;
b) Seguir as instrues de instalao e configurao do Android
Development Tools;
2.2) Criar um projeto Hello World Android.
a) Criar um novo projeto Java;
b) Inserir um cdigo de escrita Hello World;
c) Criar um emulador compatvel com a verso escolhida na criao do
projeto;
d) Criar um perfil de execuo de projeto e executar;
a) Criar um perfil de depurao de projeto e executar;
3) Conceitos Bsicos Android
3.1) Iniciar a implementao de um aplicativo gerenciador de listas de tarefas
(checklist), contemplando cadastro de listas, cadastro de tarefas, marcao de
tarefas concludas, compartilhamento de tarefas (e-mail e redes sociais), cmera
para armazenamento de foto e marcao de localizao.
120
Android
3.2) Implementar duas primeiras atividades do aplicativo.

a) Atividade Principal, responsvel pela inicializao do app, com
definies das variveis globais e constantes e layout associado contendo a
listagem das listas cadastradas;
b) Atividade Cadastro de Lista, contendo formulrio de cadastro com os
campos Ttulo, Resumo, Data Meta;
3.3) Implementar diversos eventos de controle do ciclo de vida das atividades,
tratando Pause, Resume, Start, Stop.
3.4) Implementar a estrutura de banco de dados e mtodos de persistncia para
armazenamento das listas, utilizando SQLite e SQLiteOpenHelper;
3.5) Preparar servio para execuo em segundo plano, que verifique data e
hora atual para alertas de tarefa.
4) Interface Grfica
4.1) Criar demais layouts para as telas do aplicativo:
a) Cadastro de Tarefas;
4.2) Implementar diversas telas, utilizando os principais tipos de layout
estudados, combinando-os e analisando benefcios a serem implementados no aplicativo:
a) LinearLayout;
b) FrameLayout;
c) RelativeLayout;
4.3) Implementar diversos componentes, utilizando seus recursos e analisando
benefcios a serem implementados no aplicativo:
a) TextView;
b) EditText;
c) CheckBox;
d) RadioButton;
e) ToggleButton;
f) Spinner;
4.4) Implementar avisos diversos e sobre as operaes de incluso, alterao e
excluso no aplicativo, utilizando os diversos recursos de alertas:
a) Toast;
b) AlertDialog;
c) Notification (implementar no servio);
4.5) Criar um menu para o aplicativo:
121
Android
a) Opes;
b) Sair;
4.6) Implementar sistema de tabulao de layouts no aplicativo, deixando todas
as opes de tela visveis, utilizando TabView;
5) Conceitos Avanados
5.1) Implementar um layout contendo visualizao de mapa:
a) Pesquisa de endereo no mapa;
b) Overlays contendo apontadores para localizao de tarefas;
c) No evento de pressionar sobre o mapa, abrir tela de cadastro de tarefa
para realizar associao com a lozalizao informada;
5.2) Converter a estrutura de banco de dados do aplicativo em ContentProvider;
5.3) Implementar sistema de preferncias de usurio para armazenamento das
informaes no menu opes;
5.4) Implementar sistema de armazenamento de imagem tarefa, realizando a
utilizao da cmera atravs de um dos dois mtodos apresentados:
a) Por Intent;
b) Por SurfaceView;
5.5) Implementar compartilhamento de tarefa:
a) Por E-mail;
b) Por Facebook;
122
Android
Anotaes
__________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
123
Android
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
124

Desenvolvimento Android Basico

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Desenvolvimento Android Basico

Enviado por

Direitos autorais:

Formatos disponíveis

Desenvolvimento Android

Threads e Excees ................................................................................................................ 25

2. Introduo ao sistema operacional Android ......................................................................................... 28

5.3. Persistncia em Banco de Dados (SQLite) ................................................................................. 102

1. Introduo plataforma Java

A Sun disponibiliza a maioria das extenses e distribuies Java de forma gratuita,

JME (Micro Edition): a plataforma Java mais reduzida, especfica para

1.1. Comandos bsicos

Toda classe Java, quando executada diretamente, iniciada atravs do mtodo

1.2. Tipos de dados

O tipo String no um tipo primitivo, mas sim uma Classe. Diferentemente de

Adio seguida de atribuio

Subtrao seguida de atribuio

1.4. Operadores relacionais

if(x != 1) ou if(x <> 1)

Para comparao de String, necessria a utilizao de mtodos especficos da

Os comentrios em Java podem ser teis para documentao automtica de cdigo

1.6. Pacotes, Classes e Objetos

A classe Pessoa define um conjunto de atributos e aes em comum entre todos

public class Main {

importante observar que Java case-sensitive, ou seja, h diferenciao de

java.lang; - inclui no cdigo referncias s Classes principais para codificao,

Dentre as principais Classes Java pode-se considerar:

Math: classe responsvel pela construo e manipulao de equaces e clculos

public abstract class Eletrodomestico {

public abstract void ligar();

Por fim, existem ainda as Classes Internas, declaradas internamente a outras

public class Externa {

public static void main(String [] args)

1.7. Modificadores de acesso e encapsulamento

public class Pessoa {

add(int index, Object elemento)

Nenhum mtodo a mais

put(Object key, Object value)

Existem alguns tipos de colees em Java que se aplicam melhor a situaes

Conjuntos: so arrumaes de elementos em forma no linear e no ordenadas,

1.9. Padro de projeto Observer, Eventos e Listeners

Como exemplo, identificar uma caixa de e-mails. Imagina-se que um remetente

public class EmailEvent extends EventObject {

Em seguida, necessria a criao de uma Classe que ir receber as notificaes

Depois, criada a Classe do Objeto a ser modificado.

EmailEvent event = new EmailEvent(this);

Em seguida, as classes responsveis pelo remetente e pelo destinatrio devem

public class Remetente implements EmailListener {

Para simular a execuo, cria-se uma classe gerenciadora da caixa de entrada.

O tratamento de Eventos em Java funciona de maneira semelhante. Atravs de

1.10. Threads e Excees

Basicamente, existem duas formas de se trabalhar com Threads em Java.

public class ExemploRunnable implements Runnable {

public class Main {

Dessa forma, a API Java referente a Threads se encarregar de fazer a

No exemplo acima, foi implementada a funo de diviso de uma calculadora. No

public class DivisaoZero extends Exception {

Calc calc = new Calc();

Java dispe, tambm, do comando finally, responsvel por executar o bloco

2. Introduo ao sistema operacional Android

At dezembro de 2011, foram desenvolvidas 7 verses de Android, tendo o

4.0 Ice Cream Sandwich

As verses 3 e 4 so oficialmente licensiadas para tablets.

2.1. Desenvolvimento Android

2.2. Preparao do Ambiente de Desenvolvimento

Nesta tela possvel escolher quais pacotes sero baixados e instalados.

Em seguida, coloca-se o nome do projeto (no caso HelloWorld) e seleciona-se,

Conforme configurado, o prprio SDK se encarrega de criar a atividade principal