Sumrio

1 Introduo a programao para dispositivos mveis.........................................................................1

1.1 Aplicaes, Bibliotecas, Kernel.................................................................................................1
1.2 Arquitetura Android...................................................................................................................1
1.3 Estrutura Geral (Componentes Android)...................................................................................2
1.4 Componentes Para Desenvolvimento Android..........................................................................3
1.5 Preparando Ambiente Para Instalao do Android Studio.........................................................4
1.6 Compilao e Empacotamento Projetos Android......................................................................4
1.7 IDE Android Studio...................................................................................................................6
1.8 Configurando Sem Ambiente Para Desenvolvimento...............................................................7
1.8.1 Preparando SDK................................................................................................................7
1.8.2 Preparando AVD.................................................................................................................8
2 Definindo Layout de Aplicaes Android.......................................................................................10
2.1 Criando e Estruturando um Projeto.........................................................................................10
2.2 Widgets....................................................................................................................................15
2.2.1 TextView..........................................................................................................................15
2.2.2 Button...............................................................................................................................15
2.2.3 ToggleButton....................................................................................................................16
2.2.4 CheckBox.........................................................................................................................16
2.2.5 RadioGroup e RadioButton..............................................................................................16
2.2.6 Spinner.............................................................................................................................17
2.2.7 EditText............................................................................................................................17
2.2.8 ImageView.......................................................................................................................17
2.3 Gerenciadores de Layout.........................................................................................................18
2.3.1 RelativeLayout.................................................................................................................18
2.3.2 LinearLayout....................................................................................................................20
2.3.3 GridLayout.......................................................................................................................21
3 Manipulando Informaes...............................................................................................................22
3.1 Evento de Click........................................................................................................................22
3.2 Capturando e Gerando Informaes da Tela............................................................................24
3.3 Transio de Telas com Activity..............................................................................................26
3.4 Transferindo Informaes entre Atividades.............................................................................28
4 Bibliografia......................................................................................................................................31
1 Introduo a programao para dispositivos mveis
Introduo
Iniciamos agora a entrada no mundo da plataforma Android, nesse momento conheceremos as
caractersticas da plataforma, um pouco de sua histria, seus componentes e assim poderemos
trabalhar cada funo. Nessa unidade tambm exploraremos as bibliotecas que fazem parte do
contexto da plataforma, conheceremos e entenderemos o funcionamento dos itens nativos do
Android, ver a integrao do mesmo com a Java Development Kit (JDK), estudar o processo
configurao e instalao do ADT Bundle, pacote de desenvolvimento para Android, e
compreenderemos o processo de instalao do SDK Android e Android Virtual Device nas
plataformas Windows e Linux.

1.1 Aplicaes, Bibliotecas, Kernel

O Android uma S.O (Sistema Operacional) mvel, desenvolvida pela Google que em 2007 tornou
pblica uma verso baseada na plataforma Java com sistema operacional Linux, hoje o Android
mantido pela OHA(Open Handset Alliance), um grupo de empresas que se uniram com oo objetivo
de dar suporte ao desenvolvimento de solues para a plataforma mvel.
Entre essas empresas podemos encontrar gigantes como: Vodafone, Telecom, Telefnica, Acer,
Asus, Dell, Huawei, Lenovo, LG, Motorola, Samsung, entre outras.

Saiba mais sobre OHA(Open Handset Aliance), seus membros e as aes que esse grupo de
empresas desenvolve em prol do desenvolvimento com uso da plataforma livre Android:
http://www.openhandsetalliance.com/oha_members.html

Inicialmente os aparelhos (SmarthPhones) que chegaram ao mercado brasileiro com essas

caractersticas foram o Motorola Milestone e o Samsung Galaxy.
Agora para entendermos um pouco da estrutura dessa plataforma vamos fazer algumas definies:
Assim como um sistema operacional convencional o Android possui uma srie de caractersticas
prprias. Ou seja, para entendermos seu funcionamento e conseguirmos desenvolver para ele
temos que antes compreend-lo.
Ele possui um SDK (Software Development Kit) um Kit para desenvolvimento de aplicaes que
trabalharemos nesse curso.

1.2 Arquitetura Android

S.O. desenvolvido pela Google baseado em Linux. De acordo com as prprias organizaes,
empresas como Motorola, LG, Sansung e Sony desenvolvem seus aparelhos utilizando o Android
como dispositivos fabricados, grande motivo pelo seu grande crescimento nos ltimos anos. A
Figura 1 ilustra as camadas responsveis pelo funcionamento do sistema operacional.

1
 Figura 1: Arquitetura Android

1.3 Estrutura Geral (Componentes

Android). Vocabulrio
Como todo sistema operacional o android tambm Nativo Prprio
possui itens nativos, em outras palavras, componentes SGBD Sistema Gerenciador de
Banco de Dados
que j vem com o sistema, mdulos que podem ser
SDK Software Development Kit
usados por outras aplicaes e que podem ser ou no
dependentes do Hardware.
Abaixo listamos os itens nativos mais completos dessa
plataforma:

Independentes do Hardware
Dalvik virtual machine: Uma mquina virtual como a JVM do Java porm otimizada para
dispositivos mveis.
Browser Integrado baseado no webkitengine.
Grficos Otimizados possui uma biblioteca 2D e 3D baseada na especificao OpenGL ES
1.0
SQLite: Um SGBD, para guarda de dados na prpria plataforma.
Suporte multimdia: Para udio, vdeo e formatos de imagem (MPEG4, MP3, AAC, AMR,
JPG, PNG, GIF).

