ANDROID - Desenvolvimento de Aplicações com Android Studio

Este livro foi escrito com base numa versão beta do Android Studio 2.0. Apesar disso, e tendo em atenção a evolução histórica da plataforma, não se prevê que venham a ocorrer alterações significativas entre esta versão e a versão definitiva. Para eventuais atualizações consulte o nosso site (www.fca.pt).

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 173 259 livraria@lidel.pt Copyright © 2016, FCA – Editora de Informática, Lda. ISBN edição impressa: 978-972-722-819-5 1.ª edição impressa: fevereiro 2016 Impressão e acabamento: Cafilesa – Soluções Gráficas, Lda. – Venda do Pinheiro Depósito Legal n.º 405593/16 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 AGRADECIMENTOS ............................................................................................. III 1. INTRODUÇÃO AO ANDROID ................................................................................. 1 1.1. História e versões do Android .......................................................................................................... 1 1.1.1. Android Lollipop ..................................................................................................................... 4 1.1.2. Android Marshmallow ........................................................................................................... 5 1.2. Plataforma Android ............................................................................................................................ 7 1.2.1. Arquitetura ............................................................................................................................... 8 1.2.2. Loja de Aplicações Google Play.............................................................................................. 9 1.2.3. Tipos de dispositivos ............................................................................................................. 10 2. A MINHA PRIMEIRA APLICAÇÃO ........................................................................ 15 2.1. Configuração do ambiente de desenvolvimento .......................................................................... 15 2.1.1. Instalação do JDK ................................................................................................................... 15 2.1.2. Instalação e configuração do Android Studio .................................................................... 16 2.2. A minha primeira aplicação ............................................................................................................ 19 2.2.1. Criação de projeto................................................................................................................... 19 2.2.2. Interface gráfica ...................................................................................................................... 23 2.2.3. Execução da aplicação............................................................................................................ 26 2.2.4. Publicação da aplicação ......................................................................................................... 28 2.3. Anatomia de um projeto Android .................................................................................................. 31 2.3.1. Ficheiro de manifesto ............................................................................................................. 32 2.3.2. Código-fonte Java ................................................................................................................... 33 2.3.3. Recursos ................................................................................................................................... 34 2.3.4. Classe R .................................................................................................................................... 37 2.3.5. Ficheiros Gradle ....................................................................................................................... 38 3. ANDROID STUDIO ........................................................................................... 39 3.1. Janelas ................................................................................................................................................. 39 3.1.1. Janela de boas-vindas............................................................................................................. 40 3.1.2. Janela principal ....................................................................................................................... 41 3.1.3. Janelas de ferramentas ........................................................................................................... 42 3.1.4. Janelas de edição ..................................................................................................................... 44 3.2. Ferramentas ....................................................................................................................................... 52 3.2.1. SDK Manager .......................................................................................................................... 53 3.2.2. AVD Manager ......................................................................................................................... 55 3.2.3. Android Device Monitor ....................................................................................................... 66 3.2.4. Theme Editor........................................................................................................................... 67 4. COMPONENTES ANDROID ................................................................................. 69 4.1. Introdução .......................................................................................................................................... 69 © FCA – Editora de Informática

VI

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

4.2. Atividades .......................................................................................................................................... 70 4.2.1. Introdução às atividades ....................................................................................................... 70 4.2.2. Atividades, tarefas e back stack .............................................................................................. 72 4.2.3. Ciclo de vida de uma atividade ............................................................................................ 73 4.2.4. Comunicação entre atividades.............................................................................................. 80 4.3. Serviços .............................................................................................................................................. 88 4.3.1. Introdução aos serviços ......................................................................................................... 88 4.3.2. Criação e execução ................................................................................................................. 90 4.3.3. Comunicação ........................................................................................................................... 91 4.4. Recetores de broadcast ....................................................................................................................... 97 4.4.1. Introdução aos recetores de broadcast .................................................................................. 97 4.4.2. Criação e registo ..................................................................................................................... 97 4.4.3. Difusão ..................................................................................................................................... 98 4.4.4. Exemplos práticos ................................................................................................................ 100 4.5. Fornecedores de conteúdo ............................................................................................................. 103 4.5.1. Introdução aos fornecedores de conteúdo ........................................................................ 103 4.5.2. Exemplo prático .................................................................................................................... 104 5. INTERFACE GRÁFICA ..................................................................................... 107 5.1. Introdução ........................................................................................................................................ 107 5.2. Layouts .............................................................................................................................................. 107 5.2.1. Atributos ................................................................................................................................ 109 5.2.2. Tipos de layout ...................................................................................................................... 113 5.2.3. Layouts dinâmicos ................................................................................................................. 114 5.3. Fragmentos ...................................................................................................................................... 128 5.3.1. Definir um fragmento .......................................................................................................... 129 5.3.2. Incorporar um fragmento numa atividade ....................................................................... 130 5.3.3. Ciclo de vida de um fragmento .......................................................................................... 132 5.3.4. Procurar instâncias de fragmentos ..................................................................................... 134 5.3.5. Comunicar com fragmentos ................................................................................................ 135 5.4. Views ................................................................................................................................................. 136 5.4.1. TextView.............................................................................................................................. 136 5.4.2. EditText.............................................................................................................................. 138 5.4.3. Button .................................................................................................................................. 141 5.4.4. Outras views de input............................................................................................................ 142 6. MATERIAL DESIGN ........................................................................................ 149 6.1. Introdução ........................................................................................................................................ 149 6.2. Temas................................................................................................................................................ 150 6.3. Views ................................................................................................................................................. 153 6.3.1. CardView.............................................................................................................................. 153 6.3.2. RecyclerView .................................................................................................................... 155 6.3.3. TextInputLayout ............................................................................................................. 162 6.3.4. FloatingActionButton ................................................................................................. 163 6.3.5. TabLayout ........................................................................................................................... 165 6.3.6. NavigationView ............................................................................................................... 167 © FCA – Editora de Informática

