Apostila Desenvolvimento de Aplicativos Android

Prévia do material em texto

CONTEÚDO ONLINE .............................................................................. 4 
Introdução ao Android ............................................................................ 4 
Computação móvel ....................................................................................... 4 
Principais plataformas de desenvolvimento: ........................................ 7 
Introdução ao Android .......................................................................... 8 
Um pouco mais de história: ........................................................................... 8 
Principais características comuns do Android: ..................................... 9 
Principais Características específicas do Android: ............................. 10 
Plataforma ........................................................................................... 11 
Principais características das versões Android : ................................. 12 
Arquitetura Android: ........................................................................... 15 
Componente de uma aplicação Android ............................................. 17 
Ambiente de Desenvolvimento. .......................................................... 23 
Para o desenvolvimento de aplicações Android, é preciso instalar: ................. 24 
 Java Development Kit (JDK); ....................................................... 24 
 Android SDK ............................................................................... 24 
Instalações básicas: ............................................................................ 24 
Instalação JDK: acessar o link 
http://www.oracle.com/technetwork/pt/java/javase/downloads/index.html .... 24 
Instalação Android SDK: acessar o link 
https://developer.android.com/sdk/index.html ............................................. 24 
Instalação Android Studio(Opcional): Caso deseje usar o Android Studio, 
acessar o link https://developer.android.com/sdk/index.html ........................ 24 
Click em Download Android Studio .............................................................. 24 
Instalação Eclipse(Opcional): Caso deseje usar o Eclipse, acessar o link 
http://www.eclipse.org/downloads/ ............................................................. 25 
Click em Eclipse IDE for Java EE Developers: ............................................... 25 
Para Instalar o ADT plugin pelo próprio Eclipse, acessar a menu Help, opção 
Install New Software... ............................................................................... 27 
Clicar no botão add: .................................................................................. 28 
Digite os dados da tela abaixo : .................................................................. 29 
Aceite os termos de compromisso e click em finish : .................................... 30 
Desenvolvendo programas .................................................................. 52 
Activity. ............................................................................................... 74 
Estrutura de um projeto Android: ................................................................ 74 
 
 
 
Arquivo AndroidManifest.xml: ...................................................................... 77 
Arquivo activty_main.xml: ........................................................................... 77 
Activity ...................................................................................................... 79 
Ciclo de Vida Activity: ................................................................................. 80 
Intent ........................................................................................................ 83 
Aplicando Intent na prática ................................................................ 87 
Componentes gráficos. ........................................................................ 97 
Gerenciadores de Layout ........................................................................... 100 
Principais layouts: ............................................................................. 101 
Listas: ...................................................................................................... 120 
Menus ...................................................................................................... 132 
ActionBar .................................................................................................. 146 
Popup Menu .............................................................................................. 153 
Fragment .................................................................................................. 157 
Ciclo de vida de Fragment .......................................................................... 158 
Criando Fragments: ................................................................................... 160 
Exemplo Fragments 2: ...................................................................... 165 
Crie o projeto Android com o nome AulaFragments_2.................................. 165 
Estilo e Tema ............................................................................................ 169 
Herança de Estilo ...................................................................................... 170 
Mensagens................................................................................................ 172 
Persistência de Dados em Android. ............................................................. 184 
SharedPreferences: ................................................................................... 184 
Internal Storage. ....................................................................................... 188 
External Storage ........................................................................................ 190 
SQLite Databases ...................................................................................... 191 
Classe SQLiteOpenHelper ........................................................................... 192 
Classe SQLiteDatabase .............................................................................. 192 
Usando uma conexão de rede .................................................................... 195 
WebService e Android: .............................................................................. 195 
Classe MediaPlayer .................................................................................... 202 
Google Play Services .................................................................................. 207
 
 
 
CONTEÚDO ONLINE 
Introdução ao Android 
Computação móvel 
 
Você já deve ter notado que o crescimento exponencial das tecnologias da 
informação (TI) mudou nossa forma de viver. 
Estamos na era da informação e do conhecimento. 
Esta revolução tecnológica, sem sobra de dúvidas, redesenhou a forma como 
nos comunicamos, aprendemos e, porque não dizer, percebermos o mundo. 
Estamos cada vez mais ávidos por quantidade, qualidade e velocidade das 
informações. 
Neste “Admirável Mundo Novo" é inconcebível não poder acessar informações 
e, até mesmo, serviços, independentemente de onde estejamos localizados. 
Desejamos, como preconizado pelas Organizações Globo, que tudo esteja “On 
line, on time, full time.” 
Nesta hora nasce então o conceito de computação móvel, que para nós 
consiste em: 
 “computação móvel é a capacidade de ter acesso a informação a 
qualquer lugar e a qualquer hora, onde existe total mobilidade do 
usuário 
Dispositivo móvel: 
Ainda me lembro da primeira vez que usei um Teletrim(1986). 
 
 
 
 
 
Este nada mais era do que um aparelho que usava a tecnologia decomunicação por rádio para transmitir mensagens entre seus usuários. 
Praticamente o SMS dos dias de hoje. 
Com o avanço das tecnologias de TI, nasceram uma gama de novidades 
relativas à infraestrutura da computação móvel como hardwares, softwares, 
redes de computadores e outros. Entre eles, podemos destacar os dispositivos 
móveis. 
Um dispositivo móvel(handheld) é um computador de bolso normalmente 
equipado com uma pequena tela(output) e um teclado em miniatura (input). 
A exceção se dá nos PDAs e na maioria dos smartphones, onde o output e o 
input combinam-se num touchscreen. 
Existem diversas categorias de dispositivos de computação móvel. Entre os 
mais comuns estão: 
 Smartphone; 
 PDA(Personal Digital Assistant); 
 Celular; 
 Console portátil; 
 Coletor de dados; 
 GPS(Global Positioning System) 
 
O conceito base que impulsionou o desenvolvimento dos dispositivos móveis foi 
a mobilidade, que pode ser definida como: 
Fonte:http://static.sensacionalista.com.br/wp-
content/uploads/2015/08/IMG_3604.jpg 
 
 
 
 a capacidade de poder ser movido fisicamente e/ou poder ser 
utilizado enquanto está sendo movido. 
 
Para isto, possui determinadas características como: 
 Pequeno em tamanho; 
 Leves em peso; 
 Capacidade de memória e processamento limitados; 
 Baixo consumo de energia; 
 Podem possuir conectividade ou não, ou ainda, conectividade limitada; 
 Curto tempo de inicialização; 
 Normalmente mais resistentes a quedas 
 Monitoramento de nível de energia para prevenção de perda de dados; 
 Armazenamento de dados local e/ou remoto; 
 Sincronização de dados com outros sistemas; 
 
Com o crescimento no uso de dispositivos móveis ao redor do globo, surgiram 
vários sistemas operacionais e também uma crescente demanda por aplicativos. 
Mas que tipo de aplicativo construir? 
 Específico para um determinado sistema operacional? 
 Voltado para Web? 
 Genérico? 
 
Existem muitos tipos de sistemas operacionais grande número de sistemas 
operacionais para dispositivos móveis, é necessário definir que tipo de aplicação 
móvel desenvolver dentre: 
 
 
 
 Nativa: 
São desenvolvidas especificamente para uma determinada plataforma. Faz uso 
da linguagem de programação suportada pela plataforma móvel e seu 
respectivo SDK(Software Development Kit). Normalmente são instaladas 
através de uma loja de aplicativos, como por exemplo App Store e Google Play. 
 
 WebMobile: 
 
o Diferente das aplicações nativas, o aplicativo consiste em um site 
com um layout otimizado para dispositivos. Faz uso de linguagens 
web(html, css, javascript) e design responsivo. É desenvolvido 
para multiplataforma. 
 
 Híbrida: 
 
o Tem se destacado muito nestes últimos tempos. Este consiste da 
na combinação dos tipos nativos e WebMobile. Em geral, possui 
um navegador de internet customizado para o site do aplicativo. 
É desenvolvido para uma plataforma específica, por isto, deve ser 
baixado em uma loja de aplicativos específica. 
 
 Multiplataforma: 
 
o Faz uso de ferramenta proprietária(Framework) para geração de 
aplicações móveis para várias plataformas móveis. 
Principais plataformas de desenvolvimento: 
Existem atualmente vários sistemas operacionais para celulares e dispositivos 
móveis disponíveis no mercado. Abaixo estão relacionados alguns: 
 IOS 
 Symbian 
 Android 
 BlackBerry 
 Windows Phone 
 
 
 
É público e notório que o Android, objeto de nosso estudo, se tornou o 
sistemas operacional mais usado no mundo, conforme podemos observar na 
imagem abaixo: 
 
 
Introdução ao Android 
Um pouco mais de história: 
Android é um software open-source, baseado no sistema operacional Linux 
para dispositivos móveis, como smartphones, tablets e computadores. Este foi 
desenvolvido por uma empresa chamada Android Inc. 
Situada na Califórnia-EHA, e fundada por Andy Rubin, Rick Miner, Nick Sears e 
Chris White, era inicialmente uma empresa destinada a desenvolvimento de 
aplicativos para celulares. Foi adquirida pela Google em 2005, que manteve 
Andy Rubin como colaborador no desenvolvimento da plataforma Android. 
Em novembro de 2007, foi criada a Open Handset Alliance(OHA). Formada por 
várias empresas do setor e capitaneada pela Google, a OHA fortaleceu o 
crescimento da plataforma Android. Finalmente, em 2008, foi lançado o 
primeiro dispositivo móvel Android Enabled: HTC T-Mobile: 
 
 
 
 
 
 
 
