Programação - Coding Mobile (Java) - 1

Prévia do material em texto

Unidade I
Estrutura de um Projeto Android
Introdução ao 
Coding Mobile
Diretor Executivo 
DAVID LIRA STEPHEN BARROS
Gerente Editorial 
CRISTIANE SILVEIRA CESAR DE OLIVEIRA
Projeto Gráfico 
TIAGO DA ROCHA
Autoria 
LUIZ FERNANDO CORCINI
AUTORIA
Luiz Fernando Corcini
Olá. Meu nome é Luiz Fernando Corcini. Sou formado em 
Engenharia Eletrônica, com especialização em Administração de 
TI, Mestre em Educação e Novas Tecnologias e Doutorando em 
Sistemas Tutores Inteligentes. Tenho experiência técnico-profissional 
na área de desenvolvimento e gestão da produção de softwares nas 
áreas de Gerenciamento de Processos Empresariais. Uso os recursos 
disponibilizados pela Web há mais de 20 anos. Sou professor universitário 
há mais de 15 anos e já publiquei vários livros técnicos sobre assuntos 
voltados a área de informática. Sou apaixonado pelo que faço e adoro 
transmitir minha experiência de vida àqueles que estão iniciando em 
suas profissões. Por isso fui convidado pela Editora Telesapiens a integrar 
seu elenco de autores independentes. Estou muito feliz em poder ajudar 
você nesta fase de muito estudo e trabalho. Conte comigo!
ICONOGRÁFICOS
Olá. Esses ícones irão aparecer em sua trilha de aprendizagem toda vez 
que:
OBJETIVO:
para o início do 
desenvolvimento 
de uma nova 
competência;
DEFINIÇÃO:
houver necessidade 
de apresentar um 
novo conceito;
NOTA:
quando necessárias 
observações ou 
complementações 
para o seu 
conhecimento;
IMPORTANTE:
as observações 
escritas tiveram que 
ser priorizadas para 
você;
EXPLICANDO 
MELHOR: 
algo precisa ser 
melhor explicado ou 
detalhado;
VOCÊ SABIA?
curiosidades e 
indagações lúdicas 
sobre o tema em 
estudo, se forem 
necessárias;
SAIBA MAIS: 
textos, referências 
bibliográficas 
e links para 
aprofundamento do 
seu conhecimento;
REFLITA:
se houver a 
necessidade de 
chamar a atenção 
sobre algo a ser 
refletido ou discutido;
ACESSE: 
se for preciso acessar 
um ou mais sites 
para fazer download, 
assistir vídeos, ler 
textos, ouvir podcast;
RESUMINDO:
quando for preciso 
fazer um resumo 
acumulativo das 
últimas abordagens;
ATIVIDADES: 
quando alguma 
atividade de 
autoaprendizagem 
for aplicada;
TESTANDO:
quando uma 
competência for 
concluída e questões 
forem explicadas;
SUMÁRIO
Android – Visão Geral ................................................................................ 12
Dispositivos Móveis........................................................................................................................ 12
Android – Um pouco de História ......................................................................................... 13
Android – Características........................................................................................................... 14
Arquitetura da Plataforma ...................................................................................... 17
Requisitos para o desenvolvimento de Apps .......................................... 18
Ambiente de Desenvolvimento Java para Mobile .........................20
Instalar o JDK ..................................................................................................................................... 20
Configurando as Variáveis de Ambiente .....................................................24
Instalar e Configurar o Android Studio .............................................................................28
Instando o Android Studio .....................................................................................28
Configurando o Android Studio ......................................................33
Configurar o Android SDK Manager .................................................................................. 36
Testando o Ambiente de Desenvolvimento ............................................................... 38
Fechando a aplicação Android..............................................................................................47
Estrutura do Projeto Java-Android ......................................................49
Conhecendo a Interface Android Studio ................................................... 49
Tela de Boas Vindas .................................................................................................. 50
Tela Principal ................................................................................................................... 51
Demais Janelas de Ferramentas ......................................................................54
Estrutura do projeto Java-Android .................................................................................... 56
Pasta Manifests ..............................................................................................................57
Pasta Java ..........................................................................................................................62
Pasta “res”.......................................................................................................................... 65
Fundamentos do Java para Mobile ......................................................67
Java - Um pouco de história .................................................................................................. 67
A Tecnologia Java .......................................................................................................................... 67
A Linguagem Java ...................................................................................................... 68
Esquema de execução de um programa em Java ............................ 68
A Plataforma Java ....................................................................................................... 69
Entendendo, Instalando e Configurando o Ambiente Java ............................. 70
Instalando o JDK ........................................................................................................... 71
Instalando o IDE ............................................................................................................ 71
Testando o Eclipse ......................................................................................................73
9
UNIDADE
01
Introdução ao Coding Mobile
10
INTRODUÇÃO
Seja bem-vindo(a) à Unidade 1 – Estrutura de um Projeto Android 
- da disciplina de Introdução ao Coding (Mobile). O conteúdo desta 
Unidade está dividido em quatro módulos. O primeiro módulo faz uma 
introdução a dispositivos móveis e ao sistema operacional Android, 
tratando um pouco sobre a história desse sistema, suas características 
e requisitos. No segundo Módulo explica passo a passo como instalar e 
configurar os componentes que formam o ambiente básico para iniciar 
seu aprendizado em programação móvel utilizando o Android Studio. 
Então temos o Módulo três, que apresenta as principais características da 
estrutura de projetos na plataforma Android, detalhando e explicando a 
funcionalidade de seus principais arquivos e classes, preparando o aluno 
para o desenvolvimento de aplicativos E, por fim, no último módulo desta 
Unidade 1, vamos apresentar a Plataformas Java de Desenvolvimento, 
um pouco de sua história, características, bem como o passo a passo 
para instalar o Ambiente de Desenvolvimento Integrado Java. É claro que 
existe muito mais a aprender, mas o aprofundamento de cada um destes 
conhecimentos pode ser feito acessando os links indicados durante o 
texto, no tópico [Saiba Mais]. Vamos começar? Excelente estudo para 
você!
Introdução ao Coding Mobile
11
OBJETIVOS
Olá. Seja muito bem-vindo a nossa Estrutura de um Projeto Android, 
e o nosso objetivo é auxiliar você no desenvolvimento das seguintes 
competências profissionais até o término desta etapa de estudos:
1. Conhecer o sistema operacional Android, sua história, características 
e requisitos;
2. Aprender a instalar e configurar os componentes básicos do 
Android Studio;
3. Entenderas principais características da estrutura de projetos 
na plataforma Android, suas funcionalidades de seus principais 
arquivos;
4. Conhecer a Plataforma Java de Desenvolvimento, um pouco 
de sua história, características, bem como o passo a passo para 
instalar o Ambiente de Desenvolvimento Integrado Java.
Vamos, então, rumo ao conhecimento. Bons estudos!
Introdução ao Coding Mobile
12
Android – Visão Geral
Dispositivos Móveis
Dispositivos móveis ou mobile devices, são pequenos 
computadores que normalmente cabem na palma da mão. Esses 
“computadores de mão” possuem uma tela que normalmente é sensível 
ao toque, para permitir ao usuário a entrada (input) de dados por meio de 
um miniteclado, apresentado na própria tela ou por meio de opções a 
serem selecionadas. A saída (output) pode ocorrer de várias formas, desde 
exibição de imagens, sons ou vídeos, até a execução de uma aplicação 
mais complexa, como envio ou recebimento de mensagens ou execução 
de programa especializado. Por se tratarem de minicomputadores, todos 
eles necessitam de um sistema operacional1 para gerenciar seu correto 
funcionamento e para que as várias aplicações possam ser executadas. 
No entanto, apesar do avanço constante da tecnologia, esses 
dispositivos móveis ainda possuem algumas características e limitações 
relevantes e que devem ser consideradas quando do desenvolvimento 
de aplicativos, como por exemplo: 
 • Tamanho do ecrã2 ;
 • Memória limitada (primária e secundária);
 • Poder de processamento limitado;
 • Baixo consumo de energia e 
 • Conectividade limitada. 
