Android Profissional - Desenvolvimento moderno de aplicações by Grupo Lidel

EDIÇÃO FCA – Editora de Informática, Lda. Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 511 448 fca@fca.pt www.fca.pt DISTRIBUIÇÃO Lidel – Edições Técnicas, Lda. Rua D. Estefânia, 183, R/C Dto. – 1049-057 Lisboa Tel: +351 213 511 448 lidel@lidel.pt www.lidel.pt LIVRARIA Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 511 448 * Fax: +351 213 522 684 livraria@lidel.pt Copyright © 2018, FCA – Editora de Informática, Lda. ISBN edição impressa: 978-972-722-874-4 1.ª edição impressa: fevereiro 2018 Impressão e acabamento: Tipografia Lousanense, Lda. – Lousã Depósito Legal n.º 437331/18 Capa: José M. Ferrão – Look-Ahead

Marcas Registadas de FCA – Editora de Informática, Lda. –

Todos os nossos livros passam por um rigoroso controlo de qualidade, no entanto aconselhamos a consulta periódica do nosso site (www.fca.pt) para fazer o download de eventuais correções. Não nos responsabilizamos por desatualizações das hiperligações presentes nesta obra, que foram verificadas à data de publicação da mesma. Os nomes comerciais referenciados neste livro têm patente registada. Reservados todos os direitos. Esta publicação não pode ser reproduzida, nem transmitida, no todo ou em parte, por qualquer processo eletrónico, mecânico, fotocópia, digitalização, gravação, sistema de armazenamento e disponibilização de informação, sítio Web, blogue ou outros, sem prévia autorização escrita da Editora, exceto o permitido pelo CDADC, em termos de cópia privada pela AGECOP – Associação para a Gestão da Cópia Privada, através do pagamento das respetivas taxas.

ÍNDICE GERAL O AUTOR ............................................................................................. XI AGRADECIMENTOS ............................................................................... XIII 1. A PLATAFORMA ANDROID ...................................................................... 1 1.1. Introdução ........................................................................................................................... 1 1.2. Android Oreo ..................................................................................................................... 2 1.3. Requisitos para desenvolvimento..................................................................................... 5 1.3.1. Instalação do JDK ...................................................................................................... 5 1.3.2. Instalação e configuração do Android Studio ....................................................... 6 1.4. Android Studio 3.0.............................................................................................................. 8 1.4.1. Interface gráfica do IDE ............................................................................................ 8 1.4.2. Projetos Android ..................................................................................................... 10 1.4.3. Workflow básico...................................................................................................... 17 1.5. Componentes principais .................................................................................................. 18 1.5.1. Atividades ................................................................................................................ 19 1.5.2. Recetores de broadcast ............................................................................................. 30 Resumo ...................................................................................................................................... 36 2. INTERFACE GRÁFICA .......................................................................... 37 2.1. Introdução .......................................................................................................................... 37 2.2. Layouts e views ................................................................................................................... 37 2.2.1. ConstraintLayout ................................................................................................. 39 2.2.2. CardView .................................................................................................................. 45 2.2.3. RecyclerView .......................................................................................................... 48 2.3. Bibliotecas de imagens ..................................................................................................... 53 2.3.1. Butterknife ................................................................................................................ 53 2.3.2. Picasso....................................................................................................................... 58 2.3.3. Glide .......................................................................................................................... 63 2.4. Aplicação Music2You ....................................................................................................... 67 2.4.1. Uso de templates Android ....................................................................................... 67 2.4.2. Instalação e configuração do template ................................................................... 68 2.4.3. Estrutura do projeto ................................................................................................ 70 2.4.4. Personalização ......................................................................................................... 72 2.4.5. Execução da aplicação ............................................................................................ 72 Resumo ...................................................................................................................................... 73

VIII

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

