Apostila android

Apostila de
Programando Passo-a-Passo
De : Luciano Alves (lucianopascal@yahoo.com.br)

2
Índice analítico
Apresentação..................................................................................................... 3
Introdução .......................................................................................................... 4
Instalando o Eclipse e o Android ..................................................................... 4
Criando a nossa primeira aplicação em Android......................................... 10
Usando Widgets............................................................................................... 18
Desenvolvendo uma aplicação que soma números....................................... 18
Desenvolvendo uma aplicação simples de compras...................................... 23
Desenvolvendo uma aplicação de cálculo de salário..................................... 26
Desenvolvendo uma aplicação de lista telefônica.......................................... 31
Desenvolvendo uma aplicação que visualiza imagens .................................. 34
Mudando de layouts ........................................................................................ 38
Desenvolvendo uma aplicação de cadastro................................................... 42
Lista de atributos............................................................................................. 53
Conclusão ........................................................................................................ 58

3
Apresentação
Esta apostila tem por objetivo mostrar de modo fácil como programar na
nova plataforma para dispositivos móveis da Google (Android) usando o eclipse,
por meio de vários programas e exemplos bem explicados.

4
Introdução
O Android é a nova plataforma do 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. Essa plataforma é mantida pela OHA (Open Handset Alliance), um
grupo formado por mais de 30 empresas as quais se uniram para inovar e
acelerar o desenvolvimento de aplicações, serviços, trazendo aos consumidores
uma experiência mais rica em termos de recursos, menos dispendiosa em
ternos financeiros para o mercado móvel.pode-se dizer que a plataforma
Android é a primeira plataforma móvel completa, aberta e livre.
Instalando o Eclipse e o Android
Para a elaboração desse material, eu fiz o uso do Eclipse Europa (Eclipse
3.3.1.1 para Windows) e o SDK do Android versão m5-rc15 e o plugin do
Android para o Eclipse ADT-0.4.0. Qualquer versão (de preferência superior)
dos programas citados acima serve. Claro , para que toda essa aplicação
funcione é necessário que você tenha instalado antes de tudo, a Máquina Virtual
Java (de preferência a versão 5 ou posterior). Bom, mãos a obra.
Deixo aqui os links para download dos itens citados acima:
SDK do Android e o plugin do Android (mesmas versões citadas acima ou
superiores):
http://code.google.com/android/download.html
Eclipse Europa (ou superior)
http://www.eclipse.org/downloads/
Para saber se você possui uma Maquina virtual Java, entre no prompt de
comando de digite a seguinte linha:
java –version
Se mostrar algo parecido como mostra o código abaixo:
java version "1.6.0_07"
Java(TM) SE Runtime Environment (build 1.6.0_07-b06)
Java HotSpot(TM) Client VM (build 10.0-b23, mixed mode, sharing)
Beleza, você possui uma máquina virtual Java instalada no seu
computador, caso contrário, entre no Site da Sun e faça o seu download. Aqui
está o link

5
http://java.sun.com/javase/downloads/index.jsp
Depois de obter os programas e plugins citados acima, o primeiro
programa e ser instalado é o eclipse. Para instalar o eclipse, simplesmente
descompacte-o em um local desejado.
Agora vamos instalar o SDK Android. É o mesmo procedimento do eclipse,
descompactar em um local apropriado.
Por ultimo, vamos instalar o plugin do Android. Para isso, descompacte-o o
plugin do Android em um local desejado.
Agora execute o eclipse, se você estiver executando-o pela primeira vez,
ele irá pedir para definir uma pasta padrão (um Workspace). Defina a pasta e
continue o carregamento do eclipse. Depois de carregado, se for a primeira
vez, feche a Janela do “Welcome” (Bem-vindo). Agora vamos instalar o plugin
do Android, vá no menu “Help / Softwares Updates / Find and Install”, conforme
figura abaixo:
Selecione a opção “Search for new features to install” e clique no botão
“Next”. Será exibida uma tela conforme a figura abaixo:

6
Feito isso, clique no botão “New Local site” e indique o diretório do ADT
já descompactado no local onde você extraiu. Para ficar mais claro, dento do
diretório ADT existem dois diretórios __MACOSX e um outro chamado ADT-
x.x.x , selecione este. Feito isso, clique em “OK” e será exibida uma caixa de
diálogo conforme figura abaixo:
Na caixa de diálogo acima, basta clicar no botão “OK”. Pronto! O item foi
inserido, conforme a figura abaixo. Agora é só clicar em “Finish”.

7
Depois de clicar em “Finish” na tela acima, será mostrado uma nova tela
conforme figura abaixo.
Clique no sinal “+” e faça as seleções dos plugins de acordo com a
próxima figura que é exibida a seguir. Caso você esteja utilizando uma outra
versão do plugin você pode selecionar todas as opções desde nenhuma delas
resulte em alguma mensagem de erro, como no caso nesta versão do plugin
que utilizei, o último item (Android Editors) não pode ser instalado pois requer a
existência de um outro plugin.

8
Feito isso, clique no botão “Next”, e será exibida uma tela de licensa de
software. Nesta tela é só selecionar a opção “I accpet the terms in the license
agreement” e clique no botão “Next”. Na próxima tela, simplesmente clique no
botão “Finish” e na próxima tela, que é mostrada na figura abaixo, clique no
botão “Install All”.

9
Após instalar os plugins, será exibida uma mensagem, conforme a figura
abaixo, recomendando ao usuário que ele reinicie o eclipse. Simplesmente
clique no botão “Yes”.
Após o eclipse ter reiniciado, vamos fazer agora as configurações para
fazer conexão com o emulador do Android. Vamos no menu “Window” /
“Preferences”. Aberta a caixa de diálogo, selecione o item “Android”, será
mostrada duas mensagens de erro, ignore-as. Agora vamos indicar o local onde
se encontra o emulador do Android, simplesmente clicando no botão
“Browse...” e indicando o seu local onde foi instalado. Feito isso, se a sua tela
está de acordo com a tela da figura abaixo, se estiver (mostrando lá no topo o
título Android) o diretório indica está correto, é só clicar em “OK”.

10
Criando a nossa primeira aplicação em Android
Agora vamos criar um novo projeto Android indo no menu “File” / “New” /
“Other”. Selecion o projeto Android conforme figura abaixo. Depois de
selecionar, clique em “Next”:
Após clicar em “Next” na figura acima, será exibida uma tela conforme
figura abaixo. Vamos chamar o nosso projeto “Project name” de ProjetoAndroid.
Em “Package name” vamos digitar “com.android.hello”. Em Activity name
digitaremos “AppHello” e em “Application name” digitaremos “App Hello World”,
é só conferir na figura abaixo. Depois é só clicar em “Finish”.

