Você está na página 1de 39

Utilizando recursos nativos de SMS em aplicaes Android

Facebook Twitter

(8) (0)

Este artigo apresenta o desenvolvimento de uma aplicao Android completa, a qual


permite processar dados recebidos de uma mensagem SMS, persistindo-a
automaticamente em um banco de dados local SQLite, sem a interferncia do usurios.
Artigo do tipo Tutorial
Recursos especiais neste artigo:
Contedo sobre Soluo completa.
Autores: Eduardo Malherbi Martins, Ricardo Ogliari e Robison Cris Brito

Utilizando recursos nativos de SMS em aplicaes Android


Este artigo apresenta o desenvolvimento de uma aplicao Android completa, a qual permite processar dados recebidos de uma mensagem SMS,
persistindo-a automaticamente em um banco de dados local SQLite, sem a interferncia do usurios. Aps isso, o usurio do sistema pode visualizar as
mensagem recebidas no programa, assim como os detalhes da mensagem. Como se trata de um artigo introdutrio, este pode ser acompanhado
inclusive por usurios leigos na tecnologia Android, pois so apresentados todos os conceitos e passos para o desenvolvimento do programa e para a
utilizao da tecnologia.

Em que situao o tema til


Este artigo til para programadores leigos ou experientes que desejam utilizar o recurso de SMS em aplicaes Android, sendo que este
processo permite facilmente a integrao das mensagens de texto com o banco de dados da aplicao, por exemplo, permitindo que o
contedo da mensagem seja persistido e posteriormente processado.

A sociedade moderna exige que as pessoas estejam conectadas constantemente, afim de que as informaes sejam compartilhadas de forma
rpida, isso incluindo a comunicao pessoa a pessoa, empresa a pessoa ou empresa a empresa.

Essa comunicao iniciou com a necessidade das pessoas manterem contato umas com as outras sem se preocuparem com a distncia.
Contudo, devido ao constante avano tecnolgico, j no trata simplesmente do contato mantido entre dois ou mais indivduos. A
necessidade atual facilitar e baratear ao mximo esta comunicao.

Uma forma de permitir a comunicao entre pessoas com baixo custo o envio de mensagens de texto curtas, tambm conhecidas por SMS
(Short Message Service), as quais permitem a troca de informaes.

Os celulares existentes hoje no mercado permitem, alm das funcionalidades tradicionais de realizar e receber ligaes, o envio e a recepo
de SMS. Hoje a maioria das mensagens so enviadas ou recebidas por programas nativos do aparelho celular, havendo em poucos casos sua
integrao com aplicaes especficas.

Pensando nisso, este artigo apresenta o desenvolvimento de um aplicativo que, ao receber uma mensagem SMS, registra ela em um banco de
dados, permitindo que esta mensagem seja tratada por outras aplicaes, podendo estas ser desktop ou web.

Sobre a plataforma Android

O Android uma plataforma para desenvolvimento mvel completa, composta por uma linguagem de programao e um sistema
operacional, o que permite que os aplicativos desenvolvidos possam usufruir de todos os recursos nativos do sistema operacional Android.

Outra caracterstica do Android ele ser open source, sendo assim, a comunidade Android cresce a cada dia, o que justifica o constante
lanamento de novas verses do Android, assim como a constante atualizao dos ambientes de desenvolvimento.
Apesar de ser open source, o Android mantido pela Open Handset Allice (OHA), um conjunto de vrias empresas de tecnologias, lideradas
pela Google, o que reflete a seriedade do projeto.

Dentre todas as vantagens da plataforma Android, a maior est no fato do Android ter sido desenvolvido com base no sistema operacional
Linux, embora no possua alguns padres de conjuntos apresentados em algumas distribuies Linux, por isso algumas pessoas no a
consideram um sistema operacional Linux.

Arquitetura da plataforma Android

A arquitetura do sistema operacional Android dividida em camada, sendo elas o ncleo do Linux, bibliotecas, frameworks e aplicaes,
como ilustra a Figura 1.

Figura 1. Arquitetura do Android.

A camada ncleo utiliza a verso 2.6 do ncleo do Linux para os servios centrais do sistema, tais como segurana, gesto de memria,
gesto de processos, pilha de protocolos de rede e modelo de drives. O ncleo do Linux tambm atual como uma camada de abstrao entre
hardware e o resto da pilha de software.

A camada bibliotecas possui um conjunto de bibliotecas da linguagem C como as bibliotecas das reas de multimdia. Nessa mesma camada
existe a mquina virtual Dalvik, onde os aplicativos Android so executados. Essa mquina virtual possui como caracterstica uma grande
integrao com a nova gerao de hardware dos smartphones, sendo projetada para executar vrias mquinas virtuais paralelamente.
J na camada de framework encontram-se as APIs e os recursos utilizados pelos aplicativos. nesta camada que se encontram:

Activity Manager: Gerencia o ciclo de vida de todas as activities;

Package Manager: utilizada pelo activity manager para ler as informaes dos APKs (pacotes de arquivos do Android);

Window Manager: Gerencia as apresentaes de janelas;

Content Providers: Compartilhamento de dados entre os aparelhos;

View System: Disponibiliza todo o tratamento grfico para a aplicao.

Por fim, a camada de aplicativos contm todos os aplicativos nativos (escritos em Java) do Android, como o cliente de e-mail, mapas,
navegadores, calendrios, programas de SMS, gerenciador de contatos, agendas, e tambm os aplicativos Android desenvolvidos pela
comunidade.

Recebendo mensagens SMS na plataforma Android

A plataforma Android foi concebida com a inteno de permitir aos desenvolvedores criar aplicaes mveis que tirem o mximo de
proveito dos recursos que um aparelho porttil possa oferecer. O grande objetivo da plataforma deix-la aberta ao mximo, permitindo que,
por exemplo, uma aplicao possa utilizar qualquer uma das funcionalidades de ncleo do telefone, tais como efetuar chamadas, enviar
mensagens de texto ou utilizar a cmera, permitindo aos desenvolvedores adaptarem e evolurem cada vez mais essas funcionalidades.

Qualquer telefone mvel que se compra hoje tem a capacidade de enviar e receber mensagens SMS, e quase todos os usurios de qualquer
idade sabem como utilizar este recurso. Assim, SMS uma das principais aplicaes do telefone mvel, para alguns usurios to necessrios
quanto o recurso de realizar e receber ligaes.

Na plataforma Android, a aplicao de SMS j vem integrada com o sistema operacional, sendo uma aplicao nativa, permitindo enviar e
receber mensagens de texto sempre que o aparelho celular esteja conectada a rede da operadora. No entanto, em algumas situaes este
recurso pode ser integrado com as aplicaes desenvolvidas pelos programadores, permitindo inclusive a recuperao automtica de um
SMS a partir de um aplicativo desenvolvido.

Para exemplificar o uso da recepo de SMS, ser desenvolvido um aplicativo Android que recebe uma mensagem SMS e armazena-a em
uma base de dados local. Essa situao poderia ser muito interessante em um aplicativo comercial, j que as mensagens SMS recebidas pelo
aparelho celular podem ser armazenados localmente, e de tempo em tempo pode ser sincronizado com um servidor remoto, permitindo que
estas mensagens sejam processadas por um aplicativo Desktop ou Web.

Ferramentas para o desenvolvimento do aplicativo

As ferramentas e as tecnologias utilizadas para o desenvolvimento do sistema incluem:

a) Eclipse como IDE para desenvolvimento do sistema;

b) ADT (Android Development Tools) plugin que fornece recursos para criao do sistema em Android na IDE Eclipse;

c) AVD (Android Virtual Device) emulador para Android;

d) Java como linguagem de programao orientada a objetos;

e) SQLite como banco de dados no dispositivo mvel, responsvel por armazenar informaes;

f) SQLite Expert, ferramenta para administrao do banco de dados.

Na sequncia temos uma rpida explicao sobre cada ferramenta utilizada no desenvolvimento do aplicativo.