ÍNDICE GERAL

VII

6.3.7. SnackBar.............................................................................................................................. 169 6.3.8. CoordinatorLayout ........................................................................................................ 170 6.3.9. Elevações de views ................................................................................................................ 174 6.4. Animações........................................................................................................................................ 175 6.4.1. Feedback ao toque .................................................................................................................. 175 6.4.2. Transição entre atividades................................................................................................... 176 6.4.3. Efeito reveal ............................................................................................................................ 180 6.5. Drawables .......................................................................................................................................... 182 6.5.1. Drawables vetoriais................................................................................................................ 182 6.5.2. Drawable tinting ..................................................................................................................... 183 6.5.3. Extração de cor: classe Palette ........................................................................................ 184 7. GESTÃO DE DADOS........................................................................................ 187 7.1. Introdução ........................................................................................................................................ 187 7.2. Ficheiros ........................................................................................................................................... 188 7.2.1. Armazenamento interno...................................................................................................... 188 7.2.2. Armazenamento externo ..................................................................................................... 191 7.3. Preferências partilhadas ................................................................................................................. 192 7.3.1. Leitura e escrita de dados .................................................................................................... 193 7.3.2. Classes PreferenceActivity e PreferenceFragment.......................................... 194 7.4. Base de dados SQLite ..................................................................................................................... 197 7.4.1. Classes SQLiteOpenHelper e SQLiteDatabase ........................................................ 197 7.4.2. Exemplo prático .................................................................................................................... 200 7.4.3. Object-Relational Mapping ..................................................................................................... 206 8. MULTIMÉDIA ............................................................................................... 209 8.1. Reprodução de vídeo...................................................................................................................... 209 8.1.1. Classe VideoView ............................................................................................................... 209 8.1.2. Classe MediaController ................................................................................................. 211 8.2. Gravação de vídeo e captura de imagem..................................................................................... 213 8.2.1. Gravação de vídeo ................................................................................................................ 213 8.2.2. Captura de imagem .............................................................................................................. 216 8.3. Reprodução e gravação de áudio .................................................................................................. 217 8.3.1. Reprodução de áudio ........................................................................................................... 217 8.3.2. Gravação de áudio................................................................................................................ 222 8.3.3. Exemplo prático .................................................................................................................... 223 9. NETWORKING .............................................................................................. 227 9.1. Configurações e boas práticas ....................................................................................................... 227 9.1.1. Permissões ............................................................................................................................. 227 9.1.2. Verificação de conectividade .............................................................................................. 228 9.1.3. Tarefas assíncronas............................................................................................................... 228 9.2. Gestão de páginas Web .................................................................................................................. 230 9.2.1. Exibição .................................................................................................................................. 230 9.2.2. Manipulação.......................................................................................................................... 233 9.3. Gestão de pedidos HTTP ............................................................................................................... 235 © FCA – Editora de Informática

VIII

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

9.3.1. Clientes HTTP ....................................................................................................................... 236 9.3.2. Bibliotecas externas .............................................................................................................. 239 9.4. Serviços Web ................................................................................................................................... 245 9.4.1. Facebook para Android ....................................................................................................... 245 10. MAPAS E LOCALIZAÇÃO ............................................................................... 255 10.1. Google Play Services..................................................................................................................... 255 10.1.1. Configuração do Google Play Services ............................................................................ 256 10.1.2. Classe GoogleApiClient ............................................................................................... 257 10.2. API Google Maps .......................................................................................................................... 259 10.2.1. Configurações na Google Developers Console............................................................... 259 10.2.2. Criação de uma aplicação básica ...................................................................................... 261 10.2.3. Classe GoogleMap ............................................................................................................. 263 10.3. API Google Location..................................................................................................................... 275 11. INTRODUÇÃO AO ANDROID WEAR ................................................................... 281 11.1. Introdução ...................................................................................................................................... 281 11.2. Configurações prévias .................................................................................................................. 282 11.3. A minha primeira aplicação wearable ......................................................................................... 283 11.4. Notificações ................................................................................................................................... 285 11.4.1. Emparelhamento dos dispositivos ................................................................................... 286 11.4.2. Criação de uma aplicação para envio de notificações ................................................... 287 GLOSSÁRIO DE TERMOS – PORTUGUÊS EUROPEU / PORTUGUÊS DO BRASIL .................... 293 ÍNDICE REMISSIVO ........................................................................................... 295