11
Pronto! Nosso projeto foi criado. Em Package Explorer, vamos dar uma
olhada na estrutura do Projeto, simplesmente clicando no botão “+”. É só seguir
a figura abaixo, aproveite e abra o arquivo AppHello.java , também conforme
figura abaixo:
Bom, agora irei descrever a estrutura de um projeto Android. Observem
que dentro da pasta ProjetoAndroid existe uma pasta chamada “src”, dentro
dela é que ficam os códigos fonte java das aplicações. Observem que o arquivo
AppHello.java se encontra dentro do pacote “com.android.hello” (Esse pacote
também é uma pasta). Esse arquivo é a nossa aplicação Android. Vou
descrever em detalhes o arquivo AppHello.java (Veja o código abaixo):
package com.android.hello;
import android.app.Activity;
import android.os.Bundle;
public class AppHello extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);
}
}
Diferentemente das aplicações comuns de Java, toda classe para
aplicação Android deve ser derivada da classe Activity (Atividade) e possui
como método principal, o método onCreate. Dentro desse método ele invoca o
método onCreate da super classe passando mesmo parâmetro (o icicle), logo
após esse método, vem o método setContentView, responsável por exibir a tela
da minha aplicação , baseado nos layouts xml, por padrão ele chama o arquivo
“main.xml”.

12
Dentro da pasta ProjetoAndroid existe um diretório chamado “res”, onde
ficam armazenados todos os recursos utilizados pela aplicação. Dentro do
diretório “res” existem três diretórios, cada um deles com uma finalidade, que
descreverei agora:
- O diretório drawable armazena todas as imagens que irei utilizar na
minha aplicação. Por padrão , ele tem uma imagem chamada “Icon.png”, que é
usada como ícone da aplicação Android.
- O diretório layout armazena todas os layouts da aplicação Android, que
normalmente são arquivos “.xml”. Para quem conhece a combinação HTML +
JavaScript, o Android é similar, é a combinação de XML + Java, logo todos os
nosso componentes vão ser adicionados usando tags XML. Por padrão, o
arquivo de layout é o main.xml. Veja o seu código abaixo:
<?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"
>
<TextView
android:layout_height="wrap_content"
android:text="Hello World, AppHello"
/>
</LinearLayout>
Observe que após o a primeira linha (prólogo xml), existe uma tag
chamada LinearLayout, responsável por organizar os componentes exibidos na
tela, por padrão os componentes são distribuídos na vertical pelo atributo
android:orientation="vertical".
Dentro desta tag, existe uma chamada TextView, que representa um texto
a ser exibido na tela , por padrão, ele irá exibir “Hello World, AppHello” atrvés do
atributo android:text="Hello World, AppHello".
- O diretório values armazena valores estáticos que podem ser utilizados por
um arquivo “.XML”. Normalmente esses valores estáticos devem ser
armazenados no arquivo “strings.xml”. Veja o código desse arquivo abaixo :
<resources>
<string name="app_name">App Hello World</string>
</resources>
Observem que dentro desse arquivo eu declaro um valor estático chamado
app_name, cujo valor é App Hello World.

13
Dentro da pasta ProjetoAndroid, existe um arquivo chamado
“AndroidManifest.xml” , esse arquivo é o sistema nervoso de uma aplicação em
Android. É nele que ficam as definições referentes à aplicação. Veja o código
dele abaixo:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.android.hello">
<application android:icon="@drawable/icon">
<activity android:name=".AppHello"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Observem algumas tags interessantes. A tag <application> possui o
atributo android:icon, no qual especifico o ícone da aplicação. Como havia
citado anteriormente, todas as imagens ficam no diretório drawable e nesse
diretório existe um arquivo de chamado “icon.png” que será o ícone da minha
aplicação. Logo, para usar esse ícone neste atributo, deve-se passar o valor
“@drawable/icon” .Observem que quando informamos o ícone, ele deve ser
informado sem a extensão (nesse caso, PNG).
Observem agora a tag <activity>, ela define uma atividade (Activity),.
Dentro desta tag, eu possuo o atributo chamado android:label que define o título
da minha aplicação. O título que será exibido e o valor que está armazenado no
valor estático app_name. Isso é obtido pela atribuição
android:label="@string/app_name".
Como havia falado a aplicação Android nada pais é do que a combinação
Java + XML. Agora, como um código Java vai acessar um componente que está
escrito em XML ? Ah, essa é a finalidade do arquivo R.java, ele funciona como
uma “interface” entre o código Java e o código XML, logo, se eu quiser
manipular em tempo de execução um componente via Java, tenho que fazer
interface com esse arquivo. Em breve vamos ver como.
OBS: O arquivo R.java não pode ser modificado manualmente. Ele é
modificado automaticamente de acordo com as mudanças feitas no projeto.
Vamos executar nossa aplicação. Va no Run / Open Run Dialog. Será
aberta uma caixa de diálogo com vários itens. Clique com o botão direito do
mouse no item “Android Application” e selecione a opção New, conforme a
figura abaixo:

14
Feito isso, na propriedade name ao lado digite AppAndroid. Em project
selecione o projeto que criamos em clicando no botão Browse, com o nome de
ProjetoAndroid. E por último, em Activity, selecione a atividade
“com.android.hello.AppHello”. Qualquer dúvida, siga a figura abaixo:
Agora é só clicar em Run e rodar a aplicação. Quando o emulador Android
é executado, abre junto com ele uma caixa de dialogo, conforme a figura abaixo.
Normalmente, eu desmarco a opção “Send usage statistics to Google” e clico
em “Proceed”.
Pra vocês que estão executando pela primeira vez o emulador do Android,
vê que o emulador é uma espécie de IPhone vermelho com umas teclas ao
lado. No início mostra o título Android. Depois, vem aquela bolinha vermelha
que fica batendo de um lado para outro, quando chega essa parte, normalmente
demora em torno de 2 a 10 minutos (dependendo da sua máquina. É
recomendável que você tenha no mínimo 512 MB de memória e um

15
processador bem rápido para um bom desempenho da execução) para a
aplicação ser exibida , mesmo sendo essa aplicação algo muito simples.
Passado o tempo que citei acima, será mostrada a nossa aplicação e
também duas mensagens (ou uma dependendo de alguns casos). Se aparecer,
clique no botão “Force Close” ou com o mouse ou com o botão vermelho central
situado no aparelho. Uma demonstração dessa situação situa-se na figura
abaixo:
Pronto, nossa aplicação está rodando sem problemas. Veja a figura
abaixo:

16
Esse emulador já vem com uma série de recursos como Navegador,
Aplicações de demonstração, Mapas, Lista de contatos e etc.
Se você neste exato momento fechou o emulador após a execução da
aplicação, vou te dizer uma coisa: “Não era para você ter feito isso”. Se você
esperou muito tempo para ver essa aplicação em execução, ao executar
novamente a aplicação, você vai esperar o mesmo. Nessa situação, ao executar
pela primeira vez o emulador, e caso vá executar outros programas, minimize o
emulador ao invés de fechar, pois se você esperou muito tempo para executar
esse programa, com ele minimizado, ao executar um outro programa, o eclipse
vai fazer uso do emulador já aberto em vez de abrir outro, com isso, a aplicação
levará em torno de 7 a 12 segundos em média para ser executada. Nunca
esqueça isso!
Vamos modificar essa aplicação. Minimize o emulador e vamos abrir o
arquivo “main.xml”. Na tag TextView que já havia explicado a vocês, possui um
atributo chamdado android:text, onde nele defino o título que será exibido,
modifique agora essa prorpiedade com o seguinte valor (título), conforme o
código abaixo:
android:text="Fala cara, beleza ???"

17
Feito isso, salve a aplicação e execute novamente a aplicação. O resultado
é mostrado abaixo:
Vamos fazer mais uma outra modificação na nossa aplicação. Abra
novamente o arquivo main.xml, observe que ele possui um TextView certo ?
Vamos colocar mais duas TextViews, a primeira TextView, no atributo
android:text terá o título “Primeira frase”, o segundo TextView terá o título
“Segunda Frase” e assim sucessivamente. Veja como ficará o código do arquivo
main.xml :
<LinearLayout
>
<TextView
android:text="Primeira Frase."
/>
<TextView
android:text="Segunda Frase"
/>
<TextView
android:text="Terceira Frase???"
/>
</LinearLayout>
Feito isso, salve o arquivo e execute novamente a aplicação, o resultado é
mostrado na figura abaixo:

18
E aeh, ta entendo aos poucos como se faz aplicações Android ? Com
ceretza que sim! Agora vamos aprofundar um pouco e fazer aplicações mais
interessantes com o uso dos Widgets (componentes) existentes na plataforma
Android.
Usando Widgets
O que são os widgets ? Os widgets são os componentes que compõem
uma aplicação Android, como o TextView, um Button, um EditText , um
RadioButton e etc.
Desenvolvendo uma aplicação que soma números
Vamos criar agora uma aplicação que faça uso de um desses widgets. Crie
um novo projeto Android com os seguintes dados:
Project Name: ProjetoSoma
Package Name : com.android.appsoma
Activity Name: AppSoma
Application Name: Soma Números
Criado o projeto, vamos no arquivo main.xml desse projeto. Pelo nome do
projeto, podemos ver que essa aplicação é uma aplicação de calculo. Essa
aplicação vai ler dois números inteiros e no final, irá mostrar a soma deles,
simples.
Vamos no arquivo main.xml desse projeto e vamos fazer as seguintes
modificações. Quero que você copie e cole o abaixo e coloque no arquivo
main.xml.

19
<LinearLayout
>
<TextView
android:text="Digite o primeiro número"
/>
<EditText
android:id="@+campo/num1"
/>
<TextView
android:text="Digite o segundo número"
/>
<EditText
android:id="@+campo/num2"
/>
<TextView
android:text="Resultado"
/>
<EditText
android:id="@+campo/res"
/>
<Button
android:id="@+botao/btmostrar"
android:text="Mostrar"
/>
</LinearLayout>
Bom, vamos a explicação do código acima. Observem que possuo uma
TextView com o título “Digite o primeiro número”. Logo abaixo dela , eu possuo
uma widget do tipo EditText, que exibe um campo onde vou digitar o número.
Essa widget possui uma propriedade chamada android:id, que serve para dar
nome ao componente, ou seja, funciona como um identificador daquele
componente.

20
O nome de um widget, deve estar nesse formato:
“@+<nome>/<nome>”
Se observamos, o valor desse atributo é : “@+campo/num1”. É como se
“campo” representasse um grupo e “num1” representasse o nome do
componente. Você irá entender essa notação mais a frente.
Abaixo dessa widget, temos outra do tipo TextView com o título “Digite o
segundo número”. Depois temos um outro widget do tipo EditText, cujo nome é:
“@+campo/num2”.
Abaixo dessa widget, temos um terceiro TextView com o título “Resultado”.
Depois temos um outro widget do tipo EditText, cujo nome é: “@+campo/res”.
Por último, temos uma widget do tipo Button, cuja finalidade é mostrar um
botão para podermos clicá-lo. Ele possui um título com o valor “Mostrar” e seu
nome é: “@+botao/btmostrar”.
Beleza, agora vamos abrir o código do arquivo AppSoma.java, para
acessar via código Java, os componentes que adicionamos via XML. Siga os
passos aqui descritos para você como esse processo é feito. Após a linha
Digite:
import android.widget.*;
import android.view.*;
Antes da linha:
@Override
Digite:
EditText ednum1,ednum2,edres;
Agora vamos a explicação do código acima. Como você pode ver , os
widgets também podem ser usados no nosso código Java. Se no código XML
eu possuir um widget do tipo EditText, para acessar esse componente pelo
Java, é preciso fazer uso da classe EditText. Cada widget no XML possui o seu
respectivo em classe Java, logo, se possui um widget Button, para acessa-lo
devo fazer uso da classe Button e assim vai.
Agora, após a linha:
Digite as seguintes linhas de código:

21
ednum1 = (EditText) findViewById(R.campo.num1);
ednum2 = (EditText) findViewById(R.campo.num2);
edres = (EditText) findViewById(R.campo.res);
Button btMostrar = (Button) findViewById(R.botao.btmostrar);
Agora vou explicar as linhas acima. A linha:
EditText ednum1 = (EditText) findViewById(R.campo.num1);
Faz referência ao primeiro EditText, através do método “findViewById” com
o parâmetro “R.campo.num1”.
Ah, se lembra o nome da primeira EditText que está no código XML? Ela
se chama “@+campo/num1”.
Vamos entender, observe que para fazer referência ao EditText pelo
método “findViewById” eu passei o parâmetro R.campo.num1.
Já na segunda linha, para fazer a referência à segunda EditText, cujo
nome é “@+campo/num2”, pelo método “findViewById”, passei o parâmetro
R.campo.num2.
Como você pode ver, estou fazendo uso da classe R, que funciona como
interface entre o código Java e o arquivo XML.
O procedimento é o mesmo tanto para o terceiro EditText e o Button.
Agora iremos adicionar um evento Click, no nosso Button, pois quando eu
clicar no botão, ele deverá mostrar a soma dos números. Então, logo após a
linha:
Button btMostrar = (Button) findViewById(R.botao.btmostrar);
Digite:
btMostrar.setOnClickListener(new View.OnClickListener(){
public void onClick(View arg0) {
double num1 = Double.parseDouble(ednum1.getText().toString());
double res = num1 + num2;
edres.setText(String.valueOf(res));
}
});
Toda vez que eu clicar no botão, ele irá mostrar o resultado na terceira
EditText referente ao resultado da soma. Ótimo! Vamos executar a nossa

