Android

Introdução:
O mercado de celulares está crescendo em uma proporção muito intensa.

Algumas pesquisas mostram que atualmente mais de 4 bilhões de pessoas
possuem algum aparelho celular.
Acompanhando está evolução de tecnologia e agradar estes usuários,

começou uma grande corrida, das maiores empresas do mundo em
tecnologia móvel por esse nicho do mercado, sendo assim o Android é a
resposta do Google.
O Android é uma plataforma desenvolvida pela Google voltada para

dispositivos móveis. Em 5 de novembro de 2007, a empresa tornou
pública a primeira plataforma Open Source de desenvolvimento para
dispositivos moveis baseada na plataforma Java com sistema operacional
Linux, na qual foi chamada de Android.
Android é uma plataforma aberta voltada para dispositivos móveis

desenvolvida pela Google e atualmente é mantida pela Open Handset
Alliance(OHA), um grupo formado por mais de 40 empresas as quais se
uniram para inovar e acelerar o desenvolvimento de aplicações
Destinação do material
Este material tem por objetivo mostrar de modo fácil como programar na
plataforma para dispositivos móveis da Google (Android).
É necessário ter conhecimento na linguagem Java.
Alfamídia educação profissional

Avenida Cristóvão Colombo, 1496 - Floresta
Porto Alegre - RS, 90560-001, Brasil
(0xx)51 3073-2100
Estrutura da plataforma Android:
O Android SDK é o kit de desenvolvimento que

disponibiliza as ferramentas e APIs necessárias para desenvolver
aplicações para a plataforma Android.
a) Dalvik virtual machine otimizada para dispositivos móveis
b)Application framework reutilização e substituição de

componentes
c)Browser Integrado baseado no webkit engine
d)Gráficos Otimizados possui uma biblioteca 2D; e 3D baseada na

especificação OpenGL ES 1.0 (aceleração de hardware é opcional)
e) SQLite para guardar dados estruturados
f)Suporte multimídia para áudio, vídeo e formatos de
g)Telefonia GSM (dependente de hardware)
h) Câmera e GPS (dependente de hardware)

(0xx)51 3073-2100
Configuração do Ambiente
A) Instalação do SDK:
Baixar o SDK e o plugin no endereço abaixo.
http://developer.android.com/sdk/index.html
Após fazer este processo, temos que descompactar o SDK.

Neste material iremos utilizar o SDK para o Windows.

(0xx)51 3073-2100
Ao executá-lo, irá a aparecer a imagem abaixo:
Após o sucesso da atualização, vá à seção “Available Packages”.

(0xx)51 3073-2100
Agora clique no botão “Install Selected” e será mostrada uma nova
tela,conforme a figura abaixo:
Clique no botão “Install”.
A instalação leva alguns minutos, então não fique preocupado.
Já levo em consideração, que você já tenha alguma IDE instalada, neste

tutorial irei usar o Eclipse, caso você esteja usando outra ambiente de
desenvolvimento, só perguntar no debate desta unidade.
b) Instalando o plugin do Android no Eclipse.
Só lembrando que o plugin, você baixo no mesmo link, o qual você

obteve o SDK do Android.

(0xx)51 3073-2100
Agora vamos executar o Eclipse.
Com Eclipse aberto, vá ao menu:

(0xx)51 3073-2100
Você verá a tela abaixo:
Clique no botão “Add” irá aparecer uma caixa de dialogo.

(0xx)51 3073-2100
Clique no botão “Archive” e iremos selecionar o plugin do Android.
Clique no botão “OK”

(0xx)51 3073-2100
Expanda o item “Developer Tools” e marque todas as opções.

(0xx)51 3073-2100
Clique no botão “Next”. Na próxima janela clique em “Finish”.
Após isso será instalado os processos do plugin.

(0xx)51 3073-2100
c) Configurando o Emulador do Android
Reiniciando o eclipse, vá no menu
“Window” - “Preferences”
Abrirá uma caixa, selecione o item “Android”, como a imagem abaixo.

(0xx)51 3073-2100
Selecione o diretório onde se encontra o Android, que, o android se
encontra instalado em “C:\Users\user\Documents\Android\software”,
após selecionar só clicar em no botão “OK”.
O ultimo passo agora, é definirmos o nosso dispositivo virtual, mas

conhecido como AVD (Android Virtual Device). Neste dispositivo virtual
onde nossas aplicações serão executadas. Para configurar:
Irá aparecer a tela abaixo:

(0xx)51 3073-2100
Clique no botão “New” e irá aparecer a tela abaixo.

(0xx)51 3073-2100
Definindo os parâmetros.
Em “Name”, definimos o nome do AVD, vamos chama – lô de