3. GESTÃO DE DADOS NA CLOUD ............................................................... 75 3.1. Introdução .......................................................................................................................... 75 3.2. Firebase............................................................................................................................... 76 3.2.1. Autenticação ............................................................................................................ 78 3.2.2. Bases de dados em tempo real............................................................................... 84 3.2.3. Armazenamento ...................................................................................................... 96 3.2.4. Analytics ................................................................................................................. 100 3.3. Aplicação TalkToMe ....................................................................................................... 102 3.3.1. Configurações iniciais ........................................................................................... 103 3.3.2. Interface gráfica ..................................................................................................... 104 3.3.3. Autenticação .......................................................................................................... 105 3.3.4. Criação de modelo ................................................................................................ 108 3.3.5. Submissão de mensagens ..................................................................................... 110 3.3.6. Listagem de mensagens........................................................................................ 111 Resumo .................................................................................................................................... 113 4. NETWORKING .................................................................................. 115 4.1. Introdução ........................................................................................................................ 115 4.2. Threads .............................................................................................................................. 115 4.2.1. Classes Thread e Runnable .................................................................................. 116 4.2.2. Classe AsyncTask .................................................................................................. 117 4.3. Serviços............................................................................................................................. 121 4.3.1. Introdução aos serviços ........................................................................................ 121 4.3.2. Criação e execução ................................................................................................ 123 4.3.3. Comunicação ......................................................................................................... 124 4.4. Clientes HTTP ................................................................................................................. 129 4.4.1. Classe HttpUrlConnection ................................................................................. 130 4.4.2. OkHttp .................................................................................................................... 132 4.4.3. Volley ...................................................................................................................... 136 4.4.4. Retrofit .................................................................................................................... 142 4.5. Aplicação Meteoly .......................................................................................................... 148 4.5.1. Configurações iniciais ........................................................................................... 149 4.5.2. Interface gráfica ..................................................................................................... 149 Resumo .................................................................................................................................... 156 5. SENSORES ...................................................................................... 157 5.1. Introdução ........................................................................................................................ 157 5.1.1. Sensores de movimento ........................................................................................ 158 5.1.2. Sensores ambientais .............................................................................................. 159 5.1.3. Sensores de posição............................................................................................... 160

ÍNDICE GERAL

5.2. Gestão e manipulação de sensores ............................................................................... 161 5.2.1. Android Sensor Stack ........................................................................................... 161 5.2.2. Classes principais .................................................................................................. 162 5.2.3. Manipulação de sensores ..................................................................................... 163 5.2.4. Exemplo prático: Acelerómetro........................................................................... 168 5.2.5. Exemplo prático: Giroscópio ............................................................................... 170 5.2.6. Exemplo prático: Proximidade ............................................................................ 174 5.3. Aplicação Fit .................................................................................................................... 176 5.3.1. Google Fit ............................................................................................................... 176 5.3.2. Interface gráfica ..................................................................................................... 181 5.3.3. Autenticação e autorização .................................................................................. 182 5.3.4. Leitura de sensores................................................................................................ 184 Resumo .................................................................................................................................... 186 GLOSSÁRIO DE TERMOS PORTUGUÊS EUROPEU/PORTUGUÊS DO BRASIL ........... 187 ÍNDICE REMISSIVO .............................................................................. 189

A PLATAFORMA ANDROID

O Android é um sistema operativo (SO) móvel, lançado em setembro de 2008, atualmente desenvolvido pela empresa Google. Este capítulo tem como objetivo apresentar o estado atual da plataforma. Nesse sentido, será apresentada a evolução do SO até à sua versão mais recente, o Android Oreo. Depois, serão abordados os requisitos de desenvolvimento, dando-se destaque ao novo Android Studio 3.0, bem como os principais componentes de uma aplicação Android, nomeadamente as atividades e os recetores de broadcast.

1.1

INTRODUÇÃO

O Android é o sistema operativo (SO) para dispositivos móveis mais utilizado no mundo. A história do Android é simples. Em outubro de 2003, foi fundada, em Palo Alto (Califórnia, Estados Unidos da América – EUA), a Android Inc., por Andy Rubin, Rich Miner, Nick Sears e Chris White. O propósito, nas palavras de Rubin, era o desenvolvimento de “dispositivos móveis inteligentes mais cientes da localização e preferências do seu dono”. Em julho de 2005, a Google adquiriu a Android Inc. Em novembro de 2007, a Open Handset Alliance foi apresentada ao mercado internacional como uma aliança de empresas com o objetivo de desenvolver padrões abertos para dispositivos móveis. Essa aliança teve 34 membros fundadores, desde operadores móveis (T-Mobile, Telefónica, etc.) a empresas de software (Google, eBay, etc.) e fabricantes de hardware (HTC, LG, Sony, Motorola e Samsung). Ainda em 2007, foi tornado público o primeiro produto dessa união: uma plataforma para dispositivos móveis chamada Android. Desde 2008 que o Android tem recebido várias atualizações que melhoraram substancialmente o sistema, com a adição de novas funcionalidades e a resolução de erros de versões anteriores. A cada grande atualização muda o nome de código do sistema, sendo este identificado com nomes de sobremesas ou bolos (em inglês), seguindo uma lógica alfabética (Figura 1.1).

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

FIGURA 1.1 – Versões do Android

1.2

ANDROID OREO

A nova versão do Android – Android Oreo – foi lançada em agosto de 2017. Como principais funcionalidades destacam-se as seguintes: Notificações – permite criar canais e badges de notificação, adiar notificações, definir tempos limite e configurar a visualização de mensagens, como definir cores de fundo e o estilo de mensagens (Figura 1.2);

