70
FACULDADE DE PINDAMONHANGABA Juliano Cesar Parro DESENVOLVIMENTO ANDROID COM ECLIPSE Pindamonhangaba - SP 2012

FAPI - Desenvolvimento android com eclipse e plugin adt

Embed Size (px)

Citation preview

Page 1: FAPI - Desenvolvimento android com eclipse e plugin adt

FACULDADE DE PINDAMONHANGABA

Juliano Cesar Parro

DESENVOLVIMENTO ANDROID COM ECLIPSE

Pindamonhangaba - SP

2012

Page 2: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 3: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 4: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 5: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 6: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 7: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 8: FAPI - Desenvolvimento android com eclipse e plugin adt

LISTA DE TABELAS

Tabela 1 - Opções do comando keytool .................................................................... 63

Tabela 2 - Opções do comando jarsigner ................................................................. 64

Page 9: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 10: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 11: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 12: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 13: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 14: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 15: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 16: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 17: FAPI - Desenvolvimento android com eclipse e plugin adt

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:

Page 18: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 19: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 20: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 21: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 22: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 23: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 24: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 25: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 26: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 27: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 28: FAPI - Desenvolvimento android com eclipse e plugin 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.

Page 29: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 30: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 31: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 32: FAPI - Desenvolvimento android com eclipse e plugin adt

Figura 11 - Tela New Android Project

Para criar um projeto Android, será necessário fornecer as seguintes informações:

Nome do projeto (Project Name)

Page 33: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 34: FAPI - Desenvolvimento android com eclipse e plugin adt

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:

Page 35: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 36: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 37: FAPI - Desenvolvimento android com eclipse e plugin adt

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)

Page 38: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 39: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 40: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 41: FAPI - Desenvolvimento android com eclipse e plugin adt

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="/"

Page 42: FAPI - Desenvolvimento android com eclipse e plugin adt

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"

Page 43: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 44: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 45: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 46: FAPI - Desenvolvimento android com eclipse e plugin adt

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:

Page 47: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 48: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 49: FAPI - Desenvolvimento android com eclipse e plugin adt

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:

Page 50: FAPI - Desenvolvimento android com eclipse e plugin adt

<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

Page 51: FAPI - Desenvolvimento android com eclipse e plugin adt

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());

Page 52: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 53: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 54: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 55: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 56: FAPI - Desenvolvimento android com eclipse e plugin adt

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() {

Page 57: FAPI - Desenvolvimento android com eclipse e plugin adt

//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

Page 58: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 59: FAPI - Desenvolvimento android com eclipse e plugin adt

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;

Page 60: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 61: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 62: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 63: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 64: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 65: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 66: FAPI - Desenvolvimento android com eclipse e plugin adt

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

Page 67: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 68: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 69: FAPI - Desenvolvimento android com eclipse e plugin adt

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.

Page 70: FAPI - Desenvolvimento android com eclipse e plugin adt

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