Por conta destas características, os sistemas operacionais para 
dispositivos móveis, ou mobile operating systems (MOS), em inglês, precisam 
ter características diferentes dos sistemas operacionais para desktops. 
1 Sistema Operacional: É o conjunto de programas que gerenciam recursos, processadores, 
armazenamento, dispositivos de entrada e saída e dados da máquina e seus periféricos. 
Exemplos: Dos, Unix, Linux, Mac OS, OS-2, Windows, etc. Fonte: Site Professor João Barreto 
(UFSC). Disponível aqui. 
2 2 Ecrã: Superfície fluorescente sobre a qual se forma a imagem nos tubos catódicos 
(televisão, informática, etc.) = Tela. Fonte: Dicionário Priberam da Língua Portuguesa. 
Disponível aqui.
Introdução ao Coding Mobile
http://www.inf.ufsc.br/~j.barreto/cca/sisop/sisoperac.html
https://www.priberam.pt/dlpo/ecrã
13
Relativamente aos MOS mais utilizados, tem-se que, segundo 
relatório apresentado pela empresa IDC3(em maio de 2017), o Android 
domina aproximadamente 85% do mercado de dispositivos móveis, tendo 
como segundo lugar o iOS, com aproximadamente 15%, como podemos 
verificar na figura abaixo:
Figura 1 – Quota de Marcado Mundial de S.O. para Smartphones.
Fonte: IDC – 05-2017.
Assim como os MOS, as linguagens de programação devem estar 
adaptadas para as restrições dos dispositivos móveis. Entre as linguagens 
atualmente utilizadas, podemos citar: Java, C#, OPL, Objective-C, Ruby, 
entre outras. Neste material, trabalharemos com o MOS Android e com a 
Linguagem de Programação Java.
Android – Um pouco de História
A empresa norte-americana Google foi fundada por Larry Page e 
Sergey Brin em 4 de setembro de 1998. Desde o início, a missão da empresa 
era “organizar as informações mundiais e torná-las universalmente 
acessíveis”. O foco do Google sempre foi hospedar e desenvolver uma 
série de produtos e serviços baseados na internet. De acordo com 
Meirelles (2009), depois de muita caminhada e de já estarem famosos 
com seu sistema de busca inovador, entre outros serviços e produtos, 
resolveram comprar, em 2005, uma pequena empresa de “sistemas 
3 IDC – International Data Corporation. Disponível aqui.
Introdução ao Coding Mobile
https://bit.ly/2MRQZJ2
14
embarcados4 ” chamada Android Inc. e decidiram entrar também no ramo 
de smartphones. 
Dois anos depois (em 2007), o projeto foi apresentado ao público e 
se mostrou mais ambicioso do que simplesmente um modelo específico 
de smartphone. Era um sistema operacional com código aberto (open-
source5) para dispositivos móveis, baseado em Linux, com uma interface 
de programação em Java. O Android estava sendo lançado!
VOCÊ SABIA?
Deixo aqui o link para dois sites interessantes se você quiser 
saber mais sobre a história do sistema operacional Android 
e todas as suas versões: (1) acesse aqui e (2) aqui.
Agora que conhece um pouquinho da história do MOS Android, 
vamos apresentar suas características.
Android – Características
Android não é uma linguagem de programação, mas sim um 
sistema operacional Linux multiusuário. Para programar aplicativos para 
os dispositivos móveis que utilizam o SO (sistema operacional) Android, 
são necessárias a instalação e a configuração de um ambiente de 
desenvolvimento apropriado, descrito em detalhes mais adiante neste 
material. Os programas escritos no ambiente de desenvolvimento Android 
devem ser compilados juntamente com todos os arquivos disponibilizados 
(recursos) de maneira a gerar um arquivo com a extensão APK, que é o 
arquivo utilizado pelos dispositivos para instalar a aplicação Android. 
4 Sistemas Embarcados: O sistema embarcado, também chamado de sistema embutido, 
é um sistema microprocessado em que um computador está anexado ao sistema que ele 
controla. Um sistema embarcado pode realizar um conjunto de tarefas que foram predefinidas. 
O sistema é usado para tarefas específicas, e assim, através de engenharia é possível otimizar 
um determinado produto e diminuir o tamanho, bem como os recursos computacionais e o 
seu valor final. Fonte: Site Oficina da Net – Disponível aqui. . 5Código aberto (open-source): 
É um software de utilização livre, para quem quiser. Todos podem contribuir com ele, seja 
no seu desenvolvimento, seja na correção de erros, seja na documentação, desde que a 
condição de liberdade seja mantida. Exemplos: Linux, Android, Apache, gcc, PostgreSQL, 
MySQL etc
5 Código aberto (open-source): É um software de utilização livre, para quem quiser. Todos 
podem contribuir com ele, seja no seu desenvolvimento, seja na correção de erros, seja na 
documentação, desde que a condição de liberdade seja mantida. Exemplos: Linux, Android, 
Apache, gcc, PostgreSQL, MySQL etc.
Introdução ao Coding Mobile
https://bit.ly/32SW7SC
https://bit.ly/32RifwT
https://bit.ly/2JrsNv7
15
VOCÊ SABIA?
APK vem de “Android Package”, Arquivo de Pacote de 
Aplicativos. É o formato de arquivo utilizado pelo MOS 
Android para distribuição e instalação de aplicativos para 
dispositivos móveis.
Uma vez instalado no dispositivo, cada aplicativo recebe um 
número de identificação único, chamado de ID do usuário, de maneira 
que cada ID se torna um usuário Linux gerenciado pelo sistema Android. 
Este, por padrão, executa cada uma das IDs em processos separados, isto 
é, para cada aplicação que está em execução no dispositivo, existe uma 
Máquina Virtual (VM) que a gerencia e monitora, permitindo a cada uma 
delas acesso apenas aos recursos necessários para executar suas tarefas 
e nada mais. Esta característica de isolar as aplicações cria um ambiente 
mais seguro e otimizado, onde os aplicativos acessam apenas os recursos 
de que precisam. 
Para o caso de aplicativos que precisam acessar dados ou recursos 
de outros aplicativos, eles devem compartilhar a mesma ID de usuário 
e, desta maneira, podem ser executados em um mesmo processo ou 
até mesmo compartilhar a mesma VM. Outros tipos de permissão, tais 
como acessar os dados gravados no dispositivo (contatos, telefones) 
ou acessar recursos, como câmera ou bluetooth, devem ser definidos 
pelo programador no momento do desenvolvimento e da instalação 
do aplicativo. 
Cada aplicação Android é formada por componentes, que são como 
blocos de construção, executam tarefas específicas e têm sua própria 
identificação. Podem ser utilizados como pontos de entrada do usuário ou 
para integração entre aplicativos, no casode dependência de recursos. 
Dentro de um dispositivo móvel, como o celular, podem existir vários 
aplicativos instalados e pode-se utilizá-los (executá-los) com um simples 
toque, o que permite imaginar que dois ou mais aplicativos podem estar 
rodando (sendo executados) ao mesmo tempo.
No gerenciamento de aplicativos realizado pelo Android, um desses 
aplicativos (que estão sendo executados) sempre estará visível e os outros 
Introdução ao Coding Mobile
16
estarão parados temporariamente (com status igual a paused) ou parados 
definitivamente (com status igual a stopped), mas, ainda assim, ocupando 
memória e outros recursos, em segundo plano. Um caso comum ocorre 
quando o usuário está verificando seus compromissos no aplicativo calendário/
agenda e recebe uma ligação, por exemplo. Nesse cenário, o Android vai parar 
temporariamente (pause) o aplicativo calendário/agenda e colocá-lo em 
segundo plano, enquanto o aplicativo que permite o atendimento da ligação 
(chamada telefônica) é colocado em primeiro plano e executado. Quando 
a ligação for encerrada, o Android fecha o aplicativo “chamada telefônica” e 
reposiciona o aplicativo calendário/agenda para o primeiro plano, permitindo 
que o usuário dê sequência à sua consulta de compromissos.
Tudo parece bem simples, não é mesmo?! Mas, não é bem assim! 
Como comentado anteriormente, os recursos de um dispositivo 
móvel são bastante limitados e o Android pode fechar qualquer aplicação 
que não esteja em primeiro plano, isto no caso de esses recursos ficarem 
em situação crítica ou quando alguma configuração do dispositivo for 
alterada. Esse fato pode causar grandes problemas, como por exemplo, 
no caso de o Android precisar fechar o aplicativo calendário/agenda, 
enquanto o usuário do dispositivo está atendendo uma ligação. Isso fará 
com que todos os compromissos não sejam salvos e, por consequência, 
serão perdidos. 
VOCÊ SABIA?
Quando um aplicativo é desenvolvido para os dispositivos 
que trabalham com o Android, a programação desse 
aplicativo deve prever que ele pode parar temporariamente, 
quando colocado em segundo plano, e seus estados 
(configurações, dados etc.) devem ser salvos para que o 
usuário possa retomá-los, caso necessário. 
Introdução ao Coding Mobile
17
Para auxiliar nesse gerenciamento dos aplicativos, o Android trabalha 
basicamente com quatro tipos diferentes de componentes. São eles: 
 • Atividades (Activities);
 • Provedores de Conteúdo (Content Providers) e
 • Receptores de Broadcast (Broadcast Receivers).
Sendo que, cada um dos itens acima relacionados serve para 
propósitos distintos e possuem diferentes ciclos de vida.
Toda aplicação Android pode ser formada por uma ou 
mais Activities. Estas Activities são, na verdade, pequenas 
“atividades” executada uma de cada vez. A maneira mais 
fácil de entender as Activities é associar cada tela a uma 
Activity. Para controlar todas estas Activities, já que apenas 
uma Activity pode ser executada de cada vez, existe a 
Activity Stack, ou pilha de Activity.
(OGLIARI e BRITO, 2014).
VOCÊ SABIA?
O código fonte do Android está disponível aqui..
Arquitetura da Plataforma
A arquitetura da plataforma Android está apresentada 
esquematicamente na figura abaixo:
Introdução ao Coding Mobile
https:// source.android.com/
18
Figura 2- Esquema básico da arquitetura da Plataforma Android
 
Fonte: (CORDEIRO, 2017)
Onde: (De acordo com o mesmo autor)
 • Aplicativos: São os aplicativos e jogos desenvolvidos em Java;
 • Frameworks, serviços bibliotecas: geralmente, também escritos em 
Java e servem para facilitar o desenvolvimento de aplicativos e jogos. 
 • Bibliotecas e serviços nativos: são recursos que já vêm com o 
Android, para serem utilizados pelo desenvolvedor. 
 • Linux é a base de tudo e inclui todos os drivers de hardware e 
redes (Bluetooth, câmeras, USB, GPS’s etc), sistemas de arquivos 
e processamento.
VOCÊ SABIA?
Para saber em detalhes como é a arquitetura da plataforma 
Android, acesse aqui..
Requisitos para o desenvolvimento de Apps
Para desenvolver aplicativos para o Android, são necessários alguns 
requisitos: 
Introdução ao Coding Mobile
https://bit.ly/2MRvkRm
19
 • Conhecer as bases da programação em linguagem Java;
 • Conhecimento básico sobre arquivos XML.
Montar o ambiente de desenvolvimento, que consiste em: 
 • Instalar e configurar o JDK6 ;
 • Instalar e configurar o Android Studio;
 • Configurar o SDK7 Manager;
