Desenvolvimento de Aplicativos Móveis - EAD

Prévia do material em texto

desenvolvimento de 
aplicativos móveis
Prof. ME. rICArDo VIEIrA
Reitor: 
Prof. Me. Ricardo Benedito de 
Oliveira
Pró-Reitoria Acadêmica: 
Maria Albertina Ferreira do 
Nascimento
Diretoria EAD: 
Prof.a Dra. Gisele Caroline 
Novakowski
PRODUÇÃO DE MATERIAIS
Diagramação:
Alan Michel Bariani
Thiago Bruno Peraro
Revisão Textual:
Fernando Sachetti Bomfim
Marta Yumi Ando
Olga Ozaí da Silva
Simone Barbosa
Produção Audiovisual:
Adriano Vieira Marques
Márcio Alexandre Júnior Lara
Osmar da Conceição Calisto
Gestão de Produção: 
Cristiane Alves
© Direitos reservados à UNINGÁ - Reprodução Proibida. - Rodovia PR 317 (Av. Morangueira), n° 6114
 Prezado (a) Acadêmico (a), bem-vindo 
(a) à UNINGÁ – Centro Universitário Ingá.
 Primeiramente, deixo uma frase de Só-
crates para reflexão: “a vida sem desafios não 
vale a pena ser vivida.”
 Cada um de nós tem uma grande res-
ponsabilidade sobre as escolhas que fazemos, 
e essas nos guiarão por toda a vida acadêmica 
e profissional, refletindo diretamente em nossa 
vida pessoal e em nossas relações com a socie-
dade. Hoje em dia, essa sociedade é exigente 
e busca por tecnologia, informação e conheci-
mento advindos de profissionais que possuam 
novas habilidades para liderança e sobrevivên-
cia no mercado de trabalho.
 De fato, a tecnologia e a comunicação 
têm nos aproximado cada vez mais de pessoas, 
diminuindo distâncias, rompendo fronteiras e 
nos proporcionando momentos inesquecíveis. 
Assim, a UNINGÁ se dispõe, através do Ensino 
a Distância, a proporcionar um ensino de quali-
dade, capaz de formar cidadãos integrantes de 
uma sociedade justa, preparados para o mer-
cado de trabalho, como planejadores e líderes 
atuantes.
 Que esta nova caminhada lhes traga 
muita experiência, conhecimento e sucesso. 
Prof. Me. Ricardo Benedito de Oliveira
REITOR
33www.uninga.br
unidade
01
sumário da unidade
introdução ............................................................................................................................................................. 5
1. introdução À computação móvel .............................................................................................................. 6
1.1 uma breve introdução ao paradigma orientado a objetos (poo) ............................................... 6
1.1.1 sobre as classes ........................................................................................................................................... 8
1.1.2 instanciação .................................................................................................................................................. 8
1.1.3 reutilização ................................................................................................................................................... 9
1.1.4 Herança ............................................................................................................................................................ 9
2. Histórico e as principais plataFormas móveis atuais .................................................................... 9
2.1 a História do sistema operacional android ....................................................................................... 9
2.2. a História do ios .......................................................................................................................................... 10
2.3 Falando sobre o ipHone e ipod toucH .................................................................................................. 10
introdução ao 
desenvolvimento móvel
Prof. ME. rICArDo VIEIrA
Ensino a distância
DISCIPLINA:
DESENVOLVIMENTO DE APLICATIVOS MÓVEIS
4www.uninga.br
3. projeto de interFaces para dispositivos móveis .............................................................................. 13
3.1 design de interFace de usuário do android ...................................................................................... 13
3.2 usando classes activity, view e viewgroup ..................................................................................... 13
3.2.1 activity ........................................................................................................................................................... 13
3.2.2 view ................................................................................................................................................................ 14
3.2.3 viewgroup .................................................................................................................................................... 15
3.3 como as classes activity, view e viewgroup se relacionam ..................................................... 16
consideraçÕes Finais ....................................................................................................................................... 19
5www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
introdução
Caro(a) aluno(a)!
Esta unidade inicia os estudos com uma breve introdução sobre a Computação Móvel; 
com o avanço da tecnologia, os dispositivos móveis, com sua grande capacidade de computação, 
têm se tornado mais eficientes do que um computador pessoal. 
Veremos, nesta unidade, uma recapitulação sobre o Paradigma Orientado a Objetos 
(POO). Abordaremos as principais características da POO, como, por exemplo, o que é um objeto 
e o que são atributos. Veremos que uma hierarquia de objetos é como uma estrutura de árvore, 
com um tronco principal, ramos e sub-ramos conforme você move para cima (ou para baixo) sua 
estrutura. Veremos também as Classes, que realizam o encapsulamento dos dados e abstrações 
procedurais necessárias para descrever o conteúdo e comportamento de alguma entidade 
do mundo real, mais alguns conceitos, que são de extrema importância para a Programação 
Orientada a Objetos.
Nesta unidade, convidamos você a também estudar o histórico das duas principais 
plataformas móveis com os dois principais Sistemas Operacionais que dominam o mercado 
mundial: o iOS da Apple e o Sistema Operacional Android do Google.
E, por fim, teremos uma visão geral sobre projetos de interfaces para dispositivos móveis, 
em particular, sobre o design de interface de usuário do Android, destacando as classes Activity, 
View e ViewGroup.
Chegou a grande batalha!
Vamos com tudo contra o lado Sombrio da ignorância!
Venha para o lado da Luz do Conhecimento!
A batalha para o conhecimento!
May the force be with you!
Divirta-se e bons estudos!
6www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
1. introdução À computação móvel
A computação pessoal continua a se tornar mais “pessoal”, pois os computadores estão 
se tornando cada vez mais acessíveis a qualquer hora e em qualquer lugar. Na vanguarda desse 
avanço, estão os dispositivos móveis, que estão se transformando em plataformas de computação. 
Os smartphones não são mais apenas para falar – eles são capazes de transportar dados e 
vídeo há algum tempo. Mais significativamente, o dispositivo móvel, com sua grande capacidade 
de computação, acabou se tornando mais eficiente do que um PC. 
A plataforma Android adota totalmente essa ideia de computação de uso geral para 
dispositivos móveis. Na verdade, ela é uma plataforma abrangente que apresenta uma pilha de 
Sistemas Operacionais, baseado em Linux, para gerenciar dispositivos, memória e processos. 
As bibliotecas do Android cobrem telefonia, vídeo, gráficos, programação de UI (Interface de 
Usuário) e todos os outros aspectos do dispositivo físico.
A plataforma Android, embora construída para dispositivos móveis, exibe as características 
de uma estrutura de desktop com recursos completos. O Google disponibiliza essa estrutura para 
programadores Java por meio de um kit de desenvolvimento de software chamado Android SDK. 
Quando você está trabalhando como Android SDK, raramente sente que está escrevendo para 
um dispositivo móvel, porque tem acesso à maioria das bibliotecas de classes que usa em um 
desktop ou servidor – incluindo um banco de dados relacional.
Com um pouco de conhecimento e esforço, você também pode escrever aplicativos 
Android. Para escrever bons aplicativos, no entanto, você precisará cavar mais fundo, entender 
os fundamentos da arquitetura Android, entender como os aplicativos podem funcionar juntos, 
entender como os aplicativos móveis são diferentes de todas as formas anteriores de programação 
(MACLEAN; KOMATINENI; ALLEN, 2015).
Atualmente, você verá dispositivos com Sistema Operacional Android de todos os 
tamanhos e formas em todos os lugares. Eles podem ser usados em suas roupas, graças ao Android 
WEAR; em um aparelho televisivo, graças ao Android TV; e eles fazem parte do seu carro, graças 
ao Android AUTO. Os dispositivos Android proporcionarão entretenimento em sua sala de estar 
na forma de seu aparelho de iTV; irão ajudá-lo a aprender na escola usando um tablet; permitirão 
uma boa leitura na cama com seu e-book; ou usar um console de jogos Android, como OUYA, 
Razer Forge ou nVidia Shield (JACKSON, 2017).
1.1 uma breve introdução ao paradigma orientado a objetos (poo)
A principal característica do Paradigma Orientado a Objetos (POO) é uma maior e melhor 
expressividade das necessidades do nosso dia a dia. Possibilita criar uma unidade de código mais 
próxima da forma como pensamos e agimos, assim facilitando o processo de transformação das 
necessidades diárias para uma linguagem orientada a objeto (PRESSMAN, 2011).
A base do POO é, segundo nos apresenta Jackson (2017), o próprio objeto. Tudo o que 
você criar em Java será um objeto e usará outros objetos (e valores primitivos de dados). Os 
objetos em linguagens POO são semelhantes aos objetos que você vê ao seu redor todos os 
dias, exceto que os objetos Java são virtuais e não são tangíveis, já que os computadores usarão 
zeros e uns (binários) para representar as coisas. Assim como os objetos tangíveis do mundo 
real, os objetos Java têm características, chamadas estados ou atributos, e coisas que eles fazem, 
chamadas comportamentos. Uma maneira de pensar sobre essa distinção é que os objetos Java 
são substantivos, ou coisas que existem por si mesmas, enquanto seus comportamentos são como 
verbos, ou coisas que esses substantivos podem fazer.
7www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
Como exemplo de objetos Java, vamos definir um objeto Java, baseado em um objeto 
real, popular, que vemos ao nosso redor todos os dias em nossas vidas: o automóvel. Algumas das 
características, ou estados, do automóvel comum podem ser definidas da seguinte forma:
•	 Cor (vermelho maçã, por exemplo);
•	 Direção ou rumo (norte, sul, leste ou oeste);
•	 Velocidade (45 km por hora, por exemplo);
•	 Tipo de motor (gás, diesel, biocombustível, hidrogênio, propano, elétrico ou híbrido);
•	 Configuração de marcha (1, 2, 3, 4, 5, 6 ou reverso);
•	 Tipo de trem de força (2WD ou 4WD).
A seguir, estão algumas coisas que você pode fazer com um carro, ou seja, os 
comportamentos do carro:
•	 Acelerar;
•	 Mudar de marcha;
•	 Frenar;
•	 Virar as rodas;
•	 Ligar o rádio;
•	 Acender os faróis
•	 Usar as setas. 
Você entendeu a ideia? Os objetos podem ser tão complicados quanto você deseja, e os 
objetos Java podem aninhar, ou conter, outros objetos Java em sua estrutura de objeto, assim 
como o XML. 
Uma hierarquia de objetos é como uma estrutura de árvore, com um tronco principal, 
ramos e sub-ramos conforme você move para cima (ou para baixo) sua estrutura.
Um exemplo de hierarquia que você usa todos os dias seria seu diretório de vários níveis, 
ou estrutura de pastas, que está no disco rígido do seu computador. Os diretórios ou pastas, em 
sua unidade de disco rígido, podem conter outros diretórios ou pastas, que, por sua vez, podem 
conter ainda outros diretórios e pastas, permitindo que hierarquias complexas de organização 
sejam criadas.
A Figura 1 mostra o diagrama simples “Anatomia de um Objeto de Carro” da estrutura do 
objeto Java, usando um carro como exemplo. Ele mostra as características, ou atributos, do carro, 
que são centrais para definir o objeto carro e, em torno delas, os comportamentos que o objeto 
carro pode realizar e que afetam as mudanças nos atributos ou estados do carro. Os estados e 
comportamentos servem para definir o carro para o mundo exterior, assim como seus objetos de 
aplicativo definirão os estados e comportamentos em relação à funcionalidade de seu aplicativo 
Android para seus usuários finais. É tudo muito lógico (JACKSON, 2017).
8www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
Figura 1 - Um objeto de carro que mostra os atributos ou características do carro (oval interno) e os comportamen-
tos do carro (oval externo). Fonte: Adaptado do modelo de Jackson (2017).
Você pode fazer essa mesma construção hierárquica usando objetos Java, que podem 
conter sub-objetos, que podem conter outros sub-objetos e assim por diante, conforme necessário 
para criar sua estrutura de hierarquia de objeto. 
Você verá hierarquias de objetos aninhados quando estiver trabalhando com Android, 
porque os objetos aninhados são muito úteis para agrupar objetos relacionados que são usados 
juntos, mas que são usados em mais de um lugar, bem como para mais de um tipo de uso. 
Afinal, um dos objetivos do código modular, na programação orientada a objetos, é promover a 
reutilização de código eficaz (JACKSON, 2017).
Em outras palavras, alguns tipos de objetos também serão úteis para outros tipos de 
objetos em um aplicativo Android. Você verá exemplos disso nas próximas unidades.
1.1.1 Sobre as Classes
Classe é um conceito orientado a objeto que faz o encapsulamento dos dados e abstrações 
procedurais necessárias para descrever o conteúdo e comportamento de alguma entidade do 
mundo real. Abstrações de dados que descrevem a classe são envolvidas por uma “parede” de 
abstrações procedurais capazes de manipular de certa maneira os dados. Em uma classe bem 
projetada, a única maneira de atingir os atributos e operar sobre eles é passar por um dos métodos 
que formam essa “parede” (PRESSMAN, 2011).
1.1.2 Instanciação
Segundo nos apresenta os irmãos Deitel (DEITEL; DEITEL; DEITEL, 2015), da mesma 
maneira como alguém precisa construir um carro a partir de seus desenhos de engenharia 
antes que você possa dirigi-lo, será preciso construir um objeto de uma classe antes que um 
programa possa executar as tarefas que os métodos da classe definem. Esse processo é chamado 
de Instanciação. Um objeto é uma instância de sua classe.
9www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
1.1.3 reutilização
Continuando com os irmãos Deitel (DEITEL; DEITEL; DEITEL, 2015), da mesma 
maneira como os projetos de engenharia de um carro podem ser reutilizados muitas vezes 
para a produção de muitos carros, podemos reutilizar uma classe muitas vezes para construir 
muitos objetos. A reutilização de classes já existentes, ao construir novas classes e programas, 
economiza tempo e trabalho. Com a reutilização, também se ajuda a construir sistemas mais 
confiáveis e eficientes, porque as classes e os componentes já existentes frequentemente passaram 
por extensivos testes, depuração e otimização de desempenho. Da mesma maneira como a noção 
de partes intercambiáveis foi fundamental para a Revolução Industrial, as classes reutilizáveis são 
fundamentais para a revolução na área de software estimulada pela tecnologia de objetos.
1.1.4 Herança
Uma nova classe de objetos pode ser criada rápida e convenientemente por meio de 
Herança. A nova classe absorve as características de outra classe já existente, possivelmente 
personalizando-as e adicionandosuas próprias características exclusivas. Em nossa analogia 
automobilística, um conversível certamente será um objeto da classe mais geral “automóvel”, 
porém, mais especificamente, o teto poderá ser levantado ou abaixado (DEITEL; DEITEL; 
DEITEL, 2015).
2. Histórico e as principais plataFormas móveis atuais
2.1 a História do sistema operacional android
O sistema operacional Android, segundo nos apresenta Jackson (2017), foi originalmente 
criado por Andy Rubin para ser um sistema operacional para telefones móveis. Isso aconteceu 
por volta do início do século 21. Em julho de 2005, o Google adquiriu o Android e tornou Andy 
Rubin o vice-presidente sênior de plataformas móveis do Google, onde permaneceu até novembro 
de 2014. Muitos acham que a aquisição do sistema operacional Android pelo Google foi, em 
grande parte, em resposta ao surgimento do iPhone da Apple, na mesma época. No entanto, 
havia muitos outros grandes players, como RIM Blackberry, Nokia Symbian e Microsoft Windows 
Mobile, que isso foi considerado uma decisão de negócios inteligente para o Google adquirir o 
talento de engenharia do Android Incorporated junto com sua propriedade intelectual do Sistema 
Operacional Android. Isso permitiu ao Google inserir sua empresa de mecanismo de busca da 
Internet no mercado móvel emergente, que muitos agora chamam de Internet 2.0.
A Internet 2.0, ou Internet Móvel, continuando com Jackson (2017), permite que os 
usuários de produtos eletrônicos de consumo acessem conteúdos por meio de redes de dados 
amplamente variadas, usando dispositivos eletrônicos portáteis de consumo. Atualmente, 
eles incluem tablets, smartphones, phablets (um híbrido telefone-tablet), consoles de jogos, 
smartwatches, smartglasses, robôs pessoais, drones, câmeras e e-books. Hoje em dia, os dispositivos 
baseados no sistema operacional Android também incluirão aqueles dispositivos eletrônicos 
de consumo não tão portáteis, como aparelhos de TV, centros de mídia domésticos, painéis de 
automóveis, aparelhos de som automotivos, tocadores de música, eletrodomésticos, instalações 
de controle doméstico e sistemas decodificadores de sinalização digital.
10www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
Esse fenômeno, cada vez maior do Android, coloca novos conteúdos de mídia, como 
jogos, animação 3D, televisão interativa, vídeo digital, áudio digital, e-books e imagens de alta 
definição em nossas vidas a cada passo. O Android é um veículo de código aberto popular (outros 
sendo HTML5 e JavaFX) que os artistas digitais usarão cada vez mais para poder desenvolver 
novas criações de mídias que seus usuários finais nunca experimentaram antes. 
Na última década, o Android amadureceu e evoluiu, para se tornar um sistema operacional 
de código aberto integrado estável, excepcionalmente confiável. Um sistema operacional Android 
que começou com sua versão inicial apenas uma década atrás, uma vez adquirido pelo Google, 
lançou versões estáveis de sistema operacional.
No momento da escrita deste e-book, o Android 11 está na sua versão Beta 2. Se você quiser 
ver as estatísticas mais recentes sobre cada uma das revisões anteriores do sistema operacional 
Android, diretamente do site do desenvolvedor Android, você deve visitar este URL: developer.
android.com/about/dashboards/index.html (JACKSON, 2017).
2.2. a História do ios
A segunda versão, o iPhone OS 2, foi a primeira a ter um SDK público. A partir de então, 
com cada versão do sistema operacional, a Apple introduziu vários recursos principais e muito 
mais alterações de API menores.
O iPhone OS 3 trouxe Core Data do Mac para o iPhone. Outras adições incluem Apple Push 
Notification Service, External Accessory Kit, In App Purchases por meio do StoreKit.framework, 
nas planilhas de e-mail do aplicativo, o MapKit.framework, que permite aos desenvolvedores 
incorporar o Google Maps em seus aplicativos, acesso somente à leitura da biblioteca do iPod e 
compartilhamento de dados de chaves. OS 3.1 adicionou suporte a editor de vídeo. O iPhone OS 
3.2 adicionou Core Text e reconhecedores de gestos, compartilhamento de arquivos e suporte à 
geração de PDF, outra atualização menor (embora tão importante). O OS 3.2 também adicionou 
um produto totalmente novo, iPad, suporte para o desenvolvimento de aplicativos que rodam no 
iPad e aplicativos universais que rodam no iPad (3.2) e iPhone (3.1.3). O 3.2 era apenas iPad e não 
funcionava em dispositivos iPhone ou iPod Touch.
O iPhone OS 4 (renomeado iOS 4) introduziu o suporte multitarefa muchawaited, 
notificações locais, acesso somente à leitura do calendário (estrutura do EventKit.framework), 
blocos, Grand Central Dispatch (GCD), em folhas de composição de mensagens de aplicativos 
(SMS) e suporte para tela Retina. Essa versão era apenas para iPhone e não era compatível 
com o desenvolvimento de aplicativos para iPad. Uma pequena atualização, iOS 4.2, sistemas 
operacionais unificados de iPhone e iPad.
O iOS 5 apresenta vários recursos importantes como iCloud, contagem automática de 
referência (ARC), storyboards, estrutura integrada do Twitter e vários outros recursos secundários.
A partir da iOS 5, novos recursos foram integrados aos dispositivos da Apple, tornando-a 
a dominadora do mercado global. Vieram as versões iOS 7, iOS 10, iOS 11, como novas 
tecnologias de hardware e de software. O iOS se encontra na versão 14.1 (quando este material 
foi desenvolvido). 
2.3 Falando sobre o iphone e ipod touch
 Segundo Wagner (2008), a introdução do iPhone/iPod Touch e o subsequente lançamento 
