AgNO 3 (aq) + NaCl(aq) AgCl(s) + NaNO 3 (aq) What happens when you put AgNO 3 and NaCl in water?
TCC - Agno Silveira
-
Upload
evandro-cesar-aguilera -
Category
Documents
-
view
149 -
download
6
Transcript of 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
facilidade de compartilhamento do que a linguagem Java. O método
convencional para programação em Scala é dado através da instalação do
(Simple Build Tool) na IDE Eclipse;
: o projeto Python for Android possibilita desenvolvedores desta
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
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
facilidade de compartilhamento do que a linguagem Java. O método
convencional para programação em Scala é dado através da instalação do
possibilita desenvolvedores desta
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
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
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 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
juntamente com a expansão de aplicativos disponibilizados no Android Market.
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
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,
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
juntamente com a expansão de aplicativos disponibilizados no Android Market.
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.content.Context;
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;
}catch (Exception e) {
trace("Erro : " + e.getMessage());
}
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 java.util.List;
import br.agenda.POJO.ContatoVO;
import android.content.ContentValues;
import android.content.Context;
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 br.agenda.POJO.ContatoVO;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
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){
trace("Erro : " + e.getMessage());
}
}
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();
}catch (Exception e) {
trace("Erro : " + e.getMessage());
}
}
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();
}catch (Exception e) {
trace("Erro : " + e.getMessage());
}
}
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 java.util.List;
import br.agenda.DAO.ContatoAdapter;
import br.agenda.DAO.ContatoDAO;
62
import br.agenda.POJO.ContatoVO;
import android.app.Activity;
import android.app.ListActivity;
import android.widget.*;
import android.view.*;
import android.content.Intent;
import android.os.Bundle;
import android.view.ContextMenu;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ContextMenu.ContextMenuInfo;
import android.widget.AdapterView;
import android.widget.ListView;
import android.widget.Toast;
import br.agenda.contatos.R;
import android.app.Activity;
import android.os.Bundle;
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) {
trace("Erro : " + e.getMessage());
}
}
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) {
trace("Erro : " + e.getMessage());
}
}
@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]);
}
}catch (Exception e) {
trace("Erro : " + e.getMessage());
}
}
//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
}
}catch (Exception e) {
trace("Erro : " + e.getMessage());
}
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_height="wrap_content"
android:layout_width="fill_parent">
<TextView
android:id="@+id/txtNome"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Nome" >
</TextView>
<TextView
android:layout_height="wrap_content"
android:layout_width="fill_parent"
android:id="@+id/txtEndereco"
android:text="Endereço"
android:layout_below="@+id/txtNome">
</TextView>
<TextView
android:layout_height="wrap_content"
android:layout_width="fill_parent"
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_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/txtAux1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="10dip"
android:gravity="right"
android:text="Nome :"
android:width="70dip" >
</TextView>
66
<EditText
android:id="@+id/edtNome"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="5dip"
android:layout_toRightOf="@+id/txtAux1"
android:text="Nome Contato"
android:width="190dip" >
</EditText>
<TextView
android:id="@+id/txtAux3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_below="@+id/edtNome"
android:layout_centerVertical="@+id/txtAux2"
android:layout_marginTop="10dip"
android:gravity="right"
android:text="Endereço :"
android:width="70dip" >
</TextView>
<EditText
android:id="@+id/edtEndereco"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/edtNome"
android:layout_marginLeft="5dip"
android:layout_toRightOf="@+id/txtAux3"
android:text="Endereco Contato"
android:width="190dip" >
</EditText>
<TextView
android:id="@+id/txtAux5"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_below="@+id/edtEndereco"
android:layout_centerVertical="@+id/txtAux2"
android:layout_marginTop="10dip"
android:gravity="right"
android:text="Telefone :"
android:width="70dip" >
</TextView>
<EditText
android:id="@+id/edtTelefone"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/edtEndereco"
android:layout_marginLeft="5dip"
android:layout_toRightOf="@+id/txtAux5"
android:text="Telefone Contato"
android:width="190dip" >
</EditText>
<LinearLayout
android:id="@+id/linearLayout1"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
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_height="wrap_content"
android:layout_weight="1.0"
android:onClick="btnConfirmar_click"
android:text="Confirmar" />
<Button
android:id="@+id/btnCancelar"
android:layout_width="0dip"
android:layout_height="wrap_content"
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_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<Button
android:id="@+id/add"
android:layout_width="wrap_content"
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:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Lista de Contatos:"
android:textSize="22dp"
android:textAppearance="?android:attr/textAppearanceLarge" />
<LinearLayout
android:id="@+id/group"
android:layout_width="wrap_content"
android:layout_height="wrap_content" >
</LinearLayout>
<ListView
android:id="@android:id/list"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello" />
</LinearLayout>
68