Vamos começar nossa aventura montando o ambiente de 
desenvolvimento.As bases da programação Java e dos conhecimentos 
necessários em arquivos XML serão apresentados durante o material em 
situação e profundidade oportunas, para que você possa tirar o máximo 
proveito e desenvolver com tranquilidade aplicações para dispositivos móveis.
Dito isso, seguimos em frente com a mostrar como preparar o 
ambiente para desenvolvimento Java para Mobiles.
6 JDK – Java Development Kit – Kit de desenvolvimento Java.
7 SDK – O Android SDK ou Kit de Desenvolvimento de Software para Android é um pacote 
com diversas ferramentas utilizadas pelo Android Studio e pelos desenvolvedores.
Introdução ao Coding Mobile
20
Ambiente de Desenvolvimento Java para 
Mobile
Antes de desenvolver qualquer aplicação para dispositivos móveis 
faz-se necessário instalar e configurar o ambiente de desenvolvimento. 
Você já pode ir se acostumando, pois este é um procedimento normal 
para a maioria das linguagens de programação e para a maioria dos 
ambientes. Sendo assim, execute atentamente cada passo apresentado 
neste tópico, para que, ao terminar cada etapa, tenha baixado, instalado e 
configurado adequadamente o ambiente de desenvolvimento. 
Instalar o JDK
Como os aplicativos desenvolvidos para funcionar no MOS Android 
são desenvolvidos em linguagem Java, faz-se necessário instalar o kit de 
desenvolvimento Java, o qual pode ser encontrado para download em 
vários sites. Um deles é o que segue aqui. .
Ao copiar e colar esta URL, seu navegador abrirá um site da ORACLE, 
como mostrado na figura abaixo:
Figura 3 – Baixando o JDK – Parte I
Fonte: Print da tela do Java (2018), Própria.
Introdução ao Coding Mobile
https://bit.ly/32TolNd
21
Selecione (clique sobre) a palavra “download”, apresentada na figura 
acima, e uma nova tela será apresentada, permitindo que você escolha o 
arquivo para download referente ao sistema operacional da sua máquina, 
como mostrado na figura abaixo.
Figura 4 – Baixando o JDK – Parte II
Fonte: Print da tela do Java (2018)
Para este material, será considerado que o sistema operacional de 
seu computador é o Windows 10 (64bits). Faça o download e execute o 
arquivo.
NOTA:
Não se esqueça de aceitar os termos de licença antes de 
selecionar o arquivo para fazer o download. 
IMPORTANTE:
O arquivo mostrado na figura acima é a última versão 
disponível quando este material foi escrito. Pode ser que, 
quando você for instalar o JDK em seu computador, já 
exista uma versão mais atualizada.
Logo que o arquivo seja baixado, você deverá executá-lo. Uma tela, 
como a mostrada abaixo, deve aparecer. Proceda conforme indicado:
Introdução ao Coding Mobile
22
Figura 5 – Instalando o JDK
Fonte: Print da tela do Java (2018)
Clique em NEXT;
Figura 6 - Instalando o JDK
Fonte: Print da tela do Java (2018)
Selecione o diretório onde deve ser instalado o JDK e clique NEXT;
Recomendo deixar o local do arquivo conforme definido por padrão.
Introdução ao Coding Mobile
23
Figura 7 - Instalando o JDK
Fonte: Print da tela do Java (2018)
Aguarde a Instalação....
Figura 8 - Instalando o JDK
Fonte: Print da tela do Java (2018)
JDK instalado com sucesso. Clique em CLOSE.
Introdução ao Coding Mobile
24
Configurando as Variáveis de Ambiente
Após a instalação completa do JDK, configure as variáveis de 
ambiente necessárias para o computador conseguir localizar o aplicativo 
instalado. Os passos apresentados abaixo servem para o SistemaOperacional Windows 10.
Passo 1: Acesse o Painel de Controle;
Passo 2: Selecione a opção Sistema e Segurança -> Sistema -> 
Configurações avançadas do sistema e a seguinte tela será apresentada:
Figura 9 – Tela para “Configurações Avançadas”
Fonte: Print da tela do Java (2018)
Passo 3: Clique no botão “Variáveis de Ambiente”, como mostrado 
na figura acima, e a seguinte tela será apresentada:
Introdução ao Coding Mobile
25
Figura 10 – Variáveis de Ambiente
Fonte: Print da tela do Java (2018)
Passo 4: Crie uma nova “Variável do Sistema” com o nome: JAVA_
HOME e como valor da variável coloque o caminho onde foi instalado o 
JDK, como apresentado na figura abaixo:
Figura 11 – Criação de nova variável do sistema
Fonte: Print da tela do Java (2018)
Introdução ao Coding Mobile
26
Passo 5: Clicar em OK, na tela da figura acima;
Passo 6: Localize na lista de variáveis da figura 9, a variável de nome 
“Path” e clique duas vezes sobre ela. A seguinte tela será apresentada:
Figura 12 – Editando a variável Path
Fonte: Print da tela do Java (2018)
Passo 7: Clique no botão “Novo” e digite o endereço do arquivo 
javac.exe, que é: “C:\Program Files\Java\jdk1.7.0_04\bin” ou, se preferir: 
“%JAVA_HOME%\bin”, como mostrado na figura acima.
Passo 8: Clique em OK;
Passo 9: Crie uma nova variável com o nome: CLASSPATH e coloque 
como valor da variável: “C:\Program Files\Java\jdk1.7.0_04\lib\”, como 
mostrado na figura abaixo:
Introdução ao Coding Mobile
27
Figura 13 – Criando a variável CLASSPATH
Fonte: Print da tela do Java (2018)
Passo 10: Depois de clicar em OK, reinicie o computador para que 
as alterações tenham efeito.
Muito bem, aparentemente o JDK está instalado, mas é bom fazer 
um teste, não é mesmo? Então vamos lá.
Para verificar se o JDK foi instalado corretamente e que o seu 
computar o está reconhecendo, entre no “Prompt do DOS” e digite o 
seguinte comando: “java –version”. O resultado deve ser parecido com o 
apresentado na figura abaixo:
Figura 14 – Testando a instalação do JDK
Fonte: Print da tela do prompt do DOS, (2018).
Ainda no Prompt do DOS, digite outro comando: “javac – version”. O 
resultado deve ser parecido com o apresentado na figura abaixo:
Introdução ao Coding Mobile
28
Figura 15 – Testando a instalação do JDK
Fonte: Print da tela do prompt do DOS, (2018).
O JDK está instalado e reconhecido. Podemos passar para o próximo 
passo.
Instalar e Configurar o Android Studio
Neste tópico iremos instalar e configurar a ferramenta oficial de 
desenvolvimento Android do Google: o Android Studio. Siga os passos 
relacionados abaixo.
Instando o Android Studio
Passo 1: Baixe o Android Studio;
O link para baixar a ferramenta é esse aqui. Ao clicar no link, 
aparecerá no navegador o seguinte cabeçalho de tela.
Figura 16 – Cabeçalho da tela do site oficial do Android Studio
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
https://bit.ly/2JsMgv8
29
IMPORTANTE:
Caso seu Sistema operacional seja 64 bits, clique no botão 
de download, caso contrário, clique em “Download Options” 
e selecione o link para a versão 32 bits e siga as instruções 
do instalador.
O arquivo a ser baixado tem o seguinte nome “android-studio-ide-
173.4907809-windows.exe”. (na versão 64 bits, mas pode variar conforme 
o sistema operacional utilizado em seu computador).
Passo 2: Execute o arquivo baixado
Ao clicar duas vezes sobre ele, o assistente de instalação do Android 
Studio será iniciado, apresentando a seguinte tela:
Figura 17 – Primeira tela do Assistente de Instalação do Android Studio
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
30
Passo 3: Clique em “Next” e a seguinte tela será apresentada:
Figura 18 – Assistente de Instalação – Tela 2
Fonte: Print da tela do Android, (2018).
Passo 4: Verifique se o checkbox da opção “Android Studio” está 
marcada e marque também o checkbox da opção “Android Virtual Device”. 
Passo 5: Clique em “Next”.
Figura 19 – Assistente de Instalação – Tela 3
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
31
Passo 6: Escolha o local onde o aplicativo deve ser instalado. 
(Recomendo que deixe o padrão). 
Passo 7: Clique “Next”.
Figura 20 – Assistente de Instalação – Tela 4
Fonte: Print da tela do Android, (2018).
Passo 8: Clique em “Next” e a processo de instalação terá início, 
como mostra a figura abaixo:
Figura 21 – Assistente de Instalação – Tela 5
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
32
Aguarde até a instalação ser completada.
Passo 9: Clique em “Next”.
Figura 22 – Assistente de Instalação – Tela 6
Fonte: Print da tela do Android, (2018).
Passo 10: Marque a opção para iniciar o aplicativo Android Studio.
Passo 11: Clique em “Finish”. A seguinte tela aparecerá:
Figura 23 – Assistente de Instalação – Tela 7
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
33
Passo 12: Selecione a opção para “Não importar configurações” (Do 
not import settings) e clique em “OK”. A instalação foi finalizada.
Vamos agora para configuração do Android Studio.
Configurando o Android Studio
Após clicar em “OK” (Passo 12) da instalação, a tela do assistente de 
configuração irá aparecer.
Figura 24 – Tela do Assistente de Configuração – Tela 1
Fonte: Print da tela do Android, (2018).
Passo 13: Clique em “Next”.
Introdução ao Coding Mobile
34
Figura 25 – Tela do Assistente de Configuração – Tela 2
Fonte: Print da tela do Android, (2018).
Passo 14: Mantenha marcada a opção “Standard” para que a 
instalação aconteça com as configurações e opções padrão
Passo 15: Clique em “Next”.
Figura 26 – Tela do Assistente de Configuração – Tela 3
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
35
Passo 16: Selecione a aparência desejada para a interface. 
Recomendo a opção “Dracula”, por que possui fundo mais escuro e 
por isso cansa menos a visão.
Passo 17: Clique em “Next”.
Figura 27 – Tela do Assistente de Configuração – Tela 4
Fonte: Print da tela do Android, (2018).
Passo 18: Clique em “Finish”. 
Depois de instalado e configurado, a tela de boas-vindas do Android 
Studio deve ficar assim:
Figura 28 – Tela da ferramenta Android Studio depois de instalada em seu computador.
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
36
Antes de começar um novo projeto com esta ferramenta, precisamos 
verificar o SDK Manager
Configurar o Android SDK Manager
Passo 19: Clique no botão “Configure” e na opção “SDK Manager”, 
conforme apresentado na figura abaixo:
Figura 29 – Configurando o SDK Manager
Fonte: Print da tela do Android, (2018).
A seguinte tela deverá ser apresentada:
Introdução ao Coding Mobile
37
Figura 30 – Configurando o SDK Manager
Fonte: Print da tela do Android, (2018).
Passo 20: Selecione a guia SDK Platform e os itens apresentados na 
figura acima: da API Level 14 até a 28.
Passo 21: Clique na guia SDK Tools e marque os itens apresentados 
na figura abaixo:
Figura 31 – Configurando o SDK Manager
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
38
Passo 22: Clique em “Apply” e aguarde que a atualização 
seja realizada;
Passo 23: Clique em “OK”.
Certifique-se de que os seguintes pacotes estejam listados como 
“Instalados” na coluna Status:
 • Tools > Android SDK Tools 
 • Tools > Android SDK Platform-tools 
 • Tools > Android SDK Build-tools 
 • SDK Platform (versão mais recente) > SDK Platform 
 • SDK Platform (versão mais recente) > ARM EABI v7a System Image
 • Extras > Android Support Repository 
 • Extras > Android Support Library 
 • Extras > Google Repository 
 • Extras > Google USB Driver (necessário apenas em sistemas Windows)