A OHA promoveu a concentração de esforços para o desenvolvimento do 
sistema Android. 
Sua proposta consiste em que as aplicações devem ser capazes de rodar em 
diferentes dispositivos alimentados pelo sistema operacional do Android. 
Diferente do Java, este não trabalha com uma Java Virtual 
Machine(JVM). Possui Dalvik Virtual Machine(DVM) ou Android 
Runtime(ART) que, além de possuir uma arquitetura diferente, é 
otimizada para cada dispositivo móvel. 
Principais características comuns do Android: 
 open-source; 
 não é preso a um hardware específico; 
 grande comunidade de desenvolvedores; 
 Grande variedade de dispositivos e aplicativos; 
 Custo reduzido de desenvolvimento; 
Fonte: 
http://edgblogs.s3.amazonaws.com/tecneira/files/2008/09/g1.bmp 
 
 
 
Principais Características específicas do Android: 
 
Handset Layout 
 Oferece a possibilidade de 
desenvolveremos layouts de 
qualidade para dispositivos 
mais simples, assim como para 
smartphones e tablets. Suporta 
inclusive 2D ou 3D. 
Conectividade 
 Disponibiliza suporte às 
tecnologias de GSM / EDGE, 
IDEN, CDMA, EV-DO, UMTS, 
Bluetooth, Wi-Fi, LTE, NFC e 
WiMAX. 
Armazenamento 
 É utilizado o SQLite para o 
armazenamento de dados. 
Suporte de mídia 
 Oferece suporte as tecnologias 
H.263, H.264, MPEG-4 SP, 
AMR, AMR-WB, AAC, HE-AAC, 
AAC 5.1, MP3, MIDI, Ogg 
Vorbis, WAV, JPEG, PNG, GIF e 
BMP. 
Mensagens 
 Oferece formas de envio de 
mensagens SMS(texto simples) 
e MMS(texto, imagem, áudio e 
vídeo) 
Multi-touch 
 tem suporte nativo para multi-
touch 
Multi-tasking 
 vários aplicativos podem ser 
executados simultaneamente. 
Suporte Java 
 As aplicações desenvolvidas 
nesta plataforma, são 
 
 
 
implementadas na linguagem 
Java 
Market 
 É uma loja de aplicativos 
(gratuitos e pagos) que 
permite instalar diretamente 
no dispositivo sem a 
necessidade de computador. 
Plataforma 
Segundo Lecheta, autor do livro Google Android, plataforma corresponde a 
versão do Sistema Operacional Android. Cada versão possui um número inteiro 
denominado API Level que corresponde a versão da plataforma Android. É 
importante ressaltar que o valor da API Level será usado quando for definido os 
dispositivos alvos para seu aplicativo. 
 
API Level Plataforma Android 
1 1.0 
2 1.1 
3 1.5 - Cupcake 
4 1.6 - Donut 
5 2.0 
6 2.01 
7 2.1 - Eclair 
8 2.2 - Froyo 
9 2.3 - Gingerbread 
10 2.33 
11 3.0 - Honeycomb 
12 3.1 
13 3.2 
14 4.0 0- Ice Cream Sandwich 
15 4.03 
 
 
 
16 4.1 - Jelly Bean 
17 4.2 - Jelly Bean 
18 4.3 - Jelly Bean 
19 4.4 - Kitkat 
20 4.4W – Kitkat para wearables 
21 5 - Lollipop 
22 5.1 - Lollipop MR1 
Principais características das versões Android : 
 Android 1.0: 
o Barra de Notificações; 
o Widgets na Tela Inicial, pois não era possível 
desenvolvimento de widgets; 
o Integração com os Aplicativos Google, como por exemplo, 
Gmail, Youtube e outros; 
o Possui aplicativos como alarme e calculadora; 
o Suporte Wi-fi e Bluetooth 
o Android Market(nome antigo da Google Play) 
o Web Browser 
 
 Android 1.1: 
o Antes de instalar, identifica se o aplicativo é compatível 
com o sistema; 
o suporte para letreiros em layouts; 
o comentários e mais detalhes quando um usuário faz uma 
busca no Google maps. 
o suporte para salvar anexos de mensagens; 
o Na chamada padrão, o tempo de limite da tela agora é 
maior quando usando a viva voz; 
 
 
 
 
 Android 1.5(Cupcake): 
o Câmera; 
o GPS; 
o Upload de fotos e vídeos para Youtube e Picasa; 
o HTC Magic 
o Widgets 
 
 Android 1.6: 
o Text-to-Speech(TTS) 
o Speech-to-Text(STT) 
o Criada medidas de densidades(ldpi, mdpi,hdpi) 
 
 Android 2.0 e 2.1: 
o Live WallPapers; 
o Melhorias nas câmeras, mapas 
o Suporte HTML . 
 
 Android 2,2(Froyo): 
o Compilador JIT 
o Engine Javascript 
o USB Tethering; 
o Wi-Fi Hotspot 
o Suporte a Flash; 
 
 Android 2.3(Gingerbread): 
o Alternância entre as câmeras frontal e traseira; 
o Melhorias copy-paste; 
o Melhor gerenciamento de bateria; 
o Suporte a Near Field Communications(NFC) 
 
 Android 3.0(Honeycomb): 
o Focado em tablets 
 
 
 
o Botões físicos integrados a barra de navegação da tela com 
touch screen 
 
 Android 4.0(Ice Cream Sandwhich): 
o Unificação da plataforma de desenvolvimento entre 
smartphones e tablets; 
o Mesmo sistema operacional para tablets e smartphones; 
 
 Android 4,1 (Jelly Bean): 
o Melhor desempenho 
o Melhor suporte a animações; 
o Melhoria nas notificações do Android; 
 
 Android 4.4(KitKat) 
o Redução para 512Mb de Ram como requisito mínimo; 
o Aperfeiçoamento no Bluetooth, NFC, Print Framework, 
sensores; 
o Criada a API de Transitions; 
 
 Android 5.0(Lollipop): 
o Foco na interface, usabilidade, animações e experiência do 
usuário; 
o Implementação do conceito de Material Design; 
o Desempenho superior nos jogos 2D e 3D; 
o Criada a API Leanback 
 
 
 
Arquitetura Android: 
 
 
 
 Linux kernel: 
 um nível de abstração do hardware do dispositivo 
além de possuir os drivers de hardware essenciais. 
Este proporciona gerenciamento de memória, 
gerenciamento de energia, processos, segurança, 
entre outros; 
 Libraries: 
 abrange as bibliotecas que são destinadas ao 
desenvolvimento Android. 
 Principais bibliotecas: 
o android.app - Fornece acesso à aplicação 
o android.content - Facilita o acesso ao 
conteúdo, publicação e de mensagens entre 
aplicativos e componentes dos aplicativos. 
o android.database - Usado para acessar os 
dados publicados por provedores de conteúdo 
Fonte: 
http://old.knoow.net/ciencinformtelec/informatica/android1.j
pg 
 
 
 
e inclui classes de gerenciamento de banco 
de dados SQLite. 
o android.opengl - Uma interface Java para os 
gráficos OpenGL 
o android.os - fornece acesso aos serviços do 
sistema operacional padrão, incluindo 
mensagens, serviços do sistema e 
comunicação entre processos. 
o android.text - usado para processar e 
manipular texto em uma tela do dispositivo. 
o android.view - construção das interfaces 
com o usuário do aplicativo. 
o android.widget - Uma rica coleção de 
componentes de interface do usuário pré-
construídos, tais como botões, etiquetas, 
exibições de lista, gerenciadores de layout, 
botões de rádio, etc 
 Android Runtime: 
 Esta seção fornece a Dalvik Virtual Machine, que é 
uma espécie de Java Virtual Machine especialmente 
projetado e otimizado para o Android. 
 Application Framework: 
 fornece vários serviços para aplicações na forma de 
classes Java. Os desenvolvedores de aplicativos têm 
permissão para fazer uso desses serviços em suas 
aplicações. 
 Principais serviços: 
o Activity Manager - controla todos os 
aspectos do ciclo de vida da aplicação e pilha 
de atividade. 
 
 
 
o Content Provider: Permite que os 
aplicativos para publicar e partilhar dados 
com outras aplicações. 
o Resource Manager: Fornece acesso a 
recursos, como Strings, configurações de 
cores e layouts de interface do usuário. 
o Notifications Manager: Permite que os 
aplicativos para exibir alertas e notificações 
para o usuário. 
o View System: Conjunto de views destinadas 
a criar interfaces de usuário. 
 Application: 
 É nesta camada que se encontram os aplicativos 
instalados, como por exemplo: 
 Cliente email; 
 Navegador; 
 Contactos; 
 Mapas; 
 Programas para SMS.Componente de uma aplicação 
Android 
 
Componentes são blocos de construção essenciais a um aplicativo Android. 
O arquivo AndroidManifest.xml, que é único em cada aplicação, descreve cada 
componente da aplicação e como eles interagem. 
Neste constam todas as configurações necessárias para executar a aplicação, 
como, por exemplo, o nome do pacote utilizado, o nome das classes de cada 
activity, as permissões que o aplicativo possui, qual a versão mínima da API 
Android, dentre outras configurações. 
Existem quatro componentes principais que podem ser utilizadas dentro de uma 
aplicação Android: 
 
 
 
 
 
Activity: 
o É considerado o componente base de uma aplicação 
Android. Consiste em uma classe gerenciadora de 
UI(Interface do usuário). Representa, normalmente, uma 
única tela do usuário. Tanto o fluxo da aplicação, como 
eventos de tela são de sua responsabilidade. 
o Exemplo: 
 