do iPod Touch revolucionou a maneira como as pessoas interagiam com os dispositivos portáteis. 
Os usuários não precisam mais usar um teclado para navegação na tela ou navegar na web por 
meio de páginas “simplificadas”. 
11www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
Os dispositivos Apple trouxeram entrada de tela de toque, um design de interface revolucionário 
e um navegador da web totalmente funcional nas palmas das mãos das pessoas. No entanto, a 
questão na comunidade de desenvolvedores nos meses que antecederam o lançamento do iPhone 
era: a Apple permitirá que desenvolvedores terceirizados desenvolvam aplicativos personalizados 
para essa nova plataforma móvel? A resposta da Apple deixou os desenvolvedores da web felizes e 
os programadores Objective-C tristes – os aplicativos para iPhone e iPod Touch seriam aplicativos 
baseados no Safari, desenvolvidos com tecnologias padrão da web. A Apple optou por essa solução 
como uma forma de fornecer aos desenvolvedores a liberdade de criar aplicativos personalizados, 
ao mesmo tempo em que mantinha o controle da experiência do usuário desses dois dispositivos.
Obviamente, existem diferenças importantes entre um aplicativo do iPhone / iPod Touch 
executado dentro do Mobile Safari e um aplicativo nativo. Do ponto de vista do desenvolvedor, 
a principal diferença é a linguagem de programação – utilizando tecnologias da web em vez de 
Objective-C. No entanto, há também implicações importantes para o usuário final, incluindo:
Desempenho: o desempenho de um aplicativo baseado no Safari não será tão responsivo 
quanto um aplicativo compilado nativo, tanto por causa da natureza interpretativa das linguagens 
de programação quanto pelo fato de que o aplicativo opera em redes Wi-Fi e EDGE (lembre-se de 
que o iPod Touch suporta apenas acesso Wi-Fi). No entanto, apesar das restrições tecnológicas, 
você pode realizar muitas otimizações para atingir um desempenho aceitável. 
Inicialização: embora os aplicativos integrados sejam todos iniciados na tela principal 
do Springboard do iPhone (Figura 2) e iPod Touch (Figura 3), os desenvolvedores da web não têm 
acesso a essa área para seus aplicativos. Em vez disso, um usuário só poderá acessar seu aplicativo 
inserindo sua URL ou selecionando um favorito na lista de favoritos (Figura 4).Figura 2 - Aplicativos integrados começam a partir do Springboard principal. Fonte: O autor. 
12www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
Figura 3 - Layout do iPod Touch. Fonte: Site da Apple.
 
Figura 4 - Aplicativos da web são iniciados a partir da lista de favoritos. Fonte: O autor.
Interface do Usuário (UI): os aplicativos integrados para iPhone e iPod Touch seguem 
as diretrizes de design da UI da Apple. Você pode emular de perto o design de aplicativo nativo 
usando uma combinação de HTML, CSS e JavaScript. A única restrição para completar a emulação 
é a sempre presente barra de ferramentas inferior no Mobile Safari, como mostra a Figura 5. 
13www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
 
Figura 5 - Layout de tela do game Star Wars para o iOS. Fonte: O autor.
3. projeto de interFaces para dispositivos móveis
3.1 design de interface de usuário do android 
Nesta nova era de dispositivos com tela sensível ao toque, como smartphones, tablets, 
leitores de e-book e smartwatches, sua tela se tornou o centro não apenas do feedback visual para 
o aplicativo, mas também para interagir com ele. 
A utilização das classes nos permite que seu aplicativo Android grave coisas na tela do 
dispositivo, como sua classe Activity; classes básicas de Interface do Usuário (UI); e, é claro, o 
assunto principal do aplicativo Android, texto, áudio, vídeo, animação e conteúdo gráfico.
Existem algumas superclasses Android muito importantes, como Activity, View e 
ViewGroup, que fornecem a base para as subclasses que você utilizará para colocar o conteúdo 
do aplicativo e a UI na tela de exibição. Essas superclasses não são usadas diretamente em seu 
aplicativo, mas você precisa conhecê-las mesmo assim (JACKSON, 2017).
3.2 usando classes activity, view e viewgroup
3.2.1 Activity
“A Classe Activity faz a representação de uma tela da aplicação e ela será responsável 
pelo controle dos eventos ocorridos na tela e também definirá qual view será responsável pelo 
desenho da interface gráfica do usuário” (LECHETA, 2015).
Segundo Lecheta (2015), uma Activity é uma classe que deverá herdar da classe android.
app.Activity, ou de alguma subclasse, a qual fará a representação da aplicação e será responsável 
por tratar os eventos gerados nessa tela. 
14www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
A classe da Activity deverá sobrescrever o método onCreate(bundle). Esse método é 
obrigatório e será o responsável pela inicialização necessária para a execução da aplicação, como, 
por exemplo, chamar o método setContentView(view) para a definição da interface de usuário.
Cada Activity deverá ser obrigatoriamente declarada no arquivo AndroidManifest.xml. 
Isso será feito por meio da tag <activity>, como é demonstrado a seguir:
Figura 6 - Representação da tag Activity no editor de texto Sublime. Fonte: O autor. 
Não há muito o que falar da classe android.app.Activity. Ela será utilizada para construir 
uma tela de aplicação. Se você precisar de uma nova tela, precisará de uma nova activity. A coisa 
mais importante de que você precisará se lembrar é que, sempre que uma nova classe de activity 
for criada, ela precisará ser declarada no arquivo AndroidManifest.xml (LECHETA, 2015).
3.2.2 View
A classe View é uma base para o design da interface do usuário. Um objeto View é projetado 
para conter qualquer coisa que precise ser visualizada em um aplicativo Android usando a tela 
do dispositivo. Uma vez que os dispositivos são quase 100% compostos por uma tela frontal, essa 
é aparentemente a informação mais importante no Android, pelo menos do ponto de vista de 
design visual e usabilidade da interface do usuário. Um exemplo de declaração da classe View da 
documentação do desenvolvedor (sempre no topo da documentação da classe) pode ser:
Figura 7 - Declaração da classe View, no editor de texto Sublime. Fonte: O autor.
Isso nos diz que a View pode ser usada publicamente por todas as classes de aplicativos 
Android na API, que se estende à superclasse Object e que implementa interfaces Java para 
gráficos (interface Drawable.Callback) e interatividade (interface KeyEvent.Callback) e oferece 
suporte a usuários com deficiência (interface AccessibilityEventSource) (LECHETA, 2015).
Segundo Jackson (2017), se você olhar a página de documentação da classe View no 
site do desenvolvedor Android, verá que essa classe View tem uma dúzia de subclasses diretas 
conhecidas, uma das quais é o ViewGroup. Alguns dos objetos de widget de UI mais comuns são 
criados usando essas classes. Elas incluem:
•	 ImageView: para visualização de imagens; 
•	 TextView: para visualização de textos; 
•	 TextureView: para mapeamento de textura; 
•	 SurfaceView: para renderizar gráficos; 
•	 AnalogClock: para criar relógios; 
•	 KeyboardView: para criar teclados virtuais; 
15www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
•	 ProgressBar: para criar barras de progresso; 
•	 E várias classes de utilitários relacionadas ao design da UI da View. 
3.2.3 ViewGroup
A classe ViewGroup, conforme nos apresenta Jackson (2017), é uma subclasse direta 
conhecida de View. Mesmo que os widgets View estejam aninhados dentro dos contêineres de 
layout ViewGroup, a superclasse ViewGroup é na verdade uma subclasse, da superclasse View, 
na hierarquia de classes Java do Android. Começando com a classe mestre do objeto Java, a 
hierarquia de herança será estruturada da seguinte maneira:
Figura 8 - Representação da estrutura da hierarquia de Herança, no editor de texto Sublime. Fonte: O autor.
A razão pela qual a equipe de desenvolvimento do sistema operacional Android estruturou 
a hierarquia de classes View dessa maneira é porque os atributos da classe View, como atributos 
de margem superior, inferior, esquerda e direita (propriedades ou parâmetros), também devem 
estar disponíveis para uso em um container de layout ViewGroup, bem como em todos os widgets 
View UI. Portanto, a estrutura lógica Java seria a subclasse de ViewGroup de View, de forma que 
as subclasses de ViewGroup possam herdar todas as mesmas variáveis, constantes e métodos que 
as subclasses de View incluirão (JACKSON, 2017).
Se você olhar a página de documentação da classe ViewGroup, no site do desenvolvedor 
Android (ANDROID DEVELOPERS, 2020), verá que a classe ViewGroup tem 18 subclasses 
diretas conhecidas. Alguns dos layouts de UI mais comuns incluem:
•	 LinearLayout: para design de UI horizontal ou vertical; 
•	 GridLayout: para design de interface de usuário de grade; 
•	 Toolbar: para barras de ferramentas da UI; 
•	 ViewPager: para visualização da página da UI; 
•	 DrawerLayout e SlidingDrawer: para UI em gavetas; 
•	 AbsoluteLayout e FrameLayout: para layouts fixos ou conteúdo em tela cheia;
•	 SlidingPaneLayout: para design de UI deslizante; 
•	 Design da UI do conjunto TvView: para iTV; 
•	 RecyclerView: para design de UI de lista de itens longos e eficiente (recicla ou otimiza o 
uso de memória);
•	 E vários outros para UI especializada.
16www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
3.3 como as classes activity, view e viewgroup se relacionam
Antes de examinarmos as superclasses de UI Android Activity, View e ViewGroup e suas 
subclasses mais funcionais (aquelas classes que você realmente deverá utilizar para construir 
seus aplicativos), será importante entender como elas se relacionam entre si, dentro do design da 
interface do usuário e exibir o contexto de seu aplicativo Android. 
O Android Runtime (ART) é um ambiente de execução que reside no topo de um Kernel 
Linux e se comunica com o sistema operacional Android, sob o qual seu aplicativo será executado(ou rodado). Seu aplicativo se define como ART usando o arquivo XML de definição de aplicativo 
AndroidManifest.xml. 
Para cada tela de exibição funcional em um aplicativo, que geralmente contém algum 
tipo de design de UI, bem como conteúdo de aplicativo relacionado, seu aplicativo definirá uma 
subclasse Activity (JACKSON, 2017).
Conforme Jackson (2017) nos apresenta, cada subclasse Activity em seu aplicativo Android 
precisaria ter um método .onCreate() definido, e esse método, por sua vez, deveria conter a 
chamada do método setContentView() para carregar uma interface de usuário ViewGroup(layout) 
e View(widget), elementos de UI. Os parâmetros setContentView() contêm a referência à definição 
XML do layout da UI da subclasse de Activity. Para a classe MainActivity.java, essa referência 
será R.layout.activity_main, que é a abreviação do Android para fazer referência ao arquivo/res/
layout/activity_main.xml. 
Segundo Jackson (2017), uma tag pai, em uma definição XML de layout de UI, 
geralmente fará referência a uma subclasse ViewGroup, como a classe ConstraintLayout, que no 
arquivo activity_main.xml será representada por uma tag pai <ConstraintLayout>. A superclasse 
ViewGroup no Android será usada para criar subclasses e classes de contêiner de layout 
personalizado no Android. Há um grande número de classes de contêiner de layout customizado 
no Android, porque essas classes de layout de UI fornecem a base do design de UI no Android.
Dentro do recipiente de layout de UI do ViewGroup, as tags pai são tags filhas que 
representam elementos da UI, que são chamados de Widgets no Android. Os widgets da UI são 
baseados na superclasse View do Android. Cada widget, como a tag filho <TextView>, referencia 
sua classe de widget Android TextView, que é uma subclasse usando a superclasse View. Dentro 
de cada tag filho do widget de UI (subclasse de visualização), você poderá definir parâmetros 
que fazem referência aos novos ativos de mídia para seu aplicativo, como drawables (imagens e 
animação de bitmap), animação (procedural, interpolação ou animação vetorial), áudio ou vídeo, 
formas escaláveis de gráficos vetoriais (SVG), elementos de interface do usuário personalizados 
e ativos semelhantes.
Continuando com Jackson (2017), colocar os ativos do seu aplicativo na tela de exibição 
do dispositivo Android envolve colocar parâmetros em tags de widget filho dentro de tags de 
layout de UI pai, referenciadas pela subclasse Activity, que você declarou no arquivo XML de 
manifesto do aplicativo Android. Tudo isso pode ser feito no Android Studio.
O código será passado para o mecanismo ART, que então converte tudo isso em linguagem 
de máquina e, em seguida, passa para o Kernel Linux, cujo trabalho será fazer a interface do 
software do sistema operacional com o hardware e renderizar o design e o conteúdo da UI do 
seu aplicativo para o hardware da tela de exibição do dispositivo Android com precisão de pixel 
perfeita. Essa cadeia de Android Runtime para recursos de aplicativo será parecida com esta:
Android RunTime > Manifest > Activity Subclass > ViewGroup Parent Tag > View Child 
Tag > Resources
17www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
Para tornar isso ainda mais fácil de visualizar, a Figura 9 mostra um diagrama em camadas 
(e conexões) entre os novos recursos de mídia do seu aplicativo, seus widgets de UI, que mantêm 
os aplicativos; os layouts de UI, que mantêm seus recursos; e as subclasses de Activity, que definem 
e controlam suas características de XML de layout UI, referenciando-a usando sua chamada do 
método .setContentView(). É importante observar que, como você pode definir uma imagem ou 
animação de plano de fundo para o contêiner de layout da UI, um ViewGroup também pode fazer 
referência a novos recursos de mídia; portanto, a nova área de recursos de mídia do diagrama na 
Figura 9 conecta-se às subclasses View e ViewGroup (JACKSON, 2017).
Figura 9 - Estratificação do aplicativo Android, desde novos recursos de mídia até a execução. Fonte: Jackson (2017).
O seu manifesto Android define para ART quais classes de Activity um aplicativo contém, 
bem como o que seu aplicativo tem permissão para fazer; e outras informações sobre o histórico 
da versão do seu aplicativo, suporte, estrutura, permissões, comunicações, intenções, acesso à 
rede, acesso ao Google Play e assim por diante (JACKSON, 2017).
Caro(a) aluno(a), pensando em uma maneira para aprimorar o seu conhecimento 
sobre o emprego da tecnologia para desenvolvimento de aplicativos Android, 
trago como sugestão o artigo Developer Guides, do portal Android Developers, 
como sugestão para pesquisas e para o aprimoramento no desenvolvimento de 
aplicativos Android. 
“Guias do Desenvolvedor”
“São os guias para orientar o desenvolvedor Android dentro do portal Android 
Developers. Contendo uma lista de documentos no painel de navegação, o 
desenvolvedor poderá aprender a criar aplicativos utilizando APIs no Framework 
Android e outras bibliotecas.
Para quem estiver começando a trabalhar com o Android e quiser partir para o 
desenvolvimento de código, você poderá começar com o tutorial: Crie seu primeiro 
app. 
No portal Android Developers, você poderá conferir outros recursos 
para saber mais sobre o desenvolvimento no Android, como a 
Documentação Básica, o Codlabs, Cursos para criar aplicativos 
Android e Treinamentos Online”.
Disponível em: <https://developer.android.com/guide>. 
18www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
“De certa forma não posso acreditar que haja tantas alturas que não possam 
ser escaladas por um homem que sabe os segredos de como tornar os sonhos 
realidade. Esse segredo especial pode ser resumido em quatro Cs. Eles são 
Curiosidade, Confiança, Coragem e Constância. E o maior de todos eles é a 
Confiança. Quando você acreditar em uma coisa, acredite nela até o fim” (Walt 
Disney). Disponível em: https://citacoes.in/pesquisa/?h=Walt+Disney.
Dessa forma, fica a reflexão para todos nós de que, para tornarmos os nossos 
sonhos realidade, só precisamos de quatro coisas: Curiosidade, Confiança, 
Coragem e Constância.
Título: Android 6 para Programadores - Uma abordagem 
baseada em aplicativos.
Autores: Paul Deitel, Harvey Deitel, Alexander Wald.
 
