tcc - agno silveira

UNIÃO DINÂMICA DE FACULDADES CATARATAS – UDC

SISTEMAS DE INFORMAÇÃO

ANÁLISE SOBRE AS PLATAFORMAS DE DESENVOLVIMENTO PARA

DISPOSITIVOS MÓVEIS COM ESTUDO DE CASO EM ANDROID

AGNO SILVEIRA

Foz do Iguaçu 2012

2

UNIÃO DINÂMICA DE FACULDADES CATARATAS – UDC

SISTEMAS DE INFORMAÇÃO

ANÁLISE SOBRE AS PLATAFORMAS DE DESENVOLVIMENTO PARA

DISPOSITIVOS MÓVEIS COM ESTUDO DE CASO EM ANDROID

AGNO SILVEIRA

Anteprojeto de Graduação submetido como

requisito parcial por Agno Silveira, acadêmico

do Curso de Graduação de Sistemas de

Informação à obtenção do grau de Bacharel em

Sistemas de Informação, sob a orientação do

professor Luciano S. Cardoso da UDC - União

Dinâmica de Faculdades Cataratas - Foz do

Iguaçu, Paraná.

Foz do Iguaçu

2012

3

TERMO DE APROVAÇÃO

ANÁLISE SOBRE AS PLATAFORMAS DE DESENVOLVIMENTO PARA DISPOSITIVOS MÓVEIS COM ESTUDO DE CASO EM ANDROID

Trabalho de Conclusão de Curso apresentado à Faculdade Dinâmica das

Cataratas, Curso de Sistemas de Informação para obtenção do grau de

Bacharel em Sistemas de Informação aprovado pela banca examinadora

formada por:

________________________________________

Orientador: Professor Luciano S. Cardoso

BANCA EXAMINADORA:

________________________________________

Avaliador: Professor Carlos Massami Kaneko

________________________________________

Avaliador: Professor Adélio de Souza Conter

Foz do Iguaçu, ____________________ de 2012.

4

AGRADECIMENTOS

Em primeiro lugar, agradeço a Deus, por me abençoar com a

capacidade de estar concluindo esta etapa de minha vida e por estar sempre

presente nos momentos difíceis no decorrer desta caminhada.

Aos amigos que conheci durante o curso, e meus familiares,

principalmente minha mãe Izolete Boeno Silveira, por sempre me dar apoio moral e

incentivo.

Aos professores da UDC – União Dinâmica de Faculdade Cataratas,

por auxiliarem no desenvolvimento deste trabalho sempre que necessário.

Por fim agradeço especialmente meu supervisor de estágio Professor

Luciano S. Cardoso, que me co-orientou durante todas as etapas da monografia e

nunca hesitou em oferecer auxilio durante o desenvolvimento deste trabalho.

5

RESUMO

Com os avanços tecnológicos ocorridos com a tecnologia de

telefonia móvel e smartphones de modo geral como capacidade de memória e

processamento, a mobilidade dos celulares traz uma nova realidade para as

empresas da área de tecnologia mobile, trazendo rapidamente novidades para os

usuários finais.

O crescimento do uso de dispositivos móveis, a quantidade de

plataformas como Android, iOS e ambientes de desenvolvimento, também cresceu

proporcionalmente. Serão apresentadas neste trabalho algumas ferramentas,

aplicativos, e uma análise sobre as plataformas de desenvolvimento para

dispositivos móveis mais utilizadas atualmente.

Após analisar um estudo sobre as plataformas de dispositivos

moveis, será elaborado um estudo de caso onde será desenvolvido um aplicativo

para plataforma Android.

Palavras-chave: Smartphones, Plataformas, Desenvolvimento, Android.

6

ABSTRACT

With technological advances in mobile technology and smartphones

in general as memory capacity and processing, the mobility of mobile brings a new

reality for businesses in the area of mobile technology, quickly bringing new

products to end users.

The growing use of mobile devices, the number of platforms such as

Android, iOS and development environments, has also growing proportionately. Will

be presented in this paper some tools, applications, and an analysis of the

development platforms for mobile devices used nowadays.

After reviewing a study on mobile device platforms, will produce a

case study where an application will be developed for the Android platform.

Keywords: Smartphones, Platforms, Development, Android.

7

LISTA DE FIGURAS

Figura 1: Arquitetura da plataforma S60 ................................................................. 20

Figura 2: Visual Studio ............................................................................................ 21

Figura 3: Eclipse ...................................................................................................... 24

Figura 4: Extensões Java ........................................................................................ 25

Figura 5: Arquitetura do J2ME ................................................................................. 27

Figura 6: NetBeans ................................................................................................. 28

Figura 7: Camadas da Arquitetura Android ............................................................. 40

Figura 8: Emulador Android .................................................................................... 37

Figura 9: IDE Eclipse com SDK Android ................................................................ 38

Figura 10: Aplicativos gratuitos e pagos para Android e iOS .................................. 42

Figura 11: IDE Xcode ............................................................................................. 32

Figura 12: Arquitetura iOS. ..................................................................................... 33

Figura 13: Campos da IDE Eclipse para adicionar a SDK Android ........................ 45

Figura 14: Campos da IDE Eclipse para Criar um Novo Projeto Android ................ 46

Figura 15: Graphical Layout .................................................................................... 47

Figura 16: Emulador avd_2_1 ................................................................................. 48

8

LISTA DE QUADROS

Quadro 1: SO de smartphones mais vendidos no 1T12.........................................18

9

LISTA DE ABREVIATURAS E SIGLAS

API - Application Programming Interface

MVC - Model View Controller

GPS - Global Positioning System

EDGE- Enhanced Data-Rates for Global Evolution

3G - Terceira Geração

Wi-Fi- Wireless Fidelity

PDA - Personal Digital Assistant

J2ME - Java 2 Mobile Edition,

J2SE - Java 2 Stander Edition

J2EE - Java 2 Enterprise Edition

SDK - Software Develoment kit

JDK - Java Develoment kit

WAP - Wireless Apllications Protocol

VM - Virtual Machine

NS - NextStep

UI - User Interface

AVD - Android Virtual Device

USB - Universal Serial Bus

GUI - (Graphical User Interface)

10

SUMÁRIO

1. INTRODUÇÃO .................................................................................................... 11

1.1. OBJETIVO GERAL .......................................................................................... 12

1.2. OBJETIVOS ESPECÍFICOS ............................................................................ 12

1.3. JUSTIFICATIVA ............................................................................................... 12

1.4. PROBLEMA .................................................................................................... 13

1.5. METODOLOGIA ............................................................................................... 13

1.6. ESTRUTURA DO TRABALHO ......................................................................... 14

2. DISPOSITIVOS MÓVEIS .................................................................................... 15

2.1. CONCEITO E FUNCIONALIDADES ................................................................ 15

3. DESENVOLVIMENTO PARA SMARTPHONES ................................................ 18

3.1.SYMBIAN OS ................................................................................................... 19

3.1.1. Plataformas Symbian. .................................................................................. 19

3.1.1.1. Plataforma S60 ........................................................................................... 19

3.2. BLACKBERRY OS ........................................................................................... 22

3.2.1. Plataforma BlackBerry e Desenvolvimento ................................................... 22

3.3 PLATAFORMA J2ME ........................................................................................ 25

3.3.1. Arquitetura J2ME ........................................................................................... 26

3.3.2 Ambiente para desenvolvimento J2ME. ......................................................... 28

4. iOS ...................................................................................................................... 30

4.1. PLATAFORMA iOS E DESENVOLVIMENTO ................................................. 31

4.2. ARQUITETURA DO iOS .................................................................................. 33

4.3. APLICATIVOS iOS ........................................................................................... 34

5. ANDROID ............................................................................................................ 35

5.1. DEFINIÇÃO ...................................................................................................... 35

5.2. DESENVOLVIMENTO PARA PLATAFORMA ANDROID ................................ 36

5.3. ARQUITETURA DA PLATAFORMA ANDROID ............................................... 39

5.4. APLICATIVOS ANDROID ............................................................................... 42

6. ESTUDO DE CASO-DESENVOLVIMENTO DE APLICATIVO ANDROID ......... 44

7. CONCLUSÃO ..................................................................................................... 50

7.1. TRABALHOS FUTUROS ................................................................................. 51

8. REFERÊNCIAS BIBLIOGRÁFICAS ................................................................... 52

9. ANEXO – CÓDIGO FONTE ............................................................................... 56

11

1. INTRODUÇÃO

Com o grande avanço da tecnologia os dispositivos móveis estão

se tornando cada vez mais poderosos com relação às suas capacidades de

comunicação, armazenamento e processamento, além de estarem cada vez mais

acessíveis aos consumidores, que são atraídos por uma grande diversidade de

aplicações, navegador de internet, banco de dados integrado, jogos, integração

com outros sistemas, GPS, conectividades diversas, como Bluetooth, EDGE, 3G e

Wi-Fi. Dentre esses dispositivos móveis, estão incluídos handhelds, PDAs, tablets

e telefones celulares (smartphones), que é o foco deste trabalho.

Os dispositivos móveis oferecem conectividade e poder de uso em

qualquer lugar e em qualquer momento, tornando-se importantes tanto para uso

pessoal ou profissional.

Com o crescimento do uso de dispositivos móveis, a quantidade de

plataformas e ambientes de desenvolvimento, também cresceu proporcionalmente,

por este motivo a escolha de uma plataforma correta para o desenvolvimento de

um projeto ou apenas um simples aplicativo, significa escolher uma solução que

ofereça os melhores benefícios, em termos de custo, qualidade, e tempo de

desenvolvimento para a finalização do projeto.

Sendo assim, serão apresentadas neste trabalho algumas

ferramentas, aplicativos, e uma análise sobre as plataformas de desenvolvimento

para dispositivos móveis mais utilizadas atualmente e um estudo de caso onde

será desenvolvido um aplicativo para plataforma Android.

12

1.1. OBJETIVO GERAL

Elaborar uma análise entre as plataformas de desenvolvimento para

dispositivos móveis, suas ferramentas, aplicações, e criar um aplicativo para

plataforma Android.

1.2. OBJETIVOS ESPECÍFICOS

• Expor os conceitos históricos das plataformas J2ME, Symbian,

BlackBerry, Android e iOS;

• Apresentar as arquiteturas das plataformas citadas anteriormente;

• Expor os conceitos do Android Market, iPhone App Store e seus

aplicativos;

• Fazer uma análise das ferramentas de desenvolvimento para as

plataformas citadas;

• Desenvolver um aplicativo para plataformas Android, com objetivo de

expor o funcionamento da ferramenta de desenvolvimento.

1.3. JUSTIFICATIVA

Este trabalho se justifica pela importância do estudo sobre as

plataformas de desenvolvimento para dispositivos móveis, e as tecnologias

envolvidas nesta área, além da grande influência no mercado de TI.

Por estar em rápida e constante evolução, é importante fazer um

estudo entre os principais ambientes de desenvolvimento, para que se possa saber

como funciona uma plataforma de desenvolvimento para dispositivo móvel.

Devido a esses fatores, há um intenso investimento na criação de

plataformas que tornem o desenvolvimento de softwares móveis mais simples e

economicamente viáveis, sendo assim, a necessidade de estudos sobre ambientes

de desenvolvimento para dispositivos móveis são de grande importância.

13

1.4. PROBLEMA

Como são compostas as estruturas das plataformas, e como