import android.os.Bundle; 
import android.app.Activity; 
import android.view.Menu; 
import android.view.MenuItem; 
import android.support.v4.app.NavUtils; 
 
public class MainActivity extends Activity { 
 
 @Override 
 public void onCreate(Bundle savedInstanceState) 
{ 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 } 
 
 @Override 
 
Fonte: http://designthing.net/wp-content/uploads/2015/08/The-basic-components-
in-an-android-app.jpg 
 
 
 
 public boolean onCreateOptionsMenu(Menu 
menu) { 
 getMenuInflater().inflate(R.menu.activity_main, 
menu); 
 return true; 
 } 
} 
 
 
 Service: 
o Conhecido por componente de background, é responsável 
pelo processamento em segundo plano associado a uma 
aplicação. Normalmente utilizado para realizar tarefas de 
sincronização, por exemplo, com um servidor. 
o Exemplo: 
 
import android.app.Service; 
import android.os.IBinder; 
import android.content.Intent; 
import android.os.Bundle; 
 
public class HelloService extends Service { 
 
 int mStartMode; 
 IBinder mBinder; 
 boolean mAllowRebind; 
 
 @Override 
 public void onCreate() { 
 
 } 
 
 @Override 
 public int onStartCommand(Intent intent, int 
flags, int startId) { 
 return mStartMode; 
 } 
 
 @Override 
 public IBinder onBind(Intent intent) { 
 return mBinder; 
 } 
 
 
 
 
 @Override 
 public boolean onUnbind(Intent intent) { 
 return mAllowRebind; 
 } 
 
 @Override 
 public void onRebind(Intent intent) { 
 
 } 
 
 @Override 
 public void onDestroy() { 
 
 } 
} 
 