Editora: Bookman.
Sinopse: Guia Deitel do programador profissional para 
o desenvolvimento de aplicativos para smartphones e 
tablets utilizando Android 6 e Android Studio. Aprenda 
tudo o que você precisa para desenvolver rapidamente 
ótimos aplicativos Android e publicá-los no Google Play. 
Com uma abordagem baseada em aplicativos, este livro 
discute as novas tecnologias por meio de 8 aplicativos 
Android totalmente testados, complementados por 
sintaxe em tons diferentes, realces e detalhamento dos 
códigos e saídas de exemplo. 
Fonte: Editora Bookman (2020).
19www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 1
EDUCAÇÃO A DistânCiA
consideraçÕes Finais 
Caro(a) aluno(a)!
Chegamos ao final desta unidade com a satisfação de tê-lo aqui conosco, pois procuramos 
dar o nosso melhor para trazer um norte para que você prossiga no desenvolvimento de suas 
habilidades para a sua carreira profissional.
Nesta unidade, você recebeu uma introdução aos conceitos de Computação Móvel. De 
maneira introdutória, vimos que, com o avanço da tecnologia, os dispositivos móveis, com sua 
grande capacidade de computação, ultrapassam as possibilidades oferecidas por um computador 
de mesa ou mesmo um notebook. 
Vimos uma breve recapitulação sobre o Paradigma Orientado a Objetos (POO), tão 
importante na programação para dispositivos móveis. Procuramos apresentar os conceitos 
sobre a hierarquia de objetos, que, de maneira análoga, são como uma estrutura de uma árvore, 
com um tronco principal, ramos e sub-ramos. Também vimos sobre as Classes, que fazemo 
encapsulamento dos dados e abstrações procedurais necessárias para descrever o conteúdo e 
comportamento de alguma entidade do mundo real, importantes na Programação Orientada a 
Objetos.
Contextualizando de maneira simples, apresentamos os históricos das duas principais 
Plataformas Móveis: o iOS da Apple e o Android do Google.
Outra ênfase importante dada nesta unidade foi uma introdução a Projetos de Interfaces 
para Dispositivos Móveis, como, por exemplo, o Design de Interface de Usuário do Android, em 
que destacamos as Classes Activity, View e ViewGroup.
Dando continuidade, na próxima unidade, iremos estudar sobre os principais componentes 
de uma aplicação, faremos um estudo aprofundado sobre persistência de dados em dispositivos 
móveis, veremos formas de acessar os recursos dos dispositivos móveis, e muito mais.
Esperamos você, caro(a) aluno(a), na Unidade 2.
Até breve!
Fonte: Alura Cursos Online (2020).
Título: Desenvolvimento Android.
Sinopse: Um episódio focado no desenvolvimento de 
aplicações Android. Neste bate-papo, Paulo Silveira e Felipe 
Torres conversam sobre os primeiros passos para começar 
a desenvolver, quais são as principais ferramentas do 
desenvolvimento mobile, como colocar sua aplicação no ar 
e mais!
Disponível em: <https://www.youtube.com/
watch?v=fWscDFHKgw8&ab_channel=AluraCursosOnline>. 
2020www.uninga.br
unidade
02
sumário da unidade
introdução ............................................................................................................................................................ 22
1. principais componentes de uma aplicação ......................................................................................... 23
1.1 alguns termos de programação ............................................................................................................. 23
1.2 introdução ao maniFest.Xml .................................................................................................................... 24
1.3 a classe activity: um contêiner de design de ui .............................................................................. 25
1.4 linearlayout e o boX model ...................................................................................................................... 25
1.4.1 conceitos e atributos .............................................................................................................................. 26
1.4.1.1 orientação ................................................................................................................................................... 26
1.4.1.2 modelo de preencHimento .................................................................................................................. 26
1.4.1.3 peso ............................................................................................................................................................... 26
1.4.1.4 gravidade..................................................................................................................................................... 27
principais componentes
Prof. ME. rICArDo VIEIrA
Ensino a distância
DISCIPLINA:
DESENVOLVIMENTO DE APLICATIVOS MÓVEIS
21www.uninga.br
2. persistência de dados em dispositivos móveis ................................................................................. 28
2.1 o que é persistência? ................................................................................................................................... 28
2.2 armazenamento de dados e arquivos ................................................................................................. 28
2.2.1 locais de armazenamento ...................................................................................................................... 28
2.3 biblioteca room persistence .................................................................................................................. 29
2.3.1 salve os dados em um banco de dados local usando o room .................................................. 29
3. acesso aos recursos de dispositivos móveis ..................................................................................... 32
consideraçÕes Finais ........................................................................................................................................ 38
22www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
introdução
Caro(a) aluno(a)!
Iniciaremos esta unidade com o estudo dos principais componentes de uma aplicação. 
Veremos alguns termos de programação, em especial Variável, Método e Constante.
Apresentaremos também, nesta unidade, introdução ao Manifest.XML. Veremos que esse 
arquivo contém muitas das configurações que deverão ser especificadas em uma caixa de diálogo, 
por exemplo, ou no nome do aplicativo, ou até nos nomes dos pacotes.
Abordaremos as principais características da classe Activity. Veremos que uma Activity, 
quando for criada usando Java, fará referência a essa definição de design XML UI. Além de tudo 
isso, teremos um tópico especial dedicado à Persistência de Dados em dispositivos móveis. 
Estudaremos o sistema de arquivos do Android e as várias opções para salvar os dados do seu 
aplicativo.
E, por fim, mas não menos importante, abordaremos o acesso aos recursos de dispositivos 
móveis. Veremos que o Android Studio pode abrir um projeto de cada vez e cada projeto poderá 
conter um ou mais módulos. Veremos também a estrutura do projeto, com localização da pasta do 
módulo, com o código-fonte e seus arquivos e os arquivos de compilação específicos, juntamente 
com a descrição de cada componente de uma aplicação.
Caro(a) aluno(a)!
Agora é hora de darmos continuidade aos nossos estudos.
Vamos aproveitá-los ao máximo, com muita dedicação, pois este material foi preparado 
com muito carinho para você.
Bom estudo!
23www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
1. principais componentes de uma aplicação
1.1 alguns termos de programação
Apresentaremos, a seguir, algumas das terminologias técnicas usadas em Java. Os Objetos 
possuem Campos de Dados para armazenar dados Variáveis; Constantes para manter dados 
fixos; e métodos para definir comportamentos, como segue:
•	 Os Campos de Dados que contêm os estados de um Objeto Java que podem mudar 
com o tempo são chamados de Variáveis. Usando ainda o exemplo do carro apresentado 
na Unidade 1, a direção em que você está conduzindo o carro, a marcha em que está 
dirigindo e a velocidade em que você está mudam quase em tempo real e, portanto, são 
todas variáveis.
•	 Os Campos de Dados que contêm os estados de um Objeto que não mudam com o 
tempo são chamados de Constantes. No exemplo do carro, a pintura vermelha pode ser 
uma constante, assim como o tipo de motor.
•	 Os Métodos: são lógicas de programação ou rotinas de código de programa, que operam 
e irão mudar os campos de dados e as variáveis internas do objeto. Os métodos também 
permitirão que outros objetos Java, externos ao próprio Objeto, se comuniquem com esse 
objeto, desde que o método seja declarado público. 
Como vimos na Unidade 1, um dos principais conceitos de POO é o encapsulamento de 
dados. Em Java, o encapsulamento de dados é implementado permitindo apenas que os campos 
de dados variáveis de um objeto Java sejam modificados diretamente por meio dos métodos 
internos desse mesmo objeto Java. Isso permite que um Objeto Java seja autossuficiente ou 
encapsulado.
Continuando a usar o exemplo do carro, queremos agora realizar a ação de virar o carro, 
e para isso, podemos usar o método .virarRodas (), mostrado na Figura 1, na parte inferior direita 
do diagrama. Esse método seria composto da lógica de programação Java, que posicionaria 
corretamente as rodas do carro, fazendo com que ele se movesse na direçãodesejada. Você não 
veria detalhes de como as rodas do objeto são giradas, por causa do encapsulamento. Esse detalhe 
é deixado para a funcionalidade interna contida (encapsulada) dentro do método no objeto Java.
Figura 1 - Um objeto de carro que mostra os atributos ou características do carro (oval interno) e os comportamen-
tos do carro (oval externo). Fonte: Adaptado de Jackson (2017). 
24www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Observe os parênteses vazios usados após os nomes dos métodos no texto. Eles são 
sempre usados ao escrever sobre um método, para que o leitor saiba que o autor está se referindo 
a um método Java. Além disso, como as chamadas de método são invocadas usando a notação 
de ponto, usaremos os nomes dos métodos com um ponto, reforçando ainda mais que se trata 
de uma chamada de método, para que você possa visualizá-la. Você verá essa convenção de 
nomenclatura de método usada no restante deste e-book. 
Usando o encapsulamento de dados, você pode construir e testar individualmente cada 
objeto que faz parte de uma construção de objeto maior, sem exigir que dado algum seja acessado 
de outros objetos ou módulos de um aplicativo. O acesso a dados externos pode se traduzir 
em bugs, portanto, o encapsulamento ajuda no desenvolvimento de aplicativos complicados 
de grande escala. Sem o encapsulamento de dados, os desenvolvedores de sua equipe podem 
simplesmente acessar qualquer parte dos dados do seu objeto e usar como quiserem. Isso pode 
introduzir bugs que afetam os métodos que você aperfeiçoou para manipular seu objeto e fornecer 
sua solução encapsulada. Portanto, o encapsulamento de dados promove o conceito central em 
POO de modularidade. Depois que um objeto é criado e testado, outros objetos podem usá-lo 
sem se preocupar com sua integridade.
O encapsulamento de dados, portanto, permite a reutilização de código, para que os 
programadores possam desenvolver bibliotecas de objetos úteis, que não precisam ser reescritos 
ou testados novamente por outros programadores. Você pode ver como isso pode economizar 
tempo e dinheiro do desenvolvedor, estruturando apenas o trabalho que precisa ser feito e 
evitando processos de trabalho redundantes relacionados ao teste de vários módulos de código 
em conjunto uns com os outros ao mesmo tempo. O encapsulamento de dados também permitirá 
que os desenvolvedores ocultem os dados e a lógica interna de seu objeto Java, se isso for desejado.
No exemplo do objeto carro, os atributos de nosso carro são encapsulados dentro do 
objeto carro e, portanto, podem ser alterados apenas por meio dos métodos que os cercam em 
cada diagrama. Por exemplo, alguém poderia usar um método .mudarDeMarcha() para alterar a 
variável de campo Marcha = 1 para Marcha = 2.
Por fim, os objetos Java tornam a depuração mais fácil, porque você pode adicioná-los 
ou removê-los modularmente, ou isolá-los durante o teste para verificar onde os bugs estão 
localizados no código geral (JACKSON, 2017).
1.2 introdução ao manifest.Xml
O arquivo AndroidManifest.xml é criado pelo IDE quando for criado um novo projeto de 
aplicativo. Esse arquivo contém muitas das configurações que deverão ser especificadas na caixa 
de diálogo Create New Project – o nome do aplicativo, o nome do pacote e os nomes da atividade 
e muito mais. Deverá editar o XML desse arquivo para adicionar uma nova configuração, que 
força o teclado virtual a ser exibido quando o aplicativo começa a ser executado. Você também 
especificará que o aplicativo suporta apenas a orientação retrato, ou seja, a dimensão maior do 
dispositivo é vertical (DEITEL; DEITEL; WALD, 2016).
A base de qualquer aplicativo Android é o arquivo de manifesto AndroidManifest.xml. 
Isso estará no diretório src / main / do módulo do aplicativo (o conjunto de fonte principal) para 
projetos típicos do Android Studio.
Aqui será onde iremos declarar o que estará dentro do aplicativo – as atividades, os 
serviços e assim por diante. Também indicaremos como essas peças se ligam ao sistema Android 
geral; por exemplo, indicaremos qual atividade (ou atividades) deverá aparecer no Menu principal 
do dispositivo.
25www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Ao criar seu aplicativo, obteremos um arquivo manifest inicial gerado para nós e 
disponível na Figura 2. Para um aplicativo simples, que oferece uma única atividade e nada mais, 
o manifesto gerado automaticamente provavelmente funcionará bem ou talvez requeira algumas 
pequenas modificações. Na outra extremidade do espectro, o arquivo de manifesto para o pacote 
de demonstração da API do Android tem mais de 1.000 linhas. Seus aplicativos Android de 
produção provavelmente ficarão em algum lugar no meio (MURPHY, 2019).
Figura 2 - Exemplo de Android Manifest XML. Fonte: Android Developers (2020).
1.3 a classe activity: um contêiner de design de ui
Segundo Jackson (2017), enquanto uma hierarquia de design View UI é criada com 
marcação XML, uma Activity será criada usando Java e fará referência a essa definição de design 
XML UI. A Activity funde o tema do Sistema Operacional, como você pode ver a seguir, na 
definição de classe que estende ContextThemeWrapper, com o design da interface do usuário. Ele 
implementa interfaces Java para inflação da UI, Windows, teclado, menu e componentes. Um 
exemplo de Activity é apresentado na Figura 3.
Figura 3 - Criação de uma Activity. Fonte: Android Developers (2020).
Isso nos diz que uma Activity aumenta (transforma elementos XML em objetos Java) seu 
design de UI, lida com chamadas de janelas do Sistema Operacional, “ouve” o uso do ContextMenu, 
lida com componentes do Android e passa por KeyEvents para elementos da UI.
Um objeto Activity no Android contém uma única UI focada em uma tarefa ou recurso 
específico que seu aplicativo oferece ao usuário. Quase todas as atividades interagem com o usuário, 
portanto, cada objeto Activity deve cuidar da criação de uma janela, usando uma chamada para 
o Sistema Operacional Android para que o usuário possa interagir com uma UI que é carregada 
usando a chamada do método setContentView (R.layout.uiDesignName) (JACKSON, 2017).
1.4 linearlayout e o box model
Segundo Murphy (2019), o LinearLayout representa a abordagem do Android para um 
Box Model (modelo de caixa) – widgets ou contêineres filhos serão alinhados em uma coluna ou 
linha, um após o outro.
26www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
1.4.1 Conceitos e atributos
Continuando com Murphy (2019), para configurar um LinearLayout, você tem quatro 
áreas principais de controle, além do conteúdo do contêiner: a orientação, o modelo de 
preenchimento, o peso, a gravidade.
1.4.1.1 orientação
A orientação indica se o LinearLayout representa uma linha ou uma coluna. Basta 
adicionar ao Android: orientação para seu elemento LinearLayout em seu layout XML, definindo 
o valor como Horizontal para uma linha ou Vertical para uma coluna.
A orientação poderá ser modificada em tempo de execução invocando setOrientation() 
no LinearLayout, fornecendo-lhe HORIZONTAL ou VERTICAL.
1.4.1.2 Modelo de preenchimento
 