Muito bem! Agora estamos prontos para testar o ambiente de 
desenvolvimento Android.
Testando o Ambiente de Desenvolvimento
Para montar o nosso primeiro projeto Android, clique em “Start a 
new Android Studio Project”,conforme apresentado na tela abaixo:
Introdução ao Coding Mobile
39
Figura 32 – Novo projeto Android
Fonte: Print da tela do Android, (2018).
Ao clicar no local marcado na figura acima, a seguinte tela será apresentada:
Figura 33 – Criando um projeto Android
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
40
Em “Application Name” (Nome do aplicativo) digite “Meu primeiro 
App”, deixando os demais itens como estão e clique em “Next”.
Na tela apresentada na figura abaixo, marque apenas o checkbox 
referente ao item “Phone and Tablet” e selecione, na combobox (caixa 
de combinação) o item: “API 15: Android 4.0.3 (IceCreamSandwich), 
exatamente como está destacado em vermelho.
Note que esta tela permite configurar o dispositivo para o qual 
você deseja desenvolver o projeto Android e que, além da opção que 
marcamos (Phone and Tablet), também permite outras opções, tais como 
dispositivos chamados de “weareble”, “android TV”, entre outros.
Figura 34 – Criando um projeto Android
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
41
IMPORTANTE:
Sempre que você estiver a selecionar um tipo de 
dispositivo para o projeto, precisa definir qual a API mínima 
que o referido dispositivo deve possuir para rodar/suportar 
adequadamente o executável do projeto. Caso você tenha 
alguma dúvida sobre qual API deve ser selecionada, clique 
no link “Help me choice”, destacado em branco, na figura 
acima. Ao clicar neste link, uma nova tela será apresentada 
(ver figura abaixo), onde você poderá verificar qual a 
abrangência da API que deseja selecionar.
Figura 35 – Tela que apresenta a abrangência das API disponíveis
Fonte: Print da tela do Android, (2018).
Analisando a figura acima, verificamos que se selecionarmos a API 
25 para o nosso projeto, estaremos a implementar uma aplicação que terá 
apenas 1,5% dos dispositivos capazes de executá-la. Se selecionarmos a 
API 21, nossa abrangência aumenta para 50% dos dispositivos atualmente 
no mercado. E para ter uma abrangência garantida para a maioria dos 
dispositivos, escolhemos a API 15, que nos dá praticamente 100% de 
abrangência para a nossa aplicação.
Dessa forma, depois de selecionada a API 15 para o dispositivo 
“Phone and Tablet”, clique em “Next”.
Introdução ao Coding Mobile
42
A próxima tela a ser apresentada (figura abaixo) permite selecionar 
a Activity padrão para seu aplicativo. A Activity é um módulo único e 
independente que normalmente está relacionada diretamente com uma 
tela de interface de usuário e suas funcionalidades correspondentes. Não 
se preocupe em entender completamente este conceito neste momento, 
pois, trataremos detalhadamente do mesmo mais adiante neste material. 
Por enquanto basta entender que cada Activity representa uma tela do 
aplicativo que estamos a desenvolver.
Figura 36 – Tela de seleção do tipo de Activity do Aplicativo
Fonte: Print da tela do Android, (2018).
Selecione uma “Empty Activity”, como mostra a figura acima e 
clique em “Next”.
A tela a seguir permite que você defina o nome da Activity e o nome 
do Layout para a sua aplicação. 
 • Activity Name: Isso dá à sua Activity um nome para se referir no 
código. Uma classe .java será criada e usará o conteúdo desse 
campo de texto para dar um nome à classe. (CORDEIRO, 2017)
Introdução ao Coding Mobile
43
 • Layout Name: Define o nome do arquivo XML que contém as 
configurações do Layout que será exibido para o usuário do 
aplicativo. 
Por enquanto deixe com os nomes padrões e clique em “Finish”.
Figura 37– Tela de configuração da Activity do Aplicativo
Fonte: Print da tela do Android, (2018).
O seu projeto será criado conforme as configurações que você definiu 
e será apresentado na IDE8 do Android Studio, conforme figura abaixo:
8 DE – Integrated Development Environment - Ambiente de desenvolvimento 
Intregrado - que permite ao programador o acesso a uma interface amigável 
de desenvolvimento que facilita, organiza e otimiza o desenvolvimento, teste e 
distribuição da aplicação.
Introdução ao Coding Mobile
44
Figura 38 – IDE do Android Studio
Fonte: Print da tela do Android, (2018).
Muito bem. Agora falta pouco! Depois de todo este trabalho, o que 
precisamos é ver se o aplicativo está a funcionar corretamente, certo?
Para isto, clique no menu “Run” e selecione o primeiro item: “Run 
app”. Uma nova tela será apresentada, conforme a figura a seguir:
Figura 39 – Tela para seleção do dispositivo virtual Android
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
45
Repare que a lista de dispositivos virtuais conectados está vazia 
(<none>) e, por isso, caso você clique em “OK”, uma mensagem de erro será 
apresentada, a informar que nenhum dispositivo virtual foi selecionado.
Pois bem, então precisamos criar um dispositivo virtual para rodar a 
nossa aplicação exemplo. 
É importante perceber que o Android Studio está a simular uma 
aplicação em um dispositivo móvel, mas seu computador, mesmo sendo 
um notebook, não é um “dispositivo móvel” tal como um celular ou um 
tablet. Por isso, precisamos permitir que o Android Studio faça a simulação 
deste dispositivo ou seja, precisamos criar um Dispositivo Virtual Android 
ou, em inglês, um “Android Virtual Device”. 
Para isso, clique no botão “Create New Virtual Device” e selecione o 
dispositivo “Phone” - “Nexus 4”, conforme mostrado na figura abaixo:
Para isso, clique no botão “Create New Virtual Device” e selecione o 
dispositivo “Phone” - “Nexus 4”, conforme mostrado na figura abaixo:
Figura 40 – Criando o AVD (Android Virtual Device)
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
46
Clique em “Next” e faça o download da API 28, conforme mostrado 
na figura abaixo:
Figura 41 – Carregando as API necessárias para o aplicativo.
Fonte: Print da tela do Android, (2018).
E clique em “Next”.
Figura 42 – Configuração do AVD
Fonte: Print da tela do Android, (2018).
Introdução ao Coding Mobile
47
Escolha um nome qualquer para o seu AVD, bem como a orientação 
inicial e clique em “Finish”.
Se tudo estiver de acordo, aparecerá um emulador do dispositivo 
android a executar seu primeiro app, conforme figura abaixo:
Figura 43 – AVD a executar a sua primeira app mobile.
Fonte: Print da tela do celular, (2018).
Fechando a aplicação Android
Precisamos executar mais duas atividades para concluir esta etapa:
Primeiro: Feche o AVD (Android Virtual Device), clicando no “x” que 
está localizado no canto superior direito da barra lateral, apresentada na 
figura 34, colocado em destaque na figura abaixo:
Figura 44 – Como fechar o AVD
Fonte: Print da tela do celular, (2018).
Introdução ao Coding Mobile
48
Segundo: Fechar o Projeto teste adequadamente. Para isso, clique 
no menu “File” e selecione o item “Close Project”, como mostra a figura 
abaixo:
Figura 45 – Fechando o projeto corretamente.
Fonte: Print da tela do celular, (2018).
Podemos assim, passar para a próxima fase do nosso aprendizado: 
Entender o funcionamento e os recursos disponibilizados pela interface 
Android Studio e, em seguida, aprender os fundamentos da linguagem 
Java e detalhar passo a passo cada etapa realizada até o momento no 
desenvolvimento de aplicativos para dispositivos móveis.
VOCÊ SABIA?
Se quiser aprofundar seus conhecimento em programação 
para dispositivos Android, acesse aqui.
Introdução ao Coding Mobile
https://bit.ly/2MSWyGY
49
Estrutura do Projeto Java-Android
Antes de darmos sequência no aprendizado e implementação de 
programas para dispositivos móveis utilizando Java-Android é importante 
entender os recursos disponibilizados pela interface do Ambiente 
de Desenvolvimento Integrado (IDE) Android Studio, bem como seu 
funcionamento.
É importante destacar também que a interface utilizada neste 
material não é a única maneira de se desenvolver aplicativos Java para 
dispositivos móveis. Poderíamos, por exemplo, ter instaladoo próprio 
ambiente de desenvolvimento Java, instalando o JDK na sua última versão 
disponível (atualmente é a versão 10), disponível na página da Oracle.com 
(empresa proprietária do Java). Trataremos mais sobre este assunto no 
item 4 deste material. Neste item exploraremos a interface Android Studio.
Conhecendo a Interface Android Studio
Como você deve ter percebido na primeira app que desenvolvemos 
juntos no item 2.4 deste material, a interface da IDE Android Studio possui 
uma grande variedade de telas e funções. Vamos apresentar as mais 
relevantes que você vai precisar utilizar nos exemplos e exercícios no 
escopo deste material.
Introdução ao Coding Mobile
50
Tela de Boas Vindas
Figura 46 - tela de Boas-vindas
Fonte: Print da tela do Android, (2018).
Ao abrir a IDE Android Studio, normalmente a tela de Boas-Vindas 
será a primeira a aparecer.
IMPORTANTE:
Isto só não vai acontecer caso você tenha fechado a IDE 
sem antes fechar o projeto. Para este caso, a IDE abrirá e 
carregará diretamente o projeto que estava aberto. 
Caso isso tenha acontecido com você, feche corretamente o 
projeto, como indicado no item 2.5 e terá acesso a tela de Boas-Vindas, 
conforme apresentado na figura acima.
Não está errado fechar diretamente a IDE sem fechar antes o 
projeto. Estamos a proceder assim desta vez para ter acesso a todas as 
telas e funcionalidades relevantes para o escopo deste material.
Repare que a tela de Boas-Vindas está dividida em duas colunas, 
a saber: 
Introdução ao Coding Mobile
51
 • A coluna da esquerda apresenta a lista dos últimos projetos 
