desenvolvendo seu primeiro aplicativo android

Luiz Carlos Querino Filho

Novatec

© Novatec Editora Ltda. [2014].

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 PratesCapa: Carolina KuwabataRevisão gramatical: Marta Almeida de SáEditoração eletrônica: Carolina Kuwabata

ISBN: 978-85-7522-378-9

Histórico de impressões:

Dezembro/2013 Primeira edição

Novatec Editora Ltda.Rua Luís Antônio dos Santos 11002460-000 – São Paulo, SP – BrasilTel.: +55 11 2959-6529Fax: +55 11 2950-8869Email: [email protected]: www.novatec.com.brTwitter: twitter.com/novateceditoraFacebook: facebook.com/novatecLinkedIn: linkedin.com/in/novatecXXXX

15

capítulo 1Prepare-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 home-nagem aos célebres R2-D2 e C3PO de Guerra nas Estrelas? Ou um reconhe-cimento 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 atenta às inovações que surgiam ao seu redor, percebeu que mui-tas 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 ope-racional que, assim como o Windows, dominaria seu segmento de mercado...

1.1 Uma breve história do sistema operacional AndroidEm 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.

Desenvolvendo seu primeiro aplicativo Android16

Inicialmente, parecia que o Google seria uma espécie de parceira 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.

Mas 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 Google...

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 deci-sã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, a Google anunciou a criação da Open Handset Alliance, uma associação encabeçada por ela que contava com a participação de “peixes grandes” do mercado de dispositivos móveis, como Motorola, Samsung e HTC.

Nas palavras da própria 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 ope-racional Android, que equiparia uma nova geração de telefones celulares, os 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 her-daria o pedigree deste, oferecendo estabilidade e segurança aos usuários. Para completar, seguiria a mesmo filosofia aberta (baseada no conceito de software livre/open source) do Linux: estaria disponível livremente, podendo ser usado simultaneamente por 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.

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

Isso, obviamente, se deve a vários fatores, como a evidente qualidade do siste-ma 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 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 2013, o índice Tiobe apontava Java como a segunda 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 desen-volver aplicativos para Android. E isso realmente aconteceu: especialis-tas estimam que, em janeiro de 2013, mais de 800 mil aplicativos para Android estavam disponíveis na Google Play Store e que em breve seria alcançada a marca de 1 milhão de programas, de acordo com as fontes: www.rssphone.com/google-play-store-800000-apps-and-overtake-apple-appstore/ e readwrite.com/2013/01/08/google-play-to-hit-1-million-apps-before-apple-app-store.

Quer mais uma prova do domínio do Android? O IDC informa que, no primeiro quadrimestre de 2013, o Android possuía 75% 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 www.idc.com/getdoc.jsp?containerId=prUS24108913).

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 mer-cado? E o melhor: você pode começar a criar seus aplicativos Android agora: 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?


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

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 elaboração deste livro, a versão mais recente do Android é a 4.3, codi-nome “Jelly Bean” – que conta com muitos recursos e avanços gráficos que não existiam inicialmente. A versão 4.4, chamada KitKat, também está prestes a ser lançada.

Uma curiosidade: as versões do Android, desde a 1.5, passaram a rece-ber 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. Neste livro, usaremos a versão 4.3, a "Jelly Bean" – jelly bean é como os norte-americanos chamam as nossas "gominhas" ou "jujubas".

Em outubro de 2013 chega a versão 4.4, com a sequência alfabética na letra K, e adequadamente batizada de “KitKat” (o famoso chocolatinho com wafer em barras da Nestlé).


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 7: 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 SDK (Software Development Kit): Este “pacotão” traz os outros dois elementos que, junto do JDK, completam o “quebra-cabeça” dos recursos necessários para criar aplicativos para o sistema operacional do robô: o ambiente de desenvolvimento integrado Eclipse e as bibliotecas de classes Java específicas do Android (entre outros arquivos, como utilitários e documentaçã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 elabo-ração de um software, como edição, compilação e depuração. O Eclipse é um dos mais famosos e usados IDEs para Java.

O Google, com o intuito de facilitar cada vez mais a criação de aplicativos para o Android, criou uma versão customizada do Eclipse, denominada Eclipse ADT, com recursos exclusivos para criação de software para seu sis-tema 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: é justamente este Eclipse ADT que está incluso no Android SDK, 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 "pa-drão" e acrescentar o suporte ao Android posteriormente – nada muito trabalhoso, mas com certeza mais um empecilho na hora de se conquistar usuários inexperientes para a plataforma...


Além do Eclipse e das bibliotecas do Android, o SDK traz também um recurso indispensável: um emulador do Android. Com ele, você pode testar seus aplicativos em qualquer versão do Android já disponibilizada, sem a necessidade de ter um aparelho físico com o sistema. 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 SDK, são apresentados em um computador com o sistema operacional Windows 7 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 pode 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.

1.2.1 Baixando e instalando o Java JDKÉ muito provável que você já tenha o JRE (Java Runtime Environment) na sua máquina. Ele possibilita a execução de aplicativos Java. Muitos sites e aplicativos fazem uso dele. Porém, a não ser que você já tenha pro-gramado em Java no 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 na Oracle:

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

A versão mais atualizada do JDK, no momento da finalização deste livro, era a 7u45. Isso indica que estamos usando o Java na sua versão 7, com a atualização número 45. 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.

Figura 1.2 – Site para download do Java JDK.

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).

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


Escolha a versão adequada ao seu sistema operacional. Para alguns siste-mas operacionais (como o Windows), existe a opção de baixar a versão 32 bits ou a 64 bits. Se você sabe que seu Windows executa em 64 bits, baixe a versão correspondente do JDK. Na dúvida, clique na versão de 32 bits.

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

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.

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

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


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

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