Dependentes do Hardware
Telefonia GSM
Bluetooth, EDGE, 3G, e WiFi
Cmera, GPS, compasso, e acelermetro

2
Alm dos itens j citados acima o Android possui um conjunto de aplicaes como cliente de email,
agenda, mapas, etc. Uma base de bibliotecas para uso de softwares e componentes de sistemas
como mltiplas camadas 2D e 3D, bibliotecas baseadas em C especiais para dispositivos rodando
Linux, FreeType para fontes, etc.

O runtime, ou seja, ambiente de execuo de aplicaes Android possui uma peculiaridade: Cada
aplicao Android roda em seu prprio processo com sua prpria instncia de mquina virtual
(Dalvik). Ela executa arquivos .dex, projetados para consumir o mnimo de memria. O Kernel
Linux, baseado na verso 2.6 trata servios como Gesto de memria, gesto de processos,
segurana, etc.

1.4 Componentes Para Desenvolvimento Android.

Antes de mais nada vamos entender cada componente que preenche as partes do ambiente para
desenvolvimento Android.
necessrio uma srie de aplicativos e plugins para que possamos ter o ambiente para uso do
Android:

1 O Kit de desenvolvimento Java JDK Que contm a mquina virtual Java e as ferramentas
para desenvolvedores nessa linguagem, como o compilador Java, etc.

2 O SDK(Android) para desenvolvimento Conjunto de ferramentas e APIs que compem o kit

para desenvolvimento android.

3 AVD(Android Virtual Device) Uma ferramenta que emula um Sistema Operacional Android
em sua mquina.

4 O Android Studio IDE (Ferramenta de desenvolvimento) Ambiente de desenvolvimento para

Android desenvolvida pela Google

Levando em consideraes que j conhecemos a estrutura de programao e Java, iremos apenas

passar rapidamente pelos mesmos dando enfoque maior para o SDK do Android e ao Android
Studio. At pouco tempo tnhamos que fazer download e instalar cada um desses itens para o
funcionamento, o que demandava bastante tempo com configurao. Para suprir essa
necessidade, os desenvolvedores resolveram criar um pacote que contm todas as
funcionalidades e aplicativos necessrios para funcionamento do Android em sua mquina que
pode ser baixado na pgina de desenvolvedores.

Para fazer o Download do Android Studio que contm os componentes necessrios para
instalao da plataforma Android no seu computador acesse o link:
http://developer.android.com/sdk/index.html

Nesse pacote voc tem em um s lugar:

Android Studio Ferramenta Para desenvolvimento Android.

Android SDK Tools (Todas as ferramentas de desenvolvimento do Android).