FIGURA 1.2 – Canais de notificação no Android Oreo

Google Play Protect – auxilia o utilizador na deteção e na remoção de aplicações nocivas através da ferramenta anti-malware Play Protect; Smart Text Selection – permite automatizar tarefas através da análise inteligente de texto selecionado. Suponha que alguém lhe envia um texto com um e-mail; ao selecioná-lo, o Android será capaz de perceber que tipo de informação se trata, a ponto de abrir a respetiva aplicação de e-mail; WebView – oferece suporte para novas Application Programming Interfaces (API), com o objetivo de ajudar a gerir os objetos WebView que exibem conteúdo Web numa aplicação Android; © FCA

A PLATAFORMA ANDROID

Autofill Framework – facilita o preenchimento automático de formulários, como os de login e de cartões de crédito, e minimiza os erros de entrada de dados (Figura 1.3). A Google adicionou a framework Autofill, que vai gerir a comunicação entre a aplicação e o serviço de preenchimento automático, o qual já se encontra implementado através de várias aplicações de gestão de passwords, como o 1Password ou o Dashlane;

FIGURA 1.3 – Preenchimento automático baseado no serviço Autofill

Picture in Picture (PIP) – permite que o utilizador veja, por exemplo, um vídeo numa pequena janela no canto do ecrã, ao mesmo tempo que interage com outra atividade (Figura 1.4);

FIGURA 1.4 – Função PIP © FCA

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES Áudio – introduz suporte a novas API (AAudio), projetadas para aplicações de áudio de alto desempenho que requerem baixa latência, e a novos codecs, como o codec LDAC, da Sony. O LDAC transmite músicas a um bitrate máximo de 990 kb/s e amostragem de 96 kHz a 24 bits; Wi-Fi Aware – permite que aplicações e dispositivos próximos possam comunicar por wi-fi, a alta velocidade, sem um ponto de acesso à Internet; Ícones e texto adaptativos – oferece suporte à exibição/manipulação de uma variedade de formas do mesmo ícone/texto em diferentes modelos e layouts nos dispositivos (Figura 1.5);

FIGURA 1.5 – Ícones adaptativos

Performance – permite restringir o que as aplicações em background podem fazer e diminuir a fragmentação do Android, ajudando os fabricantes a atualizarem para versões mais recentes do sistema (Treble1); Fontes – fornece suporte para fontes descarregáveis pela aplicação a um fornecedor externo (Figura 1.6), em vez de incorporar as fontes no Application Package (APK). Reduz o tamanho do APK e permite que as aplicações partilhem as mesmas fontes.

FIGURA 1.6 – Fontes descarregáveis de fornecedor externo

Link: https://source.android.com/devices/architecture/treble.

A PLATAFORMA ANDROID

1.3

REQUISITOS PARA DESENVOLVIMENTO

Para começar a desenvolver aplicações para dispositivos Android é necessário que o computador onde a aplicação vai ser criada esteja preparado com o software adequado. O computador deve possuir um dos seguintes tipos de sistemas: Windows 2003 (ou superior), Mac OS X 10.5.8 (ou superior), Linux com versão 2.11 (ou superior) da biblioteca GNU C (glibc). Para além disso, deve verificar se o computador possui os seguintes componentes: Java Development Kit (JDK) – o Java é fornecido em dois pacotes: o pacote de desenvolvimento (JDK) e o pacote de runtime (Java Runtime Environment – JRE). Para efeitos de desenvolvimento, o JDK deverá estar instalado; Android Studio – é um ambiente de desenvolvimento integrado da Google para o desenvolvimento exclusivo de aplicações Android. A instalação inclui o Software Development Kit (SDK), com as bibliotecas e ferramentas de desenvolvimento necessárias para construir e testar aplicações Android. Caso não tenha estes componentes no computador, deverá instalá-los. As secções 1.3.1 e 1.3.2 explicam o processo de instalação e configuração do software.

1.3.1

INSTALAÇÃO DO JDK

Tal como o SDK do Android, as aplicações para Android são desenvolvidas através da linguagem de programação Java. De forma a verificar qual o JDK que tem instalado no seu computador e a respetiva versão, abra um terminal e digite java-version. Se o JDK não estiver disponível ou se a versão for inferior a 7, será necessário descarregar uma versão mais recente do JDK.

Para descarregar o JDK, aceda ao site Web2 da Oracle e selecione a versão mais recente do pacote JDK, de acordo com o sistema do seu computador (Figura 1.7).

FIGURA 1.7 – Seleção do pacote JDK