Por isso, o pacote do Android SDK é significativamente maior que o do Java JDK. Mas não se preocupe: ele já vem com tudo de 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 desen-volvimento em Android: o site oficial de desenvolvedores Android do Google! Além do SDK, aqui você encontra notícias, tutoriais e a docu-mentaçã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 Get the SDK (Obtenha o SDK), como mostrado na figura 1.6.


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

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

Antes de o download começar, você deverá concordar com os termos do Google e escolher se deseja a versão de 32 ou 64 bits. Se você baixou o JDK 64 bits, marque esta opção. Caso contrário, escolha 32 bits. Finalmente, clique sobre o botão Download the SDK ADT Bundle... (Figura 1.8).

Terminado o download do Android SDK, você terá um arquivo denomi-nado adt-bundle-<sistema-operacional>-<data-da-versão>.zip.

Para deixar tudo organizado, abra sua pasta pessoal no seu sistema ope-racional, crie nela uma subpasta denominada Developer e descompacte o arquivo baixado dentro dela.

Na figura 1.9, por exemplo, eu criei a pasta Developer dentro da pasta do usuário atual (Anita). Copiei o arquivo baixado para dentro dela e vou iniciar o processo de descompactação clicando com o botão direito do mouse sobre ele e selecionando Extrair Tudo....


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

Figura 1.8 – Iniciando o download do Android SDK.


Figura 1.9 – Iniciando a descompactação do arquivo com o Android SDK.

Na janela que será aberta, indique que o conteúdo deverá ser extraído para a pasta C:\Users\<seu-usuario>\Developer (em sistemas Windows – se você usa Mac OS X ou Linux, será, respectivamente, /Users/<seu-usuario> ou /home/<seu-usuario>), como no exemplo da figura 1.10 (onde o usuário em questão é “Anita”), e clique sobre o botão Extrair.

Figura 1.10 – Descompactando o arquivo.


SE O SEU SISTEMA OPERACIONAL FOR MAC OS X OU LINUX...

... não tema! Todos os procedimentos descritos neste livro serão os mesmos, no que diz respeito ao uso do Android SDK, Eclipse e código Java. Isso é uma das grandes vantagens do uso da linguagem Java – totalmente multiplataforma – no Android!

Após descompactar, você encontrará dentro da nova pasta adt-bundle-<sistema-operacional>-<data-da-versão> duas subpastas: sdk e eclipse. A pasta sdk contém as bibliotecas e os utilitários básicos do Android SDK. A pasta eclipse possui a versão do IDE Eclipse customizada para desenvolvimento em Android, prontinha para ser usada.

Para executar o Eclipse ADT (Android Developer Tools), você pode sim-plesmente clicar duas vezes sobre o ícone do aplicativo Eclipse (Figura 1.11).

Figura 1.11 – Aplicativo Eclipse.

Como vamos usá-lo bastante, recomendo a você criar um atalho para ele na sua área de trabalho. Para fazer isso rapidamente, clique com o botão direito do mouse sobre o arquivo eclipse.exe, segure e arraste para a área de trabalho. Ao soltar, selecione a opção Criar atalho aqui.

Já abriu o Eclipse? Se ainda não, vá em frente! Vamos encarar a fera.


1.3 Executando o Eclipse pela primeira vezO Eclipse é uma das mais populares ferramentas de desenvolvimento para a linguagem Java – segundo seus fãs, a mais popular (algo ainda contestado pelos entusiastas do NetBeans...).

Provavelmente por esse fato, além da característica de ser open-source e de distribuição livre, acabou sendo escolhido pelo Google como a ferramenta oficial de desenvolvimento para o Android.

Na realidade, o Eclipse distribuído junto do Android SDK é uma versão customizada desse IDE, contendo funcionalidades específicas para o de-senvolvimento de aplicativos Android. Essa versão acabou sendo chamada pelo Google de Eclipse ADT (Android Developer Tools). Porém isso não significa que você não poderá desenvolver aplicativos Java padrão nele – essa possibilidade continua presente.

1.3.1 Definindo o workspace do Eclipse e as configurações iniciaisQuando abrimos o Eclipse pela primeira vez, ele solicita um caminho para armazenamento dos seus projetos, que ele chama de workspace (Figura 1.12).

Figura 1.12 – Definindo o worskpace para o Eclipse.

Escolha um local de sua preferência. Pode ser dentro da pasta Developer, que foi criada anteriormente na sua pasta pessoal, ou pode ser em Documentos – você decide. Se quiser, não precisa também chamá-la necessariamente de workspace – pode ser simplesmente Projetos.


IMPORTANTE: Evite ao máximo colocar seu workspace de projetos em um caminho 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 projetos.

Se não marcar a opção Use this as the default..., toda vez que você iniciar o Eclipse, precisará confirmar o local do workspace. Por isso, deixe-a mar-cada, como na figura 1.12. Se precisar mudar o workspace futuramente, basta trocá-lo nas Preferências (pelo menu Windows > Preferences) do Eclipse.

Após clicar em OK, o Eclipse continuará seu carregamento. Pode ser que seja apresentada uma tela solicitando a autorização do envio de estatística de uso ao Google, com o título Contribute Usage Statistics?. Se você concordar, deixando Yes marcado, o Eclipse ADT enviará periodicamente dados de uso da ferramenta ao Google, visando melhorá-la futuramente (Figura 1.13). Basta então clicar em Finish.

Figura 1.13 – Confirmando o envio (ou não) de estatísticas de uso ao Google.

Após alguns segundos, será apresentada a tela da figura 1.14.


Figura 1.14 – Tela de boas-vindas do Eclipse.