“Emulador_Alfamidia”.
Em “Target”, vamos definir qual será a plataforma que será utilizada no

AVD , a versão alvo.
Uma dica pessoal, como vocês estão começando eu indico colocar acima
do Android 2.1.
Eu irei usar no campo “Target” a versão “Android 2.1 - API Level 7”.

(0xx)51 3073-2100
Obs: Quando começarmos a fazer os exercicios será mostrado como
definir API. Não se preocupe neste momento.
Após definirmos os campos, a tela deve ficar como a imagem abaixo.
Agora só clique no botão “Create AVD”

(0xx)51 3073-2100
Após clique em “OK”, na caixa de dialogo. E agora na próxima Unidade
iremos desenvolver nossa primeira aplicação.
Até a Unidade 2.

(0xx)51 3073-2100
Conceitos Básicos do Android
Nesta unidade, vamos estudar os conceitos básicos do Android.
Por exemplo, a tela do Android pode utilizar simplesmente um arquivo

XML, para definir os elementos da tela ou usar algo similar ao Swing
(interface gráfica linguagem Java).
Ao final, desta unidade já iremos desenvolver nossa primeira aplicação.
1) Activity
Activity está vinculado à tarefa, ao qual aplicação pode fazer. Esta tarefa
pode ser qualquer coisa, por exemplo, uma tela de boas-vindas, um mapa,
uma lista de itens, uma tela de opções, enfim, algo que possa ser
apresentável para o usuário.
Activity é o componente chave do Android e para haver interação com a

interface de usuário uma classe deve herdar de uma Activity.
Observe a linha número 11, nesta linha, temos o método:
setContentView(view)
(0xx)51 3073-2100
Este método é o elo, entre a Activity e a view. Tendo como parâmetro a
view que será exibida na tela. A chamada do método setContentView,
deve ser sempre no método onCreate.
Se avaliarmos o valor passado por parâmetro, é uma constante

R.layout.main, ao qual é um arquivo main.xml. Este arquivo se encontra
na pasta layout, sendo assim usada como tela principal.
Obs: o arquivo main.xml é gerado, quando for criado um projeto

Android.
2) AndroidManifest.xml
Este arquivo é a base de uma aplicação desenvolvida para o Android.

AndroidManifest.xml deve ficar sempre na pasta raiz do projeto, pois
nela está contida todas as configurações para executar uma aplicação no
Android.
Podíamos associar este arquivo, ao web.xml, para aplicações web em

Java, podendo ser visualizado desta maneira ou como um arquivo do tipo
XML (prefiro desta maneira)

(0xx)51 3073-2100
 package – nome do pacote da sua aplicação e servirá identificação
única, não deve ser alterada no caso de atualização.
 android:versionCode – é a versão da sua aplicação, quando você

atualiza uma aplicação deve incrementá-la, o próprio market se
encarrega de avisar a quem tem a versão anterior de que uma nova
versão existe.
 android:versionName – é o número que o usuário verá da versão de

sua aplicação, não tem efeito real em atualizações.
 uses-sdk android:minSdkVersion – informa qual a api mínima

necessária para rodar sua aplicação, tenha cuidado na escolha desse
número pois uma aplicação que utiliza uma api maior do que
realmente precisa está apenas limitando os usuários que podem
instalá-la, ou seja você só perde mercado. Uma olhada
nesse gráfico é uma boa consulta na hora de você criar uma
aplicação android.
 application – grupo que contém elementos que podem afetar toda

a aplicação.
 android:icon – ícone que representa a aplicação.
 android:label – texto exibido na barra de status quando a aplicação

está rodando.

(0xx)51 3073-2100
 activity - cada classe que implementa activity (ou subtipo do
mesmo) exige que seja criada uma tag do tipo activity no manifesto
para que o android saiba de sua existência.
 android:name – é o nome da classe sem a sua extensão.
3) Classe R
Você deve estar se perguntando:

“Para que serve está classe R.java ??”
Está classe é criada automaticamente pelo plug – in do Eclipse e não

deve ser alterada manualmente. Isso só irá acontecer quando
criamos um novo projeto ou quando alteramos algum recurso do
projeto.

(0xx)51 3073-2100
Nossa primeira aplicação em Android
Agora vamos criar o nosso primeiro projeto no Android.

Vamos lá:
Execute o Eclipse e vá ao menu:
File / New / Other
Obs.: Além do sub – menu “other”, você pode usar o

sub – menu “Project”

(0xx)51 3073-2100
Ao clicar em “Next” será mostrada a tela abaixo:
Vamos definir:
Project name: Alfamidia_Android_01
Você deve ter percebido, as plataformas ao qual eu possuo na IDE, não se