trabalhados recentemente;
 • A coluna da direita fornece uma lista de possibilidades, das quais 
destacamos os dois primeiros: (1) Iniciar um novo projeto Android 
Studio e (2) Abrir um projeto Android Studio existente. 
Clique no projeto teste, na coluna da esquerda para ter acesso a 
tela principal do projeto.
Tela Principal
É de se referir que o layout e a configuração dos painéis da tela 
principal variam conforme o gosto de desenvolvedor e também de acordo 
com as ferramentas utilizadas da última vez que o projeto foi aberto.
Figura 47 – Tela Principal do IDE Android Studio
Fonte: Print da tela do Android, (2018).
Na figura acima, destacamos os seguintes itens:
A – Barra de Menus: Barra tradicional com as opções de salvar, abrir, 
importar, exportar, navegar, executar, etc. Veremos os mais relevantes 
no decorrer deste material e nas próximas unidades que compõe este 
e-book. Neste momento, é importante destacar alguns itens dessa barra 
de menus: 
Introdução ao Coding Mobile
52
Menu File: 
 • New – Permite a criação de um novo projeto, classe, activity, 
módulo, entre outros. Aprenderemos a trabalhar com cada um 
desses itens no decorrer do material;
 • Open – Permite abrir um projeto existente;
 • Close Project – Fecha o projeto em uso;
 • Settings – Apresenta uma nova tela que permite configurações de 
aparência e comportamento da IDE, tais como tamanho, cor e tipo 
de fonte do código, cor de fundo da IDE, entre outras;
 • Project Structure – Apresenta uma nova tela que permite configurar 
características tais como a localização do Android SDK e JDK, bem 
como verificar as versões do Android, entre outras.
 • Save All – Salva todos as janelas de código abertas;
 • Exit – Fecha a IDE sem fechar o projeto. Caso algum projeto esteja 
aberto, o mesmo será carregado da próxima vez que a IDE for aberta;
 • Menu Edit: Dá acesso as funções tradicionais de “Undo” (desfazer) e 
“Redo” (refazer), bem como copiar, colar, recortar, colar, selecionar 
tudo e localizar.
Menu View: 
 • Tool Window – Permite acesso as janelas da IDE, tais como: Logcat, 
Project, Favorites, Structure, entre outras;
 • Demais itens - Permitem a visualização de alterações recentes, 
bem como a ativação ou desativação da visualização das barras 
de ferramentas, status, navegação e botões.
Menu Navigate: permite o direcionamento do ponteiro de ação do 
editor para uma determinada classe, linha de aviso de erro, etc.
Menu Code: Atalhos para a geração de código ou inserção de 
comentários (em linha ou em bloco), entre outras coisas. Veremos esses itens 
com mais detalhes quando estivermos a tratar do código java do projeto.
Menus Analyze, Refactor e Build: Veremos mais adiante;
Introdução ao Coding Mobile
53
Manu Run: Permite a execução do projeto em modo normal ou em 
modo “debug”;
Menu Tools: Permite acesso ao SDK Manager, AVD Manager, editor 
de temas
Menus VCS, Windows e Help: Veremos mais adiante;
B – Barra de Navegação: permite mover entre os arquivos, subpastas 
e pastas que compõem o projeto. Segue o mesmo princípio da barra de 
navegações do Windows Explorer;
C – Barra de Ferramentas: É composta por botões que servem como 
atalho para as funções que são utilizadas com mais frequência. Pode ser 
personalizada, clicando com o botão direito na barra e selecionando a 
opção “Menus and Tollbars”;
D - Janela do Editor de Código: Exibe o conteúdo (código) do arquivo 
no qual o programador está a trabalhar no momento. Quando estiver a 
trabalhar com várias janelas (arquivos) de código, cada um deles será 
representado por uma aba, seguindo o mesmo princípio dos navegadores 
na internet. Exploraremos melhor os detalhes desta janela no decorrer 
deste material;
E – Janela de Ferramentas de Projeto: Fornece uma visão 
hierárquica da estrutura do arquivo de projeto, permitindo a navegação 
para arquivos e pastas específicos para serem abertos. A configuração 
padrão é a visualização Android que é o modo a ser utilizado no restante 
deste material. Exploraremos melhor os detalhes desta janela no decorrer 
deste material;
F – Barra de Status e demais Janelas de ferramentas: 
 • Barra de Status: exibe mensagens informativas sobre o projeto e 
as activities do Android Studio;
 • Janelas de Ferramentas: localizado no canto esquerdo, permite 
acesso a uma variedade de janelas que apresentam dados 
importantes sobre o projeto. Veremos mais sobre elas no item 3.1.3 
deste material.
Introdução ao Coding Mobile
54
Demais Janelas de Ferramentas
Para ter acesso as demais Janelas de ferramentas disponibilizadas 
pela IDE, pare o ponteiro do mouse sobre o ícone localizado no canto 
inferior esquerdo da mesma, conforme mostra a figura abaixo. 
Figura 48 – Lista das Janelas de Ferramentas disponibilizadas pela IDE.
Fonte: Print da tela do android
Como se pode verificar a IDE fornece uma grande variedade de 
janelas de ferramentas. As mais utilizadas, de acordo com Cordeiro (2016), 
são as seguintes:
 • Janela Project: Uma visualização que fornece uma visão geral 
da estrutura de arquivos que compõe o projeto, permitindo uma 
navegação rápida entre os arquivos. 
 • Janela Structure: Fornece uma visão de alto nível da estrutura das 
classes atualmente exibidas no editor. Essa informação inclui uma 
lista de itens, tais como classes, métodos e variáveis no arquivo. 
 • Janela Build Variants: Fornece uma maneira rápida de configurar 
diferentes tipos de compilação para o projeto atual (por exemplo, 
Introdução ao Coding Mobile
55
diferentes versões para debug e liberação de versões do aplicativo, 
ou várias compilações para atingir diferentes categorias de 
dispositivos).
 • Janela TODO: Fornece um lugar para os itens que ainda têm de ser 
concluídos no projeto. 
 • Janela Messages: Os dados da janela de Messages são gerados 
a partir do sistema de compilação Gradle, e podem ser úteis para 
identificar as causas de problemas na compilação de projetos.
 • Janela Android Monitor: Esse recurso possibilita o acesso ao 
sistema de debug do Android. Dentro desta janela, podemos 
executar tarefas básicas de debug como monitorar a saída de 
log de um aplicativo em execução, tirar screenshots e vídeos do 
aplicativo, e parar um processo.
 • Janela Android Model: A janela Android Model exibe uma lista 
completa das configurações do seu projeto. Estespodem variar 
de configurações mais óbvias, tais como a versão do SDK alvo, 
para coisas mais escondidas tais como regras da configuração de 
compilação.
 • Janela Terminal: É uma janela de terminal do sistema na qual o 
Android Studio está em execução. No Windows essa interface é o 
prompt de comando.
 • Janela Run: Essa ferramenta torna-se disponível quando um aplicativo 
está em execução e fornece uma visualização dos resultados da 
execução, junto a opções para parar ou reiniciar um processo em 
execução. 
 • Janela Event Log: A janela Evento Log exibe mensagens 
relacionadas a eventos e atividades realizadas no Android Studio. 
A compilação bem-sucedida de um projeto, por exemplo, ou o 
fato de que um app está sendo executado serão mostrados dentro 
dessa janela.
 • Janela Gradle Console: Usada para exibir todas as saídas do 
sistema Gradle enquanto os projetos são compilados dentro 
Introdução ao Coding Mobile
56
do Android Studio. Isso inclui informações sobre o sucesso ou 
insucesso do processo de desenvolvimento, assim como avisos 
ou detalhes de qualquer erro.
 • Janela Gradle: Mostra as tarefas do Gradle que compõem a 
configuração do projeto. Essa janela lista as tarefas que estão 
envolvidas na compilação dos vários elementos do projeto em um 
aplicativo Android. 
Estrutura do projeto Java-Android
Este tópico trata do reconhecimento de alguns arquivos e 
características importantes para o entendimento da estrutura básica do 
projeto Java-Android. Serão tratados neste momento apenas os arquivos e 
características relevantes para o entendimento do projeto, os demais arquivos 
características existentes na estrutura serão apresentados oportunamente.
Para verificar a estrutura do projeto, abra o Android Studio e crie um 
novo projeto com as seguintes características:
Na tela “Create Android Project”:
 • Defina o “Application Name”: AppEstrutura;
Na tela “Target Android Device”:
 • Marque a opção “Phone and Tablets”
 • Selecione a API 15;
Na tela “Add an Activity to Mobile”:
 • Selecione: Empty Activity;
Na tela “Configure Activity”:
 • Defina o “Activity Name”: Principal;
 • Define o “Layout Name”: activity_principal;