O objetivo por trás de um LinearLayout – ou qualquer uma das classes de contêiner do 
Android – será organizar vários widgets. Parte da organização desses widgets será determinar 
quanto espaço cada um obtém.
O LinearLayout adota uma abordagem de “filho mais velho ganha” para alocar espaço. 
Portanto, se tivermos um LinearLayout com três filhos, o primeiro filho receberá seu espaço 
solicitado. O segundo filho terá o espaço solicitado, se houver espaço suficiente para ele, e o 
mesmo para o terceiro filho. Portanto, se o primeiro filho solicitar todo o espaço (por exemplo, 
se esse é um LinearLayout Horizontal e o primeiro filho tiver android: layout_width = “match_
parent”), o segundoe o terceiro filhos terminarão com largura zero.
1.4.1.3 Peso
Mas você deve estar se perguntando: o que acontece se tivermos dois ou mais widgets, 
que devem dividir o espaço livre disponível? Por exemplo, suponha que temos dois campos de 
várias linhas, em uma coluna, e queremos que eles ocupem o espaço restante na coluna depois 
que todos os outros widgets tiverem seus espaços alocados.
Para fazer isso funcionar, além de definir android: layout_width (para linhas) ou 
android: layout_height (para colunas), você também deverá definir android: layout_weight. 
Essa propriedade indica qual proporção do espaço livre deverá ir para aquele widget. Se você 
definir android: layout_weight com o mesmo valor diferente de zero para um par de widgets (por 
exemplo, 1), o espaço livre será dividido igualmente entre eles. Se você definir 1 para um widget 
e 2 para outro widget, o segundo widget usará o dobro do espaço livre que o primeiro widget, e 
assim por diante. O peso de um widget será zero por padrão.
Outro padrão que pode ser usado é a base percentual em relação ao peso. Para usar essa 
técnica para um layout horizontal, siga os seguintes passos:
1. Defina todos os valores de android: layout_width, assim como para os widgets no layout;
2. Defina os valores android: layout_weight com o tamanho percentual desejado para 
cada widget no layout;
3. Certifique-se de que todos os pesos somem 100.
27www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Se quiser ter espaço sobrando, não alocado para nenhum widget, você poderá adicionar 
um atributo android: weightSum ao LinearLayout e garantir que a soma dos atributos android: 
layout_weight dos filhos seja menor que essa soma. Cada criança terá espaço alocado com base 
na proporção de seu android: layout_weight em comparação com o android: weightSum, não em 
comparação com a soma dos pesos. E haverá um espaço vazio que ocupará o resto do quarto não 
alocado para os filhos.
1.4.1.4 Gravidade
Por padrão, tudo em um LinearLayout será alinhado no início e no topo. Portanto, se 
você criar uma linha de widgets por meio de um LinearLayout Horizontal, a linha ficará alinhada 
no lado inicial da tela (por exemplo, à esquerda em um LTR language). Se não for isso que você 
deseja, será necessário especificar uma gravidade. Ao contrário do mundo físico, o Android 
possui dois tipos de gravidade: 
•	 A gravidade de um widget dentro de um LinearLayout;
•	 A gravidade do conteúdo de um widget ou contêiner.
A propriedade android: gravity de alguns widgets e contêineres – que também poderá 
ser definida via setGravity() em Java – diz ao Android para deslizar o conteúdo do widget ou 
contêiner em uma direção específica. Por exemplo:
•	 android: gravity = “right” – diz para deslizar o conteúdo do widget para a direita; 
•	 android: gravity = “right|bottom” – diz para deslizar o conteúdo do widget para a direita 
e para baixo.
Aqui, o “conteúdo” varia. TextView suporta android: gravity, e o “conteúdo” será o texto 
mantido dentro do TextView. LinearLayout suporta android: gravity, e o “conteúdo” será os 
widgets dentro do contêiner, e assim por diante.
Os filhos de um LinearLayout também têm a opção de especificar android: layout_gravity. 
Aqui, o filho estará dizendo ao LinearLayout: “se houver espaço, por favor, deslize-me (e apenas 
eu) nesta direção”. No entanto, isso só funciona na direção oposta à orientação do LinearLayout 
– os filhos de um LinearLayout Vertical podem usar android: layout_gravity para controlar seu 
posicionamento horizontalmente (início ou fim), mas não verticalmente.
Para uma linha de widgets, o padrão será que eles sejam alinhados, de forma que seus 
textos fiquem alinhados na linha de base (a linha invisível em que as letras parecem “sentar”), 
embora você possa especificar uma gravidade de center_vertical para centralizar os widgets ao 
longo do ponto médio vertical da linha (MURPHY, 2019).
28www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
2. persistência de dados em dispositivos móveis
2.1 o que é persistência?
Quase todos os aplicativos necessitam persistir os dados. A persistência é um dos conceitos 
fundamentais no desenvolvimento de aplicativos. Se um sistema de informação não preservasse 
os dados quando fosse desligado, o sistema teria pouca utilidade prática. A persistência do objeto 
significa que os objetos individuais podem sobreviver ao processo de aplicação; eles podem ser 
salvos em um armazenamento de dados e recriados posteriormente. Quando falamos sobre 
persistência em Java, normalmente estamos falando sobre mapeamento e armazenamento de 
instâncias de objetos em um banco de dados usando SQL (BAUER; KING; GARY, 2016).
2.2 armazenamento de dados e arquivos
A usabilidade de um sistema Android de arquivos se assemelha aos sistemas de arquivos 
baseados em disco em outras plataformas. O sistema possui várias opções para você salvar os 
dados do seu aplicativo:
•	 Armazenamento específico do aplicativo: armazena arquivos destinados apenas ao uso 
do seu aplicativo, em diretórios dedicados dentro de um volume de armazenamento interno 
ou em diferentes diretórios dedicados, dentro do armazenamento externo.  Podemos 
usar os diretórios no armazenamento interno para salvar informações confidenciais que 
outros aplicativos não devem acessar.
•	 Armazenamento compartilhado:  podemos armazenar arquivos que seu aplicativo 
pretende compartilhar com outros aplicativos, incluindo mídia, documentos e outros 
arquivos.
•	 Preferências: podemos armazenar dados privados primitivos em pares chave/valor.
•	 Bancos de dados:  podemos armazenar dados estruturados em um banco de dados 
privado usando a biblioteca de persistência, como, por exemplo, a Biblioteca Room, que 
veremos a seguir (developer.android.com).
2.2.1 Locais de armazenamento
O Android oferece dois tipos de locais de armazenamento físico, como vimos 
anteriormente: armazenamento interno e armazenamento externo. Na maioria dos dispositivos, 
o armazenamento interno é menor do que o externo. No entanto, o armazenamento interno está 
sempre disponível em todos os dispositivos, tornando-o um local mais confiável para colocar os 
dados dos quais seu aplicativo depende.
Volumes removíveis, como um Cartão SD, aparecem no sistema de arquivos como parte 
do armazenamento externo.  O Android representa esses dispositivos usando um caminho, 
como /sdcard (developer.android.com).
Os próprios aplicativos são armazenados no armazenamento interno por padrão. Se o 
tamanho do seu APK (Android Package) for muito grande, você pode indicar uma preferência 
no arquivo de manifesto do seu aplicativo para instalar o aplicativo em armazenamento externo, 
conforme apresentado na Figura 4.
29www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Figura 4 - Configuração de local para armazenamento externo. Fonte: Adaptado de Android Developers (2020).
2.3 biblioteca room persistence
A biblioteca de Room Persistence nos fornece uma camada de abstração sobre o SQLite, 
para permitir um acesso mais robusto ao banco de dados, ao mesmo tempo em que aproveita 
todo o poder do SQLite.
A biblioteca ajuda na criação de um cache de dados do seu aplicativo, em um dispositivo 
que o esteja executando. Esse cache, que serve como a única fonte de verdade do seu aplicativo, 
permite que os usuários vejam uma cópia consistente das principais informações dentro dele, 
independentemente de os usuários estarem conectados com a internet (developer.android.com).
Para usar o Room em seu aplicativo, adicione as seguintes dependências ao arquivo build.
gradle dele, conforme apresentado na Figura 5.
Figura 5 - Exemplo de implementação, utilizando a Biblioteca Room. Fonte: Adaptado de Android Developers 
(2020).
2.3.1 Salve os dados em um banco de dados local usando o room
A BibliotecaRoom oferece uma camada de abstração sobre o SQLite para permitir acesso 
total ao banco de dados enquanto aproveita todo o poder do SQLite.
Os aplicativos que lidam com quantidades não triviais de dados estruturados podem 
se beneficiar muito com a persistência desses dados localmente.  O caso de uso mais comum 
é armazenar dados relevantes em cache. Dessa forma, quando o dispositivo não puder acessar 
a rede, o usuário ainda poderá navegar nesse conteúdo enquanto estiver offline.  Quaisquer 
alterações de conteúdo iniciadas pelo usuário serão sincronizadas com o servidor depois que o 
dispositivo estiver online novamente (developer.android.com).
Existem três componentes principais na Room:
30www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
1. Banco de Dados: possui o suporte do banco de dados e servirá como o principal ponto 
de acesso para a conexão subjacente aos dados relacionais persistentes do seu aplicativo.
A classe com a anotação @Database deverá atender às seguintes condições:
•	 Seja uma classe abstrata que se estende a RoomDatabase.
•	 Inclua a lista de entidades associadas ao Banco de Dados na anotação.
•	 Contenha um método abstrato que possui zero argumentos e retorne à classe com a qual 
está anotado @Dao.
Em tempo de execução, você pode adquirir uma instância de Database chamando Room.
databaseBuilder() ou Room.inMemoryDatabaseBuilder().
2. Entity:  representa uma tabela no banco de dados.
3. DAO: contém os métodos usados para acessar o banco de dados.
O aplicativo usa o Room Database para obter os Objetos de Acesso a Dados, ou DAOs, 
associados a esse banco de dados.  O aplicativo então usa cada DAO para obter entidades 
do banco de dados e salvar todas as alterações feitas nessas entidades de volta ao banco de 
dados. Finalmente, o aplicativo usa uma entidade para obter e definir valores que correspondem 
às colunas da tabela no banco de dados (developer.android.com). Um diagrama de arquitetura é 
apresentado na Figura 6.
Figura 6 - Diagrama da arquitetura da Room. Fonte: Android Developers (2020).
Os fragmentos de códigos das Figuras 7, 8 e 9 contêm uma configuração de banco de 
dados de amostra, com uma Entity e um DAO.
31www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
User:
Figura 7 - Exemplo de configuração de banco de dados utilizando uma Entity. Fonte: Adaptado de Android Deve-
lopers (2020).
UserDao:
Figura 8 - Exemplo de configuração de banco de dados utilizando uma DAO. Fonte: Adaptado de Android Deve-
lopers (2020).
AppDatabase:
Figura 9 - Exemplo de criação de AppDataBase. Fonte: Adaptado de Android Developers (2020).
Depois da criação desses arquivos, você obterá uma instância do banco de dados, criado 
usando o código da Figura 10.
Figura 10 - Exemplo de instanciação de banco de dados utilizando Room. Fonte: Adaptado de Android Developers 
(2020).
32www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
3. acesso aos recursos de dispositivos móveis
O Android Studio, segundo nos apresenta Lecheta (2015), pode abrir um projeto de cada 
vez e cada projeto poderá conter um ou mais módulos. 
A estrutura do projeto é mostrada na Figura 11, com a pasta do módulo app fechada. A 
pasta app representa o módulo padrão que é criado no projeto. O código-fonte e os arquivos de 
compilação específicos desse módulo ficam armazenados dentro da pasta app. Na raiz do projeto, 
existem os outros arquivos, como, por exemplo, o arquivo build.gradle geral do projeto, que vale 
para todos os módulos. O Quadro 1 apresenta essa estrutura com um descritivo associado.
Figura 11 - Estrutura de arquivos de um projeto. Fonte: O autor.
33www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Quadro 1 - Explicação dos arquivos que ficam na raiz do projeto. Fonte: Adaptado de Lecheta (2015).
Ao expandir a pasta app, você verá os arquivos referentes a esse módulo, e basicamente 
será aqui onde ficam os arquivos da aplicação. Por exemplo, na pasta /app/src/main/, estão os 
arquivos .java, .xml e imagens do aplicativo, conforme a Figura 12.
Podemos visualizar a estrutura de diretórios real do projeto, selecionando o item Project 
no combo de opções que fica localizado na parte esquerda superior da janela. Outra visualização 
muito boa é a do Android Studio, que mostra um resumo dos principais arquivos e deixa a 
visualização mais enxuta.
34www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Figura 12 - Estrutura de arquivos do projeto. Fonte: Adaptado de Lecheta (2015).
35www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Quadro 2 - Descrição dos arquivos do módulo app. Fonte: Adaptado de Lecheta (2015). 
36www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
Cada arquivo, continuando com Lecheta (2015), seja imagem ou XML, dentro da pasta 
/app/res contém uma referência na classe R, que será automaticamente gerada ao compilar o 
projeto. Cada vez que alterarmos, adicionarmos ou removermos um arquivo dessas pastas, a 
classe R será alterada para refletir as informações. O Quadro 2 apresenta um resumo dos arquivos 
do módulo app.
Caro(a) aluno(a), pensando em uma maneira para aprimorar o seu conhecimento 
sobre o desenvolvimento de aplicativos Android, trago como sugestão este artigo, 
que é uma introdução ao Ambiente de Desenvolvimento Integrado (IDE) Android 
Studio: Conheça o Android Studio, disponível em developer.android.com/studio/
intro. 
Caro(a) aluno(a)!
Para uma reflexão, deixo este pensamento de Dale Carnegie. Ele foi um dos 
maiores escritores e pensadores que ajudou, e ainda ajuda, centenas de milhares 
de pessoas a se desenvolverem com seu legado deixado há mais de 74 anos.
 