É apenas uma tela de boas-vindas, com algumas dicas de como criar seu primeiro projeto. Você não precisa dela – já tem este livro para isso! Basta clicar no ícone de X indicado na figura 1.14, para exibir a tela principal do Eclipse.

1.3.2 A perspectiva padrão do EclipseO Eclipse chama o conjunto de elementos que compõem sua tela de perspective (perspectiva). Como ele atualmente dá suporte a várias lin-guagens além de Java, e é usado para diversas outras finalidades além de edição de código (infelizmente, ele não faz café – pelo menos ainda não), uma perspectiva configura a tela do Eclipse de acordo com a linguagem/plataforma/função ativa no momento.

O desenvolvimento para Android usa a perspectiva padrão do Eclipse, denominada Java (sim, é a mesma usada na criação de aplicativos Java tradicionais). Você pode ter uma ideia de como é essa perspectiva pela figura 1.15.

Nessa perspectiva, a tela é dividida basicamente em:

(a) Barra de ferramentas: com os botões usados para criar projetos, salvar, executar aplicativos, entre outros.

(b) Package Explorer: o “explorador de pacotes” mostra os projetos exis-tentes no workspace e o que eles contêm.

(c) Editor de código: é aqui que vamos fazer o que mais gostamos – pro-gramar!


(d) Outline: um “resumo” da estrutura do arquivo-fonte aberto no editor à esquerda. Basicamente, um recurso para você localizar rapida-mente elementos do código, como um método.

(e) Problems: ninguém gosta de problemas, mas uma hora eles apare-cem. É aqui que vamos localizá-los. Existe uma frase que diz que há apenas duas certezas na vida de uma pessoa: os impostos e a morte. Podemos acrescentar encontrar bugs em software a essa lista...

Figura 1.15 – A perspectiva Java do Eclipse.

Bem, já temos agora uma ideia da cara do Eclipse. Antes de criar nosso primeiro projeto, vamos apenas configurar alguns aspectos dele para facilitar nossa vida.

1.3.3 Configurando o EclipseAs configurações básicas do Eclipse podem ser acessadas nas versões Win-dows e Linux do aplicativo, pelo menu Window > Preferences. No Mac OS X, elas estão no menu ADT, à direita da maçã da Apple.


Se tem algo que o Eclipse oferece bastante mesmo são opções de confi-guração, como você pode perceber pela figura 1.16. Nessa mesma figura, você vai ver uma opção que, ao ser marcada, facilita muito a vida do desenvolvedor na incansável busca por bugs!

Figura 1.16 – Configurações do Eclipse.

Abra as chaves de configuração General > Editors, nesta ordem. Dentro de Editors, clique sobre Text Editors. Nas opções que são apresentadas, localize Show line numbers e marque-a (Figura 1.16), clicando em seguida no botão Apply. Dessa forma, na tela de edição de código do Eclipse, serão exibidos os números das linhas, o que ajuda na hora de localizar os erros do programa.

Antes de fechar a janela de preferências, dê uma olhada nestas outras duas chaves de configuração e tente lembrar-se delas – elas podem ser úteis futuramente:


• General > Startup and shutdown > Workspaces: aqui você pode mudar o local em que o Eclipse guarda os projetos – o workspace, lembra?

• General > Appearance > Colors and Fonts: abrindo esta chave e depois, à direita, clicando duas vezes sobre Basic > Text font, você pode mudar a fonte base do editor de código. Mas lembre-se: todo bom progra-mador só usa fontes de largura fixa para o código! Por isso, nada de Arial ou Helvetica. Prefira Consolas, Menlo ou, na pior das hipóteses, Courier New...

• Android: contém as configurações específicas para desenvolvimento em Android. Clicando sobre a chave principal (“Android”), existe a opção de configuração do caminho para o SDK. Se por alguma razão o Eclipse ADT não fez essa configuração automaticamente para você, é possível defini-la manualmente aqui.

Para poder testar o programa que vamos criar, precisaremos do emulador. E, 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 em um “dispositivo virtual do Android”, um AVD (Android Virtual Device).

1.3.4 Criando um dispositivo virtual para o emuladorOs 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 Eclipse (Figura 1.17):

Figura 1.17 – Ícone do Android Virtual Device Manager.


Clicando no botão indicado, será aberta uma janela que lista 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), vista na figura 1.18.

Figura 1.18 – Tela do Android Virtual Device Manager.

Em uma instalação nova do Android SDK, você ainda não possui nenhum AVD criado. Então vá em frente: clique sobre o botão New... para fazê-lo (Figura 1.18)!

Na tela de configuração do novo AVD (Figura 1.19), você deverá definir alguns aspectos importantes, que vão facilitar o desenvolvimento do seu aplicativo.

As principais configurações que você deve fazer são as seguintes:

(a) AVD Name: um nome para o dispositivo virtual. Pode ser qualquer um – neste exemplo, usamos somente avd.


(b) Device: aqui você pode definir um modelo de aparelho, que servirá apenas como base para teste do tamanho da tela e da resolução usada. Não se espante pelo fato de serem poucos os aparelhos mostrados aqui – trata-se apenas de uma referência para um tipo de tela. Neste exemplo, usamos o modelo Nexus One, principalmente por trazer um tamanho de tela médio (3.7 polegadas), semelhante ao de muitos aparelhos existentes no mercado (que ficam entre 3.5 e 4 polegadas). Depois falaremos mais sobre como seus aplicativos ficarão compatíveis com aparelhos com tela e/ou resolução diferente. Não se preocupe com isso no momento.

Figura 1.19 – Criando um novo Android Virtual Device (AVD).


