Fundamentos em

Desenvolvimento Mobile Android

Fabrício Valadares
2022
SUMÁRIO
Capítulo 1. Apresentação e histórico .................................................................... 5

Dispositivos Móveis .......................................................................................................... 5

Evolução do Android ........................................................................................................ 8

Capítulo 2. Instalação e configuração de ferramentas........................................ 12

Conhecendo e testando a IDE ........................................................................................ 13

Estrutura do projeto ....................................................................................................... 15

Interface dos Usuários.................................................................................................... 16

Dispositivos físicos e virtuais – testando os APPs .......................................................... 17

Capítulo 3. Contexto Mercadológico ................................................................... 20

Capítulo 4. Desafios e tendências para aplicações móveis ................................. 23

Capítulo 5. Plataforma, SDK e desenvolvimento mobile..................................... 27

Desenvolvimento Mobile ............................................................................................... 28

Capítulo 6. Criando nossa primeira aplicação móvel .......................................... 31

Criando a aplicação ........................................................................................................ 33

Adicionando uma nova activity ...................................................................................... 38

Criando uma função ....................................................................................................... 39

Capítulo 7. O Android .......................................................................................... 43

Activity Lifecycle – O ciclo de vida das aplicações.......................................................... 45

Capítulo 8. Kotlin vs. Java .................................................................................... 50

Capítulo 9. Principais Bibliotecas ......................................................................... 53

Activity ............................................................................................................................ 53

Fragments ....................................................................................................................... 54

AppCompat..................................................................................................................... 54

Navigation ...................................................................................................................... 55

2
 Lifecycles, ViewModel e LiveData .................................................................................. 55

Room .............................................................................................................................. 56

Worker Manager ............................................................................................................ 56

Android KTX .................................................................................................................... 57

Testing ............................................................................................................................ 57

Compose ......................................................................................................................... 58

Koin................................................................................................................................. 59

Retrofit ........................................................................................................................... 59

Gson................................................................................................................................ 60

Incluindo bibliotecas no projeto..................................................................................... 60

Capítulo 10. Arquitetura de Aplicações Android .................................................. 65

Princípios de projeto ...................................................................................................... 65

Padrões de projeto ......................................................................................................... 66

Arquitetura de software ................................................................................................. 68

Arquitetura de apps Android.......................................................................................... 69

Capítulo 11. Avançando na Prática ....................................................................... 73

Referências .............................................................................................................. 76

3
1
 Capítulo 1. Apresentação e histórico
Dispositivos Móveis

Em 1998, (Mateus & Loureiro, 1998, 1) iniciam o livro dizendo que nas
últimas décadas tem acontecido um crescimento extraordinário nas áreas de serviços
via satélite, comunicação celular e redes locais sem fio, o que permitirá o acesso a
informações e recursos de qualquer lugar, a qualquer momento. Os autores
continuam, e dizem que em alguns anos os laptops e PDAs serão a realidade de
milhões de pessoas, permitindo que estas estabeleçam a comunicação com a parte
fixa da rede ou mesmo com outros dispositivos portáteis. Este modelo computacional
é conhecido como computação móvel (Figueiredo and Nakamura 2003, 21) (Junior
and De Oliveira 2019).

Este cenário já é realidade há mais de uma década, e hoje somos

dependentes de nossos Smartphones para a realização de muitas de nossas tarefas
diárias. Eles são utilizados para comunicação, entretenimento, ensino, entre outras
funções. Apesar de terem se tornado populares neste século, a histórias dos
celulares, dispositivos que antecedem os smartphones, tem início em 19731, quando
a Motorola demonstrou seu primeiro celular, que pesava dois quilogramas. De lá até
hoje, ocorreu uma grande mudança nestes dispositivos, que atualmente possuem
capacidades de processamento, armazenamento e memória muito maiores do que
os computadores da década de 1990.

Para encurtar a história, vamos resumir o texto apresentado em (Tiger

Mobiles). O primeiro telefone móvel foi lançado em 1983, pela Motorola, e custava
quatro mil dólares, era um grande símbolo de status para a época. O primeiro
dispositivo móvel dobrável também é da Motorola, lançado em 1989. Neste período,
a única função dos dispositivos era a realização de chamadas telefônicas.

1
https://pt.wikipedia.org/wiki/Motorola_DynaTAC

5
 Na década seguinte, houve a redução de tamanho dos dispositivos, e o GSM
foi implantado na Europa; com isso, os celulares passaram a ser produzidos em
massa. Neste período, também foi lançado o Nokia 1011, e os aparelhos passaram a
ter SMS e jogos simples.

Finalmente cores! Eram apenas quatro, mas o suficiente para alavancar as

vendas. Entre 1995 e 1998 foram lançados aparelhos com estas características. O
Siemens S10 foi o primeiro deles; a Nokia lança a série 5100, com capas
customizáveis. Os aparelhos passam também a ter alerta vibratório. Em 1999, a
Nokia apresentou o 7110, primeiro celular a utilizar a tecnologia WAP, permitindo o
acesso à internet. Um ano mais tarde, a Sharp lançou o primeiro telefone com
câmera fotográfica. Outros incrementos vieram neste período, como GPS, texto
preditivo, toques polifônicos e outros.

Hora da revolução da internet nos dispositivos móveis! Entre 2003 e 2006, o

3G chegou até nós, e com ele maiores velocidades para troca de dados. A RIM,
fabricante do Blackberry, populariza o uso de e-mails nos celulares. A Sony Ericsson
apresentou o primeiro telefone com câmera frontal no aparelho Z1010. Surgiram os
primeiros telefones com WI-FI e navegação completa na internet.

2007 – 2010: Os dispositivos se tornam inteligentes. Neste período, a LG

apresentou o Prada, primeiro aparelho com tela touchscreen, substituindo o antigo
modo de navegação. Ainda em 2007, a Apple lançou o Iphone e revolucionou o
mercado. Em setembro de 2008, a T-Mobile G1 traz uma inovação para concorrer
com o IPhone, o Google Android. Daí em diante, os dispositivos agregaram diversas
funções, iniciando o ciclo de substituição dos computadores e notebooks. Nesta
mesma época, vieram o NFC, os aplicativos móveis e o carregamento sem fio.

2011 – 2014: os smartphones tornaram-se o ponto central da vida de muitas

pessoas. O 4G foi lançado, entregando velocidades incríveis para a época. O
reconhecimento de voz ganha espaço. Apareceram novos recursos, como

6
monitoramento de atividades físicas, telas em HD, reconhecimento facial,
reconhecimento de digitais etc.

Em seguida, de 2015 – 2018, iniciou-se o ciclo das telas grandes. Com o 4G,
passamos a consumir os serviços de streaming, exigindo telas maiores e com maior
qualidade. A tela do iPhone cresce 57% em relação à versão original. Iniciamos os
pagamentos com smartphones, e foi lançado o reconhecimento da digital direto na
tela.

Hoje, a velocidade dita a regra. Com a chegada do 5G, o céu é o limite em

velocidade de conexão; queremos jogar, assistir filmes, estudar, ou seja, os aparelhos
estão substituindo os computadores pessoais. A Figura 1 ilustra a evolução do celular
ao smartphone. A figura 2 apresenta os principais desafios que cercam o
desenvolvimento de aplicações para dispositivos móveis. Detalhes serão
apresentados no capítulo 4.

Figura 1 – Evolução do celular ao smartphone.

Fonte: https://www.researchgate.net/figure/Figura-4-Evolucao-dos-
celulares_fig3_334376415.

7
 Figura 2 – Desafios do desenvolvimento de aplicações para dispositivos móveis.

Fonte: Prof. Ricardo Rabelo, DECOM/ICEB/UFOP (adaptado).

Evolução do Android

Assim como os telefones celulares, o Android também passou por uma

grande evolução desde seu lançamento. Este processo está ilustrado na figura 3.
Neste processo muitas mudanças foram incluídas, resumimos aqui no texto, e mais
detalhes podem ser encontrados na documentação oficial da plataforma (Google
Developers).

Figura 3 – Evolução do Android.

Fonte: https://bayton.org/docs/enterprise-mobility/android/android-version-evolution-
graphics/.

A primeira versão do android foi a 1.0, API 1, lançada em 2008 e baseada no

kernel 2.6.5 do Linux. Junto a ela, foram lançados: loja de aplicativos, navegador web,

8
sincronização do Gmail, Google Maps e outros. A versão 2 da API, Android 1.1, foi
lançada em 2008 e adiciona suporte a comentários no Google Maps e permissão para
salvar texto anexo em mensagens. A próxima atualização do Android é a 1.5, e inicia
a tradição dos codinomes baseados em doces. Ela ficou conhecida como Cupcake, API
3, e trouxe o novo Kernel 2.6.27. Com ela, vieram melhorias na interface do usuário,
suporte a teclado virtual, autorrotação da tela etc. A última atualização do Android 1
foi a API 4, também chamada de ``Donut''. Um novo Kernel foi introduzido, agora na
versão 2.6.29, e permite a entrada de texto por voz, por exemplo.

A versão 2.0 traz várias atualizações, as duas primeiras sob codinome Eclair,
implementa as APIs 6 e 7, com melhorias na api e correções de bugs. A versão 2.2,
Froyo, implementa uma nova versão do Kernel, 2.6.32 e conta com otimização de
memória e desempenho e melhorias na velocidade das aplicações, por exemplo. Em
seguida, o Gingerbread, com as APIs 9 e 10, apresenta o Kernel 2.6.35, com melhorias
na interface de usuário, correção de bugs e eficiência de bateria.

A versão 3 tem três APIs e é chamada de Honeycomb, as APIs são 11, 12 e

13. Esta é a versão para tablets e melhora o sistema de multitarefa, com um teclado
redesenhado. Seguidos de melhorias de interface de usuário e suporte a joystick.

O Ice Cream Sandwich, Android 4, é baseado no Kernel 3.0.1. Esta versão

implementa as APIs 14 e 15 e apresenta os botões virtuais, facilidade para criação de
pastas, estabilidade e correções de bugs. A próxima atualização, versão 4.1, recebe
outro codinome, Jelly Bean, API 16, com nova interface de usuário e melhoria de
acessibilidade. O Jelly Bean ainda recebe outras três atualizações e implementa as
APIs 17, 18, 19 e 20, com melhorias na tela de bloqueio, controle de energia
aprimorado, suporte a múltiplos usuários e bluetooth. Na API 19, é iniciado o
processo de migração do ART para Dalvik. A versão 20 é exclusiva para Wearables.

O Android 5 implementou as APIs 21 e 22, e recebe o codinome Lollipop.

Com ele foi concretizada a migração do Dalvik para o ART. O ART traz melhorias no
processo de instalação de APPs no dispositivo do usuário. Nesta versão, o Android

9
 passa a ter suporte para processadores de 64 bits, implementa uma nova interface
de usuário e chamada de voz em alta definição. O Android 6, API 23, implementa o
novo modo de economia de energia que reduz a velocidade do CPU quando a tela
está desligada. Também traz uma nova barra de pesquisa de aplicativos favoritos e
um sistema de permissões pós-instalação, dando maior autonomia ao usuário.

O Nougat, Android 7, trouxe consigo as APIs 24 e 25. Agora existe um novo

