jeudi 23 décembre 2010

Suivi des variables personnalisées Analytics avec Blogger

Si vous utilisez Blogger, vous vous êtes sans doutes empressé à intégrer le tracking Google Analytics de vos visiteurs. Si le suivi du nombre de vos visiteurs, de leurs origines géographique, des liens et mots clés d'entrée sur votre blog, des pages les plus visitées etc... vous passionne, alors vous serez certainement intéressé par la mise en place de mesures personnalisés au moyen des custom variables ou variables personnalisées.

Les variables personnalisées Google Analytics permettent de suivre des valeurs quelconques pour des variables que vous définissez vous mêmes. Le suivi des valeurs pouvant se faire :
  • Par visiteur unique
  • Par session de navigation
  • Par impression de page
Pour une explication exhaustive sur les variables personnalisées, je vous renvoie à la documentation Google Analytics. Nous allons maintenant voir comment les utiliser pour effectuer le suivi des tags les plus populaires sur votre blog Blogger.

Vous avez sans doute déjà ajouté le code de suivi Analytics au template de votre blog :
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-XXXX-Y']);

(function() {
    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();

_gaq.push(['_trackPageview']);
La directive _gaq.push(['_trackPageview']); permet d'envoyer les données suivies pour la page affichée vers votre compte Analytics. Pour effectuer le suivi des tags les plus populaires de votre blog, il va falloir ajouter le code suivant avant cette directive _gaq.push(['_trackPageview']); :
if (/(http:\/\/){0,1}avianey.blogspot.com\/[0-9]{4}\/[0-9]{2}\/.*\.html/.test(window.location)) {
    var libellesSpan;
    var continuer = false;
    if (document.getElementsByClassName) {
        var labels = document.getElementsByClassName('post-labels');
        if (labels && labels!=null && labels.length>0) {
            libellesSpan = labels[0];
            continuer = true;
        }
    } else {
        var blog = document.getElementById('Blog1');
        if (blog && blog!=null && blog.getElementsByTagName) {
            var spans = blog.getElementsByTagName("span");
            continuer = true;
            for (var i = 0; i < spans.length; i++) {
                if (spans[i].className=='post-labels') {
                    libellesSpan = spans[i];
                    break;
                }
            }
        }
     }
     if (continuer && libellesSpan.getElementsByTagName) {
         var links = libellesSpan.getElementsByTagName('a');
         for (var i = 0; i < links.length; i++) {
             _gaq.push(['_setCustomVar', 1, 'Tag', links[i].innerText.replace(/%20/g,' '),  3]);
         }
     }
}
La première partie du code permet de récupérer les tags associés au post du blog qui est affiché :
  1. Vérification de l'URL afin de s'assurer qu'elle correspond à celle d'un post. Le suivi n'est pas effectué pour la page principale, l'historique du blog ou la liste des posts par tag.
  2. Si l'on est sur la page d'un post : récupération des tags du blog en utilisant getElementsByClassName sur les navigateurs compatibles ou en navigant dans le DOM pour les autres (Internet Explorer...)
  3. Enfin, enregistrement d'une valeur personnalisée pour chaque tag associé au post : _gaq.push(['_setCustomVar', 1, nom, valeur, 3]);
Il ne reste plus qu'à attendre quelques jours (et oui c'est plutôt long) avant de voir apparaître les premières statistiques dans votre interface Analytics :


mardi 14 décembre 2010

L'application Niveau à Bulle devient open source !

Aujourd'hui est un jour un peu particulier pour moi puisque c'est la première fois que je publie une application en licence open source. Cela fait déjà plusieurs années que j'utilise dans le cadre professionnel ou personnel des applications ou librairies java open sources (principalement sous Licence Apache ou LGPL). Ces applications ou librairies m'ont permis d'avancer sur de nombreux sujets... et il me tenait à coeur depuis un bout de temps de participer au mouvement. C'est donc avec une grande joie que je propose le code d'une de mes applications Android déjà téléchargée plus d'un million de fois :

Niveau à Bulle

De nombreuses licences open source existent mais je n'ai pas hésité longtemps pour m'orienter vers la GNU General Public License v3. Cette licence m'a semblé être la plus adapté dans le cadre de la publication d'une application complète, n'étant pas destinée à être intégrée dans une application au périmètre plus étendu. S'il avait été question d'une librairie, j'aurais sans hésitation opté pour l'Apache licence 2. Entre les deux, la GNU Lesser General Public License me paraît être destinée à la publication d'outils finis intégrables dans une application au périmètre étendu. Mais cela demeure une réflexion purement personnelle. Pour ceux d'entre vous qui sont intéressés par le code source de l'application, ça se passe ici : projets androgames. De nombreux cas d'utilisation Android sont couverts :

  • Utilisation des senseurs d'orientation et d'accélération
  • Utilisation de l'api Android de gestion des préférences
  • Persistance de données
  • Gestion d'animations 2D via une SurfaceView
  • Utilisations d'Intent
  • Effets sonores
  • Utilisation d'une police de caractères alternative
  • Gestion de la segmentation
  • Utilisation de l'API de déclaration XML de formes géométriques (dessin vectoriel)
  • Support multilingue
  • ...


Pour ceux qui ne connaissent pas encore l'application, voici quelques copies d'écran. Et si vous voulez la tester en conditions réelles, rendez-vous sur l'Android Market.



lundi 13 décembre 2010

Automatisation des livraisons pour l'Android Market

Dans la dernière version de son SDK Android, Google a intégré l'utilitaire ProGuard d'obfuscation et d'optimisation de code. Cette intégration par Google facilite l'automatisation du processus de génération d'applications optimisées à destination de l'Android market. Voyons comment il nous est possible de générer deux apk (Android Package) signés, obfusqués, optimisés et aux fonctionnalités différentes en ne maintenant qu'une unique version du code source et un script Ant.

Ennoncé du problème

Prenons l'exemple de l'application Niveau à bulle. Cette application est présente en deux versions sur l'Android market. Une version gratuite, sans publicité et une version payante permettant aux personnes qui le souhaite de faire un petit don au développer ;-)

La seule différence entre les deux applications est la présence ou non des liens "Donate" et "My Applications" au niveau des préférences.



Afin de ne pas complexifier le développement, nous voudrions ne disposer que d'une unique version des sources à maintenir et d'un moyen pour générer nos deux apk aussi rapidement qui si nous n'en avions qu'un !

Génération des scripts

Assurez-vous dans un premier temps de disposez de la version 8 du SDK Android. Pour générer les scripts initiaux permettant d'automatiser le build de l'application, il faut lancer la commande suivante à partir du répertoire tools du SDK Android :

cd %ANDROID_HOME%/tools
android update project --path ./Level


Vous vous retrouvez ainsi avec trois fichiers supplémentaires à la racine de votre projet :
build.xml
Script Ant permettant de générer un livrable Android non signé, non obfuscé et non optimisé
local.properties
Fichier de configuration du script Ant spécifique à votre ordinateur et permettant d'indiquer les chemins vers votre keystore, le répertoire d'installation du SDK Android, ... Ce fichier sera généralement spécifique à chaque poste de développement, et non géré en gestion de configuration.
proguard.cfg
Fichier de configuration spécifique à ProGuard et adapté aux applications Android.

Pour lancer la construction d'un livrable non signé, non obfuscé, il suffit de lancer la tache "release" du script build.xml :

ant release

Pour générer un livrable signé, non obfuscé, il suffit d'ajouter deux propriétés au fichier de configuration local.properties (puis relancer la tache "release" de Ant) :

key.store=/chemin/vers/mon/keystore.ks
key.alias=alias


Enfin, pour générer un livrable signé et obfuscé, il ne reste plus qu'à configurer l'utilisation de ProGuard par le SDK Android. Pour cela nous allons créer un fichier build.properties gérable en gestion de configuration et contenant la déclaration du fichier de configuration ProGuard (puis relancer la tache "release" de Ant) :

proguard.config=proguard.cfg

Il est important de re-tester son application de manière minutieuse lorsque l'on souhaite la publier en version obfuscé. En effet, Android permet de déclarer l'appel de code java depuis des fichiers XML. C'est notamment le cas du fichier AndroidManifest.xml. D'une manière générale, le fichier de configuration proguard.cfg généré pour nous par le SDK préserve le code qui est référencé par le fichier AndroidManifest.xml. Ce n'est en revenche pas le cas des click listeners introduits en version 1.6 d'Android. Si vous déclarer le click listener d'un Button dans un fichier de layout, la configuration ProGuard ne préservera pas la méthode appelée dans l'activité utilisant le layout :
<button android:onclick="monClickListener"/>
Si vous souhaitez conserver vos click listeners, vous devrez vous plonger dans la documentation ProGuard et modifier le fichier proguard.cfg.

Adaptation du code

Nous allons maintenant nous intéresser au moyen de maintenir deux versions différentes d'une application au moyen d'un unique code source. L'exemple étant simple, la solution le sera également Afin de ne conserver les préférences "Donate" et "My Applications" que pour l'application gratuite, nous allons modifier la PreferenceActivity LevelPreferences.java en ajoutant des conditions vraies ou fausses autour du code qui distingue les deux versions :
package net.androgames.level;

import net.androgames.level.config.DisplayType;
import net.androgames.level.config.Provider;
import net.androgames.level.config.Viscosity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.ActivityNotFoundException;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.Uri;
import android.os.Bundle;
import android.preference.CheckBoxPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceCategory;
import android.preference.PreferenceManager;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.Preference.OnPreferenceClickListener;

public class LevelPreferences extends PreferenceActivity implements OnPreferenceChangeListener {

    public static final String KEY_SHOW_ANGLE           = "preference_show_angle";
    public static final String KEY_DISPLAY_TYPE         = "preference_display_type";
    public static final String KEY_SOUND                = "preference_sound";
    public static final String KEY_LOCK                 = "preference_lock";
    public static final String KEY_LOCK_LOCKED          = "preference_lock_locked";
    public static final String KEY_LOCK_ORIENTATION     = "preference_lock_orientation";
    public static final String KEY_APPS                 = "preference_apps";
    public static final String KEY_DONATE               = "preference_donate";
    public static final String KEY_SENSOR               = "preference_sensor";
    public static final String KEY_VISCOSITY            = "preference_viscosity";
    public static final String KEY_ECONOMY              = "preference_economy";

    private static final String PUB_APPS     = "market://search?q=pub:\"Antoine Vianey\"";
    private static final String PUB_DONATE   = "market://details?id=net.androgames.level.donate";
    
    private static final int DIALOG_CALIBRATE_AGAIN = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
        if (true) {
            PreferenceCategory appsCategory = new PreferenceCategory(this);
            appsCategory.setTitle(R.string.preference_apps_category);
            Preference appsPreference = new Preference(this);
            appsPreference.setTitle(R.string.preference_apps);
            appsPreference.setSummary(R.string.preference_apps_summary);
            appsPreference.setKey(KEY_APPS);
            Preference donatePreference = new Preference(this);
            donatePreference.setTitle(R.string.preference_donate);
            donatePreference.setSummary(R.string.preference_donate_summary);
            donatePreference.setKey(KEY_DONATE);
            getPreferenceScreen().addPreference(appsCategory);
            appsCategory.addPreference(donatePreference);
            appsCategory.addPreference(appsPreference);
        }
    }

    public void onResume() {
        super.onResume();
        // enregistrement des listerners
        findPreference(KEY_DISPLAY_TYPE).setOnPreferenceChangeListener(this);
        findPreference(KEY_SENSOR).setOnPreferenceChangeListener(this);
        findPreference(KEY_VISCOSITY).setOnPreferenceChangeListener(this);
        findPreference(KEY_ECONOMY).setOnPreferenceChangeListener(this);
        // mise a jour de l'affichage
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
        findPreference(KEY_DISPLAY_TYPE).setSummary(DisplayType.valueOf(
                prefs.getString(LevelPreferences.KEY_DISPLAY_TYPE, "ANGLE")).getSummary()); 
        findPreference(KEY_SENSOR).setSummary(Provider.valueOf(
                prefs.getString(LevelPreferences.KEY_SENSOR, "ORIENTATION")).getSummary());
        findPreference(KEY_VISCOSITY).setSummary(Viscosity.valueOf(
                prefs.getString(LevelPreferences.KEY_VISCOSITY, "MEDIUM")).getSummary());
        findPreference(KEY_VISCOSITY).setEnabled(
                !((CheckBoxPreference) findPreference(KEY_ECONOMY)).isChecked());
        if (true) {
            // lancement du market
            findPreference(KEY_APPS).setOnPreferenceClickListener(new OnPreferenceClickListener() {
                @Override
                public boolean onPreferenceClick(Preference preference) {
                    Intent intent = new Intent(Intent.ACTION_VIEW);
                    intent.setData(Uri.parse(PUB_APPS));
                    LevelPreferences.this.startActivity(intent);
                    return true;
                }
            });
            findPreference(KEY_DONATE).setOnPreferenceClickListener(new OnPreferenceClickListener() {
                @Override
                public boolean onPreferenceClick(Preference preference) {
                    Intent intent = new Intent(Intent.ACTION_VIEW);
                    intent.setData(Uri.parse(PUB_DONATE));
                    try {
                        LevelPreferences.this.startActivity(intent);
                    } catch (ActivityNotFoundException anfe) {}
                    return true;
                }
            });
        }
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        String key = preference.getKey();
        if (KEY_DISPLAY_TYPE.equals(key)) {
            preference.setSummary(DisplayType.valueOf((String) newValue).getSummary());
        } else if (KEY_SENSOR.equals(key)) {
            preference.setSummary(Provider.valueOf((String) newValue).getSummary());
            showDialog(DIALOG_CALIBRATE_AGAIN);
        } else if (KEY_VISCOSITY.equals(key)) {
            preference.setSummary(Viscosity.valueOf((String) newValue).getSummary());
        } else if (KEY_ECONOMY.equals(key)) {
            findPreference(KEY_VISCOSITY).setEnabled(!((Boolean) newValue));
        }
        return true;
    }
    
    protected Dialog onCreateDialog(int id) {
        Dialog dialog;
        switch(id) {
            case DIALOG_CALIBRATE_AGAIN:
                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setTitle(R.string.calibrate_again_title)
                        .setIcon(android.R.drawable.ic_dialog_alert)
                        .setCancelable(true)
                           .setNegativeButton(R.string.ok, new DialogInterface.OnClickListener() {
                               public void onClick(DialogInterface dialog, int id) {
                                   dialog.dismiss();
                               }
                           })
                           .setMessage(R.string.calibrate_again_message);
                dialog = builder.create();
                break;
            default:
                dialog = null;
        }
        return dialog;
    }
    
}
Les directives if (true) {...} et if (false) {...} seront automatiquement optimisées par ProGuard lors de la phase d'optimisation du code : le code inaccessible ou inutilisé est automatiquement supprimé par l'outil.

