networkimageview – OVERSIMPLE

Pour ceux qui ne connaisse pas Volley, c’est LE Framekwork de communication réseau.

Pour commencer, voici une trés bonne vidéo de présentation réalisée par Ficus Kirkpatrick .

L’article ci-dessous permet de faire une introduction à l’utilisation Volley.

Si vous n’avez pas regardé la vidéo, vous allez me dire, il existe déjà plusieurs framework réseau sous Android, pourquoi utiliser un autre framework?

A ma connaissance, il existe 2 possibilités de framework sous Android, afin de faire du HTTP. Le premier est Apache HTTP Client, c’est celui-ci que j’utilisais avant de découvrir Volley. Mais comme vous le savez sans doute, Apache HTTP Client possède des bugs et celui-ci n’est pas forcement maintenu par l’équipe Android.
La seconde API est HttpURLConnection que je n’ai jamais utilisé mais celle-ci possède des bugs.

Pour chacun de ces 2 frameworks, il faut rédefinir des Thread afin de ne pas rester dans le main thread. Cela impliquait l’utilisation des Asynctask.

Volley permet de s’abstenir de toute cette couche. C’est facile, puissant et rapide! De plus, celui-ci possède un cache mémoire ou disque.

C’est bien beau, mais comment ça fonctionne?

Son fonctionnement est aussi simple, il possède une queue que l’on doit initialiser UNE fois (cette initialisation est assez coûteuse en performance). Ensuite, on ajoute dans cette queue les REQUETES que l’on doit effectuer. Le reste est géré par Volley.

Et comment on l’utilise?

Tout d’abord, il faut penser à mettre le user permission Internet dans le manifest d’Android :

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

Puis, il faut récupérer le JAR ou le projet:

git clone https://android.googlesource.com/platform/frameworks/volley
cd volley
android list targets #Choisir l'ID pour la compilitation du JAR
android update project -p . --target ID_DE_TARGETS
ant jar

Une fois le JAR généré, il faut le placer dans le répertoire libs de votre projet. (Penser à l’ajouter au classpath en faisant clic droit add as library)

pour la création de la QUEUE, je considère que l’on en a besoin partout dans notre Application donc on l’initialise qu’une fois. Cette initialisation est faite dans le contexte de l’application (extends Application) :

public class IntroApplication extends Application {
    private RequestQueue volleyRequestQueue;
 
    @Override
    public void onCreate() {
        super.onCreate();
        volleyRequestQueue = Volley.newRequestQueue(this);
        volleyRequestQueue.start();
    }
 
    @Override
    public void onTerminate() {
        volleyRequestQueue.stop();
        super.onTerminate();
    }
 
    public RequestQueue getVolleyRequestQueue() {
        return volleyRequestQueue;
    }
}

Vu que l’on extends Application, il faut penser à l’ajouter dans le manifest dans l’ application android:name= ».IntroApplication ».

Une fois cette initialisation faite, c’est bon, on peut travailler avec Volley. Il existe plusieurs type de Request dans Volley, String, JSONObject, JSONArray etc… (on peut bien sûr extends Request)

Un exemple avec String:

        StringRequest stringRequest = new StringRequest("url",new Response.Listener<String>() {
            @Override
            public void onResponse(String s) {
                Log.d("MainActivity","On doit traiter ici la reponse : " + s);
            }
        },new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                Log.d("MainActivity","On doit gérer ici l'erreur");
            }
        });

En ce qui concerne les deux listener(la réponse et l’erreur), il faut implémenter les interfaces : Response.Listener et Response.ErrorListener.
Une fois que notre stringRequest est géré, il faut l’ajouter dans la Queue.

IntroApplication introApplication = (IntroApplication) getApplication();
mVolleyRequestQueue = introApplication.getVolleyRequestQueue();
mVolleyRequestQueue.add(stringRequest);

Cette exemple est valable pour String mais il fonctionne tout aussi bien avec les JsonObjectRequest, JsonArrayRequest. Il faut aussi remplacer les types des listener par JSONObject ou bien JSONArray.

En ce qui concerne les images au lieu d’utiliser les ImageView, nous allons utiliser les Images pour Volley, c’est à dire NetworkImageView (com.android.volley.toolbox.NetworkImageView). Cette modification doit être effectuée au niveau du XML et ainsi au niveau des CAST pour utiliser un objet de type NetworkImageView au lieu d’un ImageView.
Il faut également ajouter dans le contexte de l’application, le chargement des images.
mVolleyImageLoader = new ImageLoader(mVolleyRequestQueue, new BitmapLruCache());
Avant le start de volley request start de préférence.

Le XML:

    <com.android.volley.toolbox.NetworkImageView
            android:id="@+id/monImage"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:src="@drawable/ic_launcher"/>

BitmapLruCache :

public class BitmapLruCache extends LruCache&lt;String, Bitmap&gt; implements ImageLoader.ImageCache {
 
    /**
     * @param maxSize for caches that do not override {@link #sizeOf}, this is
     *                the maximum number of entries in the cache. For all other caches,
     *                this is the maximum sum of the sizes of the entries in this cache.
     */
    public BitmapLruCache(int maxSize) {
        super(maxSize);
    }
 
    public BitmapLruCache() {
        this(getDefaultLruCacheSize());
    }
 
    public static int getDefaultLruCacheSize() {
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        final int cacheSize = maxMemory / 8;
        return cacheSize;
    }
 
    @Override
    protected int sizeOf(String key, Bitmap value) {
        return value.getRowBytes() * value.getHeight() / 1024;
    }
 
    @Override
    public Bitmap getBitmap(String url) {
        return get(url);
    }
 
    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        put(url, bitmap);
    }
}

Un exemple d’utilisation, super simple:

NetworkImageView networkImageView = (NetworkImageView) findViewById(R.id.monImage);
networkImageView.setImageUrl("lienDeLimage",mVolleyImageLoader);

Et si on désire passer des paramètres? Sans problème, il faut juste extends Request et redéfinir la méthode getParams (Hasmap de String/String).
Un exemple est présent dans l’archive ci-jointe : JSONParams

HashMap<String,String> map = new HashMap<String,String>();
map.put("UnParametre","laValeurDuParametre");
JSONParams jsonParams = new JSONParams("url",map,this,this);
mVolleyRequestQueue.add(jsonParams);

Et si on souhaite annuler une requête dans la QUEUE?
Super simple, il faut sur chaque Request mettre un setTag afin de pouvoir les identifier. Une fois identifiée, il faudra juste annuler celle que l’on désire:
Par exemple, si je reprends l’exemple de stringRequest avant de l’ajouter dans la queue, j’effectue un setTag

stringRequest.setTag("identifiantDeMaStringRequest");
mVolleyRequestQueue.add(stringRequest);
mVolleyRequestQueue.cancelAll("identifiantDeMaStringRequest");

Vous pouvez télécharger l’archive ici.

It’s Oversimple, isn’t it?

Étiquette : networkimageview

Un peu de Volley sous Android!

C’est bien beau, mais comment ça fonctionne?

Et comment on l’utilise?