Clique em “Finish” e aguarde a criação do projeto;
Uma vez que o projeto esteja criado, a janela de ferramenta de 
projeto deve estar como apresentada na figura abaixo:
Introdução ao Coding Mobile
57
Figura 49 – Tela de ferramentas de projeto
Fonte: Print da tela do Android, (2018).
Note que a estrutura de pastas do projeto possui duas pastas “raiz”: 
(1) app e (2) Gradle Scripts. A pasta “app” é composta por três subpastas: (a) 
pasta “manifests”; (b) pasta “java”; (e) pasta “res”. São estas pastas a serem 
verificadas aqui:
Pasta Manifests
Dentro da pasta Manifests existe um arquivo chamado 
AndroidManifests.xml. Todo aplicativo java-android deve ter um arquivo 
com exatamente este mesmo nome. Pode ser um projeto que você 
mesmo desenvolveu (ou está a desenvolver) ou pode ser um projeto de 
outrem. Ele é o “manifesto do aplicativo”, o qual contém informações 
essenciais sobre o aplicativo cujo código estamos a analisar. 
Para você talvez esteja a estranhar o nome “manifesto”, saiba que, 
segundo o dicionário priberam9 , manifesto é um substantivo masculino 
cujo significado é: “Exposição (geralmente escrita) em que se manifesta o 
que é preciso ou o que se deseja que se saiba a respeito de algo”.
Muito bem. Usando a definição supracitada, podemos inferir que 
o arquivo “manifesto do aplicativo” tem função de conter informações 
9 Dicionário Priberam – Disponível aqui.
Introdução ao Coding Mobile
https://dicionario.priberam.org//manifesto
58
necessárias (que devem ser passadas para o MOS Android) para que o 
aplicativo seja corretamente executado.
De maneira geral, segundo o próprio a própria documentação 
fornecida pelo site da Android (ANDROID, 2018), o arquivo do manifesto 
serve para:
 • Nomear (identificar unicamente) o pacote Java para o aplicativo;
 • Descrever os componentes do aplicativo;
 • Declarar as permissões que o aplicativo deve ter para acessar 
partes protegidas da API;
 • Declarar as permissões que o aplicativo deve ter para interagir 
com outros aplicativos;
 • Declarar qual a API mínima necessária para a correta execução do 
aplicativo;
 • Listar as bibliotecas às quais o aplicativo necessita estar vinculado 
para funcionar adequadamente.
Pois bem. Agora que você sabe o que é e para que serve o arquivo 
referente ao manifesto do aplicativo, vamos analisar sua estrutura do 
mesmo. A figura abaixo (figura 50) apresenta uma cópia do AndroidManifest.
xml do projeto que estamos a desenvolver. Ele deve ser idêntico ao do 
seu projeto.
Introdução ao Coding Mobile
59
Figura 50 – Arquivo AndroidManifest.xml
Fonte: Print da tela do Java, (2018).
Algumas considerações preliminares: O arquivo manifesto é um 
arquivo no formato XML (eXtensible Markup Language) que, conforme 
aponta Pereira (2009), é uma linguagem de marcação recomendada 
pela W3C para a criação de documentos com dados organizados 
hierarquicamente, assim como faz o HTML, porém, seu diferencial é ser 
“extensível”, isto é, permite ao utilizador definir seus próprios conjuntos de 
elementos de marcação.
Você deve se lembrar que quando estudamos HTML, utilizamos 
conjuntos de TAGs ou marcadores pré-definidos, tais como <body></
body>, <h1></h1>, etc. 
Com XML é possível criar nossos próprios marcadores. Você pode 
criar um marcador como, por exemplo: <inicio></inicio>, <pessoa></
pessoa>, etc. Para o caso do arquivo AndroidManifest.xml, apresentado 
na figura 50, acima, podemos identificar alguns marcadores definidos por 
quem elaborou esta solução para o desenvolvimento de aplicativos para 
dispositivos móveis. 
Note que a linha número 1 possui um cabeçalho. Todos os arquivos 
XML precisam ter este cabeçalho a informar ao navegador ou ao MOS 
Introdução ao Coding Mobile
60
Android que o arquivo a ser lido está no formato XML. Ao passar para o 
conteúdo do arquivo, veja que, na linha 2 existe um marcador chamado 
<manifest>, o qual inicia o documento e, consequentemente, também o 
finaliza, pois temos na linha 21 o fechamento do mesmo marcador. Na linha 
5 temos o marcador <application> que é fechado na linha 19. Também 
temos o marcador <activity> na linha 12 e que é fechado na linha 18.
SAIBA MAIS:
Se você estiver interessado em saber mais sobre as 
características dos arquivos XML, acesse aqui. .
Vamos verificar quais são e para que servem os marcadores (as 
TAGs) apresentados na figura 50, acima:
<manifest> - é o elemento raiz de todo arquivo AndroidManifest.xml.
 • Deve definir o namespace10 do Android, cujo atributo, segundo 
(ANDROID, 2018) pode ser sempre definido como: “http://schemas.
android.com/apk/res/android”.
 • Deve identificar o pacote (package) ao qual a aplicação pertence. 
O nome completo deste pacote é definido quando estamos a 
criar um projeto no Android Studio. O nome do pacote também 
representa, conforme (ANDROID, 2018), a identificação (ID) da 
aplicação, o qual deve ser único e será o identificador da sua 
aplicação caso queira publicá-la na Google Play.
 • Deve conter pelo menos uma aplicação (representado pelo 
marcador <application>).
 • Existem muitos outros elementos que podem estar contidos dentro do 
marcador <manifest>. Aqui estamos a tratar apenas os que o arquivo 
da figura 50 apresenta. Para saber mais, acesse aqui.
<application> - É a declaração da aplicação.
10 Os Namespace em xml são usados para prover uma maneira de evitar conflito de nomes 
de elementos (tags ou marcadores). Para saber mais sob namespaces, acesse aqui. 
Introdução ao Coding Mobile
https://bit.ly/2PjK2SN
https://bit.ly/2BT0Ac5
https://www.w3schools.com/xml/xml_namespaces.asp
61
 • Este elemento deve conter todos os subelementos que declaram 
cada um dos componentes da aplicação e também pode conter 
atributos que afetem estes componentes.São exemplos de 
atributos: icon, label, permission, process, etc
Atributos
 • android:allowBackup – Determina se o aplicativo em questão 
participa ou não da infraestrutura de backup e restauração. Pode 
ser setado para verdadeiro (true) ou falso (false);
 • android:icon – define um ícone para a aplicação como um todo e 
um ícone padrão para cada componente da aplicação. Deve ser 
setado como uma referência para uma fonte de imagem apontada 
pelo elemento @drawable/icon (que veremos mais adiante);
 • android:label – define uma etiqueta (label) legível para a 
aplicação como um todo e uma etiqueta (label) padrão para cada 
componente da aplicação;
 • android:roundIcon – A partir do versão 8 do MOS Android foi 
introduzido ícones adaptativos que podem ter os mais variados 
formatos. Um deles é o formato arredondado, por isso: roundIcon. 
Para saber mais sobre os ícones adaptativos, acesse: https://
developer.android.com/guide/practices/ui_guidelines/icon_
design_adaptive;
 • android:supportsRtl – declara se sua aplicação suporta layouts 
“Right-to-Left”. Podem ser definidos como verdadeiro (true) ou 
falso (false);
 • android:theme – Define um tema padrão para todas as atividades 
(telas) contidas na aplicação, apesar de que atividades individuais 
que usem este atributo podem sobrepor-se à definição padrão.
<activity> - Declara uma atividade, isto é, uma interface (tela) visual 
para o usuário. Uma aplicação pode ter várias telas e cada uma delas deve 
ser representada por um elemento <activity> distinto dentro do arquivo do 
manifesto.
 • Atributos: android:name – define o nome da atividade.
Introdução ao Coding Mobile
62
<intent-filter> - A intent é um objeto de mensagem que pode 
ser usado para solicitar uma ação de outro componente de aplicativo. 
(ANDROID, 2018). O <intent-filter> especifica o tipo de intent uma atividade, 
serviço ou receiver está apto a responder. Explicando melhor: Um intent-
filter declara o que uma atividade ou serviço pode fazer e quais tipos de 
“broadcasts” um “receiver” pode manipular. Veremos mais profundamente 
sobre ele nas próximas unidades deste material. Para já, temos que no 
caso da figura 50, aparecem dois subelementos: (1) action; (2) category.
 • action – adiciona uma ação ao elemento intent-filter (que pode 
possuir um ou mais elementos de ações). No caso em estudo, 
temos que a ação é definida como MAIN. Esta ação (MAIN) informa 
ao MOS Android que esta é a atividade principal da aplicação.
 • category – adiciona um nome de categoria ao elemento intent-filter. 
No caso em estudo, temos que a categoria foi declarada como 
Launcher (iniciar, lançar, começar, empreender). Isto informa ao MOS 
Android que a atividade deve estar visível no launcher do dispositivo 
móvel.
Finalizamos a análise do arquivo de manifesto do aplicativo. 
Passamos agora para a próxima pasta.
IMPORTANTE:
Não se preocupe se tudo isso ainda parece meio confuso 
pra você. Estamos na fase inicial. Trabalharemos em 
detalhes cada um destes elementos e outros mais para 
que você possa se sentir confiante ao desenvolver uma 
aplicação para dispositivo móvel.
Pasta Java
A pasta Java possui, normalmente, três subpastas. A primeira 
contém as classes (arquivos .java) referentes às activities (telas) da sua 
aplicação e demais classes que você por ventura precise desenvolver 
em uma aplicação mais sofisticada. As outras duas pastas são pastas de 
testes e não trataremos delas neste material. Vamos, então para a classe 
Introdução ao Coding Mobile
63
Principal.java, que deve conter a estrutura da nossa activity. A figura 51 
mostra o conteúdo desta classe.
Eu sei que ainda não estudamos a linguagem Java, inclusive, 
esse será o tema que inicia no próximo tópico desta unidade 1 e será 
aprofundado no decorrer da unidade 2 desta disciplina. 
Figura 51 – Classe Principal.java
Fonte: Print da tela do Java, (2018).
Mas, apesar disso, precisamos fazer aqui algumas considerações.
 • Na linha 1, a palavra reservada “package” define em que pacote 