Il ne reste plus qu'à créer un script Ant dont le but sera de remplacer la directive if (true) par if (false) et de lancer la tache ant release sur chacune des deux versions.

Automatisation des livraisons

Chaque application de l'Android market doit déclarer un nom de package unique dans son fichier AndroidManifest.xml. Pour publier deux versions différentes, il faut donc modifier le nom de package utilisé. Dans notre cas, nous en utiliserons deux :
  • net.androgames.level : pour la version gratuite
  • net.androgames.level.donate : pour la version payante 
Le renommage du package n'est pas sans conséquence, puisqu'il implique de déplacer l'activité principale (et autres activités, receivers, services, ...) dans le nouveau package déclaré, et de modifier la déclaration des packages et des imports pour ces classes et les classes référentes.

Imaginons que nous maintenions la version gratuite des sources avec l'utilisation des préférences supplémentaires. Dans un premier temps, nous allons dupliquer la totalité du projet dans un répertoire temporaire de travail :
<mkdir dir="${temp.dir}" />
<copy todir="${temp.dir}">
 <fileset dir=".">
     <exclude name="**/${temp.dir}/**" />
 </fileset>
</copy>
Il va ensuite falloir effectuer les modifications nécessaires sur le nom des packages, les imports et remplacer  la directive if (true) par if (false) :
<!-- debut des modifications specifiques -->