© FCA – Editora de Informática

3

ANDROID STUDIO

O Android Studio é um ambiente integrado para o desenvolvimento de aplicações para a plataforma Android. Foi anunciado a 16 de maio de 2013, na conferência Google I/O, e está, desde então, disponível gratuitamente sob a licença Apache 2.0. Em fevereiro de 2016, foi lançada a sua versão 2.0, bastante sofisticada, intuitiva e fácil de usar. Neste capítulo apresenta-se a organização do layout do editor através de uma visão geral sobre as várias janelas e ferramentas constituintes.

3.1

JANELAS

A arquitetura do Android Studio, exibida na Figura 3.1, é constituída por várias áreas que permitem ao programador interagir com o Android Studio e executar múltiplas tarefas associadas ao processo de desenvolvimento de software.

FIGURA 3.1 – Organização do layout do utilizador no Android Studio

Neste capítulo é feito uma pequena tour sobre as suas principais janelas, barras e ferramentas de trabalho. © FCA – Editora de Informática

40

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

3.1.1 JANELA DE BOAS-VINDAS Quando o Android Studio é executado pela primeira vez, ou é executado sem que tenha qualquer projeto aberto anteriormente, é exibida a janela de boas-vindas intitulada “Welcome to Android Studio”, como mostrado na Figura 3.2.

FIGURA 3.2 – Janela de boas-vindas ao Android Studio Se fechar o Android Studio com um projeto aberto, a ferramenta não mostrará esta janela da próxima vez que for executada, abrindo automaticamente o projeto ativo.

A janela inclui dois painéis. O painel da esquerda lista os projetos existentes.

O painel da direita inclui o seguinte conjunto de opções:

• Start a new Android Studio project – cria um projeto novo; • Open an existing Android Studio project – abre um projeto existente; • Check out project from Version Control – faz o checkout de projetos mantidos em sistemas de controlo de versões (por exemplo, GitHub, CVS, Git, Google Cloud, Mercurial, SubVersion); • Import project (Eclipse ADT, Gradle, etc.) – importa projetos do Eclipse ou através de um ficheiro Gradle; • Import an Android code sample – importa exemplos de código.

Finalmente, a barra de estado da janela inclui duas opções: Configure, que permite a configuração da ferramenta (por exemplo, acesso ao SDK Manager ou à verificação de atualizações), e Get Help, que providencia ajuda e o acesso a documentação variada.

© FCA – Editora de Informática

ANDROID STUDIO

41

3.1.2 JANELA PRINCIPAL Quando um projeto novo é criado ou um existente é aberto, a janela principal do Android Studio é exibida. Se estão abertos, simultaneamente, múltiplos projetos, cada um terá associada uma janela principal. A configuração da janela poderá variar de acordo com as ferramentas e os painéis abertos da última vez que o projeto foi aberto. A Figura 3.3 mostra o aspeto típico da janela principal do Android Studio.

FIGURA 3.3 – Janela principal do Android Studio

A janela principal é constituída por barras e outras janelas: 1) Barra de menus – contém um conjunto de menus para executar tarefas no ambiente Android Studio.

2) Barra de ferramentas – contém uma série de botões para ações frequentes.

3) Barra de navegação – permite o acesso a pastas e ficheiros do projeto. Ao clicar em qualquer elemento da barra, é exibido um menu com uma listagem das subpastas e ficheiros respetivos e prontos a serem selecionados.

4) Barra de botões de ferramentas – contém um conjunto de barras exibidas ao longo das partes esquerda, direita e inferior da janela principal com botões para ativar/desativar cada uma das janelas de ferramentas.

5) Barra de estado – exibe mensagens informativas sobre o projeto e as atividades no Android Studio. Inclui o botão para o menu das ferramentas localizado no canto esquerdo. © FCA – Editora de Informática

42

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO 6) Janela de ferramentas do projeto – fornece uma visão hierárquica da estrutura de ficheiros do projeto, permitindo a sua navegação.

7) Janela de edição – permite ao programador editar ficheiros do projeto Android.

Os menus e barras apresentados podem ser personalizados clicando com o botão direito do rato na barra de ferramentas e selecionando a opção Customize Menus and Toolbars.

É também possível alterar o tema geral do ambiente de desenvolvimento através da opção do menu principal File Æ Settings. Após a exibição da janela de configuração, selecione a opção Appearance no painel do lado esquerdo e, em seguida, altere a configuração do menu Theme. Os temas disponíveis são IntelliJ, Windows e Darcula.

A Figura 3.4 mostra um exemplo da janela principal com o tema Darcula selecionado.

FIGURA 3.4 – Tema Darcula