Link: http://www.oracle.com/technetwork/java/javase/downloads/index.html. © FCA

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

Uma vez descarregado, execute o ficheiro de instalação e siga as instruções para completar o processo de instalação. Nalguns casos, o Java poderá não ser detetado no sistema Windows. Para tal, é necessário criar uma variável de ambiente, bastando ir a Meu Computador  Propriedades do Sistema  Definições Avançadas do Sistema; em seguida, aceda ao separador Avançadas, clique no botão Variáveis do Sistema e crie uma variável de ambiente com o nome JAVA_HOME e com o valor da variável a apontar para o local onde o JDK está instalado.

1.3.2

INSTALAÇÃO E CONFIGURAÇÃO DO ANDROID STUDIO

Em maio de 2013, na conferência anual da Google para programadores (Google I/O), foi anunciado um novo ambiente exclusivo para o desenvolvimento de aplicações para Android, chamado Android Studio. Atualmente na versão 3.1 – de fevereiro de 2018 –, inclui tudo o que é necessário para desenvolver aplicações para Android: um editor, o SDK para Android e imagens do sistema para o emulador. Para além disso, é gratuito e vem com uma licença Apache 2.0. Neste livro iremos usar este editor. O Android Studio pode ser descarregado a partir da Web. Para tal, comece por aceder à página oficial do Android Studio3, clique no botão Download Android Studio4 e aceite os termos e condições para iniciar o download. Depois, execute o ficheiro android-studio-bundle-<version>-windows.exe e siga as instruções para a instalação do Android Studio e do SDK (Figura 1.8).

FIGURA 1.8 – Instalação do Android Studio

Link: http://developer.android.com/sdk.

4 Apresentam-se apenas os detalhes de instalação do Android Studio no Windows. Para outros sistemas operativos, o processo é similar.

A PLATAFORMA ANDROID

Durante o processo de instalação, defina a localização onde o editor e o SDK serão instalados. Após a instalação do Android Studio, e ao executá-lo pela primeira vez, surgirá a janela de carregamento do editor (Figura 1.9).

FIGURA 1.9 – Ecrã de carregamento do Android Studio 3.0 Da primeira vez que o Android Studio é executado após a sua instalação, poderá surgir uma caixa de diálogo com a opção para importar as configurações de uma versão anterior do Android Studio. Se quiser importá-las para a instalação mais recente, selecione a opção e o local apropriados. No caso de indicar a existência de uma versão do editor mais recente, siga as instruções para atualizar o Android Studio.

Em seguida, o Android Studio descarrega alguns componentes padrão do SDK e cria um dispositivo virtual (nalgumas versões do Android Studio, esta ação não está incluída, por omissão). Depois, clique no botão Finish e surgirá uma caixa de diálogo de boas-vindas, intitulada “Welcome to Android Studio”, como se mostra na Figura 1.10.

FIGURA 1.10 – Janela “Welcome to Android Studio”

Até agora foram instalados o Java, o ambiente de desenvolvimento integrado (Integrated Development Environment – IDE) Android Studio e um conjunto de pacotes padrão do SDK para Android. Podem ser instalados outros pacotes usando a ferramenta SDK Manager, que está disponível através da opção Configure  SDK Manager. © FCA

1.4

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

ANDROID STUDIO 3.0

O Android Studio é o IDE oficial para o desenvolvimento de aplicações Android. Para além do editor de código e de emuladores para diversos dispositivos, o IDE oferece outros recursos para aumentar a produtividade na criação de aplicações, tais como: Um sistema de compilação baseado na ferramenta de automação Gradle5; Instant Run para efetuar alterações a aplicações em execução; Modelos de códigos e integração com o GitHub6; Integração com sistemas de backend, como o Firebase7.

1.4.1

INTERFACE GRÁFICA DO IDE

Quando executa o Android Studio, surge a janela “Welcome to Android Studio” (ver Figura 1.10). Aqui existem várias opções; ao selecionar Start a new Android Studio project, é iniciado o processo de configuração de um novo projeto Android, nomeadamente, a identificação e a localização do projeto, a seleção das plataformas de execução, a adição de atividades (Figura 1.11) e, por fim, a configuração da atividade selecionada.

FIGURA 1.11 – Adição de atividades ao projeto

Site oficial: https://gradle.org/.

Site oficial: https://github.com/.

Site oficial: https://firebase.google.com/.

A PLATAFORMA ANDROID

Após finalizado o processo, é exibida a janela principal do Android Studio, composta por diversas áreas lógicas, numericamente identificadas na Figura 1.12.

FIGURA 1.12 – Janela principal do Android Studio