Eclipse
Eclipse uma IDE para o desenvolvimento de aplicativos para muitas plataformas, sendo uma referncia para o desenvolvimento Android. A
verso utilizada para o desenvolvimento deste projeto foi Eclipse Java EE IDE for Web Developers Indigo Service Release 2, o link para
download encontra-se na seo Links. Historicamente, o projeto Eclipse foi iniciado pela IBM em novembro de 2001 e apoiado por um
consrcio de fornecedores de software. A Eclipse Foundation foi criada em 2004 como uma corporao sem fins lucrativos e seus projetos
so open source (cdigo aberto).

A IDE Eclipse composta por vrios plug-ins, esses plug-ins so necessrios para o desenvolvimento em plataformas diferentes, como o
Android, Java, PHP, C/C++ e muito mais.

Existem muitas vantagens da IDE Eclipse em relao s outras IDEs, pois o Eclipse uma ferramenta gratuita, com uma tima performance,
fcil instalao dos plug-ins, configurvel conforme a necessidade do programador e possui uma enorme comunidade de usurios ativos
contribuindo para a IDE.

Para o desenvolvimento Android na IDE Eclipse necessria a instalao de um plugin chamado ADT.

Android SDK

Android SDK o kit de desenvolvimento utilizado pelos programadores que desejam desenvolver para a plataforma Android.

O Android SDK fornece as bibliotecas da API (Interface de Programao de Aplicativos) e ferramentas de desenvolvimento necessrias para
construir, testar e depurar aplicativos para o Android. Para realizar o download do Android SDK deve-se acessar o endereo que se encontra
na seo Links. Aps isso, deve-se realizar a instalao do SDK Tools para Windows. O processo de instalao bem simples, com alguns
Next possvel realizar a instalao sem nenhuma dificuldade. Feita a instalao, e com o Eclipse aberto, pode-se verificar as atualizao
necessrias do SDK, conforme Figura 2.

Figura 2. Android SDK Manager

A Figura 3 apresenta quais APIs que esto instaladas e quais podem ser instaladas. Por exemplo, o usurio pode querer instalar a API 15 que
possui os recursos do Android 4.0.3 e utilizar diferentes emuladores para cada API. Recomenda-se que seja instalada alguma API atravs
deste processo, pois ser necessria quando for realizada a instalao do Plugin do Eclipse.
abrir imagem em nova janela

Figura 3. Android SDK Manager (Instalao/Atualizao)

Plugin do Eclipse for Android ADT (Android Development Tools)

Android Development Tools (ADT) um plug-in para a IDE Eclipse que permite o desenvolvimento de aplicaes para a plataforma
Android. Projetado para ser um ambiente poderoso e integrado, permite tanto o desenvolvimento, execuo e depurao de aplicativos
Android. Atravs dele possvel criar novos projetos Android, adicionar pacotes com base na API, criar interfaces para usurio, depurar
aplicativos e exportar sua aplicao para utilizar ela em seu smartphone ou tablet.

O prprio portal oficial do Android (seo Links) aconselha desenvolver aplicaes Android no Eclipse com ADT. O plugin permite a
configurao do projeto guiada via wizard, ferramentas de integrao, editores XML personalizados e painel de sada de depurao.

Para a instalao do plugin, com o Eclipse aberto, acesso o menu Help - Install New Software. A janela de instalao ser aberta, nela deve-
se adicionar o caminho para download da ADT Eclipse (Vide seo Links), conforme ilustra a Figura 4.
abrir imagem em nova janela

Figura 4. Download do ADT no Eclipse

Na sequncia, devem-se confirmar as telas seguintes, seguindo o processo de instalao. Ao final, a IDE reiniciada e deve-se configurar o
SDK. O processo de configurao do SDK simples, apenas acionando o boto Next.

AVD Android Virtual Device

Android Virtual Device (AVD) um emulador para um aparelho Android. Atravs dele possvel simular um dispositivo real, definindo
opes de hardware e software. A Figura 5 apresenta o AVD do Android em execuo.
Figura 5. Emulador Android

Um AVD consiste em definir os recursos de hardware do dispositivo virtual, definir qual o dispositivo, o tipo de teclado, a memria do
dispositivo, configurar em que plataforma o aplicativo ser desenvolvido, especificar para o emulador as dimenses da tela, aparncia, e
especificar o tamanho do carto SD. Pode-se tambm criar vrios AVDs para testar em diferentes plataformas o dispositivo desenvolvido.

A criao da AVD possvel escolhendo-se no Eclipse o menu Windows Android Virtual Device Manager. A tela Android Virtual Device
Manager aberta, atravs dela pode-se criar os emuladores. Nesta tela, clica-se no boto New, informando as caractersticas do Android
Virtual Device. A Figura 6 apresenta os dados da AVD utilizada para testar o aplicativo.
Figura 6. Criao do AVD

SQLite

Banco de dados um conjunto de estruturas responsveis por armazenar informaes, geralmente mantido e acessado por um Sistema
Gerenciador de Banco de Dados (SGBD). As estruturas dos bancos de dados atuais adotam o modelo relacional onde a estrutura tem formas
de tabelas composta por linhas e colunas. J um SGBD um conjunto de programas e ferramentas que permite manipular as informaes
armazenadas no banco de dados.

Com as limitaes que existiam nos dispositivos mveis at alguns anos atrs, era difcil encontrar um banco de dados robusto para a
plataforma mvel, entretanto, isso mudou com o lanamento do Android, o qual possui suporte nativo ao banco de dados SQLite.
O SQLite uma biblioteca auto suficiente, com configurao zero, pois no possui servidor. Este banco implementa transaes serializveis
que so atmica, consistente, isolada e durvel (ACID), mesmo se a transao for interrompida por um acidente de programa, uma falha do
sistema operacional, ou uma falha de energia para o computador.

Este banco, diferentemente de outros, no tem um processo servidor separado. O processo que quer acessar o banco de dados l e escreve
diretamente a partir dos arquivos do banco de dados. A grande vantagem que no existe nenhum processo separado de servidor para
instalar ou configurar, por esse motivo SQLite configurao zero.

SQLite Expert

A ferramenta de administrao de banco de dados um software cuja finalidade manipular informaes do banco de dados. Com ela
possvel criar e acessar tabelas e suas informaes, modificando-a sem a necessidade de executar seu software. Muitos SGBDs j possuem
em sua instalao um programa de administrao de banco de dados.

SQLite Expert uma ferramenta para administrao do banco de dados SQLite. Com est ferramenta possvel criar banco de dados, reparar
banco de dados danificados, gerenciar tabelas (criar, apagar e renomear), executar comandos SQL como SELECT, INSERT, UPDATE e
DELETE, alm de suportar banco de dados criptografados. A Figura 7 ilustra a ferramenta SQLLite.

abrir imagem em nova janela

Figura 7. SQLite Expert

Apresentao do sistema proposto

O sistema que ser desenvolvido realiza a leitura dos SMSs recebidos dos clientes e insere essa mensagem na base do SQLite.

Para um melhor entendimento do sistema, foram criados prottipos das telas do aplicativo. A Figura 8 apresenta as interfaces do sistema.
Figura 8. Prottipos das telas

Note que as mensagem recebidas sero apresentadas na tela principal. Ao clicar sobre a mensagem, detalhes sobre ela so apresentados na
tela de detalhe.

Criao do projeto

Para iniciar o desenvolvimento, deve-se criar um projeto do tipo Android Application Project, atravs da opo do menu File New
Android Application Project. Na tela New Android App (Figura 9) deve-se preencher os campos, conforme segue:

a) Application Name: SMS (Nome da Aplicao)

b) Project Name: SMS (Nome do Projeto)

c) Package Name: br.com.devmedia.sms (Pacote onde ser gerado os arquivos de cdigo fonte)

O aplicativo est sendo compilado com Android 4.1 API 16 (Campo Build SDK), porm a instalao do aplicativo pode ser realizada em um
celular com SDK igual ou superior ao Android 2.2, API 8 (Campo Minimum Required SDK).
Figura 9. Nova Aplicao Android

Feito isso, sero apresentadas as telas para configurao do cone da aplicao e para a criao automtica do Activity principal, porm esta
ltima no ser utilizada na aplicao, conforme apresenta a Figura 10.
Figura 10. Criao de Activity

Aps finalizar, o projeto foi criado na IDE e o prximo passo a organizao do projeto em pacotes.