desenvolver para dispositivos móveis?

1.5. METODOLOGIA

Este trabalho foi realizado através de pesquisas bibliográficas

relacionadas às plataformas de desenvolvimento para dispositivos móveis, J2ME,

Symbian, BlackBerry, Android e iOS.

Foi utilizado como materiais de pesquisa livros e internet para a

melhor qualidade da produção desta monografia.

Após o levantamento de material, foram expostos os conceitos das

plataformas J2ME, Symbian, BlackBerry, Android e iOS, e também suas estruturas,

arquiteturas e linguagens de desenvolvimento.

O Projeto mostrará os conceitos das plataformas e aplicativos dos

ambientes de desenvolvimento colocados anteriormente. Focando nas ferramentas

para desenvolvimento.

Estão expostos os conceitos do Android Market, iPhone App Store

e seus aplicativos, por estarem relacionadas fortemente no mercado de TI para

dispositivos móveis.

Foi desenvolvido um aplicativo para plataforma Android, visando

expor o funcionamento da ferramenta de desenvolvimento.

Desta forma os procedimentos metodológicos a serem

desenvolvidos durante a execução deste trabalho dão a importância devida ao seu

conteúdo para a sua conclusão com qualidade e desenvoltura.

14

1.6. ESTRUTURA DO TRABALHO

O capítulo I traz a introdução, cuja temática se baseia nos objetivos,

especificamente o objetivo geral e específico. A justificativa do trabalho segue

complementada pelo problema a ser resolvido através dos tópicos co-relacionados

nas páginas a seguir.

No capítulo II estão expostos os conceitos e funcionalidades dos

smartphones e alguns destes equipamentos, além de um quadro dos sistemas

operacionais mais vendidos mundialmente.

O capítulo III mostra uma abordagem das plataformas de

desenvolvimento para smartphones mais utilizadas atualmente, seus conceitos,

ambientes de desenvolvimento e principais características, as plataformas iOS e

Android serão citadas nos capítulos posteriores.

O capítulo IV faz uma abordagem sobre o sistema operacional iOS da

Apple, seus conceitos, evolução da tecnologia, arquitetura, principais aplicativos e

seu ambiente de desenvolvimento.

O capítulo V mostra os conceitos do sistema operacional Android,

suas características, arquitetura, aplicativos e sua plataforma de desenvolvimento,

focando nos principais itens de o desenvolvimento para smartphones.

O capítulo VI expõe um estudo de caso, onde será desenvolvido um

aplicativo para plataforma Android, visando expor a ferramenta para

desenvolvimento.

15

2. DISPOSITIVOS MÓVEIS

É muito comum nos dias atuais, celulares e outros dispositivos móveis

que funcionam como PDA, GPS, WAP, consoles, leitores de áudio, navegador de

internet, vídeo e texto, entre outras utilidades, tudo em um só aparelho.

A mobilidade dos dispositivos móveis pode ser vista da seguinte

forma, conforme exposto por Cavallini et al. (2010, p. 11), “O digital é o mundo que

torna a nossa vida mais fácil e não mais complicada. O mobile é quase um órgão

humano que traz o digital a tiracolo e deixa a nossa vida mais prática”.

Neste capítulo serão expostos alguns conceitos sobre celulares, e as

funcionalidades que os tornam cada vez mais indispensáveis, já que cada vez mais

os dispositivos móveis se tornam integrados e em alguns casos indispensáveis

para os usuários.

2.1. CONCEITO E FUNCIONALIDADES

Dentre os vários dispositivos móveis que existe, o mais utilizado é o

celular, mas a comunicação mobile vai além deste aparelho.

Segundo Cavallini et al. (2010, p. 12), “Uma série de outros aparelhos

como o Kindle e o iPad podem utilizar a rede celular ou redes sem fio como o Wi-Fi

para acessar a internet e outras funções avançadas, como, por exemplo, rodar

aplicativos e jogos”.

Como acontece com os PCs, os smartphones não são todos iguais,

porém na maioria das vezes eles podem executar o mesmo sistema operacional,

mesmo se eles tiverem sido feitos por diferentes fabricantes. Como por exemplo,

alguns modelos de dispositivos fabricados pela HTC e Samsung, utilizam o sistema

operacional Android. No entanto, alguns sistemas operacionais, como o iOS, só

podem ser executados em smartphones da Apple. Os principais recursos

oferecidos atualmente nos smartphones são:

• Sistema Operacional: Programa ou conjunto de programas responsável pelo

gerenciamento de recursos do sistema;

16

• Recursos de conectividade: Recursos utilizados para acessar redes 3G, Wi-

Fi, Bluetooth e GPS;

• Recursos Multimídia: Recursos utilizados para reproduzir arquivos de

música e vídeo em vários formatos;

• Câmera: Recurso utilizado para tirar fotos e gravar vídeos;

• Touch-screen: Este recurso tem o mesmo propósito de um teclado, no entanto

o funcionamento é através de toques na tela do dispositivo. Ele foi

popularizado pelo iPhone da Apple e atualmente é utilizado em quase todos

smartphones;

• Suporte a aplicativos: A possibilidade de instalar novos aplicativos amplia as

funcionalidades do dispositivo proporcionando um funcionamento

semelhante ao de um PC. A instalação de novos aplicativos pode ser feita

através de diversas lojas on-line que disponibilizam aplicativos para

download. Porém, nem todos os smartphones têm acesso aos mesmos

aplicativos. Por exemplo, o iPhone acessa o App Store da Apple, enquanto

aparelhos baseados na plataforma Android acessam o Android Market.

Dentro do conceito histórico de dispositivos móveis, segundo Ferrari

(2011), se deu início à evolução dos celulares em 1983, com o lançamento do

Motorola Dyna TAC8000X, a antena (não retrátil) era responsável por mais de um

terço do tamanho do aparelho, guardava até 30 números na memória e a bateria

durava oito horas em espera.

O iPhone foi lançado pela em 2007, e nos modelos atuais o aparelho

possui o sistema operacional OS X, funções de iPod (outro eletrônico da mesma

empresa), câmera digital de 8 megapixels, interface de multi-touch da tela,

capacidade de até 64GB, conexão a internet via Wi-Fi ou 3G, software para

downloads de aplicativos (App Store), que possui mais de 500.000 aplicativos com

diversas funções, incluindo jogos, navegação GPS, redes sociais, publicidade,

previsão do tempo, bolsa de valores, Skype e chamadas com vídeo (FaceTime), o

que o torna capaz de satisfazer as mais diversas necessidades dos usuários

(APPLE, 2012).

O Galaxy Note lançado final de 2011, com funções de tablet, possui

agenda inteligente que permite o gerenciamento das atividades (S Planner), bloco

17

de notas otimizado (S Memo), capacidade de 32GB de memória, bateria de longa

duração, 17 horas de conversação e 25 dias no modo de espera, possui uma

interface que permite ver a caixa de entrada de e-mail e o corpo da mensagem na

mesma tela, processador Dual Core de 1.4 GHz (SAMSUNG, 2012).

18

3. DESENVOLVIMENTO PARA SMARTPHONES

Existem várias linguagens e plataformas utilizadas para

desenvolvimento de aplicativos, em diferentes sistemas operacionais, neste

capitulo será exposto algumas das plataformas mais utilizadas em relação ao

número de dispositivos vendidos de cada plataforma, seus conceitos e bases para

desenvolvimento com relação a dispositivos móveis, dando maior foco aos

smartphones.

A seguir o Quadro 1 ilustra os SO’s de smartphones mais vendidos no

1T12:

Quadro 1. SO de smartphones mais vendidos mundialmente no 1T12 em milhares de unidades.

Sistema Operacional 1T12 Unidades Market Share 1T12 (%)

Android 81,067.4 56,1

iOS 33,120.5 22,9

Symbian 12,466.9 8,6

Research In Motion (RIM) 9,939.3 6,9

Bada 3,842.2 2,7

Microsoft 2,712.5 1,9

Outros 1,242.9 0,9

Total 144,391.7 100

Fonte: (GARTNER, 2012).

O motivo da escolha das plataformas para formar este trabalho foi o

fato de que estas foram as mais utilizadas durante a evolução da tecnologia para

dispositivos móveis.

19

3.1. SYMBIAN OS

Segundo Jipping (2007), a Psion era uma pequena empresa Inglesa,

que começou a produzir computadores de mão em 1984, tendo sistema

operacional próprio, chamado EPOC, programado em C++. A Psion queria adaptar

o EPOC para outros hardwares, como celulares e aparelhos de internet, foi então

que surgiu a oportunidade, onde a Psion e os líderes da indústria de telefonia

móvel da época, Nokia, Sony-Ericsson, Motorola e Panasonic formaram um núcleo

do sistema operacional EPOC no final de 2000, que ficou chamado de Symbian

OS.

3.1.1. PLATAFORMAS SYMBIAN

Como destaca Morimoto (2010), a família Symbian é dividida em duas

plataformas parcialmente incompatíveis. De um lado temos o S60, desenvolvido

pela Nokia, e o UIQ, encontrado em aparelhos da Sony-Ericsson e da Motorola. O

S60 e o UIQ são somente interfaces que rodam sobre o Symbian OS, incluindo

aplicativos e bibliotecas de desenvolvimento. Entre os dois, o S60 é o mais usado

porque a Nokia vende um volume muito maior de aparelhos.

3.1.1.1. PLATAFORMA S60

A plataforma SDK S60 foi criada com a finalidade de ser uma

plataforma para smartphones com Symbian OS desenvolvida pela Nokia Mobile

Software, atualmente está licenciada para várias outras fabricantes de dispositivos

móveis no mundo (NOKIA DEVELOPER, 2012).

A plataforma SDK S60 garante ao desenvolvedor que elementos

específicos irão estar presentes em cada aparelho baseado em uma edição

particular da plataforma. Isso é feito utilizando a arquitetura, que consistem em:

S60 UI style, S60 Applications, S60 Application Services, S60 Java, Technology

Services, S60 Plataform Services e Extenções do Symbian OS construídas sobre

o Symbian OS (NOKIA DEVELOPER, 2012).

20

A seguir a figura 1 ilustra a arquitetura da plataforma S60:

Figura 1. Arquitetura da plataforma S60. Fonte: (NOKIA DEVELOPER, 2012).

As aplicações em Symbian OS seguem o padrão de arquitetura de

software clássico MVC (Model Viewel Controller). O nível de suporte da estrutura,

encapsula, da as informações essenciais das classes e o resumo dos sistemas

necessários subjacentes a nível de comportamento, em principio, um processo

completo pode ser escrito sem qualquer outras dependências diretas (JIPPING,

2007).

Conforme explica Fitzek et al. (2010), a plataforma de

desenvolvimento apenas suportada é Windows e é recomendável que os usuários

executem o Windows XP ou Windows Vista. Esta restrição é devido ao fato de que

algumas ferramentas na plataforma Symbian SDK S60 só estão disponíveis em

ambiente Windows. Há, no entanto, um esforço contínuo para adicionar suporte

oficial para outros ambientes de desenvolvimento como Linux ou Mac. Além da

exigência do ambiente Windows, recomenda-se um PC razoavelmente rápido para

o desenvolvimento, ou seja, um processador de 1800 MHz, 2GB RAM e espaço

livre em disco para as ferramentas, IDE e SDK.

O Symbian OS é muito versátil permitindo desenvolver aplicações em