22
aplicação ? Para executar faça os mesmos procedimentos que já mostrei. O
resultado da execução dessa aplicação você vê na figura abaixo:
Irei descrever o código do evento Click. O método “setOnClickLisneter”
serve para definir um evento de Click a um componente. Como parâmetro,
criamos uma instância de OnClickListener e dentro dessa instância existe o
método chamado “onClick”, que será disparado toda vez que o botão for clicado.
A linha:
Cria uma variável chamada num1 e atribui a ela o valor que está contido
em num1. Eu faço uso do método parseDouble da classe Double pois o
conteúdo é uma String. Observem que chamo o método “getText” de ednum1
para retornar o conteúdo. Diferente de muitos métodos de retorno de String,
esse método “getText” não retorna uma String, mais sim um tipo chamado
“Editable”. Por isso, chamei o método toString de getText para que me
retornasse uma string. A descrição da próxima linha e a mesma.
A linha:
edres.setText(String.valueOf(res));
Retorna para a terceira EditText referenciada por edres, a soma dos
valores. Isso é possível chamado o método setText, como o resultado está num
tipo double e setText aceita somente parâmetros do tipo String e Editable, fiz a
conversão desse valor através do método valueOf da classe String.

23
Beleza! Com esse conhecimento obtido até agora, você já tem capacidade
para fazer uma aplicação básica em Android.
Bom , ainda temos muitos mais pela frente.
Desenvolvendo uma aplicação simples de compras
Agora vamos fazer uma outra aplicação Android. Essa aplicação vai fazer
uso da widget CheckBox, que funciona como uma opção onde podemos marcar
e desmarcar. Nossa aplicação consiste em um simples sistemas de compras
onde possuo cinco produtos, Arroz (R$ 2,69) , Leite (R$ 5,00) , Carne (R$
10,00), Feijão (R$ 2,30) e Refrigerante coca-cola (R$ 2,00). Nessa aplicação eu
marco os itens que quero comprar e no final o sistema mostra o valor total das
compras.
Como havia dito, a gente vai fazer uso da CheckBox, a estrutura dela a
similar ao da EditText e TextView, conforme o código abaixo:
<CheckBox
android:id="@+campo/chkleite"
android:text="Leite"
/>
Bom, vamos criar um novo projeto chamado ProjetoCompras. Siga os
dados do projeto abaixo:
Project Name: ProjetoCompras
Package Name : com.android.appcompra
Activity Name: AppCompra
Application Name: Sistema de Compras
Vamos no arquivo main.xml desse projeto e coloque o código abaixo:
<LinearLayout
>
<TextView
android:text="Escolha o seu produto"
/>
<CheckBox
android:id="@+item/chkarroz"

24
android:text="Arroz (R$ 2,69)"
/>
<CheckBox
android:id="@+item/chkleite"
android:text="Leite (R$ 5,00)"
/>
<CheckBox
android:id="@+item/chkcarne"
android:text="Carne (R$ 10,00)"
/>
<CheckBox
android:id="@+item/chkfeijao"
android:text="Feijão (R$ 2,30)"
/>
<CheckBox
android:id="@+item/chkcoca"
android:text="Refrigerante Coca-Cola (R$ 2,00)"
/>
<Button
android:id="@+botao/bttotal"
android:text="Total da compra"
/>
</LinearLayout>
Bom , esse é o nosso layout com cinco CheckBoxs referentes ao itens de
compra e um Button, que quando clicado mostra o valor total de compras.
Agora vamos modificar o arquivo AppCompra.java. O código desse arquivo
será como o código que é exibido abaixo:
package com.android.appcompra;
public class AppCompra extends Activity {
CheckBox chkarroz,chkleite,chkcarne,chkfeijao,chkcoca;
@Override

25
chkarroz = (CheckBox) findViewById(R.item.chkarroz);
chkleite = (CheckBox) findViewById(R.item.chkleite);
chkcarne = (CheckBox) findViewById(R.item.chkcarne);
chkfeijao = (CheckBox) findViewById(R.item.chkfeijao);
chkcoca = (CheckBox) findViewById(R.item.chkcoca);
Button bttotal = (Button) findViewById(R.botao.bttotal);
bttotal.setOnClickListener(new View.OnClickListener(){
double total=0;
if(chkarroz.isChecked())
total += 2.69;
if(chkleite.isChecked())
total += 5.00;
if(chkcarne.isChecked())
total += 10.00;
if(chkfeijao.isChecked())
total += 2.30;
if(chkcoca.isChecked())
total += 2.00;
showAlert("Valor total da compra", 0,String.valueOf(total),
"OK", false);
}
});
}
}
Descrevendo o código do evento click: Dentro do evento eu crio uma
variável chamada “total” que armazena o valor total da compra. Observe que eu
tenho cinco estruturas if’s onde cada uma verifica se um determinado item foi
marcado, se foi, incrementa o valor do item com o valor da variável “total”.
Observe que eu faço uso do método showAlert cuja finalidade é mostrar uma
mensagem na tela. A mensagem a ser mostrada é o valor total da compra.
Os parâmetros do showAlert são:
showAlert(CharSequence title, int iconId, CharSequence message,
CharSequence buttonText, boolean cancelable)
title : Corresponde ao título da mensagem
iconId: Corresponde ao ícone a ser exibido, quando o valor é zero, significa
que não será usado nenhum ícone.
message: Corresponde a mensagem
cancelable: Define se ela será cancelável.
Vamos roda nossa aplicação ? O resultado você confere na figura abaixo:

26
Desenvolvendo uma aplicação de cálculo de salário
Bom, agora vamos fazer uma outra aplicação. Essa aplicação que vamos
desenvolver agora consiste em um sistema que vai ler o salário de um
funcionário e vai permitir que você escolha o seu percentual de aumento que
pode ser de 40% , 45% e 50% e no final o sistema irá mostrar o salário
reajustado com o novo aumento. Bom, vamos lá! Crie um novo projeto Android
com os seguintes dados:
Project Name: ProjetoSalario
Package Name : com.android.appsal
Activity Name: AppSalario
Application Name: Cálculo do salário
Nessa aplicação vamos fazer uso da widget RadioButton, que funciona
como um item de opção, podendo ser selecionado entre vários outros. Veja a
sua sintaxe abaixo:
<RadioButton
android:id="@+item/chkcoca"
android:text="Refrigerante Coca-Cola (R$ 2,00)"
/>
Porém, para que a múltipla escolha funcione, é necessário que os
RadioButtons fiquem dentro de uma RadioGroup, que funciona como agrupador
de RadioButons. Veja um exemplo abaixo:

27
<LinearLayout
>
<TextView
android:text="Escolha uma opção:"
/>
<RadioGroup xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+opcao/opcoes" >
<RadioButton
android:text="Opcão 1"
/>
<RadioButton
android:text="Opcão 2"
/>
</RadioGroup>
</LinearLayout>
Executando a aplicação, será exibido a seguinte tela:

28
Bom, agora vamos fazer a nossa aplicação. No arquivo main.xml, coloque
o código abaixo:
<LinearLayout
>
<TextView
android:text="Digite seu salário (R$)"
/>
<EditText
android:id="@+campo/edsalario"
/>
<TextView
android:text="Qual será o percentual ?"
/>
<RadioGroup xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+opcao/rbopcoes"
>
<RadioButton
android:id="@+opcao/rb40"
android:text="40%"
/>
<RadioButton
android:text="45%"
/>
<RadioButton
android:text="50%"
/>
</RadioGroup>
<Button
android:id="@+botao/btmostrar"
android:text="Mostrar novo salário"
/>
</LinearLayout>

29
No arquivo AppSalario.java, coloque o código abaixo:
package com.android.appsal;
public class AppSalario extends Activity {
@Override
Button btmostrar = (Button) findViewById(R.botao.btmostrar);
btmostrar.setOnClickListener(new View.OnClickListener(){
double salario, novo_sal;
EditText edsalario = (EditText)
findViewById(R.campo.edsalario);
salario =
Double.parseDouble(edsalario.getText().toString());
RadioGroup rg = (RadioGroup)
findViewById(R.opcao.rbopcoes);
int op = rg.getCheckedRadioButtonId();
if(op==R.opcao.rb40)
novo_sal = salario + (salario * 0.4);
else
else
showAlert("Novo salário", 0,"Seu novo salário é : R$" +
String.valueOf(novo_sal), "OK", false);
}
});
}
}

30
Vamos a explicação de alguns códigos interessantes. Dentro do evento
click, eu realizo o cálculo do novo salário do funcionário. Os primeiros códigos
do evento são similares a de programas anteriores que já foram devidamente
explicados. A linha:
int op = rg.getCheckedRadioButtonId();
Cria uma variável op e retorna para ela o Id da opção selecionada, ou seja,
qual RadioButton foi selecionada.
Agora na condição:
Verifico se a opção de 40% foi selecionada, se for, realize o cálculo do
salário com o reajuste de 40%. A mesma explicação e válida para o cálculo dos
outros reajustes. Agora vamos executar a nossa aplicação. O resultado você vê
na figura abaixo:
Até aqui você já pode fazer ótimas aplicações em Android.

31
Desenvolvendo uma aplicação de lista telefônica
Agora vamos fazer uma nova aplicação em Android. Essa aplicação
consiste em uma lista telefônica já pronta com contatos. Quando selecionamos
um contato, ele mostra na tela uma mensagem com o nome selecionado. A
nossa aplicação vai fazer uso do widget chamado ListView, que exiba uma lista
contendo valores que podem ser selecionados. Veja a estrutura de uma
ListView abaixo:
<ListView
android:id="@+id/lista"
/>
Bom, vamos criar um novo projeto chamado ProjetoLista. Siga os dados
abaixo:
Project Name: ProjetoLista
Package Name : com.android.applist
Activity Name: AppList
Application Name: Lista de contatos
No arquivo main.xml, coloque o seguinte código:
<LinearLayout
>
<TextView
android:text="Escolha um contato"
/>
<ListView
android:id="@+id/lista"
/>
</LinearLayout>

32
package com.android.applist;
import android.widget.AdapterView.OnItemClickListener;
public class AppList extends Activity {
public ListView lista;
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,
contatos);
lista = (ListView) findViewById(R.id.lista);
lista.setAdapter(adapter);
lista.setOnItemClickListener(new OnItemClickListener(){
public void onItemClick(AdapterView arg0, View arg1, int
arg2,long arg3) {
showAlert("Contato selecionado",0,lista.getSelectedItem().toString(),
"OK",false);
}
});
}
static final String[] contatos = new String[] {
"Alline","Lucas","Rafael","Gabriela","Silvana"
};
}
Vamos analisar alguns códigos acima. A linha
static final String[] contatos = new String[] {
"Alline","Lucas","Rafael","Gabriela","Silvana"
};
Cria uma constante chamada contatos, onde nela coloco alguns nomes.
Essa constante vai ser utilizada pela nossa lista. Para que eu posssa carregar
dos dados em uma ListView, preciso fazer uso da classe ArrayAdapter, como
mostra a instrução abaixo:

33
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,
contatos);
A instrução mostrada acima cria uma instância da classe ArrayAdapter
chamada “adapter” onde carrego nela o vetor de Strings da constante contatos.
A instrução:
lista.setAdapter(adapter);
Carrega os valores para a ListView, que está contido o objeto adapter.
Como havia falado, quando clicássemos em um item, o sistema mostraria
uma mensagem do item selecionado. Isso é conseguido fazendo uso da
interface OnItemClickListener, como mostra a instrução abaixo:
lista.setOnItemClickListener(new OnItemClickListener(){
public void onItemClick(AdapterView arg0, View arg1, int
arg2,long arg3) {
showAlert("Contato selecionado",0,lista.getSelectedItem().toString(),
"OK",false);
}
});
Toda vez que clicarmos em um item da lista, o método onItemClick será
disparado e será executado o comando abaixo:
showAlert("Contato
selecionado",0,lista.getSelectedItem().toString(),
"OK",false);
Que exibe o item selecionado. A obtenção do item clicado e feita
chamando o método “getSelectedItem()” . Porém, como ele retorna um tipo
“Object”, preciso converter para String o item clicado, através do método
toString.
Vamos executar a aplicação. O resultado você vê na figura abaixo:

34
Desenvolvendo uma aplicação que visualiza imagens
Agora vamos desenvolver mais uma aplicação. Essa aplicação permite
que você visualize images, tudo através do widget ImageView. A sua estrutura
você confere abaixo:
<ImageView id="@+id/imagem"
android:src="@drawable/foto1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
Agora crie um novo projeto conforme os dados abaixo:
Project Name: ProjetoImagem
Package Name : com.android.appimage
Activity Name: AppImage
Application Name: Visualizando Imagens
Antes de codificar, quero que você coloque duas imagens JPEG (com a
extensão .jpg) dentro da pasta “res/drawable”. Um arquivo deve se chamar
foto1.jpg e o outro foto2.jpg. Para importar um arquivo, clique com o botão
direito do mouse e selecione “Import”, depois selecione File System. Clique no
botão browser para selecionar o diretório onde se encontram as imagens,
depois de selecionado, marque os dois arquivos (imagens) para que eles sejam
importados para a pasta “res/drawable” . Veja a figura abaixo:

35
Depois disso, é só clicar em “Finish”.
Agora no arquivo main.xml, coloque o código abaixo:
<LinearLayout
>
<LinearLayout
android:orientation="horizontal"
>
<ImageView android:id="@+id/imagem"
android:src="@drawable/foto1"
<TextView
android:text="Imagem: Foto 1"
android:id="@+label/label"
/>
</LinearLayout>
<Button
android:text="Exibir Foto 1"
android:id="@+botao/bt1"

36
/>
<Button
android:text="Exibir Foto 2"
android:id="@+botao/bt2"
/>
</LinearLayout>
Vamos analisar o atributo android:src da widget ImageView. Esse atributo
permite especificar a imagem a ser aberta, no caso, será exibida a imagem
“foto1.jpg” através do seguinto valor: @drawable/foto1. “@drawable “
corresponde a pasta onde se encontra a imagem e “foto1” é o nome da imagem,
que deve ser informada sem a sua extensão. Logo se eu ver de inicio a segunda
imagem, usaria o seguinte valor: @drawable/foto2.
Agora no arquivo AppImage.java coloque o código abaixo:
package com.android.appimage;
public class AppImage extends Activity {
ImageView imagem;
TextView txt;
@Override
Button btfoto1 = (Button) findViewById(R.botao.bt1);
Button btfoto2 = (Button) findViewById(R.botao.bt2);
imagem = (ImageView) findViewById(R.id.imagem);
txt = (TextView) findViewById(R.label.label);
btfoto1.setOnClickListener(new View.OnClickListener(){
imagem.setImageResource(R.drawable.foto1);
txt.setText("Imagem: Foto 1");
}
});
btfoto2.setOnClickListener(new View.OnClickListener(){
}
});

37
}
}
Agora vamos analisar alguns trechos de códigos. Vamos no evento Click
referente a abertura da primeira imagem. O código:
É responsável por abrir a imagem “foto1.jpg” e exibi-la no componente.
Observe que foi passado o parâmetro “R.drawable.foto1” onde “drawable”
corresponde a pasta e “foto1” corresponde ao arquivo “foto1.jpg”. Logo após
vem o código:
Cuja finalidade é mudar o título da TextView , de acordo com a String
passada como parâmetro.
O comentário acima é o mesmo para o segundo botão referente a abertura
da segunda imagem.
Vamos executar a nossa aplicação. O resultado você vê nas imagens
abaixo:
(Foto 1)

38
(Foto 2)
Mudando de layouts
Até agora, fizemos aplicações em Android que utilizassem um único layout.
Agora vamos fazer aplicações Android que utilizem mais de um layout.
Vamos criar um novo projeto de demonstração chamado ProjetoLayout,
conforme os dados abaixo:
Project Name: ProjetoLayout
Package Name : com.android.applayout
Activity Name: AppLayout
Application Name: Mudando de layouts
No arquivo main.xml, coloque o código que é exibido abaixo:
<LinearLayout

39
>
<TextView
android:text="Você está na tela principal"
/>
<Button
android:id="@+botao/botao1"
android:text="Ir para tela 2"
/>
</LinearLayout>
Ótimo! Agora dentro da pasta “res/layout” , crie um novo arquivo em
branco chamado tela2.xml e coloque o código abaixo:
<LinearLayout
>
<TextView
android:text="Você está na tela 2"
/>
<Button
android:id="@+botao/botao2"
android:text="Ir para tela principal"
/>
</LinearLayout>
Depois disso, modifique o arquivo AppLayout.java, conforme o código
abaixo:
package com.android.applayout;
public class AppLayout extends Activity {
public void CarregaTelaPrincipal() {
Button bt1 = (Button) findViewById(R.botao.botao1);
bt1.setOnClickListener(new View.OnClickListener(){
CarregaTela2();

40
}
});
}
public void CarregaTela2() {
setContentView(R.layout.tela2);
Button bt2 = (Button) findViewById(R.botao.botao2);
bt2.setOnClickListener(new View.OnClickListener(){
CarregaTelaPrincipal();
}
});
}
@Override
}
}
Observem que nesta classe eu criei dois métodos : CarregaTelaPrincipal e
CarregaTela2. Toda aplicação que utilize mais de um layout, o carregamento
dos layouts e de seus respectivos widgets devem estar separados em funções
desenvolvidas para esse propósito. Logo, o método CarregaTelaPrincipal
carrega o layout principal e seus respectivos componentes, o mesmo válido
para o método CarregaTela2, que carrega o layout da tela 2 e seus respectivos
componentes. Feito isso, execute a aplicação. Veja o resultado abaixo:

42
Desenvolvendo uma aplicação de cadastro
Agora para encerrar, vamos desenvolver uma aplicação de cadastro. Essa
aplicação consiste em um cadastro de pessoas onde posso cadastrar dados
como: Nome, Profissão e Idade. Essa aplicação vai fazer uso de três layouts:
O layout principal: Esse layout dará acesso ao layout de cadastro e o
layout de visualização de dados.
O layout de cadastro: Nesse layout é onde será efetuado o cadastro dos
dados da pessoa.
O layout de visualização de dados: Nesse layout é onde serão visualizados
os dados cadastrados. Se nenhum dado foi cadastrado, será exibida uma
mensagem informando essa situação.
Nessa aplicação, para armazenar os dados, eu faço um de uma estrutura
de dados FIFO ou Fila. Nessa estrutura, os dados são armazenados em
seqüência, e acessados em seqüência , ou seja, o primeiro dado a entrar será o
primeiro a ser exibido.
Bom, vamos construir a nossa aplicação. Crie um novo projeto com os
dados abaixo:
Project Name: ProjetoAppCadastro
Package Name : com.android.appcadastro
Activity Name: AppCadastro
Application Name: Aplicação de Cadastros
Dentro da pasta “res/drawable”, coloque a figura que acompanha este
material, ela se chama “profile.png”.
Agora no arquivo main.xml coloque o código abaixo:
<LinearLayout
>
<ImageView android:id="@+id/imagebutton"
android:src="@drawable/profile"
<TextView

43
android:text="Bem vindo a aplicação de Cadastro de Pessoas. Este é
um pequeno programa de demonstração de cadastro. Selecione uma das
opções abaixo:"
/>
<Button android:id="@+id/btcadpess"
android:text="Cadastrar Pessoas"
<Button android:id="@+id/btlistpess"
android:text="Listar pessoas cadastradas"
</LinearLayout>
Dentro da pasta “res/layout” , crie um arquivo chamado cadastro.xml com o
seguinte código:
<LinearLayout
>
<TextView
android:text="Módulo de cadastro. Cadastre seus dados abaixo:"
/>
<TextView
android:text="Nome:"
/>
<EditText android:id ="@+campo/nome"
android:text=""
/>
<TextView
android:text="Profissão:"
/>