sistema de calibração de cores, melhorias na criptografia e a inclusão do botão limpar
tudo na tela de gerenciamento de aplicativos. A interface de usuário foi melhorada e
novos recursos foram apresentados ao desenvolvedor. O Android 8 também tem
duas versões e trouxe as APIs 26 e 27. Foram apresentadas novas cores do sistema,
melhoria nas notificações e inicialização duas vezes mais rápida. Ele também trouxe o
Android Go Edition, versão para ser utilizada em versões em aparelhos com até um
gigabyte de memória RAM.

O Android 9 Pie trouxe a API 28, com novas melhorias na interface do

usuário, novas transições entre aplicativos, além de suporte ao NFC2. A versão 10, API
29, implementa a navegação por gestos, restrições de acesso ao sistema de
armazenamento e acesso limitado a identificadores do dispositivo. As versões mais
recentes do Android são 11, 12 e 13, a última recém anunciada pelo Google.
Aproveite e faça uma pequena pausa para pesquisar quais melhorias foram trazidas
por estas versões.

2
Near field communication

10
2
 Capítulo 2. Instalação e configuração de ferramentas
O Android Studio é a IDE padrão utilizada no desenvolvimento de todos os
tipos de aplicativos Android há muitos anos. Ela é baseada na IntelliJ IDEA, e oferece
todos os recursos necessários para melhorar sua produtividade durante o processo
de desenvolvimento de aplicações. O download desta ferramenta deve ser realizado
direto do site oficial3, que está ilustrado na figura 4.

Figura 4 – Página para download do Android Studio.

Fonte: https://bayton.org/docs/enterprise-mobility/android/android-version-evolution-
graphics/.

Após clicar no botão Download Android Studio, você será direcionado para
outra tela, onde haverá outro botão com o mesmo nome. Ele lhe levará aos termos e
condições de uso, que devem ser aceitos para liberação do download. Salve o arquivo
na pasta Downloads do seu usuário e aguarde o final do procedimento. É importante
observar se seu computador atende aos requisitos mínimos necessários para a
instalação; eles estão disponíveis no final da página do Android Studio e replicados na
figura 5.

3
https://developer.android.com/

12
 O processo de instalação é simples, bastando seguir os passos exibidos pelo
utilitário de instalação. Neste link estão disponíveis informações para cada sistema
operacional suportado: https://developer.android.com/studio/install.

Figura 5 – Requisitos mínimos para instalação do Android Studio.

Fonte: https://developer.android.com/studio.

Conhecendo e testando a IDE

O visual do Android Studio é similar ao visual da IntelliJ Idea e muito

parecido com o Eclipse. Todos eles possuem um layout bastante intuitivo. A figura 6
ilustra a tela exibida na primeira vez que a IDE for aberta4. Vá em Projects, em
seguida escolha a opção New Project. Na tela seguinte, do lado esquerdo, selecione
Phone and Tablet e do lado direito escolha a opção Empty Activity. Clique em Next e
preencha os campos:

4
Ela pode variar de acordo com o sistema operacional utilizado, ou a versão da IDE.

13
 Figura 6 – Tela inicial do android studio.

• Name: IGTI - Android primeiro exemplo - Este é o nome do aplicativo.

• Package: br.com.igti.igti_androidprimeiroexemplo - Este é o pacote utilizado

para organização do código. Escolha este nome com cuidado, pois ele será o
identificador único de sua aplicação na Play Store.

• Save location: (mantenha o padrão) - Local onde seu código será salvo.

• Language: Kotlin - Linguagem utilizada para desenvolver a aplicação.

• Minimum SDK: API 24: Android 7.0 (Nougat) - Versão mínima do Android
necessária para executar o aplicativo. A escolha deve ser baseada no volume
de usuários que se deseja atingir e nos recursos que sua aplicação precisa
para ser executada. O Android Studio lhe ajuda na escolha, clique na opção
Help me choose.

Em seguida, basta clicar em Finish e aguardar o processo de criação do

projeto.

14
Estrutura do projeto

Os projetos no Android Studio podem conter um ou mais módulos, partes

funcionais da aplicação, com os arquivos de código fonte e recursos da aplicação. O
código fonte contém a lógica do aplicativo, os recursos armazenam o que é
necessário para o funcionamento do app, como imagens, arquivos de layout etc. O
modo padrão de visualização da estrutura do projeto é o Android project view,
ilustrado na figura 7. Ela estará organizada por módulos, facilitando o acesso fácil a
todos os recursos do projeto.

Figura 7 – Estrutura do projeto.

Cada módulo do projeto tem por padrão as pastas: manifest – que contém o
arquivo AndroidManifest.XML, este é o coração da aplicação, e contém registro de
todas as activities desenvolvidas; java – apesar da linguagem oficial ser o Kotlin,
todos os arquivos de código são incluídos nesta pasta, inclusive os arquivos de teste
unitário e teste instrumentado; res – esta é a pasta de recursos, ela armazena os
arquivos de layout em formato XML, o arquivo de string e imagens, por exemplo. Este
modo de visualização pode ser alterado para outros, como a visão de projeto, similar
à visão do projeto do Eclipse.

15
Interface dos Usuários

A interface principal do Android Studio está ilustrada na figura 8, onde:

Figura 8 – Interface do usuário.

Fonte: https://developer.android.com/studio/intro?hl=pt (adaptado).

1. É a barra de ferramentas, utilizada em diversas ações, como executar a

aplicação e escolher o dispositivo onde a execução será realizada.

2. Barra de navegação: permite o acesso simplificado à estrutura do

projeto. Aqui você pode navegar entre os pacotes e arquivos contidos nos
mesmos.

3. Na janela do editor, escrevemos e modificamos o código fonte.

4. Barra de ferramentas da janela: está em torno da janela de edição e

permite expandir e colapsar diferentes janelas, como sistema de
versionamento ou a visão de projeto.

5. Janela de ferramentas: fornece acesso a janelas específicas, como

gerência de projeto, controle de versão e mais.

16
 6. Barra de status: exibe o status do seu projeto e da própria IDE. Avisos
também serão exibidos aqui.

Dispositivos físicos e virtuais – testando os APPs

Para testar os aplicativos, você precisará de um dispositivo executando o

sistema operacional Android. Este dispositivo pode ser físico ou virtual. Qualquer
smartphone que execute o sistema operacional do Google pode ser utilizado em
nossos testes, desde que seja ativado o modo de desenvolvimento. Este
procedimento é realizado tocando-se sete vezes na opção build number (número de
compilação), disponível em Configurações/Sobre o telefone (Settings/About phone).
Após este procedimento, vá em Sistema/Opções do desenvolvedor e, em seguida,
ative o modo de depuração USB. Agora, basta plugar o cabo usb ao smartphone e em
seguida ligar ao computador.

Para facilitar o desenvolvimento, o Android Studio implementa o AVD -

Android Virtual Device, um emulador que permite criar smartphones virtualizados
executando alguma versão do Android. Para criar uma AVD, clique na opção Device
Manager, ela está na barra de ferramentas e seu ícone possui um smartphone com
um android em frente. Ele também está disponível na de ferramentas da janela, do
lado direito, com o mesmo nome.

Depois de abrir o gerenciador de dispositivos virtuais, clique no botão Create

device. Será aberta a janela de seleção de hardware, conforme ilustrado na figura 9.
Escolha uma imagem que possui a play store ativada, ela é necessária para a
implementação de algumas funcionalidades da aplicação, como por exemplo o Pixel
4. Em seguida, clique em Next. Na próxima tela, escolha uma imagem do sistema
operacional, como o Android 11, API 30, pode ser necessário fazer o Download da
imagem do sistema operacional. Ao final, avance.

17
 Figura 9 – Criando um dispositivo virtual.

Na tela seguinte, basta clicar em Finish e você já tem uma máquina virtual
para praticar. Uma observação relevante é que, se o computador utilizado para as
aulas possuir entre quatro e oito gigabytes de memória RAM, ficará mais confortável
a execução de testes em um dispositivo físico, pois o emulador consome muitos
recursos da máquina. Agora, basta clicar no ícone Run App (símbolo de play, verde) e
aguardar o final do processo de build. Se nenhum erro for apresentado, seu ambiente
estará configurado e pronto para iniciarmos o processo de desenvolvimento.

18
3
Capítulo 3. Contexto Mercadológico
É inegável como os celulares se tornaram uma parte importante de nosso
cotidiano. Eles são utilizados para as mais diferentes tarefas. A consultoria (We are
social 2021) aponta em seu relatório que hoje, no mundo, somos aproximadamente
7.9 bilhões de pessoas, com 56,6% de urbanização, e que existem aproximadamente
5.3 bilhões pessoas com ao menos um celular. Este já é um bom motivo para se
investir no desenvolvimento de aplicações para dispositivos móveis. O relatório com
dados de outubro de 2021 aponta que os aplicativos mais usados são Facebook,
WhatsApp e Instagram. Olhando para o Brasil, somos 213 milhões de pessoas, com
taxa de urbanização igual a 87%. Em nosso país são 205.4 milhões de conexões
celulares ativas. Por aqui seguimos a tendência mundial, e os aplicativos mais usados
são WhatsApp, Facebook e Instagram.

Nos últimos anos, os super apps vem se popularizando, principalmente em

países emergentes, como China e Brasil. Estes aplicativos conseguem unir em um
único local marketing place, entretenimento, plataforma de pagamentos e mais. A
Magazine Luiza, em 2020, teve 76% de suas vendas negociadas por aplicativo de
celular (Medeiros, 2021).

A figura 10, Statcounter, exibe o gráfico com a disputa do mercado de

celulares pelos principais fabricantes nos últimos dez anos. Nota-se que em 2011 a
Nokia era líder de mercado, seguida pela Apple, mas, por não ter investido nos
smartphones, acabou sendo ultrapassada pela Samsung em 2013, e hoje é uma das
marcas menos utilizadas. Uma observação interessante é a liderança do mercado
pela Apple, que ultrapassou a Samsung no segundo semestre de 2021. De acordo
com a (TrendForce), isso se deve ao lançamento do IPhone 13.

20
 Figura 10 – Mercado global de celulares/smartphones.

Fonte: (Statcounter).

Quando falamos de sistemas operacionais para Smartphones, o Android é o

líder isolado. Esta hegemonia iniciou em 2012 e se mantém até os dias atuais. Grande
parte deste sucesso é devido à versatilidade do sistema operacional, que é open
source, permitindo que diferentes fabricantes o adaptem a seus dispositivos físicos,
diferente do que acontece com o iOS da Apple. Este cenário está ilustrado na figura
11. Antes do Android o Symbian da Nokia dominava, mas, foi ultrapassado pelo robô
e descontinuado.

Figura 11 – Sistemas operacionais para celulares.

Fonte: (Statcounter).

21
4
Capítulo 4. Desafios e tendências para aplicações móveis
Uma pesquisa realizada pela (Mobile Time, n.d.) apontou as principais
funcionalidades buscadas por brasileiros na compra de um novo smartphone.
Conforme ilustrado na figura 12, os principais requisitos são capacidade de
processamento, seguido pela capacidade de memória. Apesar destes fatores serem
importantes, eles não são os únicos a serem levados em consideração no
desenvolvimento de aplicações, conforme veremos neste capítulo.

Figura 12 – Pesquisa Panorama Mobile Time/Opinion Box - O brasileiro e seu smartphone -

julho de 2021.

Fonte: (Mobile Time).

O desenvolvimento de aplicações para dispositivos móveis é cercado de

desafios, eles estão ilustrados na figura 2 e detalhados a seguir.