Deixo esta mensagem para que você possa chegar mais longe, buscando novos 
conhecimentos e que possa ter um desenvolvimento intelectual e moral.
“A pessoa que chega mais longe é geralmente aquela que está disposta a fazer 
e ousar. O barco seguro nunca vai muito longe da margem” (Dale Carnegie), 
disponível em https://citacoes.in/citacoes/608433-dale-carnegie-a-pessoa-que-
chega-mais-longe-e-geralmente-aquela/. 
• Título: Android - Aprenda a criar aplicações para dispositivos móveis com o 
Android SDK.
• Autor: Ricardo R. Lecheta.
• Editora: Novatec.
• Sinopse: “O Android é atualmente o sistema operacional móvel mais utilizado no 
mundo e está disponível para diversas plataformas, como smartphones, tablets, 
TV (Google TV), relógios (Android Wear), óculos (Google Glass) e carros (Android 
Auto). Este livro convida o leitor a mergulhar no incrível mundo do Android, onde a 
imaginação é o limite. 
37www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
A obra traz todos os passos necessários para desenvolver aplicativos para 
smartphones, tablets e relógios, desde o básico – sobre a instalação do emulador e 
configuração do ambiente de desenvolvimento no Android Studio – até aplicações 
que utilizem recursos avançados, como mapas, localização por GPS, multimídia, 
consulta em web services, persistência em banco de dados, sensores, execução 
de serviços em segundo plano e muito mais. Será desenvolvido um aplicativo 
completo passo a passo, conforme as boas práticas de desenvolvimento e 
interface e utilizando conceitos do Material”.
Fonte: Editora Novatec (2020).
Fonte: Butterfield (2017).
Título: Android Studio for Beginners Part 1.
Autor: Bill Butterfield. 
Ano: 2017.
Sinopse: este vídeo irá demonstrar:
1. Como configurar um projeto no Android Studio;
2. Como navegar dentro do Android Studio paraconstruir um 
aplicativo Android simples;
3. Como depurar e executar um aplicativo Android.
Disponível em: <www.youtube.com/watch?v=dFlPARW5IX8&ab_
channel=BillButterfield>.
38www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 2
EDUCAÇÃO A DistânCiA
consideraçÕes Finais
Caro(a) aluno(a)!
Chegamos ao final de nossos estudos da Unidade 2. Foi possível entender os conceitos 
dos principais componentes de uma aplicação. Vimos alguns termos de programação, como, por 
exemplo, variável, método e constante.
Vimos também os conceitos do Manifest.XML. Na Unidade 2, foi possível entender que 
o Manifest.XML contém muitas das configurações, como o nome do aplicativo, com o nome do 
pacote e os nomes da atividade e muito mais.
Foi possível estudar sobre as principais características da classe Activity e que ela faz 
referência à definição de design XML UI, quando for criada utilizando a linguagem de programação 
Java.
Foi possível também compreender os conceitos da persistência de dados no 
desenvolvimento para dispositivos móveis. Estudamos também o acesso aos recursos dos 
dispositivos móveis. Pudemos estudar sobre a estrutura do projeto, a localização da pasta do 
módulo, o código-fonte e seus arquivos e os arquivos de compilação específicos, juntamente com 
a descrição de cada componente de uma aplicação.
Aguardo você na Unidade 3.
Um grande abraço! E até lá!
3939www.uninga.br
unidade
03
sumário da unidade
introdução ............................................................................................................................................................ 41
1. comunicação e troca de dados com servidores web ...................................................................... 42
1.1 introdução ao Xml e ao json ..................................................................................................................... 42
1.2 o que é Xml? ..................................................................................................................................................... 42
1.3 declaração Xml ............................................................................................................................................. 43
1.4 Xml scHema .....................................................................................................................................................44
1.5 o que é json? ..................................................................................................................................................44
1.6 gerando json .................................................................................................................................................. 45
1.7 analisando json ............................................................................................................................................ 45
2. FrameworKs em programação para dispositivos móveis ............................................................ 47
2.1 react native ..................................................................................................................................................... 47
técnicas e Ferramentas para 
programação
Prof. ME. rICArDo VIEIrA
Ensino a distância
DISCIPLINA:
DESENVOLVIMENTO DE APLICATIVOS MÓVEIS
40www.uninga.br
2.1.1 beneFícios da utilização da plataForma nativa .............................................................................48
2.1.2 riscos e desvantagens do FrameworK react native ..................................................................48
2.2 Flutter ............................................................................................................................................................. 49
2.3 ionic .................................................................................................................................................................. 49
2.4 quasar ...............................................................................................................................................................50
2.5 Xamarin ............................................................................................................................................................50
3. programação web para dispositivos móveis ..................................................................................... 51
3.1 linguagem de programação Kotlin ....................................................................................................... 51
3.1.1 o que é Kotlin? .............................................................................................................................................. 51
3.2 linguagem de programação dart .......................................................................................................... 52
3.2.1 tudo é um objeto ........................................................................................................................................ 53
3.2.2 programa para uma interFace ............................................................................................................ 53
consideraçÕes Finais ........................................................................................................................................ 55
41www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
introdução
Caro(a) aluno(a)!
Esta unidade inicia os estudos da Comunicação e Troca de Dados com Servidores 
Web, trabalhando com algumas maneiras estruturadas de armazenar dados, sendo que, 
normalmente, os aplicativos usam documentos XML e JSON para armazenar e trocar 
informações. 
Veremos uma introdução ao XML, que significa eXtensible Markup Language 
e que é uma linguagem de marcação, pois usa “tags” simples para definir o que você 
deseja fazer.
Faremos também uma introdução ao Framework JSON (JavaScript Object 
Notation), que é um formato de dados usado frequentemente para trocar dados entre 
servidores e páginas da web, mas também poderá ser usado para comunicação servidor 
a servidor. Serão apresentadas as principais diferenças entre XML e JSON e suas 
particularidades.
Você verá também uma apresentação dos principais frameworks em programação 
para dispositivos móveis. Dentre os principais, destacamos o React Native, que é uma 
biblioteca Javascript para construir Interfaces de Usuário (UI). Apresentaremos também 
o Framework Flutter, que é a estrutura de UI portátil do Google para a construção de 
aplicativos modernos, nativos e reativos para iOS e Android.
Ao final da unidade, trataremos da programação web para dispositivos móveis. 
Abordaremos duas linguagens de programação utilizadas no Android Studio IDE para 
o desenvolvimento de aplicações para dispositivos móveis. Destacamos a linguagem 
de programação Kotlin, que é uma linguagem baseada em JVM desenvolvida pela 
JetBrains. E também abordaremos a linguagem Dart. A linguagem de programação 
Dart é uma linguagem de programação de propósito geral, que representa uma nova linguagem 
na tradição C.
Bons estudos!
42www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
1. comunicação e troca de dados com servidores web
O Android oferece algumas maneiras estruturadas de armazenar dados, notavelmente 
SharedPreferences e bancos de dados SQLite locais. E, é claro, você poderá armazenar seus dados 
“na nuvem” usando um serviço baseado na internet.
O Android permite, além disso, que você trabalhe com arquivos comuns antigos, sejam 
aqueles incorporados ao seu aplicativo (“ativos”) ou aqueles no chamado armazenamento interno 
ou externo.
Para fazer com que esses arquivos funcionem – e consumir dados da internet – você 
provavelmente precisará empregar um analisador. O Android possui várias opções para análise 
XML e JSON, alémde bibliotecas de terceiros. (MURPHY, 2019).
1.1 introdução ao Xml e ao json
Normalmente, os aplicativos usam documentos XML e JSON para armazenar e trocar 
dados. Apresentaremos, a seguir, uma breve introdução ao XML e ao JSON para aqueles que não 
estão familiarizados com essas tecnologias. 
Java oferece suporte a XML por meio de APIs como SAX, DOM, StAX, XPath e XSLT. O 
processamento Java JSON é controlado pelo JSR 374 (ou o JSR 353, mais antigo). No entanto, ele 
não faz parte do JSE, mas poderá ser encontrado no Java EE e no Jakarta EE, e poderá adicionar 
uma implementação na forma de uma biblioteca para que possa ser usado para o JSE também 
(SPATH; FRIESEN, 2020).
1.2 o que é Xml?
XML significa eXtensible Markup Language. O termo Extensível significa que você pode 
usá-lo para o que quiser. Na verdade, você poderia criar seu próprio conjunto de tags XML para 
qualquer finalidade que desejar. É uma linguagem de marcação, pois usa “tags” simples para 
definir o que você deseja fazer. A maioria de vocês estará familiarizada com outra linguagem 
de marcação chamada HTML5, ou Hypertext Markup Language V5, que é usada para criar sites 
HTML5 e, mais recentemente, para criar aplicativos HTML5.
As linguagens de marcação diferem das linguagens de programação, usam tags, que são 
parâmetros (também chamados de atributos ou características) dentro dessas tags e estruturas 
de aninhamento para realizar tarefas que linguagens de programação de alto nível, como Java 
8, implementam usando estruturas de programação complexas como matrizes de dados, loops 
lógicos e chamadas de método (JACKSON, 2017).
O XML (eXtensible Markup Language), segundo nos apresenta Spath e Friesen (2020), 
é uma metalinguagem (uma linguagem usada para descrever outras linguagens) para definir 
vocabulários (linguagens de marcação personalizadas), que é a chave para a importância e 
popularidade do XML. Vocabulários baseados em XML (como XHTML) permitem que você 
descreva documentos de uma forma significativa.
Documentos de vocabulário XML são como documentos HTML, no sentido de que são 
baseados em texto e consistem em marcação, que é a descrição codificada da estrutura lógica de 
um documento e conteúdo, que é o texto do documento não interpretado como marcação. A 
marcação será evidenciada por meio de tags – construções sintáticas delimitadas por colchetes 
angulares (<nome> </nome>) e cada tag terá um nome. Além disso, algumas tags possuem 
atributos (pares de valor de nome). 
43www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
Figura 1 - Receita baseada em XML para um sanduíche grelhado de queijo. Fonte: Adaptado de Spath e Friesen 
(2020).
A Figura 1 apresenta um documento XML que descreve uma receita para fazer um 
sanduíche de queijo grelhado. Esse documento é uma reminiscência de um documento HTML, 
pois consiste em tags, atributos e conteúdo. No entanto, é aí que termina a semelhança. Em vez de 
apresentar tags HTML como <html>, <head>, <img> e <p>, essa linguagem de receita informal 
apresenta suas próprias tags <recipe>, <ingredients> e outras (SPATH; FRIESEN, 2020).
1.3 declaração Xml
Um documento XML, continuando com Spath e Friesen (2020), geralmente começa com 
a declaração XML, uma marcação especial que informa a um analisador XML que o documento 
é XML. A ausência da declaração XML, na Figura 1, revela que essa marcação especial não é 
obrigatória. Quando a declaração XML está presente, nada pode aparecer antes dela. 
A declaração XML se parece minimamente com <? xml version = “1.0”?> em que o atributo 
de versão não opcional identifica a versão da especificação XML com a qual o documento está em 
conformidade. A versão inicial dessa especificação (1.0) foi introduzida em 1998 e é amplamente 
implementada.
O XML oferece suporte a Unicode, o que significa que documentos XML consistem 
inteiramente em caracteres tirados do conjunto de caracteres Unicode. Os caracteres do 
documento são codificados em bytes para armazenamento ou transmissão, e a codificação será 
especificada por meio do atributo de codificação opcional da declaração XML. Uma codificação 
comum é UTF-8, que é uma codificação de comprimento variável do conjunto de caracteres 
Unicode. UTF-8 é um superconjunto estrito de ASCII, o que significa que arquivos de texto 
ASCII puros também são documentos UTF-8.
44www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
1.4 Xml schema 
XML Schema é uma linguagem gramatical para declarar a estrutura, o conteúdo e a 
semântica de um documento XML. Os documentos gramaticais dessa linguagem são conhecidos 
como esquemas que são, eles próprios, documentos XML. Os esquemas devem estar em 
conformidade com o XML Schema DTD. 
O XML Schema fornece uma abordagem orientada a objetos para declarar a gramática de 
um documento XML. O XML Schema pré-define 19 tipos primitivos, que são expressos por meio 
dos seguintes identificadores: anyURI, base64Binary, boolean, date, dateTime, decimal, double, 
duration, float, hexBinary, gDay, gMonth, gMonthDay, gYear, gYearMonth, NOTATION, QName, 
String e time (SPATH; FRIESEN, 2020).
1.5 o que é json? 
JSON (JavaScript Object Notation), ainda como mostram Spath e Friesen (2020), é um 
formato de dados usado, frequentemente, para trocar dados entre servidores e páginas da web, 
mas também poderá ser usado para comunicação servidor a servidor. As principais diferenças 
entre XML e JSON são as seguintes:
•	 Em JSON, nenhuma tag será usada; os elementos do contêiner são delimitados por {} 
(objetos com elementos filhos) e [] (matrizes).
•	 Os elementos JSON não poderão ter atributos.
•	 JSON não possui um conceito de namespace.
•	 JSON não possui um mecanismo de validação.
Um documento JSON normalmente se refere a um objeto raiz, denotado por um par {} 
circundante e tem a aparência apresentada na Figura 2.
Figura 2 - Exemplo de um documento JSON. Fonte: Adaptado de Spath e Friesen (2020).
45www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
Você pode ver que os elementos do objeto seguem um “nome”: sintaxe de valor, enquanto 
o conteúdo de uma matriz é apenas uma lista separada por vírgulas. Os números são permitidos e 
apenas inseridos literalmente. Como valores booleanos, podemos usar verdadeiro e falso, e nulo 
denota “não especificado” ou “desconhecido”.
1.6 gerando json
Com todos os JARs de biblioteca de vinculação e processamento JSON adicionados, 
podemos criar arquivos JSON. Para isso, devemos usar o padrão builder, como mostra a Figura 3.
Figura 3 - Exemplo de criação de um arquivo JSON usando o padrão builder. Fonte: Adaptado de Spath e Friesen 
(2020).
1.7 analisando json
Continuando com Spath e Friesen (2020), para converter um String JSON em um objeto 
Java usando JSON-P e JSONB, você tem duas opções. Você pode converter uma String JSON em 
uma representação de árvore de objetos Java genérica ou pode realizar uma conversão em uma 
árvore de objeto com classes Java predefinidas. 
Vamos, primeiramente, criar uma árvore de objetos genéricos a partir de JSON. Não 
precisamos de JSONB para isso e o procedimento é basicamente este descrito na Figura 4.
46www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
Figura 4 - Criação de uma árvore de objetos genéricos a partir de JSON. Fonte: Adaptado de Spath e Friesen (2020).
Em vez de um Reader, você também pode usar um InputStream como fonte para os dados 
JSON, como mostra a Figura 5, de uma URL:
Figura 5 - Criação de um leitor de fonte de dados JSON, usando um ImputStream. Fonte: Adaptado de Spath e 
Friesen (2020).
Para gerar uma árvore de objetos com classes Java predefinidas, o procedimento será 
criar uma instância Jsonb e então usar seu método fromJson (), da forma apresentada na Figura 6:
47www.uninga.brDE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
Figura 6 - Criação de uma árvore de objetos com classes Java predefinidas a partir do método fromJson (). Fonte: 
Adaptado de Spath e Friesen (2020).
2. FrameworKs em programação para dispositivos móveis
2.1 react native
React é uma biblioteca Javascript para construir interfaces de usuário (UI). Criado pelo 
Facebook em 2013, foi recebido com entusiasmo por uma ampla comunidade de desenvolvedores. 
Os adotantes corporativos incluem Netflix, Yahoo!, Github e Codecademy. Os usuários elogiam 
o React por seu desempenho e flexibilidade, bem como sua abordagem declarativa baseada em 
componentes para construir interfaces de usuário. O React foi projetado para as necessidades da 
equipe de desenvolvimento do Facebook e, portanto, é particularmente adequado para aplicativos 
da web complexos que lidam fortemente com a interação do usuário e dados variáveis.
48www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
Em janeiro de 2015, a equipe React anunciou um novo projeto: o Framework React 
Native. O Framework React Native usa o React para almejar plataformas diferentes do navegador, 
como iOS e Android, implementando uma chamada “ponte” entre Javascript e a plataforma host. 
Ele promete aos desenvolvedores da web a capacidade de escrever de verdade, renderizando 
nativamente aplicativos móveis, tudo no conforto de uma biblioteca Javascript que eles já 
conhecem e adoram (EISENMAN, 2015).
2.1.1 Benefícios da utilização da plataforma nativa
O Framework React Native oferece os benefícios do desenvolvimento nativo e permite 
que o desenvolvedor aproveite qualquer plataforma para a qual esteja desenvolvendo. Isso inclui 
animações e elementos da UI, bem como APIs específicas da plataforma, como geolocalização 
ou rolo da câmera.
Podemos comparar isso com as soluções móveis de plataforma cruzada existentes. Muitos 
deles permitem que você desenvolva componentes de navegador mal disfarçados, que permitem 
implementar novamente partes da UI nativa. Normalmente, será impossível replicar totalmente 
os elementos nativos da UI e, como resultado, aspectos de seu aplicativo, como animações e 
estilos, podem parecer desajeitados ou apenas menos do que naturais. O Framework React Native 
permite que você contorne facilmente esse problema.
Em comparação com o desenvolvimento de aplicativos móveis tradicionais, o React 
Native não tem exatamente o mesmo acesso à sua plataforma host. Há uma pequena camada 
de complexidade adicional no uso de APIs ainda não suportadas pelo React Native core, por 
instância, e APIs síncronas, em particular, representam um desafio (EISENMAN, 2015).
2.1.2 riscos e desvantagens do framework react Native 
O maior risco que vem com o uso do Framework React Native está relacionado ao seu 
nível de maturidade. Como um projeto jovem, Framework React Native inevitavelmente conterá 
sua cota de bugs e implementações não otimizadas. Esse risco será um pouco compensado por 
sua comunidade. Afinal, o Facebook está usando o Framework React Native na produção, e as 
contribuições da comunidade estão ocorrendo em um bom ritmo. No entanto, trabalhar com 
tecnologia de ponta significa que você pode esperar alguns cortes de papel ao longo do caminho.
Da mesma forma, ao usar o Framework React Native, você confia muito em uma biblioteca 
que não é necessariamente endossada pela plataforma host na qual está trabalhando. Como a 
equipe Native pode não ser capaz de coordenar com a Apple, por exemplo, podemos imaginar 
que os novos lançamentos do iOS podem exigir um tempo maior para fazer a biblioteca React 
Native funcionar. Para a maioria das plataformas, no entanto, essa deve ser uma preocupação 
relativamente menor.
A outra grande desvantagem é o que acontece quando você encontra uma limitação no 
React Native. Digamos que você queira adicionar suporte para uma API de plataforma host ainda 
não incorporada à biblioteca principal React Native. Se você é um desenvolvedor que se sente 
confortável apenas com Javascript, há uma curva de aprendizado não trivial para adicionar esse 
suporte sozinho (EISENMAN, 2015).
49www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
2.2 Flutter
Flutter é a estrutura de UI portátil do Google para a construção de aplicativos modernos, 
nativos e reativos para iOS e Android. O Google também está trabalhando na incorporação de 
desktop Flutter e Flutter para a web (Hummingbird) e dispositivos incorporados (Raspberry Pi, 
doméstico, automotivo e mais). Flutter é um projeto de código aberto hospedado no GitHub com 
contribuições do Google e da comunidade. 
O Flutter usa a linguagem de programação Dart, que é uma linguagem moderna Orientada 
a Objeto que compila para código ARM nativo e código JavaScript pronto para produção. O Flutter 
usa o mecanismo de renderização 2D Skia, que funciona com diferentes tipos de plataformas de 
hardware e software e também é usado pelo Google Chrome, Chrome OS, Android, Mozilla 
Firefox, Firefox OS e outros. 
Dart é a linguagem que você usará para desenvolver seus aplicativos Flutter. Mais à frente, 
ainda nesta unidade, serão apresentados mais detalhes sobre essa linguagem de programação. O 
Dart é compilado com antecedência (AOT) em código nativo, tornando seu aplicativo Flutter 
mais rápido. O Dart também é compilado em just-in-time (JIT), tornando-o rápido para exibir 
suas alterações de código. Por meio do recurso de atualização “à quente”, não é necessário derrubar 
o serviço para realizar sua atualização.
O Flutter usa a linguagem de programação Dart para criar sua interface de usuário, 
eliminando a necessidade de usar linguagens separadas, como marcação ou designers visuais. 
Flutter é declarativo; em outras palavras, constrói a UI para refletir o estado do aplicativo. Quando 
o estado (dados) mudar, a UI será redesenhada e o Flutter construirá uma nova instância do 
widget. 
Os aplicativos feitos no Flutter são construídos a partir de uma única base de código; 
são compilados para o código ARM nativo, usam a unidade de processamento gráfico (GPU) e 
podem acessar APIs iOS e Android específicas (como localização GPS, biblioteca de imagens) 
comunicando-se por meio de canais de plataforma (NAPOLI, 2020). 
Além dos frameworks React Native e do Flutter, apresentaremos a seguir alguns frameworks 
que possuem comunidades ativas e que também são open sources.
2.3 ionic 
O Ionic Framework é um SDK de código aberto completo, muito utilizado para o 
desenvolvimento de aplicativos móveis híbridos. Ele fornece ferramentas e serviços para o 
desenvolvimento de aplicativos móveis híbridos usando tecnologias da web como CSS, HTML5 
e Sass. Os aplicativos podem ser construídos com essas tecnologias da web e, em seguida, 
distribuídos por meio de lojas de aplicativos nativos para serem instalados nos dispositivos, 
aproveitando o Cordova.
Esse framework é totalmente gratuito e de código aberto, licenciado pelo MIT e 
desenvolvido por uma grande comunidade mundial. Eles têm mais de 120 recursos de dispositivos 
nativos, como Bluetooth, HealthKit, autenticação de impressão digital e muito mais com plug-ins 
Cordova/PhoneGap e extensões TypeScript. Esse framework permite ao desenvolvedor mobile usar 
sua API para criar, construir, testar e implantar seus aplicativos Ionic em qualquer plataforma. 
O Ionic Framework tem o pacote de ícones Ionicons com centenas dos ícones de 
aplicativos mais comuns. O desenvolvedor poderá desenvolver seus aplicativos pelo Live Reload. 
O framework possui recursos mais úteis, como links diretos, compilação de AoT e uma API de 
animações personalizadas. O Framework Ionic é independente e tem suporte oficial para React, 
Preact, Angular e Vue, bem como para Web Components (ionicframework.com).
50www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CATI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
2.4 quasar
O Quasar Framework é alimentado por Vue.js e permite aos desenvolvedores escrever 
código uma única vez e implantar simultaneamente como um site, para os seguintes formatos:
•	 SPA (Single Page Application/Website);
•	 SSR (Server-side Rendered App/Website);
•	 PWA (Progressive Web App);
•	 BEX (Browser Extensions);
•	 Mobile App (through Cordova);
•	 Electron App.
Tudo isso usando uma única base de código.
O Quasar Framework traz uma interface de usuário de última geração, seguindo as 
diretrizes de materiais do Google. Ele também oferece minimização de HTML / CSS / JS, quebra 
de cache, tree shaking, sourcemapping, code-splitting & lazy loading, ES6 transpiling, Linting code e 
recursos de acessibilidade, enquanto mantém uma pequena sobrecarga de desempenho.
Com a Quasar CLI (Common Language Infrastructure), os desenvolvedores também se 
beneficiam de recursos adicionais, como hot-reloading. Um dos benefícios mais elogiados do 
framework é sua documentação muito completa e comunidade ativa.
O Quasar Framework é totalmente gratuito, de código aberto e licenciado pelo MIT 
(quasar.dev).
2.5 Xamarin
O Xamarin é uma empresa de software de propriedade da Microsoft com sede em São 
Francisco, Califórnia, fundada em maio de 2011, que tem implementações de plataforma cruzada 
da Common Language Infrastructure (CLI) e Common Language Especificações (frequentemente 
chamadas de Microsoft .NET).
Com uma base de código compartilhada C#, os desenvolvedores podem usar as ferramentas 
do Xamarin Framework para escrever aplicativos nativos para Android, iOS e Windows com 
interfaces de usuário nativas e compartilhar código em várias plataformas, incluindo Windows 
e MacOS. 
O Xamarin é o melhor framework de desenvolvimento de aplicativos móveis híbridos. Ele 
economiza seu tempo em relação à reutilização de habilidades, ferramentas, equipes e a melhor 
parte significativa é o código. Você pode influenciar a variedade de APIs Xamarin e Android, bem 
como projetar uma experiência incrível para vidro com o Android SDK e GDK (docs.microsoft.
com).
51www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
3. programação web para dispositivos móveis
3.1 linguagem de programação Kotlin
As coisas estão mudando para os desenvolvedores Android. A equipe do Android 
anunciou, durante o Google I/O 2017, que Kotlin seria uma linguagem oficial, para desenvolver 
aplicativos Android. Isso significa que, embora ainda seja possível desenvolver aplicativos 
Android usando Java, a partir de agora, a linguagem de programação Kotlin será totalmente 
compatível e o Google se certificará de que todos os novos recursos do Android, a estrutura, o 
IDE e todas as suas bibliotecas funcionem perfeitamente com a nova linguagem.
O Google ouviu a comunidade, que há anos pedia para que o Kotlin se tornasse uma 
língua primária. Agora podemos aproveitar todos os recursos de uma linguagem moderna 
enquanto desenvolvemos o Android.
3.1.1 o que é Kotlin?
Kotlin é uma linguagem baseada em JVM desenvolvida pela JetBrains, uma empresa 
conhecida por criar IntelliJ IDEA, um poderoso IDE para Java. O Android Studio, o IDE oficial 
do Android, é baseado no IntelliJ.
Kotlin foi criado com os desenvolvedores Java em mente e com IntelliJ como seu principal 
IDE de desenvolvimento. E esses são dois recursos muito interessantes para desenvolvedores 
Android:
•	 Kotlin é muito intuitivo e fácil de aprender para desenvolvedores Java. A maioria das 
partes da linguagem é muito semelhante ao que já conhecemos, e as diferenças nos 
conceitos básicos podem ser aprendidas em pouco tempo.
•	 O Android Studio pode entender, compilar e executar o código Kotlin. E o suporte para 
essa linguagem vem da empresa que desenvolve o IDE.
Mas isso está relacionado apenas ao modo como a linguagem se integra às nossas 
ferramentas. Quais são as vantagens da linguagem em relação ao Java 6?
•	 Menos verboso: esta é uma de suas qualidades mais importantes. Você pode escrever 
mais com muito menos código.
•	 Mais seguro: o Kotlin é seguro para nulos, o que significa que lidamos com possíveis 
situações nulas em tempo de compilação, para evitar exceções de tempo de execução. 
Precisamos especificar explicitamente que um objeto pode ser nulo e, em seguida, verificar 
sua nulidade antes de usá-lo. O desenvolvedor economiza muito tempo depurando 
exceções de ponteiro nulo e corrigindo bugs de nulidade.
•	 Funcional: Kotlin é basicamente uma linguagem orientada a objetos, não uma linguagem 
funcional pura. No entanto, como muitas outras linguagens modernas, ela usa muitos 
conceitos de programação funcional, como expressões lambda, para resolver alguns 
problemas de uma maneira muito mais fácil. Outra característica interessante é a maneira 
como lida com as coleções.
52www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
•	 Faz uso de funções de extensão: isso significa que podemos estender qualquer classe 
com novos recursos, mesmo se não tivermos acesso ao código-fonte.
•	 Altamente interoperável: você pode continuar usando a maioria das bibliotecas e 
dos códigos escritos em Java, porque a interoperabilidade entre as duas linguagens é 
excelente. Será até possível criar projetos mistos, com a coexistência de arquivos Kotlin e 
Java (LEIVA, 2019).
Nas Figuras 7 e 8, está um exemplo de como você poderia escrever um programa “Hello 
world!” em Java e, em seguida, em Kotlin.
Figura 7 - Criando um Hello Word com a linguagem Java. Fonte: Adaptado de Fordham (2017).
Figura 8 - Criando um Hello Word com a linguagem Kotlin. Fonte: Adaptado de Fordham (2017). 
3.2 linguagem de programação dart
A linguagem de programação Dart Sass (Syntactically Awesome Style Sheets) foi 
desenvolvida para pessoas que desejam criar rapidamente estilos CSS válidos para uso em sites. 
Originalmente escrito em Ruby e lançado em 2006, essa nova versão foi reescrita do zero para ser 
mais rápida e simples de usar, mas ainda mantém os mesmos recursos que os usuários do Sass 
passaram a conhecer e amar.
Dart Sass é para o desenvolvedor que deseja aprender como aproveitar rapidamente o 
poder do Sass para produzir código de folha de estilo válido, em que há pressão para produzir 
resultados rapidamente. É perfeito para desenvolvedores em equipes Ágil, em que o tempo é 
essencial, ou para desenvolvedores interessados em construir estilos reutilizáveis para ajudar 
a economizar tempo de desenvolvimento e recursos para projetos presentes e futuros (LIBBY, 
2019).
Dart é uma linguagem de programação de propósito geral. É uma nova linguagem 
na tradição C, projetada para ser familiar à grande maioria dos programadores. O exemplo 
obrigatório “Hello World”, ilustrado na Figura 9, mostra como a sintaxe do Dart é familiar.
Figura 9 - Apresentação de um Hello Word em linguagem Dart. Fonte: Adaptado de Bracha (2015). 
O Dart é puramente orientado a objetos, baseado em classes, opcionalmente tipado e 
suporta herança baseada em mixin (forma de implementar determinados métodos somente para 
alguns filhos, e não para todos dentro do conceito de herança) e simultaneidade de ator (modelo 
matemático para computação concorrente) (BRACHA, 2015).
53www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
3.2.1 Tudo é um objeto
O Dart é uma linguagem puramente orientada a objetos. Isso significa que todos os 
valores que um programa Dart manipula em tempo de execução são objetos – até mesmo dados 
elementares, como números e booleanos. Não há exceções.
Insistir no tratamento uniforme de todos os dados simplifica as coisas para todos os 
envolvidos com a linguagem: designers, desenvolvedores e o mais importante, usuários.
Por exemplo, as classes de coleção podem ser usadas para todos os tipos de dados, e 
ninguémprecisa se preocupar com questões de autoboxing e unboxing. Um papel fundamental de 
uma linguagem de programação é aliviar os desenvolvedores de tal carga cognitiva.
Talvez surpreendentemente, a adoção de um modelo de objeto uniforme também facilita 
a tarefa do desenvolvedor do sistema (BRACHA, 2015).
3.2.2 Programa para uma interface
A ideia de que o que importa sobre um objeto é como ele se comporta, em vez do modo 
como foi implementado, será o princípio central da programação orientada a objetos. Dart 
trabalha muito para preservar esse princípio de várias maneiras, embora o faça de maneira 
imperfeita.
•	 Os tipos de Dart são baseados em interfaces, não em classes. Como regra, qualquer 
classe pode ser usada como uma interface a ser implementada por outras classes, 
independentemente de as duas compartilharem a implementação.
•	 Não existem métodos finais no Dart. O Dart permite a substituição de quase todos os 
métodos.
•	 O Dart abstrai da representação do Objeto, garantindo que todo o acesso ao estado seja 
mediado por Métodos de Acesso.
•	 Os construtores do Dart permitem o armazenamento em cache ou a produção de 
instâncias de subtipos, portanto, o uso de um construtor não vincula ninguém a uma 
implementação específica (BRACHA, 2015).
Caro(a) aluno(a), trago para você, como meio de aprimorar o seu desenvolvimento 
sobre as linguagens de programação para aplicativos Android, a seguinte 
sugestão: um artigo publicado pela comunidade Android Developers, que trata 
sobre o desenvolvimento de Apps utilizando a linguagem de programação Kotlin: 
Desenvolver apps para Android com o Kotlin, disponível em <https://developer.
android.com/kotlin>. 
“Escreva apps Android, melhores e mais rapidamente com o Kotlin. 
Kotlin é uma linguagem de programação moderna e estaticamente 
‘tipada’, usada por mais de 60% dos desenvolvedores Android 
profissionais que ajuda a estimular a produtividade, a satisfação 
do desenvolvedor e a segurança do código”.
54www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
Caro(a) aluno(a)!
Para uma reflexão, deixo este pensamento do escritor Mario Sergio Cortella sobre 
a importância do propósito. Espero que sirva de incentivo e de alerta para que não 
vivamos de maneira autômata, sem propósito e sem objetivos claros.
Uma vida pequena é aquela que nega a vibração da própria 
existência. O que é uma vida banal, uma vida venal? É quando se 
vive de maneira automática, robótica, sem uma reflexão sobre 
o fato de existirmos e sem consciência das razões pelas quais 
fazemos o que fazemos (CORTELLA, 2016).
Título: Flutter na prática: melhore seu 
desenvolvimento mobile com o SDK open source 
mais recente do Google.
• Autor: Frank Zammetti.
• Editora: Novatec Editora/Apress.
• Sinopse: saiba o que o Flutter tem para 
oferecer, de onde ele veio e para onde vai. Flutter 
na Prática lhe dará uma base sólida de como 
construir aplicativos com o Flutter, e será um 
trampolim para a criação de aplicativos mais 
avançados por sua própria conta. Após a leitura 
desse material, uma jornada maior começará à 
medida que você entrar, mais bem preparado, 
no imenso universo do desenvolvimento com 
o Flutter, abordando com firmeza qualquer 
projeto com o qual deparar. Flutter na Prática é 
uma aventura de aprendizado que não deve ser 
perdida.Fonte: Editora Novatec (2020).
55www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 3
EDUCAÇÃO A DistânCiA
consideraçÕes Finais
Caro(a) aluno(a)!
Chegamos ao final desta unidade, com muita satisfação de tê-lo aqui conosco. Nós vimos 
juntos, nesta unidade, os estudos da Comunicação e Troca de Dados com Servidores Web.
Vimos e estudamos uma introdução ao XML, que é uma linguagem de marcação, que 
utiliza tags simples para definir o que você deseja fazer.
Vimos também uma introdução ao Framework JSON (JavaScript Object Notation), que é 
um formato de dados usado para trocar dados entre servidores e páginas da web, mas também 
poderá ser usado para comunicação servidor a servidor. 
Apresentamos dois frameworks em programação para dispositivos móveis: o React Native, 
que é uma biblioteca Javascript para construir interfaces de usuário (UI), e o framework Flutter, 
que é a estrutura de UI portátil do Google para a construção de aplicativos modernos, nativos e 
reativos para iOS e Android.
Agora que você chegou até aqui, faço um convite especial. Vamos entrar na reta final! 
Espero você na Unidade 4.
Um abraço! E até lá!
Fonte: The Net Ninja (2019).
Título: Flutter Tutorial for Beginners.
Autor: The Net Ninja.
Ano: 2019.
Sinopse: neste tutorial do Flutter para iniciantes, faz-se uma rápida introdução 
ao curso e ao próprio Flutter, uma prévia do que estaremos construindo e será 
mostrado como instalar o Flutter no seu computador.
5656www.uninga.br
unidade
04
sumário da unidade
introdução ............................................................................................................................................................ 58
1. aplicaçÕes Híbridas ....................................................................................................................................... 59
1.1 o que é desenvolvimento de aplicativos Híbridos? ......................................................................... 59
1.2 aplicativo móvel nativo ............................................................................................................................. 59
1.3 aplicativo web ...............................................................................................................................................60
1.4 aplicativos Híbridos ....................................................................................................................................60
1.5 vantagens do aplicativo Híbrido ............................................................................................................ 61
1.6 desvantagens do aplicativo Híbrido..................................................................................................... 62
2. publicação de aplicativos em lojas eletrÔnicas .............................................................................. 62
2.1 implantando seu aplicativo na google play store ......................................................................... 62
2.2 publicação de seus aplicativos .............................................................................................................. 62
aplicaçÕes Híbridas e publicaçÕes
Prof. ME. rICArDo VIEIrA
Ensino a distância
DISCIPLINA:
DESENVOLVIMENTO DE APLICATIVOS MÓVEIS
57www.uninga.br
2.3 controle de versão do seu aplicativo ................................................................................................ 63
2.4 preparação do arquivo .apK ................................................................................................................... 63
2.5 lvl - serviço de licenciamento android ............................................................................................ 64
2.6 como testar seu aplicativo ..................................................................................................................... 64
2.7 tornando-se um editor.............................................................................................................................. 64
2.8 regras a serem seguidas .......................................................................................................................... 65
2.9 enviando seus aplicativos para o google play ................................................................................ 66
consideraçÕes Finais ........................................................................................................................................ 70
58www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
introdução
Caro(a) aluno(a)!
Esta unidade inicia os estudos com uma breve introdução ao conceito do Desenvolvimento 
de Aplicativos Híbridos. Será visto, aqui, que os aplicativos híbridos são uma mistura de soluções 
nativas com soluções web. Será visto também que o desenvolvimento de um aplicativo móvel 
nativo exige ferramentas específicas. 
Você verá, nesta unidade, as vantagens do desenvolvimento de um App Híbrido, como, 
por exemplo, o fato de você poder construir seu aplicativo uma vez e implantá-lo em várias 
plataformas. Eles possuem facilidade e rapidez no desenvolvimento, sem que haja a necessidade 
de reconstruí-los constantemente para visualizar. 
Será estudado a respeito de como fazer a publicação de aplicativos em lojas eletrônicas. 
Vamos acompanhar, passo a passo, como publicar seu app na loja do Google, a Play Store; 
como fazer o controle de versões, de sua aplicação; como fazer a preparação do arquivo .Apk. 
Você poderá ver que existem algumas regras importantes a serem seguidas para se fazer uma 
publicação de um app na Play Store.
Falta pouco! Você chegou à reta final, com muito esforço e muita dedicação!
Então, vamos nos manter firmes, porque só falta um pouquinho!
Bons estudos!
59www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
1. aplicaçÕes Híbridas
1.1 o que é desenvolvimento de aplicativos Híbridos?
Os aplicativos híbridos são uma mistura de soluções nativas e da web, em que o núcleo 
do aplicativo será escrito usando tecnologias da web. Assim, essa é a origem do nome “híbrido”. 
 Ao escolher sua solução para começar a criar um novo aplicativo móvel, geralmente 