diversas linguagens diferentes como Symbian C++, JavaME, C, entre outras. O

21

C++ como linguagem nativa do sistema possibilita que aplicações escritas nesta

linguagem obtenham acesso maior as APIs (Application Programming Interface) do

sistema e desempenho superior se comparado a outras linguagens como Java.

Dentre os ambientes para desenvolvimento de aplicações estão,

Microsoft Visual Studio C++ Professional, UIQ SDK for Symbian OS v7.0, Nokia

Series 60 MIDP SDK v1.0, J2SE SDK, Wireless Developer Toolkit da Sun, Symbian

OS v5 SDKs, Visual Basic 6.0 e Borland C++ (NOKIA DEVELOPER, 2012)

A seguir a figura 2 ilustra a IDE Visual Studio com Emulador para SDK

S60:

Figura 2. Visual Studio. Fonte: (SOFTWARE KNOWHOW, 2010).

Para que seja possível utilizar o emulador durante o desenvolvimento,

é necessário que o usuário esteja utilizando a versão mais atualizada do Java.

22

Conforme exposto por Fitzek et al. (2010, p. 14), “para utilizar o

emulador de telefone totalmente, é necessário o Java Runtime Environment. O

emulador de telefone é uma ferramenta valiosa no desenvolvimento e teste de

aplicações”. É preciso instalar a última versão do Java disponível. Caso não tenha

a versão atual do Java, ao tentar acessar as preferências do emulador Symbian irá

aparecer o seguinte erro, ‘Não é possível iniciar o gerenciador’.

3.2. BLACKBERRY OS

O BlackBerry foi desenvolvido pela empresa canadense RIM

(Research In Motion), fundada em 1984 por Mike Lazaridis, e introduzido no

mercado americano em janeiro de 1999, após uma década de intensas pesquisas

(BLACKBERRY, 2012),

Conforme exposto por Dias (2011), o primeiro BlackBerry era uma

espécie de pager bidirecional com teclado Qwerty que permitia a troca de

informações através de mensagens de texto com outros aparelhos, criando uma

solução móvel importante, foi somente com o desenvolvimento do Blackberry que a

empresa conseguiu conquistar destaque no segmento de tecnologia. Rapidamente

o novo produto se tornou uma tecnologia indispensável como ferramenta para

recepção automática de mensagens de textos no caso de usuários móveis, além

de oferecer funções de organizador pessoal e aplicativos para dados empresariais.

O BlackBerry possui o App World, este serviço oferece aos usuários

um ambiente de navegação para fazer downloads e atualização de aplicativos.

3.2.1. PLATAFORMA BLACKBERRY E DESENVOLVIMENTO

Alguns dispositivos BlackBerry são baseados em C ++, mas os novos

suportam o J2ME (Java 2 Micro Edition), principalmente porque a tecnologia Java

torna o desenvolvimento de aplicações mais fácil. Sua plataforma independente

elimina problemas de portabilidade, e sua coleta de lixo automática permite que os

desenvolvedores se concentrem na lógica do aplicativo ao invés de gerenciamento

de memória (MAHMOUD, 2005).

23

A RIM possui máquina virtual Java própria (JVM), compatível com o

J2ME, que suporta o CLDC (Connected Limited Device Configuration) e o MIDP

(Perfil Mobile Information Device), adicionalmente, incorpora uma série de APIs

específicas do BlackBerry, que permitem o desenvolvimento de aplicações mais

sofisticadas e com visual similar ao das aplicações nativas do Blackberry (KLEIN,

2008):

• CLDC (Connected Limited Device Configuration): É a especificação do

conjunto de interfaces e da máquina virtual Java para dispositivos móveis

limitados em recursos;

• MIDP (Mobile Information Device Profile): É um perfil do JavaME,

baseado no CLDC, é o ambiente JavaME mais popular hoje encontrado

em celulares.

Segundo exposto por Rizk (2009), para desenvolvimento J2ME

para BlackBerry, é necessário instalar o JDK (Java Development Kit) ou kit de

desenvolvimento de aplicativos, necessário para compilar o widget BlackBerry,

necessário uma versão mínima do JDK 1.6, é preciso também instalar a versão

beta 3 do BlackBerry Widget Packager, versão de 32 bits para Windows XP e

Windows Vista, atualmente não é compatível com sistemas operacionais de 64

bits ou com o Windows 7.

Klein (2008) complementa que, “depois deve-se combinar as

ferramentas para desenvolvimento com uma IDE (Integrated Development

Environment), ambiente integrado para desenvolvimento de software Java como

Eclipse, Microsoft Visual Studio ou Netbeans”.

Existem vários modelos de aparelhos BlackBerry com diferentes

telas, teclados virtuais e resoluções, para cada um existe recursos diferentes de

se aplicar no momento do desenvolvimento.

Como explica Rizk (2009), existem vários modelos de dispositivos

BlackBerry, onde as resoluções de telas podem varias de 240 × 260-480 × 360.

Alguns dos dispositivos têm um trackball ou óptica trackpad juntamente com o

teclado. Alguns possuem teclados QWERTY completo, enquanto outros têm o

teclado BlackBerry SureType, que tem uma ou duas letras por chave. O

BlackBerry Storm pode apresentar diferentes tipos de teclados virtuais,

24

dependendo da orientação do dispositivo e as preferências do usuário. A

velocidade do processador e de memória pode variar de dispositivo para

dispositivo, como também a velocidade da rede, e alguns recursos de hardware,

tais como GPS, não estão disponíveis em todos os dispositivos.

O desenvolvedor deve estar ciente destas diferenças e projetar sua

aplicação para trabalhar de acordo com o dispositivo BlackBerry.

A seguir a figura 3 ilustra a ferramenta de desenvolvimento Eclipse:

Figura 3. Eclipse. Fonte: (DEVMOBILEBRASIL, 2011).

Os desenvolvedores podem acessar a BlackBerry Developer Zone,

para aprender mais sobre os diversos métodos de desenvolvimento para a

plataforma e baixar ferramentas de desenvolvimento gratuitas para crias jogos, e

aplicativos. Na BlackBerry Developer Zone o desenvolvedor terá acesso a

documentações de produtos, exemplos de códigos e simuladores, e analisar o

desempenho dos aplicativos (BLACKBERRY, 2012).

25

3.3. PLATAFORMA J2ME

Como descreve Piroumian (2002), Java 2 Micro Edition (J2ME) é uma

plataforma inteiramente projetada com o intuito de atender as necessidades de

desenvolvedores da área de computação móvel. Pertencente a empresa Sun

Microsystems, trata-se de uma versão reduzida da plataforma padrão J2SE (Java 2

Standard Edition), que permite a produção de aplicações para dispositivos móveis

tais como telefones celulares, PDAs, smartphones, dentre outros.

O que estes dispositivos têm em comum é o fato de possuírem pouco

poder de processamento e pouca memória para suportar a J2SE usada em

computadores desktop e servidores, daí a necessidade de uma versão reduzida

para a produção de materiais para tais dispositivos. Além disso, compreende

interfaces de usuário, modelos de segurança, protocolos de comunicação em rede

e outras funcionalidades que, quando combinadas, constituem um ambiente de

execução Java otimizado para uso de memória, processamento e operações de

entrada e saída, conforme exposto por (PIROUMIAN, 2002).

A seguir a figura 4 ilustra as extensões Java:

Figura 4. Extensões Java. Fonte: (SIBLOGSPOT, 2009).

26

Segundo Muchow (2004, p. 8), “J2ME permite desenvolver aplicativos

que não tem o mesmo poder de processamento e memória de uma plataforma

desktop típica. Os produtos podem incluir celulares, PDAs, sistemas de

entretenimento e navegação automotiva por exemplo”.

Como argumenta Piroumian (2002), J2ME não define um novo tipo de

Java, mas adapta sua plataforma para que seja possível executar programas em

dispositivos, como os citados anteriormente. Sendo assim, todo programa

desenvolvido para J2ME poderá ser executado sem nenhum problema nas edições

Standard (J2SE) e Enterprise (J2EE), desde que as APIs usadas estejam

presentes para estas plataformas.

3.3.1. ARQUITETURA J2ME

Como o J2ME acomoda uma ampla variedade de dispositivos móveis,

esta presente em sua arquitetura as configurações, perfis e máquina virtual, que

definem os recursos de linguagem e bibliotecas para estes dispositivos.

Conforme exposto por Muchow (2004), uma configuração define uma

plataforma Java para uma ampla variedade de dispositivos e esta vinculada a uma

máquina virtual Java JVM (Java Virtual Machine), ou seja, uma configuração define

os recursos da linguagem Java e as bibliotecas básicas da JVM para essa

configuração em particular. A configuração é aplicada a um dispositivo móvel

baseado na capacidade de memória, no vídeo e na conectividade de rede, e no

poder de processamento disponível (MUCHOW, 2004).

A configuração foi definida em dois padrões de configuração J2ME: o

CLDC (Connected Limited Device Configuration), configuração de dispositivos de

conexão limitada, que é direcionada a dispositivos considerados de uso pessoal,

móvel, como os smatphones, organizadores pessoais e outros aparelhos

semelhantes, ou seja, a CLDC é focada em dispositivos com restrições de

recursos. Em geral os dispositivos devem possuir de 160 KB a 512 KB de memória

não-volátil para a máquina virtual e bibliotecas, e pelo menos 122 KB de memória

RAM para a execução da máquina virtual, processador pode ser de 16 ou 32 bits, e

conexão com a rede limitada (SOUZA, 2012).

27

O CDC (Connected Device Configuration) ou configuração de

dispositivos conectados, é desenvolvida para aparelhos que suportam todas as

funcionalidades da máquina virtual Java tradicional, como conversores de TV a

cabo, alguns dispositivos GPS e alguns PDA’s, os dispositivos devem possuir no

mínimo 2 MB de memória ROM, 256 KB de memória RAM e algum tipo de conexão

de rede. A CDC providencia um ambiente de execução Java mais amplo que a

CLDC e é um ambiente mais próximo do ambiente J2SE (SOUZA, 2012).

Em cima das configurações estão os perfis de dispositivo, onde se

encontra as APIs definidas pelo MIDP (Mobile Information Decive Profile), perfil de

dispositivo de informação móvel, para projeto de interface com o usuário, suporte

para interligação em rede e armazenamento persistente, levando em consideração

as limitações de tela e memória dos dispositivos móveis (MUCHOW, 2004).

A seguir a figura 5 ilustra a Arquitetura do J2ME:

Figura 5. Arquitetura do J2ME. Fonte: (MUCHOW, 2004).

Conforme exposto por Muchow (2004, p.19), “para a CLDC, a Sun

desenvolveu uma máquina virtual específica, projetada para ser o menor e mais

eficiente possível e manipular considerações especiais dos dispositivos móveis,

como a capacidade de memória, chama-se Máquina Virtual K, ou simplesmente

KVM (K Virtual Machine)”.

28

3.3.2. AMBIENTE PARA DESENVOLVIMENTO J2ME

Segundo Wells (2004, p. 50), “primeiramente para começar o

desenvolvimento, é necessário escolher uma IDE, uma ferramenta para que seja

feito os códigos das futuras aplicações”.

Existem muitas alternativas existentes no mercado, algumas pagas,

outras gratuitas como .Net Compact Framework, da Microsoft, Brew, da Qualcomm,