Estrutura do projeto

O sistema foi desenvolvido utilizando o padro MVC (Model View Controller), onde o modelo (model) utilizado para manipular os objetos
do sistema, como mensagens e registros do banco de dados, as views so responsveis pela interface grfica do sistema, j as classes
controladoras (controllers) so responsveis por controlar o fluxo de informaes que passa pelo sistema. na controladora que se define as
informaes que devem ser geradas, quais regras devem ser acionadas e quais regras devem ser executadas. A estrutura do projeto, este
dividido em pacotes, apresentada na Figura 11. Na imagem, as classes do projeto tambm esto presentes, porm, estas sero codificadas
posteriormente.
Figura 11. Estrutura do Projeto

As classes que realizam o acesso ao banco de dados SQLite foram colocadas no pacote services. Durante a construo do projeto verificou-
se a necessidade da criao de um pacote util. Neste pacote foram colocadas as classes responsveis pelas funes genricas do sistema,
como manipulao de SQL. O pacote adapter responsvel pela construo da listagem de itens de forma personalizada. O pacote SMS
responsvel pela classe que recebe o SMS do cliente e salva no banco de dados do aplicativo desenvolvido.

A estrutura dos xml de interfaces grficas do projeto apresentada na Figura 12, sendo dividida em XML principal, como o nome
activity_main, XML que lista os itens na tela - activity_main_list e XML que apresenta a mensagem de erro cadastrada para o usurio,
activity_oc.
Figura 12. Estrutura dos layouts do projeto

Criao de pacotes

A criao de pacotes para o projeto deve ser realizada clicando-se com o boto direito do mouse sobre o pacote src, onde sero armazenados
os cdigos fontes, escolhendo a opo New Package. Aps isso apresentada a tela New Java Package (Novo Pacote Java), onde define-se
o nome para o pacote como br.com.devmedia.service.

O processo deve se repetir para os demais pacotes do projeto:

Pacote adapter: br.com.devmedia.adapter

Pacote controller: br.com.devmedia.controller

Pacote model: br.com.devmedia.model

Pacote sms: br.com.devmedia.sms

Pacote util: br.com.devmedia.util

Pacote view: br.com.devmedia.view


A Figura 13 apresenta como ficou o projeto aps a criao de todos os pacotes.

Figura 13. Pacotes do Aplicativo

Criao de classes

A criao das classes do projeto deve ser realizada atravs da opo New Class, clicando-se com o boto direito do mouse sobre o pacote
desejado. Feito isso, apresentada a tela New Java Class. Define-se um nome para a classe (Figura 14). A classe exemplificada na figura
possui nome OC, sendo armazenado no pacote model.

Figura 14. Nova Classe Java


Este processo deve se repetir para as demais classes do projeto.

Pacote controller / Classe: OcController;

Pacote model / Classe: Cliente, Oc;

Pacote sms / Classe: DataBase, DB;

Pacote util / Classe: SQL;

Pacote adapter / Classe: MainAdapter;

A diferena na criao desta classe alterar a superclass para BaseAdapter.

A Figura 15 ilustra como ficou a criao das classes Adapters do projeto.

Figura 15. Nova Classe Java Adapter

Para a criao das classes do pacote view MainActivity e OcActivity devemos considerar as instrues apresentadas na sequncia deste
artigo.

Criao de Activities
A criao das Activities do projeto deve ser realizada clicando-se com o boto direito sobre o pacote view, escolhendo a opo New Other.
Feito isso, apresentada uma tela onde possvel selecionar o tipo de classe que se deseja criar, no caso, Activity do Android.

Na sequncia iniciado um wizard para criao da Activity. O prximo passo , na tela New Activity, definir que o tipo de activity para o
projeto ser BlankActivity (basta selecionar esta opo na tela).

Na tela seguinte so solicitadas informaes adicionais da Activity, tais como (observe Figura 16):

a) Activity Name: MainActivity (Nome da Classe Activity);

b) Layout Name: activity_main (Nome do Layout Acitvity);

c) Title: MainActivity (Titulo da Activity).

Figura 16. Novo Activity

Ao final deste passo nosso projeto j ter, alm das informaes de layout, o conjunto de activities criadas. Elas podem ser observadas no
pacote view do Eclipse (Figura 11).

O prximo passo a criao do arquivo xml de layout layout_main_list. Este arquivo ser responsvel para formatao dos elementos da
lista principal do aplicativo. Para isso, deve-se criar um XML atravs da opo do menu File New Other, sendo apresentado a tela Novo.
Atravs dela possvel pesquisar o tipo de XML que se deseja criar, neste caso, Android XML Layout File. Na tela seguinte (Figura 17)
apresentada a criao do arquivo activity_main_list.
Figura 17. Criao da classe activity_main_list

Entendendo o Android Manifest

Toda aplicao Android deve possuir o arquivo AndroidManifest.xml em seu diretrio raiz. Este arquivo possui informaes essncias sobre
o aplicativo, como:

a) Verso mnima do Android para execuo do aplicativo;

b) Declarao das permisses do aplicativo, a fim de acessar partes protegidas da plataforma;

c) Informa qual a Activity principal da aplicao;

d) Descreve os componentes da aplicao (Activities, Receiver), entre outros.

A Listagem 1 apresenta o AndroidManifest.xml j personalizado para o presente aplicativo. A maior parte deste XML gerada
automaticamente pela IDE. Somente as tags de permisso e recebimento que devem ser adicionadas, sendo estas apresentadas na listagem em
negrito. As tags receiver (linhas 28 a 35) direcionam o Android para qual classe ela deve executar quando receber uma mensagem de SMS.

Listagem 1. AndroidManifest.xml Arquivo responsvel pelas configuraes do projeto.

01. <manifest xmlns:android="http://schemas.android.com/apk/res/android"


02. package="br.com.devmedia.view"
03. android:versionCode="1"
04. android:versionName="1.0" >
05.
06. <uses-sdk
07. android:minSdkVersion="8"
08. android:targetSdkVersion="15" />
09.
10. <uses-permission android:name="android.permission.SEND_SMS" />
11. <uses-permission android:name="android.permission.RECEIVE_SMS" />
12.
13. <application
14. android:icon="@drawable/ic_launcher"
15. android:label="@string/app_name"
16. android:theme="@style/AppTheme" >
17. <activity
18. android:name=".MainActivity"
19. android:label="@string/title_activity_main" >
20. <intent-filter>
21. <action android:name="android.intent.action.MAIN" />
22.
23. <category android:name="android.intent.category.LAUNCHER" />
24. </intent-filter>
25. </activity>
26. <activity android:name=".OcActivity" />
27.
28. <receiver
29. android:name="br.com.devmedia.sms.SMSActivity"
30. android:enabled="true"
31. android:exported="true" >
32. <intent-filter>
33. <action android:name="android.provider.Telephony.SMS_RECEIVED" />
34. </intent-filter>
35. </receiver>
36. </application>
37.
38.</manifest>

Criao de Layout

Um layout no Android define a estrutura visual para uma interface com o usurio. A construo de layout no Android pode ser realizada de
duas maneiras: em tempo de projeto via arquivo XML ou em tempo de execuo utilizando cdigos Java. No projeto desenvolvido todos os
layouts foram construdos em tempo de projeto devido facilidade na criao das interfaces.

A Listagem 2 apresenta o layout da tela principal (arquivo: activity_main.xml). Para edit-lo, necessrio clicar duas vezes sobre o arquivo
xml. Na tela apresentada, temos duas opes de visualizao, a primeira Graphical Layout, onde o usurio pode definir graficamente a tela,
a segunda, o modo xml, onde o usurio codifica a interface, opo esta utilizada para o desenvolvimento deste artigo. Lembre-se que os
layouts ficam na pasta res/layout do projeto.

O layout desenvolvido na Listagem 2 est dentro de um gerenciador de layout LinearLayout (linha 01), sendo que este possui uma
orientao vertical (linha 05), ou seja, um componente ser apresentado abaixo do outro.

Listagem 2. Layout da tela principal