• Arquitetura de computadores – está relacionada ao hardware dos

dispositivos, como processador, sistema de armazenamento interno,
quantidade de memória RAM etc. Nos últimos anos, houve um avanço
significativo nesta área, os wearables se tornaram realidade, com a adoção

23
 dos smartwatches. Um ponto importante é o consumo adaptativo de
energia, afinal de contas, você está trabalhando com um dispositivo móvel
que funciona com bateria. O sistema operacional pode alterar seu
comportamento de acordo com a quantidade de energia restante e sua
aplicação precisa estar preparada para isso.

• Engenharia de software – Todas as APIs para desenvolvimento de aplicações

Android seguem padrões e princípios de projetos. Além disso, os aplicativos
precisam conseguir se recuperar de falhas sem comprometer sua
funcionalidade. Como dito, o sistema operacional pode mudar seu
comportamento em situações de baixo consumo de energia, existem
situações em que não existe sinal de internet disponível. Nestes cenários,
sua aplicação simplesmente deixará de funcionar?

• Interação homem-máquina – Você deve ter notado como a aparência do

Android mudou nos últimos anos, principalmente da versão 11 em diante. A
usabilidade das aplicações é cada vez mais relevante, assim como a
preocupação com a acessibilidade. Hoje temos menus que se adaptam ao
contexto, entrada de dados multimodal, ou seja, por voz, imagem, teclado. É
preciso pensar sempre em como tornar as aplicações mais agradáveis para
quem vai utilizá-las.

• Sensores e atuadores – Sensores são dispositivos capazes de capturar

informações do ambiente, como luminosidade, pressão, gps etc. Já os
atuadores conseguem interferir, como o sistema de vibração do celular.
Cada dia os aparelhos interagem mais com o ambiente em que estão
inseridos e você, como desenvolvedor, precisa saber como lidar com esta
característica.

• Segurança e privacidade – Fator que está em relevância nos últimos três

anos, pois cada vez mais as pessoas têm dados pessoais nos dispositivos,
incluindo contas bancárias. Isso tem chamado a atenção de criminosos.

24
 • Redes e sistemas distribuídos – O smartphone tem a maior parte de suas
funcionalidades vinculadas ao uso da internet, utilizando algum canal de
comunicação sem fio. É comum você começar a trabalhar em casa no wi-fi e
se deslocar para outra localidade, neste momento o aparelho vai alterar a
conexão para uma tecnologia celular. Isso pode interromper a troca de
dados se a aplicação não for bem estruturada.

• Sistemas operacionais – Diferente dos sistemas operacionais para

computadores, como Microsoft Windows, o Android é bastante agressivo
com as aplicações nele instaladas. Isso acontece por estar trabalhando em
um ambiente cheio de restrições, memória, processamento, conectividade,
energia. Em determinados cenários, o sistema pode eliminar (fechar) sua
aplicação para oferecer mais recursos a outra que estiver em execução no
momento. Existem mudanças de estado, como giro da tela, que vão destruir
e reconstruir sua aplicação. Estar ciente destas características é fundamental
para se tornar um bom programador para dispositivos móveis.

Além destes desafios, existem ainda tendências, como o uso cada vez maior
de dispositivos vestíveis, como os smartwatches, sim, eles também têm uma versão
do Android desenvolvida especialmente para este cenário. A inteligência artificial
está nos dispositivos móveis. O Google possui APIs que permitem trabalhar com
Machine Learning diretamente no smartphone. Mais e mais serviços têm sido
oferecidos para nosso computador de bolso. Aproveite este momento para fazer uma
pesquisa e descobrir o que está sendo feito de mais recente neste cenário.

25
5
Capítulo 5. Plataforma, SDK e desenvolvimento mobile
Neste capítulo, discutiremos os termos plataforma, SDK, API e como eles
influenciam no desenvolvimento de aplicações para Android.

A Motorola possui uma excelente definição para o termo, conforme

ilustrado no texto de Murer (2012):

Plataforma é um conjunto de ativos que podem ser usados para

alavancar o reuso e o rápido desenvolvimento de novos produtos. No
mínimo, ela define o ambiente operacional, a arquitetura de alto
nível de todos os produtos desenvolvidos com base nesta plataforma,
e em conjunto com políticas de desenvolvimento para aperfeiçoar a
plataforma e o desenvolvimento de produtos.

Então, podemos definir a plataforma, de maneira sucinta, como o ambiente

em que o software será executado.

Este ambiente pode ser o hardware, como acontece no arduino, pode ser
um sistema operacional específico, como o Windows, ou uma outra plataforma de
software, como o Facebook. Cada plataforma possui diferentes níveis de abstração,
como quando o sistema operacional retira do usuário a necessidade de conhecer
profundamente o funcionamento do hardware.

Existem diferentes tipos de plataforma, como tecnológica, computacional e

outras. De acordo com Platform Hunt, 2016, uma plataforma tecnológica é
caracterizada por oferecer blocos de construção ou serviços que podem ser
reutilizados muitas vezes. Amazon Web Service e Microsoft Azure são exemplos de
plataformas tecnológicas. Elas não têm como objetivo a conexão entre os produtores
de software e os consumidores. Ao invés disso, ganham dinheiro vendendo seus
serviços para desenvolvedores e são transparentes para o usuário.

27
 Por outro lado, as plataformas de computação permitem esta interação do
usuário com o desenvolvedor. Platform Hunt, 2016, diz que em plataformas
tecnológicas o desenvolvedor “é dono” de seus usuários, enquanto as plataformas
computacionais é que “possuem” os usuários. Android, Microsoft Windows, Apple
iOS são exemplos de plataformas tecnológicas. Nelas a interação do usuário com o
produto, ou desenvolvedor, é geralmente realizada por intermédio de lojas de
aplicativos ou algum marketing place. É importante destacarmos que estas
plataformas geralmente trazem consigo as SDKs, APIs e outras ferramentas
necessárias para o desenvolvimento de software.

SDK é um acrônimo de Software Development Kit, ou kit de desenvolvimento

de software. Ele é o conjunto de ferramentas fornecidas pelo desenvolvedor de uma
plataforma de hardware, sistema operacional ou linguagem de programação. A
maioria das SDKs incluem uma API para conectar novas aplicações para facilitar o
desenvolvimento e acesso a funções de baixo nível. SDKs geralmente estão
embutidos na aplicação e são usados livremente depois de instalados.

Já o termo API significa Aplication Program Interface, ou interface de

desenvolvimento de aplicativos. Ela é considerada uma camada intermediária de
software que expõe apenas os serviços que você pode utilizar.

Desenvolvimento Mobile

O desenvolvimento de aplicações para dispositivos móveis pode ser

realizado de três maneiras, nativo, híbrido e multiplataforma. Aplicativos que são
desenvolvidos utilizando linguagem de programação específica da plataforma são
considerados nativos. Utiliza-se Kotlin ou Java para desenvolver aplicativos para
Android e Swift ou Objective-C, para desenvolver aplicações para iPhone.

Cada sistema operacional possui linguagem nativa, APIs, SDKs, IDEs e lojas
para disponibilização oficial dos APS, o que demanda o desenvolvimento de
diferentes versões do seu aplicativo, de acordo com a plataforma escolhida. Contudo,

28
eles possuem melhor performance e acesso direto a todas as funcionalidades do
dispositivo, além do visual nativo do ambiente (Pinheiro 2020) (Use mobile).

Desenvolvimento híbrido e multiplataforma não são sinônimos. O híbrido é

caracterizado pela utilização de tecnologia web, como HTML, CSS e JavaScript na
implementação da lógica da aplicação e em sua interface gráfica. As tecnologias que
trabalham com este modelo geram um aplicativo nativo que utiliza uma instância da
WebView, componente responsável por renderizar páginas web, que executam o
código da aplicação. É como ter uma página embarcada em um aplicativo. O acesso a
funcionalidades do sistema operacional, como câmera, arquivos etc., é mais difícil e
realizado por meio de uma camada de abstração do framework escolhido (Use
mobile). Aqui se enquadra o Ionic, por exemplo.

A criação de aplicações multiplataforma, ou cross-platform, tem como

característica a escrita de uma única aplicação que será executada em diferentes
sistemas operacionais. Ele se difere do desenvolvimento híbrido por utilizar uma
técnica chamada de cross-compiled, que converte o código escrito na linguagem
escolhida para um executável nativo para cada plataforma alvo. Isso elimina a
necessidade de camadas intermediárias, como acontece no híbrido (Use mobile). A
própria SDK do framework provê acesso aos recursos nativos e possui performance
melhor do que apps híbridos. São exemplos o Xamarin e o Flutter (Pinheiro, 2020).

29
6
Capítulo 6. Criando nossa primeira aplicação móvel
Antes de prosseguir e criar um aplicativo, é preciso relembrar alguns
conceitos importantes, o projeto de um APP Android é dividido em várias pastas:

• res – esta é a pasta que armazena todos os recursos necessários para a

aplicação.

– drawable – contém as imagens;

– layout – armazena os arquivos XML responsáveis pela interface de

usuário;

– menu – arquivos XML utilizados para criar os menus;

– value – arquivos XML utilizados na internacionalização do APP,

configuração de temas, valores numéricos e outros.

• java – armazena o código fonte, separado em pacotes, incluindo testes

unitários e instrumentados. Apesar do nome Java, os arquivos Kotlin
também estão armazenados nesta pasta. O nome é vestígio da linguagem de
programação inicial.

• manifest – nesta pasta está o arquivo que contém informações sobre todas
as activities do projeto. Ela também é utilizada para liberar acesso a pacotes
necessários de outras aplicações que serão chamadas pelo aplicativo. Isso é
necessário devido às mudanças de segurança aplicadas a partir do Android
11. A TAG <intent-filter> é necessária para customizar a forma como a
activity será iniciada; MAIN – significa que a activity pode ser iniciada
isoladamente, como ponto inicial da aplicação; LAUNCHER – indica que a
activity estará disponível para o usuário na tela inicial junto com outras
aplicações que o usuário possui.

31
 São quatro componentes importantes nas aplicações Android:

• Activity – este é o ponto de entrada para a interação com o usuário,

representa uma única janela do APP.

• Service – Mantém o app executando em segundo plano, mesmo sem que a

interface do usuário esteja visível. Ela permite manter uma tarefa ativa,
como, por exemplo, a execução de música.

• Broadcast receiver – Permite que o aplicativo responda a eventos

disparados pelo sistema operacional, como, tela desligada, bateria baixa,
foto capturada, e outros.

• Content provider – Permite o compartilhamento de dados da aplicação. O

Android provê um content provider que possibilita o acesso e manipulação
dos contatos armazenados no dispositivo, por exemplo.

Outro elemento importante de uma aplicação Android é a classe R, ela é

responsável por prover um ponto de acesso a todos os recursos disponíveis no APP.
Foi assim até a versão 3.5 do Android Gradle Plugin, da versão 3.6 em diante, o AGP
gera o bytecode da classe R diretamente, ao invés de uma classe .java. Por exemplo,
o recurso res/values/string.xml <string name = “hello”> pode ser acessado utilizando-
se R.string.hello.

Como apresentado anteriormente, a Activity representa uma interface de

usuário, mas é formada por elementos como botões, componentes para visualização
de texto, para captura de texto, exibição de imagem e outros. Estes componentes são
derivados da classe View, conforme ilustrado na figura 12. Como é possível notar,
existem também os ViewGroups, que funcionam como containers responsáveis pelo
armazenamento das Views. Ou seja, o ViewGroup armazena e organiza os elementos
visuais da tela. O ViewGroup padrão atualmente é o Constraint Layout, além dele
existem também o Linear Layout, e o Relative Layout, por exemplo.