assuste, pois este PC ao qual estou desenvolvendo a apostila é minha
máquina de produção.

(0xx)51 3073-2100
Sempre quando houver uma nova versão do Android, você pode se
atualizar pelo site:
http://developer.android.com/sdk/index.html
Cada versão nova há uma vantagem, sendo assim sempre ele em

consideração o level, para ver o que a sua aplicação necessita. Analisando
a tabela abaixo:
Por exemplo, se desenvolvermos uma aplicação para uma plataforma

Android 3.0 e instalaramos em aparelho com uma versão inferior teremos
problema.
Agora uma pergunta, que eu já me fiz, e vocês devem estar se

perguntando.
“Para qual versão devo desenvolver?”

(0xx)51 3073-2100
Independentemente da versão que se adote o quadro que apresenta aos
desenvolvedores a divisão entre as versões do Android em atividade é
divulgado pelo Google periodicamente, como no gráfico a seguir,
divulgado há poucas semanas:
Para você ter acesso a este gráfico, acesso o link abaixo:
http://developer.android.com/resources/dashboard/platform-
versions.html

(0xx)51 3073-2100
Mas voltando para o nosso primeiro projeto, vamos definir a versão mais
próxima da versão 2.0, como configuramos na Unidade 1.
Agora vamos definir os outros campos:
Application name : Alfamidia Android
Package name: br.com.android
Create Activity : AppAlfamidia
Min SDK Version : 7

(0xx)51 3073-2100
Após preenchermos os campos, basta clicar no botão “Finish” e pronto,
nosso projeto foi criado.
Você deve estar se perguntando :
Mas o que é este diretório “res” ?

(0xx)51 3073-2100
Totalmente diferente da versão 1, nas versões poteriores há versão do
SDK trabalha com três diretórios “drawables”, drawable-hdpi,drawable-
ldpi, drawable-mdpi.
Cada um desses diretórios só será utilizado de acordo com a resolução do

Android que você está utilizando, ou seja, qual modelo de emulador de
você estiver usando, não se preocupe iremos trabalhar com estes
diretórios mas adiante.
Vamos adicionar um componente na nossa aplicação, eu vou priorizar

sempre trabalhar direto no arquivo “XML” , pois se souber , saberás em
qualquer tipo de IDE.
Agora vamos arquivo main.xml

(0xx)51 3073-2100
LinearLayout, responsável por organizar os componentes exibidos natela,
por padrão os componentes são distribuídos na vertical pelo atributo
android:orientation="vertical".
Dentro desta tag, existe uma um componente chamado TextView,

querepresenta um texto a ser exibido na tela , por padrão, ele irá exibir
“Hello World, AppHello” através do atributo android:text="@string/hello",
onde o valor “@string/hello” equivale a uma constante, que está definida
no arquivo strings.xml, que se encontra no diretório “values”.
Agora vamos executar o nosso projeto:
Vá no menu especificado na imagem baixo:
Ao clicar você verá uma caixa de dialogo, clique com o botão direito sobre
o item Android.

(0xx)51 3073-2100
Obs: Não leve em consideração as outras aplicações, pois como já foi
dito, minha máquina é de produção.
Agora iremos mudar o campo :
Name : Alfamidia_Android

(0xx)51 3073-2100
Clique em Apply e veja que já foi adicionado :

(0xx)51 3073-2100
Agora clique no botão Browse e direcione o projeto ao qual estamos
desenvolvendo.
Agora clique em Run e espere alguns segundos e veja que será executado
o emulador:

(0xx)51 3073-2100
Desenvolver com o emulador, você perceberá que pode ser algo bem
trabalhoso, então se você necessita ver algum resultado com freqüência,
deixe o emulador minimizado.
O emulador age como se fosse um smartphone ou tablet, então temos

que desbloquear a tela, caso não consiga, coloque a sua dúvida no fórum
de debate.

(0xx)51 3073-2100
Após desbloquear veja o resultado:
Até a Unidade 3

(0xx)51 3073-2100
Definição de Activity e seu ciclo de vida.
Nesta unidade, iremos conhecer uma das mais importantes classes de

uma aplicação Android: A classe Activity.
Na unidade anterior a introduzimos, mas nesta unidade iremos estudar o

seu ciclo de vida, por exemplo, imagine o usuário usando sua aplicação, e
ele recebe uma chamada, e instantes depois com a ligação ativa, ele abre
a agenda, agora vem à pergunta: “o que acontece com a sua aplicação?” ,
está pergunta após a leitura desta unidade você responderá.
1) Activity
“Activity é basicamente uma classe gerenciadora de UI (Interface com o

usuário). Todo aplicativo Android começa por uma Activity.”
Resumindo:
“Ou seja, quando uma aplicação Android é executada, na verdade é a