1 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2 xmlns:tools="http://schemas.android.com/tools"
3 android:layout_width="fill_parent"
4 android:layout_height="fill_parent"
5 android:orientation="vertical"
6 android:layout_margin="5dp">
7
8 <ImageView
9 android:id="@+id/img_devmedia"
10 android:layout_width="wrap_content"
11 android:layout_height="64dp"
12 android:src="@drawable/devmedia"
13 android:contentDescription="@string/img_devmedia" />
14
15 <ListView
16 android:id="@+id/list_main"
17 android:layout_width="match_parent"
18 android:layout_height="wrap_content" >
19
20 </ListView>
21
22 </LinearLayout>

O primeiro componente declarado foi um ImageView (linha 08), que apresentar uma imagem, esta correspondente ao logo da devmedia.
Essa imagem referenciado na linha 12, sendo adicionada nas pastas drawable do projeto. Na pasta res do projeto, existe um arquivo com o
nome de strings.xml, no qual aconselhvel colocar todas as literais que sero apresentadas na tela para o usurio. Desta forma, nos cdigos
das listagens da tela como, por exemplo, a Listagem 2 deste artigo, as propriedades que se referem a literais como, por exemplo
contentDescription, ou as propriedades text que no apresentam um texto esttico, mas sim uma referncia a uma tag dentro do arquivo
strings.xml. Desta forma, facilitado o processo de internacionalizao do aplicativo, bem como a correo de erros na grafia das literais e
padronizao dos textos.

O ambiente Android permite trabalhar com imagens, sendo o formato PNG (Portable Network Graphics) adotado como o padro para as
imagens na plataforma Android, em especial, por este formato ser multiplataforma e aceitar recursos como transparncia. Para utilizar a
imagem, pasta selecion-la e colar na pasta drawable do Android. Como existem diferentes tipos de tela (baixa resoluo, mdia resoluo,
alta resoluo e extra-alta resoluo), interessante criar cpias das imagens, uma para cada resoluo, e copiar nas pastas distintas:
drawable-ldpi, drawable-mdpi, drawable-hdpi, drawable-xhdpi, ou ainda, se preferir, usar a mesma imagem, porm, colocando-a em todas as
pastas.

Finalizando, adicionado um componente ListView (linha 15). Como esta lista ser dinmica, seu contedo definido via cdigo Java.

Na Listagem 3 apresentado o layout que complementa a tela principal. Neste layout definido como ser a apresentao dos itens da lista.

Listagem 3. Layout que complementa a tela principal do aplicativo (activity_main_list.xml)

1 <?xml version="1.0" encoding="utf-8"?>


2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 android:layout_width="match_parent"
4 android:layout_height="match_parent"
5 android:layout_margin="10dp"
6 android:orientation="horizontal" >
7
8 <TextView
9 android:id="@+id/lb_oc"
10 android:layout_width="wrap_content"
11 android:layout_height="wrap_content"
12 android:text="@string/oc"
13 android:textAppearance="?android:attr/textAppearanceMedium"
14 android:layout_margin="5dp" />
15
16 <TextView
17 android:id="@+id/txt_oc"
18 android:layout_width="wrap_content"
19 android:layout_height="wrap_content"
20 android:text="@string/clear"
21 android:textAppearance="?android:attr/textAppearanceMedium"
22 android:layout_margin="5dp" />
23
24 <TextView
25 android:id="@+id/lb_cliente"
26 android:layout_width="wrap_content"
27 android:layout_height="wrap_content"
28 android:text="@string/cliente"
29 android:textAppearance="?android:attr/textAppearanceMedium"
30 android:layout_margin="5dp" />
31
32 <TextView
33 android:id="@+id/txt_cliente"
34 android:layout_width="wrap_content"
35 android:layout_height="wrap_content"
36 android:text="@string/clear"
37 android:textAppearance="?android:attr/textAppearanceMedium"
38 android:layout_margin="5dp" />
39
40 </LinearLayout>

Na Listagem 3 so personalizados os itens da lista principal, desta forma, foi utilizado o layout linear com alinhamento horizontal (linha 6)
onde sero contidos os quatro campos apresentados para o usurios componentes TextView.

Para um TextView no ficar muito prximo do outro, foi adicionado um espaamento de 5dp como margens (linhas 14, 22, 30, 38). Outra
caracterstica alterada foi o tamanho do texto, deixando-o maior do que o padro do Android, conforme linhas 13, 24, 29, 37.

Finalizando a parte de layout apresentando o ltimo arquivo activity_oc.xml, que apresenta a mensagem de erro, recebida por SMS para o
usurio. Este apresentado na Listagem 4.

A Listagem 4 apresenta a mensagem de erro para o cliente, apresentando uma sequncia com vrios campos. A seguir ser apresentado o
formato para apresentao do primeiro campo, mas o procedimento se repete para todos os demais.

Alm da imagem apresentada na linha 07, os demais campos so divididos em grupos de duas informaes, sendo a primeira uma literal
(TextView linha 24) para rotular o campo e o segundo o campo com a informao (TextView linha 32). Estes campos esto agrupados
em um LinearLayout (linha 19), o qual possui funo de deixar os componentes alinhados de forma centralizada horizontalmente (linha 22).

Listagem 4. Layout que apresentando a mensagem de erro (activity_oc.xml).

1 <?xml version="1.0" encoding="utf-8"?>


2 <LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
3 android:layout_width="match_parent"
4 android:layout_height="match_parent"
5 android:orientation="vertical" >
6
7 <ImageView
8 android:id="@+id/img_devmedia"
9 android:layout_width="wrap_content"
10 android:layout_height="64dp"
11 android:contentDescription="@string/img_devmedia"
12 android:src="@drawable/devmedia" />
13
14 <LinearLayout
15 android:layout_width="match_parent"
16 android:layout_height="match_parent"
17 android:orientation="vertical" >
18
19 <LinearLayout
20 android:layout_width="wrap_content"
21 android:layout_height="wrap_content"
22 android:layout_gravity="center_horizontal" >
23
24 <TextView
25 android:id="@+id/lb_oc"
26 android:layout_width="wrap_content"
27 android:layout_height="wrap_content"
28 android:layout_margin="5dp"
29 android:text="@string/oc"
30 android:textAppearance="?
android:attr/textAppearanceMedium" />
31
32 <TextView
33 android:id="@+id/txt_oc"
34 android:layout_width="wrap_content"
35 android:layout_height="wrap_content"
36 android:layout_margin="5dp"
37 android:text="@string/clear"
38 android:textAppearance="?
android:attr/textAppearanceMedium" />
39 </LinearLayout>
40
41 <LinearLayout
42 android:layout_width="wrap_content"
43 android:layout_height="wrap_content"
44 android:layout_gravity="center_horizontal" >
45
46 <TextView
47 android:id="@+id/lb_cliente"
48 android:layout_width="wrap_content"
49 android:layout_height="wrap_content"
50 android:layout_margin="5dp"
51 android:text="@string/cliente"
52 android:textAppearance="?
android:attr/textAppearanceMedium" />
53
54 <TextView
55 android:id="@+id/txt_cliente"
56 android:layout_width="wrap_content"
57 android:layout_height="wrap_content"
58 android:layout_margin="5dp"
59 android:text="@string/clear"
60 android:textAppearance="?
android:attr/textAppearanceMedium" />
61 </LinearLayout>
62
63 <LinearLayout
64 android:layout_width="wrap_content"
65 android:layout_height="wrap_content"
66 android:layout_gravity="center_horizontal" >
67
68 <TextView
69 android:id="@+id/lb_celular"
70 android:layout_width="wrap_content"
71 android:layout_height="wrap_content"
72 android:layout_margin="5dp"
73 android:text="@string/celular"
74 android:textAppearance="?
android:attr/textAppearanceMedium" />
75
76 <TextView
77 android:id="@+id/txt_celular"
78 android:layout_width="wrap_content"
79 android:layout_height="wrap_content"
80 android:layout_margin="5dp"
81 android:text="@string/clear"
82 android:textAppearance="?
android:attr/textAppearanceMedium" />
83 </LinearLayout>
84
85 <LinearLayout
86 android:layout_width="wrap_content"
87 android:layout_height="match_parent"
88 android:layout_gravity="center_horizontal"
89 android:orientation="vertical" >
90
91 <TextView
92 android:id="@+id/lb_mensagem"
93 android:layout_width="wrap_content"
94 android:layout_height="wrap_content"
95 android:layout_margin="5dp"
96 android:text="@string/mensagem"
97 android:textAppearance="?
android:attr/textAppearanceMedium" />
98
99 <TextView
100 android:id="@+id/txt_mensagem"
101 android:layout_width="wrap_content"
102 android:layout_height="wrap_content"
103 android:layout_margin="5dp"
104 android:text="@string/clear"
105 android:textAppearance="?
android:attr/textAppearanceMedium" />
106 </LinearLayout>
107 </LinearLayout>
108
109 </LinearLayout>