As áreas lógicas são as seguintes: 1) Barra de ferramentas – permite executar diversas ações, incluindo executar aplicações e inicializar ferramentas do Android. 2) Barra de navegação – ajuda na navegação pelo projeto e na abertura de ficheiros para edição. Oferece uma visualização mais compacta da estrutura visível na janela Project. 3) Janela das ferramentas (neste caso, a janela Project) – dá acesso a tarefas específicas, como gestão de projetos, procura, controlo de versão e muitos outras. O programador pode expandir ou recolher as janelas com facilidade. 4) Barra de janela de ferramentas – fica fora da janela do IDE e contém os botões que permitem expandir ou recolher a janela de cada ferramenta. 5) Janela do editor – é o local onde o programador cria e modifica o código. Dependendo do tipo de ficheiro atual, o editor pode mudar. Por exemplo, ao visualizar um ficheiro de layout, o editor abre o Editor de layout. © FCA

176

5.3

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

APLICAÇÃO FIT

Esta secção apresenta a implementação de uma aplicação chamada Fit (Figura 5.7), cujo principal objetivo é apresentar os passos semanais dados por um utilizador.

FIGURA 5.7 – Aplicação Fit

A aplicação faz uso da plataforma Google Fit para obter informações a partir de sensores específicos para a contagem de passos diárias e semanais. As secções 5.3.1 a 5.3.4 detalham a arquitetura da plataforma, as configurações necessárias para que uma aplicação Android possa usar as API do Google Fit e toda a codificação necessária para a implementação do projeto.

5.3.1

GOOGLE FIT

O Google Fit é uma plataforma que permite aos programadores armazenar os dados de fitness dos utilizadores, de forma a ajudá-los a acompanhar os seus hábitos de exercício. Todos os dados guardados através do Google Fit são armazenados online e podem ser acedidos pelo utilizador em diferentes dispositivos. A gestão dos dados de fitness é feita usando três componentes principais (Figura 5.8). O primeiro componente é a Google Fitness Store, que reside na cloud. Todos os dados de fitness do utilizador são aqui armazenados, em servidores mantidos pelo Google. Ambas as API (REST e do Android Fitness) podem gerir os dados armazenados. As API REST são serviços Web baseados em RESTful que permitem suportar o Google Fit em plataformas diferentes do Android. Podem ser usadas numa aplicação nativa de iOS ou em qualquer aplicação baseada na Web. © FCA

SENSORES

177

As API REST usam JSON para as comunicações e o protocolo OAuth 2.0 para autorização dos utilizadores. Permitem a gestão básica dos dados de fitness (como ler, escrever e excluir dados), mas têm algumas limitações quando comparadas com as API do Android Fitness, como não poder descobrir dispositivos de fitness conectados via Bluetooth ou ler online os fluxos de dados dos sensores.

FIGURA 5.8 – Arquitetura do Google Fit

As API do Android Fitness fazem parte do Google Play Services, que vem como parte do Android SDK. Fornecem acesso a dados de fitness de dois tipos de fontes diferentes: locais e remotas (aplicação ou sensor). As API do Android Fitness podem ser usadas em aplicações Android após obter as permissões necessárias do utilizador. Estas fornecem acesso para ler, escrever e excluir dados de fitness e permitem que os progra-madores criem novos tipos de dados de fitness, procurem novos dispositivos de fitness Bluetooth Low Energy (BLE) e a estes se conectem para obter dados de fitness. São sete as API do Android Fitness: Sensors – fornece o acesso a fluxos de dados de sensores disponíveis no dispositivo Android e/ou wearables. É útil quando precisamos de processar dados de fitness de sensores em tempo real; Recording – permite que a aplicação solicite o armazenamento automatizado de dados do sensor de uma forma eficiente (em termos de bateria), criando o conceito de subscrições; © FCA

178

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES History – fornece o acesso ao histórico dos dados de fitness e permite que as aplicações executem operações em massa, como inserir, excluir e ler dados de fitness. É útil quando precisamos de dados de fitness antigos; Sessions – fornece a funcionalidade para armazenar dados de fitness com metadados associados a uma sessão. As sessões representam um intervalo de tempo durante o qual o utilizador realiza uma atividade física. É útil quando queremos trabalhar com metadados de fitness; Goals – permite rastrear os objetivos que o utilizador definiu para a sua saúde e progresso de fitness; Bluetooth Low Energy (BLE) – fornece o acesso a sensores BLE no Google Fit e permite que a sua aplicação procure dispositivos BLE disponíveis e armazene dados dos mesmos na loja de fitness. É útil quando a aplicação precisa de se conectar a qualquer novo dispositivo BLE; Config – permite que a aplicação crie os seus próprios tipos de dados personalizados para uso particular, os quais não estão disponíveis para outras aplicações. É útil quando não há nenhum tipo de dados disponível que corresponda às suas necessidades e, como tal, deseja criar um novo tipo de dados.

