DESENVOLVIMENTO
MOBILE ANDROID
Módulo 1
FIT-F.1.24.01-02 Rev.B
6
Apostila do aluno
André Toyama
Autor da apostila
Larissa Jessica Alves – Analista de Suporte Pedagógico
Revisão da apostila
Fit Instituto de Tecnologia
Sorocaba, fevereiro de 2022
FIT-F.1.24.01-02 Rev.B
7
AUTOR
André Toyama
Formado em bacharelado em ciência da computação
pela Universidade de São Paulo, possui mais de 15
anos de experiência com desenvolvimento de sistemas
de alta complexidade, liderança de equipe, diretor
técnico e executivo. Empreendedor desde 2013, fundou
a LB (www.littleboat.com.br) no qual executou com
sucesso mais de 180 projetos de tecnologia em diversas áreas. Trabalhou com
tecnologias de realidade virtual, realidade aumentada, gamificação, aplicativos,
digitalização de processos, plataformas financeiras, marketplaces, games, entre
outros.
Desde 2016 atua como CTO de startups que ajudou a construir, fornecendo
desenvolvimento e tecnologia de ponta. Em 2010 coordenou uma escola, sendo autor
e professor por mais de 5 anos de cursos de desenvolvimento mobile e games.
Capacitou mais de 500 alunos em cursos de pós-graduação, cursos de extensão para
graduação e em escola especializada de tecnologia mobile.
FIT-F.1.24.01-02 Rev.B
8
APRESENTAÇÃO
A presente apostila é um instrumento teórico que complementa o curso de
capacitação de Desenvolvimento Mobile Android – Módulo 1, promovido pelo FitInstituto de Tecnologia, para colaboradores do Fit Instituto de Tecnologia, Flextronics
e comunidade. Nela, veremos os conceitos do sistema operacional Androide os
primeiros passos para iniciar o desenvolvimento de aplicativos. Este material é
baseado em artigos científicos, periódicos, revistas científicas e livros científicos. É
extremamente recomendável ao aluno que, ao final da leitura de cada seção, realize
os exercícios propostos e acesse os materiais indicados nas referências
bibliográficas, para aprofundar a leitura desse material e complementar o que foi lido
aqui.
A apostila está dividida em cinco seções, iniciando com o sistema operacional,
ambiente de desenvolvimento, fundamentos da linguagem Kotlin, layout de
aplicativos Android e componentes iniciais.
Desejo a você, prezado aluno, que tenha um excelente curso!!
Boa Leitura!!
FIT-F.1.24.01-02 Rev.B
9
IINDICAÇÕES DE ÍCONES
FIT-F.1.24.01-02 Rev.B
10
SUMÁRIO
1
SISTEMA OPERACIONAL ANDROID .................................................. 14
1.1 CONCEITO DE SISTEMA OPERACIONAL ..................................................... 14
1.2 HISTÓRIA DO ANDROID .......................................................................... 16
1.3 LICENÇA E VERSÕES ............................................................................. 17
1.4 ANDROID PARA OUTRAS APLICAÇÕES ...................................................... 21
1.4.1 Wear OS ...................................................................................... 21
1.4.2 Android Auto ................................................................................ 22
1.4.3 Android TV ................................................................................... 22
1.5 MERCADO MOBILE ................................................................................. 22
2
AMBIENTE DE DESENVOLVIMENTO .................................................. 24
2.1 PORTAL DO DESENVOLVEDOR................................................................. 24
2.1.1 Plataforma ................................................................................... 24
2.1.2 Android Studio ............................................................................. 25
2.1.3 Google Play ................................................................................. 25
2.1.4 Jetpack ........................................................................................ 25
2.1.5 Kotlin............................................................................................ 26
2.1.6 Documentos ................................................................................ 26
2.1.7 Notícias........................................................................................ 26
2.2 CONFIGURANDO O AMBIENTE ................................................................. 27
2.2.1 Download..................................................................................... 27
2.2.2 Instalação .................................................................................... 29
2.3 IDE ...................................................................................................... 38
2.4 BIBLIOTECA, APIS, SDK E FRAMEWORKS ............................................... 38
2.5 ANDROID STUDIO .................................................................................. 39
2.6 PRIMEIRO PROJETO ............................................................................... 40
2.7 SETORES DO ANDROID STUDIO .............................................................. 48
2.7.1 Estrutura do projeto ..................................................................... 49
2.7.2 A interface do usuário .................................................................. 50
2.7.3 Janelas de ferramentas ............................................................... 51
2.8 PRIMEIRO CÓDIGO ................................................................................. 52
2.9 ARQUIVO APK ...................................................................................... 53
FIT-F.1.24.01-02 Rev.B
11
2.10
3
COMPILAÇÃO ..................................................................................... 54
LINGUAGEM KOTLIN ........................................................................... 55
3.1 HISTÓRIA .............................................................................................. 55
3.2 DIFERENÇAS ENTRE JAVA ..................................................................... 56
3.3 TIPOS DE VARIÁVEIS .............................................................................. 57
3.3.1 Números ...................................................................................... 58
3.3.2 O Tipo Booleano .......................................................................... 60
3.3.3 Strings ......................................................................................... 60
3.3.4 Vetores ........................................................................................ 61
3.3.5 Comentários ................................................................................ 61
3.3.6 Nullable e not-null assertion ........................................................ 62
3.3.7 Lateinit ......................................................................................... 63
3.4 CONTROLE DE FLUXO ............................................................................ 63
3.4.1 If................................................................................................... 63
3.4.2 When ........................................................................................... 64
3.4.3 For ............................................................................................... 65
3.4.4 While............................................................................................ 66
3.5 PARADIGMA ORIENTADO À OBJETOS ........................................................ 66
3.5.1 Classes ........................................................................................ 67
3.5.2 Propriedades ............................................................................... 69
3.5.3 Métodos ....................................................................................... 70
3.5.4 Heranças ..................................................................................... 71
3.5.5 Associação .................................................................................. 72
3.5.6 Encapsulamento .......................................................................... 72
3.5.7 Abstração .................................................................................... 73
3.5.8 Instancia ...................................................................................... 73
3.5.9 Polimorfismo ................................................................................ 73
4
FUNDAMENTOS DE LAYOUT E USABILIDADE ................................. 74
4.1 CONCEITO DE UX E UI ........................................................................... 74
4.2 GUIDE LINE DO ANDROID ....................................................................... 76
4.3 ARQUIVO XML DE INTERFACES............................................................... 77
4.4 DENSIDADE DE PIXELS ........................................................................... 78
FIT-F.1.24.01-02 Rev.B
12
4.5 TIPOS DE LAYOUT ................................................................................. 81
4.5.1 Layout Linear ............................................................................... 81
4.5.2 Layout Relativo ............................................................................ 83
4.5.3 Visualização Web ........................................................................ 84
4.6 TIPOS DE NAVEGAÇÃO ........................................................................... 85
4.7 DIFERENÇAS ENTRE WEB E MOBILE ......................................................... 87
4.8 CICLO DE VIDA ...................................................................................... 87
4.9 DESIGN PATTERN MVC E MVVM ........................................................... 90
4.9.1 MVC............................................................................................. 91
4.9.2 MVVM .......................................................................................... 93
5
COMPONENTES INICIAIS .................................................................... 94
5.1 COMPONENTE TEXTVIEW ....................................................................... 97
5.2 ARQUIVO DE VALUES ........................................................................... 101
5.3 COMPONENTE BUTTON ........................................................................ 103
5.4 COMPONENTE PLAINTEXT E TEXTINPUTLAYOUT .................................... 105
5.5 COMPONENTE SWITCH ........................................................................ 110
5.6 COMPONENTE CHECKBOX .................................................................... 111
5.7 COMPONENTE CHIP ............................................................................. 112
5.8 COMPONENTE RADIOBUTTON E RADIOGROUP....................................... 113
5.9 COMPONENTE SEEKBAR, DISCRETE E PROGRESSBAR ........................... 115
5.10
COMPONENTE DIALOG E TOAST ........................................................ 122
5.11
MUDANDO DE TELA .......................................................................... 124
CONCLUSÃO.............................................................................................. 128
2.
CONTROLE DE REVISÃO DO DOCUMENTO / DOCUMENT REVISION
CONTROL 128
REFERÊNCIAS ........................................................................................... 129
FIT-F.1.24.01-02 Rev.B
13
1 Sistema Operacional Android
Android é um sistema operacional que foi construído para controlar
dispositivos móveis como smartphones, tablets, televisores, carros e relógios
inteligentes. O sistema foi baseado no núcleo do sistema operacional Linux,
com grande colaboração da empresa Google.
A licença do código do Android é aberta, porém a maior parte dos
dispositivos lançam com uma combinação de software livre e privado. O
conceito de Open Source Software (OSS), ou código aberto, é um código
projetado com total acesso ao público com permissões de visualização, edição
e distribuição além de uma caraterística de desenvolvimento descentralizado
e colaborativa.
1.1
Conceito de sistema operacional
Em uma visão geral, o sistema operacional é um conjunto de programas
capaz de gerenciar os recursos de hardware e fornecer uma interface entre o
computador e o usuário.
Figura 1: camadas de interação do computador. Fonte: Wikipedia.org.
Nos anos de 1945 até 1955, a primeira geração de computadores era
enorme, ocupando salas ou andares inteiros. Eram construídos basicamente
com válvulas e painéis com o objetivo de realizar cálculos matemáticos. Os
sistemas operacionais eram inexistentes e os programadores eram os
operadores desses equipamentos.
FIT-F.1.24.01-02 Rev.B
14
Com a evolução dos computadores nos anos 70 a 80, começaram a surgir os
primeiros computadores pessoais gerando uma grande necessidade de sistemas
operacionais para controlar os dispositivos para usuários comuns utilizarem.
Atualmente os computadores domésticos são amplamente utilizados no dia a
dia das pessoas e existem diversos sistemas operacionais como o Linux, Windows,
MacOS, entre outros.
De forma semelhante aos computadores, os smartphones também possuem a
necessidades de sistemas operacionais cada vez mais robustos e atualmente
destacamos os principais: Android e o iOS (Apple).
As principais funções de um sistema operacional são:
•
Gerenciamento de Processos: O sistema operacional multitarefa é
preparado para dar ao usuário a ilusão que o número de processos em
execução simultânea no computador é maior que o número de
processadores instalados. Cada processo recebe uma fatia do tempo e
a alternância entre vários processos é tão rápida que o usuário pensa
que sua execução é simultânea.
•
Gerenciamento de Memória: Assegurar que cada processo tenha seu
próprio espaço de endereçamento, começando em zero, para evitar ou
resolver o problema de relocação (TANENBAUM, 1999). Proteção e
segurança da memória para impedir que um processo ou software utilize
um endereço de memória que não lhe pertença.
•
Gerenciamento de Recursos: Uma das tarefas com extrema
importância atribuída ao sistema operacional é o gerenciamento de
recursos, que tem a função de definir políticas para gerenciar o uso dos
recursos de hardware pelos aplicativos, resolvendo disputas e conflitos.
Vários programas de entrada de dados competem pela vez na CPU
(Unidade Central de Processamento) e demandam memória, espaço
em disco e largura.
•
Entrada e saída de dados: Sistemas operacionais controlam e
gerenciam a entrada e saída de dispositivos de hardware como um
recurso compartilhado, fornecendo acesso de acordo com as políticas
que tornam a partilha justa e segura. Define uma interface de alto nível
FIT-F.1.24.01-02 Rev.B
15
que esconde detalhes e permite que um programador possa usar um
conjunto coerente e uniforme das operações ao interagir com os
dispositivos.
•
Sistema de arquivos: A memória principal do computador é volátil,
necessitando métodos para armazenar e recuperar informações de
modo permanente. Um arquivo é um conjunto de bytes, normalmente
armazenado em um dispositivo periférico não volátil, que pode ser lido
e gravado por um ou mais processos.
•
Interface de uso: Os sistemas operacionais fornecem abstração
de hardware para que seus recursos possam ser usados de maneira
correta e padronizada, mas para ser possível operar um computador, é
necessário fornecer também uma interface para que o usuário possa
desfrutar dos recursos do sistema.
1.2
História do Android
Na década dos anos 90 o termo smartphone ainda não existia, mas em
1992 foi lançado o primeiro aparelho que incluía múltiplas funções,
desenvolvido pelo designer norte-americano Frank Canova para a IBM. Além
de fazer e receber chamadas, o IBM Simon enviava e-mails, tinha um
calendário, calculadora e bloco de notas, e era considerado “o telefone do
futuro”. Ele foi comercializado em 1994 e vendeu cerca de 50 mil unidades.
Na década seguinte os aparelhos celulares deram passos importantes
para a sua evolução lançando aparelhos com múltiplas funções tais como:
câmeras digitais, acesso à internet, navegadores, entre outros. No ano de 2003
a empresa Android Inc. foi criada na cidade de Palo Alto, Califórnia. Os
fundadores da empresa tinham como objetivo desenvolver dispositivos móveis
com um nível de inteligência maior, ajudando o dia a dia dos usuários.
Inicialmente, o foco foi desenvolver um sistema operacional avançado para
câmeras digitais, porém perceberam que o mercado poderia ser muito mais
amplo se criassem para celulares.
A empresa Google adquiriu Android Inc. em 17 de agosto de 2005, mas pouco
se sabia sobre a empresa naquele momento e especulavam que o Google estava
planejando entrar no mercado de dispositivos móveis. Nesse período, o Google
FIT-F.1.24.01-02 Rev.B
16
desenvolveu um sistema operacional móvel tendo como base o Kernel Linux e como
estratégia e peso no nome, foram criando parcerias com empresas fabricantes de
celular e operadoras prometendo prover um sistema flexível, atualizável e com
tecnologia de ponta.
Em 2007 iniciou a era dos smartphones com o lançamento do primeiro iPhone
no mercado pela Apple. Em 5 de novembro do mesmo ano a Open Handset Alliance,
consórcio de tecnologia entre empresas do ramo incluindo Google, fabricantes de
telefones como HTC, Sony e Samsung, operadoras de telefonia como Sprint
Nextel e T-Mobile e fabricantes de chipsets como Qualcomm e a Texas Instruments
se revelaram com o objetivo de criar uma plataforma de padrão aberto para
dispositivos móveis, o Android. O primeiro smartphone disponível comercialmente
rodando o Android foi o HTC Dream, lançado em 22 de outubro de 2008.
Em 2010 o Google apresentou sua série de dispositivos Nexus, uma linha
de smartphones e tablets rodando o sistema Android e sendo fabricado por empresas
parceiras. Desde então o Google tem atualizado sua linha com novos dispositivos
como, por exemplo, o Nexus 5, feito pela LG e o Nexus 7, feito pela Asus. O Google
tem como objetivo através dos lançamentos Nexus mostrar as últimas atualizações
de software e hardware do Android, sendo estes dispositivos tidos como carroschefes do Android.
Desde 2008 o Android tem recebido inúmeras atualizações que incrementaram
substancialmente o sistema, adicionando novas funcionalidades e consertando erros
de versões anteriores. A cada grande atualização o codinome do sistema muda, em
ordem alfabética, entre nomes de doces.
Atualmente a plataforma Android é o sistema operacional móvel mais usado
no planeta Terra com cerca de 3 bilhões de telefones Android ativos em operação.
1.3
Licença e Versões
O projeto Android é de código aberto, isto é, o código fonte do sistema
operacional é público. O Google se posiciona a frente do projeto lançando publicações
de versões do código sob a licença CopyleftApache versão 2.0, que permite
modificações e redistribuições. A licença não garante direitos sobre o uso da marca
Android, mas sim a utilização do código fonte, portanto as operadores e fabricantes
de celulares devem realizar contratos individuais para utilizar a marca.
FIT-F.1.24.01-02 Rev.B
17
A Licença Apache (Apache License em inglês) é uma
licença de software livre permissiva de autoria da Apache
Software Foundation (ASF). Todo software produzido pela
ASF ou qualquer um dos seus projetos e subprojetos é
licenciado de acordo com os termos da licença Apache.
Alguns projetos não pertencentes à ASF também utilizam
esta licença. A licença Apache (versões 1.0, 1.1 e 2.0)
exigem a inclusão do aviso de copyright e um disclaimer,
mas não é uma licença copyleft - ela permite o uso e
distribuição do código fonte tanto no software open source
como no software proprietário.
Enquanto o Android em si é de código aberto, a maior parte dos
dispositivos são colocados à venda com uma grande quantidade de softwares
particulares, como os apps do Google Mobile, que incluem a Google Play
Store, Google Search, Google Pay Services, entre outros. Diversos aplicativos
nativos do Android que costumavam ser de código aberto, como a Pesquisa,
Música e Calendário, passaram a ser de código fechado e começaram a ser
distribuídos pela loja de aplicativos do Google com os novos nomes de
Pesquisa Google, Google Play Music e Google Calendário.
Desde abril de 2009, as versões Android foram desenvolvidos sob um
codinome de nome de doces (exceto Android 1.0 e 1.1) e lançadas em ordem
alfabética: Cupcake, Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice
Cream Sandwich, Jelly Bean, Kitkat, lollipop, Marchmallow, Nougat, Oreo e
Pie. Essa tradição durou até 2019, quando o Android passou a ser batizado
apenas pela sua versão e não mais pelo nome de um doce. A ideia nasceu em
uma brincadeira interna dos desenvolvedores, mas se tornou uma marca
registrada da plataforma, com grande aceitação por parte do público. A Google
coloca uma estátua em sua sede ao lançamento de cada versão, em que o
famoso "robôzinho" estava acompanhado do doce a qual a versão Android se
referia.
O Google aplica um modelo de versionamento no Android baseado em
3 diferentes notações:
FIT-F.1.24.01-02 Rev.B
18
•
Code name (codinome): como mencionado anteriormente, o Google
batizava cada versão do Android com o nome de um doce, uma forma
lúdica de referenciar essas versões. Atualmente está apenas com a letra
do alfabeto.
•
Version (Versão): é um identificador numérico da versão do sistema
dividido em 2 ou 3 partes.
•
API Level (Nível do API): é um identificador numérico composto de um
único digito decimal. O API Level é incrementado em 1 para cada versão
lançada do Android, independente se é uma versão menor ou uma
mudança de geração.
Essas três notações são utilizadas para contextos diferentes. O codinome é
usado no contexto de Marketing, já a versão, que é uma informação mais completa,
é usada dentro do sistema, como mostra a figura 2 da tela sobre.
Figura 2: informações de software no Samsung Galaxy J5 Prime. Fonte: Medium.
FIT-F.1.24.01-02 Rev.B
19
Por fim, o API Level é usado apenas pelos programadores. Por ser um número
inteiro fica mais fácil determinar se uma versão é mais nova ou mais antiga do que se
tivéssemos de comparar a versão. O API Level tem 2 aplicações básicas em um
projeto Android:
•
Determinar qual a menor versão do sistema operacional que será suportada
por seu aplicativo
•
Verificar programaticamente qual versão do sistema operacional para saber
se um determinado SDK está disponível.
Esses números também são usados pelos pacotes do Android Support Library
para determinar qual a versão mínima que a biblioteca suporta, bem como para com
qual versão do SDK ela deve ser compilada.
As versões, codinomes, data, nível de API e quantidade de aparelhos na
versão, podem ser visualizadas na tabela abaixo:
Tabela 1: tabela das versões do Android. Fonte: Wikipedia.
FIT-F.1.24.01-02 Rev.B
20
1.4
Android para outras aplicações
O fato de o Android ser um sistema aberto e extremamente
personalizável permite que ele seja usado em outros eletrônicos como
netbooks, smartbooks, smart TVs e câmeras. Além destes eletrônicos mais
usados, há também sistema Android em óculos, smartwatches, fones de
ouvidos, tocadores de CD e DVD de carros, espelhos, mp3s, telefones fixos e
vídeo games.
1.4.1 Wear OS
Em 18 de março de 2014 o Google anunciou o Android Wear, uma
plataforma baseada no sistema operacional Android para dispositivos
vestíveis, mais especificamente relógios de pulso inteligentes, os chamados
smartwatches.
Figura 3: Smartwatch Moto 360 da Motorola, um dos primeiros com o novo sistema Android.
Fonte: techspot.
O sistema foi pensado no dia a dia do usuário, exibindo informações sem que
seja necessário retirar o smartphone do bolso. O sistema permite ser controlado por
voz ou por toque, através de uma tela touchscreen em formato redondo ou quadrado.
Funções dos smartwatches incluem sensores de movimento e luz, monitores
cardíacos,
pedômetros,
sensores
GPS,
recusar
ou
aceitar
ligações,
ler/ouvir/responder mensagens de texto, fazer buscas na internet, anotar
informações, entre outras.
FIT-F.1.24.01-02 Rev.B
21
1.4.2 Android Auto
Em janeiro de 2014 o Google anunciou a formação da Open Automotive
Alliance, um grupo que incluía a gigante da tecnologia e montadoras de
automóveis como Audi, General Motors, Hyundai e Honda, com o objetivo de
criar sistemas de entretenimento unificados que combinassem sofisticação e
segurança em uma plataforma baseada em Android.
Em junho do mesmo ano foi anunciado o Android Auto, um sistema
operacional desenvolvido para carros e baseado na plataforma Android. O
sistema oferece em uma tela no carro sistemas e aplicativos como navegação
GPS, música, leitor de SMS, telefone, pesquisas online, entre outros. Poderá
ser controlado tanto por botões físicos quanto por um sistema touchscreen,
além do controle por voz. O sistema irá se comunicar com dispositivos Android
com sistema na versão Lollipop 5.0 ou superior.
1.4.3 Android TV
Anunciado junto com o Android Auto, o Android TV tem como objetivo
ser o sistema padrão de smart TVs. Foi anunciado como sucessor do Google
TV, plataforma lançada em 2010. O sistema é desenvolvido para ser intuitivo
e com recursos avançados de busca por voz.
O Android TV foi desenvolvido para ser tanto nativo na TV quanto
adaptado através de centrais de mídia ou consoles de videogame podendo
usufruir diversos aplicativos da loja Google Play.
1.5
Mercado mobile
É inegável o fato de que o uso de aplicativos está cada vez mais
presente no dia a dia da população. Aliás, com o mercado mobile em
expansão, a expectativa é de que até o final de 2021 o setor movimente US
$6,3 trilhões no mundo.
Os dados são da Think Tank Pew Research Center que estuda as principais
questões de tendências e atitudes que moldam o mundo. O estudo demonstra que o
FIT-F.1.24.01-02 Rev.B
22
Brasil é o segundo país onde o mercado de aplicativos mais cresce, atualmente a
Indonésia ocupa o primeiro lugar.
Existem alguns diferenciais do mercado de aplicativos que as grandes
plataformas utilizam que podemos destacar:
•
A inteligência mobile: é responsável pela coleta de dados fundamentais,
estratégicos e precisos para análise do mercado e concorrentes.
•
A inteligência de reviews: Através da opinião dos usuários nas lojas de
aplicativos, é criado um banco de dados e através de algoritmos e machine
learning, mapeando tendencias e melhorias.
•
O mobile Performance: é otimizar e automatizar campanhas de aquisição
e rentabilização, além de identificar nichos qualificados.
Alguns dados interessantes (TEIXEIRA, 2018):
•
Em média 41 apicativos são instalados em cada smartphone
•
A cada minuto são baixados mais de 48.000 aplicativos nas Stores
•
Os usuários passam mais de 1 hora por dia utilizando aplicativos de celular
•
Em média um usuário navega 22 miutos na internet por meio de dispositivos
móveis.
FIT-F.1.24.01-02 Rev.B
23
2 Ambiente de desenvolvimento
Neste tópico iremos entender as informações necessárias para configurar
nosso ambiente de desenvolvimento no computador.
Iremos conhecer o Portal do Desenvolvedor Android, local indicado para obter
informações sobre o desenvolvimento de aplicativos Android. Na sequência entender
o processo de configuração, download e instalação do Android Studio, conceitos de
IDE, SDK e Framework e por fim criar e executar nosso primeiro projeto.
2.1
Portal do desenvolvedor
O portal do desenvolvedor é um website oficial de desenvolvimento Android
localizado no link https://developer.android.com . Os subtópicos adiante irá explicar
de forma geral toda as áreas do portal.
2.1.1 Plataforma
O link https://developer.android.com/about relata as informações gerais da
plataforma como as novidades da última versão, novas tecnologias, novos
dispositivos, entre outros.
Os tópicos abordados são:
•
Versões: exibe a última versão do Android, novidades e o procedimento de
atualização.
•
Dispositivos: Informações de outros dispositivos que utilizam o sistema
operacional Android como Android TV.
•
Tecnologia: Explica e Ilustra a arquitetura da plataforma com informações
técnicas.
•
Bibliotecas: Página destinada aos desenvolvedores com informações das
bibliotecas utilizadas para o desenvolvimento de aplicativos
•
Jogos: Informações para desenvolvedores de games utilizando o Android
Game Development Kit (AGDK).
•
Visualização da extensão AGD: Informações do Android Game
Development para utilizar o Visual Studio como ferramenta de
desenvolvimento.
•
Machine Learning: Conceitos e informações de Machine Learning no
Android.
FIT-F.1.24.01-02 Rev.B
24
•
Privacidade: Página destinada a informações e práticas recomendadas de
privacidade
•
Android 5G: Informações sobre a tecnologia na plataforma Android.
2.1.2 Android Studio
Área destinada com informações das últimas versões do Android Studio,
ferramenta utilizada no desenvolvimento de aplicativos Android. Como subáreas
temos:
•
Download: página com os links para baixar a ferramenta e releases notes.
•
What’s new: as grandes novidades da última versão do Android Studio.
•
User Guide: Gui para conhecer as principais funcionalidades do Android
Studio.
•
Preview: Acesso antecipado a versões beta do Android Studio.
2.1.3 Google Play
Página destinada a informações sobre a loja oficial da plataforma, o Google
Play. As subáreas são:
•
Play Console: Página com informações da área do desenvolvedor
chamada Play Console.
•
Integridade GooglePlay: Explicação do funcionamento da tecnologia Play
Integrity.
•
Pay Faturamento: Informações técnicas sobre a integração com o Google
Play na parte de pagamentos mobile.
•
Políticas do GooglePlay: informações sobre as mudanças e atualizações
sobre a política de uso.
•
Recursos: Informações sobre ferramentas para promover seus aplicativos.
•
Depoimentos: Área de depoimentos de grandes empresas e aplicativos.
2.1.4 Jetpack
Informações relacionadas a bibliotecas e boas práticas para ter projetos que
funcionem de maneira mais consistente em diferentes versões e dispositivos. Abaixo
a descrição geral das subáreas:
FIT-F.1.24.01-02 Rev.B
25
•
Primeiros Passos: Guia que traz informações sobre a arquitetura e
práticas de desenvolvimento de aplicativos.
•
Bibliotecas: Acessando as bibliotecas por filtros e organizadas por
tipo.
•
Comunidade: Informações sobre as principais comunidades e links
para acessá-las.
•
Compose: Explicação sobre o kit de ferramentas Jetpack Compose,
que acelera o desenvolvimento de interfaces no Android.
2.1.5 Kotlin
Página destinada a informações sobre a linguagem de programação Kotlin. As
subáreas são:
•
Primeiros passos: Informações e diferencias da Linguagem
Kotlin.
•
Criar apps melhores: Informações e diferencias de uso da
linguagem Kotlin.
•
Histórias
de
desenvolvedores:
Notícias
e
histórias
relacionadas ao desenvolvimento utilizando Kotlin.
2.1.6 Documentos
Local para acessar a documentação detalhada das técnicas, componentes,
padrões, entre outros para o desenvolvimento de aplicativos Android. As subáreas
são:
•
Guias: Instruções, treinamentos e cursos para o desenvolvimento
Android.
•
Referências: Informações da plataforma, APIs, frameworks, etc.
•
Amostras:
Documentações
a
artigos
relacionado
ao
desenvolvimento Android.
•
Design
e
Qualidade:
Conceitos
e
informações
sobre
desenvolvimento de interface do Android.
2.1.7 Notícias
Página destinada a informar as últimas notícias da plataforma Android.
FIT-F.1.24.01-02 Rev.B
26
o
2.2
Configurando o Ambiente
Para configurar o ambiente que de desenvolvimento de aplicativos Android, é
necessário que você possua um computador com sistema operacional Windows,
Linux ou MacOS com permissão de instalação.
Os passos necessários são o download do arquivo, instalar e configurar o
Android Studio. O Android Studio é o software oficial para o desenvolvimento de
aplicativos para Android.
2.2.1 Download
Para realizar o download do Android Studio, entre no portal do desenvolvedor
e clique no link “Android Studio” no menu superior conforme a imagem abaixo:
Figura 4: página inicial do portal do desenvolvedor Android. Fonte: developer.android.
Basta clicar no botão “Download Android Studio” conforme encontrado na
figura 5 abaixo:
FIT-F.1.24.01-02 Rev.B
27
Figura 5: botão de download. Fonte: developer.android.
O site irá abrir uma tela de termos de uso (que está em inglês). Após a leitura,
clique no botão aceitar os termos conforme a figura 6 e 7 abaixo:
Figura 6: termos de uso. Fonte: autoria própria.
Figura 7: aceitar os termos de uso. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
28
Após aceitar os temos, o download irá iniciar, exibindo o progresso do
download conforme referência abaixo:
Figura 8: iniciando o download do Android Studio. Fonte: autoria própria.
Após finalizar, verificar se o download do arquivo foi realizado com sucesso
abrindo a pasta do local do download.
Figura 9: finalização do download. Fonte: autoria própria.
2.2.2 Instalação
Para iniciar o processo de instalação, basta executar o instalador que baixamos
no portal. Os requisitos mínimos do computador para conseguir instalar e executar a
IDE é ter um sistema operacional:
•
Windows: Microsoft Windows versões 11 / 10 / 8.1 / 8 / 7 / Vista /
2003 / XP com 32 ou 64 bits.
•
MacOS: versões X / 10.10 / Yosemite / El Capitain ou superiores
•
Linux: GNOME / KDE / Ubuntu / Fedora / GNU / Debian
Também é necessário ter no mínimo 4 gigabytes de memória RAM, sendo o
recomendado 8 gigabytes. Ter 2 gigabytes de espaço em disco e mais 4,5 gigabytes
de espaço para o Android SDK, imagens do sistema de emulador e caches.
FIT-F.1.24.01-02 Rev.B
29
Possuir a versão do Java Development Kit (JDK) 6 / 7 / 8 / 9 / 10 / 11 / 12 ou
superior e a resolução da tela de no mínimo 1280 x 800 pixels.
Ao executar o instalador, basta seguir as instruções conforme figuras abaixo:
Figura 10: primeira tela da instalação do Android Studio. Fonte: autoria própria.
Figura 11: tela de início de instalação do Android Studio. Fonte: autoria própria.
É importante selecionar a instalação do Android Virtual Device, caso não esteja
selecionado. Veremos futuramente, mas esse sistema é o emulador do aparelho
Android no computador. Abaixo a figura do processo de instalação do Android Virtual
Device:
FIT-F.1.24.01-02 Rev.B
30
Figura 12: processo 2 de instalação. Fonte: autoria própria.
Em seguida será exibida a tela da pasta de instalação do Android Studio, caso
tiver ok, pressionar o botão “Next” conforme figura 13 abaixo:
Figura 13: pasta de instalação do Android Studio. Fonte: autoria própria.
O processo de instalação irá perguntar qual pasta de menu inicial do Windows
você deseja criar. No caso, deixamos o padrão e clicamos em “Install”.
FIT-F.1.24.01-02 Rev.B
31
Figura 14: escolha da pasta do menu inicial. Fonte: autoria própria.
O processo de instalação irá iniciar com a barra de progresso indicativa.
Figura 15: tela de progresso de instalação do Android Studio. Fonte: autoria própria.
Aguardar finalizar e clicar em “Next”, conforme referência abaixo:
Figura 16: tela de instalação completa do Android Studio. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
32
Por fim, irá exibir a tela de instalação completa e o botão “Finish” estará
ativado. Pressiono o botão e o Android Studio iniciará.
Figura 17: finalização do processo de instalação. Fonte: autoria própria.
Após clicar no botão, o sistema operacional irá abrir o Android Studio. Nesse
momento o sistema irá realizar o download automaticamente de todos os recursos
necessários para a execução completa conforme figura abaixo:
Figura 18: processo de instalação dos módulos complementares. Fonte: autoria própria.
Deixe finalizar o processo, e apresentará a seguinte tela, conforme referência
abaixo:
FIT-F.1.24.01-02 Rev.B
33
Figura 19: tela de configuração do Android Studio. Fonte: autoria própria.
Aguardar o sistema realizar todos os downloads necessários, o processo
poderá demorar alguns minutos para se concretizar.
Figura 20: processo de download após abertura da tela inicial. Fonte: autoria própria.
No final do processo de download, o sistema irá solicitar para reiniciar o
Android Studio, basta pressionar o botão “Restart”, conforme referência abaixo:
FIT-F.1.24.01-02 Rev.B
34
Figura 21: processo de reinicialização. Fonte: autoria própria.
Após finalizado todos os downloads dos módulos complementares e reiniciado,
abrir novamente o Android Studio. O sistema apresentará a tela conforme figura 22.
Figura 22: processo de configuração completa. Fonte: autoria própria.
As telas a seguir serão para a configuração completa do Android Studio. Ao
pressionar a o botão “Next”, o sistema pedirá para escolher o tema do Android Studio,
que poderá ser “Darcula” (escuro) ou “Light” (claro).
FIT-F.1.24.01-02 Rev.B
35
Figura 23: escolha do tema. Fonte: autoria própria.
Ao escolher o tema e pressionar o botão “Next” irá apresentar a seguinte tela:
Figura 24: escolha dos itens a serem instalados. Fonte: autoria própria.
A tela exibe os itens do Android SDK, ferramentas e emuladores que deverão
ser baixados. Clica em “Finish” para iniciar o download conforme referência abaixo:
FIT-F.1.24.01-02 Rev.B
36
Figura 25: processo de download do Android SDK. Fonte: autoria própria.
Após conclusão do download, o sistema irá apresentar a tela conforme a figura
26.
Figura 26: conclusão de download e configuração do Android SDK. Fonte: autoria própria.
Basta clicar no botão “Finish” e estará finalizado o processo de download,
instalação e configuração do Android Studio.
FIT-F.1.24.01-02 Rev.B
37
2.3
IDE
A IDE vem do termo em inglês “Integrated Development Environment" ou seja,
um Ambiente de Desenvolvimento Integrado é um software que reúne características
e ferramentas de apoio ao desenvolvimento com o objetivo de agilizar e integrar o
processo.
As características mais comuns encontradas nos IDEs são:
•
Editor: Ferramenta que edita o código fone dos programas, escrito na
linguagem suportada
•
Compilador: gera um arquivo de linguagem de máquina através do
código fonte.
•
Linker: Liga as várias partes do código fonte em um único programa.
•
Depurador: Auxilia o desenvolvedor a encontrar e corrigir erros de
código, executando passo a passo o código.
•
Modelagem de Dados: Criação de modelos de classes, objetos,
interfaces, entre outros artefatos.
•
Geração de Código: Geração de códigos templates com o objetivo de
agilizar o processo de desenvolvimento.
•
Distribuição: Processo para criar a versão final do software em
produção.
•
Testes Automatizados: auxilia o desenvolvedor a realizar testes de
forma automatizada através de scripts ou programas específicos.
•
Refatoração: Consiste na melhoria do código fonte do software com o
objetivo de correção, otimização ou redefinição de estrutura do código.
2.4
No
Biblioteca, APIs, SDK e Frameworks
universo
de
desenvolvimento
de
software,
utilizamos
diversas
nomenclaturas específicas que auxilia na utilização destes recursos.
Uma Biblioteca é um pedaço de código que para ajudá-lo a fazer as coisas de
maneira mais fácil e rápida. Por exemplo, uma biblioteca de Processamento de bitmap
fornecerá recursos para carregar e manipular imagens de bitmap, economizando a
necessidade de escrever grandes quantidades de código. Normalmente, uma
biblioteca oferece apenas uma área de funcionalidade.
FIT-F.1.24.01-02 Rev.B
38
Uma API (interface de programação de aplicativos) é um termo que pode ser
utilizado em diversos níveis de programação. Significa a lista das funções ou métodos
em uma biblioteca ou a lista de chamadas de um servidor.
Um SDK (kit de desenvolvimento de software) é um grupo de bibliotecas que
ajudam no desenvolvimento de código de um sistema específico (por exemplo, código
de extensão para usar os recursos de um sistema operacional (Windows SDK),
desenhando gráficos 3D por meio de um sistema específico (DirectX SDK),
escrevendo suplementos para estender outros aplicativos (Office SDK) ou
escrevendo código para fazer com que um dispositivo como um Arduino ou um celular
faça o que você deseja.
Um framework é um conjunto de conceitos usado para resolver um problema
de um domínio específico. Framework conceitual não se trata de um software
executável, mas sim de classes, modelos de dados e funções para um domínio com
o objetivo de auxiliar o desenvolvimento de software.
2.5
Android Studio
O Android Studio é a IDE oficial para o desenvolvimento de apps Android. Foi
anunciado em 16 de maio de 2013 na conferência Google I/O e é disponibilizado
gratuitamente sob a Licença Apache 2.0. Além do editor de código e das ferramentas
de desenvolvedor avançadas do IntelliJ (IDE para JAVA da JetBrains), o Android
Studio oferece ainda mais recursos para aumentar sua produtividade na criação de
aplicativos Android, como:
•
Um sistema de compilação flexível baseado em Gradle.
•
Um emulador rápido com inúmeros recursos.
•
Um ambiente unificado que possibilita o desenvolvimento para todos os
dispositivos Android.
•
A aplicação de mudanças para enviar mudanças de código e recursos
ao aplicativo em execução sem reiniciar o aplicativo.
•
Modelos de código e integração com GitHub para ajudar a criar recursos
comuns de aplicativos e importar exemplos de código.
•
Frameworks e ferramentas de teste cheios de possibilidades.
•
Ferramentas de lint para detectar problemas de desempenho,
usabilidade, compatibilidade com versões, entre outros.
FIT-F.1.24.01-02 Rev.B
39
•
Compatibilidade com linguagem C++ e NDK.
•
Compatibilidade integrada com o Google Cloud Plataform, facilitando a
integração do Google Cloud Messaging e do App Engine.
2.6
Primeiro projeto
Ao abrir o Android Studio, irá apresentar a seguinte tela de primeiro projeto:
Figura 27: abertura do Android Studio para criar o primeiro projeto. Fonte: autoria própria.
Um passo importante que deve ser feito com frequência é verificar se tem
alguma atualização. Para realizar essa ação, basta clicar no canto inferior esquerdo,
o ícone da engrenagem e verificar se há alguma atualização conforme a figura 28.
FIT-F.1.24.01-02 Rev.B
40
Figura 28: tela para verificar se há atualização da linguagem ou IDE. Fonte: autoria própria.
Caso houver alguma atualização, será realizado o download e instalação.
Clicar no botão “New Project” e escolher o projeto “Empty Activity” conforme
referência abaixo:
Figura 29: escolha de templates de novos projetos. Fonte: autoria própria.
Ao clicar no botão “Next” o Android Studio irá apresentar uma tela para
configurar o novo projeto. Iremos colocar o nome como “HelloWorld”, escolher a
linguagem Kotlin e o minimum SDK como 5.0, conforme figura abaixo:
Figura 30: configuração de um novo projeto. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
41
Ao pressionar o botão “Finish” o Android Studio irá abrir o projeto para iniciar a
programação conforme a figura abaixo:
Figura 31: tela inicial do projeto. Fonte: autoria própria.
O primeiro passo de aprendizado é executar o projeto que criamos, para
verificar se está tudo certo. Para realizar essa ação, vamos clicar no menu superior o
botão “Build”. Ao executar a ação aparecerá o seguinte erro:
Figura 32: erro ao tentar realizar o Build e executar o projeto. Fonte: autoria própria.
O console de erro é uma ferramenta fundamental para todo desenvolvedor.
Saber identificar os erros e alertas reduzirá muito o tempo do desenvolvedor para
encontrar falhas e ter mais robustez no código.
O erro apresentado é que não foi aceito a licença dos pacotes do Android SDK.
Para realizar esse processo, basta clicar no botão “Tools” e no menu suspenso o
botão “SDK Manager”, conforme figura abaixo:
FIT-F.1.24.01-02 Rev.B
42
Figura 33: acessando o SDK Manager. Fonte: autoria própria.
Ao clicar no botão SDK Manager, irá apresentar a tela com todos os SDKs
instalados no computador. Como criamos o projeto para o Android SDK 5.0, basta
clicar na versão e depois no botão “ok”. É importante ressaltar que cada SDK ocupa
um espaço no disco rígido do computador, não necessitando realizar o download de
todas as versões, apenas as que serão utilizadas. A figura 34 demonstra a tela para
seleção das versões do Android SDK.
Figura 34: tela das versões do Android SDK. Fonte: autoria própria.
Ao clicar no botão “OK” irá exibir um popup com as informações dos SDKs que
serão transferidos para o computador e o espaço estimado que irá ocupar no disco
rígido, conforme figura abaixo:
FIT-F.1.24.01-02 Rev.B
43
Figura 35: informações do download do SDK e espaço que ocupará no disco rígido. Fonte:
autoria própria.
Ao clicar no botão OK, o sistema irá apresentar a tela de licença. O usuário
deverá ler e aceitar os termos e condições de uso, conforme referência abaixo:
Figura 36: licença do Android SDK. Fonte: autoria própria.
Por fim, será exibido a tela de instalação dos componentes. Basta aguardar a
finalização e clicar no botão “Finish”.
FIT-F.1.24.01-02 Rev.B
44
Figura 37: instalação completa do Android SDK. Fonte: autoria própria.
Ao realizar novamente o processo de Build do projeto, o Android Studio irá
exibir a informação de “BUILD SUCCESSFUL”, conforme figura 38.
Figura 38: processo de Build realizado com sucesso. Fonte: autoria própria.
Após realizar o processo de Build, iremos executar o aplicativo clicando no
botão de “Run”. Ao executar, o Android Studio exibirá a seguinte tela de erro:
Figura 38: tela de erro ao executar o projeto. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
45
O erro demonstra que não foi encontrado aparelhos conectados para executar
o aplicativo. Para resolver o erro, precisamos acessar o gerenciador de emuladores
e criar um aparelho virtual. Basta clicar em “ok” e em seguida clicar no botão do menu
que está com o texto “No Devices” e clicar em “AVD Manager”, conforme imagem
abaixo:
Figura 40: acessando a tela de AVD manager. Fonte: autoria própria.
Ao clicar no botão “AVD Manager” irá apresentar uma tela para criar um
aparelho virtual conforme a figura 41 abaixo:
Figura 41: tela para criar um Aparelho Virtual. Fonte: autoria própria.
Ao clicar no botão “+ Create Virutal Device...” irá apresentar uma sequência de
telas para configurar um aparelho virtual, isto é, um emulador do aparelho celular.
Para fins de exemplo, iremos escolher o aparelho Pixel 2 com a tela de cinco
polegadas, conforme imagem abaixo:
FIT-F.1.24.01-02 Rev.B
46
Figura 42: escolha de aparelho para o virtual device. Fonte: autoria própria.
Ao clicar no botão “Next”, iremos para a configuração da versão do sistema
operacional Android. No exemplo deste primeiro projeto, clicamos na versão mais
recente o Android R, API level 30. A figura 43 ilustra a tela.
Figura 43: escolha da versão do virtual device. Fonte: autoria própria.
Ao clicar em “Next”, basta colocar o nome do emulador e em seguida aguardar
o download e instalação do emulador.
FIT-F.1.24.01-02 Rev.B
47
Figura 44: download e instalação do virtual device. Fonte: autoria própria.
Ao finalizar o download e clicar no botão “Finish” clicar no botão de Run
novamente e o emulador irá abrir e executar o projeto. A imagem abaixo ilustra a
ação:
Figura 45: imagem executando o projeto Hello World no aparelho. Fonte: autoria própria.
2.7
Setores do Android Studio
Nesta seção iremos aprender sobre as principais áreas do Android Studio e
suas funcionalidades.
FIT-F.1.24.01-02 Rev.B
48
2.7.1 Estrutura do projeto
No lado esquerdo da IDE está localizado a estrutura de arquivos do projeto,
conforme ilustração abaixo:
Figura 46: arquivos do projeto na visualização do Android. Fonte: Android Developer.
Para cada projeto criado no Android Studio, contém um ou mais módulos com
arquivos de código-fonte e de recursos utilizados no projeto. O módulo do Project
exibe os arquivos do projeto na visualização, como mostrado na figura 46, essa
visualização é organizada por módulos para permitir o acesso rápido aos principais
arquivos de origem do projeto.
•
manifests: contém o arquivo “AndroidManifest.xml” responsável pela
configuração geral do aplicativo
•
Java: contém os arquivos de código-fonte do Java ou Kotlin, incluindo o
código de teste do JUnit
•
Res: contém todos os recursos que não são código, como layouts XML,
textos de IU e imagens em bitmap
FIT-F.1.24.01-02 Rev.B
49
Também é possível personalizar a visualização dos arquivos do projeto para
se concentrar em aspectos específicos do desenvolvimento do aplicativo. Por
exemplo, a escolha da visualização Problems do projeto exibe links para os arquivos
de origem que contêm erros reconhecidos de programação e sintaxe, como a falta de
uma tag de fechamento de elemento XML em um arquivo de layout.
Figura 47: arquivos do projeto na visualização "Problems", mostrando um arquivo de layout
com problema. Fonte: Android Developer.
2.7.2 A interface do usuário
A janela principal do Android Studio é composta de diversas áreas lógicas,
identificadas na figura 48.
Figura 48: janela principal do Android Studio. Fonte: Android Developer.
FIT-F.1.24.01-02 Rev.B
50
1 A barra de ferramentas permite realizar diversas ações, inclusive executar
aplicativos e inicializar ferramentas do Android.
2 A barra de navegação ajuda a navegar pelo projeto e a abrir arquivos para
edição. Ela oferece uma visualização mais compacta da estrutura visível na
janela Project.
3 A janela do editor é onde você cria e modifica o código. Dependendo do
tipo de arquivo atual, o editor pode mudar. Por exemplo, ao visualizar um
arquivo de layout, o editor abre o Layout Editor.
4 A barra de janela de ferramentas fica fora da janela do ambiente de
desenvolvimento integrado e contém os botões que permitem expandir ou
recolher as janelas de cada ferramenta.
5 As janelas de ferramentas permitem acessar tarefas específicas, como
gerenciamento de projetos, pesquisa e controle de versões, entre outras.
As janelas podem ser expandidas e recolhidas.
6 A barra de status exibe o status do projeto e do próprio ambiente de
desenvolvimento integrado, bem como todos os avisos ou mensagens.
Podemos organizar a janela principal para ver mais espaço na tela ocultando
ou movendo barras e janelas de ferramentas. Também é possível usar atalhos de
teclado para acessar a maioria dos recursos do ambiente de desenvolvimento
integrado.
A qualquer momento, você pode pesquisar o código-fonte, bancos de dados,
ações, elementos da interface do usuário, entre outros, pressionando duas vezes a
tecla "Shift" ou clicando na lupa no canto superior direito da janela do Android Studio.
Isso pode ser muito útil quando, por exemplo, você quer localizar uma determinada
ação do ambiente de desenvolvimento integrado e esqueceu a forma de acionamento.
2.7.3 Janelas de ferramentas
Em vez de usar perspectivas predefinidas, o Android Studio segue o contexto
e exibe automaticamente as janelas de ferramentas relevantes de acordo com o
trabalho. Por padrão, as janelas de ferramentas mais comuns são fixadas na barra de
janelas de ferramentas, nas bordas da janela de aplicativos.
FIT-F.1.24.01-02 Rev.B
51
•
Para expandir ou recolher uma janela de ferramentas, clique no nome
da ferramenta na barra de janelas de ferramentas. Também é possível
arrastar, fixar, desafixar, anexar e desanexar janelas de ferramentas.
•
Para voltar ao layout padrão atual da janela de ferramentas, clique
em “Window > Restore Default Layout” ou personalize o layout padrão
clicando em “Window > Store Current Layout as Default”.
•
Para mostrar ou ocultar toda a barra da janela de ferramentas, clique no
ícone
•
no canto inferior esquerdo da janela do Android Studio.
Para localizar uma janela de ferramentas específica, passe o cursor
sobre o ícone de janela e selecione-a no menu.
•
Caso queira ocultar todas as barras de ferramentas, janelas de
ferramentas e guias do editor, clique em “View > Enter Distraction Free
Mode”. O Distraction Free Mode será ativado. Para sair do Distraction
Free Mode, clique em “View > Exit Distraction Free Mode”.
•
É possível utilizar o Speed Search para pesquisar e filtrar dentro da
maioria das janelas de ferramentas no Android Studio. Para usar "Speed
Search", selecione a janela de ferramentas e digite a consulta de
pesquisa.
2.8
Primeiro código
Ao criar o projeto, abrir o arquivo MainActivity e digitar o seguinte código
abaixo:
Figura 49: função println que imprime no console da IDE. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
52
Para olharmos o resultado, basta executar o projeto e verificar na aba “Logcat”
a impressão do nosso texto, exibido na figura 50.
Figura 50: impressão de textos no logcat Fonte: autoria própria.
2.9
Arquivo APK
Android Application Pack (APK) é um arquivo de pacote destinado ao sistema
operacional Android. Ele pode ser comparado com os arquivos proprietários de
instalação de software do Windows, como o .exe. Acontece que o APK tem um
formato semelhante a compressão que é feita pelo ZIP, e em seu interior ficam todos
os arquivos necessários para a instalação de aplicativos e jogos. Para criar um
arquivo APK, todo o código fonte da aplicação é compilado e depois empacotado em
um único arquivo.
O arquivo APK, geralmente contém os seguintes arquivos e diretórios:
•
META-INF/ : diretório que contém:
•
MANIFEST>MF: arquivo de manifesto
•
CERT.RSA: certificado de aplicativo
•
CERT>SF: listas de recursos e assinaturas criptografada baseado em
SHA-1
•
lib/ : diretório que contém código nativo compilado para uma arquitetura
de processador específica. Exemplo: armeabi-v7a, arm64-v8a, mips,
x86, etc.
•
re/ : diretório de recursos. É dividido em vários subdiretórios:
•
drawable/ : diretório de arquivos Bitmap (.png, jpg, gif) ou arquivos XML.
•
Layout/ : diretório de arquivos XML que definem um layout de interface
do usuário.
•
Mipmap/ : diretório de ícones com diferentes densidades que será
exibido no inicializador (launcher).
FIT-F.1.24.01-02 Rev.B
53
•
Values/ : diretório de arquivos XML que contêm valores simples, como
strings, números inteiros, cores, estilos e dimensões.
Além dos diretórios citados anteriormente, há outros diretórios
específicos como: anim/, menu/, raw/, xml/, etc.
•
AndroidManifest.xml: arquivo de manifesto adicional do Android
contendo o nome e versão do aplicativo, permissões de acesso,
etc.
•
classes.dex: arquivo executável Dalvik compilado a partir do
código-fonte java, e executado na Máquina Virtual Dalvik ou no
Android Runtime (ART).
•
resources.arsc: arquivo que contém recursos pré-compilados do
diretório "values / " usados na aplicação.
2.10 Compilação
O Android Studio usa o Gradle como o sistema de compilação de base, com
outros recursos específicos do Android disponibilizados pelo plug-in do Android para
Gradle. Esse sistema de compilação é executado como uma ferramenta integrada no
menu do Android Studio e de forma independente na linha de comando. Você pode
usar os recursos do sistema de compilação para fazer o seguinte:
•
Personalizar, configurar e ampliar o processo de programação.
•
Criar diversos APKs para seu aplicativo com diferentes recursos usando o
mesmo projeto e os mesmos módulos.
•
Reutilizar código e recursos nos conjuntos de origem.
A flexibilidade do Gradle permite que você faça tudo isso sem modificar os
arquivos de origem principais do seu aplicativo. Cada projeto tem um arquivo de
compilação de nível superior para todo o projeto e arquivos de compilação de módulo
separados para cada módulo. Quando você importa um projeto já existente, o Android
Studio gera automaticamente os arquivos de compilação necessários.
FIT-F.1.24.01-02 Rev.B
54
3 Linguagem Kotlin
Kotlin é uma linguagem de programação multiplataforma, orientada a objetos
e funcional, concisa e estaticamente tipada (variáveis com tipos específicos) e
desenvolvida pela JetBrains em 2011. Foi anunciada em 2017 pela Google como a
linguagem oficial do sistema Android.
Foi considerada pelo público a 2ª linguagem "mais amada", de acordo com
uma pesquisa conduzida pelo site Stack Overflow em 2018.
3.1
História
Em julho de 2011 a JetBrains revelou o Projeto Kotlin, no qual já estava
trabalhando havia um ano. Um dos objetivos declarados da Kotlin é compilar tão
rápido quanto Java. Em fevereiro de 2012, a JetBrains abriu o projeto Kotlin sob a
Licença Apache de código aberto.
Kotlin v1.0 foi lançada em 15 de fevereiro de 2016. Este é considerado o
primeiro lançamento oficialmente estável e a JetBrains comprometeu-se com a
compatibilidade com versões anteriores a partir desta versão.
No Google I/O 2017, o Google anunciou que o Kotlin é oficialmente suportado
pela Google para desenvolvimento móvel no Android. Desde o lançamento do Android
Studio 3.0 em outubro de 2017, o Kotlin é incluído como uma alternativa ao
compilador Java padrão.
Kotlin v1.3 foi lançada em 29 de outubro de 2018, trazendo coroutines para
programação assíncrona. Em 7 de maio de 2019, Google anunciou que agora o Kotlin
é a linguagem principal para desenvolvedores de aplicativo Android. A versão que
iremos trabalhar no curso será a 1.6.10.
A forma de identificar as diferentes versões, são
classificadas:
•
•
Feature releases (1. x) trás as maiores e
principais mudanças da linguagem.
Incremental
releases (1. x. y)
são
funcionalidades incluídas no interval das
“feature releases” , podendo conter novas
funções,
incremento
de
performance,
correções, melhorias em ferramentas, entre
outros.
FIT-F.1.24.01-02 Rev.B
55
•
3.2
Bug
fix
releases (1. x. yz)
é
lançada
especificamente para correções de erros.
Diferenças entre JAVA
Embora sejam utilizados para a mesma funcionalidade, Java e Kotlin
têm diferenças específicas na forma como são trabalhados e que podem
impactar diretamente os processos executados pelos desenvolvedores.
O Kotlin se baseia nas linguagens de programação mais atuais,
oferecendo a opção de trabalhar com parâmetros com valor padrão. Desse
modo, pode-se determinar um valor em situações em que a pessoa que chama
o método não tenha fornecido essa informação. Já no Java, esse processo é
realizado com sobrescrita de métodos no próprio corpo do método.
A linguagem Java conta com o operador ternário, no qual o programador
pode atribuir uma variável de acordo com o resultado obtido em uma operação
condicional. Essa função foi aprimorada no Kotlin, tendo em vista que os blocos
condicionais “if” e “when” fazem o retorno de um valor especificamente para a
variável. O seu benefício está na capacidade de executar blocos inteiros de
código e, no fim da operação, ainda retornar o valor.
Um dos recursos mais populares do Kotlin são as data classes, que
acabam eliminando a necessidade de uso do boilerplate dos incontáveis
getters e setters presentes nas classes de negócios típicos do Java. Nesse
sentido, o Kotlin segue o conceito de propriedade, enquanto o Java atua a partir
de atributos.
Pode-se dizer que essa diferença é conceitual, pois no Java os atributos
são privados e o desenvolvedor precisa aplicar os métodos getters e setters
para conseguir acessá-los. No Kotlin, esse acesso ocorre pela instância da
classe, bastando aplicar o operador “.”. Somente quando for estritamente
necessário utilizar uma regra de negócio é que o programador poderá recorrer
ao getter ou setter.
Por fim, vale destacar que o Kotlin não é ideal para favorecer a herança.
Nessa linguagem, diferentemente do que costuma acontecer no Java, para que
uma classe seja herdada é preciso que esta use o operador “open” durante a
FIT-F.1.24.01-02 Rev.B
56
sua declaração. Se esse processo não for efetuado, certamente o
desenvolvedor vai se deparar com um erro de compilação.
É importante conhecermos os fundamentos da programação de aplicativos
mobile em JAVA pois é certo que sistemas e aplicativos legados deverão ter os
projetos baseados em JAVA.
3.3
Tipos de variáveis
Os tipos de variáveis no Kotlin são estáticas, mas nem sempre é necessário
informar explicitamente o tipo da variável, o compilador consegue entender o tipo
conforme o contexto usado ou atribuições.
Para declaramos uma variável utilizamos a palavra “val”. Utilizando esse termo,
a variável recebe o valor uma única vez, não podendo ser alterado.
Figura 51: declaração de variável tipo val. Fonte: autoria própria.
Ao tentar executar, dará um erro nesse segundo exemplo, pois a variável
“preco” não pode ser alterada.
O segundo tipo de variável que podemos declarar é utilizando o termo “var”.
Ao contrário do “val”, não é obrigatório iniciar a variável na declaração, conforme
figura abaixo:
Figura 52: declarando uma variável tipo var. Fonte: autoria própria.
A linguagem Kotlin podemos utilizar do recurso de Inferência de Tipo, isto é, o
tipo da variável poderá ser omitido na declaração quando tivermos um valor atribuído
a ela.
FIT-F.1.24.01-02 Rev.B
57
Figura 53: declaração escondendo o tipo da variável. Fonte: autoria própria.
3.3.1 Números
Os tipos inteiros disponíveis em Kotlin são:
•
Long – 64 bit
•
Int – 32 bits
•
Short – 16 bits
•
Byte – 8 bits
Os tipos de ponto flutuante são:
•
Double – 64 bits
•
Float – 32 bits
Abaixo alguns exemplos de declaração:
Figura 54: declaração de inteiros e floats. Fonte: autoria própria.
Você̂ pode observar que criamos um “long” literal, adicionando o sufixo “L”, e
para o float, acrescentamos o sufixo “F” ou “f”. Os números também podem ser
escritos em notação hexadecimal, usando os prefixos “0x” ou “0X” e em binário
usando os prefixos 0b ou 0B.
Para converter um número de um tipo para outro, você̂ precisa chamar
explicitamente a função de conversão correspondente. Em outras palavras, não há
nenhuma conversão implícita entre tipos de números.
FIT-F.1.24.01-02 Rev.B
58
Figura 55: nesse caso dará um erro. Fonte: autoria própria.
Cada tipo de número tem funções auxiliares que convertem de um tipo de
número para outro:
•
toByte()
•
toInt()
•
toLong()
•
toFloat()
•
toDouble()
•
toChar()
•
toShort()
Reescrevendo da forma correta, encontramos:
Figura 56: realizando um cast explicito. Fonte: autoria própria.
No código acima, convertemos de um número inteiro para um long. Podemos
também fazer o inverso usando o método toInt() na variável long. Observe que isso
truncará o valor para se ajustar ao tamanho menor de um tipo “Int”, portanto tenha
cuidado ao converter de tipos maiores para menores.
Você̂ também pode converter uma String em um tipo de número, conforme
referencia abaixo:
Figura 57: convertendo string para número. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
59
3.3.2 O Tipo Booleano
O tipo Boolean tem o seu valor como “true” ou “false”, assim como a maioria
das linguagens de programação. As operações de disjunção (OR) “||”, conjunção
(AND) “&&” e negação (NOT) “!” podem ser executadas normalmente, conforme o
exemplo abaixo:
Figura 58: declarando e utilizando booleano. Fonte: autoria própria.
3.3.3 Strings
As Strings são criadas com aspas duplas compostos por caracteres no centro.
Na figura 59 abaixo, um exemplo de declaração de String. Além disso, os caracteres
de escape podem ser usados com aspas duplas.
Figura 59: exemplo de declaração de string em Kotlin. Fonte: autoria própria.
Caso quisermos criar uma String que utiliza diversas linhas na origem,
utilizamos as aspas triplas, conforme figura 60. Para criar uma sequência de
caracteres que abrange várias linhas no arquivo de origem, também utilizamos as
aspas triplas.
FIT-F.1.24.01-02 Rev.B
60
Figura 60: exemplo de strings com múltiplas linhas. Fonte: autoria própria.
3.3.4 Vetores
Na linguagem de programação Kotlin, conseguimos declarar um vetor ou
matriz utilizando a função “arrayOf()” ou o método construtor “Array()”. No código
abaixo, utilizamos as duas maneiras de declarar um vetor:
Figura 60: código declarando vetores Fonte: autoria própria.
Para acessar os elementos de um array, utilizamos a sintaxe “array[i]” onde o
array é o nome da variável e o “i” é o índice de acesso.
Na declaração utilizando o construtor, conseguimos garantir que todos os
elementos do array serão do mesmo tipo.
Existem funções para criar matrizes de outros tipos como:
•
charArrayOf()
•
booleanArrayOf()
•
longArrayOf()
•
shortArrayOf()
•
byteArrayOf()
3.3.5 Comentários
Os comentários é o mesmo utilizado em diversas linguagens como o Java e o
C#, podemos utilizar 2 tipos, de bloco ou linha:
FIT-F.1.24.01-02 Rev.B
61
Figura 61: comentários em Kotlin. Fonte: autoria própria.
3.3.6 Nullable e not-null assertion
No Kotlin temos um mecanismo prático para tratar variáveis nulas evitando os
erros de “Exceptions”. Os tipos comuns são por padrão “não-nulos”, e caso o
desenvolvedor necessite que a variável aceite nulo, ele deve indiciar utilizando o
termo “?”.
Por exemplo, vamos considerar uma função que recebe como parâmetro uma
String e retorna o tamanho dela, conforme a figura 62 abaixo:
Figura 62: criando uma função e passando um valor nulo. Fonte: autoria própria.
Ao tentar compilar, apresenta um erro, dizendo que a função não aceita nulo
como parâmetro. Para funcionar devemos incluir o operador “?” e o operador “!!” que
é o “not-null assertion”, conforme imagem abaixo:
Figura 63: exemplo de operador de chamada segura “?” e not-null assertion “!!”. Fonte:
autoria própria.
FIT-F.1.24.01-02 Rev.B
62
O operador de not-null assertion “!!” converte o tipo para um tipo not-null e caso
o valor seja nulo resulta em NullPointerException.
3.3.7 Lateinit
É um modificador do Kotlin que possibilita que a variável “var” não nula possa
ser inicializada posteriormente. Caso o desenvolvedor esqueça de inicializar, a
mensagem “Lateinit porperty someValue has not been initialized” será exibida.
3.4
Controle de fluxo
Os tópicos a seguir, iremos abortar os controles de fluxo utilizados na
linguagem Kotlin.
3.4.1 If
A estrutura condicional “if” serve para o programa executar diferentes blocos
dado uma condição ou expressão lógica. Em Kotlin a forma de utilizar o “If” é simples,
conforme figura 64 abaixo:
Figura 64: expressão lógica IF. Fonte: autoria própria.
A expressão “if (b > a)” se for verdadeira executará o bloco que atribui a variável
max o valor de b. Caso quisermos verificar se os valores são iguais, utilizaremos a
expressão “==” conforme a figura 65 abaixo:
Figura 65: expressão para valores iguais. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
63
Também podemos utilizar os ifs sequenciais, conforme exemplo abaixo:
Figura 66: Ifs na sequência. Fonte: autoria própria.
Na linguagem Kotlin, também é possível utilizar o “operador ternário” e utilizar
o if retornando o valor diretamente, conforme exemplo abaixo:
Figura 67: If retornando valor. Fonte: autoria própria.
3.4.2 When
A estrutura de múltipla seleção “When” é utilizada para comparar um valor com
um conjunto de opções. Nas outras linguagens é semelhante ao “Switch-case”, que
compara uma variável a diversas opções podendo ou não ter um valor padrão.
A estrutura pode ser vista no exemplo na figura 68 abaixo:
Figura 68: estrutura do When. Fonte: autoria própria.
Semelhante ao “if” também conseguimos utilizar o when como expressão,
conforme exemplo abaixo:
FIT-F.1.24.01-02 Rev.B
64
Figura 69: utilizando o When como expressão. Fonte: autoria própria.
A condição em uma ramificação de when também
pode ser uma expressão que retorna algum valor,
desde que o valor retornado seja no mesmo tipo
que o valor passado para when. Por exemplo, para
comparar um número com uma série podemos
escrever o seguinte código:
Figura 70: usando when entre números. Fonte: autoria
própria.
3.4.3 For
A estrutura do “For” no Kotlin é semelhante as demais linguagens. Vamos
utilizar o array do exemplo anterior e percorrer por todos os seus elementos. O código
abaixo demostra essa função:
Figura 71: percorrendo o vetor myArray2. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
65
3.4.4 While
A função While é semelhante as demais linguagens que possui uma expressão
lógica e um bloco de código a ser executado enquanto a expressão for verdadeira.
Abaixo um exemplo de código utilizando o while:
Figura 72: exemplo utilizando While. Fonte: autoria própria.
3.5
Paradigma orientado à objetos
Para falarmos de programação orientada a objetos, precisamos entender o
conceito de paradigma. O paradigma nos define a forma de pensarmos em um
determinado problema. Na computação temos diversos paradigmas como por
exemplo: imperativo, orientação à objetos, funcional, lógico, concorrente, script,
aspectos, entre outros. Cada paradigma nos fornece instruções da forma que
devemos pensar na construção do software ou na resolução do nosso problema.
As linguagens de programação podem ou não dar suporte aos tipos de
paradigmas. No caso do paradigma Orientado à Objetos, existem as linguagens que
dão suporte como por exemplo o Java, C++, Koltin, etc. Essas linguagens dão
possibilidades de implementar seus códigos utilizando o paradigma orientado a
objetos.
Dado uma linguagem orientada à objetos, temos o conceito de Programação
Orientada a Objetos, também conhecida pela sigla POO, que é a forma prática de
programação utilizando o paradigma orientado a objetos. Portanto, o POO é um
modelo de análise, projeto e programação de software baseado na composição e
interação entre diversas unidades chamadas de “objetos”.
A seguir aprofundaremos cada conceito da orientação à objetos e praticaremos
utilizando a linguagem Kotlin.
FIT-F.1.24.01-02 Rev.B
66
3.5.1 Classes
As classes na orientação à objetos representa um conjunto de objetos com
características e funções. Uma classe define o comportamento dos objetos através
de seus métodos, e quais estados ele é capaz de manter através de seus atributos.
Vamos usar um exemplo de um objeto comum, o carro. A classe define as
propriedades e ações comuns de um carro, que poderá ter diversos modelos com
características e funcionalidades diferentes.
Para isso, criaremos uma classe, clicando com o botão direito do mouse na
pasta “app/java/com.example.primeiroprojeto” e posteriormente no botão “New >
Kotlin Class/File”, conforme figura 73 abaixo:
Figura 73: criando uma nova classe. Fonte: autoria própria.
Definiremos o nome da classe de Carro no popup que irá abrir conforme figura
74 abaixo:
Figura 74: definindo o nome da classe. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
67
Por fim a IDE irá abrir o arquivo com a definição da classe. No Kotlin a definição
é bem simples, conforme imagem abaixo:
Figura 75: definição de classe em Kotlin. Fonte: autoria própria.
O próximo passo é definir um construtor da classe. Essa função especial é
responsável por configurar o carro inicialmente e validar se estará tudo certo com o
objeto carro. Em comparação ao mundo real, a classe é como se fosse o projeto
detalhado do carro e a função de construtor seria a linha de montagem física do carro.
Exemplo: o projeto do carro diz que ele precisa de um motor, rodas, carroceria, etc e
na linha de montagem recebemos as especificações e literalmente montamos o carro
fisicamente.
Na linguagem Kotlin, podemos diferenciar construtores entre primários e
secundários. O construtor primário de uma classe faz parte do seu cabeçalho e pode
conter apenas uma lista de parâmetros, como o exemplo abaixo:
FIT-F.1.24.01-02 Rev.B
68
Figura 76: método init. Fonte: autoria própria.
3.5.2 Propriedades
As propriedades é uma característica do objeto, basicamente a estrutura de
dados da classe.
Continuando o exemplo do carro, as propriedades poderiam ser peso, cor,
potência, nome, etc. Podemos ter propriedades privadas como por exemplo a
velocidade do carro.
FIT-F.1.24.01-02 Rev.B
69
Figura 77: declarando e inicializando as propriedades. Fonte: autoria própria.
3.5.3 Métodos
Os métodos ou funções definem as habilidades, ações ou comportamento do
objeto. As funções ou ações do carro seriam ligar, desligar, acelerar, reduzir,
acionar seta, virar, etc.
Um outro termo utilizado na orientação à objetos são as interfaces que é um
contrato entre a classe e o mundo externo. Quando uma classe implementa uma
interface, ela está comprometida a fornecer o comportamento publicado pela
interface.
Os métodos são funções (fun) das classes e podem ser publicas ou privadas.
Segue abaixo o exemplo de métodos da nossa classe carro:
FIT-F.1.24.01-02 Rev.B
70
Figura 78: declarando métodos da classe. Fonte: autoria própria.
3.5.4 Heranças
A herança é o mecanismo pelo qual uma classe pode estender outra classe ou
ser estendida por outra classe. O mecanismo de herança permite que uma classe
(subclasse) compartilhe o código-fonte outra classe (superclasse), aproveitando seus
comportamentos (métodos) e variáveis possíveis (atributos).
As grandes vantagens deste mecanismo são a organização do software e
evitar a duplicação desnecessária de código, o que pode levar a reduzir o tempo gasto
para desenvolver o projeto.
Generalização é o processo de herança, no qual é criada uma superclasse, a
partir de subclasses já existentes.
Especialização é o processo no qual é criada uma subclasse a partir de
superclasse(s) já existentes.
Utilizando nosso exemplo do carro, poderíamos ter uma classe geral do carro
e uma subclasse que seria carro de Fórmula 1. A função específica desse carro seria
“abrirAsa” durante as ultrapassagens.
Para executarmos o exemplo, basta criar uma classe, colocar a propriedade
“open” na classe Carro (permitindo herança) e modificar o código conforme referência
abaixo:
FIT-F.1.24.01-02 Rev.B
71
Figura 79: criando uma classe formula 1 que herda de carro. Fonte: autoria própria.
Toda classe em Kotlin possui um supertipo chamado Any,
que possui apenas um pequeno número de funções, as
quais são equals(), hashCode() e toString(). Dessa forma,
ambas as declarações abaixo são sintaticamente
equivalentes: Class Foo(param1:Double) e Class
Foo(param1:Double) : Any()
Podemos sobreescrever funções da classa pai através do termo reservado
override. O exemplo abaixo ilustra sobrescrever a função acelerar para o carro
Formula1:
Figura 80: sobreescrevendo a função. Fonte: autoria própria.
3.5.5 Associação
Associação é o mecanismo pelo qual um objeto utiliza os recursos de outro.
Pode tratar-se de uma associação simples "usa um" ou de um acoplamento "parte
de".
Um exemplo diferente seria criarmos para a classe Carro e outra classe motor.
Podemos dizer que a classe carro faz uma associação com a classe motor, isto é, um
carro possui um motor.
3.5.6 Encapsulamento
O conceito de encapsulamento consiste na separação de aspectos internos e
externos de um objeto. Este mecanismo é utilizado amplamente para impedir o
FIT-F.1.24.01-02 Rev.B
72
acesso direto ao estado de um objeto (seus atributos), disponibilizando externamente
os métodos que acessam (getters) e alteram (setters) estes estados.
Um exemplo que podemos citar é a classe motor do carro, que você não
precisa ter acesso a atributos internos do motor ou do comportamento detalhado,
basta ter um método de ligar e desligar.
3.5.7 Abstração
A abstração é a habilidade de concentrar nos aspectos essenciais de um
contexto qualquer, ignorando características menos importantes ou acidentais. Na
POO, uma classe é uma abstração de entidades existentes no domínio do software.
3.5.8 Instancia
A instância é a concretização de uma classe que chamamos de objeto. Um
objeto armazena estados através de seus atributos e reage a mensagens enviadas a
ele, se relaciona e envia mensagens a outros objetos.
Mensagem é uma chamada a um objeto para executar um de seus métodos.
Também pode ser direcionada diretamente a uma classe.
Para executarmos o exemplo, vamos abrir o arquivo MainActivity.kt e instanciar
a classe carro, abaixo o código de exemplo:
Figura 81: instanciando uma classe. Fonte: autoria própria.
3.5.9 Polimorfismo
Polimorfismo consiste no princípio pelo qual duas ou mais classes derivadas
de uma mesma superclasse podem invocar métodos que têm a mesma identificação
(assinatura) mas comportamentos distintos, especializados para cada classe.
Voltando ao exemplo do Carro e Formula1, a função acelerar() existe nos dois,
porém o comportamento interno é diferente.
FIT-F.1.24.01-02 Rev.B
73
4 Fundamentos de layout e usabilidade
A usabilidade define o modo que o usuário irá interagir com os sistemas
computacionais. Atualmente é uma área de grande peso, pois além de performance
os sistemas necessitam de ser fácil de aprender e manipular. Caso o usuário enfrente
dificuldades no uso do sistema o engajamento irá diminuir e provavelmente o software
em si poderá não atingir o sucesso, mesmo tendo uma performance boa.
4.1
Conceito de UX e UI
No universo da tecnologia a Interface Gráfica do usuário (GUI – Graphical User
Interface), é um tipo de sistema que permite a interação com os dispositivos digitais
através de elementos gráficos como ícones e outros indicadores visuais. Foi criada
pela Xerox mas somente se tornou um produto com a Apple na década de 70.
A interação é feita geralmente com dispositivos de entrada como mouse e
teclado, com os quais o usuário é capaz de selecionar símbolos e manipulá-los de
forma a obter algum resultado prático. Esses símbolos são designados de wdigets e
são agrupados em kits.
Ambiente gráfico é um software feito para facilitar e tornar prática a utilização
do computador por meio de representações visuais do sistema operacional.
Uma interface gráfica do utilizador usa uma combinação de tecnologias e
dispositivos para fornecer uma plataforma com a qual o utilizador pode interagir.
O UI (User Interface) que conhecemos atualmente é o design visual das telas
e botões que o usuário interage. Já o User Experience (UX) é experiência do usuário
relativos à interação do usuário com o sistema.
O termo iniciou na década de 1990 e envolve não somente aspectos
relacionados ao design (hardware, software, interface, usabilidade, facilidade de
busca, etc), mas também destaca os aspectos afetivos e experienciais, significativos
e valiosos de interação humano-computador e propriedade do produto. A experiência
do usuário é de natureza subjetiva, pois é sobre a percepção e pensamento individual
no que diz respeito ao sistema. Ela é também dinâmica, pois é constantemente
modificada ao longo do tempo, devido à evolução das circunstâncias e inovações.
FIT-F.1.24.01-02 Rev.B
74
Um conceito importante no design UX é o processo pelo qual os usuários
formam experiências. Quando o usuário encontra um produto, forma uma impressão
momentânea, que evolui ao longo do tempo. Neste processo, a percepção, ação,
motivação e cognição do usuário se integram para formar uma história memorável e
coerente: chamada "experiência do usuário". Esse processo suscita respostas
emocionais, que determinam em grande parte se a experiência será considerada
positiva ou negativa.
A seguir, os principais elementos que compõe a interface e experiência do
usuário são:
•
Superfície: Essa camada é mais tangível, pois onde se concentram as
decisões sobre a finalização do projeto e é onde atingirá diretamente o
usuário. Engloba textos e imagens, alguns que se podem clicar,
realizando alguma função como de levar ao carrinho de compras.
•
Esqueleto: Neste plano é feito todo o rascunho do projeto para o
usuário de forma rudimentar ainda, esse plano possui uma grande
interação com o plano de estrutura. É constituído pela colocação de
botões, controles, fotos e blocos de texto, projetado para otimizar o
arranjo desses elementos, a aumentar a efetividade e a eficiência.
Como por exemplo, para que você se lembre do logotipo ou possa
encontrar o botão carrinho de compras quando precisar.
•
Estrutura:
É
feito
a
concretização
do
plano
de
esqueleto,
complementando o projeto do que já foi feito no plano anterior. O
esqueleto é uma expressão concreta, já a estrutura, é abstrata. O
esqueleto define o posicionamento da interface de elementos na página,
a estrutura define como os usuários chegarão a essa página e onde
podem ir quando terminarem ou o esqueleto pode definir o arranjo de
navegação dos elementos em categorias de produtos, a estrutura
definiria quais eram essas categorias.
•
Escopo: Nessa parte o objetivo é mapear e coordenar funcionalidades
e informações que sejam relevantes para o que foi obtido no plano
anterior. Define a forma como os vários recursos e funções do site se
encaixam. Por exemplo, alguns sites de comércio oferecem um recurso
que permite aos usuários salvarem os endereços de envio para que eles
FIT-F.1.24.01-02 Rev.B
75
possam ser usados novamente. Seja este o recurso - ou qualquer
recurso - que está incluído em um site, então é uma questão de escopo.
•
Estratégia: Dita como a camada mais profunda, nele ocorre todo o
mapeamento, pesquisas e hipóteses sobre as necessidades do usuário.
É fundamentalmente determinada pela estratégia do projeto, ou seja,
incorpora não somente o que as pessoas executam, mas também o que
elas e o desenvolvedor desejam como objetivo final, como por exemplo
no caso de lojas em que a finalidade é que os usuários comprem os
produtos apresentados.
4.2
Guide Line do Android
Os usuários do Android esperam que seu aplicativo tenha uma aparência e um
comportamento consistentes com a plataforma. É necessário não apenas seguir as
diretrizes de Material Design para os padrões visuais e de navegação, mas também
as diretrizes de qualidade para compatibilidade, desempenho, segurança e muito
mais.
O link https://developer.android.com/design oferece informações oficiais sobre
as interfaces no sistema operacional Android.
Figura 82: materiais encontrados no portal developer android. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
76
4.3
Arquivo XML de interfaces
O layout define a estrutura de uma interface do usuário no aplicativo, como
acontece na atividade. Todos os elementos do layout são criados usando a hierarquia
de objetos View e ViewGroup. A View geralmente desenha algo que o usuário pode
ver e com que pode interagir. Já um ViewGroup é um contêiner invisível que define a
estrutura do layout para View e outros objetos ViewGroup, como pode ser visto na
figura 83.
Figura 83: ilustração de uma hierarquia de visualização, que define o layout de uma IU.
Um layout pode ser declarado de duas maneiras:
•
Declarar elementos da IU em XML. O Android fornece um
vocabulário XML direto que corresponde às classes e subclasses de
visualização, como as de widgets e layouts. Também é possível usar
o Layout Editor do Android Studio para criar o layout XML usando
uma interface de arrastar e soltar.
•
Instanciar elementos do layout no momento da execução. O
aplicativo pode criar objetos View e ViewGroup (e processar suas
propriedades) programaticamente.
Ao declarar a IU no XML, é possível separar a apresentação do seu aplicativo
do código que controla o comportamento dele. O uso de arquivos XML também facilita
conseguir layouts diferentes para diferentes orientações e tamanhos de tela.
A biblioteca do Android oferece flexibilidade para usar um ou ambos os
métodos para criar a IU do seu aplicativo. Por exemplo, é possível declarar os layouts
FIT-F.1.24.01-02 Rev.B
77
padrão do aplicativo em XML e, em seguida, modificar o layout no momento da
execução.
Usando o vocabulário XML do Android, é possível projetar rapidamente layouts
de IU e os elementos de tela intrínsecos, do mesmo modo que se cria páginas Web
em HTML, com uma série de elementos aninhados.
4.4
Densidade de Pixels
Dispositivos Android não só vêm com vários tamanhos de telas (celulares,
tablets, TVs etc.) como as telas também têm diferentes tamanhos de pixel. Ou seja,
enquanto um dispositivo tem 160 pixels por polegada quadrada, outro encaixa 480
pixels no mesmo espaço. Se você não considerar essas variações em densidade de
pixels, o sistema pode dimensionar suas imagens (resultando em imagens borradas)
ou as imagens podem aparecer em um tamanho completamente errado.
A primeira armadilha a ser evitada é usar pixels para definir distâncias ou
tamanhos. Definir dimensões com pixels é um problema, porque telas diferentes têm
densidades pixels diferentes, de maneira que o mesmo número de pixels pode
corresponder a diferentes tamanhos físicos nos vários dispositivos.
FIT-F.1.24.01-02 Rev.B
78
Figura 83: duas telas do mesmo tamanho podem ter um número diferente de pixels. Fonte:
autoria própria.
Para preservar o tamanho visível da sua interface do usuário em telas com
diferentes densidades, você precisa projetar sua IU com pixels de densidade
independente (dp) como unidade de medida. Um dp é uma unidade de pixel virtual
aproximadamente do tamanho de um pixel em uma tela de densidade média (160 dpi,
a densidade "básica"). O Android converte esse valor no número apropriado de pixels
reais para cada densidade.
Por exemplo, veja os dois dispositivos da Figura 83. Se você definir uma
exibição como "100 px" de largura, ela aparecerá muito maior no dispositivo à
esquerda. Em vez disso, você precisa usar "100 dp" para garantir que ela apareça do
mesmo tamanho nas duas telas.
No entanto, você precisa usar pixels escalonáveis (sp) como suas unidades
para definir tamanhos de texto, mas nunca para tamanhos de layout. Por padrão, a
unidade sp é do mesmo tamanho que a dp, mas ela é redimensionada com base no
tamanho de texto preferencial do usuário.
Para
elementos
visuais,
android:layout_width
os
atributos
android:layout_height
e
são definidos em densidade de pixels. Em outras
palavras, o próprio framework do Android se encarrega de fazer os cálculos de
conversão de pixels para densidade de pixels, assim conseguimos garantir que os
componentes dos nossos aplicativos tenham o mesmo tamanho independente do
dispositivo utilizado.
Por fim, outra funcionalidade importante para manter a boa qualidade gráfica
em dispositivos com diferentes densidades de pixels é fornecer bitmaps alternativos.
Você precisa oferecer várias versões de cada bitmap no seu app, uma para cada
intervalo de densidade em uma resolução correspondente. Sem isso o Android
precisará dimensionar seu bitmap para que ele ocupe o mesmo espaço em cada tela,
o que pode resultar em imagens desfocadas. Veja um exemplo de tamanhos relativos
para bitmaps em diferentes densidades na figura 84.
FIT-F.1.24.01-02 Rev.B
79
Figura 84: Bitmaps em diferentes densidades. Fonte: Google Developers (2021).
Diversos sites para criação e download de imagens/ícones para Android já
fornecem uma opção de arquivo para cada densidade de pixel. Os diferentes
qualificadores de densidade e suas respectivas descrições segundo Google
Developers (2021) pode ser visto na seguinte tabela:
Qualificado
r de
densidade
Descrição
ldpi
Recursos para telas de baixa densidade (ldpi)
(cerca de 120 dpi).
mdpi
Recursos para telas de média densidade (mdpi)
(cerca de 160 dpi). Essa é a densidade básica.
hdpi
Recursos para telas de alta densidade (hdpi)
(cerca de 240 dpi).
xhdpi
Recursos para telas de densidade extra-alta
(xhdpi) (cerca de 320 dpi).
xxhdpi
Recursos para telas de densidade extra-extra-alta
(xxhdpi) (cerca de 480 dpi).
xxxhdpi
Recursos para telas de densidade extra-extraextra-alta (xxxhdpi) (cerca de 640 dpi).
nodpi
Recursos para todas as densidades. Esses são
recursos independentes de densidade. O sistema
não dimensiona recursos marcados com esse
qualificador, independentemente da densidade
da tela atual.
tvdpi
Recursos para telas entre
aproximadamente 213 dpi.
FIT-F.1.24.01-02 Rev.B
80
mdpi e hdpi;
Esse não é
considerado um grupo de densidade "principal".
Ele é destinado principalmente a televisões, e a
maioria dos apps provavelmente não precisa
dele. Fornecer recursos mdpi e hdpi é o suficiente
para a maioria dos apps, e o sistema os
dimensionará conforme for apropriado. Se julgar
necessário fornecer recursos tvdpi, dimensioneos para um fator de 1,33*mdpi. Por exemplo, uma
imagem de 100 x 100 px para telas mdpi precisa
ter 133 x 133 px para tvdpi.
Tabela 2: qualificadores de densidade. Fonte: Google Developers (2021).
Mais informações sobre densidade de pixels no Android
podem ser consultadas no portal developer
(https://developer.android.com/training/multiscreen/scre
endensities). Você pode ver todas as unidades de
dimensões
suportadas
pelo
Android
(https://developer.android.com/guide/topics/resources/
more-resources.html#Dimension) .
4.5
Tipos de Layout
No Android podemos utilizar alguns tipos de construção do layout, podemos
destacar três o Linear, Relative e Webview. Iremos aprofundar cada um nos próximos
subtópicos.
4.5.1 Layout Linear
Linear Layout é um grupo de visualizações que alinha todos os filhos em uma
única direção vertical ou horizontal. Você pode especificar a direção do layout com o
atributo “android:orientation”.
FIT-F.1.24.01-02 Rev.B
81
Figura 85: exemplo de um linear layout. Fonte: Google Developers (2021).
Todos os filhos de um LinearLayout são empilhados um após o outro. Portanto,
uma lista vertical terá somente um filho por linha, independentemente da largura, e
uma lista horizontal terá altura de apenas uma linha (a altura do filho mais alto, mais
preenchimento).
Um
LinearLayout
respeita margens entre
filhos
e
a gravidade (alinhamento à direita, no centro ou à esquerda) de cada filho.
Alguns elementos que podemos utilizar no LinearLayout:
•
Ponderação
do
layout:
uma ponderação a
filhos
é
compatível
com
individuais
a
com
atribuição
o
de
atributo
“android:layout_weight”. Este atributo confere um valor de “importância”
a uma visualização em relação à quantidade de espaço que ela deve
ocupar na tela. Um valor de ponderação maior permite que ela se
expanda para preencher qualquer espaço restante na visualização pai.
As visualizações filhas podem especificar um valor de ponderação. Com
isso, todo o espaço restante no grupo de visualizações será designado
aos filhos na proporção da própria ponderação declarada. A ponderação
padrão é zero.
•
Distribuição igual: Para criar um layout linear em que cada filho usa a
mesma
quantidade
de
espaço
na
tela,
defina
a
“android:layout_height” de cada visualização como "0dp" (para um
layout vertical) ou a “android:layout_width” como "0dp" (para um layout
FIT-F.1.24.01-02 Rev.B
82
horizontal). Em seguida, defina a “android:layout_weight” de cada
visualização como "1".
•
Distribuição desigual: Você também pode criar layouts lineares em
que os elementos filhos usam diferentes quantidades de espaço na tela:
•
Se houver três campos de texto e dois deles tiverem uma ponderação
1, enquanto o outro não tiver ponderação, o terceiro campo de texto não
será expandido. Em vez disso, esse terceiro campo de texto ocupará
somente a área exigida pelo conteúdo. Os outros dois campos se
expandirão igualmente para preencher o espaço restante depois que os
três campos forem medidos.
•
Se houver três campos de texto e dois deles tiverem uma ponderação
1, enquanto o terceiro campo tiver uma ponderação 2 (em vez de 0), o
último será declarado mais importante que os outros e ficará com
metade do espaço total restante, enquanto os dois primeiros
compartilharão o resto igualmente.
4.5.2 Layout Relativo
RelativeLayout é um grupo de visualizações que exibe visualizações filhas em
posições relativas. A posição de cada visualização pode ser especificada como
relativa a elementos irmãos (por exemplo, à esquerda ou abaixo de outra
visualização) ou em posições relativas à área RelativeLayout pai (por exemplo,
alinhado à parte inferior, à esquerda ou no centro).
Um RelativeLayout é um utilitário muito eficiente para projetar uma interface de
usuário, porque ele pode eliminar grupos de visualização aninhados e manter a
hierarquia de layout plana, o que melhora o desempenho. Se você estiver usando
vários grupos aninhados de LinearLayout, poderá substituí-los por um único
RelativeLayout.
RelativeLayout permite que as visualizações filhas especifiquem a posição
delas em relação à visualização pai ou entre si (especificadas pelo código). Assim,
você pode alinhar dois elementos pela borda direita ou deixar um abaixo do outro,
centralizado na tela, centralizado à esquerda e assim por diante. Por padrão, todas
as visualizações filhas são desenhadas no canto superior esquerdo do layout.
FIT-F.1.24.01-02 Rev.B
83
Portanto, você precisa definir a posição de cada visualização usando as diversas
propriedades de layout disponíveis em RelativeLayout.LayoutParams.
Algumas das muitas propriedades de layout disponíveis para visualizações em
um RelativeLayout incluem:
•
android:layout_alignParentTop: Se "true", faz com que a borda superior
dessa visualização corresponda à borda superior do pai.
•
android:layout_centerVertical: Se "true", centraliza esse filho na vertical
no pai.
•
android:layout_below: Posiciona a borda superior dessa visualização
abaixo da visualização especificada com um código de recurso.
•
android:layout_toRightOf:
Posiciona
a
borda
esquerda
dessa
visualização à direita da visualização especificada com um código de
recurso.
Esses são apenas alguns exemplos. Todos os atributos de layout estão
documentados em RelativeLayout.LayoutParams.
O valor de cada propriedade de layout é um booleano para ativar uma posição
de layout em relação ao RelativeLayout pai ou um ID que referencia outra visualização
no layout em que a visualização tem que ser posicionada.
No layout XML, as dependências em relação a outras visualizações no layout
podem ser declaradas em qualquer ordem. Por exemplo, você pode declarar que
"visualização1"
está
posicionada
abaixo
de
"visualização2",
mesmo
que
"visualização2" seja a última visualização declarada na hierarquia. O exemplo abaixo
demonstra esse cenário.
4.5.3 Visualização Web
Se você quer entregar um aplicativo da Web (ou apenas uma página da Web)
como parte de um aplicativo cliente, é possível fazer isso usando WebView. A classe
WebView é uma extensão da classe View do Android, que permite exibir páginas da
Web como parte do layout de atividades. Ela não inclui recursos de um navegador da
Web completamente desenvolvido, como controles de navegação ou uma barra de
endereço. Por padrão, tudo o que WebView faz é mostrar uma página da Web.
FIT-F.1.24.01-02 Rev.B
84
Usar WebView pode ser útil quando você quer fornecer informações que talvez
precisem ser atualizadas, por exemplo, como um contrato de usuário final ou um guia
do usuário. No app para Android, você pode criar uma Activity que contenha uma
WebView e usá-la para exibir o documento hospedado on-line.
A WebView também pode ajudar caso o app forneça ao usuário dados que
sempre exigem uma conexão de Internet para serem recuperados, como e-mails.
Nesse caso, pode ser mais fácil criar no seu app para Android uma WebView que
mostre uma página da Web com todos os dados do usuário em vez de executar uma
solicitação de rede, analisar os dados e renderizá-los em um layout do Android. Em
vez disso, você pode criar uma página da Web personalizada para dispositivos
Android e implementar no próprio aplicativo uma WebView que carregue essa página.
Este documento mostra como dar os primeiros passos com a WebView e como
fazer outras coisas, como gerenciar a navegação nas páginas e vincular o JavaScript
da página da Web ao código do cliente no seu app para Android.
4.6
Tipos de navegação
Todo aplicativo que você criar terá um destino inicial fixo. Essa é a primeira tela
que o usuário vê ao abrir o aplicativo da tela de início. Esse destino também é a última
tela que o usuário vê quando retorna à tela de início após pressionar o botão "Voltar".
Vamos dar uma olhada na figura 86 de um aplicativo exemplo.
Figura 86: a tela ListScreen é o destino inicial do aplicativo exemplo. Fonte: Google
Developer (2021).
Ao iniciar o aplicativo exemplo da tela inicial, a primeira tela visualizada pelo
usuário é a List Screen, a lista de plantas no jardim. Essa também é a última tela que
FIT-F.1.24.01-02 Rev.B
85
eles veem antes de sair do aplicativo. Ao pressionar o botão "Voltar" na tela da lista,
eles voltarão para a tela de início.
Figura 87: os botões "Para cima" e "Voltar". Fonte: Google Developer (2021).
O botão "Voltar" é exibido na barra de navegação do sistema na parte inferior
da tela. É usado para navegar em ordem cronológica inversa pelo histórico de telas
com as quais o usuário trabalhou recentemente. Quando você pressiona o botão
"Voltar", o destino atual é removido da parte superior da pilha de retorno e você
navega até o destino anterior.
Os fragmentos introduzem a modularidade e a reutilização na IU da sua
atividade, permitindo que você divida a IU em blocos discretos. As atividades são um
local ideal para colocar elementos globais em torno da interface do usuário do seu
aplicativo, como uma gaveta de navegação. Por outro lado, os fragmentos são mais
adequados para definir e gerenciar a IU de uma única tela ou parte de uma tela.
Imagine um aplicativo que responde a vários tamanhos de tela. Em telas
maiores, o aplicativo precisa exibir uma gaveta de navegação estática e uma lista em
um layout de grade. Em telas menores, o aplicativo precisa exibir uma barra de
navegação inferior e uma lista em um layout linear. Gerenciar todas essas variações
na atividade pode ser difícil. Separar os elementos de navegação do conteúdo pode
tornar esse processo mais gerenciável. A atividade é responsável por exibir a IU de
navegação correta enquanto o fragmento exibe a lista com o layout adequado.
FIT-F.1.24.01-02 Rev.B
86
Figura 88: exemplo de uma navegação Fragment. Fonte: Google Developer (2021).
A figura 88 exibe duas versões da mesma tela em diferentes tamanhos. À
esquerda, uma tela grande contém uma gaveta de navegação controlada pela
atividade e uma lista de grade controlada pelo fragmento. À direita, uma tela pequena
contém uma barra de navegação inferior controlada pela atividade e uma lista linear
controlada pelo fragmento.
Dividir a IU em fragmentos facilita a modificação da aparência da atividade no
ambiente de execução. Enquanto sua atividade está no estado de ciclo de vida
STARTED ou em um estado mais avançado, os fragmentos podem ser adicionados,
substituídos ou removidos. Você pode manter um registro dessas mudanças em uma
pilha de retorno gerenciada pela atividade, permitindo que as mudanças sejam
revertidas.
É possível usar várias instâncias da mesma classe de fragmento na mesma
atividade, em várias atividades ou até mesmo como filha de outro fragmento. Você
precisa apenas fornecer um fragmento com a lógica necessária para gerenciar a
própria IU. É recomendável evitar a dependência ou manipulação de um fragmento
por outro.
4.7
Diferenças entre web e mobile
Uma grande diferença entre a navegação web e a mobile é que a web funciona
por páginas e links. Na programação pensamos na montagem das páginas e depois
nos links que levam o usuário até determinada página.
Já na navegação mobile, temos que pensar nessas duas formas, na mudança
de contexto ou aprofundamento dos detalhes. Uma grande diferença também está no
consumo de memória dos dispositivos que além de muito menor a navegação é feita
em pilhas ou nos contextos que ficam salvos na memória.
4.8
Ciclo de vida
Ao falar da arquitetura de aplicativo Android é importante ressaltar a diferença
entre o fluxo desses aplicativos e o fluxo de aplicativo desktop. Na maioria dos casos,
os apps desktop têm um único ponto de entrada em uma área de trabalho ou um
acesso rápido de programas e, em seguida, são executados como um único processo
monolítico. Por outro lado, os aplicativos Android têm uma estrutura muito mais
FIT-F.1.24.01-02 Rev.B
87
complexa. O usuário pode, por exemplo, estar usando um aplicativo de rede social.
Para tirar uma foto é aberto um aplicativo de câmera. O aplicativo de câmera pode
abrir outro aplicativo para gerenciamento de arquivos. Por fim o usuário retorna ao
app de rede social e publica a foto. Quando o usuário finalizar esse processo vai
querer voltar para o mesmo ponto em que parou no aplicativo de rede social. Além
disso, no meio de todo esse processo o usuário pode ainda receber ligações, abrir
outros apps e assim por diante. É preciso lidar com esses fluxos cuidadosamente. O
ciclo de vida é o responsável por indicar em qual estado o app se encontra (GOOGLE
DEVELOPERS, 2021).
A classe Activity fornece um conjunto de callbacks que permite que a atividade
sai sobre a mudança do estado: informa a respeito da criação, interrupção ou
retomada de uma atividade ou da destruição do processo em que ela reside por parte
do sistema. Dentro dos métodos de callback do ciclo de vida é possível declarar como
a atividade deve se comportar quando o usuário sai e retorna dela (GOOGLE
DEVELOPERS,
2021).
Segundo
Google
Developers
(2021),
https://developer.android.com/guide/components/activities/activity-lifecycle,
em
não
implementar o ciclo de vida corretamente pode ocasionar os seguintes problemas:
•
Falhas se o usuário receber uma chamada telefônica ou mudar para outro
aplicativo enquanto estiver usando seu aplicativo.
•
Consumo de recursos importantes do sistema quando o usuário não estiver
usando ativamente o aplicativo.
•
Perda do progresso do usuário se ele sair do aplicativo e retornar mais
tarde.
•
Falhas ou perda do progresso do usuário quando a orientação da tela
mudar entre paisagem e retrato.
O conjunto principal de callbacks fornecidos pela Activity segundo Google
Developers (2021) são:
•
onCreate(), acionado assim que o sistema cria a atividade, onde deve
ser executada a lógica básica de inicialização dos componentes da
atividade. Quando a atividade é criada é inserido o estado Criado;
•
onStart(), acionado quando a atividade é movida para o estado
Iniciado. A chamada a esse callback torna a atividade visível ao usuário;
FIT-F.1.24.01-02 Rev.B
88
•
onResume(), acionado quando a atividade vem para o primeiro plano e é
movida para o estado Retomado. Após esse método o app está em
interação com o usuário;
•
onPause(), acionado quando ocorre um evento de interrupção e a
atividade é movida para o estado Pausado. É a primeira indicação de que
o usuário está deixando a atividade, movendo-a para segundo plano;
•
onStop(), acionado quando a atividade não estiver mais visível ao usuário
ela for movida para o estado Interrompido. Nesse método o app deve
liberar ou ajustar recursos desnecessários e salvar informações que podem
ser destruídas caso o app venha a ser destruído;
•
onDestroy(), acionado antes da atividade ser destruída. Esse callback
libera todos os recursos não liberados pelos recursos anteriores.
Esses estados são alternados diretamente pelo Framework do Android e cabe
a nós implementar corretamente os callbacks. Os callbacks não são acionados
necessariamente na ordem completa. Caso o app entre no estado Pausado ele pode
retomar para o estado Retomado, nesse caso o app passará pelo callback onPause
e posteriormente pelo callback onResume. Caso o app entre no estado Interrompido
ele pode retomar para o estado Iniciado, nesse caso o app passará do callback
onStop para o callback onStart (GOOGLE DEVELOPERS, 2021). A partir do
momento que uma atividade entra no estado pausado seu processo pode ser morto
caso o sistema necessite de memória. Uma imagem ilustrando esse ciclo de vida
pode ser visualizada na figura 89.
FIT-F.1.24.01-02 Rev.B
89
Figura 89: ciclo de vida da Activity. Fonte: Google Developers (2021).
Veja informações detalhadas do ciclo de vida das
atividades
(https://developer.android.com/guide/components/activi
ties/activity-lifecycle).
4.9
Design Pattern MVC e MVVM
Na programação mobile utilizamos padrões de desenvolvimento para evitar
problemas de estruturação do código principalmente entre as regras de negócio e
elementos visuais.
Vamos conhecer dois grandes padrões utilizados na programação mobile, o
MVC e o MVVM.
FIT-F.1.24.01-02 Rev.B
90
4.9.1 MVC
Esta abordagem separa sua aplicação em um nível macro com 3 conjuntos de
responsabilidades. Sendo eles:
Figura 90: estrutura do MVC. Fonte: Medium.com (2017).
•
Model: No Model irá conter Data + State + Business Logic, de forma não
técnica. Podemos usar como exemplo lógica comercial, acesso a dados e
regra de negócios, que não está ligado a View ou Controller e com isto se
torna muito reutilizável.
•
View: Representa o Model, ela é a UI (user interface) e faz a comunicação
com a Controller sempre que ocorre uma interação do usuário. O ideal é
que sejam “burras”, isto é, quanto menos eles souberem do que deve ser
feito com a interação, mais flexíveis serão para mudar.
•
Controller: Ele é o responsável pelo que acontece no aplicativo. Quando a
View diz para o Controller que um usuário clicou em um botão, ele decide
como interagir. Se ocorrer modificação de dados no Model, o Controller
pode decidir atualizar o estado de exibição, quase sempre representado por
uma activity ou fragment. Há quem diga que ele é o coordenador entre a
View e o Model.
FIT-F.1.24.01-02 Rev.B
91
VC faz um excelente trabalho de separar o Model e a View. Assim o Model
pode ser facilmente testado, porque não está vinculado a nada e a View não tem
muito para testar em um nível de teste unitário. No entanto, o Controller definha.
Preocupações/Problemas do Controller:
•
Testabilidade - O controlador está tão ligado às APIs do Android que é
difícil testar a unidade.
•
Modularidade e flexibilidade - Os Controllers estão bem acoplados às
Views. Pode também ser uma extensão da View.
•
Se mudarmos a View, devemos voltar e mudar o Controller.
•
Manutenção - Ao longo do tempo, particularmente em aplicações com
modelos anêmicos, cada vez mais o código começa a ser transferido
para os Controllers, tornando-os cheios, complexos e com grande
facilidade de crashs.
VC faz um excelente trabalho de separar o Model e a View. Assim o Model
pode ser facilmente testado, porque não está vinculado a nada e a View não tem
muito para testar em um nível de teste unitário. No entanto, o Controller definha.
Preocupações/Problemas do Controller:
•
Testabilidade - O controlador está tão ligado às APIs do Android que é
difícil testar a unidade.
•
Modularidade e flexibilidade - Os Controllers estão bem acoplados às
Views. Pode também ser uma extensão da View.
•
Se mudarmos a View, devemos voltar e mudar o Controller.
•
Manutenção - Ao longo do tempo, particularmente em aplicações com
modelos anêmicos, cada vez mais o código começa a ser transferido
para os Controllers, tornando-os cheios, complexos e com grande
facilidade de crashs.
Preocupações/Problemas do Presenter:
•
Manutenção - Os Presenters, assim como os Controllers, são propensos
a colecionar lógica comercial adicional, espalhados com o tempo.
•
Eventualmente,
os
desenvolvedores
Presenters difíceis de separar.
FIT-F.1.24.01-02 Rev.B
92
deparam-se
com
grandes
4.9.2 MVVM
MVVM com o Data Binding tem como benefícios testes mais fáceis e
modularidade, ao mesmo tempo que reduz a quantidade de código que temos que
escrever para conectar o Model com a View. Este Pattern suporta ligação bidirecional
entre View e ViewModel, com isto nos permite ter propagação automática de
mudanças. Bem, vou explicar.
Figura 91: estrutura do MVVM. Fonte: Medium.com (2017).
•
Model: Igual ao MVC e MVP / Nenhuma mudança.
•
View: A View liga-se a variáveis Observable e ações expostas pelo
ViewModel de forma flexível.
ViewModel:
•
ViewModel é responsável por expor métodos, comandos e
propriedades que mantém o estado da View, assim como manipular
a Model com resultados de ações da View e preparar dados
Observable necessários para a exibição. Ele também fornece
ganchos para que a View passe eventos para o Model. No entanto o
ViewModel não está vinculado à View. Existe uma relação de muitospara-um entre a View e ViewModel, o que significa que uma
ViewModel pode mapear muitas Views.
Preocupações do MVVM:
•
Manutenção - As Views podem se ligar (bind) a ambas as variáveis
e expressões, adicionando código efetivamente ao nosso XML. Para
evitar isso, sempre obtenha valores diretamente do ViewModel em
vez de tentar calcular utilizando Lambda no XML, como no último
exemplo para trabalhar com VISIBLE ou GONE.
FIT-F.1.24.01-02 Rev.B
93
5 Componentes iniciais
Entender como funciona os componentes no desenvolvimento de aplicativos é
a base de conhecimento para nos tornarmos especialistas. O conhecimento do
desenvolvimento,
das
possibilidades,
complexidades
e
customizações
dos
componentes é muito importante para se tornar um excelente desenvolvedor mobile.
Nas próximas secções iremos abortar em detalhes os principais componentes
utilizados no desenvolvimento.
Para
o
treinamento,
iremos
criar
um
novo
projeto
chamado
“PrimeirosComponentes”, selecionando o template “Empty Activity” conforme
referência abaixo:
Figura 92: criando um novo projeto. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
94
Figura 93: criando um projeto utilizando o template Empty Activity. Fonte: autoria própria.
Figura 94: configuração do projeto de componentes. Fonte: autoria própria.
Vamos deixar o projeto já preparado para os componentes, criando um layout
do tipo linear. Abra o arquivo na pasta “app/res/layout/activity_main.xml” e aparecerá
a seguinte tela conforme a figura 5.4 abaixo:
FIT-F.1.24.01-02 Rev.B
95
Figura 95: layout do projeto. Fonte: autoria própria.
Na sequência, vamos selecionar a TextView “Hello World!” localizado no centro
da tela e deletar. Na sequência, na área “Pallet”, clicar em “Layouts” e clicar e arrastar
o “Linear Layout (vertical” para a tela conforme referência abaixo:
Figura 96: criando um Linear Layout (vertical). Fonte: autoria própria.
Para verificar se está tudo correto, na área “Component Tree”, aparecerá um
“Linear Layout” com configuração vertical conforme a figura 97 abaixo:
FIT-F.1.24.01-02 Rev.B
96
Figura 97: visualizando o “Component Tree” com o Linear Layout. Fonte: autoria própria.
5.1
Componente TextView
O primeiro componente que iremos aprender é o TextView. O componente tem
o objetivo de apresentar textos ou informações na tela.
Para criarmos, vamos na área “Palette” clicar em “Text” e clicar e arrastar para
a tela o “TextView”, conforme referencia abaixo:
Figura 98: arrastando o componente TextView. Fonte: autoria própria.
Para cada componente da tela, temos inúmeras propriedades para alterar e
customizar conforme nossas necessidades. Para visualizarmos todos os atributos
que o componente possui, basta clicar na visualização da tela no componente
desejado e aparecerá a área “Attributes” localizado na direita da tela conforme
referência abaixo:
FIT-F.1.24.01-02 Rev.B
97
Figura 99: aba de Attributes. Fonte: autoria própria.
Para atualizarmos o texto, basta procurarmos na lista o atributo “text” e altere
para o texto desejado. Como exemplo, vamos alterar o texto para “Curso de Android,
aprendendo textview”, conforme referência abaixo:
Figura 100: alterando o atributo “text” do componente TextView. Fonte: autoria própria.
Podemos alterar também a cor de fundo e o texto. Se Procurarmos os atributos
de core e não encontrarmos, basta clicar no botão do menu de Atributes chamado
“AllAttributes”, pois ele fica “recolhido”. Ao clicar, iremos visualizar todos os atributos
do componente conforme figura abaixo:
FIT-F.1.24.01-02 Rev.B
98
Figura 101: exibindo todos os atributos do componente “TextView”. Fonte: autoria própria.
Para alterar as cores procurar a propriedade background e clicar no botão de
“conta gotas”, abrindo o popup de seleção de cor conforme referência abaixo:
FIT-F.1.24.01-02 Rev.B
99
Figura 102: escolha do background color. Fonte: autoria própria.
Para alterar a cor da fonte, basta ir à propriedade “textColor” e alterar. A fim de
exemplo, segue o resultado da alteração conforme a figura abaixo:
Figura 103: alterando a cor do fundo e do texto. Fonte: autoria própria.
Existe uma propriedade importante que é a “ellipsize”. Essa propriedade diz o
comportamento de textos que são muito grandes. Por exemplo, se determinarmos um
tamanho curto com o texto aaabbbccc o comportamento se daria da seguinte forma:
•
startA saída será: ... bccc
•
endA saída será: aaab ...
•
middlea saída será: aa ... cc
FIT-F.1.24.01-02 Rev.B
100
•
marqueeA saída será: aaabbbccc deslizando automaticamente da
direita para a esquerda
Podemos também criar links para páginas web, email e telefone. Prosseguindo
o exemplo, vamos colocar algumas textview na sequência conforme referencia
abaixo:
Figura 104: Textviews com links. Fonte: autoria própria.
O comportamento será que ao clicar no site abrirá o navegador padrão com o
link informado, ao clicar no telefone irá solicitar uma ligação, no email, abrir o email
padrão e por fim, no endereço abrirá um mapa.
Por fim, segue alguns outros atributos com uma breve descrição:
5.2
•
font: fonte utilizada na label
•
gravity: formato da identação
•
maxlines: quantidade máxima de linhas
Arquivo de Values
Ao digitar textos, cores ou informações nos componentes, percebemos que o
Android Studio abre uma lista de informações. Essas informações ficam centralizadas
em arquivos padrões que facilitam a busca pelos textos, cores e recursos em geral.
FIT-F.1.24.01-02 Rev.B
101
É altamente recomendável que todo texto ou cores sejam primeiramente
inseridas nesses arquivos e depois referenciados nos componentes. Um exemplo
prático para a utilização destes arquivos é a internalização do aplicativo, caso tenha
múltiplas línguas ou atualização visual das cores.
O arquivo de textos está localizado na pasta res/values/strings.xml e o arquivo
de cores na res/values/colors.xml. Para inserir algum dado nesses arquivos, basta
editá-los, conforme exemplo abaixo, editamos o string.xml:
Figura 105: criando no arquivo strings. Fonte: autoria própria.
Da mesma forma, editamos o colors.xml conforme referência abaixo:
Figura 106: inserindo uma nova cor no arquivo colors.xml. Fonte: autoria própria.
Ao lado esquerdo do XML no arquivo de colors, fica a cor
final utilizado.
Para utilizarmos no layout, basta nos lugares fixos dos textos ou cores,
incluirmos o nome que criamos, conforme o exemplo abaixo:
FIT-F.1.24.01-02 Rev.B
102
Figura 107: utilizando os aquivos xml para texto e cor. Fonte: autoria própria.
5.3
Componente Button
Para criar o componente Button, basta ir à área “Palette>Buttons”, clicar e
arrastar para a tela o componente Button, conforme referência abaixo:
Figura 108: componente Button. Fonte: autoria própria.
Se rodarmos o exemplo percebemos que o botão aparece, porém quando
clicamos, nada acontece. O próximo passo é conseguir capturar esse evento para
realizar alguma programação específica.
Para conseguirmos capturar o evento precisamos criar uma função vamos criar
uma função de para ser executada quando o botão for clicado, conforme referência
abaixo:
FIT-F.1.24.01-02 Rev.B
103
Figura 109: função do botão ao ser clicado. Fonte: autoria própria.
Veja que ao digitar a função o tipo do parâmetro “View” ficou em vermelho,
sinalizando que há algum erro. Se passar o mouse por cima, ele irá sugerir de importar
a classe, basta clicar em “import” e o problema será resolvido, conforme imagem
abaixo:
Figura 110: problema ao utilizar uma classe sem importar. Fonte: autoria própria.
O próximo ponto é associar o evento de clique do botão a função que criamos.
Faremos isso de duas formas na programação e no arquivo XML do layout. Para
associarmos, basta abrirmos o aquivo activity_main.xml, selecionar o botão que
criamos anteriormente, ir na área “Common Attributes” e clicar no atributo “onClick”.
Figura 111: associar o evento do componente a função. Fonte: autoria própria.
Ao atribuir a função e executar o projeto, conseguimos verificar a execução
através do LogCat, conforme figura abaixo:
FIT-F.1.24.01-02 Rev.B
104
Figura 112: resultado da tela do logcat. Fonte: autoria própria.
5.4
Componente PlainText e TextInputLayout
Vamos adicionar os componentes PlainText e TextInputLayout no projeto
ficando da seguinte forma:
Figura 113: inserindo os componentes na tela. Fonte: autoria própria.
Ao executar o projeto e clicarmos em um dos campos irá abrir o teclado do
sistema operacional conforme imagem abaixo:
FIT-F.1.24.01-02 Rev.B
105
Figura 114: imagem do simulador exibindo o teclado. Fonte: autoria própria.
Uma propriedade muito importante é a hint, que é um texto que exibe o que o
usuário deve digitar no campo. Utilizamos para digitar o e-mail do usuário conforme
exemplo abaixo:
FIT-F.1.24.01-02 Rev.B
106
Figura 115: campo de input com hint “digite seu email” . Fonte: autoria própria.
A diferença entre os componentes é apenas que o PlainText está com o
inputType já atribuído como “textPersonanName”. Esse atributo nos diz qual o tipo de
input que o componente irá aceitar ou priorizar. Segue abaixo a lista completa do
atributo:
FIT-F.1.24.01-02 Rev.B
107
Figura 116: lista de tipos do inputType. Fonte: autoria própria.
Podemos destacar os principais inputType:
•
Date, datetime, numeber: permite input de números apenas
•
textAutoComplete: Completa o texto.
•
Phone: Input para número de telefone.
•
textEmailAddress: Configura o teclado para apresentar o “@”.
•
textPassword, numberPassword ou textWebPassword: componente
que esconde o item digitado.
O próximo passo é capturar o texto digitado. Podemos utilizar o evento do
botão para realizar essa captura. O primeiro ponto é termos acesso ao componente
que criamos, para isso existe um atributo em todos os componentes visuais chamado
“id”. Para testarmos o conceito, vamos criar mais um textView e alterar o seu id para
“tv_imprimindoTexto”, alterar o id do textInput para “ti_textoUsuario”. Ao realizar a
alteração, o Android Studio solicitará um “refactor” no código, para mudar o nome do
FIT-F.1.24.01-02 Rev.B
108
ID em todos os locais que fazem referência, basta clicar em “Refactor” conforme
imagem abaixo:
Figura 117: refatorando o nome do ID dos componentes. Fonte: autoria própria.
O próximo passo é abrir a MainActivity.kt e modificarmos a função do clique do
botão para o seguinte código:
Figura 118: atribuindo o texto ao componente. Fonte: autoria própria.
Ao executar, digitar o texto no componente e clicar no botão, teremos o
seguinte resultado:
FIT-F.1.24.01-02 Rev.B
109
Figura 119: Resultado do exemplo. Fonte: autoria própria.
5.5
Componente Switch
O componente switch é utilizado com um aspecto booleano, isto é,
ligado/desligado. O componente fica localizado na “Palette>Buttons>Switch”, basta
clicar e arrastar conforme a figura abaixo:
FIT-F.1.24.01-02 Rev.B
110
Figura 120: inserindo o componente switch. Fonte: autoria própria.
Vamos alterar o atributo “text” para “Componente Visível” e deixar já habilitado
no atributo checked. O objetivo do exercício é ao desabilitar, esconder o componente
de input, para isso precisaremos construir uma função quando mudar de on para off
ou vice e versa. Abaixo a função criada:
Figura 121: código para esconder o botão utilizando o switch. Fonte: autoria própria.
5.6
Componente Checkbox
O próximo atributo que iremos aprender é o checkbox. Para adicionar na tela
basta ir na área “Palette>Buttons>CheckBox”, clicar e arrastar para a tela, deixando
conforme referencia abaixo:
FIT-F.1.24.01-02 Rev.B
111
Figura 122: incluindo o componente CheckBox na tela. Fonte: autoria própria.
Vamos criar uma função chamada “mudouCheckBox” e colocar o evento de
onClick para os dois itens. Para utilizar a mesma função para múltiplos itens da
mesma classe, podemos identificar os itens com a propriedade “tag”, conforme código
exemplo abaixo:
Figura 123: código para deixar visível ou invisível os componentes de texto. Fonte: autoria
própria.
5.7
Componente Chip
O chip componente é uma pequena caixa que pode conter até: imagem de
perfil; texto; e ícone. Na documentação do Material Design este componente é
descrito como "pequena caixa complexa" podendo ser utilizado em vários contextos:
tags; contatos; marcações em texto; entre outros.
FIT-F.1.24.01-02 Rev.B
112
A seguir algumas regras de negócio quanto ao uso de componentes chip não
somente em aplicativos Android, mas também em qualquer app que faz uso do
Material Design como linguagem de design:
Figura 124: exemplo de utilização do componente Chip. Fonte: autoria própria.
Qualquer contexto onde seja necessário, de maneira destacada e completa, a
apresentação de pequenos itens que tenham ao menos um pequeno trecho de texto
de representação de contato, tag de conteúdo, informe publicitário, notificação
interna, entre outros.
Essa parte de "ao menos um pequeno trecho de texto" é definida aqui de
maneira explícita, pois na documentação do chips no Material Design isso fica
implícito: não fazer sentido ter um ChipView sem um pequeno texto, mesmo que ele
já tenha imagem e ícone.
5.8
Componente RadioButton e RadioGroup
Este componente é bem semelhante ao CheckBox, porém se difere que ao
menos um elemento deve ser selecionado. O componente faz sentido em um grupo
de botões e não isoladamente, portanto vamos criar o componente RadioGroup e
adicionar RadioButtons dentro e executar o projeto. Ele terá o comportamento de
selecionar apenas 1 deste grupo, isto é, quando selecionar o segundo elemento ele
retira a seleção do anterior, conforme referência abaixo:
FIT-F.1.24.01-02 Rev.B
113
Figura 125: exemplo de radio button. Fonte: autoria própria.
Podemos declarar uma função que recebe o RadioButton e verifica qual
elemento está selecionado, conforme código abaixo:
Figura 126: Percorrendo os RadioButtons do RadioGruop. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
114
5.9
Componente Seekbar, Discrete e ProgressBar
Para o treinamento dos últimos componentes, vamos criar um último projeto
para esse módulo que seria uma calculadora. Basicamente teremos 2 inputs de
entrada um grupo de radiobuttons que serão divisão e multiplicação, um textView que
exibirá o resultado e um botão para calcular.
Vamos iniciar criando um projeto chamado “Componentes2” utilizando o
template de “EmpityActivity”. Vamos configurar a tela deletando o TextView “Hello
World”, criando um Linear Layout (vertical) com os componentes: “Palette > Widgets
> SeekBar”, textView, “Palette > Widgets > SeekBar (discrete)”, textView,
RadioGroup, RadioButton1, RadioButton2, Button, TextView e um “Palette > Widgets
> ProgressBar (Horizontal), conforme referência abaixo:
Figura 127: montando a tela do exemplo da calculadora. Fonte: autoria própria.
Em seguida, vamos definir todos os IDs para cada componente conforme
abaixo:
•
seekbar: sb_seekOperador1
•
textView: tv_textOperador1
FIT-F.1.24.01-02 Rev.B
115
•
seekbar (discrete): sb_seekOperador2
•
textView: tv_textOperador2
•
radioGroup: rg_grupo
•
radiobutton1: rb_divisao
•
radiobutton2: rb_multiplicacao
•
button: btn_calcular
•
textview: tv_textResultado
•
progressbar (horizontal): pb_progressoCampos
Caso quisermos mudar a ordem dos componentes que é apresentado na tela,
podemos fazer via XML, clicando na parte de visualização de CODE, localizado no
canto superior direito da tela, conforme referência abaixo:
Figura 128: botão de “Code” na tela de layout. Fonte: autoria própria.
Ao clicar, iremos visualizar o XML do layout e basta trocar a ordem da
declaração do componente. Para fins de exemplo, vamos colocar o progressBar como
o primeiro item, ficando o XML da seguinte forma:
FIT-F.1.24.01-02 Rev.B
116
Figura 129: XML do layout, passamos o progressBar para o primeiro item. Fonte: autoria
própria.
Para voltar a visualização como antes, basta clicar em “Design”.
O primeiro ponto é configurar os textos para a forma inicial, conforme referência
abaixo:
FIT-F.1.24.01-02 Rev.B
117
Figura 130: resultado com as alterações textuais. Fonte: autoria própria.
O passo seguinte é limitar os dois seekbar com números que queremos
utilizando os atributos “max” e o “progress” (no seekbar discrete). Em seguida,
precisamos capturar o evento, quando o valor do seekbar alterar, para isso
utilizaremos o conceito de “Listeners”.
Os listeners são funções de interface pré definida que serão chamadas dado
que algum evento aconteça. Para utilizar os listeners no componente seekbar, segue
o código adicionando um listener para cada seekbar:
FIT-F.1.24.01-02 Rev.B
118
Figura 131: adicionando listeners ao seekbar. Fonte: autoria própria.
Ao executar o código conseguimos já visualizar os valores do seekbar na tela,
conforme a figura abaixo:
FIT-F.1.24.01-02 Rev.B
119
Figura 132: visualizando os Textview com o valor do seekbar. Fonte: autoria própria.
O próximo passo é atualizar o progressBar para cada interação, isto é, quando
o usuário interagir com o seekbar1 irá preencher 33%, interagiu com o seekbar2,
acrecentar mais 33% e ao selecionar algum RadioButton acrescentar mais 33%.
Ao clicar em calcular, apresentar o resultado na textview, conforme código
abaixo:
Figura 133: declaração de variáveis booleanas. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
120
Figura 134: código do onStart() para o progressBar. Fonte: autoria própria.
Figura 135: código implementando a seekbar e progressbar. Fonte: autoria própria.
Por fim, é adicionar o capturar o evento do radioButton e ao clicar em “Calcular”
realizar a conta, imprimindo no textView. O Código final ficará da seguinte forma:
FIT-F.1.24.01-02 Rev.B
121
Figura 136: código final para a calculadora utilizando seekbar e progressbar. Fonte: autoria
própria.
5.10 Componente Dialog e Toast
Continuando o projeto da calculadora, e se não clicarmos em nenhum
radioButton ou tentarmos uma divisão por zero, o que aconteceria com o aplicativo?
Com certeza não é um comportamento esperado e temos que evitar e avisar o usuário
a inserir todos os dados corretamente
Utilizaremos o componente Dialog para avisar divisão por zero e o Toast caso
ele esqueça de inserir algum dado. O código da função “acaoCalcular” ficará da
seguinte forma:
Figura 137: início da função calcular. Fonte: autoria própria.
E alterar o if da condição de divisão, inserindo o bloco de código abaixo:
FIT-F.1.24.01-02 Rev.B
122
Figura 138: código para abertura de uma Dialog. Fonte: autoria própria.
Caso a mensagem tipo Toast não aparece no emulador, é necessário habilitar
essa configuração entrando na tela de AVD Manager, selecionando o seu emulador,
clicando na seta a direita e “Wipe Data” conforme imagem abaixo:
Figura 139: habilitando as notificações no emulador. Fonte: autoria própria.
O resultado ficará conforme a figura abaixo:
FIT-F.1.24.01-02 Rev.B
123
Figura 140: resultado utilizando o Toast e Dialog. Fonte: autoria própria.
5.11 Mudando de tela
Para realizar uma mudança de tela, precisamos criar uma nova Activity. Cada
tela no Android é uma Activity, portanto o primeiro passo é criar uma nova tela
clicando com o botão direito do mouse na pasta “Java/com.example.componentes2 >
New > Acitivty > Basic Activity” conforme a figura abaixo:
FIT-F.1.24.01-02 Rev.B
124
Figura 141: criando uma nova Activity. Fonte: autoria própria.
O Android Studio irá abrir uma tela de configuração para definir o nome
da nova activity. Vamos colocar o nome de ActivityResultado e clicar em finish,
conforme figura abaixo:
Figura 142: criando uma nova Activity. Fonte: autoria própria.
Vamos abrir o activity_resultado.xml e criar a tela com uma label que é o
resultado e um botão voltar para a tela anterior, conforme a referencia abaixo:
FIT-F.1.24.01-02 Rev.B
125
Figura 143: montagem da tela de resultado. Fonte: autoria própria.
Precisamos alterar o método “acaoCalcular” e no final, criar um Intent para
solicitar uma mudança de tela, conforme o código abaixo:
Figura 144: criando uma Intent para mudar de tela. Fonte: autoria própria.
O próximo passo é passar informações para a tela seguinte, portanto iremos
alterar o código anterior para inserir informações na Intent utilizando o método
“putExtra” conforme referencia abaixo:
FIT-F.1.24.01-02 Rev.B
126
Figura 145: inserindo informações para a próxima tela. Fonte: autoria própria.
Para realizar a leitura, basta puxarmos na Intent as informações utilizando o
método getIntExtra(), conforme código abaixo:
Figura 146: puxando informações. Fonte: autoria própria.
Por fim, iremos criar uma função para ao clicar no botão “Voltar” e a forma
lógica seria criar uma outra Intent, porém estaríamos criando uma nova tela e não
retornando a tela anterior. Portanto a forma correta é de finalizar a activity utilizando
o método finish, conforme referencia abaixo:
Figura 147: finalizando a activity. Fonte: autoria própria.
FIT-F.1.24.01-02 Rev.B
127
Conclusão
A abordagem desta apostila permite ao leitor uma interação ativa com os
fundamentos do desenvolvimento Android mobile. Ensinar como iniciar e utilizar os
principais componentes para o desenvolvimento de aplicativos para a plataforma
mobile foi trabalhada para dar ao aluno autonomia, estímulo, senso crítico e contribuir
para uma aprendizagem mais efetiva.
O
aluno
pode
aprender
sobre
conceitos
importantes para
o
seu
desenvolvimento profissional e praticar seu aprendizado técnico utilizando os
principais componentes para desenvolver aplicativos mobile para a plataforma
Android.
Assim, o conteúdo do curso Desenvolvimento Android Mobile – Módulo 1
familiariza o leitor com o mundo tecnológico e as grandes tendências de mercado,
onde o desenvolvimento e utilização de aplicativos mobile ganha, cada vez mais,
espaço e agrada as empresas por reduzir custos e aumentar as margens de lucro.
Obrigada por fazer parte do curso e ter realizado a leitura desta apostila. Espero que
o interesse pelo desenvolvimento mobile apresentado neste curso esteja aguçado,
para que você pratique e conheça ainda mais as maravilhas desse universo.
A tecnologia mobile e o desenvolvimento de aplicativos é uma grande
tendência e o aprendizado desde curso servirá como base para ingressar neste
mercado.
2.
Revisão
Review
A
CONTROLE DE REVISÃO DO DOCUMENTO / DOCUMENT REVISION CONTROL
Descrição
Description
-
Razão
Reason
Revisão inicial
FIT-F.1.24.01-02 Rev.B
128
Autor
Author
Larissa Alves
Data
Date
02/02/22
Referências
OPENHUB
(2021)
Languages. Disponível
em:
<
https://www.openhub.net/p/android/analyses/latest/languages_summary>.
Acessado em: outubro de 2021
TANENBAUM, ANDREW. Sistemas operacionais modernos. Rio de
Janeiro: LTC. 1999.
TEIXEIRA, FABRICIO (2016). Estatísticas sobre uso de aplicativos
mobile. Disponível em: < https://brasil.uxdesign.cc/estat%C3%ADsticas-sobreuso-de-aplicativos-mobile-b0d2fac578eb>. Acessado em: Janeiro 2022
ZANELLA, JONATHAN RAFAEL (2017). Kotlin: explorando uma nova
linguagem.
Diponível
em:
<
https://medium.com/android-dev-br/kotlin-
explorando-uma-nova-linguagem-%EF%B8%8F-799ffc99a1a2>
Acessado
em: Janeiro 2022
KOTLINLANG
(2022).
Disponível
em
:
<
https://kotlinlang.org/docs/home.html>. Acessado em: Janeiro 2022
CAENO, MOBILE (2018), Android – Entedendo o API Level. Disponível
em:
https://medium.com/droid-dev/android-entendendo-o-api-level-
c4e3b7528b85. Acessado em: Janeiro 2022
GOOGLE
(2021).
Udacity.
Disponivel
<https://www.udacity.com/google>. Acesso em: Fevereiro 2021.
FIT-F.1.24.01-02 Rev.B
129
em:
GOOGLE
(2021).
Material
Design.
Disponivel
em:
<https://material.io/>. Acesso em: Fevereiro 2021.
GOOGLE DEVELOPERS (2021). Android Developers. Disponivel em:
<https://developer.android.com>. Acesso em: Fevereiro 2021.
ESTEVAO,
DEVMEDIA
(2019).
Disponível
em:
<
https://www.devmedia.com.br/kotlin-variaveis/40673>. Acessado em: Janeiro
2022
MGBEMENA, CHIKE (2017). Kotlin a partir do princípio. Disponível em:
<
https://code.tutsplus.com/pt/tutorials/kotlin-from-scratch-variables-basic-
types-arrays-type-inference-and-comments--cms-29328> .
Acessado
em:
Janeiro 2022
NUNES, FILIPE (2017). Android MVC x MVP x MVVM. Disponível em:
<
https://medium.com/@FilipeFNunes/android-mvc-x-mvp-x-mvvm-qual-
pattern-utilizar-parte-1-3defc5c89afd> Acessado em: Janeiro 2022
FIT-F.1.24.01-02 Rev.B
130
BOM CURSO!
FIT-F.1.24.01-02 Rev.B
131