Outra maneira que o usurio possui de desenvolver interfaces grficas, sem a utilizao do arquivo XML, a partir do clicar e arrastar de
componentes na tela. Para isso, so apresentados os componentes disponveis na barra de ferramentas Palette, no modo Graphical Layout,
apresentado na Figura 18.

Figura 18. Layout tela principal

Codificao das Activities

No Android, toda classe codificada na camada de viso (view) um Activity que processar os dados gerados por uma interface visual
(arquivo xml da pasta layout). Desta forma, para o Activity se comportar como tal, necessrio fazer um extend da classe pai Activity. As
classes filhas de Activity so responsveis pela comunicao com os componentes visuais da tela. A Figura 19 apresenta o ciclo de vida de
um Activity.
abrir imagem em nova janela

Figura 19. Ciclo de vida de um activity.

De todos os mtodos apresentados na Figura 19, o mtodo onCreate() foi utilizado em todas as Activities do projeto. Esse mtodo
chamado quando uma Activity executada pela primeira vez.

Ao criar um Activity deve-se sobrescrever o mtodo onCreate. Esse mtodo responsvel por criar a interface usurio (view). Na
Listagem 5 apresentado o cdigo da classe MainActivity, responsvel por tratar a listagem inicial com as mensagens do programa.

As primeiras linhas da Listagem 5 (linhas 2 a 13) apresentam os imports correspondentes s classes utilizadas no Activity. Como esta classe
trata uma interface grfica com uma lista, foi implementada a interface OnItemClickListener na declarao da classe (linha 15) para o
tratamento de seleo de elementos.
Em seguida, so declarados os componentes ListView linha 16 - (tela principal), bem como MainAdapter linha 18, esta ltima uma classe
responsvel por formatar os elementos da lista principal.

No mtodo onCreate (linha 22) iniciado o Activity (linha 23) e apresentada na tela a interface definida no layout activity_main (linha 24).

A linha 26 recupera todos os registros armazenados localmente no banco de dados SQLite, e a linha 27 cria a formatao destes dados, que
ser apresentada na tela. Por fim, feita a chamada do mtodo createView linha 29, este codificado das linhas 32 a 37.

Listagem 5. Criao do cdigo Java para a janela principal (MainActivity.java).

1 package br.com.devmedia.view;
2 import java.util.ArrayList;
3 import android.app.Activity;
4 import android.content.Intent;
5 import android.graphics.Color;
6 import android.os.Bundle;
7 import android.view.View;
8 import android.widget.AdapterView;
9 import android.widget.AdapterView.OnItemClickListener;
10 import android.widget.ListView;
11 import br.com.devmedia.adapter.MainAdapter;
12 import br.com.devmedia.model.Oc;
13 import br.com.devmedia.service.DB;
14
15 public class MainActivity extends Activity
implements OnItemClickListener {
16 private ListView list_main;
17
18 private MainAdapter listAdapter;
19 private ArrayList<Oc> listOC;
20
21 @Override
22 public void onCreate(Bundle savedInstanceState) {
23 super.onCreate(savedInstanceState);
24 setContentView(R.layout.activity_main);
25
26 listOC = DB.getInstance( this ).getAll();
27 listAdapter = new MainAdapter( this, listOC );
28
29 this.createView();
30 }
31
32 private void createView() {
33 list_main = ( ListView ) findViewById
( R.id.list_main );
34 list_main.setOnItemClickListener( this );
35 list_main.setAdapter(listAdapter);
36 list_main.setCacheColorHint(Color.TRANSPARENT);
37 }
38 public void onItemClick(AdapterView<?>
parent, View view, int position, long id)
{
39 Oc oc = (Oc) listAdapter.getItem( position );
40 this.onEdit( oc );
41 }
42
43 public void onEdit(Oc oc) {
44 Intent i = new Intent( MainActivity.this,
OcActivity.class );
45 i.putExtra("oc", oc);
46 startActivity( i );
47 }
48 }

O mtodo onCreate possui a funo de recuperar o componente ListView da tela (linha 33), definindo o tratamento de evento para esta lista
(linha 34), bem como definindo o local onde se encontram os registros (linha 35).
O mtodo responsvel pelo tratamento de cliques sobre a lista o onItemClick (linha 38), o qual recupera o item selecionado (linha 39) e
executa o mtodo onEdit (linha 30), responsvel pela apresentao de uma tela de detalhes sobre a mensagem selecionada.

O mtodo onEdit (linhas 43 a 48) cria uma inteno de chamada a nova tela, sendo esta a OcActivity (linha 44), adicionando informaes
sobre o registro selecionado (linha 45) a qual ser apresentada nesta nova tela, iniciando na sequncia a tela (linha 46).

A codificao do Activity que trata a tela de detalhes apresentada na Listagem 6. A Listagem 6 apresenta a codificao da classe
OcActivity. Da mesma forma que a Activity apresentada anteriormente, tem os import, a declarao da classe OcActivity e a declarao
dos componentes das linhas 11 a 16.

No mtodo onCreate existe a declarao da classe OcController, responsvel por controlar o fluxo de informaes existentes dentro do
sistema (linha 23), assim como os mtodos onCreateView e onEdit (linhas 25 e 26).

O mtodo onCreateView define os componentes visuais da tela, assim como realizada na Activity anterior, e o mtodo onEdit (linhas 36 a
48) tem a funo de recuperar os dados do registro selecionado da tela principal, passando esta informao por parmetro no mtodo onEdit
do controller (linha 44).

Listagem 6. Activity que apresenta detalhes da mensagem (OcActivity.java).

1 package br.com.devmedia.view;
2
3 import android.app.Activity;
4 import android.content.Intent;
5 import android.os.Bundle;
6 import android.widget.TextView;
7 import br.com.devmedia.controller.OcController;
8 import br.com.devmedia.model.Oc;
9
10 public class OcActivity extends Activity {
11 private OcController controller;
12 private Intent i;
13 public TextView txt_oc;
14 public TextView txt_cliente;
15 public TextView txt_celular;
16 public TextView txt_mensagem;
17
18 @Override
19 public void onCreate(Bundle savedInstanceState) {
20 super.onCreate(savedInstanceState);
21 setContentView(R.layout.activity_oc);
22
23 controller = new OcController( this );
24
25 this.createView();
26 this.onEdit();
27 }
28
29 private void createView() {
30 this.txt_oc = ( TextView )
findViewById( R.id.txt_oc );
31 this.txt_cliente = ( TextView )
findViewById( R.id.txt_cliente );
32 this.txt_celular = ( TextView )
findViewById( R.id.txt_celular );
33 this.txt_mensagem = ( TextView )
findViewById( R.id.txt_mensagem );
34 }
35
36 private void onEdit() {
37 i = getIntent();
38 if ( i != null )
39 {
40 Bundle b = i.getExtras();
41
42 if ( b != null )
43 {
44 controller.onEdit( (Oc)
b.getSerializable("oc") );
45 }
46 }
47 }
48 }

Criao das Controladoras

A controladora (controller) responsvel por controlar o fluxo de informaes que passa pelo sistema. na controladora que se define as
informaes que devem ser geradas, quais regras devem ser acionadas e quais regras devem ser executadas.

A controladora recebe a entrada de dados e inicia a resposta ao utilizador, invocando objetos do modelo. Por fim, uma resposta gerada e
enviada para camada de viso, apresentando uma resposta ao usurio.