o desenvolvedor se depara com uma ampla gama de opções, mas não tem certeza por onde 
começar.  Muitos questionamentos surgem de imediato, como: construir seu aplicativo 
exclusivamente com soluções nativas ou usar uma solução híbrida? A equipe de desenvolvimento 
deve olhar apenas para tecnologias da web? Se escolhermos a solução híbrida, qual das várias 
tecnologias existentes será a melhor para meu projeto? 
Quando iniciar o processo, será importante lembrar que escolher a solução certa para sua 
aplicação dependerá de vários fatores (ionicframework.com): 
•	 Seu orçamento; 
•	 O cronograma; 
•	 A experiência de sua equipe com a tecnologia; 
•	 Seu público-alvo.
1.2 aplicativo móvel nativo
Quando as pessoas falam de um aplicativo móvel nativo, geralmente estão se referindo 
a um aplicativo que foi escrito usando a linguagem de desenvolvimento nativa e ferramentas 
específicas para essa plataforma. Podemos usar como exemplo: um aplicativo iOS nativo deverá 
ser escrito em Swift ou Objective-C e compilado usando Xcode, enquanto um aplicativo Android 
nativo deverá ser desenvolvido usando a linguagem de programação Kotlin ou Java e é compilado 
usando Android Studio.
Como esses aplicativos são desenvolvidos usando as soluções padrão da plataforma, os 
desenvolvedores têm acesso total e mais fácil aos recursos do dispositivo; como todos os sensores 
do dispositivo, à agenda de endereços do usuário e qualquer que seja a última e mais recente 
tecnologia que o telefone possa oferecer.
 Os aplicativos nativos também tendem a ter mais desempenho, já que seu código está 