44
<EditText android:id ="@+campo/profissao"
android:text=""
/>
<TextView
android:text="Idade:"
/>
<EditText android:id ="@+campo/idade"
android:text=""
/>
<LinearLayout
android:layout_height="wrap_content">
<Button
android:id="@+cadastro/btcadastro"
android:text="Cadastrar"
<Button
android:id="@+cadastro/btvoltar"
android:text="Voltar"
</LinearLayout>
</LinearLayout>
Agora dentro da pasta “res/layout” , crie um arquivo chamado
listacadastros.xml com o seguinte código:
<LinearLayout
>
<TextView
android:textSize="20sp"
android:textColor="#FFFFFF"
android:text="Lista das pessoas cadastradas."

45
/>
<LinearLayout
<TextView
android:textColor="#FFFF00"
android:text="Nome:"
/>
<TextView android:id ="@+field/nome"
android:text=""
/>
</LinearLayout>
<LinearLayout
<TextView
android:text="Profissão:"
/>
<TextView android:id ="@+field/profissao"
android:text=""
/>
</LinearLayout>
<LinearLayout
<TextView
android:text="Idade:"
/>
<TextView android:id ="@+field/idade"
android:text=""
/>
</LinearLayout>
<LinearLayout

46
<Button
android:id="@+lista/btvoltar"
android:text="Voltar"
<Button
android:id="@+lista/btanterior"
android:text="Anterior"
<Button
android:id="@+lista/btproximo"
android:text="Proximo"
</LinearLayout>
</LinearLayout>
Agora no arquivo AppCadastro.java, coloque o seguinte código:
package com.android.appcadastro;
public class AppCadastro extends Activity {
Registro pri,reg,ult,aux;
EditText ednome,edprof,edidade;
int numreg,pos;
void CarregaTelaPrincipal () {
Button btcadpess = (Button) findViewById(R.id.btcadpess);
Button btlistapess = (Button) findViewById(R.id.btlistpess);
btcadpess.setOnClickListener(new View.OnClickListener(){
public void onClick(View arg0){
CarregaTelaCadastro();

47
}});
btlistapess.setOnClickListener(new View.OnClickListener(){
CarregaListaPessoas();
}});
}
void CarregaTelaCadastro() {
setContentView(R.layout.cadastro);
Button btcadastrar = (Button)
findViewById(R.cadastro.btcadastro);
Button btvoltar = (Button) findViewById(R.cadastro.btvoltar);
btcadastrar.setOnClickListener(new View.OnClickListener(){
try {
reg = new Registro();
ednome = (EditText)findViewById(R.campo.nome);
edprof = (EditText)findViewById(R.campo.profissao);
edidade = (EditText)findViewById(R.campo.idade);
reg.nome = ednome.getText().toString();
reg.profissao = edprof.getText().toString();
reg.idade = edidade.getText().toString();
if(pri==null)
pri=reg;
reg.Ant = ult;
if(ult==null)
ult=reg;
else {
ult.Prox = reg;
ult=reg;
}
numreg++;
showAlert("Aviso", 0,"Cadastro efetuado com sucesso", "OK",
false);
}
catch(Exception e) {
showAlert("Erro", 0,"Erro ao cadastrar", "OK", false);
}}
});
btvoltar.setOnClickListener(new View.OnClickListener(){

48
}
});
}
void CarregaListaPessoas() {
if(numreg==0) {
showAlert("Aviso", 0,"Nenhum registro cadastrado", "OK",
false);
return;
}
setContentView(R.layout.listacadastrados);
pos=1;
aux=pri;
TextView fnome = (TextView)findViewById(R.field.nome);
TextView fidade = (TextView)findViewById(R.field.idade);
TextView fprof = (TextView)findViewById(R.field.profissao);
Button btanterior = (Button) findViewById(R.lista.btanterior);
Button btproximo = (Button) findViewById(R.lista.btproximo);
Button btvoltar = (Button) findViewById(R.lista.btvoltar);
fnome.setText(aux.nome);
fidade.setText(aux.idade);
fprof.setText(aux.profissao);
btvoltar.setOnClickListener(new View.OnClickListener(){
}
});
btanterior.setOnClickListener(new View.OnClickListener(){
if(pos==1)
return;
pos--;
aux=aux.Ant;
TextView fidade =
(TextView)findViewById(R.field.idade);
TextView fprof =
(TextView)findViewById(R.field.profissao);
}
});
btproximo.setOnClickListener(new View.OnClickListener(){
if(pos==numreg)
return;
pos++;

49
aux=aux.Prox;
TextView fidade =
(TextView)findViewById(R.field.idade);
TextView fprof =
(TextView)findViewById(R.field.profissao);
}
});
}
numreg=0;
pri=ult=null;
}}
Agora no mesmo local onde se encontra o arquivo AppCadastro.java (no
pacote com.android.appcadastro), você vai criar uma classe Chamada Registro.
Depois de criar a classe, coloque o código que é exibido abaixo:
package com.android.appcadastro;
public class Registro {
String nome;
String profissao;
String idade;
Registro Prox;
Registro Ant;
}
Agora vamos analisar aos poucos os códigos dessa aplicação. Observe
que nessa aplicação ou possuo três métodos: um método chamado
CarregaTelaPrincipal , responsável por carregar o layout da tela principal. O
método CarregaTelaCadastro é responsável por carregar a tela de cadastro.
Vamos analisar alguns códigos do método CarregaTelaCadastro. Se você
observar nessa aplicação, que eu declarei quatro variáveis chamadas pri,ult e
reg e aux do tipo “Registro”. A variável pri, serve para apontar para o endereço
do primeiro registro. A variável ult aponta para o endereço do último registro. A
variável reg armazena os dados do registro corrente e a variável aux funciona
como uma variável auxiliar.

50
É com a utilização essas variáveis que faço o cadastro dos dados das
pessoas. Vamos para o evento click do botão btcadastrar situado dentro do
método CarregaTelaCadastro e analisar algumas linhas de código. A linha:
reg = new Registro();
Cria uma nova instância da classe da classe “Registro” e coloca em .”reg”.
As linhas:
reg.nome = ednome.getText().toString();
reg.profissao = edprof.getText().toString();
reg.idade = edidade.getText().toString();
Gravam os dados dos campos no objeto “reg”. Já as linhas abaixo:
if(pri==null)
pri=reg;
reg.Ant = ult;
if(ult==null)
ult=reg;
else {
ult.Prox = reg;
ult=reg;
}
Fazem todo o processo de armazenamento dos dados.
Agora vamos para o método CarregaListaPessoas. Quando esse método é
chamado, é feita uma verificação se há dados cadastrados. Se não houver
dados cadastrados, será exibida uma mensagem indicando essa situação e
você será retornado a tela principal. Vou comentar algumas linhas. A linha:
aux=pri;
Retorna para a variável “aux” o endereço do primeiro registro, que está
armazenado em “pri” . Já as linhas:
Joga as informações obtidas (nome, idade e profissão) para os campos
(TextViews), para que eles possam ser exibidas.
Vamos agora para o evento click do botão btanterior. Esse botão mostra os
registros anteriores. Antes de voltar um registro, verifico se eu me encontro no
primeiro registro pela condição:
if(pos==1)
Se a condição for verdadeira, saio do evento, senão, continuo executando
as instruções. A linha:
aux=aux.Ant;
Retorna para aux o endereço do registro anterior. Depois disso são
executados instruções para que os dados possam ser exibidos.