<replace file="${temp.dir}/AndroidManifest.xml" token="net.androgames.level"
            value="net.androgames.level.donate"/>

<replace dir="${temp.dir}" value="net.androgames.level.donate.R">
    <include name="**/*.java"/>
    <replacetoken><![CDATA[net.androgames.level.R]]></replacetoken>
</replace>

<replace dir="${temp.dir}" value="net.androgames.level.donate.Level">
    <include name="**/*.java"/>
    <replacetoken><![CDATA[net.androgames.level.Level]]></replacetoken>
</replace>

<move todir="${temp.dir}/src/net/androgames/level/donate">
    <fileset dir="${temp.dir}/src/net/androgames/level">
        <include name="*.java"/>
    </fileset>
</move>

<replace dir="${temp.dir}" value="package net.androgames.level.donate;">
    <include name="**/*.java"/>
    <replacetoken><![CDATA[package net.androgames.level;]]></replacetoken>
</replace>

<replace file="${temp.dir}/src/net/androgames/level/donate/LevelPreferences.java">
      <replacetoken><![CDATA[if (true) {]]></replacetoken>
      <replacevalue><![CDATA[if (false) {]]></replacevalue>
</replace>

<!-- fin des modifications specifiques -->
Une fois les sources modifiées dans le répertoire temporaire, il peut être nécessaire de supprimer le répertoire gen contenant les fichiers java générées par le SDK afin que ceux-ci soient regénérés lors de la construction des livrables. Si votre version alternative contient des ressources différentes (strings, arrays, attrs, ...), cette régénération est indispensable pour éviter de nombreuses RuntimeException.

Il ne reste plus qu'à mettre le tout en musique dans un script Ant :
<?xml version="1.0" encoding="iso-8859-1"?>
<project name="Livraison Level" default="all">

    <property file="make.properties" />

    <target name="all" 
        description="Package les 2 versions" 
        depends="prepare-livraison, do-original, do-modified, clean"/>
    
    <target name="prepare-livraison" depends="clean">
        <mkdir dir="${temp.dir}" />
        <copy todir="${temp.dir}">
            <fileset dir=".">
                <exclude name="**/${temp.dir}/**" />
            </fileset>
        </copy>
        
        <replace file="${temp.dir}/build.xml" token="${original.name}" value="${modified.name}"/>

        <!-- debut des modifications specifiques -->
        
        <replace file="${temp.dir}/AndroidManifest.xml" token="net.androgames.level"
                    value="net.androgames.level.donate"/>
        
        <replace dir="${temp.dir}" value="net.androgames.level.donate.R">
            <include name="**/*.java"/>
            <replacetoken><![CDATA[net.androgames.level.R]]></replacetoken>
        </replace>
        
        <replace dir="${temp.dir}" value="net.androgames.level.donate.Level">
            <include name="**/*.java"/>
            <replacetoken><![CDATA[net.androgames.level.Level]]></replacetoken>
        </replace>
        
        <move todir="${temp.dir}/src/net/androgames/level/donate">
            <fileset dir="${temp.dir}/src/net/androgames/level">
                <include name="*.java"/>
            </fileset>
        </move>
        
        <replace dir="${temp.dir}" value="package net.androgames.level.donate;">
            <include name="**/*.java"/>
            <replacetoken><![CDATA[package net.androgames.level;]]></replacetoken>
        </replace>
        
        <replace file="${temp.dir}/src/net/androgames/level/donate/LevelPreferences.java">
              <replacetoken><![CDATA[if (true) {]]></replacetoken>
              <replacevalue><![CDATA[if (false) {]]></replacevalue>
        </replace>
        
        <!-- fin des modifications specifiques -->
        
    </target>
    
    <target name="clean">
        <delete dir="${temp.dir}"/>
    </target>

    <target name="do-original">
        <echo message="Création de la version originale" />
        <ant dir="." antfile="build.xml" target="release"/>
    </target>
    
    <target name="do-modified">
        <echo message="Création de la version modifiee" />
        <delete dir="${temp.dir}/gen" />
        <ant dir="${temp.dir}" antfile="build.xml" target="release"/>
        <move file="${temp.dir}/bin/${modified.name}-release.apk" todir="bin"/>
    </target>

</project>
Avec son fichier de configuration :

original.name=Level
modified.name=Level-donate
temp.dir=tmp


Vous vous retrouvez au final avec les deux apk signées, obfuscées et optimisées dans le répertoire bin à la racine du répertoire projet de l'application :

dimanche 21 novembre 2010

Configurer son mobile Android en debug sous Ubuntu

Après de nombreuses bidouilles pour faire reconnaître mon téléphone mobile Android en mode debug sous Ubuntu, voici un petit step by steb qui devrait vous permettre de tester vos applications Android depuis Eclipse. La méthode a fonctionnée avec mon Samsung Galaxy S i9000. Elle devrait également marcher avec d'autres téléphones (HTC Hero, HTC Desire, Sony Xperia, Motorola Droid, ...) si vous n'arrivez pas à le faire reconnaitre par l'ADB :

user@ubuntu:$ ./adb devices
List of devices attached
???????????? no permissions


La commande ./adb s'exécute depuis le répertoire d'installation du SDK Android.

La première étape consiste à récupérer le Vendor ID du périphérique USB correspondant à votre téléphone. Utilisez pour cela la commande usb-device :

user@ubuntu:$ usb-devices

T: Bus=02 Lev=02 Prnt=02 Port=02 Cnt=01 Dev#= 4 Spd=480 MxCh= 0
D: Ver= 2.00 Cls=02(commc) Sub=00 Prot=00 MxPS=64 #Cfgs= 1
P: Vendor=04e8 ProdID=681c Rev=04.00
S: Manufacturer=SAMSUNG
S: Product=SAMSUNG_Android
S: SerialNumber=1000239e45c7
C: #Ifs= 4 Cfg#= 3 Atr=c0 MxPwr=96mA
I: If#= 0 Alt= 0 #EPs= 1 Cls=02(commc) Sub=02 Prot=01 Driver=cdc_acm
I: If#= 1 Alt= 0 #EPs= 2 Cls=0a(data ) Sub=00 Prot=00 Driver=cdc_acm
I: If#= 2 Alt= 0 #EPs= 2 Cls=08(stor.) Sub=06 Prot=50 Driver=usb-storage
I: If#= 3 Alt= 0 #EPs= 2 Cls=ff(vend.) Sub=42 Prot=01 Driver=usbfs


Le code hexa 04e8 est à renseigner dans un fichier 51-android.rules sous /etc/udev/rules.d. Les fichier doit être créé avec les droits root :

user@ubuntu:$ sudo gedit /etc/udev/rules.d/51-android.rules

Y inscrire la ligne :

SUBSYSTEM=="usb", SYSFS{idVendor}=="04e8", MODE="0666"

L'idVendor correspond ici au code hexa récupéré pour le Samsung Galaxy S. Il ne reste ensuite plus qu'à redémarrer l'ADB :

user@ubuntu:$ sudo ./adb kill-server
user@ubuntu:$ sudo ./adb start-server
* daemon not running. starting it now on port 5037 *
* daemon started successfully *
user@ubuntu:$ ./adb devices
List of devices attached
1000239e45c7 device


Le téléphone est correctement reconnu. Les applications peuvent ainsi directement être lancées depuis Eclipse sur le téléphone. Bon développement !

dimanche 7 novembre 2010

New York city Trip

Quelques photos de notre voyage à New York.
Un temps parfait, une saison extra (vacances de la toussaint) pour voir les arbres de central park sous toutes les couleurs et ne pas avoir ni trop chaud ni trop froid...

Central park

Statue of liberty

Taxi à Time Square

Time Square

Flatiron Building

China Town (traitement croisé)

mercredi 20 octobre 2010

Android JAX-RS Client : partie cliente avec Gson

Dans un post précédent, nous avons vu comment il était possible d'exposer des services JAX-RS JSON grâce au Google appEngine et aux API Java Jersey et Jackson. Nous allons cette fois-ci aborder la partie cliente de ces services sous Android dont voici une capture d'écran :

Téléchargement et installation des outils

Pour reproduire ce tutorial, vous aurez besoin des outils et API suivants :
  • Eclipse : le célèbre IDE
  • SDK Android : pour développer des applications Android avec Eclipse
  • Gson : API de sérialisation / désérialisation made in Google
Une fois téléchargés et installés, créez un nouvel Android Project dans votre workspace Eclipse :


Ajoutez un répertoire /lib à la racine du projet et importez-y la librairie gson.jar. Ajoutez également la dépendance au classpath du projet Eclipse.


Afin d'autoriser notre application à effectuer des appels réseaux via Internet, il faut ajouter au fichier AndroidManifest.xml la permission android.permission.INTERNET :
<?xml version="1.0" encoding="utf-8"?>
<manifest 
    xmlns:android="http://schemas.android.com/apk/res/android"
    package="net.androgames.blog.sample.rest.client"
    android:versionCode="1"
    android:versionName="1.0">
      
    <application 
        android:icon="@drawable/icon" 
        android:label="@string/app_name">
    
        <activity 
            android:name=".UserConsumer"
            android:label="@string/app_name"
            android:screenOrientation="portrait">
                  
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
            
        </activity>

    </application>
    
    <uses-sdk android:minSdkVersion="4" />
    
    <uses-permission android:name="android.permission.INTERNET" />

</manifest>

Mise en place de l'interface utilisateur

Notre application sera décomposée en deux parties. L'une permettra la création, la mise à jour et la suppression d'utilisateurs tandis que l'autre affichera la liste de tous les utilisateurs avec leur prénom, nom et id :


Le layout utilisé pour le rendu d'un utilisateur de la liste est définit par le fichier user.xml du répertoire res/layout :
<?xml version="1.0" encoding="UTF-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="?android:attr/listPreferredItemHeight"
    android:padding="6dip">
    
    <ImageView
        android:src="@drawable/user"
        android:layout_width="48dip"
        android:layout_height="48dip"
        android:layout_marginRight="6dip" />

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="0dip"
        android:layout_weight="1"
        android:layout_height="fill_parent">

        <TextView
            android:id="@+id/name"
            android:textAppearance="?android:textAppearanceMedium"
            android:layout_width="fill_parent"
            android:layout_height="0dip"
            android:layout_weight="1"
            android:ellipsize="marquee"
            android:gravity="center_vertical" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="fill_parent"
            android:layout_height="0dip"
            android:layout_weight="1" >

            <TextView
                android:textAppearance="?android:textAppearanceSmall"
                android:textColor="#FFCC3333"
                android:textStyle="bold"
                android:layout_marginRight="6dip"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="ID :"
                android:ellipsize="marquee" />
            
            <TextView
                android:id="@+id/id"
                android:textAppearance="?android:textAppearanceSmall"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginRight="6dip"
                android:singleLine="true"
                android:ellipsize="marquee" />
            
        </LinearLayout>
            
    </LinearLayout>

</LinearLayout>
Le formulaire permettant la mise à jour ou la suppression d'un utilisateur existant, ainsi que la création de nouveaux utilisateurs se présentera sous les formes suivantes :



Les actions réalisables sont au nombre de 5 :
  1. Créer un nouvel utilisateur
  2. Enregistrer les modifications apportées au nom ou au prénom d'un utilisateur
  3. Supprimer un utilisateur
  4. Annuler l'édition en cours d'un utilisateur, le formulaire est alors remis à zéro
  5. En cliquant sur un utilisateur de la la liste, le formulaire se met à jour avec les informations de l'utilisateur sélectionné.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    
    <LinearLayout
        android:orientation="vertical"
        android:paddingLeft="6dip"
        android:paddingRight="6dip"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content">
        
        <TextView
            android:text="@string/forName"
            android:textAppearance="?android:textAppearanceLarge"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"/>
    
        <EditText 
            android:id="@+id/forName"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"/>
        
        <TextView
            android:text="@string/name"
            android:textAppearance="?android:textAppearanceLarge"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"/>
    
        <EditText 
            android:id="@+id/name"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"/>
    
        <LinearLayout
            android:orientation="horizontal"
            android:layout_gravity="right"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content">
            
            <Button 
                android:id="@+id/insertOrUpdate"
                android:onClick="insertOrUpdate"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"/>
            
            <Button 
                android:id="@+id/delete"
                android:text="@string/delete"
                android:onClick="delete"
                android:visibility="gone"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"/>
            
            <Button 
                android:id="@+id/initialize"
                android:text="@string/initialize"
                android:onClick="initialize"
                android:visibility="gone"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"/>
                
        </LinearLayout>
    
    </LinearLayout>
        
    <ListView 
        android:id="@+id/users"
        android:layout_height="0dip"
        android:layout_weight="1"
        android:layout_width="fill_parent" />
        
</LinearLayout>
Dans le Layout ci dessus, on remarquera en particulier que les boutons ne sont pas tous présents par défaut. Les boutons "Enregistrer", "Supprimer" et "Annuler" ne sont proposés que si un utilisateur de la liste à été sélectionné. L'attribut android:onClick des balises Button permet de spécifier le nom de la méthode appelée lorsque lorsque le bouton est pressé. Ces méthodes doivent être déclarées dans la ou les Activity qui utilisent le Layout comme content view. Elle doivent être publiques et prendre un unique paramètre de type View.

Pour le rendu de la liste des utilisateurs, nous utilisons un ListAdapter afin de faire le pont entre la ListView (couche de présentation) et notre liste d'utilisateurs (modèle de données).
package net.androgames.blog.sample.rest.client;

import java.util.List;

import android.content.Context;
import android.database.DataSetObserver;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ListView;
import android.widget.TextView;

public class UserAdapter extends BaseAdapter {

    private List<User> users;
    private LayoutInflater inflater;

    public UserAdapter(final ListView list, Context context) {
        this.inflater = LayoutInflater.from(context);
        // on attache l'adapter à la ListView
        list.setAdapter(this);
        // raffraichissement de la liste lorsque
        // une donnée est modifiée
        registerDataSetObserver(new DataSetObserver() {
            public void onChanged() {
                list.invalidateViews();
            }
        });
    }

    public int getCount() {
        if (users == null) {
            return 0;
        } else {
            return users.size();
        }
    }

    public Object getItem(int position) {
        return users.get(position);
    }

    public long getItemId(int position) {
        return position;
    }

    public View getView(int position, View convertView, ViewGroup parent) {
        
        TaskHolder holder;
        
        // récupération du holder
        if (convertView == null) {
            convertView = inflater.inflate(R.layout.user, null);
            holder = new TaskHolder();
            holder.name = (TextView) convertView.findViewById(R.id.name);
            holder.id = (TextView) convertView.findViewById(R.id.id);
            convertView.setTag(holder);
        } else {
            holder = (TaskHolder) convertView.getTag();
        }
        
        // affichage de l'utilisateur d'index demande
        // via l'utilisation du holder
        if (position < getCount()) {
            User user = (User) getItem(position);
            holder.name.setText(user.getPrenom() + " " +user.getNom());
            holder.id.setText(user.getId());
        }
        
        return convertView;
    }
    
    public void setUsers(List<User> users) {
        this.users = users;
        // mise à jour de la liste
        notifyDataSetChanged();
    }
    
    public void addUser(User user) {
        if (!users.contains(user)) {
            users.add(user);
            // mise à jour de la liste
            notifyDataSetChanged();
        }
    }

    public void removeUser(User user) {
        users.remove(user);
        // mise à jour de la liste
        notifyDataSetChanged();
    }
    
    /**
     * Holder class :
     * Permet de ne pas multiplier le nombre
     * d'instance de View utilisées pour
     * l'affichae des utilisateurs dans la
     * ListView
     */
    static class TaskHolder {
        TextView name;
        TextView id;
    }

}
La méthode getView de l'Adapter permet de retourner une instance du LinearLayout utilisé pour le rendu d'un utilisateur (/res/layout/user.xml) et dans lequel les vues sont remplies avec les données de l'utilisateur en position demandée.

Appels aux services REST

L'interface utilisateur maintenant en place, nous allons nous pencher sur les appels aux services REST. Afin de ne pas tomber dans les fameuses erreurs ANR (Application Not Responding), les appels aux services s'exécuteront dans un Thread différent de celui utilisé pour les interactions avec l'utilisateur (rendu graphique, capture des événements, ...). Pour cela, nous utiliserons des AsyncTask afin que l'envoi de la requête au serveur, l'attente de la réponse et la récupération de la réponse s'exécute en parallèle du Thread principal. La méthode est similaire à l'utilisation du de la classe SwingWorker de Java 6.
/**
 * Classe abstraite pour l'envoi de requètes asynchrones au serveur.
 */
public abstract class AbstractTask 
        extends AsyncTask<HttpRequestBase, Void, HttpResponse> {
    
    /**
     * Appelée avant le lancement du traitement en arrière plan.
     * Cette méthode est exécutée dans le Thread appelant.
     */
    protected void onPreExecute() {}
    
    /**
     * Traitement en arrière plan.
     * Cette méthode est exécuté dans un Thread différent
     * du Thread appelant.
     */
    protected HttpResponse doInBackground(final HttpRequestBase...requests) {}

    /**
     * Appelée après la fin du traitement en arrière plan.
     */
    protected void onPostExecute(final HttpResponse response) {}
    
    /**
     * Traitement spécifique du JSON
     * @param in Le contenu de la réponse HTTP OK
     */
    protected abstract void handleJson(final InputStream in);

};
Cette classe nous permet de définir un comportement générique pour chacun des appels aux services REST ainsi qu'un comportement spécifique à implémenter :
onPreExecute
Cette méthode est appelée dans le Thread principal avant que le traitement en tâche de fond ne soit lancé. Dans notre cas, nous l'utiliserons pour afficher une fenêtre popup d'attente.
doInBackground
Cette méthode appelée dans un Thread annexe permet de lancer un traitement en tâche de fond. Nous l'utiliserons pour effectuer les requêtes HTTP à destination du serveur et attendre la réponse de ce dernier. Cette méthode retourne un objet dans le type correspond à celui de la méthode ci dessous.
onPostExecute
Cette méthode est appelée dans le Thread principal une fois que le traitement en tâche de fond a terminé.Elle prend en paramètre le résultat du traitement effectué en tache de fond. Dans notre cas, cette méthode sera utilisée pour analyser la réponse du serveur et traiter le contenu de celle-ci.
handleJson
Cette méthode abstraite doit être surchargée pour traiter de manière spécifique le contenu de la réponse du serveur au format JSON.
Nous utiliserons 4 implémentations différentes de cette classe abstraite, chacune ayant pour but le traitement d'un type particulier de réponse du serveur :
/**
 * Récupération de la liste des User
 */
private class ListUsersTask extends AbstractTask {

    protected void handleJson(final InputStream in) {
        final Type collectionType = new TypeToken<List<User>>(){}.getType();
        List<User> users = null;
        synchronized (lock) {
            users = gson.fromJson(new InputStreamReader(in), collectionType);
        }
        // La liste récupérée initialement est la référence
        // des User pour l'application Android
        adapter.setUsers(users);
    }

};
/**
 * Recuperation d'un utilisateur
 * déjà référencé localement
 */
private class GetUserTask extends AbstractTask {

    protected void handleJson(final InputStream in) {
        synchronized (lock) {
            updateCurrentUser(gson.fromJson(new InputStreamReader(in), User.class));
        }
    }

};
/**
 * Récupération d'un nouvel utilisateur
 * non encore référencé localement
 */
private class AddUserTask extends AbstractTask {

    protected void handleJson(final InputStream in) {
        synchronized (lock) {
            updateCurrentUser(gson.fromJson(new InputStreamReader(in), User.class));
        }
        adapter.addUser(currentUser);
    }

};
/**
 * Suppression d'un utilisateur
 * référencé localement
 */
private class DeleteUserTask extends AbstractTask {

    protected void handleJson(final InputStream in) {
        User fakeUser = new User();
        try {
            fakeUser.setId(new BufferedReader(
                    new InputStreamReader(in, ENCODING_UTF_8)).readLine());
        } catch (Exception e) {}
        adapter.removeUser(fakeUser);
        updateCurrentUser(null);
    }

};
Dans le cas de la suppression d'un utilisateur, le serveur nous renvoie un objet de type String sans délimiteur d'objet JSON : '{' ou '['. Nous traitons donc le contenu directement comme une chaine de caractères au moyen d'un BufferedReader.

Pour lancer ces traitements asynchrones d'envoi des requêtes au serveur, nous devons au préalable construire la HttpRequestBase que nous allons passer en paramètre à l'une de nos AbstractTask. Le code ci-dessous nous permet de mettre à jour l'utilisateur en cours d'édition en quelques étapes :
  1. Création d'un bean User avec les informations modifiées du formulaire
  2. Création d'une instance de la classe HttpPost pointant sur /user/{user.getId()}
  3. Le Content-Type du Header de la requête précise que le contenu est de type application/json
  4. Le bean User est sérialisé en JSON via la librairie Gson
  5. La représentation JSON est encodée en UTF-8 et positionnée dans la requête HTTP
  6. La requête est envoyé via une GetUserTask afin de récupérer le bean User retourné par le serveur
// mise a jour du currentUser
User updatedUser = new User();
updatedUser.setNom(name.getEditableText().toString());
updatedUser.setPrenom(forName.getEditableText().toString());
// création d'une requête de type POST
// l'URL contient l'ID du User à mettre à jour
HttpPost request = new HttpPost(
        getString(R.string.user_endpoint) + "/" + currentUser.getId());
// précision du Content-Type
request.setHeader("Content-Type", JSON_CONTENT_TYPE);
synchronized (lock) {
    try {
        // l'objet de type User sérialisé est envoyé dans le corps
        // de la requête HTTP et encodé en UTF-8 (cf. Jackson)
        request.setEntity(new StringEntity(gson.toJson(updatedUser), ENCODING_UTF_8));
    } catch (UnsupportedEncodingException e) {}
}
(new GetUserTask()).execute(request);
L'emploi de l'encodage UTF-8 est imposé par la librairie Jackson utilisé par Jersey côté serveur pour la sérialisation / désérialisation du JSON. En espérant un support de l'encodage ISO-8859-1 dans une prochaine release...

Pour l'appel aux autres méthodes du serveur vous pouvez regarder le code complet de l'Activity donné ci-dessous :
package net.androgames.blog.sample.rest.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Type;
import java.util.List;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.AdapterView.OnItemClickListener;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

public class UserConsumer extends Activity implements OnItemClickListener {
    
    private static final DefaultHttpClient httpClient = new DefaultHttpClient();
    static {
        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setContentCharset(params, "UTF-8");
        httpClient.setParams(params); 
    }
    
    private static final Gson gson = new Gson();

    private static final String JSON_CONTENT_TYPE = "application/json; charset=UTF-8";
    private static final String ENCODING_UTF_8 = "UTF-8";

    private static final int DIALOG_ERROR = 0;
    private static final int DIALOG_LOADING = 1;
    
    private EditText name, forName;
    private Button insertOrUpdate, initialize, delete;
    
    private User currentUser; // utilisateur courant
    private UserAdapter adapter; // utilisé comme référentiel local
    
    private Object lock = new Object();
    
    /**
     * Classe abstraite pour l'envoi de requêtes asynchrones au serveur.
     */
    private abstract class AbstractTask 
            extends AsyncTask<HttpRequestBase, Void, HttpResponse> {
        
        /**
         * Appelée avant le lancement du traitement en arrière plan.
         * Cette méthode est exécutée dans le Thread appelant.
         */
        protected void onPreExecute() {
            showDialog(DIALOG_LOADING);
        }
        
        /**
         * Traitement en arrière plan.
         * Cette méthode est exécutée dans un Thread différent
         * du Thread appelant.
         */
        protected HttpResponse doInBackground(final HttpRequestBase...requests) {
            HttpResponse response = null;
            synchronized (lock) {
                try {
                    response = httpClient.execute(requests[0]);
                } catch (Exception e) {
                    Log.e(UserConsumer.class.getSimpleName(), 
                            "Erreur d'appel au serveur", e);
                }
            }
            return response;
        }

        /**
         * Appelé après la fin du traitement en arrière plan.
         */
        protected void onPostExecute(final HttpResponse response) {
            dismissDialog(DIALOG_LOADING);
            if (response == null 
                    || !(response.getStatusLine()
                            .getStatusCode() == HttpStatus.SC_OK)) {
                showDialog(DIALOG_ERROR);
            } else {
                try {
                    handleJson(response.getEntity().getContent());
                } catch (IOException e) {
                    Log.e(UserConsumer.class.getSimpleName(), 
                            "Erreur de flux", e);
                }
            }
        }
        
        /**
         * Traitement spécifique du JSON
         * @param in Le contenu de la réponse HTTP OK
         */
        protected abstract void handleJson(final InputStream in);

    };
    
    /**
     * Récupération de la liste des User
     */
    private class ListUsersTask extends AbstractTask {

        protected void handleJson(final InputStream in) {
            final Type collectionType = new TypeToken<List<User>>(){}.getType();
            List<User> users = null;
            synchronized (lock) {
                users = gson.fromJson(new InputStreamReader(in), collectionType);
            }
            // La liste récupérée initialement est la référence
            // des User pour l'application Android
            adapter.setUsers(users);
        }

    };
    
    /**
     * Recuperation d'un utilisateur
     * déjà référencé localement
     */
    private class GetUserTask extends AbstractTask {

        protected void handleJson(final InputStream in) {
            synchronized (lock) {
                updateCurrentUser(gson.fromJson(new InputStreamReader(in), User.class));
            }
        }

    };
    
    /**
     * Récupération d'un nouvel utilisateur
     * non encore référencé localement
     */
    private class AddUserTask extends AbstractTask {

        protected void handleJson(final InputStream in) {
            synchronized (lock) {
                updateCurrentUser(gson.fromJson(new InputStreamReader(in), User.class));
            }
            adapter.addUser(currentUser);
        }

    };
    
    /**
     * Suppression d'un utilisateur
     * référencé localement
     */
    private class DeleteUserTask extends AbstractTask {

        protected void handleJson(final InputStream in) {
            User fakeUser = new User();
            try {
                fakeUser.setId(new BufferedReader(
                        new InputStreamReader(in, ENCODING_UTF_8)).readLine());
            } catch (Exception e) {}
            adapter.removeUser(fakeUser);
            updateCurrentUser(null);
        }

    };
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        adapter = new UserAdapter((ListView) findViewById(R.id.users), this);
        insertOrUpdate = (Button) findViewById(R.id.insertOrUpdate);
        initialize = (Button) findViewById(R.id.initialize);
        delete = (Button) findViewById(R.id.delete);
        name = (EditText) findViewById(R.id.name);
        forName = (EditText) findViewById(R.id.forName);
    }
    
    @Override
    public void onResume() {
        super.onResume();
        // recuperation de tous les utilisateurs
        (new ListUsersTask()).execute(new HttpGet(getString(R.string.user_endpoint)));
        // initialisation des actions
        ((ListView) findViewById(R.id.users)).setOnItemClickListener(this);
        // initialisation de l'IHM
        // currentUser peut ne pas être null
        // si l'activité a été résumée
        updateCurrentUser(currentUser);
    }
    
    /**
     * Clique sur le bouton Créer ou Enregistrer
     * @param v
     */
    public void insertOrUpdate(View v) {
        if (currentUser == null) {
            // nouvel utilisateur
            User user = new User();
            user.setNom(name.getEditableText().toString());
            user.setPrenom(forName.getEditableText().toString());
            // création d'une requête de type POST
            // l'URL contient l'ID du User Ã  mettre Ã  jour
            HttpPut request = new HttpPut(getString(R.string.user_endpoint));
            // précision du Content-Type
            request.setHeader("Content-Type", JSON_CONTENT_TYPE);
            synchronized (lock) {
                try {
                    // l'objet de type User sérialisé est envoyé dans le corps
                    // de la requête HTTP et encodé en UTF-8 (cf. Jackson)
                    request.setEntity(new StringEntity(
                            gson.toJson(user), ENCODING_UTF_8));
                } catch (UnsupportedEncodingException e) {}
            }
            (new AddUserTask()).execute(request);
        } else {
            // mise a jour du currentUser
            User updatedUser = new User();
            updatedUser.setNom(name.getEditableText().toString());
            updatedUser.setPrenom(forName.getEditableText().toString());
            // création d'une requête de type POST
            // l'URL contient l'ID du User Ã  mettre Ã  jour
            HttpPost request = new HttpPost(
                    getString(R.string.user_endpoint) + "/" + currentUser.getId());
            // précision du Content-Type
            request.setHeader("Content-Type", JSON_CONTENT_TYPE);
            synchronized (lock) {
                try {
                    // l'objet de type User sérialisé est envoyé dans le corps
                    // de la requête HTTP et encodé en UTF-8 (cf. Jackson)
                    request.setEntity(new StringEntity(
                            gson.toJson(updatedUser), ENCODING_UTF_8));
                } catch (UnsupportedEncodingException e) {}
            }
            (new GetUserTask()).execute(request);
        }
    }
    
    /**
     * Clique sur le bouton Supprimer
     * @param v
     */
    public void delete(View v) {
        // envoi d'une requête DELETE au serveur
        // sur l'URL correspondant au User Ã  supprimer
        (new DeleteUserTask()).execute(new HttpDelete(
                getString(R.string.user_endpoint) + "/" + currentUser.getId()));
    }
    
    /**
     * Clique sur le bouton Annuler
     * @param v
     */
    public void initialize(View v) {
        // raz du formulaire
        updateCurrentUser(null);
    }

    // Met a jour le formulaire avec les
    // informations de l'utilisateur passé
    // en paramètre. Si le formulaire est 
    // positionné sur les données d'un utilisateur
    // de même id, le référentiel local est mis à jour
    private void updateCurrentUser(User user) {
        if (user == null) {
            currentUser = null;
            name.setText("");
            forName.setText("");
            delete.setVisibility(View.GONE);
            initialize.setVisibility(View.GONE);
            insertOrUpdate.setText(R.string.create);
        } else {
            if (!user.equals(currentUser)) {
                // changement de User
                currentUser = user;
            } else {
                // mise a jour des informations du User
                // dans le référentiel local
                currentUser.setNom(user.getNom());
                currentUser.setPrenom(user.getPrenom());
                adapter.notifyDataSetChanged();
            }
            // mise à jour du formulaire
            name.setText(currentUser.getNom());
            forName.setText(currentUser.getPrenom());
            delete.setVisibility(View.VISIBLE);
            initialize.setVisibility(View.VISIBLE);
            insertOrUpdate.setText(R.string.update);
        }
    }
    
    @Override
    public Dialog onCreateDialog(int dialogId) {
        Dialog dialog = null;
        AlertDialog.Builder builder = null;
        switch (dialogId) {
        
            case DIALOG_LOADING : // recuperation en cours...
                dialog = new ProgressDialog(this);
                ((ProgressDialog) dialog).setIndeterminate(true);
                ((ProgressDialog) dialog).setMessage(getString(R.string.loading));
                break;
                
            case DIALOG_ERROR : // message d'erreur
                builder = new AlertDialog.Builder(this);
                builder.setTitle(R.string.error)
                       .setMessage(R.string.error_message)
                       .setNegativeButton(R.string.close, new OnClickListener() {
                            public void onClick(DialogInterface dialog, int which) {
                                dialog.dismiss();
                            }
                        });
                dialog = builder.create();
                break;
        }
        return dialog;
    }
    
    /**
     * L'utilisateur à cliqué sur un User de la liste,
     * le formulaire est mis à jour avec les informations
     * du User récupérés depuis le serveur
     */

    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        // mise a jour du formulaire avec les informations
        // du User sélectionné par l'utilisateur
        updateCurrentUser((User) adapter.getItem(position));
        
        // on aurait également pu demander l'utilisateur 
        // au serveur à chaque fois, mais on considere
        // que la liste initialement chargée est notre
        // référence afin de garder un jeu de donnée cohérent
        
        // (new GetUserTask()).execute(new HttpGet(
        //        getString(R.string.user_endpoint) + 
        //        "/" + ((User) adapter.getItem(position)).getId()));
    }
    
}
Vous pouvez récupérer l'exemple complet sur Google Code : SampleAndroidRestClient.

mardi 12 octobre 2010

Android JAX-RS Client : partie serveur avec Jersey et App Engine

En 2008, Google a ouvert son offre de cloud computing au monde Java. Depuis, le Google appEngine permet à n'importe quelle personne de déployer une application web Java scalable et à haute disponibilité ! Dans ce tutorial, nous allons voir comment exposer un service REST en JSON dans le cloud au moyen de l'appEngine et de l'api Jersey JAX-RS. Le webservice exposé consistera en un simple CRUD d'objets de type User.

Téléchargement et installation des outils

Pour suivre ce tutorial, vous aurez besoin des outils et api suivantes :
Une fois téléchargées et installée, créez un nouveau Web Application Project :


Ajoutez les librairies Jersey suivante dans le répertoire war/WEB-INF :
  • asm.jar
  • commons-validator.jar
  • jackson-core-asl.jar
  • jackson-jaxrs.jar
  • jackson-mapper-asl.jar
  • jackson-xc.jar
  • jersey-client.jar
  • jersey-core.jar
  • jersey-json.jar
  • jettison.jar
  • jsr311-api.jar


Mise en place du modèle de données

Dans le répertoire src/META-INF du projet, nous allons remplacer le fichier de configuration JDO créé par défaut par un fichier de configuration JPA persistence.xml :

<?xml version="1.0" encoding="UTF-8" ?>
<persistence version="1.0"
    xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
                        http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">

    <persistence-unit name="transactions-optional">
        <provider>
                org.datanucleus.store.appengine.jpa.DatastorePersistenceProvider
        </provider>
        <properties>
            <property name="datanucleus.NontransactionalRead" value="true"/>
            <property name="datanucleus.NontransactionalWrite" value="true"/>
            <property name="datanucleus.ConnectionURL" value="appengine"/>
        </properties>
    </persistence-unit>

</persistence>

Nous nous contenterons de la configuration JPA minimale.
Notre entité persisté sera une classe User :

package net.androgames.blog.sample.rest.server;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import org.datanucleus.jpa.annotations.Extension;


@Entity
public class User implements Serializable {

    /**
     * 1 : Version initiale
     */
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Extension(vendorName="datanucleus", key="gae.encoded-pk", value="true")
    private String id;
    
    private String nom;
    private String prenom;
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getNom() {
        return nom;
    }
    public void setNom(String nom) {
        this.nom = nom;
    }
    public String getPrenom() {
        return prenom;
    }
    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
    
}

Mise en place de Jersey et CRUD simple

Pour exposer les fonctionnalités de création, suppression, modification et récupération en REST, nous allons utiliser l'api Jersey. Comme la plupart des framework utilisés dans une application web, sa configuration s'effectue en déclarant une Servlet spécifique dans le fichier web.xml :

<?xml version="1.0" encoding="utf-8"?>
<web-app 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
    version="2.5">

    <servlet>
        <servlet-name>Jersey</servlet-name>
        <servlet-class>
            com.sun.jersey.spi.container.servlet.ServletContainer
        </servlet-class>
        <!-- Packages a analyser -->
        <init-param>
            <param-name>com.sun.jersey.config.property.packages</param-name>
            <param-value>net.androgames.blog.sample.rest.server</param-value>
        </init-param>
        <!-- Mapping JSON POJO -->
        <init-param>
            <param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>Jersey</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>
    
</web-app>

La sérialisation / désérialisation des POJO par Jersey sera effectuée par la classe com.sun.jersey.api.json.POJOMappingFeature. Jersey va ainsi supporter la sérialisation / désérialisation au format JSON. L'implémentation de notre CRUD est la suivante :

package net.androgames.blog.sample.rest.server;

import java.util.List;
import java.util.logging.Logger;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;

import com.sun.jersey.api.NotFoundException;

@Path("/user")
@Produces("application/json")
@Consumes("application/json")
public class UserService {
    
    private static final Logger log = Logger.getLogger(UserService.class.getName());
    
    private static final EntityManagerFactory ENTITY_MANAGER = 
        Persistence.createEntityManagerFactory("transactions-optional");
    
    public static EntityManager getEntityManager() {
        return ENTITY_MANAGER.createEntityManager();
    }

    /**
     * Mise a jour d'un utilisateur par son id
     * @param id
     * @param user
     * @return
     */
    @POST
    @Path("{id}")
    public User update(
            @PathParam("id") String id, 
            User user) {
        log.info("Mise a jour du user d'id : " + id);
        
        if (user == null) {
            throw new IllegalArgumentException();
        }
        
        EntityManager em = getEntityManager();
        User persistedUser = em.getReference(User.class, id);
        
        if (persistedUser == null) {
            throw new NotFoundException();
        }
        
        persistedUser.setNom(user.getNom());
        persistedUser.setPrenom(user.getPrenom());

        em.getTransaction().begin();
        em.merge(persistedUser);
        em.getTransaction().commit();
        
        return persistedUser;
    }

    /**
     * Recupere un utilisateur par son id
     * @param deviceId
     * @return
     */
    @GET
    @Path("{id}")
    public User get(@PathParam("id") String id) {
        log.info("Recuperation du user d'id : " + id);
        
        EntityManager em = getEntityManager();
        User persistedUser = em.getReference(User.class, id);
        
        if (persistedUser == null) {
            throw new NotFoundException();
        }
        
        return persistedUser;
    }

    /**
     * Recuperation de la liste des utilisateurs
     * @param deviceId
     * @return
     */
    @GET
    @SuppressWarnings("unchecked")
    public List<User> list() {
        log.info("Recuperation des utilisateurs");
        
        EntityManager em = getEntityManager();
        List<User> users = em.createQuery("SELECT u FROM User u").getResultList();
        
        return users;
    }

    /**
     * Supprime un utilisateur par son id
     * @param deviceId
     * @return
     */
    @DELETE
    @Path("{id}")
    public String delete(@PathParam("id") String id) {
        log.info("Suppression du user d'id : " + id);
        
        EntityManager em = getEntityManager();
        User persistedUser = em.getReference(User.class, id);
        
        if (persistedUser == null) {
            throw new NotFoundException();
        }

        em.getTransaction().begin();
        em.remove(persistedUser);
        em.getTransaction().commit();
        
        return id;
    }

    /**
     * Ajoute un utilisateur
     * @param deviceId
     * @return
     */
    @PUT
    public User add(User user) {
        log.info("Ajout d'un utilisateur");
        
        EntityManager em = getEntityManager();
        em.getTransaction().begin();
        em.persist(user);
        em.getTransaction().commit();
        
        return user;
    }
    
}

Jersey se configure au moyen d'annotations :
@Path
Cette annotation permet de spécifier le chemin d'accès à la ressource relativement au chemin paramétré dans le fichier web.xml pour la Servlet Jersey. Utilisée sur la déclaration d'une classe, elle s'applique à toutes ses méthodes. Utilisée sur une méthode, elle s'applique relativement au Path définit pour la classe.
@PathParam
Elle permet de récupérer une partie du Path en paramètre d'une méthode. Dans notre exemple, nous déclarons le Path "/user/{id}" pour la méthode get. Ainsi définit, notre Path nous permet de récupérer la partie mappée par "{id}" grâce à l'annotation PathParam.
@PUT, @POST, @GET, @DELETE
Ces annotations permettent de spécifier la méthode HTTP à mapper sur une méthode de la classe UserService. Seules les requêtes du type spécifié seront transmises à la méthode. Cela permet d'utiliser le même chemin "/user" pour la création d'un utilisateur (PUT), la récupération de tous les utilisateurs (GET) et la suppression d'un utilisateur (DELETE). La récupération d'un utilisateur (GET) et la imse à jour d'un utilisateur (POST) partagent le chemin "/user/{id}".
@Produce
Cette annotation permet de préciser le (ou les) type MIME que Jersey peut utiliser pour sérialiser les retours des méthodes annotées PUT, GET, POST, DELETE, ... Dans notre exemple, nous avons spécifier une sérialisation en JSON pour l'ensemble des méthodes de la classe. Il est également possible de spécifier le type MIME par version, ou d'en spécifier plusieurs séparés par des virgules. Dans ce cas, le type MIME utilisé pour la sérialisation correspond au premier type MIME rencontré dans le header HTTP Accept.
@Consume
Tout comme l'annotation Produce, cette annotation permet de définir un type MIME et, plus précisément, le type MIME qui sera utiliser par Jersey pour désérialiser les valeurs à passer en paramètre aux méthodes exposées. Dans notre exemple, nous attendons donc pour les méthodes add et update une requête HTTP nous envoyant un bean User sérialisé en JSON. Il est également possible de spécifier le type MIME par méthode ou d'en préciser plus d'un.

Test des services avec l'API de test Jersey


Jersey offre la possibilité de recetter rapidement un webservice REST en utilisant la classe Client de son API. L'exemple ci dessous montre comment tester rapidement l'ajout, la mise à jour, la récupération et la suppression d'un utilisateur.

package net.androgames.blog.sample.rest.server;

import javax.ws.rs.core.MediaType;

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;

public class TestUserService {

    private static final String URL = "http://localhost:8888/user";
    
    /**
     * 
     * @param args
     */
    public static void main(String[] args) {
        
        // creation d'un client Jersey
        Client c = Client.create();
        WebResource r;
        User user;
        
        // test d'insertion d'un utilisateur
        r = c.resource(URL);
        user = new User();
        user.setNom("Vianey");
        user.setPrenom("");
        user = r.type(MediaType.APPLICATION_JSON_TYPE)
                .accept(MediaType.APPLICATION_JSON_TYPE)
                .put(User.class, user);
        
        System.out.println("User enregistré avec l'id : " + user.getId());
        
        // test de mise a jour de l'utilisateur
        r = c.resource(URL + "/" + user.getId());
        user = new User();
        user.setNom("Vianey");
        user.setPrenom("Antoine");
        user = r.type(MediaType.APPLICATION_JSON_TYPE)
                .accept(MediaType.APPLICATION_JSON_TYPE)
                .post(User.class, user);
        
        System.out.println("User mise a jour : " + user.getPrenom() + " " + user.getNom());
        
        // test de recuperation de l'utilisateur
        r = c.resource(URL + "/" + user.getId());
        user = r.type(MediaType.APPLICATION_JSON_TYPE)
                .accept(MediaType.APPLICATION_JSON_TYPE)
                .get(User.class);
        
        System.out.println("User récupéré : " + user.getPrenom() + " " + user.getNom());
        
        // test de suppression des utilisateurs
        r = c.resource(URL + "/" + user.getId());
        r.type(MediaType.APPLICATION_JSON_TYPE)
                .accept(MediaType.APPLICATION_JSON_TYPE)
                .delete();
        
    }

}

Pour le test de récupération de la liste des utilisateurs, je n'ai malheureusement pas trouver de méthode élégante pour désérialiser directement le type List en JAX-RS comme cela est fait avec le type User... Une solution répandue consiste à retourner un wrapper encapsulant la liste des utilisateurs. Dans le prochain tutorial, nous aborderons nous verrons comment coder un client Android pour ces webservices avec l'utilisation d'une librairie nous permettant de désérialiser de manière élégante notre liste d'utilisateur. A la prochaine !
Fork me on GitHub