Introduo a Prograo Android

Por Carlos Silva e Pedro Veloso

(iterao 1)

Sobre
Este livro distribudo livremente sobre a licena Creative Commons AttributionShareAlike 3.0 Unported License .

Resumidamente este licena permite que o trabalho seja distribudo e reutilizado livremente. Caso existam trabalhos derivados deste, esses mesmos trabalhos devero ser tornados acessveis comunidade livremente. Este resumo no invalida a leitura da verso completa da licena, para tal consulte a pgina da licena referida em cima.

Autoria
Este livro fruto do trabalho conjunto de Carlos Silva e Pedro Veloso. Este trabalho ia inicialmente ser realizado com o intuito de produzir um livro para venda por uma editora, mas infelizmente o tempo dos autores no permitiu progredir conforme esperavam sendo que abandonamos essa modalidade e decidimos aproveitar o trabalho realizado e distribuir o mesmo livremente sem qualquer tipo de custo para benefcio de todos os potenciais interessados.

Dito isto, pedimos a compreenso do leitor sobre o facto de que este livro se encontra incompleto. Os primeiros 4 captulos sendo os essenciais encontram-se maioriatariemente completos. Os captulos 5 e 7 no se encontram completos nem revistos pelo que optamos pela sua excluso. No entanto no existe relao directa entre captulos a partir do 4 cap. pelo que o leitor poder tirar partido dos mesmo sem recear quebras de maior na linha de aprendizagem. Imagem da capa de autoria de Sara Lima.

Futuro e Donativos
Esta a 1 verso que tornamos disponvel ao pblico. Dependendo da recepo da mesma, da futura disponibilidade dos autores e/ou eventuais contribuies externas podero existir novas verses deste documento. Para tal consulte a pgina que os

autores dedicaram a esse propsito no frum androidPT.

Para ajudar os autores pondere fazer um donativo; consulte a pgina em cima para ver o impacto dos donativos. De momento os autores aceitam donativos na forma de Bitcoin para o seguinte endereo:

1GcxrHzcRGnxjYB4Liz1GbpiYaFTw9je3v
QR Code do endereo Bitcoint apresentado em cima

ndice
Sobre.................................................................................................................................... 2 Autoria .............................................................................................................................. 2 Futuro e Donativos ............................................................................................................ 3 Introduo plataforma Android .......................................................................................... 8 As Origens ........................................................................................................................ 8 Viso sucinta das vrias verses de Android .................................................................... 10 a. b. c. d. e. f. g. h. i. j. Android 1.0 ........................................................................................................... 10 Android 1.1 ........................................................................................................... 10 Android 1.5 ........................................................................................................... 10 Android 1.6 ........................................................................................................... 11 Android 2.0, 2.0.1, 2.1 .......................................................................................... 12 Android 2.2 ........................................................................................................... 13 Android 2.3, 2.3.1, 2.3.2, 2.3.3, 2.3.4, 2.3.5, 2.3.6, 2.3.7 ..................................... 14 Android 3.0, 3.1 e 3.2............................................................................................ 16 Android 4.0 ........................................................................................................... 18 Android 4.1 ........................................................................................................... 19

O que e o que no ..................................................................................................... 20 Componentes Base .......................................................................................................... 21 Fragmentao ................................................................................................................. 22 Instalao do eclipse ....................................................................................................... 23 Instalao do ADT ........................................................................................................... 24 Configurao do SDK....................................................................................................... 27 IntelliJ IDEA ..................................................................................................................... 27 MOTODEV Studio............................................................................................................. 28 2.6 Android Studio .......................................................................................................... 28

Android Debug Bridge ..................................................................................................... 30 DDMS .............................................................................................................................. 31 Emulador......................................................................................................................... 32 Outras ferramentas ......................................................................................................... 34 k. l. m. n. o. p. Draw 9-patch ......................................................................................................... 34 Hierarchy Viewer .................................................................................................... 34 Monkey............................................................................................................... 35 ProGuard ............................................................................................................... 35 Zipalign ................................................................................................................. 35 Outros ................................................................................................................... 35

Desenvolver para plataformas mveis.............................................................................. 36 Componentes aplicacionais de Android ........................................................................... 37 q. r. s. t. Activity .................................................................................................................. 38 Service ................................................................................................................... 38 Broadcast Receiver ................................................................................................. 38 Content Provider .................................................................................................... 38

Ciclo de vida de uma Activity ........................................................................................... 39 Gesto de recursos .......................................................................................................... 41 Android Manifest ............................................................................................................. 45 u. v. w. x. y. z. aa. Uses-permission .................................................................................................... 46 Permission ............................................................................................................. 46 Uses-sdk ............................................................................................................. 47 Uses-configuration ................................................................................................. 48 Uses-feature........................................................................................................... 48 Supports-screens ................................................................................................... 49 Application ......................................................................................................... 49

Classe application ........................................................................................................... 50 O que so views .............................................................................................................. 53

Layouts ........................................................................................................................... 54 Menus ............................................................................................................................. 63 Caixas de Dilogo ........................................................................................................... 71 bb. cc. dd. AlertDialog ......................................................................................................... 73 Progressdialog .................................................................................................... 78 CustomDialog ..................................................................................................... 80

Toasts e Notificaes ...................................................................................................... 82 Intents O que so e como utilizar ................................................................................. 87 Usar Intents de Sistema ................................................................................................... 89 Mais sobre Actions .......................................................................................................... 90 Intent Extras.................................................................................................................... 90 Notas Finais sobre Intents ............................................................................................... 93 Modelo De Segurana Aplicacional .................................................................................. 94 Permisses e Descrio ................................................................................................... 95 Assinar uma aplicao com um Certificado Digital ........................................................... 98

1
As Origens

Introduo plataforma Android

Neste primeiro captulo iremos falar um pouco da histria de como tudo comeou e o porqu da importncia do programador perceber sucintamente a evoluo da plataforma.

As origens primordiais da plataforma Android remetem para o ano de 2003. Nessa altura o conceito de smartphone era muito diferente do atual, o Symbian e o Windows CE eram as escolhas de eleio para qualquer fabricante que quisesse produzir dispositivos que encaixassem neste conceito de equipamento mvel. Inicialmente a plataforma foi desenvolvida pela Android Inc., sendo que aps 22 messes de existncia, em Agosto de 2005 a Google compra esta empresa e fica com todos os direitos de desenvolvimento da plataforma. A liderar esta empresa, e sendo tambm co-fundador da Danger Inc. estava um homem de nome Andy Rubin, cuja viso e talento demonstrados fizeram que aquando a compra a Google lhe atribusse a chefia da sua diviso mvel, posio na qual continua a ocupar at data presente. Em 2003 Andy Rubin falou de 2 pontos que viriam a ser fundamentais na estipulao das bases da plataforma: dispositivos que tirem proveito da localizao do utilizador para lhe oferecer informao de qualidade e agregao de informao de vrias tipos para melhor servir consumidores mais tecnologicamente informados. Desde essa data a Google tinha iniciado ento o desenvolvimento do Android, no entanto em Janeiro de 2007 um evento particular mudou a realidade do mercado radicalment1e, o aparecimento do primeiro iPhone. O iPhone e a genialidade de marketing da Apple trouxeram consigo uma mudana fundamental de mercado, fizeram com que o pblico em geral visse os Smarthphones como uma necessidade, sendo que at ento este tipo de dispositivos era quase que exclusivamente usados no contexto empresarial ou por pessoas com gosto por gadgets.

No entanto sua filosofia tal como tudo na Apple segue uma forma de controlo nica e centralizada, querendo isto dizer que s a Apple escolhe que fabricantes fabricam as peas do iPhone, s eles podem construir dispositivos com o seu sistema operativo, e aquando do aparecimento do mesmo outras limitaes existiam como o facto de s uma operadora nos Estados Unidos poder comercializar o mesmo. Ora, a Google no encarou isto como um desafio, mas sim como uma oportunidade. Qualquer limitao que um sistema concorrente tenha uma vantagem para um que no tenha essas mesmas limitaes. fcil de conceber a ideia de que com tantos fabricantes existentes no mercado global esta viso monopolista em que s 1 fabricante e 1 operador mvel podem oferecer algo deste teor e qualidade aos consumidores no vai de encontro aos seus planos de perdurar no mercado, sendo que algo teria de ser feito para acompanhar a nova varivel de mercado. Desta forma, em Novembro de 2007 a Google juntamente com 34 outros membros fundam a Open Handset Alliance (geralmente chamada pelo acrnimo OHA), com um objetivo muito claro: criar uma plataforma livre que permita qualquer fabricante/operadora produzir dispositivos e servios com capacidades avanadas num equipamento mvel, criando uma base uniforme e sobre standards da indstria que permitam a todos fabricar dispositivos que interajam bem com qualquer outro dispositivo independentemente da marca, modelo ou fabricante. A OHA tomou o Android, que foi ento liberadi livremente pela Google, como base para o seu desenvolvimento sendo que todos os membros da OHA contribuem para a gesto e melhoria da plataforma. Entre os membros fundadores esto, para alm da prpria Google, a HTC, Samsung Electronics, LG, Motorola, Sony, Texas Instruments, Marvell Technology, Nvidia Corporation, Intel Corporation, Qualcomm, Synaptics, entre outros grandes nomes da indstria. por isso que em qualquer dispositivo Android existente em comercializao hoje em dia, o cdigo fonte que deu origem a esse equipamento tem contribuies de todas essas marcas e mais algumas, sendo que presentemente a OHA conta com mais de 80 membros. Finalmente, a revoluo comea a ser aparente quando a 12 de Novembro de 2007 uma verso beta da SDK de Android lanada ao pblico, tendo-se tornado possvel a partir desse momento comear a aprender a programar para a mesma. No entanto o primeiro dispositivo comercial a ser lanado com Android s veria a luz do dia no ano seguinte, em Setembro de 20082.

Lanamento do HTC Dream, tambm conhecido por HTC G1.

Viso sucinta das vrias verses de Android

De modo a que o leitor compreenda de que funcionalidades de sistema pode usufruir, importante perceber quando que estas foram introduzidas na histria da plataforma Android. S desse modo consegue garantir agilmente qual a verso mnima de Android que a sua aplicao dever suportar. Nos captulos seguintes o leitor descobrir como possvel manter compatibilidade com dispositivos que possuem verses de Android mais antigas e que no possuem APIs necessrias de modo a usufruir de uma funcionalidade concreta mas no vital da sua aplicao, e como dinamizar e gerir todo esse processo. Para j, convidamos-lo a dar uma vista de olhos pelas verses existentes de Android, sendo que nem este texto compreende toda a informao necessria, nem o leitor precisar em instncia alguma de saber de cr esta informao. A mesma aqui apresentada como convenincia para quando se deparar com a necessidade de averiguar diferenas entre verses de Android.

a. Android 1.0 Nome de cdigo: A ndroid

Esta verso de Android foi distribuda aquando do incio da venda do HTC G1, o primeiro smartphone comercial com Android. A sua data de disponibilidade para o pblico portanto coincidente com a comercializao efetiva do dispositivo que teve lugar em Outubro de 2008.

b. Android 1.1 Nome de cdigo: Bender

Esta verso foi lanada como uma atualizao para o G1 a 9 de Fevereiro de 2009, embora poucos detalhes. Entre outras, trouxe a possibilidade de referenciao de bibliotecas externas no Manifest de Android, muitas correes sendo a maioria relativa ao cliente de correio electrnico e foi adicionado o suporte inicial para testes de JUnit nicos a Android.

c. Android 1.5 Nome de cdigo: C upcake

A verso Cupcake pode ser considerada um major release3, apesar da numerao parecer indicar o contrrio. Foi lanada em Abril de 2009, e teve 4 revises4 desde ento.

Entre as novidades destacam-se os seguintes pontos:

Gravao de Vdeo Upload de contedo para o Youtube e Picasa diretamente do dispositivo Novo teclado no ecr, com previso de texto Suporte para Bluetooth AD2P e suporte para AVRCP Novos widgets e pastas para popular o ambiente de trabalho Transies animadas Suporte extensivo para localizao de lngua de sistema, at aqui s existia Ingls e Alemo, sendo que passaram a ser suportadas mais de 20 lnguas oficialmente Suporte para dispositivos de densidades diferentes Muitas APIs melhoradas desde geo-localizao, mtodos de introduo, e framework visual

A ttulo de curiosidade, a partir desta verso os nomes de cdigo das verses de Android passaram a ser baseados de doces de culinria para alm da primeira letra seguir a ordem crescente do alfabeto.

d. Android 1.6 Nome de cdigo: D onut

A verso Donut constituiu uma minor release5, sendo que o seu foco principal foi a uniformizao e re-estruturao de algumas partes da framework visual, assim como correo de falhas presentes na verso anterior. Foi lanado em Setembro de 2009 e teve 3 revises desde ento.

Major Release: lanamento que constitui um aumento e alterao significativa da API face

existente 4 Uma reviso (revision) constitui correes a uma API existente, geralmente de teor de

segurana ou estabilidade. Numa reviso a API manten-se a mesma do ponto de vista do programador. 5 Minor Release: em contraste com a Major Release, uma minor release no constitui uma

mudana significativa da API

Entre as novidades destacam-se os seguintes pontos:

Android Market melhorado Aplicao da cmara e galeria melhoradas Introduo da procura por voz Suporte para CDMA/EVDO, 802.1x, VPNs e motor de texto-para-voz (TTS - Text-To-Speech) Suporte para ecrs com resoluo WVGA Melhorias de performance na cmara e aplicao de procura Suporte para Gestos no Ecr

e. Android 2.0, 2.0.1, 2.1 Nome de cdigo: E clair

A verso Eclair de Android foi uma major release, e a sua numerao foi um pouco confusa. O lanamento inicial foi em Outubro de 2009, sendo que s 1 dispositivo Android chegou oficialmente a ter esta verso do Eclair, o Motorola Droid, na altura a verso 2.0 do mesmo. A razo pela qual houveram outras verses Eclair prende-se com o produo do Nexus One, um dispositivo que iria ser comercializado pela Google e o qual j estava em desenvolvimento internamente na altura que o Motorola Droid foi lanado. Assim em Janeiro de 2010 surge o Nexus One que trouxe consigo a verso 2.1 do Eclair. Entre estas duas datas existiu ainda uma outra verso, a 2.0.1, que foi uma atualizao para o Motorola Droid, sendo que teve pouca relevncia no panorama global. J o mesmo no se pode dizer do Nexus One, cujo objetivo principal do telemvel no era tanto ser um sucesso de vendas mas sim elevar o patamar e criar um telemvel modelo sobre os quais os fabricantes se deveriam apoiar quando conceptualizassem novos dispositivos Android, e a verdade que funcionou pois vejam-se que at dispositivos de baixo custo como o Sapo A5 tm uma semelhana caracterstica com o Nexus One, tanto a nvel de design como de funcionalidades base. Um dos outros objetivos do Nexus One foi construir um telemvel moderno que oferecesse uma base slida para quem quiser ter um telemvel de desenvolvimento em Android, sendo que com isto ficou a promessa que este dispositivo seria atualizado pelo menos durante 2 anos com as ltimas verses de Android.

Entre as novidades introduzidas pela verso Eclair destacam-se os seguintes pontos:

Otimizaes de performance do hardware Suporte para mais resolues e densidades Interface visual renovada Novo Browser com suporte para HTML5 Nova lista de contactos Melhor rcio de contraste Google Maps melhorado Suporte oficial para Microsoft Exchange Suporte para flash da cmara fotogrfica Zoom Digital Suporte para Multi-Toque Teclado virtual melhorado Suporte para Bluetooth 2.1 e outras melhorias na stack de Bluetooth Live Wallpapers (panos de fundo animados) O browser embebido em aplicaes passa a ter uma gesto de recursos separada do browser do telemvel Suporte para Ant Suporte para Virtual Android Keys ou seja, os botes nativos de Android tais como Home ou Search passam a poder ser emulados virtualmente ao invs de serem apenas referenciados pela tecla fsica

f. Android 2.2 Nome de cdigo: F royo

Esta verso foi uma das principais novidades do evento Google I/O de 2010, mais concretamente a 20 de Maio. Nesta altura o Android tinha j conquistado uma posio relevante no cenrio global de smartphones e o mundo estava de olhos postos nas novidades que iriam ser anunciadas pela Google no evento. Apesar da Google ter assinalado esta como uma minor release a mesma contem uma panplia de novidades no menos importantes:

Melhoria de performance geral, com introduo de JIT (Just-In-Time compiler)

Melhorias na gesto de memria Integrao do motor de javascript V8 do Chrome no browser, resultando num aumento considervel de performance do mesmo

Melhorado suporte do Microsoft Exchange Launcher de aplicaes melhorado Suporte oficial para tethering, e funcionalidade de ponto-de-acesso mvel Adicionado suporte oficial para desligar a conexo ao operador mvel Atualizado Android Market - includo suporte para updates automticos Suporte para Adobe Flash 10.1 (S para arm v7) Melhorias no teclado virtual - possibilidade de swiping para mudana de lngua e disposio do teclado

Suporte para telefonemas e partilha de contactos via Bluetooth Suporte para GIFs animados no Browser Suporte para instalar aplicaes para o carto de memria (apps2sd) Introduzido suporte para OpenGL ES 2.0 Introduzida API do AudioManager Suporte para motores de TTS externos Vrias novidades nas permisses aplicacionais em consequncia das novas funcionalidades introduzidas

g. Android 2.3, 2.3.1, 2.3.2, 2.3.3, 2.3.4, 2.3.5, 2.3.6, 2.3.7 Nome de cdigo: G ingerbread
Mais uma vez, uma verso de Android caracteriza uma famlia de verses sobre o mesmo nome de cdigo. O Gingerbread surge inicialmente trazido por mais um dispositivo Nexus, neste caso o Nexus S apresentado oficialmente a 10 de Dezembro de 2010. Trouxe consigo a verso de Android 2.3.

A verso 2.3 de Gingerbread trouxe as seguintes principais novidades:

Suporte para o formato de vdeo WebM Copiar-Colar melhorado Suporte para resoluo 1366768 Px Introduzido novo look para Android Market Goggle Maps atualizado, contendo a nova funcionalidade de visualizar uma camada unicolor de Edifcios 3D sobre o mapa

Novo tema visual, com fundos a preto e elementos visuais em tons de verde Suporte para Near-Field Communication (leitor NFC) Suporte nativo para cmara frontal Suporte para protocolo SIP Motor de Garbage Collect redesenhado, agora mais rpido Drivers grficos atualizados, com melhor performance para OpenGL ES (incluindo tambm uma interface para Khronos EGL )

Suporte para o sensor Giroscpio Vrias bibliotecas internas atualizadas, e aperfeioamentos ao Just In Time Compiler (JIT).

As verses 2.3.1, 2.3.2 e 2.3.5, 2.3.6 e 2.3.7 so tidas como revises, e portanto no obtiveram uma verso de API diferente ou alteraes de SDK relevantes. A verso 2.3.3 foi lanada a 9 de Fevereiro de 2011 e foi considerada uma minor release pois adicionou algumas coisas funcionalidade que requeriam alteraes na API tais como suporte para mais normas de NFC (near-field-communication) entre outras pequenas melhorias a nvel multimdia. A verso 2.3.4 foi lanada a 4 de Maio de 2011. Como habitualmente neste ms esta verso tratase da extenso de funcionalidades que foi apresentada no Google I/O de 2011, tento trazido essencialmente pequenas correes e suporte a dispositivos USB (funcionalidade conhecida como USB Host). Esta funcionalidade permite a comunicao com dispositivos USB, tais como PEN drives, Joysticks, teclados e ratos USB, etc, e com isto foi tambm introduzido o Android ADK

(Accessory Development Kit) que permite tirar partido desta funcionalidade e extender o seu uso para novos tipos de perifricos.

h. Android 3.0, 3.1 e 3.2

Nome de cdigo: Honeycomb

Esta verso de Android exclusiva a Tablets!

Com o lanamento da verso Honeycomb a plataforma encontrou-se dividida em 2 partes fundamentais, a verso de Android para Smartphones e a verso para Tablets. Patente a esta fragmentao est o trabalho tardio do conceito de tablet como um dos focos da plataforma, e quando finalmente se pretendeu fazer uma verso de Android para este novo formato os programadores da plataforma foram deparados com um conceito muito diferente de dispositivo que no enquadrava bem na mesma filosofia e parmetros que os smartphones. No entanto a plataforma est construda de forma que uma aplicao possa, mediante algumas alteraes e cuidados no desenvolvimento de aplicaes, tornar possvel a mesma aplicao executar tanto numa como noutra, este dinamismo e como lidar com o mesmo ser explicado neste livro tambm. Para j fica a referncia de que esta divergncia da plataforma foi dissimilidada com o aparecimento da iterao seguinte da plataforma, pelo que as diferenas de programao para Smartphones e Tablets tendero a diminuar com o passar do tempo.

O Honeycomb 3.0 surge com a apresentao do Motorola Xoom a Fevereiro de 2011. Entre as principais novidades destacam-se as seguintes:

Interface grfica redesenhada com tablets em mente. Inmeras mudanas visuais, desde incluso da System Bar, Action Bar de aplicaes persistente, nova aplicao de Launcher, etc

Nova vista de aplicaes recentes Teclado virtual melhorado (agora suporta atalhos com a tecla CTRL, etc)

Aplicaes atualizadas: Browser de Internet, Contactos, Cmara, Galeria, Email Acesso nativo s funcionalidades de acelerao por Hardware para grficos 3D e 2D Suporte para processadores de mltiplos ncleos Suporte para a framework 3D Renderscript Suporte nativo para Live Streaming HTTP (formato m3u) Suporte para framework de Digital Rights Management (DRM) Suporte para Media/Picture Transfer Protocol (MTP/PTP) sobre ligao USB Suporte para Bluetooth A2DP e perfis de HSP Suporte para Drag & Drop de elementos visuais Melhoramentos e novas funcionalidades de animao nativas Suporte para Fake Touch Suporte para conversao de vdeo no Google Talk

Em pleno Google I/O de 2011, mais concretamente a 10 de Maio de 2011 anunciada oficialmente a verso 3.1 de Honeycomb, sendo que se trata de uma minor release, e apresenta as seguintes novidades:

Suporte nativo para USB ( USB Host ) Suporte para MTP (Media-Transfer-Protocol) e PTP (Picture-Transfer-Protocol) Suporte para RTP (Real-time Transport Protocol), um protocolo de streaming de contedos muito utilizado

Widgets de tamanho varivel (embora j existissem solues no Android Market para cumprir este objetivo, o suporte no era nativo)

Melhorias e novidades nas frameworks de Animao e Interface de Utilizador em geral Wi-Fi Lock - Aplicaes podem escolher que o Wi-Fi no entre em modo de hibernao quando o dispositivo fica em modo adormecido (tipicamente ao desligar o ecr), til para manter ligao ativa numa comunicao SIP por exemplo

Suporte para udio FLAC e raw ADTS AAC Suporte para a tag de <video> de HTML5 e outras melhorias no Browser

Tal como referido anteriormente para a verso 2.3.4 de Gingerbread, tambm a verso 3.1 suporta a nova ADK de Android.

A Julho de 2011 apresentada a verso 3.2 de Honeycomb, que fica marcada pela correes de falhas e pela introduo de algumas novas funcionalidades, entre quais se destacam as seguintes:

Suporte para novo hardware, de modo a suportar novos tipos de tablets Introduzido modo de Zoom de compatibilidade, de modo a que mais aplicaes que foram feitas para telemvel sejam possveis de executar no tablet

Sincronismo de media a nvel do carto SD - dispositivos com suporte a cartes SD passam a suportar carregamento direto de ficheiros de media a partir do carto

Re-Introduo do suporte para montar cartes SD tinha sido removido no 3.0) Adicionado suporte nativo para desenvolvimento para resolues de TV (por exemplo: 720p)

Suporte para redes HSPAP

i. Android 4.0

Nome de cdigo: I ce-Cream Sandwich

A verso Ice-Cream Sandwich foi lanada a 19 de Outubro de 2011, e trouxe a to aguardada unio de tablets com smartphones em Android, contituindo assim um patamar importante na uniformizao e reduo de fragmentao da plataforma. A verso 4.0 de Android uma major release, e conta com as seguintes novidades:

Novo launcher e app drawer Introduo formal do padro de desenho (design pattern): Action Bar de aplicao Widgets redimensionveis

Novo ecr de bloqueio, com novas opes Possibilidade de ter Suporte para Fake Touch (j presente tambm em Honeycomb) Novo teclado virtual, com melhorias de layout e vrias melhorias a nvel de deteco de erros ortogrficos

Melhorias no sistema de reconhecimento de voz Visualizao e gesto de fluxo de dados de rede das aplicaes instaladas Aplicao dedicada integrao com Redes Sociais Novo calendrio, e melhorias na disponibilizao de servios de calendrio a outras aplicales de sistema

Edio de fotos a partir da galeria Nova aplicao de cmara Reconhecimento de face, e elementos faciais Suporte para Wi-Fi direct e Bluetooth HDP (possibilidade de integrao com qualquer dispositivo certificado pela Continua)

Partilha de dados por NFC (Android Beam) Novas APIs de ligaes VPN

j. Android 4.1

Nome de cdigo: J ellyBean

Interface mais fluda e com melhor tempo de resposta (adicionados VSync e Triple Buffering)

Adicionadas novas funcionalidades e API de Acessibilidade Suporte para Texto Bi-Direcional

Suporte para instalao de Keymaps para suportar teclados externos Notificaes expansveis e agrupveis Widgets auto-ajustveis Fotos de contactos em alta resoluo Controlo de hardware de vibrao de dispositivos conectados (Rumble Pak, etc) Multicast DNS Discovery e melhorado Wi-Fi Direct API para aceder listagem de low-level codecs Suporte para udio por USB Suporte para udio multi-canal at 5.1 AAC Reencaminhamento de udio, Media Router e Audio Chainning adicionados Melhoramentos de performance de Renderscript e novo suporte para texturas Motor V8 e WebView atualizados para melhorar performance e permitir captura de media de HTML5 e deteo correta de field-type

Introduzido Google Cloud Messaging (GCM) para envio de mensagens pequenas em multicast

Encriptao de aplicaes pagas Atualizao inteligente de aplicaes - apenas as componentes novas das aplicaes so transferidas nas atualizaes e no a aplicao nova na totalidade

Melhor integrao de servios do Google+

O que e o que no

Existe alguma confuso por parte de alguns programadores, e mesmo utilizadores, do que realmente a plataforma Android. Uma das principais confuses em relao linguagem de programao da plataforma. Realmente a linguagem usada para programar para Android Java, mas Android no baseado na plataforma Java ME. Como tal, no possvel correr aplicaes Java compiladas para Java ME (como o caso de algumas aplicaes para terminais Nokia) em

Android. Isto porque a mquina virtual de Java que executa o cdigo em Android a Dalvik VM, que uma VM6 otimizada para terminais mveis. Android tambm no simplesmente uma camada aplicacional, sendo que define muito mais que isso. Quando se fala em Android como plataforma, estamos a falar desde o Kernel que corre no dispositivo (Linux), at s Aplicaes em si passando por bibliotecas nativas, bibliotecas da API, e como bvio, a camada Aplicacional e de Servios fornecidos pela plataforma aos programadores. Outra grande confuso, se o Android um telemvel. Para alm de todo o software que a plataforma Android define, tambm faz parte da plataforma um design de referncia para os fabricantes de terminais se basearem para o desenvolvimento dum novo terminal, mas no h uma rigidez nos componentes que tm de ser aplicados nesses terminais. Por isso, a plataforma possibilita aos fabricantes a utilizao da plataforma Android em vrios tipos de terminais, desde terminais de gama baixa at aos topo de gama da marca, sendo que Android pode ser utilizado at em equipamentos que no dispe de uma utilizao para tele-comunicaes como em eletrodomsticos inteligentes, etc.

Componentes Base
A componente mais importante de toda a plataforma, provavelmente a Dalvik VM. Esta mquina virtual a responsvel pela execuo de todo o cdigo Java que faz parte da plataforma Android. Foi criada por um programador da Google (Dan Bornstein) com o intuito de ser base da plataforma. tambm bastante diferente das Java VMs que so usadas normalmente noutros sistemas operativos pois esta est especialmente otimizada para que os programas possam ser interpretados duma forma rpida e eficaz e ao mesmo tempo usando pouca memria. Como j deve ser do seu conhecimento, o Kernel usado pela plataforma o Kernel Linux. Este conta com algumas alteraes para que todo o software possa executar sem problemas. Algumas destas alteraes includas no Kernel so:

Android Debug Bridge (adb): Usado para aceder ao terminal via USB ou TCP/IP e poder obter informaes de sistema como logs, aceder shell do terminal, enviar e receber ficheiros, etc.

Mquina Virtual

Low Memory Killer: Componente do Kernel que gere a memria do terminal. este o componente responsvel por terminar aplicaes quando o terminal precisa de memria livre para executar alguma coisa.

IPC Binder: Esta parte do Kernel responsvel por uma parte muito importante da plataforma. Quando as aplicaes precisam de falar entre si, por vezes podem precisar de algo mais completo que uma simples chamada de um Intent (mais frente veremos o que ). Para isto existe este servio que possibilita os programadores falarem diretamente com outras aplicaes instaladas.

Numa arquitetura Linux, precisamos de algo que ligue o Kernel s aplicaes. A esta biblioteca chamamos LibC e a mais usada nas tecnologias de informao a GNU LibC. Na plataforma Android no entanto, esta biblioteca foi substituda pela BIONIC C Library. A BIONIC C uma verso muito reduzida e otimizada, com partes da biblioteca C de *BSD e partes da GNU LibC para Linux, e ainda funcionalidades que lhe so nicas. Muitas coisas foram alteradas e reduzidas de forma a que todos os pedidos ao Kernel sejam feitos o mais rpido possvel e sem haver uma preocupao com otimizaes especficas. Muitas otimizaes utilizadas na LibC de Linux por exemplo, seriam demasiado pesadas para serem executadas em terminais com pouca memria e com escassos recursos de processamento, logo o seu custo/benefcio seria nulo.