(c) Target: Escolha a versão mais recente disponível: Android 4.2.2 API Level 17, Android 4.3 API Level 18, ou posterior. No exemplo da figura 1.19, escolhemos Android 4.3. Isso indica que o dispositivo virtual criado executará na versão aqui especificada. Para poder usar outra versão, você precisa ter baixado a imagem da mesma usando o aplicativo SDK Manager. Mas relaxe: você pode testar o seu aplicativo na versão mais recente (que sempre vem junto do pa-cote do Android SDK) e mesmo assim garantir que o seu aplicativo funcione em versões anteriores. Também falaremos mais sobre isso posteriormente.

(d) Keyboard: certifique-se de deixar ativada a opção Hardware keyboard present. Com ela ativa, você poderá usar o teclado físico do seu computador para digitar texto no aplicativo, sem necessidade de recorrer ao teclado virtual do aparelho.

(e) Emulation options: marque a opção Snapshot. Por meio dela, seu emu-lador ficará sempre “congelado” no estado em que foi usado pela última vez (de maneira semelhante ao que acontece com aplicati-vos de virtualização). Se você não marcá-lo, toda vez que iniciar o emulador deverá esperar o longo e tedioso “boot” do Android... Dependendo do computador usado, pode dar tempo de fazer um café e até deixá-lo esfriar antes de beber, o que irrita qualquer programador...

Clicando no botão OK, seu novíssimo AVD será criado (Figura 1.20)! É praticamente um aparelho novinho para você testar (sem, é claro, possi-bilidade de fazer chamadas ou receber SMS de promoções da operadora – o que é uma grande vantagem)!

Figura 1.20 – Tela do AVD Manager com o novo dispositivo virtual criado.


Pode fechar a janela do AVD Manager agora. Finalmente, estamos com tudo pronto para criar nosso aplicativo de teste!

1.4 Testando tudo com um exemplo prático: conversor de medidasO sistema métrico é o padrão de unidades de medida em praticamente todo o 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...

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 resig-nar (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. Mas 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) 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 um teste inicial para verificar que a casa está em ordem, e para aprendermos os conceitos mais básicos do desenvolvimento para Android. Mas 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), onde 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. Vai ficar razoavelmente interessante, como você pode ver na figura 1.21.


Figura 1.21 – Tela final do aplicativo Conversor.

1.4.1 Criação do projeto no EclipsePara criar o projeto no Eclipse, na barra de ferramentas, clique sobre a seta para baixo no lado direito do primeiro botão (Figura 1.22). No menu que será exibido, selecione Android Application Project.

Figura 1.22 – Criando o novo projeto no Eclipse.

Será exibida a primeira tela do processo de criação de um novo projeto (Figura 1.23).

Nessa tela, fazemos várias configurações importantes sobre o projeto:

(a) Application Name: o nome do aplicativo, que será mostrado na lista de programas instalados no aparelho e na Google Play Store. Para este exemplo, informe Conversor.


Figura 1.23 – Tela inicial da criação de um novo projeto Android.

(b) Project Name: o nome do projeto dentro do Eclipse. Geralmente, usa-mos o mesmo nome do aplicativo (Conversor). Você vai perceber que o Eclipse colocará aqui o mesmo nome informado em Application Name.

(c) Package Name: o nome do pacote das classes Java do seu projeto. Basicamente, um pacote em Java é uma forma de categorizar cor-retamente 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.23 que usei meu domínio particular (querino.net) invertido (net.querino) seguido de um ponto e o 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 na Google Play Store (se você 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).

(d) Minimum Required SDK: mantenha selecionado API 8: Android 2.2 (Froyo). Essa configuração especifica a versão mínima do Android necessá-ria para que seu programa funcione. Marcando a 2.2, temos duas consequências: uma muito boa (seu aplicativo vai funcionar na esmagadora maioria dos aparelhos existentes no mercado, já que muitos deles ainda executam o Android 2.2 ou 2.3) e uma não tão boa assim (somente poderemos usar no aplicativo recursos que já existiam desde essa versão, ou seja, nada feito para funções inova-doras acrescentadas nas versões mais recentes, como a Jelly Bean). Mas isso não é tão ruim quanto parece, e vai por mim: se o seu interesse é alcançar a maior quantidade possível de usuários, vale a pena manter Android 2.2 nesta configuração!

(e) Target SDK: deixe marcada a versão sugerida (API 18: Android 4.3 (Jelly Bean), no exemplo) ou uma versão mais recente (caso disponível), como a KitKat. Isso indica que, apesar de manter compatibilidade com as versões >= 2.2 (você é um programador, então com certeza leu isso como “maior ou igual a”...), vamos testar nosso aplicativo com a versão mais recente. Sem entrar em muitos detalhes, isso quer dizer o seguinte: apesar de o seu aplicativo funcionar em versões anteriores, vai rodar legalzinho e sem “modo de compatibilidade” na versão mais recente, que equipa os smartphones Android mais poderosos e novos do mercado. Bom isso, não é mesmo?

(f) Compile With: também mantenha o recomendado pelo assistente de criação do projeto (API 18: Android 4.3 (Jelly Bean)). Isso indica que o seu aplicativo será compilado com a versão mais atual do SDK, o que é uma boa ideia, pois traz melhorias e correções que as versões anteriores não têm. Mas não entre em pânico: a retrocompatibili-dade com versões mais antigas está garantida pela seleção feita em Minimum Required SDK!


(g) Theme: Finalmente, o tema que será usado pelo aplicativo. O tema estabelece o “visual padrão” do programa: suas cores, suas fontes, seus tamanhos, o aspecto dos botões e demais controles etc. Deixe Holo Light with Dark Action Bar marcado, pois é o tema padrão das novas versões do Android.

NOTA SOBRE A VERSÃO 4.3