BroadCast Receiver: 
o Eles lidam com a comunicação entre sistema operacional e 
aplicativos Android. São responsáveis por tratar eventos do 
sistema ou de outras aplicações. 
o Exemplo: 
public class MyReceiver extends 
BroadcastReceiver { 
 @Override 
 public void onReceive(Context context, 
Intent intent) { 
 Toast.makeText(context, "Intent 
Detected.", Toast.LENGTH_LONG).show(); 
 } 
} 
 Content Provider: 
o Eles lidam com questões de gestão de dados e banco de 
dados.Permitem o compartilhamento de dados entre 
aplicações. É responsável prover às aplicações dados. 
o Exemplo: 
 
import android.content.ContentProvider; 
import android.content.ContentValues; 
 
 
 
import android.database.Cursor; 
import android.net.Uri; 
public class ImagesProvider extends 
ContentProvider { 
 
 @Override 
 public String getType(Uri uri) { 
 return ""; 
 } 
 
 @Override 
 public boolean onCreate() { 
 return true; 
 } 
 
 @Override 
 public Cursor query(Uri uri, String[] 
projection, String selection, String[] 
selectionArgs, String sortOrder) { 
 return null; 
 } 
 
 @Override 
 public Uri insert(Uri uri, ContentValues 
values) { 
 return null; 
 } 
 
 @Override 
 public int delete(Uri uri, String selection, 
String[] selectionArgs) { 
 return 0; 
 } 
 
 @Override 
 public int update(Uri uri, ContentValues 
values, String selection, String[] 
selectionArgs) { 
 return 0; 
 } 
} 
 
 Componentes Adicionais: 
o Existem componentes adicionais que serão utilizados na 
construção de das aplicações: 
 
 
 
 Fragments: Representa uma parte da interface do 
usuário em uma atividade. 
 
 Views: Elementos de interface do usuário que são 
desenhadas na tela incluindo botões, enumera 
formas etc. 
 
 Layouts: controlam formato de tela e aparência dos 
pontos de vista. 
 
 Intents: 
 Mensagens 
 Resource: 
 Elementos externos, tais como cordas, constantes e 
imagens drawable. 
 Manifest: Arquivo de configuração para a aplicação 
 
A classe ExemploActivity estende a classe Activity e representa a tela de nosso 
exemplo. Obrigatoriamente o método onCreate deve ser implementado, pois, 
quando a tela for criada, este será invocado. 
 
Principais IDEs: 
 
 Android Studio: 
o https://developer.android.com/sdk/index.html 
 IntelliJ: 
o https://www.jetbrains.com/idea/download/ 
 Eclipse: 
o https://eclipse.org/downloads/ 
 
 
 
 
 
Tipos de Licenças: 
1. Kernel Linux segundo a GNU General Public License(GPL). 
Este tipo a licença se baseia-se em 4 liberdades: 
I. A liberdade de executar o programa, para qualquer propósito. 
II. A liberdade de estudar como o programa funciona e adaptá-lo 
para as suas necessidades. 
III. A liberdade de redistribuir cópias de modo que você possa 
ajudar ao seu próximo. 
IV. A liberdade de aperfeiçoar o programa, e liberar os seus 
aperfeiçoamentos, de modo que toda a comunidade se 
beneficie deles. 
 
Restante da Plataforma segundo diretivas da Apache Software License(ASL). 
A Licença Apache (Apache License) é uma licença para software livre (open 
source) de autoria da Apache Software Foundation (ASF). Todo software 
produzido pela ASF ou qualquer um dos seus projetos e subprojetos é 
licenciado de acordo com os termos da licença Apache. Alguns projetos não 
pertencentes à ASF também utilizam esta licença. A licença Apache (versões 
1.0, 1.1 e 2.0) exige a inclusão do aviso de copyright e disclaimer, mas não é 
uma licença copyleft - ela permite o uso e distribuição do código fonte tanto no 
software open source como no proprietário. 
Ambiente de Desenvolvimento. 
 
A linguagem Java é usada para o desenvolvimento em Android. Porém o 
arquivo bytecode(.class) não é o formato pertinente, no caso da Máquina 
Virtual Dalvik(DVM), para execução. 
Este é convertido no formato Dalvik Executable(.dex) e compactado juntos 
com demais recursos, como imagens e XMLs, em um arquivo no formato 
Android Package File(.apk) que constitui a aplicação a ser executada. 
 
 
 
A partir do Android 5.0((Lollipop) a Dalvik foi substituída pela máquina virtual 
ART(Android Runtime) como default. Segunda a Google, a ART sofreu algumas 
modificações que melhoraram sensivelmente o desempenho. 
Dentre as melhorias podemos destacar o processo de compilação. 
Por ser baseada no JIT(just in time), o Dalvik traduz(compila) para código de 
máquina o código necessário do aplicativo no momento da execução. 
Isto se constitui como um grande problema para aplicativos mais pesados, 
podendo levar a travamentos, em função da quantidade de recursos utilizados. 
Já o ART, baseia-se na compilação AOT(Ahead-of-Time), onde o aplicativo será 
pré-compilado somente uma vez durante a instalação, eliminando a compilação 
JIT e tendo como resultado um melhor desempenho. 
 
Para o desenvolvimento de aplicações Android, é preciso instalar: 
 Java Development Kit (JDK); 
 Android SDK 
Embora não seja obrigatório, você poderá instalar uma IDE para facilitar o 
desenvolvimento. Exemplo: Eclipse ou Android Studio. 
Instalações básicas: 
Instalação JDK: acessar o link 
http://www.oracle.com/technetwork/pt/java/javase/downloads/index.html 
Instalação Android SDK: acessar o link 
https://developer.android.com/sdk/index.html 
Instalação Android Studio(Opcional): Caso deseje usar o Android Studio, 
acessar o link https://developer.android.com/sdk/index.html 
Click em Download Android 
 
 
 
Studio 
 
A após aceitar os termos de compromisso e instalar o arquivo baixado o 
Android Studio estará instalado conforme tela abaixo: 
 
 
Instalação Eclipse(Opcional): Caso deseje usar o Eclipse, acessar o link 
http://www.eclipse.org/downloads/ 
 
Click em Eclipse IDE for Java EE Developers: 
 
 
 
 
 
 
Descompacte o arquivo baixado e execute-o; 
Selecione a onde serão armazenados seus arquivos: 
 
 
 
 
 
 
A após aceitar instalar, o Eclipse estará instalado conforme tela abaixo: 
 
 
Para Instalar o ADT plugin pelo próprio Eclipse, acessar a menu Help, opção 
Install New Software... 
 
 
 
 
 
 
Clicar no botão add: 
 
 
 
 
 
Digite os dados da tela abaixo : 
 
 
 
Embora não seja obrigatório, selecione todas as ferramentas conforme figura 
abaixo e selecione next: 
 
 
 
 
 
Aceite os termos de compromisso e click em finish : 
 
 
https://www.youtube.com/watch?v=Kg6TMURNyi8 
 
Embora você ainda não conheça os componentes e a estrutura do Android 
Studio, vamos implementar um pequeno exemplo demonstrando que é muito 
fácil desenvolver uma aplicação com o Android Studio. 
Execute o Android Studio. Será exibida a tela abaixo. 
 
 
 
 
Aguarde alguns instantes e será exibida a tela abaixo: 
 
 
Como podemos observar, dentre outras opções, podemos criar um projeto 
novo, abrir um projeto e existente ou até mesmo importar um projeto. Para o 
nosso primeiro exemplo, estarei criando um projeto novo(Start a new Android 
Studio project). 
Logo após, preencha os campos conforme demonstrado na figura abaixo: 
 
 
 
 
 
Após clicar no botão NEXT, será exibida uma tela, onde selecionamos o 
tipo de dispositivo para o qual desenvolverá seu aplicativo. 
 
 
 
Por opção, em nossos exemplos vou usar o API 23 Android 6.0. Altere seu 
exemplo conforme tela abaixo: 
 
 
 
 
 
 
Ao avançamos a tela (Next) , teremos que selecionar o tipo de Activity que 
desejamos implementar. 
Este assunto será discutido com mais detalhes na próxima aula. Por hora, ele 
representa uma tela que será exibida. 
Em nosso exemplo vou selecionar a Black Activity. Este tipo corresponde a uma 
tela em branco com a mensagem Hello World. Depois avançaremos a tela 
novamente (Next). 
 
 
Agora vamos configurar este Activity criado conforme definido na tela abaixo: 
 
 
 
 
 
 
Quando selecionar o Finish, o Android Studio estará montandotodas a 
estrutura necessária para que sua aplicação possa ser executada. Isto pode 
demorar algum tempo dependendo de seu equipamento. 
 
 
 
Logo após, será exibida a tela abaixo. Aparece uma tela dando algumas dicas. 
Você pode fecha-la apenas clicando em close. 
 
 
 
 
 
Pronto. Você já tem uma aplicação exemplo. Conforme informei anteriormente, 
só será exibida uma tela com Hello World. 
 
 
Para executar seu exemplo, é necessário que seja carregado um emulador 
referente ao seu dispositivo. Para tanto, na tela acima selecione o ícone 
indicado pela seta azul(AVD Manager). 
 
 
 
Será exibida a tela abaixo. Neste instante, como é a primeira vez que você esta 
rodando um aplicativo, não haverá nenhum emulador definido. Precisamos criar 
então este dispositivo virtual. Clique no botão indicado pela seta azul. 
 
 
Será exibida uma tela que apresenta uma série de dispositivos de tamanhos e 
resoluções diferentes. Fica a seu encargo escolher o que desejar. Em nosso 
exemplo, vou selecionar o modelo Nexus 5x, conforme demonstrado na tela 
abaixo. 
 
 
 
 
Ao avançar a tela, selecionando Next, Será exibida uma tela com os 
emuladores(AVD) disponíveis. 
Nesta opção recomnended serão exibidas as imagens em função dos SDKs que 
instalou. Você poder verificá-los no SDK Manager. No meu exemplo, estou 
selecionando a primeira opção, que é compatível com o meu SDK. 
 
Após o next, é possível configurar, com mais detalhes, o nosso emulador. 
 
 
 
 
 
 
Selecione Finish e será construído o nosso emulador. Isto pode demorar um 
pouco. 
 
 
 
Finalmente, será exibida a tela abaixo. Precisamos executar o emulador, para 
que a nossa aplicação possa rodar neste. 
Click no ícone indicado pela seta azul. 
 
 
 
 
 
Em um primeiro momento, nossa tela ficara aproximadamente assim. 
 
 
Aguarde mais um pouco até que nosso emulador fique a aparência semelhante 
à da tela abaixo. Para facilitar, apenas desloquei o emulador para o lado direito 
da tela. 
 
 
Agora vamos rodar nosso aplicativo. Click no ícone indicado pela seta azul, na 
tela acima. 
 
 
 
 
Será exibida a tela acima. Basta clicar em OK e pronto. 
Este processo pode demorar um pouco. 
Isto vai depender também de seu hardware. Logo após seu aplicativo já estará 
rodando em seu emulador. 
 
 
 
É bastante fácil, não é mesmo? 
 
 
 
Vamos incrementar um pouco mais nosso App? 
Antes vamos fazer uma analise mais detalhada de nosso App, lembrando que 
ainda discutiremos, cada componente, com mais profundidade nas próximas 
aulas. 
 
Veja a tela abaixo: 
 
 
Primeiramente, indicados pelas setas azuis horizontais na tela acima, temos os 
layouts. 
São arquivos XML que contem as definições das telas no Android. 
 Você pode, se desejar, observar o código XML referente a esta tela na aba 
Text, indicada pela seta azul vertical. 
 
 
 
 
 
 
Vinculado a esta tela, temos uma Activity, no meu caso MainActivity. É um 
arquivo Java. Nele, dentre várias coisas, são definidos os tratamentos dos 
eventos gerados em nosso dispositivo. Selecione a aba MainActivity indicada 
pela seta azul na figura acima. 
 
 
Observe que estamos configurando o MainActivity através do comando 
efetuado no código indicado pela seta azul da figura acima. 
 
 
 
Vamos conhecer um pouco mais da estrutura de nosso projeto. 
 
 
Esta tela nos apresenta o AndroidManifest.xml, indicado pelas setas azuis. 
Ele possui informações da aplicação, como por exemplo, as telas que possui, 
permissões, o que pode fazer entre outras coisas. Vamos exemplificar: Se criar 
uma atividade e não registrar neste arquivo, vai dar erro em tempo de 
execução. Pode observar, no código acima, que nosso MainActivity está 
definido. 
 
 
 
 
Na tela acima temos a pasta Java. Nesta encontraremos o código Java 
propriamente dito. Em nosso exemplo temos somente a MainActivity, que foi 
criada pela IDE. 
 
Na tela acima, encontramos a pastas res referente a recursos, como, por 
exemplo, imagens(bipmap), menus(menu), layouts(layout) e valores em 
geral(value). 
Vamos verificar o conteúdo do arquivo strings.xml. Para isto click no arquivo. 
Está sendo indicado pela seta azul na tela acima. 
 
 
 
 
Aqui está o nosso arquivo. Como exemplo, vou criar uma string que será 
exibida em nossa tela. 
Crie a linha abaixo: 
<string name="meuNome">Oswaldo Borges Peres</string> 
 
Agora, insira no arquivo onde indicado abaixo: 
 
 
 
 
Vamos alterar a mensagem de nossa tela de “Hello Word” para “Oswaldo 
Borges Peres”. 
Primeiramente selecione o arquivo content_main.xml. Esta indicado pela seta 
azul acima. 
 
 
 
 
Após isto clique uma vez na mensagem ”Hello World” que está na tela, 
conforme indicado abaixo: 
 
 
Vamos ver a propriedade referente ao texto deste componente. Em sua IDE 
pode não estar aparecendo como a minha. Basta clicar em Designer conforme 
indicado pela tela azul abaixo. 
 
 
 
 
 
Após isto selecione a propriedade Text. Veja na figura abaixo: 
 
 
 
Observe que este texto está definido como ”Hello World”. 
Podemos definir uma mensagem diretamente aqui ou capturar a string definida 
no arquivo strings.xml. 
Mas como? É muito fácil. Basta alterar este texto por: @string/meuNome 
Isto é apresentado na tela abaixo: 
 
 
 
 
Observe que é alterado automaticamente a mensagem exibida em seu 
dispositivo. 
Podemos também acrescer componentes e definir tratamento de eventos para 
os mesmos. Vamos lá! Ë muito fácil! 
Vamos inserir um Plain Text para dentro de nosso dispositivo e soltar. 
 
 
Depois reposicionei para o canto esquerdo o componente e alterei seu 
tamanho. 
 
 
 
 
Vou incluir agora um botão. 
 
 
Após arrastar e soltar o botão em meu dispositivo, temos a tela abaixo: 
 
 
 
 
 
 
Vou alterar o texto exibido no botão para Copiar. Basta apenas acessar a 
propriedade text e alterar. Veja tela abaixo: 
 
 
 
Podemos também tratar um evento para este botão facilmente. Veja a figura 
abaixo: 
 
 
 
 
 
Selecione a propriedade onCLick. Escreva exibir, que corresponderá a um 
método que criarei na MainActivity a ser executado quanto clicarmos neste 
botão. 
Observe que este evento é definido automaticamente no arquivo xml. Você 
poderia também alterar diretamente no mesmo. Veja a figura abaixo: 
 
Agora só falta construir o método exibir na MainActivity. Vamos lá? Selecione a 
aba MainActivity e acrescente o método exibir conforme ilustrado abaixo: 
 
 
 
 
 
Pronto. Nosso aplicativo já responderá ao nosso clique no botão. Execute-o e 
você verá a tela abaixo. Click em copiar. 
 
Viu como foi fácil? 
Desenvolvendo programas 
Para criar um projeto no Android Studio, selecione a opção Start a new Android 
Studio project na tela abaixo: 
 
 
 
 
Será exibida a tela abaixo onde: 
 
 Application Name: 
o nome do seu aplicativo. Não se esqueça que este nome 
será exibido no aparelho; 
 Company Domain: 
o domínio da sua empresa. 
 Package Name: 
o pacote Java onde serão salvas as classes do projeto. Este 
nome identifica o aplicativo, podendo ser editado, mas não 
podemos nos esquecer que deve ser único. Não é possível 
publicar na Google Play, aplicativos com o mesmo pacote, 
ou seja, não pode haver aplicativos com o mesmo nome 
instalados em seu aparelho 
 Project Location: 
o local onde será salvo o seu projeto.Após clicar em next será exibida a tela abaixo. Podemos selecionar o tipo de 
plataforma do projeto sendo: 
 
 Phone and tablet: 
 
 
o Em todos exemplos que estou trabalhando em nossa disciplina, 
selecionarei esta opção. Destina se a desenvolvimento para 
Smartphones e Tablets 
 Wear: 
 
o Este deve ser selecionado quando estamos desenvolvendo app 
para aplicativos que podemos “vestir”. Um exemplo seria os 
relógios que rodam Android. 
 TV: 
 
 
 
 
o Já este deve ser selecionado quando estamos desenvolvendo 
aplicativos para TVs que rodam sistema operacional Android. 
Inclusive já existem no mercado algumas TVs deste tipo, criadas 
por uma parceria Google e Sony. 
 
 Android auto: 
 
o Os automóveis não poderiam ficar de fora, não é mesmo? Este é 
destinado a aplicativos para equipar várias marcas de automóveis. 
 Glass: 
 
o Por último, o sonho de consumo da maioria dos brasileiros: 
Google Glass. Estes óculos inteligentes são equipados com 
Android. Logo precisam de aplicativos. Esta opção é destinada a 
este fim. 
 
Para todos os tipos de dispositivos, devemos escolher o Minimum SDK que 
corresponde ao menor SDK em que a aplicação vai rodar. 
Na tela abaixo, temos um exemplo da API 10 Android 2.3.3. Observe que este 
SDK é compatível com 100.0% dos dispositivos segundo informações do Google 
Play. Se alterássemos para API 18 Android 4.3, seria compatível com 74.3% 
dos dispositivos. 
 
 
 
 
 
Clicando em next, será exibida a tela abaixo que disponibiliza vários 
modelos(templates) de Activity que poderão ser selecionados em função do tipo 
de aplicação desejada. 
Em nosso exemplo, estamos selecionando o Blank Activity. 
 
 
A tela abaixo será exibida, após clicarmos em next, onde: 
 
 Activity Name: 
 
o Nome do Activity principal. Em um aplicativo podem haver várias 
activities. 
 Layout Name: 
 
o Nome do arquivo XML que possui especificações dos aspectos 
visuais de seu Activity; 
 Title: 
 
o Título da sua aplicação quando executado no emulador Android; 
 
 
 
 Menu Resource Name: 
 
o nome do arquivo XML que possui a especificações dos itens de 
menu da action bar. 
 
Após clicarmos em next, será exibida a tela abaixo: 
 AVD Manager 
 
 
 
 
Próximo passo é selecionar o emulado do dispositivo a que o projeto se destina. 
Este é conhecido como Android Virtual Device(AVD). Para isto, na barra de 
ícones, clique no ícone 
 
 
É necessário selecionar o emulador referente a mesma plataforma do sistema 
operacional, resolução de tela, dentre outras configurações. Para tanto 
selecione a opção Create Virtual Device. 
 
 
 
 
 
Selecione o emulador em função do seu tipo de aplicativo e selecione next. 
 
 
Selecione, em função da API baixada, a imagem de sistema para criar o 
emulado Android e clique em next. 
 
 
 
 
 
 
Nesta tela é exibida as configurações do seu AVD. Se desejar, pode efetuar 
alterações e clique em Finish. 
Para executar o emulador basta clicar no ícone 
 
 
 
 
 
 
Este processo pode demorar um pouco. 
 
 
 
 
Para executar seu projeto, basta clicar no ícone 
 
 
 
 
 
Conforme podemos visualizar na tela acima, será exibido um quadro, chamado 
Choose a running device, onde podemos selecionar o tipo de emulador 
desejado, se o dispositivo estiver fechado devemos selecionar a opção Launch 
emulator e ainda podemos definir este dispositivo como padrão para as 
demais chamadas ao emulador. 
Logo após ser clicado Ok, será exibida a tela abaixo: 
 
 
 
 
 Eclipse ADT Bundle: 
 
O processo de criação de programas no Eclipse é bastante similar 
ao do Android Studio. 
Primeiramente, devemos executar o Eclipse. Será exibida a tela 
abaixo: 
 
 
 
 
 
No menu File ou com o botão direito do mouse, devemos selecionar a opção 
New e Android Application Project. Logo após, será exibida a tela abaixo: 
 
 
 
 
 
 
 
Assim como no Android Studio, nesta tela precisamos informar: 
 
 Application Name: nome do projeto que será exibido 
 Project Name: nome físico do projeto. Corresponde à pasta 
onde o mesmo será armazenado; 
 Package Name: o nome do pacote onde a aplicação será 
armazenada; 
 Minimum Required SDK: informa a versão mínima do Android 
que o dispositivo deve possuir para rodar sua aplicação; 
 Target SDK: Informa a versão ideal para rodar sua aplicação; 
 Compile With: Informa a versão usada para compilação de sua 
aplicação; 
 Theme: o nome do tema de sua aplicação. 
 
Após ter digitado os dados, selecione a opção next. 
 
 
 
 
 
Nesta tela será oferecida a opção de criar um ícone personalizado para 
representar se projeto, seu Activity, se o projeto será marcado como uma 
biblioteca e o local onde será salvo seu projeto(por default, seu workspace). 
Agora selecione a opção Next. 
 
 
 
 
 
 
É nesta tela que podemos configurar o ícone de sua aplicação, sendo: 
 
 Image: imagens existentes no computador; 
 Clipart: imagens disponibilizadas pelo Android; 
 Text: texto como representação visual. 
 
O Android oferece suporte aos principais tipos de imagens(JPEG, GIF, PNG e 
outras), porém é recomendável utilizar o formato PNG(Portable NetWork 
Graphic) por ser um formato mais leve e que suporta transparência, 
multiplataforma, dentre outras vantagens. 
Uma vez configurado o ícone de sua aplicação, selecione a opção Next. 
 
 
 
 
 
Nesta tela, podemos selecionar um template para o seu Activity. 
Precisamos tomar cuidado na compatibilidade com as versões do Android. 
Uma vez escolhido, selecione Next. 
 
 
 
 
 
 
 
Finalizando o processo de criação de sua aplicação, esta tela devemos informar: 
 
 Activity Name: nome do Activity, que representa uma tela de 
sua aplicação. 
 Layout Name: nome do arquivo .XML onde definimos o layout da 
tela 
 
Agora, para criar o projeto, basta selecionar Finish. 
 
 
 
 
 
 
Como pode observar nesta tela, a estrutura do seu projeto é constituida por: 
 
 src: localização dos códigos-fontes de seu aplicativo; 
 gen: localização do arquivo R.java. Arquivo que contém 
referências a recursos de sua aplicação. 
 res: contém os recursos de seus projetos; 
 assets: pasta que contém recursos de seu projeto que 
independem da diferença de densidade ou do tamanho de seu 
display. 
 libs: bibliotecas externas que seu aplicativo faz uso; 
 AndroidManisfest.xml: arquivo de manifesto. 
Agora vamos configurar no AVD. Para tanto devemos selecionar o AVD 
Manager através do ícone 
 
 
 
 
 
 
AVD Manager 
 
 
Em nosso exemplo, já existe um AVD, mas podemos criar um novo. Para tanto, 
selecione a opção Create na tela acima. 
 
 
 
 
 
Nesta tela podemos configurar: 
 
 AVD Name: nome do AVD 
 Device: Selecionar o tipo de dispositivo; 
 Target: Versão do Android para a emulação no AVD; 
 CPU/ABI: Selecionar a CPU que será emulada; 
 Keyboard: informar se existe ou não um teclado físico no 
dispositivo; 
 Skin: informar se as teclas de hardware(Back, Home, Menu) 
serão apresentada no Emulado; 
 Front camera e Back camera: simular câmera fronta ou atrás 
do dispositivo; 
 Memory Options: infomar valores referentes a memória RAM do 
Emulador; 
 Internal Storage: simular o tamanho de armazenamento interno 
do dispositivo emulado; 
 
 
 
 SD Card: informar sobresuposto cartão de memória conectado 
ao Emulador; 
 
Uma vez que seu AVD esta configurado, basta selecionar a opção Ok. 
 
 
Selecione o AVD que deseja executar e clique em Start. 
Feito isto a tela abaixo será exibida. 
 
 
 
 
 
Isto pode demorar alguns instantes, pois o Android, ao contrário de outros, usa 
Emulador e não simulador. 
 
 
 
 
 
 
Para executar sua aplicação, clique com o botão direito no seu projeto e 
selecione Run As e Android Application. Seu projeto será executado 
conforme exibido na tela abaixo: 
 
 
Activity. 
Estrutura de um projeto Android: 
 
O Android Studio pode abrir um projeto de cada vez. Conforme é demonstrado 
na figura abaixo, cada projeto pode possuir um ou mais módulos. 
 
 
 
 
 
 
Arquivos do diretório raiz do projeto: 
 
Pasta Descrição 
 
app módulo app do projeto. Este módulo é padrão 
build.gradle arquivo de configuração do Gradle. Vale para 
todo o projeto, incluindo todos os módulos. 
gradle.properties arquivo de propriedades para customizar o 
build do Gradle 
gradlew.bat Script que executa o build do Gradle para 
 compilar o projeto 
local.properties arquivo com as configurações locais do 
projeto 
settings.gradle arquivo de configuração do gradle que indica 
quais módulos dever ser compilados. 
 
Arquivos do módulo app: 
 
 
 
 
 
Pasta Descrição 
 
build onde ficam os arquivos compilados do 
módulo. 
R.java A classe R que é gerada 
automaticamente ao 
se compilar o projeto. Esta permite a 
aplicação acessar qualquer recurso. 
libs onde devem ser inseridos os arquivos 
.jars a 
serem compilados com o projeto. 
src/main/java pasta que contém os arquivos 
Java. 
src/main/res pasta que contém os recursos da 
aplicação. 
res/drawable pasta que contém as imagens da 
aplicação. 
res/mipmap pasta com o ícone da aplicação; 
res/layout pasta que contém os arquivos XML de 
layouts 
para construir as telas da aplicação; 
res/menu pasta que contém os arquivos XML que 
criam 
os menus da aplicação, que são os 
botões com 
ações na action bar; 
res/values pasta que contém os arquivos XML 
utilizados 
 para a internacionalização, 
configuração de 
 temas e outras configurações. 
 
 
 
Arquivo AndroidManifest.xml: 
 
Considerado um dos principais arquivos de sua aplicação, é neste arquivo que 
são descritas informações essenciais à execução de seu projeto como, por 
exemplo, nome do pacote utilizado, nome das activities, permissões que o 
aplicativo possui, versão mínima da API Android, dentre outros. 
 
 
 
 
 
 
 
 
 
Precisamos declarar obrigatoriamente todas as activity implementadas no 
projeto neste arquivo. Isto é realizado através da tag <activity></activity>, 
como podemos observar no exemplo acima. 
Arquivo activty_main.xml: 
 
Este arquivo, por default, possui este nome. Porém podemos escolher um nome 
mais adequado. 
Neste arquivo são definidas as configurações para criação do layout da tela. 
 
<?xml version="1.0" encoding="utf-8"?> 
<manifest 
xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.profoswaldo" 
 android:versionCode="1" 
 android:versionName="1.0.0"> 
 <application android:icon="@drawable/icon" 
android:label="@string/app_name"> 
 <activity android:name=".MainExemplo" 
 android:label="@string/app_name"> 
 <intent-filter> 
 <action android:name="android.intent.action.MAIN" /> 
 <category 
android:name="android.intent.category.LAUNCHER" /> 
 </intent-filter> 
 </activity> 
 </application> 
</manifest> 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Arquivo strings.xml: 
 
Este arquivo centraliza as mensagens de seu aplicativo. Facilita, inclusive, muito 
a internacionalização do aplicativo. 
 
 
 
 
 
 
 
Classe R: 
 
Este arquivo possui as referências para acessar os recursos de seu projeto. Ë 
gerada automaticamente pelo compilador. É recomendável que está classe não 
seja alterada manualmente. 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 android:orientation="vertical" 
 android:layout_width="fill_parent" 
 android:layout_height="fill_parent" 
 android:background="@color/all_white"> 
<TextView 
 android:layout_width="fill_parent" 
 android:layout_height="wrap_content" 
 android:text="@string/hello" android:textColor="@color/all_black" 
 android:gravity="center_horizontal"/> 
</LinearLayout> 
<?xml version="1.0" encoding="utf-8"?> 
<resources> 
 <string name="hello">Exemplo</string> 
 <string name="app_name">MainActivity</string> 
 <color name="branco">#FFFFFF</color> 
 <color name="preto">#000000</color> 
</resources> 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Activity 
 
Muito similar ao JFrame do J2SE , a Activity é responsável por construir uma 
tela em Android, bem como tratar os eventos gerados por ela. 
Toda aplicação Android deve implementar ao menos um Activity, podendo 
chamar outras activities. 
O Android é responsável por gerenciar o ciclo de vida dos Activities. Para tanto, 
faz uso do conceito de pilha, chamada de “activity stacks”(pilha de atividades). 
Toda Activity ao ser executada é inserida no topo desta pilha. A Activity anterior 
é parada e move-se para baixo da pilha. 
 
O Android pode até mesmo encerra Activities se precisar de recursos. Nesta 
caso, ele verifica a pilha de atividade para determinar a prioridade das 
atividades e quais podem ser fechadas. 
 
public final class R { 
 public static final class attr { } 
 public static final class drawable { 
 public static final int icon=0x7f020000; 
 } 
 public static final class id { 
 public static final int b1=0x7f050001; 
 public static final int text1=0x7f050000; 
 } 
 public static final class layout { 
 public static final int main=0x7f030000; 
 } 
 public static final class string { 
 
 public static final int app_name=0x7f040001; 
 public static final int app_name1=0x7f040003; 
 
 public static final int hello=0x7f040000; 
 public static final int hello1=0x7f040002; 
 } 
} 
 
 
 
 
 
Ciclo de Vida Activity: 
 
 
 
Fonte: http://android.okhelp.cz/wp-content/uploads/lifecycle-activity-
android.png 
Fonte: http://4.bp.blogspot.com/-HSwGf-
pS91g/UZx5IRzamSI/AAAAAAAAAEs/y6wK1CnLUw0/s1600/ACTIVITYSTA.png 
 
 
 
Principais métodos: 
 onCreate(): 
 
o é a primeira função executada quando a activity é criada. Tem por 
responsabilidade, carregar os layouts XML, inicializar os objetos, 
variáveis e outras operações de inicialização. É importante 
lembrar que é executada somente uma vez. 
 onStart(): 
 
o é executado antes da activity ficar visível na tela do dispositivo, 
podendo ser chamado após os métodos onCreate() ou 
onRestart(). 
 
 
 
onResume(): 
 
o representa o estado de que a activity está executando. É chamada 
logo após o evento onStart. 
 onRestart(): 
 
o É chamado, imediatamente após ao método onStart(), quando 
uma Activity que estava parada volta ao foco. 
 onPause(): 
 
o É chamado sempre que a tela do activity fechar. Isto ocorre 
quando uma outra activity (da sua aplicação ou não) ganhar o 
foco. 
 onStop(): 
 
oé chamada após o método onPause(), quando a Activity não está 
mais visível e está sendo encerrada; 
 onDestroy(): 
 
o é chamada antes da Activity ser destruída e logo após será 
liberada a memória. 
 
 
 
 
Exemplo: 
package com.profoswaldo.helloworld; 
 
import android.os.Bundle; 
import android.app.Activity; 
import android.util.Log; 
 
public class MainActivity extends Activity { 
 String msg = "Android : "; 
 
 /** Chamado quando a activity é criada pela primeira vez.*/ 
 @Override 
 public void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 Log.d(msg, "The onCreate() event"); 
 } 
 
 /** Chamado quando a activity está prestes a tornar-se visível. */ 
 @Override 
 protected void onStart() { 
 super.onStart(); 
 Log.d(msg, "The onStart() event"); 
 } 
 
 /** Chamado quando a activity tornou-se visível.*/ 
 @Override 
 protected void onResume() { 
 super.onResume(); 
 Log.d(msg, "The onResume() event"); 
 } 
 
 /** Chamado quando uma outra activity está tomando foco. */ 
 @Override 
 protected void onPause() { 
 super.onPause(); 
 Log.d(msg, "The onPause() event"); 
 } 
 
 /** Chamado quando a activity não é mais visível.*/ 
 @Override 
 protected void onStop() { 
 super.onStop(); 
 Log.d(msg, "The onStop() event"); 
 } 
 
 /** Chamado antes da activity ser destruída.*/ 
 @Override 
 public void onDestroy() { 
 super.onDestroy(); 
 Log.d(msg, "The onDestroy() event"); 
 } 
} 
 
 
 
Intent 
 
Como estudamos, cada Activity corresponde a uma tela de nossa aplicação no 
Android, muito embora seja muito mais do que simplesmente uma tela, não é 
mesmo? Mas se precisássemos trabalhar com mais de uma tela? Devido a 
limitação de tamanho de nossos dispositivos, é muito comum distribuirmos 
componentes por várias telas visando facilitar o uso da aplicação. 
O que fazer então? Dentre várias componentes fundamentais a programação de 
aplicativos Android, como Activities, Services e BroadCast Receivers, a Intent 
possibilita realizar a ligação, em tempo de execução, de componentes 
separados como, por exemplo, chamar Activities diferentes. Em outras palavras, 
podemos dizer que uma Intent nada mais é do que a intenção da aplicação em 
realizar uma determinada tarefa. 
Como falei, é uma intenção, ou seja, não necessariamente vai ser executado, 
pois depende se o dispositivo permitirá. 
Mas como é possível isto? Para tanto, a Intent envia ao sistema operacional o 
equivalente a uma mensagem(broadcast). 
Este receberá a chamada e, dependendo do conteúdo, tomará as providências 
necessárias. Como exemplo, poderíamos: 
 Iniciar uma nova Activity; 
 Iniciar Bluetooth do aparelho; 
 Ligar o GPS(Global Positioning System); 
 Efetuar uma ligação telefônica; 
 Abrir o programa de envio de SMS(Short Message Service); 
 Chamar o navegador Web; 
 Enviar mensagens para o Sistema Operacional; 
 E muitas outras ações. 
 
 
 
 
Um Intent é basicamente um conjunto de dados que possuem informações de 
interesse para os componentes que a recebem e também para o Android. Este 
deve conter: 
 
 Nome do componente: 
o Representa o nome do componente que tratará a Intent. Deve ser 
o nome completo da classe alvo do componente. Este nome deve 
ser uma combinação do pacote do componente e o pacote 
definido no manifesto. 
 
 Ação: 
o É o que propriamente dito você deseja executar. Consiste de uma 
String com o nome da ação a ser executada. N caso de um 
broadcast, a ação que aconteceu e que está sendo reportada. 
Podemos possuir ações específicas de nossa aplicação, biblioteca 
ou ações predefinidas conforme tabela abaixo: 
Constante 
Componente 
alvo 
Ação 
ACTION_CALL activity 
Inicia uma chamada de 
telefone 
ACTION_EDIT activity 
Mostra dados para o 
usuário editar 
ACTION_MAIN activity 
Inicia a atividade que 
está marcada como 
inicial em modo vazio e 
com nenhum retorno 
ACTION_SYNC activity 
Sincroniza dados no 
servidor a partir do 
dispositivo móvel 
ACTION_BATTERY_LOW broadcast receiver 
Mostra um aviso que a 
bateria está baixa 
 
 
 
ACTION_HEADSET_PLUG broadcast receiver 
Mostra que um fone de 
ouvido foi plugado no 
dispositivo ou 
desplugado 
ACTION_SCREEN_ON broadcast receiver A tela foi ligada 
ACTION_TIMEZONE_CHANGED broadcast receiver 
As configurações da 
zona de tempo foi 
mudada 
 
 
 Dados: 
o URI e MIME type dos dados que vão adicionados à Intent. 
Diferentes ações são paradas com diferentes tipos de dados. 
Exemplo: Enviar uma foto para que um outro aplicativo trate, 
precisamos definir a URI e o MIME type. 
 
 Categoria: 
o String com informações adicionais sobre o tipo do componente 
que deve tratar a Intent. Qualquer número de categorias pode ser 
adiciona em uma Intent. Segue abaixo, as principais constantes 
predefinidas: 
 
Constante Significado 
CATEGORY_BROWSABLE 
A atividade alvo pode ser chamada de 
maneira segura pelo navegador para 
mostrar dados referenciados por um link 
(imagem ou email, etc) 
CATEGORY_GADGET 
A atividade pode ser embarcada dentro de 
outra atividade que hospede gadgets. 
CATEGORY_HOME 
A atividade mostra a tela home, a primeira 
tela que o usuário vê quando o dispositivo é 
ligado ou quando a tela HOME é 
pressionada. 
 
 
 
CATEGORY_LAUNCHER 
A atividade pode ser a atividade inicial ou 
uma tarefa e é listada no tipo da aplicação 
launcher. 
CATEGORY_PREFERENCE A atividade alvo é o painel de preferências 
 
 Extras: 
o Pares chave-valor para informações adicionais que devem ser 
entregue para o componente que tratará a Intent. 
 
 Flags: 
o Funcionam como instruções para o sistema Android, de como 
lançar uma Activity ou como tratá-la depois de lançada. Todas as 
falas são definidas na classe Intent. 
 
Intent Filter 
 
Como saber se uma Intent vai ser entregue para o componente correto? 
Primeiramente precisamos entender melhor os tipos básicos de Intents. 
 
Tipos de Intents: 
As Intents podem ser classificadas como implícitas e explícitas. 
 Explícitas: 
o Como determina o componente pelo nome, é usada para 
passagem de mensagens na própria app. 
 Implícitas: 
o É enviada ao sistema operacional e pode ser tratada por 
componentes em outras app’s. Neste caso, a definição de 
quem tratará a Intent é feita o conteúdo do objeto Intent é 
comparado com alguns filtros chamados Intent Filters. 
 
 
 
 
 
Basicamente, um Intent Filter informa ao sistema quais Intents um certo 
componente pode tratar. Um componente pode ter uma ou mais Intent Filters. 
Com relação à tipo implícita, a Intent seráo entregue se um dos filtros atender 
aos critérios da Intent. Já no caso da explícita, será entregue diretamente ao 
componente designado, não importanto o filtro, pois nem chega a consultá-lo. 
 
Aplicando Intent na prática 
 Vamos criar um projeto demonstrando o Intent em ação? 
 
 
Primeiramente abra o Android Studio e click na opção Start a new Android 
Studio projetct. 
 
 
 
 
 
 
Em nosso exemplo, vou criar o nome de nossa aplicação Aula4Intent. O nome 
do domínio da empresa será meu email. 
Manterei o nome do pacote gerado a partir do nome da aplicação e do domínio 
da empresa. Você pode até alterar, mas não se esqueça que deve ser único. 
 
 
 
 
 
Para este exemplo, selecionarei o meu dispositivo para Phone e tablete o sdk 
mínimo para Android API 23 (Marshmallow). 
 
 
 
 
 
 
 
Para simplificar, em nosso exemplo estarei selecionando o modelo Empty 
Activity. O nome desta Activity será Principal. 
O nome do arquivo de layout será demominado activity_principal. Este é 
responsável por informações do layout de nossa tela. 
 
 
Após selecionar Finish, a tela abaixo será exibida. Não se preocupe, pois pode 
demorar um pouco, dependendo de seu equipamento. 
 
 
 
 
Pronto. Sua tela deve estar semelhante a retratada abaixo: 
 
 
Selecione a Activity Principal. Observe que dentro do método 
setOnClickListener, estamos instanciando o objeto i(Intent) e em seu 
conntrutor são passados dois parâmetros: 
 
 
 
 o contexto da Activity atual; 
 classe da Activity a ser iniciada. 
Em nosso exemplo corresponde respectivamente aos métodos 
getApplicationContext() e Segunda.class. 
 
 
 
Logo após, vamos criar uma Empty Activity com o nome Segunda. Esta 
corresponderá a nossa segunda Activity. Alteres seu código conforme descrito 
abaixo: 
 
 
 
 
 
Criamos o nosso Intent exatamente igual a activity Principal. 
A única diferença é que será iniciada será a Principal, pois este parâmetro 
configurado é Principal.class. 
Dando mais um passo, selecione o arquivo activity_principal.xml. Este é 
responsável por definir a nossa tela. 
 
 
 
 
 
 
Observe a tag <RelativeLayout>. Mais a frente, estudaremos com mais 
detalhes os diversos tipos, mas, por enquanto, o RelativeLayout organiza os 
componentes do layout de uma tela em relação uns aos outros. 
 
 
 
 
 
 
Observe que definimos que em nossa tela constará um botão e um textView. 
Não é fabuloso? Mais a frente em nossa aula, estudaremos os principais views 
com mais detalhes. 
Vamos alterar agora o título do menu de nossa aplicação conforme pode ser 
constatado no arquivo activity_main.xml exibido na tela abaixo: 
 
Para finalizar, vamos definir o título de nossa aplicação e título de nosso menu 
para, respectivamente Aula4Intent e Configurações. 
 
 
 
 
 
Pronto. Agora é só rodar. Vamos lá! Selecione. Chamar a segunda activity e 
depois em chamar a primeira activity. 
 
 
 
 
Componentes gráficos. 
O Android tem evoluido constantemente no que tange a interface gráfica. Ainda 
mais nos dias de hoje, onde existem dispositivos móveis muitas vezes com uma 
capacidade de tela superior até mesmo às televisões de última geração. 
Para tanto, o Android oferece suporte nativo para o desenvolvimento de 
interfaces gráficas sofisticadas. Podemos destacar: 
 View: 
o é a classe responsável pela criação de qualquer componente 
gráfico. Esta ocupa uma área retangular na tela e é 
responsável por desenhar e controlar os eventos. 
 Widgates: 
o representa os componentes gráficos. Esta é base para a 
criação de componenets da interface do usuário interativos, 
como por exemplo, botões, caixas de texto, entre outros. 
 View Group: 
o É a classe base para o desenvolvimentos dos layouts. 
 Layouts: 
o são sub-classes de ViewGroup. 
 
 
 
 
Tipos de componentes gráficos: 
Existem vários tipos de componentes, entre eles, podemos destacar: 
 TextView: 
http://i.stack.imgur.com/vYsMp.pn
g 
 
 
 
o Considerado um dos componentes mais usados em 
Android, define um texto que será exibido na tela; 
 Button: 
o nada mais é que um simples botão. Após clicarmos neste, 
podemos executar uma ação. 
 ImageButton: 
o Similar ao botão, porém, você adiciona uma imagem neste 
botão. 
 EditText: 
o Uma caixa onde é digitada alguma informação, que poderá 
ser usado para interagir com a aplicação Android. 
 CheckBox: 
o Um botão do tipo "caixa de seleção", onde existe dois 
estados: verdadeiro ou falso. 
 RadioButton: 
o Similar ao CheckBox, porém não deve permitir a seleção 
mais de uma opção. 
 RadioGroup: 
o tem por objetivo agrudar estes radiobuttons, permitindo a 
seleção de apenas um RadioButton dentro deste 
Radiogroup. 
 
Exemplo prático: 
 
Crie um projeto com o nome que desejar e altere o arquivo activity_main.xml 
conforme vemos abaixo: 
 
 
 
 
 
Agora vamos definir nosso arquivo MainActivity conforme tela abaixo: 
 
 
Não podemos esquecer do arquivo string.xml. 
 
 
 
 
 
 
Execute agora. Fácil não é mesmo? 
Gerenciadores de Layout 
 
No mundo conteporâneo, houve um crescimento exponencial no uso de 
dispositivos móveis, em especial, tablets e celulares. 
Com isto, nossos usuários já não são mais os mesmos. 
Estes, ávidos por informações de qualidade e em curto prazo de tempo, 
evoluíram muito em suas necessidades e , com isto, conceitos referentes 
velocidade, design, usabilidade, acessibilidade e outros estão em pauta para 
qualquer tipo de desenvolvimento de aplicação, em especial, para os 
dispositivos móveis. 
 Em nossa aula anterior, aprendemos como desenvolver telas gráficas no 
Android, a partir de elementos visuais conhecidos por Widgets. Mas, para 
atendermos a este novo perfil de usuário, precisamos melhorar a qualidade de 
nossas telas. 
 
 
 
Esta tarefa nem sempre é tão fácil, no que tange a implementação. Nossas 
aplicações precisam ser executadas em vários tipos de dispositivos diferentes, 
mas nem todos possuem as mesmas características, como por exemplo, 
tamanho da tela. Já imaginou o trabalho que seria para organizar os 
componentes em cada tipo de tela? Neste ponto, o Android nos ajuda muito 
através de um conjunto de classes, pré-definidas, denominadas Gerenciadores 
de layout, que tem por finalidade organizar os componentes de nossas telas. 
Observe a figura abaixo: 
 
Como estudamos anteriormente, a classe View é a base para todo e 
qualquer componente visual no Android, que devem implementar o 
método onDraw(), responsável por desenhar o componente na tela. Em 
amarelo são destacados os Widgets, que nada mais são do que 
componentes simples que herdam diretamente desta classe. Em branco 
estão as classes que herdam a classe View Group. Estes são conhecidos 
por gerenciadores de layout. 
 
 
Principais layouts: 
 
 AbsoluteLayout(android.widget.AbsoluteLayout): 
o Os componentes são posicionados na tela em função das 
coordenadas X e Y fornecidadas. 
 FrameLayout(android.widget.FrameLayout): 
o O componente ocupa a tela inteira. Funciona como uma 
pilha sendo que uma view fica por cima da outra. 
 LinearLayout(android.widget.LinearLayout): 
o Os componentes são organizados na vertical ou horizontal. 
 TableLayout(android.widget.TableLayout): 
https://www.ibm.com/developerworks/br/opensource/tutorials/os-eclipse-
androidwidget/figure07.gif 
 
 
 
o Assim como em uma tabela, os componente são 
organizados em colunas e linhas 
 RelativeLayout(android.widget.RelativeLayout): 
o A organização do componente é implementada relativa a 
outro componente. 
 
 
a. AbsoluteLayout(deprecated): 
 
Neste tipo de gerenciador de layout , todos os componentes são 
posicionados em função de abcissa e ordenada, tendo como base 
o canto superior esquerdo. É bastante oportuno lembrar que este 
é menos flexível e mais difícil de manter que os demais 
gerenciadores. 
É importante também saber que este gerenciador está 
obsoleto(Deprecated). 
 
Exemplo: 
 
Abra o Android Studio. Selecione a opção Start a new 
Android Studio project e será exibida a tela abaixo: 
 
 
 
 
 
 
Para o nosso projeto escolhi o nome da aplicação comoAula5AbsoluteLayout e a companhia, como em todos os meus exemplos, é 
com.profoswaldo. Selecione agora Next. 
 
 
 
Em meu exemplo, selecionarei o meu dispositivo para Phone e tablet e o sdk 
mínimo para Android API 23 (Marshmallow). Selecione Next. 
 
 
 
 
 
 
 
Para meu exemplo, estou selecionando um Empty Activity. Avançar 
novamente. 
 
 
 
 
 
 
Embora possa definir qualquer nome para minha Activity e para o layout, 
manterei os mesmo sugerido pela minha IDE. Agora para finalizar, selecione 
Finish. 
Vamos agora configurar nossas Strings que serão exibidas na tela de nosso 
aplicativo. Para tanto, selecione o arquivo string.xml e altere seu conteúdo 
conforme definido abaixo: 
 
 
 
 
Foram criadas as Strings app_name e menu_settings e atribuidos os valores 
Aula5 - Exemplo AbsoluteLayout e Configurações respectivamente. 
Logo após, estou definido o título do menu de configurações de nosso 
aplicativo. 
Conforme discutido em nossa aula anterior, isto é possível devido a 
"@string/menu_settings" 
 
 
 
 
 
 
 
Para nosso exemplo, estou incluindo 2 botões em nossa tela. Para tanto, alterei 
o arquivo activity_main.xml conforme você pode observar abaixo: 
 
 
 
 
 
 
 
Para construirmos nossa tela, precisamos, configurar a altura e largura de cada 
widgets, assim como do layout principal. Isto é feito através dos parâmetros: 
 android:layout_height 
o Define a altura de uma determinada view; 
 android:layout_width 
o Define a largura de uma determinada view; 
 
 
Os valores possíveis para estes dois parâmetros são: 
 fill_parent(deprecated): Idem ao match_parent; 
 match_parent: 
o este poderá expandir o quanto precisar. 
Precisamos ter cuidado, pois com este 
atributo, principalmente com imagens, pois 
pode ocorrer a distorção da mesma. 
 wrap_content: 
o este poderá expandir o quanto for possível, ou 
seja, o tamanho necessário para desenhar o 
componente. 
 número (dp): 
o define um tamanho fixo; 
 
Precisamos definir o também definir a posição de nossos 
widgets: 
 android:layout_x: 
o Define a coordenada X; 
 android:layout_y: 
o Define a coordenada Y; 
 
Estas coordenadas são referentes ao canto superior do componente em relação 
ao canto superior esquerdo de nosso layout. 
 
 
 
 
Está quase acabando! Só falta agora, o nosso MainActivity. Veja a figura 
abaixo: 
 
 
Pronto. Execute agora! 
 
b. FrameLayout: 
É utilizado para reservar um espaço na tela que será utilizado por um ou mais 
componentes. 
 
 
 
Quando mais de um componente for inserido dentro de um único FrameLayout, 
haverá uma sobreposição dos mesmos, a menos é claro que você divida a tela 
e coloque cada um na sua posição. 
Exemplo: 
Como no exemplo anterior, criaremos o nosso projeto com o nome 
Aula5FrameLayout. 
 
 
 
Assim como todos os nossos exemplos nesta aula, estarei usando a API 23 
conforme podemos verificar na tela abaixo: 
 
 
 
 
 
 
 
Para fins pedagógicos, estarei selecionando uma Empty Activity. Precisamos 
dominar este conceito melhor, não é mesmo? Mais a frente, estarei trabalhando 
com os demais tipos. 
 
 
 
 
 
 
Manterei, para facilitar, o nome sugerido pelo Android Studio para atividade e 
layout. Veja a tela abaixo: 
 
 
 
Aqui está o coração de nosso layout, no caso, FrameLayout. Altere o conteúdo 
do arquivo conforme tela abaixo: 
 
 
 
 
 
Alguns parâmetros, precisam ser discutidos para entendermos melhor este tipo 
de layout. 
Criei os componentes textView, textView1, textView2, textView3, textView4. Já 
verificamos, no exemplo referente a AbsoluteLayout, os parâmetros 
android:layout_height e android:layout_width, mas existem novas: 
 
 android:layout_marginTop: 
o Esta propriedade define o tamanho da margem 
superior. Embora não tenhamos implementado 
em nosso exemplo, existem suas correlatas, 
como: 
 android:layout_marginBottom: 
 margem inferior; 
 android:layout_marginLeft: 
 margem esquerda; 
 android:layout_marginRight: 
 margem direita; 
 android:layout_margin: 
 as quatro margens. 
Exemplo: 
android:layout_margin="10dp" 
 android:layout_gravity: 
o define a posição dos componentes em relação ao 
gerenciador de layout que os contem. 
 android:gravity: 
o define o posicionamento do conteúdo do 
componente; 
 android:padding: 
o define a distância entre o conteúdo interno do 
componente e sua borda. Neste caso todos os 4 
espaçamentos serão iguais. Poderiamos também 
 
 
 
escolher o espaçamento que desejássemos 
usando: 
o android:paddingTop 
 espaçamento superior; 
o android:paddingBottom 
 espaçamento inferior; 
o android:paddingRight 
 espaçamento lado direito; 
o android:paddingLeft 
 espaçamento lado esquerdo; 
 android:background: 
o define uma cor(em hexadecimal) ou imagem 
referente ao backgroud de nosso layout; 
 android:textColor: 
o define a cor de nossa fonte; 
 android:textSize: 
o define o tamanho de nossa fonte; 
 android:textStyle: 
o define o estilo do texto(bold. Italic, normal) 
 
Pronto. Agora é só executar e verificar o FrameLayout em ação: 
 
 
 
 
 
 
c. LinearLayout: 
 
Este tipo de gerenciador de layout tem por característica a 
capacidade de alinhar verticalmente ou horizontalmente os 
componentes. Isto depende, obviamente da orientação escolhida. 
Veja os exemplos abaixo: 
Exemplo LinearLayout Horizontal: 
 
Como já criamos vários projetos passo-a-passo anteriormente, 
vamos direto ao ponto: 
Na tela abaixo estão as alterações que efetuei no arquivo 
activity_main.xml para demonstrar o LinearLayout Horizontal. 
 
 
 
 
 
 
Excute e poderá constatar, conforme exibido na tela abaixo, que os widgets 
estão alinhados na horizontal, não é mesmo? 
Até o momento, não usamos nenhuma atributo desconhecido, exceto, é claro, o 
LinearLayout. 
 
 
Exemplo LinearLayout Vertical: 
 
 
 
Agora vamos transformar o exemplo anterior em vertical. Para tanto, só 
precisamos alterar o atributo android:orientation="vertical" conforme 
demonstrado na tela abaixo. Repare que este atributo não foi modificado no 
exemplo anterior, pois o default é horizontal. 
 
 
 
Pronto, somente isto é necessário para demonstrar os nossos componentes 
sendo alinhado na vertical. Fácil, não é mesmo? 
 
 
 
 
d. RelativeLayout: 
 
O RelativeLayout organiza os componentes do layout de uma tela em relação 
uns aos outros. Isso é uma grande vantagem deste gerenciador de layout, no 
que tange a flexibilidade de posicionamento dos componentes. Na teoria é 
muito fácil de entender, mas como seria em um código fonte? Vamos ver o 
exemplo abaixo: 
 
Exemplo: 
 
Altere o arquivo activity_main.xml conforme tela abaixo: 
 
 
 
 
Principais atributos: 
 android:layout_below: 
o posiciona abaixo do componente indicado; 
 android:layout_above: 
o posiciona acima do componente indicado; 
 
 
 
 android:layout_toRightOf: 
o posiciona à direita do componente indicado; 
 android:layout_toLeftOf: 
o posiciona à esquerda do componente indicado; 
 android:layout_alignParentTop: 
o alinha no topo do layout-pai; 
 android:layout_alignParentBottom: 
o alinha abaixo do layout-pai; 
 android:layout_alignParentRight: 
o alinha à direita do layout-pai; 
 android:layout_alignParentLeft: 
o alinha à esquerda do layout-pai;