Fragmentao
A fragmentao um problema criado pela plataforma devido a ser bastante malevel, e portanto poder adaptar-se quase a qualquer tipo de terminal. Acontece que muitas vezes os fabricantes e/ou as operadoras lanam terminais para o mercado que depois acabam por no lhes dar suporte a nvel de atualizaes do Sistema Operativo, mesmo aps a Google disponibilizar novas verses da plataforma. Com isto cria-se uma dor de cabea para os programadores porque se quiserem suportar o mximo de terminais possveis para a sua aplicao tm de ter em conta vrios aspetos para no quebrarem a compatibilidade com os terminais mais antigos. Assim temos por exemplo aplicaes que suportam APIs desde a verso 1.5 at verso mais atual de Android mas que recorrem a vrios truques para que isto seja possvel. Num captulo mais frente este assunto ser abordado novamente numa perspetiva de perceber o que um programador pode fazer para resolver e lidar com este problema.

2
usados, Windows, Linux e MacOS X.

COMO CONFIGURAR O
AMBIENTE DE DESENVOLVIMENTO

Como plataforma e ambiente de desenvolvimento para Android, a Google adotou o ambiente Eclipse, desenvolvendo um plugin chamado Android Developer Tools Plugin for Eclipse (ADT). Neste captulo vai ver como instalar e configurar corretamente o Eclipse para desenvolvimento para a plataforma Android, sendo que as introes aqui presentes cobrem os 3 sistemas operativos mais

Instalao do eclipse

O 1 passo caso esteja num ambiente Windows ou MacOS X, ir ao website oficial do Eclipse 7 e fazer a transferncia da ltima verso disponvel para programao em Java (com o ttulo Eclipse IDE for Java Developers, tal como ilustrado na figura 2.1). Ter em ateno a verso do sistema operativo, se 32bits ou 64bits e fazer download da verso apropriada. No caso de estar a usar Linux, pode tambm utilizar o mtodo anteriormente descrito para Windows/MacOS X, ou ento usar o sistema de instalao de aplicaes da sua distribuio (apt-get, emerge, yum, rug, etc).

FIGURA 2.1 Transferncia do Eclipse para Java

http://www.eclipse.org

Aps a transferncia ter concludo, basta descomprimir o ficheiro que guardou para a aplicao ficar pronta a usar. Pode faz-lo por exemplo para o seu Ambiente de Trabalho. Aps isto feito, pode abrir o Eclipse pela 1 vez. Neste altura ser-lhe- tambm perguntado onde fica definido o seu workspace8.

Instalao do ADT
Com o Eclipse aberto, selecione o menu Help e em seguida escolha a opo Install New Software. Ser-lhe- apresentada uma janela semelhante da figura 2.2 .

FIGURA 2.2 Janela de instalao de plugins do Eclipse

Na janela apresentada dever ento pressionar o boto Add para adicionar um repositrio. Na caixa de dialogo que ir aparecer preencha o campo Name com ADT e o campo Location com o valor https://dl-ssl.google.com/android/eclipse/ , tal como evidenciado pela figura 2.3.

Workspace o local onde os projectos do eclipse ficam guardados. Este mecanismo

prtico pois permite por exemplo ter vrios workspaces se estiver a trabalhar em diferentes contextos, e dessa forma agrupar e separar o trabalho convenientemente.

FIGURA 2.3 Adicionar o repositrio do plugin de Android

O Eclipse ir ento procurar no novo repositrio inserido os plugins disponveis para serem instalados. Quando terminar iro estar disponveis novas opes para instalao dentro do grupo Developer Tools tal como est na figura 2.4. Pode simplesmente selecionar todas e clicar em Next.

FIGURA 2.4 Componentes do plugin de Android

Na fase seguinte o Eclipse apenas nos diz que software ns escolhemos para instalao e se tudo est conforme para a executar. Basta pressionar o boto Next novamente para passarmos fase

onde lhe dada a conhecer as licenas dos Plugins que vai instalar no Eclipse. No fim de aceitar as licenas, s tem de pressionar o boto Finish e a instalao iniciar-se-. Durante a instalao, vai-lhe aparecer um aviso acerca de contedo que vai ser instalado mas que no est assinado digitalmente, semelhante ao que apresentado na figura 2.5. Este aviso normal nesta instalao.

FIGURA 2.5 Aviso de assinaturas digitais

No final da instalao vai-lhe ser pedido para reiniciar o Eclipse para aplicar as alteraes efetuadas pela instalao do Plugin. Clique ento em reiniciar. Aps o Eclipse iniciar novamente, veremos que o ADT j est instalado, visto que lhe dever ser mostrada uma janela a pedir para fazermos a transferncia da SDK9 para desenvolver em Android. Nesta altura selecione as duas opes disponveis debaixo da opo Install new SDK e escolha o local onde quer guardar toda a SDK, tal como evidenciado na figura 2.6. Finalmente, apenas necessita de pressionar Finish.

FIGURA 2.6 Transferncia da SDK de Android

Mais uma vez, o Eclipse vai analisar o que necessrio instalar e mostra-nos essa informao. De notar que esta instalao j o prprio ADT a fazer e no o Eclipse visto estarmos a instalar verses da SDK de Android que nada tm a ver com o Eclipse em si. A esta altura apenas necessita de aceitar todas as e carregar em Install.

Sofware Development Kit

A partir deste momento, tem o ambiente de desenvolvimento completamente preparado para comear a desenvolver aplicaes Android usando o Eclipse.

Configurao do SDK

Dentro da aplicao de configurao do SDK Android, que pode ser aberta clicando no boto que se encontra na barra superior do Eclipse (ver figura 2.7). Esta aplicao do SDK serve para instalar vrias verses da API de Android, fazer atualizaes quando saem novas verses e tambm instalar outros componentes no obrigatrios do SDK.

FIGURA 2.7 Iniciar o SDK Manager

Ao abrir o configurador do SDK, este tentar automaticamente atualizar as verses que tem instaladas e instalar mais alguma coisa que lhe seja til para o desenvolvimento. Pode instalar ainda documentao de cada API e as APIs da Google (para utilizao do Google Maps, etc). Os itens relativos a ARM EABI v7a System Image so as imagens dos emuladores para testar as aplicaes no PC de desenvolvimento.
Sugesto: Instale sempre a documentao, e para o mbito deste livro, instale tambm as Google APIs.

IntelliJ IDEA
tambm possvel usar o ItelliJ IDEA como ambiente de desenvolvimento. A ltima verso gratuita disponvel no website do IntelliJ usando a SDK oficial.
10

j compatvel com o desenvolvimento para Android

10

http://www.jetbrains.com/idea/

MOTODEV Studio
O MOTODEV Studio
11

um IDE baseada em Eclipse e no plugin ADT que foi referido

anteriormente, e com o acrscimo de algumas ferramentas extra para auxiliar certas tarefas que de outra forma requeriam trabalho manual do programador. Entre estas contam-se ferramentas para melhor suporte a localizao de contedos (mesma aplicao em vrias lnguas), gesto integrada de bases de dados sqlite, snippets de cdigo, etc. No entraremos em pormenor de como instalar e configurar corretamente o MOTODEV Studio visto no ser oficialmente suportado ficando portanto o leitor encarregue de o instalar e configurar para desenvolvimento Android caso assim o deseje.

2.6 Android Studio

Desde Maio de 2013 que o IDE oficial de Android passou a ser o AndroidStudio. Este IDE no mais do que uma verso do IntelliJ IDEA com um conjunto de tecnologias limitado ao espectro Android e Google App Engine. Como na altura da escrita deste livro ainda no existia o dito IDE, deixamos aqui o link para a pgina do mesmo para que possa descubrir mais.

11

http://developer.motorola.com/docstools/motodevstudio

3
a compilao do software.

FERRAMENTAS DO
3

SDK DE ANDROID

No captulo anterior vimos como podemos configurar o ambiente de desenvolvimento, cujo cenrio tpico passa por instalar a SDK de Android e uma IDE (que embora aconselhado no obrigatria para o desenvolvimento), mas no entanto a SDK de Android fornece um conjunto muito mais extenso de ferramentas para auxiliar o desenvolvimento aplicacional que vai muito para alm de simplesmente permitir

Android Debug Bridge

O Android Debug Bridge (ADB) uma aplicao de cliente-servidor que se comparte em 3 componentes: 1) Uma aplicao Servidor que corre na mquina de desenvolvimento, qual os dispositivos e emuladores se ligam para intercomunicao 2) Um Daemon que corre em plano de fundo no dispositivo de testes ou emulador 3) Uma aplicao cliente, que corre na mquina de desenvolvimento e permite a interao do programador com a componente Servidor que corre tambm ela na mquina de desenvolvimento

Para o programador esta aplicao usada para uma panplia de casos possveis. Esta componente usada abstratamente sempre que o vai ao ecr de Debug do Eclipse para operar com o DDMS12 por exemplo. A um nvel operacional mais baixo pode tambm usar a ferramenta de linha de comandos "adb" que se encontra presente da diretoria /platform-tools da raiz de instalao do SDK. Esta ferramenta de linha de comandos permite iniciar e terminar a componente

12

Componente do plugin de Android e do SDK, explicado em detalhe mais frente neste

captulo

de servidor que executa na mquina de desenvolvimento, assim como tirar partido de uma instncia deste j em execuo para interao com o dispositivo. Tal como o nome sugere, o Android Debug Bridge tem como principal objetivo auxiliar o processo de depurao da aplicao. A utilizao mais vulgar e comum feita com recurso opo logcat. Esta opo permite ver e filtrar em tempo real toda a informao de depurao que emitida pelo terminal. Em Android existe uma class dedicada exclusivamente tarefa de depurao de nome Log. Sempre que o programador invocar esta class ter de especificar o tipo de severidade do registo que vai fazer (Warning, Error, Debug, Verbose, Info, etc) e a tag sobre a qual faz esse registo, deste modo ao usar a opo logcat -nos possvel filtrar por aplicao, tag e severidade de registo.

DDMS

O Dalvik Debug Monitor Bridge (DDMS) a ferramenta visual de depurao que vem juntamente com o SDK de Android. O DDMS recai na ligao estabelecida pelo daemon de ADB para abstrair a comunicao com o dispositivo (ou instncia de emulador). A ferramenta pode ser aberta dentro do Eclipse (mediante instalao prvia do plugin de desenvolvimento Android) da seguinte forma: clicar no menu Window na barra de ferramentas, e de seguida escolher as opes Open Perspective > Other... > DDMS . A vista resultante ser semelhante da figura 3.1. O DDMS pode alternativametne ser executado separadamente do Eclipse sendo que se encontra na diretoria tools com o nome ddms (ou ddms.exe se se tratar do sistema operativo Windows).

FIGURA 3.2 Vista DDMS no Eclipse

Emulador
O emulador de Android baseado na tecnologia de cdigo aberto QEMU dado sua versatilidade de permitir emular processadores Advanced RISC Machine (ARM) e Intel x86, que por sua vez abstrado pelo Android Virtual Device (AVD). Um AVD uma instncia de emulador criada com recurso ao SDK Manager. A sua criao e manuseamento podem ser feitos tanto por linha de comandos ou atravs do editor visual para o efeito (que tambm integra com o plugin de Android). Dada a diversidade de equipamentos fsicos existentes o AVD uma exelente ferramena para combater essa tndencia uma vez que torna possvel criar vrias instncias virtuais que simulam equipamentos com caractersticas de hardware distintas. Entre os atributos que so parametrizveis contam-se a descriminao do tamanho de ecr, memria RAM disponvel e verso do sistema operativo (com ou sem suporte para Google APIs). Para criar um AVD atravs do Eclipse, primeiro tem de abrir o gestor de AVDs atravs do boto para o efeito (ver figura 3.2).

FIGURA 3.2 Gestor de AVDs

De seguida clica no boto New para criar uma nova AVD, e -lhe apresentado um formulrio semelhante ao da figura 3.3, o qual como pode ver j preenchemos os campos com uma AVD ao nosso gosto. Poder e dever criar tantas AVDs quantas achar necessrias para testar as suas aplicaes em condies variadas. Aps criar a instncia de AVD esta ficar disponvel no gestor tal como apresentado na figura 3.4.

FIGURA 3.3 Formulrio de criao de um AVD

FIGURA 3.4 Janela de gesto de AVDs existentes

Se o leitor pretender criar um AVD semelhante ao anterior pela linha de comandos, a sua sintaxe seria:
android create avd -n emulador_ics -t 2 -c 32M

Onde -n diz respeito ao parmetro do nome, -t ao identificador nico da AVD, -c ao tamanho do carto de memria a criar. Se o leitor quisesse habilitar suporte para Snapshots bastaria passar a opo -A.

Outras ferramentas
As ferramentas referidas em at agora so de uso comum e genrico seja qual for a escala ou contexto (empresarial, didtico, etc) do desenvolvimento que o programador se deparar. No entanto existem outras ferramentas de uso especfico que passamos agora a referir.

k. Draw 9-patch
Ferramenta para criar e visualizar um tipo de imagem nica a Android, usualmente denominadas por imagens 9-patch.

l. Hierarchy Viewer

Permite visualizar a hierarquia de desenho das Views e Layouts de Android, o leitor perceber melhor a utilidade desta ferramenta nos prximos captulos. Esta ferramenta tambm integra com o Eclipse.

m. Monkey
Permite gerar e enviar eventos de input pseudo-aleatrios para o dispositivo, serve essencialmente para uma despistagem rpida de eventos relacionadas com a interao do utilizador.

n. ProGuard
Otimizao e ofuscao do cdigo gerado por pr-compilao. A ofuscao renomeia Classes, parmetros e mtodos.

o. Zipalign
Otimiza o tamanho final do .APK gerado pela compilao atravs da compresso de ficheiros de imagem presentes na aplicao.

p. Outros
Para mais informaes consultar a documentao oficial relativa s ferramentas da SDK Android na pgina respetiva13.

13

http://developer.android.com/guide/developing/tools/index.html

4
Desenvolver para plataformas mveis

FUNDAMENTOS APLICACIONAIS
4

Neste captulo damos-lhe a conhecer as bases aplicacionais da plataforma. Entender os tpicos que iremos falar essencial para que o leitor se sinta vontade com os captulos seguintes e consiga capturar a essncia do funcionamento do sistema operativo Android.
1

Quando se trata de desenvolver para Android, ou qualquer plataforma mvel em geral, existem certas consideraes que devem ser tidas em conta. Em particular os smartphones actuais so mquinas muito capazes e completas que incorporam desde cmara de vdeo a receptor de GPS, vrias formas de conectividade, entre outras, mas parte do uso que as aplicaes do a este conjunto de capacidades para que exista uma experincia agradvel para o utilizador e bem integrada com o sistema. O primeiro ponto que vamos falar talvez o mais evidente que se trata da boa gesto de recursos do dispositivo. Os terminais mveis pela prpria natureza que tm so dispositivos que tm uma bateria cujo consumo pode variar largamente consoante a velocidade de relgio do processador, tempo de uso de certas capacidades do hardware (receptores de sinal, sensores, etc) e estado de operao, sendo que todas estas variveis so afectadas pelas aplicaes que esto a executar no dispositivo a um dado momento. Deste modo importante que uma aplicao feita para este tipo de terminais seja o mais eficiente possvel na gesto desses recursos. Uma considerao importante a ter que o Android uma plataforma multitarefa14, sendo que a qualquer momento o utilizador pode decidir comutar entra

14