A versão 4.3 é uma atualização menor do Android e foi lançada pela Google em 24 de julho de 2013. Possui pequenas melhorias e correções em relação à versão anterior (4.2.2), sem nenhuma mudança muito significativa. No decorrer deste livro, manteremos o uso da 4.2 como "Target" dos projetos e a 4.3 em "Compile With", mas sinta-se à vonta-de para usar uma versão mais recente (se disponível). Como a área de computação móvel é a atual “menina dos olhos” do setor de TI e sua evolução está aceleradíssima, pode ser que uma versão ainda mais nova que a 4.3 já esteja em uso quando você estiver lendo este parágrafo (e tudo indica que o Android 4.4 KitKat será ela)...

Finalmente, clique em Next para passar à próxima tela. Nela (Figura 1.24), indicaremos se desejamos definir um ícone personalizado para o aplicativo (a – Create custom launcher icon, não para este caso) e se queremos que uma primeira tela seja criada para o programa (b – Create activity, sim, pode deixar marcada).

As demais opções podem ser mantidas como estão. Clique em Next para passar à tela seguinte.

Como indicamos na tela da figura 1.24 que queremos uma tela inicial neste projeto (com a opção Create activity), devemos especificar na tela da figura 1.25 que tipo de tela será esta.

Existem três opções iniciais:

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

• Fullscreen Activity: essa opção permite a criação de uma tela com bar-ra de navegação e/ou ferramentas e que possa ocupar a tela toda quando o usuário interagir com seu conteúdo.


• Master/detail Activity: este tipo de tela apresenta uma lista de opções à esquerda e quando um dos itens é selecionado mostra um conteúdo diferente à direita. É ideal para uso em dispositivos com tela maior, como tablets.

Figura 1.24 – Segunda tela de criação do projeto.

Como indicado na figura 1.25, deixe a caixa Create Activity marcada, com a opção Blank Activity selecionada logo abaixo. Clique em Next.

Finalmente, passamos à última tela (Figura 1.26).

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.

(c) Navigation Type: mantenha None (nenhum), pois criaremos um apli-cativo com uma única tela. Se estivéssemos criando um programa com mais de uma tela, poderíamos especificar aqui uma forma para a navegação entre as várias telas.

Figura 1.25 – Terceira tela de criação do projeto.


Figura 1.26 – Tela final de criação de um novo projeto Android.

MAS O QUE É ESSA TAL ACTIVITY?

O Android SDK fornece a classe Java Activity como a base para a im-plementaçã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 úni-ca tela possui uma Activity só, como esse 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, aguardar uns segundinhos e ver como é um projeto Android recém-criado!


Na figura 1.27 você pode ter uma ideia do aspecto do Eclipse com um novo projeto Android.

Figura 1.27 – Eclipse com um novo projeto.

São estes os elementos aos quais você deve estar atento:

(a) Package Explorer: aqui você vai encontrar seu projeto (Conversor) e as pastas que o compõem. Por enquanto, nós vamos nos preocupar com apenas duas: src, que contém o código-fonte Java do aplicativo, e res\layout, onde fica o arquivo com XML para o layout da tela.

(b) activity_main.xml: esta aba mostra a interface atual da nossa tela, dentro do editor de interface. Repare bem neste nome: estamos com o arquivo activity_main.xml aberto, e este fica dentro da pasta layout, que por sua vez está dentro de res!

(c) Pallete: a palheta contém os vários “widgets” que colocamos na tela do nosso aplicativo Android. Os mais usados estão nos grupos Form Widgets (que contêm rótulos de texto e botões) e Text Fields (onde ficam os campos de entrada de texto).


(d) Graphical Layout | activity_main.xml: aqui você pode alternar entre a visualização gráfica da tela (onde nós estamos no momento e po-demos simplesmente arrastar os widgets para algum local na tela) e a visualização do arquivo em XML, onde caras durões e corajosos, do tipo Chuck Norris, preferem editar a interface. Obviamente, os acréscimos e mudanças feitos em um refletem diretamente no outro. Como nós não queremos arrumar encrenca pra cabeça e queremos maximizar nossa produtividade, vamos usar o layout gráfico sempre que possível.

(e) Outline: uma visualização hierárquica dos widgets existentes na tela. Podemos ver por ele que temos na nossa tela um RelativeLayout e, dentro dele, um TextView (falaremos mais sobre estes widgets em breve).

(f) Properties: aqui podem ser vistas e alteradas as configurações do widget atualmente selecionado. Quem conhece o Visual Studio, NetBeans ou o próprio Eclipse com o plugin WindowBuilder ins-talado já conhece estas famosas janelinhas.

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 você achando que se tratava de alguma criatura de um RPG ou de Guerra nas Estrelas...

1.4.2 Começando pela interface: muito além do simples arrastar e soltarVocê pode perceber pela tela da figura 1.27 que estamos com o arquivo activity_main.xml aberto. Este é o arquivo que contém a definição da in-terface 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.).


Como estamos começando, vamos editar o layout do nosso aplicativo diretamente pelo editor visual, sem mexer (por enquanto) no código XML.

Inicie removendo o rótulo de texto estático (um widget do tipo TextView) que exibe o texto “Hello world!” na tela existente: clique sobre ele para selecioná-lo e pressione a tecla delete.

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)... Como é um “costume mundial”, os en-genheiros do Android SDK colocaram a mensagem exibida por padrão nas telas iniciais dos aplicativos novos criados dentro do Eclipse. 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!

Estes são os widgets de que vamos precisar (todos ficam na categoria Form Widgets da Palette – veja sua localização na figura 1.28):

• UmTextView de tamanho Médio (Medium), contendo uma mensagem informativa.

• UmSeekBar, que será usado para especificar a altura em metros, bastando para isso deslizar seu botão com o dedo.

