RESTful con android y Json

Me pareció interesante el tema de servicios web y estuve viendo su uso en dispositivos móviles, por eso aquí les detallo los pasos a tomar para la creación de una sencilla aplicación android que nos permitirá conectarnos a un RESTFUL, obtener un resultado, procesar y mostrar en pantalla.

¿Qué necesitamos?

  • IDE Eclipse con SDK Android instalado
  • Conocimientos sobre Java, PHP, JSON
  • Servidor (local o en internet)

EL PROYECTO

1. Antes de entrar con la programación en Android, debemos preparar el servidor de pruebas, no construiremos un RestFul como tal, no es el objetivo de este tutorial, sin embargo con unas cuantas lineas de código en php podemos imitar la respuesta que este servicio nos puede entregar.

En nuestro servidor creamos un archivo php en la dirección por ejemplo http://tuservidor/restful/datos.php (ojo con esta url porque la usaremos más adelante), una vez creado este archivo, pegamos el siguiente código:

<?php
$data1 = array(‘nombre’=>’Juan’,’apellido’=>’Saira’);
$data2 = array(‘nombre’=>’Hector,’apellido’=>’Huaman’);
$data3 = array(‘nombre’=>’Susana’,’apellido’=>’Pinto’);
$data = array( $data1, $data2, $data3 );
$datares = array( ‘status’=>200, ‘Registros’=>$data );
print (json_encode( $datares ) );
?>

Este pequeño código crea unos datos en formato JSON

{
  “status”: 200,
  “Registros”: [
    {
      “nombre”: “Juan”,
      “apellido”: “Saira”
    },
    {
      “nombre”: “Hector”,
      “apellido”: “Huaman”
    },
    {
      “nombre”: “Susana”,
      “apellido”: “Pinto”
    }
  ]
}

Podemos observar que está formado por un campo llamado status y un array que contiene 3 registros, el campo llamado status tiene un valor de 200 esto es para indicarle a la aplicación que se tuvo éxito en realizar la acción en el server, esta forma de devolver los resultados es una “buena práctica” que se usa en los APIS puedes leer más sobre estos códigos en List of HTTP status codes.

Podemos hacer uso de herramientas online para poder apreciar mejor como están distribuidos los datos en JSON, por ejemplo usando la herramienta online  jsonviewer tenemos:

json_sasa

Ahora que tenemos listo nuestro servidor de pruebas, continuamos con el paso #2

2. Crea un nuevo proyecto Android en Eclipse que llamaremos RestFulBasic,  mantendremos el MainActivity que se crea  por defecto y añadiremos una clase que llamaremos MyRestFul, debes tener algo como esto:

sasasasas

3. LAYOUT

Abre el archivo activity_main.xml y pega el siguiente código xml:

<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android&#8221;
xmlns:tools=”http://schemas.android.com/tools&#8221;
android:id=”@+id/LinearLayout1″
android:layout_width=”match_parent”
android:layout_height=”match_parent”
android:orientation=”vertical”
android:paddingBottom=”@dimen/activity_vertical_margin”
android:paddingLeft=”@dimen/activity_horizontal_margin”
android:paddingRight=”@dimen/activity_horizontal_margin”
android:paddingTop=”@dimen/activity_vertical_margin”
tools:context=”.MainActivity” >
<Button
android:id=”@+id/btnRF”
android:layout_width=”match_parent”
android:layout_height=”wrap_content”
android:text=”@string/strButton” />
<EditText
android:id=”@+id/txtRespuesta”
android:layout_width=”match_parent”
android:layout_height=”wrap_content”
android:ems=”10″
android:inputType=”textMultiLine” >
<requestFocus />
</EditText>
</LinearLayout>

Nuestra interfaz está compuesta por un botón para iniciar la conexión con el servidor y una caja de texto donde mostrar el resultado obtenido

Abre también el archivo strings.xml y añade:

<string name=”strButton”>Test</string>

4. PERMISOS

Hacemos uso de permisos de INTERNET por lo que debemos añadir el mismo en el archivo AndroidManifest.xml:

<uses-permission android:name=”android.permission.INTERNET”/>

5. MyRestFul