3.1.3 JANELAS DE FERRAMENTAS As janelas de ferramentas do Android Studio permitem dotar a janela principal com áreas especializadas no processo de desenvolvimento das aplicações Android. A janela de visualização de projetos é uma dessas janelas. Para aceder à lista de janelas, passe o ponteiro do rato sob o botão no lado esquerdo da barra de estado (1), aparecendo um menu com uma listagem de todas as janelas de ferramentas disponíveis (2), conforme demonstra a Figura 3.5.

© FCA – Editora de Informática

ANDROID STUDIO

43

FIGURA 3.5 – Menu com as janelas de ferramentas disponíveis no Android Studio

A seleção de um item do menu fará com que a janela correspondente seja exibida ao longo das partes inferior ou lateral da janela principal. Alternativamente, pode usar a barra de botões de ferramentas cuja visibilidade pode ser controlada com o clique sucessivo no botão da barra de estado (1).

Para gerir a visibilidade das barras dos botões de ferramentas, pode também usar a opção do menu principal View Æ Tool Buttons.

De entre todas estas janelas destaca-se, para além da janela Project, a janela Android Monitor (Figura 3.6).

FIGURA 3.6 – Janela de ferramentas Android Monitor

O Android Monitor permite traçar o perfil do desempenho das aplicações Android, de forma a otimizar, depurar e melhorar o seu desempenho. Para isso, conta © FCA – Editora de Informática

44

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

com a ferramenta LogCat para gerir as mensagens de log enviadas pela aplicação ou pelo sistema e por vários monitorizadores para gerir vários aspetos da aplicação, tais como o uso da memória, o CPU, o GPU e o tráfego de rede (dispositivo de hardware apenas).

Outras destas janelas serão explicadas ao longo da obra, sempre que o seu uso seja importante para o tópico abordado.

3.1.4 JANELAS DE EDIÇÃO As janelas de edição no Android Studio permitem a edição dos ficheiros de um projeto Android. São duas: • Janela de edição de texto – para edição de ficheiros baseados em texto (por exemplo, código-fonte Java); • Janela de edição gráfica – para edição de ficheiros de layout.

A forma de exibição do conteúdo é contextual. Por exemplo, quando se abre um ficheiro Java surge a janela de edição de código, mas quando se está a trabalhar com um ficheiro de layout surge uma janela de edição gráfica do tipo WYSIWYG (What You See Is What You Get). Quando múltiplos ficheiros estão abertos simultaneamente, cada ficheiro é representado por um separador (tab) no topo da janela.

3.1.4.1 EDIÇÃO DE TEXTO

O editor de texto surge sempre que for selecionado para edição um ficheiro Java, XML ou outro ficheiro baseado em texto. A Figura 3.7, por exemplo, mostra a janela de edição para um ficheiro com código-fonte Java.

FIGURA 3.7 – Janela de edição de código © FCA – Editora de Informática

ANDROID STUDIO

45

A janela principal é constituída por barras e outras janelas: 1) Barra de separadores – contém um conjunto de separadores que permitem o acesso aos ficheiros abertos na janela de edição de código. Ao clicar com o botão direito sobre um separador, acede a um menu com várias operações.

2) Barra de Gutter – exibe ícones e controlos informativos que permitem definir, por exemplo, breakpoints para depuração de código, abrir e fechar blocos de código, associar bookmarks ou mostrar números de linha (botão direito para gerir a visibilidade dos números).

3) Área de edição – exibe o código do separador ativo permitindo ao programador editá-lo.

4) Barra de validação – exibe informações sobre a análise on-the-fly do código.

5) Barra de estado – exibe informações sobre a posição atual do cursor (linha e coluna), o separador de linha, o formato de codificação do ficheiro (ASCII, UTF-8, etc.). Clicando nestes elementos, é possível alterar os seus valores.

No caso da posição do cursor, o clique exibirá a caixa de diálogo Go to Line, que permite posicionar o cursor numa linha específica.

Hoje em dia os editores de código são muito sofisticados, oferecendo ao programador várias funcionalidades com vista a: • Autocompletação e geração de código – reduzir a digitação de código; • Navegação no código – facilitar a navegação entre ficheiros e em ficheiros extensos de código; • Validação de código – detetar/destacar erros no código em tempo real.

AUTOCOMPLETAÇÃO E GERAÇÃO DE CÓDIGO

Para reduzir a digitação de código e, assim, acelerar a escrita de código, o Android Studio permite a completação automática de código. À medida que o código é digitado, o editor verifica o que está a ser digitado e, se for caso disso, faz sugestões em relação ao que pode ser necessário para completar uma declaração ou referência. Quando uma sugestão de conclusão é detetada pelo editor, surge um painel com uma lista de sugestões (Figura 3.8).

© FCA – Editora de Informática

46

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

FIGURA 3.8 – Autocompletação de código

Depois, basta posicionar-se sobre a sugestão correta através das teclas do cursor e pressionar as teclas Enter ou Tab. As sugestões de conclusão podem ser chamadas manualmente utilizando a combinação de teclas Ctrl+Space. Isto pode ser útil quando se muda uma palavra ou declaração no editor.