32
 Figura 12 – View e ViewGroup.

Fonte: https://developer.android.com.

Criando a aplicação

O processo inicial de criação do novo APP é idêntico ao utilizado no capítulo

2, seção Conhecendo e testando a IDE. Então, vá ao menu New em seguida Project e
escolha a opção New Project. Na janela que se abriu, escolha a opção Empty Activity
e avance. Na tela seguinte, informe os dados solicitados. Você pode definir os valores
que achar interessante para sua organização. Utilizaremos os seguintes dados:

• Name – IGTI Android P2

• Package name – br.com.igti.igtiandroidp2

• Save location – local em sua máquina onde o código será salvo

• Minimum SDK – API 24: Android 7

Em seguida, clique em Finish e aguarde o build inicial. Isso pode demorar um

pouco dependendo da configuração de seu computador. Ao final do processo, solicite
a execução do aplicativo, para isso pressione Shift + F10 ou clique no ícone similar ao
play na barra de ferramentas. O emulador que foi criado anteriormente será exibido
na tela, aguarde até que sua aplicação apareça. Se sua máquina possuir menos de
oito gigabytes de memória RAM, é recomendado utilizar um dispositivo físico para os
testes.

33
 Neste momento, uma ferramenta útil é o Screen Copy (Genymobile),
desenvolvido e disponibilizado pela GenyMobile, em formato open source e gratuito.
Este aplicativo permite espelhar a tela do android direto no seu computador,
independentemente do sistema operacional utilizado. O Download pode ser feito na
página https://github.com/Genymobile/scrcpy, bastando escolher a versão de acordo
com o software instalado em seu computador. Depois de instalar, basta executar o
programa, se ele não exibir a tela, ou apresentar falha, abra o aplicativo pelo
terminal, utilizando o comando scrcpy --max-size 1024, que reduzirá a
resolução permitindo que você tenha acesso à tela. A segunda dica importante é,
uma vez aberto o emulador, não o feche, pois o processo de inicialização pode ser
bastante demorado.

Já existem duas guias abertas no Android Studio, a primeira delas é o

arquivo android_main.xml, que representa o layout da tela, a segunda é a Activity,
MainActivity.kt. Observe o padrão de nomes, toda activity tem seu nome terminado
com esta palavra, e a view inicia com a palavra activity. Estes detalhes estão
ilustrados na figura 13.

Figura 13 – Android Studio, tela de edição do layout.

34
 Do lado direito da tela, temos três opções, Code, Split e Design. A guia Code
exibirá apenas o XML do arquivo de layout, a guia Design, que está ilustrado na figura
13, mostra o modo gráfico de edição, e o modo Split, como o nome indica, dividirá a
tela entre os dois modos. Todos os elementos disponíveis para criação da tela
estarão disponíveis na paleta (Palette), do lado esquerdo da IDE, bastando selecionar
o elemento desejado e arrastar para a tela. Cada elemento selecionado na parte
central da tela, que representa o smartphone, abrirá a guia de atributos (Attributes)
do lado direito da IDE, onde é possível alterar características do elemento, como tipo
de fonte, cor, alinhamento, id, entre outros.

Voltando para o lado esquerdo da IDE, você verá o Component Tree, ou

árvore de componentes, que representa todos os elementos da interface do usuário,
organizados hierarquicamente. Alguns componentes muito utilizados para a
construção da interface são:

• TextView – utilizado para a exibição de texto.

• EditTextView – utilizado para capturar informações em formato textual do

usuário.

• Button – Botões.

• ImageView – Visualização de imagens.

• RecyclerView – Componente poderoso utilizado para exibição de listas

dinâmicas.

Como já discutido, o layout padrão das aplicações Android é o Constraint

Layout. Ele é bastante robusto e versátil, e apresenta as principais qualidades dos
outros gerenciadores de layout. Para que um elemento seja exibido na posição
correta, é preciso que ele esteja ancorado em ao menos dois pontos, um no eixo X e
outro no eixo Y, ou seja, um ponto de ancoragem na horizontal e outro na vertical.
Quando um widget, outro nome dado para views, são arrastados para a tela, eles

35
parecem estar no local correto, mas isso é apenas aparência. Sem a ancoragem,
todos eles serão levados para o ponto inicial da tela, no topo, à esquerda.

Se observar a figura 13, existe uma “mola” com uma seta na ponta nos
quatro cantos do TextView selecionado, estes são os pontos de ancoragem, e eles
são criados ao arrastar o círculo que aparece na borda até a borda de outro
elemento. A figura 14 apresenta outras formas de ancoragem.

Figura 14 – ConstraintLayout - pontos de ancoragem.

Fonte: https://developer.android.com/training/constraint-layout.

O tamanho do elemento pode ser definido dinamicamente, quando

trabalhamos com este gerenciador de layout:

• Fixo – O desenvolvedor determina manualmente a dimensão do

elemento.

• Wrap Content – o componente ocupará apenas o espaço

necessário para exibir seu conteúdo, como um texto, por exemplo.

• Match Constraint – O elemento expandirá para ocupar o máximo

de espaço disponível na view.

Na figura 15, está ilustrado o processo de ancoragem de um EditText ao

“parent”, este é o contêiner onde o elemento está inserido. Inicialmente ele estará
colado na lateral do ViewGroup, basta adicionar uma margem, como ilustrado ao

36
lado direito. O número 16 representa 16 DP, que é a margem padrão recomendada
na documentação.

Figura 15 – Layout da aplicação.

DP é o acrônimo para Density Independent Pixel, ou pixel independente de

densidade. Esta medida é utilizada para manter a proporção do elemento
independente da densidade de pixels da tela, ou seja, será mantida a proporção,
telas de diferentes tamanhos e resolução. O dp é utilizado para margin, padding,
largura e altura de elementos. Mas, para determinar o tamanho da fonte do texto
utilizamos a medida SP, de Scale Independent Pixel, ou pixel independente de escala.
Ele permite que o Android ajuste o tamanho da fonte, de acordo com as preferências
do usuário.

O botão será alinhado utilizando o comando baseline; para exibi-lo, clique

com o botão direito sobre o elemento, e escolha a opção Show Baseline, clique sobre
o baseline que aparece no widget e arraste para o baseline do EditText. Isso garantirá
o alinhamento vertical entre os dos componentes. Depois, conecte o final do botão
ao final da tela. Selecione o elemento EditText, e na janela de atributos, e escolha a
opção match constraint, para o alinhamento horizontal. Defina este alinhamento no
botão para wrap_content. Em seguida, segure shift e selecione o botão e o EditText.
Clique com o botão direito sobre eles, e abra a opção Chains/Create horizontal chain.

37
Este recurso permitirá que o EditText ocupe todo o espaço que sobrar do Button,
como representado na figura 16.

Figura 16 – Alinhamento dos widgets.

Adicionando uma nova activity

Para adicionar uma nova Activity, basta ir ao menu File/New/Activity/Galery.

Será aberta a mesma janela exibida quando você criou o projeto. Selecione empty
activity e avance. Na próxima tela, insira os dados solicitados, conforme ilustrado na
figura 17 e clique em Finish.

Figura 17 – Criando uma Activity.

38
 Abra o arquivo de layout recém-criado e insira um TextView, ancorado ao
topo, início e fim do “parent”, aproveite para alterar o ID deste elemento, conforme
ilustrado na figura 18. O id é importante, pois será utilizado para identificar
unicamente o elemento, tanto na Activity, quanto na View.

Figura 18 – Layout da segunda activity.

Criando uma função

Em Kotlin, a função tem o mesmo papel do método no Java. Adicione a

função chamada enviarMensagem à MainActivity.kt. Ela será responsável por
capturar o texto digitado pelo usuário e enviá-lo para a outra tela. O conteúdo da
classe MainActivity ficará como apresentado na figura 19.

Figura 19 – Classe MainActivity.kt.

Na linha 19 está a assinatura da função, observe que ela começa com a

palavra fun seguido do nome da função. Entre parênteses estão os atributos

39
necessários para o trabalho dela. Neste caso, uma view. Na linha 19 é criada uma
variável imutável chamada editText, que contém o objeto correspondente ao
elemento utilizado para os usuários inserirem uma mensagem. O comando
findViewById é faz esta associação, entre parênteses está o identificador do
elemento. Este é o ID fornecido pelo desenvolvedor quando está construindo a
interface gráfica.

A linha 20 tem mais uma variável imutável, chamada mensagem, ela

armazenará o texto fornecido no EditText. Na linha 21, é criada uma Intent,
componente que indica ao sistema operacional que o aplicativo tem a intenção de
realizar uma ação. Aqui, será a abertura de uma nova Activity.

Perceba que a palavra reservada, val, é utilizada para construir variáveis

imutáveis, ou seja, variáveis que não podem alterar o conteúdo nela armazenado
depois de sua inicialização. Se este procedimento for necessário, devemos utilizar a
palavra reservada var. Para a maior parte dos cenários a val resolverá os seus
problemas, mas, se for necessário editar o valor da variável, substitua a palavra val
por var.

O comando da linha 22 adiciona dados ao nosso pedido de abertura da nova

activity. Veja que ele utiliza o conjunto chave-valor (Key-Value) para conseguir extrair
estas informações. EXTRA_MESSAGE foi a chave utilizada, ela é declarada na linha
10, mensagem é o conteúdo extraído do EditText. Na linha 24, o comando
startActivity(intent) solicita a exibição da Activity ExibirMensagemActivity, passando
uma string, a mensagem informada pelo usuário.

Agora, na classe ExibirMensagemActivity.kt, faça as modificações exibidas na

figura 20. Na linha 19 foi adicionada uma variável chamada mensagem, que recebe o
conteúdo da intent. Em seguida, na linha 20, alteramos o conteúdo do TextView.

Por enquanto, considere que o comando apply permite modificar um objeto

enquanto ele é invocado.

40
 Assim, o texto deste widget será o conteúdo da variável mensagem.

Figura 20 – ExibirMensagemActivity.

Tudo pronto, execute o projeto. Agora no dispositivo, digite uma mensagem

no campo de texto e clique no botão enviar. A mensagem será exibida na próxima
tela. Aproveite agora para explorar a guia de atributos, e veja como é possível alterar
as características dos elementos, como cor, tamanho de fonte, alinhamento etc.

41
7
Capítulo 7. O Android
O Android é o sistema operacional mais utilizado no mundo! Ele foi
desenvolvido para operar em Smartphones e hoje possui versões para TV,
Smartwatches e mais. Ele é um projeto de código fonte aberto, liderado pelo Google.
Apesar de open-source, o código só é liberado para a comunidade depois que o
Google faz todo o desenvolvimento. Neste momento, as empresas interessadas
podem customizar o sistema para seus dispositivos.

A pilha do Android é exibida na figura 21. Falaremos mais sobre ela logo
adiante. Neste ponto, devemos ressaltar o elemento responsável pela instalação e
execução das aplicações no telefone, o ART, ou Android Runtime. Esta é a versão
mais recente da máquina virtual responsável pela instalação e execução dos apps no
aparelho. Antes dela, o Dalvik era utilizado. Ambos foram criados exclusivamente
para a execução de apps no Android. O ART apresenta algumas vantagens, como a
compilação ahead of time, que compila a aplicação no momento da instalação,
otimizando o desempenho. Para quem utiliza o Android desde as versões iniciais, é
possível notar que o processo de instalação está um pouco mais demorado, contudo,
a inicialização das aplicações está bem rápida. Para saber mais, consulte
(GeeksForGeeks 2021).