Antes que os utilizadores possam usar os recursos do Google Fit da sua aplicação, é necessário registar a aplicação através da Google Developers Console. Em seguida, deve ativar a API Google Fit e criar um ID de cliente OAuth, de forma a que a aplicação tenha acesso a dados de fitness armazenados nos servidores Google. Depois, precisa de conectar um GoogleApiClient na aplicação e de solicitar os recursos necessários para esta. Mal a aplicação esteja configurada e o utilizador tenha concedido a permissão para esta poder aceder às suas informações de fitness, estará pronto para iniciar o desenvolvimento. 5.3.1.1 CONFIGURAÇÕES INICIAIS

Como vimos anteriormente, para usar o Google Fit para Android é necessário: Ativar a Fitness API na Google Developers Console; Criar um ID de cliente OAuth 2.0; Conectar a Fitness API na aplicação Android. Comece por criar um projeto novo no Android Studio, designado por Fit. Depois, aceda à Google Developers Console2 e crie um novo projeto, com o nome GoogleFitApp.

Em https://console.developers.google.com.

SENSORES

179

Em seguida, aceda à secção das API, pesquise pela Fitness API e selecione-a. Para a ativar, basta pressionar o botão Ativar (Figura 5.9).

FIGURA 5.9 – Ativação da Fitness API na Google Developers Console

Depois de ativar a Fitness API, recebe um aviso a informar de que precisa de criar credenciais para a usar. Para tal, clique no botão Criar credenciais. Na página Credenciais, é necessário fornecer algumas informações gerais sobre a aplicação (Figura 5.10). Especifique que está a usar a Fitness API, que esta é chamada a partir de uma aplicação Android e que precisa de aceder a dados de um utilizador. Em seguida, pressione o botão Preciso de quais credenciais?.

FIGURA 5.10 – Criação de credenciais na Google Developers Console

Posteriormente, necessita de criar um ID de cliente OAuth 2.0 para a aplicação Android. Duas informações são importantes para esta etapa: um certificado digital assinado e o nome do pacote da aplicação. O certificado digital, conhecido como SHA-1 fingerprint, é uma sequência de texto único gerado a partir do algoritmo comummente usado, o SHA-1 hashing. Uma vez que a fingerprint é única, o Google Fit pode usá-la como uma forma de identificar a aplicação. Pode-se gerar a chave a partir de dois tipos de certificados: debug e release. Durante o desenvolvimento da aplicação, o Android Studio usa a chave de debug com base no ficheiro [userhome]/.android/debug.keystore.

180

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

Para obter a impressão digital do certificado navegue para a localização do certificado da aplicação. Abra um terminal (Figura 5.11) e execute o seguinte comando: keytool -list -v -keystore debug.keystore

FIGURA 5.11 – Geração de certificado digital (a partir do SHA-1 fingerprint)

Cole a chave SHA-1 no campo SHA-1 e insira o nome do pacote incluído no ficheiro do manifesto do projeto Fit do Android Studio no campo correspondente. Depois, clique no botão Criar ID de cliente. Por último, é necessário configurar a janela de consentimento OAuth 2.0. Esta é exibida para que o utilizador possa conceder a permissão à aplicação para aceder aos seus dados de fitness. Esta etapa requer um e-mail e um nome do produto para mostrar aos utilizadores (Figura 5.12).

FIGURA 5.12 – Janela de aceitação do OAuth 2.0 para acesso a dados dos utilizadores © FCA

SENSORES

181

Clique no botão Continuar e, em seguida, no botão Concluído. É exibida a secção das Credenciais (Figura 5.13), com uma listagem das credenciais para aceder às API ativadas.

FIGURA 5.13 – Listagem dos ID de cliente OAuth 2.0

Agora, está preparado para criar uma aplicação Android com suporte para o Google Fit. Abra o projeto Android com o nome Fit, criado anteriormente, e, em seguida, o ficheiro build.gradle. Importe o pacote de fitness do Google Play Services ao adicionar as próximas linhas na secção de dependências: implementation 'com.google.android.gms:play-services-fitness:11.6.0' implementation 'com.google.android.gms:play-services-auth:11.6.0'

Inclua também uma dependência para objeto gráfico CardView: implementation 'com.android.support:cardview-v7:26.1.0'

5.3.2

INTERFACE GRÁFICA

A interface gráfica da aplicação Fit é composta por vários elementos gráficos (Figura 5.14).