Para conectarnos con el servidor desde android debemos hacer uso de un hilo paralelo al hilo principal, esto porque no queremos que nuestra aplicación se quede colgada esperando el resultado del servidor y porque android no deja ejecutar este tipo de tareas en el hilo principal. Para realizar esta tarea nos valemos de la clase AsyncTask  que usamos de la siguiente forma:

package com.bolivia.restfulbasic;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.widget.EditText;
public class MyRestFul extends AsyncTask<Void,Void,String>{
//ruta del servidor
private final String HTTP_RESTFUL=”http://TU_SERVIDOR/restful/datos.php&#8221;;
//
private ProgressDialog progressDialog;
private Context context;
private EditText editText;
/**Constructor de clase */
public MyRestFul(EditText editText, Context context) {
this.context = context;
this.editText = editText;
}
/**
* Metodo que se conecta al RESTFUL para obtener un resultado
* */
public String getRestFul()
{
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(HTTP_RESTFUL);
String strResultado=”NaN”;
try {
//ejecuta
HttpResponse response = httpclient.execute(httppost);
//Obtiene la respuesta del servidor
String jsonResult = inputStreamToString(response.getEntity().getContent()).toString();
JSONObject object = new JSONObject(jsonResult);
//obtiene el status
String status = object.getString(“status”);
//200 -> todo esta bien
if( status.equals(“200”) )
{
strResultado=””;
//extrae los registros
JSONArray array = new JSONArray(object.getString(“Registros”));
for (int i = 0; i < array.length(); i++)
{
//recorre cada registro y concatena el resultado
JSONObject row = array.getJSONObject(i);
String nombre = row.getString(“nombre”);
String apellido = row.getString(“apellido”);
strResultado += nombre + ” ” + apellido + “\n”;
}
return strResultado;
}
} catch (ClientProtocolException e) {
strResultado = e.getMessage();
e.printStackTrace();
} catch (IOException e) {
strResultado = e.getMessage();
e.printStackTrace();
} catch (JSONException e) {
strResultado = e.getMessage();
e.printStackTrace();
}
return strResultado;
}
/**
* Transforma el InputStream en un String
* @return StringBuilder
* */
private StringBuilder inputStreamToString(InputStream is)
{
String line = “”;
StringBuilder stringBuilder = new StringBuilder();
BufferedReader rd = new BufferedReader( new InputStreamReader(is) );
try
{
while( (line = rd.readLine()) != null )
{
stringBuilder.append(line);
}
}
catch( IOException e)
{
e.printStackTrace();
}
return stringBuilder;
}
/**
* Realiza la tarea en segundo plano
* */
@Override
protected String doInBackground(Void… arg0) {
String resul = getRestFul();
progressDialog.dismiss();
return resul;
}
/**
* Antes de comenzar la tarea muestra el progressDialog
* */
@Override
protected void onPreExecute() {
super.onPreExecute();
progressDialog = ProgressDialog.show(
context, “Por favor espere”, “Procesando…”);
}
/**
* Cuando se termina de ejecutar doInBackground se actualiza la interfaz
* **/
@Override
protected void onPostExecute(String resul) {
editText.setText(resul);
}
}//end:class

Esta clase nos permite ejecutar en paralelo una tarea que no sabemos cuánto puede durar, implementamos también un ProgressDialog que se mostrara en pantalla mientras dure la conexión al servidor, cuando la conexión termine y nos devuelva un resultado, mostraremos este en pantalla.

6. MainActivity

Para terminar abre el MainActivity y completa con lo siguiente:

public class MainActivity extends Activity {

Button button;
EditText txt;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

button = (Button) findViewById( R.id.btnRF );
txt = (EditText) findViewById( R.id.txtRespuesta );

button.setOnClickListener( new View.OnClickListener() {
@Override
public void onClick(View view) {
new MyRestFul(txt, MainActivity.this).execute();
}
});
}

7. Ejecuta

Imagen1dsdssd

 

Referencias:

https://spring.io/guides/gs/consuming-rest-android/

https://elbauldelprogramador.com/fundamentos-programacion-android/

http://www.sgoliver.net/blog/acceso-a-servicios-web-rest-en-android-12/

http://www.hermosaprogramacion.com/2015/10/servicio-web-restful-android-php-mysql-json/

 

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s