sua Activity principal que é lançada.”

(0xx)51 3073-2100
Ciclo de vida de uma Activity
Uma das coisas que é importante conhecerem sobre a Activity é o seu
ciclo de vida. E para explicá-lo, nada melhor do que o seguinte diagrama:

(0xx)51 3073-2100
 onCreate() É a primeira função a ser executada quando uma Activity
é lançada. Geralmente é a responsável por carregar os layouts XML
e outras operações de inicialização. É executada somente uma vez
durante a “vida útil” da Activity.
 onStart() É chamada imediatamente após a onCreate() – e também

quando uma Activity que estava em background volta a ter foco.
 onResume() Assim como a onStart(), é chamada na inicialização da

Activity (logo após a própria onStart()) e também quando uma
Activity volta a ter foco. Qual a diferença entre as duas? A onStart()
só é chamada quando a Activity não estava mais visível na tela e
volta a ter o foco, enquanto a onResume() sempre é chamada nas
“retomadas de foco”.
 onPause() É a primeira função a ser invocada quando a Activity

perde o foco (ou seja, uma outra Activity vem à frente).
 onStop() – Análoga à onPause(), só é chamada quando a Activity

fica completamente encoberta por outra Activity (não é mais
visível).
 onDestroy() A última função a ser executada. Depois dela, a Activity

é considerada “morta” – ou seja, nao pode mais ser relançada. Se o
usuário voltar a requisitar essa Activity, outro objeto será contruído.
 onRestart() Chamada imediatamente antes da onStart(), quando

uma Activity volta a ter o foco depois de estar em background.

(0xx)51 3073-2100
Processos do ciclo de vida
O Android tenta manter os processos de aplicações em

memória pelo tempo máximo possível, mas
eventualmente será necessário remover processos
antigos quando a memória começa a ficar menos
disponível. A decisão de qual processo ser removido é
intimamente ligada ao estado da interação do processo
com o usuário. Em geral, existem quatro tipos de
processos que podem ser baseados nas atividades que
estão rodando, abaixo listadas em ordem de importância.
O sistema vai matar processos menos importantes antes
de matar processos mais importantes na tentativa de
liberar memória.
1. Atividade de frente (foreground Activity) - A

atividade que está sendo rodada naquele instante é
considerada a mais importante. Seus processos
somente serão mortos como último recurso, se ele
usar mais memória que o que vem disponível no
dispositivo. Geralmente nesse momento o
dispositivo já chegou ao estado de uso de paginação,
então é requerido matar esse processo será
necessário para manter a resposta de interface.

(0xx)51 3073-2100
2. Atividade visível (visible Activity) - Uma atividade
que está visível mas o usuário não o têm na frente,
como uma atividade que fica atrás de um diálogo em
janela flutuante, por exemplo, é considerada
extremamente importante e não será morta a não
ser que seja requerido para que a atividade de frente
possa continuar rodando.
3. Atividade de fundo (background activity) - Uma

atividade que não é visível ao usuário e que está em
modo onPause() não é mais crítica e o sistema
poderá, de maneira bastante segura, matar seu
processo na memória para que possa ser usada por
outros processos. Se esse processo precisar ser
morto, quando o usuário navegar de volta a ele
(fazendo com que ele se torne visível novamente na
tela), o método onCreate(Bundle) dele será chamado
com o savedInstanceState suprido pelo
onSaveInstanceState(Bundle) para que possa ser
reiniciado no mesmo estado que foi deixado.
4. Processo vazio é um processo que não tem nenhuma

atividade ou outros componentes de aplicação
rodando nele (como um Service ou
BroadcastReceiver). Eles são rapidamente mortos
pelo sistema assim que é necessário mais memória.
Então, quaisquer operações de fundo que precisam
(0xx)51 3073-2100
ser executadas fora da atividade devem ser
executadas no contexto de uma atividade
BroadcastReceiver ou Service para assegurar que o
sistema saiba que é necessário mantê-la no ar para
que seu processo seja executado.
Algumas vezes uma atividade necessita que uma

operação que é longa seja executada independentemente
do ciclo de vida da aplicação. Um exemplo é o de uma
aplicação de câmera que esteja fazendo o upload de uma
imagem para um site. O upload pode tomar bastante
tempo e a aplicação deverá permitir ao usuário que ele
saia dela sem que, no entanto, o upload pare. Para
conseguir isso, sua atividade deverá iniciar um Service no
qual o upload é feito. Isso permite ao sistema priorizar
apropriadamente seu processo pela duração do upload,
independentemente se a aplicação original está pausada,
parada ou finalizada.