A Listagem 7 apresenta a codificao da classe OcController. Na classe codificada temos a varivel view OcActivity, representando a
camada de viso (Linha 7). O mtodo construtor (Linha 8) recebendo a view OcActivity (Linha 9). O mtodo onEdit tem a funo de
valorizar os componentes da tela Oc, com o contedo vindo da tela principal (Linhas 12 a 15).

Listagem 7. Codificao da classe controladora (OcController.java).

1 package br.com.devmedia.controller;
2
3 import br.com.devmedia.model.Oc;
4 import br.com.devmedia.view.OcActivity;
5
6 public class OcController {
7 private OcActivity view;
8 public OcController(OcActivity view) {
9 this.view = view;
10 }
11 public void onEdit(Oc oc) {
12 view.txt_oc.setText( Integer.toString(oc.getCodigo()) );
13 view.txt_cliente.setText( oc.cliente.getNome() );
14 view.txt_celular.setText( oc.cliente.getCelular() );
15 view.txt_mensagem.setText( oc.getMensagem() );
16 }
17 }

Criao dos modelos (Objetos)

O modelo (model) utilizado para manipular os objetos do sistema. Um objeto alguma coisa que faz sentido no contexto de uma aplicao.
Os objetos facilitam a compreenso do mundo real e oferecem uma base real para a implementao em computador.

Todos os objetos tm uma identidade e sos distinguveis em relao a outros. Por exemplo, dois objetos carros com a mesma motorizao,
cor e modelo. De modo anlogo, gmeos idnticos, porm so dois objetos distintos significando que cada objeto tem sua prpria identidade,
sua prpria existncia.

Um objeto pode ser entendido como sendo um conceito, uma abstrao, algo com limites ntidos e significado em relao ao problema em
questo. Um objeto tambm pode ser definido como uma instncia de uma classe. Ele capaz de armazenar seu estado atravs de seus
atributos e reagir a mensagens enviadas a ele, assim como se relacionar e enviar mensagens a outros objetos.

A Listagem 8 apresenta a codificao dos objetos do sistema desenvolvido. Na listagem apresentada a classe Oc possui todos os atributos
existentes na tabela Oc do banco de dados, possuindo um mtodo construtor (linhas 10 a 14) que inicializa os campos, e os mtodos getters e
setters para cada um dos atributos da classe.

Listagem 8. Classe que mapeia os atributos da tela de mensagens (Oc.java).

1 package br.com.devmedia.model;
2
3 import java.io.Serializable;
4
5 public class Oc implements Serializable {
6 private static final long serialVersionUID = 1L;
7 public int codigo;
8 public Cliente cliente;
9 public String mensagem;
10 public Oc() {
11 this.codigo = 0;
12 this.cliente = new Cliente();
13 this.mensagem = "";
14 }
15 public int getCodigo() {
16 return codigo;
17 }
18 public void setCodigo(int codigo) {
19 this.codigo = codigo;
20 }
21 public Cliente getCliente() {
22 return cliente;
23 }
24 public void setCliente(Cliente cliente) {
25 this.cliente = cliente;
26 }
27 public String getMensagem() {
28 return mensagem;
29 }
30 public void setMensagem(String mensagem) {
31 this.mensagem = mensagem;
32 }
33 }

Na Listagem 9 apresentado o cdigo da classe cliente. A classe cliente possui atributos como cdigo do cliente (Linha 8), nome do cliente
(Linha 9) e celular (Linha 10). Possui tambm um mtodo construtor (Linhas 12 a 14) que inicializa os campos, e os mtodos getters e setters
para cada um dos atributos da classe.

Listagem 9. Classe que mapeia os atributos da tela de cliente (Cliente.java).

1 package br.com.devmedia.model;
2
3 import java.io.Serializable;
4
5 public class Cliente implements Serializable {
6
7 private static final long serialVersionUID = 1L;
8 private int codigo;
9 private String nome;
10 private String celular;
11 public Cliente() {
12 this.codigo = 0;
13 this.nome = "";
14 this.celular = "";
15 }
16 public int getCodigo() {
17 return codigo;
18 }
19 public void setCodigo(int codigo) {
20 this.codigo = codigo;
21 }
22 public String getNome() {
23 return nome;
24 }
25 public void setNome(String nome) {
26 this.nome = nome;
27 }
28 public String getCelular() {
29 return celular;
30 }
31 public void setCelular(String celular) {
32 this.celular = celular;
33 }
34 }

Criao de Adaptadores

Um objeto adaptador funciona como uma ponte entre um AdapterView e os dados que sero apresentados na interface visual.

Para personalizar o componente ListView da classe principal, foi criado um Adapter, juntamente com um XML referente ao item. A
Listagem 10 apresenta a codificao da classe Adapter do sistema.

A classe Adapter do aplicativo desenvolvido tem como pai (extends) um BaseAdapter (linha 14). O pai desta classe possui todos os
recursos de implementao comum para um adaptador, estes muito comuns nas aplicaes Android.

Uma subclasse de BaseAdapter deve codificar alguns mtodos, entre eles o getCount (linha 30), o qual retorna a quantidade de elementos de
uma lista. O mtodo getItemId (linha 34) retorna o ndice do elemento selecionado.

J o mtodo addItem (linha 38) responsvel por adicionar um item na lista, sendo este replicado na linha 41, onde recebe por parmetro o
objeto Oc, que representa um registro. Aps isso disparado o mtodo notifyDataSetChanged, este mtodo atualiza a lista apresentada para o
usurio.

O mtodo setItem (linha 53) responsvel por modificar um item na lista, e o mtodo mtodo getView (linha 53) um dos mais importantes
do Adapter, nele montada a lista que ser apresentado para o usurio.

Listagem 10. Adapter para personalizaoo da lista apresentada para o usurio (MainAdapter.java).

1 package br.com.devmedia.adapter;
2
3 import java.util.ArrayList;
4
5 import android.content.Context;
6 import android.view.LayoutInflater;
7 import android.view.View;
8 import android.view.ViewGroup;
9 import android.widget.BaseAdapter;
10 import android.widget.TextView;
11 import br.com.devmedia.model.Oc;
12 import br.com.devmedia.view.R;
13
14 public class MainAdapter extends BaseAdapter {
15
16 private LayoutInflater mInflater;
17
18 private Oc oc;
19 public ArrayList<Oc> listOC;
20
21 private TextView txt_oc;
22 private TextView txt_cliente;
23
24 public MainAdapter(Context context, ArrayList<Oc> listOC) {
25 this.listOC = listOC;
26
27 mInflater = LayoutInflater.from(context);
28 }
29
30 public int getCount() {
31 return listOC.size();
32 }
33
34 public long getItemId(int position) {
35 return position;
36 }
37
38 public Object getItem(int position) {
39 return listOC.get( position );
40 }
41 public void addItem(Oc oc) {
42 listOC.add( oc );
43
44 this.notifyDataSetChanged();
45 }
46
47 public void setItem(int position, Oc oc) {
48 listOC.set(position, oc);
49
50 this.notifyDataSetChanged();
51 }
52
53 public View getView(int position, View view, ViewGroup parent) {
54 oc = listOC.get( position );
55
56 view = mInflater.inflate(R.layout.activity_main_list, null);
57
58 txt_oc = ( TextView ) view.findViewById
( R.id.txt_oc );
59 txt_cliente = ( TextView ) view.findViewById
( R.id.txt_cliente );
60 txt_oc.setText( Integer.toString( oc.getCodigo() ) );
61 txt_cliente.setText( oc.cliente.getNome() );
62
63 return view;
64 }
65 }

Criao da Classe SQL Pacote Util

O pacote til muito utilizado pelos programadores para criao de classes genricas, onde mtodos genricos muitos utilizados devem ser
criados. Por exemplo, converter uma data do formato Ingls para o Portugus.

Este pacote contm a classe SQL responsvel pela criao das tabelas do banco de dados SQLite, assim como sentenas SQL executadas
pela classe DataBase. A Listagem 11 apresenta a codificao da classe SQL.

Nesta listagem definimos inicialmente na linha 4 a verso do banco de dados (Linha 4). Em seguida, temos a definio do nome do banco de
dados (linha 5), e o nome das tabelas do banco de dados (linhas 11 e 29).

Tambm so apresentados comandos de criao de tabelas (linhas 12 e 30) e consultas de registros (linhas 19 e 36).