Eclipse ME, da Eclipse Foundation, JBuilder MobileSet, da Borland Software

Corporation e o NetBens, que será usado como exemplo.

Independente da escolha da IDE, é obrigatório a presença de alguns

programas no computador, estes programas são o JDK (Java Development Kit)

versão 5.0, o WTK (Wireless Toolkit) versão 2.3, que é o Kit de Desenvolvimento

da Sun Microsystems voltado para a criação de aplicações móveis, e o Mobility

Pack 5.0, pacote que adiciona suporte à criação de aplicações móveis no

NetBeans (ORRICO, 2008).

A seguir a figura 6 ilustra o Ambiente de desenvolvimento NetBeans:

Figura 6. NetBeans. Fonte: (ORRICO, 2008).

29

O WTK é um kit de desenvolvimento, mas não provê um ambiente de

desenvolvimento completo, apenas um compilador para as aplicações móveis e

alguns emuladores de dispositivos, todos fictícios, para testar as aplicações

criadas, por isso é preciso uma IDE, como o NetBeans (ORRICO, 2008).

30

4. iOS

O iOS, conhecido como iPhone OS antes de Junho de 2010, é o

sistema operacional da Apple. Desenvolvido originalmente para o iPhone que

desde então tem sido usado no iPad Touch, iPad e também na Apple TV. Este

sistema operacional é um exclusivo Apple, pois é usado apenas em seus

dispositivos.

O iOS foi apresentado com o iPhone na Macworld Conference & Expo

no dia 9 de Janeiro de 2007, e lançado em Junho do mesmo ano. A Apple não

atribui nome para o SO, apenas deu referência que se tratava de uma versão

modificada do OS X. Em 17 de Outubro de 2007, a Apple anunciou que o SDK

nativo estava em desenvolvimento e que estaria nas mãos dos desenvolvedores

até Fevereiro do ano seguinte (SILVA, 2011).

Em Junho de 2010, a Apple rebatiza o nome do SO de iPhone OS

para iOS.

A interface do usuário do iOS é baseada no conceito de manipulação

direta, utilizando gestos em multi-toque. A interação com o sistema operacional

inclui gestos como apenas tocar na tela, deslizar o dedo, e o movimento de pinça,

utilizado para se ampliar ou reduzir imagens. Acelerômetros internos são usados

por alguns aplicativos para responder à agitação do aparelho, ou rodá-lo em três

dimensões, mudando do modo retrato para paisagem (SILVA, 2011).

4.1. PLATAFORMA iOS E DESENVOLVIMENTO

De acordo com MARK et al. (2011, p. 46), “o desenvolvimento e

designer para iOS foram guiados por um conceito chamado Model View Controller

(MVC), que é uma maneira muito lógica dividindo-se o código que compõe uma

aplicação baseada em GUI (Graphical User Interface)”. O padrão MVC divide todas

as funcionalidades em três categorias distintas:

• Model: As classes que armazenam dados de seu aplicativo;

• View: Composto por uma das janelas, controles e outros elementos

que o usuário pode ver e interagir com ele;

31

• Controller: O código que vincula o modelo e a visualização. Ele

contém a lógica de aplicação que decide como lidar com o usuário.

O objetivo da MVC é fazer com que os objetos implementam esses

três tipos de códigos distintos a partir de outra possível. A MVC ajuda a garantir a

reutilização máxima. Uma classe que implementa um botão genérico pode ser

utilizada em qualquer aplicação. Uma classe que implementa um botão que faz

algum cálculo especial quando é clicado só pode ser utilizada na aplicação para a

qual foi originalmente escrito (MARK, 2011).

Segundo BRANNAN e WARD (2011), para que seja possível

desenvolver para os dispositivos da Apple (iPhone, iPad), é necessário que seja

feito um registro pessoal no iPhone Dev Center em

http://developer.apple.com/iphone, a adesão é gratuita. Neste mesmo endereço é

possível baixar as ferramentas necessárias para poder desenvolver, estas

ferramentas são: o kit de desenvolvimento SDK, a IDE Xcode (conjunto de

ferramentas), Cocos2D (usado para criação de jogos, caso necessário), é preciso

também que se tenha um computador com MAC OS X executando as ferramentas

do Xcode.

Quando inicializa uma aplicação no Xcode, existe a opção de

inicializar no simulador ou no aparelho. O simulador providencia um ambiente local

para testar as aplicações e ter certeza que ela se comporta de maneira desejada.

Depois de executar o comportamento básico da aplicação, o Xcode inicializar a

aplicação no IPhone conectado no computador (BRANNAN e WARD, 2011).

32

A seguir a figura 11 ilustra o ambiente de desenvolvimento Xcode:

Figura 11. IDE Xcode. Fonte: (MARK et al., 2011).

A linguagem de programação usada para desenvolver na plataforma

iOS é Objective-C, esta linguagem é própria para o desenvolvimento de

dispositivos da Apple e foi herdada da linguagem C, é utilizada para construção de

aplicativos para iPhone, iPad, iPod Touch, ela adia a maior parte das decisões que

conseguir a partir do momento de compilação e execução, e sempre que possível

faz tudo dinamicamente. Isso significa que a linguagem não requer apenas um

compilador, mas também um sistema de runtime para executar o código compilado

(APPLE, 2012).

CONWAY e HILLEGASS (2011, p. 31) complementam que, “O

runtime funciona como uma espécie de sistema operacional para linguagem

Objective-C”.

33

4.2. ARQUITETURA DO iOS

O Kernel do iOS possui uma arquitetura em camadas, onde as

camadas estão dividas em: Core OS, Core Services, Media, e Cocoa Touch. O

Kernel é baseado no kernel Mach, que se trata da mesma base encontrada no Mac

OS X. No topo do kernel estão as camadas de serviços utilizadas para

implementação de aplicativos na plataforma, a estrutura das camadas esta

representada na figura a seguir (APPLE, 2012).

A seguir a figura 12 ilustra as camadas da arquitetura da plataforma

iOS:

Figura 12. Arquitetura iOS. Fonte: (APPLE 2012).

• Core OS: (Núcleo do sistema operacional) OS X Kernel, Sockets,

Segurança, Gerenciamento de Energia, Certificados, Sistema de Arquivos.

• Core Services: (Serviços oferecidos pelo sistema) SQLite, Acesso a

Arquivos, Preferências, Livro de Endereços, Rede.

• Media: (serviços de mídia IOS) OpenAL, Gravação e Mixagem de Audio,

Núcleo de Animação, Leitor de PDF, OpenGL ES e Quartz.

• Cocoa Touch: Eventos e controle, Acelerômetro, Câmera, Alertas, Pickers,

Sistema de Localização. A arquitetura desta API do iOS é dividida no

Foundation Framework e no UIKit, e segue o padrão MVC.

34

Foundation oferece classes utilitárias, como XMLParser, coleções

(Arrays e Dicionários), serviços (como o controlador do “Desfazer” e de Erros),

entre vários outros. As classes oferecidas pela Foundation começam por NS

(NextStep), e são a NSXMLParser, NSString e NSMutableArray.

O UIKit controla as interações do usuário UI (User Interface) em

tempo de execução, é com ele que colocam botões, labels, campos de texto e tudo

mais que o usuário interage como, UIButton, UIColor, UILabel, UIOutlet,

UITextFieldDelegate e outros (APPLE, 2012).

4.3. APLICATIVOS iOS

Como explica CONWAY e HILLEGASS (2011), o que tornam os

dispositivos da Apple tão famosos e essenciais, são seus aplicativos, que

disponibiliza aos usuários serviços de mapas, músicas, jogos, e câmera com

funcionalidade built-in do iPhone, iPod Touch e iPad, mas a real vantagem destes

dispositivos é a App Store. Onde se encontram mais de um quarto de milhão de

aplicações, que transformam o dispositivo em uma ferramenta especializada para

exatamente o que o usuário desejar. A Apple revisa todos os aplicativos antes da

publicação na App Store, e o usuário deve ler suas diretrizes atuais para a

aceitação antes de iniciar a aplicação. A App Store é uma aplicação da Apple sobre

o iPhone, iPodTouch, e iPad. Os clientes podem usar a App Store para navegar e

fazer download de aplicativos da Apple, e iTunes Store.

CONWAY e HILLEGASS (2011, p. 4) também explicam que, “alguns

aplicativos são gratuitos, enquanto outros têm um custo (geralmente) nominal.

Utilizando uma conta iTunes, é possível fazer download de aplicativos diretamente

para os dispositivos da Apple”.

Muitas aplicações são inúteis, mas muitas são bastante

surpreendentes. O download de aplicativos da App Store é fácil e barato, e os

desenvolvedores independentes podem desenvolver aplicativos para a App Store

fazendo o download do SDK iOS, desenvolvendo um aplicativo, e se cadastrando

no iOS Developer Program. A Apple, em seguida, analisa a aplicação, e uma vez

que passe pelo processo de revisão, é adicionado ao iTunes Store (CONWAY e

HILLEGASS, 2011).

35

5. ANDROID

A plataforma Android foi concebida inicialmente pelo Google em 05 de

Novembro de 2007, tornando pública a primeira plataforma open source de

desenvolvimento para dispositivos móveis baseada na sintaxe da plataforma Java

com sistema operacional baseado em Linux (RABELLO, 2012).

A plataforma está sendo mantida pelo Open Handset Alliance (OHA),

que é um grupo formado por 84 empresas (de tecnologias de dispositivos móveis,

provedoras de serviços móveis e fabricantes), lideradas pela Google, as quais se

uniram para inovar e acelerar o desenvolvimento de aplicações e serviços,

trazendo aos consumidores uma experiência mais rica em termos de recursos, e

menor custo financeiro para o mercado móvel, conforme exposto por (ABLESON et

al., 2011).

5.1. DEFINIÇÃO

O Android é uma plataforma para tecnologia móvel completa,

envolvendo um pacote com programas para celulares, já com um sistema

operacional middleware, aplicativos e interface do usuário.

Como mencionado por PEREIRA e SILVA (2009), a plataforma Android

foi construída com a intenção de permitir aos desenvolvedores criar aplicações

móveis para aparelhos portáteis e para ser verdadeiramente aberto. Por exemplo,

uma aplicação pode apelar a qualquer uma das funcionalidades de núcleo a

câmera, que permite aos desenvolvedores adaptarem e evoluírem cada vez mais

estas funcionalidades.

Por ser open source, a plataforma Android pode ser sempre adaptado

a fim de incorporar novas tecnologias, conforme estas forem surgindo. A plataforma

vai estar sempre em evolução, já que as comunidades de desenvolvedores estarão

trabalhando em conjunto para construir aplicações móveis inovadoras.

36

5.2. DESENVOLVIMENTO PARA PLATAFORMA ANDROID

O sistema operacional Android é o primeiro projeto de uma plataforma

open source para dispositivos móveis em conjunto com a Open Hanset Alliance.

A plataforma Android oferece aos desenvolvedores a capacidade de

criar aplicações extremamente ricas e inovadoras. Os desenvolvedores estão livres

para aproveitar o hardware do dispositivo, as informações de localização de

acesso, e execução de serviços. Os desenvolvedores têm acesso total às APIs

(Application Programming Interface ou Interface de Programação de Aplicativos) do

mesmo core utilizado pelo sistema operacional (ANDROID DEVELOPERS, 2011).

Como descreve Gargenta et al. (2010), para que seja possível o