(0xx)51 3073-2100
Antes de exercitarmos está teoria, vamos estudar a leitura do LOG, no
Android, para sabermos os acontecimentos da nossa app.
LOGCAT
Assim que iniciamos os estudos na plataforma Android nos deparamos
com um problema simples: o System.out.println() não funciona, então
como ver os meus logs para ajudar no debug dos meus apps? A resposta é
simples, no Android temos a Classe Log que é responsável pela captura e
visualização das saídas de debug do sistema, e é através dela que veremos
os nossos logs.
Existe 5 tipos de logs são eles:
 V — Verbose
 D — Debug
 I — Info
 W — Warning
 E — Error
Veja a imagem abaixo, mostrando um exemplo de LogCat.

(0xx)51 3073-2100
No exercício, ao qual iremos desenvolver vamos usar o LOG CAT, para
vermos claramente o ciclo de vida da nossa aplicação.
Vamos criar um projeto novo.
Obs.: Caso não lembre, revise a unidade 2 ou tire a duvida no fórum para
debatermos .
Nome do Projeto: “Projeto_Ciclo_Vida”
Application name : Alfamidia Ciclo Vida
Create Activity : Projeto_Ciclo_VidaActivity
Min SDK Version : 7

(0xx)51 3073-2100
Na classe Projeto_Ciclo_VidaActivity.java digite o código abaixo.
public class Projeto_Ciclo_VidaActivity extends Activity {

/** Called when the activity is first created. */
protected static final String CAT = "Ensino_Alfamidia";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
TextView texto = new TextView(this);
texto.setText("Ciclo de Vida");
setContentView(texto);
}
protected void onStart() {

super.onStart();
// Log.i LOG tipo informação
Log.i(CAT,getName()+".onStart() executando");
}
protected void onRestart() {

super.onRestart();
Log.i(CAT,getName()+".onRestart() executando");
}
protected void onResume() {

super.onResume();
Log.i(CAT,getName()+".onResume() executando ");
}
protected void onPause() {

super.onPause();
Log.i(CAT,getName()+".onPause() executando ");
}
protected void onStop() {

super.onStop();
Log.i(CAT,getName()+".onStop() executando ");
}
protected void onDestroy() {

super.onDestroy();
Log.i(CAT,getName()+".onDestroy() executando ");
}
protected String getName() {

String s= getClass().getName();
s = s.substring(s.lastIndexOf("."));
return s;
}
}

(0xx)51 3073-2100
Execute este código fonte, sendo assim faça as configurações para
executar o emulador.
Obs.: Caso não lembre, revise a unidade 2 ou tire a duvida no fórum para
debatermos
Ao executar o emulador irá parecer.
Vou mostrar agora como visualizar os logs no Eclipse, porque os mesmos

não aparecem no console como os logs do
System.out.println();
No Eclipse aperte Ctrl + 3 e digite logcat, visualize o LogCat na tela e
selecione-o.

(0xx)51 3073-2100
Onde está em destaque, você pode fazer um filtro no LOGCAT. Como
nossas informações de LOG, são do tipo “i”, de informação, vamos clicar
na letra “I”.
Veja imagem abaixo:
Enquanto a nossa aplicação estiver sendo executado, e também

visualizado pelo usuário, estes dois métodos foram chamados.
Agora vamos fechar a nossa aplicação. Para fechar a aplicação, abra o

emulador e clique na tecla “ESC”.
E agora volte para o LOGCAT e veja adição de outras informações.
Está unidade foi muito importante, para entendermos como funciona

nossa aplicação.
Até a Unidade 4.

(0xx)51 3073-2100
Intent
Nesta unidade, iremos entender a seguinte pergunta, que o Android faz

para a sua aplicação.
Qual sua intenção (intent)?
Cabe o sistema operacional Android, interpretar a resposta dado pela

aplicação. E sendo assim tomar as providências necessárias para aplicação.
O trecho acima demonstra como o sistema operacional Android trata

todas requisições como intenções, ou tarefas, ou broadcast (veremos nos
próximos capítulos), ou mensagens que a aplicação deseja executar. Estas
mensagens podem ser: a abertura de uma Activity com passagem de
parâmetros, envio de SMS, chamada telefônica, ate mesmo abrir o Google
Play (chamado antigamente de Android Market).
Para ficar bem claro, o uso da Intent, vamos desenvolver um exemplo.

(0xx)51 3073-2100
Abrindo o browser
Vamos dizer que por algum motivo você deseja abrir o browser,
para mostrar para usuário uma determinada página. Neste exemplo
ficará bem clara a utilização de uma Intent, usando a seguinte ação:
Intent.ACTION_VIEW
Vamos desenvolver um novo projeto:
Nome do Projeto: “Projeto_Browser”
Application name : “Alfamidia Browser”
Create Activity : Projeto_BrowserActivity
Min SDK Version : 7