Figura 21 – Pilha do Android.

Fonte: developers.android.com.

43
 Para falar das demais camadas, será utilizada a figura 22, onde:

• Linux kernel. Núcleo do sistema operacional, é um sistema Linux com alguns

recursos especiais, como o Low Memory Killer, Sistema de gerenciamento de
energia aprimorado, interface para comunicação entre processos.

• Hardware abstraction layer (HAL). Remove a complexidade e variedade de

hardware dos dispositivos, padronizando a interface de implementação.

• System services. Possibilitam a comunicação da API com serviços de baixo

nível. São organizados em módulos por funcionalidade.

• Binder IPC. Mecanismo que permite ao framework da aplicação a cruzar as

barreiras de comunicação dos processos deste nível e realizar chamadas ao
Android System Service. Isso permite que a API de alto nível interaja
diretamente com os Serviços do sistema. Elas são transparentes para o
usuário, dão a impressão de que as coisas simplesmente funcionam.

• Application framework. É onde vamos trabalhar. Ela oferece uma coleção

de bibliotecas que nos permite desenvolver as aplicações, sem a
necessidade de conhecermos os serviços de baixo nível.

44
 Figura 22 – Android.

Fonte: developers.android.com

Activity Lifecycle – O ciclo de vida das aplicações

Talvez este seja um dos pontos mais enigmáticos para quem está iniciando
no desenvolvimento de aplicações para Android. Aqui, o sistema operacional tem
muito poder sobre nossas aplicações e precisamos tomar medidas preventivas
quando certas mudanças acontecerem. Você já parou para pensar no que acontece

45
quando o telefone toca quando você está usando outro APP, como o Whatsapp? Ou
quando você troca de um APP para outro? Pressiona o botão hoje? Para entender o
que acontece, precisamos conhecer o ciclo de vida da aplicação.

O ciclo de vida pode alterar o comportamento de sua aplicação de acordo

com algumas mudanças de estado, como o giro da tela por exemplo. A activity possui
uma série de callbacks, chamadas de função, para cada estado em que a aplicação
pode estar.

• onCreate() – Método chamado quando a activity é iniciada. Ela ainda não

está visível neste ponto. É utilizado para iniciar a lógica básica da aplicação.
Será executado apenas uma vez no ciclo de vida da aplicação. Ele recebe um
parâmetro (savedInstanceState, um objeto bundle, que contém os dados
salvos previamente pela activity). Ele também é usado para passar dados
entre activities. Aqui também é definida a interface gráfica do usuário, no
método setContentView. Você já vinha utilizando esta função, mesmo sem
saber sua real responsabilidade.

• onStart() – este método é utilizado para tornar a activity visível para o

usuário e preparar o app para ficar visível e interagir com o usuário. Ele é
executado rapidamente, logo, operações pesadas não devem ser inseridas
aqui.

• onResume() – Este callback coloca a activity em primeiro plano e permite

que o usuário interaja com ela. O sistema permanecerá aqui até que uma
mudança de estado aconteça. Podemos utilizar este método para alocar
recursos como a câmera, por exemplo.

• onPause() – Esta chamada do sistema indica que o usuário está deixando a

activity (ela não está sendo destruída) e ainda está visível em segundo plano.
Devemos liberar recursos onerosos como a câmera neste estado. Operações
mais pesadas como persistência de dados e chamada de rede devem ser
realizadas no método onStop, porque o onPause é executado muito rápido.

46
 • onStop() - Neste estado a activity não está mais visível para o usuário. Isso
acontece quando outra activity está usando toda a tela. Podemos executar
aqui operações mais pesadas, como realizar o envio de dados para uma api,
por exemplo.

• onDestroy() - é chamado instantes antes da activity ser destruída. Pode ser

invocado por duas razões:

– O usuário está deixando a aplicação.

– O sistema está destruindo activities para economizar recursos ou

para mudar alguma configuração, como a rotação da tela ou modo
de múltiplas janelas.

Um importante recurso para manter os dados independentes das mudanças

de configuração e diferentes estados do ciclo de vida é a utilização do Viewmodel,
que veremos nos próximos módulos.

Como você já deve ter notado, o onCreate é o único callback obrigatório,

nele é realizada a conexão entre a View e a Activity. Para o ciclo de vida de uma
aplicação Android, você pode utilizar a classe Log, responsável pelo registro de
mensagens do sistema de acordo com a necessidade do desenvolvedor. Este log será
exibido no LogCat, disponível na parte inferior do Android Studio. Observe que ele
registra uma série de eventos disparados pelo sistema operacional e por outras
aplicações. Para utilizar o Log, não é necessário criar um objeto, você pode fazer isso
de maneira direta, informando apenas o tipo de log, a tag e uma mensagem. Existem
diferentes níveis de log:

• Log.i – Utilizado para exibir informações sobre a aplicação.

• Log.w – Utilizado para exibir warnings, avisos.

• Log.e – Utilizado para exibir erros.

47
 • Log.v – Utilizado para exibir todos os tipos de mensagens.

• Log.d – Utilizado para depuração do código.

A assinatura padrão da chamada é Log.i(tag: String, msg:

String), onde tag é o identificador utilizado para localizar suas mensagens no
logcat e mensagem é o texto que deseja exibir. Opcionalmente, pode-se informar
qual é a mensagem de erro que disparou o log, incluindo o parâmetro Throwable tr
depois da string de mensagem.

Esta é uma excelente oportunidade para praticar; gere um projeto novo, em

seguida, crie mensagens e log para cada mudança de estado possível, onCreate,
onDestroy etc. O exemplo completo desta implementação está na pasta de código da
disciplina.

48
8
Capítulo 8. Kotlin vs. Java
Se fizer uma pesquisa rápida na internet, você perceberá que o Java está
sempre na lista das linguagens de programação mais utilizadas no mundo, em várias
delas entre os cinco primeiros colocados. Cass, 2021, apresenta uma pesquisa
bastante relevante sobre o tema.

O Java é líder de mercado, principalmente no mundo corporativo.

Inicialmente era a única alternativa para o desenvolvimento de APPs nativos para
Android. O Java começou a ser desenvolvido na década de 1990, em um time
chefiado por James Gosling, na Sun Microsystems (adquirida em 2008 pela Oracle).
Utilizando o paradigma orientado a objetos, ela possuía outra grande vantagem em
relação à maioria das linguagens de programação utilizadas na época. Ao invés de
gerar aplicações compiladas em código nativo, o código fonte será convertido em
bytecode que é interpretado em sua máquina virtual, a Java virtual Machine ou JVM.
Projetada para trabalhar em um ambiente heterogêneo, o Java só decolou com o
surgimento da internet. Por executar em uma máquina virtual, a aplicação escrita em
Java pode ser executada em praticamente qualquer sistema operacional, o que a
torna bastante versátil. Daí vem seu lema “Write once, run anywhere”

Um dos motivos da escolha do Java para Android é a grande comunidade em

torno da linguagem de programação.

No Google IO de 2019, a empresa de Mountain View anunciou que a partir

desta data o Android se torna Kotlin First. O que não quer dizer que o Java foi
abandonado! De acordo com a página de desenvolvedores Android (Google
Developers, n.d.), o Kotlin se tornou o padrão por ser compatível com o Android,
concisa, expressiva e projetada para ser type e null-safe. Além de funcionar
perfeitamente com o Java.

50
 Ela é uma linguagem de programação multiplataforma, orientada a objetos e
funcional, concisa, e estaticamente tipada, e compila o código para ser executado na
JVM, por isso, alguns pesquisadores apontam que o Kotlin é uma extensão do Java.
Foi desenvolvida pela JetBrains em 2011 e pode ser utilizada para desenvolvimento
de softwares estatísticos, para desktop, Android nativo, multiplataforma e web
(Kotlin Foundation).

Algumas das características do Kotlin:

• 100% de interoperabilidade com Java.

• O projeto pode ter classes das duas linguagens e elas se comunicam

abertamente, inclusive é possível criar herança entre classes de linguagens
diferentes.

• Funções de extensão (muito útil) (extension functions) – Permitem estender

a funcionalidade de classes já existentes, mesmo que não sejam suas.

• Null safety e type safety - “acabou o null pointer exception” do java

• Redução do boilerplate code, esta é uma linguagem Limpa e Expressiva

• Android Studio e Kotlin pertencem à IntelliJ - ao copiar uma classe java para
uma classe Kotlin, a IDE realiza a conversão.

Veja na pasta de códigos o exemplo IGTI Java vs Kotlin. Nele é possível

perceber como uma classe escrita em Java contendo 82 linhas pode ser convertida
em uma classe Kotlin de apenas oito, sim, oito linhas.

51
9
Capítulo 9. Principais Bibliotecas
O Android e seu framework evoluíram bastante nos últimos anos, como
devem ter notado ao longo do material. Com isso, muitas bibliotecas foram criadas,
gerando certa confusão para os desenvolvedores. A fim de padronizar a situação e
mitigar o problema, uma equipe de engenheiros do Google lançou o Android JetPack,
ou andoidx.

Este é um conjunto de bibliotecas que ajudam os desenvolvedores a

seguirem as melhores práticas para a construção de APPs, reduzindo o boilerplate
code, escrevendo código mais conciso e consistente, que é capaz de trabalhar de
maneira estável entre as diferentes versões do sistema operacional e tipos de
dispositivos. Assim, os desenvolvedores podem focar no código. O conjunto de
bibliotecas e apis do jetpack são atualizadas com frequência e sempre mantêm a
compatibilidade com as versões anteriores do Android. Serão apresentadas a seguir
as bibliotecas mais utilizadas.

Activity

Este é um componente crucial de um aplicativo Android e a forma como elas

– as activities – são lançadas e colocadas em conjunto é uma parte fundamental do
modelo de aplicação da plataforma. Como já discutido, o paradigma utilizado pelos
Apps android se difere de outros, onde o lançamento é realizado por intermédio de
um método main. Aqui, as activities são instanciadas pela chamada de métodos
callback específicos que correspondem a estados específicos do ciclo de vida da
aplicação. Ou seja, a aplicação pode ser iniciada em diferentes “Lugares”.

Isso quer dizer que a jornada do usuário sempre é iniciada de maneira não
determinística. Por exemplo, você pode abrir o aplicativo de e-mail utilizando o ícone
da aplicação e ir direto para a listagem da caixa de entrada, ou ele pode ser aberto ao

53
compartilhar o conteúdo de outro app por e-mail, onde você será direcionado para a
tela de edição.

Fragments

Vocês já foram apresentados à Activity e viram que ela é usada para definir,
exibir e controlar a interação com a interface do usuário, sendo uma responsável por
cada tela. Contudo, podemos criar um aplicativo com várias telas e uma única
activity. Isso é possível com o uso de fragments.

Os fragmentos podem ser vistos como “empacotadores” de recursos e

widgets. Em outras palavras, são literalmente fragmentos de telas que podem ser
utilizados para construir um layout mais complexo, para construir uma aplicação com
apenas uma activity e diversas telas ou também para customizar o layout do app de
acordo com o tipo de dispositivo, como smartphones ou tablets.