mais próximo do hardware.  Além de ser mais rápido, o desenvolvedor também terá acesso a 
todos os controles e layouts da UI nativa. Além disso, o desenvolvedor pode desejar estilizá-los 
de acordo com o tema de seus aplicativos.
No entanto, qualquer aplicativo escrito para iOS usando Swift não poderá ser executado 
no Android e vice-versa. O desenvolvedor deverá fazer uma codificação especificamente para 
cada plataforma, o que poderá levar a um orçamento e tamanho de equipe maiores, supondo que 
deseje lançar seu aplicativo para iOS e Android. 
Outra implicação que ocorrerá com seu aplicativo é que ele está disponível apenas nas 
lojas de aplicativos de cada plataforma, sujeitando-se às respectivas regras e restrições.  Isso 
significa que, para cada versão, seja um novo recurso ou uma correção de bug, o mesmo processo 
de aprovação deverá ocorrer. Isso poderá levar de um dia a duas semanas para a Apple App Store. 
(ionicframework.com).
60www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
1.3 aplicativo web
Existem histórias de aplicativos de primeira linha que entraram em conflito com a 
regulamentação e foram removidos das lojas de aplicativos e, com isso, ocasionou perda de 
receita. Por essa razão, alguns desenvolvedores passaram a criar um aplicativo somente para a 
web, o que lhes dá a liberdade de existir fora das lojas de aplicativos e de oferecer seus aplicativos 
a outros usuários móveis e de desktop. 
Esses são apenas aplicativos web tradicionais escritos em HTML, CSS e JavaScript para os 
quais o desenvolvedor poderá aproveitar uma ampla variedade de estruturas e bibliotecas, como 
Angular, React, Vue ou mesmo JavaScript simples (ionicframework.com).
1.4 aplicativos Híbridos
Um aplicativo híbrido é um aplicativo móvel que contém uma instância isolada do 
navegador, geralmente chamada de WebView, para executar um aplicativo da web dentro de 
um aplicativo nativo. Ele usa um wrapper de aplicação nativa, que poderá se comunicar com a 
plataforma do dispositivo nativo e o WebView. Isso significa que os aplicativos da web poderão 
ser executados em um dispositivo móvel e ter acesso ao dispositivo, como a câmera ou recursos 
de GPS.
Ferramentas que facilitam a comunicação entre o WebView e a plataforma nativa tornam 
possíveis aplicativos híbridos. Essas ferramentas não fazem parte das plataformas iOS ou Android 
oficiais, mas são ferramentas de terceiros, como o Apache Cordova, Ionic, React Native, Xamarin, 
Flutter, AngularJS e muitos outros. Quando um aplicativo híbrido é compilado, seu aplicativo da 
web se transforma em um aplicativo nativo (WILKEN, 2016). 
Essa solução é uma mistura de soluções nativas e web. O núcleo do aplicativo é escrito 
usando tecnologias da web (HTML, CSS e JavaScript), que são então encapsuladas em um 
aplicativo nativo.  Por meio do uso de plug-ins, esses aplicativos podem ter acesso total aos 
recursos do dispositivo móvel. Para entender melhor essa abordagem, vamos analisar como tudo 
se encaixa.
Figura 1 - Representação de uma aplicação híbrida. Fonte: Adaptado de Ionic Framework (2020). 
61www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
Como pode ser visto na Figura 1, o coração de um aplicativo híbrido-móvel ainda é 
apenas um aplicativo escrito em HTML, CSS e JavaScript. No entanto, em vez de o aplicativo 
ser mostrado no navegador do usuário, ele é executado a partir de um aplicativo nativo e de 
seu próprio navegador integrado, que é essencialmente invisível para o usuário. Por exemplo, 
um aplicativo iOS usaria WKWebView para exibir um aplicativo, enquanto no Android usaria o 
elemento WebView para fazer a mesma função.
A única coisa a ser levada em consideração é o fato de que a aplicação híbrida ainda 
estará sendo executada no navegador nativo do dispositivo. Nesse caso, poderemos encontrar 
problemas de desempenho ou outras peculiaridades específicas de cada plataforma ou versão 
operacional (ionicframework.com).
No Quadro 1, é apresentada uma lista comparativa entre as principais características de 
um aplicativo e a relação dela com aplicações desenvolvidas de forma nativa, web e híbrida.
Quadro 1 - Principais recursos de uma aplicação nativa, web e híbrida. Fonte: Adaptado de Ionic Framework (2020).
1.5 vantagens do aplicativo Híbrido
Aplicativos híbridos, segundo nos apresenta Wilken (2016), possuem algumas vantagens 
sobre sites móveis e aplicativos nativos que tornam os aplicativos híbridos uma ótima plataforma 
para a construção de aplicativos:
•	 Plataforma Cruzada: você pode construir seuaplicativo uma vez e implantá-lo em várias 
plataformas com o mínimo de esforço.
•	 Mesmas Habilidades do Desenvolvimento da Web: elas permitem que você crie 
aplicativos móveis usando as mesmas habilidades já utilizadas para desenvolver sites e 
aplicativos da web.
•	 Acesso ao Dispositivo: Como o WebView é empacotado em um aplicativo nativo, seu 
aplicativo tem acesso a todos os recursos do dispositivo disponíveis para um aplicativo 
nativo.
•	 Facilidade de Desenvolvimento: eles possuem facilidade e rapidez no desenvolvimento, 
sem que haja a necessidade de reconstruí-los constantemente para visualizar. O 
desenvolvedor também tem acesso às mesmas ferramentas de desenvolvimento usadas 
para construir sites.
62www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
Os aplicativos híbridos fornecem uma base robusta para o desenvolvimento de aplicativos 
móveis, mas ainda permitem que se use a plataforma da web. O desenvolvedor poderá construir a 
maior parte do seu aplicativo como um site, mas sempre que precisar de acesso a uma API nativa, 
a estrutura de aplicativo híbrido fornecerá uma ponte para acessar essa API com JavaScript. Seu 
aplicativo poderá detectar deslizamentos, pinças e outros gestos, como cliques ou eventos de 
teclado. Mas existem algumas desvantagens, como é de se esperar (WILKEN, 2016).
1.6 desvantagens do aplicativo Híbrido
Os aplicativos híbridos têm algumas desvantagens devido às restrições colocadas em 
WebViews e às limitações das integrações nativas:
•	 Limitações do WebView: o aplicativo só pode ser executado tão bem quanto a instância 
do WebView, o que significa que o desempenho estará vinculado à qualidade do navegador 
da plataforma escolhida.
•	 Acesso a Recursos Nativos por Meio de Plug-Ins: o acesso às APIs nativas de que o 
desenvolvedor precisar poderá não estar disponível no momento e poderá exigir 
desenvolvimento adicional para fazer um plug-in para suportá-lo.
•	 Sem Controles de Interface de Usuário Nativos: sem uma ferramenta como Ionic, os 
desenvolvedores teriam que criar todos os elementos de interface de usuário (WILKEN, 
2016).
2. publicação de aplicativos em lojas eletrÔnicas
2.1 implantando seu aplicativo na google play store
Criar um ótimo aplicativo que as pessoas vão adorar é uma coisa, mas você também precisa 
de uma maneira fácil para que as pessoas o encontrem e baixem. O Google criou a Play Store para 
esse fim. A partir de um ícone diretamente no dispositivo, os usuários podem clicar diretamente 
na Play Store para navegar, pesquisar, revisar e baixar aplicativos. Os usuários também podem 
acessar a Play Store pela internet para fazer as mesmas coisas, embora o download não seja para 
o computador, mas sim os aplicativos são enviados diretamente para o dispositivo do usuário. 
Muitos aplicativos são gratuitos; para aqueles que não o são, a Play Store oferece mecanismos de 
pagamento para facilitar a compra (MACLEAN; KOMATINENI; ALLEN, 2015).
2.2 publicação de seus aplicativos
Para tornar a vida do desenvolvedor mais fácil, o Google fornece várias documentações, 
com o intuito de orientá-los a se preparar para lançar seus aplicativos por meio do portal 
developer.android.com/studio/publish/preparing.
A documentação de preparação para o desenvolvedor realizar o lançamento do app 
resume o que você precisará fazer:
63www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
•	 Como obter uma chave criptográfica para assinar digitalmente seu aplicativo, criando um 
ícone de aplicativo;
•	 Como incluir um Contrato de Licença de Usuário Final com seu aplicativo (opcional);
•	 Como criar controle de versão de seu aplicativo (por exemplo, 1.0, 2.3, 3.0);
•	 Como fazer a compilação de seu aplicativo para o lançamento;
•	 Como fazer os testes de versão de lançamento do seu aplicativo, em dispositivos Android. 
Antes de fazer a publicação do seu aplicativo, o desenvolvedor também deverá ler o 
documento Core App Quality, que está disponível em developer.android.com/docs/quality-
guidelines/core-app-quality.
2.3 controle de versão do seu aplicativo
É importante incluir um nome de versão (mostrado aos usuários) e um código de versão 
(um número de versão inteiro usado internamente pela Google Play) para seu aplicativo e 
considerar sua estratégia para numerar as atualizações. 
Por exemplo, o nome da primeira versão do seu aplicativo pode ser 1.0, as atualizações 
secundárias podem ser 1.1 e 1.2 e a próxima atualização principal pode ser 2.0. O código da 
versão é um número inteiro que normalmente começa em 1 e é incrementado em 1 para cada 
nova versão do seu aplicativo que você publica. 
Qual é a importância de se fazer o controle de versões?
•	 Os usuários precisam ter as informações específicas sobre a versão do aplicativo instalada 
no seu dispositivo e as versões de upgrade que estão disponíveis para instalação;
•	 Outros aplicativos precisam consultar o sistema para consultar a versão do seu aplicativo, 
com a finalidade de determinar a compatibilidade;
•	 Os serviços de publicação também podem conferir a versão do app para determinar a 
compatibilidade e estabelecer relações de upgrade/downgrade (developer.android.com).
2.4 preparação do arquivo .apk 
Para preparar seu aplicativo testado para upload – isto é, para criar o arquivo .apk para 
upload – você precisa criar uma exportação assinada de seu aplicativo. Isso pode ser feito de 
várias maneiras, mas a mais simples é usar os recursos integrados do IDE. Para Eclipse, clique 
com o botão direito do mouse no nome do projeto e escolha: Ferramentas → Android → Exportar 
pacote de aplicativos assinados. Para o Android Studio, você selecionaria o nome do projeto e 
escolheria o menu Build → Gerar APK assinado. Siga as caixas de diálogo para escolher uma chave 
de certificado de assinatura adequada e criar seu APK de produção (MACLEAN; KOMATINENI; 
ALLEN, 2015).
64www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
2.5 lvl - serviço de licenciamento android 
Devido à maneira como os aplicativos Android são desenvolvidos, eles se tornam alvos 
fáceis de pirataria. É possível fazer cópias de aplicativos Android e que poderão ser distribuídos 
para outros dispositivos. Mas qual será a maneira de garantir que os usuários que não compraram 
seu aplicativo não possam executá-lo? A equipe do Android criou algo chamado Biblioteca de 
Verificação de Licença (LVL), para atender a essa necessidade. Ela funciona da seguinte maneira:
•	 Se seu aplicativo foi baixado pela Google Play Store, então deverá haver uma cópia do 
aplicativo Google Play Store no dispositivo. 
•	 O aplicativo Google Play Store tem permissões elevadas para ler valores do dispositivo, 
como o nome da conta do usuário do Google, o IMSI e outras informações. 
•	 O aplicativo Google Play Store responderá a uma solicitação de verificação de licença de 
um aplicativo. 
O desenvolvedor faz chamadas para o LVL a partir de seu aplicativo, o LVL se comunica 
com o aplicativo Google Play Store, o aplicativo Google Play Store se comunica com os servidores 
do Google e seu aplicativo recebe uma resposta indicando se esse usuário, nesse dispositivo, está 
ou não licenciado para usar sua inscrição. Isso significa que o aplicativo deve ter sido comprado 
na Google Play Store; caso contrário, os servidores do Google não saberão sobre isso. 
Existem configurações sob seu controle, para decidir o que fazer, se a rede estiver 
indisponível. Uma descrição completa do processo de implementação de LVL pode ser encontrada 
em developer.android.com/google/play/licensing/overview (MACLEAN; KOMATINENI; 
ALLEN, 2015).
2.6 como testar seu aplicativo
O seu aplicativo deverá ser testado completamente, em dispositivos distintos. O aplicativo 
poderá funcionar perfeitamente, utilizando o emulador em seu Android Studio, maspoderão 
surgir problemas ao executá-lo em dispositivos Android específicos. 
O desenvolvedor poderá realizar os testes de seu aplicativo, utilizando o Firebase Test 
Lab, do Google, em uma ampla variedade de dispositivos. Para o desenvolvimento de testes do 
seu aplicativo, utilizando a plataforma Firebase Test Lab, basta acessar a plataforma em firebase.
google.com/docs/test-lab/ (DEITEL; DEITEL; WALD, 2016).
2.7 tornando-se um editor
Para o desenvolvedor publicar seu aplicativo, primeiramente precisará criar uma conta 
de desenvolvedor na Google Play. Para fazer isso, ele deverá criar uma conta de editor do Google 
Play Console.
A partir daqui, você pode clicar no botão “Iniciar” para iniciar o processo. Se ainda não 
tiver uma conta do Google, será solicitada a criação de uma. Para ser um editor, você também 
precisará fornecer um nome de desenvolvedor, um endereço de e-mail, um endereço de site da 
web e um número de telefone por meio do qual possa ser contatado. 
65www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
Figura 2 - Tela de login para o Google Console. Fonte: Google (2020).
Você poderá alterar esses valores posteriormente, assim que sua conta estiver configurada. 
Você também precisará pagar a taxa de inscrição. Para concluir a transação de pagamento, você 
precisará usar sua conta do Google.
Uma das opções apresentada ao desenvolvedor durante o processo de pagamento será: 
“Manter meu endereço de e-mail confidencial”. Isso se refere à transação atual entre você e a 
Google Play Store para adquirir acesso de editor. Se você escolher sim, você manterá seu endereço 
de e-mail secreto da Google Play Store. Isso não tem nada a ver com manter seu endereço de 
e-mail secreto dos compradores de seu aplicativo. 
A capacidade dos compradores de ver seu endereço de e-mail não tem nada a ver com 
essa opção. O próximo é o Contrato de distribuição do desenvolvedor do Google Play. Esse é o 
contrato legal entre o Google e você. Ele descreve as regras para distribuição de aplicativos, coleta 
de pagamentos, concessão de reembolsos, feedback, classificações, direitos do usuário, direitos 
do desenvolvedor e assim por diante (MACLEAN; KOMATINENI; ALLEN, 2015).
Ao aceitar o Contrato, você será levado a uma página comumente chamada de Console 
do desenvolvedor em play.google.com/console/u/0/signup.
2.8 regras a serem seguidas
Para o desenvolvedor publicar seu aplicativo, algumas regras deverão ser seguidas; 
descreveremos alguns destaques que são interessantes e deverão ser seguidos:
•	 O desenvolvedor precisará ter uma situação regular, para usar a Google Play Store. Isso 
significa que deverá seguir o processo descrito, para se registrar, aceitar o Acordo e 
obedecer às regras do Acordo. Quebrar as regras poderá fazer com que você seja barrado 
e seus produtos removidos da Play Store.
66www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
•	 Você poderá distribuir produtos gratuitamente ou cobrar um preço por ele. O Acordo 
se aplica de qualquer maneira. Os pagamentos deverão ser coletados por meio de um 
processador de pagamentos autorizado da Google Play Store.
Depois de fazer isso, o desenvolvedor poderá enviar seus aplicativos para a Play Store, 
para que possam ser encontrados e baixados pelos usuários. Se você for cobrar dinheiro por 
seu aplicativo ou aceitar compras no aplicativo, também precisará configurar uma conta 
do comerciante do Google Wallet. Para obter mais informações, o desenvolvedor poderá 
acessar developer.android.com/distribute/best-practices/earn/in-app-purchases (MACLEAN; 
KOMATINENI; ALLEN, 2015).
2.9 enviando seus aplicativos para o google play
Depois de preparar seus arquivos e estar pronto para fazer upload de seu aplicativo, o 
desenvolvedor poderá revisar as etapas na Launch Checklist em developer.android.com.
Em seguida, faça login no Google Play e clique no botão “Publicar um aplicativo Android 
no Google Play” para iniciar o processo de upload. Será solicitado que sejam carregados os 
seguintes recursos:
•	 Arquivo .apk do aplicativo que contenha os arquivos de código do aplicativo, ativos, 
recursos e o arquivo do manifest.
•	 Capturas de Telas: deverão ser incluídas, no mínimo, duas capturas de telas do seu 
aplicativo, no Google Play. Poderão ser incluídas capturas de tela para um smartphone 
Android, tablet de 7’’, tablet de 10’’, Android TV e Android Wear.
•	 Ícone do Aplicativo: deverá ser incluído um ícone de alta resolução (512 por 512 pixels) 
no Google Play.
•	 Gráfico de Recursos: será usado pela equipe editorial do Google Play para promover 
aplicativos e na página de produtos do seu aplicativo. A imagem deverá ter 1024 pixels 
de largura por 500 pixels de altura no formato JPEG ou formato PNG de 24 bits, sem alfa 
(transparência).
•	 Gráfico Promocional para o Google Play (opcional): para ser usado pelo Google, caso 
decidam promover o aplicativo. O gráfico deverá conter as seguintes dimensões: 180 
pixels de largura por 120 pixels de altura, no formato JPEG ou no formato PNG de 24 bits 
sem alfa (transparência).
•	 Vídeo Promocional para ser incluído no Google Play (opcional): o desenvolvedor 
poderá incluir um URL para um vídeo promocional para seu aplicativo (por exemplo, um 
link do Youtube para um vídeo com a demonstração do funcionamento do seu aplicativo) 
(DEITEL; DEITEL; WALD, 2016).
O desenvolvedor deverá fornecer os seguintes detalhes adicionais de listagem para o 
Google Play:
•	 Language (idioma): seu aplicativo será listado em inglês (por padrão). Se desejar listá-lo 
em outros idiomas, selecione-os na listagem fornecida (Quadro 2).
67www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
•	 Title (título): o título de seu aplicativo como ele aparecerá no Google Play (máximo de 30 
caracteres). Ele não precisa ser exclusivo entre todos os aplicativos Android.
•	 Short Description (breve descrição): uma breve descrição do seu aplicativo (máximo de 
80 caracteres).
•	 Description (descrição): uma descrição de seu aplicativo e seus recursos (máximo de 
4.000 caracteres). É recomendado que você utilize a última parte da descrição, para 
explicar por que o aplicativo requer cada permissão e como ela será usada.
•	 Recent Changes (mudanças recentes): um passo a passo de todas as alterações específicas 
para a versão mais recente do seu aplicativo (máximo de 500 caracteres).
•	 Promo Text (texto promocional): o texto promocional para a comercialização do seu 
aplicativo (máximo de 80 caracteres).
 