(0xx)51 3073-2100
No arquivo main.xml, faça as alterações o deixando como a imagem
abaixo.
Obs.: Não se preocupe em entender sobre interface gráfica neste

momento, pois teremos uma unidade sobre este assunto.

(0xx)51 3073-2100
No arquivo Projeto_BrowserActivity, veja a imagem abaixo.
package br.com.android;
import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class Projeto_BrowserActivity extends Activity implements

OnClickListener
{
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
final Button botao = (Button) findViewById(R.id.botaoPesquisa);
botao.setOnClickListener(this);
public void onClick(View view)

{
// URL que queremos abrir para o usuário
Uri url = Uri.parse("http://www.google.com.br");
// Estamos usando o INTENT(intenção de algo)
Intent intencao = new Intent(Intent.ACTION_VIEW,url);
//Enviando a intenção para o sistema operacional Android
startActivity(intencao);
}
}
Agora você deve estar pensando: “Só isso? Já posso executar o

emulador?”
Ainda não, temos que solicitar a permissão para poder acessar a internet
usando a aplicação:
A permissão para isto:
Android.permission.Internet

(0xx)51 3073-2100
No arquivo AndroidManifest.xml, veja a imagem abaixo.
Adicionamos a permissão para permitir, navegar na internet.
Agora vamos executar o emulador e veremos a imagem abaixo:

(0xx)51 3073-2100
Quando clicar no botão “Google”, irá aparecer:
Só reforçando, criamos a intenção na seguinte linha:

Intent intencao = new Intent(Intent.ACTION_VIEW,url);
E enviamos está intenção para o sistema operacional Android, através da

linha:
startActivity(intencao);
Não se preocupe, pois nas outras unidades iremos trabalhar mais com a
classe Intent.
Até a Unidade 5 turma..

(0xx)51 3073-2100
Interface Gráfica
Nesta unidade, iremos introduzir a interface gráfica no sistema

operacional Android.
Neste artigo vamos aprender como criar interfaces gráficas (UI) mais
básicas com Android.
Para quem está chegando de mundos um pouco mais obscuros em relação

à UI, como o Java ME, a diferença é gritante e impressiona. Com Android
temos gerenciadores de layout sofisticados, componentes estilizados com
efeitos atrativos graficamente, além de uma facilidade no
desenvolvimento.
O Android oferece dois modos de criar interfaces gráficas, uma é

definindo um arquivo XML que será carregado no startup da aplicação e a
renderização da tela é construída em tempo de execução. O outro modo é
através da codificação pura. Na maioria dos casos o desenvolvedor usará
as duas maneiras, porém, recomenda-se a preferência pelo uso do XML.
Obs:
A Activity utiliza uma pilha, chamada de activity stack, o índice que

estiver no topo da pilha será a tela exibida para o usuário da aplicação.
Para quem programa para BlackBerry OS verá grandes similaridades com
a pilha de Screens desta plataforma.

(0xx)51 3073-2100
View e ViewGroup
Quando pensamos em interface gráfica de um aplicativo Android
devemos ter em mente o que significa View e ViewGroup.
Ambos representam qualquer componente visual que você
visualizar na tela do aparelho.
A classe View representa o bloco de construção básico para

componentes de interface gráfica. Uma View ocupa uma área
retangular na tela e é responsável por desenhar e controlar os
eventos.
View é a classe básica para widgets , que são usados para criar
componenetes de UIinterativos (botões, caixas de texto, etc.). A
subclasse.
ViewGroup é a classebase para layouts , que são containers

invisíveis que contém Views (ou outros ViewGroups) e definem
as propriedades desse layout. Veja a Figura1 para um melhor
entendimento.

(0xx)51 3073-2100
Na interface existe um vasto conjunto de widgets, desde botões atécaixas
de seleções. Todos esses componentes estão dentro de um gerenciador
de layout, mais precisamente em um LinearLayout.

(0xx)51 3073-2100
Gerenciadores de Layout
Vamos começar a brincadeira com UI no Android com osgerenciadores de

layout. Como o próprio nome indica, estas classesorientam o
posicionamento dos widgets na tela. Dependendo do layout utilizado, até
a altura e largura do componente é alterada.Para quem trabalhou com o
swing do Java lembra do BorderLayout,FlowLayout , dentre outros. Até
mesmo no Java ME é possível utilizargerenciador parecidos com os
mencionados anteriormente, através doLWUIT.Inicialmente vamos criar
uma aplicação Android que alteraremosconforme o gerenciador de layout
a ser estudado.
LinearLayout
Este gerenciador organiza seus componentes filhos em uma única coluna