• UmsegundoTextView de tamanho Médio (Medium), logo abaixo do SeekBar, que exibirá o valor correspondente à posição do SeekBar.

• UmButton, que, ao ser tocado, realizará a conversão.

• UmúltimoTextView, só que agora Grande (Large), onde será exibida a altura convertida em pés.


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

Comece removendo o TextView pequeno com a mensagem “Hello world”: clique sobre ele e pressione Delete (ou Del) no teclado.

Clique sobre o TextView Medium (Figura 1.28) com o botão esquerdo do mouse, mantenha-o pressionado e arraste o widget para o canto superior esquerdo da tela (deixe um pequeno espaço à direita e à esquerda).

Note que, à medida que você move o widget pela tela, o Eclipse mostra linhas de guia para que você se oriente com relação ao posicionamento do objeto.

Isso acontece pois estamos usando um widget container, que serve para agrupar um conjunto de outros widgets dentro dele de alguma maneira específica. Estes containers são chamados gerenciadores de layout. Esta-mos usando o “default” em uma tela do Android, o RelativeLayout (layout relativo). Ele estabelece que todo elemento na tela é posicionado em relação a algum outro. Isso facilita a organização e ajuda na adaptação para tamanhos de tela diferentes.

Quando você soltar o TextView na tela, poderá ver pelo Outline (a pequena janelinha no canto superior direito do Eclipse) que o TextView está contido no RelativeLayout, de uma maneira hierárquica (Figura 1.29):


Figura 1.29 – Exibição da hierarquia de widgets da tela no Outline.

OUTLINE, MAS NÃO OUTLAW (FORA DA LEI)

Janelinhas acessórias como o Outline costumam ser tratadas como os “renegados” das ferramentas de software – muita gente nem sabe que eles existem e costumam fechá-los assim que aparecem. Mas espere! Neste caso aqui, o Outline 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 Outline: com ele você pode ser usado para “caçar” um widget perdido ou de difícil seleção!

Uma informação importantíssima de cada widget é seu Id (de identifi-cador). 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 mi-núsculas (por exemplo, TextView começa com textView, e Button com button) seguido por um número. Um jeito fácil de descobrir o Id de um widget é visualizá-lo no Outline: o seu Id é aquele mostrado ao lado do seu ícone.

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 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 “Medium Text”... Para isso, vamos trocar o conteúdo da sua propriedade Text (Texto).

Clique sobre ele para selecioná-lo (se ainda não estiver selecionado). No canto inferior direito do Eclipse, fica a janela de propriedades (Properties – Figura 1.30). 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.30.

Figura 1.30 – Mudando a propriedade Text.

DICA: Você pode acessar as propriedades mais comuns de um widget clicando com o botão direito do mouse sobre ele! Em alguns casos, esse procedimento é ainda mais fácil que usar a janela Properties.


Depois de digitar o texto e pressionar Enter, você verá o texto atualizado aparecendo no widget.

Acrescente agora o SeekBar, posicionando-o logo abaixo do TextView.

Para exibir a medida em metros escolhida pela movimentação do SeekBar, precisaremos de um novo TextView. Arraste um TextView Medium para logo abaixo do SeekBar e procure colocá-lo no centro da tela. Em seguida, mude sua propriedade Text para “0,00 m” (veja a figura 1.32 para se orientar).

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!

O melhor e mais rápido jeito de mudar o Id é clicar com o botão direito do mouse sobre o widget e selecionar Edit ID no menu. Será exibida a tela da figura 1.31, onde você pode digitar o novo Id:

Figura 1.31 – Mudando o ID de um widget.

Agora podemos passar aos próximos widgets, colocando-os na sequência indicada pela figura 1.32. No caso dos outros TextView e Button, assim que posicioná-los, modifique sua propriedade Text para exibir o texto mos-trado na figura 1.32:


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

Coloque o último widget, um TextView Large que exibirá a altura conver-tida em pés, logo abaixo do Button, alinhado à esquerda deste. Preste atenção nas linhas verdes, que mostram a relação do alinhamento com outro widgets. Evite deixar este último TextView alinhado em relação ao TextView que exibe a altura em metros (txtMetros), para evitar surpresas no posicionamento.

Não deixe de definir o ID deste último TextView para txtPes, clicando com o botão direito sobre ele e selecionando Edit ID.

Pronto! Com isso, completamos a interface da tela do nosso programa. Al-ternando para a aba de exibição do código XML do arquivo (activity_main.xml), ele deve estar semelhante ao da listagem 1.1:


RELATIVELAYOUT: NÃO É FUTEBOL, MAS PODE SER UMA CAIXINHA DE SURPRESAS

Parece discurso de jogador de futebol no final do jogo, mas é a pura verdade: o utilíssimo RelativeLayout pode se tornar uma verdadeira “caixinha de surpresas” se você não souber utilizá-lo. Por quê?

Bem, como já vimos, esse tipo de layout posiciona um novo elemento em relação a outro já existente. Isso significa que seu posicionamento está diretamente relacionado ao posicionamento do anterior. Ou seja, ao mudar a posição de um elemento, todos aqueles que tiverem sua posição definida em relação a este serão reposicionados – e os resul-tados podem ser os mais variados (e esquisitos) possíveis...

Por isso, aí vai uma dica valiosa: procure primeiro rascunhar o seu layout antes de passá-lo para o arquivo XML e somente vá para o pró-ximo elemento quando definir com certeza onde ficará o atual – não deixe para reposicioná-lo depois.

Listagem 1.1: código do arquivo activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:paddingBottom="@dimen/activity_vertical_margin"

android:paddingLeft="@dimen/activity_horizontal_margin"

android:paddingRight="@dimen/activity_horizontal_margin"

