Post on 17-Aug-2015
FACULDADE DE PINDAMONHANGABA
Juliano Cesar Parro
DESENVOLVIMENTO ANDROID COM ECLIPSE
Pindamonhangaba - SP
2012
Juliano Cesar Parro
DESENVOLVIMENTO ANDROID COM ECLIPSE
Monografia apresentada como parte dos requisitos
para obtenção do Diploma de Bacharel pelo Curso de
Sistemas de Informação da Faculdade de
Pindamonhangaba.
Orientador: Prof. Esp. Reuel Adimar Lopes
Pindamonhangaba - SP
2012
AGRADECIMENTOS
À minha família pela ajuda e pelo incentivo nos estudos, que resultou na conclusão
deste curso.
Ao Professor Esp. Reuel Adimar Lopes pelo interesse em me orientar e pela forma
como ministrou sua disciplina exigindo sempre o melhor de seus alunos buscando enriquecer
nosso conhecimento.
RESUMO
Este trabalho destaca as principais características da plataforma Android e aborda alguns
conceitos sobre o desenvolvimento de aplicativos para dispositivos móveis utilizando o IDE
Eclipse. É aplicada uma metodologia didática com exemplos práticos, focando o aprendizado.
Algumas características do Android são abordadas, como sua arquitetura, componentes
fundamentais de suas aplicações, interface com o usuário e outros recursos. Além de ensinar a
instalar, configurar e utilizar o IDE Eclipse com o plug-in ADT para o desenvolvimento de
aplicativos Android. Ao final, um simples aplicativo Android é desenvolvido e executado em
um dispositivo móvel, desmistificando que desenvolver para Android seja uma tarefa
complexa.
Palavras-chave: Android. Eclipse. Plug-in. ADT. Desenvolvimento. Aplicativo.
ABSTRACT
This paper highlights the main features of the Android platform and discusses some ideas
about developing applications for mobile devices using the Eclipse IDE. It is an applied
teaching methods with practical examples, focusing on learning. Some features of Android
are addressed, such as its architecture, key components of their applications, user interface
and other features. Besides teaching you install, configure and use the Eclipse IDE with the
ADT plug-in for Android application development. Finally, a simple Android application is
developed and implemented on a mobile device, demystifying that developing for Android is
a complex task.
Keywords: Android. Eclipse. Plug-in. ADT. Developing. Application.
LISTA DE ABREVIATURAS E SIGLAS
ADT Android Developer Toolkit
AOSP Android Open Source Project
API Application Programming Interface
APK Android Package
AVD Android Virtual Device
CPU Central Processing Unit
IDC International Data Corporation
IDE Integrated Development Environment
JDK Java Development Kit
JRE Java Runtime Environment
SDK Software Development Kit
SMS Short Message Service
SQL Structured Query Language
USB Universal Serial Bus
LISTA DE FIGURAS
Figura 1 - Smartphone HTC T-Mobile G1 ................................................................. 12
Figura 2 - Gráfico da previsão IDC ............................................................................ 13
Figura 3 - Logo do Android ........................................................................................ 14
Figura 4–Camadas e componentes Android ............................................................. 16
Figura 5 – Saída do comando javac –version no prompt do Windows ...................... 22
Figura 6 - Primeira execução do Eclipse, tela Welcome ........................................... 23
Figura 7 - Gerenciador de SDK do Android com níveis de API selecionados ........... 26
Figura 8 - Tela “Add Site” do Eclipse ......................................................................... 28
Figura 9 - Tela “Install New Software” com o plug-in ADT a ser instalado ................ 29
Figura 10 - Tela “Preferences” do Android com a localização do SDK ..................... 30
Figura 11 - Tela New Android Project ....................................................................... 32
Figura 12 - Tela "Package Explorer" ......................................................................... 34
Figura 13 - Gerenciador de AVD do Android ............................................................. 36
Figura 14 - Caixa de diálogo "Create New Android Virtual Device (AVD)" ................ 37
Figura 15 - Aplicativo criado sendo executado no emulador ..................................... 39
Figura 16 - Tela “Package Explorer” com o Projeto Calculadora .............................. 40
Figura 17 - Figuras sendo criadas no Photoshop ...................................................... 44
Figura 18 - Tela de importação de arquivos .............................................................. 46
Figura 19 - Ícone personalizado do Projeto Calculadora no emulador ...................... 48
Figura 20 - Mensagem de aviso “Campo vazio" ........................................................ 54
Figura 21 - Resultado da assinatura com o comando jarsigner ................................ 65
Figura 22 - Resultado da verificação de assinatura com o comando jarsigner ......... 66
Figura 23 - Resultado do comando zipalign .............................................................. 67
LISTA DE TABELAS
Tabela 1 - Opções do comando keytool .................................................................... 63
Tabela 2 - Opções do comando jarsigner ................................................................. 64
SUMÁRIO
1 INTRODUÇÃO ................................................................................................... 11
1.1 Objetivo do trabalho ................................................................................................ 11
1.2 Dispositivos móveis .................................................................................................. 11
2 ANDROID .......................................................................................................... 14
2.1 Características .......................................................................................................... 15
2.2 Arquitetura ............................................................................................................... 16
2.3 Applications .............................................................................................................. 16
2.4 Application Framework .......................................................................................... 16
2.5 Libraries ................................................................................................................... 17
2.6 Android Runtime ..................................................................................................... 18
2.7 Linux Kernel ............................................................................................................ 19
3 PREPARANDO O AMBIENTE DE DESENVOLVIMENTO ............................... 20
3.1 Instalando o SDK ..................................................................................................... 20
3.2 Instalando o JDK ..................................................................................................... 21
3.3 Instalando o IDE Eclipse ......................................................................................... 22
3.4 Instalando o SDK do Android ................................................................................ 24
3.4.1 ADICIONANDO ALVOS DE COMPILAÇÃO NO SDK DO ANDROID ... 25
3.5 Download e instalação do plug-in ADT ................................................................. 27
3.5.1 CONFIGURANDO O PLUG-IN ADT ...................................................... 29
4 CRIANDO UM PROJETO ANDROID ................................................................ 31
4.1 Criando um Android Virtual Device (AVD) ......................................................... 35
4.2 Executando uma aplicação no AVD ....................................................................... 38
5 CRIANDO O PROJETO CALCULADORA ........................................................ 40
5.1 O arquivo main.xml ................................................................................................. 41
5.2 Criando botões com o componente ImageView .................................................... 42
5.3 Criação das imagens no Photoshop ........................................................................ 43
5.4 Importando imagens ................................................................................................ 44
5.5 Animando os botões ................................................................................................. 46
5.6 Adicionando um ícone a aplicação ......................................................................... 47
5.7 Tratamento de erros ................................................................................................ 49
5.7.1 RESTRINGINDO CAMPOS NUMÉRICOS ............................................ 49
5.7.2 CORRIGINDO ERROS DE CAMPO VAZIO .......................................... 50
5.7.3 RESTRINGINDO EDIÇÃO NO CAMPO RESULTADO ......................... 54
5.8 O arquivo ProjetoCalculadoraActivity.java ......................................................... 55
6 DISPONIBILIZANDO A APLICAÇÃO PARA O PÚBLICO ............................... 61
6.1 Obtendo uma chave privada ................................................................................... 61
6.2 Compilando a aplicação em modo de liberação .................................................... 63
6.3 Assinando a aplicação com a chave privada ......................................................... 63
6.4 Alinhando o pacote APK ......................................................................................... 66
6.5 Executando a aplicação em dispositivos Android ................................................. 67
7 CONCLUSÃO .................................................................................................... 69
REFERÊNCIAS ......................................................................................................... 70
1 INTRODUÇÃO
A plataforma Android continua a crescer, mudar e evoluir em ritmo acelerado, e escrever
sobre Android considera uma série de atualizações, passando por difíceis decisões sobre o que
deve ser deixado de fora do trabalho para ter certeza que ele seja aprovado.
A escolha da plataforma Android para o desenvolvimento deste projeto ocorreu devido às
suas características que fornecem os melhores benefícios em termos de custos, eficiência e
tempo de desenvolvimento esperado até a finalização de um projeto.
A plataforma Eclipse foi escolhida por suportar uma quantidade maior de ferramentas do
SDK Android e outros plug-ins, permitindo ser personalizada de acordo com as necessidades
do desenvolvedor e também por ser o IDE (Integrated Development Environment) mais
utilizado.
1.1 Objetivo do trabalho
Este trabalho tem como objetivo o estudo da plataforma Android e suas principais
características, buscando explorar seus recursos disponíveis para dispositivos móveis.
Contribuindo assim para que este projeto se torne uma fonte de estudos para os interessados
em começar a desenvolver aplicativos para Android.
Além de ensinar a instalar, configurar e utilizar a plataforma Eclipse como um ambiente de
desenvolvimento Android, a criação e disponibilização de um aplicativo Android também é
realizada no decorrer do trabalho.
Vale ressaltar que algumas considerações feitas, são aplicáveis também no desenvolvimento
de aplicativos para dispositivos móveis em geral.
1.2 Dispositivos móveis
Os dispositivos móveis estão cada vez mais poderosos em termos de capacidades de
armazenamento, processamento e comunicação, e mais acessíveis aos consumidores.
Oferecem conectividade e podem ser utilizados nos mais diversos lugares e em qualquer
momento, tornando-se cada vez mais importantes para o uso pessoal e profissional das
pessoas.
Com o aumento da quantidade de dispositivos móveis, o número de plataformas e ambientes
de desenvolvimento, cresce proporcionalmente. Atentas a este mercado em constante
crescimento, diversas empresas, entre elas a Google, se juntaram para formar, em novembro
de 2007, a OHA (Open Handset Alliance) e lançar a plataforma Android, que contribui de
forma significativa na transformação do mercado de celulares e tablets.
Atualmente o grupo conta com 84 empresas do setor tecnológico e de dispositivos móveis que
se uniram para acelerar a inovação em dispositivos móveis, implantando comercialmente
telefones e serviços que utilizam a plataforma Android (OHA, 2012).
Em setembro de 2008 a fabricante HTC lançou nos Estados Unidos o primeiro smartphone
equipado com Android, o T-Mobile G1 (Figura 1), e seis meses após o seu lançamento, já
havia vendido 1 milhão de unidades (Gohring). Posteriormente outras importantes empresas,
entre elas Samsung e Motorola, anunciaram dispositivos equipados com a plataforma.
Figura 1 - Smartphone HTC T-Mobile G1
De acordo com a previsão do IDC (International Data Corporation), o uso do Android
ultrapassará o sistema operacional Windows, e será o sistema mais usado do mundo. A
consultoria divulgou uma previsão que mostra que a Microsoft apresentará uma queda
superior a 10% nos próximos quatro anos; iOS ficará em terceiro (IDC, 2012).
Mesmo com essa queda, 90% dos PCs ainda rodarão o Windows. O aquecido segmento de
smartphones deve crescer mais em relação ao de computadores, fazendo com que o sistema
da Microsoft caia para a segunda posição mundial.
Em termos de plataformas, o IDC espera uma mudança dramática entre 2011 e 2016, com o
Windows na plataforma x86, a liderança de 35,9 % em 2011 passará para 25,1 % em 2016.
Por outro lado, o número de dispositivos Android, irá crescer modestamente de 29,4 % em
2011 para liderar o mercado com 31,1% em 2016 (Figura 2).
Figura 2 - Gráfico da previsão IDC
Com a mobilidade e a conectividade oferecidas por um celular, as ferramentas de
desenvolvimento criadas e disponibilizadas para Android, suportam e facilitam o uso dos
recursos de hardware, tornando mais simples a construção de aplicativos que acessam,
armazenam e processam informações.
2 ANDROID
Android é uma plataforma para dispositivos móveis baseado no sistema operacional Linux,
possui um ambiente de desenvolvimento flexível e poderoso, contém as ferramentas
necessárias para a criação de aplicativos utilizando a linguagem Java, possui suporte a
diversos serviços e hardware, além de ser um sistema de código aberto e livre (Lecheta,
2009).
Figura 3 - Logo do Android
As ferramentas de desenvolvimento de aplicativos são gratuitas e conta com o diferencial
onde ainda é possível substituir facilmente as aplicações nativas e acessar todos os seus
recursos utilizados (Meier, 2009).
Além da prática de boa programação, técnicas de modelagem, noções de lógica e algoritmos,
princípios de interação com usuário e de segurança da informação, o conhecimento na área de
banco de dados faz a diferença e influência positivamente para o produto final obter a
qualidade e o sucesso esperado.
A loja virtual do Android, a Google Play (antiga Android Market), conta com mais de meio
milhão de softwares disponíveis, onde os desenvolvedores podem vender sua aplicação ou
disponibilizá-la gratuitamente para o usuário final, em um modelo semelhante à AppStore,
loja virtual de aplicativos para o iPhone, smartphone da marca Apple.
A plataforma Android possui também outras características interessantes, como a fácil
integração com os serviços oferecidos pelo Google. Além disso, diversas ferramentas estão
disponíveis gratuitamente para os seus desenvolvedores (Meier, 2009).
O AOSP (Android Open Source Project), liderado pelo Google, é encarregado da manutenção
e do desenvolvimento do Android. Muitos fabricantes disponibilizam dispositivos Android no
mercado de todo o mundo, e o seu principal objetivo é construir uma excelente plataforma de
software para os usuários diários. Certo número de empresas tem designado muitos
engenheiros para atingir este objetivo, e o resultado é uma produção completa com qualidade
e um produto de código fonte aberto, com excelente personalização e portabilidade.
2.1 Características
A plataforma Android possui as seguintes características:
Framework simplifica a reutilização e substituição de componentes.
Maquina Virtual Dalvik otimizada para dispositivos móveis.
Browser Integrado baseado no mecanismo de código aberto WebKit.
Gráficos otimizados fornecido por uma biblioteca 2D personalizada; gráficos 3D
baseados na especificação OpenGL ES 1.0 (aceleração de hardware opcional).
SQLite como estrutura de armazenamento de dados.
Suporte a mídias comuns de áudio, vídeo e imagens estáticas (MPEG4, H.264, MP3,
AAC, AMR, JPG, PNG, GIF).
Telefonia GSM (depende do hardware).
Bluetooth, EDGE, 3G, e WiFi (depende do hardware).
Câmera, GPS, bússola e acelerômetro (depende do hardware).
Ambiente de desenvolvimento rico possuindo emulador de dispositivo, ferramenta para
depuração, perfil para memória e desempenho, e um plug-in para eclipse.
2.2 Arquitetura
Na imagem em sequência (Figura 4), são ilustradas as camadas da arquitetura do sistema
operacional Android e seus principais componentes (Developers, 2012).
Figura 4–Camadas e componentes Android
Veja a descrição de cada componente logo abaixo:
2.3 Applications
O Android é disponibilizado com um conjunto de aplicações incluindo um programa cliente
de e-mail, SMS, calendário, mapas, browser, contatos entre outros. Todas as aplicações são
escritas usando a linguagem de programação Java.
2.4 Application Framework
Por ser uma plataforma de desenvolvimento aberta, oferece aos desenvolvedores a
possibilidade de construir aplicações extremamente ricas e inovadoras. Os programadores são
livres para tirar proveito do hardware do dispositivo, acessar informações locais, executar
serviços de segundo plano, definir alarmes, adicionar notificações na barra de status, e muito
mais.
Os desenvolvedores têm acesso total ao mesmo quadro de APIs (Application Programming
Interface) utilizadas pelas aplicações. A arquitetura da aplicação destina-se a simplificar o
reuso de componentes; qualquer aplicação pode publicar as suas características e qualquer
outra aplicação pode então fazer uso dessas características (sujeito a restrições de segurança
impostas pelo framework) (Ableson, Sen, King, & Ortiz, 2011). Este mesmo mecanismo
permite identificar os componentes a serem substituídos pelo usuário.
Basicamente o framework é composto por:
Um rico conjunto de Componentes que podem ser usados para construir a aplicação,
incluindo listas, grades, caixas de texto, botões, e um Web Browser integrado.
Provedores de conteúdos que permitem que os aplicativos acessem dados de outras
aplicações (tais como contatos), ou compartilhem seus próprios dados.
Um Gerenciador de recursos, que dá acesso aos recursos não codificados como strings
locais, gráficos e arquivos de layout.
Um Gerenciador de notificações, que permite que as aplicações exibam alertas
personalizados na barra de status.
Um Gerenciador de atividades que gerencia o ciclo de vida das aplicações e fornece
uma navegação com retorno de pilha.
2.5 Libraries
O Android inclui um conjunto de bibliotecas C/C++ utilizadas por vários componentes do
sistema. Estas características são expostas aos programadores através do framework Android.
Dentre as principais bibliotecas podemos citar:
Biblioteca de sistema C – Uma implementação BSD da biblioteca padrão de sistema C
(libc) voltado para dispositivos embarcados baseados em Linux.
Bibliotecas de mídia – baseada no Packet Video da OpenCORE; as bibliotecas suportam
reprodução e gravação de vários formatos de áudio e vídeo populares, como também
arquivos de imagens estáticas, inclusive MPEG4, H.264, MP3, AAC, AMR, JPG e PNG.
Gerenciador de superfície – administra o acesso ao subsistema de exibição, e de modo
homogêneo, combina camadas gráficas 2D e 3D de múltiplas aplicações.
LibWebCore – um moderno mecanismo de browser com visualização embutida.
SGL – mecanismo gráfico 2D de baixo nível.
Bibliotecas 3D – uma implementação baseada na API OpenGL ES 1.0; as bibliotecas
usam alguma aceleração de hardware 3D (quando disponível ou inclusa), software de
rasterização 3D altamente otimizado.
FreeType – renderização de fonte vetorial e bitmap.
SQLite – um mecanismo de banco de dados relacional poderoso e leve, disponível para
todas as aplicações.
2.6 Android Runtime
O Android inclui um conjunto de bibliotecas de núcleo, que oferece o máximo de
funcionalidade disponível nas bibliotecas de núcleo da linguagem de programação Java.
Cada aplicação Android funciona em seu próprio processo, com sua própria instância da
máquina virtual Dalvik. Dalvik foi escrita para que um dispositivo possa executar múltiplas
máquinas virtuais de forma eficiente. A máquina virtual Dalvik executa arquivos (.dex),
formato otimizado para o uso mínimo de memória. A máquina virtual roda as classes
compiladas em linguagem Java transformadas no formato .dex pela ferramenta "dx Tool".
A Máquina Virtual Dalvik roda sobre o kernel Linux que proporciona funcionalidades e
gerenciamento de memória de baixo nível.
2.7 Linux Kernel
O Android é baseado na versão 2.6 do Linux, assim como o seu núcleo de serviços de
sistema, segurança, gestão de memória, gestão de processos, pilha de protocolos de rede e
modelos de drivers. O kernel também funciona como uma camada de abstração entre o
hardware e o resto da pilha de software.
O capítulo em sequência ensina a preparar o ambiente de desenvolvimento com as
ferramentas necessárias para desenvolver aplicações Android.
3 PREPARANDO O AMBIENTE DE DESENVOLVIMENTO
Esta parte do trabalho ensina a instalar configurar e utilizar as ferramentas para
desenvolvimento de aplicações Android, além das informações necessárias sobre Java para
escrever um código funcional para o Android. Esses tópicos são elementos centrais de
qualquer modelo de aplicativo Android, do sistema de persistência e também da
implementação de padrões de projeto, essenciais em aplicativos Android.
3.1 Instalando o SDK
Este capítulo ensina a instalar o SDK (Software Development Kit, ou Kit de Desenvolvimento
de Software), para Android, e todos os softwares necessários. O objetivo é executar um
simples “Hello world” (“Olá mundo”) em um emulador. O sistema operacional utilizado é o
Windows, mas sistemas Mac OS e Linux também podem ser utilizados para desenvolver
aplicativos Android. Neste texto é explicado como é carregado o software, como é
apresentado às ferramentas do SDK e também é indicado o código fonte de exemplo.
Há muitas instruções que explicam como instalar e atualizar as ferramentas para a criação de
aplicativos Android. O local mais indicado para encontrar informações e links para
ferramentas é o site de desenvolvedores do Android: http://developer.android.com.
Parte deste trabalho guia o processo de instalação, possuindo explicações que ajudam a
compreender como os elementos do Android e suas ferramentas de desenvolvimento se
encaixam.
Primeiramente é necessário possuir instalado dois outros sistemas que não fazem parte do
SDK: o JDK (Java Development Kit, ou Kit de Desenvolvimento Java), e o IDE (Integrated
Development Environment, ou Ambiente de Desenvolvimento Integrado) Eclipse.
Apesar destes dois sistemas não acompanharem o SDK do Android, ambos já podem estar
instalados no sistema, pois também são utilizados com outros propósitos além do
desenvolvimento de sistemas para Android. É comum ocorrer conflitos de versões devido a
instalações redundantes destes sistemas (Mednieks, Dornin, Meike, & Nakamura, 2012).
Muitas versões recentes do IDE Eclipse e do JDK são compatíveis com o SDK do Android. O
ideal é instalar a versão mais atual de cada uma dessas ferramentas, garantindo assim a
compatibilidade entre elas. No site de desenvolvedores do Android são especificados os
requisitos exigidos pelo sistema: http://developer.android.com/sdk/requirements.html.
Outras IDEs além do Eclipse também podem ser utilizadas no desenvolvimento de aplicativos
para Android. Mais informações podem ser obtidas no link:
http://developer.android.com/guide/developing/other-ide.html. A escolha do Eclipse ocorreu
devido ao suporte a uma quantidade maior de ferramentas do SDK Android e outros plug-ins,
sendo também o IDE mais utilizado.
3.2 Instalando o JDK
Caso o sistema já possua o Java Development Kit (JDK) instalado e atualizado, não é
necessário instalar novamente. No JDK há a ferramenta de compilação Java, utilizada pelos
IDEs e SDKs para desenvolvimento de softwares em Java e também há um Java Runtime
Environment (JRE), que executa aplicativos Java no sistema, como o próprio Eclipse por
exemplo.
O JDK pode ser instalado a partir do site da Oracle:
http://www.oracle.com/technetwork/java/javase/downloads/index.html.
Será feito o download automaticamente da versão de acordo com o sistema detectado,
bastando apenas executar o arquivo baixado para instalar o JDK.
Para verificar se o JDK foi instalado corretamente, o comando a seguir é digitado no prompt
de comando do Windows:
javac -version
Este comando mostra o número da versão do JDK instalado (Figura 5).
Figura 5 – Saída do comando javac –version no prompt do Windows
Talvez possa ser necessário adicionar manualmente o diretório bin do JDK no PATH.
3.3 Instalando o IDE Eclipse
A plataforma Eclipse, pode ser utilizada tanto na criação de IDEs (Integrated Development
Environment) para diferentes linguagens, quanto na criação de IDEs personalizadas para
SDKs específicos. Seu uso também se estende a aplicativos além das ferramentas de
desenvolvimento de software, como por exemplo, fornecer uma plataforma de cliente rica
(Rich Client Plataform, ou RPC) para o Lotus Notes, entre outros.
O Eclipse é mais utilizado como IDE para escrever, testar e depurar software Java. Existem
muitos IDEs e SDKs derivados do Eclipse para diferentes tipos de softwares Java.
Neste trabalho é utilizado o pacote Eclipse Java EE Developers com um plug-in para o
desenvolvimento de softwares Android. O download do pacote Eclipse pode ser feito neste
endereço: http://www.eclipse.org/downloads/, onde consta uma lista dos pacotes disponíveis.
Um “pacote” é um conjunto de módulos que torna o Eclipse mais capacitado para certo tipo
de desenvolvimento de software.
O pacote baixado é o Java EE Developers, de acordo com a lista de requisitos do site de
desenvolvedores do Android, as telas capturadas refletem essa escolha. Também é adicionado
o plug-in ADT à instalação do Eclipse.
O site de download do Eclipse detecta automaticamente os downloads disponíveis para o
sistema utilizado, restando escolher apenas entre as versões de 32 e 64 bits, de acordo com a
arquitetura desejada. Após o download do arquivo compactado, o mesmo deve ser extraído
em alguma pasta que o usuário tenha acesso, o executável do Eclipse fica disponível na pasta
extraída.
A instalação do Eclipse é um elemento dentre muitos agrupamentos possíveis de plug-ins, que
o usuário segue personalizando com plug-ins dedicados ao desenvolvimento de software.
Além disso, as atualizações do Eclipse são separadas de outros softwares pelo sistema.
Figura 6 - Primeira execução do Eclipse, tela Welcome
Por ser implementado em Java, o Eclipse requer um ambiente de tempo de execução Java
(Java Runtime Environmente, ou JRE). O JDK instalado fornece um JRE, e caso o Eclipse
não consiga ser executado, a instalação do JDK deve ser verificada.
3.4 Instalando o SDK do Android
Instalados o JDK e o Eclipse, os pré-requisitos para o SDK do Android estão completos. O
SDK do Android é um conjunto de bibliotecas, executáveis, scripts, documentação e outros
tipos de arquivos. Para instalar o SDK é necessário baixar a versão de acordo com a
plataforma utilizada e disponibilizar seus arquivos em uma pasta que o usuário possua acesso.
O download do SDK correspondente ao sistema utilizado pode ser feito através da página:
http://developer.android.com/sdk/index.html. Conforme o tipo de arquivo baixado, ele deve
ser extraído ou instalado dentro de uma pasta definida pelo usuário.
Há duas pastas para ferramentas: uma é a tools, e a partir da versão 8, a outra é a platforms.
Essas pastas devem estar no path (uma lista de pastas onde o sistema pesquisa arquivos
executáveis quando um executável é invocado a partir da linha de comando).
No path do Windows, estas pastas podem ser inclusas clicando em Iniciar, depois com o
botão direito em Meu Computador, e escolhendo a opção Propriedades. Depois na guia
Avançado, e no botão Variáveis de ambiente. Ao clicar duas vezes na variável de sistema
PATH, o caminho das pastas pode ser adicionado. Isso deve ser feito no final do valor dessa
variável (sem alterar nenhuma informação já presente!) adicionando os dois caminhos ao final
da linha, separados por ponto e vírgula, sem espaços em branco antes ou depois deles. Por
exemplo:
C:\Program Files\Android\android-sdk\tools;C:\Program Files\Android\android-sdk\platforms
Após editar o path no Windows, é necessário fechar e abrir novamente os prompts de
comando para que as novas configurações da variável PATH sejam reconhecidas.
3.4.1 ADICIONANDO ALVOS DE COMPILAÇÃO NO SDK DO ANDROID
Alvos de compilação (build targets) necessitam ser instalados antes de criar um aplicativo
Android ou um projeto que crie aplicações desse tipo. Isso pode ser feito utilizando o
gerenciador de SDK do Android (Android SDK Manager). Por meio desta ferramenta,
pacotes que oferecem suporte a diversas versões do sistema operacional Android e vários
níveis de API, podem ser instalados no SDK.
Após a instalação do plug-in ADT no Eclipse (próximo assunto), o gerenciador SDK do
Android pode ser invocado pelo Eclipse, ou pelo seguinte comando:
android
A imagem abaixo (Figura 7) mostra a tela Android SDK Manager com as versões disponíveis
e selecionadas para instalação.
Figura 7 - Gerenciador de SDK do Android com níveis de API selecionados
Os pacotes chamados “SDK platform” suportam a criação de aplicativos compatíveis com
diferentes níveis de API do Android. É altamente recomendado instalar a versão mais recente
(de maior número), e também todos os demais níveis de API disponíveis, bem como, todos os
pacotes de add-ons da Google, caso seja necessário criar aplicativos que possam ser
executados em versões mais antigas do Android. É recomendável instalar as versões mais
recentes do pacote de aplicativos de exemplo e também o pacote SDK Plataform-Tools do
Android.
3.5 Download e instalação do plug-in ADT
Após a instalação dos arquivos do SDK do Eclipse e do JDK, falta o componente crítico a ser
instalado: o plug-in Android Developer Toolkit (ADT), responsável por adicionar
funcionalidades específicas do Android ao Eclipse.
O plug-in ADT agrega ao Eclipse compilação para aplicativos Android, emulador Android
com conexão aos serviços de depuração, edição de arquivos XML do Android, edição e
compilação de arquivos na Linguagem de Definição de Interface do Android (Android
Interface Definition Language, ou AIDL), criação de pacotes de aplicativos para o Android
(arquivos .apk) e outras tarefas específicas.
O assistente Install New Software (Instalar Novo Software) pode ser inicializado através do
menu Help >Install New Software no Eclipse. No campo WorkWith (Trabalhar Com) a URL:
https://dl-ssl.google.com/android/eclipse/, deve ser adicionada (Figura 8), conectando ao
repositório de instalação do plug-in ADT.
Figura 8 - Tela “Add Site” do Eclipse
Mais informações sobre a instalação do plug-in ADT através do assistente “Install New
Software” podem ser encontradas no site de desenvolvedores do Android:
http://developer.android.com/sdk/eclipse-adt.html#downloading. A documentação do Eclipse
sobre este assistente pode ser encontrada no site de documentação do Eclipse:
http://help.eclipse.org/galileo/index.jsp?topic=/org.eclipse.platform.doc.user/tasks/tasks-
124.htm.
Após a URL ser adicionada na lista para aquisição de novos plug-ins, a entrada Developer
Tools (Ferramentas do Desenvolvedor) é mostrada na lista de softwares disponíveis (Figura
9). Ao marcar a caixa de seleção Developer Tools, e avançar, uma tela solicitando o aceite da
licença deste software é mostrada. Ao aceitá-la e clicar no botão finalizar, o plug-in ADT será
instalado. É necessário reiniciar o Eclipse para completar a instalação.
Figura 9 - Tela “Install New Software” com o plug-in ADT a ser instalado
3.5.1 CONFIGURANDO O PLUG-IN ADT
Para concluir a instalação é necessário configurar o plug-in ADT. Após o reinicio do Eclipse,
uma tela de boas vindas ao desenvolvimento Android é mostrada. Nesta tela, a segunda opção
(utilizar o SDK Android existente) é escolhida, informando a localização onde ele está
instalado, neste caso, foi utilizado o diretório padrão: C:\Program Files\Android\android-sdk.
Ao clicar em Next, é perguntado se deseja enviar as estatísticas de utilização ao Google.
Agora diversas partes do Eclipse contêm novas caixas de diálogo, comandos de menus e
outras ferramentas específicas para o desenvolvimento de softwares Android. Através da
caixa de diálogo preferências em Window>Preferences, o item Android localizado no painel
esquerdo da caixa de diálogo preferências mostra um diálogo com as configurações do
Android.
No campo de entrada de texto SDK Location (Localização do SDK), próximo ao topo, deve
ser informado o caminho onde o SDK está instalado. O caminho pode ser digitado, ou
navegado até a sua localização, e depois selecionado seu diretório (Figura 10). Ao clicar em
Apply, os alvos de compilação instalados anteriormente também são listados.
Figura 10 - Tela “Preferences” do Android com a localização do SDK
Agora a instalação do SDK do Android está completa. Para confirmar se tudo está
funcionando corretamente, um simples aplicativo Android será criado no próximo capítulo.
4 CRIANDO UM PROJETO ANDROID
Para desenvolver um aplicativo Android, é necessário criar um projeto Android. O Eclipse
organiza os trabalhos como “projetos”, que neste caso, informa ao Eclipse que o plug-in ADT
e outras ferramentas Android estão presentes neste tipo de projeto. O seguinte endereço
contém mais detalhes sobre a criação de um projeto Android:
http://developer.android.com/guide/developing/projects/projects-eclipse.html.
Um novo projeto pode ser iniciado utilizando o comando de meu File > New > Android
Project. A primeira caixa de diálogo: New Project (Figura 11) surge ao clicar em Next na
opção Android Project da caixa de diálogo New Project sob uma seção intitulada Android.
Figura 11 - Tela New Android Project
Para criar um projeto Android, será necessário fornecer as seguintes informações:
Nome do projeto (Project Name)
Esse não é o nome do aplicativo, mas sim o nome do projeto que surge no Eclipse.
ProjetoTeste foi o nome definido (Figura 11).
Espaço de trabalho (Workspace)
Workspace, ou espaço de trabalho, é a pasta onde ficam armazenados os projetos do Eclipse;
quando um novo projeto é criado, pode ser escolhido o espaço de trabalho atual, ou um novo
local para armazenar o projeto no sistema de arquivos. Por padrão é utilizado à opção (Create
New Project in Workspace e Use Default Location).
Alvo (Target)
As imagens do sistema Android instaladas do SDK ficam disponíveis na lista de alvos de
compilação. Podem ser escolhidas essas imagens, do fornecedor, da versão do sistema
operacional Android e do nível de API correspondente à versão para qual o aplicativo é
desenvolvido. Os parâmetros de maior importância são a plataforma e o nível de API, são eles
que governam a biblioteca da plataforma Android com a qual o aplicativo será compilado e o
nível de API aceito – APIs com um nível mais alto do que o selecionado, não estará
disponível para o programa. O apropriado é escolher a versão do sistema operacional Android
mais recente e o nível de API instalado.
Nome do Aplicativo (ApplicationName)
Este é o nome do aplicativo visualizado pelo usuário (Aplicativo Teste).
Nome do pacote (PackageName)
O nome do pacote cria um espaço de nomes (namespaces) que identifica individualmente
pacotes do aplicativo Android desenvolvido dentre os outros aplicativos instalados. O nome
do pacote é formado exclusivamente pelo nome de domínio de quem publicou o aplicativo
mais um nome próprio definido para o aplicativo. Os namespaces de pacotes não são todos
exclusivos no Java, mas as convenções utilizadas diminuem as chances de conflitos.
Recomenda-se utilizar algo apropriado ao domínio (ou utilizar com.example.apteste, pois
example.com é um nome de domínio reservado a exemplos como esse).
Atividade (Activity)
A atividade é uma interface de usuário de um aplicativo Android correspondente na maioria
das vezes, a um grupo de objetos de interfaces de usuários que ocupam a tela inteira. A
criação do projeto de um aplicativo com interface visual (e não um serviço, que não contém
representação visual na interface do usuário) é uma forma conveniente de criar a atividade
com a qual o aplicativo iniciará. Neste exemplo, é criado uma atividade com o nome
ProjetoTesteActivity.
Versão mínima do SDK (Minimum SDK Version)
O campo Min SDKVersion é utilizado para iniciar o atributo “uses-sdk” no manifesto do
aplicativo (arquivo que armazena os atributos do aplicativo). Ele deve ser preenchido com um
número inteiro que corresponde à versão mínima do SDK necessária para que o aplicativo
funcione. Na maioria das vezes, esse valor corresponde ao nível de API do alvo de
compilação escolhido, visualizado na coluna mais a direita da lista de alvos de compilação.
Ao clicar em finalizar, o projeto Android é criado, podendo ser visto no painel esquerdo do
Eclipse (Figura 12).
Figura 12 - Tela "Package Explorer"
Clicando no sinal de + da árvore é possível ver as várias partes do projeto Android. Ao
expandir a pasta src é possível ver o pacote Java com o nome digitado no assistente.
Expandindo esse pacote é mostrada a classe Activity criada. Clicando duas vezes nela é
mostrado o código Java do programa Android:
packagecom.example.apteste;
importandroid.app.Activity;
importandroid.os.Bundle;
publicclassProjetoTesteActivityextendsActivity {
/** Calledwhentheactivityisfirstcreated. */
@Override
publicvoidonCreate(BundlesavedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Nos capítulos em sequência, será explorado mais um pouco do SDK, executando o programa
em um emulador Android e posteriormente em um dispositivo Android.
4.1 Criando um Android Virtual Device (AVD)
O SDK do Android fornece o emulador de um dispositivo com uma CPU ARM executando
um sistema operacional Android para testar os aplicativos no computador. O dispositivo
virtual Android (Android Virtual Device, ou AVD) é um conjunto de parâmetros que
configura o emulador para utilizar uma versão específica do sistema operacional Android e
configura o tamanho da tela, o tamanho da memória e outras características do hardware
emulado. A documentação mais detalhada sobre AVDs está disponível em:
http://developer.android.com/guide/developing/tools/emulator.html.
Utilização do gerenciador de AVD do Android (Figura 13), para executar o programa de
exemplo criado anteriormente com o assistente New Android Project.
Figura 13 - Gerenciador de AVD do Android
A imagem de sistema do AVD não deve ser mais recente que a versão do projeto criado. Ao
clicar no botão New, é exibida a caixa de diálogo Create New Android Virtual Device (AVD)
com as especificações dos parâmetros a serem preenchidos para o novo AVD (Figura 14).
Figura 14 - Caixa de diálogo "Create New Android Virtual Device (AVD)"
Os seguintes parâmetros do novo AVD são definidos nessa tela:
Nome (Name)
Pode ser utilizado qualquer nome no AVD, mas o ideal é utilizar um nome que indique a
imagem de sistema utilizada.
Alvo (Target)
O parâmetro “Target” define qual imagem de sistema é utilizada no AVD. Sendo a mesma, ou
mais recente, que a versão selecionada como alvo de compilação no projeto Android.
Cartão SD (SD Card)
Muitos aplicativos requerem um cartão SD, para estender a capacidade de armazenamento
para além da memória flash do dispositivo. É possível criar um cartão SD virtual, por
exemplo, com capacidade de armazenamento de 100MB, para os aplicativos em
desenvolvimento, mesmo que a maioria dos celulares esteja equipada com cartões SD capazes
de armazenar muitos gigabytes.
Skin
Responsável principalmente pela definição do tamanho da tela. Não é necessário alterar a
configuração padrão para verificar se a instalação funciona, emulando diferentes tamanhos de
tela é possível verificar se os layouts funcionam em dispositivos de resoluções diferentes.
Hardware
Neste campo é definido qual hardware opcional está presente na configuração do AVD. É
recomendável manter a configuração padrão para este projeto.
Ao preencher os campos Name, Target e SD Card, e clicar no botão Create AVD, um novo
AVD é criado. Se a versão da imagem do AVD criado não corresponder ou não for mais
recente que a versão definida no projeto para Android, o programa não será capaz de ser
executado.
4.2 Executando uma aplicação no AVD
Possuindo o projeto do aplicativo, um AVD com uma imagem de sistema compatível como
alvo de compilação e com os requisitos do nível de API do aplicativo, o SDK agora produz e
executa o programa Android.
O programa é executado clicando com o botão direito no projeto, e no menu de contexto,
escolhendo Run As... > Android Application.
Com o AVD criado e compatível com o aplicativo, o emulador já pode ser inicializado
executando a aplicação criada (Figura 15).
Figura 15 - Aplicativo criado sendo executado no emulador
Concluído o exemplo básico que ensina a criar uma aplicação Android e executar em um
emulador, o próximo passo é a criar uma aplicação mais avançada, que utiliza mais recursos
sendo interativa com o usuário.
No capítulo em sequência um novo projeto é criado, seu objetivo é desenvolver uma
calculadora e explicar todas as etapas desse processo.
5 CRIANDO O PROJETO CALCULADORA
Agora é criado um novo projeto Android denominado Projeto Calculadora e com o mesmo
nome de aplicação. O pacote utilizado é chamado de juliano.calculadora e a Activity é
chamada de ProjetoCaluladoraActivity. Todos os demais parâmetros devem ser configurados
conforme explicado anteriormente, incluindo um AVD correspondente à versão do SDK do
projeto.
A tela Package Explorer em sequência (Figura 16) mostra como deve ficar a estrutura do
Projeto Calculadora e sua hierarquia de pastas e arquivos.
Figura 16 - Tela “Package Explorer” com o Projeto Calculadora
5.1 O arquivo main.xml
Para definir a parte gráfica do aplicativo, é utilizado o arquivo main.xml, localizado em:
res/layout/main.xml. Neste arquivo, são inseridos e configurados os componentes gráficos
conforme desejado.
No primeiro código, foi desenvolvido apenas alguns recursos básicos, como Button (Botão),
TextView (Visualizador de textos) e o EditView (Editor de texto).
Observe a seguir, como ficou o primeiro código do arquivo main.xml referente aos botões
responsáveis pela realização das operações matemáticas de cálculo:
<Buttonandroid:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="+"
android:id="@+button/soma"/>
<Buttonandroid:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="-"
android:id="@+button/subtrai"/>
<Buttonandroid:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="*"
android:id="@+button/multiplica"/>
<Buttonandroid:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="/"
android:id="@+button/divide"/>
Posteriormente, um ambiente gráfico com uma interface mais amigável foi criado,
adicionando ícones animados e imagens à aplicação, substituindo os componentes Button por
componentes ImageView, adicionando efeitos quando algum botão é pressionado, explicado
mais adiante.
5.2 Criando botões com o componente ImageView
Com intuito de melhorar a aplicação, o código referente aos botões padrão do Android foi
refatorado, substituindo os componentes básicos do tipo Button por componentes do tipo
ImageView personalizáveis. O código referente aos novos botões ficou assim no arquivo
main.xml:
<LinearLayoutandroid:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"><!-- orientaçao horizontal do ImageView-->
android: background="@drawable/fundo"
<ImageView
android:id="@+img/soma"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/soma"/>
<ImageView
android:id="@+img/subtrai"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/subtrai"/>
<ImageView
android:id="@+img/multiplica"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/multiplica"/>
<ImageView
android:id="@+img/divide"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/divide"/>
</LinearLayout>
Observe que no parâmetro android:id um grupo foi definido como img, por se tratar de
componentes relacionados a imagens, e um id é determinado para cada figura.
O caminho que aponta para a imagem a ser utilizada, é informado pelo parâmetro
android:src, que contém o nome da pasta onde as imagens estão armazenas, neste caso
drawable, e também o nome da figura a ser utilizada.
Note que no inicio do código, ainda há o componente LinerLayout que define a orientação dos
componentes ImageView como horizontal. Este mesmo parâmetro é configurado para os
botões limpar e sair.
No primeiro parâmetro LinearLayout, que diz respeito a aplicação, um plano de fundo é
definido utilizando o atributo android:background=“” e o valor passado é
@drawable/fundo, onde, @drawable especifica o caminho onde o arquivo com o id fundo se
encontra.
5.3 Criação das imagens no Photoshop
Para gerar uma interface gráfica mais bonita e amigável, foram criadas imagens no Photoshop
(Figura 17) para servirem como botões, com dimensões de 84x58 pixels, extensão do tipo
.png e fundo transparente. E como plano de fundo, foi criada uma imagem com dimensão de
482x856 pixels, contendo o logo da instituição de ensino.
Figura 17 - Figuras sendo criadas no Photoshop
Uma dica interessante para mudar facilmente a cor de alguma imagem a ser utilizada como
botão é utilizar a propriedade HUE da caixa Hue/Saturation, e depois apenas salvar a imagem
com outro nome, obtendo assim uma nova imagem idêntica a anterior, com as mesmas
dimensões.
Essas imagens podem ser criadas na maioria dos editores gráficos existentes no mercado, e
como este não é o foco do trabalho, maiores detalhes foram suprimidos.
5.4 Importando imagens
As imagens correspondentes ao componente ImageView devem ser importadas para a pasta
res/drawable-hdpi ou alguma outra pasta do tipo drawable, conforme foram especificadas no
AVD utilizado.
Para importar uma imagem, basta clicar com o botão direito do mouse sobre a pasta
correspondente, por exemplo, res/drawable-hdpi, e no Menu que surge, escolher a opção
Import. Na janela que se abre a opção General/File System deve ser selecionada e depois
clicar no botão Next.
Na tela Import (Figura 18) deve ser informado o endereço que contém as imagens a serem
importadas no campo From directory:. Através da árvore de diretórios, na parte esquerda
dessa tela, é possível navegar até a pasta desejada, e do lado direito da tela, selecionar os
arquivos desejados para a importação. No campo Into folder: deve ser informado o caminho
de destino para onde os arquivos serão importados, neste caso é utilizado o caminho: Projeto
Calculadora/res/drawable-hdpi. Ao clicar no botão finish, as imagens já se encontram
disponíveis na pasta escolhida, estando prontas para serem utilizadas.
Figura 18 - Tela de importação de arquivos
5.5 Animando os botões
Estando com os componentes ImageView inseridos e prontos na tela do aplicativo, um efeito
para ocorrer sempre quando um componente for pressionado pode agora ser desenvolvido,
este efeito irá fazer com que a cor do botão (ImageView) mude sempre que ele estiver
pressionado.
Para a criação desta ação, um novo arquivo xml deve ser criado na pasta res/drawable-hdpi.
Neste caso, um arquivo responsável pelo efeito em um dos botões é o soma.xml, que
corresponde ao “botão soma” da calculadora, o código deste arquivo é mostrado logo abaixo:
<?xmlversion="1.0"encoding="utf-8"?>
<selectorxmlns:android="http://schemas.android.com/apk/res/android">
<itemandroid:state_pressed="true"android:drawable="@drawable/btn_soma2"/><!--
pressionado -->
<itemandroid:drawable="@drawable/btn_soma"/><!-- padrão -->
</selector>
Os comentários indicam qual a linha de código é responsável pela exibição da imagem
quando a ação pressionar ocorre, e também qual a imagem padrão deve ser exibida quando
nenhuma ação está sendo executada.
Para que não ocorram erros neste código, deve ser importada outra imagem chamada de
btn_soma2 que corresponde ao botão soma quando ele estiver sendo pressionado. Ela possui
as mesmas dimensões e o mesmo desenho da imagem anterior, sendo apenas de cor diferente.
Este mesmo procedimento é aplicado aos demais componentes do tipo ImageView,
correspondente as operações de cálculo como a divisão, subtração e multiplicação. Também é
aplicado aos componentes responsáveis pela ação de limpar os campos e sair do sistema.
5.6 Adicionando um ícone a aplicação
O procedimento para adicionar um ícone à aplicação consiste em importar um ícone de
preferência com o tamanho de 48x48 pixels que é o padrão de um ícone para Android, na
pasta res/drawable-hdpi que corresponde à aplicação Android. Deste modo o arquivo R.java
cria um id correspondente.
É necessário editar o arquivo AndroidManifest.xml, onde o parâmetro application contém o
atributo android:icon=“”, que define qual será o ícone da aplicação. Este atributo costuma
estar com o valor padrão @drawable/icon preenchido que busca o arquivo de nome icon na
pasta drawable.
Deste modo, basta alterar o id da imagem, ou seja, o nome da imagem. Uma dica é apagar o id
icon deixando apenas @drawable/ e executar a combinação de teclas Ctrl + Space, assim
uma lista com as possíveis opções disponíveis é mostrada para serem inseridas neste atributo.
Ao executar a aplicação, o ícone deve estar conforme foi definido no código (Figura 19).
Figura 19 - Ícone personalizado do Projeto Calculadora no emulador
Dando continuidade, agora é adicionado o ícone na barra de títulos da aplicação. Este
procedimento é realizado no arquivo ProjetoCalculadoraActivity.java com o código logo
abaixo:
packagejuliano.calculadora;
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.view.Window;
@Override
publicvoidonCreate(BundlesavedInstanceState) {
//Habilita novos recursos na janela
requestWindowFeature(Window.FEATURE_LEFT_ICON);
super.onCreate(savedInstanceState);
//Associa um arquivo de layout a esta classe
setContentView(R.layout.main);
//Adiciona ícone a esquerda
setFeatureDrawableResource(Window.FEATURE_LEFT_ICON,R.drawable.ic_calc);
}
}
O método requestWindowFeature(Window.FEATURE_LEFT_ICON) insere alguns recursos
adicionais na tela, e como parâmetro, o recurso passado foi um ícone a esquerda.
Ao utilizar o setFeatureDrawableResource(Window.FEATURE_LEFT_ICON, R.drawable.-
c_calc) é adicionado o ícone que deverá ficar ao lado esquerdo do título e como segundo
parâmetro, é passado o ícone em si, mapeado pelo R.java.
5.7 Tratamento de erros
Com as operações básicas funcionando, a continuação do desenvolvimento do software agora
é focada na criação de códigos que corrigem os eventuais erros que surgem, sendo explicado
logo em sequência.
5.7.1 RESTRINGINDO CAMPOS NUMÉRICOS
Quando valores não numéricos são digitados e alguma operação de cálculo é solicitada, um
erro surge. Para evitar este problema, os campos de edição de texto, responsáveis pela captura
dos valores fornecidos pelos usuários, são programados para aceitar apenas valores do tipo
decimal.
No arquivo layout.xml, os componentes EditText, responsáveis pela captura dos valores
informados pelo usuário e pela exibição do resultado dos cálculos, devem conter o parâmetro
android:numeric=”decimal”, conforme o código dos componentes abaixo:
<EditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@+edittext/valor1"
android:numeric="decimal"/><!-- permite apenas entrada do tipo decimal-->
<EditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@+edittext/valor2"
android:numeric="decimal"/><!-- permite apenas entrada do tipo decimal-->
<EditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@+edittext/resultado"
android:numeric="decimal"/><!-- permite apenas entrada do tipo decimal-->
5.7.2 CORRIGINDO ERROS DE CAMPO VAZIO
No arquivo ProjetoCalculadoraActivity.java é inserido um código que verifica se o campo
está vazio quando alguma operação de cálculo é solicitada pelo usuário.
O código em sequência ilustra a solução aplicada nos componentes responsáveis pelas
operações de adição, subtração, multiplicação e divisão:
//Ação do botão personalizado Somar
soma.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") || `
valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo = newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1+v2;
resultado.setText(String.valueOf(total));
}
}
});
//Ação do botão personalizado Subtrair
subtrai.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") || (valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo = newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1-v2;
resultado.setText(String.valueOf(total));
}
}
});
//Ação do botão personalizado Multiplicar
multiplica.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") || (valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo = newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1*v2;
resultado.setText(String.valueOf(total));
}
}
});
//Ação do botão personalizado dividir
divide.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") || (valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo = newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1/v2;
resultado.setText(String.valueOf(total));
}
}
});
Nas linhas com o comentário: “//Mensagem de alerta para campos vazios”, o bloco de
código que se inicia é responsável por verificar se os campos estão vazios antes de realizar um
cálculo. Está função é programada através das estruturas de if e else, que verificam se foram
capturados valores nos campos de textos. Se o campo valor1 ou valor2 estiver vazio, uma
mensagem de alerta deve ser exibida (Figura 20), senão, a operação de cálculo deve ser
executada.
Figura 20 - Mensagem de aviso “Campo vazio"
5.7.3 RESTRINGINDO EDIÇÃO NO CAMPO RESULTADO
Após o cálculo de alguma operação matemática, seu resultado é apresentado no campo
EditText, programado para receber este valor. Porém o usuário pode alterar seu valor clicando
neste campo e digitando o valor desejado.
Para corrigir esta falha, o parâmetro android:focusable=”” é definido com o valor false no
arquivo main.xml no bloco de código deste componente, veja como fica:
<EditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@+edittext/resultado"
android:numeric="decimal"
android:focusable="false"/><!-- campo EditText não editavel -->
5.8 O arquivo ProjetoCalculadoraActivity.java
Uma Activity é uma classe Java que herda da classe Activity do pacote Android, alguns
conceitos básicos relacionados à sua estrutura. Ela define a tela que irá interagir com um
usuário de Android. Ao menos uma Activity é necessária para desenvolver qualquer aplicação
com interface em Android.
A Activity é apenas a tela exibida, sem nenhum layout, para adicionar conteúdo nas activies, é
utilizado os arquivos xml de layout do Android, nos quais são definidos os elementos visuais,
como botões e imagens.
Após a conclusão da programação e das edições do arquivo main.xml, o resultado final do
código do arquivo ProjetoCalculadoraActivity.java é este:
packagejuliano.calculadora;
importandroid.app.Activity;
importandroid.app.AlertDialog;
importandroid.os.Bundle;
importandroid.view.View;
importandroid.view.Window;
//importandroid.widget.Button;
importandroid.widget.EditText;
importandroid.widget.ImageView;
publicclassProjetoCalculadoraActivityextendsActivity {
/** Calledwhentheactivityisfirstcreated. */
//Componentes do layout
EditTextvalor1, valor2, resultado;
ImageViewsoma, subtrai, multiplica, divide, limpar, sair;
//Button sair;
//Declaração das variáveis para o cálculo
doublev1, v2, total;
//Chamada quando a activity é criada pela primeira vez
@Override
publicvoidonCreate(BundlesavedInstanceState) {
//Habilita novos recursos na janela
requestWindowFeature(Window.FEATURE_LEFT_ICON);
super.onCreate(savedInstanceState);
//Associa um arquivo de layout a esta classe
setContentView(R.layout.main);
//Adiciona ícone a esquerda
setFeatureDrawableResource(Window.FEATURE_LEFT_ICON,R.drawable.ic_calc);
//Obtendo os valores dos objetos do main.xml
valor1 = (EditText) findViewById(R.edittext.valor1);
valor2 = (EditText) findViewById(R.edittext.valor2);
resultado = (EditText) findViewById(R.edittext.resultado);
soma = (ImageView) findViewById(R.img.soma);
subtrai = (ImageView) findViewById(R.img.subtrai);
multiplica = (ImageView) findViewById(R.img.multiplica);
divide = (ImageView) findViewById(R.img.divide);
sair = (ImageView) findViewById(R.img.sair);
//sair = (Button) findViewById(R.button.sair);
limpar = (ImageView) findViewById(R.img.limpar);
//Ação do botão somar
//btnSoma.setOnClickListener(new View.OnClickListener() {
//publicvoidonClick(View v) {
//v1 = Double.parseDouble(valor1.getText().toString());
//v2 = Double.parseDouble(valor2.getText().toString());
//total = v1+v2;
//resultado.setText(String.valueOf(total));
//}
//});
//Ação do botão personalizado Somar
soma.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") ||
(valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo =
newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1+v2;
resultado.setText(String.valueOf(total));
}
}
});
//Ação do botão personalizado Subtrair
subtrai.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") ||
(valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo =
newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1-v2;
resultado.setText(String.valueOf(total));
}
}
});
//Ação do botão personalizado Multiplicar
multiplica.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") ||
(valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo =
newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1*v2;
resultado.setText(String.valueOf(total));
}
}
});
//Ação do botão personalizado dividir
divide.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
//Mensagem de alerta para campos vazios
if(valor1.getText().toString().equals("") ||
(valor2.getText().toString().equals(""))){
AlertDialog.Builder dialogo =
newAlertDialog.Builder(ProjetoCalculadoraActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Campo vazio");
dialogo.setNeutralButton("Ok", null);
dialogo.show();
}else{
v1 = Double.parseDouble(valor1.getText().toString());
v2 = Double.parseDouble(valor2.getText().toString());
total = v1/v2;
resultado.setText(String.valueOf(total));
}
}
});
//Acaodo botão Limpar
limpar.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
valor1.setText("");
valor2.setText("");
resultado.setText("");
}
});
//Acaodo botão Sair
sair.setOnClickListener(newView.OnClickListener() {
publicvoidonClick(View v) {
finish();
}
});
}
}
O próximo capítulo ensina a preparar o pacote apk para que a aplicação desenvolvida possa
ser instalada e executada em dispositivos móveis Android.
6 DISPONIBILIZANDO A APLICAÇÃO PARA O PÚBLICO
O sistema Android requer que suas aplicações sejam assinadas digitalmente com um
certificado cuja chave privada é mantida pelo desenvolvedor. O Android usa o certificado
como um meio de identificar o autor da aplicação e estabelecer uma relação de confiança
entre as aplicações.
O certificado não define quais aplicações o usuário pode instalar e não precisa ser assinado
por uma autoridade certificadora: é perfeitamente permitido e típico, aplicações Android
usarem certificados autoassinados.
Para disponibilizar a aplicação ao público, é necessário:
• Obter uma chave privada válida
• Compilar a aplicação em modo de liberação
• Assinar a aplicação com a chave privada
• Alinhar o pacote APK final
APK (AndroidPackage) é um formato de arquivo executado nativamente no sistema Android.
Um APK pode ser compilado de duas maneiras: em modo de depuração, utilizado para testes
em dispositivos Android, e em modo de produção (liberação), destinado ao mercado de
aplicativos para o público final, como o Google Play.
Possuindo o Eclipse mais o plug-in ADT instalados, a maneira mais simples decompilar,
assinar e alinhar um aplicativo Android é utilizar a ferramenta Android Tools e preencher os
campos do assistente Android ExportApplication. Como este trabalho possui um foco mais
didático, é utilizado o modo texto com linhas de comando no prompt do Windows.
6.1 Obtendo uma chave privada
Para assinar as aplicações, é preciso possuir uma chave privada válida com a qual executará a
assinatura. Uma chave privada possui as seguintes características:
É de propriedade do desenvolvedor.
Representa a entidade pessoal, corporativa ou organizacional que será identificada
com a aplicação.
Possui um período de validade que exceda o tempo de vida esperado da aplicação. É
recomendado um período de validade maior que o encerramento exigido pelo Google
(22/10/2033), para que a aplicação seja publicada no Google Play. Não é permitido
fazer upload de uma aplicação cuja chave expire antes dessa data.
Não pode ser uma chave de depuração gerada pelas ferramentas do SDK do Android.
Uma chave válida, precisa ser gerada usando o Keytool, podendo ser uma chave autoassinada.
Para gerar uma chave autoassinada com Keytool, é utilizado o comando keytool e as opções
necessárias listadas abaixo.
A chave privada deve ser mantida de forma segura. Antes de executar a Keytool, é
recomendável a leitura do seguinte artigo: http://developer.android.com/tools/publishing/app-
signing.html. Ao gerara chave, senhas fortes devem ser usadas tanto para a keystore quanto
para a chave.
KeytoolOption Description
-genkey Gera um par de chaves (pública e privada)
-v Ativa o modo verbose
-alias <alias_name> Um apelido para a chave. Apenas os 8 primeiros caracteres do
apelido são usados.
-keyalg<alg> Algoritmo de encriptação usado para geração da chave. Tanto o
DSA quanto o RSA são suportados.
-keysize<size> O tamanho (em bits) de cada chave gerada. Caso não seja
fornecida, o Jeytool usa um tamanho padrão de 1024 bits. Em
geral, é recomendada uma chave de 2048 bits ou maior.
-dname<name> Um nome único que descreva quem criou a chave. O valor é
usado nos campos issuer e subject nos certificados autoassinados.
Não é necessário especificar essa opção na linha de comando. Se
não fornecida, o Jarsigned pedirá para informar cada campo.
-keypass<password> A senha para essa senha.
-validity<valdays> O período de validade da chave, em dias.
Um valor de 10000 ou maior é recomendado.
-keystore <keystore- Um nome para a keystore que conterá sua chave privada.
name>.keystore
-storepass<password> Uma senha para a keystore.
Tabela 1 - Opções do comando keytool
É importante ressaltar que informações digitadas por linha de comando podem ficar
armazenadas no histórico do shell, o que compromete a segurança.
Veja o comando Keytool usado para gerar a chave privada do projeto.
keytool -genkey -v -keystore projeto.calculadora.keystore -alias calculadora -keyalg RSA -
keysize 2048 -validity 10000
Para mais informações sobre a Keytool, sua documentação pode ser consultada em:
http://java.sun.com/j2se/1.5.0/docs/tooldocs/#security
6.2 Compilando a aplicação em modo de liberação
Para poder liberar a aplicação para os usuários, é preciso compilar em modo de liberação.
Nesse modo, a aplicação compilada não é assinada por padrão, sendo preciso assiná-la com a
chave privada. A aplicação não deve ser liberada sem ser assinada, ou assinada com uma
chave de depuração.
Para exportar um arquivo apk não assinado pelo Eclipse, basta dar um clique com o botão
direito do mouse no Package Explorer e selecionar Android
Tools > ExportUnsignedApplicationPackage. Então especificar a localização e um nome para
o arquivo a ser compilado. Neste caso o arquivo foi chamado de ProjetoCalculadora.apk.
6.3 Assinando a aplicação com a chave privada
Depois de gerada a keystore e o pacote de aplicação, a ferramenta Jarsigner já pode ser
utilizada para realizar o processo de assinatura.
Para assinar a aplicação, execute o Jarsigner, informando o arquivo apk da aplicação e a
keystore que contém a chave privada. Em sequência são mostras as opções disponíveis
(Tabela 2):
JarsignerOption Description
-keystore <keystore-name>.keystore O nome da keystore que contém a chave privada.
-verbose Ativa o modo verbose.
-storepass<password> A senha da keystore.
-keypass<password> A senha da chave privada.
Tabela 2 - Opções do comando jarsigner
É importante ressaltar que informações digitadas por linha de comando podem ficar
armazenadas no histórico do shell, o que compromete a segurança.
O comando abaixo usa o Jarsigner para assinar a aplicação contida no pacote chamado
ProjetoCalculadora.apk, usando a keystore projeto.calculadora.keystore criada
anteriormente.
jarsigner -verbose –keystore projeto.calculadora.keystore ProjetoCalculadora.apk
calculadora
Ao executar o comando acima, o Jarsigner solicita a senha da keystore e chave privada. Então
o arquivo apk é modificado, o que significa que o arquivo passa a estar assinado, o resultado é
mostrado logo abaixo (Figura 21).
Figura 21 - Resultado da assinatura com o comando jarsigner
O arquivo apk pode ser assinado várias vezes com chaves diferentes. Para verificar se o
arquivo apk está assinado, é utilizado o comando:
jarsigner -verify ProjetoCalculadora.apk
Com o arquivo apk assinado adequadamente, o Jarsigner imprime na tela “jarverified”. Para
maiores detalhes, o comando abaixo é utilizado:
jarsigner -verify -verbose ProjetoCalculadora.apk
Ou
jarsigner -verify -verbose -certs ProjetoCalculadora.apk
O comando acima, com a opção -certs adicionada, mostra na linha “CN=” quem criou a
chave, conforme a imagem abaixo (Figura 22):
Figura 22 - Resultado da verificação de assinatura com o comando jarsigner
Para mais informações sobre o Jarsigner, sua documentação se encontra disponível em:
http://java.sun.com/j2se/1.5.0/docs/tooldocs/#security
6.4 Alinhando o pacote APK
Após ter assinado o APK com a chave privada, o comando zipalign é executado no arquivo.
Essa ferramenta garante que todos os dados não comprimidos iniciem com um byte de
alinhamento em particular, relativo ao inicio do arquivo. Garantindo o alinhamento no limite
do byte 4, que permite a otimização de performance quando instalado no dispositivo. Quando
alinhado, o sistema Android é capaz de ler os arquivos com mmap(), mesmo se conterem
dados binários com restrições de alinhamento, assim que copiar todos os dados do pacote. O
beneficio é uma redução da quantidade de memória RAM consumido pela aplicação.
A ferramenta Zipalign é fornecida junto com o SDK do Android, dentro da pasta tools. Para
alinhar o APK assinado, o seguinte comando é executado:
zipalign -v 4 ProjetoCalculadora.apk projeto.calculadora-align.apk
Observe o resultado do comando em sequência (Figura 23):
Figura 23 - Resultado do comando zipalign
A opção -v muda para o modo verbose (opcional). O atributo 4 é o alinhamento do byte
(valores maiores que 4 não são recomendados). O primeiro arquivo no argumento é o arquivo
apk assinado (a entrada) e o segundo é o arquivo apk de destino (a saída). Para sobrescrever
um arquivo apk existente, é utilizada a opção –f.
O arquivo apk de entrada precisa ser assinado com a chave privada antes de otimizar o pacote
com zipalign. Se for assinado depois de usar o comando zipalign, o alinhamento será desfeito.
No próximo capítulo, o arquivo final alinhado, ProjetoCalculadora-align.apk, é
disponibilizado e executado em um dispositivo móvel Android.
6.5 Executando a aplicação em dispositivos Android
Para enviar o aplicativo criado para dispositivos Android, uma das formas possíveis, consiste
em utilizar o dispositivo conectado ao computador via USB (Universal Serial Bus), com os
drivers instalados e as permissões de acesso definidas, se necessário. Neste caso, é necessário
habilitar a opção contida no dispositivo Android que permite instalar fontes desconhecidas
(UnknownSources), já que o arquivo não é fornecido por uma fonte confiável.
O Android não vem com nenhum método de explorar os dados do cartão SD nativamente,
assim será necessário instalar um gerenciador de arquivos como o AndExplorer ou o Astro
File Manager, por exemplo, ambos baixados no Google Play.
As instruções específicas e os drivers necessários estão disponíveis neste link:
http://developer.android.com/sdk/win-usb.html.
Uma forma mais prática pode ser utilizada para receber o arquivo apk, basta enviar um e-mail
com o arquivo em anexo. Neste caso, é necessário possuir acesso à internet e uma conta de
e-mail configurada no dispositivo móvel.
Ao abrir o arquivo em anexo no aparelho, o Android pergunta se deseja realmente instalá-lo e
executá-lo após a sua instalação. Se não houve nenhum erro, o aplicativo já deve estar sendo
executado no dispositivo móvel.
O próximo e último capítulo apresenta a conclusão do trabalho.
7 CONCLUSÃO
Desenvolver aplicações para Android é uma tarefa que exige bastante estudo como qualquer
programação. Bons programadores leem muito código. O código de exemplo fornecido neste
trabalho pretende ser um exemplo de codificação em Java e do uso das capacidades da
plataforma Android.
Alguns exemplos existentes não atendem a necessidade para criar o melhor e mais extensível
software comercial possível. Muitos aplicativos de exemplo fazem escolhas fragmentadas,
quando o objetivo do programador é apenas criar um exemplo em uma única classe Java. É
comum, aplicativos Android serem versões adulteradas dos códigos de exemplo, se tornando
ilegíveis e de manutenção impraticável. Mesmo assim, isso não significa que deve ser evitada
a leitura de exemplos que sejam mais exatos do que um aplicativo completo deve ser.
O desenvolvimento deste sistema permitiu a participação na construção de um software em
todas as suas fases até a produção, garantindo a aplicação prática do que foi aprendido no
período acadêmico.
Um fator importante é ser autodidata, uma habilidade muito exigida no mercado de trabalho
para qualquer área, mas principalmente na área de informática, onde é necessário estar em
constante aprendizado, para se obter um software de qualidade e também se manter sempre
atualizado.
Como caminho inicial para um bom desenvolvimento é recomendado estudar e melhorar o
código das aplicações de exemplo, considerando as boas práticas de engenharia e projeto,
aplicando as ideias dentro de seu próprio código, visando criar produtos de alta qualidade.
Deste modo, o aprendizado ocorre de maneira natural, resultando no entendimento máximo
dos processos realizados.
REFERÊNCIAS
ABLESON, W. F., Sen, R., King, C., & Ortiz, C. E. (2011). Android in Action, Third
Edition. Manning Publications.
DEVELOPERS, A. (2012). What is Android. Acesso em 04 de 03 de 2012,
disponível em Android Developers:
http://developer.android.com/guide/basics/what-is-android.html
GOHRING, N. (28 de Setembro 2009). Android completa um ano envolto em
dúvidas e expectativas. Acesso em 21 de Maio de 2012, disponível em IDG
Now: http://idgnow.uol.com.br/mobilidade/2009/09/28/android-completa-um-
ano-envolto-em-duvidas-e-expectativas/
IDC. (28 de Março de 2012). Nearly 1 Billion Smart Connected Devices Shipped
in 2011 with Shipments Expected to Double by 2016, According to IDC.
Acesso em 1 abril de 2012, disponível em IDC Corporate USA:
http://www.idc.com/getdoc.jsp?containerId=prUS23398412
LECHETA, R. R. (2009). Google Android - Aprenda a criar aplicações para
dispositivos móveis (1ª ed.). Novatec.
MEDNIEKS, Z., Dornin, L., Meike, G. B., & Nakamura, M. (2012). Programando o
Android. São Paulo: Novatec.
MEIER, R. (2009). Professional Android Application Development. Wiley / Wrox.
OHA. (1 de Março de 2012). FAQ. Acesso em 21 de Maio de 2012, disponível em
Open Handset Alliance: http://www.openhandsetalliance.com/oha_faq.html