ou única linha, dependendo da orientação que o mesmo tiver
Para ficar mais claro, vamos editar o arquivo main.xml, como já explicado
nas unidades anteriores.

(0xx)51 3073-2100
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=http://schemas.android.com/apk/res/android
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<EditText android:id="@+id/EditText01"
android:layout_width="180px"
android:layout_height="wrap_content"
/>
android:layout_height="wrap_content”
/>
<Button android:id="@+id/Button01"
android:layout_width="wrap_content"
android:text="Enviar"
/>
</LinearLayout>

(0xx)51 3073-2100
Se executar a aplicação:
Vamos fazer algumas alterações no XML para compreender o que ele faz.
Na declaração do layout, que sempre deve ser o nó raiz do
documento,temos o LinearLayout.
Definimos para este componente três propriedades:

android:layout_height="fill_parent"

(0xx)51 3073-2100
A orientation defina se os componentes se desenrolarão no sentido
horizontal ou vertical. Se a tela terá apenas uma linha ou uma coluna,
como falado anteriormente. Mudemos essa propriedade para:
android:orientation="horizontal"
Também definimos as propriedades de largura (width) e altura (height ).

Ambos usam fill_parent, que diz o seguinte: use todo o espaço disponível
na tela. Vamos mudar novamente o main.xml, mais especificamente as
propriedades do LinearLayout.

(0xx)51 3073-2100
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android "
android:layout_height="100px"
>
Perceba que o restante dos componentes foi cortado, por exceder do seu
container, o LinearLayout. Na prática, porém, vai ser raro as vezes em que
este gerenciador de layout não vai ocupar todo o espaço disponível na
tela.
Existem alguns atributos específicos para componentes que fazem todo

sentido quando aplicados no LinearLayout.Vamos trabalhar com duas
propriedades: android:layout_weight e android:layout_gravity.
Vamos modificar o arquivo main.xml.

(0xx)51 3073-2100
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android “
>
android:layout_weight="0.3"
/>
android:layout_weight="0.7"
/>
Button android:id="@+id/Button01"
android:layout_gravity="right"
/>
</LinearLayout>

(0xx)51 3073-2100
Executando veremos a imagem abaixo.
A propriedade gravity funciona como uma função de alinhamento em

relação ao container, como usamos right no botão, veja que ele se
encontra na extremidade direita da tela.

(0xx)51 3073-2100
O weight repassa para os componentes o espaço não utilizado na tela. Há
não se preocupem com os componentes, eles serão tratados daqui
apouco.
Volte para a figura 4 e perceba que o espaço “vazio” desapareceu, sendo

atribuído para as duas caixas de textos que definiram a propriedade
weight.
Perceba também, que a segunda caixa de texto recebeu 70% do espaço

não utilizado, por isso ficou maior que a primeira caixa
Bem, encerramos por aqui a discussão sobre a LinearLayout.
Há não se preocupe com os widgets (componentes).
Logo veremos detalhadamente cada um.
AbsoluteLayout
Este gerenciador define exatamente a posição (coordenada x/y) onde

cada componente deve ficar. Este layout é menos flexível e também exige
um maior trabalho para manutenção. Por exemplo, quando o aparelho
muda a orientação, quem deve redefinir a posição dos componentes é o
programador, via código.

(0xx)51 3073-2100
Mas chega de conversa, redefina o main.xml:
<?xml version="1.0" encoding=”utf-8"?>
<AbsoluteLayout
xmlns:android="http://schemas.android.com/apk/res/android "
>
android:layout_x="12px"
android:layout_y="12px"
/>
/>
/>
</AbsoluteLayout>

(0xx)51 3073-2100
Quando executar a aplicação, veremos:
Simples né ? Mas você já deve ter percebido, na é um gerenciador de

layout muito aconselhado.
TableLayout
Este gerenciador pode ser o mais auto-descritivo de todos. Para surpresa

geral, ele organiza seus componentes filhos em linhas e colunas.As linhas
da tabela são representadas pela classe TableRow.
As colunas são criadas conforme a inserção de componentes em uma

mesma linha. Não é permitido bordas em linhas, colunas e células

(0xx)51 3073-2100
Vamos editar o arquivo main.xml.
<?xml version="1.0"
encoding="utf-8"?>
<TableLayout
xmlns:android="http://schemas.android.com/apk/res/android "
>
<TableRow>
<TextView
android:text="Nome"
/>
<EditText
android:id="@+id/EditText01"
/>
</TableRow>
<TableRow>
<TextView
android:text="Endereço"
/>
<EditText
/>
</TableRow>
<TableRow>
<TextView />

