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ém