Quando o cursor é posicionado sobre uma palavra no editor, essa palavra é destacada automaticamente. Pressionando Ctrl+Space, é exibida uma lista de sugestões alternativas. Para substituir a palavra atual com o item destacado no momento na lista de sugestões, basta pressionar a tecla Tab. Para uma conclusão inteligente (smart completion), o Android Studio usa a combinação de teclas Shift+Ctrl+Space, que fornece sugestões mais detalhadas com base no contexto atual do código.

Nas declarações dos métodos também é possível usar a autocompletação do código, pressionando Shift+Ctrl+Enter, e o Android Studio, de forma automática, incluirá as chavetas que delimitam o código do método.

Além de completar código, o Android Studio também permite a geração de código. De forma a exibir uma lista de opções contextuais de geração de código disponíveis (Figura 3.9), use a combinação de teclas Alt+Insert quando o cursor estiver no local em que o código deve ser gerado.

FIGURA 3.9 – Geração de código © FCA – Editora de Informática

ANDROID STUDIO

47

NAVEGAÇÃO NO CÓDIGO

Para além da barra de navegação, existem outros mecanismos úteis para navegar dentro da janela principal do Android Studio. Um desses mecanismos é o Switcher.

O Switcher, ativado através da combinação de teclas Ctrl+Tab, aparece como um painel listando ambas as janelas de ferramentas e os ficheiros atualmente abertos (Figura 3.10).

FIGURA 3.10 – Painel Switcher

Após a sua exibição, o Switcher permanecerá visível durante o tempo em que a tecla Ctrl estiver premida. Nesse período, prima repetidamente a tecla Tab para navegar entre as várias opções. Quando soltar a tecla Ctrl, o item selecionado é exibido dentro da janela principal.

Para além do Switcher, é possível navegar pelos ficheiros abertos recentemente através do painel Recent Files (Figura 3.11).

FIGURA 3.11 – Painel Recent Files

Para aceder a este painel use a combinação de teclas Ctrl+E. Uma vez exibido o painel, use o rato para selecionar uma opção ou, em alternativa, as setas do teclado para percorrer as opções das janelas de ferramentas ou dos ficheiros abertos recentemente.

No fim, pressione a tecla Enter para abrir o item atualmente selecionado. © FCA – Editora de Informática

48

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

O Android Studio inclui uma gama variada de teclas de atalho projetadas para economizar tempo ao executar tarefas comuns. Uma listagem completa (mapa de teclas de atalho) pode ser visualizada/impressa selecionando a opção do menu principal Help Æ Default Keymap Reference.

Um ficheiro Java pode atingir um tamanho considerável, prejudicando a sua legibilidade e navegação. São várias as funcionalidades que o Android Studio apresenta para facilitar a navegação no código. Uma das mais importantes é a abertura/fecho de blocos de código através de marcadores situados na barra de Gutter da janela de edição.

A Figura 3.12 destaca os marcadores de início e fim (sinal -) para uma declaração de método expandida (1). Ao clicar em qualquer um dos marcadores, o bloco de código é fechado (2), surgindo um único marcador (sinal +). Pode-se reverter a situação clicando no marcador, ou, no caso de querer ver o código sem o expandir, pode passar o ponteiro do rato sobre o texto {…} (3) de forma a exibir um painel com o código escondido.

Todas as funcionalidades apresentadas estão concentradas e acessíveis através da opção do menu principal Code. De forma a configurar os seus valores por omissão, aceda à opção File Æ Settings e selecione, no painel da esquerda, Editor e depois General.

FIGURA 3.12 – Abertura e fecho de blocos de código

VALIDAÇÃO DE CÓDIGO

Relativamente à validação do código, o Android Studio apresenta a barra de validação como uma preciosa ajuda em tempo real. Ou seja, à medida que o programador digita o código, o editor verifica se há avisos e/ou erros de sintaxe colocando marcadores individuais para cada situação (amarelos para avisos e vermelhos para erros).

© FCA – Editora de Informática

ANDROID STUDIO

49

Surge também um ícone na parte superior da barra: •

Visto verde – código “limpo” (sem avisos nem erros);

•

Quadrado amarelo – código com avisos;

•

Ponto de exclamação vermelho – código com erros.

Ao passar o rato sob o ícone é exibido um pop-up que contém um resumo dos problemas encontrados, conforme ilustrado na Figura 3.13.

FIGURA 3.13 – Análise global do código Por vezes, vai ser necessário formatar o código devido aos sistemáticos copy & paste. Para reformatar o código-fonte, pressione as teclas Ctrl+Alt+L. Se quiser refinar o local onde essa reformatação vai ocorrer, pressione Ctrl+Alt+Shift+L para exibir a caixa de diálogo Reformat File.

Esta caixa de diálogo oferece a opção de reformatar apenas o código selecionado no momento, todo o ficheiro atualmente ativo no editor ou todos os ficheiros numa determinada pasta do projeto.