Quando os fragments são utilizados, o usuário fica trocando de fragmento

em fragmento quando necessário, por exemplo, ao clicar em um botão, ele pode ser
direcionado para outro fragment que será exibido na tela (Google Developers, n.d.).

AppCompat

O Android está no mercado há mais de 10 anos; para ser mais preciso,

completou, em setembro de 2021, 13 anos! Apesar do lançamento de novas versões
com uma boa frequência, a maioria dos dispositivos não recebe muitas atualizações
de seus fabricantes. Poucos deles receberão atualizações por mais de 2 anos, e o
pior, ainda existem aparelhos que nem as recebem. De uma versão para a outra, as
mudanças podem ser pequenas ou discrepantes.

A biblioteca AppCompat vem para auxiliar neste processo. Ela oferece uma
API para nossas activities e fragments que permite trabalhar com versões mais
recentes e mais antigas do Android. Quando o aplicativo for executado em uma
versão antiga, o APPCompat tenta preencher as funcionalidades faltantes da UI
sempre que possível. A desvantagem é que o uso dela torna o aplicativo maior, e

54
eleva um pouco a complexidade do desenvolvimento, contudo, será possível
executar sua aplicação sem problemas em versões mais antigas do sistema
operacional.

Navigation

Um aplicativo pode ter uma única tela com informações ou, como acontece
na maior parte dos casos, possuir diversas telas. Durante a interação, o usuário pode
clicar em um widget, como um botão, e ser direcionado para outra activity. Ao
pressionar o outro botão, ele será redirecionado à janela anterior.

Existe mais de uma maneira de controlarmos este fluxo. A primeira delas é

programaticamente, utilizando Java/Kotlin, que pode se tornar complexo algumas
vezes. A biblioteca Navigation provê uma forma de declarar como a movimentação
entre telas ocorrerá, por intermédio de um arquivo de recursos, utilizando o
assistente do Android Studio para auxiliar na definição do processo.

Lifecycles, ViewModel e LiveData

A maioria dos dispositivos que executam Android são smartphones e

Tablets, e estes podem ser utilizados na vertical ou horizontal, respectivamente
modo Portrait ou Landscape. Em capítulos passados, vimos como mudanças de
configuração podem afetar os aplicativos. Este é um dos pontos que merecem
atenção no desenvolvimento e que podem trazer problemas, principalmente para
desenvolvedores iniciantes.

Manter os dados salvos enquanto mudanças de configuração acontecem é

um aspecto importante, pois os usuários não gostam de perder as coisas. O Google
oferece dois componentes do Jetpack para nos ajudar com isso. Códigos especiais
que nos ajudam a lidar com o ciclo de vida da aplicação, e a classe Viewmodel, que
permite manter os dados quando mudanças de configuração acontecem. Para alguns
desenvolvedores, estas mudanças de configuração são uma dor de cabeça, para
outros são as threads. Elas são utilizadas para realizar trabalhos em segundo plano,

55
fora do fluxo principal de execução da aplicação, para mantê-la responsiva (Google
Developers, n.d.)!

O Live Data, gerenciado pelo ViewModel, veio para facilitar. Ele simplifica o
processo de monitoramento de dados alterados em segundo plano, notificando a
interface gráfica sempre que os dados estiverem disponíveis ou forem alterados.

Room

Localmente a forma mais segura de armazenar informações é por

intermédio do SQLite. Ele é uma biblioteca escrita em linguagem C e implementa
uma engine de banco SQL, pequeno, rápido, autocontido, altamente disponível, com
muitos recursos. Ele é o sistema de banco de dados mais utilizado no mundo e vem
embarcado em smartphones, computadores, dispositivos móveis e muito mais
(SQLite Consortium, n.d.).

O sqlite está disponível por intermédio uma biblioteca que também faz parte
do Jetpack. Apesar de ser uma API muito poderosa, ela possui um nível mais baixo,
ou seja, é mais complexo de ser utilizado, consumindo tempo e esforço de
desenvolvimento. Para facilitar a manipulação da base de dados, é extremamente
recomendado utilizar o Room persistence Library, uma camada de abstração para
acessar informação na base de dados sqlite da aplicação. Ele traz uma série de
benefícios, como estratégias de migração em caso de modificações na estrutura do
banco.

Worker Manager

Existem tarefas nos aplicativos que precisam ser executadas em segundo

plano, e para isso utilizamos threads, ou coroutines, em Kotin. Elas são utilizadas, por
exemplo, quando precisamos realizar tarefas de IO, entrada e saída de dados. Estes
processamentos são realizados bem próximos do tempo real de execução do APP.
Mas também existem tarefas que podem ser executadas em segundo plano,
independente da interface gráfica estar em uso naquele instante.

56
 Isso acontece, por exemplo, ao executar um tocador de música, ou quando o
aplicativo precisa realizar alguma tarefa de tempos em tempos. Várias soluções para
este problema foram disponibilizadas ao longo dos anos e com o Jetpack surgiu mais
uma, que atualmente é recomendada pelo Google, o WorkManager.

Ele é utilizado para agendar tarefas que precisam ser executadas em

segundo plano. Este agendamento pode ser baseado em períodos, como em algumas
horas, ou faça tão logo quanto possível. Também podem ser agendadas com base no
estado do dispositivo, como executar a tarefa durante o carregamento ou somente
quando estiver conectado ao WiFi. Então, o workmanager se organiza para executar
esta tarefa, mesmo se o usuário deixar a UI.

Android KTX

Como já discutido, a SDK do Android é desenvolvida em Java, logo o

desenvolvimento segue o padrão desta linguagem. De 2018 em diante, o Kotlin se
tornou a linguagem padrão para o desenvolvimento de aplicações, mantendo a
compatibilidade com o Java, assim como a Apple fez ao migrar do Objective-C para
Swift (Alura 2021) (Junior, n.d.) (Terminal Root 2019).

Para facilitar o trabalho dos desenvolvedores, o Google lançou o Android

KTX, uma biblioteca que é uma coleção de “Extention functions” criadas para tornar
os aspectos comuns da API em um formato mais próximo do Kotlin. Lembrando que
as Extension Functions são uma forma de a biblioteca adicionar novas funções a
alguma classe já existente, sendo sua ou não. O uso destas funções é idêntico à
utilização das funções originais da classe.

Testing

Nenhum projeto pode ser considerado completo se testes não forem

realizados! Para Michael Feathers: Code without tests is bad code, o que pode ser
traduzido livremente como: um código sem testes é um código ruim. A execução de
testes garantirá que seu aplicativo esteja correto, comportando-se de acordo com

57
suas especificações e usabilidade, antes de ser disponibilizado aos utilizadores. Os
testes fornecem as seguintes vantagens:

• Rápido feedback às falhas.

• Detecção dos erros ainda na etapa de desenvolvimento.

• Refatoração de código segura, permitindo que o código seja otimizado sem

se preocupar com regressões.

• Estabilidade na velocidade de desenvolvimento, ajudando a minimizar

débitos técnicos.

Este conjunto de bibliotecas lhe permite desenvolver diversos tipos de

testes, como unitários, testes instrumentados (mais próximos do processo de
execução da aplicação, utilizando a api do android em um dispositivo físico ou
emulado). E testes de UI, utilizando o expresso, por exemplo.

Compose

Esta é a mais recente e um dos maiores incrementos ao Jetpack. Ele

apresenta uma nova forma de desenvolvimento da interface gráfica, sem depender
dos arquivos XML, para isso, utiliza apenas o Kotlin. O compose se tornou estável
apenas em julho de 2021, mas vem ganhando força e pode se tornar um fator
importante no desenvolvimento de aplicações.

Apresentamos apenas algumas das bibliotecas que fazem parte do JetPack,

ainda existem muitas outras que permitem, por exemplo, controlar a câmera do
dispositivo, gerenciar dependências, ou vincular os componentes da UI com fontes de
dados em modo declarativo. Vocês podem consultar a lista completa em:
https://developer.android.com/jetpack/.

Existem muitas outras bibliotecas importantes no mundo do

desenvolvimento de aplicações Android, como as que serão apresentadas em
seguida.

58
Koin

Esta biblioteca auxilia o desenvolvedor a controlar as dependências internas

