Presentacion #bbmnk

Programación en
Android
Picasso, Asynchronous HTTP Client, Otto
con

Picasso
http://square.github.io/picasso/
Es una librería para gestionar de forma
eﬁciente la carga de imágenes en
nuestras aplicaciones
¿Qué es?

Picasso
¿Cuando utilizarla?
Nuestra aplicación muestra un volumen
signiﬁcativo de imágenes que obtiene de
una o diversas fuentes, usando ListView o
GridView.
galería, timeline, …

Picasso
<dependency>
<groupId>com.squareup.picasso</groupId>
<artifactId>picasso</artifactId>
<version>2.4.0</version>
</dependency>
dependencies {
compile ‘com.squareup.picasso:picasso:2.4.0'
}
Descargar el jar de la web e incluirlo en nuestro proyecto
¿Cómo utilizarla? (1)
Maven
Gradle
jar

Picasso
Picasso.with(context)
.load(R.drawable.img)
.into(imageView1);
.load(“http://dominio.com/img.png”)
.into(imageView1);
.load(new File(“path”))
.into(imageView1);

Picasso
1. Gestión óptima de los recursos en la visualización de
imágenes en ListView y GridView
2. Caché automática en memoria y disco
• Cancelación automática de la descarga
• Reciclado de bitmaps
¿Qué ventajas tiene?
4. Es muy fácil de utilizar y no necesita componentes
extras para visualizar las imágenes.
3. Permite cargar las imágenes desde el propio
dispositivo o desde HTTP
5. Es muy ligera, sólo 115Kb la última versión

Picasso
Diario Secreto de Violetta
Experiencia personal

Asynchronous HTTP Client
Es una librería para realizar peticiones
HTTP de forma asíncrona
http://loopj.com/android-async-http/
Está construida utilizando la librería HttpClient
de apache que está incluida en el SDK de Android
¿Qué es?

¿Cuando utilizarla?
Nuestra aplicación utiliza un API REST
propia o de terceros para obtener
información

<dependency>
<groupId>com.loopj.android</groupId>
<artifactId>android-async-http</artifactId>
</dependency>
dependencies {
compile 'com.loopj.android:android-async-http:1.4.6'
}
Maven
Gradle
jar

!
clase AsyncHttpClient
!
interface AsyncHttpResponseHandler
Cliente HTTP Callback
Ambas están definidas en el package com.loopj.android.http

import com.loopj.android.http.*;
!
AsyncHttpClient client = new AsyncHttpClient();
!
client.get(“http://helloworld.com”, new AsyncHttpResponseHandler()
{
@Override
public void onStart() {
}
@Override
public void onSuccess(int statusCode, Header[] headers, byte[]
response) {
}
@Override
public void onFailure(int statusCode, Header[] headers, byte[]
errorResponse, Throwable e) {
}
@Override
public void onRetry(int retryNo){
}
});

!
public class MyAppRestClient {
!
private static final BASE_URL = “http://api.service.com/1/”;
private static AsyncHttpClient client = new AsyncHttpClient();
!
public static void get(String url, RequestParams params,
AsyncHttpResponseHandler responseHandler) {
client.get(getAbsoluteUrl(url), params, responseHandler);
}
!
public static void post(String url, RequestParams params,
AsyncHttpResponseHandler responseHandler) {
client.post(getAbsoluteUrl(url), params, responseHandler);
}
!
private static String getAbsoluteUrl(String url) {
return BASE_URL + url;
}
!
}

!
public class MyAppRestClientUsage {
!
public void getPosts() {
MyAppRestClientUsage.get(“posts”, null, new
JsonHttpResponseHandler(){
!
@Override
public void onSuccess(int statusCode, Header[] headers,
JSONObject response) {
// Si la respuesta es un JSONObject
}
@Override
public void onSuccess(int statusCode, Header[] headers,
JSONArray timeline) {
// Si la respuesta es un JSONArray
});
}
!
}

1. Las peticiones se llevan a cabo en un Threadpool fuera
del UI thread, lo que mejora la experiencia del usuario.
2. Dispone de subclases del callback preparadas para tratar
con respuestas JSON, o para realizar subidas/descargas de
ﬁcheros.
6. Es muy fácil de utilizar.
5. Es robusta y ligera: Sólo 95Kb la última versión
3. Almacena las cookies en las preferencias del usuario. Si el
API rest gestiona la sesión del usuario con cookies, el usuario
se mantendrá conectado al volver a abrir la aplicación.
4. Está implementada usando el API HttpClient de apache.

Social CVC : Hackathon Menorca

¿Quién la utiliza?

Otto
http://square.github.io/otto/
Bus de eventos para desacoplar
componentes de la aplicación que
se comunican entre ellos.
¿Qué es?

Otto
Conectando componentes: interfaces
Componente
1
Productor
Componente
2
Consumidor
Interface
implementausa

Otto
public interface ConsumerDelegate {
public void notify(List<String> data);
}

Otto
public class ProducerTask extends AsyncTask<Void, Void, List<String>> {
private ConsumerDelegate mDelegate;
!
public ProducerTask(ConsumerDelegate delegate) {
mDelegate = delegate;
}
!
protected List<String> doInBackground(Void... params) {
List<String> data = new ArrayList<String>();
data.add(“Hola Mundo!”);
return data;
}
protected void onPostExecute(List<String> result) {
mDelegate.notify(result);
}
}

Otto
public class MyActivity extends Activity implements ConsumerDelegate {
@Override
public void notify(List<String> data) {
// Mostrar mensaje en pantalla
}
!
}

Otto
Conectando componentes:
Bus de eventos
Bus de eventos
Componente
1
Productor
mensaje
Componente
3
Consumidor
Componente
4
Consumidor
mensaje mensaje
Componente
2
Productor/
Consumidor
mensaje-2
Componente
5
Consumidor
mensaje-2mensaje-2mensaje

Otto
<dependency>
<groupId>com.squareup</groupId>
<artifactId>otto</artifactId>
</dependency>
dependencies {
compile 'com.squareup:otto:1.3.6'
}
Maven
Gradle
jar

Otto
!
com.squareup.otto.Bus
Bus
!
@com.squareup.otto.Subscribe
Consumidores
!
clases Java estándar
Mensajes

Otto
Tener una instancia del bus accesible por el resto de componentes:
• Application
• Método estático
• Singleton
Los productores obtienen la instancia del bus para publicar eventos
Los consumidores se suscriben al bus para recibir eventos
e implementan métodos con la anotación @Subscribe para procesarlos.

Otto
!
!
public class MyApplication extends Application {
!
private Bus bus;
!
public Bus getBus() {
!
if (mBus == null) {
mBus = new Bus();
}
!
return mBus;
!
}
!
}
Declaración del bus

Otto
!
!
public class Event {
!
private List<String> mData;
public Event(List<String> data) {
mData = data;
}
!
public List<String> getData() {
return mData;
}
!
}
Declaración del mensaje

Otto
public class MyActivity extends Activity {
@Override
protected void onResume() {
((MyApplication) getApplication()).getBus().register(this);
}
!
@Override
protected void onPause() {
((MyApplication) getApplication()).getBus().unregister(this);
}
!
@Subscribe
public void loadList(Event eventData) {
// Mostrar mensaje en pantalla
}
!
}
Consumidores de mensajes

Otto
!
application.getBus().post(new
Event(Arrays.asList(“Hello World!”));
Productor de mensajes
@Produce
public Event produceEvent() {
return new Event(Arrays.AsList(“Hello World!”));
}
*requiere que la clase que produce el evento esté registrada en el Bus

Otto
1. Es una forma estándar de conectar los componentes de
nuestra app: Si muchos componentes de nuestra aplicación
se comunican entre sí, es una forma estándar de deﬁnir la
comunicación, creando los modelos que representan los
mensajes y utilizando el bus para comunicar.
2. Es robusta y ligera: Sólo 19Kb la última versión

Otto
Social CVC : Hackathon Menorca

Sobre mi
juan.miqueo@yuraksisa.com
www.yuraksisa.com
@yurak_sisa

Presentacion #bbmnk

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (9)

Destacado

Destacado (13)

Similar a Presentacion #bbmnk

Similar a Presentacion #bbmnk (20)

Último

Último (9)

Presentacion #bbmnk