Baixado 801 vezes
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_l
ist_item_1, paises);
ednomepais = (AutoCompleteTextView)
findViewById(R.id.ednomepais);
ednomepais.setAdapter(adapter);
}
private final String[] paises = new String[]
{ "Afeganistão", "África do Sul",
"Albânia","Alemanha",
"Andorra","Angola",
"Anguila","Antárctida" "Azerbaijão",
"Baamas", "Bangladeche","Brasil",
"Canadá", "Catar",
"Cazaquistão", "Chade",
"Chile","China","Chipre",
"Clipperton Island",
"Dhekelia", "Dinamarca",
"Domínica", "Egipto",
"Equador", "Eritreia",
"Eslováquia", "Eslovénia",
"Espanha", "Estados Unidos",
"Grécia", "Gronelândia",
"Ilhas Salomão", "Ilhas Turcas e Caicos",
"Indonésia", "Irão",
"Iraque"};
}
Vamos analisar alguns trechos de código abaixo. A linha :
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_l
ist_item_1, paises);
72](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-72-320.jpg)
![Luciano Alves da Silva
Cria um objeto do tipo Array através da classe ArrayAdapter e
carregamos em seus parâmetros um vetor (array de Strings) pré-
definido com o nome dos países chamado paises.
A linha abaixo:
ednomepais.setAdapter(adapter);
Carrega o vetor no componente através do método “setAdapter”.
E na linha seguinte:
private final String[] paises = new String[]
{....}
Havíamos definido o array de Strings paises onde nele estão
definidos os países onde alguns deles serão exibidos durante o
processo de sugestão do componente.
Bom, agora vamos rodar a nossa aplicação. Veja como ficou na
figura seguinte:
Demonstração do uso AutoCompleteTextView
73](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-73-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Tela de layout da aplicação
Agora no arquivo “AppSalario.java”, coloque o seguinte código:
package br.com.appsalariospinner;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
import android.app.*;
public class AppSalario extends Activity {
private static final String[] percentual =
{"De 40%","De 45%","De 50%"};
ArrayAdapter<String> aPercentual;
Spinner spnsal;
92](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-92-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
case 1: novo_sal = salario + (salario *
0.45); break;
case 2: novo_sal = salario + (salario *
0.5); break; }
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppSalario.this);
dialogo.setTitle("Novo salário");
dialogo.setMessage("Seu novo salário é : R$"
+ String.valueOf(novo_sal));
dialogo.setNeutralButton("OK", null);
dialogo.show();
}
});
}
}
Observando o código do programa acima, podemos ver que ele
é similar o da primeira versão do aplicativo, porém, quero
comentar alguns códigos interessantes desta aplicação. Observe
que foi necessário declarar um “array” de “String” chamado
percentual, conforme mostra o código abaixo:
private static final String[] percentual =
{"De 40%","De 45%","De 50%"};
Este “array” possui três elementos, correspondentes ao
percentual do aumento do salário. Também foi necessário
94](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-94-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
dialogo.show();
}
});
}
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 possa carregar dos dados em uma ListView, preciso fazer
uso da classe ArrayAdapter, como mostra a instrução abaixo:
100](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-100-320.jpg)
![Luciano Alves da Silva
package br.com.appgallery;
import android.content.Context;
import android.view.*;
import android.widget.*;
public class ImageAdapter extends BaseAdapter {
private Context myContext;
/* Neste array são colocadas as imagens a serem
exidas
no componente Gallery .*/
private int[] myImageIds = {
R.drawable.imagem1,
R.drawable.imagem2,
R.drawable.imagem3,
};
public ImageAdapter(Context c) { this.myContext
= c; }
public int getCount() { return
this.myImageIds.length; }
public Object getItem(int position) { return
position; }
public long getItemId(int position) { return
position; }
public View getView(int position, View
convertView, ViewGroup parent) {
ImageView i = new
ImageView(this.myContext);
117](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-117-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
i.setImageResource(this.myImageIds[position]);
i.setScaleType(ImageView.ScaleType.FIT_XY);
i.setLayoutParams(new
Gallery.LayoutParams(150, 150));
return i;
}
public float getScale(boolean focused, int
offset) {
return Math.max(0, 1.0f /
(float)Math.pow(2, Math.abs(offset)));
}
}
Observem que dentro desta classe existe um array chamado
myImageIds, onde eu armazeno as imagens a serem visualizadas
no componente.
Agora , carregue o arquivo “main.xml” e modifique o conteúdo
da TextView com a frase: “Visualização de Imagens”, e em
seguida insira na tela o componente Gallery (que se encontra na
guia “Images & Media”). Modifique as propriedades do
componente Gallery conforme é mostrado abaixo:
Propriedade Valor
Id @+id/gallery
Layout_width fill_parent
118](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-118-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Agora no arquivo “AppGallery.java” vamos substituir o código
recente pelo novo código abaixo:
package br.com.appgallery;
import android.app.Activity;
import android.os.Bundle;
import android.view.*;
import android.widget.*;
public class AppGallery extends Activity {
Gallery g;
ImageView imagem;
private int[] myImageIds = {
R.drawable.imagem1,
R.drawable.imagem2,
R.drawable.imagem3,
};
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
g = (Gallery) findViewById(R.id.gallery);
g.setAdapter(new ImageAdapter(this));
imagem = (ImageView)
findViewById(R.id.imagem);
122](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-122-320.jpg)
![Luciano Alves da Silva
g.setOnItemClickListener(new
AdapterView.OnItemClickListener(){
public void
onItemClick(AdapterView<?> arg0, View arg1,
int arg2, long arg3) {
imagem.setImageResource(myImageIds[arg2]);
Toast.makeText(getBaseContext(),
"Figura " + (arg2 +
1) + " selecionada",
Toast.LENGTH_SHORT).show();
}
});
}
}
Quais foram as modificações desse programa? Nesse programa
foi adicionado um componente chamado ImageView, que faz
referência ao componente ImageView no arquivo XML, como
mostra o código abaixo:
ImageView imagem;
Também na aplicação adicionamos o “array” que contém todas
as referências das imagens contidas no projeto, conforme mostra
o código seguinte:
123](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-123-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
private int[] myImageIds = {
R.drawable.imagem1,
R.drawable.imagem2,
R.drawable.imagem3,
};
Dentro do método onCreate foi feito uma referência ao
componente ImageView contido no XML e definimos o evento
OnItemClickListener , do componente Gallery. Vamos
analisar seu código abaixo:
imagem.setImageResource(myImageIds[arg2]);
Toast.makeText(getBaseContext(),
"Figura " + (arg2 + 1) + " selecionada",
Toast.LENGTH_SHORT).show();
A primeira instrução carrega a imagem selecionada no
componente Gallery no ImageView, através do método
setImageResource, cujo parâmetro é o valor do índice do vetor.
A segunda instrução fazendo uso do método makeText, da
classe Toast, cuja finalidade é mostrar uma pequena mensagem
na tela em um tempo curto.
No primeiro parâmetro desse método sempre passamos o valor
getBaseContext(). No segundo parâmetro passamos o conteúdo
a ser exibido na tela. No terceiro parâmetro, definimos o tempo
de exibição da mensagem na tela.
Execute a aplicação. O resultado você vê na figura abaixo:
124](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-124-320.jpg)
![Luciano Alves da Silva
AlertDialog com o botão OK e com ícone
É possível também na classe AlertDialog.Builder trabalharmos
com lista de itens (como no ListView) e também com opções
(como no RadioButton).
Vou demonstrar aqui como trabalhar com lista de itens. Veja o
código abaixo:
AlertDialog.Builder d = new
AlertDialog.Builder(AppAlert.this);
final String[] opcoes
={"Azul","Amarelo","Vermelho"};
d.setTitle("Escolha uma opção");
d.setItems(opcoes, new
DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int
item) {
switch (item) {
233](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-233-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
case 0: //EXECUTA OPERAÇÃO SE SELECIONOU
A OPÇÃO AZUL
case 1: //EXECUTA OPERAÇÃO SE SELECIONOU
A OPÇÃO AMARELO
case 2: //EXECUTA OPERAÇÃO SE SELECIONOU
A OPÇÃO VERMELHO
}
}
});
d.show();
Vamos analisar algumas linhas de código acima. Observe que
criei uma constante de array de String chamada opcoes, com três
valores, como é demonstrado abaixo:
final String[] opcoes
={"Azul","Amarelo","Vermelho"};
Para criar a lista de itens na caixa de diálogo, foi preciso usar o
método setItems que possui dois parâmetros :no primeiro, você
passa o array de itens a serem selecionados ; no segundo você
define um evento onClick, que será disparado toda vez que um
determinado item for selecionado. Vamos analisar o evento
onClick:
public void onClick(DialogInterface dialog, int
item) {
switch (item) {
case 0: //EXECUTA OPERAÇÃO SE SELECIONOU
A OPÇÃO AZUL
case 1: //EXECUTA OPERAÇÃO SE SELECIONOU
A OPÇÃO AMARELO
234](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-234-320.jpg)
![Luciano Alves da Silva
case 2: //EXECUTA OPERAÇÃO SE SELECIONOU
A OPÇÃO VERMELHO
}
}
});
O método onClick possui dois parâmetros : o primeiro
corresponde a instância da caixa de diálogo e o segundo
parâmetro corresponde ao índice do item selecionado.
Veja o resultado abaixo:
AlertDialog com o lista de opções
Agora vamos trabalhar com itens de opções , como no
RadioButton. Veja o código abaixo:
AlertDialog.Builder d = new
AlertDialog.Builder(AppAlert.this);
final String[] opcoes
={"Azul","Amarelo","Vermelho"};
235](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-235-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Agora vamos criar uma nova classe Java, indo no menu
“File”/”New”/”Class”. No campo name digite “ServidorCalc” e
marque a opção “public static void main(String arg[])”,
conforme a figura abaixo:
Criando uma nova classe
Agora, adicione o código abaixo:
import java.net.*;
import java.io.*;
public class ServidorCalc {
250](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-250-320.jpg)
![Luciano Alves da Silva
public static void main(String[] args) {
double num1,num2;
try {
ServerSocket ss = new ServerSocket(60);
System.out.print("Aguardando conexao...nn");
Socket s = ss.accept();
System.out.print("Conexao aceita...nn");
DataInputStream in = new
DataInputStream(s.getInputStream());
DataOutputStream out = new
DataOutputStream(s.getOutputStream());
num1 = in.readDouble();
num2 = in.readDouble();
System.out.println(num1 + "+" + num2 + "=" +
(num1 + num2));
out.writeDouble((num1 + num2));
in.close();
out.close();
s.close();
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
251](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-251-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Layout da tela da aplicação
Agora no arquivo “AppPlayList.java”, coloque o seguinte
código abaixo:
package br.com.appplaylist;
import android.app.Activity;
import android.os.Bundle;
import android.media.*;
import android.widget.*;
import
android.widget.AdapterView.OnItemSelectedListener;
import android.view.*;
public class AppPlayList extends Activity {
/** Called when the activity is first created.
*/
Spinner spnmusicas;
Button btplay,btstop;
private final String[] musicas = {"Musica
1","Musica 2","Musica 3"};
MediaPlayer mp;
@Override
302](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-302-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
findViewById(R.id.spnmusicas);
btplay = (Button)
findViewById(R.id.btplay);
btstop = (Button) findViewById(R.id.btstop);
File[] files = new
File(diretorio).listFiles();
ArrayList arquivos = new ArrayList();
for(int i=0 ; i < files.length ; i++)
if(files[i].isFile())
arquivos.add(files[i].getName());
ArrayAdapter musicas = new
ArrayAdapter(this,android.R.layout.simple_spinner_i
tem,arquivos.toArray());
spnmusicas.setAdapter(musicas);
spnmusicas.setOnItemSelectedListener(new
AdapterView.OnItemSelectedListener() {
public void onItemSelected(AdapterView<?>
arg0, View arg1,int arg2, long arg3) {
String nome_musica = ((TextView)
arg1).getText().toString();
mp = new MediaPlayer();
try {
mp.setDataSource(diretorio + nome_musica);
mp.prepare();
312](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-312-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Observe que no nosso programa, é criada uma constante
chamada “diretório”, que aponta para o diretório “sdcard”,
conforme é mostrado na figura abaixo:
final String diretorio = "/sdcard/";
Por que apontamos para o diretório do “sdcard” ?, porque o
Android (tanto o emulador quanto um SmartPhone) possui um
diretório chamado sdcard onde dentro dele, são armazenados
arquivos comuns, que possivelmente serão utilizados por uma
aplicação.
Observe também que foi necessário a criação de um array do
tipo File, que irá armazenar os arquivos contidos dentro do
diretório “sdcard”, conforme mostra o código abaixo:
File[] files = new File(diretorio).listFiles();
Para obtermos os arquivos dentro do diretório “sdcard“, foi
necessário o uso do método “listFiles”, que retorna um array de
objetos do tipo File, onde cada um equivale à um arquivo.
Em seguida, é criado um objetivo do tipo “ArrayList”, que
consiste em um array genérico de dimensão aleatória, ou seja, a
quantidade de elementos dentro desse objeto pode alterar
durante a execução do programa. Qual o objetivo de criar este
objeto ? Dentro dele iremos armazenar o nome dos arquivos que
estão dentro do objeto “files”, conforme você confere no código
abaixo:
for(int i=0 ; i < files.length ; i++)
if(files[i].isFile())
arquivos.add(files[i].getName());
314](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-314-320.jpg)
![Luciano Alves da Silva
public class AppPlayListVideos extends Activity {
/** Called when the activity is first created.
*/
Spinner spnvideos;
Button btplay,btstop;
VideoView video;
final String diretorio = "/sdcard/";
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
spnvideos = (Spinner)
findViewById(R.id.spnvideos);
video = (VideoView)
findViewById(R.id.video);
btplay = (Button)
findViewById(R.id.btplay);
btstop = (Button)
findViewById(R.id.btstop);
File[] files = new
File(diretorio).listFiles();
ArrayList arquivos = new ArrayList();
for(int i=0 ; i < files.length ; i++)
if(files[i].isFile())
arquivos.add(files[i].getName());
327](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-327-320.jpg)
![Luciano Alves da Silva
12.1.1) O comando CREATE TABLE
Esse comando serve para criar tabelas em banco de dados. Veja
a sua sintaxe abaixo:
create table <tabela>(<campo1> <tipo>
[<constraints>] [,<campo2> <tipo>
[<constraints>],...,<campon> <tipo> [<constraints>
]])
Exemplo: Criar uma tabela chamada “cadastro” com os
seguintes campos:
- codusuario: Do tipo inteiro com propriedades de chave
primária e auto numeração.
- nome : Do tipo texto e requerido
- idade : Do tipo inteiro e requerido
create table cadastro(codusuario integer
primary key autoincrement, nome text not null,
idade integer not null)
Outro exemplo : Criar uma tabela chamada “cadastro” (com os
mesmos campos do exemplo acima) no banco de dados, se ela
não existir.
331](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-331-320.jpg)
![Luciano Alves da Silva
update <tabela> set <campo1> = <valor1>[ ,...,
<campon> = <valorn>]
where <condição>
Exemplo: Atualizar a idade do primeiro registro (Luciano) para
24 anos.
update cadastro set idade = 24
where codusuario=1
12.1.4) O comando DELETE
Esse comando serve para remover dados de uma tabela já
existente. Veja a sua sintaxe abaixo:
delete from <tabela> where <condição>
Exemplo: Remover o primeiro registro da tabela (Luciano)
delete from cadastro where codusuario=1
12.1.5) O comando SELECT
Esse comando serve para fazer consultas a dados em uma tabela
já existente. Veja a sua sintaxe abaixo:
333](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-333-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
select <campo1>[,<campo2>,...,<campon>]
from <tabela>
where <condição>
Exemplos :
Mostrar todos os dados cadastrados na tabela
select codusuario,nome,idade
from cadastro
Mostrar todos os nomes cuja idade seja maior que 25.
select nome
from cadastro
where (idade >= 25)
Mostrar todos os nomes cujo prefixo seja ‘David’, ou seja, todos
que se chamam David, independente do sobrenome.
select nome
from cadastro
where (nome like ‘David%’)
A partir de agora, vamos ver abaixo algumas funções do
Android que trabalham com banco de dados.
No Android existe um pacote chamado android.sqlite, onde
existe uma classe chamada SQLiteDataBase, que possui os
seguintes métodos:
334](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-334-320.jpg)
![Luciano Alves da Silva
Método Descrição
Realiza uma consulta SQL
no banco de dados
(equivale ao comando
SELECT). Essa função
retorna uma instância do
tipo Cursor. Vamos
conhecer os parâmetros
que iremos utilizar dessa
função:
Cursor query(String <tabela> : Neste parâmetro
<tabela>, String[]
<colunas>, String você informa o nome da
<condicao_de_busca>, tabela.
String[] <selecionArgs>,
String <groupby>, String <coluna> : Neste
<having>, String <orderby>)
parâmetro a(s) coluna(s)
que o banco possui.
<condição de busca>: Aqui
você informa a condição
de busca de dados. Este
parâmetro funciona como
se fosse a clausula where
do SQL, onde é informada
a condição de busca.
O resto dos parâmetros
iremos trabalhar em seu
valor null.
335](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-335-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Vamos fazer algumas comparações da função “execSQL”, que
permite sintaxes de comando SQL com as demais funções,
como “update”,”insert” e “delete” para a realização de uma
consulta SQL.
12.2) Exemplos de SQL usando as funções do Android
12.2.1) Fazendo uma consulta a tabela (usando SELECT)
- Comando SQL :
select codusuario, nome, idade
from cadastro
- Usando a função query :
query(“cadastro“, (new String[]
{“codusuario“,“nome“,“idade“}), null, null, null,
null, null);
- Comando SQL :
select nome
from cadastro
where idade > 24
- Usando a função query :
338](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-338-320.jpg)
![Luciano Alves da Silva
query(“cadastro“, (new String[] {“nome“}),“ idade > 24“
, null, null, null, null);
12.2.2) Inserindo dados (usando INSERT)
- Comando SQL :
insert into cadastro(nome,idade)
values(‘Luciano’,23)
- Usando a função execSQL
execSQL(“insert into cadastro(nome,idade)
values(‘Luciano’,23); “);
Usando a função insert :
ContentValues valor = new ContentValues();
valor.put(“nome“, “Luciano“);
valor.put(“idade“, “23“);
insert(“cadastro“,null,valor);
12.2.3) Atualizando dados (usando UPDATE)
- Comando SQL :
339](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-339-320.jpg)
![Luciano Alves da Silva
Vou mostrar agora um exemplo para que você tenha um melhor
entendimento do mecanismo de banco de dados do Android.
Imagine uma tabela chamada “cadastro” com os seguintes dados
abaixo:
nome idade
Amanda 32
Bianca 30
Bruna 23
Carla 20
Agora, observe a linha de código abaixo:
SQLDatabase db;
db = openOrCreateDatabase("dbbanco",
Context.MODE_PRIVATE, null);
Cursor c = db.query("cadastro", (new String[]
{"nome","idade"}), "idade < 32", null, null, null,
null);
Observe que a linha acima cria um objeto do tipo Cursor que
vai receber o resultado da consulta da função query, que retorna
uma instância do mesmo tipo. Logo, a instância retornada pela
função query na verdade, retorna uma tabela resultante da
consulta. Veja esse resultado abaixo:
nome idade
Bruna 23
Carla 20
345](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-345-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
btcadastrarpessoa.setOnClickListener(new
View.OnClickListener(){
public void onClick(View arg0){
CarregaTelaCadastro();
}});
btlistarpessoas.setOnClickListener(new
View.OnClickListener(){
public void onClick(View arg0){
CarregaListaPessoas();
}});
btcadastrarpessoa.requestFocus();
}
void CarregaTelaCadastro() {
setContentView(R.layout.cadastro);
dados = db.query("cadusuarios",( new String[]
{"nome","profissao","idade"}), null, null,
null, null, null);
numreg = dados.getCount();
Button btcadastrar = (Button)
findViewById(R.cadastro.btcadastrar);
Button btcancelar = (Button)
354](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-354-320.jpg)
![Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
}
catch(Exception e) {
showMessage("Erro ao cadastrar",
"Erro");
showMessage(e.toString(), "Erro");
}}
});
btcancelar.setOnClickListener(new
View.OnClickListener(){
public void onClick(View arg0){
CarregaTelaPrincipal();
}
});
}
void CarregaListaPessoas() {
try {
dados = db.query("cadusuarios",( new String[]
{"nome","profissao","idade"}), null, null, null,
null, null);
numreg = dados.getCount();
pos=1;
}catch(Exception e) {
showMessage(e.toString(), "Erro");
}
if(numreg==0) {
showMessage("Nenhum registro
cadastrado", "Aviso");
356](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-356-320.jpg)
![Luciano Alves da Silva
CarregaTelaPrincipal();
return;
}
setContentView(R.layout.listacadastrados);
dados = db.query("cadusuarios",( new String[]
{"nome","profissao","idade"}), null, null, null,
null, null);
numreg = dados.getCount();
txtnome = (TextView)
findViewById(R.lista.txtnome);
txtidade = (TextView)
findViewById(R.lista.txtidade);
txtprofissao =
(TextView)findViewById(R.lista.txtprofissao);
Button btvoltar = (Button)
findViewById(R.lista.btvoltar);
Button btavancar = (Button)
findViewById(R.lista.btavancar);
Button btmenu = (Button)
findViewById(R.lista.btmenu);
try {
dados.moveToFirst();
txtnome.setText(dados.getString(dados.getColu
mnIndex("nome")));
txtidade.setText(dados.getString(dados.getCol
umnIndex("idade")));
txtprofissao.setText(dados.getString(dados.getColum
nIndex("profissao")));
357](https://image.slidesharecdn.com/android1250-110918220719-phpapp01/85/android-357-320.jpg)
android
- 1. Luciano Alves daSilva Apresentação O Android é uma plataforma aberta voltada para dispositivos móveis desenvolvida pela Google e atualmente é mantida pela Open Handset Alliance (OHA). Todas as aplicações desenvolvidas para essa plataforma utilizam a linguagem Java, o que facilita muitos programadores com conhecimentos em Java a desenvolver aplicações para essa plataforma. Este livro tem por objetivo mostrar de modo fácil como programar na plataforma para dispositivos móveis da Google (Android) usando a IDE Eclipse. Para quem dedico este livro? Este livro é dedicado aos usuários experientes ou iniciantes em programação (tanto para Desktop, Móbile e etc.), que já tenha algum contato com a linguagem Java ou de suas derivadas (C, C++ ou C#).
- 2. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Índice analítico 1) Visão geral sobre o Google Android ................................... 6 1.1) Introdução...................................................................... 6 1.2) Estrutura Geral da plataforma Google Android ............ 9 1.2.1) A arquitetura do Android.......................................... 10 1.2.2) Aplicações ................................................................ 10 1.2.3) Android Runtime ...................................................... 12 1.2.4) Linux Kernel............................................................. 12 2) Instalando e Configurando o Android SDK no Eclipse .. 13 3) Começando a programar no Google Android ................. 31 4) Conhecendo as widgets do Android.................................. 52 4.1) A widget TextView ..................................................... 52 4.2) A widget EditText ....................................................... 52 4.3) A widget Button .......................................................... 52 4.4) Desenvolvendo uma aplicação que soma números ..... 52 4.5) A widget AutoCompleteTextView.............................. 69 4.6) A widget CheckBox .................................................... 74 4.7) Desenvolvendo uma aplicação simples de compras.... 74 4.8) A widget RadioButton ................................................. 80 4.9) Desenvolvendo uma aplicação de cálculo de salário (Com RadioButton)................................................................... 80 4.10) A widget Spinner ....................................................... 90 4.11) Desenvolvendo uma aplicação de cálculo de salário (Com Spinner)........................................................................... 91 4.12) A widget ListView .................................................... 97 4.13) Desenvolvendo uma aplicação de lista telefônica ..... 97 4.14) A widget Imageview................................................ 103 2
- 3. Luciano Alves daSilva 4.15) Desenvolvendo uma aplicação que visualiza imagens (Com ImageView) .................................................................. 103 4.16) A widget Gallery ..................................................... 114 4.17) Desenvolvendo uma aplicação que visualiza imagens (Com Gallery) ......................................................................... 114 4.18) A widget ProgressBar.............................................. 125 4.19) Desenvolvendo uma aplicação que simula um download................................................................................. 126 4.20) A widget SeekBar.................................................... 133 4.21) Desenvolvendo uma aplicação que demonstre o sistema RGB Color. ................................................................ 133 4.22) A widget DatePicker................................................ 141 4.23) Desenvolvendo uma aplicação de calendário.......... 141 4.24) A widget TimePicker............................................... 145 4.25) Desenvolvendo uma aplicação que faz uso do TimePicker.............................................................................. 145 4.26) A widget ToogleButton ........................................... 149 4.27) Desenvolvendo uma aplicação que faz uso do ToogleButton .......................................................................... 149 4.28) A widget Chronometer ............................................ 152 4.29) Desenvolvendo um cronômetro digital ................... 152 4.30) A widget DigitalClock............................................. 161 4.31) Desenvolvendo uma aplicação que mostra a hora corrente do sistema. ................................................................ 161 4.32) A widget ZoomControls .......................................... 163 4.33) Desenvolvendo um programa que aplica zoom em Imagens ................................................................................... 163 5) Mudando de layouts ......................................................... 170 5.1) Desenvolvendo uma aplicação de cadastro ............... 177 6) Trabalhando com mais de uma Activity (Atividade) .... 203 3
- 4. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 7) Trabalhando com o componente TabWidget................. 210 8) Trabalhando com menus em uma aplicação.................. 219 9 ) Conhecendo as caixas de diálogo do Android............... 229 9.1) A classe AlertDialog.................................................. 229 9.2) A classe DatePickerDialog ........................................ 237 9.3) A classe TimePickerDialog ....................................... 239 9.4) A classe ProgressDialog ............................................ 241 9.5) Criando uma caixa de diálogo personalizada ........... 245 10) Programação com internet em Android....................... 248 10.1) Trabalhando com sockets em Android .................... 248 10.2) Desenvolvendo uma aplicação cliente em Android e um servidor Java. .................................................................... 249 10.3) Obtendo conteúdo de uma URL .............................. 263 10.4) Enviando informações para uma página Web via URL ................................................................................................ 269 10.5) Enviando informações para uma página Web via POST (Usando a classe HttpPost) .......................................... 275 10.6) Fazendo download de um arquivo........................... 285 10.7) O componente WebView ........................................ 289 10.8) Desenvolvendo uma aplicação que visita páginas Web ................................................................................................ 292 11) Programação com multimídia ....................................... 296 12) Programação com banco de dados................................ 330 12.1) A linguagem SQL.................................................... 330 12.1.1) O comando CREATE TABLE ............................. 331 12.1.2) O comando INSERT............................................. 332 12.1.3) O comando UPDATE........................................... 332 4
- 5. Luciano Alves daSilva 12.1.4) O comando DELETE ........................................... 333 12.1.5) O comando SELECT............................................ 333 12.2) Exemplos de SQL usando as funções do Android .. 338 12.3) Desenvolvendo uma aplicação de cadastro (segunda versão)..................................................................................... 347 13) Propriedades e eventos dos componentes trabalhados 361 Widget TextView.............................................................. 361 Widget EditText / AutoCompleteTextView ..................... 363 Widget Button................................................................... 367 Widget ToogleButton ....................................................... 369 Widget CheckBox/RadioButton ....................................... 372 Widget Spinner / ListView ............................................... 374 Widget ImageView ........................................................... 376 Widget Gallery.................................................................. 377 Widget ProgressBar .......................................................... 378 Widget SeekBar ................................................................ 380 Widget DatePicker ............................................................ 381 Widget TimePicker ........................................................... 383 Widget Chronometer......................................................... 384 Widget ZoomControls ...................................................... 385 Componente MediaPlayer................................................. 386 Widget VideoView ........................................................... 387 Apêndice – Links Úteis ......................................................... 391 5
- 6. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 1) Visão geral sobre o Google Android 1.1) Introdução C onforme mencionado na apresentação deste livro, o Android é uma plataforma desenvolvida pela Google voltada para dispositivos móveis, totalmente aberta é livre (Open Source), que foi divulgada em 5 de novembro de 2007. Ela foi desenvolvida na plataforma Java com sistema operacional Linux e atualmente essa plataforma é mantida pela OHA (Open Handset Alliance), um grupo constituído por aproximadamente 80 empresas as quais se uniram para inovar e acelerar o desenvolvimento de aplicações e serviços, com o objetivo e trazer aos consumidores uma experiência mais rica em termos de recursos, menos dispendiosa em ternos financeiros para o mercado móvel. Um dos SmartPhones que ofereceu suporte a esse sistema operacional foi o G1 da empresa T-Mobile. Confira na imagem seguinte: 6
- 7. Luciano Alves daSilva G1 - T-Mobile Não demorou muito para que o Android chegasse aqui no Brasil. Hoje já contamos com operadoras como a Claro, TIM e Vivo que já oferecem suporte a essa plataforma. Os SmartPhones disponíveis aqui no Brasil oferecidos por algumas dessas operadoras, que suportam o sistema Android é o Samgung Galaxy e o Motorola Milestone. Confira esses SmartPhones nas imagens seguintes: 7
- 8. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Samsung Galaxy Motorola Milestone 8
- 9. Luciano Alves daSilva 1.2) Estrutura Geral da plataforma Google Android O Android SDK é uma ferramenta de desenvolvimento que disponibiliza um conjunto de APIs necessárias para desenvolver aplicações para a plataforma Android, utilizando a linguagem Java. Vamos conhecer os recursos encontrados nessa plataforma: - Application framework: Permite a reutilização e substituição de componentes ; - Dalvik virtual machine: É uma Máquina Virtual Java (JVM) voltada para dispositivos móveis ; - Browser Integrado baseado no webkit engine ; - Gráficos Otimizados O Android é cosntituído por bibliotecas 2D e 3D baseada na especificação OpenGL ES 1.0 ; - SQLite: Sistema Gerenciador de Banco de Dados (SGBD) já embutido no Android para guardar dados ; - Suporte multimídia: A plataforma já oferece para áudio, vídeo e formatos de imagem (MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF) ; - Telefonia GSM (dependente de hardware) ; - Bluetooth, EDGE, 3G, e WiFi (dependente de hardware) ; 9
- 10. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores - Câmera, GPS, compasso, e acelerômetro (dependente de hardware) ; - Rico ambiente de desenvolvimento , incluindo um emulador de dispositivo, ferramentas de depuração, memória, performance e um plugin para o Eclipse (ADT) ; 1.2.1) A arquitetura do Android Arquitetura geral da plataforma 1.2.2) Aplicações O Android nos fornece um conjunto de aplicações fundamentais, são elas: - um cliente de e-mail; - programa de SMS; 10
- 11. Luciano Alves daSilva - agenda; - mapas; - navegador; - contatos entre outros. Todos os aplicativos acima presentes no Android foram desenvolvidos na linguagem de programação Java. O Android nos fornece um conjunto de bibliotecas C/C++ utilizadas por vários componentes do sistema. Veja algumas das bibliotecas abaixo: - System C library: Consiste em uma implementação derivada da biblioteca C padrão baseado no sistema (libc) do BSD sintonizada para dispositivos rodando Linux. - Media Libraries: Baseado no PacketVideo’s OpenCORE; são as bibliotecas que suportam os mais diversos formatos de áudio e vídeo, incluindo também imagens. - Surface Manager: Responsável pelo acesso ao subsistema de exibição bem como as múltiplas camadas de aplicações 2D e 3D; - LibWebCore: Consiste em um web browser engine utilizado tanto no Android Browser quanto para exibições web. - SGL – o engine de gráficos 2D - 3D libraries: Uma implementação baseada no OpenGL ES 1.0 APIs; As bibliotecas utilizam aceleração 3D via hardware (quando disponível) ou o software de renderização 3D altamente otimizado incluído no Android. 11
- 12. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores - FreeType – Biblioteca responsável pela renderização de fontes bitmap e vector; - SQLite – Conforme já mencionado, consiste no sistema gerenciador de banco de dados (SGBD) relacional disponível para todas as aplicações. 1.2.3) Android Runtime O Android é costituído por um conjunto de bibliotecas que fornece a maioria das funcionalidades disponíveis nas principais bibliotecas da linguagem Java. Toda aplicação Android roda em seu próprio processo, com sua própria instância da máquina virtual Dalvik. O Dalvik foi escrito de forma a executar várias VMs eficientemente. Ele executa arquivos .dex, que é otimizado para consumo mínimo de memória. A VM é baseada em registros e roda classes compiladas pela linguagem Java que foram transformadas em arquivos .dex, através da ferramenta “dx” incluída no SDK. O Dalvik VM foi baseado no kernel do Linux para funcionalidades subjacentes como o encadeamento e a gestão de baixo nível de memória. 1.2.4) Linux Kernel O Android foi projetado em cima da versão 2,6 do kernel do Linux para os serviços centrais do sistema, tais como segurança, gestão de memória, gestão de processos, etc. O kernel também atua como uma camada de abstração entre o hardware e o resto do software. 12
- 13. Luciano Alves daSilva 2) Instalando e Configurando o Android SDK no Eclipse P ara a elaboração desse livro eu fiz o uso do Eclipse Galileo (Eclipse 3.5.1 para Windows), o SDK do Android Revisão 10 e o plugin do Android para o Eclipse ADT-10.0.1. Qualquer versão (de preferência superior) dos programas citados acima serve. 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. 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) Significa você possui uma máquina virtual Java instalada no seu computador, caso contrário, instale o JDK. Você pode fazer o download do JDK pelo link abaixo: http://www.oracle.com/technetwork/java/javase/downloads/inde x.html 13
- 14. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Se você já possui a máquina virtual Java instalada em seu computador, basta agora você fazer o download do Eclipse, que pode ser feita pelo link abaixo: http://www.eclipse.org/downloads/ Para fazer o download do Android SDK e do seu plugin , faça pelo link abaixo: http://developer.android.com/sdk/index.html Depois de obter os programas e plugins citados acima, vamos fazer agora as devidas configurações. Primeiramente, você irá descompactar o arquivo “android-sdk_r10-windows.zip”, de preferência no diretório raiz “C:”. Depois de descompactar, execute o utilitário “SDK Manager”, que se encontra dentro da pasta descompactada, conforme é mostrado na figura abaixo: Conteúdo do arquivo descompactado 14
- 15. Luciano Alves daSilva Ao executá-lo ele irá atualizar as suas fontes , conforme demonstra a figura seguinte: Processo de atualização das informações Ao terminar o processamento acima, ele ira mostrar uma lista de pacotes disponíveis e necessários para download, como podemos conferir a figura abaixo: Lista de pacotes disponíveis para download 15
- 16. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Vamos cancelar a instalação dos pacotes acima clicando no botão “Cancel”, pois, não iremos instalar tudo. Feito isso você irá visualizar a seguinte caixa de diálogo abaixo: Caixa de diálogo – Installed packages Precisamos agora instalar a plataforma Android através desta caixa de diálogo. Clique na seção “Avaiable packages” para visualizar todos os recursos disponíveis para instalação. Feito isso expanda a opção “Android Repository” e automaticamente você verá os recursos disponíveis para download como você pode conferir na figura abaixo: 16
- 17. Luciano Alves daSilva Caixa de diálogo - Available Packages Nós iremos trabalhar aqui neste livro com a plataforma Android 2.1 API 7, revision 2. Então vamos marcar a opção “SDK Platform Android 2.1, API 7, revision 2” e em seguida vamos clicar no botão “Install Selected”, você verá a seguinte caixa de diálogo abaixo: Preparando para Instalar o Android 17
- 18. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Vamos proceder com a instalação clicando no botão “Install”. Feito isso a plataforma Android 2.1 será instalada, conforme demonstra a figura abaixo Instalação do Android em processo Depois de concluída a instalação do Android será mostrada uma mensagem pedindo que o ADB seja reiniciado, como demonstra a figura abaixo: Mensagem solicitando para reiniciar do adb Clique em “Yes” para reiniciar a ADB, e o resultado você pode conferir na figura abaixo. 18
- 19. Luciano Alves daSilva Instalação do Android concluída Uma etapa concluída. Agora vamos instalar o Eclipse com o plugin do Android. Para instalar o Eclipse simplesmente descompacte-o em um local apropriado, de preferência no drive “C:”. Depois disso copie para o drive “C:” o plugin do Android “ADT-10.0.1.zip”. Feito isso vamos executar o Eclipse. Com o Eclipse aberto na no menu “Help” / “Install New Software”, como mostra a figura abaixo: Install New Software 19
- 20. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Ao fazer esse procedimento será aberta uma tela conforme mostra a figura abaixo: Caixa de diálogo - Install Para instalarmos o plugin do Android clique no botão “Add”, e será exibida uma caixa de diálogo conforme mostra a figura abaixo: 20
- 21. Luciano Alves daSilva Caixa de diálogo - Add Site Agora vamos clicar no botão “Archive” e iremos procurar e selecionar o plugin do Android “A.D.T-10.0.1.zip”. Preencha o campo “Name” como mostra a figura abaixo: Caixa de diálogo - Add Site Ao clicar em “OK” será mostrada uma tela, conforme demonstra a figura seguinte: 21
- 22. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Caixa de Dialogo - Install Agora expanda o item “Developer Tools” e marque todas as opções, conforme mostra a figura seguinte: 22
- 23. Luciano Alves daSilva Caixa de Dialogo - Install Após fazer isso clique no botão “Next”, e em seguida será mostrada a próxima tela, conforme demonstra a figura abaixo: 23
- 24. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Caixa de Dialogo - Install Agora, clique no botão “Finish”. Após isso ocorrerá alguns processos, como demonstra a figura abaixo, aguarde até terminar. Instalando do Android no Eclipse 24
- 25. Luciano Alves daSilva Se em algum momento durante o processo for exibida a figura abaixo: Caixa de mensagem Pode clicar em “OK” sem problemas, e o processo se completará. Após o termino do processo você deve reiniciar o Eclipse, clicando em “Yes”, na mensagem abaixo: Caixa de mensagem 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” e será mostrada uma tela, conforme demonstra a figura seguinte: 25
- 26. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Caixa de diálogo - Preferences Agora você vai selecionar o diretório onde se encontra o Android, que aqui no meu computador, o Android se encontra instalado em “C:android-sdk-windows”, logo, terei que selecionar essa pasta. Feito isso basta clicar em “OK”. Para finalizar vamos definir um dispositivo virtual, conhecido como AVD (Android Virtual Device), onde nossas aplicações daqui para frente serão executadas. Para isso, vá no menu “Windows” / “Android SDK and AVD Manager”, conforme mostra a figura abaixo: 26
- 27. Luciano Alves daSilva Android SDK and AVD Manager Feito o procedimento acima, será aberta uma tela conforme mostra a figura abaixo: Caixa de diálogo - Virtual Settings 27
- 28. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Para criarmos um dispositivo virtual clique no botão “New”, e será aberta uma tela conforme mostra a figura abaixo: Caixa de diálogo - Crete new AVD De inicio, vamos configurar o básico pra executarmos a nossa aplicação. Em “Name” você define o nome do AVD, vamos chamá-lo de “Emulador”. Em “Target” definirmos a plataforma-alvo a ser executada, neste caso só temos uma o “Android 2.1-update1 - API Level 7”. Vamos selecioná-la. Em Skin na opção “Built-in” a opção padrão é “Default (WVGA800)”. Vamos mudar essa opção para “HVGA”. 28
- 29. Luciano Alves daSilva Depois de preencher todos os campos, a tela de criação do AVD deve estar de acordo com a figura abaixo: Caixa de diálogo - Create new AVD Para criarmos nosso AVD, clique no botão “Create AVD” e pronto. O resultado você confere na figura seguinte: 29
- 30. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores AVD Criado com sucesso Até aqui aprendemos a instalar e configurar a plataforma Android no Eclipse. Agora vamos dar nossos primeiros passos desenvolvendo uma aplicação básica no Android. 30
- 31. Luciano Alves daSilva 3) Começando a programar no Google Android D epois de tudo configurado e instalado, vamos começar a desenvolver nossas aplicações no Android. Para isso, vamos criar um novo projeto Android indo no menu “File” / “New” / “Other”. Selecione o projeto Android conforme figura abaixo. Depois de selecionar, clique em “Next”: Criando um novo projeto Android no Eclipse Após clicar em “Next” na figura acima, será exibida uma tela conforme figura abaixo: 31
- 32. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Criando um novo projeto Android no Eclipse Vamos preencher os campos citados abaixo: Project name : HelloWorldAndroid Application name : Hello World Android Package name: br.com.apphello Create Activity : AppHello Min SDK Version : 7 32
- 33. Luciano Alves daSilva Os campos preenchidos acima devem estar de acordo com a figura abaixo: Criando um novo projeto Android no Eclipse Depois de tudo preenchido basta clicar no botão “Finish” e 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” como também demonstra a figura: 33
- 34. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Visão geral de uma aplicação Android Irei descrever a estrutura de um projeto Android. Observem que dentro da pasta de projeto “HelloWorldAndroid” existe uma pasta chamada “src”, e dentro dela é que ficam os códigos fontes das aplicações. Observem que o arquivo “AppHello.java” se encontra dentro do pacote “br.com.apphello” (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 br.com.apphello; import android.app.Activity; import android.os.Bundle; public class AppHello extends Activity { /** Called when the activity is first created. */ 34
- 35. Luciano Alves daSilva @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } } Diferentemente das aplicações comuns em Java (J2SE), toda classe para aplicação Android deve ser derivada da classe Activity (Atividade), e possui como método principal o onCreate. Dentro desse método ele invoca o método onCreate da super classe passando mesmo parâmetro (o savedInstanceState), 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”. Dentro da pasta “HelloWorldAndroid” existe um diretório chamado “res”, onde ficam armazenados todos os recursos utilizados pela aplicação. Dentro do diretório “res” existem cinco diretórios, cada um deles com uma finalidade que descreverei agora: Os diretórios “drawable-hdpi”,”drawable-mdpi” e “drawable- ldpi”. A partir da versão 1.6 da plataforma Android foram adicionados três diretórios responsáveis pelo gerenciamento de imagens: “drawable-hdpi”, “drawable-ldpi”, “drawable-mdpi”. Qual a diferença de um para outro ? Cada um desses diretórios só será utilizado de acordo com a resolução do Android em uso, ou seja, qual modelo de emulador de você estiver usando. Por exemplo, quando você usa uma resolução de 480x800 no seu emulador, é 35
- 36. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores utilizado o diretório “drawable-hdpi” para buscar a imagem que vai representar o ícone da sua aplicação Android. Se você for usar uma resolução 320x480 (que normalmente é a resolução padrão do emulador Android), é utilizado o diretório “drawable- mdpi”. Se você usar uma resolução 240x400, é utilizado o diretório “drawable-ldpi”. O diretório “layout” armazena todos os layouts da aplicação Android, que normalmente são arquivos “.xml”. Para quem conhece a combinação HTML + JavaScript, no Android é similar, é a combinação de XML + Java, logo, todos os nossos componentes vão ser adicionados usando tags XML. Por padrão o arquivo de layout é o “main.xml”. Uma coisa interessante que existe nessa versão (e alguma das anteriores do SDK) é a capacidade de você ter um “preview” de como ficara a sua aplicação antes mesmo de você rodar o emulador Android, para confirmarmos isso, simplesmente vá no diretório “res/layout” e de um duplo clique no arquivo “main.xml”, e você verá o seu preview conforme demonstra a figura seguinte: 36
- 37. Luciano Alves daSilva Preview da aplicação Android Para visualizarmos o código do arquivo “main.xml” simplesmente clique na guia “main.xml”, que se encontra abaixo da seção “Views” como demonstra a figura seguinte: 37
- 38. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Preview da aplicação Android Veja o seu código abaixo: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/a ndroid" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello" /> </LinearLayout> 38
- 39. Luciano Alves daSilva Observe que após 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 um componente chamado TextView, que representa um texto a ser exibido na tela que por padrão, já vem escrito a frase “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”, que iremos descrevê-lo agora. O diretório “values” armazena valores estáticos (constantes) que podem ser utilizados por um arquivo “.xml”. Normalmente esses valores estáticos devem ser armazenados no arquivo “strings.xml”. Vá no diretório “res/values” e de um duplo clique no arquivo “strings.xml”, e será mostra o gerenciador desse arquivo conforme mostra a figura seguinte: 39
- 40. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Propriedades do arquivo “strings.xml” Observe que nas propriedades do atributo “hello” está atribuído um valor a ela, que é o valor “Hello World, AppHello!”. Isso quer dizer que lá no arquivo XML no componente TextView, tem uma propriedade chama android:text, com o valor “@string/hello” , que equivale a na verdade a string “Hello World, AppHello!”. Para ver a sua estrutura , clique na guia “strings.xml”. O código desse arquivo é igual ao que demonstra o código abaixo: <?xml version="1.0" encoding="utf-8"?> <resources> <string name="hello">Hello World, AppHello!</string> <string name="app_name">Hello World Android</string> </resources> 40
- 41. Luciano Alves daSilva Observem que dentro desse arquivo eu declaro um valor estático chamado “app_name”, cujo valor é “Hello World Android”. Dentro da pasta “HelloWorldAndroid” existe um arquivo chamado “AndroidManifest.xml” Esse arquivo é o sistema nervoso de uma aplicação Android. É nele que ficam as definições referentes à aplicação. De um duplo clique nesse arquivo para abri-lo, feito isso será mostrado o seu gerenciador, conforme mostra a figura abaixo: Propriedades do arquivo “AndroidManifest.xml” Bom, o que nos interessa aqui é o código. Para visualizarmos seu código clique na seção “AndroidManifest.xml”. Veja seu código abaixo: 41
- 42. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/a ndroid" package="br.com.android" android:versionCode="1" android:versionName="1.0"> <application android:icon="@drawable/icon" android:label="@string/app_name"> <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). 42
- 43. Luciano Alves daSilva 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 é 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 mais é 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” (que fica dentro do pacote “gen” , situado no projeto), 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. Agora iremos executar nossa aplicação. Vamos no menu “Run / Run Configurations”, conforme mostra a figura abaixo: “Run Configurations” 43
- 44. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Feito isso, 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: Criando um novo “Android Application” Feito isso, na propriedade “Name” ao lado digite “AppHello”. Em Project selecione o projeto que criamos em clicando no botão “Browse”, com o nome de “HelloWorldAndroid”. E por último, em “Launch Action”, deixe marcada a opção “Lauch Default Activity”. Qualquer dúvida siga a figura abaixo: Propriedades do “Android Application” 44
- 45. Luciano Alves daSilva Agora é só clicar em “Run” e rodar a aplicação. Quando o emulador Android é executado, possivelmente, poderá abrir 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”. Caixa de diálogo do Android SDK Pra você que está executando pela primeira vez o emulador do Android, vê que o emulador é uma espécie de SmartPhone. Lado esquerdo nós temos a tela do dispositivo e no lado direito temos o teclado com suas funções, conforme mostra a figura seguinte: 45
- 46. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Emulador do Android em Execução No início da execução do emulador mostra o título Android, conforme você vê na figura acima. Depois vem um outro título escrito “Android”, com um titulo cinza em animação. Isso 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 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 algumas mensagens, é só cancelá-las. Quando o emulador chegar nessa tela abaixo: 46
- 47. Luciano Alves daSilva Emulador do Android em Execução Clique no botão redondo com o titulo “MENU” para desbloquear a tela e a aplicação continuará a processar até ser carregada com sucesso, conforme mostra a figura abaixo: 47
- 48. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Emulador do Android em Execução 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 tempo. 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 outro programa, o Eclipse vai fazer uso do emulador já aberto 48
- 49. Luciano Alves daSilva 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 chamado android:text, onde nele defino o título que será exibido, modifique agora essa propriedade com o seguinte valor (título), conforme o código abaixo: android:text="Fala cara, beleza ???" Feito isso, salve a aplicação e veja seu “preview”, clicando na seção “Graphical Layout”. Veja na figura abaixo: Preview da aplicação 49
- 50. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 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 dois componentes TextView, 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” : <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/a ndroid" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Primeira Frase." /> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Segunda Frase" /> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Terceira Frase???" /> </LinearLayout> Feito isso, salve o arquivo e veja seu “preview”, como demonstra a figura abaixo: 50
- 51. Luciano Alves daSilva Preview da aplicação E ai, está entendo aos poucos como se faz aplicações Android ? Com certeza que sim! Como podemos ver nessa versão do Android, ele já oferece um utilitário que permite a criação de aplicações de forma rápida, simplesmente arrastando e soltando os componentes. Isso acelera o processo de desenvolvimento de aplicações. Neste livro, vamos trabalhar no Android usando esse utilitário que acelera o processo de desenvolvimento de aplicações, mas, em algumas ocasiões, faremos do modo tradicional, ou seja, digitar o código. Agora vamos aprofundar um pouco e fazer aplicações mais interessantes com o uso dos Widgets (componentes) existentes na plataforma Android. 51
- 52. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 4) Conhecendo as widgets do Android T oda aplicação Android é constituída por widgets, que são componentes gráficos que constituem uma aplicação Android. A partir de agora iremos conhecer os widgets básicos que constituem a plataforma Android, para o desenvolvimento das aplicações. De acordo com alguns widgets que fomos conhecendo, vamos desenvolver aplicações que demonstrem o uso deles. 4.1) A widget TextView A widget TextView funciona como se fosse uma Label (“rotulo”), onde nele podemos mostrar alguma informação, mensagem e etc. Na nossa primeira aplicação tivemos a oportunidade de usarmos esse componente. 4.2) A widget EditText A widget EditText funciona como se fosse caixa onde podemos digitar nela dados do teclado. 4.3) A widget Button A widget Button nada mais é do que um Botão de comando , que quando clicado, dispara uma ação, um evento. 4.4) Desenvolvendo uma aplicação que soma números Com os componentes até agora vistos, já é possível desenvolvermos uma aplicação. Vamos criar agora uma 52
- 53. Luciano Alves daSilva aplicação que faça uso de um desses widgets. Crie um novo projeto Android com os seguintes dados: Project Name: SomaNumeros Package Name: br.com.appsoma Create Activity: AppSoma Application Name: Soma Números Min SDK Version: 7 Criado o projeto vamos no arquivo “main.xml” desse projeto e como havia mencionado, vamos agora fazer uso do utilitário que ira nos ajudar a construir a nossa aplicação da forma rápida. 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 será carregado o “layout” dessa arquivo, como mostra a figura abaixo: 53
- 54. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Tela de layout da aplicação Primeiramente, antes de qualquer modificação no programa, vamos mudar a resolução da visualização do layout da nossa aplicação, para que esteja de acordo com a resolução do emulador Android. Na opção onde está selecionada como padrão “2.7in QVGA” , e vamos selecionar a opção “3.2in HVGA slider (ADP1)” (Essa será a resolução que passaremos a trabalhar daqui pra frente). Você verá que a resolução mudará , como demonstra a figura abaixo: 54
- 55. Luciano Alves daSilva Tela de layout da aplicação Agora vamos fazer as modificações iniciais no programa. Observe que logo de início, ele mostra a frase “Hello World,AppSoma!” na widget TextView. Vamos carregar as propriedades (Properties) dessa widget clicando com o botão direito sobre ele e em seguida selecione o menu “Show in / Properties”, como você confere na figura seguinte: 55
- 56. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Tela de layout da aplicação Em seguida as propriedades do componente se carregarão, conforme você pode conferir na figura abaixo: 56
- 57. Luciano Alves daSilva Tela de layout da aplicação Agora vamos na guia “Properties” encontrar uma propriedade chamada “Text”, que indica o conteúdo assumido pelo componente TextView, que no caso é a frase “Hello World,AppHello!”. Depois de encontrar a propriedade Text, substitua o valor corrente pela frase “Digite o primeiro número” e depois disso, de ENTER. O resultado você confere na figura abaixo: 57
- 58. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Tela de layout da aplicação Ótimo, agora vamos inserir a widget EditText, que funciona como um campo para preenchermos com valores numéricos ou alfanuméricos. Como vamos adicionar esse componente? Se você observar na figura acima, existe uma seção chamada “Form Widgets”, é nela onde ficam os componentes básicos que constituem uma aplicação Android. Primeiramente, encontre o componente (widget) EditText, depois de encontrá-lo, simplesmente você vai clicar sobre ele e arrastar até a tela do dispositivo, para adicioná-lo. O resultado você confere na figura abaixo: 58
- 59. Luciano Alves daSilva Tela de layout da aplicação Bom, agora vamos modificar duas propriedades desse componente. Encontre a propriedade “id” do componente EditText e nela você vai inserir o valor “@+id/numero1”. Essa propriedade serve para darmos um nome ao componente, caso ele seja trabalhado no código Java. O nome de um widget deve estar nesse formato: “@+<nome>/<nome>” 59
- 60. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Se observamos, o valor desse atributo é : “@+id/numero1”. É como se “id” representasse um grupo e “numero1” representasse o nome do componente. Você irá entender essa notação mais a frente. Depois disso, vamos na propriedade “Layout width”, que define a largura de um componente e iremos definir o valor “fill_parent”, que indica que o componente irá ocupar toda a largura do dispositivo. Para finalizar, vamos agora modificar a propriedade “Text“, deixando seu conteúdo em branco. O resultado você confere na figura abaixo: Tela de layout da aplicação 60
- 61. Luciano Alves daSilva Agora você vai inserir, NA SEQUÊNCIA, os componentes TextView e EditText. Na segunda TextView, vamos inserir na propriedade “Text” a frase “Digite o segundo número”. Já na segunda EditText, vamos repetir os mesmos procedimentos que fizemos na primeira EditText, sabendo-se que a diferença vai estar na propriedade “id” que assumirá o valor “@+id/numero2”. Somente essa é a diferença, o resto é tudo igual. Agora vamos inserir um componente chamado Button na nossa aplicação. Depois de inserido, modifique as propriedades abaixo com os seus respectivos valores: Button Propriedade Valor Layout width fill_parent Id @+id/btsomar Text Somar Depois de feito todas as alterações, o layout da aplicação deve estar de acordo com a figura abaixo: 61
- 62. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Tela de layout da aplicação Bom, agora vamos analisar o código produzido. Para visualizarmos o código produzido, basta clicar na guia “main.xml” . O código produzido você confere abaixo: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/a ndroid" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:layout_width="fill_parent" 62
- 63. Luciano Alves daSilva android:layout_height="wrap_content" android:text="Digite o primeiro número"/> <EditText android:layout_height="wrap_content" android:id="@+id/numero1" android:layout_width="fill_parent"></EditText> <TextView android:id="@+id/TextView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Digite o segundo número"></TextView> <EditText android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+id/numero2"></EditText> <Button android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+id/btsomar" android:text="Somar"></Button> </LinearLayout> Vamos analisar o código: Dentro da estrutura LinearLayout temos um componente TextView, identificado pela tag <TextView......></TextView>. Dentro desse componente possuímos as propriedades android:layout_width (Layout Width), que possui o valor “fill_parent” ; android:layout_height (Layout Height), que possui o valor “wrap_content” ; android:text (Text) que possui o valor “Digite o primeiro número”. Em seguida temos o componente EditText, identificado pela tag <EditText......></EditText>. Dentro desse componente possuímos as propriedades android:layout_width , android:layout_height e android:id (Id) que possui o valor “@+id/ednumero1” (que equivale ao nome do componente). 63
- 64. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores A descrição acima da estrutura dos componentes e das propriedades segue também para os componentes seguintes. 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ê ver como esse processo é feito. Após a linha import android.os.Bundle; Digite: import android.widget.*; import android.view.*; import android.app.*; Antes da linha: @Override Digite: EditText ednumero1,ednumero2; Agora vamos à 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 acessá- lo devo fazer uso da classe Button e assim vai. 64
- 65. Luciano Alves daSilva Agora, após a linha: setContentView(R.layout.main); Digite as seguintes linhas de código: ednumero1 = (EditText) findViewById(R.id.numero1); ednumero2 = (EditText) findViewById(R.id.numero2); Button btsomar = (Button) findViewById(R.id.btsomar); Agora vou explicar as linhas acima. A linha: ednumero1 = (EditText) findViewById(R.id.numero1); Faz referência ao primeiro EditText, através do método findViewById com o parâmetro “R.id.numero1”. Se lembra o nome da primeira EditText que está no código XML? Ela se chama “@+id/numero1”. Vamos entender. Observe que para fazer referência ao EditText pelo método findViewById eu passei o parâmetro “R.id.numero1”. 65
- 66. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Já na segunda linha, para fazer a referência à segunda EditText, cujo nome é “@+id/numero2”, pelo método findViewById, passei o parâmetro “R.id.numero2”. 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 para o componente 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 btsomar = (Button) findViewById(R.id.btsomar); Insira o código abaixo: btsomar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { double num1 = Double.parseDouble(ednumero1.getText().toString()); double num2 = Double.parseDouble(ednumero2.getText().toString()); double res = num1 + num2; AlertDialog.Builder dialogo = new AlertDialog.Builder(AppSoma.this); dialogo.setTitle("Aviso"); dialogo.setMessage("Soma:" + res); dialogo.setNeutralButton("OK", null); dialogo.show(); 66
- 67. Luciano Alves daSilva } }); Toda vez que eu clicar no botão ele irá mostrar o resultado da soma na tela através de uma caixa de mensagem. Ótimo! Vamos executar a nossa 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: Aplicação que soma números em execução OBS: Provavelmente durante a execução da aplicação ao entrar com um número, deve ter surgido no dispositivo um teclado 67
- 68. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores virtual (como mostra a figura acima), para ocultar ele é só pressionar ESC. 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: double num1 = Double.parseDouble(ednumero1. getText().toString()); 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 ednumero1 para retornar o conteúdo. Diferente de muitos métodos de retorno 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. O código abaixo: AlertDialog.Builder dialogo = new AlertDialog.Builder(AppSoma.this); dialogo.setTitle("Aviso"); dialogo.setMessage("Soma:" + res); dialogo.setNeutralButton("OK", null);dialogo.show(); 68
- 69. Luciano Alves daSilva É responsável por mostrar a soma na tela através da classe AlertDialog.Builder, responsável por criar caixas de diálogo e exibi-las. Muito bem, com esse conhecimento adquirido até agora, você já tem capacidade para fazer uma aplicação básica em Android. 4.5) A widget AutoCompleteTextView A widget AutoCompleteTextView é uma widget baseada no EditText que possui um mecanismo “auto complete” , que funciona como um mecanismo de busca de certas palavras de acordo com o que está sendo digitado no componente. Vamos demonstrar o uso desse componente. Project Name: ExemploAutoCompleteTextView Package Name : br.com.appautocomplete Create Activity: AppAutoComplete Application Name: Exemplo com AutoCompleteTextView Min SDK Version: 7 Depois de criar o projeto, carregue o layout do arquivo “main.xml” e em seguida selecione o componente TextView e vamos na propriedade Text para alterar o texto dele com a seguinte frase “Digite o nome de um país”. Agora precisamos inserir o componente (widget) AutoCompleteTextView. Ele também se encontra na seção 69
- 70. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores “Form Widgets”. Muito provável que você não esteja vendo esse componente, então, como faço para visualizá-lo ? Observe que onde se encontra a guia “Properties” (Propriedades dos componentes), existem outras guias como “Problems”, “Javadoc” e etc. Precisamos “minimizar essas guias para podermos ver todas as widgets da seção “Form Widgets”. Para minimizar essas guias , clique no botão localizado à direita bem depois da guia “Properties”, no local indicado pela a figura abaixo: Botão minimizar Feito isso você verá todos os componentes da seção “Form Widgets” inclusive o componente “AutoCompleteTextView”. Vamos inserir esse componente e em seguida mude suas propriedades como demonstra a figura abaixo: Propriedade Valor Text Id @+id/ednomepais Layout_width fill_parent A tela da nossa aplicação terá que estar de acordo com a figura abaixo: 70
- 71. Luciano Alves daSilva Layout da aplicação Feito isso vamos no arquivo “AppAutoComplete.java” e vamos adicionar o seguinte código abaixo: package br.com.appautocomplete; import android.app.Activity; import android.os.Bundle; import android.widget.*; public class AppAutoComplete extends Activity { /** Called when the activity is first created. */ AutoCompleteTextView ednomepais; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); 71
- 72. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_l ist_item_1, paises); ednomepais = (AutoCompleteTextView) findViewById(R.id.ednomepais); ednomepais.setAdapter(adapter); } private final String[] paises = new String[] { "Afeganistão", "África do Sul", "Albânia","Alemanha", "Andorra","Angola", "Anguila","Antárctida" "Azerbaijão", "Baamas", "Bangladeche","Brasil", "Canadá", "Catar", "Cazaquistão", "Chade", "Chile","China","Chipre", "Clipperton Island", "Dhekelia", "Dinamarca", "Domínica", "Egipto", "Equador", "Eritreia", "Eslováquia", "Eslovénia", "Espanha", "Estados Unidos", "Grécia", "Gronelândia", "Ilhas Salomão", "Ilhas Turcas e Caicos", "Indonésia", "Irão", "Iraque"}; } Vamos analisar alguns trechos de código abaixo. A linha : ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_l ist_item_1, paises); 72
- 73. Luciano Alves daSilva Cria um objeto do tipo Array através da classe ArrayAdapter e carregamos em seus parâmetros um vetor (array de Strings) pré- definido com o nome dos países chamado paises. A linha abaixo: ednomepais.setAdapter(adapter); Carrega o vetor no componente através do método “setAdapter”. E na linha seguinte: private final String[] paises = new String[] {....} Havíamos definido o array de Strings paises onde nele estão definidos os países onde alguns deles serão exibidos durante o processo de sugestão do componente. Bom, agora vamos rodar a nossa aplicação. Veja como ficou na figura seguinte: Demonstração do uso AutoCompleteTextView 73
- 74. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 4.6) A widget CheckBox A widget CheckBox funciona como um componente que pode ser marcado e desmarcado, e que possui também um rótulo. 4.7) Desenvolvendo uma aplicação simples de compras Vamos fazer uma outra aplicação Android que vai fazer uso da widget CheckBox, que acabamos de conhecer acima. 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. Bom, vamos criar um novo projeto chamado SistemaDeCompras. Siga os dados do projeto abaixo: Project Name: SistemaDeCompras Package Name : br.com.appcompra Create Activity: AppCompra Application Name: Sistema de Compras Min SDK Version: 7 Vamos no arquivo “main.xml” desse projeto para carregarmos seu layout. Depois de carregado, modifique o valor da 74
- 75. Luciano Alves daSilva propriedade Text da TextView com a frase “Escolha seu produto”. Feito isso, adicione os seguintes componentes, na sequência: CheckBox Propriedade Valor Text Arroz (R$ 2,69) Id @+id/chkarroz CheckBox Propriedade Valor Text Leite (R$ 5,00) Id @+id/chkleite CheckBox Propriedade Valor Text Carne (R$ 9,70) Id @+id/chkcarne CheckBox Propriedade Valor Text Feijão (R$ 2,30) Id @+id/chkfeijao 75
- 76. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Button Propriedade Valor Text Total das compras Id @+id/btotal Layout_width fill_parent Ao final, o layout da nossa aplicação deve estar de acordo com a figura seguinte: Layout da tela da aplicação Agora vamos modificar o arquivo “AppCompra.java“. O código desse arquivo será como o código que é exibido abaixo: 76
- 77. Luciano Alves daSilva package br.com.appcompra; import android.app.AlertDialog; import android.os.Bundle; import android.widget.*; import android.view.*; import android.app.*; public class AppCompra extends Activity { CheckBox chkarroz,chkleite,chkcarne,chkfeijao; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); chkarroz = (CheckBox) findViewById(R.id.chkarroz); chkleite = (CheckBox) findViewById(R.id.chkleite); chkcarne = (CheckBox) findViewById(R.id.chkcarne); chkfeijao = (CheckBox) findViewById(R.id.chkfeijao); Button bttotal = (Button) findViewById(R.id.bttotal); bttotal.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { 77
- 78. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores double total =0; if(chkarroz.isChecked()) total += 2.69; if(chkleite.isChecked()) total += 5.00; if(chkcarne.isChecked()) total += 9.7; if(chkfeijao.isChecked()) total += 2.30; AlertDialog.Builder dialogo = new AlertDialog.Builder(AppCompra.this); dialogo.setTitle("Aviso"); //Defino o título dialogo.setMessage("Valor total da compra :" + String.valueOf(total)); //colocando a mensagem que vai ter dentro do Dialog dialogo.setNeutralButton("OK", null); //adicionando o botão de OK dialogo.show(); //mostrando o Dialog } }); } } Descrevendo o código do método onClick : Dentro do método eu crio uma variável chamada total que armazena o valor total da compra. Observe que eu tenho quatro estruturas if’s onde 78
- 79. Luciano Alves daSilva cada uma verifica se um determinado item foi marcado, se foi, incrementa o valor do item com o valor da variável total. No final mostro valor total das compras na tela. Vamos roda nossa aplicação? O resultado você confere na figura seguinte: Aplicação simples de compras em execução 79
- 80. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 4.8) A widget RadioButton A widget RadioButton é um componente muito utilizado em opções de múltipla escolha, onde somente uma única opção pode ser selecionada. 4.9) Desenvolvendo uma aplicação de cálculo de salário (Com RadioButton) 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: CalculoDeSalario Package Name : br.com.appsalario Create Activity: AppSalario Application Name: Cálculo do salário Min SDK Version: 7 80
- 81. Luciano Alves daSilva Nessa primeira versão da aplicação, como havia falado, vamos fazer uso da widget RadioButton. Carregado o arquivo “main.xml”, modifique a propriedade Text da TextView com a frase “Digite seu salário (R$)”. Em seguida adicione os seguintes componentes, na sequência : EditText Propriedade Valor Text Id @+id/edsalario Layout_width fill_parent TextView Propriedade Valor Text Qual é o seu percentual ? Seguindo os passos acima ate aqui, a aplicação deve estar de acordo com o dá figura abaixo: 81
- 82. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Tela de layout da aplicação Cálculo de salário Bom, agora vamos adicionar um componente ou melhor, uma estrutura que será responsável por agrupar as RadioButtons dentro dela, que se chama RadioGroup. Nesta versão do Android o RadioGroup já oferece por padrão três RadioButtons, que é quantidade necessária para a nossa aplicação. Essa estrutura também se encontra dentro da seção “Form Widgets” e para adicionar este componente no dispositivo, simplesmente clique e arraste ele até a tela do dispositivo. O resultado você confere na figura abaixo: 82
- 83. Luciano Alves daSilva Estrutura RadioGroup inserida Com o RadioGroup selecionado, modifique as propriedades abaixo: Propriedade Valor Layout Width fill_parent Id @+id/rgopcoes Observe que dentro do RadioGroup existem três RadioButtons, cada uma telas identificada por um nome. Se você observar no Eclipse, à direita da tela da aplicação, existe uma seção chamada “Outline” onde nela posso visualizar toda a estrutura dos 83
- 84. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores componentes que estão na minha aplicação. Confira na figura abaixo: Guia “Outline” Agora modifique as propriedades das RadioButons de acordo com as indicações abaixo: radio0 Propriedade Valor Text 40% Id @+id/rb40 radio1 84
- 85. Luciano Alves daSilva Propriedade Valor Text 45% Id @+id/rb45 radio2 Propriedade Valor Text 50% Id @+id/rb50 Agora, vamos adicionar uma Button, simplesmente clicando e arrastando o componente na tela. Agora um detalhe, é para colocar esse componente na tela do dispositivo mas FORA da área do RadioGroup. Depois de colocar o Button, modifique as propriedades abaixo: Propriedade Valor Text Calcular novo salário Id @+id/btcalcular Layout_width fill_parent Depois de inserir todos os componentes citados, o layout da aplicação deve ficar de acordo com a figura abaixo: 85
- 86. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout da tela da aplicação Vamos analisar agora parte de um trecho de código produzido. Como havia falado acima, as RadioButtons precisam ficar dentro de uma estrutura chamada RadioGroup certo ? Vamos ver como isso é estruturado dentro de um código XML, como você confere abaixo: <RadioGroup android:layout_width="wrap_content" android:layout_height="wrap_content" android:orientation="vertical" android:id="@+id/rgopcoes"> <RadioButton android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="40%" android:checked="true" android:id="@+id/rb40"></RadioButton> <RadioButton android:layout_width="wrap_content" android:layout_height="wrap_content" 86
- 87. Luciano Alves daSilva android:text="45%" android:id="@+id/rb45"></RadioButton> <RadioButton android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="50%" android:id="@+id/rb50"></RadioButton> </RadioGroup> Observe acima que logo após a definição da estrutura RadioGroup, existe dentro dela as RadioButtons, que serão utilizadas na aplicação. No arquivo “AppSalario.java”, coloque o código abaixo: package br.com.appsalario; import android.app.Activity; import android.os.Bundle; import android.widget.*; import android.view.*; import android.app.*; public class AppSalario extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button btcalcular = (Button) 87
- 88. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores findViewById(R.id.btcalcular); btcalcular.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { double salario, novo_sal; EditText edsalario = (EditText) findViewById(R.id.edsalario); salario = Double.parseDouble (edsalario.getText().toString()); RadioGroup rg = (RadioGroup) findViewById(R.id.rgopcoes); int op = rg.getCheckedRadioButtonId(); if(op==R.id.rb40) novo_sal = salario + (salario * 0.4); else if(op==R.id.rb45) novo_sal = salario + (salario * 0.45); else novo_sal = salario + (salario * 0.5); AlertDialog.Builder dialog = new AlertDialog.Builder(AppSalario.this); dialog.setTitle("Novo salário"); 88
- 89. Luciano Alves daSilva dialog.setMessage("Seu novo salário é : R$" + String.valueOf(novo_sal)); dialog.setNeutralButton("OK", null); dialog.show(); } }); } } Vamos à explicação de alguns códigos interessantes. Dentro do método onClick, eu realizo o cálculo do novo salário do funcionário. Os primeiros códigos do evento são similares 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: if(op==R.id.rb40) Verifico se a opção de 40% foi selecionada, se estiver, realiza o cálculo do salário com o reajuste de 40%. A mesma explicação e 89
- 90. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores válida para o cálculo dos outros reajustes. Agora vamos executar a nossa aplicação. O resultado você vê na figura abaixo: Aplicação de cálculo de salário em execução 4.10) A widget Spinner A widget Spinner é um componente do tipo caixa de combinação (“ComboBox”) onde nele é armazenado vários itens a serem selecionados. Para que um componente possa ser selecionado, é preciso clicarmos na seta , para que os itens possam ser mostrados e , por consequência, serem selecionados. 90
- 91. Luciano Alves daSilva 4.11) Desenvolvendo uma aplicação de cálculo de salário (Com Spinner) Bom, agora vamos criar a nossa segunda versão do aplicativo acima, usando agora o componente Spinner. Crie um novo projeto Android com os seguintes dados: Project Name: CalculoDeSalarioSpinner Package Name : br.com.appsalariospinner Create Activity: AppSalario Application Name: Cálculo do salário Min SDK Version: 7 Nessa segunda versão da aplicação, vamos fazer uso da widget Spinner. Carregue o arquivo “main.xml” e faça os mesmos procedimentos do programa anterior, só que ao invés de adicionar a RadioGroup com os RadioButtons, você vai inserir somente um componente Spinner. Segue abaixo as propriedades do Spinner que você precisa modificar: Propriedade Valor Id @+id/spnopcoes Layout_width fill_parent Seguindo os passos, a aplicação deve estar de acordo com a figura abaixo: 91
- 92. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Tela de layout da aplicação Agora no arquivo “AppSalario.java”, coloque o seguinte código: package br.com.appsalariospinner; import android.app.Activity; import android.os.Bundle; import android.widget.*; import android.view.*; import android.app.*; public class AppSalario extends Activity { private static final String[] percentual = {"De 40%","De 45%","De 50%"}; ArrayAdapter<String> aPercentual; Spinner spnsal; 92
- 93. Luciano Alves daSilva @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button btmostrar = (Button) findViewById(R.id.btcalcular); aPercentual = new ArrayAdapter<String>(this,android.R.layout.simple_s pinner_item, percentual); spnsal = (Spinner) findViewById(R.id.spnopcoes); spnsal.setAdapter(aPercentual); btmostrar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { double salario=0, novo_sal = 0; EditText edsalario = (EditText) findViewById(R.id.edsalario); salario = Double.parseDouble(edsalario.getText().toString()); switch(spnsal.getSelectedItemPosition()) { case 0: novo_sal = salario + (salario * 0.4); break; 93
- 94. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores case 1: novo_sal = salario + (salario * 0.45); break; case 2: novo_sal = salario + (salario * 0.5); break; } AlertDialog.Builder dialogo = new AlertDialog.Builder(AppSalario.this); dialogo.setTitle("Novo salário"); dialogo.setMessage("Seu novo salário é : R$" + String.valueOf(novo_sal)); dialogo.setNeutralButton("OK", null); dialogo.show(); } }); } } Observando o código do programa acima, podemos ver que ele é similar o da primeira versão do aplicativo, porém, quero comentar alguns códigos interessantes desta aplicação. Observe que foi necessário declarar um “array” de “String” chamado percentual, conforme mostra o código abaixo: private static final String[] percentual = {"De 40%","De 45%","De 50%"}; Este “array” possui três elementos, correspondentes ao percentual do aumento do salário. Também foi necessário 94
- 95. Luciano Alves daSilva declarar um objeto do tipo ArrayAdapter chamado aPercentual. Esse objeto serve para fazer referencia ao “array” percentual. Dentro do método OnCreate, existe uma linha de código abaixo: aPercentual = new ArrayAdapter<String>(this,android.R.layout.simple_s pinner_item, percentual); Que cria uma instância da classe ArrayAdapter e atribuo essa instância ao objeto aPercentual, onde carrego nele o “array” de Strings percentual. Logo depois, vem a instrução: spnsal.setAdapter(aPercentual); Onde carrego no objeto do tipo Spinner uma lista de opções de percentual. Vamos agora dentro do evento OnClick do objeto Button. Dentro existe o código mostrado abaixo: switch(spnsal.getSelectedItemPosition()) { case 0: novo_sal = salario + (salario * 0.4); break; case 1: novo_sal = salario + (salario * 0.45); break; case 2: novo_sal = salario + (salario * 0.5); break; } Que verifica qual será o novo salário , de acordo com a opção selecionada no objeto Spinner. Vamos entender esse código. Observe que o objeto spnsal, possui um método chamado getSelectedItemPosition, que é responsável por retornar o 95
- 96. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores índice do item selecionado, sabendo se que o primeiro item possui índice zero, o segundo possui índice um e assim por diante. Observe que dentro dessa estrutura eu verifico a opção selecionada, se for a primeira, o novo salário terá aumento de 40%, se for a segunda , o aumento será de 45% senão, o aumento será de 50%. Logo após o cálculo do novo salário, é exibido na tela o novo salário. Vamos executar a nossa aplicação. O resultado da execução você confere na figura abaixo: Aplicação de cálculo de salário usando Spinner em execução 96
- 97. Luciano Alves daSilva 4.12) A widget ListView A widget ListView é um componente que possui vários itens a serem selecionados, similar ao componente Spinner. A única diferença entre o ListView e o Spinner é que no componente ListView os itens já são mostrados sem nenhuma necessidade de se clicar em alguma parte dele para que os mesmos possam ser mostrados. 4.13) 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. Bom, vamos criar um novo projeto. Siga os dados abaixo: Project Name: ListaTelefonica Package Name : br.com.applista Create Activity: AppLista Application Name: Lista de contatos Min SDK Version: 7 Vamos no layout do nosso arquivo “main.xml” e vamos modificar o conteúdo na TextView, com a frase : “Escolha um 97
- 98. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores contato”. Depois disso, vamos inserir um ListView (que se encontra na guia “Composite”) e depois iremos modificar suas propriedades, conforme abaixo: Propriedade Valor Id @+id/lstcontatos Layout_width fill_parent A aplicação depois de feito todos os passos acima, deve estar de acordo com a figura abaixo: Layout da tela da aplicação No arquivo AppList.java, coloque o seguinte código: package br.com.applista; import android.app.Activity; 98
- 99. Luciano Alves daSilva import android.app.AlertDialog; import android.os.Bundle; import android.widget.*; import android.widget.AdapterView.OnItemClickListener; import android.view.*; public class AppLista extends Activity { public ListView lista; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_l ist_item_1, contatos); lista = (ListView) findViewById(R.id.lstcontatos); lista.setAdapter(adapter); lista.setOnItemClickListener(new OnItemClickListener(){ public void onItemClick(AdapterView parent, View view, int position, long id) { AlertDialog.Builder dialogo = new AlertDialog.Builder(AppLista.this); dialogo.setTitle("Contato selecionado"); dialogo.setMessage(((TextView) view).getText().toString()); dialogo.setNeutralButton("OK", null); 99
- 100. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores dialogo.show(); } }); } 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 possa carregar dos dados em uma ListView, preciso fazer uso da classe ArrayAdapter, como mostra a instrução abaixo: 100
- 101. Luciano Alves daSilva 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 se clica 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 parent, View view, int position,long id) { AlertDialog.Builder dialogo = new AlertDialog.Builder(AppLista.this); dialogo.setTitle("Contato selecionado"); dialogo.setMessage(((TextView) view).getText() .toString()); dialogo.setNeutralButton("OK", null); dialogo.show(); 101
- 102. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores }); Toda vez que clicarmos em um item da lista, o método onItemClick será disparado e será executado o comando abaixo: AlertDialog.Builder dialogo = new AlertDialog.Builder(AppLista.this); dialogo.setTitle("Contato selecionado"); dialogo.setMessage(((TextView) view).getText() .toString()); dialogo.setNeutralButton("OK", null); dialogo.show(); Que exibe o nome do item selecionado. O item selecionado está em um objeto View, que precisa ser convertido para um objeto do tipo TextView, para que o método getText possa ser invocado retornando em uma String o item selecionado . Vamos executar a aplicação. O resultado você vê na figura abaixo: 102
- 103. Luciano Alves daSilva Aplicação de lista de contatos em execução 4.14) A widget Imageview A widget ImageView é um componente que permite que visualizemos imagens dentro dele. As imagens suportadas por esse componente são imagens no formato JPEG, GIF e PNG. 4.15) Desenvolvendo uma aplicação que visualiza imagens (Com ImageView) Agora vamos desenvolver uma aplicação que visualiza imagens, usando o componente ImageView. 103
- 104. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Agora crie um novo projeto conforme os dados abaixo: Project Name: VisualizadorDeImagens Package Name : br.com.appimagem Create Activity Name: AppImagem Application Name: Visualizador de Imagens Min SDK Version: 7 Antes de iniciarmos a codificação do programa, quero que você coloque duas imagens JPEG (com a extensão .jpg), dentro da pasta “res/drawable-mdpi” (para esse projeto usei duas imagens chamadas “foto1.jpg” e “foto2.jpg”). Para importar um arquivo, clique com o botão direito do mouse sobre a pasta “res/drawable-mdpi” e selecione “Import”, depois selecione File System (Que se encontra dentro da pasta “General”). 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-mdpi” . Veja a figura abaixo: 104
- 105. Luciano Alves daSilva Importando imagens para aplicação Depois disso, é só clicar em “Finish”. Agora no layout do arquivo “main.xml” apague o componente TextView que se encontra na tela do dispositivo. Feito isso, siga os passos abaixo para construirmos a nossa aplicação. Vamos adicionar dentro da tela da nossa aplicação uma estrutura LinearLayout (que se encontra na guia “Layouts”) simplesmente arrastando o componente para a tela da aplicação. O resultado você confere na figura abaixo: 105
- 106. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Estrutura LinearLayout inserida Agora nessa estrutura LinearLayout que inserimos, vamos modificar a seguinte propriedade abaixo: Propriedade Valor Orientation horizontal Logo após a alteração da propriedade, a estrutura LinearLayout que inserimos “perdeu foco”. Se você clicar novamente no local onde você inseriu estrutura é muito provável que você não consiga selecioná-lo (isso normalmente acontece com essa estrutura) . Para solucionar esse problema simplesmente selecione esta estrutura pela guia “Outline”, como demonstra a figura abaixo: 106
- 107. Luciano Alves daSilva Selecionando a estrutura LinearLayout Agora dentro da estrutura LinearLayout que configuramos acima, vamos inserir o componente ImageView (que se encontra na guia “Images & Media”), e em seguida mude as seguintes propriedades: ImageView Propriedade Valor Id @+id/imagem Src @drawable/foto1 Bom antes de prosseguir, quero explicar a propriedade “Src”. Nessa propriedade definimos a imagem corrente que irá aparecer na tela que é especificada pela notação “@drawable/foto1” (lembre-se que uma das imagens que utilizei para o projeto chama-se “foto1.jpg”), irei explicar essa notação. 107
- 108. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Se você notou, quando importamos as duas imagens que seriam utilizadas pelo nosso programa, essas imagens ficaram dentro do diretório “drawable-mdpi” certo ? Porém, quando especificamos pela propriedade “Src” o nome do diretório das imagens sempre será “@drawable”. Outro detalhe: Quando especificamos o nome do arquivo de imagem, o nome do arquivo não pode ter a extensão dele, isso é regra. TextView Propriedade Valor Id @+id/txtinfo Text Foto 1 Seguindo os passos acima, o resultado do layout deve ficar de acordo com a figura abaixo: Layout da aplicação 108
- 109. Luciano Alves daSilva Agora vamos colocar na sequência dois Buttons, só que esses dois componentes vão estar dentro da tela da aplicação , ou seja , da estrutura principal. Segue abaixo as propriedades que precisam ser modificadas: Button1 Propriedade Valor Id @+id/btimagem1 Text Exibir foto 1 Layout_width fill_parent Button2 Propriedade Valor Id @+id/btimagem2 Text Exibir foto 2 Layout_width fill_parent Depois de seguir todos os passos descritos acima, a aplicação tem que estar de acordo com a figura abaixo: 109
- 110. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout da aplicação Agora no arquivo “AppImage.java” coloque o código abaixo: package br.com.appimagem; import android.app.Activity; import android.os.Bundle; import android.view.*; import android.widget.*; public class AppImagem extends Activity { ImageView imagem; TextView txt; @Override 110
- 111. Luciano Alves daSilva public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button btfoto1 = (Button) findViewById(R.id.btimagem1); Button btfoto2 = (Button) findViewById(R.id.btimagem2); imagem = (ImageView) findViewById(R.id.imagem); txt = (TextView) findViewById(R.id.txtinfo); btfoto1.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { imagem.setImageResource(R.drawable.foto1); txt.setText("Foto 1"); } }); btfoto2.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { imagem.setImageResource(R.drawable.foto2); txt.setText("Foto 2"); } }); } } 111
- 112. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Agora vamos analisar alguns trechos de códigos. Vamos no evento Click referente a abertura da primeira imagem. O código: imagem.setImageResource(R.drawable.foto1); É 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: txt.setText("Foto 1"); 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 à abertura da segunda imagem. Vamos executar a nossa aplicação. O resultado você vê nas imagens abaixo: 112
- 113. Luciano Alves daSilva Aplicação de visualização de imagens em execução (mostrando a foto 1) Aplicação de visualização de imagens em execução (mostrando a foto 2) 113
- 114. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 4.16) A widget Gallery Na aplicação anterior, fizemos uso do widget ImageView. Note que usamos a mesma widget para visualizar duas imagens distintas. Agora nesta segunda aplicação vamos fazer uso da widget Gallery, que funciona como um grupo do ImageViews onde cada foto pode ser visualizada simplesmente arrastando o mouse ou clicando nas setas direitas ou esquerda do SmartPhone . Veja na figura abaixo uma aplicação que faz uso dessa estrutura: 4.17) Desenvolvendo uma aplicação que visualiza imagens (Com Gallery) Bom, vamos a nossa aplicação. Crie um novo projeto de acordo com os dados abaixo: Project Name: GaleriaDeImagens Package Name : br.com.appgallery Create Activity: AppGallery Application Name: Galeria de Imagens Min SDK Version: 7 114
- 115. Luciano Alves daSilva Depois de criado o projeto coloque na pasta de imagens do android (res/drawable-mdpi) três imagens, que devem se chamar respectivamente “imagem1.jpg”, ”imagem2.jpg” e “imagem3.jpg”. Feito o que se pediu acima vamos criar uma classe chamada ImageAdapter, que será uma classe iremos utilizar em nossa aplicação e essencial para o funcionamento do componente Gallery. Siga os passos abaixo: Vá no menu “File/New/Class”, conforme mostra a figura abaixo: Criando uma nova classe Será aberto um formulário no qual você deverá preencher os dados da classe a ser criada. Segue abaixo os dados a serem preenchidos: Source folder : GaleriaDeImagens/src Package: br.com.appgallery 115
- 116. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Name: ImageAdapter Seguindo os passos acima, os dados devem estar de acordo com a figura abaixo: Criando uma nova classe Se estiver tudo “OK” é só pressionar o botão “Finish” para que a classe possa ser criada. Em seguida coloque o código seguinte: 116
- 117. Luciano Alves daSilva package br.com.appgallery; import android.content.Context; import android.view.*; import android.widget.*; public class ImageAdapter extends BaseAdapter { private Context myContext; /* Neste array são colocadas as imagens a serem exidas no componente Gallery .*/ private int[] myImageIds = { R.drawable.imagem1, R.drawable.imagem2, R.drawable.imagem3, }; public ImageAdapter(Context c) { this.myContext = c; } public int getCount() { return this.myImageIds.length; } public Object getItem(int position) { return position; } public long getItemId(int position) { return position; } public View getView(int position, View convertView, ViewGroup parent) { ImageView i = new ImageView(this.myContext); 117
- 118. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores i.setImageResource(this.myImageIds[position]); i.setScaleType(ImageView.ScaleType.FIT_XY); i.setLayoutParams(new Gallery.LayoutParams(150, 150)); return i; } public float getScale(boolean focused, int offset) { return Math.max(0, 1.0f / (float)Math.pow(2, Math.abs(offset))); } } Observem que dentro desta classe existe um array chamado myImageIds, onde eu armazeno as imagens a serem visualizadas no componente. Agora , carregue o arquivo “main.xml” e modifique o conteúdo da TextView com a frase: “Visualização de Imagens”, e em seguida insira na tela o componente Gallery (que se encontra na guia “Images & Media”). Modifique as propriedades do componente Gallery conforme é mostrado abaixo: Propriedade Valor Id @+id/gallery Layout_width fill_parent 118
- 119. Luciano Alves daSilva Feito isso, abra o arquivo “AppGallery.java” e vamos modificá- lo com o seguinte código abaixo: package br.com.appgallery; import android.app.Activity; import android.os.Bundle; import android.widget.*; public class AppGallery extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); ((Gallery) findViewById(R.id.gallery)) .setAdapter(new ImageAdapter(this)); } } Agora vamos executar a nossa aplicação. O resultado da execução você confere nas figuras abaixo: 119
- 120. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Aplicação de galeria de imagens em execução (primeira foto em exibição) Aplicação de galeria de imagens em execução (segunda foto em exibição) 120
- 121. Luciano Alves daSilva Aplicação de galeria de imagens em execução (terceira foto em exibição) Agora vamos tornar essa aplicação mais interessante. Vamos colocar nessa aplicação um ImageView, que irá armazena a imagem seleciona no componente Gallery. Carregue novamente o arquivo “main.xml” e em seguida coloque os seguintes componentes, na sequência: TextView Propriedade Valor Text Imagem selecionada ImageView Propriedade Valor Id @+id/imagem Layout_width fill_parent 121
- 122. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Agora no arquivo “AppGallery.java” vamos substituir o código recente pelo novo código abaixo: package br.com.appgallery; import android.app.Activity; import android.os.Bundle; import android.view.*; import android.widget.*; public class AppGallery extends Activity { Gallery g; ImageView imagem; private int[] myImageIds = { R.drawable.imagem1, R.drawable.imagem2, R.drawable.imagem3, }; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); g = (Gallery) findViewById(R.id.gallery); g.setAdapter(new ImageAdapter(this)); imagem = (ImageView) findViewById(R.id.imagem); 122
- 123. Luciano Alves daSilva g.setOnItemClickListener(new AdapterView.OnItemClickListener(){ public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3) { imagem.setImageResource(myImageIds[arg2]); Toast.makeText(getBaseContext(), "Figura " + (arg2 + 1) + " selecionada", Toast.LENGTH_SHORT).show(); } }); } } Quais foram as modificações desse programa? Nesse programa foi adicionado um componente chamado ImageView, que faz referência ao componente ImageView no arquivo XML, como mostra o código abaixo: ImageView imagem; Também na aplicação adicionamos o “array” que contém todas as referências das imagens contidas no projeto, conforme mostra o código seguinte: 123
- 124. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores private int[] myImageIds = { R.drawable.imagem1, R.drawable.imagem2, R.drawable.imagem3, }; Dentro do método onCreate foi feito uma referência ao componente ImageView contido no XML e definimos o evento OnItemClickListener , do componente Gallery. Vamos analisar seu código abaixo: imagem.setImageResource(myImageIds[arg2]); Toast.makeText(getBaseContext(), "Figura " + (arg2 + 1) + " selecionada", Toast.LENGTH_SHORT).show(); A primeira instrução carrega a imagem selecionada no componente Gallery no ImageView, através do método setImageResource, cujo parâmetro é o valor do índice do vetor. A segunda instrução fazendo uso do método makeText, da classe Toast, cuja finalidade é mostrar uma pequena mensagem na tela em um tempo curto. No primeiro parâmetro desse método sempre passamos o valor getBaseContext(). No segundo parâmetro passamos o conteúdo a ser exibido na tela. No terceiro parâmetro, definimos o tempo de exibição da mensagem na tela. Execute a aplicação. O resultado você vê na figura abaixo: 124
- 125. Luciano Alves daSilva Aplicação de galeria de imagens em execução (versão otimizada) 4.18) A widget ProgressBar Agora será mostrado uma widget do Android que consiste em uma barra de progresso, o ProgressBar. Ela é muito utilizada quando queremos indicar algum andamento em processo como por exemplo, quando ocorre a instalação de um programa ou quando se faz um download de um arquivo normalmente é mostrado aquela barra de porcentagem que indica em 125
- 126. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores porcentagem, o andamento daquele processo. Aquilo é uma barra de progresso. 4.19) Desenvolvendo uma aplicação que simula um download Para demonstrar o uso do componente ProgressBar, criaremos uma aplicação que vai simular um download, onde o processo desse download será feito por esse componente. Vamos criar um novo projeto em Android, com os seguintes dados: Project Name: ExemploProgressBar Package Name : br.com.appprogressbar Create Activity: AppProgressBar Application Name: Exemplo com ProgressBar Min SDK Version: 7 Agora no arquivo de layout modifique o conteúdo da TextView com a seguinte frase: “Status download”. Em seguida adicione o componente ProgressBar (que se encontra na guia “Form Widgets”) e mude suas propriedades conforme é indicado abaixo: Propriedade Valor Id @+id/progresso Layout_width fill_parent 126
- 127. Luciano Alves daSilva Style ?android:attr/progressBarStyleHorizontal Max 100 Depois vamos adicionar o componente Button e mudar as seguintes propriedades, como segue : Button Propriedade Valor Id @+id/progresso Layout_width fill_parent Text Efetuar download Seguindo os passos acima, a aplicação deve estar de acordo com a aplicação da figura abaixo: 127
- 128. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout da aplicação Vendo o layout acima talvez você dever estar se perguntando: Espere aí, nos não definimos uma barra de progresso horizontal? Sim, definimos sim. A razão pela qual de nós não estarmos vendo uma barra de progresso horizontal é porque em tempo de projeto, a imagem PADRÃO do componente ProgressBar é um anel. Em tempo de projeto quando modificamos o estilo dela, ela não sofreu nenhuma mudança quanto ao desenho dela, isso é normal. Quando executarmos, você verá que o estilo da ProgressBar estará de acordo com o estilo que selecionamos. 128
- 129. Luciano Alves daSilva Agora vá no arquivo “AppProgressBar.java” e coloque o seguinte código abaixo: package br.com.appprogressbar; import android.app.Activity; import android.os.Bundle; import android.os.Handler; import android.view.View; import android.widget.*; public class AppProgressBar extends Activity implements Runnable{ ProgressBar p; Button b; Thread t; Handler h; int i; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); p = (ProgressBar) findViewById(R.id.progresso); b = (Button) findViewById(R.id.btdownload); b.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { h = new Handler(); t = new Thread(AppProgressBar.this); 129
- 130. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores t.start(); } }); } public void run() { i=1; try { while(i<=100) { Thread.sleep(100); h.post(new Runnable(){ public void run() { p.setProgress(i++); } }); } }catch(Exception e) {} } } Agora vou explicar o código desse programa. Observe a declaração da classe abaixo: public class AppProgressBar extends Activity implements Runnable{ Além de derivar da classe Activity, eu implemento também a interface Runnable. Essa interface possui um método abstrato 130
- 131. Luciano Alves daSilva chamado run, que é bastante utilizado por “Threads”. Uma Thread consiste em um processo que é executado em “paralelo” com o programa que o invocou, ou seja, quando uma Thread é executada ,não é preciso que a próxima instrução (ou instruções) após a Thread espere ela ser finalizada, elas podem ser executadas em paralelo. Veja as declarações abaixo: Thread t; Handler h; Aqui é declarada uma variável do tipo Thread e outra do tipo Handler (que consiste também em uma Thread). A variável do tipo Handler é utilizada quando queremos manipular os widgets em tempo de execução dentro de uma Thread. Vamos para o evento onClick do botão. Veja o código abaixo: public void onClick(View v) { h = new Handler(); t = new Thread(AppProgressBar.this); t.start(); } No evento onClick, eu crio uma instância da classe Handler e atribuo essa instância à variável h. Logo após eu crio uma instância da classe Thread e atribuo essa instância à variável t, em seguida eu disparo a Thread pelo método start, executando assim o método run. Vamos ao código do método run. 131
- 132. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores public void run() { i=1; try { while(i<=100) { Thread.sleep(100); h.post(new Runnable(){ public void run() { p.setProgress(i++); } }); }}catch(Exception e) {} } Vamos analisar o código dentro do “loop”. A instrução: Thread.sleep(100); Gera um atraso de 100 milissegundos. Logo após vem a instrução: h.post(new Runnable(){ public void run() { p.setProgress(i++); } }); A instrução acima é responsável por incrementar o valor de progresso da widget ProgressBar. Quando usamos uma Thread e queremos modificar o valor de algum componente (widget), precisamos disparar um método post e dentro dela, criar uma instância da interface Runnable com o método run onde nele é 132
- 133. Luciano Alves daSilva executado a instrução responsável por modificar o valor de um componente. Vamos executar a nossa aplicação . O resultado você vê na figura abaixo: Aplicação que simula um download em execução 4.20) A widget SeekBar A widget SeekBar nada mais é do que uma extensão da widget ProgressBar que funciona como uma barra de pesquisa e ela possui um “indicador”, onde podemos arrastá-lo tanto para esquerda quanto para a direita. 4.21) Desenvolvendo uma aplicação que demonstre o sistema RGB Color. Vamos desenvolver uma aplicação que irá demonstrar o sistema RGB Color , através do componente SeekBar. Crie um projeto Android com os seguintes dados abaixo: 133
- 134. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Project Name: SistemaRGBColor Package Name : br.com.apprgbcolor Create Activity: AppRGBColor Application Name: Sistema RGB Color Min SDK Version : 7 Depois de carregar o layout do arquivo “main.xml”, apague a TextView do layout da nossa aplicação. Agora vamos adicionar uma nova estrutura LinearLayout dentro da tela da nossa aplicação. Após adicionar a estrutura LinearLayout (que vai estar nomeada de linearLayout01), modifique as seguintes propriedades abaixo: Propriedade Valor Orientation vertical Layout width fill_parent Layout height 250px Gravity center Se você observar acima, o valor da propriedade “Layout height” não é nem “fill_parent” e nem “wrap_content” e sim ‘250px’ (250 pixels de altura). Não necessáriamente, os valores “fill_parent” e “wrap_content” são obrigatórios nessa propriedade (incluindo também é propriedade “Layout width”), podemos também especificar valores números com uma escala de notação como foi demonstrado acima. 134
- 135. Luciano Alves daSilva Bom, agora dentro da estrutura linearLayout1 vamos adicionar o seguintes componentes, na sequência: TextView Propriedade Valor Text RGB Color TextView Propriedade Valor Id @+id/boxcolor Layout width 150px Layout height 150px Text Agora novamente dentro da tela principal vamos adicionar uma nova estrutura LinearLayout abaixo da estrutura linearLayout1. E dentro dessa estrutura (que vai estar nomeada de linearLayout2), modifique as seguintes propriedades abaixo: Propriedade Valor Orientation vertical Layout width fill_parent Layout height fill_parent Agora dentro dessa estrutura linearLayout2, adicione os seguintes componentes, na sequência: TextView 135
- 136. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Propriedade Valor Text Red SeekBar (esse componente se encontra em “Form Widgets”) Propriedade Valor Id @+id/sbarred Layout width fill_parent Max 255 TextView Propriedade Valor Text Green SeekBar Propriedade Valor Id @+id/sbargreen Layout width fill_parent Max 255 TextView Propriedade Valor Text Blue SeekBar 136
- 137. Luciano Alves daSilva Propriedade Valor Id @+id/sbarblue Layout width fill_parent Max 255 Seguindo os passos acima, a aplicação deve estar de acordo com a figura abaixo: Layout da tela da aplicação Agora vamos na arquivo “AppRGBColor.java” e coloque o seguinte código abaixo: package br.com.apprgbcolor; import android.app.*; import android.graphics.Color; import android.os.Bundle; 137
- 138. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores import android.widget.*; public class AppRGBColor extends Activity implements SeekBar.OnSeekBarChangeListener { /** Called when the activity is first created. */ TextView boxcolor; SeekBar sbarred,sbargreen,sbarblue; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); boxcolor = (TextView) findViewById(R.id.boxcolor); sbarred = (SeekBar) findViewById(R.id.sbarred); sbargreen = (SeekBar) findViewById(R.id.sbargreen); sbarblue = (SeekBar) findViewById(R.id.sbarblue); sbarred.setOnSeekBarChangeListener(this); sbargreen.setOnSeekBarChangeListener(this); sbarblue.setOnSeekBarChangeListener(this); } @Override public void onProgressChanged(SeekBar arg0, int arg1, boolean arg2) { boxcolor.setBackgroundColor(Color.rgb(sbarred .getProgress(), sbargreen.getProgress(), sbarblue.getProgress())); 138
- 139. Luciano Alves daSilva } @Override public void onStartTrackingTouch(SeekBar arg0) { // TODO Auto-generated method stub } @Override public void onStopTrackingTouch(SeekBar arg0) { // TODO Auto-generated method stub } } Agora vamos a explicação de alguns trechos de código acima. Observe a linha abaixo: public class AppRGBColor extends Activity implements SeekBar.OnSeekBarChangeListener Observem acima que na declaração da nossa classe, eu implemento a interface OnSeekChangeListener, pertencente ao componente SeekBar, que na verdade é um evento que é disparado toda vez que o valor de progresso da nossa SeekBar é alterado. Porque eu implementei isso na declaração da classe ao invés de definir isso para cada SeekBar ? A razão é muito simples, seria gasto muito código e todas as três SeekBars vão disparar, ou melhor, executar o mesmo trecho de código. A interface OnSeekBarChangeListener possui três métodos : onProgressChanged, onStartTrackingTouch e onStopTrackingTouch e todas elas precisam ser 139
- 140. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores implementadas, como foi feita no código, porém, o único método que será codificado será o onProgressChanged, que possui o seguinte código abaixo: boxcolor.setBackgroundColor(Color.rgb(sbarred.getPr ogress(),sbargreen.getProgress(), sbarblue.getProgress())); Vamos entender o código acima. O objeto boxcolor (que na verdade é uma TextView com o texto EM BRANCO), possui um método chamado setBackgroundColor, onde podemos definir a cor de fundo de objeto. Dentro do seu parâmetro invocamos o método rgb da classe Color, cuja finalidade é retornar um valor inteiro corresponde ao valor “rgb” passado no seu parâmetro. Observe que o método rbg possui três parâmetros onde cada um deles representa o valor de uma cor: a cor vermelha (red), a cor verde (green) e outra, a cor azul (blue). Execute a aplicação. O resultado você confere na figura abaixo: 140
- 141. Luciano Alves daSilva Aplicação de RGB em execução 4.22) A widget DatePicker O componente DatePicker funciona como se fosse um calendário onde especificamos ou consultamos uma determinada data. 4.23) Desenvolvendo uma aplicação de calendário Crie um novo projeto com os seguintes dados abaixo: Project Name: Calendario 141
- 142. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Package Name : br.com.appcalendario Create Activity: AppCalendario Application Name: Calendário Min SDK Version : 7 Depois de carregar o layout do arquivo “main.xml”, modifique o conteúdo da TextView com a frase : Selecione a data. Agora, insira os seguintes componentes na sequência: DatePicker Propriedade Valor Id @+id/data Layout_width fill_parent Button Propriedade Valor Id @+id/btdata Layout_width fill_parent Text Mostrar data Seguindo os passos acima, a aplicação deve estar de acordo com a figura abaixo: 142
- 143. Luciano Alves daSilva Layout da aplicação E por último, vá no arquivo “AppData.java” e coloque o seguinte código abaixo: package br.com.appcalendario; import android.app.Activity; import android.app.AlertDialog; import android.os.Bundle; import android.view.View; import android.widget.*; public class AppCalendario extends Activity { DatePicker dp; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); 143
- 144. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Button b = (Button) findViewById(R.id.btdata); dp = (DatePicker) findViewById(R.id.data); dp.updateDate(2009, 04, 23); b.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { AlertDialog.Builder dialogo = new AlertDialog.Builder(AppCalendario.this); dialogo.setMessage("Data selecionada : " + String.valueOf(dp.getDayOfMonth()) + "/" + String.valueOf(dp.getMonth() + 1) + "/" + String.valueOf(dp.getYear())); dialogo.setNeutralButton("OK", null); dialogo.setTitle("Data"); dialogo.show(); } }); } } Vamos executar a nossa aplicação. O resultado você vê na figura abaixo: 144
- 145. Luciano Alves daSilva Aplicação de calendário em execução 4.24) A widget TimePicker O componente TimePicker funciona como se fosse um DatePicker ,só que ao invés de trabalhar com datas, você trabalha com horas. 4.25) Desenvolvendo uma aplicação que faz uso do TimePicker Crie um novo projeto com os seguintes dados abaixo: Project Name: ExemploTimePicker Package Name : br.com.apptime Create Activity: AppTime Application Name: Exemplo com TimePicker 145
- 146. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Min SDK Version: 7 Agora carregue o arquivo de layout “main.xml” e modifique o conteúdo da TextView com a seguinte frase : “Selecione a hora:”. Agora, adicione os componentes na sequência: TimePicker Propriedade Valor Id @+id/hora Layout_width fill_parent Button Propriedade Valor Id @+id/btmostrar Layout_width fill_parent Text Mostrar hora Segundo os passos acima, a aplicação deve estar de acordo com o layout abaixo: 146
- 147. Luciano Alves daSilva Layout da aplicação E por último, vá no arquivo “AppTime.java” e coloque o seguinte código abaixo: package br.com.apptime; import android.app.Activity; import android.app.AlertDialog; import android.os.Bundle; import android.view.View; import android.widget.*; public class AppTime extends Activity { TimePicker tp; @Override 147
- 148. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button btmostrar = (Button) findViewById(R.id.btmostrar); tp = (TimePicker) findViewById(R.id.hora); btmostrar.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { AlertDialog.Builder dialogo = new AlertDialog.Builder(AppTime.this); dialogo.setMessage("Hora selecionada : " + String.valueOf(tp.getCurrentHour() + 1) + ":" + String.valueOf(tp.getCurrentMinute())); dialogo.setNeutralButton("OK", null); dialogo.setTitle("Hora"); dialogo.show(); } }); } } Vamos executar a nossa aplicação . O resultado você vê na figura abaixo: 148
- 149. Luciano Alves daSilva Aplicação que demonstra o uso do TimePicker em execução 4.26) A widget ToogleButton O componente ToogleButton é como se fosse uma combinação do componente Button com o componente CheckBox. Toda vez que clicamos no botão para marcá-lo ou desmarca-lo, o texto dele muda indicando essa mudança. 4.27) Desenvolvendo uma aplicação que faz uso do ToogleButton Project Name: ExemploToogleButton Package Name : br.com.apptooglebutton Create Activity: AppToogleButton Application Name: Exemplo com ToogleButton 149
- 150. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Min SDK Version: 7 Bom, depois de criar o projeto carregue o arquivo “main.xml” e apague o componente TextView. Em seguida, coloque o componente ToogleButton (que se encontra na seção “Form Widgets”) na tela do dispositivo somente um. Seguindo esse passo, o layout deve estar de acordo com a figura abaixo: Layout da aplicação Se você observar, automaticamente o texto que esta no ToogleButton é “OFF”, ele coloca esse texto automaticamente. Agora vamos mudar as seguintes propriedades abaixo: Propriedade Valor Text off apagado Text on aceso 150
- 151. Luciano Alves daSilva Bom, vou explicar as propriedades acima. A propriedade “Text off” serve para definirmos um texto que irá apaecer quando o botão estiver desmarcado e a propriedade “Text on” serve para o definirmos um texto que irá aparecer quando o botão estiver marcado. Execute a aplicação e veja os resultados, conforme demonstra a figura abaixo: Aplicação em execução (ToogleButton desmarcado) Aplicação em execução (ToogleButton marcado) 151
- 152. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 4.28) A widget Chronometer Este componente foi baseado no TextView e funciona como um cronômetro, onde podemos fazer um controle de tempo. 4.29) Desenvolvendo um cronômetro digital Para demonstrar o uso deste componente, vamos construir um cronômetro digital com algumas operações básicas. Crie um novo projeto com os seguintes dados abaixo: Project Name: CronometroDigital Package Name : br.com.appcronometro Create Activity: AppCronometro Application Name: Cronômetro Digital Min SDK Version: 7 Bom, depois de criar o projeto carregue o arquivo “main.xml” e apague o componente TextView. Em seguida , adicione o componente abaixo: Chronometer Propriedade Valor Id @+id/cronometro Format Tempo decorrido (%s) 152
- 153. Luciano Alves daSilva Vamos analisar a propriedade Format. Essa propriedade funciona como se fosse a propriedade Text (do componente TextView) mas, com uma formatação pra tempo. Quando você colocou o componente na tela, ele mostrou o valor “’’00” (que durante a execução do Android, será substituído pelo tempo decorrido no formato “mm:ss”). Observe que quando digitamos o valor acima na propriedade , o “%s” foi substituído pelo “’’00”, que equivale ao tempo decorrido. Agora adicione os seguintes componente na sequência: Button Propriedade Valor Id @+id/btiniciar Layout_width fill_parent Text Iniciar Button Propriedade Valor Id @+id/btpausa Layout_width fill_parent Text Pausa Button Propriedade Valor Id @+id/btparar Layout_width fill_parent Text Parar 153
- 154. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: Layout da aplicação Bom, agora vamos codificar o arquivo “AppCronometro.java”, com o seguinte código abaixo: package br.com.appcronometro; import android.app.Activity; import android.os.Bundle; import android.os.SystemClock; import android.widget.*; import android.view.*; public class AppCronometro extends Activity { /** Called when the activity is first created. */ Chronometer cronometro; Button btiniciar, btpausa, btparar; boolean deuStop; 154
- 155. Luciano Alves daSilva @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); deuStop = true; cronometro = (Chronometer) findViewById(R.id.cronometro); btiniciar = (Button) findViewById(R.id.btiniciar); btpausa = (Button) findViewById(R.id.btpausa); btparar = (Button) findViewById(R.id.btparar); btiniciar.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { if(deuStop) cronometro.setBase(SystemClock. elapsedRealtime()); cronometro.start(); } }); btpausa.setOnClickListener(new View.OnClickListener() { 155
- 156. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores @Override public void onClick(View arg0) { deuStop = false; cronometro.stop(); } }); btparar.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { deuStop = true; cronometro.stop(); cronometro.setText("Tempo decorrido (00:00)"); } }); } } Vamos analisar alguns trechos de código do programa, principalmente os eventos dos botões. Vamos no evento do botão “iniciar”, conforme mostro abaixo: public void onClick(View arg0) { if(deuStop) cronometro.setBase(SystemClock.elapsedRealtime()); 156
- 157. Luciano Alves daSilva cronometro.start(); } Quando eu pressiono o botão “iniciar”, a primeira coisa que faço é verificar se a variável deuStop assume o valor true (ou seja, indicando que o botão stop foi pressionado), caso verdadeiro, executo o método “setBase”, com o argumento “SystemClock.elapsedRealTime()”, cujo objetivo é zerar o tempo do cronômetro. Em seguida disparo o cronômetro com o método “start”. Agora vamos dentro do botão “pausa”, como mostro abaixo: public void onClick(View arg0) { deuStop = false; cronometro.stop(); } Quando eu pressiono o botão pausa, a variável deuStop assume o valor false e em seguida, disparo o método “stop”. Agora vamos dentro do botão “parar”, conforme mostro abaixo: public void onClick(View arg0) { deuStop = true; cronometro.stop(); cronometro.setText("Tempo decorrido (00:00)"); 157
- 158. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores } Quando eu pressiono o botão “parar”, a variável deuStop assume o valor “true". Em seguida, disparo o método “stop” e depois, altero o rótulo do cronômetro utilizando o método setText. Porque utilizo o método setText e não o setFormat ? Pelo seguinte motivo : Quando o tempo é disparado ele irá buscar o conteúdo da propriedade “Format” , cujo objetivo é mostrar de formato personalizado o tempo, desde que haja a string “%s”. Se nos usássemos o método setFormat, nunca iríamos ver o tempo de forma correta. Por isso utilizei o método setText, que também modifica o conteúdo exibido pelo componente. Execute a aplicação e veja o resultado: Aplicação de cronômetro digital em execução 4.30) A widget AnalogClock O componente AnalogClock mostra um relógio analógico comum com dois ponteiros : um pra minutos e outro para segundos. O objetivo desde componente é mostrar hora corrente do sistema, nada mais. 158
- 159. Luciano Alves daSilva 4.31) Desenvolvendo uma aplicação que mostra a hora corrente do sistema. Crie um projeto com os seguintes dados abaixo: Project Name: HoraDoSistema Package Name : br.com.appanalogclock Create Activity: AppHora Application Name: Hora do Sistema (AnalogClock) Min SDK Version : 7 Depois de criado o projeto carregue o arquivo “main.xml”, e em seguida selecione o componente TextView na tela do dispositivo e mude as seguintes propriedades: Propriedade Valor Text size 24sp Text color #ffffff Text Hora certa Gravity center Layout_width fill_parent Agora adicione o componente abaixo: 159
- 160. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores AnalogClock Propriedade Valor Layout_width fill_parent Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: Layout da aplicação Execute a aplicação e veja o resultado, conforme demonstra a figura abaixo: Aplicação em execução 160
- 161. Luciano Alves daSilva 4.30) A widget DigitalClock O componente DigitalClock foi baseado no componente TextView, e possui a mesma finalidade do componente AnalogClock, mostrar à hora corrente do sistema porém, no formato digital, nada mais. 4.31) Desenvolvendo uma aplicação que mostra a hora corrente do sistema. Crie um projeto com os seguintes dados abaixo: Project Name: HoraDoSistema2 Package Name : br.com.appdigitalclock Create Activity: AppHora Application Name: Hora do sistema (DigitalClock) Min SDK Version : 7 Depois de criado o projeto carregue o arquivo “main.xml”, e em seguida selecione o componente TextView na tela do dispositivo e mude as seguintes propriedades: Propriedade Valor Text size 24sp Text color #ffffff 161
- 162. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Text Hora certa Gravity center Layout_width fill_parent Agora, adicione o componente abaixo: DigitalClock Propriedade Valor Text size 24sp Text color #ffff00 Gravity center Layout_width fill_parent Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: Layout da aplicação Execute a aplicação e veja o resultado. Aplicação em execução 162
- 163. Luciano Alves daSilva 4.32) A widget ZoomControls A widget ZoomControls consiste naqueles dois botões de ZOOM, um para maximizar e outro para minimizar o zoom. 4.33) Desenvolvendo um programa que aplica zoom em Imagens Crie um novo projeto com os seguintes dados abaixo: Project Name: ZoomImagens Package Name : br.com.appzoom Create Activity: AppZoom Application Name: Zoom em imagens Min SDK Version: 7 Após criado o projeto, vamos adicionar uma imagem qualquer na pasta “drawable-mdpi”, que será utilizado na nossa aplicação (neste projeto, utilizei uma imagem chamada android.jpg). Depois de adicionar uma imagem no projeto, carregue o arquivo “main.xml”, e em seguida selecione o componente TextView e faça as seguintes modificações: Propriedade Valor 163
- 164. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Text size 24sp Text color #ffff00 Text Zoom com Imagens Gravity center Layout_width fill_parent Em seguida, dentro da estrutura LinearLayout principal, vamos adicionar uma nova estrutura LinearLayout e em seguida, modifique as seguintes propriedades abaixo: LinearLayout Propriedade Valor Id @+id/layoutImagem Gravity center Layout_width fill_parent Layout Height 250px Agora dentro da estrutura LinearLayout que acabamos de configurar acima (layoutImagem), adicione um componente ImageView e faça as seguintes modificações: ImageView Propriedade Valor Id @+id/imagem Scale type fitXY Src @drawable/android Layout_width 100px Layout Height 100px 164
- 165. Luciano Alves daSilva Bom, agora vou explicar a propriedade “Scale type” do componente ImageView. Como vamos trabalhar com zoom na imagem, é preciso que ao aplicarmos o zoom, a imagem se estique dentro da proporção do zoom. Para isso, defini o valor “fitXY” que permite esticar a imagem quando ela for redimensionada. Agora dentro da estrutura LinearLayout principal, vamos adicionar o componente ZoomControls (que se encontra na guia “Advanced”) e em seguida fazer as seguintes modificações: Propriedade Valor Id @+id/zoom Gravity center Layout_width Fill_parent Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: 165
- 166. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout da aplicação Agora vamos codificar o arquivo “AppZoom.java” com o seguinte código abaixo: package br.com.appzoom; import android.app.Activity; import android.os.Bundle; import android.view.*; import android.widget.*; public class AppZoom extends Activity { /** Called when the activity is first created. */ ZoomControls zoom; ImageView imagem; int sizeX=100, sizeY=100; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); zoom = (ZoomControls) findViewById(R.id.zoom); imagem = (ImageView) findViewById(R.id.imagem); zoom.setOnZoomInClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { // TODO Auto-generated method stub sizeX+=10; sizeY+=10; 166
- 167. Luciano Alves daSilva imagem.setLayoutParams(new LinearLayout.LayoutParams(sizeX, sizeY)); } }) ; zoom.setOnZoomOutClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { // TODO Auto-generated method stub sizeX-=10; sizeY-=10; imagem.setLayoutParams(new LinearLayout.LayoutParams(sizeX, sizeY)); } }) ; } } Agora vamos analisar alguns trechos do código. Observe que nesse programa em defino dois eventos para o componente ZoomControls, um evento que será disparado quando o botão “Zoom In” for pressionado , através do método setOnZoomInClickListener e um outro que será disparado quando o botão “Zoom Out” for pressionado , através do método setOnZoomOutClickListener. Agora vamos ver o código do evento OnZoomInClickListener : 167
- 168. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores public void onClick(View arg0) { // TODO Auto-generated method stub sizeX+=10; sizeY+=10; imagem.setLayoutParams(new LinearLayout.LayoutParams(sizeX, sizeY)); } Observe que dentro desse método, incremento o valor das variáveis sizeX e sizeY com “10” onde essas variáveis correspondem respectivamente a largura e a altura da imagem (em pixels). Na instrução abaixo: imagem.setLayoutParams(new LinearLayout.LayoutParams(sizeX, sizeY)); Redimensiono a imagem de acordo com os valores das variáveis, através do método setLayoutParams. Como argumento para este método, criei a instancia de LinearLayout e em seguida, disparei o LayoutParams passando como argumento, as variáveis que representam a largura e a altura da imagem. O código do evento OnZoomOutClickListener é similar ao do evento acima. Execute a aplicação e veja seu resultado: 168
- 169. Luciano Alves daSilva Aplicação em execução Até aqui, com o que já foi visto até agora, você já é capaz de desenvolver aplicações em Android. Vamos agora nos próximos tópicos nos aprofundar um pouco nos recursos existentes no Android. 169
- 170. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 5) Mudando de layouts A té 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 TrocaDeLayouts, conforme os dados abaixo: Project Name: TrocaDeLayouts Package Name : br.com.applayout Create Activity: AppLayout Application Name: Mudando de layouts Min SDK Version: 7 Carregue o arquivo de layout “main.xml” e modifique o conteúdo da TextView, com a seguinte frase : “Você está na tela principal”. Agora adicione um Button e modifique as seguintes propriedades: Button Propriedade Valor Id @+id/bttela2 Layout width fill_parent Text Ir pata tela 2 170
- 171. Luciano Alves daSilva Seguindo os passos acima, a aplicação deve estar de acordo com a figura abaixo: Layout da tela 1 Ótimo! Agora vamos criar um novo arquivo chamado “tela2.xml”, que vai estar também dentro da pasta “layout”. Siga os passos abaixo: Clique com o botão direito sobre a pasta “layout” e selecione a opção “New/Android XML File”, conforme mostra a figura abaixo: Criando um arquivo 171
- 172. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Agora no campo “File” digite “tela2”, conforme figura abaixo e logo depois, clique em “Finish”. Definindo o nome do arquivo Ao carreguar o arquivo “tela2.xml”, será mostrado a seguinte tela abaixo: 172
- 173. Luciano Alves daSilva Tela de layout em branco Vamos ajustar a visualização do nosso layout, selecionando para “3.2in HVGA slider (ADP1)”. Em seguida mude o valor da propriedade do layout principal da tela da aplicação, conforme é mostrado abaixo: LinearLayout Propriedade Valor Orientation vertical Logo em seguida adicione os seguintes componentes, na sequência: 173
- 174. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores TextView Propriedade Valor Text Você está na tela 2 Button Propriedade Valor Id @+id/bttelaprincipal Layout width fill_parent Text Ir pata tela principal Seguindo os passos acima, o layout do arquivo “tela2.xml” deve estar de acordo com a figura abaixo: Layout da tela 2 174
- 175. Luciano Alves daSilva Depois disso, modifique o arquivo “AppLayout.java”, conforme o código abaixo: package br.com.applayout; import android.app.Activity; import android.os.Bundle; import android.view.*; import android.widget.*; public class AppLayout extends Activity { public void CarregaTelaPrincipal() { setContentView(R.layout.main); Button bttela2 = (Button) findViewById(R.id.bttela2); bttela2.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { CarregaTela2(); } }); } public void CarregaTela2() { setContentView(R.layout.tela2); Button bttelaprincipal = (Button) findViewById(R.id.bttelaprincipal); 175
- 176. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores bttelaprincipal.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0) { CarregaTelaPrincipal(); } }); } @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); CarregaTelaPrincipal(); } } 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: 176
- 177. Luciano Alves daSilva Aplicação em execução (no layout principal) Aplicação em execução (no segundo layout) 5.1) Desenvolvendo uma aplicação de cadastro Agora 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. 177
- 178. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 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 sequência, e acessados em sequê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: AplicacaoDeCadastro Package Name : br.com.appcadastro Create Activity: AppCadastro Application Name: Aplicação de Cadastro Min SDK Version: 7 Dentro da pasta “res/drawable-mdpi”, coloque uma figura , que que represente o ícone da nossa aplicação. Para esta aplicação utilizei uma imagem de extensão PNG chamada “profile.png”. 178
- 179. Luciano Alves daSilva Agora carregue o arquivo “main.xml” e APAGUE a TextView que se encontra na tela do layout do dispositivo. Em seguida, coloque os seguintes componentes, na sequência: ImageView Propriedade Valor Src @drawable/profile TextView Propriedade Valor Bem vindo a Aplicação de Cadastro de Pessoas.Este é Text um pequeno programa de demonstração de cadastro.Selecione uma das opções abaixo: Button Propriedade Valor Id @+principal/btcadastrarpessoas Layout_width fill_parent Text Cadastrar pessoa 179
- 180. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Button Propriedade Valor Id @+principal/btlistarpessoas Layout_width fill_parent Text Listar pessoas cadastradas Seguindo os passos acima, a aplicação deve estar de acordo com a figura abaixo: Layout da tela principal da aplicação Agora vamos criar um arquivo chamado “cadastro.xml” e vamos coloca-lo dentro da pasta “res/layout” do nosso projeto. 180
- 181. Luciano Alves daSilva No início o arquivo estará somente com a estrutura de layout da tela, mude a propriedade desse layout, conforme é mostrado abaixo: LinearLayout Propriedade Valor Orientation vertical Em seguida coloque os seguintes componentes na sequencia: ImageView Propriedade Valor Src @drawable/profile TextView Propriedade Valor Text Módulo de cadastro.Digite seus dados abaixo: TextView Propriedade Valor Text Nome: 181
- 182. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores EditText Propriedade Valor Id @+cadastro/ednome Layout_width fill_parent Text TextView Propriedade Valor Text Profissão: EditText Propriedade Valor Id @+cadastro/edprofissao Layout_width fill_parent Text TextView Propriedade Valor Text Idade: EditText Propriedade Valor Id @+cadastro/edidade Layout_width fill_parent Text 182
- 183. Luciano Alves daSilva Seguindo os passos acima, a aplicação deve estar de acordo com a figura seguinte: Layout da tela de cadastro Bom, ainda não acabou. Agora vamos adicionar uma estrutura LinearLayout que será responsável por organizar os botões de forma horizontal logo após a EditText que representa o campo “idade”. Após adicionar essa estrutura ela vai estar nomeada de linearLayout2 e em seguida, modifique a seguintes propriedades dela, conforme abaixo: Propriedade Valor Orientation horizontal Layout fill_parent Gravity center 183
- 184. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores A propriedade “Gravity” , similar a propriedade “Orientation”, determina o alinhamento dos componentes dentro da estrutura, que no caso acima está alinhando os componentes de forma centralizada, ou seja, os componentes vão estar dispostos de forma horizontal (um ao lado do outro) e todos esses componentes estarão alinhados de forma centralizada. Seguindo o mesmo procedimento acima, vamos adicionar dois Buttons dentro dessa estrutura, e mude as seguintes propriedades citadas abaixo. Button Propriedade Valor Id @+cadastro/btcadastrar Text Cadastrar pessoa Button Propriedade Valor Id @+cadastro/btcancelar Text Cancelar Seguindo os passos acima, o Layout de nossa aplicação deve estar de acordo com a figura abaixo: 184
- 185. Luciano Alves daSilva Layout da tela de cadastro Agora dentro da pasta “res/layout” vamos criar um arquivo chamado “listacadastrados.xml” que será responsável por mostrar todos usuários devidamente cadastrados. No início o arquivo estará somente com a estrutura de layout da tela, mude a propriedade desse layout, conforme é mostrado abaixo: LinearLayout Propriedade Valor Orientation vertical Em seguida coloque os seguintes componentes, na sequência: 185
- 186. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores ImageView Propriedade Valor Src @drawable/profile TextView Propriedade Valor Text Lista de pessoas cadastradas. Text color #ffffff Text size 20sp Se você observar acima, estou trabalhando com duas propriedades pertencentes também ao componente TextView, uma chamada “Text color”, responsável por definir a cor do texto que neste caso, o valor da cor precisa estar no formato hexadecimal precedido do símbolo # ,e “Text size” responsável por definir o tamanho do texto. Seguindo os passos acima, o layout da aplicação deve estar de acordo com a figura abaixo: Layout da tela de listagem de cadastrados 186
- 187. Luciano Alves daSilva Bom, ainda não acabou. Se você observou damos um nome a nossa estrutura LinearLayout, nós a chamados de “layoutPrincipal”. Seguindo os procedimentos que já foram explicados, vamos adicionar dentro da estrutura “layoutPrincipal” uma nova estrutura LinearLayout dentro dela. Depois de adicionar vamos mudar as seguintes propriedades dela, conforme abaixo: LinearLayout Propriedade Valor Orientation Horizontal Id @+id/layoutNome Bom, agora dentro da estrutura “layoutNome” vamos adicionar os seguintes componentes na sequência: TextView Propriedade Valor Text Nome. Text color #ffff00 Text size 20sp TextView Propriedade Valor Text 187
- 188. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Text color #ffffff Text size 20sp Id @+lista/txtnome Bom agora dentro da estrutura “layoutPrincipal”, vamos adicionar uma nova estrutura LinearLayout, e em seguida modifique as seguintes propriedades abaixo: Propriedade Valor Orientation Horizontal Id @+id/layoutProfissao Bom, agora dentro da estrutura “layoutProfissao” vamos adicionar os seguintes componentes na sequência: TextView Propriedade Valor Text Profissão. Text color #ffff00 Text size 20sp TextView Propriedade Valor Text Text color #ffffff Text size 20sp Id @+lista/txtprofissao 188
- 189. Luciano Alves daSilva Agora dentro da estrutura “layoutPrincipal” vamos adicionar uma nova estrutura LinearLayout, e em seguida modifique as seguintes propriedades abaixo: Propriedade Valor Orientation Horizontal Id @+id/layoutIdade Bom, agora dentro da estrutura “layoutProfissao” vamos adicionar os seguintes componentes na sequência: TextView Propriedade Valor Text Idade. Text color #ffff00 Text size 20sp TextView Propriedade Valor Text Text color #ffffff Text size 20sp Id @+lista/txtidade Bom agora dentro da estrutura “layoutPrincipal”, vamos adicionar uma nova estrutura LinearLayout, como já foi mostrado acima. E depois, modifique as seguintes propriedades abaixo: 189
- 190. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Propriedade Valor Orientation Horizontal Id @+id/layoutBotoes Layout width fill_parent Gravity Center Bom, agora dentro da estrutura “layoutProfissao” vamos adicionar os seguintes componentes na sequência: Button Propriedade Valor Id @+lista/btvoltar Text Voltar Button Propriedade Valor Id @+lista/btavancar Text Avançar Agora vamos adicionar na estrutura “layoutPrincipal’ um Button com as seguintes propriedades abaixo: Button Propriedade Valor Id @+lista/btmenu Text Menu principal Layout width fill_parent 190
- 191. Luciano Alves daSilva Seguindo todos os passos acima, o layout da aplicação deve estar de acordo com a figura abaixo: Layout da tela de listagem de cadastrados Agora no arquivo “AppCadastro.java”, coloque o seguinte código: package br.com.appcadastro; import android.app.Activity; import android.os.Bundle; import android.widget.*; import android.view.*; import android.app.*; public class AppCadastro extends Activity { 191
- 192. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Registro pri,reg,ult,aux; EditText ednome,edprof,edidade; int numreg,pos; void CarregaTelaPrincipal () { setContentView(R.layout.main); Button btcadpess = (Button) findViewById(R.principal.btcadastrarpessoa); Button btlistapess = (Button) findViewById(R.principal.btlistarpessoas); btcadpess.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaTelaCadastro(); }}); btlistapess.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaListaPessoas(); }}); 192
- 193. Luciano Alves daSilva } void CarregaTelaCadastro() { setContentView(R.layout.cadastro); Button btcadastrar = (Button) findViewById(R.cadastro.btcadastrar); Button btcancelar = (Button) findViewById(R.cadastro.btcancelar); btcadastrar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ try { reg = new Registro(); ednome = (EditText)findViewById(R.cadastro.ednome); edprof = (EditText)findViewById(R.cadastro.edprofissao); edidade = (EditText)findViewById(R.cadastro.edidade); 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) 193
- 194. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores ult=reg; else { ult.Prox = reg; ult=reg; } numreg++; showMessage("Cadastro efetuado com sucesso", "Aviso"); CarregaTelaPrincipal(); } catch(Exception e) { showMessage("Erro ao cadastrar", "Erro"); }} }); btcancelar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaTelaPrincipal(); } }); } void CarregaListaPessoas() { if(numreg==0) { showMessage("Nenhum registro cadastrado", "Aviso"); CarregaTelaPrincipal(); return; 194
- 195. Luciano Alves daSilva } setContentView(R.layout.listacadastrados); pos=1; aux=pri; TextView txtnome = (TextView)findViewById(R.lista.txtnome); TextView txtidade = (TextView)findViewById(R.lista.txtidade); TextView txtprofissao = (TextView)findViewById(R.lista.txtprofissao); Button btmenu = (Button) findViewById(R.lista.btmenu); Button btavancar = (Button) findViewById(R.lista.btavancar); Button btvoltar = (Button) findViewById(R.lista.btvoltar); txtnome.setText(aux.nome); txtidade.setText(aux.idade); txtprofissao.setText(aux.profissao); btmenu.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaTelaPrincipal(); } }); btvoltar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ if(pos==1) return; 195
- 196. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores pos--; aux=aux.Ant; TextView txtnome = (TextView) findViewById(R.lista.txtnome); TextView txtidade = (TextView) findViewById(R.lista.txtidade); TextView txtprofissao = (TextView) findViewById(R.lista.txtprofissao); txtnome.setText(aux.nome); txtidade.setText(aux.idade); txtprofissao.setText(aux.profissao); } }); btavancar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ if(pos==numreg) return; pos++; aux=aux.Prox; TextView txtnome = (TextView) findViewById(R.lista.txtnome); TextView txtidade = (TextView) findViewById(R.lista.txtidade); TextView txtprofissao = (TextView) findViewById(R.lista.txtprofissao); txtnome.setText(aux.nome); txtidade.setText(aux.idade); txtprofissao.setText(aux.profissao); } }); 196
- 197. Luciano Alves daSilva } public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); numreg=0; pri=ult=null; CarregaTelaPrincipal(); } public void showMessage(String Caption,String Title) { AlertDialog.Builder dialogo = new AlertDialog.Builder(AppCadastro.this); dialogo.setTitle(Title); dialogo.setMessage(Caption); dialogo.setNeutralButton("OK", null); dialogo.show(); } } Agora no mesmo local onde se encontra o arquivo “AppCadastro.java” (no pacote “br.com.appcadastro”), você vai criar uma classe chamada Registro. Depois de criar a classe, coloque o código que é exibido abaixo: package br.com.appcadastro; public class Registro { 197
- 198. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 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. É 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 Registro e atribui a “variável objeto” reg. As linhas: 198
- 199. Luciano Alves daSilva 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: txtnome.setText(aux.nome); txtidade.setText(aux.idade); txtprofissao.setText(aux.profissao); 199
- 200. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 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 btvoltar. 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. Já no evento click do botão btavancar, 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. Bom, vamos executar a nossa aplicação ? O resultado você confere nas figuras seguintes: 200
- 201. Luciano Alves daSilva Aplicação em execução – Tela principal Aplicação em execução – Tela de cadastro 201
- 202. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Aplicação em execução – Tela de listagem dos cadastrados 202
- 203. Luciano Alves daSilva 6) Trabalhando com mais de uma Activity (Atividade) C omo vimos no tópico anterior, aprendemos a utilizar mais de um layout (tela) em uma aplicação. Agora iremos ver como trabalhar com mais de uma Activity (Atividade) dentro de uma aplicação Android. Bom, vamos construir a nossa aplicação. Crie um novo projeto com os dados abaixo: Project Name: TrocaDeAtividades Package Name : br.com.appactivity Create Activity: AppActivity1 Application Name: Troca de atividades Min SDK Version: 7 Bom, carregue o arquivo “main.xml” e em seguida selecione a TextView e mude o valor da propriedade Text com a seguinte frase : “Você está executando a Activity 1”. Em seguida insira um Button e mude as seguintes propriedades abaixo: Propriedade Valor Id @+lista/btchamaractivity2 Text Chamar Activity2 Layout width fill_parent 203
- 204. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: Layout da tela para a Activity1 Dentro da pasta “layout”, vamos criar um segundo arquivo chamado “tela2.xml”. Depois de criar o arquivo mude a propriedade desse layout, conforme é mostrado abaixo: LinearLayout Propriedade Valor Orientation vertical Depois disso, insira os seguintes componentes na sequência: 204
- 205. Luciano Alves daSilva TextView Propriedade Valor Text Você está executando a Activity 2 Button Propriedade Valor Id @+id/btchamaractivity1 Text Chamar Activity1 Layout width fill_parent Seguindo os passos acima, a tela da nossa aplicação deve estar de acordo com a figura abaixo: Layout da tela para a Activity2 Agora vamos no arquivo “AppActivity1.java” e vamos inserir o seguinte código abaixo: 205
- 206. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores package br.com.appactivity; import android.app.Activity; import android.content.*; import android.os.Bundle; import android.widget.*; import android.view.*; public class AppActivity1 extends Activity { /** Called when the activity is first created. */ Button btchamaractivity2; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); btchamaractivity2 = (Button) findViewById(R.id.btchamaractivity2); btchamaractivity2.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { Intent atividade = new Intent(AppActivity1.this,AppActivity2.class); AppActivity1.this.startActivity(atividade); AppActivity1.this.finish(); } }); } } Bom, vamos analisar alguns trechos de código abaixo: 206
- 207. Luciano Alves daSilva Se você observar acima, dentro do evento OnClick, fazemos uso da classe Intent, ela é responsável por executar alguns serviços internos do Android inclusive também, responsável por chamar ou melhor, executar outras atividades (aplicações). Vamos ver a linha abaixo: Intent atividade = new Intent(AppActivity1.this,AppActivity2.class); Na linha acima eu crio uma instância da classe Intent e nela são passados dois parâmetros, um referente a atividade em execução (AppActivity1.this) e outro referente a aplicação que eu quero executar (AppActivity2.class). Na linha abaixo: AppActivity1.this.startActivity(atividade); Eu executo a minha atividade AppActivity2 pelo método startActivity, representado pela instância “atividade”. Em seguida, finalizo a minha atividade corrente pelo método finish, como demonstra a linha abaixo: AppActivity1.this.finish(); Agora no mesmo local onde se encontra o arquivo “AppActivity1.java” (no pacote “br.com.appactivity”), você vai criar uma classe chamada “AppActivity2”. Depois de criar a classe, coloque o código que é exibido abaixo: 207
- 208. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores package br.com.appactivity; import android.app.Activity; import android.content.*; import android.os.Bundle; import android.widget.*; import android.view.*; public class AppActivity2 extends Activity { /** Called when the activity is first created. */ Button btchamaractivity1; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.tela2); btchamaractivity1 = (Button) findViewById(R.id.btchamaractivity1); btchamaractivity1.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { // TODO Auto-generated method stub Intent atividade = new Intent(AppActivity2.this, AppActivity1.class); AppActivity2.this. startActivity(atividade); AppActivity2.this.finish(); } }); } } Bom, agora para finalizar a nossa aplicação vamos configurar o arquivo “AndroidManifest.xml”, dizendo a ele que nosso 208
- 209. Luciano Alves daSilva projeto vai utilizar mais de uma atividade. Dê um duplo clique no arquivo e em seguida clique na guia “AndroidManifest.xml” e insira o seguinte código logo após a tag </activity>. <activity android:name=".AppActivity2" android:label="@string/app_name"> </activity> Bom, depois disso já podemos rodar a nossa aplicação. Veja a figura abaixo: Aplicação em execução (Activity1) Aplicação em execução (Activity2) 209
- 210. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 7) Trabalhando com o componente TabWidget N o Android é possível desenvolvermos aplicações onde cada componente fica disponível em páginas (Tabs). Isso é conseguido através da estrutura TabWidget. Vamos desenvolver uma aplicação que faça uso dessa estrutura. Crie um novo projeto com os dados abaixo: Project Name: TabWidget Package Name : br.com.apptabwidget Create Activity: AppTabWidget Application Name: TabWidget Min SDK Version: 7 Agora siga os passos para a construção dessa aplicação. Primeiramente vamos criar um novo arquivo chamado “tela_activity1.xml” dentro do diretório “layout”. Depois de criado, insira uma TextView e modifique a sua propriedade Text com a seguinte frase: “Esta é a Activity1”. Seguido o que se foi pedido, o layout da tela deve estar de acordo com o da figura abaixo: 210
- 211. Luciano Alves daSilva Layout da tela da aplicação Agora vamos criar um novo arquivo chamado “tela_activity2.xml” dentro do diretório “layout”. Depois de criado, insira uma TextView e modifique a sua propriedade Text com a seguinte frase: “Esta é a Activity2”. Seguido o que se foi pedido, o layout da tela deve estar de acordo com o da figura abaixo: Layout da tela da aplicação Agora vamos criar um novo arquivo chamado “tela_activity3.xml” dentro do diretório “layout”. Depois de criado, insira uma TextView e modifique a sua propriedade Text com a seguinte frase: “Esta é a Activity3”. Seguido o que se foi pedido, o layout da tela deve estar de acordo com o da figura abaixo: 211
- 212. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout da tela da aplicação Bom carregue o arquivo “main.xml” e em seguida, clique na guia “main.xml” e substitua o código existente pelo código abaixo: <?xml version="1.0" encoding="utf-8"?> <TabHost xmlns:android="http://schemas.android.com/apk/res/a ndroid" android:id="@android:id/tabhost" android:layout_width="fill_parent" android:layout_height="fill_parent"> <LinearLayout android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:padding="5dp"> <TabWidget android:id="@android:id/tabs" android:layout_width="fill_parent" android:layout_height="wrap_content" /> <FrameLayout android:id="@android:id/tabcontent" android:layout_width="fill_parent" android:layout_height="fill_parent" android:padding="5dp" /> </LinearLayout> </TabHost> 212
- 213. Luciano Alves daSilva A estrutura acima é reponsável por suportar aplicações baseadas em páginas (Tabs). Depois de substituir o código, salve o arquivo. Bom agora vamos criar três classes (Atividades), cada uma correspondendo a uma tela de aplicação. Clique com o botão direito sobre o pacote “br.com.appwidget” e selecione “New/Class”. O nome da nossa primeira classe vai se chamar “Activity1”. Depois de criada a classe , coloque o código o seguinte, conforme mostra abaixo: package br.com.appwidget; import android.app.*; import android.os.*; public class Activity1 extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.tela_activity1); } } Seguindo os mesmos procedimentos acima, crie uma segunda classe chamada “Activity2”, e depois de criada , coloque o seguinte código abaixo: package br.com.appwidget; import android.app.*; import android.os.*; 213
- 214. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores public class Activity2 extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.tela_activity2); } } Repetindo os mesmos procedimentos, crie uma terceira classe chamada “Activity3”, e depois de criada , coloque o seguinte código abaixo: package br.com.appwidget; import android.app.*; import android.os.*; public class Activity3 extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.tela_activity3); } } Bom, agora vamos no arquivo “AppTabWidget.java” e vamos colocar o seguinte código abaixo: 214
- 215. Luciano Alves daSilva package br.com.apptabwidget; import android.app.*; import android.os.Bundle; import android.widget.*; public class AppTabWidget extends TabActivity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); TabHost tabHost = getTabHost(); TabHost.TabSpec spec; Intent intent; intent = new Intent().setClass(this, Activity1.class); spec = tabHost.newTabSpec("tab1"). setIndicator("TAB 1").setContent(intent); tabHost.addTab(spec); intent = new Intent().setClass(this, Activity2.class); spec = tabHost.newTabSpec("tab2"). setIndicator("TAB 2").setContent(intent); tabHost.addTab(spec); intent = new Intent().setClass(this, Activity3.class); 215
- 216. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores spec = tabHost.newTabSpec("tab3"). setIndicator("TAB 3").setContent(intent); tabHost.addTab(spec); tabHost.setCurrentTab(0); } } Agora vamos a explicação do código: Se você observar, agora não derivamos da classe Activity e sim da classe TabActivity. Essa classe é voltada para trabalhar com aplicações baseadas em páginas e possui alguns métodos similares ao da classe Activity como o método onCreate. Na linha abaixo: TabHost mTabHost = getTabHost(); Criamos um objeto do tipo TabHost que recebe como valor a instância retornada pelo método getTabHost. Na linha seguinte: TabHost.TabSpec spec; Crio um objeto do tipo TabSpec, que na verdade representa uma TAB a ser adicionada na estrutura TabHost. Na linha abaixo: Intent intent; 216
- 217. Luciano Alves daSilva Crio uma variável objeto do tipo Intent (classe responsável por executar algumas operações dentro do Android, conforme já foi explicado). Na linha seguinte: intent = new Intent().setClass(this, Activity1.class); Crio uma instância da classe Intent , disparando uma chamada para a Activity1, através do método setClass. Na linha seguinte: spec = tabHost.newTabSpec("tab1").setIndicator("TAB 1").setContent(intent); Crio uma nova TAB referenciando a “intent” que representa à Activity1. Na linha seguinte: tabHost.addTab(spec); Adiciono a página criada a estrutura . Os passos mostrados acima são os mesmos para a Activity2 e Activity3. Na linha abaixo: tabHost.setCurrentTab(0); Definimos a página corrente a ser exibida, que no caso será a primeira. Ainda não acabou, precisamos fazer agora uma última operação. Acabamos de criar três classes : Activity1, Activity2 e Activity3. Precisamos definir no “AndroidManifest.xml”, que acabamos de criar três classes que na verdade são Atividades (Activitys) a serem executadas pela aplicação Android. Para isso carregue o arquivo “AndroidManifest.xml” e em seguida, clique 217
- 218. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores na guia “AndroidManifest.xml” e dentro do seu código antes da tag </application>, insira o seguinte bloco de instruções abaixo: <activity android:name=".Activity1" android:label="@string/app_name"></activity> <activity android:name=".Activity2" android:label="@string/app_name"></activity> <activity android:name=".Activity3" android:label="@string/app_name"></activity> O código acima fará com que o Android reconheça as três classes criadas como Atividades. Agora sim podemos executar a nossa aplicação. Veja o resultado da execução na figura abaixo: Aplicação baseada em páginas em execução 218
- 219. Luciano Alves daSilva 8) Trabalhando com menus em uma aplicação T ambém em uma aplicação Android é possível adicionar menus em uma aplicação. Os menus são visualizados quando pressionamos o botão “Menu” do emulador. Vamos a um exemplo, crie um novo projeto com os seguintes dados abaixo: Project Name: ExemploMenus Package Name : br.com.appmenu Create Activity: AppMenu Application Name: Exemplo com menus Min SDK Version: 7 Carregue o arquivo “main.xml“ e modifique o conteúdo da TextView com a seguinte frase: “Clique no botão menu para ver as opções”. Seguindo o passo acima a aplicação deve estar de acordo com a figura abaixo: Seguindo o passo acima a aplicação deve estar de acordo com a figura abaixo: 219
- 220. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout da tela de aplicação No arquivo “AppMenu.java”, coloque o seguinte código abaixo: package br.com.appmenu; import android.app.Activity; import android.os.Bundle; import android.view.*; public class AppMenu extends Activity { private static final int GRAVAR = Menu.FIRST; private static final int EDITAR = Menu.FIRST+1; private static final int SAIR = Menu.FIRST+2; 220
- 221. Luciano Alves daSilva @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override public boolean onCreateOptionsMenu(Menu menu) { menu.add(0, GRAVAR, 0, "Gravar"); menu.add(0, EDITAR, 0, "Editar"); menu.add(0, SAIR, 0, "Sair"); return super.onCreateOptionsMenu(menu); } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case GRAVAR: //Executa algo return true; case EDITAR: //Executa algo return true; default: return super.onOptionsItemSelected(item); } } 221
- 222. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores } . Vamos à explicação do código. Nas linhas : private static final int GRAVAR = Menu.FIRST; private static final int EDITAR = Menu.FIRST+1; private static final int SAIR = Menu.FIRST+2; São criadas três constantes que descrevei a seguir. A constante “GRAVAR”, recebe o valor contido no campo “FIRST”, do objeto Menu , que normalmente é o valor “1”. Logo, as constantes “EDITAR” e ”SAIR” recebem, respectivamente os valores 2 e 3. Agora vamos analisar o método onCreateOptionsMenu. Esse método é responsável por criar os menus e adicioná-los à aplicação. Vamos analisar as instruções abaixo: menu.add(0, GRAVAR, 0, "Gravar"); menu.add(0, EDITAR, 0, "Editar"); menu.add(0, SAIR, 0, "Sair"); Elas são responsáveis por adicionar os menus “Gravar”,”Editar” e “Sair”. 222
- 223. Luciano Alves daSilva Toda vez que um item de menu é selecionado, o método onOptionsItemSelected é disparado. Vamos ver o código dele abaixo: @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case GRAVAR: //Executa algo return true; case EDITAR: //Executa algo return true; default: return super.onOptionsItemSelected(item); } } Vamos analisar o código desse método. Observe que na estrutura switch é avaliado o valor retornado pelo método getItemId(), do objeto “item”. Esse método retorna o “Id” do menu selecionado, que é representado pelas constantes, como pode ser observado na estrutura switch. Vamos executar a nossa aplicação. O resultado você vê na figura abaixo: 223
- 224. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Aplicação que demonstra do uso de menus em execução Também é possível adicionar sub-menus a um determinado menu. Vamos a um outro exemplo, agora utilizando os sub- menus. Vamos modificar todo o código do arquivo “AppMenu.java” , pelo novo código abaixo: package br.com.appmenu; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.MenuItem; import android.view.SubMenu; public class AppMenu extends Activity { private static final int ABRIR = Menu.FIRST; private static final int SALVAR = 224
- 225. Luciano Alves daSilva Menu.FIRST+1; private static final int FERRAMENTAS = Menu.FIRST+2; private static final int PERSONALIZAR = Menu.FIRST+3; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override public boolean onCreateOptionsMenu(Menu menu) { menu.add(0, ABRIR, 0, "Abrir"); menu.add(0, SALVAR, 0, "Salvar"); SubMenu outros = menu.addSubMenu("Outros"); outros.add(0, FERRAMENTAS, 0, "Ferramentas"); outros.add(0, PERSONALIZAR, 0, "Personalizar"); return super.onCreateOptionsMenu(menu); } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case ABRIR: //Executa algo return true; 225
- 226. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores case SALVAR: //Executa algo return true; case FERRAMENTAS: //Executa algo return true; case PERSONALIZAR: //Executa algo return true; default: return super.onOptionsItemSelected (item); } } } Vamos analisar as mudanças. Observe que nesse novo código eu criei quatro constantes, conforme mostra as instruções abaixo: private static final int ABRIR = Menu.FIRST; private static final int SALVAR = Menu.FIRST+1; private static final int FERRAMENTAS = Menu.FIRST+2; private static final int PERSONALIZAR = Menu.FIRST+3; Agora vamos ver as mudanças feitas no método onCreateOptionsMenu. Veja as instruções abaixo: menu.add(0, ABRIR, 0, "Abrir"); menu.add(0, SALVAR, 0, "Salvar"); 226
- 227. Luciano Alves daSilva SubMenu outros = menu.addSubMenu("Outros"); outros.add(0, FERRAMENTAS, 0, "Ferramentas"); outros.add(0, PERSONALIZAR, 0, "Personalizar"); Observando o código acima, são criados dois menus: Um menu chamado “Abrir” e um outro chamado “Salvar”. Depois de criar os dois menus eu crio logo em seguida um sub- menu , cujo rótulo é “Outros” e dentro desse sub-menu adiciono dois itens, um chamado “Ferramentas” e “Personalizar”. Vamos executar a nossa aplicação. O resultado você vê na figura abaixo: Aplicação que demonstra do uso de menus em execução 227
- 228. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Selecione a opção “Outros”, como mostra a figura acima, e será mostrado mais dois itens : “Ferramentas” e ”Personalizar”. Veja a figura abaixo: Usando submenus 228
- 229. Luciano Alves daSilva 9 ) Conhecendo as caixas de diálogo do Android N os já usamos, em alguns dos nossos programas anteriores, a classe AlertDialog responsável por mostrar as mensagens na tela do dispositivo. Mas agora vamos entender melhor essa classe e algumas outras, enfatizando aqui alguns métodos interessantes. 9.1) A classe AlertDialog Já trabalhamos com essa classe nos programas anteriores. Agora vamos conhecer alguns métodos existentes dessa classe: Métodos Descrição Neste método, você setIcon(int IconId) define um ícone para a sua caixa de diálogo. Neste método, você setMessage(CharSequence define a mensagem mensagem) que será exibida na caixa de diálogo. Neste método, você setTitle(CharSequence titulo) define o título que será exibido na caixa de diálogo. Neste método você define um botão setNeutralButton(CharSequence <rotulo do botão>, neutro (normalmente OnClickListener evento) rotulado com o título “OK”) e um evento, caso ele seja clicado. 229
- 230. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Neste método você define um botão setPositiveButton(CharSequence <rotulo do botão>, positivo DialogInterface.OnClickListener (normalmente evento) rotulado com o título “Sim” ou “Yes”) e um evento, caso ele seja clicado. Neste método você define um botão setNegativeButton(CharSequence <rotulo do botão>, negativo(normalmente DialogInterface.OnClickListener rotulado com o título evento) “Não” ou “No”) e um evento, caso ele seja clicado. Veja alguns exemplos abaixo: AlertDialog.Builder dialog = new AlertDialog.Builder(this); dialog.setMessage("Cadastro efetuado com sucesso."); dialog.setNeutralButton("OK", null); dialog.setTitle("Aviso"); dialog.show(); O resultado será : 230
- 231. Luciano Alves daSilva AlertDialog com o botão OK Outro Exemplo: AlertDialog.Builder dialog = new AlertDialog.Builder(this); dialog.setMessage("Deseja cadastrar esse registro ?"); dialog.setPositiveButton("Sim", new DialogInterface.OnClickListener(){ public void onClick(DialogInterface di, int arg) { //Executa algo se o botão "Sim" por pressionado } }); dialog.setNegativeButton("Não", new DialogInterface.OnClickListener(){ public void onClick(DialogInterface di, int arg) { //Executa algo se o botão "Não" por pressionado 231
- 232. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores } }); dialog.setTitle("Aviso"); dialog.show(); O resultado será : AlertDialog com botões SIM e NÃO Mais um exemplo : AlertDialog.Builder dialog = new AlertDialog.Builder(this); dialog.setMessage("Exemplo com ícone."); dialog.setNeutralButton("OK", null); dialog.setTitle("Ícone"); dialog.setIcon(R.drawable.icon); dialog.show(); O resultado será: 232
- 233. Luciano Alves daSilva AlertDialog com o botão OK e com ícone É possível também na classe AlertDialog.Builder trabalharmos com lista de itens (como no ListView) e também com opções (como no RadioButton). Vou demonstrar aqui como trabalhar com lista de itens. Veja o código abaixo: AlertDialog.Builder d = new AlertDialog.Builder(AppAlert.this); final String[] opcoes ={"Azul","Amarelo","Vermelho"}; d.setTitle("Escolha uma opção"); d.setItems(opcoes, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int item) { switch (item) { 233
- 234. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores case 0: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO AZUL case 1: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO AMARELO case 2: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO VERMELHO } } }); d.show(); Vamos analisar algumas linhas de código acima. Observe que criei uma constante de array de String chamada opcoes, com três valores, como é demonstrado abaixo: final String[] opcoes ={"Azul","Amarelo","Vermelho"}; Para criar a lista de itens na caixa de diálogo, foi preciso usar o método setItems que possui dois parâmetros :no primeiro, você passa o array de itens a serem selecionados ; no segundo você define um evento onClick, que será disparado toda vez que um determinado item for selecionado. Vamos analisar o evento onClick: public void onClick(DialogInterface dialog, int item) { switch (item) { case 0: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO AZUL case 1: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO AMARELO 234
- 235. Luciano Alves daSilva case 2: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO VERMELHO } } }); O método onClick possui dois parâmetros : o primeiro corresponde a instância da caixa de diálogo e o segundo parâmetro corresponde ao índice do item selecionado. Veja o resultado abaixo: AlertDialog com o lista de opções Agora vamos trabalhar com itens de opções , como no RadioButton. Veja o código abaixo: AlertDialog.Builder d = new AlertDialog.Builder(AppAlert.this); final String[] opcoes ={"Azul","Amarelo","Vermelho"}; 235
- 236. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores d.setTitle("Escolha uma opção"); d.setSingleChoiceItems(opcoes, -1, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int item) { switch (item) { case 0: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO AZUL case 1: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO AMARELO case 2: //EXECUTA OPERAÇÃO SE SELECIONOU A OPÇÃO VERMELHO } } }); d.show(); Bom, vamos analisar o código acima. Observe que para utilizar o recursos de itens de opção foi necessário usar o método setSingleChoiceItems, que possui três parâmetros : no primeiro, você passa o array de itens a serem selecionados ; no segundo, você define a opção que já será por default ao abrir a caixa de diálogo através do seu índice, neste caso definimos como -1 ou seja, nenhuma opção padrão será selecionada ; no terceiro você define um evento onClick, que será disparado toda vez que um determinado item for selecionado. O restante do código já foi explicado anteriormente. Veja o resultado na figura abaixo: 236
- 237. Luciano Alves daSilva AlertDialog com o lista RadioButons 9.2) A classe DatePickerDialog Se lembra daquele componente que nós trabalhamos o DatePicker ? Pois bem, ele também existe na sua forma de caixa de diálogo, o DatePickerDialog. Vamos ver uma demonstração do uso dessa caixa de diálogo. DatePickerDialog.OnDateSetListener mudarData = new DatePickerDialog.OnDateSetListener() { @Override public void onDateSet(DatePicker dialog, int year, int monthOfYear, int dayOfMonth) { //ESSE MÉTODO SEMPRE SERÁ EXECUTADO TODA VEZ QUE UMA DATA FOR SELECIONADA } }; DatePickerDialog dp = new DatePickerDialog(AppAlert.this,mudarData,2010,6,24) ; 237
- 238. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores dp.setTitle("Selecione a data"); dp.show(); Bom, vamos analisar o código acima. Observe que a primeira coisa que faço é criar uma instância da interface OnDateSetListener, que será representado pela variável mudarData. Nesta interface existe um método chamado onDateSet, que possui quatro parâmetros : no primeiro você tem a instância da caixa de diálogo , no segundo você tem o ano, no terceiro você tem o mês (não se esqueça daquele detalhe: primeiro mês número zero, segundo mês número um e assim por diante), e no quatro e ultimo parâmetros temos o dia do mês. Na linha abaixo: DatePickerDialog dp = new DatePickerDialog(AppAlert.this,mudarData,2010,6,24) ; Crio a instância do objeto DatePickerDialog. Esta classe possui 5 parâmetros : o primeiro faz referencia à atividade em execução ; o segundo faz referência a interface que será disparada quando a data for selecionada, que está sendo representada pela variável mudarData ; no terceiro parâmetro especificamos o ano no quarto o mês e no último, o dia. Veja o resultado abaixo: 238
- 239. Luciano Alves daSilva Exemplo usando DatePickerDialog 9.3) A classe TimePickerDialog Se lembra daquele componente que nós trabalhamos o TimePicker ? Pois bem, ele também existe na sua forma de caixa de diálogo, o TimePickerDialog. Vamos ver uma demonstração do uso dessa caixa de diálogo. TimePickerDialog.OnTimeSetListener mudarHora = new TimePickerDialog.OnTimeSetListener() { @Override public void onTimeSet(TimePicker view, int hourOfDay, int minute) { //ESTE MÉTODO SERÁ EXECUTADO QUANDO A HORA FOR SELECIONADA } }; 239
- 240. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores TimePickerDialog tp = new TimePickerDialog (AppAlert.this,mudarHora,10,10,false); tp.setTitle("Selecione a hora"); tp.show(); Bom, vamos analisar o código acima. Observe que a primeira coisa que faço é criar uma instância da interface OnTimeSetListener, que será representado pela variável mudarHora. Nesta interface existe um método chamado onTimeSet, que possui três parâmetros : no primeiro você tem a instância do objeto TimePicker ; no segundo parâmetro nós temos a hora e no terceiro parâmetro, nós temos os minutos. Na linha abaixo: TimePickerDialog tp = new TimePickerDialog (AppAlert.this,mudarHora,10,10,false); Crio a instância do objeto DatePickerDialog. Esta classe possui 5 parâmetrros : o primeiro faz referencia à atividade em execução ; o segundo faz referência a interface que será disparada quando a hora for selecionada, que está sendo representada pela variável mudarHora ; no terceiro parâmetro especificamos a hora ; no quarto especificamos o minuto e no último, especificamos se a hora será vista no formato 24 horas (true) ou não (false). Veja o resultado abaixo: 240
- 241. Luciano Alves daSilva Exemplo usando TimePickerDialog 9.4) A classe ProgressDialog Se lembra daquele componente que nós trabalhamos o ProgressBar ? Pois bem, ele também existe na sua forma de caixa de diálogo, o ProgressDialog. Vamos ver uma demonstração do uso dessa caixa de diálogo. ProgressDialog pd = new ProgressDialog(AppAlert.this); pd.setProgressStyle(ProgressDialog.STYLE_SPINNE R); pd.setTitle("Carregando..."); pd.setMessage("Carregando dados, aguarde..."); pd.show(); 241
- 242. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Vamos analisar as instruções acima. As linhas: ProgressDialog pd = new ProgressDialog(AppAlert.this); pd.setProgressStyle(ProgressDialog.STYLE_SPINNE R); Cria uma instância da classe ProgressDialog e em seguida especifica o estilo da progress bar, que neste caso é um estilo “Spinner”. As instruções seguintes já são conhecidas. Veja o resultado abaixo: Exemplo usando ProgressDialog Quando a ProgressDialog é exibida na tela , não existe um botão de “OK” para encerrar a sua exibição. Então, como fazemos para “sumir” ele da tela ? Existem duas formas : A primeira forma é pressionando a tela “ESC” , dando a entender que você quis cancelar um processo em andamento. A segunda forma é chamar o método “dismiss” da classe ProgressDialog. Como ? Considerando a variável pd do tipo ProgressDialog : pd.dismiss(); 242
- 243. Luciano Alves daSilva Este método é utilizado quando um determinado processo em andamento, indicado pela exibição da ProgressDialog na tela é finalizado. Vamos supor que uma mensagem desse tipo indica o download de um arquivo, após o termino do download, esse método deve ser chamado, fechando a caixa de diálogo, indicando fim do processo. Também é possível trabalharmos com uma barra de progresso no estilo horizontal. Veja uma demonstração abaixo: Declarando a seguintes variáveis abaixo como globais: ProgressDialog pd; Thread t; Handler h; int i; Agora dentro de um método qualquer: pd = new ProgressDialog(AppAlert.this); pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL ); pd.setTitle("Carregando..."); pd.setMessage("Carregando dados, aguarde..."); pd.setMax(100); pd.setProgress(0); pd.show(); 243
- 244. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores h = new Handler(); t = new Thread(new Runnable(){ @Override public void run() { while(i < 100){ try { i++; h.post(new Runnable(){ @Override public void run() { pd.setProgress(i); if(i==100) pd.dismiss(); } }); Thread.sleep(100); }catch(Exception e) { } } } }) ; t.start(); Veja o resultado dessa execução na figura abaixo: 244
- 245. Luciano Alves daSilva Exemplo usando ProgressDialog 9.5) Criando uma caixa de diálogo personalizada Acabamos de ver agora os diversos tipos de caixas de diálogo que o Android nos oferece. Agora, se eu quisesse criar uma caixa de diálogo minha personalizada como por exemplo, uma caixa de diálogo para o usuário preencher um campo com uma determinada informação. Pois bem, o Android também nos permite fazermos isso. Do mesmo jeito que utilizamos os arquivos XML para definirmos a tela da nossa aplicação, podemos utilizá-los para definir uma caixa de diálogo nossa personalizada. Para demonstrar esse exemplo, suponhamos um arquivo XML chamado “mensagem.xml”, com a estrutura principal configurada segundo os dados abaixo: LinearLayout Propriedade Valor Id @+id/mensagem Layout height fill_parent 245
- 246. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout width fill_parent Padding 10dp Orientation vertical Dentro da estrutura acima, vamos supor os seguintes componentes: TextView Propriedade Valor Text Digite o número da matricula EditText Propriedade Valor Id @+id/edmatricula Layout width fill_parent Text Button Propriedade Valor Id @+id/btok Layout width fill_parent Text OK 246
- 247. Luciano Alves daSilva Agora, em um método qualquer: Dialog d = new Dialog(AppAlert.this); d.setContentView(R.layout.mensagem); d.setTitle("Matricula"); d.show(); Exemplo de uma caixa de diálogo personalisada 247
- 248. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 10) Programação com internet em Android A qui nesta seção irei mostrar como fazer algumas aplicações em Android voltadas para a internet, envolvendo aqui programação com Sockets , envio e recebimento de dados para uma página Web, download de arquivos e etc. 10.1) Trabalhando com sockets em Android O que são sockets ou soquetes ? Os sockets são conexões de internet que são especificadas pelos protocolos TCP/IP, ou melhor, são endereços de nós e um número de porta, os quais identificam um serviço. Como funciona ? 1) Primeiro, o programa servidor começa a ser executado esperando por um pedido do cliente. 2) O programa cliente requisita uma conexão indicando o servidor com o qual quer se conectar. 3) Quando o cliente envia um pedido, o servidor pode “aceitar” a conexão, e inicia um “soquete” no lado servidor e dedica esse soquete para essa conexão cliente especifica. 248
- 249. Luciano Alves daSilva Todo computador ou dispositivo conectado a internet pode ser acessado qualquer outro computador ou dispositivo,e eles podem estar atuando como cliente (que requisita uma conexão) ou servidor (negando ou aceitando essa conexão). A idéia aqui e criar um cliente , que será uma aplicação em Android onde ela irá requisitar um serviço no servidor, que será uma aplicação em Java. A aplicação cliente será uma calculadora onde ela envia dois números para o servidor, que será responsável por retornar a soma dos dois números para o cliente. Existem duas classes Java utilizadas aqui para trabalhar com sockets que são ServerSocket (usada no lado servidor) e Socket (usada no lado cliente). 10.2) Desenvolvendo uma aplicação cliente em Android e um servidor Java. A classe ServerSocket é utilizada para “escutar” as conexões clientes que vem da rede. Bom, vamos criar uma aplicação “Servidor” para receber as requisições da aplicação cliente do Android. Vá no menu “File”/”New”/”Java Project” e será uma caixa de diálogo para a criação da projeto. No campo “Project Name” , digite “AplicacoesJava” e depois, clique no botão “Finish”. Expanda o item “AplicacoesJava” e selecione a pasta “src”, conforme a figura abaixo: Pasta “AplicacoesJava” expandida 249
- 250. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Agora vamos criar uma nova classe Java, indo no menu “File”/”New”/”Class”. No campo name digite “ServidorCalc” e marque a opção “public static void main(String arg[])”, conforme a figura abaixo: Criando uma nova classe Agora, adicione o código abaixo: import java.net.*; import java.io.*; public class ServidorCalc { 250
- 251. Luciano Alves daSilva public static void main(String[] args) { double num1,num2; try { ServerSocket ss = new ServerSocket(60); System.out.print("Aguardando conexao...nn"); Socket s = ss.accept(); System.out.print("Conexao aceita...nn"); DataInputStream in = new DataInputStream(s.getInputStream()); DataOutputStream out = new DataOutputStream(s.getOutputStream()); num1 = in.readDouble(); num2 = in.readDouble(); System.out.println(num1 + "+" + num2 + "=" + (num1 + num2)); out.writeDouble((num1 + num2)); in.close(); out.close(); s.close(); ss.close(); } catch (IOException e) { e.printStackTrace(); } } 251
- 252. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores } Vamos ao comentário de algumas linhas de código. A linha : ServerSocket ss = new ServerSocket(60); Cria uma instância na classe ServerSocket, passando como parâmetro do construtor, o número da porta pela qual, o socket irá escutar as conexões clientes, que será 60. A linha: Socket s = ss.accept(); Nesta linha acontece o seguinte, o objeto ss chama o método accept, que é responsável por aguardar uma conexão cliente que virá na porta 60. Enquanto nenhuma conexão vir, essa linha ficará “pendurada” , ou seja, ficará aguardando uma conexão cliente até que venha a conexão. Quando vier uma conexão, a referência do cliente será referência pela variável s, do tipo Socket. Nas instruções abaixo : DataInputStream in = new DataInputStream(s.getInputStream()); DataOutputStream out = new DataOutputStream(s.getOutputStream()); São criados dois objetos. O primeiro objeto se chama in, do tipo DataInputStream, que é uma classe responsável por receber dados que vem de uma conexão. O segundo objeto se chama out, do tipo DataOutputStream, que é uma classe responsável por enviar dados para uma conexão. 252
- 253. Luciano Alves daSilva Nas instruções : num1 = in.readDouble(); num2 = in.readDouble(); Ocorre o seguinte : as variáveis num1 e num2 recebem os números que são enviados pelo cliente, pelo método readDouble. A instrução: out.writeDouble((num1 + num2)); Envia para a aplicação cliente, a soma dos dois números, pelo método writeDouble. As instruções: in.close(); out.close(); s.close(); ss.close(); Fecha todas as conexões. Bom, agora salve o arquivo, mas não o execute. Iremos executar esse arquivo fora do eclipse. Quando salvamos um arquivo, se a sintaxe dele estiver correta, o eclipse “automaticamente” compila o arquivo. Agora vamos copiar esse executável para a unidade “C”. Onde esse executável se encontra ? quando executamos o eclipse pela primeira vez, ele pede um diretório para trabalho (workspace). Automaticamente ele já sugere um, 253
- 254. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores mas você pode mudá-lo. Provavelmente você deve ter feito uma dessas opções. Agora, você lembra qual é o diretório que você selecionou para workspace? Se você não se lembra, faça o seguinte : Vá no menu “File”/”Switch Workspace”/”Other...”, e será mostrada a caixa de diálogo abaixo: Definindo um workspace Agora se lembrou né ? Simplesmente cancele a caixa de diálogo mostrada na figura acima e vá no diretório especificado. Dentro do diretório “AplicacoesJava”, existe um diretório chamado “bin”, onde estão armazenados todos os executáveis do Java (arquivos “.class”). Agora, vá no “prompt” do comando e vamos executar essa classe.Como ? A minha classe se encontra no seguinte caminho: "F:LucianoProgramaçãoJavaAplicacoesJavabin" 254
- 255. Luciano Alves daSilva Quando eu for executar a minha, será assim: java –cp "F:LucianoProgramaçãoJavaAplicacoesJavabin" ServidorCalc Veja um exemplo na figura abaixo: Aplicação servidor em execução Você vai “minimizar” essa janela, deixando o servidor em execução. Agora vamos criar a nossa aplicação cliente em Android. Crie um novo projeto com os seguintes dados abaixo: Project Name: AndCliente Package Name : br.com.appcliente Create Activity: AppCliente 255
- 256. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Application Name: Cliente Min SDK Version : 7 Após criar o projeto, carregue o layout do arquivo “main.xml” e em seguida selecione o TextView já inserido na tela e modifique o conteúdo do texto para “Primeiro número”. Depois de fazer o que foi pedido acima, insira os seguintes componentes, na sequência: EditText Propriedade Valor Id @+id/txtnum1 Layout width fill_parent Text TextView Propriedade Valor Text Segundo número EditText Propriedade Valor Id @+id/txtnum2 Layout width fill_parent Text 256
- 257. Luciano Alves daSilva Button Propriedade Valor Id @+id/btsomar Layout width fill_parent Text Somar Depois de seguir os passos acima, a tela da nossa aplicação deverá estar de acordo com a figura abaixo: Layout da tela da aplicação Agora salve o arquivo para confirmar as alterações feitas. Agora, no arquivo “AppCliente.java”, coloque o seguinte código abaixo: 257
- 258. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores package br.com.appcliente; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.Socket; import java.net.UnknownHostException; import android.widget.*; import android.view.*; import android.app.Activity; import android.app.AlertDialog; import android.os.Bundle; public class AppCliente extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button btsomar = (Button) findViewById(R.id.btsomar); btsomar.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { try { Socket s = new Socket("10.0.2.2",60); DataInputStream in = new 258
- 259. Luciano Alves daSilva DataInputStream(s.getInputStream()); DataOutputStream out = new DataOutputStream(s.getOutputStream()); TextView txtnum1,txtnum2; txtnum1 = (TextView) findViewById(R.id.txtnum1); txtnum2 = (TextView) findViewById(R.id.txtnum2); out.writeDouble(Double.parseDouble( txtnum1.getText().toString())); out.writeDouble(Double.parseDouble( txtnum2.getText().toString())); AlertDialog.Builder d = new AlertDialog.Builder(AppCliente.this); d.setTitle("Soma"); d.setMessage("Soma:" + String.valueOf(in.readDouble())); d.setNeutralButton("OK", null); d.show(); in.close(); out.close(); s.close(); } catch (Exception e) { 259
- 260. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores e.printStackTrace(); } } }); } } Vamos a explicação de algumas partes de código desse programa. A linha: Socket s = new Socket("10.0.2.2",60); Cria uma instância da classe Socket, passando como parâmetros no construtor o endereço IP do nosso servidor e a porta pela qual nós iremos se comunicar. Espere, o endereço IP local normalmente não é 127.0.0.1 ou localhost? Sim, mas se passássemos como parâmetro o IP 127.0.0.1 ou localhost nós estaríamos se comunicando com o emulador e não com o computador que está com o servidor em execução. No Android, todo endereço IP local de um computador é referenciado pelo IP 10.0.2.2, que é um endereço local de rede. As instruções : out.writeDouble(Double.parseDouble( txtnum1.getText().toString())); out.writeDouble(Double.parseDouble( txtnum2.getText().toString())); 260
- 261. Luciano Alves daSilva Enviam para o servidor, os números a serem somados, pelo método writeDouble. A instrução : d.setMessage("Soma:" + String.valueOf(in.readDouble())); Chama o método readDouble, responsável por receber a soma enviada pelo servidor, convertendo-a para um tipo String, para que possa ser exibido na mensagem. Agora vamos fazer uma última modificação. Abra o arquivo “AndroidManifest.xml” e em seguida, clique na guia “AndroidManifest.xml” e antes da tag “</manifest>”, coloque a seguinte linha: <uses-permission android:name="android.permission.INTERNET" /> Para que isso ? Toda aplicação Android que por acaso venha a usar uma conexão internet ou local, é obrigado a ter essa linha, caso contrário, a aplicação não funcionará. Vamos executar a nossa aplicação. O resultado você vê na figura abaixo: 261
- 262. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Aplicação cliente Android em execução Experiente digitar dois números quaisquer e depois, clique no botão “Somar”. Será exibida uma mensagem com o valor da soma, como mostra um exemplo da figura abaixo: Aplicação cliente Android em execução 262
- 263. Luciano Alves daSilva Lembra-se que eu pedi para que você deixasse minimizado aquela janela de prompt , pela qual executamos o servidor ? Maximize-a e veja o que aconteceu, como mostra a figura abaixo: Aplicação servidor em execução: Resultado O servidor aceitou a conexão, recebeu os dois números e os enviou de volta para o cliente Android. 10.3) Obtendo conteúdo de uma URL Agora irei mostrar como desenvolver uma aplicação que obtém um conteúdo de uma determinada URL, que será especificada através da aplicação. Para que esse exemplo funcione, verifique as configurações do seu Firewall, caso contrário, essa aplicação não funcionará. Crie um novo projeto com os seguintes dados abaixo: 263
- 264. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Project Name: ObtendoConteudoURL Package Name : br.com.appcontent Create Activity: AppContent Min SDK Version: 7 Application Name: Obtendo conteúdo de uma URL Após criar o projeto, carregue o layout do arquivo “main.xml” e em seguida selecione o TextView já inserido na tela e modifique o conteúdo do texto para “Digite sua URL”. Depois de fazer o que foi pedido acima, insira os seguintes componentes, na sequência: EditText Propriedade Valor Id @+id/edurl Layout width fill_parent Text Button Propriedade Valor Id @+id/btmostrar Layout width fill_parent Text Mostrar 264
- 265. Luciano Alves daSilva Seguindo os passos acima, o layout da aplicação deve estar de acordo com a figura abaixo: Layout da tela da aplicação Agora, vá no arquivo “AppContent.java”, coloque o seguinte código abaixo: package br.com.appcontent; import android.app.Activity; import android.os.Bundle; import android.widget.*; import android.view.*; import android.app.*; import java.io.*; import java.net.*; public class AppContent extends Activity { 265
- 266. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores EditText edurl; Button btmostrar; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); edurl = (EditText) findViewById(R.id.edurl); btmostrar = (Button) findViewById(R.id.mostrar); btmostrar.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { try { String strurl = edurl.getText().toString(); URL url = new URL(strurl); InputStream is = url.openStream(); int i; String conteudo=""; while((i = is.read()) != -1) conteudo+= ((char)i); AlertDialog.Builder dialogo = new AlertDialog.Builder(AppContent.this); 266
- 267. Luciano Alves daSilva dialogo.setMessage(conteudo); dialogo.setTitle("Conteúdo"); dialogo.setNeutralButton("OK", null); dialogo.show(); }catch(Exception e) { } } }); } } Agora vamos analisar o programa. Nesse programa existe um EditText, através do qual irei digitar uma URL de minha escolha para obter o seu conteúdo (que pode ser de página Web ou um arquivo de texto simples) e um botão que será responsável por “obter” o conteúdo dessa URL. Vamos analisar o código do evento desse botão responsável por obter o conteúdo da URL. A linha: String strurl = edurl.getText().toString(); Cria uma variável do tipo String chamada strurl , que ira conter a URL digitada pelo usuário. A linha: URL url = new URL(strurl); 267
- 268. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Cria uma instância da classe URL, responsável por acessar uma determinada URL. Neste caso, a URL está contida dentro da variável strurl. A linha : InputStream is = url.openStream(); Retorna para a variável chamada is, do tipo InputStream, o fluxo obtido pela URL, através do método openStream. O código: while((i=is.read())!= -1) s+=(char) i; Joga para a variável s, do tipo String, o conteúdo da URL. Só para lembrar que para executar essa aplicação, não se esqueça da linha abaixo no arquivo “AndroidManifest.xml”: <uses-permission android:name="android.permission.INTERNET" /> Execuque a aplicação. Veja o resultado de sua execução abaixo: 268
- 269. Luciano Alves daSilva Aplicação em execução Como havia falado, você pode experimentar uma outra URL, porém, é muito provável páginas muito grandes faça com que a aplicação não responda ou talvez, você se depare com um erro de execução pois, um conteúdo muito grande de uma URL não seja talvez “comportado” pela caixa de diálogo (e também , pela variável s). 10.4) Enviando informações para uma página Web via URL Utilizando os mesmos conceitos do programa anterior, vamos construir uma aplicação Android que envia informações via URL para uma determinada página Web. Para esse exemplo, desenvolvi uma página PHP no meu site (MakeWare) para que ele possa receber os dados enviados por nossa aplicação. A aplicação consiste em um cadastro onde os 269
- 270. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores dados serão armazenados em uma página Web, e esses dados serão passados via URL para o site. Crie um novo projeto com os seguintes dados abaixo: Project Name: EnviandoDadosAndroid Package Name : br.com.appsend Create Activity : AppSend Application Name Enviando Dados Min SDK Version: 7 Após criar o projeto, carregue o layout do arquivo “main.xml” e em seguida selecione o TextView já inserido na tela e modifique o conteúdo do texto para “Nome:”. Em seguida coloque os seguintes componentes , na sequência: EditText Propriedade Valor Id @+id/ednome Layout width fill_parent Text TextView Propriedade Valor Text Idade: 270
- 271. Luciano Alves daSilva EditText Propriedade Valor Id @+id/edidade Layout width fill_parent Text Button Propriedade Valor Id @+id/btenviar Layout width fill_parent Text Enviar dados Seguido os passos acima, a tela da nossa aplicação deve estar de acordo com a figura abaixo: Layout da tela da aplicação Agora no arquivo “AppSend.java” coloque o seguinte código abaixo: 271
- 272. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores package br.com.appsend; import java.io.*; import java.net.*; import android.app.Activity; import android.app.AlertDialog; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.TextView; public class AppSend extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button b = (Button) findViewById(R.id.btenviar); b.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { TextView txtnome = (TextView) findViewById(R.id.nome); TextView txtidade = (TextView) findViewById(R.id.idade); 272
- 273. Luciano Alves daSilva String nome = txtnome.getText().toString(); String idade = txtidade.getText().toString(); //Substitui todos os caracteres especiais nome = URLEncoder.encode(nome); try { //Envia dados , via URL URL url = new URL("http://www.makeware.ueuo.com/cadastrar_dados.p hp?nome=" + nome + "&idade=" + idade); //Executa a requisição url.openStream(); AlertDialog.Builder d = new AlertDialog.Builder(AppSend.this); d.setMessage("Dados enviados com sucesso."); d.setNeutralButton("OK", null); d.setTitle("Resultado"); d.show(); }catch(Exception e) { AlertDialog.Builder d = new AlertDialog.Builder(AppSend.this); d.setMessage(e.toString()); d.setNeutralButton("OK", null); 273
- 274. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores d.setTitle("Erro"); d.show(); } } }); } } O código dessa aplicação é similar ao da aplicação anterior, então não há muitos comentários a ser fazer dessa aplicação porém,há algumas linhas de código que preciso explicar. Observe que passamos os parâmetros nome e idade para a URL certo ? A idade é um valor numérico simples , já o nome é um conjunto formado por vários caracteres comuns e especiais. Quando passamos parâmetros para uma URL, nessa URL não pode HAVER caracteres especiais , para isso fiz uso do método encode da classe URLEncoder, responsável por converter esses caracteres especiais em seus respectivos valores hexadecimais, que são aceitos pela URL, conforme mostro abaixo: nome = URLEncoder.encode(nome); Executar a aplicação. O resultado você confere na figura abaixo: 274
- 275. Luciano Alves daSilva Aplicação de envio de dados em execução 10.5) Enviando informações para uma página Web via POST (Usando a classe HttpPost) Desenvolvemos uma aplicação que enviava dados para o servidor, através de sua URL (Método GET). Agora vamos desenvolver um aplicação similar ao da aplicação anterior, só que agora, essa aplicação fará uso do método POST, conseguido através da classe HttpPost, do Android. 10.5.1) Diferenças entre GET e POST Para muitos programadores os métodos GET e POST são métodos que executam ações diferentes uma das outras, o que não é verdade. Os métodos GET e POST tem a mesma finalidade, que é o de enviar dados para uma página Web. A diferença está no “método de envio” deles. Vamos citá-los: 275
- 276. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores O método GET envia dados para o servidor utilizando como meio de trafego desses dados, a URL de onde se encontra o servidor. Por exemplo: quero enviar para meu servidor dois números para serem processados por uma página Web. Pelo faríamos assim: http://www.meuservidor.com/calculadora.php?numero=12&nu mero2=13 Observe que na URL acima, existe uma página que vai processar os números que quero mandar pra ela, no caso, a página “calculadora.php”. Observe que nessa página são passados dois parâmetros : “numero”, que recebe como valor 12 e “numero2”, que recebe como valor 13. Esses dois parâmetros são reconhecidos pela página “calculadora.php”, que fará o processamento deles. Uma das características do GET é que nesse método de envio, podemos “visualizar” os dados que são enviados para a pagina no servidor, o que , em algumas ocasiões, não é seguro. Vamos supor que você enviasse via GET dados de nome e senha, facilmente esses dados seriam de alguma forma, capturados e usados de forma indevida. Uma outra característica do método GET está relacionado à limitação de dados a serem enviados para uma página no servidor, pois, uma url suporta no máximo 2.000 caracteres. Por exemplo, vamos supor que eu construísse uma página de um fórum para que o usuário escrevesse seu tópico, com certeza, jamais conseguiria fazer isso usando o método de envio GET, pois páginas de fórum deste tipo, possuem mais de 2.000 caracteres para serem enviados e processados. 276
- 277. Luciano Alves daSilva Todas essas desvantagens do GET podem ser solucionadas através do uso do método de envio POST. Com o método POST, os dados enviados para uma página Web não são visualizados na URL do servidor, garantido assim que os dados não sejam capturados. E outra vantagem do POST é que você pode enviar dados sem limite de tamanho. 10.5.2) Desenvolvendo a aplicação Bom, vamos desenvolver agora a nossa aplicação. Crie um projeto Android com os seguintes dados abaixo: Project Name: EnviaDadosPost Package Name : br.com.appsendpost Create Activity: AppSendPost Application Name: Enviando dados Min SDK Version: 7 Após criar o projeto, carregue o layout do arquivo “main.xml” e em seguida selecione o TextView já inserido na tela e modifique o conteúdo do texto para “Nome:”. Em seguida coloque os seguintes componentes , na sequência: EditText 277
- 278. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Propriedade Valor Id @+id/ednome Layout width fill_parent Text TextView Propriedade Valor Text Idade: EditText Propriedade Valor Id @+id/edidade Layout width fill_parent Text Button Propriedade Valor Id @+id/btenviar Layout width fill_parent Text Enviar dados Seguido os passos acima, a tela da nossa aplicação deve estar de acordo com a figura abaixo: 278
- 279. Luciano Alves daSilva Layout da tela da aplicação Se vocês notaram, a tela da aplicação a similar ao da aplicação anterior que desenvolvemos. Agora no arquivo “AppSendPost.java”, coloque o seguinte código abaixo: package br.com.appsendpost; import java.io.*; import java.net.*; import java.util.ArrayList; import java.util.List; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.apache.http.client.HttpClient; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.message.BasicNameValuePair; import android.app.Activity; import android.app.AlertDialog; 279
- 280. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.TextView; public class AppSendPost extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button b = (Button) findViewById(R.id.btenviar); b.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { TextView txtnome = (TextView) findViewById(R.id.nome); TextView txtidade = (TextView) findViewById(R.id.idade); String nome = txtnome.getText().toString(); String idade = txtidade.getText().toString(); try { //Envia dados , via POST HttpClient httpclient = new DefaultHttpClient(); 280
- 281. Luciano Alves daSilva HttpPost httppost = new HttpPost("http://www.makeware.ueuo.com/cadastrar_da dos.php"); List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2); nameValuePairs.add(new BasicNameValuePair("nome",nome)); nameValuePairs.add(new BasicNameValuePair("idade",idade)); httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs)); httpclient.execute(httppost); AlertDialog.Builder d = new AlertDialog.Builder(AppSendPost.this); d.setMessage("Dados enviados com sucesso"); d.setNeutralButton("OK", null); d.setTitle("Aviso"); d.show(); }catch(Exception e) { AlertDialog.Builder d = new AlertDialog.Builder(AppSendPost.this); d.setMessage(e.toString()); d.setNeutralButton("OK", null); d.setTitle("Erro"); d.show(); } 281
- 282. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores } }); } } Se observarmos o código da aplicação acima é praticamente o mesmo da última aplicação, porém, com algumas diferenças (que envolve o uso da classe HttpPost). Vamos aos comentários: A linha abaixo: HttpClient httpclient = new DefaultHttpClient(); Cria uma instância da classe HttpClient. Essa classe funciona como se fosse uma INTERFACE Cliente, que vai requisitar dados do servidor. A linha abaixo: HttpPost httppost = new HttpPost("http://www.makeware.ueuo.com/cadastrar_da dos.php"); Cria uma instância da classe HttpPost, responsável por enviar dados através do método POST. Observe que foi passado no parâmetro do seu construtor, o endereço da página que vai receber os dados através desse método. A linha abaixo: 282
- 283. Luciano Alves daSilva List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2); Cria uma instância da classe List, que funciona como um Array dinâmico que recebe valores. Os valores que serão armazenados nesse Array são os valores que serão enviados pelo servidor, estruturados na classe NameValuePair. Observe que foi passado dois argumentos : o tipo de informação que será armazenado nesse Array (NameValuePair) e o valor 2, que corresponde aos dois valores que serão enviados ao servidor, “nome” e “idade”. A instruções abaixo: nameValuePairs.add(new BasicNameValuePair("nome",nome)); nameValuePairs.add(new BasicNameValuePair("idade",idade)); Adiciona no Array os dois valores que serão enviados para o servidor, “nome” e “idade”, cada um com seus respectivos valores. A linha abaixo: httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs)); Prepara os dados a serem enviados para o servidor. A classe UrlEncodedFormEntity é responsável por codificar a estrutura 283
- 284. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores “nameValuePair” do tipo List , para que ela possa ser enviada para o servidor. A linha abaixo: httpclient.execute(httppost); Envia os dados para o servidor através do método “execute”, da classe HttpClient, passando como parâmetro, o objeto da classe HttpPost. Para finalizar, coloque essa linha no arquivo “AndroidManifest.xml”, antes da Tag </manifest>: <uses-permission android:name="android.permission.INTERNET"/> Execute a aplicação. O resultado você confere na figura seguinte: Aplicação em execução 284
- 285. Luciano Alves daSilva 10.6) Fazendo download de um arquivo Agora irei mostrar como realizar um download de um arquivo, que pode ser uma imagem, um arquivo texto e etc. Crie um novo projeto com os seguintes dados abaixo: Project Name: Download Package Name : br.com.appdownload Create Activity: AppDownload Application Name: Exemplo de download Min SDK Version: 7 Após criar o projeto, carregue o layout do arquivo “main.xml” e e apague o TextView já inserido na tela. Em seguida insira os componentes, na sequencia : Button Propriedade Valor Id @+id/btdownload Layout width fill_parent Text Baixar imagem TextView Propriedade Valor Text Imagem 285
- 286. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores ImageView Propriedade Valor Id @+id/imagem Src Layout height wrap_content Layout width wrap_content Seguindo os passos acima, a tela da nossa aplicação deve estar de acordo com a figura abaixo: Layout da tela da aplicação No arquivo “AppDownload.java”, coloque o seguinte código abaixo: package br.com.appdownload; import android.app.*; import android.app.AlertDialog.Builder; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.ImageView; 286
- 287. Luciano Alves daSilva import java.net.*; import java.io.*; public class AppDownload extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button b = (Button) findViewById(R.id.btdownload); b.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { //Faz o download da imagem ImageView imagem = (ImageView) findViewById(R.id.imagem); try { URL url = new URL("http://10.0.2.2/icon.png"); InputStream is = url.openStream(); Bitmap bmp = BitmapFactory.decodeStream(is); imagem.setImageBitmap(bmp); } catch (Exception e) { 287
- 288. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores AlertDialog.Builder d = new AlertDialog.Builder(AppDownload.this); d.setMessage(e.toString()); d.setTitle("Aviso"); d.setNeutralButton("OK", null); d.show(); } } }); } } Vamos analisar algumas linhas de código. A maioria dos códigos desse programa já são conhecidos. A linha abaixo: Bitmap bmp = BitmapFactory.decodeStream(is); Cria o objeto do tipo Bitmap e carrega nele, o objeto InputStream, que contem o conteúdo da imagem baixada, no formato dele. Logo após o download da imagem, ela é visualizada, através do código abaixo: imagem.setImageBitmap(bmp); 288
- 289. Luciano Alves daSilva Vamos executar a nossa aplicação. Veja a figura abaixo: Aplicação que faz downloads em execução 10.7) O componente WebView Esse componente WebView é muito utilizado quando queremos desenvolver um navegador próprio para o nosso dispositivo. Embora o emulador já possua um Browser embutido, o Android já fornece um componente próprio voltado para tal finalidade. Ele funciona como um display onde podemos visualizar as páginas da internet. Normalmente, o componente WebView é trabalhado em conjunto com o componente WebSettings. Vamos ver alguns métodos dos componentes Método Descrição boolean canGoBack() Retorna verdadeiro caso seja possível voltar para a página anterior. boolean canGoForward() Retorna verdadeiro caso seja possível avançar para a 289
- 290. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores próxima página. Retorna verdadeiro caso seja possível retornar para algumas páginas anteriores ou avançar alguns páginas. boolean Ex: se você entrar com o canGoBackOrForward(int valor 2, você aqui verifica passos) se é possível avançar duas páginas. Se você entrar com o valor -2, você aqui verifica se é possível retornar duas páginas anteriores. Logo, números positivos indicam números de páginas que você deseja avançar e números negativos indicam números de páginas que você deseja retornar. void clearHistory() Lista o histórico das páginas visitadas. WebSettings getSettings() Retorna um objeto WebSettings usado para fazer as configurações do WebView. String getTitle() Retorna o título da página corrente. String getUrl() Retorna a URL da página corrente. void goFoward() Avança uma página. void goBack() Retorna à página anterior. Retorna para algumas 290
- 291. Luciano Alves daSilva páginas anteriores ou avançar alguns páginas. void goBackOrForward(int passos) Ex: se você entrar com o valor 2, você avança duas páginas. Se você entrar com o valor -2, você retorna duas páginas anteriores. Logo, números positivos indicam números de páginas que você deseja avançam páginas e números negativos retornam páginas anteriores. void loadUrl(String url) Carrega a url especificada no parâmetro. - WebSettings Métodos Descrição void setSaveFormData (boolean Define se o Browser arg) deve salvar dados de formulário (true) ou não (false). Habilita (true) ou não void (false) a execução de setJavaScriptEnabled(boolean arg) JavaScript existentes em algumas páginas Web. void setSavePassword(boolean Habilita (true) ou não arg) (false) o armazenamento de senhas digitadas. 291
- 292. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 10.8) Desenvolvendo uma aplicação que visita páginas Web Crie um novo projeto com os seguintes dados abaixo: Project Name: NavegadorWeb Package Name : br.com.appnevagador Create Activity: AppNavegador Application Name: Navegador Min SDK Version: 7 O único arquivo que iremos modificar neste projeto é o “AppNavegador.java”, com o seguinte código abaixo: package br.com.appnavegador; import android.app.Activity; import android.os.Bundle; import android.webkit.*; public class AppNavegador extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); WebView w = new WebView(this); WebSettings ws = w.getSettings(); 292
- 293. Luciano Alves daSilva ws.setSavePassword(false); ws.setSaveFormData(false); ws.setJavaScriptEnabled(true); ws.setSupportZoom(false); w.loadUrl("http://10.0.2.2"); setContentView(w); } } E para finalizar, no arquivo “AndroidManifest.xml”, coloque antes da tag “</manifest>”, a seguinte linha : <uses-permission android:name="android.permission.INTERNET" /> Para podermos acessar a internet. Vamos executar a nossa aplicação. O resultado você vê na figura abaixo: 293
- 294. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Aplicação que navegada n Internet em execução O próprio componente já oferece uma série de recursos, que podem ser acessados quando clicamos no botão “Menu” do emulador, como demonstra a figura abaixo: 294
- 295. Luciano Alves daSilva Aplicação que navegada n Internet em execução 295
- 296. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 11) Programação com multimídia A partir deste tópico, iremos aprender a desenvolver aplicações multimídia para a plataforma Android através de componentes que serão descritos agora. 11.1) O classe MediaPlayer A classe MediaPlayer do Android reproduz músicas e também vídeos mas, aprenderemos a reproduzir músicas neste componente. Crie um novo projeto com os seguintes dados abaixo: Project Name: MediaPlayer Package Name : br.com.appmediaplayer Create Activity: AppMediaPlayer Application Name: MediaPlayer Min SDK Version: 7 Após criar o projeto, carregue o layout do arquivo “main.xml” e apague o TextView já inserido na tela. Em seguida insira os componentes, na sequência : Button Propriedade Valor Id @+id/btplay 296
- 297. Luciano Alves daSilva Layout width fill_parent Text Play Button Propriedade Valor Id @+id/btstop Layout width fill_parent Text Stop Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: Layout da tela da aplicação Bom, agora no nosso projeto, dentro do diretório “res”, vamos criar um diretório chamado “raw”, e dentro desse diretório vamos colocar um arquivo de musica MP3, que deve se chamar “musica1”, para podermos utilizá-lo em nosso projeto. Agora no arquivo “AppMediaPlayer.java”, coloque o seguinte código abaixo: 297
- 298. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores package br.com.appmediaplayer; import android.app.Activity; import android.os.Bundle; import android.media.*; import android.widget.*; import android.view.*; public class AppMediaPlayer extends Activity { /** Called when the activity is first created. */ Button btplay,btstop; MediaPlayer mp; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); btplay = (Button) findViewById(R.id.btplay); btstop = (Button) findViewById(R.id.btstop); mp = MediaPlayer.create(this, R.raw.musica1); try { mp.prepare(); }catch(Exception e) { } btplay.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { mp.start(); } 298
- 299. Luciano Alves daSilva }); btstop.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { mp.pause(); } }); } } Vamos comentar algumas linhas de código abaixo. A linha: mp = MediaPlayer.create(this, R.raw.musica1); try { mp.prepare(); }catch(Exception e) { } Cria uma instância da classe MediaPlayer e carrega o arquivo de música “musica1.mp3” e em seguida prepara a música para ser tocada, através do método prepare. 11.2) Desenvolvendo um reprodutor de músicas (primeira versão) A partir de agora, com o conhecimento do uso da classe MediaPlayer, vamos desenvolver um reprodutor de músicas no Android. Essa aplicação vai consistir em um “playlist”, onde 299
- 300. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores nele teremos músicas a nossa disposição onde podemos reproduzi-las, de acordo com a musica escolhida. Crie um projeto com os seguintes dados abaixo: Project Name: PlayListMusicas Package Name : br.com.appplaylist Create Activity: AppPlayList Application Name: Reprodutor de músicas Min SDK Version: 7 Dentro do diretório “res” do nosso projeto crie uma pasta chamada “raw”, e dentro dela, adicione três arquivos de musica MP3, cujos nomes devem ser, respectivamente : musica1.mp3, musica2.mp3 e musica3.mp3. Vamos carregar o layout do arquivo “main.xml” e em seguida selecione o TextView já inserido na tela e modifique o conteúdo do texto para “Escolha sua música abaixo:”. Em seguida coloque os seguintes componentes, na sequência: Spinner Propriedade Valor Id @+id/spnmusicas Layout width fill_parent LinearLayout 300
- 301. Luciano Alves daSilva Propriedade Valor Id @+id/layoutBotoes Layout width fill_parent Orientation horizontal Gravity center Agora dentro do layout que acabamos de inserir , coloque os componentes abaixo: Button Propriedade Valor Id @+id/btplay Layout width wrap_content Layout height wrap_content Text Play Button Propriedade Valor Id @+id/btstop Layout width wrap_content Layout height wrap_content Text Stop Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: 301
- 302. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Layout da tela da aplicação Agora no arquivo “AppPlayList.java”, coloque o seguinte código abaixo: package br.com.appplaylist; import android.app.Activity; import android.os.Bundle; import android.media.*; import android.widget.*; import android.widget.AdapterView.OnItemSelectedListener; import android.view.*; public class AppPlayList extends Activity { /** Called when the activity is first created. */ Spinner spnmusicas; Button btplay,btstop; private final String[] musicas = {"Musica 1","Musica 2","Musica 3"}; MediaPlayer mp; @Override 302
- 303. Luciano Alves daSilva public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); spnmusicas = (Spinner) findViewById(R.id.spnmusicas); btplay = (Button) findViewById(R.id.btplay); btstop = (Button) findViewById(R.id.btstop); ArrayAdapter<String> Itens = new ArrayAdapter<String>(this,android.R.layout.simple_s pinner_item, musicas); spnmusicas.setAdapter(Itens); spnmusicas.setOnItemSelectedListener(new OnItemSelectedListener(){ public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) { // TODO Auto-generated method stub if(mp != null) { mp.release(); } if(arg2 == 0) mp = MediaPlayer.create(AppPlayList.this, R.raw.musica1); else if(arg2 ==1) mp = MediaPlayer.create(AppPlayList.this, R.raw.musica2); else 303
- 304. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores mp = MediaPlayer.create(AppPlayList.this, R.raw.musica3); try { mp.prepare(); }catch(Exception e) { } } public void onNothingSelected (AdapterView<?> arg0) { // TODO Auto-generated method stub } }); btplay.setOnClickListener(new View.OnClickListener() { public void onClick(View arg0) { // TODO Auto-generated method stub mp.start(); } }); btstop.setOnClickListener(new View.OnClickListener() { public void onClick(View arg0) { // TODO Auto-generated method stub mp.pause(); } }); } } 304
- 305. Luciano Alves daSilva Execute a aplicação e veja os resultados. Aplicação reprodutora de músicas em execução Se analisarmos a estrutura da aplicação, todas as musicais ficam dentro da pasta “raw”, disponível para serem usados na aplicação porém, tem um detalhe. Essas musicais ficam dentro do executável do Android ou seja, quando o programa é compilado, as musicas também são armazenadas dentro do “*.apk” e isso, dependendo da quantidade de musicas existentes dentro do projeto, pode atrasar o processo de compilação do programa. Para solucionarmos esse problema, vamos fazer uma segunda versão desse mesmo programa só que com um detalhe: as músicas agora estarão armazenadas no SD-Card (cartão de memória), isso resultará na compilação mais rápida do programa pois, as músicas serão carregadas desse cartão e elas não estarão mais dentro do nosso projeto. Para trabalharmos com o SD-Card, precisaremos criar um novo AVD, configurado para trabalhar com SD-Card. Vamos lá : 305
- 306. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores No Eclipse, vamos no menu “Windows” e depois selecione “Android SDK and AVG Manager”, que será aberto a caixa de diálogo conforme mostra a figura abaixo: Android SDK and AVD Manager Se observarmos acima, já estamos trabalhando com um perfil chamado “Emulador” porém, esse perfil não faz uso do SD- Card. Vamos editar esse perfil, configurando ele para trabalhar com SD-Card. Para isso, Selecione o emulador na lista e em seguida clique no botão “Edit”, será aberta a seguinte caixa de diálogo: 306
- 307. Luciano Alves daSilva Editando o Android Virtual Device Vamos na seção “SD Card”, com a opção “Size” marcada, para definirmos o tamanho do nosso cartão de memória. Vamos especificar o seu tamanho como 30 Megabytes simplesmente digitando 30 no campo “Size”, pois automaticamente, o tamanho do SD-Card já é em Megabytes. Seguindo os passos acima, as propriedades devem estar de acordo com a imagem abaixo: 307
- 308. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Editando o Android Virtual Device Depois disso, basta clicar em “Edit AVD” para salvarmos as configurações. Se você estiver com o emulador em execução, feche-o para que na próxima vez que você executar a aplicação, o suporte ao SD- Card seja habilitado. 11.3) Desenvolvendo um reprodutor de músicas (segunda versão) Bom, agora vamos desenvolver a segunda versão da aplicação reprodutora de músicas, a diferença e que nessa versão as 308
- 309. Luciano Alves daSilva músicas estarão em um SD-Card e não mais dentro da pasta “raw”. Crie um novo projeto com os seguintes dados abaixo: Project Name: PlayListMusicasSDCard Package Name : br.com.appplaylistsdcard Create Activity: AppPlayListSDCard Application Name: Reprodutor de músicas Min SDK Version: 7 Vamos carregar o layout do arquivo “main.xml” e em seguida selecione o TextView já inserido na tela e modifique o conteúdo do texto para “Escolha sua música abaixo:”. Em seguida coloque os seguintes componentes, na sequência: Spinner Propriedade Valor Id @+id/spnmusicas Layout width fill_parent LinearLayout Propriedade Valor Id @+id/layoutBotoes Layout width fill_parent Orientation horizontal Gravity center 309
- 310. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Agora dentro do layout que acabamos de inserir , coloque os componentes abaixo: Button Propriedade Valor Id @+id/btplay Layout width wrap_content Layout height wrap_content Text Play Button Propriedade Valor Id @+id/btstop Layout width wrap_content Layout height wrap_content Text Stop Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: Layout da tela da aplicação 310
- 311. Luciano Alves daSilva Agora no arquivo “AppPlayListSDCard.java”, coloque o seguinte código abaixo: package br.com.appplaylistsdcard; import android.app.Activity; import android.os.Bundle; import android.media.*; import android.widget.*; import android.view.*; import java.io.*; import java.util.*; public class AppPlayListSDCard extends Activity { /** Called when the activity is first created. */ Spinner spnmusicas; Button btplay,btstop; MediaPlayer mp; final String diretorio = "/sdcard/"; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); spnmusicas = (Spinner) 311
- 312. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores findViewById(R.id.spnmusicas); btplay = (Button) findViewById(R.id.btplay); btstop = (Button) findViewById(R.id.btstop); File[] files = new File(diretorio).listFiles(); ArrayList arquivos = new ArrayList(); for(int i=0 ; i < files.length ; i++) if(files[i].isFile()) arquivos.add(files[i].getName()); ArrayAdapter musicas = new ArrayAdapter(this,android.R.layout.simple_spinner_i tem,arquivos.toArray()); spnmusicas.setAdapter(musicas); spnmusicas.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { public void onItemSelected(AdapterView<?> arg0, View arg1,int arg2, long arg3) { String nome_musica = ((TextView) arg1).getText().toString(); mp = new MediaPlayer(); try { mp.setDataSource(diretorio + nome_musica); mp.prepare(); 312
- 313. Luciano Alves daSilva }catch(Exception e) { } } public void onNothingSelected (AdapterView<?> arg0) { // TODO Auto-generated method stub } }); btplay.setOnClickListener(new View.OnClickListener() { public void onClick(View arg0) { // TODO Auto-generated method stub mp.start(); } }); btstop.setOnClickListener(new View.OnClickListener() { public void onClick(View arg0) { // TODO Auto-generated method stub mp.pause(); } }); } } Bom, agora vamos analisar algumas linhas de código abaixo: 313
- 314. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Observe que no nosso programa, é criada uma constante chamada “diretório”, que aponta para o diretório “sdcard”, conforme é mostrado na figura abaixo: final String diretorio = "/sdcard/"; Por que apontamos para o diretório do “sdcard” ?, porque o Android (tanto o emulador quanto um SmartPhone) possui um diretório chamado sdcard onde dentro dele, são armazenados arquivos comuns, que possivelmente serão utilizados por uma aplicação. Observe também que foi necessário a criação de um array do tipo File, que irá armazenar os arquivos contidos dentro do diretório “sdcard”, conforme mostra o código abaixo: File[] files = new File(diretorio).listFiles(); Para obtermos os arquivos dentro do diretório “sdcard“, foi necessário o uso do método “listFiles”, que retorna um array de objetos do tipo File, onde cada um equivale à um arquivo. Em seguida, é criado um objetivo do tipo “ArrayList”, que consiste em um array genérico de dimensão aleatória, ou seja, a quantidade de elementos dentro desse objeto pode alterar durante a execução do programa. Qual o objetivo de criar este objeto ? Dentro dele iremos armazenar o nome dos arquivos que estão dentro do objeto “files”, conforme você confere no código abaixo: for(int i=0 ; i < files.length ; i++) if(files[i].isFile()) arquivos.add(files[i].getName()); 314
- 315. Luciano Alves daSilva Dentro do loop do código acima, observe que é feito uma analise para verificar se o objeto analisado é um arquivo, se for, é adicionado dentro do objeto “arquivo”, caso contrário não adiciona. Em seguida, crio um objeto do tipo “ArrayAdapter”, onde nele iremos adicionar os itens armazenados no objeto “arquivo” , do tipo “ArrayList”, conforme mostra o código abaixo: ArrayAdapter musicas = new ArrayAdapter(this,android.R.layout.simple_spinner_i tem,arquivos.toArray()); Em seguida, carrego os itens no componente Spinner , pelo método “setAdapter”, que recebe como parâmetro, um objeto do tipo “ArrayAdapter”, conforme é mostrado abaixo: spnmusicas.setAdapter(musicas); Toda vez que uma música é selecionada, o método “onItemSelected”, que pertence ao evento “onItemSelectedListener”, é disparado executando o código que será descrito abaixo: A musica selecionada fica armazenada dentro do objeto View, que precisa ser convertido para um objeto do tipo TextView. Após a conversão, o nome da música selecionada é armazenado em uma variável do tipo string, conforme você confere abaixo: String nome_musica = ((TextView) arg1).getText().toString(); 315
- 316. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Em seguida, crio o objeto MediaPlayer conforme mostra a figura abaixo: mp = new MediaPlayer(); Em seguida carrego a música selecionada e preparo para que ela seja tocada, conforme mostra o código abaixo: try { mp.setDataSource(diretorio + nome_musica); mp.prepare(); }catch(Exception e) { } Antes de executarmos a nossa aplicação, vamos no menu “Windows”, “Show View”, “Other...” (do Eclipse) e em seguida será aberta a seguinte caixa de diálogo abaixo: 316
- 317. Luciano Alves daSilva Show View Expanda o item “Android” e selecione o item “File Explorer”, conforme mostra a figura abaixo: 317
- 318. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Show View Em seguida, é só clicar em “OK” que a seção “File Explorer” será exibida, como demonstra a figura abaixo: File Explorer Agora vamos executar a nossa aplicação porém, SIGA OS PASSOS AQUI DESCRITOS. 318
- 319. Luciano Alves daSilva Vamos executar a nossa aplicação. “File Explorer” serve para gerenciar os arquivos que vamos trabalhar dentro da pasta sdcard. Durante a execução do Emulador, enquanto ele estiver carregando, será mostrado as seguintes pastas no “File Explorer”. File Explorer Enquanto o emulador carrega, não temos nenhuma permissão para gravar nada na pasta “sdcard”. Quando o emulador carregar por completo, as permissões sobre a pasta “sdcard” irão mudar, ficando de acordo com a figura abaixo: File Explorer Isso significa que você já pode adicionar musicas dentro da pasta “sdcard”. Agora, quando a aplicação iniciar, o componente “Spinner” estará sem itens, por que ? Porque não tem nenhum arquivo na pasta “sdcard”, então vamos adicionar os arquivos 319
- 320. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores dentro da pasta. Para adicionarmos um arquivo dentro da pasta “sdcard” selecione a pasta e clique no botão para adicionar os aqruivos. Depois de adicionar os arquivos de música reinicie a aplicação e a execute novamente. Veja o resultado abaixo: Aplicação reprodutora de músicas em execução 11.4) Desenvolvendo um reprodutor de vídeo Agora vamos aprender a desenvolver uma aplicação que reproduz vídeos, utilizando o componente VideoView. Esse componente, além de reproduzir vídeos (no formato .3gp), também reproduz músicas. Vamos demonstrar o uso deste componente. Antes de nós demonstrarmos o uso deste componente, vamos adicionar um vídeo 3gp dentro da pasta “sdcard”, para que a nossa aplicação possa fazer uso deste arquivo. Agora crie um projeto com os seguintes dados abaixo: 320
- 321. Luciano Alves daSilva Project Name: VideoView Package Name : br.com.appvideo Create Activity: AppVideo Application Name: Reprodutor de vídeos Min SDK Version: 7 Neste projeto NÃO VAMOS MEXER no arquivo “main.xml”, somente no arquivo “AppVideo.java” e nele iremos colocar o seguinte código abaixo: package br.com.appvideo; import android.app.Activity; import android.os.Bundle; import android.widget.MediaController; import android.widget.VideoView; public class AppVideo extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); VideoView v = new VideoView(this); v.setVideoPath("/sdcard/video1.3gp"); 321
- 322. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores setContentView(v); v.setMediaController(new MediaController(this)); v.requestFocus(); v.start(); } } Vamos analisar algumas linhas de código abaixo: A linha: VideoView v = new VideoView(this); Cria uma instancia da classe VideoView. Na linha seguinte: v.setVideoPath("/sdcard/video1.3gp"); Carrego o meu arquivo de vídeo através do método “setVideoPath”. Na próxima instrução: setContentView(v); Carrego o componente na tela dispositivo. Na linha seguinte: v.setMediaController(new MediaController(this)); 322
- 323. Luciano Alves daSilva Carrego os seus controles (os botões play, pause) através do método “setMediaController”. Na instrução seguinte: v.requestFocus(); Joga o foco para o componente e em seguida, executo o vídeo. Execute a aplicação e veja os resultados: Aplicação que reproduz vídeos em execução 11.5) Desenvolvendo um playlist de reprodução de vídeos Como na aplicação de playlist de músicas, vamos repetir o mesmo processo para a reprodução de vídeos. Crie um projeto com os seguintes dados abaixo: 323
- 324. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Project Name: PlayListVideos Package Name : br.com.appplaylistvideos Create Activity: AppPlayListVideos Application Name: Reprodutor de vídeos Min SDK Version: 7 Após criar o projeto, carregue o layout do arquivo “main.xml” e em seguida selecione o TextView já inserido na tela e modifique o conteúdo do texto para “Escolha seu vídeo abaixo:”. Em seguida coloque os seguintes componentes , na sequência: Spinner Propriedade Valor Id @+id/spnvideos Layout width fill_parent LinearLayout Propriedade Valor Id @+id/layoutbotoes Layout width fill_parent Layout height wrap_content Orientation horizontal Gravity center 324
- 325. Luciano Alves daSilva Agora dentro da estrutura de layout que acabamos de adicionar acima, coloque dois botões, conforme abaixo: Button Propriedade Valor Id @+id/btplay Layout width wrap_content Layout height wrap_content Text Play Button Propriedade Valor Id @+id/btstop Layout width wrap_content Layout height wrap_content Text Stop Bom, logo após a estrutura de layout que nomeados de “layoutBotoes”, adicione o componente VideoView (que se encontra na guia “Images & Media”), e mude as propriedades dele conforme abaixo: VideoView Propriedade Valor Id @+id/video Layout width wrap_content Layout height wrap_content 325
- 326. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Seguindo os passos acima, a tela da aplicação deve estar de acordo com a figura abaixo: Layout da tela da aplicação Agora no arquivo “AppPlayList.java”, coloque o seguinte código abaixo: package br.com.appplaylistvideos; import android.app.Activity; import android.os.Bundle; import android.media.*; import android.widget.*; import android.view.*; import java.io.*; import java.util.*; import java.net.*; 326
- 327. Luciano Alves daSilva public class AppPlayListVideos extends Activity { /** Called when the activity is first created. */ Spinner spnvideos; Button btplay,btstop; VideoView video; final String diretorio = "/sdcard/"; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); spnvideos = (Spinner) findViewById(R.id.spnvideos); video = (VideoView) findViewById(R.id.video); btplay = (Button) findViewById(R.id.btplay); btstop = (Button) findViewById(R.id.btstop); File[] files = new File(diretorio).listFiles(); ArrayList arquivos = new ArrayList(); for(int i=0 ; i < files.length ; i++) if(files[i].isFile()) arquivos.add(files[i].getName()); 327
- 328. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores ArrayAdapter musicas = new ArrayAdapter(this,android.R.layout.simple_spinner_i tem,arquivos.toArray()); spnvideos.setAdapter(musicas); spnvideos.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { public void onItemSelected(AdapterView<?> arg0, View arg1,int arg2, long arg3) { String nome_video = ((TextView) arg1).getText().toString(); video.setVideoPath(diretorio + nome_video); } public void onNothingSelected(AdapterView<?> arg0) { // TODO Auto-generated method stub } }); btplay.setOnClickListener(new View.OnClickListener() { public void onClick(View arg0) { // TODO Auto-generated method stub video.start(); } }); btstop.setOnClickListener(new View.OnClickListener() { 328
- 329. Luciano Alves daSilva public void onClick(View arg0) { // TODO Auto-generated method stub video.pause(); } }); }} O código acima é similar ao da aplicação de playlist de músicas, o que muda é que nós usamos o componente VideoView para reproduzir vídeos. Execute a aplicação e veja os resultados: Aplicação de playlist de vídeos em execução 329
- 330. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores 12) Programação com banco de dados A plataforma Android possui um mecanismo em que podemos trabalhar com banco de dados usando a linguagem SQL, o SQLite. Aqui neste capítulo irei mostrar como trabalhar com banco de dados no Android. Para a criação de banco de dados, não é necessário possuir um SGBD para criar banco de dados no formato SQLite, o Android já faz isto. 12.1) A linguagem SQL A linguagem SQL (Structured Query Language) é uma linguagem de consulta estruturada que realiza consultas à banco de dados. A SQL é dividida em duas sub-linguagens: LMD (Linguagem de Manipulação de Dados ou Data Manipulation Language – DML) e LDD (Linguagem de Definição de Dados ou Data Definition Language – DDL) . A LDD é um conjunto de comandos dentro da SQL usada para a definição das estruturas de dados, fornecendo as instruções que permitem a criação, modificação e remoção das tabelas, assim como criação de índices. Já a LMD é o grupo de comandos dentro da linguagem SQL utilizado para a recuperação, inclusão, remoção e modificação de informações em bancos de dados. Vamos conhecer agora alguns comandos básicos muito utilizados da linguagem SQL. 330
- 331. Luciano Alves daSilva 12.1.1) O comando CREATE TABLE Esse comando serve para criar tabelas em banco de dados. Veja a sua sintaxe abaixo: create table <tabela>(<campo1> <tipo> [<constraints>] [,<campo2> <tipo> [<constraints>],...,<campon> <tipo> [<constraints> ]]) Exemplo: Criar uma tabela chamada “cadastro” com os seguintes campos: - codusuario: Do tipo inteiro com propriedades de chave primária e auto numeração. - nome : Do tipo texto e requerido - idade : Do tipo inteiro e requerido create table cadastro(codusuario integer primary key autoincrement, nome text not null, idade integer not null) Outro exemplo : Criar uma tabela chamada “cadastro” (com os mesmos campos do exemplo acima) no banco de dados, se ela não existir. 331
- 332. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores create table if not exists cadastro(codusuario integer primary key autoincrement, nome text not null, idade integer not null) 12.1.2) O comando INSERT Esse comando serve para inserir dados em uma tabela já existente. Veja a sua sintaxe abaixo: insert into <tabela>(<campo1>,...<campon>) values(<valor1>,...,<valorn>) Exemplo: Adicionar dados na tabela cadastro (que foi criada com o comando CREATE TABLE), conforme é mostrado abaixo: nome : Luciano idade : 23 OBS: Como o campo codusuario é do tipo auto-numeração, o valor dele já é definido automaticamente. insert into cadastro(nome,idade) values(’Luciano’,23) 12.1.3) O comando UPDATE Esse comando serve para atualizar dados de uma tabela já existente. Veja a sua sintaxe abaixo: 332
- 333. Luciano Alves daSilva update <tabela> set <campo1> = <valor1>[ ,..., <campon> = <valorn>] where <condição> Exemplo: Atualizar a idade do primeiro registro (Luciano) para 24 anos. update cadastro set idade = 24 where codusuario=1 12.1.4) O comando DELETE Esse comando serve para remover dados de uma tabela já existente. Veja a sua sintaxe abaixo: delete from <tabela> where <condição> Exemplo: Remover o primeiro registro da tabela (Luciano) delete from cadastro where codusuario=1 12.1.5) O comando SELECT Esse comando serve para fazer consultas a dados em uma tabela já existente. Veja a sua sintaxe abaixo: 333
- 334. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores select <campo1>[,<campo2>,...,<campon>] from <tabela> where <condição> Exemplos : Mostrar todos os dados cadastrados na tabela select codusuario,nome,idade from cadastro Mostrar todos os nomes cuja idade seja maior que 25. select nome from cadastro where (idade >= 25) Mostrar todos os nomes cujo prefixo seja ‘David’, ou seja, todos que se chamam David, independente do sobrenome. select nome from cadastro where (nome like ‘David%’) A partir de agora, vamos ver abaixo algumas funções do Android que trabalham com banco de dados. No Android existe um pacote chamado android.sqlite, onde existe uma classe chamada SQLiteDataBase, que possui os seguintes métodos: 334
- 335. Luciano Alves daSilva Método Descrição Realiza uma consulta SQL no banco de dados (equivale ao comando SELECT). Essa função retorna uma instância do tipo Cursor. Vamos conhecer os parâmetros que iremos utilizar dessa função: Cursor query(String <tabela> : Neste parâmetro <tabela>, String[] <colunas>, String você informa o nome da <condicao_de_busca>, tabela. String[] <selecionArgs>, String <groupby>, String <coluna> : Neste <having>, String <orderby>) parâmetro a(s) coluna(s) que o banco possui. <condição de busca>: Aqui você informa a condição de busca de dados. Este parâmetro funciona como se fosse a clausula where do SQL, onde é informada a condição de busca. O resto dos parâmetros iremos trabalhar em seu valor null. 335
- 336. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Realiza uma inserção de dados na tabela (equivale ao comando INSERT). Essa função possui três parâmetros: long insert(String <tabela>, String <nullColumnHack>, ContentValues <values>) <tabela> : Neste parâmetro você informa o nome da tabela. <nullColumnHack> : O SQL não permite a inserção de linhas em branco, logo, se o valor de uma coluna for vazio, ele será iniciado com o valor null. <values> : Este parâmetro possui os valores a serem adicionados na tabela. Realiza uma atualização de dados na tabela (equivale ao comando UPDATE). Essa função possui três int update(String <tabela>, parâmetros: ContentValues <values>, String <condição>, String <whereArgs>) <tabela> : Neste parâmetro você informa o nome da tabela. 336
- 337. Luciano Alves daSilva <values> : Este parâmetro possui os valores a serem adicionados na tabela. <condição de busca>: Aqui você informa a condição para a realização da atualização dos dados. Realiza a remoção de dados na tabela (equivale ao comando DELETE). Essa função possui três parâmetros: int delete(String <tabela>, String <condição>, String <whereArgs>) <tabela> : Neste parâmetro você informa o nome da tabela. <condição>: Aqui você informa a condição para a realização da remoção dos dados da tabela. Executa uma consulta SQL (como CREATE TABLE, void execSQL(String sql) INSERT INTO, UPDATE, DELETE e etc.). Não é possível usar a clausula SELECT nesta função. Para isso, use a função “query”. 337
- 338. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Vamos fazer algumas comparações da função “execSQL”, que permite sintaxes de comando SQL com as demais funções, como “update”,”insert” e “delete” para a realização de uma consulta SQL. 12.2) Exemplos de SQL usando as funções do Android 12.2.1) Fazendo uma consulta a tabela (usando SELECT) - Comando SQL : select codusuario, nome, idade from cadastro - Usando a função query : query(“cadastro“, (new String[] {“codusuario“,“nome“,“idade“}), null, null, null, null, null); - Comando SQL : select nome from cadastro where idade > 24 - Usando a função query : 338
- 339. Luciano Alves daSilva query(“cadastro“, (new String[] {“nome“}),“ idade > 24“ , null, null, null, null); 12.2.2) Inserindo dados (usando INSERT) - Comando SQL : insert into cadastro(nome,idade) values(‘Luciano’,23) - Usando a função execSQL execSQL(“insert into cadastro(nome,idade) values(‘Luciano’,23); “); Usando a função insert : ContentValues valor = new ContentValues(); valor.put(“nome“, “Luciano“); valor.put(“idade“, “23“); insert(“cadastro“,null,valor); 12.2.3) Atualizando dados (usando UPDATE) - Comando SQL : 339
- 340. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores update cadastro set idade = 24 where codusuario=1 - Usando a função execSQL execSQL(“update cadastro set idade = 24 where (codusuario=1); “); Usando a função update : ContentValues valor = new ContentValues(); valor.put(“idade“, “24“); update(“cadastro“,valor, “codusuario=1“); 12.2.4) Removendo dados (usando DELETE) - Comando SQL : delete from cadastro where codusuario=1 - Usando a função execSQL execSQL(“delete from cadastro where (codusuario=1); “); 340
- 341. Luciano Alves daSilva Usando a função delete : delete(“cadastro“, “codusuario=1“,null); 12.2.5) Criando uma tabela (usando CREATE TABLE) - Comando SQL : create table cadastro(codusuario integer primary key autoincrement, nome text not null, idade integer not null) - Usando a função execSQL execSQL(“create table cadastro(codusuario integer primary key autoincrement, nome text not null, idade integer not null);“); Agora vamos conhecer as funções responsáveis por criar e abrir banco de dados no Android. SQLDatabase openOrCreateDatabase(String nome_do_banco,int mode, CursorFactory cf); Essa função abre ou cria um novo banco de dados. Você deve especificar o nome do, o modo de abertura (somente leitura ; somente escrita e etc.) e um terceiro parâmetro, que normalmente é null. Veja um exemplo abaixo: 341
- 342. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores SQLDatabase db; db = openOrCreateDatabase("dbbanco", Context.MODE_PRIVATE, null); O comando acima abre ou cria o banco de dados chamado “dbbanco”. Quando realizamos uma consulta do tipo SELECT usando a função “query”, ela retorna um objeto do tipo Cursor, onde nela estão armazenados os registros solicitados pela consulta. Vamos ver abaixo os métodos da classe Cursor: Método Descrição Move o cursor para o boolean moveToFirst() primeiro registro da tabela. Move o cursor para o registro boolean moveToPrevious() anterior da tabela. Move o cursor para o boolean moveToNext() próximo registro da tabela. Move o cursor para o último boolean moveToLast() registro da tabela. int getCount() Retorna o número de registros da tabela. int getColumnIndex(String Retorna o índice da coluna na columnName) 342
- 343. Luciano Alves daSilva tabela, através do seu nome, que é passado como parâmetro. Retorna o nome da coluna na String getColumnName(int tabela, através do seu índice, columnIndex) que é passado como parâmetro. Método Descrição Move o cursor para o boolean moveToFirst() primeiro registro da tabela. Move o cursor para o registro boolean moveToPrevious() anterior da tabela. Move o cursor para o boolean moveToNext() próximo registro da tabela. Move o cursor para o último boolean moveToLast() registro da tabela. int getCount() Retorna o número de registros da tabela. Retorna o índice da coluna na tabela, através do seu nome, int getColumnIndex(String columnName) que é passado como parâmetro. Lembre-se : o índice do primeiro campo é 0, o índice do segundo campo é 1 e assim por diante. Retorna o valor do campo, tendo como seu parâmetro o String getString(int seu índice, convertido em 343
- 344. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores columnIndex) String. Lembre-se : o índice do primeiro campo é 0, o índice do segundo campo é 1 e assim por diante. Retorna o valor do campo, tendo como seu parâmetro o int getInt(int columnIndex) seu índice, convertido em int. Lembre-se : o índice do primeiro campo é 0, o índice do segundo campo é 1 e assim por diante. Retorna o valor do campo, tendo como seu parâmetro o float getFloat(int columnIndex) seu índice, convertido em float. Lembre-se : o índice do primeiro campo é 0, o índice do segundo campo é 1 e assim por diante. Retorna o valor do campo, tendo como seu parâmetro o double getDouble(int columnIndex) seu índice, convertido em double. Lembre-se : o índice do primeiro campo é 0, o índice do segundo campo é 1 e assim por diante. Retorna o valor do campo, tendo como seu parâmetro o short getShort(int seu índice, convertido em columnIndex) short. Lembre-se : o índice do primeiro campo é 0, o índice do segundo campo é 1 e assim por diante. 344
- 345. Luciano Alves daSilva Vou mostrar agora um exemplo para que você tenha um melhor entendimento do mecanismo de banco de dados do Android. Imagine uma tabela chamada “cadastro” com os seguintes dados abaixo: nome idade Amanda 32 Bianca 30 Bruna 23 Carla 20 Agora, observe a linha de código abaixo: SQLDatabase db; db = openOrCreateDatabase("dbbanco", Context.MODE_PRIVATE, null); Cursor c = db.query("cadastro", (new String[] {"nome","idade"}), "idade < 32", null, null, null, null); Observe que a linha acima cria um objeto do tipo Cursor que vai receber o resultado da consulta da função query, que retorna uma instância do mesmo tipo. Logo, a instância retornada pela função query na verdade, retorna uma tabela resultante da consulta. Veja esse resultado abaixo: nome idade Bruna 23 Carla 20 345
- 346. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Continuando a codificação. Veja a linha abaixo: c.moveToFirst(); A linha acima coloca o ponteiro no primeiro registro da tabela. A linha: String nome = c.getString(0); Retorna o valor do campo “nome” do primeiro registro, no caso, “Bruna”. Veja agora a próxima linha: int idade = c.getInt(1); Retorna o valor do campo “idade” do primeiro registro, no formato int. Neste caso, o valor retornado é 23. A linha: c.moveToNext(); A linha acima avança para o próximo registro. A linha: nome = c.getString(0); Retorna o valor do campo “nome” do segundo registro, no caso, “Carla”. Veja agora a próxima linha: int idade = c.getInt(1); Retorna o valor do campo “idade” do segundo registro, no formato int. Neste caso, o valor retornado é 20. 346
- 347. Luciano Alves daSilva Bom, com certeza você entendeu como funciona o mecanismo de manipulação de banco de dados no Android. Agora vamos por esse aprendizado na prática. 12.3) Desenvolvendo uma aplicação de cadastro (segunda versão) Lembra-se daquele programa de cadastro que nos desenvolvemos lá no inicio ? Vamos desenvolver agora esse mesmo programa (com os mesmos arquivos de layouts do programa anterior), porém, voltado para banco de dados. Vamos criar um projeto com os seguintes dados abaixo: Project Name: AplicacaoDeCadastroBD Package Name : br.com.appcadastrobd Create Activity: AppCadastroBD Application Name: Aplicação de Cadastro Min SDK Version: 7 Para acelerar o processo de codificação das telas da aplicação, vamos simplesmente copiar e colar o código XML das telas da aplicação de cadastro anterior. Antes de tudo, coloque uma imagem PNG (pode ser a mesma da aplicação anterior), dentro do diretório “drawable-mdpi”, ela deve se chamar “profile.png”. 347
- 348. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Vamos fazer o seguinte, no arquivo “main.xml” substitua o código dele pelo seguinte código abaixo: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/a ndroid" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <ImageView android:id="@+id/ImageView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:src="@drawable/profile"></ImageView> <TextView android:id="@+id/TextView01" android:layout_width="wrap_content" android:layout_height="wrap_content" 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:"></TextView> <Button android:layout_height="wrap_content" android:layout_width="fill_parent" android:text="Cadastrar pessoa" android:id="@+principal/btcadastrarpessoa"></Button > <Button android:layout_height="wrap_content" android:layout_width="fill_parent" android:text="Listar pessoas cadastradas" android:id="@+principal/btlistarpessoas"></Button> </LinearLayout> Agora dentro do diretório “res/layout”, vamos criar um arquivo chamado “cadastro.xml” e substitua o código XML existente dele pelo código XML abaixo: 348
- 349. Luciano Alves daSilva <LinearLayout android:id="@+id/LinearLayout01" android:layout_width="fill_parent" android:layout_height="fill_parent" xmlns:android="http://schemas.android.com/apk/res/a ndroid" android:orientation="vertical"><ImageView android:id="@+id/ImageView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:src="@drawable/profile"></ImageView> <TextView android:id="@+id/TextView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Módulo de cadastro. Digite seus dados abaixo:"></TextView> <TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Nome:"></TextView> <EditText android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+cadastro/ednome"></EditText> <TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Profissão:"></TextView> <EditText android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+cadastro/edprofissao"></EditText> <TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Idade:"></TextView> <EditText android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+cadastro/edidade"></EditText> 349
- 350. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores <LinearLayout android:id="@+id/LinearLayout02" android:layout_height="wrap_content" android:layout_width="fill_parent" android:gravity="center"><Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Cadastrar pessoa" android:id="@+cadastro/btcadastrar"></Button> <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Cancelar" android:id="@+cadastro/btcancelar"></Button> </LinearLayout> </LinearLayout> Agora dentro do diretório “res/layout”, vamos criar um arquivo chamado “listacadastros.xml” e substitua o código XML existente dele pelo código XML abaixo: <LinearLayout android:layout_width="fill_parent" android:layout_height="fill_parent" xmlns:android="http://schemas.android.com/apk/res/a ndroid" android:orientation="vertical" android:id="@+id/layoutPrincipal"><ImageView android:id="@+id/ImageView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:src="@drawable/profile"></ImageView> <TextView android:id="@+id/TextView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:textColor="#ffffff" android:textSize="20sp" android:text="Lista de pessoas cadastradas."></TextView> <LinearLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/layoutNome"><TextView 350
- 351. Luciano Alves daSilva android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:textColor="#FFFF00" android:textSize="20sp" android:text="Nome:"></TextView> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+lista/txtnome" android:textSize="20sp" android:textColor="#ffffff" android:text=" "></TextView> </LinearLayout> <LinearLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/layoutProfissao"><TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:textColor="#FFFF00" android:textSize="20sp" android:text="Profissão:"></TextView> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+lista/txtprofissao" android:textSize="20sp" android:textColor="#ffffff" android:text=" "></TextView> </LinearLayout> <LinearLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/layoutIdade"><TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:textColor="#FFFF00" android:textSize="20sp" android:text="Idade:"></TextView> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+lista/txtidade" 351
- 352. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores android:textSize="20sp" android:textColor="#ffffff" android:text=" "></TextView> </LinearLayout> <LinearLayout android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+id/layoutBotoes" android:gravity="center" android:orientation="horizontal"> <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+lista/btvoltar" android:text="Voltar"></Button> <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Avançar" android:id="@+lista/btavancar"></Button> </LinearLayout> <Button android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+lista/btmenu" android:text="Menu principal"></Button> </LinearLayout> No arquivo “AppCadastroBD.java”, substitua o antigo código pelo novo código abaixo: package br.com.appcadastrobd; import android.app.Activity; import android.app.AlertDialog; import android.content.Context; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.os.Bundle; 352
- 353. Luciano Alves daSilva import android.widget.*; import android.view.*; public class AppCadastroBD extends Activity { EditText ednome,edprofissao,edidade; TextView txtnome,txtprofissao,txtidade; String nome; int numreg,pos,numpesq; SQLiteDatabase db; Cursor dados; void CarregaTelaPrincipal () { setContentView(R.layout.main); Button btcadastrarpessoa = (Button) findViewById(R.principal.btcadastrarpessoa); Button btlistarpessoas = (Button) findViewById(R.principal.btlistarpessoas); 353
- 354. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores btcadastrarpessoa.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaTelaCadastro(); }}); btlistarpessoas.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaListaPessoas(); }}); btcadastrarpessoa.requestFocus(); } void CarregaTelaCadastro() { setContentView(R.layout.cadastro); dados = db.query("cadusuarios",( new String[] {"nome","profissao","idade"}), null, null, null, null, null); numreg = dados.getCount(); Button btcadastrar = (Button) findViewById(R.cadastro.btcadastrar); Button btcancelar = (Button) 354
- 355. Luciano Alves daSilva findViewById(R.cadastro.btcancelar); btcadastrar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ try { ednome = (EditText)findViewById (R.cadastro.ednome); edprofissao = (EditText)findViewById (R.cadastro.edprofissao); edidade = (EditText)findViewById (R.cadastro.edidade); String nome = ednome.getText() .toString(); String profissao = edprofissao.getText().toString(); String idade = edidade.getText().toString(); //Cadastra numreg++; db.execSQL("insert into cadusuarios values(" + String.valueOf(numreg) +",'" + nome + "','" + profissao + "'," + idade + ")"); showMessage("Cadastro efetuado com sucesso", "Aviso"); 355
- 356. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores } catch(Exception e) { showMessage("Erro ao cadastrar", "Erro"); showMessage(e.toString(), "Erro"); }} }); btcancelar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaTelaPrincipal(); } }); } void CarregaListaPessoas() { try { dados = db.query("cadusuarios",( new String[] {"nome","profissao","idade"}), null, null, null, null, null); numreg = dados.getCount(); pos=1; }catch(Exception e) { showMessage(e.toString(), "Erro"); } if(numreg==0) { showMessage("Nenhum registro cadastrado", "Aviso"); 356
- 357. Luciano Alves daSilva CarregaTelaPrincipal(); return; } setContentView(R.layout.listacadastrados); dados = db.query("cadusuarios",( new String[] {"nome","profissao","idade"}), null, null, null, null, null); numreg = dados.getCount(); txtnome = (TextView) findViewById(R.lista.txtnome); txtidade = (TextView) findViewById(R.lista.txtidade); txtprofissao = (TextView)findViewById(R.lista.txtprofissao); Button btvoltar = (Button) findViewById(R.lista.btvoltar); Button btavancar = (Button) findViewById(R.lista.btavancar); Button btmenu = (Button) findViewById(R.lista.btmenu); try { dados.moveToFirst(); txtnome.setText(dados.getString(dados.getColu mnIndex("nome"))); txtidade.setText(dados.getString(dados.getCol umnIndex("idade"))); txtprofissao.setText(dados.getString(dados.getColum nIndex("profissao"))); 357
- 358. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores btmenu.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ CarregaTelaPrincipal(); } }); btvoltar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ if(pos==1) return; pos--; dados.moveToPrevious(); txtnome.setText(dados.getString(dados.getColumnInde x("nome"))); txtidade.setText(dados.getString(dados.getColumnInd ex("idade"))); txtprofissao.setText(dados.getString(dados.getColum nIndex("profissao"))); } }); btavancar.setOnClickListener(new View.OnClickListener(){ public void onClick(View arg0){ if(pos==numreg) return; pos++; 358
- 359. Luciano Alves daSilva dados.moveToNext(); txtnome.setText(dados.getString(dados.getColumnInde x("nome"))); txtidade.setText(dados.getString(dados.getColumnInd ex("idade"))); txtprofissao.setText(dados.getString(dados.getColum nIndex("profissao"))); } }); }catch(Exception e) { showMessage(e.toString(), "Aviso"); } } public void onCreate(Bundle icicle) { super.onCreate(icicle); numreg=0; try { db = openOrCreateDatabase("dbbanco", Context.MODE_PRIVATE, null); db.execSQL("create table if not exists cadusuarios(codusuario integer primary key autoincrement , nome text not null, profissao text not null, idade integer not null)"); }catch(Exception e) { showMessage(e.toString(), "Erro"); } 359
- 360. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores CarregaTelaPrincipal(); } public void showMessage(String Caption,String Title) { AlertDialog.Builder builder = new AlertDialog.Builder(AppCadastroBD.this); builder.setMessage(Caption); builder.setNeutralButton("OK", null); AlertDialog dialog = builder.create(); dialog.setTitle(Title); dialog.show(); } } Depois de toda a codificação do programa, execute a aplicação e veja os resultados. 360
- 361. Luciano Alves daSilva 13) Propriedades e eventos dos componentes trabalhados N esta seção eu irei mostrar e descrever as propriedades e eventos de todos os componentes que trabalhamos neste livro. Widget TextView - Propriedades Propriedade Em XML Em Java Text android:text setText(CharSequence c) Nessa propriedade, você define o texto a ser exibido na tela. Propriedade Em XML Em Java Text color android:textColor setTextColor(Color c) Nessa propriedade, você define a cor de texto. Proprieda Em XML Em Java de Backgroun android:backgrou setBackGroundColor(Co d nd lor c) Nessa propriedade , você define o cor de fundo do componente exibido. 361
- 362. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Valor: #000000 até #FFFFFF. Propriedade Em XML Em Java setTextSize(float tamanho) ou Text size android:textSize setTextSize(int unidade, int tamanho) Define o tamanho do texto. O tamanho da fonte pode ser especificado em várias notações : px (pixels),sp(scaled-pixels) , mm(milímetros), in (polegadas) e etc. Propriedade Em XML Em Java setTypeface(Typeface Typeface android:typeface fonte) Essa propriedade serve para definir uma fonte ao texto (normal,sans,serif,monospace). 362
- 363. Luciano Alves daSilva - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, disparando o método onClick. Widget EditText / AutoCompleteTextView - Propriedades Propriedade Em XML Em Java Text android:text setText(CharSequence c) Nessa propriedade, você define o texto a ser exibido na tela. Propriedade Em XML Em Java Text color android:textColor setTextColor(Color c) Nessa propriedade, você define a cor do texto. 363
- 364. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Proprieda Em XML Em Java de Backgroun android:backgrou setBackGroundColor(Co d nd lor c) Nessa propriedade , você define o cor de fundo do componente exibido. Valor: #000000 até #FFFFFF. Propriedade Em XML Em Java Capitalize android:capitalize Essa propriedade serve para definir o tipo capitalização das palavras. Por padrão, o valor e “none”(nenhum). Os possíveis valores para essa propriedade são : “words”,”sentences” e ”characters” Propriedade Em XML Em Java Password android:password Com essa propriedade você habilita a digitação de senhas. O valor padrão desse atributo é “false”. 364
- 365. Luciano Alves daSilva Propriedade Em XML Em Java setTextSize(float tamanho) ou Text size android:textSize setTextSize(int unidade, int tamanho) Define o tamanho do texto. O tamanho da fonte pode ser especificado em várias notações : px (pixels),sp(scaled-pixels) , mm(milímetros), in (polegadas) e etc. Propriedade Em XML Em Java Typeface android:typeface setTypeface(Typeface fonte) Essa propriedade serve para definir uma fonte ao texto. Os possíveis valores são : “normal”,”monospace”,”sans” e “serif”. Propriedade Em XML Em Java Hint android:hint setHint(CharSequence c) define uma mensagem que aparecerá quando a EditText estiver vazia. 365
- 366. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, disparando o método onClick. Método que define o Evento Métodos evento relacionados ao evento setOnKeyListener OnKeyListener onKey(View v,int KeyCode, KeyEvent event) Esse evento é disparado toda vez que a tecla é acionada, disparando o método onKey. Método que define o Evento Métodos evento relacionados ao evento onFocusChange setOnFocusChangeLi OnFocusChangeLis (View v, stener tener boolean hasFocus) Esse método é disparado toda vez quando um componente EditText ganha ou perde foco. 366
- 367. Luciano Alves daSilva Widget Button - Propriedades Propriedade Em XML Em Java Text android:text setText(CharSequence c) Nessa propriedade, você define o texto a ser exibido na tela. Propriedade Em XML Em Java Text color android:textColor setTextColor(Color c) Nessa propriedade, você define a cor do texto. Propriedade Em XML Em Java setTextSize(float tamanho) ou Text size android:textSize setTextSize(int unidade, int tamanho) Define o tamanho do texto. O tamanho da fonte pode ser especificado em várias notações : px (pixels),sp(scaled-pixels) , mm(milímetros), in (polegadas) e etc. 367
- 368. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Propriedade Em XML Em Java Typeface android:typeface setTypeface(Typeface fonte) Essa propriedade serve para definir uma fonte ao texto. Os possíveis valores são : “normal”,”monospace”,”sans” e “serif”. - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, disparando o método onClick. Método que define o Evento Métodos evento relacionados ao evento setOnKeyListener OnKeyListener onKey(View v,int KeyCode, KeyEvent event) Esse evento é disparado toda vez que a tecla é acionada, disparando o método onKey. 368
- 369. Luciano Alves daSilva Widget ToogleButton - Propriedades Propriedad Em XML Em Java e Text Off android:textOf setTextOff(CharSequenc f e c) Nessa propriedade, você define o texto a ser exibido quando o botão estiver desmarcado. Propriedade Em XML Em Java Text On android:textOn setTextOn(CharSequence c) Nessa propriedade, você define o texto a ser exibido quando o botão estiver marcado. Propriedade Em XML Em Java Text color android:textColor setTextColor(Color c) Nessa propriedade, você define a cor do texto. Propriedade Em XML Em Java Text size android:textSize setTextSize(float tamanho) ou 369
- 370. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores setTextSize(int unidade, int tamanho) Define o tamanho do texto. O tamanho da fonte pode ser especificado em várias notações : px (pixels),sp(scaled-pixels) , mm(milímetros), in (polegadas) e etc. Propriedade Em XML Em Java Typeface android:typeface setTypeface(Typeface fonte) Essa propriedade serve para definir uma fonte ao texto. Os possíveis valores são : “normal”,”monospace”,”sans” e “serif”. Propriedade Em XML Em Java setChecked(boolean Checked android:checked estado) Nessa propriedade você define o estado do CheckBox, se estará marcado (true) ou não (false). - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, 370
- 371. Luciano Alves daSilva disparando o método onClick. Método que define Evento Métodos o evento relacionados ao evento setOnCheckedCha OnCheckedChang onCheckedChanged(C ngeListener eListener ompondButton v, boolean isChecked) Esse evento é disparado toda vez que a propriedade Checked do ToggleButton é alterada Método que define o Evento Métodos evento relacionados ao evento setOnKeyListener OnKeyListener onKey(View v,int KeyCode, KeyEvent event) Esse evento é disparado toda vez que a tecla é acionada, disparando o método onKey. 371
- 372. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Widget CheckBox/RadioButton - Propriedades Propriedade Em XML Em Java Text android:text setText(CharSequence c) Nessa propriedade, você define o texto a ser exibido na tela. Propriedade Em XML Em Java Text color android:textColor setTextColor(Color c) Nessa propriedade, você define a cor do texto. Propriedade Em XML Em Java setChecked(boolean Checked android:checked estado) Nessa propriedade você define o estado do CheckBox, se estará marcado (true) ou não (false). 372
- 373. Luciano Alves daSilva - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, disparando o método onClick. Método que define o Evento Métodos evento relacionados ao evento onCheckedCh setOnCheckedChangeL OnCheckedChangeLi anged istener stener (CompoundBu tton cb,boolean b) Esse evento será disparado toda vez que o estado do CheckBox for modificado, ou seja, marcado ou desmarcado, disparando o método onCheckedChanged. 373
- 374. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Widget Spinner / ListView - Propriedades Método Descrição Nesse método você define os elementos que setAdapter(SpinnerAdapter a) irão compor esse componente através de um vetor (array). Essa função retorna a posição do elemento selecionado. Por exemplo, se for o int getSelectedPosition() primeiro elemento, retorna 0, se for o segundo, retorna 1 e assim sucessivamente. Essa função retorna em um tipo Object, o item Object getSelectedItem() selecionado. Retorna em um tipo Object o elemento de Object getItemAtPosition(int posicao) uma determinada posição, passada como parâmetro. 374
- 375. Luciano Alves daSilva - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, disparando o método onClick. Método que define o Evento Métodos evento relacionados ao evento onItemClick setOnItemClickList OnItemClickListe (AdapterView ener ner <?> a, View v, int I, long l) Esse evento será disparado toda vez que um derminado item for clicado, disparando o método onItemClick. Método que Evento Métodos define o evento relacionados ao evento onItemSelected(Ada pterView av, View setOnItemSelect OnItemSelecte v,int posição,long edListener dListener id) 375
- 376. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores onNothingSelected( AdapterView av) Esse evento será disparado toda vez que um derminado item for selecionado, disparando o método onItemSelected. Caso nenhum item seja selecionado, será disparado o método onNothingSelected. Widget ImageView - Propriedades Propriedade Em XML Em Java Src android:src setImageResource(int Id) Nessa propriedade, você define a imagem que será exibida na tela. Método Descrição Esse método é similar ao método acima, sendo setImageURI(Uri link) que aqui você especifica o Uri (como se fosse um link de internet) como caminho de localização da imagem. 376
- 377. Luciano Alves daSilva - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, disparando o método onClick. Widget Gallery - Propriedades Método Descrição Nesse método você define os elementos que setAdapter(SpinnerAdapter a) irão compor esse componente através de um vetor (array). - Eventos Método que define o Evento Métodos evento relacionados ao evento setOnClickListener OnClickListener onClick(View v) Esse evento é disparado toda vez que o componente for clicado, 377
- 378. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores disparando o método onClick. Método que define o Evento Métodos evento relacionados ao evento onItemClick setOnItemClickList OnItemClickListe (AdapterView ener ner <?> a, View v, int I, long l) Esse evento será disparado toda vez que um derminado item for clicado, disparando o método onItemClick. Widget ProgressBar - Propriedades Propriedade Em XML Em Java Style style Nessa propriedade, você define o estilo da progressbar. Essa propriedade assume os seguintes valores: "?android:attr/progressBarStyleHorizontal", "?android:attr/progressBarStyle" "?android:attr/progressBarStyleLarge" "?android:attr/progressBarStyleSmall" Propriedade Em XML Em Java Max android:max setMax(int 378
- 379. Luciano Alves daSilva valor_maximo) Neste método você define o valor máximo da faixa. Ou seja, se definir o valor máximo como 100, a faixa de progresso será entre 0 e 100. Propriedade Em XML Em Java setProgress(int Progress android:progress progresso) Neste método, você define o valor corrente do progresso. Propried Em XML Em Java ade Secondar android:secondaryPro setSecondaryProgres y gress s(int progresso) progress Neste método, você define o valor corrente do progresso secundário. Método Descrição Neste método você incrementProgressBy(int incr) define o quando o progresso será incrementado. Neste método você incrementSecondaryProgressBy(int define o quando o incr) progresso secundário será incrementado. 379
- 380. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Widget SeekBar - Propriedades Propriedade Em XML Em Java Max android:max setMax(int valor_maximo) Neste método você define o valor máximo da faixa. Ou seja, se definir o valor máximo como 100, a faixa de progresso será entre 0 e 100. Propriedade Em XML Em Java setProgress(int Progress android:progress progresso) Neste método, você define o valor corrente do progresso. Método Descrição Neste método você incrementProgressBy(int incr) define o quando o progresso será incrementado. - Eventos Método que define o Evento Métodos evento relacionados ao evento onProgressChang ed( setOnSeekBarChangeLi OnSeekBarChangeLi SeekBar sBar, int stener stener progress, boolean fromUser) 380
- 381. Luciano Alves daSilva onStartTrackingT ouch( SeekBar sBar) onStopTrackingTo uch( SeekBar sBar) Esse evento é disparado toda vez que uma alteração no valor de progresso da SeekBar é ocorrida, tanto por parte do usuário tanto por parte de comando. Widget DatePicker - Propriedades Método Descrição Neste método você define o valor inicial do ano , init(int ano, int mês, int dia, mês e dia inclusive onDateChangedListener também, você define um evento) evento toda vez que uma data for modificada (onDateChangedListener). Neste método você atualiza a data passando updateDate(int ano, int mês, como parâmetros o ano, o int dia) mês e o dia. Esse método retorna o ano int getYear() da data. Esse método retorna o mês do ano, sabendo se 381
- 382. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores que, para o primeiro mês (janeiro) ele retorna 0, int getMonth() para o segundo mês (fevereiro) retorna 1 e assim por diante. Esse método retorna o dia do mês. int getDayOfMonth() - Eventos Método Evento Métodos que define relacionados ao o evento evento Init onDateChangedListener onDateChanged(View v, int ano, int mês , int dia) Esse evento é disparado toda vez que a data for alterada, disparando o método onDateChanged. 382
- 383. Luciano Alves daSilva Widget TimePicker - Propriedades Método Descrição Neste método você define o valor da hora sabendo se setCurrentHour(int hora) que , uma hora. Neste método você define o valor do minuto entre 0- setCurrentMinute(int minuto) 59. Esse método retorna o minuto corrente. int getCurrentMinute() Esse método retorna a hora corrente. int getCurrentHour() - Eventos Método que define Evento Métodos o evento relacionados ao evento setOnTimeChanged OnTimeChangedL onTimeChanged(Ti Listener istener mePicker tp, int hora, int minuto ) Esse evento é disparado toda vez que a hora for alterada, disparando o método onTimeChanged. 383
- 384. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Widget Chronometer - Propriedades Método Descrição Neste método você define uma exibição setFormat(string format) personalizada do tempo decorrido. Neste método você define a base de tempo para o setBase(long base) cronômetro. Retorna a base de tempo do temporizador. long getBase() Esse método inicia a start() contagem do cronômetro. Esse método pára a stop() contagem do cronômetro. - Eventos Método que define o Evento Métodos evento relacionados ao evento onChronomet erTick setOnChronometerTic OnChronometerTick (Chronomete kListener Listener r 384
- 385. Luciano Alves daSilva cronometro ) Esse evento é disparado toda vez quando o tempo muda, de segundo em segundo. Widget ZoomControls - Eventos Método que define o Evento Métodos evento relacionado s ao evento setOnZoomInClickList OnZoomInClickList onClick(Vi ener ener ew v) Esse evento é disparado toda vez que botão “Zoom In” for clicado. Método que define o Evento Métodos evento relacionad os ao evento setOnZoomOutClickLis OnZoomOutClickLis onClick(V tener tener iew v) Esse evento é disparado toda vez que botão “Zoom Out” for clicado. 385
- 386. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Componente MediaPlayer - Propriedades Método Descrição Carrega um arquivo de música através do path, setDataSource(String path) passado como parâmetro Esse método prepara a mídia que será executada. prepare() Esse método pausa a pause() música que esta em execução. Esse método executa a start() musica. Detalhe : esse método precisa ser executado logo após a invocação do método prepare() ou pause(). setLopping(boolean arg) Neste método definimos se uma música estará em lopping (true) ou não (false). int getDuration() Esse método retorna em um int, a duração da musica carregada. Este método retorna a posição corrente da int getCurrentPosition() execução da música. 386
- 387. Luciano Alves daSilva Esse retorna o status da reprodução da música ou boolean isPlaying() seja, se ela está reproduzindo(true) ou não(false). - Eventos Método que Evento Métodos define o evento relacionados ao evento setOnPreparedL MediaPlayer.OnClic onPrepared(Medi istener kListener aPlayer mp) Esse evento é disparado toda vez que uma música é preparada com o método “prepare()” . Widget VideoView - Propriedades Método Descrição Carrega um arquivo de vídeo/música através do setVideoPath(String path) path, passado como parâmetro Esse método pausa a pause() vídeo/música que esta em execução. 387
- 388. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Esse método executa a start() vídeo/musica. Esse método retorna em int getDuration() um int, a duração da vídeo/musica carregada. Este método retorna a posição corrente da int getCurrentPosition() execução da vídeo/música. Esse retorna o status da reprodução da boolean isPlaying() vídeo/música ou seja, se ela está reproduzindo(true) ou não(false). - Evento Método que Evento Métodos define o evento relacionados ao evento setOnPreparedList MediaPlayer.OnClickLis onPrepared(MediaPl ener tener ayer mp) Esse evento é disparado toda vez que uma vídeo/música é preparada com o método “prepare()” . 388
- 389. Luciano Alves daSilva Método que define Evento Métodos o evento relacionados ao evento onCompletion(Medi setOnCompletionL MediaPlayer aPlayer mp) istener .OnCompletionL istener Esse evento será disparado toda vez que uma vídeo/música em reprodução termina a sua reprodução. Propriedades comuns a todos os componentes Propriedade Em XML Em Java Id android:id Nessa propriedade , definimos o nome do nosso componente. Propriedade Em XML Em Java Layout width android:layout_width Nessa propriedade, você define a largura do componente a ser exibido. Normalmente essa propriedade assume dois valores : “fill_parent” (preenche toda a largura restante do dispositivo) e “wrap_content” (a largura do componente será definida de acordo com o seu conteúdo) . Também podem especificar valores números com suas respectivas escalas, ex: “160px”,”50sp” e etc. 389
- 390. Aprenda passo apasso a programar em Android - Guia essecial para desenvolvedores Propriedade Em XML Em Java Layout android:layout_heigth height Nessa propriedade, você define a altura do componente a ser exibido. Normalmente essa propriedade assume dois valores : “fill_parent” (preenche toda a altura restante do dispositivo) e “wrap_content” (a altura do componente será definida de acordo com o seu conteúdo) . Também podem especificar valores números com suas respectivas escalas, ex: “160px”,”50sp” e etc. Propriedade Em XML Em Java setVisibility(int Visibility android:visibility modo_visibilidade) Essa propriedade serve para definir se o componente estará visível ou não. Ela assume os seguintes valores : “visible”,”invisible” e “gone”. 390
- 391. Luciano Alves daSilva Apêndice – Links Úteis G ostaria de aproveitar também e deixar aqui alguns links interessantes, para que você possa ter a oportunidade de se aprofundar a respeito da tecnologia Android. Portal Android • www.portalandroid.org Android Brasil • www.androidbrasil.com Android Brasil Projetos • www.androidbrasilprojetos.org Eu, Android • www.euandroid.com.br Android Development Community • www.anddev.org 391