Cliente Nativo Android para consumir Servicios Web SOAP y Restful generados en Genexus

De manera similar a la usada en Genexus con el HttpClient para configurar la llamada al servicio (Ver Entrada Anterior para Consumir y Generar Servicios desde Genexus), de la misma forma se usará un tipo de objeto específico para esta tarea en Android. 

Antes se usaban las clases de la biblioteca de Apache como el HttpClient, HttpRequest y HttpRespose para manejar las solicitudes al Servidor, pero a partir del Android 6.0 (API 23) se ha cambiado (ver cambios de la API 23) al uso de la Clase HttpURLConnection, más eficiente en el uso de la red y el manejo de la caché. La misma que usaremos en el presente ejemplo para los clientes de los servicios que creamos en Genexus anteriormente.

Cliente Nativo Android para servicio REST de Genexus

Bueno ahora si vamos con la implementación del Cliente para el servicio REST construido en Genexus, El código a explicar no fue implementado desde cero sino adaptado principalmente de Aquí y otras cositas traídas desde Aquí.

Así que lo que haré es proceder a explicar un poco la lógica del código y las Clases usadas. Para posteriormente dejarlos con el código completo implementado en la clase respectiva.

Como mencionábamos ahora se usará la clase HttpURLConnection que mediante un cast desde un objeto url permite configurar todas las opciones de la conexión como son tiempo de timeout, entre otras. Principalmente nos interesa las opciones setRequestMethod como POST y setReuqestProperty como “Content-Type” application/json“ ya que son los parámetros con los que Genexus construye el servicio Web.

HttpURLConnection urlConnection = null;
URL urlToRequest = new URL(serviceUrl);
urlConnection = (HttpURLConnection) urlToRequest.openConnection();
urlConnection.setConnectTimeout(CONNECTION_TIMEOUT);
urlConnection.setReadTimeout(DATARETRIEVAL_TIMEOUT);
urlConnection.setRequestMethod("POST");
urlConnection.setRequestProperty("Content-Type", "application/json");

Otro punto importante es no olvidar setear las configuraciones necesarias para permitir el envio de parametros y la recepcion de una respuesta.

urlConnection.setDoInput(true);
urlConnection.setDoOutput(true);}

Por último para manejar el parámetro a enviar al servicio web se usa el Formato JSON, basándonos en el nombre del parámetro del procedure (ApplicationId) y en la respuesta obtenida en el cliente construido en Genexus anteriormente en formato JSON, construimos a mano en un String el parámetro a Enviar. Adicionalmente configuramos el tamaño del cuerpo a enviar en la petición.

String body = "{\"ApplicationId\":1}";
urlConnection.setFixedLengthStreamingMode(body.getBytes().length);

Para enviar el parámetro respectivo al servidor en nuestra petición se debe usar un OutputSteam que se encargara de esta tarea.

byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = new BufferedOutputStream(urlConnection.getOutputStream());
os.write(outputInBytes);
os.flush();
os.close();

Por último de manera similar para manejar la respuesta del server se usa un objeto de la Clase InputStream obtenido del objeto urlConnection. El mismo que ya puede ser usado para convertirlo a un String o JSON.

InputStream in = new BufferedInputStream(urlConnection.getInputStream());

Bueno ahora si la Clase completa como se prometió anteriormente.

Descarga Aquí.

Y uso estas líneas para imprimir el resultado obtenido del servicio Rest en consola pasando como parámetro la url del Servicio Rest construido en Genexus:

JSONObject response = restservice.requestWebService("http://192.168.2.128/IAMEV3.NetEnvironment/rest/getapplicationsrest");
if (response.length() == 0){
    Log.i("MyHttpClientLibrary", "is null");
}else {
    Log.i("MyHttpClientLibrary", response.toString());
}

Importando la librerías respectivas

import org.json.JSONObject;
import android.util.Log;

Cliente Nativo Android para servicio SOAP de Genexus

De manera similar al Cliente Rest construido anteriormente se usará el objeto HttpUrlConnection un OutputStream para enviar el body construido mediante un String con la única diferencia que en este caso será con estructura xml, y un ImputStream para manejar la respuesta del servidor. El código base usado lo pueden ver Aquí.

Si revisan el código básicamente es el mismo salvo la requestProperty “Content-Type” que ahora es “text/xml”

httpURLConnection.setRequestProperty("Content-Type", "text/xml");

y las funciones createSoapHeader y getReqData que construyen el parámetro o body a enviar el server en fomato xml recibido por el Servicio Soap de Genexus. De manera similar al servicio explicado anteriormente, para construir el body o parámetro a enviar al servidor, se uso el wsdl del servicio, y las pruebas por Genexus para conocer como estructura Genexus la respuesta y el SOAClient mencionado en la entrada anterior para ver la trama cruda devuelta y configurar la cabecera y el cuerpo a enviar.

Se recomienda observar principalmente la línea o el tag siguiente que contiene como namespace el nombre de la KB usada y el nombre de la función a usar “getApplications.Execute”

<getApplications.Execute xmlns="IAMEV3"> </getApplications.Execute>

Observar el tag ApplicationId que acogen el parámetro usado en el servicio.

<Applicationid xmlns="IAMEV3">1</Applicationid>

Y por último los tags que acogen el cuerpo y los tags internos respectivos.

<SOAP-ENV:Body> </SOAP-ENV:Body>
<SOAP-ENV:Envelope> </SOAP-ENV:Envelope>

A continuación se muestra el código completo de la clase creada.

Descarga Aquí.

Por último para llamar a la clase correspondiente usamos:

SoapConsumer soapConsumer = new SoapConsumer();
String response = soapConsumer.callSOAPWebService("http://192.168.2.128/IAMEV3.NetEnvironment/agetapplications.aspx?wsdl");
Log.i("Soap Service: " , response);

Obsérvese que se envía como url el wsdl creado en Genexus.

Todo el código mostrado es solo un ejemplo básico de como consumir los servicios Web creados en Genexus usando las nuevas clases del API de Android y enfocándose en el formato que debe tener los parámetros de entrada principalmente.

Adicionalmente se podría usar clases especializadas para crear el body o los parámetros a usar para la petición al servidor ya sean XML o JSON, o incluso manejar unos parsers adecuados para tratar la respuesta del Servidor.