Capitulo 9788575226407

Luiz Carlos Querino Filho

Novatec

Copyright © 2014, 2017 da Novatec Editora Ltda.

Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora.

Editor: Rubens Prates PY20171128 Revisão gramatical: Smirna Cavalheiro Editoração eletrônica: Carolina Kuwabata Capa: Carolina Kuwabata ISBN: 978-85-7522-640-7 Histórico de impressões: Novembro/2017 Novembro/2014 Dezembro/2013

Segunda edição Primeira reimpressão Primeira edição (ISBN: 978-85-7522-378-9)

Novatec Editora Ltda.

Rua Luís Antônio dos Santos 110 02460-000 – São Paulo, SP – Brasil Tel.: +55 11 2959-6529 Email: novatec@novatec.com.br Site: www.novatec.com.br Twitter: twitter.com/novateceditora Facebook: facebook.com/novatec LinkedIn: linkedin.com/in/novatec

capítulo 1

Prepare-se para se render ao robozinho verde do Google!

O ano: 2003. O local: Vale do Silício, Estados Unidos da América. Neste verdadeiro “oásis” da tecnologia, no meio da ensolarada Califórnia, surgia a Android Inc., empresa fundada por Andy Rubin, Rich Miner, Nick Sears e Chris White, voltada ao desenvolvimento de sistemas móveis.

Não se sabe ao certo o porquê do nome Android. Talvez uma singela homenagem aos célebres R2-D2 e C3PO de Guerra nas Estrelas? Ou um reconhecimento tardio a Data, o androide de Jornada nas Estrelas: A Nova Geração?

Isso realmente não importa. O que interessa de verdade é que o Google, sempre atento às inovações que surgiam ao seu redor, percebeu que muitas ideias interessantes ainda poderiam sair da Android Inc. e passou a financiar as pesquisas realizadas pela empresa.

Em pouco tempo, a “empresa” Android daria o seu nome a um sistema operacional que, assim como o Windows, dominaria seu segmento de mercado.

1.1 Uma breve história do sistema operacional Android Em 2005, o Google adquiriu a Android Inc., e esta passou a fazer parte da gigante das buscas na internet. Essa aquisição serviu também para aguçar a curiosidade de especialistas em tecnologia: Quais seriam os planos da empresa de Larry Page e Sergey Brin no mercado de dispositivos móveis?

Tudo começou a ficar mais claro logo após a Apple apresentar ao mundo o iPhone, em janeiro de 2007, causando uma verdadeira revolução na forma que as pessoas usavam os seus telefones celulares.

12

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

13

Inicialmente, parecia que o Google seria uma espécie de parceiro da Apple no iPhone. O aparelho usava o Google como seu principal mecanismo de busca, e os mapas usados na navegação GPS do aparelho provinham do Google Maps. Até Eric Schmidt, na época CEO do Google, fazia parte do conselho de direção da Apple, chegando até mesmo a participar do evento de lançamento do aparelho.

No entanto, os fortes rumores que indicavam que o Google estaria preparando algo que competiria de igual para igual com o iPhone serviram para acabar com a “lua de mel” entre a empresa de Steve Jobs e a gigante dos mecanismos de busca.

Diz a lenda que Steve Jobs se enfureceu com Eric Schmidt e sua empresa assim que ficou sabendo dos planos do Google para o mercado móvel. Seguiu-se a isso a saída de Eric Schmidt do conselho da Apple e a decisão da grande maçã de remover o Google Maps do iPhone, criando seu próprio serviço de mapas (o Apple Maps).

Fofocas do mundo dos negócios à parte, os fatos são estes: em 5 de novembro de 2007, quando o iPhone já tinha se tornado um grande sucesso de vendas, o Google anunciou a criação da Open Handset Alliance, uma associação encabeçada por ele que contava com a participação de “peixes grandes” do mercado de dispositivos móveis, como Motorola, Samsung e HTC. Nas palavras do próprio Google, o intuito na criação da Open Handset Alliance era desenvolver padrões abertos para dispositivos móveis. E neste mesmo dia a associação apresentou seu primeiro produto: o sistema operacional Android, que equiparia uma nova geração de smartphones que seriam lançados comercialmente em 2008.

Fruto direto da Android Inc., o Android foi anunciado como um sistema operacional baseado no núcleo do Linux e que, consequentemente, herdaria o pedigree deste, oferecendo estabilidade e segurança aos usuários. Para completar, seguiria a mesma filosofia aberta (baseada no conceito de software livre/open source) do Linux: estaria disponível livremente, podendo ser usado simultaneamente em aparelhos de vários fabricantes.

Em pouco tempo, assim como previsto pelos especialistas, o Android tornou-se o líder no mercado de sistemas operacionais para dispositivos móveis.

Isso, obviamente, se deve a vários fatores, como a evidente qualidade do sistema e sua arquitetura aberta, que possibilitou seu uso em diversos aparelhos (se você não sabe, o iOS, sistema operacional do iPhone e do iPad, não pode ser usado em outros aparelhos que não sejam os produzidos pela Apple).

Outro fato que também levou à popularização do sistema foi a escolha da linguagem Java para o desenvolvimento dos aplicativos que executam no Android. Afinal

14

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

de contas, Java é uma das linguagens de programação mais populares do mundo já há algum tempo, com uma base enorme de desenvolvedores experientes. Em junho de 2017, o índice Tiobe apontava Java como a linguagem de programação mais usada no mundo (www.tiobe.com/index.php/content/paperinfo/tpci/index.html).