desenvolvimento para plataforma Android, é necessário o Android SDK (Software

Develoment kit) kit de desenvolvimento e emulador que disponibiliza as

ferramentas e APIs necessárias para desenvolver aplicações para a plataforma

Android, o SDK funciona em Windows, Linux e Mac OS X, é necessário que instale

também o JDK e uma IDE.

O sistema operacional Android oferece suporte completo para banco

de dados SQLite, um leve e poderoso banco de dados, onde qualquer banco de

dados criado poderá ser acessado pelo nome de qualquer classe da aplicação,

mas não permite acesso de fora do aplicativo (ANDROID DEVELOPERS, 2012).

O Android conta com um emulador de dispositivos móveis, um

dispositivo móvel virtual que roda no computador. O emulador permite ao

desenvolvedor testar aplicativos Android sem o uso de um dispositivo físico

(ANDROID DEVELOPERS, 2012).

37

A seguir a figura 8 ilustra o Emulador para Android, utilizando IDE

Eclipse:

Figura 8. Emulador Android. Fonte: Gargenta et al. (2010).

Como descreve Gargenta et al. (2010), o desenvolvimento pode ser

feito em outras linguagens de programação como:

• C/C++: apoiada pela Google através do NDK (Kit de Desenvolvimento

Nativo), existente desde 2009, que permite os programadores criarem ou

migrarem aplicativos nas linguagens C e C++ (código nativo) para a

plataforma Android, aumentando o numero de jogos e aplicações

multimídias no Android Market;

• .NET Framework: os desenvolvedores que utilizam as linguagens da

Microsoft podem utilizar Mono For Android, esta habilita a programação para

Android através da linguagem C# e .Net Framework 4. Isto é feito através da

transformação do código .Net em código nativo do Android. Como a grande

maioria dos projetos desenvolvidos nas linguagens do framework da

Microsoft, os projetos destinados ao SO Android podem ser desenvolvidos

no Microsoft Visual Studio baixando-se um plug-in para o ambiente;

• Scala: esta ainda é uma linguagem pouco utilizada, é estática e funciona

sobre a Máquina Virtual Java

Scala, apesar de sua sintaxe ser semelhante ao Java

defendida por permitir a escrita do código

facilidade de compartilhamento do que a linguagem Java. O método

convencional para programação em Scala é dado através da instalação do

plug-in SBT (Simple Build Tool) na IDE Eclipse;

• Python: o projeto

distinta linguagem a migrarem aplicativos para a plataforma Android. A

ferramenta utiliza os recursos do projeto SL4A (ScriptingLayer for Android),

que permite usuário executarem linguagens tipadas no Android. Os

aplicativos Python podem ser executados no e

físico.

A seguir a

Figura 9. IDE Eclipse com SDK Android

: esta ainda é uma linguagem pouco utilizada, é estática e funciona

sobre a Máquina Virtual Java (JVM). Ainda possui pouco material sobre

apesar de sua sintaxe ser semelhante ao Java

defendida por permitir a escrita do código mais rapidamente e uma maior



(Simple Build Tool) na IDE Eclipse;

: o projeto Python for Android possibilita desenvolvedores desta




vos Python podem ser executados no emulador e no dispositivo

uir a figura 9 ilustra a IDE Eclipse com SDK Android

IDE Eclipse com SDK Android.

38

: esta ainda é uma linguagem pouco utilizada, é estática e funciona

uco material sobre

apesar de sua sintaxe ser semelhante ao Java, ela vem sendo

mais rapidamente e uma maior



possibilita desenvolvedores desta




mulador e no dispositivo

lustra a IDE Eclipse com SDK Android:

39

“A plataforma Android foi desenvolvida com base no sistema

operacional Linux e é composta por um conjunto de ferramentas que atua em todas

as fases do desenvolvimento do projeto, desde a execução até a criação de

softwares específicos”, segundo PEREIRA e SILVA (2009, p. 12).

5.3. ARQUITETURA DA PLATAFORMA ANDROID

A arquitetura da plataforma Android é dividida em várias camadas:

Applications and Widgets, Application Framework, Libraries, Android Runtime, e

Linux Kernel.

Conforme menciona Gargenta et al. (2010), na camada Applications

and Widgets, está localizada uma lista de aplicações padrões que incluem um

cliente de e-mail, programa de SMS, calendário, mapas, navegador, gerenciador de

contatos, e outros que serão desenvolvidos pela comunidade, sendo todas essas

aplicações escritas na linguagem Java.

Gargenta et al. (2010, p.33) argumenta que, “na camada Application

Framework estão os componentes que permitirão com que novas estruturas sejam

utilizadas para futuras aplicações, enfatizando a reutilização de código”. Os

seguintes componentes fazem parte desta camada:

• Um rico e extensível conjunto de gráficos que pode ser utilizado para

construir uma aplicação, bem como listas, grids, caixas de textos, botões, e

até um navegador web embutido.

• Provedores de conteúdo que habilitam às aplicações acessar dados de

outras aplicações (como os Contatos, por exemplo) ou compartilhar seus

próprios dados.

• Recursos que prove acesso a recursos não-codificados como strings,

gráficos, e arquivos de layout.

• Um gerenciador de notificação que permite que todas as aplicações exibam

mensagens de alerta personalizáveis na barra de status.

• Um de atividade que gerencia o ciclo de vida das aplicações e permite

controlar os recursos previamente alocados, sendo que caso eles não

40

estejam sendo mais utilizados, os mesmos são desalocados para liberar

memória.

A seguir a figura 7 ilustra as camadas da Arquitetura Android:

Figura 7. Camadas da Arquitetura Android. Fonte: (GARGENTA et al., 2010).

Como descreve Gargenta et al. (2010), logo abaixo da camada

Application Framework esta subdivida o grupo das bibliotecas (libraries) e o

ambiente de execução (runtime) da plataforma Android, composto pelas bibliotecas

padrão e pela máquina virtual denominada Dalvik. No primeiro grupo estão as

bibliotecas escritas em C/C++, que são compostas por uma coleção de bibliotecas

que são utilizadas pela plataforma Android. Estas bibliotecas são:

• Biblioteca de sistema C: é uma implementação da biblioteca C padrão (libc),

otimizada para dispositivos que suportam a plataforma Linux (embeded-

linux).

41

• Bibliotecas de Mídias: as bibliotecas suportam execução e gravação da

maioria dos formatos de áudio e vídeo, bem como exibição de imagens,

incluindo MPEG4, H.264, MP3, AAC, AMR, JPG, e PNG.

• Gerenciador de Superfície: gerencia o acesso ao display do dispositivo e

camadas de gráficos 2D e 3D de múltiplas aplicações.

• LibWebCore: uma moderna engine de navegador web que turbina tanto o

navegador da plataforma Android e um outro navegador qualquer

desenvolvido.

• SGL: uma engine de gráficos 2D.

• 3D libraries: uma implementação baseada na especificação OpenGL ES 1.0,

a qual utiliza tanto aceleração de hardware 3D e um avançado e otimizado

software para renderização de modelos tridimensionais.

• FreeType: renderização em formatos bitmaps e vetoriais de fontes.

• SQLite: uma poderosa e leve engine de banco de dados relacional

disponível para todas as aplicações.

Meier (2011) afirma que sobre o ambiente de execução, a plataforma é

composta pela máquina virtual Dalvik. Toda e qualquer aplicação em Android roda

dentro de seu próprio processo, isto é, no contexto da sua instância de máquina

virtual. Esta VM foi escrita para que os dispositivos possam suportar múltiplas

máquinas virtuais eficientemente. A Dalvik executa arquivos no formato Dalvik

Executable, com extensão .dex, um arquivo .dex nada mais é do que uma espécie

de bytecodes de Java, os famosos arquivos compilados .class, otimizados para a

plataforma Android.

Segundo Meier (2011, p.13), “Na base, está localizado o kernel Linux,

que para a Android será a versão 2.6, fornecendo serviços do núcleo do sistema

como segurança, gerenciamento de memória, gerenciamento de processos, pilhas

de redes, etc”.

5.4. APLICATIVOS ANDROI

Aplicativo, ou simplesmente app, é um

funções ao celular. Eles podem ser comprados e baixados das lojas virtuais

vinculadas ao sistema operacional do aparelho. As mais populares são App Store,

para o sistema operacional da Apple (iOS), e Android

Google.

O mercado de aplicativos

outubro de 2008, porém,

download. Em dezembro de 2009, esse número já havia subido para cerca de 20

mil apps. O crescimento do número de aparelhos e as vendas em 2010 segu

juntamente com a expansão de aplicativos disponibilizados no Android Market.

Atualmente, a loja conta com mais de 400

download, entre eles sucess

(RASMUSSEN, 2011).

A seguir a

para Android e iOS:

Figura 10. Aplicativos gratuitos X

2012).

APLICATIVOS ANDROID

Aplicativo, ou simplesmente app, é um programa que adiciona novas



para o sistema operacional da Apple (iOS), e Android Market, para Android

O mercado de aplicativos Android Market foi disponibil

outubro de 2008, porém, com pouco mais de dois mil aplicativos disponíveis para

. Em dezembro de 2009, esse número já havia subido para cerca de 20

apps. O crescimento do número de aparelhos e as vendas em 2010 segu


te, a loja conta com mais de 400 mil aplicativos gratuitos e pagos para

, entre eles sucessos como o Angry Birds, TweetDeck

A seguir a figura 10 ilustra o numero de aplicativos pagos e gratuitos

ativos gratuitos X pagos para Android Market e iOS(App Store)

42

programa que adiciona novas



Market, para Android, do

foi disponibilizado em

mil aplicativos disponíveis para

. Em dezembro de 2009, esse número já havia subido para cerca de 20

apps. O crescimento do número de aparelhos e as vendas em 2010 seguiram


mil aplicativos gratuitos e pagos para

TweetDeck e Facebook,

ilustra o numero de aplicativos pagos e gratuitos

