Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
SUMÁRIO
APRESENTAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Aula 7 – Intents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.1. Definição da classe Intent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2. Criando e abrindo uma nova tela com Intent . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.3. Passando valores para uma nova tela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Considerações Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Glossário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Referências bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
APRESENTAÇÃO
Bem-vindo(a) à nossa disciplina, caro(a) aluno(a). Meu nome é Luiz, mas sou mais conhecido
pelo meu sobrenome: Querino. Vou apresentar a você os conceitos (e, é claro, as práticas) essenciais
para criação de aplicativos móveis (os famosos apps) para aparelhos equipados com o sistema
operacional Android.
Estamos vivendo uma nova revolução na computação pessoal, ocasionada pelo aparecimento
dos smartphones e tablets. As pessoas passaram a contar com esses tipos de aparelho no seu
dia a dia, passando literalmente a “depender” deles! Isso abriu as portas dos desenvolvedores de
software para um novo e empolgante segmento: a criação dos apps, os pequenos (mas poderosos)
programas para dispositivos móveis.
Dentre os diversos aparelhos existentes no mercado, aqueles que executam o sistema operacional
Android se destacam como os mais vendidos, justamente por serem acessíveis e estarem disponíveis
em diversas configurações. Por isso, o Android é hoje o líder isolado no mercado de sistemas
operacionais para dispositivos móveis (seguido pelo iOS da Apple em segundo lugar, e pelo Windows
Phone da Microsoft, que ainda possui uma fatia bem pequena desse novo e disputadíssimo mercado).
Uma das medidas usadas pela Google para popularizar o Android foi ter optado pelo uso da
linguagem Java para o desenvolvimento de aplicativos. Como Java já era uma linguagem amplamente
conhecida e utilizada por milhões de desenvolvedores, estes poderiam fácil e rapidamente começar
a desenvolver apps para Android!
Pág. 5 de 95
E é justamente aí que nós entramos! Como você já é um programador Java, nada melhor que
acrescentar agora o desenvolvimento de aplicativos móveis Android no seu portfólio! Prepare-se,
então, para entrar de cabeça na onda do momento: o desenvolvimento de apps!
E foi justamente a Google que começou a prestar atenção na pequena empresa e seu potencial
de inovação tecnológica. Em 2005, reconhecendo a qualidade daquilo que estava sendo criado na
Android Inc., a Google comprou a empresa e deu início à criação de um novo sistema operacional
para dispositivos móveis (celulares, naquela época), usando como base o código-fonte do Linux.
No dia 5 de novembro de 2007, a Google fez dois anúncios importantes: o primeiro, a formação
do grupo Open Handset Alliance, encabeçado por ela e formado por diversas empresas do setor
móvel, como Samsung, Sony e HTC; o segundo, anunciando o primeiro produto resultante do trabalho
desse grupo – o sistema operacional Android (QUERINO FILHO, 2013).
O sistema passou, então, a ser testado e aprimorado, até que em setembro de 2008 foi lançado
o Android 1.0 – a primeira versão disponível comercialmente. Finalmente, o mundo teria acesso a
aparelhos equipados com o hoje já conhecido “robozinho verde” (figura 1).
Pág. 6 de 95
FIGURA 1 – Logo da Plataforma Android
Fonte: <https://commons.wikimedia.org/wiki/File:Android_robot.svg>
Desde esse primeiro lançamento, muita coisa mudou. O Android assumiu a liderança do mercado
de sistemas operacionais para dispositivos móveis, superando o iOS (que equipa o iPhone e o iPad
da Apple), então líder até sua chegada, e hoje está presente em centenas de aparelhos dos mais
diversos fabricantes. No momento da finalização deste material, a versão oficial mais recente do
Android era a 6.0.1, denominada Marshmallow (figura 2).
É uma tradição da Google dar um codinome para cada versão do Android com o nome de um
doce, sempre em ordem alfabética. Por exemplo, a primeira versão a ganhar esse tipo de “apelido”
Pág. 7 de 95
foi a 1.5, chamada Cupcake. Em seguida, vieram Donut, Eclair, Froyo, Gingerbread, Honeycomb,
Ice Crem Sandwich, Jelly Bean, KitKat, Lollipop e, finalmente, Marshmallow. A próxima versão já
tem codinome anunciado: Nougat, conhecido no Brasil popularmente como “torrone”. Para cada
versão, também é criado um desenho estilizado do robozinho verde como a sobremesa “da vez”
(veja a figura 3).
Fonte: <http://techtoward.com/wp-content/uploads/2014/02/Android-Versions-History.jpg>
Fabricantes conhecidos como Samsung, Motorola, HTC e LG trazem ao usuário várias opções,
com diferentes capacidades de processamento, memória e tamanho de tela. Isso proporciona ao
usuário uma grande variedade de escolha, mas traz também uma nova preocupação ao desenvolvedor:
como compatibilizar seu app para todas essas variedades de aparelhos?
Apesar de o sistema operacional ser o mesmo nos aparelhos que divulgam o fato de serem
“Android”, há algumas peculiaridades a serem consideradas, segundo Querino Filho (2013):
Pág. 8 de 95
• Variações na configuração (hardware) de cada aparelho: como já citado, cada modelo tem
uma configuração específica. Por exemplo, o tamanho de uma tela pode variar de cerca de 3
a 7 polegadas em um smartphone e até mesmo mais de 10 polegadas em um tablet.
Como podemos ver, a versatilidade do Android é uma faca de dois gumes: dá ao usuário
mais opções de escolha de um lado, mas dificulta um pouco de outro – o “nosso lado” como
desenvolvedores, pois temos de preparar o aplicativo de forma que execute corretamente em várias
configurações.
Manter a compatibilidade com o vasto universo de aparelhos Android é tão importante que a
própria Google coloca no site oficial dos desenvolvedores – <http://developer.android.com/index.
html> – uma estatística sobre a diversidade atual de versões (figura 4).
Fonte: <http://developer.android.com/about/dashboards/index.html>
As estatísticas da figura 4 são geradas com base nos aparelhos com Android acessando a
Google Play Store.
Podemos ver que, embora cerca de 80% dos usuários já estejam usando as versões mais
recentes (da 4.4 em diante), uma fatia importante (cerca de 20%) ainda usa versões mais antigas.
Esse percentual tende a ser ainda maior em países com população de baixa renda, em que celulares
mais simples são mais vendidos.
Pág. 9 de 95
Significa que, ao criarmos um app para Android, devemos nos assegurar que ele executará na
maior quantidade possível de versões, para que possamos alcançar mais “clientes”. E para que isso
aconteça, são necessários alguns cuidados na hora de criar seu app (falaremos mais sobre isso
quando começarmos a criar os programas).
Outro fator a ser considerado: o tamanho e a resolução das telas. Veja o gráfico da figura 5.
Os dados e gráficos da figura 5, também gerados com base nos dispositivos que acessam
a Google Play Store, mostram que há uma grande variedade de tamanhos de tela (e resoluções)
nos aparelhos. Se o desenvolvedor não adequar seus apps para essas diferenças, poderá correr o
risco de o seu aplicativo aparecer com a tela cortada, “bagunçada” ou exibindo gráficos com baixa
qualidade.
FIGURA 5 – Estatísticas sobre o tamanho e a resolução de tela em uso nos dispositivos Android, em Agosto de
2016
Fonte: <http://developer.android.com/about/dashboards/index.html>
Pág. 10 de 95
CURIOSIDADE
Bem antes de o Android existir, a linguagem Java já se fazia presente nos dispositivos móveis, por
meio do “J2ME”, hoje conhecido como Java ME (Mobile Edition).
O Android, visualmente mais rico e preparado para usar os recursos mais modernos dos
smartphones, superou o Java ME como plataforma Java mais popular para dispositivos móveis,
apesar de este último ainda marcar presença significativa em outros segmentos.
De acordo com Fawcett e Quin (2012), o XML surgiu e ganhou popularidade como uma maneira
eficiente de troca de dados entre dispositivos e plataformas distintas, de forma que estes dados
pudessem ser entendidos por qualquer uma das partes envolvidas. Outra característica importante
do XML é que essas “partes” citadas possam ser tanto máquinas quanto humanos; ou seja, dados
em XML são estruturados de forma que possam ser criados e lidos (interpretados) por um software
ou pela pessoa que criou e está usando o software.
Sabemos que os computadores lidam com informações em bits (dígitos com valor zero ou um).
Esse formato, denominado formato binário, é facilmente entendido por um computador, mas nem
Pág. 11 de 95
tanto por um ser humano. Além disso, dados binários são codificados em uma forma específica
de uma determinada arquitetura de computadores, o que dificulta ainda mais o uso destes dados
por outro tipo de sistema.
Já os arquivos em formato texto (também conhecidos pela extensão .TXT, usada em muitos
destes arquivos) também podem ser processados e lidos facilmente por um computador (pois cada
caractere corresponde a uma dada sequência de bits), trazendo a vantagem de poderem ser lidos
também por seres humanos. Uma desvantagem do uso de arquivos de formato texto, no uso para
transferência de dados, está na definição de uma sintaxe adequada para a formatação dos dados,
os chamados metadados. A definição dos metadados pode variar muito, além de ocupar um espaço
significativo dentro do arquivo.
O XML veio para sanar os problemas inerentes aos formatos binário e texto!
Segundo Fawcett e Quin (2012), tudo começou com a criação do padrão SGML-Standard
Generalized Markup Language para facilitar a especificação dos metadados de um arquivo texto.
O SGML, apesar de já ser um bom começo no caminho de uma padronização para troca de dados,
ainda era complexo demais – da sua simplificação surgiu, em 1996, o XML. Foi um passo tão
importante para a Internet que já nasceu como um padrão do World Wide Web Consortium (W3C),
a entidade que controla os padrões usados na web.
Fonte: <http://www.pcmanias.com/wp-content/uploads/2014/10/w3c.jpg>
Pág. 12 de 95
Detergente
Farinha de Trigo
Sabão em Pó
Olhando os dados do quadro 1, podemos deduzir que se trata de uma lista de produtos. Mas
produtos do quê e de onde? Pode ser uma lista de compras de supermercado, um conjunto de
produtos no estoque de uma empresa; poderíamos até mesmo complementar as linhas do arquivo
com mais uma informação, como mostra o Quadro 2.
Detergente, 5
Farinha de Trigo, 2
Sabão em Pó, 4
Vemos agora que, após a descrição do produto, temos uma vírgula seguida de um número. O
que significa este número? O preço de venda do produto? Ou sua quantidade de estoque?
Não podemos saber ao certo, pois estão faltando os metadados, ou seja, os dados sobre os
dados – as informações sobre o que está especificado em cada linha.
Poderíamos transformar a listagem do Quadro 2 em um arquivo XML, em que tudo ficaria mais
claro, como no Quadro 3.
<estoque>
</estoque>
Agora sim sabemos que se trata de um estoque! E que cada item é um produto, com uma
descrição e uma quantidade.
Pág. 13 de 95
Experimente escrever o código XML do Quadro 3 em um arquivo de texto (que você pode criar
com o bloco de notas no Windows), salvá-lo com a extensão .xml e abri-lo em um navegador (o
Firefox e o Chrome são os que apresentam melhores resultados neste sentido).
Um dos modelos para o qual os dados de um documento XML podem ser extraídos é o DOM
(Document Object Model). Trata-se de uma representação em árvore do documento XML e é também
usado em arquivos HTML. Veja, na figura 8, um gráfico mostrando a hierarquia de uma tabela HTML
dentro do DOM.
Pág. 14 de 95
FIGURA 8 – Representação DOM de uma tabela
Fonte: <http://www.w3.org/TR/WD-DOM/introduction.html>
Outra forma de se especificar a estrutura de um arquivo XML são os DTDs (Document Type
Definitions) e XML Schemas. Podemos dizer que, quando precisamos de uma representação de
dados maior e mais detalhada, o uso de DTDs e XML Schemas é mais interessante que DOM. À
medida que começarmos a usar XML no Android, você verá que XML Schemas são as formas para
representar os dados que utiliza.
Java possui, há muito tempo, APIs próprias para a leitura e geração de arquivos XML. A SAX
(Simple API for XML) é uma das opções, em que a leitura dos arquivos XML é feita de forma
sequencial. Já a TrAX (Transformation API for XML), que faz parte da API JAXP, permite a conversão
de um documento XML em outros formatos (FAWCETT e QUIN, 2012).
Dentro do Android, a maior parte da leitura e criação de arquivos XML é feita internamente pelo
sistema operacional, evitando que o desenvolvedor precise utilizar diretamente API deste tipo.
Pág. 15 de 95
Vamos agora ao download do Android Studio, uma IDE (Integrated Development Environment,
ou Ambiente de Desenvolvimento Integrado, em português) que contém as bibliotecas básicas
para desenvolver em Java para Android. Acesse http://developer.android.com e procure pelo link
indicado na figura 9.
Pág. 16 de 95
Fonte: <http://developer.android.com>
Na tela seguinte, a versão adequada do Android Studio para seu sistema operacional poderá
ser baixada, bastando clicar no botão indicado na figura 10.
Pág. 17 de 95
FIGURA 10 – Botão para download do Android Studio na versão do seu sistema operacional
Fonte: <https://developer.android.com/studio/index.html>
Em seguida, você deverá concordar com os termos do download do Android Studio marcando a
caixa indicada pela seta e clicar no botão logo abaixo (figura 11) para iniciar o download do pacote
de instalação.
Fonte: <https://developer.android.com/studio/index.html>
Pág. 18 de 95
No caso de instalação no Windows, após executar o programa baixado, será exibida a tela
mostrada na figura 12. Clique sobre o botão Next para começar o processo de instalação.
Fonte: <https://developer.android.com/studio/index.html>
Pág. 19 de 95
Fonte: <https://developer.android.com/studio/index.html>
Ao clicar em Finish, como indicado na figura 13, o instalador será encerrado e o Android Studio
passará a ser inicializado pela primeira vez.
AVISO!
Para executar o Android Studio de modo satisfatório, é recomendado que o computador possua pelo
menos 4 GB de RAM.
Pág. 20 de 95
Na tela seguinte (figura 16), mantenha a opção Standard selecionada e clique em Next.
Pág. 21 de 95
Será então exibida uma tela mostrando os componentes adicionais que serão baixados e onde
eles serão armazenados no seu computador (figura 17).
Clique em Finish para iniciar o download. Assim que ele for concluído, o Android Studio fará a
autoconfiguração do AVD.
Caso seu computador suporte a virtualização VT-x, tudo deverá acontecer sem problema.
Porém, caso não tenha, talvez seja mostrada, ao final da instalação, uma mensagem semelhante
à apresentada na figura 18:
Pág. 22 de 95
IMPORTANTE
Com o intuito de acelerar a execução do emulador, o Android Studio inicialmente tenta criar um
AVD com uma versão do Android para processadores x86, que poderá ser executada com excelente
desempenho em computadores que suportam a tecnologia de virtualização VT-x com uso do
software Intel HAXM.
Caso seu computador apresente a mensagem em vermelho na figura 18 (ou algo semelhante),
será necessário, antes de executar os programas no emulador, criar manualmente um AVD usando
uma versão do Android para processadores ARM. Veja como isso é feito na próxima seção deste
material.
De qualquer forma, tendo sido mostrada a mensagem de erro ou não, logo após o fechamento
da janela mostrada na figura 18 será exibida a tela de boas-vindas do Android Studio (figura 19):
Pág. 23 de 95
Clique no botão indicado pela seta na figura 19 para criar um novo projeto de aplicativo Android.
Pág. 24 de 95
Em Company Domain você pode colocar um nome de domínio Internet, que será usado, em
formato reverso, nos pacotes das suas classes Java; se não tiver direito de uso de um domínio,
pode usar uma valor fictício, como o indicado (example.com).
O seu projeto ficará salvo na pasta indicada em Project Location; você pode alterá-la, se quiser.
Após definir as configurações desejadas, clique em Next.
Na próxima tela (figura 21) indicamos a plataforma alvo do aplicativo Android que criaremos.
É possível criar apps para Android destinados a outras plataformas de aparelhos, como TVs,
relógios (Wear) e até mesmo o famoso Google Glass, mas no nosso caso o alvo serão os principais
dispositivos para esse sistema operacional: Phone and Tablet.
Em Minimum SDK é possível estabelecer a versão mínima do Android necessária para que
o aplicativo funcione. O padrão mostrado na tela da figura 21 (API 15: Android 4.0.3) indica que
nosso app poderá ser executado em versões do Android iguais ou superiores a esta – assim, a
abrangência do aplicativo aumenta, como dissemos. Porém, recursos novos acrescentados em
versões posteriores poderão não estar disponíveis. A versão sugerida é uma boa escolha, pois
proporciona um balanço entre disponibilidade de recursos novos e abrangência de uso (veja na
figura 21 que a versão selecionada é a utilizada em cerca de 97,4% dos aparelhos ativos). Clique
em Next para passar à próxima tela.
Pág. 25 de 95
Neste momento (figura 22) podemos escolher um modelo inicial para a tela principal do aplicativo.
Nos nossos projetos escolheremos sempre a versão mais simples de tela: a Empty Activity, como
indicado na figura 22, que traz uma tela em branco sem conteúdo específico. Selecione esse tipo
e clique em Next.
Após alguns segundos, seu projeto estará criado e pronto para ser modificado. A tela do Android
Studio com um projeto recém-criado é semelhante à apresentada na figura 23. Caso não esteja
Pág. 26 de 95
visualizando a tela do aplicativo como a mostrada na figura, abra, à esquerda, as pastas app\res\
layout e clique duas vezes sobre o arquivo activity_main.xml.
• À esquerda, temos a aba Project, em que são exibidos os arquivos do projeto. Os dois arquivos
mais importantes para nós, por enquanto, são os seguintes:
• Na parte central do Android Studio, são exibidos os arquivos atualmente abertos. Na figura
24, o arquivo atualmente aberto é o activity_main.xml, que contém o layout da tela. Quando
criamos o layout, podemos alternar entre a sua exibição gráfica (por meio da aba Design,
na parte inferior) ou do seu código em XML (exibido no clique da aba Text). Outros arquivos
abertos podem ser “trazidos para frente” por meio do uso das abas.
• No canto superior direito, temos a Component Tree (Árvore de Componentes). Ela é útil, pois
mostra a hierarquia dos widgets na janela (os componentes que usamos para montar uma
tela – como botões e rótulos de texto).
Pág. 27 de 95
• No canto inferior direito, temos Properties, a janela de propriedades. Ela é usada para
modificarmos os atributos dos widgets existentes na tela. Por exemplo: clicando sobre um
botão, podemos trocar o texto exibido dentro dele alterando a propriedade text.
• Por fim, na parte inferior do Android Studio, temos (ocultas na figura 24, mas que podem ser
abertas clicando nos botões existentes) janelas de informações diversas. É ali que serão
exibidas informações sobre a execução de um programa e localização de erros de compilação
e execução.
Se este foi o seu caso, siga as etapas da próxima seção, onde são dadas instruções sobre como
criar o AVD caso ele não exista.
Você precisa criar somente um AVD para testar seus programas. Porém, caso deseje (ou precise),
pode criar AVDs com diferentes versões do Android e configurações de hardware variadas para testes.
Verifique se o AVD foi criado no momento da instalação clicando sobre o botão indicado na figura
25. Este botão abre o AVD Manager, um gerenciador para criação e manutenção dos dispositivos
virtuais.
Pág. 28 de 95
Se seu computador atendeu aos requisitos necessários, deve ter sido criado um AVD usando
uma imagem do Android para processadores x86, que poderá ser executada em alto desempenho
no seu computador. Caso não tenha sido possível a criação, e uma mensagem de erro semelhante
à exibida na figura 18 tenha sido mostrada, será preciso criar um AVD usando uma imagem do
Android para processadores ARM.
Caso seja exibida uma tela como a da figura 26, siga as próximas etapas para criar o AVD.
Para iniciar o processo de criação do AVD, clique no botão Create Virtual Device. Será mostrada
a tela apresentada na figura 27.
Pág. 29 de 95
Neste ponto selecionamos uma configuração para o aparelho a ser emulado. Marque o Nexus 4
dentro da categoria Phone. Ele tem um tamanho de tela semelhante a muitos aparelhos Android do
mercado e serve perfeitamente como base para nossos aplicativos. Clique em Next para continuar.
Para baixar a imagem do Android para ARM, clique na aba Other Images da tela na figura 28.
Localize a imagem do Android Marshmallow (ou versão mais recente) para processador ARM
(indicada na coluna ABI como armeabi-v7) e com suporte às APIs do Google, como a indicada pela
seta na figura 28. Clique então em Download para que a imagem seja baixada.
Pág. 30 de 95
Uma nova tela, exibida na figura 29, será exibida. Para iniciar o download, você precisa concordar
com os termos de uso da imagem clicando em Accept e, posteriormente, em Next.
O download será então iniciado. Quando estiver finalizado, clique no botão Finish (figura 30).
Pág. 31 de 95
A nova imagem poderá agora ser selecionada, como indicado na figura 31. Clique sobre ele e,
em seguida, no botão Next.
Os avisos em vermelho indicam que a CPU do computador em questão não suporta a tecnologia
VT-x, por isso temos de criar um AVD com a imagem do Android para processador ARM. Como
Pág. 32 de 95
indicado na outra mensagem logo abaixo, a emulação para x86 apresentaria um desempenho
superior.
Na última tela de configuração do AVD (figura 32), podemos manter as configurações default
e clicar no botão Finish.
Tudo pronto! Pode fechar o AVD Manager e voltar ao projeto que criamos anteriormente; vamos
finalmente implementá-lo!
Você tem duas opções agora: pode construir sua interface graficamente, arrastando os widgets
existentes na palheta (Palette) e configurando suas propriedades de acordo com a listagem do
quadro 4, ou digitar diretamente seu código em XML.
Pág. 33 de 95
<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android”
xmlns:tools=”http://schemas.android.com/tools”
tools:context=”com.example.professores.contador.MainActivity”>
<TextView
android:textAppearance=”?android:attr/textAppearanceLarge”
android:text=”0”
android:id=”@+id/txtContador”
android:layout _ alignParentTop=”true”
android:layout _ centerHorizontal=”true”
<Button
android:layout _ width=”wrap _ content”
android:text=”Contar”
android:id=”@+id/button”
android:layout _ below=”@+id/txtContador”
android:layout _ centerHorizontal=”true”
android:layout _ marginTop=”41dp”
android:onClick=”onClickContar” />
</RelativeLayout>
Neste layout, temos um TextView, usado para exibição de um texto, e um Button, o qual, quando
tocado, incrementará uma variável contadora que será posteriormente mostrada no TextView.
Pág. 34 de 95
O TextView recebeu o idtxtContador, e será por meio dele que faremos acesso a este widget
pelo código Java.
Também modificamos a propriedade text de cada um deles, colocando nela o texto que será
exibido (0 inicialmente para o TextView contador e “Contar” para o botão).
Repare, na última linha das configurações do Button, que definimos o valor onClickContar para
sua propriedade onClick. Trata-se do nome do método Java que será disparado, dentro do arquivo
MainActivity.java, quando o usuário clicar no botão.
O nome que você coloca na propriedade onClick de um Button deve ser exatamente o mesmo que
utilizará no código Java! Tome cuidado, pois maiúsculas e minúsculas fazem, sim, toda a diferença.
Vamos agora ao código Java. Abra o arquivo MainActivity.java, existente dentro da pasta java\
nome_do_seu_pacote do seu projeto (o nome do pacote dependerá do que foi colocado em Company
domain no momento da criação do app – veja a figura 20). Deixe o código-fonte como o exibido
no quadro 5.
Pág. 35 de 95
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
int contador = 0;
contador++;
txtContador.setText(String.valueOf(contador));
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ main);
Começamos acrescentando os imports para duas classes do Android SDK que vamos utilizar:
View e TextView.
Em seguida, no início da classe, declaramos uma variável int denominada contador e atribuímos
0 a ela. Essa variável será criada assim que a janela for aberta (ou seja, assim que o programa
começar), e será visível por todos os métodos existentes nela. Sua “vida útil” será a mesma da
classe; como a classe corresponde à janela, enquanto a janela estiver ativa a variável será mantida.
Pág. 36 de 95
O método onClickContar será executado quando o usuário tocar no botão que colocamos
na interface. Repare que este método deve ter o mesmo nome colocado no arquivo XML e deve,
obrigatoriamente, ter o retorno e parâmetro especificados.
Os widgets colocados na interface não são diretamente acessíveis pelo código Java; por isso
precisamos da primeira linha existente no método, na qual chamamos o importantíssimo comando
findViewById() para “conectar” a variável local txtContador, declarada dentro do método, ao respectivo
widget existente na interface (localizado por seu id em R .id .txtContador).
Tudo pronto! Para executar o aplicativo e testá-lo no emulador, clique no botão da barra
de ferramentas do Android Studio, selecione um AVD na tela que será mostrada e clique em OK. O
resultado será semelhante ao apresentado na figura 33.
Pág. 37 de 95
por meio da sua Activity. Por fim, conhecerá a ListActivity e a ListView, que permitem a exibição
rápida e prática de uma lista de itens na tela do Android.
Basicamente, poderíamos definir uma View como um espaço retangular delimitado na tela
do Android. Nessa definição se encaixam os widgets e, também, os gerenciadores de layout, que
funcionam como “caixas” ou “containers” de outros widgets.
Todos pertencem a uma hierarquia de classes, que pode ser observada (parcialmente) na figura
34.
Por isso, lembre-se: todo elemento colocado em uma tela do Android é, portanto, uma View.
Isso possibilita, por exemplo, que possamos usar o comando findViewById para conectar o código
Java a qualquer tipo de objeto na tela.
Pág. 38 de 95
Você pode conhecer os demais pela Palette do Android Studio (figura 35) ou consultando a
documentação oficial da API do Android.
Você já percebeu que podemos colocar os widgets diretamente em uma tela arrastando os
componentes a partir da palheta. Selecionando um widget, você pode configurar suas propriedades
pela janela Properties, como na figura 36.
Pág. 39 de 95
Pág. 40 de 95
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ main);
Imediatamente, pela declaração da classe, você pode perceber que ela herda AppCompatActivity,
uma classe existente no Android SDK que serve como base para nossas telas.
Como desenvolvedor Java experiente, você já notou a existência de um método e que ele está
marcado com a anotação @Override, que indica que este método está sobrescrevendo um método
recebido por herança da sua superclasse (AppComptaActivity).
O método em questão se chama onCreate. Como o próprio nome dá a entender, ele é executado
quando o evento de criação da tela acontece, ou seja, assim que a tela aparece pela primeira vez.
Dentro dele, vemos uma chamada ao método original da superclasse – ele está lá para que
uma tela básica em branco seja criada. Em seguida, vem uma parte fundamental: o comando
setContentView. Perceba que passamos ao setContentView o nome do nosso arquivo de layout,
Pág. 41 de 95
existente na pasta res/layout. Sim, é ele mesmo: o arquivo XML no qual definimos nossa interface!
É graças ao setContentView que, ao invés de ficarmos com a tela branca padrão, temos a exibição
do layout criado!
CURIOSIDADE
Para entender melhor o “porquê” do setContentView, faça uma experiência com um dos seus projetos:
comente (coloque duas barras no início da linha) o setContentView, dentro do método onCreate da
classe MainActivity, execute o projeto e veja o resultado.
O widget EditText pode ser configurado para restringir os caracteres que o usuário poderá digitar
nele. Por exemplo, no caso de fornecimento de valores numéricos, é possível “travar” a entrada de
caracteres que não sejam números, pontuação e sinal. Há também uma variação adequada para o
fornecimento de números de telefone, por exemplo, que permite apenas números, parênteses e hífen.
Você pode adicionar o EditText diretamente pelo código XML ou pode simplesmente arrastar e
soltar uma das suas variações existentes na palheta, dentro da categoria Text Fields (veja a figura 38).
Pág. 42 de 95
Todos os widgets existentes na palheta são EditText; o que diferencia um do outro aqui é sua
configuração Input Type, que estabelece o controle sobre quais caracteres são permitidos.
Com um EditText na interface, você pode obter o valor digitado nele por seu método getText(),
que deverá receber um toString() ao final para que seja convertido para uma String Java. Para
colocar uma String em um EditText, usamos o seu método setText(), passando a String como seu
parâmetro. Veja no quadro 7 exemplos de como utilizá-los.
editText1.setText(textoNoEdit.toUpperCase());
Outro widget que pode ser bastante útil em seus projetos é o ImageView. Com ele, podemos
exibir imagens e fotos em uma tela do Android.
Para utilizá-lo, basta copiar uma imagem para a pasta res\drawable do seu projeto. Você pode
fazer isso simplesmente copiando o arquivo da imagem (com CTRL+C em um PC ou Command+C
Pág. 43 de 95
Após colocada a imagem, arraste um widget ImageView (ele está dentro da categoria Widgets da
palheta) até alguma parte da sua tela. Clique duas vezes sobre ele e, na janela popup que aparecerá,
especifique a imagem a ser utilizada na propriedade src (veja a figura 39)!
Conheceremos agora mais um widget útil: o Toast. Ele não é encontrado na palheta de objetos
– seu uso é realizado diretamente pelo código Java. Com o Toast, você consegue exibir mensagens
curtas que desaparecem automaticamente após um período.
Pág. 44 de 95
NUNCA SE ESQUEÇA de chamar o método show() após makeText(), como no quadro 8! O método
makeText cria a mensagem mas não a exibe; quem faz isso é o método show().
Porém, existem outros eventos em uma Activity que podem ser programados. Suponha, por
exemplo, que no momento em que a Activity for fechada, você precisaria salvar dados ou gravar o
estado atual do aplicativo para que possa ser restaurado depois. Pois bem, existe um evento que
você pode sobrescrever para especificar o que fazer nesta situação!
Para compreender melhor o ciclo de vida de uma Activity, dê uma olhada no gráfico da figura 40.
Pág. 45 de 95
FIGURA 40 – Ciclo de vida de uma Activity
Fonte: <https://developer.android.com/images/training/basics/basic-lifecycle.png>
• No caso de uma nova tela ser aberta e ocultar totalmente a tela atual, dizemos que esta Activity
entrou no estado de parada e executou o evento onStop().
◊ Neste caso, quando o usuário retorna à Activity que ficou “de baixo”, ela executa o evento
onRestart() e posteriormente o onStart().
• Finalmente, logo antes da Activity ser totalmente fechada, ocorre o evento onDestroy().
Definimos o nome do método que será disparado no toque de um botão por meio da sua
propriedade onClick, dentro de um arquivo XML. Também pode ser designado por meio da interface
Pág. 46 de 95
android:text=”Incluir”
android:id=”@+id/button”
android:layout _ centerHorizontal=”true”
android:layout _ marginTop=”36dp”
android:onClick=”onClickIncluir” />
Depois de configurado o nome do método na propriedade, o método para o evento deve ter
exatamente o mesmo nome que foi especificado. Também é obrigatório que o método seja public
com retorno vazio (void) e que receba um objeto da classe View como parâmetro, como mostra o
exemplo no quadro 10.
Pág. 47 de 95
Você pode adicionar este ListView a uma tela de layout, conectá-lo ao código Java com
findViewById() e depois programar o widget para exibir os dados. Mas há um jeito ainda mais
prático e com mais opções: usar a ListActivity.
Trata-se de uma Activity especial, que já “sabe” como lidar com um ListView. Na verdade, ela
traz em si um ListView embutido, e poderia até mesmo ser usada sem um arquivo de layout, mas
vamos usá-la junto do activity_main.xml para que possamos customizá-lo.
Vamos supor que você está querendo criar uma lista de compras. O primeiro passo é criar um
layout com um ListView para exibição da lista, assim como um EditText para o usuário escrever
um nome de um item e um botão com a ação de incluí-lo. Um exemplo de layout dessa maneira
pode ser visto no quadro 11.
Pág. 48 de 95
<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android”
xmlns:tools=”http://schemas.android.com/tools”
tools:context=”com.example.professores.listadecompras.MainActivity”>
<EditText
android:id=”@+id/edtProduto”
android:layout _ alignParentTop=”true”
android:layout _ alignParentLeft=”true”
android:layout _ alignParentStart=”true”
android:layout _ alignParentRight=”true”
<Button
android:layout _ width=”wrap _ content”
android:text=”Incluir”
android:id=”@+id/button”
android:layout _ below=”@+id/edtProduto”
android:layout _ alignParentLeft=”true”
android:layout _ alignParentStart=”true”
android:layout _ alignRight=”@+id/edtProduto”
android:layout _ alignEnd=”@+id/edtProduto”
Pág. 49 de 95
android:onClick=”onClickAdicionar” />
<ListView
android:id=”@android:id/list”
android:layout _ below=”@+id/button”
android:layout _ alignParentLeft=”true”
</RelativeLayout>
• Colocamos no EditText, em que será digitado o item idedtProduto, para identificá-lo corretamente
no código Java;
• No Button que vai realizar a inclusão do item digitado, configuramos seu evento onClick para
disparar o método onClickAdicionar – este será o nome que deveremos usar na classe Java;
• No ListView, uma configuração fundamental para que ele possa ser usado na ListActivity: seu
id tem que ser, obrigatoriamente, @android:id/list.
Para conseguir cumprir esses procedimentos, altere o código da MainActivity.java do seu projeto
para o exibido no quadro 12.
Pág. 50 de 95
import java.util.ArrayList;
import android.app.ListActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Toast;
EditText edtProduto;
ArrayList<String>lista;
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ main);
lista.add(produtos[i]);
setListAdapter(adaptador);
edtProduto = (EditText)findViewById(R.id.edtProduto);
Pág. 51 de 95
lista.add(produto);
adaptador.notifyDataSetChanged();
edtProduto.setText(“”);
@Override
SHORT).show();
android:layout _ alignRight=”@+id/edtProduto”
android:layout _ alignEnd=”@+id/edtProduto”
android:onClick=”onClickAdicionar” />
<ListView
android:id=”@android:id/list”
android:layout _ below=”@+id/button”
android:layout _ alignParentLeft=”true”
</RelativeLayout>
• Toda lista precisa ter uma fonte para seus dados, ou seja, os elementos que serão colocados
na lista; por isso, declaramos na nossa classe um ArrayList de Strings denominado lista.
Como usaremos o EditText edtProduto em mais de um método, também o colocamos como
um campo global da classe;
• No onCreate, fazemos a inicialização da lista. Criamos um vetor comum de Strings (produtos)
e depois adicionamos os seus elementos ao ArrayList lista. Para conectar os elementos do
Pág. 52 de 95
SAIBA MAIS
A VERSATILIDADE DO onListItemClick
Este método pode ser usado para várias outras operações com a lista:
Abrir uma próxima tela com mais informações do elemento tocado (veremos como abrir uma nova
tela no próximo módulo);
Iniciar a alteração do item, em uma caixa de diálogo ou tela em que os dados podem ser alterados.
Pág. 53 de 95
adequadamente na tela, até mesmo no caso de aparelhos com diferentes tamanhos de tela. Neste
módulo, conheceremos um pouco mais sobre os gerenciadores de layout. A classe Intent, utilizada
para realizar operações que envolvam atenção do sistema operacional, por exemplo, abrir novas
janelas, também será abordada neste módulo.
Porém, a grande maioria dos aplicativos é construída com um destes dois: RelativeLayout e
LinearLayout, que são, inclusive, os mais utilizados nos documentos de referência que a Google
disponibiliza no developer.android.com.
Veremos agora um pouco mais sobre cada um destes dois, assim como as vantagens e
desvantagens em utilizá-los.
Pág. 54 de 95
6.1. RelativeLayout
O layout relativo (RelativeLayout) é o padrão para construção de novas telas no Android. Ele faz
com que os widgets sejam posicionados em relação a outro, ou em relação aos cantos e centro da
tela. Assim, os widgets podem se adaptar adequadamente a mudanças na tela. Veja na figura 43
um exemplo de uso do layout relativo.
Você vê as linhas verdes na figura 43? Elas mostram o posicionamento relativo do widget
selecionado. Por exemplo, o TextView contendo o texto Celsius está posicionado em relação aos
lados superior e esquerdo da tela, assim como um pouco acima em relação ao TextView contendo
o texto Fahrenheit. Agora veja na figura 44 o posicionamento do EditText à direita de Fahrenheit.
Pág. 55 de 95
Podemos ver que o EditText está posicionado em relação aos dois TextView, ao EditText do
Celsius e também ao botão.
Para ter uma garantia maior da posição final dos widgets, diminuindo a liberdade no seu
posicionamento, podemos utilizar o Linear Layout.
6.2. LinearLayout
Com o layout linear, podemos ter mais certeza com relação ao posicionamento final dos widgets
em diferentes tamanhos de tela, assim como não correremos mais o risco de um reposicionamento
de um widget alterar completamente a interface.
Aparentemente, o uso do LinearLayout parece ser bem limitado; afinal, no vertical, (esquerda na
figura 45) você pode apenas colocar um widget abaixo do outro, e no horizontal (direita na figura
44), todos ficam na mesma linha, um ao lado do outro.
Pág. 56 de 95
Porém, você pode mesclar o uso do layout linear horizontal com o vertical e criar telas em um
estilo tabela. Dê uma olhada no exemplo da figura 46.
Na figura 46, veja na Component Tree (no canto superior direito) que colocamos um Layout Linear
Vertical com dois Layout Linear Horizontal empilhados, seguidos de um botão. Dentro dos dois
layouts horizontais, colocamos, em linha, os TextViews e campos de entrada de texto necessários.
A listagem deste exemplo de layout pode ser vista no quadro 13.
Pág. 57 de 95
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
<LinearLayout
android:orientation=”horizontal”
<TextView
android:layout _ width=”0dp”
android:textAppearance=”?android:attr/textAppearanceLarge”
android:text=”Celsius:”
android:id=”@+id/textView3”
android:layout _ weight=”1”
android:gravity=”right” />
<EditText
android:layout _ width=”0dp”
android:inputType=”numberDecimal”
android:ems=”10”
android:id=”@+id/editText3”
android:layout _ weight=”1”>
<requestFocus/>
</EditText>
</LinearLayout>
<LinearLayout
android:orientation=”horizontal”
Pág. 58 de 95
<TextView
android:layout _ width=”0dp”
android:textAppearance=”?android:attr/textAppearanceLarge”
android:text=”Fahrenheit:”
android:id=”@+id/textView4”
android:layout _ weight=”1”
android:gravity=”right” />
<EditText
android:layout _ width=”0dp”
android:inputType=”numberDecimal”
android:ems=”10”
android:id=”@+id/editText4”
</LinearLayout>
<Button
android:text=”Converter”
android:id=”@+id/button2” />
</LinearLayout>
Pág. 59 de 95
Para poder usar a ActionBar é necessário possuir um arquivo XML que define os itens que ela
contém. Também é preciso possuir dois métodos específicos implementados no código da Activity.
Você não precisa criar o arquivo XML e os métodos manualmente: para tê-los automaticamente,
no momento de criação do seu projeto, escolha o modelo Blank Activity para sua tela inicial (veja
a figura 22 na seção 3.3).
Os itens de menu da ActionBar são ações que devem ser definidas com a tag item, em um
arquivo XML existente dentro da pasta res/menu. Todo novo projeto criado com o modelo de te;a
Blank Activity já vem com um arquivo XML contendo um item de menu para abrir as preferências
do aplicativo (caso existam). Veja seu conteúdo no quadro 14.
xmlns:app=”http://schemas.android.com/apk/res-auto”
xmlns:tools=”http://schemas.android.com/tools”
tools:context=”com.example.professores.megasena.MainActivity”>
<item
android:id=”@+id/action _ settings”
android:orderInCategory=”100”
android:title=”@string/action _ settings”
app:showAsAction=”never” />
</menu>
Pág. 60 de 95
Em seguida, o que acontecerá quando um item for tocado deverá ser programado no evento
onOptionsItemSelected, dentro da Activity (veja o quadro 15).
QUADRO 15 – Código para o evento que trata o clique em cada um dos itens de menu na AppCompatActivity
@Override
int id = item.getItemId();
Toast.LENGTH _ LONG).show();
return true;
return super.onOptionsItemSelected(item);
Para cada item criado no arquivo XML, é possível testar, dentro do onOptionsItemSelected, se ele
foi pressionado e executar o procedimento adequado. No exemplo do quadro 15, apenas mostramos
uma mensagem ao usuário. Veremos na próxima aula como abrir novas janelas – esse poderia ser
o resultado final do clique do item de menu Settings.
No caso de novos itens, você pode adicionar outros else if ao código ou simplesmente trocar
o uso de if por switch...case.
Uma caixa de diálogo pode ser criada facilmente no Android, por meio do uso da classe
DialogFragment. Podem ser criados diálogos simples, com botões que o usuário pode utilizar para
responder uma questão, por exemplo, ou diálogos mais sofisticados, com widgets como caixas de
entrada de texto.
Pág. 61 de 95
Para criar um diálogo com DialogFragment, precisamos criar uma subclasse desta. Isso pode
ser feito dentro da própria classe da Activity – afinal, Java permite criar classes dentro de classes!
Veja um exemplo no quadro 16, que pode ser colocado dentro de uma Activity.
@Override
// USUÁRIO CLICOU EM OK
}
})
});
return builder.create();
Agora, você pode chamar o diálogo no ponto em que desejar da sua Activity (como em um clique
de botão) instanciando a classe criada e chamando o método show() no objeto criado, como pode
ser visto no quadro 17.
Pág. 62 de 95
QUADRO 17 – Código para exibir a caixa de diálogo criada no quadro 14
public void onClick(View view) {
fecharDialogFragment.show(getSupportFragmentManager(), “dialog”);
AULA 7 – INTENTS
Provavelmente o uso mais comum de um Intent é a abertura de uma nova tela. Veja no diagrama
da figura 48 como acontece esse processo.
Fonte: <http://developer.android.com/guide/components/intents-filters.html>
A partir da tela inicial (Activity A), usamos o comando startActivity() com uma Intent para
sinalizar ao Android que desejamos abrir uma nova tela. O sistema operacional abre então a Activity
B indicada na Intent e passa a execução ao evento onCreate() nela existente.
Pág. 63 de 95
Veremos na próxima seção quais são os comandos necessários para realizar estas etapas.
Embora esses dois arquivos possam ser criados individualmente, o Android Studio possui um
assistente de criação de Activities que automatiza o processo de criação destes dois arquivos.
Para criar uma nova tela no seu aplicativo, clique com o botão direito do mouse sobre a pasta
app do seu projeto e, no menu que será exibido, selecione File > New >Activity. Escolha o modelo
para a nova tela – pode ser Empty Activity, como indicado na figura 49.
Em seguida (figura 50), dê um nome para sua nova Activity em Activity Name (procure sempre
manter a palavra Activity ao final – é uma convenção dentro do Android nomear activities dessa
forma). Note que à medida que você digita o nome da Activity, o nome do arquivo de layout (Layout
Name) também muda de forma correspondente. Selecione o pacote adequado em Package name
e clique em Finish.
Pág. 64 de 95
Perceba que agora você possui uma nova classe Java na pasta java (dentro do primeiro pacote
de classes) do projeto e um novo arquivo de layout em res\layout! E não é só isso: novas telas devem
ser declaradas no arquivo AndroidManifest.xml do projeto, e isso também já foi feito pelo assistente.
Supondo que você criou uma nova Activity chamada NovaActivity, como na figura 46, para abri-
la você deverá usar os comandos do quadro 18.
É bastante simples: basta declarar um objeto da classe Intent, instanciá-lo e passar ao seu
construtor o contexto atual (this) e o nome da classe da Activity que desejamos abrir. Em seguida,
invocamos o método startActivity() passando o objeto intent como parâmetro.
Existem várias sobrecargas deste método, para que possamos passar diferentes tipos de
valores, e todos eles recebem como primeiro parâmetro uma String que servirá como chave do
valor passado, seguindo a sintaxe putExtra(chave, valor).
Pág. 65 de 95
No exemplo do quadro 19, estamos passando um número double com uma chave denominada
valor e uma String com a chave nome.
intent.putExtra(“valor”, 200.5);
intent.putExtra(“nome”, “Anita”);
startActivity(intent);
Na Activity que será aberta, podemos obter estes valores no seu evento onCreate, como é
mostrado no quadro 20.
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ nova);
É simples: primeiro, obtemos uma referência à Intent que abriu esta tela, com getIntent. Em
seguida, obtemos os parâmetros passados a ele com seu método getExtras() e extraímos dentro
deles os valores que queremos, usando um método getter adequado para os tipos de dados de cada
valor. Por exemplo, como “valor” foi passado como um número double, usamos getDouble; como
“nome” foi passado como String, usamos getString.
Pág. 66 de 95
volume de dados. Neste módulo saberemos como utilizar o SQLite no nosso aplicativo Android para
salvar e posteriormente consultar dados.
Como o próprio nome dá a entender, o SQLite é pequeno: sua versão mais recente ocupa pouco
mais de 650 KB! Mas isso não quer dizer que ele seja pequeno na capacidade, já que pode lidar
com bancos de dados de até 140 Terabytes e que, segundo testes realizados, consegue realizar
cerca de 50.000 inclusões por segundo em um computador desktop padrão (de acordo com dados
disponíveis no site oficial).
Outra característica importante: para criar a estrutura e manipular os dados na tabela, são
usados comandos tipo-SQL, o que facilita bastante a adaptação e migração para o SQLite.
Fonte: https://sqlite.org/images/sqlite370_banner.gif
Por razões como as supracitadas, o SQLite é o banco de dados padrão não só dos aparelhos
com Android, mas também daqueles com iOS! Sim, o iPhone e o iPad também possuem o SQLite
instalado e usam o banco para armazenar boa parte dos dados dos seus aplicativos.
Apesar de a API do SQLite estar originalmente em C, a Google criou classes Java que abstraem
os principais comandos para manipulação do banco.
Pág. 67 de 95
Basta criar uma classe Java básica herdando SQLiteOpenHelper e implementar o seu evento
onCreate, que será usado para criar a(s) tabela(s) do banco (somente quando ele ainda não tiver
sido criado).
No quadro 21 você pode ver um exemplo de classe para abrir e criar um banco de dados com
uma tabela para armazenar a lista de compras criada na seção 5.3.
Pág. 68 de 95
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
@Override
“nome TEXT);”;
db.execSQL(criarTabela);
“VALUES (‘Arroz’)”);
“VALUES (‘Feijão’)”);
@Override
O onCreate é obrigatório, pois será executado quando o aplicativo tentar abrir um banco que
ainda não existe. Ou seja, é ele que faz a criação inicial da estrutura do banco a ser usado!
Pág. 69 de 95
No exemplo do quadro 21, executamos no banco de dados (por meio do objeto db da classe
SQLiteDatabase, recebido por onCreate) um comando SQL CREATE TABLE, para criar a estrutura
da tabela Produtos. Ela possui os seguintes campos:
• _id: o campo inteiro (INTEGER), chave primária (PRIMARY KEY), que será único para cada produto
e será gerado automaticamente (AUTOINCREMENT) como um número inteiro. Precisamos
usar este nome exato (_id) para facilitar a ligação da tabela com um ListView – falaremos
mais sobre isso depois.
• nome: um campo do tipo TEXT (equivalente à String ou VARCHAR em outros SGBDs) para
armazenar a descrição/nome do produto.
• quantidade: um campo inteiro (INTEGER) para guardar a quantidade a ser comprada do produto.
Em seguida, executamos mais três comandos SQL para inclusão (INSERT) de alguns produtos
de exemplo no banco, junto das suas respectivas quantidades.
SAIBA MAIS
Para saber mais sobre a sintaxe SQL e tipos de dados suportados pelo SQLite, acesse a
documentação oficial em http://www.sqlite.org/docs.html.
Esta classe é comumente conhecida como classe DAO (Data Access Object), que é que uma
classe Java padrão que encapsula todos os procedimentos de manipulação dos dados, assim como
abertura e fechamento do banco.
Para utilizá-la no seu aplicativo, crie uma classe Java padrão e chame-a de Dao. Acrescente a
ela o código existente no quadro 22.
Pág. 70 de 95
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
null, 1);
banco = bancoOpenHelper.getWritableDatabase();
if (banco != null)
banco.close();
}
novoProduto.put(“nome”, nome);
produtoAlterado.put(“nome”, nome);
Pág. 71 de 95
• Como na classe Dao realizaremos todo o acesso ao banco, precisamos ter dentro dela uma
instância de SQLiteDatabase e outra de BancoListaOpenHelper;
• O construtor desta classe recebe um Context como parâmetro. Ele chamará por sua vez o
construtor de BancoListaOpenHelper passando a ele: o contexto atual; uma String especificando
um nome para o arquivo de banco de dados; null no terceiro parâmetro, pois não usaremos
CursorFactory; e 1 no último parâmetro, sendo este o número de versão do banco. O objeto
instanciado ficará armazenado em bancoOpenHelper;
• O método abrir faz a obtenção do objeto SQLiteDatabase gravável que servirá de “ponte de
acesso” ao arquivo de banco de dados, por meio do método getWritableDatabase do openHelper;
assim, seu retorno deve ficar armazenado em um objeto SQLiteDatabase-banco;
• Já o método fechar realiza o fechamento de banco, caso este seja diferente de null (significando
que o mesmo foi aberto);
• O método inserirProduto é uma abstração para o método insert existente no objeto banco.
Passamos ao inserirProduto um nome de produto e uma quantidade, para serem inseridos
como um novo registro do banco. Um objeto da classe ContentValues chamado novoProduto
é então usado para fazer a correspondência entre os campos da tabela e os valores a serem
colocados neles, por meio do seu método put(campo, valor). Este objeto é então passado ao
método insert, junto do nome da tabela na qual o registro será incluído;
• A modificação de um produto na lista é feita com o método alterarProduto. Seu funcionamento
é muito parecido com inserirProduto, contudo, como estamos alterando os valores de um
produto existente, passamos ao alterarProduto o id do produto sendo modificado, junto dos
(possíveis) novos valores para nome e quantidade. Este id será usado para montar a cláusula
de condição de alteração (“_id = “ + id) no método update do objeto banco;
Pág. 72 de 95
• Para excluir um produto, usamos o método removerProduto, que recebe como parâmetro o id
do registro a ser excluído. Este id é então usado na condição de exclusão do método delete,
existente no objeto banco;
• Por fim, temos o método obterTodosOsProdutos. Ele retorna um objeto da classe Cursor do
Android, que é um ponteiro para um conjunto de registros.
Este cursor é criado por meio de uma consulta gerada com o método query, que faz um SELECT
no banco de acordo com os parâmetros que recebe, sendo eles, em ordem sequencial:
Agora, podemos voltar à Activity. Nela, utilizaremos estes métodos da classe Dao para fazer a
interação com o banco de dados.
Para poder mostrar os dados da tabela no ListView, usaremos uma nova classe: SimpleCursor
Adapter, o adaptador de listas usando cursores como fonte de dados.
Pág. 73 de 95
import android.app.ListActivity;
import android.os.Bundle;
import android.support.v4.widget.SimpleCursorAdapter;
import android.view.View;
import android.widget.EditText;
import android.widget.ListView;
EditText edtProduto;
Dao dao;
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ main);
dao.abrir();
this,
dao.obterTodosOsProdutos(),
new String[]{“ _ id”, “nome”},
0);
setListAdapter(adaptador);
edtProduto = (EditText)findViewById(R.id.edtProduto);
dao.inserirProduto(produto);
Pág. 74 de 95
adaptador.swapCursor(dao.obterTodosOsProdutos());
edtProduto.setText(“”);
@Override
dao.removerProduto(id);
adaptador.swapCursor(dao.obterTodosOsProdutos());
@Override
dao.fechar();
super.onDestroy();
• Comparando com a versão anterior, usando ArrayList para armazenar os dados, temos como
primeira mudança a declaração da variável global dao, objeto da classe Dao. Usaremos este
objeto para acessar os métodos da classe Dao dentro dos eventos da Activity;
• No onCreate, passamos a usar agora o SimpleCursorAdapter para conectar a lista aos dados.
Ele recebe como parâmetros:
◊ O nome de um layout para cada linha da lista – neste caso, usamos o layout simple_list_
item_2 do Android, que exibe duas linhas de texto (a de cima com fonte grande e a de baixo
com fonte pequena);
◊ O cursor que trará os dados do banco – isso será feito pelo método obterTodosOsProdutos
da classe Dao;
◊ Um vetor de Strings com os nomes dos campos trazidos pelo cursor que serão exibidos
na lista;
Pág. 75 de 95
◊ Um vetor de ints com os ids dos widgets, no qual os campos do parâmetro anterior serão
colocados, respectivamente; android.R.id.text1 indica a linha grande de cima e android.R.id.
text2 indica a linha de baixo com fonte pequena;
Aliando os dados do GPS a um serviço de mapas, como o Google Maps, o usuário poder ter no
seu celular um dispositivo de localização e de planejamento de rotas e itinerários imprescindível.
No Android, os dados de localização são fornecidos pelos Location Services. O primeiro passo
para utilizá-los em um aplicativo é solicitar sua utilização quando o usuário iniciar o programa. Isso
Pág. 76 de 95
Outro requisito importante: Nas novas versões do Android, o acesso aos serviços de localização
é feito pelo Google Play Services. Dessa forma, para que os recursos de localização funcionem
corretamente, é preciso que o aparelho do usuário tenha o Google Play instalado e atualizado.
Mais um requisito: para desenvolver usando o Google Play Services, é preciso instalar o pacote
necessário usando o SDK Manager. Para abri-lo, clique no botão da barra de ferramentas do Android
Studio indicado na figura 52.
Na janela que será mostrada, clique na aba SDK Tools e, logo abaixo, marque a caixa relativa ao
Google Play Services (figura 53). Clique então em OK para que ele seja baixado e instalado.
Pág. 77 de 95
Depois de clicar em OK, será feito o download e instalação da biblioteca do Google Play Services.
Pode ser que seja solicitada a confirmação do download ou da licença de uso da biblioteca, bastando
aceitá-la para iniciar a instalação.
....
compile ‘com.google.android.gms:play-services:9.4.0’
Cumpridos todos estes requisitos, ainda é preciso que sejam implementados alguns eventos
na Activity, em que será feito o acesso aos serviços de localização. Veja o exemplo no quadro 26.
Pág. 78 de 95
import android.content.pm.PackageManager;
import android.location.Location;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationServices;
GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
GoogleApiClient googleApiClient;
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ main);
if (googleApiClient == null) {
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
Pág. 79 de 95
googleApiClient.connect();
super.onStart();
googleApiClient.disconnect();
super.onStop();
if (ActivityCompat.checkSelfPermission(this,
!= PackageManager.PERMISSION _ GRANTED) {
ActivityCompat.requestPermissions(this,
0);
return;
gleApiClient);
if (localizacaoAtual != null) {
“ALTITUDE: “ + altitude;
Pág. 80 de 95
textView.setText(texto);
@Override
Toast.LENGTH _ SHORT).show();
@Override
Toast.LENGTH _ SHORT).show();
@Override
Toast.LENGTH _ SHORT).show();
• Para poder usar os Location Services, a classe, logo na sua declaração, deve dizer que implementa
(usando a palavra chave implements) as interfaces: GoogleApiClient.ConnectionCallbacks
e GoogleApiClient.OnConnectionFailedListener
• Declaramos globalmente na classe um objeto da classe GoogleApiClient, que servirá como
nosso cliente de acesso ao Google Play Services;
• No evento onCreate da Activity, instanciamos o objeto googleApiClient;
• No evento onStart da Activity chamamos o método connect do objeto googleApiClient, que
fará a conexão ao serviço; de forma equivalente, chamamos o método disconnect no evento
onStop da Activity;
• Quando o usuário clicar no botão no qual está designado o método onClick, primeiramente
solicitaremos a permissão do usuário para acessar sua localização, se isso ainda tiver sido
feito (ActivityCompat.checkSelfPermission); em seguida, obteremos a última localização válida
usando o método getLastLocation do LocationServices, cujo retorno é armazenado em um
objeto da classe Location; desse objeto, podemos obter a latitude, longitude e altitude atual,
que exibimos ao usuário em um TextView;
Pág. 81 de 95
SAIBA MAIS
EXIBINDO MAPAS
Para exibir a localização do usuário em um mapa do Google Maps, é preciso antes se registrar no
serviço, obter uma chave de acesso e depois adaptar seu aplicativo à API do Google Maps. Mais
detalhes em: <http://developer.android.com/google/play-services/maps.html>
• URL: usada para representar o endereço a um recurso na Web, ou seja, um site ou Web Service;
• HttpUrlConnection: permite a realização de uma conexão a uma URL por meio do protocolo
HTTP.
Além delas, utilizaremos também uma classe do pacote org.json para poder extrair os dados
recebidos dos Web Services. O formato JSON é oriundo do JavaScript, e é utilizado para obtermos
uma representação em modo texto de objetos, com os dados no formato “chave” : “valor”. Um objeto
JSON é um conjunto de chaves e valores delimitados por { e }.
Para saber como usar estas classes para se conectar a um Web Service REST, veja o código
do quadro 27, com comentários explicando seu funcionamento.
Pág. 82 de 95
QUADRO 27 – Código de exemplo para conexão a um Web Service e recepção de dados em JSON
package net.querino.dicionario;
import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
String respostaJSON;
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ main);
new ConsultaWebService().execute(“”);
HttpURLConnection urlConnection;
Pág. 83 de 95
@Override
try {
“parametro=valor”
);
urlConnection = (HttpURLConnection)url.openConnection();
InputStream in = new
BufferedInputStream(urlConnection.getInputStream());
BufferedReader(new InputStreamReader(in));
String linha;
resultado.append(linha);
} catch (Exception e) {
Pág. 84 de 95
e.printStackTrace();
finally {
urlConnection.disconnect();
respostaJSON = resultado.toString();
return true;
@Override
JSONObject objetoJSON;
try {
} catch (JSONException e) {
e.printStackTrace();
Pág. 85 de 95
Tirar e salvar a foto em um aparelho Android é um processo que envolve o uso de várias classes.
No código do quadro 29, temos uma Activity com um evento de clique de botão que abre a câmera
e salva a foto obtida no sistema de arquivos do Android.
QUADRO 29 – Código completo de uma Activity para tirar e salvar uma foto
package com.example.professores.cameraaudio;
import android.content.Intent;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
String caminhoParaFoto;
Environment.DIRECTORY _ PICTURES);
pastaDeGravacao);
Pág. 86 de 95
return imagem;
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ main);
if (intentParaTirarFoto.resolveActivity(getPackageManager()) != null) {
try {
arquivo = criarArquivoDaFoto();
if (arquivo != null) {
intentParaTirarFoto.putExtra(MediaStore.EXTRA _ OUTPUT,
Uri.fromFile(arquivo));
startActivityForResult(intentParaTirarFoto, 1);
Pág. 87 de 95
ACONTECEU
Em 2013, a NASA, agência espacial americana, lançou três satélites feitos com smarphones Android.
Os satélites possuíam o tamanho de uma caixa de 25 cm e custavam entre 3.500 e 7.000 dólares, o
que é um valor incrivelmente barato perto de um satélite convencional, que pode custar milhões!
<http://exame.abril.com.br/ciencia/nasa-coloca-em-orbita-satelites-feitos-com-smartphones/>
import android.content.Intent;
import android.net.Uri;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.VideoView;
VideoView videoView;
@Override
super.onCreate(savedInstanceState);
setContentView(R.layout.activity _ video);
videoView = (VideoView)findViewById(R.id.videoView);
}
Intent takeVideoIntent =
Pág. 88 de 95
if (takeVideoIntent.resolveActivity(getPackageManager()) != null) {
startActivityForResult(takeVideoIntent, 1);
@Override
videoView.setVideoURI(uriDoVideo);
Pág. 89 de 95
<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android”
xmlns:tools=”http://schemas.android.com/tools”
tools:context=”com.example.professores.cameraaudio.VideoActivity”>
<Button
android:text=”Gravar Vídeo”
android:id=”@+id/button2”
android:layout _ alignParentTop=”true”
android:layout _ alignParentLeft=”true”
android:layout _ alignParentStart=”true”
android:onClick=”onClickGravarVideo” />
<VideoView
android:layout _ width=”wrap _ content”
android:id=”@+id/videoView”
android:layout _ below=”@+id/button2”
android:layout _ alignParentLeft=”true”
android:layout _ alignParentStart=”true”
</RelativeLayout>
Pág. 90 de 95
Com a MediaPlayer, é possível reproduzir arquivos de áudio nos formatos suportados pelo
Android, que são: MP3, MP4, M4A, WAV, AAC, MIDI, FLAC e Ogg Vorbis (.ogg).
Você deverá acrescentar seus arquivos de áudio em uma pasta denominada raw, dentro da
pasta res, no seu projeto. Esta pasta não existe inicialmente; para criá-la, clique com o botão direito
do mouse sobre a pasta res do seu projeto e selecione New... > Folder. Forneça o nome raw para a
pasta e clique em Finish.
Criada a pasta, arraste seus arquivos de áudio para ela, lembrando de, ao soltar, selecionar a
opção Copy Files para que uma cópia do arquivo seja colocada no projeto.
mediaPlayer.start();
}
CONSIDERAÇÕES FINAIS
Então é isso! Chegamos ao final de mais uma etapa deste curso. Parabéns!
Aproveitando boa parte do conhecimento em Java que você já havia adquirido, pudemos agora
transportá-los para uma nova plataforma, agregando as novidades e mudanças existentes em um
app Android.
Pág. 91 de 95
Como você pode perceber, um desenvolvedor Java experiente pode começar a criar aplicativos
Android em pouco tempo. Isso abre de imediato uma grande gama de oportunidades de desenvolvimento
de novos aplicativos, assim como a migração de outros já existentes para essa nova plataforma.
O mercado de aplicativos móveis está literalmente “pegando fogo” neste momento – por isso,
arregace as mangas, junte os conceitos aprendidos nesta disciplina com os que você já possui, “dê
asas” à sua imaginação e comece já a criar e publicar seus próprios programas.
Desejo a todos boa sorte e muito sucesso nos seus projetos “móveis”!
Prof. Querino
GLOSSÁRIO
Startups
Uma empresa de tecnologia que acaba de ser aberta, ainda em fase de desenvolvimento.
Formato Binário
Metadados
São os dados sobre outros dados. É a informação interpretada pelo computador que relaciona
um tipo de dado a outra informação, qualidade ou característica. Disponível em: <https://pt.wikipedia.
org/wiki/Metadados>. Acesso em: 24 jan. 2017.
Parser
Pág. 92 de 95
Emulador
É um software que reproduz um determiando ambiente para executar outros softwares, simulando
o comportamento de uma configuração de hardware ou sistemas específicos, permitindo que um
software criado para uma platforma específica funcione em outra diferente. Disponível em: <https://
pt.wikipedia.org/wiki/Emulador>. Acesso em: 24 jan. 2017.
Domínio
Widget
Interface
Interface é o conjunto de meios para adaptar dois sistemas com o objetivo de alcançar um
resultado que possui características comuns aos dois sistemas. São as ferramentas utilizadas para
uso e movimentação de qualquer sistema de informação. Disponível em: <https://pt.wikipedia.org/
wiki/Interface>. Acesso em: 24 jan. 2017.
Variável
Pág. 93 de 95
REFERÊNCIAS BIBLIOGRÁFICAS
ARNOLD, K.; GOSLING, J.; HOLMES, D. A Linguagem de Programação Java. Porto Alegre: Bookman,
2007.
DEITEL, H. et al. Android for Programmers: An App-Driven Approach. Upper Saddle River: Pearson
Education, 2012.
DEVELOPER ANDROID. These are the Android APIs. 2014. Disponível em: <http://developer.android.
com/reference/packages.html>. Acesso em: 20 ago. 2014.
FAWCETT, J.; QUIN, L.R.E. Beginning XML: 5th Edition. Indianapolis: John Wiley & Sons, Inc, 2012.
GOSLING, J.; MCGILTON, H. The Java Language Environment. 1997. Disponível em: <http://www.
oracle.com/technetwork/java/intro-141325.html>. Acesso em: 20 ago. 2014.
JAVA 7 API. Java™ Platform, Standard Edition 7 API Specification. 2014. Disponível em: <http://docs.
oracle.com/javase/7/docs/api/>. Acesso em: 20 set. 2014.
MEIER, R. Professional Android 4 Application Development. Indianapolis: John Wiley & Sons, Inc.,
2012.
PHILLIPS, B.; HARDY, B. Android Programming: The Big Nerd Ranch Guide. Indianapolis: Pearson
Education, 2013.
Pág. 94 de 95
QUERINO FILHO, L. C. Desenvolvendo seu Primeiro Aplicativo Android. São Paulo: Novatec, 2013.
Sites importantes:
http://developer.android.com/index.html
http://www.eclipse.org
http://www.sqlite.org
Pág. 95 de 95