Listagem 11. Classe com os comandos SQL utilizados no projeto (SQL.java)

1 package br.com.devmedia.util;
2
3 public class SQL {
4 public static final int DBVERSION = 1;
5 public static String DBNAME = "SMS";
6
7 // ********************************* //
8 // ** OC ** //
9 // ********************************* //
10
11 public static String TABLE_OC = "OC";
12 public static String CREATE_OC =
13 "CREATE TABLE IF NOT EXISTS OC (" +
14 " ID_OC INTEGER PRIMARY KEY," +
15 " MENSAGEM VARCHAR(255)," +
16 " ID_CLIENTE INTEGER, " +
17 " FOREIGN KEY(ID_CLIENTE)
REFERENCES CLIENTE(ID_CLIENTE)" +
18 ");";
19 public static String GET_OC_ALL =
20 " SELECT ID_OC, MENSAGEM,
b CLIENTE.ID_CLIENTE, NOME, CELULAR " +
21 " FROM OC " +
22 " INNER JOIN CLIENTE " +
23 " ON OC.ID_CLIENTE = CLIENTE.ID_CLIENTE ";
24
25 // ********************************* //
26 // ** CLIENTE ** //
27 // ********************************* //
28
29 public static String TABLE_CLIENTE = "CLIENTE";
30 public static String CREATE_CLIENTE =
31 " CREATE TABLE IF NOT EXISTS CLIENTE (" +
32 " ID_CLIENTE INTEGER PRIMARY KEY," +
33 " NOME VARCHAR(150), " +
34 " CELULAR VARCHAR(010)" +
35 " );";
36 public static String GET_CLIENTE =
37 " SELECT ID_CLIENTE, NOME, CELULAR " +
38 " FROM CLIENTE " +
39 " WHERE CELULAR = ? ";
40
41 }

Criao dos Servios

O pacote Servios utilizado para criao das classes responsveis pela comunicao com o banco de dados SQLLite. A Listagem 12
apresenta o cdigo da classe BD, aonde declarado uma varivel instance (linha 7), que a instncia da classe DataBase e um mtodo
getInstance (linha 8).

Ao ser acionado o mtodo getInstance (linha 8), se a varivel instance for igual a nula (linha 10) criada a classe DataBase (linha 12) e
retornada para o mtodo que chamou (linha 14), caso contrario, a instncia j foi criada, somente retornada a classe ao mtodo chamador
(linha 14).

Perceba que estamos utilizando o padro Singleton nesta codificao. Esse padro garante a existncia de apenas uma instncia de uma
classe, em outras palavras, permite uma nica instncia da conexo com o banco de dados em todo o aplicativo, mantendo um ponto global
de acesso ao seu objeto.

Listagem 12. Singleton para conexo com o banco de dados SQLite (DB.java)

1 package br.com.devmedia.service;
2
3 import android.content.Context;
4
5 public class DB {
6
7 private static DataBase instance;
8 public static DataBase
getInstance(Context context)
9 {
10 if ( instance == null )
11 {
12 instance = new
DataBase(context);
13 }
14 return instance;
15 }
16 }

A classe Database realiza a comunicao com o banco de dados SQLite e foi codificada na Listagem 13. A classe DataBase tem como pai a
classe SQLiteOpenHelper, a qual possui mtodos que devem ser sobrescritos, como: onCreate, onUpgrade.
O mtodo onCreate() linha 26 responsvel pela criao das tabelas do banco de dados, caso no exista. Neste mtodo tambm foram
inserido alguns clientes e objetos fictcios. O mtodo onUpgrade() linha 60 utilizado para atualizar o banco de dados, neste projeto no
foi necessrio utilizar esse mtodo.

Tambm foi necessria a criao de uma varivel bd do tipo SQLiteDatabase. Esta varivel possui mtodos para realizar a comunicao com
o banco de dados SQLite.

O mtodo insert() linha 62 responsvel por inserir um objeto no banco de dados SQLite. Este mtodo recebe como parmetro o nome
da tabela e o objeto que ser inserido na tabela solicitada. A funo chamada pela varivel bd insert (Linha 65), recebendo como parmetro
a tabela e o objeto e retornando o nmero do registro inserido.

O mtodo getAll linhas 70 a 104 busca no banco de dados todas as ocorrncias registradas, e retorna para a funo chamadora uma lista
de ocorrncias. Dentro deste mtodo so valorizados os objetos Oc. Os objetos Oc possuem informaes como mensagem do cliente e
informaes do cliente, como cdigo, nome e telefone.

O mtodo getCliente linhas 105 a 131 busca no banco de dados informaes especficas de um determinado cliente atravs do nmero do
seu telefone.

Listagem 13. Classe responsvel pelas operaes do banco de dados (DataBase.java)

1 package br.com.devmedia.service;
2
3 import java.util.ArrayList;
4
5 importandroid.content.ContentValue;
6 import android.content.Context;
7 import android.database.Cursor;
8 import android.database.sqlite.SQLiteDatabase;
9 import android.database.sqlite.SQLiteOpenHelper;
10 import android.widget.Toast;
11 import br.com.devmedia.model.Cliente;
12 import br.com.devmedia.model.Oc;
13 import br.com.devmedia.util.SQL;
14
15 public class DataBase extends SQLiteOpenHelper {
16
17 private SQLiteDatabase bd;
18 private Context context;
19
20 public DataBase(Context context) {
21 super(context, SQL.DBNAME, null, SQL.DBVERSION);
22 this.context = context;
23 }
24
25 @Override
26 public void onCreate(SQLiteDatabase db) {
27 // ** Criao das Tabelas
28 db.execSQL(SQL.CREATE_OC);
29 db.execSQL(SQL.CREATE_CLIENTE);
30 Toast.makeText( context , "Criao das Tabelas Oc e Cliente!",
Toast.LENGTH_LONG ).show();
31 // ** Criao dos Clientes
32 ContentValues obj = new ContentValues();
33 obj.put( "NOME", "JUCA BALA" );
34 obj.put( "CELULAR", "4199991234" );
35 db.insert(SQL.TABLE_CLIENTE, null, obj);
36
37 obj.put( "NOME", "MARCOS" );
38 obj.put( "CELULAR", "4199995511" );
39 db.insert(SQL.TABLE_CLIENTE, null, obj);
40
41 obj.put( "NOME", "RICARDO" );
42 obj.put( "CELULAR", "4198895522" );
43 db.insert(SQL.TABLE_CLIENTE, null, obj);
44 Toast.makeText( context , "Criao dos Clientes!",
Toast.LENGTH_LONG ).show();
45
46 // ** Criao das Mensagens
47 obj = new ContentValues();
48 obj.put( "MENSAGEM", "Erro ao Salvar o Cliente!" );
49 obj.put( "ID_CLIENTE", "1" );
50 db.insert(SQL.TABLE_OC, null, obj);
51
52 obj = new ContentValues();
53 obj.put( "MENSAGEM", "Erro ao Salvar a Fatura!" );
54 obj.put( "ID_CLIENTE", "2" );
55 db.insert(SQL.TABLE_OC, null, obj);
56 Toast.makeText( context , "Criao das OCs!", Toast.LENGTH_LONG ).show();
57 }
58
59 @Override
60 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { }
61
62 public long insert(String table, ContentValues values) {
63 bd = this.getWritableDatabase();
64
65 long row = bd.insert(table, null, values);
66 bd.close();
67
68 return row;
69 }
70
71 public ArrayList<Oc> getAll() {
72 ArrayList<Oc> result = new ArrayList<Oc>();
73
74 bd = this.getReadableDatabase();
75 Cursor cursor = bd.rawQuery( SQL.GET_OC_ALL, null );
76
77 cursor.moveToFirst();
78 while( !cursor.isAfterLast() )
79 {
80 Oc oc = new Oc();
81
82 try
83 {
84 oc.setCodigo( cursor.getInt(0) );
85 oc.setMensagem( cursor.getString(1) );
86 oc.cliente.setCodigo( cursor.getInt(2) );
87 oc.cliente.setNome( cursor.getString(3) );
88 oc.cliente.setCelular( cursor.getString(4) );
89 }
90 catch (Exception e)
91 {
92 System.out.println( e.getMessage() );
93 }
94 finally
95 {
96 result.add( oc );
97 }
98
99 cursor.moveToNext();
100 }
101 cursor.close();
102
103 return result;
104 }
105 public Cliente getCliente(String telefone) {
106 Cliente cliente = null;
107 bd = this.getReadableDatabase();
108
109 Cursor cursor = bd.rawQuery( SQL.GET_CLIENTE,
new String[] { telefone } );
110 cursor.moveToFirst();
111 while( !cursor.isAfterLast() )
112 {
113 cliente = new Cliente();
114
115 try
116 {
117 cliente.setCodigo( cursor.getInt(0) );
118 cliente.setNome( cursor.getString(1) );
119 cliente.setCelular( cursor.getString(2) );
120 }
121 catch (Exception e)
122 {
123 System.out.println( e.getMessage() );
124 }
125
126 cursor.moveToNext();
127 }
128 cursor.close();
129
130 return cliente;
131 }
132 }