Muito mais haveria a destacar sobre as funcionalidades do Android Studio relativamente à gestão do código, como, por exemplo, a navegação pela hierarquia do código atravás da janela de ferramentas Structure, a sua análise e refatorização. Estas e outras funcionalidades serão introduzidas na obra sempre que sejam pertinentes.

3.1.4.2 EDIÇÃO GRÁFICA

O Android Studio disponibiliza um editor gráfico WYSIWYG (Figura 3.14) para o desenho de interfaces gráficas nas aplicações Android. No editor podem-se selecionar componentes gráficos (widgets ou views) a partir de uma paleta e, em seguida, colocá-los numa área de desenho representativa de um ecrã de um dispositivo Android. As views podem depois ser configuradas através da alteração das suas propriedades. A janela principal é constituída por vários elementos: 1) Palette – fornece acesso a uma variedade de componentes gráficos agrupados em categorias para facilitar a navegação. Os componentes podem ser adicionados ao layout arrastando-os para a posição desejada no layout, ou © FCA – Editora de Informática

8

MULTIMÉDIA

Nos dias de hoje, os dispositivos Android oferecem um excelente suporte multimédia como resposta às necessidades dos utilizadores, aliada à evolução das tecnologias de transferência de dados. A reprodução, a gravação e a captura de recursos multimédia, como, por exemplo, o vídeo e o áudio, são agora mais fáceis de implementar com as novas classes multimédia disponibilizadas pelo SDK do Android. Neste capítulo introduzem-se as boas práticas de desenvolvimento para a reprodução e gravação de vídeo e áudio, bem como para a captura de imagens e sua respetiva manipulação.

8.1

REPRODUÇÃO DE VÍDEO

O Android SDK inclui duas classes que facilitam a reprodução de vídeo em dispositivos Android: ! VideoView – componente visual que, quando adicionado a um layout de uma atividade, proporciona uma superfície onde o vídeo é reproduzido; ! MediaController – fornece um conjunto de controlos que permitem ao utilizador gerir a reprodução de um vídeo (por exemplo, parar, retomar ou procurar para trás ou para a frente na linha de tempo do vídeo).

A combinação destas classes proporciona ao utilizador uma experiência rica no contexto da reprodução de vídeos numa aplicação Android.

8.1.1 CLASSE VIDEOVIEW A classe VideoView modela um componente visual para gerir a reprodução de vídeos. Para usar um VideoView numa aplicação Android, comece por inserir a view no layout de uma atividade Android: <VideoView android:id="@+id/video_view" android:layout_width="320px" android:layout_height="240px" />

© FCA – Editora de Informática

210

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

Em seguida, armazene um ficheiro localmente (por exemplo, myVideo.mp4) na pasta res/raw/myVideo.mp4 e reproduza o vídeo na view com o seguinte código: VideoView myVideoView = (VideoView) findViewById(R.id.video_view); myVideoView.setVideoURI( Uri.parse("android.resource://" + getPackageName() +"/"+R.raw.myVideo)); myVideoView.requestFocus(); myVideoView.start();

Para reproduzir um vídeo remoto, comece por dar as permissões de acesso à Internet no ficheiro de manifesto do projeto e, em seguida, use o seguinte código: final VideoView myVideoView = (VideoView) findViewById(R.id.video_view); myVideoView.setVideoPath("http://www.server.com/myVideo.mp4"); myVideoView.requestFocus(); myVideoView.setOnPreparedListener(new OnPreparedListener() { // FECHE A BARRA DE PROGRESSO E REPRODUZA O VÍDEO

public void onPrepared(MediaPlayer mp) { mVideoView.start(); } });

Tudo o que este código faz é obter uma referência à instância VideoView no layout, definir o caminho do vídeo como um ficheiro MPEG-4 remoto e, em seguida, registar um callback para ser chamado quando o ficheiro de vídeo é carregado e pronto a ser reproduzido (Figura 8.1).

FIGURA 8.1 – Classe VideoView

A classe VideoView possui um conjunto de métodos para gerir a reprodução de vídeos. Alguns dos métodos mais utilizados são apresentados na Tabela 8.1.

© FCA – Editora de Informática

MULTIMÉDIA

211

MÉTODO

DESCRIÇÃO

setVideoPath(String path)

Reproduz um vídeo a partir de uma string (caminho para o vídeo). O vídeo pode ter origem local ou remota.

setVideoUri(Uri uri)

Reproduz um vídeo a partir de um objeto Uri.

start()

Inicia a reprodução do vídeo.

pause()

Para a reprodução de um vídeo.

stopPlayback()

Termina a reprodução de um vídeo.

getDuration()

Devolve a duração do vídeo.

getCurrentPosition()

Devolve um valor inteiro a indicar a posição atual da reprodução do vídeo.

isPlaying()

Devolve um valor booleano a indicar se o vídeo está em reprodução (true) ou não (false).

setMediaController(MediaController)

Associa uma instância MediaController de forma a exibir controlos de reprodução ao utilizador.

