Artigos Java Consumindo WebServices em aplicações Android

Primeiramente vamos entender o que é um WS. Bem, web service é uma solução utilizada na integração de sistemas e na comunicação entre aplicações diferentes. Com esta tecnologia é possível que novas aplicações possam interagir com aquelas que já existem e que sistemas desenvolvidos em plataformas diferentes sejam compatíveis. No nosso caso, iremos fazer a integração do Android com uma plataforma Web, nós iremos consumir um web service que nos retornará tipo do logradouro, logradouro, bairro, cidade, estado e complemento, do CEP que for solicitado. O caminho do WebService que iremos utilizar é o http://www.maniezo.com.br/webservice/soap-server.php.

Bom pessoal, o KSOAP é um excelente framework para se acessar um web service, essa é uma ferramenta bastante utilizada entre os desenvolvedores Java ME e é ela que será utilizada no nosso projeto Android, através da sua versão Java SE.

O KSOAP poderá ser facilmente encontrado para download no site da sourceforge.

Para começarmos, crie no Eclipse um novo projeto Android. Como estamos utilizando uma biblioteca de terceiros, teremos que adicioná-la ao Build Path do nosso projeto. Para fazer isso, crie uma pasta com o nome libs na raiz do projeto e em seguida coloque o arquivo ksoap2-j2se-full-2.1.2.jar ou versão superior dentro dela, para adicionar o KSOAP ao nosso projeto, basta clicar com o botão direito sobre o arquivo da biblioteca e selecionar Build Path > Add to Build Path. Em seguida, clique com o botão direito sobre o projeto e selecione Build Path > Configure Build Path. Na janela que for exibida, na aba Order and Export, marque a biblioteca ksoap2-j2se-full-2.1.2.jar (se essa for a versão do KSOAP utilizada por vocês). Feito isso o package do projeto deve ficar parecido com o da Figura 1.

Package do Projeto
Figura 1. Package do Projeto

Agora teremos que incluir no nosso AndroidManifest.xml uma permissão de internet android.permission.INTERNET, já que iremos fazer uma requisição Web, ou seja, iremos utilizar um serviço Web. Essa permissão será adicionada ao nosso projeto através da uses-permission, assim como mostra a Listagem 1.


<uses-permission android:name="android.permission.INTERNET"/>
Listagem 1. Trecho de código responsável pela permissão de acesso a internet no AndroidManifest.xml

Então, na nossa Activity mostraremos como utilizaremos os objetos KSOAP, que serão retornados pelo web service em forma de String. Vale a pena informar que toda comunicação de rede deve ser feita com uma Thread separada da Thread principal da aplicação, pois enquanto estamos fazendo a requisição ao web service, não fica parecendo que sua aplicação está travada. Para isso faremos com que a classe onde está a conexão com o WS (Web Service) implemente a interface Java.lang.Runnable e, no método onCreate(), criaremos e iniciaremos uma nova Thread, passando a própria instância da Activity como parâmetro. Com isso, o método run() chamará um métodos que, por sua vez, fará a requisição aos nossos serviços assim como mostra a Listagem 2:


package weslley.ws.devmedia.com.br;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import android.app.Activity;
import android.app.ProgressDialog;
import android.os.Bundle;
import android.util.Log;

public class WSCepActivity extends Activity implements Runnable {

	ProgressDialog dialog;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

dialog = ProgressDialog.show(WSCepActivity.this,
"", "Aguarde Buscando CEP...", true);

		new Thread(this).start();
	}

	// Metodo da classe Runnable, execulta ao iniciar a classe.
	public void run() {

		chamarInforCep();

	}
Listagem 2. Trecho de código responsável pela chamada do método que irá fazer a requisição ao WS(web service)

Feito isso, iremos ver agora a chamada do serviço. Criamos um método chamado chamarInforCep(), ele é responsável pelo envio das requisições ao web service e pelos retornos que esse irá nos fornecer. Iniciaremos com a criação de um SoapObject que representa o namespace do web service e o método que queremos chamar. Essas informações estão contidas no WSDL do WS (web service), vocês encontrarão elas no targetNamespace e no soap:address, respectivamente. Em seguida, passaremos o parâmetro que o WS requer, no nosso caso ele pede o CEP. No exemplo está sendo atribuído o CEP com os números 50740110, vale a pena resaltar que os CEPs devem ser sempre digitados desta forma. Feita a requisição, é só pegar a resposta que será retornada pelo objeto Objectmsg=envelope.getResponse(); , assim como mostra a Listagem 3:


public void chamarInforCep() {

		//Objeto composto pelo NameSpace e pelo método que queremos chamar
		SoapObject soap = new SoapObject("http://www.maniezo.com.br/",
				"traz_cep");

		//Requisição do web service, solicitação do número do CEP
		soap.addProperty("cep", "50740110");

		SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
				SoapEnvelope.VER11);

		envelope.setOutputSoapObject(soap);

		Log.i("DEVMEDIA", "Chamando WebService para consulta de CEP");

		String url = "http://www.maniezo.com.br/webservice/soap-server.php";

		HttpTransportSE httpTransport = new HttpTransportSE(url);

		try {

			httpTransport.call("", envelope);

			Object msg = envelope.getResponse();

			Log.d("DEVMEDIA", "Endereço: " + msg);
Listagem 3. Trecho de código responsável pela requisição ao WS(web service)

Até esse trecho de código iremos receber do WS (web Service) um retorno (“Text” em Azul) no formato que está na Figura 2.

Objetos retornados pelo WS (web service)
Figura 2. Objetos retornados pelo WS (web service)

Bom pessoal, teremos agora que tratar esse objeto que nos foi retornado com o endereço. Para fazermos isso teremos que colocar na continuação do código uma clausula if/else, que por sua vez irá fazer uma comparação do objeto retornado (msg) com a string “#####”, essa comparação quer dizer que se o objeto (msg) for exatamente igual a “#####”, então o CEP não existe, caso o objeto (msg) esteja diferente disso, o CEP digitado será valido e irá retornar as devidas informações. Veja na Listagem 4 como iremos tratar o nosso objeto msg.


if (msg.equals("#####")) {
	Log.e("DEVMEDIA", "Cep Incorreto");

	dialog.dismiss();
} else {
	Log.d("DEVMEDIA", "CEP Encontrado");
Listagem 4. Código para comparação do objeto retornado pelo web service

Caso o CEP fornecido esteja válido, a nossa app continuará executando. O código continua, mostrando como iremos tratar o nosso objeto. Precisaremos agora de três variáveis do tipo inteiro (int), a primeira variável iremos chamar de ext, essa variável será responsável por armazenar o tamanho (length) do nosso objeto msg. A segunda variável, também do tipo inteiro (int), será chamada contmarc, ela será responsável por contar cada “#”. Já a terceira e última variável do tipo inteiro (int) será chamada de “i”, essa variável será usada apenas como contador. Teremos também que criar as strings que irão receber cada informação que for tratada do objeto, serão elas tipodologradouro, logradouro, bairro, cidade, estado, complemento. Veja como ficará a continuação do código anterior na Listagem 5.


// Variavel responsavel por armazenar a extenção do objeto retornado pelo envelope
	int ext = String.valueOf(msg).length();
	// Contador de marcadores retornado pelo envelope
	int contmarc = 0;
	// Contador que serve como base para execultar a captura de caracter
	// em caracter
	int i = 0;

	String tipodologradouro = "";
	String logradouro  = "";
	String bairro = "";
	String cidade = "";
	String estado = "";
	String complemento = "";

		while (i < ext) {
			String caracter = String.valueOf(msg).substring(i, i + 1);

			if (caracter.equals("#")) {
				contmarc++;
			}

			if (contmarc == 0) {
				tipodologradouro = tipodologradouro + caracter; 
			}
			
			if (contmarc == 1)
			{
				if(!(caracter.equals("#")))
				{
					logradouro = logradouro + caracter;
				}
			}
				
			if (contmarc == 2)
			{
				if(!(caracter.equals("#")))
				{
					complemento = complemento + caracter;
				}
			}
			
			if (contmarc == 3)
			{
				if(!(caracter.equals("#")))
				{
					bairro = bairro + caracter;
				}
			}
			
			if (contmarc == 4)
			{
				if(!(caracter.equals("#")))
				{
					cidade = cidade + caracter;
				}
			}
			
			if (contmarc == 5)
			{
				if(!(caracter.equals("#")))
				{
					estado = estado + caracter;
				}
			}
			
			i++;
			}
			dialog.dismiss();
			
				Log.w("DEVMEDIA", "Tipo Logradouro: " + tipodologradouro);
				Log.w("DEVMEDIA", "Logradouro: " + logradouro);
				Log.w("DEVMEDIA", "Bairro: " + bairro);
				Log.w("DEVMEDIA", "Cidade: " + cidade);
				Log.w("DEVMEDIA", "Estado: " + estado);
				Log.w("DEVMEDIA", "Complemento: " + complemento);
				
			}

		} catch (Exception e) {
			Log.e("GB", "CATH DE BUSCA CEP!");

			finish();
		}
	}
}
Listagem 5. Código responsável por tratar o objeto retornado do Web Service

Utilizamos na Listagem 5 um while que será responsável por percorrer caracter a caracter do nosso objeto e conforme isso for acontecendo, esses caracteres serão comparados e distribuídos entre as variáveis que foram criadas nas clausulas if/else. No final do loop (while) iremos encerrar o dialog que até então estaria girando para o usuário, e mostraremos no LogCat do Eclipse os dados devidamente distribuídos as suas respectivas Strings. Veja na Figura 3 como será retornado o objeto msg a partir de agora.

Objeto retornado pelo WS(web service), distribuído para suas respectivas Strings
Figura 3. Objeto retornado pelo WS(web service), distribuído para suas respectivas Strings

Conclusão

Bom pessoal, o que observamos é que o web service é uma tecnologia muito promissora, ela funciona perfeitamente, independente da linguagem que o desenvolvedor utiliza e ainda proporciona a integração de varias plataformas utilizando uma única base de dados centralizada na internet. Sem falar que o web service permite que a integração de sistemas seja realizada de maneira compreensível, reutilizável e padronizada, concluímos também que o WS em si é uma tentativa de organizar um cenário cercado por uma variedade de diferentes aplicativos e plataformas.

Com isso finalizamos mais um artigo, muito obrigado pela atenção de todos.