Quadro 2 - Listagem de idiomas para aplicativos no Google Play. Fonte: Deitel, Deitel e Wald (2016).
•	 Application Type (tipo de aplicativo): escolha Aplicativos ou Jogos.
•	 Category (categoria): selecione a categoria que melhor se adapta ao seu jogo ou aplicativo.
•	 Price (preço): para vender seu aplicativo por uma taxa, você precisará configurar uma 
conta de vendedor.
•	 Content Rating (classificação do conteúdo): você pode selecionar High Maturity 
(maturidade alta), Medium Maturity (maturidade média), Low Maturity (maturidade 
baixa) ou Everyone (todos). 
68www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
•	 Locations (localizações): por padrão do Google Play, o seu aplicativo será listado em 
todos os países atuais e futuros. Se você não desejar que seu aplicativo esteja disponível em 
todos os países, você poderá escolher aqueles específicos, onde desejar que seu aplicativo 
seja listado.
•	 Website: um link Visit Developer’s Website será incluído na lista de seu aplicativo no Google 
Play. Forneça um link direto para a página em seu site, onde os usuários interessados em 
baixar seu aplicativo poderão encontrar mais informações.
•	 E-mail: seu endereço de e-mail também será incluído no Google Play, para queos clientes 
possam entrar em contato com você com perguntas, relatar erros etc.
•	 Phone Number (número de telefone): às vezes, seu número de telefone estará incluído no 
Google Play. É recomendável que você deixe esse campo em branco, a menos que forneça 
suporte por telefone. 
•	 Privacy Policy (política de privacidade): um link para sua política de privacidade. Além 
disso, se você vender produtos no aplicativo ou usar qualquer serviço do Google deverá 
adicionar seus produtos no aplicativo e especificar os serviços que utiliza (DEITEL; 
DEITEL; WALD, 2016). 
Caro(a) aluno(a), gostaria de indicar a leitura de um artigo, a respeito de um 
assunto que aqui foi pouco explorado: os testes de software dos aplicativos, que 
é de fundamental importância no desenvolvimento de dispositivos móveis. Como 
sugestão de leitura para que seu estudo esteja completo, proponho a leitura do 
artigo Testar App. 
Testar seu App
“O Android Studio foi projetado para facilitar testes. Com apenas alguns cliques, 
você pode configurar um teste do JUnit executado na JVM local ou um teste de 
instrumentação executado em um dispositivo. Naturalmente, é possível ampliar 
os recursos de teste integrando frameworks como o Mockito (link em inglês) para 
testar chamadas de API do Android em testes de unidades locais e o Espresso ou 
o UI Automator para simular a interação do usuário nos testes de instrumentação. 
Você pode gerar testes do Espresso automaticamente usando o Espresso Test 
Recorder”. 
Esta página oferece informações básicas sobre como adicionar 
novos testes ao app e executá-los no Android Studio: <https://
developer.android.com/studio/test?hl=pt_br>. 
 
69www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
“Encontre a felicidade no seu trabalho ou talvez nunca saiba o que é felicidade” 
(Elbert Hubbard).
O verdadeiro sentido da felicidade talvez seja não fazer aquilo que você gosta, mas 
sim gostar daquilo que faz. Se você gostar daquilo que faz, certamente fará tudo 
com amor e dedicação. O amor e a dedicação é uma das chaves da felicidade.
Seja feliz todos os dias.
Um grande abraço!
Disponível em: https://citacoes.in/citacoes/109125-elbert-hubbard-encontre-a-
felicidade-no-seu-trabalho-ou-talvez-nu/. 
Título: Kotlin com Android - Crie aplicativos de 
maneira fácil e divertida.
Autor: Kassiano Resende.
Editora: Casa do Código.
Sinopse: A linguagem Kotlin vem ganhando 
cada vez mais destaque no cenário do 
desenvolvimento de aplicativos. Projetada 
para ter uma interoperabilidade total com 
código Java, Kotlin tem sido a primeira escolha 
na criação de aplicativos Android, sendo 
multiparadigma e multiplataforma. Trata-se de 
uma linguagem moderna, concisa e poderosa, 
oferecendo segurança, clareza e suporte a 
ferramentas de alta produtividade.
Fonte: Editora Casa do Código (2020).
70www.uninga.br
DE
SE
NV
OL
VI
M
EN
TO
 D
E 
AP
LI
CA
TI
VO
S 
M
ÓV
EI
S 
| u
ni
Da
DE
 4
EDUCAÇÃO A DistânCiA
consideraçÕes Finais
Caro(a) aluno(a)!
Chegamos ao final desta Unidade 4 com muita satisfação em tê-lo aqui conosco, e uma 
grande alegria em saber que você, querido(a) aluno(a), conseguiu chegar até o fim. Parabéns! 
 Você recebeu, nesta unidade, uma breve introdução ao conceito do Desenvolvimento 
de Aplicativos Híbridos. Você estudou que os aplicativos híbridos são uma mistura de soluções 
nativas de soluções web e que, para o desenvolvimento de um aplicativo móvel nativo, é necessária 
a utilização de ferramentas específicas para isso. 
Procuramos apresentar as vantagens do desenvolvimento e desvantagens de um App 
Híbrido. Você pôde estudar que, desenvolvendo seu app uma vez, você poderá publicá-lo em 
várias plataformas.
Contextualizamos, de maneira simples, para facilitar o entendimento como fazer a 
publicação de aplicativos em lojas eletrônicas. Foi apresentada a maneira como publicar seu app 
na loja Play Store. Você também estudou que existem algumas regras a serem seguidas, para fazer 
uma publicação de um app em uma loja digital.
Caro(a) aluno(a), gostaria de parabenizá-lo pelo esforço e pela dedicação para chegar até 
aqui. Desejo todo o sucesso que você puder conquistar em sua vida pessoal e profissional. 
Um grande abraço e até a próxima!
Fonte: Android Developers (2019).
Título: Build testable apps for Android (Google I/O’19).
Autor: Android Developers.
Ano: 2019.
Sinopse: Aprenda a desenvolver uma estratégia de teste completa que espelha 
cenários do mundo real usando as bibliotecas e ferramentas de teste AndroidX 
mais recentes, criando um aplicativo Android do zero usando padrões de design 
modernos.
Disponível em: https://www.youtube.com/watch?v=VJi2vmaQe6w&feature=emb_
logo&ab_channel=AndroidDevelopers. 
71www.uninga.br
Ensino a distância
rEFErÊnCiaS
ALURA CURSOS ONLINE. Desenvolvimento Android. 2020. 1 vídeo (10 min 36 s). Disponível 
em: https://www.youtube.com/watch?v=fWscDFHKgw8&ab_channel=AluraCursosOnline. 
Acesso em: 28 out. 2020.
ANDROID DEVELOPERS. Disponível em: https://developer.android.com/. Acesso em: 14 dez. 
2020. 
ANDROID DEVELOPERS. Conheça o Android Studio. Disponível em: https://developer.
android.com/studio/intro. Acesso em: 18 dez. 2020.
ANDROID DEVELOPERS. Guias do desenvolvedor. Disponível em: https://developer.android.
com/guide. Acesso em: 14 dez. 2020.
ANDROID DEVELOPERS. RoomDatabase. Disponível em: https://developer.android.com/
reference/androidx/room/RoomDatabase. Acesso em: 10 nov. 2020.
ANDROID DEVELOPERS. Salvar dados em um banco de dados local usando o Room. 
Disponível em: https://developer.android.com/training/data-storage/room. Acesso em: 18 nov. 
2020.
ANDROID DEVELOPERS. Build testable apps for Android (Google I/O’19). 2019. 1 vídeo (41 
min 40 s). Disponível em: https://www.youtube.com/watch?v=VJi2vmaQe6w&feature=emb_
logo&ab_channel=AndroidDevelopers. Acesso em: 18 dez. 2020.
ANDROID STUDIO. Disponível em: https://developer.android.com/studio. Acesso em: 10 dez. 
2020.
BAUER, C.; KING, G.; GREGORY, G. Java Persistence with Hibernate. Shelter Island: Manning 
Publications, 2016.
BRACHA, G. The Dart Programming Language. Crawfordsville: Pearson 
Education, 2015.
BUTTERFIELD, B. Android Studio for Beginners Part 1. 2017. 1 vídeo (37 min 
20 s). Disponível em: https://www.youtube.com/watch?v=dFlPARW5IX8&ab_
channel=BillButterfield. Acesso em: 28 nov.2020.
CITAÇÕES E FRASES FAMOSAS. Dale Carnegie. Disponível em: https://citacoes.
in/citacoes/608433-dale-carnegie-a-pessoa-que-chega-mais-longe-e-geralmente-
aquela/. Acesso em: 18 nov. 2020.
CITAÇÕES E FRASES FAMOSAS. Elbert Hubbard. Disponível em: https://citacoes.
in/citacoes/109125-elbert-hubbard-encontre-a-felicidade-no-seu-trabalho-ou-talvez-
nu/. Acesso em: 19 dez. 2020.
72www.uninga.br
Ensino a distância
rEFErÊnCiaS
CITAÇÕES E FRASES FAMOSAS. Walt Disney. Disponível em: https://citacoes.in/
pesquisa/?h=Walt+Disney. Acesso em: 28 out. 2020.
CORTELLA, M. S. Por que fazemos o que fazemos? São Paulo: Planeta do Brasil 
Editora, 2016.
DEITEL, P.; DEITEL, H.; DEITEL, A. Android para programadores: uma abordagem baseada 
em aplicativos. Porto Alegre: Bookman, 2015.
DEITEL, P.; DEITEL, H.; WALD, A. Android 6 for programmers an app-driven approach. 
Michigan: Pearson Education, 2016. 
DEVMEDIA. Persistência de dados no Android. Disponível em: https://www.devmedia.com.
br/persistencia-de-dados-no-android/26947. Acesso em: 11 nov. 2020.
EISENMAN, B. Learning React Native building mobile applications with Javascript. Boston: 
O’Reilly, 2015.
FORDHAM, M, J. Kotlin development for Android (create your own app). [S. l.: s. n.], 2017.
IONIC FRAMEWORK. Disponível em: https://ionicframework.com. Acesso em: 1 dez. 2020.
IONIC FRAMEWORK. Hybrid vs. Native. Disponível em: https://ionicframework.com. Acesso 
em: 2 dez. 2020. 
JACKSON, W. Android apps for absolute beginners covering Android 7. 4. ed. New York: 
Apress, 2017.
LECHETA, R. R. Android: aprenda a criar aplicações para dispositivosmóveis com o Android 
SDK. São Paulo: Novatec, 2015.
LEIVA, A. Kotlin for Android developers learn Kotlin the easy way while developing an 
Android app. Columbia: British Columbia Lean Publishing, 2019.
LIBBY, A. Introducing Dart Sass: a practical introduction to the replacement for Sass, built on 
Dart. Rugby: Apress, 2019.
MACLEAN, D.; KOMATINENI, S.; ALLEN, G. Pro Android 5. New York: Apress, 2015.
MICROSOFT. Xamarin documentation. Disponível em: https://docs.microsoft.com/en-us/
xamarin. Acesso em: 1 dez. 2020. 
MURPHY, M. L. The busy coder’s guide to Android development. USA: CommonsWare, 2019.
NAPOLI, M. L. Beginning Flutter a hands on guide to app development. Indianapolis: John 
Wiley & Sons, 2020.
73www.uninga.br
Ensino a distância
rEFErÊnCiaS
PRESSMAN, R. S. Engenharia de Software: uma abordagem profissional. 7. ed. Porto Alegre: 
AMGH, 2011.
QUASAR FRAMEWORK. Disponível em: https://quasar.dev. Acesso em: 1 dez. 2020.
SPATH, P.; FRIESEN, J. Learn Java for Android development: migrating Java SE programming 
skills to mobile development. New York: Apress, 2020.
WAGNER, R. Professional iPhone and iPod touch programming building applications for 
mobile Safari. Indianapolis: Wiley, 2008. 
WILKEN, J. Ionic in action hybrid mobile apps with Ionic and AngularJS. Shelter Island: 
Manning Publications, 2016.