Os desenvolvedores Java poderiam, então, facilmente começar a desenvolver aplicativos para Android. E isso realmente aconteceu: especialistas estimam que, em março de 2017, mais de 2 milhões e 800 mil aplicativos Android estavam disponíveis para download no Google Play Store (https://www.statista.com/statistics/276623/ number-of-apps-available-in-leading-app-stores/).

Quer mais uma prova do domínio do Android? O IDC informa que, no último quadrimestre de 2016, o Android possuía 86% do mercado (seu market share) de sistemas operacionais móveis, como pode ser observado no gráfico da Figura 1.1 (criado de acordo com os dados disponibilizados pelo IDC em http://www.idc.com/ promo/smartphone-market-share/os).

Figura 1.1 – Fatias de mercado dos principais sistemas operacionais para dispositivos móveis.

O mercado de desenvolvimento de aplicativos móveis está literalmente “pegando fogo”. É hora de arregaçar as mangas e aproveitar o momento, deixando sua marca neste novo e promissor segmento.

Qual seria a melhor forma de começar se não pelo sistema líder do mercado? E o melhor, você pode começar a criar seus aplicativos Android agora, pois o kit de desenvolvimento básico, sua “caixa de ferramentas” para desenvolver os programas, pode ser instalado e usado livremente em qualquer computador com os principais sistemas operacionais: Windows, Linux ou Mac OS X! Então? Vamos nessa?

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

15

AS VERSÕES DO ANDROID O sistema operacional do robô verde evoluiu bastante desde sua primeira versão (1.0), lançada oficialmente em 2008. No momento da atualização da nova edição deste livro, a versão mais recente do Android é a 7.1, codinome “Nougat” – o nome dado “lá fora” para o que nós conhecemos como “torrone”.

Uma curiosidade que você já deve ter notado: as versões do Android, desde a 1.5, passaram a receber codinomes – sempre um tipo de doce ou sobremesa –, seguindo a ordem alfabética. A versão 1.5 era a “Cupcake”; a 1.6 foi chamada de “Donut”; e assim, sucessivamente, as versões foram nomeadas como “Eclair”, “Froyo” (Frozen Yogurt), “Gingerbread”, “Honeycomb”, “Ice Cream Sandwich” e “Jellybean”.

Em outubro de 2013 chegou a versão 4.4, com a sequência alfabética na letra K, e adequadamente batizada de “KitKat” (o famoso chocolatinho com waffer em barras da Nestlé). As versões seguintes continuaram a “tradição”: “Lollipop” (5.0) e “Marshmallow” (6.0), chegando ao “Nougat”, versão utilizada neste livro.

1.2 Obtendo e instalando sua “caixa de ferramentas” O primeiro e imprescindível passo é deixar seu computador preparado para o processo de desenvolvimento de aplicativos para Android.

Independentemente do sistema operacional do seu computador, isso envolverá duas etapas básicas: • Baixar e instalar o Java JDK 8: O Java Development Kit contém o conjunto essencial de ferramentas e bibliotecas para criação de programas em Java. Você já sabe que programas para Android são escritos nesta linguagem, não é mesmo?

• Baixar e instalar o Android Studio: Esta é a ferramenta “oficial” disponibilizada pelo Google para a criação de aplicativos para o sistema operacional do robô: um ambiente de desenvolvimento integrado completo que inclui as bibliotecas de classes Java específicas do Android (entre outros arquivos, como utilitários e documentação).

16

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Se você já é um programador experiente, sabe que o ideal na hora de criar um software é usar um ambiente de desenvolvimento integrado, o chamado IDE (Integrated Development Environment). Os IDEs agrupam um conjunto de funcionalidades que otimizam todo o processo de elaboração de um software, como edição, compilação e depuração. O Android Studio é um IDE criado especificamente para desenvolvimento de aplicações nativas Android, usando a linguagem de programação Java.

O Google, com o intuito de facilitar e estimular cada vez mais a criação de aplicativos para o Android, criou o Android Studio como uma versão customizada do IntelliJ IDEA (um dos IDEs mais usados pelos desenvolvedores Java) contendo recursos exclusivos para criação de softwares para seu sistema operacional móvel.

Um desses recursos, por exemplo, é o editor visual de telas, que ajuda bastante a criação das interfaces dos aplicativos Android.

Pois bem, quando você baixar o Android Studio terá em suas mãos um conjunto de ferramentas de desenvolvimento prontinho para ser usado. O que é um alívio, já que nos primórdios do desenvolvimento para o Android era necessário baixar o Eclipse (um outro IDE muito usado por programadores Java) e acrescentar o suporte ao Android posteriormente com um plugin – nada muito trabalhoso, mas com certeza mais um empecilho na hora de se conquistar usuários inexperientes para a plataforma.

Além do IDE propriamente dito, o download do Android Studio traz as bibliotecas básicas para desenvolvimento no Android, o chamado SDK (Software Development Kit, o “kit” de desenvolvimento de software). O pacote contém também um recurso indispensável: um emulador do Android. Com ele, você pode testar seus aplicativos em qualquer versão do Android liberada pelo Google diretamente em seu computador, sem a necessidade de ter um aparelho físico. Bom, mas chega de conversa.

Vamos começar a colocar a casa em ordem!

Os exemplos a seguir, de obtenção e instalação do Java e do Android Studio, são apresentados em um computador com o sistema operacional Windows instalado.

Se você usa Mac OS X ou Linux, não se preocupe, o processo é praticamente o mesmo (afinal de contas, estamos trabalhando com desenvolvimento em Java – uma linguagem multiplataforma).

Outra consideração importante: estamos dentro de uma área em evolução aceleradíssima nos tempos atuais – a programação para dispositivos móveis! Por isso, pode ser que, enquanto você lê este livro e segue estes tutoriais, um ou outro detalhe possa ter sido mudado, como uma tela ou um procedimento. Com certeza não será muito, mas lembre-se de fazer as adaptações que forem necessárias.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

17

1.2.1 Baixando e instalando o Java JDK É muito provável que você já tenha o JRE (Java Runtime Environment) em sua máquina. Ele possibilita a execução de aplicativos Java. Muitos sites e programas fazem uso dele. Porém, a não ser que você já tenha programado em Java em seu computador, você não deve ter o JDK instalado. Ele é usado para criar aplicativos em Java.

Mesmo se tiver, ou caso não saiba se tem ou não, é recomendável baixar e instalar uma versão mais atual. Ah! Também não há problema se você não tiver o JRE instalado, viu? O JDK vem com ele.

Para baixar o JDK, acesse o endereço de download oficial da Oracle: http://www.oracle.com/technetwork/java/javase/downloads/index.html

AVISO SOBRE O JDK! As versões mais novas do Android Studio trazem uma versão do kit de desenvolvimento Java (JDK) “embutido”, o que, a rigor, torna desnecessário o download e instalação do JDK da Oracle. Porém, como alguns casos de problemas no uso do OpenJDK (a versão incluída nos novos Android Studio) foram relatadas, é recomendado (principalmente aos novos usuários) contar com a “versão oficial” do JDK instalado. Isso também pode ser vantajoso se você quiser desenvolver paralelamente (ou posteriormente) outros tipos de aplicação Java.

A versão mais atualizada do JDK, no momento da finalização desta edição do livro, era a 8u131. Isso indica que estamos usando o Java na sua versão 8, com a atualização número 131. Como o Java é constantemente atualizado pela Oracle, pode ser que, quando você estiver lendo isso, uma nova versão já esteja disponível.

Vá em frente e baixe a versão mais nova.

Para fazer o download, clique no link indicado na Figura 1.2.

Ao clicar, você será levado a uma página onde escolherá a versão do JDK específica para o seu sistema operacional. Você também deverá aceitar os termos da Oracle para poder fazer o download (Figura 1.3).

Escolha a versão adequada ao seu sistema operacional. Para alguns sistemas operacionais (como o Windows), existe a opção de baixar a versão 32 bits ou a 64 bits.

Baixe sempre a versão correta para o seu caso (isso também será importante na hora de obter o Android Studio).

18

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.2 – Site para download do Java JDK.

Figura 1.3 – Escolhendo a versão adequada do JDK.

Após a conclusão do download, clique duas vezes sobre o arquivo baixado para iniciar a instalação. Será apresentada uma tela semelhante à da Figura 1.4.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

19

Figura 1.4 – Instalação do JDK.

O processo de instalação do JDK é bastante simples e rápido. Basta seguir o “famoso” Next... Next... Next... Finish. Ao término da instalação, será mostrada uma tela parecida com a da Figura 1.5. Agora é só clicar em Close (Fechar) para encerrar a instalação.

Figura 1.5 – Instalação do JDK 8 concluída.

Neste ponto você já possui em seu computador os recursos necessários para executar e criar programas Java tradicionais.

20

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Agora precisamos do Android SDK para que possamos criar programas em Java para a plataforma!

1.2.2 Baixando e instalando o Android Studio Nesta etapa, vamos obter o “pacotão” de desenvolvimento específico para o Android, que engloba o ambiente de desenvolvimento integrado para criar programas Android (Android Studio), o Android SDK (bibliotecas e ferramentas) e o emulador.

Por isso, o pacote do Android Studio é significativamente maior que o do Java JDK, mas não se preocupe: ele já vem com (quase) tudo que precisamos para começar a programar. Para obtê-lo, acesse o endereço: http://developer.android.com

Você entrará no melhor local para encontrar informações sobre o desenvolvimento em Android: o site oficial de desenvolvedores Android do Google! Além do Android Studio, nele você encontrará notícias, tutoriais e a documentação completa do SDK. Recomendo que você adicione este site aos seus favoritos e faça dele um ponto de parada obrigatória na rede!

Na parte inferior da tela, clique em Obter o Android Studio (ou algum link equivalente, se estiver visualizando a página em outro idioma ou diferente do que está sendo exibido), como mostrado na Figura 1.6.

Figura 1.6 – Site developer.android.com e link para download do Android Studio.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

21

Você será levado à página de download. Nela, com base em informações do seu navegador, será sugerida automaticamente a versão do Android Studio adequada ao seu sistema operacional. Basta então clicar no botão indicado para iniciar o download (Figura 1.7).

Figura 1.7 – Botão para início do download do Android Studio.

Na próxima tela, antes do download efetivamente começar, você deverá concordar com os termos do Google (Figura 1.8). Se quiser ler tudo, vá em frente... nos veremos daqui uns 30 minutos... 

Figura 1.8 – Aceitando os termos e iniciando o download do Android Studio.

22

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Terminado o download do Android Studio, você terá um arquivo executável de instalação salvo em seu computador. Clique nele para começarmos o processo.

SE O SEU SISTEMA OPERACIONAL FOR MAC OS X OU LINUX... ... não tema! Todos os procedimentos descritos neste livro serão bastante semelhantes, sendo que o código Java será exatamente o mesmo. Isso é uma das grandes vantagens do uso da linguagem Java – totalmente multiplataforma – no Android!

A primeira tela da instalação é mostrada na Figura 1.9. Clique em Next para iniciá-la.

Figura 1.9 – Iniciando a instalação do Android Studio.

Na tela seguinte (Figura 1.10) são mostrados os componentes que serão instalados. A instalação padrão traz, além do Android Studio, o SDK (Software Development Kit) e um Android Virtual Device (AVD). O AVD é uma “cópia” do sistema operacional Android pronto para ser executado no emulador, possibilitando assim o teste dos aplicativos diretamente no computador. Mantenha todas as opções selecionadas e clique em Next para continuar.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

23

Figura 1.10 – Escolha dos componentes para instalação.

Você deverá concordar (mais uma vez...) com os termos e condições de uso do Android Studio para prosseguir (Figura 1.11). Pode concordar sem medo clicando em I Agree, não tem “pegadinha”!

Figura 1.11 – Concordando com os termos e seguindo em frente!

24

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Depois desta tela você poderá escolher a pasta no seu computador onde ficarão instalados o Android Studio e o SDK, assim como o grupo de programas no menu Iniciar onde ficará o atalho para iniciar o programa. Recomendo que você mantenha as opções recomendadas e siga clicando em Next.

IMPORTANTE: Evite ao máximo colocar os arquivos do Android Studio e do SDK em um caminho de pastas que contenha acentuação no nome ou espaços.

Existem algumas situações em que isso pode ocasionar problemas na abertura e execução dos programas. Se seu usuário no sistema operacional tem acentos no nome (e que isso reflete no nome da pasta pessoal), considere criar um outro usuário sem acentos ou espaços no nome e instalar o Android Studio por meio dele.

Será iniciado o processo de cópia dos arquivos. Quando for finalizado, será mostrada uma tela semelhante à da Figura 1.12. Clique mais uma vez em Next.

Figura 1.12 – Término do processo de cópia dos arquivos.

A tela final da instalação é exibida na Figura 1.13.

Mantenha a opção Start Android Studio selecionada e clique em Finish. A instalação abrirá o Android Studio automaticamente. É hora de encarar a fera!

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

25

Figura 1.13 – Encerrando a instalação do Android Studio.

1.3 Executando o Android Studio pela primeira vez Como já vimos, o Android Studio é uma versão customizada do IntelliJ IDEA criada pelo Google especificamente para o desenvolvimento de aplicativos para o Android. Herdou dessa maneira várias das qualidades do IntelliJ, e que fazem dele um dos IDEs mais populares entre os desenvolvedores Java (competindo com o Eclipse e com o NetBeans).

Porém, não é necessariamente um aplicativo leve e rápido – foi totalmente escrito em Java (ou seja, é um programa escrito em Java para criar programas Java ), o que significa que você precisará ter um bom computador com uma quantidade razoável de memória RAM para executá-lo satisfatoriamente.

Para que ele execute com um mínimo de desempenho adequado, você precisará ter 4 GB de RAM. Executá-lo em computadores com menos que isso é inviável. O ideal, contudo, é ter 8 GB (ou até mais) de memória, para que você consiga utilizá-lo de forma mais produtiva. Se seu notebook/computador tiver apenas 4 GB, considere seriamente fazer um upgrade.

26

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

1.3.1 As configurações iniciais do Android Studio Quando abrimos o Android Studio pela primeira vez, ele pergunta se você quer importar suas configurações de uma versão anterior já instalada (Figura 1.14). Como o estamos instalando pela primeira vez, mantenha selecionada a segunda opção (I do not have a previous version...) e clique em OK.

Figura 1.14 – Importando (ou não) as configurações iniciais do Android Studio.

Como se trata da primeira execução do Android Studio, temos que configurar algumas outras “coisinhas”. Na verdade, nesse ponto (como demonstra o texto na Figura 1.15) será realizada a validação final da instalação que inclui (provavelmente) o download adicional de outros componentes necessários. Clique em Next para iniciar.

Figura 1.15 – Instalação e configuração de componentes do Android Studio e SDK.

Para não tornar as coisas mais complicadas, selecione o tipo de instalação padrão (Standard) na tela seguinte (Figura 1.16) e clique em Next.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

27

Figura 1.16 – Escolhendo o tipo de instalação.

Será feita uma verificação de quais componentes adicionais devem ser baixados e instalados no seu caso. A quantidade e tamanho destes componentes varia a cada caso (ou seja, o tamanho do download e os itens exibidos no seu caso poderão ser diferentes daqueles mostrados na Figura 1.17). Clique em Finish para que o processo se inicie.

Figura 1.17 – Sumário da instalação que será realizada.

28

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Depois que os componentes tiverem sido baixados em instalados, será exibida uma janela semelhante à mostrada na Figura 1.18. Clique em Finish para finalizar.

Figura 1.18 – Finalizando a instalação dos componentes.

Agora sim o Android Studio vai entrar em cena. Será apresentada a tela de boas-vindas do programa (Figura 1.19) que permite a você criar um novo projeto ou abrir um existente, entre outras coisas.

Figura 1.19 – Tela de boas-vindas do Android Studio.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

29

Vamos agora criar um novo projeto, clicando no botão indicado na Figura 1.19. Não será muito útil (e você com certeza não desejará publicá-lo na Play Store, para não ser xingado nos comentários dos usuários!), mas servirá para testarmos se tudo está OK com a instalação e seguirmos uma das “grandes tradições” do mundo da programação.

1.3.2 Criando um projeto: o tradicional “Alô, Mundo!”

Ao clicar no botão “Start a new Android Studio project” é iniciado o assistente de criação de um novo projeto. Como você deve ter percebido, criaremos o tradicional aplicativo “Alô, Mundo!” (ou “Hello, World!”) que somente exibe esta mensagem na tela.

A TRADIÇÃO DO “HELLO, WORLD!” Todo estudante de programação conhece o tradicional “Hello, World!”.

Trata-se de uma tradição criar um programa que simplesmente mostra essa mensagem na tela quando se está aprendendo uma nova linguagem (ou a sua primeira linguagem). Diz a lenda que o uso desse tipo de “programinha” começou com o livro The C Programming Language (A Linguagem de Programação C), de Brian Kernighan e Dennis Ritchie, em que um “Hello, World!” é o primeiro exemplo apresentado para ensinar ao leitor seu primeiro programa em C. Este livro foi lançado em 1978! Ou seja, o “Hello, World!” já serviu para começar a ensinar mais de uma geração a programar!

Na primeira tela, exibida na Figura 1.20, você deverá especificar um nome para o projeto (e que será, consequentemente, o nome do aplicativo dentro do Android) em Application name. Especifique o nome que desejar ou coloque simplesmente “AloMundo”.

Se quiser modificar o local no seu computador onde este projeto será salvo, modifique o caminho exibido em Project location, clicando no botão com três pontinhos à direita. Clique em Next para prosseguir.

A segunda tela (Figura 1.21) serve para definirmos o fator de formação (“form factor”) do aplicativo que vamos criar. Esse “fator de formação” nada mais é que a plataforma (ou seja, o tipo de aparelho) onde o app vai executar. Como hoje o Android está disponível também em outros aparelhos como Smart TVs e relógios é possível usar o Android Studio para criar apps para esses aparelhos também. No nosso caso, vamos sempre deixar marcada a opção padrão, Phone and Tablet. Clique em Next para continuar.

30

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.20 – Primeira tela da criação de um novo projeto.

Figura 1.21 – Escolhendo a plataforma onde o aplicativo executará.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

31

Posteriormente, talvez seja exibida uma janela semelhante à da Figura 1.22. Ela indica que alguns arquivos necessários estão sendo obtidos e adicionados ao SDK. Quando a cópia finalizar, clique em Next.

Figura 1.22 – Arquivos necessários sendo adicionados ao SDK.

Na tela seguinte (Figura 1.23) especificamos um modelo para a tela do aplicativo.

Selecione a Empty Activity, que representa uma tela totalmente vazia, e clique em Next.

A última tela, apresentada na Figura 1.24, possibilita a modificação do nome da classe Java relativa à tela do aplicativo (MainActivity) e seu arquivo de layout (activity_main). Não se preocupe com eles agora, apenas clique em Finish para encerrar o assistente.

Depois de alguns segundos (ou minutos, se seu computador for mais antigo...), o novo projeto será criado e o Android Studio aparecerá finalmente em sua tela, em toda sua glória (Figura 1.25).

Você pode ver, na Figura 1.25, a barra de menus e barra de ferramentas na parte superior. À esquerda (1) é exibida a aba Project; ela exibe a estrutura completa do projeto, mostrando todos os arquivos existentes nele. À direita (2) está sendo exibido o código-fonte do arquivo MainActivity.java. O arquivo MainActivity.java é onde colocamos a programação referente às ações do usuário na tela do programa.

32

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.23 – Escolhendo um modelo para a tela do aplicativo.

Figura 1.24 – Finalizando o assistente de criação de um novo projeto.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

33

Figura 1.25 – Android Studio com o projeto AloMundo aberto.

O aspecto visual da tela (seu layout) fica em outro arquivo, denominado activity_main.xml. Por conveniência, ele já fica aberto com o projeto recém-criado.

Você pode visualizá-lo clicando em sua aba, como indicado pela seta na Figura 1.26. Clique sobre esta aba para visualizá-lo. Você deverá ver um layout de tela semelhante ao da Figura 1.26.

Figura 1.26 – Android Studio com o arquivo de layout activity_main.xml aberto.

34

Desenvolvendo seu primeiro aplicativo Android – 2ª edição IMPORTANTE: Em alguns computadores pode ocorrer um pequeno problema no momento da primeira visualização de um arquivo de layout. Nesses casos, a tela não aparecerá corretamente e uma mensagem de erro será exibida na parte inferior do layout. Se acontecer no seu caso, feche o arquivo de layout (clicando no “x” na aba do arquivo) e abra-o novamente. Para abri-lo novamente, localize-o dentro da pasta res (Figura 1.26-1) e subpasta layout (Figura 1.26-2). Clique duas vezes no nome do arquivo para abri-lo.

Você já deve ter visto um pequeno texto contendo a frase “Hello, World!” no centro da tela. Todo novo projeto criado no Android Studio com o modelo de tela Empty Activity vem com o texto previamente colocado na tela – os programadores da Google também sabem que um primeiro programa em uma nova linguagem (ou plataforma) deve ser o tradicional “Alô, Mundo!”!

Isso significa que não precisamos acrescentar ou mudar nada em nosso projeto.

Ele já está pronto para ser executado e mostrar a mensagem!

Para poder testar o programa que vamos criar, precisaremos de um aparelho conectado (e configurado no computador) ou do emulador. Vamos começar usando o emulador, que é mais fácil e prático, já que está disponível para todo mundo. Porém, antes de usá-lo, temos que configurá-lo: Qual versão do Android ele executará? Qual dispositivo ele vai emular (na questão do tamanho e da resolução da tela, por exemplo)?

Fazemos essas configurações criando um “dispositivo virtual do Android”, um AVD (Android Virtual Device).

1.3.3 Executando o programa e criando um dispositivo virtual para o emulador Os AVDs são criados usando uma ferramenta incluída no Android SDK denominada Android Virtual Device Manager. Ela é tão importante que um ícone de atalho a ela foi adicionado à barra de ferramentas do Android Studio. Porém, vamos abrir o Device Manager por outro caminho.

Toda vez que você quiser testar seu programa, seja no emulador seja em um dispositivo real conectado ao computador, ele deverá ser compilado antes de ser executado.

A compilação “transforma” o código-fonte que você escreveu no Android Studio em código executável capaz de funcionar diretamente no Android. Esse código executável fica empacotado em um arquivo denominado APK. Apesar de ser um processo relativamente complexo, você não precisa se preocupar muito com ele. O Android Studio faz tudo por você, bastando clicar no botão da barra de ferramentas indicado na Figura 1.27.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

35

Figura 1.27 – Executando o aplicativo no Android Studio.

Vá em frente e clique nele! Se você é do tipo que prefere teclas de atalho, é só teclar Shift + F10 (ou CTRL + R em Macs).

Dentro de alguns instantes será exibida a janela mostrada na Figura 1.28. Ela permite que você escolha em qual dispositivo ou instância do emulador você deseja executar o app.

Figura 1.28 – Escolhendo onde o aplicativo será executado.

Sua tela deve estar parecida com a da Figura 1.28, onde ainda não temos nenhuma instância do emulador disponível ou dispositivo conectado para executar o programa (veja a mensagem “No USB devices or running emulators detected”).

Precisamos resolver isso já! Faremos isso abrindo o AVD Manager citado anteriormente, clicando no botão Create New Virtual Device.

36

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Clicando no botão indicado, será aberta uma janela (Figura 1.29) que possibilitará criar um novo AVD. Posteriormente, quando já tivermos um AVD criado pelo menos, esta mesma janela listará todos os dispositivos virtuais já criados (sim, você pode criar mais de um – por exemplo, quando precisar testar seu programa em versões diferentes do Android).

Figura 1.29 – Tela do Android Virtual Device Manager.

Em uma instalação nova do Android Studio não temos nenhum AVD criado. Então, vá em frente: clique sobre o botão Create Virtual Device para fazê-lo (Figura 1.29)!

Na primeira tela do assistente de criação de um AVD (Figura 1.30) definimos uma configuração de hardware para o dispositivo virtual – ou seja, se é um smartphone, tablet, wearable (como um relógio), e quais são suas configurações básicas de tamanho e resolução de tela.

Não espere encontrar aqui configurações para os aparelhos comumente encontrados no mercado, como os da Samsung, por exemplo; só aparecerão modelos padronizados do Google, mas não se preocupe: você pode posteriormente, se quiser, importar ou criar um perfil de hardware para um aparelho específico. Em nosso caso, ficaremos como a “sugestão” do assistente, o Nexus 5X, que tem uma configuração próxima à de vários aparelhos existentes à venda. Clique em Next para continuar.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

37

Figura 1.30 – Configurando o hardware do dispositivo virtual.

A tela seguinte (Figura 1.31) é muito importante, pois escolhemos nela a “imagem do sistema” que será usada no emulador, ou seja, uma cópia completa de uma versão do sistema operacional Android. Você pode escolher qualquer versão do Android disponibilizada, mas é sempre recomendado utilizar uma das mais recentes. No momento da edição deste livro, a versão mais recente é o Android Nougat (versão 7.0); portanto, será ela que utilizaremos aqui. Se, no momento em que está lendo e seguindo estes passos, houver uma versão final mais recente (e não uma versão Preview, como a do Android “O” exibida na Figura 1.31 – e que com certeza ainda contém bugs), vá em frente e a use!

PORÉM, PARE! Antes de escolher a versão, há algo muito importante a ser feito e que, com certeza, economizará muitos minutos do seu precioso tempo quando estiver testando seus programas no emulador: instalar o acelerador Intel HAXM! Com ele instalado, a execução do emulador ficará BEEEEEEMMM mais rápida.

E coloca BEM nisso! Portanto, antes de escolher a versão, clique no “link” Install Haxm como indicado na Figura 1.31.

A primeira tela do processo de instalação do HAXM é mostrada na Figura 1.32.

38

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.31 – Escolhendo a versão do Android que será usada no emulador.

Figura 1.32 – Tela inicial do assistente de instalação do Intel HAXM.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

39

Sem entrar em detalhes técnicos complicados, o Intel HAXM usa uma tecnologia de aceleração de virtualização, existente em processadores Intel mais recentes. Com essa tecnologia, máquinas virtuais ou emuladores com imagens de sistemas operacionais baseados no padrão x86 (como o Android – hoje ele está presente tanto em equipamentos com processadores ARM quanto x86) conseguem executar ainda mais rápido.

Na tela da Figura 1.32 o assistente está indicando uma quantidade de memória RAM a ser alocada para o Intel HAXM. Você até pode aumentar ou diminuir a quantidade, mas para ter um bom desempenho o ideal é seguir a sugestão do assistente e clicar em Next.

NOTA: No seu caso, a quantidade de memória recomendada poderá ser maior ou menor que a apresentada na Figura 1.32.

O Intel HAXM será então instalado em seu computador, como indica a Figura 1.33. Caso apareça alguma mensagem de erro, pode ser que seu computador não suporte a aceleração do Intel HAXM. Neste caso, você ainda poderá executar o emulador e testar os programas, mas com um desempenho inferior.

Figura 1.33 – Instalação do Intel HAXM.

Depois que a instalação terminar, clique em Finish. Voltaremos à tela de escolha da imagem do sistema (Figura 1.34). Clique no link de Download existente ao lado da versão desejada (lembre-se: use a versão mais recente, desde que não seja ainda

40

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

uma versão de testes, mas se a instalação do Intel HAXM teve sucesso você precisa, obrigatoriamente, escolher uma versão para plataforma x86 para que possa se beneficiar da aceleração).

Figura 1.34 – Escolhendo a versão do Android e iniciando o download.

Será necessário aceitar os termos do Google e clicar em Next, como indicado na Figura 1.35.

Quando o download encerrar, clique em Finish (Figura 1.36).

Após clicar em Finish, você voltará à tela que contém as imagens disponíveis. Agora será possível selecionar a imagem que você acabou de baixar (no exemplo da Figura 1.37, o Android 7.0 Nougat). Clique sobre a versão para selecioná-la e depois clique em Next para prosseguir.

A tela seguinte (Figura 1.38) é a última do processo de criação do AVD. Nela você pode customizar algumas configurações do dispositivo virtual. Não se preocupe com essas configurações agora; os valores default são adequados para o nosso caso.

Se desejar, você pode alterar o nome do AVD, como indicado na Figura 1.38. Para encerrar, clique em Finish.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

Figura 1.35 – Aceitando os termos do Google para iniciar o download.

Figura 1.36 – Download da imagem do Android encerrado.

41

42

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.37 – Selecionando a imagem do Android baixada.

Figura 1.38 – Encerrando o procedimento de criação de um AVD.

Após encerrar, você visualizará novamente a tela apresentada na Figura 1.28, só que agora contendo o novo AVD recém-criado (Figura 1.39).

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

43

Figura 1.39 – Selecionando o AVD que será usado para executar o aplicativo.

Se você não se lembra, estávamos nesta tela após termos clicado no botão que executa o projeto dentro do Android Studio. Para que o app possa ser executado precisávamos ter um AVD disponível ou um aparelho real conectado – e com os seus drivers instalados – no computador. Bem, agora nós temos um AVD! Então selecione-o e clique em OK, como mostrado na Figura 1.39.

Talvez seja exibido um aviso como o da Figura 1.40. Ele apenas indica que precisará adicionar alguns arquivos para a plataforma escolhida para que o Instant Run seja habilitado. O Instant Run é um recurso relativamente novo do Android Studio, o qual possibilita a execução mais rápida do app no emulador após alguma modificação. Clique em Install and Continue e espere o download terminar. Após ele encerrar, clique em Finish.

Figura 1.40 – Habilitando o Instant Run.

44

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Nesse momento o emulador e o AVD serão inicializados. Depois de alguns segundos (se você tiver um computador com uma boa quantidade de memória RAM e se o Intel HAXM tiver sido instalado com sucesso) ou, infelizmente, minutos (caso tenha um computador mais antigo com pouca RAM e a instalação do Intel HAXM tenha falhado), você deverá ver seu primeiro app rodando no emulador (Figura 1.41).

Figura 1.41 – O app AloMundo em execução no emulador do Android.

Com certeza foi legal ver o nosso “Hello, World!” para Android funcionando, mas nós sabemos que é um aplicativo sem um “pingo” de utilidade...

Pois bem: vamos agora criar um que pode, sim, ser útil! Ele também servirá para escrevermos nossas primeiras linhas de código Java em um app Android.

1.4 O nosso primeiro app “útil”: um conversor de medidas O sistema métrico é o padrão de unidades de medida em quase todo mundo. Se você for para algum outro país, provavelmente também vai se deparar com metro, centímetro e quilômetro. A não ser que esse país seja os Estados Unidos...

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

45

Sim, a terra do Tio Sam é o único país industrializado que não adotou o sistema métrico como padrão! E, consequentemente, temos de nos resignar (e nos adaptar) a este fato! Se um dia você tiver que saber sua altura em pés (esta é a unidade de medida que os norte-americanos usam para essa finalidade), deverá fazer uma conversão.

Nada que a boa e velha matemática não resolva. Porém, vamos tornar tudo um pouco mais fácil: vamos carregar em nosso bolso um aplicativo de conversão de metros para pés.

A conversão é simples: um pé (foot em inglês) equivale a 30,48 centímetros. Se uma pessoa possui 1,83 metro de altura, totalizamos 183 centímetros. Após fazer a divisão (183/30,48), ficamos sabendo que este indivíduo mede exatamente seis pés (feets)! É claro que este não é o aplicativo principal do nosso livro – trata-se apenas de mais um teste para verificar que a casa está em ordem, e para já aprendermos alguns conceitos básicos do desenvolvimento para Android. No entanto, não é por isso que ele deve ser sem graça, não é verdade?

Teremos uma barra com um botãozinho deslizante (chamada de SeekBar no Android SDK), na qual o usuário poderá especificar sua altura. Após marcar a altura, o usuário tocará em outro botão e o valor da medida em metros será convertido para pés e exibido em um rótulo de texto. Vai ficar razoavelmente interessante, como você pode ver na Figura 1.42.

Figura 1.42 – Tela final do aplicativo Conversor.

46

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

1.4.1 Criação do projeto no Android Studio Para criar o novo projeto no Android Studio, primeiramente feche o projeto AloMundo (já que não precisaremos consultar ou utilizar nada existente nele e queremos liberar memória RAM do nosso computador) – basta fechar a janela, clicando no botão X no seu canto superior direito (ou esquerdo, dependendo do sistema operacional que você estiver usando).

O Android Studio retornará à sua tela inicial (a mesma que já vimos na Figura 1.19 – se ela não for exibida dentro de alguns segundos, abra o Android Studio novamente clicando no seu ícone). Assim como fizemos para criar o projeto AloMundo, clique no botão Start a new Android Studio project. Será exibida a primeira tela do assistente de criação de um novo projeto (Figura 1.43).

Figura 1.43 – Primeira tela do assistente de criação de um novo projeto.

Desta vez vamos dar uma olhada mais atenta às opções existentes na criação do projeto: (a) Application name: o nome do aplicativo, que será mostrado na lista de programas instalados no aparelho e no Google Play Store (se você decidir publicá-lo).

Para este exemplo, informe Conversor.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

47

(b) Company domain: um pacote, na linguagem Java, é uma forma de categorizar corretamente as unidades básicas de código-fonte que você escreve (chamadas de classes). A convenção na definição de pacotes do Java é usar um domínio da internet em forma reversa, seguido de um identificador para o programa.

Você pode ver no exemplo da Figura 1.43 que usei meu domínio particular (querino.net). Repare que, na opção logo abaixo (Package name), é mostrado o nome de domínio que eu especifiquei invertido (net.querino), seguido de um ponto e do nome do aplicativo em letras minúsculas (net.querino.conversor).

Evite ao máximo usar valores fictícios ou inválidos neste caso, pois este nome de pacote também servirá para identificar seu aplicativo no Google Play Store (se você for publicá-lo lá). Então, se não possuir um domínio próprio, use o da empresa onde trabalha, da sua faculdade ou o domínio de alguém que conhece (não deixe de, obviamente, pedir permissão para usá-lo ao responsável). É claro que, se não tiver intenção de publicar o app, você pode inserir qualquer nome ou aceitar o valor padrão mostrado pelo Android Studio. (c) Package name: o nome do pacote das classes Java do seu projeto. Como vimos na opção anterior, este valor será definido automaticamente de acordo com o que você informou na opção anterior (Company domain). (d) Project location: o local onde o projeto ficará armazenado em seu computador.

O Android Studio cria uma pasta com o nome do aplicativo fornecido em Application name e coloca todos os arquivos e subpastas do projeto dentro dela. Você pode alterar o local onde o projeto será salvo digitando o novo local ou clicando no botão com três pontinhos à direita. ATENÇÃO: evite ao máximo colocar seu projeto em um caminho de pastas com acentos e caracteres internacionais (como cedilha), pois isso pode ocasionar problemas na compilação e execução.

Finalmente, clique em Next para passar à próxima tela. Nela (Figura 1.44) indicamos a plataforma onde o aplicativo executará.

Como já tínhamos visto na criação do projeto AloMundo, é possível usar o Android Studio para criar aplicativos para vários outros dispositivos que executam o sistema operacional do robozinho verde, muito além de smartphones e tablets. Porém, este livro e nossos apps são destinados à criação de aplicativos móveis para a plataforma “mãe” do Android: justamente os smartphones. Por isso, mantemos selecionada a opção Phone and Tablet, como indicado na Figura 1.44.

E com relação à opção Minimum SDK, marcada pela letra a???

48

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.44 – Especificando a plataforma de execução do projeto.

A minha sugestão é que você mantenha selecionado o valor sugerido pelo Android Studio (no caso da Figura 1.44, API 15: Android 4.0.3 (IceCreamSandwich). Essa configuração especifica a versão mínima do Android necessária para que seu programa funcione. Marcando uma versão mais antiga teremos duas consequências: uma boa (seu aplicativo vai funcionar em aparelhos mais antigos) e uma não tão boa assim (somente poderemos usar no nosso aplicativo os recursos que já existiam desde a versão escolhida – vão ficar de fora muitas funções inovadoras acrescentadas nas versões mais recentes do Android).

A primeira impressão nesse momento é de que a melhor ideia é realmente colocar uma versão BEM MAIS antiga, mas não é exatamente assim. Veja, no texto logo abaixo da opção escolhida, que se a mantiver selecionada, seu app poderá executar em 100% dos dispositivos ativos na Play Store! Isso quer dizer que você somente “perderá” do alcance os aparelhos de usuários que NÃO USAM A PLAY STORE, ou seja, que NUNCA BAIXAM APPS! Por essa razão, realmente não compensa mudar esse valor: deixando ele assim você terá acesso a recursos mais novos do sistema operacional e atingirá 100% dos usuários que nos interessam, que são aqueles que baixam novos apps nos seus aparelhos.

Clique em Next para passar à tela seguinte (Figura 1.45).

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

49

Figura 1.45 – Escolhendo um modelo para a tela do aplicativo.

Chegamos no ponto onde escolhemos uma opção para a tela inicial do nosso aplicativo. Existem várias opções, como por exemplo: • Add No Activity: nenhuma tela será criada. O projeto começará totalmente “vazio”.

• Basic Activity: uma tela em branco com uma ActionBar no topo (uma espécie de barra de ferramentas que pode incluir botões e um menu) e um botão “flutuante” que aparece no canto direito inferior.

• Empty Activity: uma tela em branco padrão. Mantenha-a selecionada, pois é essa que utilizaremos.

• Fullscreen Activity: essa opção permite a criação de uma janela que ocupa todo o espaço disponível na tela do aparelho.

• Google Maps Activity: uma tela que já inclui um layout e o código Java inicial para exibição de mapas do Google Maps.

• Login Activity: a tela será criada com um layout contendo campos para um login de entrada no app, de forma que o usuário digite um nome de usuário e uma senha.

Mantenha Empty Activity selecionada e clique em Next. A última tela do assistente de criação de um novo projeto é então exibida (Figura 1.46).

50

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.46 – Tela final do assistente de criação do projeto Conversor.

Não vamos mudar os valores das opções, mas é bom saber o que cada um significa: (a) Activity Name: o nome da classe em que ficará o código responsável pelo controle do “ciclo de vida” da tela principal do seu programa, assim como todos os eventos relacionados aos elementos na tela. Se você não é muito familiarizado com Java, saiba que escrevemos o código dos programas criados nesta linguagem em classes, e que dentro delas ficam os métodos e eventos, que são como funções relacionadas à tela ou algum existente dentro delas (como botões e caixas de entrada de texto). Neste caso, vamos manter o nome MainActivity para a classe de nossa tela principal. (b) Layout Name: activity_main é o nome do arquivo em XML que contém a especificação do layout da tela, ou seja, o que esta tela possui (botões, texto etc.), como estes elementos estão posicionados nela e quais suas configurações de exibição (tamanho, cor, alinhamento, entre outros). Vamos manter este valor padrão.

Mantenha as caixas de marcação Generate Layout File e Backwards Compatibility (AppCompat) selecionadas; elas servem, respectivamente, para criar o arquivo de layout especificado na opção (b) e fazer com que a tela do aplicativo seja compatível com versões mais antigas do Android.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

51

MAS O QUE É ESSA TAL ACTIVITY? O Android SDK fornece a classe Java Activity como a base para a implementação de uma tela dentro de um aplicativo. Dentro do código de uma Activity, controlamos o “ciclo de vida” de uma tela (o que fazer quando ela é criada, encerrada etc.) assim como o que deve acontecer quando o usuário interage com os elementos existentes na mesma (chamamos essas interações de eventos). Um aplicativo com uma única tela possui uma Activity só, como este que estamos criando, mas é bastante comum possuir várias delas em um mesmo projeto, quando este possuir múltiplas telas.

Agora você pode clicar em Finish para que seu projeto seja criado. Em alguns instantes, você terá uma tela semelhante à da Figura 1.47 (e também muito parecida com aquela que obteve quando criou o projeto AloMundo).

Figura 1.47 – Projeto Conversor no Android Studio.

O arquivo aberto atualmente é o MainActivity.java, onde fica a programação. Vamos começar montando a interface (ou seja, a tela) do programa. Por isso, alterne para o arquivo activity_main.xml clicando em sua aba, como indicado na Figura 1.47.

52

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

1.4.2 Começando pela interface: muito além do simples arrastar e soltar Você pode perceber pela tela da Figura 1.48 que estamos agora com o arquivo activity_main.xml aberto. Este é o arquivo que contém a definição da interface do nosso aplicativo em linguagem XML, ou seja, a especificação dos widgets contidos na tela e suas respectivas configurações (posição, tamanho etc.). Na parte central do Android Studio está a visualização da tela do aplicativo, da forma como a mesma deverá ser mostrada nos aparelhos. É nesta “prévia” que você colocará os widgets que formarão sua interface. Perceba também que à direita dela fica uma outra visualização da tela, semelhante a uma “planta baixa” – você pode simplesmente ignorá-la ou utilizá-la como guia para definir precisamente os tamanhos e posições dos widgets.

Figura 1.48 – Projeto Conversor com o arquivo do layout de tela aberto.

WIDGET: MAIS UM TERMO “ESTRANHO”...

Na verdade, este termo “estranho”, cuja tradução literal seria algo como “dispositivo” ou “mecanismo”, é usado para indicar elementos que são usados na criação de interfaces gráficas com o usuário (as famosas GUI – Graphical User Interfaces). Portanto, um botão, um rótulo de texto em uma tela gráfica – seja ela Android ou Windows – são todos widgets. E tem desenvolvedor que acha que se trata de alguma criatura de um RPG ou de Star Wars...

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

53

Como estamos começando, vamos editar o layout do nosso aplicativo diretamente pelo editor visual, sem mexer (por enquanto) no código XML. Comece removendo o TextView pequeno com a mensagem “Hello, World”: clique sobre ele e pressione Delete (ou Del) no teclado.

Estes são os widgets de que vamos precisar (todos ficam na categoria Widgets da Palette – veja sua localização na Figura 1.49): • Um TextView contendo uma mensagem informativa (“Informe sua altura em metros:”) • Um SeekBar, que será usado para especificar a altura em metros, bastando para isso deslizar seu botão com o dedo.

• Um segundo TextView logo abaixo do SeekBar, que exibirá o valor correspondente à posição do SeekBar. • Um Button, que ao ser tocado realizará a conversão.

• Um último TextView, onde será exibida a altura convertida em pés.

Figura 1.49 – Widgets necessários para o aplicativo Conversor.

Clique sobre o TextView (Figura 1.49) com o botão esquerdo do mouse, mantenha-o pressionado e arraste o widget para o centro da tela.

Note que, quando você tiver posicionado o widget no ponto central da tela, o Android Studio mostrará uma linha vertical tracejada para sua orientação.

Quando você soltar o TextView na tela, poderá ver pela aba Component Tree (a pequena janelinha no canto inferior esquerdo do Android Studio) que o TextView está contido dentro do ConstraintLayout, de uma maneira hierárquica (Figura 1.50):

54

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.50 – Exibição da hierarquia de widgets da tela no Component Tree.

COMPONENT TREE É SEU AMIGO! Janelinhas acessórias como o Component Tree costumam ser tratadas como os “renegados” das ferramentas de software – muita gente nem sabe que elas existem e costumam fechá-las assim que aparecem. Porém, espere! Neste caso aqui o Component Tree pode ser um grande aliado!

Muitas vezes, widgets podem sumir da tela ou ficar em locais onde é difícil clicar sobre eles para selecioná-los. Lembre-se nesse momento do Component Tree: com ele você “caçar” um widget perdido ou de difícil seleção!

Uma informação importantíssima de cada widget é seu Id (de identificador). Trata-se de um nome usado para identificá-lo dentro do layout e posteriormente acessá-lo via programação. Todo widget colocado na tela recebe um “id automático”, formado pelo seu tipo iniciado em letras minúsculas (por exemplo, TextView começa com textView, e Button com button); novos widgets de um tipo já existente recebem um nome desse tipo seguido por um número. Um jeito fácil de descobrir o Id de um widget é visualizá-lo no Component Tree: o seu Id é aquele mostrado ao lado do seu ícone.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

55

Também é possível mudar o Id de um widget na tela. Isso é particularmente interessante quando temos mais de um widget do mesmo tipo na tela (como dois ou mais TextView, por exemplo) e precisamos diferenciá-los depois no código. Vamos fazer isso daqui a pouco para os dois TextView que mostrarão a altura em metros e depois em pés.

Antes de adicionar o próximo widget (o SeekBar), vamos trocar o texto que é exibido no TextView para algo mais informativo que simplesmente “TextView”. Para isso, vamos trocar o conteúdo da sua propriedade text (Texto).

Clique sobre ele para selecioná-lo (se ainda não estiver selecionado). Quando estamos montando um layout, no lado direito do Android Studio fica a janela de propriedades (Properties – Figura 1.51). Ela mostra os atributos (ou seja, as configurações) do widget atualmente selecionado. Localize a propriedade text e mude seu valor para “Informe sua altura em metros:”, como mostrado na Figura 1.51.

Figura 1.51 – Mudando a propriedade text.

ATENÇÃO: Não é a propriedade text com o desenho de uma “chave de fenda” à esquerda. É a outra!

56

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Depois de digitar o texto e pressionar Enter, você verá o texto atualizado aparecendo no widget. Para que o texto exibido fique maior, altere a propriedade textSize, existente dentro da propriedade textAppearance, para 24sp.

Feitas essas mudanças, você deve ter percebido que o texto não está mais alinhado no centro da tela. Para colocá-lo de novo no centro, arraste-o para o meio da tela até que a linha tracejada vertical apareça.

Para garantir que o texto fique sempre centralizado, não importando o tamanho da tela do aparelho onde o app execute, precisamos acrescentar as restrições de posicionamento. Elas podem ser adicionadas aos widgets manualmente ou de forma automática – o Android Studio “deduz” as configurações com base na posição do widget. Vamos usar essa forma, que é mais rápida e prática e funciona bem na maioria dos casos.

Clique sobre o TextView para garantir que o mesmo esteja selecionado. Na barra de ferramentas logo acima do layout de tela, clique sobre o botão Infer Constraints, como indicado na Figura 1.52:

Figura 1.52 – Adicionando as restrições de posicionamento automaticamente.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

57

IMPORTANTE: A partir de agora, nos projetos em que utilizar o ConstraintLayout (como este do Conversor), sempre clique no botão Infer Constraints logo depois de posicionar um novo widget no layout. Vamos omitir esta etapa nos outros widgets do projeto atual para economizar papel e ajudar o meio ambiente, mas não se esqueça de que é preciso repeti-la para cada um deles!

Acrescente agora o SeekBar, posicionando-o logo abaixo do TextView. Arraste as alças azuis da direita de maneira que ele ocupe um espaço horizontal um pouco maior que o do texto. Se tiver dúvida com relação ao tamanho, oriente-se pela Figura 1.41.

Após terminar de redimensioná-lo, certifique-se de alinhá-lo no centro antes de clicar no botão Infer Constraints.

Para exibir a medida em metros escolhida pela movimentação do SeekBar, precisaremos de um novo TextView. Arraste um TextView para logo abaixo do SeekBar e procure colocá-lo também no centro da tela. Em seguida, mude sua propriedade text para “0,00 m”, textSize (dentro de textAppearance) para 20sp e textStyle em negrito clicando sobre a letra “B” (novamente, veja a Figura 1.41 para se orientar como ele deve ficar visualmente).

Quando o usuário movimentar a “bolinha” do SeekBar, vamos, por meio da programação em Java, exibir o valor correspondente à sua posição neste TextView de tamanho médio que acabamos de inserir. Por isso, seria interessante mudar seu ID, de algo genérico como textView2 para algo mais significativo. Uma boa ideia de ID seria txtMetros – as primeiras três letras minúsculas indicam seu tipo (TextView), e a segunda parte, seu conteúdo!

Para trocar o ID, selecione o widget e localize a propriedade ID no topo da aba Properties (Figura 1.53).

Agora podemos passar aos próximos widgets, colocando-os na sequência indicada pela Figura 1.54. No caso dos outros TextView e Button, assim que posicioná-los, modifique sua propriedade text para exibir o texto mostrado na Figura 1.54.

Coloque o último widget, um TextView, que exibirá a altura convertida em pés, logo abaixo do Button, alinhado à esquerda deste. Para que ele fique como na Figura 1.54, configure suas propriedades da seguinte forma: text para 0,00 pé(s); textSize em 20sp e textColor (ambos visíveis após clicar na setinha do lado esquerdo de textAppearance) para @android:color/holo_blue_dark. Não deixe também de definir o ID deste último TextView para txtPes (assim mesmo, sem acento no “e”).

58

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Figura 1.53 – Mudando o ID de um widget.

Figura 1.54 – Tela do aplicativo com todos os widgets posicionados.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

59

Pronto! Com isso, completamos a interface da tela do nosso programa. Alternando para a exibição do código XML do arquivo (clicando na aba Text, localizada na parte inferior da tela, abaixo do Component Tree), ele deve estar semelhante ao da listagem 1.1 (não se preocupe se não ficar totalmente igual):

 Listagem 1.1: código do arquivo activity_main.xml <?xml version="1.0" encoding="utf-8"?> <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context="net.querino.conversorfinal.MainActivity">

<TextView android:id="@+id/textView" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="42dp" android:text="Informe sua altura em metros:" android:textSize="24sp" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" tools:layout_constraintLeft_creator="1" tools:layout_constraintRight_creator="1" tools:layout_constraintTop_creator="1" />

<SeekBar android:id="@+id/seekBar" android:layout_width="0dp" android:layout_height="33dp" android:layout_marginEnd="20dp" android:layout_marginLeft="20dp" android:layout_marginRight="20dp" android:layout_marginStart="20dp"

60

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

android:layout_marginTop="101dp" android:max="220" android:progress="183" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" tools:layout_constraintLeft_creator="1" tools:layout_constraintRight_creator="1" tools:layout_constraintTop_creator="1" />

<TextView android:id="@+id/textView2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="36dp" android:text="0,00 m." android:textSize="20sp" android:textStyle="bold" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toBottomOf="@+id/seekBar" tools:layout_constraintLeft_creator="1" tools:layout_constraintRight_creator="1" tools:layout_constraintTop_creator="1" />

<Button android:id="@+id/button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Converter" android:layout_marginLeft="55dp" app:layout_constraintLeft_toLeftOf="parent" android:layout_marginStart="55dp" app:layout_constraintBaseline_toBaselineOf="@+id/txtPes" tools:layout_constraintBaseline_creator="1" />

<TextView android:id="@+id/txtPes"

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

61

android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginLeft="23dp" android:layout_marginStart="23dp" android:layout_marginTop="29dp" android:text="0,00 pé(s)" android:textColor="@android:color/holo_blue_dark" android:textSize="20sp" app:layout_constraintLeft_toRightOf="@+id/button" app:layout_constraintTop_toBottomOf="@+id/textView2" tools:layout_constraintLeft_creator="1" tools:layout_constraintTop_creator="1" /> </android.support.constraint.ConstraintLayout>

Como nos diria o mestre chinês do kung fu: agora, pequenos gafanhotos, vocês estão prontos para entrar no caminho que os levará à sabedoria plena na arte da programação em Android – escrever código em Java!

1.4.3 Escrevendo o código Java Em uma linguagem de programação orientada a objetos como Java, as classes e os objetos são os blocos fundamentais que constroem um aplicativo. É neles que escrevemos o código que vai fazer o programa “funcionar”.

Vamos ver uma explicação mais detalhada sobre eles no capítulo 3. Por enquanto, você pode já ficar sabendo que, no Android SDK, a tela de um aplicativo é representada por uma classe especial denominada Activity.

Outro recurso legal que uma linguagem como Java possui é você reutilizar facilmente algo que já foi feito, evitando ter de “reinventar a roda”. Por exemplo, você não precisa ter de criar uma janela de um aplicativo do zero, partindo de detalhes tão complexos como o processo de desenhá-la na tela etc. Os caras do Google já fizeram isso para você, criando a classe Activity e suas “primas”, como a AppCompatActivity, que oferece recursos de compatibilidade com versões mais antigas do Android.

Para se beneficiar dessa janela em branco que já existe, basta você reutilizar a Activity ou a AppCompatActivity que eles criaram, usando-a como base para sua janela personalizada. Fazemos isso criando uma nova classe que herda as características da Activity original.

62

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Assim, a sua tela já nasce sabendo como pelo menos “aparecer” para o usuário!

Basta agora você customizá-la.

Já começamos a fazer isso na seção anterior, quando definimos o layout da tela no arquivo activity_main.xml. Porém, esse arquivo não contém a “alma” da tela, ou seja, aquilo que ela pode fazer, mas somente o que ela apresenta. Deveremos definir o que ela pode fazer diretamente na classe que controla a tela, que se chama MainActivity.

Pois bem, vamos ver de perto essa tal Activity. Abra a sua MainActivity clicando duas vezes sobre o arquivo indicado na Figura 1.55 (a aba Project, que lhe permite explorar o conteúdo do seu projeto, fica localizada à esquerda no Android Studio).

Figura 1.55 – Localização do arquivo MainActivity.java dentro do projeto.

A pasta java é onde ficam os arquivos com código Java (as classes) do seu projeto.

Como é possível ter muitos arquivos (muitas classes) em um mesmo projeto, estes são organizados em pacotes. No exemplo da Figura 1.55, o arquivo está dentro do pacote net.querino.conversor. No seu caso, o pacote pode ser esse mesmo ou qualquer outro que você definiu ao criar o projeto (veja a seção 1.4.1).

Clique duas vezes sobre o arquivo MainActivity.java para abri-lo no editor de código do Android Studio (a parte central da janela). O conteúdo inicial do arquivo deve ser semelhante ao da listagem 1.2 (as linhas de comando começadas com import podem estar originalmente ocultas; para exibi-las clique no sinal de adição ( + ) existente à esquerda do comando).

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

63

 Listagem 1.2: código do arquivo MainActivity.java 1 package net.querino.conversor; 2 import android.support.v7.app.AppCompatActivity; 3 import android.os.Bundle; 4 public class MainActivity extends AppCompatActivity { 5 @Override 6 protected void onCreate(Bundle savedInstanceState) { 7 super.onCreate(savedInstanceState); 8 setContentView(R.layout.activity_main); 9 } 10 }

Antes de mudá-lo para o que precisamos, vamos analisar este “esqueleto” inicial da Activity: • Linha 1: O arquivo começa com a definição do pacote ao qual a classe pertence.

Um pacote em Java é um grupo de classes. Quando criamos um aplicativo em Java, as classes do nosso projeto devem pertencer a um pacote, e este é definido no momento da criação do projeto. Neste caso, indicamos que a classe pertence ao package (pacote) net.querino.conversor. No seu caso, o pacote mostrado aqui será aquele definido na criação do projeto.

• Linhas 2 e 3: Estas linhas contêm comandos import do Java, que indicam os nomes (e os respectivos pacotes) de outras classes usadas dentro desta classe. São de certa forma semelhantes aos include de linguagem C. Repare que, para economizar espaço na tela, o Android Studio inicialmente oculta os imports. Para exibir todos, como na Listagem 1.2, clique sobre o sinal de + existente à esquerda do primeiro import.

• Linha 4: aqui começa nossa unidade básica de código em Java – a classe. Esta linha declara e abre a classe MainActivity, indicando que esta é pública (public – falaremos mais sobre isso no capítulo 3) e herda (extends) as características básicas de outra classe preexistente, denominada simplesmente AppCompatActivity. Como veremos também no capítulo 3 (você já deve estar curioso em relação a ele neste momento...), a herança é uma das principais vantagens da programação orientada a objetos. Com ela, podemos reutilizar facilmente algo que já foi programado antes. Neste exemplo, vamos reutilizar a tela “básica” de um aplicativo Android, criada pelos próprios engenheiros do Google, que serve de modelo inicial para

64

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

todas as demais. Esta classe é a classe Activity, e ela pertence ao pacote android. support.v7.app – ou seja, já veio pronta no Android SDK para você usar. Como vamos reutilizá-la, você pode notar que seu “nome completo” (formado pelo nome do seu pacote seguido de um ponto e o nome da classe) está especificado em um import na linha 2. A chave no final da linha indica o início da classe. Ela só termina com a outra chave de fechamento, existente na linha 10.

• Linhas 5 a 9: aqui é definido o primeiro método desta classe. Um método em Java é semelhante a uma função de linguagem C – ele é criado para “fazer” algo e pode (ou não) retornar um valor ao ser executado. A anotação (annotation em inglês) @Override na linha 5 indica que estamos reescrevendo este método. O que isso quer dizer? Bem, trata-se de um método preexistente na nossa superclasse (também chamada classe-pai ou classe-mãe – bom, você entendeu o que eu quis dizer...), a AppCompatActivity. Como herdamos AppCompatActivity, já recebemos dela este método. No entanto, agora vamos criar uma nova versão dele, para que possamos fazer algo diferente e específico com nossa tela. Na linha 6 é definido o nome deste método: onCreate(). Traduzindo seu nome literalmente, temos algo como “na criação” – isso indica o momento em que este método será executado: na criação da tela. Este é um tipo de método especial, associado a um evento. Um evento é algum tipo de ação que acontece no aplicativo, muitas vezes associado ao que o usuário fez.

O comando super na linha 7 chama o onCreate() da superclasse, que serve para começar o processo de elaboração da tela. Já na linha 8, algo muito importante: é graças ao comando setContentView() que a tela “mostra” o layout que definimos no arquivo activity_main.xml. Sem esta linha a classe MainActivity e o layout em XML de activity_main.xml estariam totalmente desconectados e a tela seria mostrada em branco, sem nenhum widget... Aí seria muito sem graça o programinha, concorda?

Se você deixasse este arquivo dessa forma e o executasse, já poderia ver a tela principal do programa, mas nada funcionaria. Para dar vida ao aplicativo, precisamos escrever nosso próprio código e fazer algumas mudanças.

Modifique seu arquivo MainActivity.java de acordo com a listagem 1.3.

 Listagem 1.3: código do arquivo MainActivity.java 1 package net.querino.conversor; 2 import android.os.Bundle; 3 import android.support.v7.app.AppCompatActivity;

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

4 import 5 import 6 import 7 import

android.view.View; android.widget.Button; android.widget.SeekBar; android.widget.TextView;

8 import java.util.Locale; 9 public class MainActivity extends AppCompatActivity { 10 int alturaEmCentimetros = 0; 11 @Override 12 protected void onCreate(Bundle savedInstanceState) { 13 super.onCreate(savedInstanceState); 14 setContentView(R.layout.activity_main); 15 final TextView txtMetros = (TextView) findViewById(R.id.txtMetros); 16 final TextView txtPes = (TextView) findViewById(R.id.txtPes); 17 final SeekBar seekBar = (SeekBar)findViewById(R.id.seekBar); 18 seekBar.setMax(230); 19 seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() { 20 @Override 21 public void onStopTrackingTouch(SeekBar seekBar) { 22 } 23 @Override 24 public void onStartTrackingTouch(SeekBar seekBar) { 25 txtPes.setText("Toque em Converter"); 26 } 27 @Override 28 public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { 29 alturaEmCentimetros = progress; 30 String texto = formataValorComDoisDigitos(progress / 100.0); 31 texto += " m."; 32 txtMetros.setText(texto); 33 } 34 }); 35 final Button button = (Button)findViewById(R.id.button); 36 button1.setOnClickListener(new View.OnClickListener() { 37 @Override

65

66

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

38 public void onClick(View v) { 39 double alturaEmPes = alturaEmCentimetros / 30.48; 40 String texto = formataValorComDoisDigitos(alturaEmPes); 41 texto += " pé(s)"; 42 txtPes.setText(texto); 43 } 44 }); 45 } 46 private String formataValorComDoisDigitos(double valor) { 47 return String.format(Locale.FRANCE, "%.2f", valor); 48 } 49 }

Vamos analisar por partes o que estamos fazendo aqui.

• Linhas 2 e 3: o comando import da linguagem Java é semelhante ao #include de linguagem C. Ele serve para “importar” no arquivo atual outro arquivo (melhor dizendo: importar na classe atual uma outra classe) que utilizaremos dentro do código. Nestas duas linhas estamos importando as classes Bundle e AppCompatActivity. A primeira é usada como parâmetro do evento onCreate (linha 12), enquanto a segunda é a superclasse da nossa tela, denominada MainActivity (veja linha 9).

• Linhas 4 a 7: esta sucessão de imports disponibiliza em nosso código o uso direto das classes View, Button, SeekBar e TextView. São classes existentes no Android SDK (repare que seu pacote começa com android) e que são usadas para representar, dentro do código Java, os widgets na tela.

• Linha 8: neste caso, estamos importando a classe Locale, existente no pacote java.util e que serve para obtermos informações sobre configurações regionais (como formatos numéricos de diferentes países). Seu uso será explicado na linha 47.

• Linha 10: declaramos uma variável básica do tipo int (o mesmo tipo int de linguagem C), denominada alturaEmCentimetros, a qual vai guardar o valor definido pelo usuário quando movimentar o SeekBar. Armazenamos o valor em centímetros, e não diretamente em metros, pois o valor definido pelo movimento da “bolinha” do SeekBar é um número inteiro. Para obter o valor em metros, basta então dividir por cem. Outro detalhe importante: declarando a variável neste ponto, estamos fazendo com que a mesma seja global dentro da classe. Assim, todo e qualquer método declarado dentro da classe terá acesso à variável.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

67

• Linhas 15 e 16: estamos agora dentro do evento onCreate() – aquele que será disparado automaticamente no momento da criação da tela. Por mais incrível que possa parecer, a maior parte do código do nosso aplicativo ficará aqui dentro!

Começamos declarando dois objetos da classe TextView: txtMetros e txtPes. Estes dois objetos, variáveis locais do método onCreate(), serão “amarrados” aos respectivos TextViews da tela, que exibem o valor em metros e em pés. Após estas linhas, sempre que usarmos txtMetros ou txtPes no código Java, estaremos nos referindo aos respectivos widgets do XML. Essas linhas são tão importantes que merecem até receber um box explicativo só para elas... Lá vai:

A (INICIALMENTE INEXISTENTE) RELAÇÃO ENTRE WIDGETS NO XML E NO CÓDIGO JAVA Prepare-se para o choque: widgets colocados na interface por meio do arquivo XML não estão diretamente acessíveis no código Java! Para quem vem do Visual C#, ou até mesmo do Swing com Java desktop, isso realmente é meio chocante. Porém, nem tudo está perdido! Nesses momentos, o método findViewById() da Activity e a classe R.java vêm para nos salvar.

Basta usar o método findViewById(), passando para ele o Id do widget na tela, que ele “magicamente” nos devolve uma referência ao widget.

Armazenando esta referência em uma variável local do código Java, passamos então a acessar o objeto na tela. Fácil, não é mesmo?

Porém, preste atenção aos detalhes: o Id que deve ser passado para findViewById() tem de ser especificado usando o prefixo R.id . Por exemplo, para localizar o widget com Id txtMetros, não podemos usar findViewById(txtMetros), mas sim findViewById(R.id.txtMetros). Existe uma classe Java escondida no seu projeto, denominada simplesmente R; ela é gerada automaticamente toda vez que você compila seu projeto. Dentro dela há uma série de constantes Java (as linhas iniciadas com public static final) que possuem como nome o Id do widget e um valor atribuído a elas. É por meio desse valor que o Android SDK consegue “localizar” o widget no XML e disponibilizar o acesso a ele no código Java.

Parece confuso? Mas não é, não. Apenas lembre-se de que, sempre que precisar acessar um widget existente na interface em XML pelo código Java, deverá usar o findViewById(). Ele é um dos melhores amigos do programador Android!

68

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

• Linhas 15 e 16 (de novo!): estas linhas são realmente tão importantes que precisamos falar mais sobre elas! Notou o final no início de cada linha? Trata-se de uma palavra-chave do Java usada na declaração de variáveis e que determina que esta não poderá mais ser modificada após sua atribuição inicial. Nós a usamos aqui para garantir que os métodos que serão disparados na interação do usuário com os widgets (quando ele move o SeekBar, por exemplo) tenham acesso a esses mesmos valores, e não a algo acidentalmente atribuído a mesma variável em outro momento. Basicamente, é um requisito para poder acessar os widgets dentro dos métodos dos eventos. Outro detalhe: o TextView entre parênteses existente antes de findViewById() está lá para fazer um casting. Um casting faz com que um tipo genérico seja tratado de forma mais específica. Isso acontece porque o findViewById() pode ser usado para “achar” qualquer tipo de widget na tela. E, no Android, todo widget colocado na tela é descendente de uma “mãe comum”, a classe android.view.View. Huuummm, eu acho que precisaremos de mais um box explicativo...

A DINASTIA DAS VIEWS DO ANDROID Uma das principais características (e vantagens) da POO (Programação Orientada a Objetos – não confunda com a famosa e tão exercida POG, Programação Orientada a Gambiarras) é a herança de código. Isso significa que os elementos básicos em um programa orientado a objetos, as classes, podem herdar outras classes, recebendo automaticamente seus mesmos atributos e métodos. Isso facilita a reutilização do código!

Percebendo que os elementos existentes em uma tela (os widgets) compartilhariam características em comum, os engenheiros de software da Google sabiamente os elaboraram seguindo uma hierarquia de herança. No topo da árvore, está a “classe mãe de todos os widgets”, a View (veja na Figura 1.56).

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

Figura 1.56 – “Árvore genealógica” (parcial) das views do Android.

Uma View é basicamente qualquer espaço delimitado em uma tela do Android. Inicialmente vazio, o conteúdo específico de uma View será determinado pelas suas subclasses, ou suas “classes-filhas”.

Como a View é a classe-mãe, suas características passam automaticamente para todas as suas “filhas” e consequentemente “netas”, “bisnetas”, “tataranetas” etc. Isso significa que um TextView é uma view, assim como um Button também é! Aliás, como podemos ver na Figura 1.56, além de ser uma View, um Button também é um TextView. Outra curiosidade: os widgets containers, como RelativeLayout e LinearLayout, também são subclasses de View – afinal de contas, eles são espaços delimitados em uma tela que possuem a função adicional de agrupar elementos colocados dentro deles, assim como o ConstraintLayout, que não “coube” no gráfico, mas também é subclasse de View e ViewGroup!

E o que isso tudo tem a ver com os findViewById() das linhas 15, 16 e 17 do código? Bem, este método serve para retornar qualquer tipo de elemento existente na tela. Como qualquer elemento existente na tela, seja ele um Button, seja um TextView, é necessariamente uma View, faz total sentido o retorno desse método ser mais genérico que específico, não é mesmo?

69

70

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

• Linha 17: aqui fazemos também um findViewById() para obter uma referência ao SeekBar, a barra deslizante que será usada para a definição da altura em metros.

O SeekBar é um widget diferente dos usados nas linhas anteriores (TextView), mas o conceito é o mesmo: a variável local seekBar será uma referência a R.id.seekBar, colocado na interface. Como todo SeekBar é uma View, o findViewById() também funciona para “encontrá-lo na selva do layout XML”. LEMBRE-SE: estamos criando estas referências no código para os widgets da interface em XML porque precisaremos acessar e modificar suas propriedades (como o Text dos TextView) como objetos Java!

• Linha 18: nesta linha, com o método setMax(230), configuramos o valor máximo possível na escala do SeekBar. A escala de um SeekBar começa em 0 e vai até o valor (inteiro) especificado aqui (no caso, 230). Por que este valor de 230? Como a escala do SeekBar é inteira, ele vai, na realidade, medir a altura em centímetros.

Apenas na hora de mostrar o valor ao usuário é que será exibido em metros.

Para mostrar o valor em metros, basta “pegar” a posição atual do SeekBar e dividi-la por 100! Obviamente, nosso pequeno app tem um bug para usuários gigantes: quem medir mais de 2,30 metros ficará de fora...

• Linha 19: definimos aqui um listener para o SeekBar. Um listener é um objeto que vai ficar “escutando” por um evento que pode acontecer a um widget. Neste caso, estamos definindo um SeekBarChangeListener, que ficará monitorando por mudanças no SeekBar, ou seja, quando o seu botão for deslizado pelo usuário. Ele pode detectar (e fazer algo) em três eventos básicos: onStartTrackingTouch, quando o usuário começa a deslizar o botão da barra; onStopTrackingTouch, quando para de deslizar o botão da barra; e onProgressChanged, que ocorre em qualquer ocasião onde o progresso da barra for modificado – ou seja, sempre que o botão for movido. Basta implementar SeekBarChangeListener e os métodos relativos a esses eventos para conseguirmos fazer a SeekBar trabalhar a nosso favor! E é justamente isso que começamos a fazer aqui.

Começamos a implementação do SeekBarChangeListener nesta linha e finalizamos na linha 34. É importante saber que essa implementação é feita por meio do uso de um poderoso recurso da linguagem Java, que são as classes internas anônimas.

Sem entrar em muitos detalhes, trata-se basicamente de uma forma rápida e prática de se escrever uma segunda classe dentro de uma primeira.

• Linhas 20 a 22: o método do evento onStopTrackingToch() está vazio. Isso acontece porque, neste caso, não precisamos fazer nada de diferente quando o usuário parar de mover o botão da SeekBar. Porém, mesmo vazio, ele precisa ficar aqui declarado, pois se você removê-lo vai receber um “puxão de orelha” do compilador Java ao executar o projeto...

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

71

• Linhas 23 a 26: a implementação de onStartTrackingTouch() serve para, assim que o usuário começar a mover o botão deslizante do SeekBar, exibir a mensagem "Toque em Converter" em txtPes (o TextView logo abaixo do botão), indicando que o valor correspondente em pés será calculado quando o usuário tocar no botão com o rótulo Converter.

• Linhas 27 a 33: aqui fica o evento mais importante (pelo menos em nosso caso) do SeekBar, o onProgressChanged(). Ele será executado sempre que o botão deslizante for movido, ocasionando, consequentemente, uma mudança no progresso do SeekBar (que, como vimos, vai de 0 a 230, de acordo com a posição do botão). Esse método é o que podemos chamar de “um cara gente fina”: além de disparado automaticamente, traz de presente uma variável contendo o progresso atual por meio do seu parâmetro progress, do tipo int (veja a linha 28). Isso quer dizer que dentro do método podemos usar esta variável para saber a medida atualmente selecionada pelo usuário. Na linha 29, aproveitamos a deixa e guardamos o valor de progress na variável global da classe, alturaEmCentimetros, pois é exatamente o que precisaremos saber quando o usuário tocar no botão Converter.

Em seguida, na linha 30, chamamos o método formataValorComDoisDigitos (implementado nas linhas 46 a 48), passando a ele o valor de progress dividido por 100, obtendo então a altura em metros. Como você verá na explicação das linhas 46 a 48, o método retorna uma String relativa ao valor, sempre com duas casas decimais (assim, 1,8 será mostrado como 1,80, por exemplo), e que fica armazenada como texto. Para ficar ainda mais informativo, concatenamos “m.” à String, na linha 31. E, finalmente, na linha 32, exibimos a string texto em txtMetros (o TextView existente abaixo da barra), por meio do seu método setText().

• Linha 34: nesta linha, fechamos a implementação do listener, iniciada na linha 19.

• Linha 35: assim como fizemos nas linhas 15, 16 e 17, “laçamos” agora com findViewById() o botão R.id.button1 na interface em XML, para que possamos programar o que acontece quando ele é clicado (melhor dizendo, tocado, mas a tradição do evento onClick na programação de sistemas desktop acabou “contaminando” os aplicativos móveis...).

• Linhas 36 a 44: mais um listener para a nossa coleção, só que agora se trata do mais famoso de todos os eventos em programação visual (conheço até uma empresa batizada com o nome dele) – aquele que é disparado quando um widget (neste caso, um botão) é tocado (clicado), o onClickListener! A implementação desse listener abrange apenas a programação do método onClick(), que é efetivamente disparado quando o usuário tocar no botão. Começamos, na linha 39, fazendo

72

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

a conversão de centímetros para pés, e armazenando o resultado na variável alturaEmPes, do tipo double. Em seguida, na linha 40, convertemos o valor de alturaEmPes para String, adequado para colocação em um TextView, e que fica guardado em texto. Veja que, assim como acontece no evento onProgressChanged() do SeekBar, também usamos o método formataValorComDoisDigitos, definido nas linhas 46 a 48, para deixar o número com duas casas decimais fixas. Adicionamos à string texto o valor “pé(s)” na linha 41 e, finalmente, na linha 42, colocamos texto no TextView txtPes (aquele logo abaixo do botão), para que o usuário veja o resultado. A linha 44 encerra a definição do onClickListener, iniciada na linha 36.

• Linhas 46 a 48: nestas linhas é definido o método formataValorComDoisDigitos, que usamos nos eventos onProgressChanged() e onClick(). A palavra-chave private, existente no início da linha 46, indica que esse método é privado, ou seja, pertence à classe MainActivity e só pode ser usado dentro dela. O String logo em seguida indica o tipo de retorno do nosso método. Você também vê na linha 46 que, assim como as funções de linguagem C, este método recebe um parâmetro do tipo double, denominado valor – trata-se do número que será convertido para String e formatado para duas casas decimais. Existem várias maneiras de fazer essa formatação em Java. Uma delas é por meio da classe DecimalFormat, mas o método format da classe String quebra bem o galho nesse caso. Na linha 47 passamos a ele três parâmetros: um Locale do Java, indicando um país que use o padrão de separador de casas decimais igual ao nosso (a vírgula – no caso, como não temos um Locale para o Brasil, usamos o da França); uma String como máscara da formatação, que deve seguir o mesmo padrão da usada no comando printf() de linguagem C – no caso, estamos formatando um valor real com duas casas (%.2f); e, por fim, o número que será formatado: o parâmetro valor passado ao método formatarValorComDoisDigitos. O método String.format retorna então a String formatada, que é, por sua vez, devolvida ao “chamador” do nosso método com return.

Pronto! Agora é só ver como o nosso “mini-app” ficou!

1.4.4 Testando no emulador Temos um aplicativo, temos um emulador com um dispositivo virtual configurado e temos curiosidade para ver como esse app funciona! Por isso, vamos executá-lo!

Para isso, clique no botão Run da barra de ferramentas do Android Studio, como mostrado na Figura 1.57.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

73

Figura 1.57 – Executando o projeto.

Quando executamos um projeto no Android Studio é exibida uma janela onde devemos escolher em qual dispositivo virtual do emulador (AVD, Android Virtual Device) queremos que o projeto seja executado. Selecione aquele que criamos anteriormente (ou qualquer outro da sua preferência) e clique em OK, como indicado na Figura 1.58.

Figura 1.58 – Especificando em qual dispositivo o aplicativo será executado.

74

Desenvolvendo seu primeiro aplicativo Android – 2ª edição

Seu aplicativo será então compilado e um arquivo com a extensão .apk será gerado – trata-se de um arquivo binário pronto para ser instalado e executado em um dispositivo Android. Este arquivo será automaticamente instalado pelo Android Studio no emulador.

Em alguns segundos, você deverá visualizar seu aplicativo em execução no emulador, como mostra a Figura 1.59. Se for a primeira vez que você está abrindo o emulador e seu computador for “meio antigo”, o processo de inicialização do Android pode demorar um pouquinho...

Figura 1.59 – O aplicativo Conversor em execução no emulador.

Caso ocorra algum erro, confira seu código com relação ao apresentado nas listagens. Se mesmo sem erros o programa insistir em não aparecer, clique novamente sobre o botão Run e aguarde – pode ser que o Android Studio não tenha conseguido instalar o aplicativo no emulador na primeira tentativa.

Capítulo 1 ■ Prepare-se para se render ao robozinho verde do Google!

75

1.5 E agora? Para onde vamos?

Como poderemos incrementar nosso modesto aplicativo de conversão?

Bem, você neste momento já deve ter pensado em várias formas de melhorá-lo... Uma delas pode ser feita bem facilmente: Que tal aproveitar o evento onProgressChanged() e “matar dois coelhos com uma cajadada só” (é apenas um provérbio, hein, sociedade protetora dos animais...)? Como assim?

Além de usar este evento para atualizar a visualização da medida em centímetros no TextView, podemos perfeitamente fazer a conversão diretamente nele! Ou seja, em vez de acioná-la no click do Button, você pode colocar o código referente à conversão e exibição do texto no mesmo onProgressChanged(), que exibe o valor da medida em centímetros escolhida. Dessa forma, assim que o usuário deslizar o dedo pelo SeekBar, aparecerá a mesma medida em centímetros e polegadas simultaneamente!

Tente realizar essa mudança sozinho, enquanto nos aquecemos para, enfim, começar a nossa sensacional calculadora – este é o tema do próximo capítulo.