android:paddingTop="@dimen/activity_vertical_margin"

tools:context=".MainActivity" >

<TextView

android:id="@+id/textView1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_alignParentLeft="true"

android:layout_alignParentTop="true"

android:layout_marginLeft="36dp"

android:layout_marginTop="34dp"

android:text="Informe sua altura em metros:"

android:textAppearance="?android:attr/textAppearanceMedium" />


E ESTES RETÂNGULOS AMARELOS PRÓXIMOS AOS WIDGETS E/OU ÀS LINHAS DO XML?

Não precisa entrar em pânico. Se estes ícones aparecem em widgets que exibem texto, ou nas linhas do XML relativas aos atributos android:text, eles simplesmente indicam que estamos definindo texto “hard-coded” para estes widgets e que esse valor será fixo, não se adaptando ao idioma do aparelho. Para conseguir essa tradução automática, o Android SDK recomenda que usemos strings em XML para especificar o texto que será exibido nos widgets. Essa abordagem facilita o processo de inter-nacionalização (sim, eu também acho isso um verdadeiro “palavrão”…) do app. Para saber mais sobre como fazer isso no seu aplicativo, acesse este endereço no site oficial dos desenvolvedores do Android: developer.android.com/guide/topics/resources/localization.html.

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 JavaEm uma linguagem de programação orientada a objetos como Java, as classes e os objetos são os blocos fundamentais que constroem um aplica-tivo. É 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 da Google já fizeram isso para você, criando a classe Activity!

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


Assim, a sua tela já nasce sabendo como pelo menos “aparecer” para o usuário! Basta agora você customizá-la.

Nós 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 cli-cando duas vezes sobre o arquivo indicado na figura 1.33 (o Package Explorer é a aba localizada à esquerda no Eclipse).

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

A pasta src é 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.33, 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 Eclipse (a parte central da janela). O conteúdo inicial do arquivo deve ser semelhante ao da listagem 1.2.


Listagem 1.2: código do arquivo MainActivity.java

1 package net.querino.conversor;

2 import android.os.Bundle;

3 import android.app.Activity;

4 import android.view.Menu;

5 public class MainActivity extends Activity {

6 @Override

7 protected void onCreate(Bundle savedInstanceState) {

8 super.onCreate(savedInstanceState);

9 setContentView(R.layout.activity_main);

10 }

11 @Override

12 public boolean onCreateOptionsMenu(Menu menu) {

13 //Inflatethemenu;thisaddsitemstotheactionbarifitispresent.

14 getMenuInflater().inflate(R.menu.main,menu);

15 return true;

16 }

17 }

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 a 4: 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 Eclipse oculta os imports, colocando apenas primeiro na tela do código. Para exibir todos, como na Listagem 1.2, clique sobre o sinal de + existente à esquerda do primeiro import.


• Linha 5: 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 Activity. Como veremos também no capítulo 3 (você já deve estar ficando 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 da Google, que serve de modelo inicial para todas as demais. Esta classe é a classe Activity, e ela pertence ao pacote android.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 – android.app.Activity) está especificado em um import na linha 3. A chave no final da linha indica o início da classe. Ela só termina com a outra chave, existente na linha 17.

• Linhas 6 a 10: aqui é definido o primeiro método desta classe. Um méto-do 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 6 indica que esta-mos 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 Activity. Como herdamos Activity, já recebemos dela este método. Mas agora vamos criar uma nova versão dele, para que possamos fazer algo diferente e específico com nossa tela. Na linha 7 é 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 associada ao que o usuário fez.

O comando super na linha 8 chama o onCreate() da superclasse, que serve para começar o processo de elaboração da tela. Já na linha 9, 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?

• Linhas 11 a 16: nestas linhas encontramos outro método criado auto-maticamente com a classe, o onCreateOptionsMenu(). Trata-se também de um evento, que é disparado quando o usuário pressiona a tecla de menu existente em certos modelos de aparelhos Android. Dentro dele, podemos definir os botões do menu que será apresentado na tela e suas respectivas ações. Como não possuiremos menu em nosso app Conversor, podemos tranquilamente excluir as linhas referentes a este método para deixar nosso código mais “enxuto”.

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 aplica-tivo, 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 java.util.Locale;

3 import android.os.Bundle;

4 import android.app.Activity;

5 import android.view.View;

6 import android.view.View.OnClickListener;

7 import android.widget.Button;

8 import android.widget.SeekBar;

9 import android.widget.SeekBar.OnSeekBarChangeListener;

10 import android.widget.TextView;

11 public class MainActivity extends Activity {

12 int alturaEmCentimetros = 0;

13 @Override

14 protected void onCreate(Bundle savedInstanceState) {

15 super.onCreate(savedInstanceState);

16 setContentView(R.layout.activity_main);


17 finalTextViewtxtMetros=(TextView)findViewById(R.id.txtMetros);

18 finalTextViewtxtPes=(TextView)findViewById(R.id.txtPes);

19 finalSeekBarseekBar1=(SeekBar)findViewById(R.id.seekBar1);

20 seekBar1.setMax(230);

21 seekBar1.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {

22 @Override

23 public void onStopTrackingTouch(SeekBar seekBar) {

24 }

25 @Override

26 public void onStartTrackingTouch(SeekBar seekBar) {

27 txtPes.setText("pé(s): toque em Converter");

28 }

29 @Override

30 public void onProgressChanged(SeekBar seekBar, int progress,

boolean fromUser) {

31 alturaEmCentimetros = progress;

32 String texto = formataValorComDoisDigitos(progress / 100.0);

33 texto += " m.";

34 txtMetros.setText(texto);

35 }

36 });

37 finalButtonbutton1=(Button)findViewById(R.id.button1);

38 button1.setOnClickListener(new OnClickListener() {

39 @Override

40 public void onClick(View v) {

41 double alturaEmPes = alturaEmCentimetros / 30.48;

42 String texto = formataValorComDoisDigitos(alturaEmPes);

43 texto += " pé(s)";

44 txtPes.setText(texto);

45 }

46 });

47 }