Multitarefa a capacidade de um sistema operativo executar vrios processos em

simultaneo

a sua e outra qualquer aplicao ou mesmo premir o boto de energia para colocar o dispositivo em standby. Um outro ponto importante a capacidade de resposta da aplicao, e este talvez o ponto mais habitualmente desprezado por programadores iniciantes plataforma. Por capacidade de resposta entende-se que ao disputar uma aco de carcter moroso o dispositivo no fique bloqueado durante mais do que meros segundos na aplicao sem o utilizador poder intaragir com o terminal. Neste caso o ideal fazer esse tipo de tarefas num processo no plano de fundo e providenciar notificaes ao utilizador para que este tenha a percepo do progresso dessa operao, mas ao mesmo tempo poder continuar a interagir com a aplicao em reas que no requeiram que o resultado da operao demorada tenha terminado. Por exemplo, se o utilizador estiver no Browser, certamente quer poder transitar para uma nova pgina enquanto uma transferncia de um ficheiro que foi entretanto iniciada seja efectuada em segundo plano. Nas aplicaes mveis, mais do que nas aplicaes de computador pessoal, necessrio ter em vista a organizao visual da informao. Como o ecr de um dispositivo mvel pode ser muitas vezes inferior em resoluo comparativamente ao ecr de um computador as aplicaes devero ser pensadas tendo em conta esse fator. Com uma boa organizao do layout da pgina consegue encapsular em pequenas reas muita informao til, mas ateno para no reduzir nem compactar a informao em demasia porque seno o utilizador poder ficar confuso pela proximidade da mesma, e ao mesmo tempo se no meio dessa informao houverem componentes que respondem ao toque no convm que 2 elementos deste tipo estejam demasiado prximos porque seno ir causar muitos falsos toques por parte do utilizador. As consideraes aqui faladas so de um mbito genrico em Android, sendo que a mais discusses de melhores prticas sero expostas ao longo do livro conforme se encaixem no contexto do captulo em que se inserem.

Componentes aplicacionais de Android

As componentes de uma aplicao so os blocos bsicos de construo da mesma. A SDK de Android fornece vrios blocos diferentes, sendo que atravs de cada um destes o sistema consegue interagir com sua aplicao. Nem todos estes tm um carter de interaco direta do utilizador como poder compreender de seguida. Uma aplicao pode ser constituda por vrios destes blocos, e estes blocos so comunicveis entre si na maioria dos casos.

q. Activity
Uma Activity um ecr da aplicao, o anlogo a uma Janela no Windows (ou Form noutras linguagens/sistemas). aqui que habitualmente se produz e elabora a componente de interaco visual de uma aplicao.

r. Service
Um Service como o nome sugere um servio. No contem um frontend visual como a Activity, e serve geralmente para efectuar tarefas potencialmente demoradas em plano de fundo. Geralmente usado como estrutura de suporte s vrias Activities de uma aplicao, tratando de coisas como a comunicao com a ligao Internet, atualizaes peridicas de contedos, e inter-comunicao entre aplicaes.

s. Broadcast Receiver
Um Broadcast Receiver uma componente que reage a eventos/sinais de sistema. No processo de instalao de uma aplicao em Android, o instalador procura pelas componentes deste tipo e insere numa tabela de sistema as referncias sobre a que tipo de eventos aquela aplicao reage. Entre eventos deste tipo enviados pelo sistema operativo podem-se contar coisas como a mudana da hora actual, alterao do estado da bateria, alterao das condies de conectividade (passou a ter ligao, ficou sem ligao, etc), entre muitos outros. Desse modo, a ttulo de exemplo, possvel produzir uma aplicao que tenha uma componente deste tipo e que cada vez que o sistema envia um sinal de que se perdeu ligao rede, adiada a atualizao de contedos via rede at que o sinal de ligao restabelecida seja enviado e mais uma vez recebido pela nossa componente de Broadcast Receiver, desse modo fazendo uma gesto inteligente de quando que a aplicao vai executar cdigo relativo tentativa de obteno de atualizaes peridicas. Este e outros exemplos de gesto inteligente com recurso a Broadcast Receivers sero estudados em mais detalhe em captulos posteriores do livro.

t. Content Provider
Um Content Provider uma forma de providenciar informao da nossa aplicao a outras aplicaes instaladas no sistema operativo. Isto permite criar um eco-sistema muito poderoso assim que o leitor de aperceber de que forma esta componente pode ser utilizada e das diversas aplicaes que atualmente j tiram ou permitem tirar partido desta capacidade. Um exemplo de uma aplicao com uma componente deste gnero a aplicao de Contactos (Contacts) presente na generalidade de terminais Android. Esta aplicao fornece um Content Provider para

que qualquer outra aplicao possa saber quais os contactos guardados no dispositivo, e iterar sobre a listagem dos mesmos. A componente de Content Provider fornece deste modo uma forma geral e abstrata de fornecer os contedos da aplicao em que se insere, esta forma genrica segue sempre a mesma estrutura tornando fcil o uso desta componente por outras aplicaes. Ao mesmo tempo, a implementao de como a informao que est a ser fornecida da escolha do programador, que pode mesmo controlar que tipo de informao fornecida e a forma como esta est guardada no dispositivo (podendo mesmo estar na nuvem ao invs de fisicamente no dispositivo por exemplo).

Ciclo de vida de uma Activity

Tal como j foi referido o Android um sistema operativo multitarefa, e tendo sido concebido nesse sentido desde o inicio do seu desenvolvimento consta de uma gesto inteligente e eficaz de processos, sendo que isto acarreta consequncias forma como se programam aplicaes na plataforma. As Activities contam com um conjunto de mtodos de callback
15

que devem ser usados na

construo lgica de aplicaes. O diagrama apresentado de seguida pela figura 4.1 ilustra o ciclo de vida de uma Activity e os mtodos que callback (onStart, onPause, etc) que so chamados aquando a ocorrncia de cada uma das condies que lhes precedem.

15

Mtodos chamados automaticamente pelo sistema face a um acontecimento especfico

FIGURA 4.3 Ciclo de vida de uma Activity

Para ilustrar uma estrutura de uma Activity deixamos em baixo um excerto de cdigo de uma Activity do Hello World tpico de Android. Neste momento no necessrio que o leitor perceba j toda a estrutura do cdigo aqui ilustrado, serve apenas para se comear a ambientar com a sintaxe

import android.app.Activity; import android.os.Bundle;