setOnPreparedListener (MediaPlayer.OnPreparedListener)

Permite definir um método callback a ser chamado quando o vídeo está pronto a ser reproduzido.

setOnCompletionListener (MediaPlayer.OnCompletionListener)

Permite definir um método callback a ser chamado quando é atingido o fim do vídeo.

setOnErrorListener (MediaPlayer.OnErrorListener)

Permite definir um método callback a ser chamado quando um erro é detetado durante a reprodução do vídeo.

TABELA 8.1 – Métodos principais da classe VideoView

Se um vídeo é reproduzido usando simplesmente a classe VideoView, o utilizador não terá qualquer controlo sobre a sua reprodução, até que termine. A situação é resolvida associando uma instância da classe MediaController ao VideoView.

8.1.2 CLASSE MEDIACONTROLLER A classe MediaController fornece um conjunto de controlos que permitem ao utilizador gerir a reprodução de um vídeo, nomeadamente pará-lo e retomá-lo, controlar o seu volume, etc. Os controlos são ancorados a uma view no layout. Uma vez ancorados, irão aparecer brevemente no início da reprodução, podendo ser posteriormente restaurados, a qualquer momento, pelo utilizador, bastando para isso que se toque na view.

© FCA – Editora de Informática

212

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO A Tabela 8.2 apresenta os principais métodos da classe MediaController.

MÉTODO

DESCRIÇÃO

setAnchorView(View view)

Especifica a view na qual o controlador será ancorado.

Controla a localização dos controlos no ecrã.

show()

Mostra os controlos.

show(int timeout)

Mostra os controlos por um período de tempo (em milissegundos).

hide()

Esconde os controlos.

isShowing()

Devolve um valor booleano indicando se os controlos estão visíveis para o utilizador (true) ou não (false).

TABELA 8.2 – Métodos principais da classe MediaController

O próximo excerto de código mostra como associar um objeto MediaController a um VideoView: final VideoView videoView = (VideoView) findViewById(R.id.videoView1); videoView.setVideoPath("http://www.server.com/myVideo.mp4"); MediaController mediaController = new MediaController(this); mediaController.setAnchorView(videoView); videoView.setMediaController(mediaController); videoView.start();

Após execução, os controlos surgem sob a parte inferior da reprodução do vídeo durantes alguns segundos (Figura 8.2), podendo ser restaurados a qualquer altura.

FIGURA 8.2 – Classe MediaController

Os controlos incluem uma seekbar, controlo de volume e botões de reprodução, pausa, avanço e retrocesso.

Podem-se também executar ações em determinados momentos da reprodução do vídeo. O próximo exemplo apresenta um SnackBar quando o fim do vídeo é atingido: videoView.setOnCompletionListener(new MediaPlayer.OnCompletionListener(){ public void onCompletion(MediaPlayer mp){ Snackbar.make(view, "Fim do vídeo!", Snackbar.LENGTH_LONG).show(); } });

© FCA – Editora de Informática

MULTIMÉDIA

8.2

213

GRAVAÇÃO DE VÍDEO E CAPTURA DE IMAGEM

Os dispositivos Android possuem, na sua generalidade, uma câmara instalada, no sentido de permitir ao utilizador tirar fotos e gravar vídeos. O sistema Android inclui uma aplicação nativa chamada Camera para lidar com essas tarefas. Em vez de reinventar a roda e implementar uma nova aplicação para fazer uso da câmara, a ideia é demonstrar como se pode tirar partido da aplicação Camera do Android e codificar uma aplicação multimédia com poucas linhas de código.

Porventura, poderá necessitar de uma interface gráfica mais personalizada para a câmara que vá, por exemplo, ao encontro da interface gráfica geral da aplicação ou mesmo de funcionalidades avançadas. Nestes casos, deve ponderar o uso das API Camera (obsoleta a partir do nível 21 do Android) ou Camera2. A nova API fornece uma interface para dispositivos de câmara individuais conectados a um dispositivo Android. Poderá encontrar mais detalhes em http://developer.android.com/reference/android/hardware/camera2/package-summary.html.

As próximas secções demonstram como se pode gravar vídeos e capturar imagens usando as intents predefinidas do sistema Android.

8.2.1 GRAVAÇÃO DE VÍDEO O processo de gravação de vídeo envolve três partes: verificar o hardware da câmara, definir uma intent para iniciar a atividade que vai gravar o vídeo (aplicação Camera) e, finalmente, lidar com o resultado dessa atividade.

Em primeiro lugar, configure as permissões necessárias no ficheiro de manifesto de forma a poder gravar no armazenamento externo do dispositivo. Em seguida, comece a gravar o vídeo, iniciando uma intent que vai desencadear uma ação de captura do vídeo: private static final int VIDEO_CAPTURE = 101; Uri videoUri; public void startRecordingVideo() { if(getPackageManager().hasSystemFeature( PackageManager.FEATURE_CAMERA_FRONT)) { Intent intent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE); File mediaFile = new File(Environment.getExternalStoragePublicDirectory( Environment.DIRECTORY_MOVIES),"/myVideo.mp4"); videoUri = Uri.fromFile(mediaFile); intent.putExtra(MediaStore.EXTRA_OUTPUT, videoUri); startActivityForResult(intent, VIDEO_CAPTURE); } else { Toast.makeText(this, "Sem câmara!", Toast.LENGTH_LONG).show(); } }