(App Store). Fonte: (LOOKOUT,

43

O Brasil faz parte dos países que podem vender e comprar aplicativos

no Android Market, função essa liberada no final de 2010. Diferente da loja de

aplicativos da Apple, uma das vantagens do Market é a venda de jogos também

para o nosso país, algo bloqueado pela Apple devido às leis que regem a

classificação etária de games no Brasil (RASMUSSEN, 2011).

Existem alguns aplicativos disponíveis no Android Market conhecidos

como spyware ou malware, que possuem códigos maliciosos e vírus, estes

aplicativos mal intencionados podem ser baixados livremente, pois a Google não

restringe os aplicativos que são postados no Android Market. Os softwares

maliciosos podem roubar dados dos usuários, gravar conversas, e até mesmo

informações para fazer ligações sem a autorização expressa do usuário

(BRUNELLI, 2011).

O Android Market possui alguns antivírus, incluindo o aplicativo Avast, e

já é possível encontrar soluções da AVG, BitDefender, Kaspersky, e Trend Micro.

Assim como a AVG, que comprou a DroidSecurity para criar o AntiVirus Free atual,

a Avast comprou a empresa ITAgents, que criou o Theft Aware. O programa

verifica o conteúdo e aplicativos no aparelho e no cartão de memória, identifica

riscos potenciais e filtra ligações e SMS, o que pode evitar os cavalos de tróia que

ligam para números estrangeiros, por exemplo. Além disso, oferece proteção

contra endereços suspeitos na Internet (EISHIMA, 2011).

Eishima (2008), também complementa que, assim como outros

programas do gênero antivírus, o Avast oferece a opção de limpar a memória do

aparelho, tocar um alarme, travar o sistema e reiniciar o sistema remotamente,

além de localizá-lo em caso de perda ou roubo.

44

6. ESTUDO DE CASO – DESENVOLVIMENTO DE APLICATIVO ANDROID

Para o desenvolvimento do aplicativo na plataforma Android,

primeiramente foi necessário instalar as ferramentas de desenvolvimento citadas

no item 5.2., o JDK e uma IDE (neste caso o Eclipse) para executar a ferramenta

Android SDK.

Como descreve Gargenta et al. (2010), para que seja possível o

desenvolvimento para plataforma Android, é necessário o Android SDK (Software

Develoment kit) kit de desenvolvimento e emulador que disponibiliza as

ferramentas e APIs necessárias para desenvolver aplicações para a plataforma

Android, é necessário que instale também o JDK e uma IDE.

Após instalado a IDE Eclipse e a ferramenta JDK, foi necessário

instalar o plugin Android SDK diretamente no Eclipse da seguinte forma:

• Na IDE Eclipse, em (help) e (Install New Software);

• No campo (Work with), adicionar o link:

http://schemas.android.com/apk/res/android no campo (Location), este link

encontra-se no site www.androiddevelopers.com;

• Clicar em (ok), depois (finish), e aguardar que seja instalado.

45

A seguir a figura 13 ilustra os campos para instalar o plugin Android

SDK:

Figura 13. Campos da IDE Eclipse para adicionar a SDK Android.

Depois de instalado o plugin, foi criado um novo Android Project,

para ser desenvolvido o aplicativo. O novo projeto foi criado da seguinte forma:

• Na IDE Eclipse, em (New) e (Android Project);

• Logo dado o nome do projeto, e selecionado qual versão da plataforma

Android para qual será desenvolvido (no caso Android 2.1);

• Depois clicado em (Next >) e (Finish).

46

A seguir a figura 14 ilustra os campos para Criar um Novo Projeto

Android:

Figura 14. Campos da IDE Eclipse para Criar um Novo Projeto Android.

Depois de gerado o projeto, automaticamente é criado a estrutura

básica inicial, porém, foi criado 3 pacotes onde se encontram as classes que

constituíram a formação do aplicativo final. Dentre estas classes estão a classe

(BaseDAO.java) do pacote (br.agenda.DAO), onde esta o código de criação do

banco de dados, utilizando a biblioteca SQLite existente no SDK Android, e a

classe (ContatoVO.java) do pacote (br.agenda.POJO), que é a responsável pelo

transporte dos dados entre a interface e o banco de dados.

Na arquitetura para o desenvolvimento em Android é possível criar

classes que contém a ferramenta Graphical Layout, usada para inserir imagens,

editore de texto, botões, listas de arquivos, CheckBox, relógio, controle de zoom,

dentre outros recursos que facilitam o desenvolvimento.

47

A seguir a figura 15 ilustra alguns recursos do Graphical Layout:

Figura 15. Graphical Layout.

Para finalizar o aplicativo, foi utilizado o emulador do SDK Android

AVD (Android Virtual Device), onde é possível realizar os testes e verificações para

garantir o funcionamento perfeito do aplicativo, neste caso foi criado uma Agenda

de Contatos, onde se pode cadastrar o nome, endereço, e telefone do contato,

além de ser possível editar e excluir um contato existente.

Antes de utilizar o emulador, este deve ser criado da seguinte forma:

48

• Na IDE Eclipse, é preciso clicar no ícone do emulador Android no lado

superior esquerdo (Opens the Android Virtual Device Manager);

• Adicionar um novo emulador (AVD) em (New);

• No campo (Target) é preciso selecionar a versão do Android de acordo

com o que foi criado o projeto;

• Deve-se definir o nome do emulador (neste caso o nome é avd_2_1),

capacidade de memória e a resolução de tela (neste caso 1024 MB, e

resolução de HVGA);

• E por fim clicar em (Creat AVD), o emulador será carregado e estará

pronto para uso.

A seguir a figura 16 ilustra o Emulador avd_2_1:

Figura 16. Emulador avd_2_1.

Para instalar este aplicativo no celular, primeiramente é necessária

que a versão do dispositivo seja a mesma criada no projeto, para que não ocorram

erros durante a execução das funções do aplicativo, segundo passo, é preciso que

49

o celular seja conectado por cabo USB (Universal Serial Bus), e que esteja com as

funções (Fontes Desconhecidas, Depuração USB, Permanecer Ativo e Permitir

Locais Fictícios) selecionadas, assim quando executar o projeto no Eclipse,

automaticamente poderá ser escolhido se deve rodar no Emulador AVD, ou no

dispositivo externo (celular). Caso for selecionado o celular como emulador, o

aplicativo será instalado automaticamente e pronto para uso.

Para o desenvolvimento deste aplicativo, não houve problemas que

dificultassem o objetivo final e o funcionamento correto. Com a experiência

adquirida após finalizar este projeto, é possível executar outros com mais facilidade

e menos tempo, dependendo do problema a ser resolvido.

50

7. CONCLUSÃO

Tendo em vista que a tecnologia para dispositivos móveis evolui

rapidamente e que as pessoas (usuários) estão cada vez mais dependentes destas

tecnologias, além do fato da existência de várias plataformas para desenvolvimento

destes dispositivos, foi proposta a realização deste trabalho e por base no

conteúdo apresentado do mesmo, pode-se considerar que é de vital importância a

escolha mais adequada da plataforma para desenvolvimento de aplicativos para

smartphones, de acordo com a problemática do desenvolvedor, ou empresa

desenvolvedora.

Algumas das possíveis soluções de desenvolvimento citadas no

decorrer do trabalho são as ferramentas de desenvolvimentos (IDEs) como o

Eclipse, NetBeans, Visual Studio e Xcode, voltada apenas para desenvolvimento

de dispositivos da Apple.

Porém, como o mercado atual esta crescendo na maior parte para

plataforma Android, que é patrocinada e utilizada por instituições e empresas

participantes da OHA (Open Handset Alliance), como a Acer, Asus, Dell, LG,

Samsung, Sony Ericsson, Toshiba, Intel, e a Google que é a líder deste grupo,

ajudando a demonstrar a aplicabilidade e confiabilidade do sistema operacional

Android.

O desenvolvimento de um estudo de caso permitiu avaliar as

principais vantagens e dificuldades encontradas durante o desenvolvimento e

instalação do aplicativo em um exemplo real, além de expor de forma prática a

criação, desenvolvimento e finalização de um projeto de aplicativo Android.

Para tanto, com a realização desta pesquisa é possível compreender

a importância dos sistemas operacionais e ferramentas para desenvolvimento em

dispositivos móveis, de forma que os desenvolvimentos de aplicações podem ser

executadas em ambas as plataformas, mas não com os mesmos recursos, o que

pode afetar no resultado final das aplicações e projetos.

Conclui-se que o desenvolvimento para dispositivos móveis, é

indispensável, por estar em constante evolução e ser de alta usabilidade para os

usuários finais, ainda pode-se afirmar que é de suma importância uma escolha

adequada da ferramenta para desenvolvimento, visando a qualidade do produto

final.

51

Este trabalho contribuiu para ampliar meus conhecimentos em termos

de plataformas de desenvolvimento para dispositivos móveis, principalmente por ter

executado um projeto de criação de um aplicativo na prática e estudado as

plataformas dos sistemas operacionais mais vendidos mundialmente, Android e

iOS.

7.1. TRABALHOS FUTUROS

Como neste trabalho foi apresentados conceitos sobre as plataformas

e ferramentas para desenvolvimento de aplicações para dispositivos móveis

focando nos smartphones com estudo de caso em Android. Para a continuação

deste trabalho propõe-se realizar uma análise aprofundada da plataforma iOS,

suas ferramentas, podendo também dar maior foco nos dispositivos móveis como

Tablets, por estarem em constante evolução no mercado tecnologico.

Para trabalhos futuros, também pode ser feito o desenvolvimento de

um projeto utilizando outra plataforma de desenvolvimento, ou uma análise

comparativa entre duas plataformas utilizando um quadro por exemplo.

52

8. REFERÊNCIAS BIBLIOGRÁFICAS

ABLESON, Frank W; SEM, Robi; KING, Chris. Android in Action. 2 ed. United

States of America. Manning Publications Co. 2011.

APLLE. iOS Developer Library. Disponível em:

<http://developer.apple.com/library/ios/navigation/#section=Resource%20Types&to

pic=Guides>. Acessado em: 08 de junho de 2012.

BLACKBERRY. Disponivel em: < http://br.blackberry.com/>. Acessado em: 08 de

junho de 2012.

BRANNAN, James A; WARD, Blake. iOS SDK Programming: A beginner’s Guide.

United States of America. The McGraw-Hill Companies. 2011.

BRUNELLI, João Moreno. Malware para Android. 2011. Disponível em:

http://tecnoblog.net/82503/malware-android-cresce/. Acessado em: 17 de maio de

2012.

CAVALLINI, Ricardo; XAVIER, Léo; SOCHACZEWSKI, Alon. Mobilize. São Paulo.

Ed. dos Autores. 2010.

CONWAY, Joe; HILLEGASS, Aaron. iOS Programming: The Big Nerd Ranch

Guide. 2 ed. Atlanta, United States of America. Copyright Big Nerd Ranch, Inc.

2011

DIAS, Kadu. BlackBerry. 2011. Disponível em:

http://mundodasmarcas.blogspot.com.br/2006/09/blackberry-always-on-always-

connected.html. Acessado em: 03 de abril de 2012.

EISHIMA, Rubens Haruo. Avast Lança Antivírus Para Android. 2011. Disponível

em: http://www.superdownloads.com.br/materias/avast-lanca-antivirus-android.html.

Acessado em 17 de maio de 2012.

53

FERRARI, Bruno. Os tijolões Estão de Volta. Revista Época, publicado em 12 de

dezembro de 2011. Disponível em:

http://colunas.revistaepoca.globo.com/fazcaber/2011/12/12/diagrama-sobre-a-

evolucao-dos-celulares-fotos-ou-desenhos/. Acessado em 18 de março de 2012.

GALAXY NOTE. Disponível em: <http://www.samsung.com/br/>. Acessado em: 28

de março de 2012.

GARGENTA, Marko; MILANO, Diego Torres; RAPP, Nathan; MARTIN, Michael.

Hello, Android: Introducing Google’s Mobile Development Platform. 3 ed. United

States of America. Pragmatic Programmers LLC. 2010.

GARTNER. Vendas mundiais de dispositivos móveis para usuários finais por

Vendedor (Empresa) 1T12. 2012. Disponível em:

http://www.gartner.com/it/page.jsp?id=2017015. Acessado em: 10 de junho de

2012.

IPHONE. Disponível em: <http://www.apple.com/br/iphone/>. Acessado em: 18 de

março de 2012.

IPAD. Disponível em: <http://www.apple.com/br/ipad/>. Acessado em: 28 de março

de 2012.

BULL JUNIOR, Lealcy. Do tijolo ao IPhone: A evolução dos celulares.

Disponível em: http://ceticismo.wordpress.com/2007/06/05/do-tijolo-ao-iphone-a-

evolucao-dos-celulares/. Publicado em 05/06/2007. Acesso em: 11/02.

KLEIN, Eduardo. Desenvolvimento J2ME para celulares. 2008. Disponível em:

http://arquiteturaemobilidade.blogspot.com.br/search/label/blackberry. Acessado

em: 03 de abril de 2012.

LOOKOUT. Aplicativos pagos e gratuitos Android e iOS. 2011. Disponível em:

https://www.mylookout.com/appgenome. Acessado em: 18 de maio de 2012.

54

MARK, Dave; NUTTING, Jack; LaMarche, Jeff. Beginning iOS 5 Development:

Exploring the iOS SDK. Apress ED Books. 2011.

MEIR, Reto. Professional Android Application Development. Indiana: Wiley

Publishing Inc., 2009.

MORIMOTO, Carlos E. SmartPhones: A historia do Symbian. 2010. Disponível

em:

http://www.hardware.com.br/dicas/historia-symbian.html. Acessado em: 02 de abril

de 2012.

MUCHOW, John W. Core J2ME Tecnologia & MIDP. São Paulo: Pearson Makron

Books, 2004.

OHA. Disponível em:

<http://www.openhandsetalliance.com/android_overview.html> Acessado em: 07 de

março de 2012.

PEREIRA, Lúcio C. Oliva; SILVA, Michel Lourenço. Android Para

Desenvolvedores. Rio de Janeiro: Brasport Livros e Multimídia Ltda, 2009.

RABELLO, Ramon Ribeiro. Artigo da revista WebMobile 18 - Android: um novo

paradigma de desenvolvimento móvel. 2012. Disponível em:

http://www.devmedia.com.br/artigo-webmobile-18-android-um-novo-paradigma-de-

desenvolvimento-movel/9350. Acessado em: 09 de março de 2012.

RASMUSSEN, Bruna. Android: o sistema operacional móvel que conquistou o

mundo. 2011. Disponível em:

http://www.tecmundo.com.br/infografico/9010-android-o-sistema-operacional-

movel-que-conquistou-o-mundo.htm. Acessado em: 15 de abril de 2012.

RIZK, Anthony. Beginning BlackBerry Development. United States of America,

New York. Ed. Apress. 2009.

55

SILVA, Renato. A evolução do sistema operacional iOS. 2011. Disponível em:

http://pt.calameo.com/read/00053935644470a885967. Acessado em: 18 de maio

de 2012.

SOUZA, Leonardo da Silva. J2ME-Plataforma Java Para Dispositivos Móveis.

2011. Disponível em:

http://www.ebah.com.br/content/ABAAAelI4AJ/j2me-plataforma-java-dispositivos-

moveis. Acessado em: 11 de abril de 2012.

VISUAL STUDIO. 2008. Disponível em:

http://www.softwareknowhow.info/portals/0/articleresources/images/43-mobile-

platforms-1.jpg&imgrefurl. Acessado em: 12 de junho de 2012.

WELLS, Martin J. J2ME: Game Programming. Boston. Thomson Course

Technology. 2004.

56

9. ANEXO – CÓDIGO FONTE Pacote: br.agenda.DAO Classe BaseDAO.java:

package br.agenda.DAO;

import android.content.Context;

import android.database.sqlite.SQLiteDatabase;

import android.database.sqlite.SQLiteOpenHelper;

//Classe responsável pela criação do Banco de Dados e tabelas

public class BaseDAO extends SQLiteOpenHelper {

public static final String TBL_AGENDA = "agenda";

public static final String AGENDA_ID = "_id";

public static final String AGENDA_NOME = "nome";

public static final String AGENDA_ENDERECO = "endereco";

public static final String AGENDA_TELEFONE = "telefone";

private static final String DATABASE_NAME = "agenda.db";

private static final int DATABASE_VERSION = 1;

//Estrutura da tabela Agenda (sql statement)

private static final String CREATE_AGENDA = "create table " +

TBL_AGENDA + "( " + AGENDA_ID + " integer primary key

autoincrement, " +

AGENDA_NOME + " text not null, " +

AGENDA_ENDERECO + " text not null, " +

AGENDA_TELEFONE + " text not null);";

public BaseDAO(Context context) {

super(context, DATABASE_NAME, null, DATABASE_VERSION);

}

//Criação da tabela

@Override

public void onCreate(SQLiteDatabase database) {

database.execSQL(CREATE_AGENDA);

}

@Override

public void onUpgrade(SQLiteDatabase db, int oldVersion, int

newVersion) {

//Caso seja necessário mudar a estrutura da tabela

//deverá primeiro excluir a tabela e depois recriá-la

db.execSQL("DROP TABLE IF EXISTS " + TBL_AGENDA);

onCreate(db);

}

}

Classe ContatoAdapter.java: package br.agenda.DAO;

import java.util.List;


import android.view.LayoutInflater;

import android.view.View;

import android.view.ViewGroup;

import android.widget.BaseAdapter;

import android.widget.TextView;

import android.widget.Toast;

import br.agenda.POJO.ContatoVO;

import br.agenda.contatos.R.id;

import br.agenda.contatos.R.layout;

public class ContatoAdapter extends BaseAdapter {

57

private Context context;

private List<ContatoVO> lstContato;

private LayoutInflater inflater;

public ContatoAdapter(Context context, List<ContatoVO> listAgenda) {

this.context = context;

this.lstContato = listAgenda;

inflater = (LayoutInflater)

context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

}

//Atualizar ListView de acordo com o lstContato

@Override

public void notifyDataSetChanged() {

try{

super.notifyDataSetChanged();

}catch (Exception e) {

trace("Erro : " + e.getMessage());

}

}

public int getCount() {

return lstContato.size();

}

//Remover item da lista

public void remove(final ContatoVO item) {

this.lstContato.remove(item);

}

//Adicionar item na lista

public void add(final ContatoVO item) {

this.lstContato.add(item);

}

public Object getItem(int position) {

return lstContato.get(position);

}

public long getItemId(int position) {

return position;

}

public View getView(int position, View convertView, ViewGroup

viewGroup) {

try

{

ContatoVO contato = lstContato.get(position);

//O ViewHolder irá guardar a instâncias dos objetos do estado_row

ViewHolder holder;

//Quando o objeto convertView não for nulo nós não precisaremos inflar

//os objetos do XML, ele será nulo quando for a primeira vez que for

carregado

if (convertView == null) {

convertView = inflater.inflate(layout.contato_row, null);

//Cria o Viewholder e guarda a instância dos objetos

holder = new ViewHolder();

holder.tvNome = (TextView)

convertView.findViewById(id.txtNome);

holder.tvEndereco = (TextView)

convertView.findViewById(id.txtEndereco);

holder.tvTelefone = (TextView)

convertView.findViewById(id.txtTelefone);

58

convertView.setTag(holder);

} else {

//pega o ViewHolder para ter um acesso rápido aos objetos do XML

//ele sempre passará por aqui quando,por exemplo, for efetuado uma rolagem

na tela

holder = (ViewHolder) convertView.getTag();

}

holder.tvNome.setText(contato.getNome());

holder.tvEndereco.setText(contato.getEndereco());

holder.tvTelefone.setText(contato.getTelefone());

return convertView;



}

return convertView;

}

public void toast (String msg)

{

Toast.makeText (context, msg, Toast.LENGTH_SHORT).show ();

}

private void trace (String msg)

{

toast (msg);

}

//Criada esta classe estática para guardar a referência dos objetos abaixo

static class ViewHolder {

public TextView tvNome;

public TextView tvEndereco;

public TextView tvTelefone;

}

}

Classe ContatoDAO.java: package br.agenda.DAO;

import java.util.ArrayList;



import android.content.ContentValues;


import android.database.Cursor;

import android.database.SQLException;

import android.database.sqlite.SQLiteDatabase;

public class ContatoDAO {

private SQLiteDatabase database;

private BaseDAO dbHelper;

//Campos da tabela Agenda

private String[] colunas = {BaseDAO.AGENDA_ID,

BaseDAO.AGENDA_NOME,

BaseDAO.AGENDA_ENDERECO,

BaseDAO.AGENDA_TELEFONE };

public ContatoDAO(Context context) {

dbHelper = new BaseDAO(context);

}

public void open() throws SQLException {

database = dbHelper.getWritableDatabase();

}

public void close() {

dbHelper.close();

}

59

public long Inserir(ContatoVO pValue) {

ContentValues values = new ContentValues();

//Carregar os valores nos campos do Contato que será incluído

values.put(BaseDAO.AGENDA_NOME, pValue.getNome());

values.put(BaseDAO.AGENDA_ENDERECO, pValue.getEndereco());

values.put(BaseDAO.AGENDA_TELEFONE, pValue.getTelefone());

return database.insert(BaseDAO.TBL_AGENDA, null, values);

}

public int Alterar(ContatoVO pValue) {

long id = pValue.getId();

ContentValues values = new ContentValues();

//Carregar os novos valores nos campos que serão alterados

values.put(BaseDAO.AGENDA_NOME, pValue.getNome());

values.put(BaseDAO.AGENDA_ENDERECO, pValue.getEndereco());

values.put(BaseDAO.AGENDA_TELEFONE, pValue.getTelefone());

//Alterar o registro com base no ID

return database.update(BaseDAO.TBL_AGENDA, values,

BaseDAO.AGENDA_ID + " = " + id, null);

}

public void Excluir(ContatoVO pValue) {

long id = pValue.getId();

//Exclui o registro com base no ID

database.delete(BaseDAO.TBL_AGENDA, BaseDAO.AGENDA_ID + " = " +

id, null);

}

public List<ContatoVO> Consultar() {

List<ContatoVO> lstAgenda = new ArrayList<ContatoVO>();

//Consulta para trazer todos os dados da tabela Agenda ordenados pela

coluna Nome

Cursor cursor = database.query(BaseDAO.TBL_AGENDA, colunas,

null, null, null, null, BaseDAO.AGENDA_NOME);

cursor.moveToFirst();

while (!cursor.isAfterLast()) {

ContatoVO lContatoVO = cursorToContato(cursor);

lstAgenda.add(lContatoVO);

cursor.moveToNext();

}

//Tenha certeza que você fechou o cursor

cursor.close();

return lstAgenda;

}

//Converter o Cursor de dados no objeto POJO ContatoVO

private ContatoVO cursorToContato(Cursor cursor) {

ContatoVO lContatoVO = new ContatoVO();

lContatoVO.setId(cursor.getLong(0));

lContatoVO.setNome(cursor.getString(1));

lContatoVO.setEndereco(cursor.getString(2));

lContatoVO.setTelefone(cursor.getString(3));

return lContatoVO;

}

}

Pacote: br.agenda.POJO Classe ContatoVO.java: package br.agenda.POJO;

import java.io.Serializable;

//Classe responsável pelo transporte dos dados entre a

//interface(tela) e Banco de Dados

public class ContatoVO implements Serializable {

private static final long serialVersionUID = 1L;

private long id;

60

private String nome;

private String endereco;

private String telefone;

public long getId() {

return id;

}

public void setId(long id) {

this.id = id;

}

public String getNome() {

return nome;

}

public void setNome(String value) {

this.nome = value;

}

public String getEndereco() {

return endereco;

}

public void setEndereco(String value) {

this.endereco = value;

}

public String getTelefone() {

return telefone;

}

public void setTelefone(String value) {

this.telefone = value;

}

// Will be used by the ArrayAdapter in the ListView

@Override

public String toString() {

return nome;

}

}

Pacote: br.agenda.UI Classe ContatoUI.java: package br.agenda.UI;


import android.app.Activity;

import android.content.Intent;

import android.os.Bundle;


import android.widget.EditText;


import br.agenda.contatos.R;

public class ContatoUI extends Activity {

private static final int INCLUIR = 0;

//private static final int ALTERAR = 1;

ContatoVO lContatoVO;

EditText txtNome;

EditText txtEndereco;

EditText txtTelefone;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.contato);

try{

final Bundle data = (Bundle) getIntent().getExtras();

int lint = data.getInt("tipo");

61

if (lint == INCLUIR){

//quando for incluir um contato criamos uma nova instância

lContatoVO = new ContatoVO();

}else{

//quando for alterar o contato carregamos a classe que veio por Bundle

lContatoVO = (ContatoVO)data.getSerializable("agenda");

}

//Criação dos objetos da Activity

txtNome = (EditText)findViewById(R.id.edtNome);

txtEndereco = (EditText)findViewById(R.id.edtEndereco);

txtTelefone = (EditText)findViewById(R.id.edtTelefone);

//Carregando os objetos com os dados do Contato

//caso seja uma inclusão ele virá carregado com os atributos text

//definido no arquivo main.xml

txtNome.setText(lContatoVO.getNome());

txtEndereco.setText(lContatoVO.getEndereco());

txtTelefone.setText(lContatoVO.getTelefone());

}catch (Exception e){


}

}