public class TestActivity extends Activity { /** Mtodo de Callback chamado quando a Activity criada inicialmente. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //Definir a layout da Activity baseada no ficheiro main.xml setContentView(R.layout.main); } }

Gesto de recursos
Uma das grandes potencialidades a nvel de programao da plataforma Android a sua fcil gesto e utilizao de recursos (Resources). Facilmente identificveis visto estarem sobre o directrio /res do projecto, aqui que tudo aquilo o que no cdigo Java fica guardado, incluindo imagens. Como se pode ver pela figura 4.2, existem vrios sub-diretrios dentro do directrio /res quando se cria um projeto Android no Eclipse, servindo para categorizar os recursos que l esto e para que a plataforma Android os possa otimizar e usar da melhor maneira possvel tendo em conta a sua finalidade. Cada agrupamento de recursos dividido em duas partes: o tipo e o qualificador, podendo haver mais do que 1 qualificador. Na figura 4.2 podemos constatar que existem 5 grupos de recursos, sendo que apenas existem 3 tipos diferentes: drawable, layout e values. Estes so habitualmente os 3 tipos de recursos mais usados na plataforma, embora hajam mais com outros propsitos. A tabela 4.1 mostra todos os tipos de recusos que existem.

FIGURA 4.2 Resources de um projecto novo no Eclipse

NOME animator anim

DESCRIO DE USO Defenies de animaes do tipo property Animaes do tipo tween Usado para definio de cores ou para definies de Listas de Estado de Cor

color

(Color State Lists) que so usadas para definio de uma cor para um estado (selecionado, pressionado, etc) Onde so guardadas todas as imagens (incluindo definies em xml como

drawable

podem ser por exemplo as animaes frame-by-frame) que sero usadas no projeto

layout

Define os layouts da interface com o utilizador Definem o contedo dos menus aplicacionais bem como da Action Bar nas verses mais recentes de Android (Honeycomb e Ice Cream Sandwich) Este tipo especial visto que pode albergar vrios tipos de recursos dentro de si, sendo o mais importante o tipo Strings que um ficheiro xml com um nome

menu

values

especfico (strings.xml), que define os vrios textos para uso no projecto. Os outros recursos que podero ser inseridos neste tipo sero falados ao longo do livro quando pertinente

Tabela 4.1 Tipos de Resources disponveis

Conhecendo ento os tipos de recursos que podem ser utilizados, resta saber o que so exatamente os qualificadores. Queremos realar desde j que no necessrio para a definio de um grupo de recursos, o uso de um ou qualquer qualificador nesse grupo. Como visvel na imagem em cima, os tipos layout e values no tm qualquer qualificador, e o tipo drawable est dividido em 3 grupos por 3 qualificadores: hdpi, mdpi e ldpi. Estes 3 qualificadores dizem respeito aos DPI
16

do ecr onde a aplicao est a executar a um dado momento: 240dpi, 160dpi

e 120dpi respetivamente. Esta diviso particularmente til quando queremos que a nossa aplicao no perca qualidade grfica dum tipo de ecr para outro. Os qualificadores so ento usados para diferenciar o mesmo recurso mas para outro tipo ou outra utilizao da aplicao. Por exemplo, para traduzir uma aplicao para Portugus, bastaria criar um grupo com o nome values-pt, e criar um ficheiro com o nome strings.xml l dentro como os mesmos valores existentes no string.xml global (que se encontra dentro do grupo de nome values apenas) mas com a traduo dos textos de cada valor para Portugus. Tambm bastante utilizados so os qualificadores land e port que dizem respeito s orientaes do ecr na Horizontal (Landscape) e na Vertical (Portrait) respetivamente. Com estes qualificadores, pode definir um layout duma Activity especfico para quando o ecr se encontra na horizontal, e outra para quando est na vertical. Uma grande potencialidade dos qualificadores que o pode agrupar vrios associando-os a um tipo de recurso. Por exemplo, se quiser definir um layout para quando um terminal estiver em com um orientao horizontal (landscape) e que tenha um ecr considerando largo (large) 17 , ento pode definir o layout dentro dum grupo com o nome layout -large-land. Deste modo pode abstrair uma Activity que usa sempre o mesmo cdigo Java do seu aspecto visual de acordo com o terminal em que est a executar, sendo que a prpria plataforma decide que layout utilizar pois escolher o grupo que melhor se encaixar nas especificaes do dispositivo. No cdigo seguinte pode ver este exemplo.

16 17

Pontos por polegada (Dots Per Inch) Mnimo de resoluo de 640 x 480 px

Ficheiro: HelloWorldActivity.java public class HelloWorldActivity extends Activity { /** Mtodo de Callback chamado quando a Activity criada inicialmente. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } }

FIGURA 4.3 Resources do projecto HelloWorld

Para aceder aos recursos que guarda dentro do projeto a partir do cdigo Java, utiliza-se a classe R que gerada automaticamente pelo ADT quando cria, apaga, ou altera algum recurso dentro da directoria /res. No caso dos layouts, podem ser acedidos fazendo referncia a R.layouts, e estes so todos os layouts definidos nos recursos do projecto, no havendo qualquer filtragem ou diferenciao sobre estes tendo em conta os qualificadores usados na sua definio. A funo para definir a UI duma Activity a setContentView(int value). Como se pode ver ento pelo cdigo em cima, aquela Activity usa um Layout com o nome main . Este recurso diz respeito ao main.xml que est presente na figura 4.3 . Pode constatar que existem 3 grupos de layout cada um com um main.xml l dentro, desde modo a plataforma que decide qual destes

vai usar em tempo de execuo. Procurar primeiro o um que se aplique condio e/ou especificao atual do dispositivo, e caso no seja aplicvel ir ento usar a verso que se aplica a todos os outros casos, definida em /layout. aconselhada a leitura da pgina relativa a este assunto na documentao oficial para mais informaes : http://developer.android.com/guide/topics/resources/providingresources.html#AlternativeResources .

Android Manifest
O Android Manifest onde definida a aplicao. Contm as definies das Activities, Services, Broadcast Receivers, permisses, compatibilidade com verses de Android, entre outros aspectos para que tanto o Android Market e o dispositivo possam filtrar aplicaes por compatibilidade, para gerir acessos a recursos da prpria aplicao e gerir tambm acessos da aplicao a recursos do sistema e/ou de outras aplicaes. A definio do Manifest feita atravs dum ficheiro chamado AndroidManifest.xml que se encontra na raiz do projecto. Este ficheiro composto pela tag <manifest> com vrios atributos sendo que o package, versionCode e versionName so obrigatrios. A diferena entre os dois ltimos que o primeiro usado internamente pela plataforma (e pelo Android Market) para controlo de verses e pode ser qualquer nmero inteiro (p.e. 25), no tendo qualquer relao com o versionName que somente uma descrio verbal da verso para o utilizador ver (p.e. 1.0.5 Beta). O atributo package o package name que foi atribudo aplicao quando esta foi criada.

Aps um package name ser utilizado com uma assinatura digital no Android Market, este package name fica reservado para uso exclusivo e as atualizaes consecutivas tero de conter a mesma assinatura digital. Guarde a sua assinatura digital num local seguro, tanto para no ser roubada como para no a perder.

Um AndroidManifest.xml muito bsico teria o seguinte aspecto:

<manifest xmlns:android="http://schemas.android.com/apk/res/android package="org.hello_world" android:versionCode="1"

android:versionName="1.0" > </manifest>

Dentro da tag manifest podem existir vrias outras, algumas obrigatrias como a application e outras opcionais como por exemplo a uses-feature. Apresentamos de seguida as tags mais usadas que podem ser inseridas dentro da tag manifest, bem como um exemplo sucinto da sua utilizao.

Consulte o manual online para esclarecimentos adicionais bem como todas a opes possveis para tags e atributos em http://developer.android.com/guide/topics/manifest/manifest-intro.html

u. Uses-permission
Esta tag diz plataforma Android que a aplicao necessita de uma ou mais permisses para executar corretamente. Num captulo mais adiante iremos falar mais aprofundadamente a questo das permisses em Android. Uma permisso que usada muito frequentemente a android.permission.INTERNET, que d permisso de uma aplicao aceder internet. Necessria para aceder a um WebService para obteno de dados por exemplo. As permisses de sistema so todas as que comeam por android.permission, todas as outras so permisses de outras aplicaes que declararam no seu Manifest uma nova permisso usando a tag permission para que outras aplicaes podessem aceder a dados e/ou recursos dela. Exemplo de uso:
<uses-permission android:name="android.permission.INTERNET"/>

v. Permission
Como falado anteriormente, esta tag serve para declarar, e deste modo proteger, o acesso a alguns dados ou servios disponibilizados pela aplicao a outras aplicaes. A permisso pode ter vrios nveis de alerta para o utilizador, mediante a importncia do recurso que estar a ser acedido por outra aplicao. Por exemplo, se uma aplicao decidir partilhar um servio que possibilita a outra aplicao o acesso a uma palavra-passe introduzida pelo utilizador, esta permisso deve ser tida em conta aquando da instalao da aplicao que a usa, e portanto,

considerada perigosa visto disponibilizar dados pessoais. Os nveis de alerta so os seguintes: normal, dangerous, signature, signatureOrSystem. Exemplo de uso:

<permission android:name="org.hello_world.SHARE_PASSWORD" android:label="@string/share_hello_password" android:protectionLevel="dangerous" android:description="@string/share_hello_password_desc" />

w. Uses-sdk

Esta tag define vrios aspetos da aplicao em relao ao SDK usada para a criar. Pode conter 3 atributos: minSdkVersion, targetSdkVersion, e maxSdkVersion. O primeiro usado para dizer que verso de SDK a mnima para aplicao executar corretamente. muito til para criar uma aplicao compatvel com verses anteriores do SDK. Se este atributo no for definido, ele toma automaticamente o valor 1, fazendo a aplicao compatvel com todas as verses de Android at especificada em maxSdkVersion caso esta exista. Se a aplicao usar APIs apenas definidas em verses superiores de Android, a aplicao ir terminar anormalmente durante a sua execuo por no ter o suporte s APIs necessrias no terminal. portanto extremamente recomendado o teste da aplicao desde a minSdkVersion at targetSdkVersion. O targetSdkVersion, define a SDK com a qual a aplicao foi compilada e em qual foi efetivamente testada. Se durante o desenvolvimento da aplicao est a ser usada a verso da SDK 4.0 (14), garantido que a aplicao vai funcionar sobre esta verso de Android visto ter sido compilada com ela. O maxSdkVersion um atributo raramente usado pois no tem muita lgica o seu uso na generalidade dos casos, visto a plataforma garantir a retro-compatibilidade das aplicaes antigas em verses de Android mais recentes. Portanto uma aplicao com um targetSdkVersion=7 (Android 2.1), vai funcionar da mesma forma na verso de SDK 14 (Android 4.0). No entanto possibilitado ao programador que a sua aplicao s seja executada em terminais at uma determinada verso de Android e para isso deve usar este atributo. Exemplo de uso:

<uses-sdk android:minSdkVersion="7" android:targetSdkVersion="14" />

x. Uses-configuration
Com esta tag, define-se que tipo de hardware, nomeadamente em termos de controlo do utilizador, uma aplicao necessita. Existem 5 atributos que podem ser definidos dentro desta tag que so: reqFiveWayNav, reqHardKeyboard, reqKeyboardType, reqNavigation, reqTouchscreen. A mair parte dos atributos explicam-se automaticamente pelo nome deles tirando o reqFiveWay que diz respeito a um controlo como um D-Pad, ou uma TrackBall18, que permita ao utilizador o input direcional (cima, baixo, esquerda, direita) e clique; o atributo reqNavigation no diz respeito navegao GPS mas sim a algo parecido com o reqFiveWay, mas especificando exatamente que tipo de controlo se quer (D-Pad, TrackBall, ). Este atributo tem a particularidade de se poder definir mltiplas vezes, significando que a aplicao suporta vrios formas de input do utilizador. Como exemplo, uma aplicao que necessite dum touchscreen que possa ser usado por uma caneta stylus e um teclado QWERTY ou um teclado numrico, teria esta definio:

<uses-configuration android:reqTouchScreen="stylus" android:reqKeyboardType="qwerty" /> <uses-configuration android:reqTouchScreen="stylus" android:reqKeyboardType="twelvekey" />

y. Uses-feature

Esta tag usada para definir que hardware, e em alguns casos que stack de software, a aplicao necessitar para funcional corretamente e ainda se mesmo necessria ou no. Existem muitas

18

Esta caracterstica de hardware pouco comum na generalidade dos novos dispositivos

Android, e portanto de carcter opcional.

possibilidades para esta tag, e descreve-las todas aqui seria demasiado extenso, mas por exemplo uma aplicao que tire fotografias que incorpore geo-tagging (localizao da fotografia nos metadados da mesma) caso exista sistema de localizao no dispositivo, necessitar pelo menos de usar a cmara e obter a localizao. Como tal necessitaria de declarar no seu Manifest, que usa uma cmara e que usar um sistema de localizao se disponvel. Seria ento definido assim:

<uses-feature android:required="false" android:name="android.hardware.location"/> <uses-feature android:required="true" android:name="android.hardware.camera"/>

z. Supports-screens
Esta tag explicar-se a sim mesma. Serve simplesmente para definir que tipo de ecrs a aplicao suporta. Se uma aplicao poder funcionar em todo o tipo de ecrs, a definio seria assim:

<supports-screens android:largeScreens="true" android:xlargeScreens="true" android:smallScreens="true" android:normalScreens="true" android:anyDensity="true" />

aa. Application
Aqui define-se a aplicao em si, que Activities fazem parte dela, Services, Receivers, Providers, etc. Todo um conjunto de componentes e propriedades, que interligados entre si formam a aplicao.

Exemplo de uso:

<application android:icon="@drawable/ic_launcher"

android:label="@string/app_name" > <activity android:label="@string/app_name" android:name=".HelloWorldActivity" > <intent-filter > <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application>

Classe application
A classe Application serve para manter um estado global sobre a aplicao em si. Pode ser usada muito facilmente, acabando muitas vezes por ser bastante til para partilhar objetos e propriedades entre vrios componentes ( Services, Activities, etc). Para a usar tem que a definir no AndroidManifest.xml dentro da tag <application> como elemento. Por exemplo:

<application android:name=".MyApp"> [] </application>

Seguindo o exemplo declarado no AndroidManifest em cima, deverse- criar uma classe que por sua vez estende a classe Application com o nome MyApp. De notar que esta classe instanciada primeiro que qualquer outro objeto da aplicao ficando portanto desde logo disponvel para ser usada quando necessrio pelo programador. Como exemplo, se quiser partilhar um valor por toda a aplicao e para evitar ter que definir esse valor em todas as classes que o requerem, poderia proceder da seguinte forma:

public class MyApp extends Application {

private static MyApp singleton; private int mSharedNumber = 5; public static MyApp getInstance() { return singleton; } @Override public void onCreate() { super.onCreate(); singleton = this; } public int getSharedNumber() { return mSharedNumber; } }

Utilizando o princpio dos singletons19, em que cada classe s poder ter uma nica instanciao, podemos muito facilmente obter o desejado: o acesso ao valor partilhado em qualquer componente da aplicao. Portanto, num caso tpico em que fosse necessrio aceder ao valor partilhado, teria simplesmente que fazer o seguinte:
int x = MyApp.getInstance().getSharedNumber();

Claro que este tipo de utilizao serve para partilhar um ou mais objetos por toda a aplicao usando exatamente o mesmo mtodo, e no est limitado ao uso deste exemplo. A classe Application, pode tambm controlar a forma de como e quando libertar memria quando o Sistema est a precisar. A plataforma avisa todas as aplicaes em execuo que precisa de memria, para que estas removam alguns dos seus objetos evitando assim ser terminadas pelo sistema, mas cabe ao utilizador especificar o comportamento desta ao. Para tal, basta substituir (override) a funo onLowMemory() na classe Application criada. Exemplo:

19

http://en.wikipedia.org/wiki/Singleton_pattern

@Override public void onLowMemory() { // Limpar alguns objetos de memria }

5
O que so views

CAMADA DE UI DE ANDROID
6

CONCEITOS BASE

Neste captulo damos-lhe a conhecer as bases aplicacionais da plataforma Neste captulo ir ficar com uma noo das componentes Interface Grfica (GUI ou apenas UI) da plataforma Android, como se relacionam entre elas, e de como usar alguns sistemas de alerta (caixas de dilogo, notificaes) usando as ferramentas base que a plataforma disponibiliza.

Views so o elemento base das aplicaes Android e basicamente so tudo o que se v no ecr. Existem tambm algumas Views que no se vm como so o caso dos Layouts como ver a seguir. Portanto, caixas de texto (TextView), caixas de entrada de texto (EditText), imagens (ImageView), botes (Button), listas (ListView), etc., so tudo views que podem ser usadas numa aplicao Android e que compem a interface para o utilizador. Uma aplicao Android usar as Views que necessitar para alcanar o seu objetivo e no h nenhuma que seja de uso obrigatri, at porque por exemplo existem aplicaes que correm nos terminais como servios e que no tm qualquer interao direta com o utilizador, portanto essas no usaro Views. Uma View portanto a classe base duma grande parte das classes disponveis na plataforma e sendo base define vrias coisas que importante saber e que comum a todas as Views: Posio Tamanho Propriedades bsicas comuns (Visibilidade, Focus, etc.) Desenho da View Eventos

Existem muitas mais propriedades que so comuns a todas as Views, mas estas so as que mais se usam no desenho e construo da interface. sempre necessrio ter em conta o tamanho que vai ocupar no ecr, o seu posicionamento relativo a outras Views, como so organizadas no ecr (usando vrios tipos de Layouts), se est visvel para o utilizador ou se invisvel ficando visvel aps algo acontecer na aplicao, isto tudo para que o utilizador tenha uma experincia de utilizao do terminal e especialmente da aplicao que se est a cria, fluda e que no seja confusa. Outro aspeto muito especial das Views o tratamento de eventos, por exemplo: OnTouch e OnFocus. Estes exemplos mais genricos e comuns a todas as Views, fazem parte da classe me View, mas outras Views descendentes (directa ou indiretamente) desta classe adicionam novos eventos que muitas vezes vo ser usados, como por exemplo o OnKeyDown da View de nome TextView.

FIGURA 5.4 - Exemplo de algumas Views dentro da mesma Layout

(TextView, Button, EditText, ImageView, CalendarView)

Layouts
Layouts so Views especiais que vo organizar outras Views de maneira a que fiquem dispostas da forma que deseja no ecr. um conjunto de Layouts que define como uma Activity ou um Widget mostram o seu contedo. Pode-se dizer portanto que os Layouts so o esqueleto onde todas as outras Views vo assentar. Para maior facilidade e portabilidade, todos os Layouts devem ser definidos em ficheiros XML, contudo possvel criar um Layout completamente em cdigo mas este caso no vai ser coberto neste livro. A questo da portabilidade bastante importante porque estando definido o Layout em XML, facilmente se agarra nesse ficheiro e se adapta para outro tipo de terminal ou para vrios tipos de display (como por exemplo Portrait vs. Landscape), j para no falar que permite

tirar partido da seleo adquada do layout correto que fornecido pela gesto de recursos como foi apresentada em captulos anteriores. Em tempo de edio, algo que achar bastante til quando desenhado um Layout usando o Eclipse o Outline que normalmente se encontra no lado direito quando se est a editar um ficheiro. Quando o ficheiro um XML que define um Layout, o Outline mostra a estrutura do Layout sendo fcil visualizar a estrutura que estamos a criar.

FIGURA 5.2 - Estrutura do ficheiro main.xml de um HelloWorld

Existem ento vrios tipos de Layouts e neste captulo sero abordadosos mais usados nas aplicaes bem um exemplo para cada. O Layout mais simples de todos o FrameLayout. o mais simples porque a organizao dele muito bsica: Todas as Views descendentes deste Layout, so posicionadas no topo superior esquerdo do Layout ficando portanto umas por cima das outras caso haja mais que uma. particularmente til para espaos vazios numa Activity, que pode ser posteriormente preenchido com uma imagem que pode variar, por exemplo, consoante algo que tenha sido selecionado.

FIGURA 5.3 - FrameLayout com duas imagens

Provavelmente, o Layout mais utilizado em Android o LinearLayout. Basicamente este Layout permite dispor as Views descendentes todas seguidas umas s outras podendo ser orientado vertical ou horizontalmente de acordo com a escolha do programador, bastando para isso

alterar o atributo android:orientation para vertical ou horizontal respetivamente. A figura 5.4 evidencia a forma como a orientao afecta a disposio visual.

FIGURA 5.4 - Duas LinearLayout com a mesma definio,

mas orientaes diferentes

Outro Layout que til o TableLayout. Este layout tem como principal caracterstica a de organizar as suas Views descendentes num formato tabular; para o efeito o TableLayout axuliado com outra View que a TableRow. Ao usar ambas pode ento criar Layouts que se cuja disposio dos elementos se paream com uma tabela. Ainda que sendo uma tabela, h coisas que no se conseguem fazer como por exemplo expandir uma clula para ocupar vrias colunas (como em HTML). Em baixo ver a figura 5.5 e o exemplo 5.1 que corresponde ao cdigo XML que deu origem ao resultado da dita figura.

A tabela criada ter tantas colunas quantas a linha com mais colunas tiver, e no apresentar qualquer tipo de linhas de separao entre as clulas.

FIGURA 5.5 - Outline e resultado dum TableLayout

EXEMPLO 5.1 <?xml version="1.0" encoding="utf-8"?> <TableLayout xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/tableLayout1" android:layout_width="fill_parent" android:layout_height="fill_parent" android:stretchColumns="1" > <TableRow android:id="@+id/tableRow1" android:layout_width="wrap_content" android:layout_height="wrap_content" > <TextView android:id="@+id/textView1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Linha1 Coluna1" /> <TextView android:id="@+id/textView2" android:layout_width="wrap_content" android:layout_height="wrap_content"

android:layout_gravity="right" android:text="Linha1 Coluna2" /> </TableRow> <TableRow android:id="@+id/tableRow2" android:layout_width="wrap_content" android:layout_height="wrap_content" > <TextView android:id="@+id/textView1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Linha2 Coluna1" /> <TextView android:id="@+id/textView2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="right" android:text="Linha2 Coluna2" /> </TableRow> </TableLayout>

Outro tipo de layout bastante popular o RelativeLayout. Dever evitar o seu uso se for possivl produzir o mesmo efeito com recurso a outro tipo de Layout visto que pode ficar completamente diferente daquilo que deseja dependendo do tipo de ecr do terminal, e tambm porque se tiver muitos descendentes deste Layout o cdigo torna-se mais difcil de ler. Este tipo de Layout funciona posicionando os seus descendentes relativos uns aos outros. Por exemplo, diz-se que uma determinada TextView est esquerda duma EditText. A associao feita com recurso propriedade android:id que o programador define manualmente. Sabendo isto, s vezes poderse- deparar com o problema de dependncia circular que quando dois descendentes deste Layout se referenciam um ao outro tornando assim impossvel a criao do Layout. No entanto,

consegue ser um Layout que bom de usar em casos simples em que o posicionamento relativo essencial. O exemplo da figura 5.6 (investigue o cdigo que o originou no exemplo 5.2) poderia ser obtido com recurso exclusivo a LinearLayout, sendo que nesse caso teria de conter 1 LinearLayout me, e 2 LinearLayout filhos para cada linha. Ou seja, o 1 trataria da disposio vertical e os outros dois da disposio horizontal de componentes.

FIGURA 5.6 - Outline e resultado dum RelativeLayout

EXEMPLO 5.2 <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/relativeLayout1" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:id="@+id/textView1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_alignParentLeft="true" android:text="TextView1" /> <EditText android:id="@+id/editText1" android:layout_width="fill_parent"

android:layout_height="wrap_content" android:layout_alignParentTop="true" android:layout_toRightOf="@+id/textView1" android:inputType="textPersonName" /> <TextView android:id="@+id/textView2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@+id/editText1" android:text="TextView2" /> <EditText android:id="@+id/editText2" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_alignLeft="@+id/editText1" android:layout_alignParentRight="true" android:layout_alignTop="@+id/textView2" android:inputType="textPassword" /> </RelativeLayout>

Com o ICS20 veio um novo Layout que veio resolver algumas dificuldades que existiam quando se tentavam criar certos tipos de layouts com o Layouts existentes at ento. Este novo tipo, o GridLayout, tenta juntar o melhor de dois mundos, do LinearLayout e do TableLayout (ambos falados anteriormente). Consegue-se por exemplo, alinhar Views quer verticalmente quer horizontalmente com outras Views (alinhar e no posicionar como no RelativeLayout). Conseguese tambm criar layouts mais complexos sem ter uma estrutura demasiado complexa, que acaba comprometer a performance.

20

Ice Cream Sandwich

Sendo baseado no LinearLayout, consegue-se muitas vezes simplesmente renomear a tag LinearLayout por GridLayout e obter a mesma IU21 que estava anteriormente mas com todas as otimizaes disponibilizadas pelo GridLayout. Umas das melhorias que traz relativamente ao TableLayout, a possibilidade das Views descendentes poderem ocupar mais que uma clula (Span) .
Para uma descrio mais extensa deste novo Layout, sugere-se a leitura (em Ingls) da seguinte publicao no Blog dos Android Developers: http://android-developers.blogspot.com/2011/11/new-layoutwidgets-space-and-gridlayout.html

FIGURA 5.7 - Outline e resultado dum GridLayout (cdigo no exemplo 5.3)

EXEMPLO 5.3 <?xml version="1.0" encoding="utf-8"?> <GridLayout xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/gridLayout1" android:layout_width="fill_parent" android:layout_height="fill_parent" android:columnCount="4" > <TextView android:id="@+id/textView1" android:layout_column="0" android:layout_columnSpan="2"

21

Interface de Utilizador

android:layout_row="1" android:text="Nome de Utilizador" /> <EditText android:id="@+id/editText1" android:layout_column="3" android:layout_gravity="fill_horizontal" android:layout_row="1" android:inputType="textEmailAddress" > </EditText> <TextView android:id="@+id/textView2" android:layout_column="1" android:layout_gravity="right" android:layout_row="3" android:text="Password" /> <EditText android:id="@+id/editText2" android:layout_column="3" android:layout_gravity="fill_horizontal" android:layout_row="3" /> <Space android:layout_width="1dp" android:layout_height="21dp" android:layout_column="0" android:layout_gravity="fill_horizontal" android:layout_row="0" /> <Space android:layout_width="21dp"

android:layout_height="1dp" android:layout_column="0" android:layout_row="0" /> <Space android:layout_width="10dp" android:layout_height="1dp" android:layout_column="2" android:layout_gravity="fill_horizontal" android:layout_row="0" /> <Space android:layout_width="1dp" android:layout_height="10dp" android:layout_column="0" android:layout_gravity="fill_horizontal" android:layout_row="2" /> </GridLayout>

Menus
Existem dois tipos de Menus em Android, os contextuais (os que aparecem quando o utilizador carrega no boto fisico de Menu do dispositivo) e os Menus de prefncias (tal como o nome sugere so os menus da preferncias da aplicao). Os menus fazem parte de quase todas as aplicaes Android e so uma ferramenta bastante til quando queremos adicionar funcionalidades variadas dentro da mesma Activity. Existem dois tipos de menus: Contextuais e de Preferncias, este ltimo subdividindo-se em menus prHoneycomb (Android 3.0) e menus Honeycomb ou superior. A diferena entre estes dois ltimos a sua localizao, sendo que os pr-Honeycomb aparecem na parte inferior do ecr, e os Honeycomb na parte superior-direita. Felizmente a API bastante simples e muito intuitiva para a criar todos os tipos de Menus.

Para criar um Menu de Preferncias pode, e deve, usar um ficheiro XML dentro da diretoria res/menu. Para isso usa-se um pequeno assistente disponvel no Eclipse acedendo ao menu File (Ficheiro) New (Novo) Android XML File (Ficheiro XML Android).

FIGURA 5.8 - Assistente de criao dum ficheiro XML para Menus

Deve ser selecionado o Resource Type (Tipo de Recurso) Menu, e dado um nome ao ficheiro que termine em .xml .

aconselhado usar o nome da Activity no nome do ficheiro para mais fcil identificao do menu.

Aps clicar em Finish (Concluir), ir ser levado para a rea de edio do novo ficheiro XML que ir definir um Menu para ser usado numa Activity. Como exemplo, use o contedo do exemplo 5.4.

EXEMPLO 5.4 <?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/menu_partilhar" android:icon="@android:drawable/ic_menu_share" android:title="@string/partilhar" />

<item android:id="@+id/menu_ajuda" android:icon="@android:drawable/ic_menu_help" android:title="@string/ajuda" /> <item android:id="@+id/menu_guardar" android:icon="@android:drawable/ic_menu_save" android:title="@string/guardar" /> </menu>

Portanto agora, para se usar o menu na Activity que se deseja basta fazer Inflate (inflacionar no sentido de usar o XML para contruir as componentes visuais), tal como demonstrado no exemplo 5.5.
EXEMPLO 5.5 /* Cria um menu para esta Activity a partir dum XML */ @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menusactivity_menu, menu);