51
Já no evento click do botão btproximo, antes de passar para o próximo
registro, verifico se já está no último registro pela instrução:
if(pos==numreg)
Se a condição for verdadeira, saio do evento, senão, continuo executando
as instruções. A linha:
aux=aux.Prox;
Retorna para aux o endereço do próximo registro. Depois disso são
executados instruções para que os dados possam ser exibidos.
Agora vamos no arquivo de layout listacadastrados.xml, quero comentar
algumas propriedades interessantes. Se você observar, algumas TextViews
possuem um atributo chamado android.textColor e android:textSize, esses
atributos definem a cor e o tamanho do texto respectivamente.
Bom, vamos executar a nossa aplicação ? O resultado você confere nas
figuras abaixo:
(Tela Principal)

52
(Tela de cadastro)
(Tela de visualização dos dados cadastrados)

53
Lista de atributos
Agora irei mostrar alguns atributos comumente usados em uma aplicação
Android de alguns componentes, principalmente os componentes que nós
usamos nas aplicações acima.
Aqui vou descrever os atributos usados nos componentes (no formato
XML) e quais são os métodos referentes aos atributos descritos, ou seja, vamos
supor que queira modificar o valor de um determinado atributo em tempo de
execução, então cada atributo possui um método, para que seu valor possa ser
modificado em tempo de execução.
android:text: Essa propriedade serve para mostrar o texto que é passado
como parâmetro.
Método relacionado: setText(CharSequence)
Exemplos:
XML
android:Text=”Hello World”
Java
texto.setText(“Hello World”)
Widgets que possuem essa propriedade: TextView, EditText,
RadioButton, CheckBox, Button
android:textColor: Essa propriedade serve para definir uma cor para o
texo exibido.
Método relacionado: setTextColor(int color)
Exemplos:
XML
android:textColor=”#FFFF00”
Java
texto.setTextColor(Color.YELLOW);
OBS:A classe Color se encontra no pacote “android.graphics”.

54
android:background: Essa propriedade serve para definir uma cor de
fundo.
Métodos relacionados: setBackgroundColor(int color);
Exemplos:
XML
android:background=”#FF0000”
Java
texto. setBackgroundColor (Color.RED);
android:phoneNumber Essa propriedade serve para definir uma entrada
de valores no formato de número telefônico. O valor padrão desse atributo é
“falso”.
Métodos relacionados: setKeyListener(KeyListener Arg);
Exemplos:
XML
android: phoneNumber =”true”
Java
Em Java você deveria definir um conjunto de instruções para capturar as
entradas de dados de modo que as entradas atendam a essa finalidade.
Widgets que possuem essa propriedade: TextView, EditText
android:numeric Com essa propriedade habilitada, o widget com essa
propriedade só irá aceitar números (inteiros e decimais). O valor padrão desse
atributo é “falso”.
Exemplos:
XML

55
android:numeric =”true”
Java
Widgets que possuem essa propriedade: TextView, EdiText
android:textStyle: Essa propriedade serve para definir um estilo a fonte
(negrito e/ou itálico).
Métodos relacionados: setTypeface(Typeface);
Exemplos:
XML
android:textStyle =”bold”
android:textStyle =”italic”
android:textStyle =”bold_italic”
Java
texto. setTypeface (Typeface.DEFAULT_BOLD);
texto. setTypeface (Typeface.DEFAULT_ITALIC);
texto. setTypeface (Typeface.DEFAULT_BOLD_ITALIC);
OBS:A classe Typeface se encontra no pacote “android.graphics”.
Widgets que possuem essa propriedade: TextView,
EdiText,RadioButton,CheckBox,Button.
android:textSize: Essa propriedade serve para definir o tamanho da fonte.
O tamanho da fonte pode ser especificado em várias notações : px
(pixels),sp(scaled-pixels) , mm(milímetros), in (inches) e etc.
Métodos relacionados: setTextSize(float tamanho) ou setTextSize(int
unidade, int tamanho);
Exemplos:
XML
android:textSize =”10px”
android:textStyle =”20sp”

56
Java
texto. setTextSize (TypedValue.COMPLEX_UNIT_PX,10); //Unidade em
pixels
texto. setTypeface (TypedValue.COMPLEX_UNIT_SP,10); //Unidade
em scaled-pixels
texto. setTypeface (20); //Unidade em scaled-pixels
OBS: A classe Typeface se encontra no pacote “android.util”.
android:typeface: Essa propriedade serve para definir uma fonte ao texto
(Arial , Times NewRoman, Courier New e etc).
Métodos relacionados: setTypeface(Typeface);
Exemplos:
XML
android:typeface =”Arial”
android:typeface =”Times New Roman”
Java
texto. setTypeface (Typeface.create(“Arial”,0));
texto. setTypeface (Typeface.create(“times New Roman”,0));
android:capitalize: Essa propriedade serve para definir o tipo
capitalização das palavras. Por padrão, o valor e “none”(nenhum). Os valores
usados nessa propriedade são:
none Nenhuma capitalização ocorrerá
sentences Capitaliza a primeira letra da primeira
palavra de qualquer sentença
words Capitaliza a primeira letra de qualquer
sentença
characters Capitaliza todos os caracteres

57
Exemplos:
XML
android:capitalize =”sentences”
Java
Em Java você deveria definir um conjunto de instruções para
capturar as entradas de dados de modo que as entradas atendam a essa
finalidade.
android:password Com essa propriedade você habilita a digitação de
senhas.
Métodos relacionados:
setKeyTransformationMethod(TransformationMethod arg);
Exemplos:
XML
android:password =”true”
Java
Widgets que possuem essa propriedade: TextView, EdiText

58
Conclusão
Nesta apostila aprendemos a programar o “básico” do Android. Vimos um
pouco sobre a plataforma Android, como ela surgiu e tudo mais. Aprendemos a
instalar o eclipse e os plugins necessários para o funcionamento do Android,
incluindo o SDK. Aprendemos a construir uma aplicação Android básica e
depois conhecemos os componentes (widgets) que constituem uma aplicação
Android para a construção de aplicações mais interessantes. Vimos também
como trocar de layouts em uma aplicação Android tendo como exemplo prático,
uma aplicação de cadastro e por último, conhecemos algumas propriedades
comumente usadas em alguns widgets que constituem uma aplicação Android.
Espero que esse material lhe tenha sido útil.
Abraços

Apostila android

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Apostila android

Apostila android