Backendless BaaS

Buenas a todos,

Después de la retirada de Parse, me decidí por Backendless como mi backend para mis aplicaciones Android. La segunda opción era Firebase, pero finalmente me decidí por Backendless.

En este post quiero explicar todo el procedimiento desde la creación de la cuenta de Backendless, siguiendo por la especificación de los objetos, la descarga de datos siguiendo la API Rest de backendless, hasta la presentación en la aplicación.

El ejemplo que usaremos será sencillo, una simple lista de datos inflada desde nuestro backend. En este caso será una lista con los nombres de nuestros amigos y su fecha de cumpleaños, pero como veremos, cambiar esto por vuestro caso particular es muy sencillo.

1. Preparación de backendless

Lo primero que debemos hacer es crearnos una cuenta en backendless. Una vez logueados en la plataforma, navegaremos hasta la pestaña de ‘Datos’.

El siguiente paso será la creación de la tabla ‘Amigos’ que contendrá tres columnas: nombre, teléfono y fecha de cumpleaños. Para ello, se debe hacer click en el signo ‘+’ situado en el esquina inferior izquierda de la pestaña ‘Datos’.

Una vez creada la tabla ‘Amigos’, crearemos sus columnas. Es conveniente hacer click en el botón rojo ‘Esquema de tablas y permisos’. Añadiremos tres columnas, todas de tipo String. El resultado ha de ser algo parecido a esto:

Captura de pantalla 2016-04-16 a las 19.14.57

Una vez creadas las columnas, se debe rellenar la base de datos. Rellenaremos con datos al azar para este ejemplo. Quedaría algo así:

Captura de pantalla 2016-04-16 a las 19.20.07

2. Android

El proyecto va a constar de una única activity con un recyclerview. Primero vamos a crear el modelo de datos, en nuestro caso Amigo. Es importante que los atributos se llamen iguales que las columnas creadas en backendless. La clase debe tener constructor, además de getters y setters para todos sus atributos.

/**
 * Created by josedelpozo on 16/4/16.
 */
public class Amigo {

    private String nombre;
    private String telefono;
    private String cumple;

    public Amigo(String nombre, String telefono, String cumple) {
        this.nombre = nombre;
        this.telefono = telefono;
        this.cumple = cumple;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getTelefono() {
        return telefono;
    }

    public void setTelefono(String telefono) {
        this.telefono = telefono;
    }

    public String getCumple() {
        return cumple;
    }

    public void setCumple(String cumple) {
        this.cumple = cumple;
    }
}

La respuesta de Backendless es un JSON con atributos de offset, un array de Amigos, un link a la siguiente página y el número de total de objectos que aparecen en el array. Es necesario crear una clase como esta:

/**
* Created by josedelpozo on 17/4/16.
*/
public class BackendlessResponse {

private String offset;
private List<Amigo> data;
private String nextPage;
private float totalObjects;

public BackendlessResponse(String offset, List<Amigo> data, String nextPage, float totalObjects) {
this.offset = offset;
this.data = data;
this.nextPage = nextPage;
this.totalObjects = totalObjects;
}

public String getOffset() {
return offset;
}

public void setOffset(String offset) {
this.offset = offset;
}

public List<Amigo> getData() {
return data;
}

public void setData(List<Amigo> data) {
this.data = data;
}

public String getNextPage() {
return nextPage;
}

public void setNextPage(String nextPage) {
this.nextPage = nextPage;
}

public float getTotalObjects() {
return totalObjects;
}

public void setTotalObjects(float totalObjects) {
this.totalObjects = totalObjects;
}
}

Una vez terminado el modelo, comenzamos con la descarga de datos desde backendless. Como comenté, vamos a usar la API Rest. Para facilitarnos la vida, vamos a usar la librería Retrofit 2.0. Así que, se debe añadir a build.gradle las siguiente líneas:

compile 'com.squareup.retrofit2:retrofit:2.0.0-beta4'

compile 'com.squareup.retrofit2:converter-gson:2.0.0-beta4'

El siguiente paso es crear una interfaz, ‘AmigoService’ que define el método a llamar para recuperar nuestros amigos.

/**
 * Created by josedelpozo on 17/4/16.
 */
public interface AmigoService {

    @Headers({"application-id: APP-ID",
            "secret-key: SECRET-KEY",
            "Content-Type: application/json"})
    @GET("/{version}/data/{table-name}")
    Call<BackendlessResponse> getAmigos(@Path("version") String version, @Path("table-name") String table);
}

Vamos a pararnos un momento en este método. Primero se han de definir unas cabeceras que indican una conexión segura hacia nuestra cuenta de backendless. El id de aplicación, y la clave secreta rest se deben copiar y pegar de nuestro dashboard de backendless. Además, definimos que lo que vamos a recibir es un json con los datos de nuestros amigos.

 

Lo siguiente indica que es una petición GET, e indica la dirección a la que haremos dicha petición. En este caso, la versión de nuestra aplicación es v1 y el nombre de la tabla ‘Amigos’.

Este método devuelve un objeto de tipo Call<Object>, siendo object lo que queremos recibir ya parseado. En nuestro caso, BackendlessResponse.

Bien, una vez creado el servicio, hagamos la petición. Como va a ser una aplicación tan sumamente sencilla que solo descargará estos datos, la petición se hará sobre la Activity que mostrará los datos, pero esto no es Clean Code y no se debe hacer así.

Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.backendless.com")
.addConverterFactory(GsonConverterFactory.create())
.build();

final AmigoService service = retrofit.create(AmigoService.class);

Call<BackendlessResponse> call = service.getAmigos("v1", "Amigos");
Callback callbackRetrofit = new Callback<BackendlessResponse>() {
@Override
public void onResponse(Call<BackendlessResponse> call, Response<BackendlessResponse> response) {
adapter.addAll(response.body().getData());
}

@Override
public void onFailure(Call<BackendlessResponse> call, Throwable t) {
Log.d("ERROR","Failure "+t.getMessage());
}
};
call.enqueue(callbackRetrofit);

Este código será el encargado de hacer la petición a la dirección https://api.backendless.com que se especifica en el objecto Retrofit. También se especifica que usaremos Gson para parsear de JSON a nuestro objecto Amigo.

 

Seguidamente creamos el servicio, y llamamos al método definido en la interfaz anterior. Realizaremos la petición de forma asíncrona, eso quiere decir que cuando el servidor nos devuelva la respuesta, nos aparecerá en el callback definido. Si no ha habido fallo, esta aparecerá en onResponse, y en caso contrario en onFailure.

Para mostrar estos datos, es necesario montar un recyclerview sobre nuestro layout, y un adapter que muestre esos datos. Este tema no lo voy a comentar aquí, ya que es muy sencillo y hay miles de tutoriales más detallados. El código si que lo dejaré en Github por si alguien quiere consultarlo.

Captura de pantalla 2016-04-17 a las 10.46.29

¡El resultado es este!

GITHUB

Anuncios

One comment

  1. Arturo · marzo 1

    Backendless es una porqueria y sus gestores unos sinverguenzas. Multiples fallos, crashes en su libreria que te penalizan, pushes invisibles, pushes duplicados o triplicados y para colmo unos precios desproporcionados puestos a traicion dias antes del cierre de PArse.

    Me gusta

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