return true; }

Da prxima vez que for executada a aplicao num terminal (ou emulador), pode-se pressionar a tecla Menu que um menu como o da figura 5.9 aparecer no ecr:

FIGURA 5.9 - Screenshot do Menu criado acima

O menu criado no executa nada, ou seja, apenas diz ao sistema, que quando a tecla Menu for pressionada, o menu que deve aparecer aquele, composto por 3 botes, com aquele texto e aquelas imagens. Para que quando se clique num boto seja executado algum cdigo tem que se definir um novo mtodo na classe que define a Activity em questo que se chama OnOptionsMenuSelected. Este mtodo de Callback sempre executado quando pressionado um boto presente no menu, neste caso, no boto Partilhar, Ajuda ou Guardar. Em suma a estrutura do processamento do toque dos botes ser semelhante ao apresentado no exemplo 5.6.
EXEMPLO 5.6 @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.menu_partilhar: { /* Executar o cd respetivo */ return true; }

case R.id.menu_ajuda: { /* Executar o cd respetivo */ return true; } case R.id.menu_guardar: { /* Executar o cd respetivo */ return true; } }

return false; }

Como cada opo do menu tem um cdigo (um valor do tipo constante Integer) atrbudo, podemos usar uma estrutura switch/case para facilmente saber que boto foi pressionado e assim executar o cdigo adequado. A razo do mtodo retornar um valor do tipo Boolean serve para saber se aquele clique foi ou no tratado. Devolvendo false, o sistema informado que a Activity no tratou o clique e ento vai percorrer toda a hierarquia de Views at algum o tratar. Se for retornado true, ento quer dizer que a Activity tratou o clique e o sistema no precisa de fazer mais nada para tratar aquele clique. Agora j consegue criar um menu e executar algo quando dispoltado um evento de toque em alguma das suas opes, mas e se for preciso alterar a disponibilidade das opes consoante um determinado estado da aplicao? Num exemplo prtico, pode-se ter uma opo de criar uma nova entrada num histrico apenas se no estiver em modo de edio de uma entrada. Contrariamente ao que se possa pensar, editar o object Menu no mtodo onCreateOptionsMenu para ativar ou desativar uma opo no ir funcionar, isto porque este mtodo s executado quando pressionada a tecla Menu pela primeira vez nas verses de Android pr-Honeycomb, ou assim que a Activity criada em Honeycomb ou superior, pelo que s executado uma nica vez. Tem-se ento outro mtodo para controlar o Menu sempre que ele aberto que a OnPrepareOptionsMenu.
EXEMPLO 5.7

@Override public boolean onPrepareOptionsMenu(Menu menu) { Random generator = new Random(System.currentTimeMillis()); int x = generator.nextInt(10);

MenuItem BotaoPartilhar = menu.findItem(R.id.menu_partilhar);

BotaoPartilhar.setEnabled(x < 5);

return true; }

No exemplo 5.7, o boto partilhar vai ficar ativo 50% das vezes que for pressionado a tecla Menu. Para isso, gerado um nmero aleatrio entre 0 e 9:
Random generator = new Random(System.currentTimeMillis()); int x = generator.nextInt(10);

Depois vai-se buscar o objeto que identifica o boto que quer controlar:
MenuItem BotaoPartilhar = menu.findItem(R.id.menu_partilhar);

E por fim, ativar ou desativar conforme o valor obtido em cima aleatoriamente:

BotaoPartilhar.setEnabled(x < 5);

Como j se deve ter apercebido, a API Android bastante simples e fcil de entender, e agora vem mais um exemplo disso mesmo. Para transformar o menu anterior numa opo de destaque em Honeycomb ou superior basta adicionar o seguinte atributo a cada Item definido no ficheiro XML correspondente ao menu:
android:showAsAction="ifRoom"

ifRoom

Coloca a opo do menu destacado na Action

Bar caso haja espao nesta de maneira a no colidir com outras Views nela existentes Caso a opo seja colocada num local de withText destaque, colocar tambm texto. (caso contrrio, apenas o icon ir aparecer)
TABELA 5.2 Valores mais utilizados no atributo

Se adaptar o exemplo de menu anterior para Honeycomb ou superior, ficaria semelhante ao exemplo 5.8.
EXEMPLO 5.8 <?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/menu_partilhar" android:icon="@android:drawable/ic_menu_share" android:title="@string/partilhar" android:showAsAction="ifRoom|withText" /> <item android:id="@+id/menu_ajuda" android:icon="@android:drawable/ic_menu_help" android:title="@string/ajuda" android:showAsAction="ifRoom" /> <item android:id="@+id/menu_guardar" android:icon="@android:drawable/ic_menu_save" android:title="@string/guardar" android:showAsAction="" /> </menu>

Note as alteraes aos elementos Item e os respetivos valores do exemplo 5.8. Quando executado num terminal Honeycomb, produzido este resultado:

FIGURA 5.10 - Screenshot do Menu criado em Honeycomb

Para comparao, fica um screenshot na figura 5.11 do mesmo menu mas sem as alteraes para Honeycomb ou superior, ou seja, sem o atributo android:showAsAction .

FIGURA 5.11 - Screenshot do Menu sem alteraes criado em Honeycomb

Mais diferente ainda, se a aplicao no estiver a ser compilada com um SDK Android 3.0 ou superior. Nesse caso o resultado seria semelhante ao da figura 5.12.

FIGURA 5.12 - Screenshot do Menu compilado para uma verso Android pr-Honeycomb

Caixas de Dilogo
As caixas de dilogo so normalmente utilizadas para alertar o utilizador de que algo est para acontecer mas que precisa de uma deciso da sua parte. So tambm usadas quando ocorre algum problema e o utilizador tem de ser notificado disso. Em Android, temos a possibilidade de criar vrios tipos de caixas de dilogo consoante a sua finalidade, no entanto a maneira de criar e mostar qualquer desses tipos (que ir ver j de seguida) sempre a mesma. Os mtodos a ter em conta so:
protected Dialog onCreateDialog(int id) protected void onPrepareDialog(int id, Dialog dialog)

O primeiro mtodo responsvel pela criao do objeto do tipo Dialog. portanto executado apenas uma vez mesmo que a caixa de dilogo seja mostrada vrias vezes durante a utilizao da aplicao. O segundo mtodo permite que a caixa de dilogo seja alterada antes de ser mostrada ao utilizador, por exemplo, quando se quer ativar ou desativar um boto na caixa de dilogo consoante algo esteja ativo na aplicao, e executado sempre que a caixa de dilogo mostrada. Sendo que os dois mtodos em cima referidos fazem parte do ciclo de criao da caixa de dilogo e apresentao ao utilizador, existem dois mtodos para esconder a caixa de dilogo novamente:
dismiss() dismissDialog(int id)

A diferena entre os dois mtodos, que o primeiro usado dentro do objeto do tipo Dialog, e o segundo, dentro dum objeto do tipo Activity. Qualquer um dos dois produz o mesmo efeito que esconder a caixa de dilogo. Para mostrar a caixa de dilogo em si, basta usar o mtodo showDialog(int id). A melhor forma de implementar os mtodos de criao da caixa de dilogo atravs do uso de uma estrutura switch case. Usando esta estrutura pode duma forma muito simples e percetvel criar Dialogs. Comea-se por definir uma (ou mais) varivel global com um Id nico de maneira a identificar a caixa de dilogo, tal como ilustrado no exemplo 5.9.
EXEMPLO 5.9 private static final int DIALOG_HELLO_WORLD = 0;

Depois s implementar pelo menos o mtodo de criao do Dialog em si, tal como ilustrado no exemplo 5.10.
EXEMPLO 5.10 @Override protected Dialog onCreateDialog(int id) { Dialog dialog;

switch (id) { case DIALOG_HELLO_WORLD: { // Criar o Dialog aqui break; } default: dialog = null; } return dialog; }

Com isto feito, apenas falta ver como criar o objeto Dialog. Como falado anteriormente existem vrios tipos de caixas de dilogo em Android, sendo elas: AlertDialog ProgressDialog CustomDialog

bb. AlertDialog
A classe AlertDialog muito mais genrica do que o nome faz parecer, sendo capaz de criar qualquer tipo de caixa de dilogo e no apenas algo do tipo Alerta. Para dar um exemplo de como fcil e til este tipo de caixa de dilogo, seguem-se trs exemplos bastante comuns: mensagem com resposta (sim/no); lista de itens dos quais o utilizador deve escolher um; lista de itens dos quais o utilizador deve escolher vrios ou nenhum. No exemplo 5.11 apresentada uma mensagem de resposta (sim/no), o resultado visual produzido ser semelhante ao da figura 5.13.
EXEMPLO 5.11 private Dialog criarDialogoComMessagem() { AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Ol Mundo") .setMessage("O dia est bom?") .setCancelable(false) .setIcon(android.R.drawable.ic_dialog_info) .setPositiveButton("Sim", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Fazer alguma coisa com este clique dialog.dismiss(); } }) .setNegativeButton("No, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Fazer alguma coisa com este clique

dialog.dismiss(); } });

return builder.create(); }

FIGURA 5.13 - AlertDialog com dois botes de resposta