© FCA – Editora de Informática

214

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

Antes de tentar aceder à câmara do Android, é essencial começar por verificar a presença do hardware da câmara. O método PackageManager.hasSystemFeature pode receber constantes, tais como FEATURE_CAMERA_FRONT para verificar a presença de câmara frontal ou FEATURE_CAMERA_ANY para qualquer câmara.

Em seguida, define-se a intent MediaStore.ACTION_VIDEO_CAPTURE com o extra MediaStore.EXTRA_OUTPUT a apontar para um objeto Uri, que detém a referência ao ficheiro de captura. Neste caso, optou-se por guardar o vídeo chamado myVideo.mp4 na pasta Movies da área pública do armazenamento externo do emulador.

Quando o utilizador completa a sessão de gravação de vídeo, é chamado o método onActivityResult da atividade. Este método verifica se o código do pedido passado como parâmetro corresponde ao especificado quando a intent foi lançada e, ainda, se a sessão de gravação foi bem-sucedida.

Neste exemplo, é apresentado o caminho do ficheiro de gravação de vídeo num objeto Toast: protected void onActivityResult(int reqCode, int resCode, Intent data) { if (reqCode == VIDEO_CAPTURE) { if (resCode == RESULT_OK) { Toast.makeText(this, "Vídeo gravado em:\n" + data.getData(), Toast.LENGTH_LONG).show(); } else if (resCode == RESULT_CANCELED) { Toast.makeText(this, "Gravação de vídeo cancelada", Toast.LENGTH_LONG).show(); } else { Toast.makeText(this, "Erro na gravação do vídeo ", Toast.LENGTH_LONG).show(); } } }

Depois destas explicações, é tempo de criar um projeto Android com um layout a exibir apenas um botão que vai despoletar o início da gravação do vídeo (Figura 8.3).

FIGURA 8.3 – Gravação de vídeo

© FCA – Editora de Informática

MULTIMÉDIA

215

Após clique no botão, é aberta a atividade que consegue lidar com a intent criada.

Neste caso, surge a aplicação Camera pronta a iniciar o processo de gravação (Figura 8.4).

FIGURA 8.4 – Aplicação Camera

Após clique no botão da câmara, a gravação inicia-se, apresentando no canto superior esquerdo o tempo de duração atual da gravação (Figura 8.5). Quando já não desejar continuar com a gravação, prima o botão de paragem.

FIGURA 8.5 – Gravação de um vídeo

Depois de terminar a gravação do vídeo, surgem três botões na interface da aplicação Camera (Figura 8.6). O primeiro cancela a gravação, o segundo confirma a gravação e o terceiro reproduz a gravação.

FIGURA 8.6 – Cancelamento, confirmação ou reprodução do vídeo gravado © FCA – Editora de Informática

216

ANDROID – DESENVOLVIMENTO DE APLICAÇÕES COM ANDROID STUDIO

Os dois primeiros botões definem um resultado que é enviado para a atividade de origem. Esse resultado é gerido no método onActivityResult. No caso de premir o botão de confirmação, é apresentado na atividade um objeto Toast a indicar o caminho absoluto para o ficheiro de gravação persistindo no armazenamento externo do emulador (Figura 8.7).

FIGURA 8.7 – Apresentação do caminho absoluto do ficheiro de gravação num objeto Toast

8.2.2 CAPTURA DE IMAGEM Além da intent de captura de vídeo, o Android inclui também uma intent projetada para capturar fotos com a câmara nativa do Android. Esta intent é executada passando como parâmetro a constante MediaStore.ACTION_IMAGE_CAPTURE: private static final int IMAGE_CAPTURE = 102; Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); if (takePictureIntent.resolveActivity(getPackageManager()) != null) { startActivityForResult(takePictureIntent, IMAGE_CAPTURE); }

Observe que o método startActivityForResult é protegido por uma condição que usa o método resolveActivity para devolver a primeira atividade que pode lidar com a intenção. Esta verificação é importante, porque se chamar o método startActivityForResult usando uma intent com que nenhuma aplicação pode lidar, isso resultará no fecho abrupto da aplicação.

Neste exemplo não se especifica o local de armazenamento. Quando o utilizador completa a sessão de captura da foto, é chamado o método onActivityResult da atividade. Neste exemplo é apresentada a foto tirada dentro de um ImageView: protected void onActivityResult(int reqCode, int resCode, Intent data) { if (reqCode == VIDEO_CAPTURE && resCode == RESULT_OK) { Bundle extras = data.getExtras(); Bitmap imageBitmap = (Bitmap) extras.get("data"); imageView.setImageBitmap(imageBitmap); } } } © FCA – Editora de Informática