do projeto. Com ela é possível utilizar o padrão Injeção de dependências, utilizado
para manter um baixo nível de acoplamento entre diferentes módulos do sistema
(Valente 2020, #). Para isso, as dependências entre os módulos são definidas pela
configuração de uma infraestrutura de software, que será responsável por “injetar”
em cada componente as dependências declaradas.

Imagine uma classe, que internamente precisa gerar uma instância da classe
Y. Temos aqui uma dependência entre elas. Toda vez que o construtor de Y for
alterado, precisaremos alterar a criação do objeto na classe X que a utiliza. Com a
injeção de dependência, nós retiramos da classe X a responsabilidade de criar uma
instância de Y e passamos para quem vai consumi-la ou a alguma biblioteca que faça
isso por nós, e é aí que o Koin entra.

O koin é um framework para injeção de dependências leve e pragmático

(eficiente, objetivo e prático). Ele é uma DSL, domain specific language, construído
em kotlin, que ajuda a descrever sua aplicação sem a necessidade de annotations ou
a criação de código adicional para isso.

Retrofit

A maior parte das aplicações para dispositivos móveis não sobrevive

isoladamente, em algum momento será necessário se comunicar com algum serviço
disponível na internet para obter ou enviar dados. Este é o tipo de tarefa que exige
bastante tempo e esforço para ser concluída.

Para facilitar o processo, a Square, empresa desenvolvedora de software

conhecida pelas inúmeras bibliotecas open source criadas para nós desenvolvedores
de ambientes Android, Java e IOS. O retrofit nos permite consumir serviços de
maneira mais “fácil”, além disso, permite que o desenvolvedor determine qual será o
conversor utilizado para transformar o JSON em objetos, variáveis ou estruturas de
dados de nossas aplicações. Alguns desenvolvedores acham complexo a configuração

59
do retrofit, mas o esforço é compensado pela estabilidade e frequente atualização da
biblioteca.

Gson

Trabalhar com JSON em linguagens estaticamente tipadas, como o Java e

Kotlin, nem sempre é uma tarefa fácil, porém necessária ao trabalharmos com
serviços web. Existem diversas ferramentas utilizadas para isso, uma das mais
conhecidas é o GSON. Ela foi criada inicialmente para uso interno do Google, mas
posteriormente foi disponibilizada para a comunidade.

O GSON permite a Leitura de JSON em três modos: Conversão para objetos,

arrays ou valores. Em Kotlin, esta conversão é facilmente realizada utilizando-se
dataclasses.

Incluindo bibliotecas no projeto

As bibliotecas externas são incluídas e gerenciadas pelo Gradle, um

poderoso sistema de controle de build, ele possui arquivos de configuração do
projeto e arquivos para cada módulo presente. Sua configuração pode ser realizada
pelo editor de texto ou por intermédio do assistente gráfico. O modo textual pode
ser acessado abrindo a opção Project na barra de ferramentas de janela, como
ilustrado na figura 8, encontre a opção Gradle Scripts. Para projetos novos, ou que
possuem apenas um módulo, você encontrará dois arquivos build.gradle, um
correspondente ao projeto, que possui a marcação Project e outro do módulo,
marcado com a opção Module, como ilustrado na figura 23.

60
 Figura 23: Build gradle.

Ao abrir o arquivo correspondente ao módulo, você terá uma visão

equivalente ao exibido na figura 24. Observe na linha 37, o junit está destacado em
amarelo, isso pode indicar dependência possui atualizações ou que está usando uma
versão “genérica”, o símbolo de + ao final. Ao passar o mouse sobre ela será exibida
uma lâmpada amarela com sugestões de correção, clique nela e estará disponível a
opção de utilizar uma versão específica.

Para inserir dependências no modo textual, basta acessar a página oficial da

biblioteca desejada e verificar como ela deve ser inserida. Estas páginas já possuem a
linha que você precisa copiar e colar no arquivo de configuração. Veja que existem ao
menos duas tags diferentes: implementation que indica bibliotecas utilizadas na
construção de seu aplicativo, como o material design, recyclerview etc.;
testImplementation - utilizadas em testes unitários e androidTestImplementation,
utilizadas em testes instrumentados.

61
 Figura 24: Build gradle – módulo.

Outra possibilidade é editar este arquivo com o assistente. Para isso, utilize a
opção Open, que está no topo da janela do arquivo de configurações, ou vá em
File/Project Structure. Uma tela similar à apresentada na figura 25 será exibida. Abra
a guia Dependencies (dependências), ela mostra todas as dependências já instaladas
em seu projeto. Para incluir novas, clique no símbolo de mais, que está abaixo de All
Dependencies. Escolha Library Dependency.

Figura 25 – Configuração de dependências em modo gráfico.

62
 Na tela seguinte, digite o nome da biblioteca desejada, como
androidx.recyclerView; em seguida, inicie a busca. No resultado, as bibliotecas
estarão organizadas por GroupID, Artifact Name, Repository e no final é possível
escolher a versão. Em APPs de produção é sempre interessante utilizar a versão
estável do pacote. Em seguida, basta clicar em OK, OK novamente e aguardar o
processo de importação.

63
10
Capítulo 10. Arquitetura de Aplicações Android
Como todos os tipos de software, aplicativos Android também devem seguir
regras arquiteturais e padrões de projeto. As aplicações que não possuem uma
arquitetura bem definida podem até funcionar, mas, conforme crescem, tendem a se
tornar difíceis de serem mantidas, devido ao emaranhado de activities, fragments e
outras classes inconsistentes com padrões de design e comportamento.

Um dos conceitos fundamentais da computação é dividir para conquistar, ou

seja, a habilidade de quebrar um grande problema em problemas menores que
podem ser resolvidos isoladamente, e a união destas soluções resolve o todo. Em
conjunto com a capacidade de abstração, esta é uma ferramenta que nos ajuda a
atender a implementação de um sistema que atenda aos requisitos definidos pelo
Product Owner (Valente 2020).

Princípios de projeto

Princípios de projeto podem então ser vistos como diretrizes que garantem
que o projeto se mantenha aderente a determinadas propriedades, como integridade
conceitual – capacidade de manter a uniformidade do comportamento da aplicação
ou seja, o modo de operação similar em todos os módulos; ocultação de informação
– exibir apenas decisões de projeto que não são alteradas com frequência; coesão –
toda classe deve implementar uma única funcionalidade ou serviço; acoplamento –
força de ligação entre duas classes e expansibilidade – capacidade de fazer o sistema
crescer.

Para atender a estas propriedades, foram criados os princípios de projeto, o

SOLID é um dos mais conhecidos e utilizados (Valente 2020, #) (Paixão 2019) (Martin
2019, #)

65
 • Single responsibility Principle (responsabilidade única) – A classe deve ter
uma única responsabilidade. Ou seja, ela não deve ser responsável por exibir
a interface gráfica e persistir informações no banco de dados.

• Open/Closed principle - (Aberto/fechado) – A classe deve estar preparada

para se adaptar a diferentes cenários, por meio de expansão, se houver
necessidade de modificar seu código.

• Liskov substitution principle - (Substituição de liskov) – Determina condições

semânticas, não sintáticas, que subclasses devem atender para que um
programa funcione.

• Interface Segregation Principle (segregação de interfaces) – Caso especial da

responsabilidade única, define que interfaces precisam ser pequenas, coesas
e específicas para cada tipo de cliente. Ou seja, quebrar interfaces muito
genéricas em interfaces menores.

• Dependency inversion principle (inversão de responsabilidade) – O cliente

deve estabelecer as dependências com abstrações e não com
implementações concretas. (Prefira interfaces a classes)

Mais detalhes sobre o SOLID e outros princípios de projeto podem ser

encontrados em nossos cursos de arquitetura de software e em livros de engenharia
de software, como os presentes no referencial bibliográfico.

Padrões de projeto

Padrões de projeto são formas de resolver problemas que sempre

acontecem, através de uma solução que pode ser reutilizada. O nome padrões de
projeto vem do Livro de mesmo nome lançado em 1995 por Erich Gamma, Richard
Helm, Ralph Johnson e John Vlissides (Gang of Four). Uma citação bastante conhecida
do livro diz que “projetos de software correm sérios riscos de mudanças drásticas no

66
futuro se mudanças não forem levadas em consideração durante a elaboração”
(Gamma et al. 2006). O livro propõe três regras para entendimento dos padrões de
projeto:

1. Entender o problema que se deseja resolver;

2. Entender o contexto em que ele acontece;

3. Apresentação da solução proposta.

Os autores apresentam vinte e três padrões de projetos, divididos em:

• Criacionais - que propõem soluções para criação de objetos.

• Estruturais - soluções para composição de classes e objetos.

• Comportamentais - soluções para interação e divisão de responsabilidades

entre classes e objetos.

A API do Android utiliza extensivamente os padrões de projeto em sua

construção. O padrão Observer (observador) é muito utilizado no desenvolvimento
de aplicações para Android e foi escolhido para uma breve descrição.

No desenvolvimento de aplicações, é muito comum termos objetos que

podem ser alterados durante a execução do APP. Estas alterações podem, por
exemplo, ser reflexo de uma tarefa que está em execução no segundo plano e o
resultado pode modificar o comportamento do software. A activity deve ter apenas o
trabalho de interagir com a interface gráfica e possuir apenas a lógica relacionada a
este processo. Então, os projetos terão ao menos uma activity e mais uma classe
responsável por estes dados. Todas as modificações no modelo devem ser refletidas
em atualizações na interface do usuário.

Problema: Não gerar um acoplamento entre o modelo e a activity, porque

ela pode sofrer muitas mudanças e ainda ser destruída em caso de mudanças na

67
configuração do dispositivo. Além disso, o mesmo modelo pode ser utilizado por
diversas activities em instantes diferentes e todos devem reagir às mudanças nos
dados.

Solução: O padrão observer é uma solução recomendada para este contexto

e problema, pois permite criar uma relação do tipo um para muitos entre objetos
observáveis (sujeitos) e observadores. Desta maneira, sempre que uma modificação
acontecer no objeto observável, os objetos observadores receberão uma notificação
para que ações possam ser tomadas. Isso permite executar uma tarefa, como
consultar o banco de dados, sem interromper a interação com a interface gráfica.

Arquitetura de software

Se buscarem na literatura, vocês encontrarão diversas definições para

arquitetura de software, Architecture is about the important stuff. Whatever that is. –
Ralph Johnson. A arquitetura representa as decisões significativas de design que
moldam um sistema onde a significância é medida pelo custo da mudança - Grady
Booch. Se você acha que uma arquitetura boa é cara, experimente uma arquitetura
ruim. Brian Froote e Joseph Yoder.

De maneira bastante genérica, pode-se dizer que a arquitetura de software

está ligada com a organização da aplicação, e o modo como seus módulos interagem
interna e externamente. Estas decisões são importantes e, uma vez tomadas,
dificilmente poderão ser revertidas no futuro, principalmente se o software crescer
demasiadamente. Não é à toa que alguns sistemas ainda trabalham com bancos de
dados não relacionais e linguagens como Cobol (Valente 2020).

Para auxiliar neste processo, existem os padrões arquiteturais que propõem

uma organização de mais alto nível para sistemas de software, conforme destacado
pelo professor Marco Túlio Valente no livro Engenharia de Software moderna
(Valente 2020).

68
 A arquitetura em camada, utilizada, por exemplo, na pilha do protocolo
tcp/ip, é um destes modelos. Existem outros, como Arquitetura MVC, muito utilizada
em aplicações WEB, Micro Serviços, utilizados em APIs, publish and subscribe,
orientada a mensagens etc. Apesar de ser possível utilizar algumas destas
arquiteturas para aplicações Android, o Google apresenta sugestões que melhor se
adequam a este cenário.

Para que uma arquitetura tenha sucesso, é preciso que o desenvolvedor

fique atento a ao menos três pontos: Simplicidade - Muitas partes e uma forte
dependência entre elas pode tornar difícil o trabalho, principalmente ao longo do
tempo; Manutenibilidade - Deve existir o mínimo possível de dependências do
mundo exterior, ou seja, se por exemplo, um repositório possui componentes que
dependem do framework do Android, e a biblioteca deixa de ser suportada, em
algum momento precisaremos substituí-la; Flexibilidade - Possibilidade de realizar
mudanças de maneira mais fácil. Em aplicações móveis, a arquitetura escolhida deve
proporcionar independência entre a camada lógica e a camada de UI. Isso permite
que modificações possam ser realizadas na lógica do negócio sem que seja preciso
modificar a interface do usuário.

Arquitetura de apps Android

Como apresentado antes, o comportamento de aplicativos para dispositivos

móveis difere do comportamento da maioria dos aplicativos. Ele é formado por
múltiplos componentes, que incluem activities, fragments, services, content providers
e broadcast receivers. A maior parte destes são declarados no app manifest, arquivo
utilizado pelo sistema operacional para decidir como integrar o aplicativo com o
comportamento geral do usuário. Lembre-se: aplicativos Android são formados por
muitos componentes; o usuário pode interagir com múltiplos aplicativos em um
pequeno período; e estes aplicativos precisam se adaptar a este fluxo de trabalho.
Além disso, os dispositivos móveis possuem recursos limitados e o sistema
operacional pode eliminar a aplicação sempre que precisar de mais recursos.

69
 A equipe de desenvolvimento do Android define arquitetura de software
como as barreiras entre partes de um APP e as responsabilidades que cada parte
deve ter. Isso mantém o princípio da separação de responsabilidades, que traz
diversos benefícios, como já mencionamos (Google Developers). Um exemplo do que
não é separação de responsabilidade é implementar a lógica da aplicação nas
activities ou fragments.

De acordo com Google Developers, uma aplicação android deve possuir ao

menos duas camadas, User Interface, Data Layer e Domain Layer, opcional. A
camada de interface do usuário, também chamada de camada de apresentação, é
responsável pela exibição de dados na tela. A interface deve se adaptar às interações
do usuário, como pressionar botão, ou entradas externas, como resposta a uma
consulta da rede. A camada de UI é feita de duas coisas: Elementos de UI,
responsáveis pela renderização, utilizando as Views ou, recentemente, as funções do
Jetpack Compose. Gerenciadores de estado como as classes ViewModel,
responsáveis por manter os dados independentes do ciclo de vida das activities.

A data layer de uma aplicação android contém a lógica do negócio, ela é o

que dá valor ao seu aplicativo. Esta camada determina como ele cria, armazena e
altera os dados, sendo composta por repositórios que podem conter de zero a
diversas bases de dados. É necessário criar uma classe para cada repositório, para
cada tipo diferente de dados que sua aplicação precisar manipular. Por exemplo,
você pode criar uma Classe chamada VeiculosRepositorio para dados relacionados a
veículos, ou uma classe PagamentoRepositório para manipular dados de
pagamentos.

A camada de dados possui as classes de repositório que devem ser

responsáveis pelas seguintes tarefas:

• Centralização das mudanças nos dados.

• Resolução de conflitos entre múltiplas fontes de dados.

70
 • Abstração das fontes de dados do restante da aplicação.

• Expor dados para o restante da aplicação.

Cada classe de dados será responsável por uma e apenas uma fonte de
dados, como recursos online, ou um banco de dados local. Ou seja, ela será uma
ponte entre a aplicação e o sistema para operações de dados.

Domain layer é uma camada opcional, responsável por encapsular regras de

negócio que são mais complexas ou regras de negócio que podem ser reutilizadas por
múltiplos ViewModels. Ela é opcional porque nem todas as aplicações têm este
requisito, ou seja, utilize apenas se for necessário, assim você reduz a complexidade
da aplicação e facilita sua escalabilidade.

Outro importante tópico ao construir aplicações android é a gerência das

dependências entre componentes, pois as classes do projeto dependem de outras
classes para funcionar corretamente. Existem dois padrões de projeto que podem ser
utilizados: Injeção de dependência - Permite que a classe determine suas
dependências sem construí-las; Service locator - padrão que provê um registro onde
classes podem obter suas dependências, no lugar de construí-las.

A documentação recomenda o uso da injeção de dependências utilizando a

biblioteca Hilt, mas existem outras que nos permitem realizar o mesmo trabalho e
são muito utilizadas, como o Koin.

71
11

72
Capítulo 11. Avançando na Prática
No último vídeo, foi desenvolvido um aplicativo capaz de registrar frases,
que foram armazenadas em uma lista na memória RAM do dispositivo, ela será
utilizada para simular a persistência de dados utilizando um repositório. Além disso,
você também utilizará o viewBinding, Observer e Livedata.

Até o momento, os exemplos apresentados utilizavam o comando

findViewById para criar uma conexão entre a view definida no XML e a activity,
armazenada no arquivo com a extensão .Kt. Este modo de associação existe desde a
primeira versão da SDK e, para reduzir a repetição de códigos, a equipe de
desenvolvimento do Android criou uma biblioteca chamada viewBinding. Uma vez
habilitada, ela cria uma classe para cada layout XML presente no módulo, com
referência a todos os seus widgets.

Para habilitar o viewBinding, basta adicionar as seguintes linhas ao

build.gradle do módulo desejado, como exibido na figura 26. O acesso aos elementos
agora é feito por intermédio de um objeto que representa a classe criada pela
biblioteca. como ilustrado no exemplo da figura 27. Observe que agora existe um
atributo chamado binding que aponta para ResultProfilingBinding, classe criada para
representar o layout do arquivo result_profile.xml.

Figura 26 – Ativando o viewBinding.

Figura 27 – Ativando o viewBinding

73
 Figura 27 – Ativando o viewBinding.

Existem duas principais vantagens do viewBiding em relação ao

findiViewById:

1. Ele elimina o risco de gerar uma exceção por tentar acessar um

objeto nulo, porque gera uma referência direta às views;

2. Também elimina o risco de gerar uma exceção por conversão de

tipos incorretos, devido à geração da classe de modo automático.

Neste projeto, também foi utilizado o Recycler View para exibir a lista de
frases salvas. Este componente é responsável por criar uma lista de itens e reutilizar
cada componente, otimizando assim o seu funcionamento. Para utilizá-lo, é
necessário criar um widget de mesmo nome no arquivo de layout e, junto,
determinar se a lista será exibida em linha, em formato de grade ou em grade
otimizado, onde o número de linhas e colunas não precisam ser os mesmos.

O próximo passo é criar o adapter e o viewholder, classes que trabalham em

conjunto para determinar como os dados devem ser exibidos na tela. O viewholder
determina o layout para cada item da lista, enquanto o adapter cria o viewholder
conforme for necessário e, em seguida, atribui a ele os dados que devem ser
exibidos. Três métodos são importantes neste processo: onCreateViewHolder –
Chamado sempre que for necessário criar um ViewHolder; onBindViewHolder –
responsável por associar a view ao dado; e getItemCount – chamado para saber a
quantidade de itens do conjunto de dados.

74
 O ViewModel foi utilizado para manter os dados da aplicação, mesmo em
caso de mudanças no ciclo de vida. Nele, criamos um objeto LiveData, classe capaz de
armazenar dados observáveis. Além de reconhecer o ciclo de vida da aplicação, ela
também permite que a interface gráfica seja atualizada utilizando observadores, do
padrão Observer, discutido anteriormente.

No exemplo deste capítulo, utilizamos um MutableLiveData, que permite a

alteração do conteúdo durante a execução do APP. Os objetos deste tipo podem ter
seus dados alterados de duas maneiras; diretamente, utilizando objeto.value = valor,
onde objeto é o liveData, e value o valor armazenado por ele. Valor representa o
dado que se deseja salvar neste momento. Esta forma de atribuição só é possível na
corroutine principal, se estiver trabalhando em outra coroutine, será necessário
utilizar o método objeto.postvalue(valor). As corrotinas serão estudadas em módulos
futuros. Deste modo, sempre que alteramos o valor do nosso objeto liveData,
automaticamente será disparado um evento de alteração da view, como
demonstrado no exemplo.

75
Referências
ALURA. 2021. “Kotlin vs Java - Qual escolher | Android.” Alura. Disponível em:
<https://cursos.alura.com.br/forum/topico-kotlin-vs-java-qual-escolher-170448>.
Acesso em: 26 abr. 2022.

CASS, Stephen. 2021. “Top Programming Languages 2021.” Top Programming

Languages 2021. Disponível em: <https://spectrum.ieee.org/top-programming-
languages-2021>. Acesso em: 26 abr. 2022.

FIGUEIREDO, Carlos M., and NAKAMURA, Eduardo. 2003. “Computação móvel: Novas
oportunidades e novos desafios.” T & C Amazônia 1:21.

GAMMA, Erich. HELM, Richard. JOHNSON, Halp. VLISSIDES, John. 2006. Padrões de
Projetos: Soluções Reutilizáveis. N.p.: Bookman.

GeeksForGeeks. 2021. “Difference Between Dalvik and ART in Android.”

GeeksforGeeks. Disponível em: <https://www.geeksforgeeks.org/difference-
between-dalvik-and-art-in-android/>. Acesso em: 26 abr. 2022.

Genymobile. n.d. “Genymobile/scrcpy: Display and control your Android device.”

GitHub. Disponível em: <https://github.com/Genymobile/scrcpy>. Acesso em: 26 abr.
2022.

Google Developers. n.d. “Android Developers.” Android Developers. Disponível em:

<https://developer.android.com/>. Acesso em: 26 abr. 2022.

JUNIOR, Deusemar. n.d. “Java vs Kotlin: Vantagens, Desvantagens e Performance.”

Zup. Disponível em: <https://www.zup.com.br/blog/java-vs-kotlin-vantagens-
desvantagens>. Acesso em: 26 abr. 2022.

JUNIOR, Eler, and Ildeir De Oliveira. 2019. Sistema de computação móvel para
gerenciamento de informações relacionadas a objetos do espaço físico. N.p.: UFOP.

76
Kotlin Foundation. n.d. “Kotlin Programming Language.” Kotlin Programming
Language. Disponível em: <https://kotlinlang.org/>. Acesso em: 26 abr. 2022.

MARTIN, Robert C. 2019. Arquitetura Limpa: O guia do artesão para estrutura e

design de software. N.p.: Alta Books.

MATEUS, Geraldo R., and Antônio A. Loureiro. 1998. Introdução à computação móvel.
11a ed. Rio de Janeiro: Escola de computação.

MEDEIROS, Henrique. 2021. “Mobile responde por 76% das vendas do Magazine
Luiza.” Mobile Time. Disponível em:
<https://www.mobiletime.com.br/noticias/09/03/2021/mobile-responde-por-76-
das-vendas-do-magazine-luiza/>. Acesso em: 26 abr. 2022.

Mobile Time. n.d. “O brasileiro e seu smartphone - julho de 2021 - Panorama Mobile
Time/Opinion Box.” Mobile Time. Disponível em:
<https://www.mobiletime.com.br/pesquisas/o-brasileiro-e-seu-smartphone-julho-
de-2021/>. Acesso em: Acesso em: 26 abr. 2022.

MURER, Ricardo. 2012. “Introdução às plataformas de software.” Webinsider.

Disponível em: <https://webinsider.com.br/introducao-as-plataformas-de-
software/>. Acesso em: 26 abr. 2022.

PAIXÃO, João Roberto d. 2019. “O que é SOLID: O guia completo para você entender
os 5 princípios da POO.” Medium. Disponível em:
<https://medium.com/desenvolvendo-com-paixao/o-que-%C3%A9-solid-o-guia-
completo-para-voc%C3%AA-entender-os-5-princ%C3%ADpios-da-poo-
2b937b3fc530>. Acesso em: 26 abr. 2022.

PINHEIRO, Juliana S. 2020. Análise do desenvolvimento de aplicativos mobile nativos e

multiplataforma. N.p.: Universidade Federal de Santa Catarina.

77
Platform Hunt. 2016. “The 9 Types of Software Platforms | by Platform Hunt |
Platform Hunt.” Medium. Disponível em: <https://medium.com/platform-hunt/the-
8-types-of-software-platforms-473c74f4536a>. Acesso em: 26 abr. 2022.

SQLite Consortium. n.d. “SQLite Home Page.” SQLite Home Page. Disponível em:
<https://www.sqlite.org/index.html>. Acesso em: 26 abr. 2022.

Statcounter. n.d. “Global stats.” Statcounter Global Stats - Browser, OS, Search
Engine including Mobile Usage Share. Disponível em: <https://gs.statcounter.com/>.
Acesso em: 26 abr. 2022.

Terminal Root. 2019. “Java VS Kotlin: Quais são as principais diferenças entre elas?”
Terminal Root. Disponível em: <https://terminalroot.com.br/2019/10/java-vs-kotlin-
quais-sao-as-principais-diferencas-entre-elas.html>. Acesso em: 26 abr. 2022.

Tiger Mobiles. n.d. “Evolution of the Mobile Phone - History and Timeline -
TigerMobiles.com.” Tiger Mobiles. Disponível em:
<https://www.tigermobiles.com/evolution/#start>. Acesso em: 26 abr. 2022.

TrendForce. n.d. “TrendForce.” | TrendForce - Market research, price trend of DRAM,

NAND Flash, LEDs, TFT-LCD and green energy, PV. Disponível em:
<https://www.trendforce.com/>. Acesso em: 26 abr. 2022.

Use mobile. n.d. “Aplicativo nativo, híbrido e webapp: o que são e qual o melhor?”
Usemobile. Disponível em: <https://usemobile.com.br/aplicativo-nativo-web-
hibrido/>. Acesso em: 26 abr. 2022.

VALENTE, Marco T. 2020. Engenharia de Software Moderna: Princípios e Práticas

para Desenvolvimento de Software com Produtividade.

We are social. 2021. “Digital 2021.” We Are Social. Disponível em:

<https://wearesocial.com/uk/blog/2021/01/digital-2021-uk/>. Acesso em: 26 abr.
2022.

78