Como pode ver bastante simples criar um caixa de dilogo. Comeamos por criar um objeto do tipo AlertDialog.Builder que recebe como parmetro um objeto do tipo Context, que neste caso o contexto da Activity atual. Depois criada a caixa de dilogo atribuindo-lhe um ttulo e uma mensagem. O mtodo setCancelable serve para prevenir o utilizador de pressionar a tecla Back e deste modo cancelar a caixa de dilogo. Neste caso prevenimos o utilizador de o fazer de modo que vai ter sempre de responder Sim ou No para prosseguir com a utilizao da aplicao, a menos que a volte a iniciar do zero. De seguida atribudo um icone caixa de dilogo e por fim, criam-se os dois botes de resposta, Sim e No. possvel tambm criar um boto Neutral (setNeutralButton) mas que no foi usado neste exemplo. No caso de ter decidido que o utilizador pode cancelar a caixa de dilogo, em vez de criar um boto para poder detetar quando o utilizador cancela, deve ser usado o mtodo setOnCancelListener como ilustrado no exemplo 5.12.
EXEMPLO 5.12 private Dialog criarDialogoComMessagemCancelavel() { AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Ol Mundo")

.setMessage("O dia est bom?") .setCancelable(true) .setIcon(android.R.drawable.ic_dialog_info) .setPositiveButton("Fechar", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Fazer alguma coisa com este clique dialog.dismiss(); } }) .setOnCancelListener(new DialogInterface.OnCancelListener() { public void onCancel(DialogInterface dialog) { // Utilizador pressionou a tecla BACK cancelando a caixa de dilogo dialog.dismiss(); } });

return builder.create(); }

Veja agora um outro exemplo onde apresentada uma caixa com uma lista de opes em que o utilizador pode escolher uma destas. O cdigo igualmente simples, e pode ser visto no exemplo 5.13 e o respetivo resultado visual produzido na figura 5.14.
EXEMPLO 5.13 private Dialog criarDialogoComTresOpcoes() { final String[] opcoes = { "Ontem", "Hoje", "Amanh" }; AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Escolha uma opo") .setItems(opcoes, new DialogInterface.OnClickListener() {

public void onClick(DialogInterface dialog, int which) { // O item selecionado foi o opcoes[which] dialog.dismiss(); } });

return builder.create(); }

FIGURA 5.14 - Caixa de dilogo com 3 opes

Como pde constatar, foi bastante simples a criao duma caixa de dilogo com uma lista de opes. Foi usado um objeto do tipo AlertDialog.Builder novamente para ajudar na criao da caixa, e usado o mtodo setItems() para associao da lista de itens a um Array com as opes pretendidas, bem como atribuir um mtodo de Callback que executado quando o utilizador seleciona uma das opes. Por fim o exemplo 5.14 mostra como criar uma caixa de dilogo smelhante anterior mas com a possibilidade de escolha mltipla.
EXEMPLO 5.14 private Dialog criarDialogoComMultiplaEscolha() { final String[] opcoes = { "Ontem", "Hoje", "Amanh" }; AlertDialog.Builder builder = new AlertDialog.Builder(this);

builder.setTitle("Escolha uma opo") .setMultiChoiceItems(opcoes, null, new DialogInterface.OnMultiChoiceClickListener() { public void onClick(DialogInterface dialog, int which, boolean isChecked) { // A opo opcoes[which] ficou isChecked } }) .setPositiveButton("OK", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Utilizador carregou no OK dialog.dismiss(); } });

return builder.create(); }

Como se pode reparar, muito parecido ao exemplo anterior mudando basicamente na chamada ao mtodo setMultiChoiceItems() em vez do setItems(), produzindo ento a caixa de dilogo da figura 5.15.

FIGURA 5.15 - Caixa de dilogo de escolha mltipla

cc. Progressdialog
As ProgressDialog so aquelas aquelas caixa de dilogo que aparecem quando est a acontecer alguma coisa em plano de fundo. So usadas para indicar ao utilizador que algo est a acontecer, geralmente associado a alguma tarefa que demore algum tempo a ser efetuada e cuja execuo da aplicao deve ficar parada at que tenha terminado, e deste modo o utilizador no pensa que a aplicao bloqueou, percebendo que est efetivamente a acontecer algo. Existem esencialmente dois tipos destas caixas de dilogo: caixa de progresso indefinido e de progresso definido. A primeira usado quando a operao tem durao indefinida e portanto est-se simplesmente espera que a tarefa acabe; a segunda quando a tarefa tem um tempo de durao que pode ser estimado no inicio da operao, por exemplo quando se carregam 10 imagens, sabe-se que vo ser carregadas 10, logo um processo finito e facilmente representado de forma percentual. Como ver de seguida so ambos fceis de criar. O primeiro exemplo para uma caixa de progresso infinito, veja o exemplo 5.15 e a figura 5.16 que lhe correspondente.
EXEMPLO 5.15 private Dialog criarProgressoInfinito() { ProgressDialog dialog = new ProgressDialog(this); dialog.setMessage("A carregar... Por favor espere."); dialog.setIndeterminate(true); dialog.setCancelable(false);

return dialog; }

FIGURA 5.16 - Caixa de Progresso de tempo indefinido

Como pode verificar ainda mais simples de criar que os anteriores AlertDialog. O mtodo que define que o progresso indeterminado percence ao objecto ProgressDialog e o setIndeterminate(). Uma forma alternativa de criar a mesma caixa de progresso sem ter de usar o mtodo normal (descrito no inicio do captulo) seria como ilustrado no exemplo 5.16.
EXEMPLO 5.16 ProgressDialog.show(this, "", "A carregar... Por favor espere.", true, false);

O mtodo de acesso esttico show() leva como parmetros um Context, um ttulo para a caixa, uma mensagem, se indeterminado ou no e se cancelvel pelo utilizador ou no. Consegue-se portanto substituir um mtodo inteiro com 5 linhas. Todas as chamadas aos outros mtodos (showDialog(), onCreateDialog(), etc.) tambm podem ser chamados de forma esttica, simplificando o trabalho do programador. O outro tipo de caixas de progresso o finito, ou seja quando se sabe partida quanto tempo ir demorar a tarefa que est a ser realizada. Nesse caso substituiria-se o argumento de setIndeterminate() por false, e poder-se-ia especificar o nmero de tarefas a realizar tal como ilustrado no exemplo 5.17 (figura 5.17 ilustra o resultado desse exemplo).
EXEMPLO 5.17 private Dialog criarProgressoFinito() { ProgressDialog dialog = new ProgressDialog(this); dialog.setMessage("A carregar... Por favor espere."); dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); dialog.setIndeterminate(false); dialog.setCancelable(false); dialog.setMax(10);

return dialog; }

FIGURA 5.17 - Caixa de Progresso de tempo definido

A grande diferena para a caixa de progresso indefinido o uso obrigatrio do mtodo setProgressStyle() e a utilizao do mtodo setMax(). O primeiro tem de ser sempre chamado para que a caixa de progresso tenho a aparncia de uma barra horizontal e no de um progresso circular, ou seja no basta alterar o parmetro do mtodo setIndeterminate() para False. O mtodo setMax() serve apenas para mostrar um pequeno contador com a posio corrente e a posio mxima bem como para calcular a percentagem. A atualizao deste tipo de caixa de progresso fica a cargo do programador no sendo algo automtico. No entanto, isso ir ser discutido mais frente no capitulo 12 (Processamento Paralelo).

dd. CustomDialog
Este tipo de caixas de dilogos so para ser usadas quando os outros dois tipos no servem a propsito pretendido do programado por alguma razo. Aqui o aspeto duma caixa de dilogo definido manualmente e segue a mesma metodologia de construo que uma Layout, ou seja preferncialmente ser feito em XM. O exemplo 5.18 define uma ImageView com uma TextView ao lado, usando um LinearLayout com orientao horizontal. O exemplo 5.19 por sua vez demonstra como utilizar a caixa de dialogo do definida no exemplo 5.18. O resultado visual ser semelhante ao da figura 5.18.
EXEMPLO 5.18 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:padding="5dip" android:orientation="horizontal" >

<ImageView android:id="@+id/imageView1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:src="@drawable/ic_launcher" />

<TextView android:id="@+id/textView1" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Ol, isto um CustomDialog" /> </LinearLayout>

EXEMPLO 5.19 private Dialog criarCustomDialog() { Dialog dialog = new Dialog(this); dialog.setTitle("Exemplo"); dialog.setContentView(R.layout.custom_dialog);

return dialog; }

FIGURA 5.18 - Caixa de Dialogo personalizada

Toasts e Notificaes
A plataforma Android fornece vrias formas de alertar o utilizador que algo aconteceu ou est para acontecer. As que mais se usam normalmente so os Toasts, pequenas mensagens que aparecem na parte inferior do ecr centradas, e as notificaes que so mensagens que aparecem na barra de estado (no topo no caso de smartphones, e no canto inferior direito, no caso de tablets). Os dois tipos tm objetivos diferentes. Os Toasts usam-se para mensagens curtas e rpidas e quando se tem a certeza que o utilizador est a olhar para o ecr naquele momento. Isto porque o Toast apenas fica visvel no ecr durante 1 ou 3 segundos (dependendo a construo do Toast), logo se o utilizador no estiver a olhar para o ecr naquele momento, possvel que ele no veja a mensagem que a aplicao lhe est a transmitir. As Notificaes, so usadas quando se quer alertar o utilizador duma coisa que aconteceu ou que vai acontecer, mas que no se consegue garantir que o utilizador est a olhar para ecr ou ento quando preciso uma resposta do utilizador para aquele evento. Um exemplo de quando isto acontece quando se recebe um SMS ou um email. gerada uma notificao que o utilizador tem que ver e tomar conhecimento e s depois que ela desaparece. Tudo o que preciso para criar um Toast e mostr-lo ao utilizador uma linha de cdigo, tal como demonstrado no exemplo 5.20, e o resultado visual resultante ser similar ao da figura 5.19.

EXEMPLO 5.20 Toast.makeText(this, "Bom dia!", Toast.LENGTH_SHORT).show();

FIGURA 5.19 - Exemplo de um Toast

Como pde verificar, a criao mesmo muito simples. Usar o mtodo makeText () da classe Toast com 3 parmetros: Context (a Activity atual), a mensagem a mostrar, e a durao. A durao pode ser LENGTH_SHORT ou LENGTH_LONG, que o primeiro representa 1 e o segundo 3 segundos. Depois, basta chamar o mtodo show() que mostra efetivamente a mensagem no ecr.

J as Notificaes, so um pouco mais complicadas de usar em comparao com os Toasts mas visto que tm objetivos completamente diferentes normal que assim seja. Desta forma do-se bastantes possibilidades aos programadores para fazerem o que precisam sem ter de se complicar muito o cdigo. Para comear, as Notificaes so criadas normalmente por Servios22 que correm em background, porque estes esto sempre a correr no dispositivo mesmo quando est em standby, permitindo assim que as Notificaes sejam sempre geradas. Tambm podem ser lanados dentro duma Activity, mas neste caso apenas podem ser criadas quando a aplicao est a ser mostrada ao utilizador, portanto se algo acontece que fosse preciso gerar uma Notificao e a aplicao no estivesse aberta no seria possvel notificar o utilizador; por exemplo: As Notificaes de SMSs recebidos so sempre geradas, quer o terminal esteja em standby ou no. Isto porque so lanadas por um Servio que est a correr em background, caso contrrio, apenas quando abri-se a aplicao para ver SMSs, que recebia notificaes. Portanto, para criar uma notificao so usados 4 passos: 1. Obter uma referncia para o NotificationManager, que um processo de sistema que gere as notificaes:

NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

2. Criar uma um objeto do tipo Notification:

Notification notificacao = new Notification(R.drawable.ic_launcher, "Ol Android", System.currentTimeMillis()); notificacao.flags |= Notification.FLAG_AUTO_CANCEL;

22

Discutidos em pormenor no captulo 16

Esta alterao das flags necessria para a notificao desaparecer assim que utilizador clica nela. Se, por oposio, a notificao for fixa (nunca desaparece), basta usar a flag FLAG_NO_CLEAR.

3. Criar um PendingIntent para ser executado quando o utilizador clicar na notificao, e atribuir um ttulo e uma mensagem:

Intent intentALancar = new Intent(this, ActividadeNotificacao.class); PendingIntent intentConteudo = PendingIntent.getActivity(this, 0, intentALancar, 0); notificacao.setLatestEventInfo(getApplicationContext(), "Ttulo", "Exemplo de notificao", intentConteudo);

4. Avisar o NotificationManager da nova notificao:

private static final int NOTIFICATION_EXEMPLO = 0; notificationManager.notify(Main.NOTIFICATION_EXEMPLO, notificacao);

A notificao resultante ter um aspect semelhante ao da figura 5.20.

FIGURA 5.20 - Notificao presente na barra de notificaes

No 1 passo, utilizou-se o mtodo getSystemService() para obter uma referncia ao servio de sistema NOTIFICATION_SERVICE. foi criado o objeto que representa a Notificao em si. O 1 e 2 parmetros so referentes ao contedo que aparece na barra de estado quando a notificao mostrada (um cone e uma mensagem de texto). O 3 parmetro quando mostrar a notificao, sendo que pode ser num tempo futuro ou de imediato. No 3 passo, criado o PendingIntent que vai ser executado quando o utilizador clicar na notificao e associado notificao anteriormente criada, juntamente com um ttulo e uma mensagem. No 4 e ltimo passo, passada a informao ao NotificationManager de que existe uma nova notificao do tipo
NOTIFICATION_EXEMPLO que deve ser mostrada na barra de estado. Se por acaso acontecer a

aplicao gerar uma nova notificao sem o utilizador ver a anterior o NotificationManager automaticamente remove a anterior e substitui pela nova. Usando este mtodo, pode-se ainda alterar outros aspetos da notificao, como adicionar o som de notificaes por omisso:
notificacao.defaults |= Notification.DEFAULT_SOUND;

Ou usar um ficheiro de som definido pelo programar:

notificacao.sound = Uri.parse("file:///sdcard/sons/som.mp3");

Pode ainda forar a vibrao do terminal:

notificacao.defaults |= Notification.DEFAULT_VIBRATE;

Ou ainda fazer a luz de notificao do terminal acender:

notificacao.defaults |= Notification.DEFAULT_LIGHTS;

A partir da verso Honeycomb da plataforma Android foi disponibilizada aos programadores uma nova forma de criar as notificaes, muito parecida com a forma como se criam os as Caixas de Dilogos. Neste caso usando a classe Notification.Builder. O exemplo 5.21 mostra um exemplo de como pode criar uma notificao igual anterior usando este novo mecanismo.

EXEMPLO 5.21 private void criarNotificacaoNovoMetodo() { Intent intentALancar = new Intent(this, ActividadeNotificacao.class); PendingIntent intentConteudo = PendingIntent.getActivity(this, 0, intentALancar, 0);

Notification.Builder builder = new Notification.Builder(this); builder.setSmallIcon(R.drawable.ic_launcher) .setTicker("Ol Android") .setWhen(System.currentTimeMillis()) .setAutoCancel(true) .setContentTitle("Ttulo") .setContentText("Exemplo de notificao") .setContentIntent(intentConteudo);

NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE); notificationManager.notify(Main.NOTIFICATION_EXEMPLO, builder.getNotification()); }

Como pode constatar o cdigo mais simples e mais fcil de ler comparado com o outro anterior. O nico problema que esta classe (Notification.Builder) s existe em terminais que estejam a correr a verso Honeycomb ou superior de Android, portanto necessrio ter cuidado quando se decide usar esta nova classe.

COMUNICAO ENTRE
COMPONENTES

Neste captulo sero apresentadas vrias peas fundamentais construo de aplicaes em Android, a comunicao entre componentes. Por componentes entenda-se as vrias Activities, Services e todas as outras constituintes que podem ser os blocos de uma aplicao.

Intents O que so e como utilizar

O conceito de Intent pode ser visto como um mecanismo genrico de invocao de componentes, embora em Android o seu uso seja to verstil que melhor explicado pelo tipo de invocaes possveis. Um Intent pode ser usado para invocar componentes da sua aplicao, tal como de uma Activity passar para outra ou iniciar um Service, mas tambm pode ser usada para invocar aplicaes externas que estejam presentes no sistema operativo, assim como para comunicar com componentes especificas destas ou do prprio Android, tal como evocar um Alarme. Neste sentido pode ser dito que um Intent consome uma ao e produz um efeito. Os dados dessa aco tero influncia no tipo de efeito que produzido. O conceito de Intent est presente at nas mais simples aplicaes, de facto j lidou com eles ainda que talvez no se recorde em que momento. Veja o simples exemplo de quando se define uma Activity tal como a que definimos nos captulos anteriores. O exemplo 6.1 mostra o cdigo de declarao de uma simples Activity e o exemplo 6.2 ilustra a respectiva entrada que seria colocada no AndroidManifest para esta Activity que sendo a nica na aplicao tambm o ponto de entrada da mesma. Como pode ver no Manifest feito uso da sintaxe <intent-filter>, ou seja no Manifest declarado no s que uma Activity existe mas tambm certos aspectos relacionados com a sua inicializao.

EXEMPLO 6.1 import android.app.Activity; import android.os.Bundle;

public class SimpleActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); EXEMPLO 6.2 <activity android:name=".SimpleActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity>

De modo generico para iniciar a Activity declarada no exemplo apresentado a partir de uma outra Activity bastaria enunciar um Intent cuja ao inicar a dita Activity, isto poderia ser feito de forma simples, tal como ilustrado no exemplo 6.3.
EXEMPLO 6.3 String action = com.livroandroid.cap6.SimpleActivity; Intent myIntent = new Intent(action); startActivity(myIntent);

Usar Intents de Sistema

Do que j foi explicado sobre o funcionamento de Intents, faz todo o sentido que no sistema operativo existam certas componentes a tirar partido deste mecanismo, a estes chama-se usualmente Intents de Sistema. So apresentados de seguida 3 exemplos do uso destes (exemplo 6.4), para informaes sobre todos os intents de sistema disponveis a um dado momento visite a pgina oficial23. Nestes exemplos na definio do objecto do tipo Intent passado o tipo de Action (ao a realizar), e de seguida especificado o tipo de dados (setData) para esse mesmo Intent, tal como j deve estar a adivinhar os dados dizem respeito ao tipo de ao. Finalmente ao invocar o mtodo startActivity iniciado o Intent especificado. tambm introduzido neste exemplo o conceito de URI. A definio de dados do Intent no guarda na verdade os dados mas sim um apontador para os mesmos. Nesse sentido um URI funciona de forma semelhante a um URL num browser de Internet, ou seja, um endereo do local onde os dados se encontram, dessa forma para passar dados pelo mtodo setData tem de os encapsular com URI.parse de modo a obter um URI para esses dados especficos.
EXEMPLO 6.4 Intent openWebpage = new Intent(Intent.ACTION_VIEW); openWebpage.setData(Uri.parse("http://www.google.pt")); startActivity(openWebpage); Intent dialNumber= new Intent(Intent.ACTION_DIAL); dialNumber.setData(Uri.parse("tel:118")); startActivity(dialNumber); Intent openGmaps= new Intent(Intent.ACTION_VIEW); openGmaps.setData(Uri.parse("geo:39.63,-7.84?z=6")); startActivity(openGmaps);

23

http://developer.android.com/guide/appendix/g-app-intents.html

Mais sobre Actions

As Actions tal como vimos no exemplo 6.4 indicam o tipo de ao a realizar, mas o tipo de dados juntamente com a Action que fornecem ao sistema operativo a informao necessria para este saber qual a componente a executar. Note que o exemplo de abrir a pgina web e um endereo no Google Maps ambos usam a ACTION_VIEW. Nas aplicaes de destino no Android Manifest que declarado o tipo de dados que uma dada componente aceita. Veja agora o exemplo 6.5. Aqui estamos a definer que a Activity de nome TestActivity pode ser iniciada sempre que alguma aplicao inicie uma Action do tipo ACTION_VIEW em que o tipo de dados seja do tipo http, ou seja esta Activity passaria a funcinar de forma semelhante ao browser de Android para pginas http.
EXEMPLO 6.5 <activity android:name="TestActivity"> <intent-filter> <action android:name="android.intent.action.VIEW" > <data android:scheme="http" /> </action> </intent-filter> </activity>

Para mais informaes sobre que formatos de Intent-Filter existem e das combinaes possvel consulte a documentao oficial24.

Intent Extras
Para alm dos dados de URI, um Intent tambm pode conter informaes adicionais s quais se do o nome de Extras. Os Extras so informaes do tipo pares chave-valor. Os valores podem ser tipos bsicos de Java ou objectos de classes que implementem a interface android.os.Parcelable. A informao contida nos extras contida por um objecto do tipo Bundle, os exemplos 6.6 e 6.7 demonstram como se pode tirar partido desta funcionalidade. Aqui temos duas Activities (uma em cada exemplo), a primeira fornece uma caixa de dilogo em que aguarda pela introduo de texto do utilizador e assim que este toca no boto Seguinte iniciada uma nova Activity (a do exemplo 6.6) que recebe o texto introduzido pelo utilizador na Activity anterior. Este exemplo demonstra assim sucintamente um dos casos tipicos de utilizao de Extras, a transio de dados temporrios entre componentes dentro de uma aplicao. O

24

http://developer.android.com/guide/topics/intents/intents-filters.html

exemplo 6.6 tem um aspeto semelhante ao da figura 6.1, e o cdigo aqui exibido encontra-se dentro do bloco de ao do boto, como a esta altura j tem um entendimento da estrutura de tal cdigo no mostrado o cdigo todo da Activity em questo, no entanto pode consultar o cdigo fonte fornecido com o livro, onde encontrar estes exemplos em projectos de aplicaes completas e funcionais prontas a testar e modificar. De modo anlogo o exemplo 6.7 tem o aspecto da figura 6.2, e o seu cdigo encontrar-se- compreendido no mtodo OnCreate da Activity em que se insere.
EXEMPLO 6.6 EditText userInput = (EditText) findViewById(R.id.et_typeanything); Intent nextActivity = new Intent(ExtrasExample1.this, ExtrasExample2.class); nextActivity.putExtra("TEXTO_A_TRANSITAR", userInput.getText().toString()); startActivity(nextActivity); EXEMPLO 6.7 Bundle extras = getIntent().getExtras(); if (getIntent().hasExtra(PREVIOUS_VALUE)){ TextView tv1 = (TextView) findViewById(R.id.tv_extra_from_previous); tv1.setText(extras.getString(PREVIOUS_VALUE)); }

FIGURA 6.5 Exemplo 6.6

FIGURA 6.2 Exemplo 6.7

Notas Finais sobre Intents

Para terminar este captulo sero referidas algumas informaes de ambito genrico que extendem aquilo que foi dito ao longo do captulo. Tal como j foi referido em captulos anteriores o Android possui vrias componentes aplicacionais, neste catulo vimos ainda que para iniciar uma Activity com um intent pode ser utilizado o mtodo startActivity. De modo anlogo tambm possvel iniciarem-se Services (com o mtodo startService) ou enviar Broadcasts de sistema (com o mtodo sendBroadcast ), ambos consomem um Intent como parmetro em semelhana ao startActivity. Existe um tipo especial de Intent, de nome PendingIntent, que serve essencialmente para agendar a execuo de um Intent num tempo futuro, este mecanismo habitualmente usado com o gestor de alarmes de Android, sendo que este Intent estudado em detalhe no captulo 16.

7
cada dispositivo.

SEGURANA

APLICACIONAL

Neste captulo ser-lhe- explicado o modelo de segurana aplicacional de Android, uma parte fundamental do sistema operativo e muito relevante programao de aplicaes na plataforma. Este modelo estendido desde a fase de desenvolvimento at instalao final da aplicao em

Modelo De Segurana Aplicacional

Para melhor perceber este modelo necessrio falar um pouco de como o Android funciona. Quando uma aplicao instalada em Android -lhe associada um utilizador nico no sistema operativo, isto garante que a no ser que o utilizador explicitamente assim especifique, os dados da aplicao apenas podero ser lidos pela prpria (exceptuando se os dados forem guardados em armazenamento externo ou se a aplicao executar num dispositivo em que as aplicaes podem usufruir de permisses de utilizador Root, o que no acontece por omisso). Para que uma aplicao seja instalvel esta tem de estar assinada de por um certificado digital, isto garante que assim que surja um update da aplicao este s possa ser instalado se a aplicao contiver a mesma assinatura digital, isto garante a fidelidade da mesma. A API de Android extremamente poderosa e abrangente, e algumas funcionalidades fornecidas pelo sistema aos programadores poderiam ser utilizadas para uso mal intencionado. De modo a controlar o acesso a estas funcionalidades e de certo modo a passar o poder de deciso para o lado do utilizador que instalar a aplicao, em Android existe um mecanismo de permisses. De modo simples, quando uma aplicao tenta aceder a uma funcionalidade especifica de Android dever ter declarado no seu Manifest que far uso dessa funcionalidade. Deste modo, em tempo de instalao o utilizador ser notificado de que a aplicao necessita da respectiva permisso, tal como evidenciado na figura 7.1. Se a permisso no for declara no Manifest e o programador fizer uso da mesma, a aplicao fechar abruptamente lanando uma excepo relacionada com o facto de no ter declaro essa permisso no Manifest.

FIGURA 7.1 Exemplo de aviso de permisses de aplicao aquando instalao da mesma

Permisses e Descrio
Tal como referimos anteriormente para usar vrias funcionalidades do sistema necessria a incluso de uma permisso no ficheiro Android Manifest da aplicao. So apresentadas de seguida algumas das permisses existentes mais usadas. Algumas permisses s existem a partir de determinada verso de Android, como o caso da permisso para usar a funcionalidade NFC que s existe a partir da verso Gingerbread de Android. Para uma consulta integral de todas as permisses existentes e a sua descrio consulte a documentao oficial25. No final apresentado um exemplo de como so adicionadas estas permisses ao projecto.

25

http://developer.android.com/reference/android/Manifest.permission.html

ACCESS_NETWORK_STATE

Acesso ao estado de conectividade atual do dispositivo

ACCESS_COARSE_LOCATION

Acesso localizao aproximada do utilizador (tem apenas em conta as clulas de rede e rede Wi-Fi nas imediaes do dispositivo)

ACCESS_FINE_LOCATION

Acesso localizao exacta do utilizador (tem em conta a capacidade de recepo de GPS do dispositivo)

BATTERY_STATS BLUETOOTH

Acesso ao estado da(s) bateria(s) do dispositivo Acesso s capacidades de envio e recepo de dados via Bluetooth

BLUETOOTH_ADMIN

Acesso capacidade de procura e emparelhamento com outros dispositivos Bluetooth

CAMERA INTERNET NFC READ_CALENDAR READ_CONTACTS READ_PROFILE SET_WALLPAPER VIBRATE

Acesso (s) Cmara(s) do dispositivo Acesso a comunicao de rede em geral Acesso funcionalidade de Near Field Communication Acesso ao calendrio do utilizador do dispositivo Acesso lista de contactos do utilizador do dispositivo Acesso informao de Perfil do utilizador Google Acesso capacidade de definir um fundo no Launcher Acesso capacidade de vibrao do dispositivo

Quadro 7.1

Permisses aplicacionais de Android mais frequentemente usadas

Estas permisses tal como referido so declaradas no Android Manifest que como sabe se encontra na raiz de qualquer projecto Android. A figura 7.2 ilustra como pode declarar permisses a partir da interface visual do Manifest no Eclipse, e o exemplo 7.1 mostra o aspecto de tais definies quando vista a um nvel de edio XML.

FIGURA 7.2 Adicionar permisses ao Manifest atravs da interface visual

EXEMPLO 7.1 <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.livroandroid.capitulo8" android:versionCode="1" android:versionName="1.0" >

<uses-sdk android:minSdkVersion="15" /> <uses-permission android:name="android.permission.INTERNET"/>

<application android:icon="@drawable/ic_launcher" android:label="@string/app_name" > <activity

android:name=".MainActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> </manifest>

Neste ltimo exemplo note que a especificao da permisso feita neste linha de cdigo:
<uses-permission android:name="android.permission.INTERNET"/>

Assinar uma aplicao com um Certificado Digital

Tal como foi referido na introduo deste captulo uma aplicao para ser instalada num dispositivo tem de ser assinada digitalmente com um certificado. Pode no estar ciente disso, mas at agora todas as aplicaes que testou tanto no seu dispositivo ou num emulador estavam digitalmente assinadas com um certificado que foi gerado automaticamente aquando a instalao da SDK. Ora este certificado digital no dever ser o que usado para a publicao de aplicaes no Google Play, pois se mais tarde voltar a instalar o SDK o certificado gerado ser diferente e nessa altura se j no tiver o certificado gerado anteriormente fica impossibilitado de publicar actualizaes da aplicao. Para alm disso boa prtica criar um certificado que contenha informaes sobre o autor. De seguida mostramos como possvel usar o Eclipse para criar um certificado e assinar aplicaes com este certificado digital.

Com um qualquer projecto Android aberto, clique em File > Export nos menus do Eclipse. De seguida escolha a opo Export Android Application tal como evidenciado na figura 7.3.

FIGURA 7.3 Caixa de dialogo de exportao do Projecto

De seguida clique em Next para prosseguir, ser-lhe- pedido que selecione o projecto que pretende exportar, clique em Browse... e escolha o nome do projecto pretendido de entre a listagem. Clique de novo em Next, e de seguida ser confrontado com um formulrio em que pode escolher um certificado existente ou criar um novo. Para o efeito didtico vai criar um novo certificado, mas lembre-se que de futuro aps ter criado um certificado para uma aplicao dever usar sempre esse mesmo certificado para produzir a verso final dos APKs da mesma, e em dita altura pode faz-lo clicando no boto Browse... adjacente ao campo Location. Para criar um novo certificado mude primeiro a opo para Create new keystore, de seguida o boto Browse... adjacente ao campo Location permite escolher onde quer guardar o certificado e os dois seguintes campos dizem respeito palavra chave e confirmao da mesma com a qual deseja proteger o certificado. A figura 7.4 mostra um exemplo de preenchimento do formulrio, o nome do certificado e a palavra passe so inteiramente sua escolha.

FIGURA 7.4 Criao de um novo Certificado Digital

De seguida ser-lhe- apresentado um novo formulrio que conter informaes sobre o autor ou entidade responsvel pelo certificado. A figura 7.5 ilustra este formulrio e um exemplo de preenchimento, os 4 primeiros campos so de preenchimento obrigatrio, e tambm necessrio o preenchimento de pelo menos 1 dos consecutivos campos, no exemplo apresentado foi escolhido o Organizational Unit, mas poderia ter sido outro qualquer.

Nota: A validade do certificado deve ser no minmo de 30 anos para que as aplicaes assinadas com este sejam elegveis para publicao no Google Play.

FIGURA 7.5 Informaes do autor ou entidade na criao de um novo Certificado Digital

Clicando em Next chagar finalmente ao passo em que pode escolher o nome do caminho de destino do APK assinado com este certificado. Se tivesse escolhido um certificado existente

apenas lhe teriam sido facultadas as palavras chave do certificado e dos dados deste, e por fim teria um ecr para seleco do caminho de destino do APK igual ao agora apresentado. O ficheiro APK gerado est pronto para publicao.