FIGURA 5.14 – Interface gráfica da aplicação Fit

A interface gráfica é modelada através de um ficheiro XML agregado num layout do tipo ConstraintLayout, conforme ilustrado na Figura 5.15. © FCA

182

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

FIGURA 5.15 – Hierarquia dos elementos da interface gráfica do layout principal

Segue-se uma descrição de todos os elementos gráficos presentes: Um CardView que agrega toda a informação devolvida pelos sensores através de um layout do tipo LinearLayout (horizontal); Uma ImageView fixa com uma imagem representativa da aplicação; Quatro TextView agregadas num LinearLayout (vertical) para os dados:

5.3.3

→

Rótulo para a contagem de passos;

→

Número total de passos;

→

Histórico com a contagem de passos diária;

→

Média de passos por dia.

AUTENTICAÇÃO E AUTORIZAÇÃO

Antes de invocar os métodos das API do Google Fit, conecte a aplicação a um ou mais clientes das API que compõem os serviços do Google Fit: Sensors, Recording, History, Sessions, Goals, BLE e Config. A versão 11.6.0 do SDK do Google Play Services inclui uma nova forma de aceder à API do Google Fit para Android. O cliente GoogleApi é bem mais fácil de usar do que o seu antecessor (GoogleApiClient), pois gere automaticamente as conexões com o Google Play Services. Esta abordagem reduz a quantidade de código na aplicação e ajuda a eliminar erros comuns nestes cenários. Sendo assim, caso use versões mais antigas de cliente, recomenda-se que atualize a sua aplicação para usar o novo cliente, conforme explicado nesta secção.

Quando a aplicação solicita uma conexão com o serviço, ela especifica o(s) tipo(s) de dados e acesso de que precisa. O Google Fit pede ao utilizador que conceda permissão à sua aplicação para aceder aos dados de fitness. © FCA

SENSORES

183

No método onCreate da atividade, crie uma instância de FitnessOptions, declarando os tipos de dados da API do Google Fit e o acesso exigido pela aplicação: FitnessOptions fitnessOptions = FitnessOptions.builder() .addDataType(DataType.TYPE_STEP_COUNT_DELTA, FitnessOptions.ACCESS_READ) .addDataType(DataType.AGGREGATE_STEP_COUNT_DELTA, FitnessOptions.ACCESS_READ).build();

O primeiro tipo representa o número de passos feitos desde a última leitura e o segundo tipo agrega o número de passos durante um intervalo de tempo. Em seguida, verifique se o utilizador concedeu previamente o acesso de dados necessário. Caso não o tenha feito, inicie o fluxo de autorização: if(!GoogleSignIn.hasPermissions( GoogleSignIn.getLastSignedInAccount(this), fitnessOptions)) { GoogleSignIn.requestPermissions(this, GOOGLE_FIT_PERMISSIONS_REQUEST_CODE, GoogleSignIn.getLastSignedInAccount(this), fitnessOptions); } else { accessGoogleFit(); }

O código vai desencadear a autenticação do utilizador, caso não a tenha feito previamente, e autorizar a aplicação a aceder aos dados de fitness (Figura 5.16).

FIGURA 5.16 – Autenticação e autorização ao Google Fit

Em seguida, lide com a resposta do utilizador no método onActivityResult. O resultado vem acoplado num objeto Intent: @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (resultCode == Activity.RESULT_OK) { © FCA

184

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

if (requestCode == GOOGLE_FIT_PERMISSIONS_REQUEST_CODE) { accessGoogleFit(); } } }

Em caso de sucesso, é invocado o método accessGoogleFit (consultar secção 5.3.4).

5.3.4

LEITURA DE SENSORES

Depois de o utilizador ter autorizado o acesso aos dados solicitados, crie o cliente da GoogleApi. Usa-se a HistoryClient para ler e/ou gravar dados de fitness do histórico desta aplicação. Crie o seguinte método: private void accessGoogleFit() { ... }

Prossiga com a criação de duas variáveis do tipo long de modo a definir o intervalo de tempo para a contagem de passos do histórico do Google Fit. Para tal, obtém-se a data de hoje e a data de há uma semana: Calendar cal = Calendar.getInstance(); Date now = new Date(); cal.setTime(now); long endTime = cal.getTimeInMillis(); cal.add(Calendar.WEEK_OF_YEAR, -1); long startTime = cal.getTimeInMillis();