public void btnConfirmar_click(View view){

try{

//Quando confirmar a inclusão ou alteração deve-se devolver

//o registro com os dados preenchidos na tela e informar

//o RESULT_OK e em seguida finalizar a Activity

Intent data = new Intent();

lContatoVO.setNome(txtNome.getText().toString());

lContatoVO.setEndereco(txtEndereco.getText().toString());

lContatoVO.setTelefone(txtTelefone.getText().toString());

data.putExtra("agenda", lContatoVO);

setResult(Activity.RESULT_OK, data);

finish();



}

}

public void btnCancelar_click(View view){

try{

//Quando for simplesmente cancelar a operação de inclusão

//ou alteração deve-se apenas informar o RESULT_CANCELED

//e em seguida finalizar a Activity

setResult(Activity.RESULT_CANCELED);

finish();



}

}

public void toast (String msg){

Toast.makeText (getApplicationContext(), msg,

Toast.LENGTH_SHORT).show ();

}

private void trace (String msg){

toast (msg);

}

}

Classe main.java: package br.agenda.UI;


import br.agenda.DAO.ContatoAdapter;

import br.agenda.DAO.ContatoDAO;

62



import android.app.ListActivity;

import android.widget.*;

import android.view.*;

import android.content.Intent;


import android.view.ContextMenu;