(0xx)51 3073-2100
/>
</TableRow>
</TableLayout>
Execute o emulador e veja:
Vários pontos devem ser detalhados aqui. Primeiramente, veja que

definimos a largura dos componentes somente para a primeira linha. Isso
porque a coluna define sua largura como igual a largura do maior
componente horizontal. Assim, se redefinirmos a última caixa de texto e o
botão para:

(0xx)51 3073-2100
<TableRow>
<TextView
android:text="Endereço"
/>
<EditText
/>
</TableRow>
<TableRow>
<TextView />
<Button
android:id="@+id/Button01"
/>
</TableRow>
O resultado da interface vai ser o mesmo. Tanto o campo de texto

deendereço como o botão tem largura menor que a primeira caixa de
texto.Na última linha colocamos um campo de texto vazio:
<TextView />

(0xx)51 3073-2100
Ao executar o emulador veremos a seguinte imagem:
Temos outros tipos de manipulações de Layout, RelativeLayout e
FrameLayout, nesta unidade demos ênfase nos tipos de Layout principais.
Depois de estudarmos os sobre os gerenciadores de layout, representados

pelos ViewsGroups na próxima unidade iremos estudar sobre os
componentes representados pelas classes que herdam de View.
Até a próxima Unidade.

(0xx)51 3073-2100

Android

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Android

Uploaded by

Copyright:

Available Formats

Introdução:

O mercado de celulares está crescendo em uma proporção muito intensa.

Acompanhando está evolução de tecnologia e agradar estes usuários,

O Android é uma plataforma desenvolvida pela Google voltada para

Android é uma plataforma aberta voltada para dispositivos móveis

É necessário ter conhecimento na linguagem Java.

Alfamídia educação profissional

O Android SDK é o kit de desenvolvimento que

a) Dalvik virtual machine otimizada para dispositivos móveis

b)Application framework reutilização e substituição de

c)Browser Integrado baseado no webkit engine

d)Gráficos Otimizados possui uma biblioteca 2D; e 3D baseada na

e) SQLite para guardar dados estruturados

f)Suporte multimídia para áudio, vídeo e formatos de

g)Telefonia GSM (dependente de hardware)

h) Câmera e GPS (dependente de hardware)

Alfamídia educação profissional

Baixar o SDK e o plugin no endereço abaixo.

Após fazer este processo, temos que descompactar o SDK.

Alfamídia educação profissional

Após o sucesso da atualização, vá à seção “Available Packages”.

Alfamídia educação profissional

Clique no botão “Install”.

A instalação leva alguns minutos, então não fique preocupado.

Já levo em consideração, que você já tenha alguma IDE instalada, neste

b) Instalando o plugin do Android no Eclipse.

Só lembrando que o plugin, você baixo no mesmo link, o qual você

Alfamídia educação profissional

Com Eclipse aberto, vá ao menu:

Alfamídia educação profissional

Clique no botão “Add” irá aparecer uma caixa de dialogo.

Alfamídia educação profissional

Clique no botão “OK”

Alfamídia educação profissional

Alfamídia educação profissional

Após isso será instalado os processos do plugin.

Alfamídia educação profissional

Reiniciando o eclipse, vá no menu

Abrirá uma caixa, selecione o item “Android”, como a imagem abaixo.

Alfamídia educação profissional

O ultimo passo agora, é definirmos o nosso dispositivo virtual, mas

Irá aparecer a tela abaixo:

Alfamídia educação profissional

Alfamídia educação profissional

Em “Name”, definimos o nome do AVD, vamos chama – lô de

Em “Target”, vamos definir qual será a plataforma que será utilizada no

Alfamídia educação profissional

Após definirmos os campos, a tela deve ficar como a imagem abaixo.

Agora só clique no botão “Create AVD”

Alfamídia educação profissional

Alfamídia educação profissional

Por exemplo, a tela do Android pode utilizar simplesmente um arquivo

Ao final, desta unidade já iremos desenvolver nossa primeira aplicação.

Activity é o componente chave do Android e para haver interação com a

Observe a linha número 11, nesta linha, temos o método:

Se avaliarmos o valor passado por parâmetro, é uma constante

Obs: o arquivo main.xml é gerado, quando for criado um projeto

Este arquivo é a base de uma aplicação desenvolvida para o Android.

Podíamos associar este arquivo, ao web.xml, para aplicações web em

Alfamídia educação profissional

 android:versionCode – é a versão da sua aplicação, quando você

 android:versionName – é o número que o usuário verá da versão de

 uses-sdk android:minSdkVersion – informa qual a api mínima

 application – grupo que contém elementos que podem afetar toda