SMS Receiving

Uma das grandes vantagens da tecnologia Android permitir o acesso a funcionalidades nativas da plataforma, tais como Enviar e Receber
SMS, GPS, Bluetooth, entre outras. Para acessar essas funcionalidades, devem ser declaradas tags de permisso no arquivo
AndroidManifest.xml do projeto. A Listagem 1, apresentada anteriormente, possui a declarao das permisses de envio e recebimento de
SMS.

Para efetuar a leitura do SMS foi criada uma classe com o nome SMSActivity. Esta apresentada na Listagem 14. Esta classe tem como
pai um BroadcastReceiver, responsvel por tratar mensagens SMS recebidas pelo Smartphone.

O mtodo onReceive o mtodo responsvel por tratar as mensagens SMS recebidas. A funo getBundle (linhas 32 43 a 46)
responsvel por verificar se existe algum SMS passado para o mtodo onReceive.

Aps isso criado o SMS e depois formatado o SMS, atravs das funes createSMS (linha 34), formatSMS (linha 35). O mtodo
createSMS (linha 47 a 50) recebe o objeto do intent e cria um objeto array do tipo SmsMessage.

O mtodo formatSMS (linha 51 a 60) atravs de um for percorre o array SmsMessage e atravs de funes contidas neste tipo de array
possvel pegar o nmero de telefone, chamando a funo getOriginatingAddress (linha 56) e a mensagem getMessageBody (linha 57). Aps
isso chamado o mtodo para salvar o SMS no banco SQLite.

O mtodo saveOC (Linha 58 62 a 74) cria um objeto do tipo Oc, e formata o objeto passando a mensagem recebida do SMS e o cliente.
Para saber qual o cliente, foi criado um mtodo na classe Database que recebe como parmetro o nmero de telefone do cliente e retorna
todas as informaes do cliente, como cdigo, nome e telefone. Em seguida criado um objeto do tipo ContentValues (linha 69). Este objeto
formatado e chamada a funo onInsert da classe DataBase. Por fim, temos o mtodo onInsert que realiza a insero no banco de dados
SQLite do registro passado como parmetro.

Listagem 14. Classe responsvel pelo recebimento das mensagens SMS (SMSActivity.java).

1 package br.com.devmedia.sms;
2
3 import android.content.BroadcastReceiver;
4 import android.content.ContentValues;
5 import android.content.Context;
6 import android.content.Intent;
7 import android.os.Bundle;
8 import android.telephony.SmsMessage;
9 import br.com.devmedia.model.Oc;
10 import br.com.devmedia.service.DB;
11 import br.com.devmedia.util.SQL;
12
13 public class SMSActivity extends BroadcastReceiver {
14
15 private Oc oc;
16
17 private Context context;
18 private Intent intent;
19 private Bundle b;
20 private Object[] pdus;
21 private SmsMessage[] msgs;
22 private String telefone;
23 private String mensagem;
24
25 @Override
26 public void onReceive(Context context, Intent intent) {
27 try
28 {
29 this.context = context;
30 this.intent = intent;
31
32 if ( this.getBundle() )
33 {
34 this.createSMS();
35 this.formatSMS();
36 }
37 }
38 catch (Exception e)
39 {
40 System.out.println( e.getMessage() );
41 }
42 }
43 private boolean getBundle() {
44 b = intent.getExtras();
45 return ( b != null ) ? true : false;
46 }
47 private void createSMS() {
48 pdus = ( Object[] ) b.get("pdus");
49 msgs = new SmsMessage[pdus.length];
50 }
51 private void formatSMS() {
52 for ( int i=0; i<msgs.length; i++ )
53 {
54 msgs[i] = SmsMessage.createFromPdu( (byte[]) pdus[i] );
55
56 telefone = msgs[i].getOriginatingAddress();
57 mensagem = msgs[i].getMessageBody().toString();
58 this.saveOC();
59 }
60 }
61
62 private void saveOC()
63 {
64 oc = new Oc();
65 oc.mensagem = this.mensagem;
66 oc.cliente = DB.getInstance( context ).
getCliente( this.telefone );
67 if ( oc.cliente != null )
68 {
69 ContentValues obj = new ContentValues();
70 obj.put( "MENSAGEM", oc.mensagem );
71 obj.put( "ID_CLIENTE", oc.cliente.getCodigo() );
72 this.onInsert( context, obj );
73 }
74 }
75
76 private void onInsert(Context context, ContentValues obj) {
77 DB.getInstance( context ).insert( SQL.TABLE_OC, obj );
78 }
79 }
Simulao da APP Desenvolvida

Como no possvel testar de forma real a aplicao no emulador, uma vez que os computadores no costumam receber mensagens SMS, foi
necessrio simular tal recurso. Para simular o sistema, deve-se clicar com o boto direito sobre o projeto, escolhendo a opo run.

Para simular o envio de mensagens no emulador, deve-se adicionar a perspectiva DDMS - Atravs do menu Window Open Perspective.

O DDMS (Dalvik Debug Monitor Server) uma ferramenta de depurao que fornece servios de encaminhamento de porta, captura de tela
do dispositivo, linha e informaes de pilha no dispositivo, chamada, SMS e muito mais.

Depois de adicionada a perspectiva DDMS, com a aba Emulador Control aberta, atravs da opo Telephony Actions, pode-se inserir o
nmero de telefone que enviar o SMS e o texto da mensagem. A Figura 20 apresenta a aba Emulador Control.

abrir imagem em nova janela

Figura 20. Emulador Control

A Figura 20 apresenta a mensagem enviada para o aplicativo desenvolvido com o contedo Erro na leitura do cdigo de barras dos
produtos. Por sua vez, a Figura 21 apresenta as mensagens recebidas pelo emulador.
Figura 21. SMS recebidos no emulador

A seguir apresentada a tela principal do aplicativo desenvolvido (Figura 22), juntamente com as mensagens recebidas e j cadastradas no
aplicativo.
Figura 22. Tela principal

Por fim, a Figura 23 apresenta a mensagem de erro recebida por SMS do cliente e j cadastrada no sistema desenvolvido.
Figura 23. Mensagem de erro recebida por SMS

Concluso

O desenvolvimento de aplicativos mveis para a plataforma Android vem crescendo de forma acelerada. Um das grandes vantagens da
tecnologia permitir acesso a funcionalidades nativas da plataforma, tais como, Send and Receiving SMS, GPS e Bluetooth.

Neste contexto, desenvolveu-se um aplicativo em Android que utilizou os recursos da API da plataforma Android de recebimento de SMS do
celular, no qual o cliente poder enviar um SMS que automaticamente cadastrado no banco SQLite. Isso poderia ser alterado para um
servidor, por exemplo, podendo ser utilizado para resolver problemas do dia a dia de uma empresa.

O aplicativo desenvolvido foi instalado em um celular Android, onde foram realizados vrios testes e o aplicativo se comportou como
esperado.

Links

Portal do Android
http://developer.android.com/

Download do Eclipse
http://www.eclipse.org/downloads/.

Android SDK
http://developer.android.com/sdk/index.html

ADT Elipse
https://dl-ssl.google.com/android/eclipse/

Você também pode gostar