48 private String formataValorComDoisDigitos(double valor) {

49 return String.format(Locale.FRANCE, "%.2f", valor);

50 }

51 }


Vamos analisar por partes o que estamos fazendo aqui.

• Linha 2: 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. 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 49.

• Linhas 5 a 10: essa sucessão de imports disponibiliza em nosso código o uso direto das classes View, Button, SeekBar e TextView. São classes exis-tentes 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. Também importamos duas subclasses: uma de View (denominada OnClickListener) e outra de SeekBar (OnSeekBarChangeListener). Essas duas são classes especiais (na realidade, são interfaces em Java – uma espécie de “molde” para uma classe), usadas para que possamos programar eventos (ações) que acontecem com os widgets.

• Linha 12: 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. Armaze-namos 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.

• Linhas 17 e 18: 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, nós estaremos nos referindo


aos respectivos widgets do XML. Essas linhas são tão importantes que merecem até receber um box explicativo só pra 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 real-mente é meio chocante. Mas 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?

Mas 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). Por quê? Bem, se você é curioso, abra a pasta gen do seu projeto e clique duas vezes sobre a classe R.java, para abri-la. Lá dentro, você verá uma série de constantes Java (as linhas iniciadas com publicstaticfinal) 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 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!

• Linhas 17 e 18 (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 estes mes-mos 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 uma 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 sig-nifica 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) com-partilhariam 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.34).

Figura 1.34 – "Á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”, “tata-ranetas” etc. Isso significa que um TextView é uma view, assim como um Button também é! Aliás, como podemos ver na figura 1.34, 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 pos-suem a função adicional de agrupar elementos colocados dentro deles.

E o que isso tudo tem a ver com o findViewById() da linha 24 do código? Bem, este método serve para retornar qualquer tipo de elemento exis-tente 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 do que específico, não é mesmo?

• Linha 19: aqui fazemos também um findViewById() para obter uma refe-rê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 seekBar1 será uma referência a R.id.seekBar1, 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 20: 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 21: 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 co-meç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 36. É 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 22 a 24: 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 – se você removê-lo, vai receber um “puxão de orelha” do compilador Java ao executar o projeto...

• Linhas 25 a 28: 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 “pé(s): 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 29 a 35: 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 antes, 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 30). Isso quer dizer que dentro do método podemos usar esta variável para saber a me-dida atualmente selecionada pelo usuário. Na linha 31, aproveitamos a deixa e guardamos o valor de progress na variável global da classe, alturaEmCentimetros, pois é tudo que precisaremos quando o usuário tocar em Converter.

Em seguida, na linha 32, chamamos o método formataValorComDoisDigitos (implementado nas linhas 48 a 50), 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 48 a 50, 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 33. E, finalmente, na linha 34, exibimos a string texto em txtMetros (o TextView existente abaixo da barra), por meio do seu método setText().

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

• Linha 37: assim como fizemos nas linhas 17, 18 e 19, "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 38 a 46: mais um listener para a nossa coleção, só que agora se trata do mais famoso de todos (conheço até empresas batizadas com o nome desse evento) – aquele que é disparado quando um widget é 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 41, fazendo a conversão de centímetros para pés, e armazenando o resultado na variável alturaEmPes, do tipo double. Em seguida, na linha 42, convertemos o valor de alturaEmPes para String, adequado para co-locaçã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 48 a 50, para deixar o número com duas casas decimais fixas. Adicionamos à string texto o valor " pé(s)" na linha 43 e, finalmente, colocamos texto no TextView txtPes (aquele logo abaixo do botão), para que o usuário veja o resultado. A linha 46 encerra a definição do onClickListener, iniciada na linha 38.

• Linhas 48 a 50: nestas linhas é definido o método formataValorComDoisDigitos, que usamos nos eventos onProgressChanged() e onClick(). A palavra-chave private, existente no início da linha 48, indica que esse método é pri-vado, 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 48 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 49, 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 emuladorTemos uma aplicativo, temos um emulador com um dispositivo virtual configurado e temos curiosidade para ver como esse app funciona! Por isso, vamos executá-lo!


Clique sobre o nome do projeto no Project Explorer e depois no botão Run da barra de ferramentas do Eclipse, como mostrado na figura 1.35.

Figura 1.35 – Executando o projeto.

Quando executamos um projeto no Eclipse pela primeira vez, é exibida uma pequena janela questionando que tipo de aplicativo nós estamos compilando. Selecione Android Application e clique em OK, como indicado na figura 1.36.

Figura 1.36 – Especificando que o projeto será executado como um aplicativo Android.


Seu aplicativo será então compilado e um arquivo chamado Conversor.apk será gerado. Este arquivo será automaticamente instalado pelo Eclipse no emulador. Se você é curioso (como eu), pode encontrar este arquivo dentro da pasta do projeto, em uma subpasta chamada bin (de binário).

Em alguns segundos, você deverá visualizar seu aplicativo em execução no emulador, como mostra a figura 1.37. Se for a primeira vez que você está abrindo o emulador, o processo de inicialização do Android pode demorar um pouquinho...

Figura 1.37 – 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 Eclipse não tenha conseguido instalar o aplicativo no emulador na primeira tentativa.


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...)? Mas 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 dire-tamente 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 en-fim começar a nossa sensacional calculadora – este é o tema do próximo capítulo.

desenvolvendo seu primeiro aplicativo android

Documents