esta classe está declarada. Um pacote pode conter várias classes 
que devem estar separados por assunto ou aplicação, assim 
como separamos arquivos de documentos numa pasta ou pacote 
documentos e arquivos de imagens numa pasta ou pacote de 
imagens;
 • Na linha 3, a palavra reservada “import” declara quais são as 
bibliotecas que esta nossa classe Principal vai precisar usar 
para que seja executada adequadamente pelo MOS Android. As 
classes importadas não aparecem por motivos de organização 
de código, mas se você clicar nos “...” que estão logo depois da 
palavra “import” poderá ver quais são as classes necessárias para 
fazer este projeto ser executado;
 • Na linha 6, a classe principal está a ser definida. A palavra 
reservada “class” define que Principal é uma classe. A palavra 
Introdução ao Coding Mobile
64
reservada “public” define que esta classe pode ser instanciada 
por qualquer outra que a utilize, sem precisar ser um classe 
filha. (Exatamente como vimos quando estudamos PHP). A 
palavra reservada “extends” declara que a classe Principal (nossa 
classe) deve estender (herdar) as características (atributos) e os 
comportamentos (métodos) da classe AppCompatActivity.
 • Na linha 8, a palavra reservada @Override informa que o método 
que está na linha abaixo (onCreate) é um método que está a 
fazer sobreposição11 de um método já existente na classe mãe 
(AppCompatActivity).
 • Na linha 9, o método onCreate é definido. Ele é responsável por 
carregar os layouts e outras operações de inicialização. Veremos 
com mais detalhes este método quando estudarmos o ciclo de 
vida completo da Activity.
 • A palavra reservada “void” declara que este método não retorna 
qualquer valor e a palavra reservada “protected” define que este 
método não pode ser acessado por qualquer classe, mas sim 
apenas pelas classes filhas desta que estamos a criar. 
 • Note também que o método onCreate possui um parâmetro. 
Não se preocupe com ele agora. Estudaremos com detalhes 
quando tratarmos do ciclo de vida de uma activity.
 • Na linha 10, a palavra reservada “super” indica que o método 
onCreate original (definido na classe mãe) deve ser chamado e 
executado. Veremos mais sobre estas palavras reservadas a partir 
da próxima unidade.
 • Na linha 11, o método setContentView será chamado. Ele tem 
a função de apresentar um conteúdo na tela. Este conteúdo é 
definido por um layout que está declarado no argumento ou 
parâmetro deste método (R.layout.activity_principal).
 • R indica a pasta “res” (abreviatura para resource);
11 Sobreposição (Override) é uma característica da Programação Orientada 
a Objetos que permite a uma subclasse ou classe filha prover uma específica 
implementação de um método que já foi implementado pela classe mãe.
Introdução ao Coding Mobile
65
 • layout é o nome da subpasta da pasta “res”;
 • activity_principal é o nome do arquivo (activity_principal.xml);
A pasta “res” será analisada agora e você terá, então, uma visão da 
estrutura completa.
Pasta “res”
É a pasta de recursos (resources) da sua aplicação Android.
 • Pasta Drawable: Onde serão armazenados todos os recursos de 
imagens para o seu aplicativo;
 • Pasta Layout: onde ficararão armazenados todos os layouts que 
você for utilizar em cada uma das activities (telas) de sua aplicação. 
Dentro desta pasta existe um arquivo chamado activity_principal.
xml, do qual comentamos a pouco. Este arquivo define o layout 
da única activity que você tem, por enquanto, em sua aplicação. 
A figura abaixo mostra o conteúdo do referido arquivo. Trataremos 
em detalhes desse arquivo na unidade 3 deste material.
Figura 52 – Arquivo de Layout – activity-principal.xml
Fonte: Print da tela do Java, (2018).
 • Pasta mipmap: local onde são armazenados todos os ícones 
utilizados em sua aplicação. Existem duas subpastas: (1) ic_
launcher e (2) ic_launcher_round, onde você podeverificar os 
arquivos .png utilizados na sua aplicação;
 • Pasta Values: possui três arquivos, como mostrado na figura abaixo:
Introdução ao Coding Mobile
66
Figura 53 – Arquivo de Layout – activity-principal.xml
Fonte: Print da tela do Java, (2018).
 • colors.xml: É recomendado que você registre aqui todas as 
cores que você pretende utilizar dentro da sua aplicação. 
Depois de registrado aqui neste arquivo a cor pode ser 
referenciada nos arquivos de layouts de cada uma das telas 
(activities) de sua aplicação. Uma vez que você queira alterar a 
cor que você utilizou em 10 layouts por exemplo é só trocar aqui 
e os layouts que fazem referência a esta cor serão alterados 
automaticamente;
 • strings.xml: tem o mesmo funcionamento que o arquivo de 
cores explicado acima. É onde devem ser registrados todos 
os textos estáticos da sua aplicação. Antes de definir um texto 
para um botão ou um texto para um label, defina-o aqui e 
use a referência aqui definida nos layouts. Uma vez que você 
mude aqui o texto do botão que era “Alterar” para “Editar” todos 
os botões das telas que fazem referência a este texto serão 
alterados automaticamente;
 • styles.xml: Define o estilo de sua aplicação. Aqui serão definidos 
características como tamanho, margem, cor de fundo, etc. e da 
mesma forma que acontece com o arquivo de strings ou de 
cores, usa apenas a referência a este estilo dentro dos layouts. 
Quando você alterar um parâmetro de margem ou cor de fundo 
aqui neste arquivo estará automaticamente alterando em todas 
as telas (activities) da sua aplicação que a eles fazem referência. 
Agora que você entendeu um pouco como funciona a estrutura de 
uma aplicação Java-Android, vamos aos fundamentos da programação 
Java para dispositivos móveis.
Introdução ao Coding Mobile
67
Fundamentos do Java para Mobile
Este tópico tem como função apresentar um pouco da história 
de como surgiu a Linguagem de Programação Java e permitir ao aluno 
entender como funciona a sua plataforma de desenvolvimento.
Java - Um pouco de história
Era o ano de 1991 e a empresa Sun Microsystems trabalhava num 
projeto chamado “Green Project”, cujo objetivo era desenvolver uma nova 
plataforma para a computação interativa. O resultado desse projeto foi a 
criação do handheld StarSeven (cujo símbolo era “*7”). Era um dispositivo 
com tela sensível ao toque (touchscreen) que controlava uma variedade 
de aparelhos domésticos. Na verdade, pode-se dizer que se tratava de 
um controle remoto sofisticado que tinha a capacidade de controlar 
uma grande variedade de aparelhos domésticos disponíveis na época, 
apresentando uma interface animada, numa tela colorida de cinco 
polegadas, de LCD, sensível ao toque.
A linguagem de programação desenvolvida para o StarSeven foi 
denominada de Linguagem “Oak”, que em português quer dizer “carvalho”. 
Ela tinha este nome porque, segundo a lenda, era a árvore que um dos 
criadores da linguagem, James Gosling, via de sua janela.
Bem, este projeto não deu muito certo e foi abandonado, pois, 
segundo alguns, estava bem à frente de seu tempo, mas a Linguagem 
Oak, por ser independente de plataforma, tornou-se de grande interesse 
para a Sun e foi retrabalhada, ajustada e moldada por uma equipe de 
engenheiros para se tornar, depois de dois ou três anos de pesquisa, a 
primeira versão da Linguagem Java.
Em 23 de maio de 1995, foi anunciado que a tecnologia Java estava 
disponível, na sua primeira versão, incorporada no navegador Netscape.
A Tecnologia Java
Quando se fala em Tecnologia Java está a fazer referência à 
Linguagem Java e a Plataforma Java.
Introdução ao Coding Mobile
68
A Linguagem Java
A Linguagem Java é uma linguagem de alto nível. Abaixo estão 
relacionadas algumas de suas características:
 • Orientada a Objetos;
 • Para ambientes distribuídos: Um sistema distribuído é um conjunto 
de computadores independentes que aparenta ao usuário ser um 
único computador. Exemplo: Sistema de reserva de passagens 
aéreas, Serviços da internet.
 • Arquitetura Neutra e portável: É uma linguagem criada para rodar 
em várias plataformas.
 • Alto Desempenho;
 • Interpretada.
IMPORTANTE:
Vale destacar aqui a diferença entre linguagens de 
programação Interpretadas e Compiladas:
Linguagem Interpretada: é uma linguagem de programação 
onde o programa (código-fonte) é lido (executado) por 
um interpretador que o interpreta diretamente, durante 
a execução, isto é, não existe o executável do programa. 
Exemplos: Java, C#, ASP.
Linguagem Compilada: é uma linguagem de programação 
cujo código fonte é traduzido pelo compilador, gerando um 
arquivo executável do programa (linguagem de máquina) 
que é executado diretamente pelo processador ou pelo 
sistema operacional. Exemplos:C, C++, Delphi.
Esquema de execução de um programa em Java
Quando um programa em Java é escrito, ele é gravado em um arquivo 
texto com extensão .java. O compilador lê este arquivo e o transforma em 
um arquivo “.class”. Este processo é chamado de Compilação. A JVM (Java 
Virtual Machine) lê (interpreta) este arquivo “.class” e executa o programa. 
Introdução ao Coding Mobile
69
Este processo é chamado de Execução. A figura abaixo ilustra o processo 
de execução de um programa Java.
Figura 54 – Processo de execução de um programa Java
Fonte: Adaptado pelo autor do processo do Java (2018).
Quando o programa.java é compilado, o resultado é um arquivo.
class (bytecodes) que é a linguagem de máquina que a JVM consegue 
entender. Os bytecodes são então processados (interpretados) pela JVM 
que executa o programa em seu computador. Caso o sistema operacional 
do seu computador seja o Windows, você vai precisar de uma JVM para 
o Windows. Caso você esteja trabalhando com um computador cujo 
sistema operacional seja o MacOS, precisará de uma JVM para este S.O., 
e assim por diante.
A Plataforma Java
É o nome dado ao ambiente computacional que permite 
desenvolver aplicativos utilizando a linguagem Java. A grande vantagem 
desta plataforma é que ela não está presa a um único sistema operacional 
ou a um único hardware.
Atualmente, existem 3 plataformas Java principais12:
 • Java SE: Java Standard Edition – permite desenvolver e implantar 