Em seguida, cria-se um novo DataReadRequest para um tipo específico de dados. Esses dados podem ser agrupados em conjunto em objetos Bucket por tempo ou por sessão. Para este exemplo, solicitam-se dados agregados de passos para a última semana, organizados por dia: DataReadRequest readRequest = new DataReadRequest.Builder() .aggregate(DataType.TYPE_STEP_COUNT_DELTA, DataType.AGGREGATE_STEP_COUNT_DELTA) .bucketByTime(1, TimeUnit.DAYS) .setTimeRange(startTime, endTime, TimeUnit.MILLISECONDS) .build();

Depois de criar o objeto DataReadRequest, pode solicitar dados da API do Google Fit usando o método Fitness.getHistoryClient. Através do objeto HistoryClient chame o método readData e passe o pedido previamente definido. Depois, adicione várias interfaces listeners para verificarem o estado do pedido. Para a interface mais importante, implemente o método onSuccess, desencadeado após o sucesso do pedido. O método recebe como parâmetro a resposta do serviço do tipo DataReadResponse: Fitness.getHistoryClient(this, GoogleSignIn.getLastSignedInAccount(this)) .readData(readRequest) .addOnSuccessListener(new OnSuccessListener<DataReadResponse>() { @Override public void onSuccess(DataReadResponse dataReadResponse) { © FCA

SENSORES

185

printData(dataReadResponse); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.e(LOG_TAG, "onFailure()", e); } }) .addOnCompleteListener(new OnCompleteListener() { @Override public void onComplete(@NonNull Task task) { Log.d(LOG_TAG, "onComplete()"); } }); O método readData(DataReadRequest) deverá ser usado sempre que os dados históricos sejam necessários. Poderá ser combinado com uma subscrição ao cliente Recording para colecionar dados em background e consultá-los mais tarde para exibição.

Em caso de sucesso, é chamado o método printData, que recebe um objeto DataReadResponse, o qual será tratado no próximo método. Observe o conteúdo do método printData; se o objeto DataReadResponse tiver dados agregados, será devolvido como um conjunto de Buckets contendo DataSets em vez de apenas DataSets: public void printData(DataReadResponse dataReadResult) { // USADO PARA DADOS AGREGADOS

if (dataReadResult.getBuckets().size() > 0) { for (Bucket bucket : dataReadResult.getBuckets()) { List<DataSet> dataSets = bucket.getDataSets(); for (DataSet dataSet : dataSets) { dumpDataSet(dataSet); } }

// USADO PARA DADOS NÃO AGREGADOS

} else if (dataReadResult.getDataSets().size() > 0) { for (DataSet dataSet : dataReadResult.getDataSets()) { dumpDataSet(dataSet); } }

// ESTATÍSTICAS

}

...

Independentemente da abordagem, é invocado o método DumpData, que recupera cada DataPoint dos objetos DataSet devolvidos: private void dumpDataSet(DataSet dataSet) { DateFormat df = DateFormat.getDateInstance(); for (DataPoint dp : dataSet.getDataPoints()) { histSteps.append(df.format(dp.getEndTime(TimeUnit.MILLISECONDS))+": "); © FCA

186

ANDROID PROFISSIONAL – DESENVOLVIMENTO MODERNO DE APLICAÇÕES

for (Field field : dp.getDataType().getFields()) { int nSteps = dp.getValue(field).asInt(); histSteps.append(nSteps + " passos\n"); totalSteps += nSteps; nDays++; } } }

Para cada objeto DataPoint são obtidos o dia da contagem e o respetivo número de passos. Ambos os valores são guardados em variáveis de instância que servirão para atualizar a interface gráfica. No final, volte ao método printData e atualize a interface gráfica com as variáveis anteriores: // ESTATÍSTICAS FINAIS

txtTotalSteps.setText(String.valueOf(totalSteps)); txtSteps.setText("\n" + histSteps.toString()); txtAverageSteps.setText("Média diária:" + String.valueOf(totalSteps/nDays) + " passos");

São atualizadas as três TextView da interface gráfica, conforme demonstra a Figura 5.17, com o número de passos dados na última semana.

FIGURA 5.17 – Atualização da interface gráfica da aplicação Fit

RESUMO O uso de sensores em dispositivos móveis é cada vez mais comum. Eles tornam possível a monitorização de uma série de variáveis, como a velocidade e o posicionamento, entre outras. Este capítulo focou-se exclusivamente na gestão e manipulação de sensores em dispositivos Android. Numa primeira fase foram abordados apresentada a arquitetura e os componentes da Android Sensor Stack, as suas classes principais e as boas práticas na manipulação de sensores. Em seguida, foram apresentados três exemplos práticos, que lidam com os sensores acelerómetro, giroscópio e de proximidade. Por fim, foi criada a aplicação Fit, que modela uma aplicação de fitness. A aplicação usa as API do Google Fit para monitorizar os passos semanais dados por um utilizador. © FCA