3
 Android Platform-tools (ferramentas da plataforma android, como AVD (Android Virtual
Device, um emulador para o android no seu computador).
A ltima plataforma Android (Ultima verso distribuda do android).
A ltima imagem do sistema Android para o emulador (Verso do android para o
emulador).

Isso facilitou muito a vida dos desenvolvedores, pois juntou em um nico pacote tudo que o
que os programadores precisam para trabalhar com a plataforma android. Vamos agora
conhecer esses componentes:

1.5 Preparando Ambiente Para Instalao do Android Studio

Antes de Iniciar a instalao do Ambiente de Desenvolvimento Android Studio, certifique-se que a
verso Java est instalada:

Para Linux:

Para Windows:

1.6 Compilao e Empacotamento Projetos Android.

Iremos agora entender de uma forma mais detalhada qual a funo de cada componente
necessrio para o Desenvolvimento para aplicativos Android.
Quem estuda linguagens de programao, certamente j ouviu falar em JAVA, essa linguagem de
programao que domina o mercado. O JDK um kit que contm uma srie de aplicativos
necessrios para quem pretende desenvolver usando essa linguagem, ou seja, ele cria todo o
ambiente necessrio para que as aplicaes Java possam ser: compiladas, interpretadas e
executadas.

Dentro dos JDK ns temos uma ferramenta chamada JVM (Java Virtual Machine), ou seja,
mquina virtual Java, essa ferramenta consegue rodar as aplicaes Java de forma que diversas
plataformas possam us-lo. Porm para executar especificamente aplicaes android temos que
ter o pacote AVD(Android Virtual Device), portanto deve ser instalado separadamente. Observe a
imagem abaixo que representa o funcionamento da JVM:

4
 Cdigo Java

Compilador

Bytecode Java.

VM Windows VM Linux VM Celular

S.O Windows S.O Linux S.O Celular

Desenho 1: Compilao com JVM

Observe que temos o ambiente de desenvolvimento onde escreveremos e compilar o JAVA, em

seguida gerado pelo compilador um cdigo intermedirio chamado: bytecode, ele pode rodar em
diversas mquinas virtuais, por isso o cdigo Java independente de plataforma, a nica coisa
necessria para que o Java rode em determinado sistema que l exista uma mquina virtual
Java que entenda os bytecodes. Assim, temos diversas mquinas virtuais para diversas
plataformas: Linux, Windows e dispositivos mveis.

Para ter uma aplicao android executvel Android necessrio que de um SDK(Software
development kit). Ele contm um componente responsvel por fazer o Processo de
empacotamento, reunindo no apenas o bytecode, mas tambm arquivos de configurao, layout,
imagens sons, vdeos e outros. O resultado final gerado um arquivo no formato .apk. A Figura 2
ilustra o processo at a gerao do executvel.

Figura 2: Empacotamento Android

5
1.7 IDE Android Studio
Devido ao vasto conjunto de pacotes necessrio para desenvolver e executar aplicativos Android
em uma mquina a Google desenvolveu um Ambiente prprio para o a criao de aplicativos para
o Sistema Operacional Android, essa Ferramenta chama-se Android Studio.

Figura 3: Android Studio

http://developer.android.com/sdk/index.html
Quem j ouviu falar sobre linguagens de programao, certamente j ouviu falar sobre IDEs, ela
um ambiente de desenvolvimento integrado, que permite ao desenvolvedor dispor de ferramentas
que facilitaro sua vida durante o processo de criao de software, uma IDE traz consigo inmeras
funes para facilitar a vida de quem programa, como exemplo podemos citar o fato de
autocompletar o cdigo ao digitarmos determinado trecho de uma linguagem. Observe a Figura 4:

Figura 4: IDE Android Studio v2.2

Atravs dessa IDE podemos baixar Ferramenta SDK e Platform-tools para acesso ao AVD. Assunto
que iremos ver nos prximos tpicos.

6
1.8 Configurando Sem Ambiente Para Desenvolvimento.

1.8.1 Preparando SDK

O primeiro passo configurar o nosso SDK, acesse no menu Principal: Tools > Android > SDK
Manager. Antes de Clicar, certifique-se de deixar habilitado a opo Enable ADB Integration.

Figura 5: Configurando SDK 1

Na rea do SDK, aparecer um conjunto de verses Android com suas respectivas APIs, Escolha
Android 7.0 utilizando API 24, instalei tambm outras verses que deseja desenvolver para
projetos futuros. Observe a Figura 6.

Figura 6: Configurando SDK 2

7
Ao Clicar em OK. Todos os pacotes necessrios sero baixados e instalados em seu computador,
caso necessrio Clique em: Launch Standalone SDK Manager para visualizar todos os pacotes
de forma mais detalhada.
1.8.2 Preparando AVD
Como dito em tpicos anteriores, AVD significa (Android Virtual Device). Depois que criarmos
nossa primeira aplicao precisaremos dele para executar nosso projeto. Para criar nosso primeiro
Emulador basta ir em : Tools > Android > AVD Manager como na Figura 7.

Figura 7: Configurando AVD 1

Inicialmente, voc precisa criar um emulador utilizando as configuraes que baixou no processo de
instalao do SDK. No final do processo, aparecer uma janela com esse contedo:

Figura 8: Configurando AVD 2

Ocorrendo tudo certo, ao clicar no boto Run na Coluna Actions abrir o emulador com a
seguinte Janela:

8
Nesse momento configuramos com sucesso nosso
emulador, todas as aplicaes desenvolvidas no
Android Studio passar pelo processo de
compilao, empacotamento e ir ser direcionada
para esse emulador..

OBS 1: Se deseja executar em outra verso do

android, basta voltar ao SDK, baixar os pacotes de
instalao da verso desejada e preparar um
emulador para a verso escolhida.
OBS 2: Se tiver um aparelho android com verso
compatvel com seu SDK, poder executar
diretamente de dele oferecendo as permisses
necessrias.

Com nosso ambiente preparado, Iremos no

prximo Captulo comear a criar nossos Figura 9: Emulador AVD
primeiros projetos e comear a pr a mo na massa com os Aplicativos!!!!!

9
2 Definindo Layout de Aplicaes Android
Agora chegamos ao momento de iniciarmos o desenvolvimento das aplicaes Android. O
desenvolvimento dessas aplicaes requer o conhecimento das estruturas que compem um
projeto para a plataforma, nessa unidade comearemos a compreender as estruturas SRC, GEN e
RES, bem como as estruturas de Layout que facilitam a construo de um projeto para essa
aplicao. Veremos a funo de cada estrutura e com exemplos ilustraremos a criao de
aplicaes.
Compreenderemos tambm os diretrios de sada de projeto onde identificaremos o local de
encontro dos executveis Android. E em seguida o uso dos Widgets que so os componentes
grficos e no-grficos que compem a plataforma android. Nosso objetivo : Entender os
componentes de um projeto android no Android Studio, verificando cada diretrio e sua funo.
Tambm reconheceremos e faremos uso das estruturas de diviso do projeto e suas camadas,
determinando assim o uso de mdias extras dentro do projeto; Usaremoos o compilador para
criao dos aplicativos; Definiremos o passo a passo para a criao uma aplicao Android;
Exportaremos a aplicao Android para Smartphones ou Tablets e realizaremos sua instalao; Por
fim, conheceremos e faremos uso dos widgets Android nas aplicaes com exemplos.

2.1 Criando e Estruturando um Projeto.

Projetos Android seguem os mesmos passos de aplicaes Java, a criao de um projeto gerar
uma srie de diretrios que iro compor toda a estrutura lgica de uma aplicao como diretrios e
arquivos de configurao observe a sequncia iniciando em: File > New > New Project

Figura 10: Criando um Projeto 1

Na Figura 10 definimos o nome do projeto, o seu domnio de acesso e o caminho que ele ficar
guardado, passando para a tela seguinte temos:

10
 Figura 11: Criando um Projeto 2

Aqui definiremos em qual verso do SDK mnimo rodar nossas aplicaes. Como instalamos e
baixamos a verso Android 7.0 com API 24, criaremos nosso projeto nessa verso tambm.
Passando para a tela seguinte temos:

Figura 12: Criando um Projeto 3

Agora precisamos definir um layout padro para o nosso projeto. Para nosso projeto inicial iremos
escolher Empty Activity, na tela seguinte temos:

11
 Figura 13: Criando um Projeto 3

Aqui definiremos o nome da Classe Principal que trabalhar com nossa Tela inicial, deixaremos
com o nome MainActivity, por fim clicamos em Finish.

Com isso, o Android Studio criar algumas pastas e arquivos com definies padres do nosso
Projetos, entenderemos o que cada pasta representa no nosso projeto.

Manifest: Toda aplicao Android dever ter

um AndroidManifest.xml, o arquivo contm informaes
Essncias sobre o aplicativo, como nome do aplicativo,
Domnio, telas que sero carregadas, etc.

Java: Aqui ficaro todos os cdigos java do Projeto,

basicamente todas as regras de camada de controle e
modelo feitas em Java ficaro organizadas nessa pasta.

Res: Abreviao de resource, nessa pasta ficar todos

os recursos da aplicao, como telas em xml, imagens
Icones, sons etc..

Grandle Script: Aqui uma rea para as configuraes do

seu aplicativos, como verso mnima suportada.

12
 Agora que entendemos um pouco as pastas, inicialmente vamos compreender como
funciona a classe Principal da nossa aplicao. MainActivity.java

Resumindo, a nossa classe MainActivity precisa estender de AppCompactActivity. Essa classe

contm alguns mtodos para processamento de telas. Essa classe nos possibilita usar o mtodo
onCreate que ser executada ao ser carregado. Internamente utilizaremos o mtodo
setContentView, que receber como parmetro uma tela chamada ao layout activity_main que
nossa tela principal.

OBS: A Classe R uma classe definida para capturar informaes da nossa camada de viso, no
nosso contexto atual, estamos acessando rea de layout e acessando nosso layout inicial.

Figura 14: Classe MainActivity

Nossa classe MainActivity est pronta para carregar o layout principal, antes de e executarmos o
projeto, vamos at nossa main_activity.xml e realizar algumas alteraes na tela.

Entrando na pasta res > layout > main_activity.xml podemos visualizar a tela que ser carregada
na Figura 15 :

13
 Figura 15: Layout Principal

Ao clicar em activity_main.xml podemos ver como a interface. Nela trabalharemos a camada de

viso: A esquerda temos a Paleta onde podemos trabalhar com nossos Widget, ou seja,
componentes da nossa tela, no centro podemos ver como ficar nossa tela, e a direita podemos ver e
alterar algumas propriedades de cada elemento.

OBS: todo layout nativo android utiliza-se da linguagem XML que basicamente uma linguagem
de marcao onde podemos definir ordem e propriedades, abaixo podemos ver 2 Abas: Design e
Text, ao clicar em Text podemos ver todas as informaes escritas em XML dessa tela.

Ao executar nosso projeto no Android Studio no menu

Principal em Run > app, ser perguntado em qual emulador
rodar. Como configuramos um emulador inicialmente, basta
escolher o emulador configurado que abrir o que foi feito
j..

1 Crie uma tela que representar uma rea de Login

utilizando s elementos da Paleta do Android Studio

2 Crie uma tela que pedir 2 nmeros e somar.

3 Crie uma tela que simular uma lista de contatos.

14
2.2 Widgets
Os Componentes que compem um layout so criados a partir de widgets, mostraremos na
apostila qual XML gerado para cada componente apresentando algumas propriedades de cada
elementos. Antes de entendermos qualquer componente temos que compreender como funciona o
redimensionamento deles, existem 2 propriedades bsicas:

1. android:layout_width: Define a largura de um componente.

2. android:layout_height: Define a Altura de um Componente.

Os valores que so atribudos a eles podem ser representados por 4 elementos:

1. match_parent: Esse valor faz o elemento ter a mesma largura ou altura do elemento pai.

2. wrap_content: Esse valor faz o elemento ter a largura ou a altura suficiente englobar o seu
contedo.

3. fill_parent: Mesmo que match_parent. Recomenda-se utilizar o valor match_parent a partir

da API Level 8.

4. Valor: Uma dimenso, ou seja, um valor numrico utilizando uma das unidades de medida
suportadas na plataforma Android.

Sabendo dessa propriedade Podemos comear a estudar nossos Widgets!!!!

2.2.1 TextView

TextView basicamente um componente onde pode inserir uma informao em formato de texto
muito parecido com a estrutura de uma label. Sua criao em formato XML logo abaixo:

1. <TextView
2. android:layout_width="wrap_content"
3. android:layout_height="wrap_content"
4. android:text="Ol Mundo!" />

Nesse contexto podemos dizer que meu textview ira ter uma largura to tamanho do seu contedo:
Ol Mundo!.
2.2.2 Button
1. <Button
2. android:text="Button"
3. android:layout_width="wrap_content"
4. android:layout_height="wrap_content"
5. android:id="@+id/button" />

15
2.2.3 ToggleButton
Este um elemento que variar entre ON e OFF de acordo com o pressionar do usurio.

1. <ToggleButton
2. android:text="ToggleButton"
3. android:layout_width="wrap_content"
4. android:layout_height="wrap_content"
5. android:id="@+id/toggleButton" />

2.2.4 CheckBox
Esse elemento permite uma seleo individual do usurio, em nvel de controle, esse elemento
poder retornar verdadeiro ou falso.

1. <CheckBox
2. android:text="CheckBox"
3. android:layout_width="wrap_content"
4. android:layout_height="wrap_content"
5. android:id="@+id/checkBox" />

2.2.5 RadioGroup e RadioButton

Esse elemento permite uma seleo singular excluindo outras selees que tiver no mesmo grupo,
para isso, alm da marcao RadioButton, temos que agrupar todos eles em um RadioGroup, veja
o exemplo abaixo:

1. <RadioGroup
2. android:layout_width="wrap_content"
3. android:layout_height="wrap_content"
4. android:layout_alignParentStart="true" >
5. <RadioButton
6. android:text="Feminino"
7. android:layout_width="wrap_content"
8. android:layout_height="wrap_content"
9. android:id="@+id/radioButton2"
10. />
11. <RadioButton
12. android:text="Masculino"
13. android:layout_width="wrap_content"
14. android:layout_height="wrap_content"
15. android:id="@+id/radioButton"
16. />
17. </RadioGroup>

16
2.2.6 Spinner
Os Spinners so seletores que podem ser criados para o usurio escolher uma opo. Para isso
temos que antes atribuir o conjunto de opes em strings.xml

1. <string-array name = "bairros">

2. <item>Selecione Um Bairro</item>
3. <item>Aerolndia</item>
4. <item>Dias Macedo</item>
5. <item>Aldeota</item>
6. </string-array>

Depois de Preparada as opes podemos fazer a referncia no XML Spinner no nosso layout
principal activity_main.xml

1. <Spinner
2. android:layout_width="match_parent"
3. android:layout_height="wrap_content"
4. android:layout_alignParentTop="true"
5. android:layout_alignParentStart="true"
6. android:entries="@array/bairros" />

Utilizamos o atributo android:entries para capturar o conjunto de elementos que atribumos em

strings.xml

2.2.7 EditText
Esse componente permite que voc digite um texto ao pression-lo,

1. <EditText
2. android:layout_width="wrap_content"
3. android:layout_height="wrap_content"
4. android:inputType="textPersonName"
5. android:text="Digite um nome"
6. android:id="@+id/editText" />

Por padro, abre o teclado genrico para um componente EditText, porm existe uma propriedade
chamada android:inputType onde podemos definir esse campo como senha, campos
numricos, telefone e outros elementos.

2.2.8 ImageView
Componente responsvel por mostrar uma imagem no projeto. Antes de inserir o componente,
temos que importar a imagem na pasta drawable.

1. <ImageView
2. android:layout_width="wrap_content"
3. android:layout_height="wrap_content"

17
 4. app:srcCompat="@drawable/egpce"
5. android:id="@+id/imageView2"
6. />

Para pegar um recurso, precisamos utilizar a propriedade app:srcCompat , informar a pasta

com a referncia @drawable e informar o nome da imagem.

Aprendemos como incluir nos nossos projeto os elementos, porm temos a responsabilidade de
manter esses elementos alinhados nos mais diferentes tipos de aparelhos com resolues
diferentes. Para isso Trabalharemos em conjunto com Gerenciamento de Layout, assunto que
iremos ver nos prximos tpicos.

2.3 Gerenciadores de Layout.

Os gerenciadores de layout so estruturas que permitem a orientao e organizao dos
demais componentes vinculando-os a posies na vertical e horizontal e tambm os formatos de
distribuio do objeto dentro do layout principal. No Android a classe que permite o incio da
criao e da distribuio desses layouts a classe android.view.View, dela que herdam todos os
outros widgets. Os layouts so classificados como uma subclasse da classe View. Nesse contexto
surge a classe ViewGroup que a partir dela surgem as classes: RelativeLayout, LinearLayout e
GridLayout e outros. Abaixo citaremos os principais layouts e faremos exemplos para mostrar sua
funcionalidade.

2.3.1 RelativeLayout
O RelativeLayout o gerenciador de layout criado por padro nos nossos aplicativos. Veja a seguir
a sua criao XML:

1. <RelativeLayout
2. android:layout_width="match_parent"
3. android:layout_height="match_parent"
4. android:layout_alignParentTop="true"
5. android:layout_alignParentStart="true">

6. <!-- Os Componentes, como botes, caixa de texto, imagens ficaro nessa

rea -->

7. </RelativeLayout>

Os componentes se posicionam considerando a posio dos outros componentes ou atravs de

coordenadas, para isso, novas propriedades iro ser utilizadas para cada elemento, vamos para
um exemplo prtico com alguns botes seguindo diferentes tipos de alinhamentos e posies:

18
 Figura 16: Componentes com RelativeLayout

A estrutura XML referente Figura 16 encontra-se a seguir:

<RelativeLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_alignParentTop="true"
android:layout_alignParentStart="true">
<Button
android:text="Button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_alignParentStart="true"
android:layout_marginStart="19dp"
android:layout_marginTop="20dp"
android:id="@+id/button4" />
<Button
android:text="Button3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/button6"
android:layout_alignBaseline="@+id/button5"
android:layout_alignBottom="@+id/button5"
android:layout_toEndOf="@+id/button5" />
<Button
android:text="Button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/button5"
android:layout_below="@+id/button4"
android:layout_alignStart="@+id/button4" />
<Button
android:text="Button4"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_alignParentEnd="true"
android:layout_marginEnd="65dp"

19
 android:layout_marginTop="163dp"
android:id="@+id/button7" />
</RelativeLayout>

2.3.2 LinearLayout
O LinearLayout um gerenciador que permite posicionar todos os outros componentes da tela,
inclusive novos layouts, na vertical ou na horizontal. Os principais atributos dessa classe so o
width e o height (Largura e altura) e o orientation(orientao) que define a colocao do layout na
vertical e na horizontal. Para testar vamos criar um projeto para definio de alguns objetos:

1. <LinearLayout
2. android:orientation="horizontal"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. android:layout_alignParentTop="true"
6. android:layout_alignParentStart="true">

7. <!-- Os Componentes, como botes, caixa de texto, imagens ficaro nessa

rea -->

8. </LinearLayout>

O atributo que define os alinhamentos dos elementos : android:orientation, que poder ser definido
como: "horizontal" ou "vertical". Veja como os elementos ficam posicionados:

Figura 17: LinearLayout Horizontal

Figura 18: LinearLayout Vertical

20
2.3.3 GridLayout
O GridLayout trabalha em formato de grade, definindo coordenadas(linha,coluna) para dispor os
elementos na tela, para isso iremos incluir 2 propriedades em cada elemento:

android:layout_row: Define e linha que o componente ficar na grid

android:layout_column: Define a coluna que o componente ficar na grid.

As coordenadas da grid so definidas em formato de inteiro. Veja um exemplo a seguir:

Figura 19: GridLayout

o Exemplo do cdigo gerado em XML vem a seguir:

<GridLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_alignParentTop="true"
android:layout_alignParentStart="true">
<TextView
android:text="TextView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_row="0"
android:layout_column="0" />
android:id="@+id/textView" />
<Button
android:text="Button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_row="0"
android:layout_column="1" />
android:id="@+id/button9" />
<CheckBox
android:text="CheckBox1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/checkBox"

21
 android:layout_row="1"
android:layout_column="2" />
</GridLayout>

Agora que aprendemos a dispor os elementos e organiz-los em layouts, iremos capturar

informaes e trabalhar com eles em classes Java.

3 Manipulando Informaes.
3.1 Evento de Click.
Para Criar um evento de Click, precisamos primeiro criar e definir um boto na camada de viso,
ento indo para nossa main_activity.xml criaremos um boto simples. O Processo o mesmo que
fizemos no tpico 2.2.2. Alm disso criaremos uma referncia para esse boto, estou chamando-o
de btnEvento

Figura 20: Criando Boto com Evento

Agora podemos ir at a nossa Classe Java. Como esto na tela principal, iremos at a Classe Java
que faz sua criao, ela chama-se MainActivity nela implementaremos o seguinte cdigo:

OBS: Pata ativar o evento do boto, tambm aprenderemos como criar uma Caixa de Dialogo,
atravs do AlertDialog.

22
 1. public class MainActivity extends AppCompatActivity implements
View.OnClickListener {
2. Button btnEvento;
3. @Override
4. protected void onCreate(Bundle savedInstanceState) {
5. super.onCreate(savedInstanceState);
6. setContentView(R.layout.activity_main);
7. // Capturando informaes do boto criado.
8. this.btnEvento = (Button) findViewById(R.id.btnEvento);
9. //Criando Evento para boto capturado
10. this.btnEvento.setOnClickListener(this);
11. }
12. @Override
13. public void onClick(View v) {
14. AlertDialog.Builder cDialog = new
AlertDialog.Builder(MainActivity.this);
15. cDialog.setTitle("Ttulo da Mensagem")
16. .setMessage("Contedo da Mensagem")
17. .setNeutralButton("Fechar", null)
18. .show();
19. }
20. }

Inicialmente criamos uma classe com uma implementao chamada OnClickListener que nos
obriga a implementar o mtodo OnClick da linha 13. Em seguida criamos uma referncia ao
boto da tela chamada BtnEvento na linha 2, agora conseguimos capturar as informaes atravs
do mtodo findViewById chamado na linha 8. Quando criamos qualquer elemento na tela, o
Android Studio cria para ns uma referncia em uma Classe chamada R. Dentro dela podemos
fazer a busca apenas por Identificao, em R.id, em seguida basta buscar o ID que definimos no
boto.

Na Linha 10 chamamos o evento setOnClickListener, responsvel por acionar o evento ao click

desse boto. Inserimos como parmetro o evento OnClinck da linha 13 criado na nossa
implementao. Entre as linhas 14 at 18, criamos uma caixa de dialogo simples que contm um
ttulo, uma mensagem de texto e um boto que ir apenas fechar a caixa de dialogo.

O resultado final temos:

23
 Figura 21: Resultado Final Eventos

Agora que criamos nosso primeiro evento de click de boto, estamos prontos para fazer a captura
de informao de outros elementos e realizar processamento entre os dados capturamos.

3.2 Capturando e Gerando Informaes da Tela.

O processo de capturar de informaes de dados da tela bem semelhante a o que j fizemos
com o boto. Para isso, faremos uma aplicao simples que far a Soma entre 2 nmeros e
mostrar em uma caixa de dialogo o resultado Veja a tela que ser trabalhada:

Figura 22: Tela Soma

24
Na Esquerda podemos perceber os elementos que foram criados e na direita podemos ver os Ids
que foram definidos para cada elemento, isso importante, pois precisaremos dessas informaes
na classe de controle.
Na nossa nova implementao modularizaremos melhor nossa aplicao, assim aparecero alguns
elementos importantes para conhecermos ao manipular informaes de uma tela. Inicialmente
criaremos uma classe de controle que ir ser responsvel por acionar o clique do boto e fazer a
soma, ento vamos criar uma classe chamada Calculadora, veja o cdigo a seguir:

1. public class Calculadora {

2. //Mtodo para Somar
3. public static Integer soma(Integer n1,Integer n2){
4. return n1 + n2;
5. }
6. //Mtodo para converter um contedo de um EditText para Inteiro
7. public static Integer convertNumber(EditText edNumber){
8. return Integer.parseInt(edNumber.getText().toString().trim());
9. }
10.}

Vamos explicar o que temos de novidade no cdigo acima:

O mtodo da soma da linha 3, descreve uma Soma simples entre 2 valores.

O mtodo convertNumber captura o contedo de um EditText e faz a converso para
inteiro, precisaremos desse mtodo, pois realizaremos uma soma.

Agora na nossa tela principal chamaremos classe Calculadora que fizemos.

1. public class MainActivity extends AppCompatActivity implements

View.OnClickListener {
2. Button btnEvento;
3. EditText txt1,txt2;
4. @Override
5. protected void onCreate(Bundle savedInstanceState) {
6. super.onCreate(savedInstanceState);
7. setContentView(R.layout.activity_main);
8. // Capturando informaes do boto criado.
9. this.btnEvento = (Button) findViewById(R.id.btnEvento);
10. //Criando Evento para boto capturado
11. this.btnEvento.setOnClickListener(this);
12. }
13. @Override
14. public void onClick(View v) {
15. //Capturando elementos da tela
16. this.txt1 = (EditText) findViewById(R.id.txtN1);
17. this.txt2 = (EditText) findViewById(R.id.txtN2);
18. //Realizando Soma
19. Integer resposta =
20. Calculadora.soma(
21. Calculadora.convertNumber(this.txt1),
22. Calculadora.convertNumber(this.txt2));
23. //Montando e execuando caixa de dialogo.
24. AlertDialog.Builder cDialog = new
AlertDialog.Builder(MainActivity.this);
25. cDialog.setTitle("Ttulo da Mensagem")

25
 26. .setMessage("Resposta = "+resposta)
27. .setNeutralButton("Fechar", null)
28. .show();
29. }
30. }

Veja o resultado final:

Figura 23: Resultado Soma Com Evento

3.3 Transio de Telas com Activity

A medida que seu aplicativo for crescendo, existe a necessidade de navegar entre as telas, isso
possvel atravs das transies de Activity. Vamos preparar primeiro a nossa Janela Principal
main_activity.xml.

Figura 24: Tela 1

26
Observe que nomeamos nosso boto na Tela Principal de btnGoToJan2, esse boto acionar um
evento para ir para uma, Nova tela..

Para criar uma tela no Android Studio basta ir em res > layout clicar com o boto direito na pasta
layout e ir em New > XML > Layout XML FILE. Com uma nova janela em branco, definiremos a
interface da tela 2.

Figura 25: Tela2

Por padro, o Android Studio cria a classe MainActivity.java que ir se comunicar com a tela
principal, como criamos uma tela, precisamos criar uma classe Java que ir se comunicar com
essa segunda tela e para isso temos que criar uma classe ao lado de MainActivity.java que
tambm herdar de AppCompatActivity, veja a Classe criada.

1. public class Janela2 extends AppCompatActivity {

2. @Override
3. protected void onCreate(@Nullable Bundle savedInstanceState) {
4. super.onCreate(savedInstanceState);
5. setContentView(R.layout.janela2);
6. }
7. }

O que faremos de diferente chamar a janela2 dentro de setContentView.

Importante: Depois dessa Operao temos que ir no nosso arquivo AndroidManifest.xml do projeto
e adicionar a janela2 como uma nova Activity. Veja o cdigo abaixo:

1. <activity
2. android:name="com.example.fabricionote.appaula.Janela2">
3. </activity>

As definies de android:name mudar de acordo com as Configuraes do seu Projeto. Com isso,
temos nossas 2 telas configuradas, comearemos a criar nossa transio apenas utilizando o
Objeto Intent. Veja o cdigo abaixo:

1. public class MainActivity extends AppCompatActivity implements

View.OnClickListener {
2. // Referncia do boto criado
3. private Button btnEvento;
4. private EditText txtNome;

27
 5. @Override
6. protected void onCreate(Bundle savedInstanceState) {
7. super.onCreate(savedInstanceState);
8. setContentView(R.layout.activity_main);
9. this.btnEvento = (Button) findViewById(R.id.btnGoToJan1);
10. this.btnEvento.setOnClickListener(this);
11. }
12. @Override
13. public void onClick(View v) {
14. Intent intent = new Intent(this,Janela2.class);
15. this.startActivity(intent);
16. }
17. }

O Objeto que ser responsvel pela transio chamada de Intent, ela est declarada na linha 14.
Para transitar entre as atividades, o objeto precisar da Activity atual e uma referncia da classe
que ser responsvel pela prxima tela. No construtor da nossa classe Intent est pedindo essas
informaes. Perceba que ainda na Linha 14 o processo de trilha entra a tela atual e a prxima
feita.

OBS: No efeito de transio a tela antiga no perdida, possvel voltar para ela pelo prprio
navegador android, porm se realmente no precisar da tela que foi deixada, podemos encerrar da
memria ela. Para isso basta incluir o mtodo finish().

3.4 Transferindo Informaes entre Atividades

Quando trabalhamos com mais de uma tela, em vrios momentos precisamos passar informaes
entre elas, para aprendermos, iremos aproveitar a implementao do tpico anterior. Primeiro
vamos at o layout main_activity e adicionar uma Edit Text.

Figura 26: Informao entre Atividades 1

Nossa EditText foi criada com o nome de txtInfo como mostra a Figura 26. Nosso prximo passo
criar uma TextView na atividade que ser carregada. Veja a imagem a seguir:

28
 Figura 27: Informao entre Atividades 1

na janela2 criamos uma TextView chamada txtResposta, ela ir receber as informaes digitadas
da tela principal. Agora vamos para implementao em Java, comeando pela MainActivity, veja o
cdigo a seguir.

1. public class MainActivity extends AppCompatActivity

implements View.OnClickListener {
2. // Referncia do boto criado
3. private Button btnEvento;
4. //Referncia do campo QUe ser digitado
5. private EditText txtNome;
6. @Override
7. protected void onCreate(Bundle savedInstanceState) {
8. super.onCreate(savedInstanceState);
9. setContentView(R.layout.activity_main);
10. this.btnEvento = (Button) findViewById(R.id.btnGoToJan2);
11. this.btnEvento.setOnClickListener(this);
12. }
13. @Override
14. public void onClick(View v) {
15. //Capturando a informao digitada na tela
16. this.txtNome = (EditText) this.findViewById(R.id.txtInfo);
17. Bundle dados = new Bundle();
18. dados.putString("NOME",this.txtNome.getText().toString());
19. Intent intent = new Intent(this,Janela2.class);
20. intent.putExtras(dados);
21. this.startActivity(intent);
22. }
23. }

As novidades esto entre as Linhas 16 e 21, vamos por etapas para entender o que foi feito. Na
linha 16 capturamos as informaes que o usurio digitou na MainActivity. O Objeto responsvel
por transferir uma informao de uma tela para outra chamado de Bundle, ele est sendo criado
na linha 17. Para Adicionarmos uma informao do tipo String, usaremos o mtodo putString na
linha 18. O mtodo implementado ir pedir 2 parmetros, uma chave, que poder definir como
desejar, e a informao digitada que ir representar o valor. O processo de armazenamento de
uma Bundle similar ao de um HashMap onde tambm criado referencia por chave/valor.

Se tivermos mais informaes a inserir, podemos abaixo da linha 18 chamar mais mtodos put.

29
Na linha 20 preparamos nossa informao armazenada inserindo no nosso Intent atravs do
mtodo putExtras(), assim na linha 21, podemos garantir que a Intent ir fazer a transio da tela
levando a informao da nossa tela atual.

Agora, na prxima tela, podemos capturar o Objeto Bundle que criamos, e realizar os mais
diversos tipos de manipulao, veja o cdigo abaixo:

1. public class Janela2 extends AppCompatActivity implements

View.OnClickListener {
2. private Bundle dados;
3. private TextView tvResposta;
4. @Override
5. protected void onCreate(@Nullable Bundle savedInstanceState) {
6. super.onCreate(savedInstanceState);
7. setContentView(R.layout.janela2);
8. this.tvResposta = (TextView) this.findViewById(R.id.txtResposta);
9. this.dados = this.getIntent().getExtras();
10. if(this.dados.containsKey("NOME")){
11. this.tvResposta.setText(this.dados.getString("NOME"));
12. }
13. }
14.}

A novidade est entre as linhas 8 e 12, inicialmente capturamos a referncia da nossa TextView
criada na janela 2 na linha 8. Na linha 9 recebemos a Bundle que criamos na tela anterior. Atravs
do Mtodo getExtras() do mtodo getIntent(). Podemos utilizar um mtodo de verificao de
chave pelo mtodo containsKey() definido na linha 10. Por fim, na linha 11 capturamos as
informaes que armazenamos na tela anterior, atravs do mtodo getString passando como
parmetro a chave que definimos. O Mtodos setText() em tvResposta ir ser encarregado de
alterar as informaes para a digitada na tela inicial do nosso projeto.

Bem Pessoal, nosso curso de Introduo a Desenvolvimento Android est no Fim, o objetivo do
curso dar uma introduo para que vocs possam dar os prximos passos no desenvolvimento
de aplicativos Mveis Android. Espera que tenha gostado do nosso Curso!

30
4 Bibliografia
ANDROID DEVELOPER. Documentao: Disponvel em: <http://developer.android.com>.
15/10/2016

Macedo A. K19. Desenvolvimento Mobile com Android: Disponvel em:

<http://www.k19.com.br/cursos/desenvolvimento-mobile-com-android> 12/10/2016

Rosal, F. S. Projeto e-Jovem. Introduo ao Desenvolvimento Android pra Mobile .2016

31