aplicações em desktops e servidores;
 • Java EE: Java Enterprese Edition – permite desenvolver aplicações 
corporativas e para a internet;
 • Java ME: Java Micro Edition – permite desenvolver aplicações para 
dispositivos móveis.
12 Fonte: clique aqui
Introdução ao Coding Mobile
http://www.oracle.com/technetwork/java/javase/overview/index.html
70
O próximo tópico deste material mostra, passo a passo, como 
montar um ambiente de desenvolvimento Java para as aplicações que 
serão desenvolvidas durante este curso.
Entendendo, Instalando e Configurando o 
Ambiente Java
Antes de começar a programar em linguagem Java, é necessário 
preparar o ambiente de desenvolvimento, que é composto basicamente 
por: JDK13 e IDE14 . 
A tabela abaixo esclarece e relembra alguns conceitos necessários 
para o correto entendimento deste material.
Tabela 1 – Conceitos importantes
Item Descrição
 JDK Conjunto de ferramentas de desenvolvimento que 
permite criar programas na plataforma Java. Contém o 
JRE (Java Runtime Environment – Ambiente de execução 
Java) e outras ferramentas, tais como o compilador 
(javac), o empacotador (jar) e ferramentas para 
documentação (javadoc);
JRE Contém a JVM (Java Virtual Machine – Máquina Virtual 
Java) e as bibliotecas de classes Java (APIs Java)
JVM Ferramenta fundamental para permitir a funcionalidade 
do Java de ser multiplataforma. Antes de instalar uma 
JVM é necessário defi nir em qual sistema operacional ela 
será utilizada.
IDE Ambiente de desenvolvimento que permite ao 
programador o acesso a uma interface amigável de 
desenvolvimento que facilita, organiza e otimiza o 
desenvolvimento, teste e distribuição da aplicação;
Fonte: o autor (2018).
Precisamos instalarambas as ferramentas (JDK e IDE) em 
nosso computador.
13 JDK : Java Development Kit – Kit de Desenvolvimento Java.
14 IDE : Integrated Development Environment – Ambiente de Desenvolvimento Integrado.
Introdução ao Coding Mobile
71
Instalando o JDK
O processo de instalação do kit de Desenvolvimento Java já foi 
explicado no item 2.1 desta unidade, caso você tenha realizado todas as 
atividades desta unidade até aqui, não precisará reinstalá-la. Pode passar 
para o próximo passo. Mas é importante lembrar que se você quiser 
apenas trabalhar com a Linguagem Java em outro computador em que 
não instalou os itens relacionados no módulo 2, deverá executar o item 2.1 
antes de continuar por aqui.
Instalando o IDE
Iremos trabalhar com o IDE Eclipse Photon, que pode ser encontrado 
clicando aqui. 
Figura 55 – Baixando a IDE
Fonte: Tela Splash do Eclipse Photonm, (2018).
Ao abrir estra URL em seu navegador, selecione “Dowload 
Packages”, como mostrado na figura acima e uma nova tela será carrega 
em seu navegador.
Introdução ao Coding Mobile
http://www.eclipse.org/downloads/
72
Figura 56 – Baixando a IDE
Fonte: Tela Splash do Eclipse Photonm, (2018).
Selecione o pacote: Eclipse IDE for Java EE Developers e a versão 
do seu sistema operacional (32 ou 64 bits). Para este material, iremos 
trabalhar com a versão 64 bits.
Figura 57 – Baixando a IDE
Fonte: Tela Splash do Eclipse Photonm, (2018).
Baixe o arquivo: eclipse_jee_photon-R-win32-x86_64.zip e 
descompacte-o no mesmo diretório em que está o jdk. Para o caso deste 
material é o diretório: “c:\program files\java\”. A pasta eclipse será criada 
dentro deste diretório.
IMPORTANTE:
O Eclipse não precisa ser instalado. Uma vez 
descompactado, é só clicar no arquivo eclipse.exe e mãos 
à obra!
Introdução ao Coding Mobile
73
Testando o Eclipse
Para ter certeza que tudo (todas as instalações e descompactações) 
ocorreram de acordo com o esperado, segue uma lista de testes 
necessários, antes de prosseguir:
Execute o arquivo eclipse.exe. Uma tela como a mostrada abaixo 
deve aparecer:
Figura 58 – Tela Splash do Eclipse Photon
Fonte: Tela Splash do Eclipse Photonm, (2018).
Logo em seguida, o eclipse irá solicitar que seja informado qual o 
caminho para o “workspace”, como mostrado na figura abaixo:
Figura 59 – Selecionar o Diretório de Trabalho
Fonte: Tela Splash do Eclipse Photonm, (2018).
O “workspace” significa “espaço de trabalho” e define o endereço 
(diretório e pasta) onde serão colocados todos os arquivos do seu projeto. 
Podem ser criados vários “workspaces”, um para cada projeto que seja 
desenvolvido. Para este teste, digite o endereço: “c:\Teste” e clique em OK.
Introdução ao Coding Mobile
74
O Eclipse irá criar uma pasta com o nome especificado, no local 
especificado. Neste caso: a pasta é “Teste”, o local é “c:\”. O Eclipse irá 
carregar as bibliotecas necessárias e a tela, como a mostrada na figura 
abaixo, será apresentada:
Figura 60 – Tela de abertura do Eclipse
Fonte: Tela Splash do Eclipse Photonm, (2018).
Clique em “Workbench”, como mostrado na figura acima.
Figura 61 – IDE Eclipse
Fonte: Tela Splash do Eclipse Photonm, (2018).
Introdução ao Coding Mobile
75
Este é o ambiente de desenvolvimento integrado ou IDE do Eclipse. 
Neste ambiente serão escritos os códigos em Java para os programas 
que estão propostos neste material. Com a evolução do material, serão 
apresentadas as funcionalidades necessárias desta interface.
Para finalizar, (1) minimize a janela do Eclipse; (2) abra o Windows 
Explorer; (3) verifique que a pasta “Teste” foi criada no drive “c:\”; (4) abra 
a pasta “Teste” e verifique que o Eclipse criou toda a estrutura de pastas e 
arquivos para que seu projeto possa funcionar.
Feche o Eclipse e delete a pasta “Teste” no Windows Explorer, pois 
ele foi criado apenas para este primeiro exemplo teste. Nos exercícios 
propostos neste material serão utilizados outros “workspaces”.
Muito bem! Depois de tudo isso você deve estar com seu 
computador em condições de desenvolver em Java e em Java para 
dispositivos móveis, foco desta disciplina.
Sei que você deve estar “louco” para aprender mais! Mas não 
podemos colocar tudo em uma única unidade, não é verdade? Precisamos 
fazer como nos filmes e anunciar “As cenas dos próximos capítulos”.
Espero que você tenha gostado. A aprendizagem não pode parar! 
Na próxima unidade veremos a estrutura básica da linguagem Java. Até lá!
Introdução ao Coding Mobile
76
REFERÊNCIAS
ANDROID. Documentation Guide. Android Developers, 2018. 
Disponivel em: <https://developer.android.com/guide/topics/manifest/
manifest-intro>. Acesso em: 15 Set. 2018.
CLARO, D.; SOBRAL, J. Programação em JAVA. Florianópolis: 
Copyleft Pearson Education, 2008. 89 p. Disponivel em: <http://www.
faeterj-rio.edu.br/downloads/bbv/0031.pdf>. Acesso em: 06 Set. 2018.
CORDEIRO, F. Android Studio. 3. ed. [S.l.]: AndroidPro, 2016.
CORDEIRO, F. Android Aprendiz. [S.l.]: AndroidPro, 2017. 37 p. 
Disponivel em: <https://www.androidpro.com.br/>. e-Book.
MEIRELLES, A. Smartphones, Guia Prático - Android. Hardware.
com.br, 2009. Disponivel em: <https://www.hardware.com.br/livros/
smartphones/android.html>. Acesso em: 05 Set. 2018.
OGLIARI, R.; BRITO, R. Android LifeCycle: ciclo de vida de uma 
aplicação Android. DevMedia, 2014. Disponivel em: <https://www.
devmedia.com.br/android-lifecycle-ciclo-de-vida-de-uma-aplicacao-
android/29991>. Acesso em: 15 Set. 2018.
PEREIRA, A. P. O que é XML? TecMundo’, 2009. Disponivel em: 
<https://www.tecmundo.com.br/programacao/1762-o-que-e-xml-.htm>. 
Acesso em: 14 Set. 2018.
Introdução ao Coding Mobile
	Android – Visão Geral
	Dispositivos Móveis
	Android – Um pouco de História
	Android – Características
	Arquitetura da Plataforma
	Requisitos para o desenvolvimento de Apps
	Ambiente de Desenvolvimento Java para Mobile
	Instalar o JDK
	Configurando as Variáveis de Ambiente
	Instalar e Configurar o Android Studio
	Instando o Android Studio
	Configurando o Android Studio
	Configurar o Android SDK Manager
	Testando o Ambiente de Desenvolvimento
	Fechando a aplicação Android
	Estrutura do Projeto Java-Android
	Conhecendo a Interface Android Studio
	Tela de Boas Vindas
	Tela Principal
	Demais Janelas de Ferramentas
	Estrutura do projeto Java-Android
	Pasta Manifests
	Pasta Java
	Pasta “res”
	Fundamentos do Java para Mobile
	Java - Um pouco de história
	A Tecnologia Java
	A Linguagem Java
	Esquema de execução de um programa em Java
	A Plataforma Java
	Entendendo, Instalando e Configurando o Ambiente Java
	Instalando o JDK
	Instalando o IDE
	Testando o Eclipse