import android.view.Menu;

import android.view.MenuItem;


import android.view.ContextMenu.ContextMenuInfo;

import android.widget.AdapterView;

import android.widget.ListView;


import br.agenda.contatos.R;



public class main extends ListActivity {

/** Called when the activity is first created. */

private static final int INCLUIR = 0;

private static final int ALTERAR = 1;

private ContatoDAO lContaoDAO;

//instância responsável pela persistência dos dados

List<ContatoVO> lstContatos;

//lista de contatos cadastrados no BD

ContatoAdapter adapter;

//Adapter responsável por apresentar os contatos na tela

boolean blnShort = false;

int Posicao = 0;

//determinar a posição do contato dentro da lista lstContatos

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

lContaoDAO = new ContatoDAO(this);

lContaoDAO.open();

lstContatos = lContaoDAO.Consultar();

adapter = new ContatoAdapter(this, lstContatos);

setListAdapter(adapter);

registerForContextMenu(getListView());

}

// Este evento será chamado pelo atributo onClick

// que está definido no botão criado no arquivo main.xml

public void onClick(View view) {

switch (view.getId()) {

case R.id.add:

InserirContato();

break;

}

}

//Rotina executada quando finalizar a Activity ContatoUI

@Override

protected void onActivityResult(int requestCode, int resultCode,

Intent data) {

ContatoVO lAgendaVO = null;

try{

super.onActivityResult(requestCode, resultCode, data);

if (resultCode == Activity.RESULT_OK){

//obtem dados inseridos/alterados na Activity ContatoUI

63

lAgendaVO =

(ContatoVO)data.getExtras().getSerializable("agenda");

//o valor do requestCode foi definido na função startActivityForResult

if (requestCode == INCLUIR){

//verifica se digitou algo no nome do contato

if (!lAgendaVO.getNome().equals("")) {

//necessário abrir novamente o BD pois ele foi fechado no método onPause()

lContaoDAO.open();

//insere o contato no Banco de Dados SQLite

lContaoDAO.Inserir(lAgendaVO);

//insere o contato na lista de contatos em memória

lstContatos.add(lAgendaVO);

}

}else if (requestCode == ALTERAR){

lContaoDAO.open();

//atualiza o contato no Banco de Dados SQLite

lContaoDAO.Alterar(lAgendaVO);

//atualiza o contato na lista de contatos em memória

lstContatos.set(Posicao, lAgendaVO);

}

//método responsável pela atualiza da lista de dados na tela

adapter.notifyDataSetChanged();

}

}

catch (Exception e) {


}

}

private void InserirContato(){

try{

//a variável "tipo" tem a função de definir o comportamento da Activity

//ContatoUI, agora a variável tipo está definida com o valor "0" para

//informar que será uma inclusão de Contato

Intent it = new Intent(this, ContatoUI.class);

it.putExtra("tipo", INCLUIR);

//chama a tela e inclusão

startActivityForResult(it, INCLUIR);

}

catch (Exception e) {


}

}

@Override

protected void onResume() {

//quando a Activity main receber o foco novamente abre-se novamente a

conexão

lContaoDAO.open();

super.onResume();

}

@Override

protected void onPause() {

//toda vez que o programa perde o foco fecha-se a conexão com o BD

lContaoDAO.close();

super.onPause();

}

public void toast (String msg){

Toast.makeText (getApplicationContext(), msg,

Toast.LENGTH_SHORT).show ();

}

private void trace (String msg){

64

toast (msg);

}

@Override

public void onCreateContextMenu(ContextMenu menu, View v,

ContextMenuInfo menuInfo) {

try{

//Criação do popup menu com as opções sobre os Contatos

AdapterView.AdapterContextMenuInfo info =

(AdapterView.AdapterContextMenuInfo)menuInfo;

if (!blnShort){

Posicao = info.position;

}

blnShort = false;

menu.setHeaderTitle("Selecione:");

//a origem dos dados do menu está definido no arquivo arrays.xml

String[] menuItems =

getResources().getStringArray(R.array.menu);

for (int i = 0; i<menuItems.length; i++) {

menu.add(Menu.NONE, i, i, menuItems[i]);

}



}

}

//Este método é disparado quando o usuário clicar em um item do

ContextMenu

@Override

public boolean onContextItemSelected(MenuItem item) {

ContatoVO lAgendaVO = null;

try{

int menuItemIndex = item.getItemId();

//Carregar a instância POJO com a posição selecionada na tela

lAgendaVO = (ContatoVO) getListAdapter().getItem(Posicao);

if (menuItemIndex == 0){

//Carregar a Activity ContatoUI com o registro selecionado na tela

Intent it = new Intent(this, ContatoUI.class);

it.putExtra("tipo", ALTERAR);

it.putExtra("agenda", lAgendaVO);

startActivityForResult(it, ALTERAR);

//chama a tela de alteração

}else if (menuItemIndex == 1){

//Excluir do Banco de Dados e da tela o registro selecionado

lContaoDAO.Excluir(lAgendaVO);

lstContatos.remove(lAgendaVO);

adapter.notifyDataSetChanged();

//atualiza a tela

}



}

return true;

}

@Override

protected void onListItemClick(ListView l, View v, int position, long

id){

super.onListItemClick(l, v, position, id);

//por padrão o ContextMenu, só é executado através de LongClick, mas

//nesse caso toda vez que executar um ShortClick, abriremos o menu

/e também guardaremos qual a posição do item selecionado

Posicao = position;

blnShort = true;

65

this.openContextMenu(l);

}

}

Layouts xml: contato_row.xlm: <?xml version="1.0" encoding="utf-8"?>

<LinearLayout

android:id="@+id/LinearLayout01"

android:layout_width="fill_parent"

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

android:layout_height="wrap_content"

android:orientation="vertical">

<RelativeLayout

android:id="@+id/LinearLayout02"


android:layout_width="fill_parent">

<TextView

android:id="@+id/txtNome"



android:text="Nome" >

</TextView>

<TextView



android:id="@+id/txtEndereco"

android:text="Endereço"

android:layout_below="@+id/txtNome">

</TextView>

<TextView



android:id="@+id/txtTelefone"

android:text="Telefone"

android:layout_below="@+id/txtEndereco">

</TextView>

</RelativeLayout>

</LinearLayout>

contato.xml:

<?xml version="1.0" encoding="utf-8"?>

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


android:layout_height="fill_parent"

android:orientation="vertical" >

<TextView

android:id="@+id/txtAux1"

android:layout_width="wrap_content"


android:layout_marginTop="10dip"

android:gravity="right"

android:text="Nome :"

android:width="70dip" >

</TextView>

66

<EditText

android:id="@+id/edtNome"



android:layout_marginLeft="5dip"

android:layout_toRightOf="@+id/txtAux1"

android:text="Nome Contato"


</EditText>

<TextView




android:layout_alignParentLeft="true"

android:layout_below="@+id/edtNome"

android:layout_centerVertical="@+id/txtAux2"



android:text="Endereço :"


</TextView>

<EditText

android:id="@+id/edtEndereco"



android:layout_below="@+id/edtNome"



android:text="Endereco Contato"


</EditText>

<TextView





android:layout_below="@+id/edtEndereco"

android:layout_centerVertical="@+id/txtAux2"



android:text="Telefone :"


</TextView>

<EditText

android:id="@+id/edtTelefone"



android:layout_below="@+id/edtEndereco"



android:text="Telefone Contato"


</EditText>

<LinearLayout

android:id="@+id/linearLayout1"




android:layout_below="@+id/edtTelefone"

android:layout_marginTop="31dp"

android:gravity="center_vertical" >

67

<Button

android:id="@+id/btnConfirmar"

android:layout_width="0dip"


android:layout_weight="1.0"

android:onClick="btnConfirmar_click"

android:text="Confirmar" />

<Button

android:id="@+id/btnCancelar"

android:layout_width="0dip"


android:layout_weight="1.0"

android:onClick="btnCancelar_click"

android:text="Cancelar" />

</LinearLayout>

</RelativeLayout> main.xml: <?xml version="1.0" encoding="utf-8"?>

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


android:layout_height="fill_parent"

android:orientation="vertical" >

<Button

android:id="@+id/add"


android:layout_height="62dp"

android:layout_gravity="center_horizontal"

android:onClick="onClick"

android:text="Adicionar Contato"

android:textSize="18dp" />

<TextView

android:id="@+id/textView1"



android:text="Lista de Contatos:"

android:textSize="22dp"

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

<LinearLayout

android:id="@+id/group"


android:layout_height="wrap_content" >

</LinearLayout>

<ListView

android:id="@android:id/list"



android:text="@string/hello" />

</LinearLayout>

tcc - agno silveira

Documents