Pilote dont je vous ai parlé déjà à de nombreuses reprises ici ou ici, Olivier Lombard est vraiment un des plus prometteurs !

Il signe ce jour avec l’écurie Nissan Signatech et on lui souhaite tout le succès que son talent mérite.

Olivier Lombard: « Mon titre de Champion LMS LMP2 2011 a été une bonne carte de visite pour être intégré dans l’équipe officielle SIGNATECH-NISSAN, elle aussi championne LMP2 2011 mais en Intercontinental le Mans Cup. Mon objectif est de continuer à apprendre notamment aux cotés de Franck, pour les circuits je ne connais pas. Mais l’équipe a une grosse expérience et je sens une énorme motivation de la part de tous les acteurs. »

Son site web a été mis à jour en conséquence par les équipes d’OXiane.

PS: Savez vous pourquoi toutes les voitures Nissan engagées portent le n°23 ?

23 en japonais veut dire Nissan, Merci à Jean (Lombard, le papa de notre champion, ndlr) pour cette info !

Qu’est ce que Core Data ?

« C’est une bibliothèque permettant de gérer le cycle de vie des objets et les graphes d’objets de manière automatique et générale incluant également la persistance » – traduction partielle de la page du site d’Apple.

En gros, pour moi c’est un peu comme une base de données orientée objet, on pourrait faire la parallèle avec Hibernate côté Java sauf que ce n’est pas un framework de persistance d’objet même s’il peut persister les graphes d’objets (relations et états).

Ici, nous allons créer le mapping entre la base de donnée et les objets puis les requêtes permettant de récupérer/modifier/… nos objets et enfin accéder aux « colonnes de notre table » grâce aux propriétés de ces objets.

Retour sur le delegate

Mais avant tout ça, il faut quand même que nous revenions sur la délégation.

En effet, nous avons utilisé 2 fois ce pattern afin de permettre la transmission d’une donnée au contrôleur parent et la disparition de la vue courante faîte par le contrôleur parent.

Seulement dans notre PageTrickViewController, nous avons deux propriétés correspondant aux deux types de contrôleurs affichables et si nous voulons ajouter 3, 4 ou 15 autres contrôleurs nous allons devoir ajouter 3,4 ou 15 autres propriétés.

Il faut donc appliquer le pattern jusqu’au bout pour résoudre cela et ne plus avoir qu’ 1 propriété.
Pour y arriver, il suffit que les délégants soit conforme au même protocole que PageTrickViewController !

Ainsi, on peut remplacer les propriétés par une seule dans le PageTrickViewController:

On n’oublie pas de synthétiser :

Bien sûr, il va falloir modifier prepareForSegue et dismissWithData:

Passons à Core Data !

Comment l’utilise t-on ?

Eh bien c’est assez simple, nous allons créer nos entités grâce à Xcode puis y accéder avec un NSManagedObjectContext, l’objet central autour duquel tourne toute l’activité de Core Data.

1. Importation du framework :

Comme expliquer dans mon précédent billet, faîtes les étapes permettant d’ajouter
un framework à votre projet.
Ici nous devons importer : CoreData.framework

2. Création visuelle de la base de données :

Tout en vidéo :

Et oui alors, c’est quoi @dynamic ?
Pour tout vous dire c’est un peu comme @synthesize sauf que l’on dit au compilateur : « ne t’inquiète pas, je te filerai les implémentations des accesseurs à l’exécution ou directement ».

Mais comme tout est bien fait dans iOS (enfin presque), Core Data génère lui-même les accesseurs pour nous à l’exécution… si c’est pas sympa tout ça !

On peut donc employer la notation pointée sur nos entités les yeux fermés mais avant cela précisons un peu plus comment fonctionne Core Data.

En fait, il y a 2 façons d’utiliser ce framework :
– soit on crée un projet en cochant la case « use Core Data » (ce qu’on n’a pas fait au début… flûte !)
– soit on utilise UIManageDocument et on récupère son NSManagedObjectContext

On opte donc pour la 2ème solution, d’ailleurs elle est très pratique car c’est une porte ouverte sur iCloud mais je n’en dis pas plus pour l’instant à ce sujet. (suspens !)

Il faut voir UIManageDocument comme un conteneur pour notre base de données.

Afin de faciliter le codage, j’ai utilisé une classe mise à disposition ici par Paul Hegarty de l’Université de Stanford.
Rassurez-vous le zip de mon projet est disponible en bas de page.

Cette classe facilite la gestion d’un UITableViewController dont les cellules sont peuplées en fonction de nos entités car pour les remplir nous avons besoin d’un NSFetchedResultController capable de répondre au protocole UITableViewDataSource.

Par exemple, une des méthodes importante de NSFetchedResultController est :

qui irait très bien dans :

Une fois cette classe importer dans notre projet, il ne nous reste plus qu’à la sous-classer en créeant notre classe CoreDataTablePageCurlController :

Interface :

Implémentation :

J’ai fait quelques brefs commentaires dans le code afin de montrer les différentes étapes mais détaillons un peu…
Comme notre base de données est vide au début, on récupère une description de l’entité qui nous intéresse (ici « Objet ») :

puis on instancie l’objet tout en l’ajoutant au contexte :

ensuite on définit c’est champs grâce à la notation pointée, en effet rappelez-vous ce que j’ai dit tout à l’heure : @dynamic indique au compilateur que l’implémentation des accesseurs lui sera fournit plus tard à l’exécution et justement Core Data l’a fait pour nous !

enfin, il ne reste plus qu’à sauver le contexte et créer la base de données :

Ah mais on oublierait pas de parler de requête par hasard ? Les objets ne vont pas arriver tous seuls comme par magie !
Bah non, c’est sûr.
Si on regarde dans le block passé en argument de ce message, on tombe sur l’envoi du message setupFetchedResultsController.
Dans la méthode setupFetchedResultsController, on fait toutce qu’il faut :

création de la requête pour l’entité Objet
[/objc]
NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:@"Objet"];
[/objc]

on trie les objets selon leur attribut num

on ne définit pas de prédicat car on désire récupérer tous les objets, en revanche on n’oublie pas d’instancier notre NSFetchedResultsController

pour plus de détails sur les requêtes voir la doc.

Une fois terminé, ajoutez dans votre storyboard :
– un bouton « clickCoreData »
– un UITableViewController, dont le type sera évidemment CoreDataTablePageCurlController
– un segue de ce bouton vers le UITableViewController avec comme transition « Cover vertical » (pour changer, en plus c’est joli ça fait un effet rebond avec le offset)

Oups, nous allions oublier de mettre à jour notre méthode prepareForSegue dans PageTrickViewController :

Le mal est réparé !

Et voici la petite vidéo et le projet zippé en bonus :

Jeff, tu as cinq minutes ? Sers-toi un café, je te monte un subversion accessible y compris depuis Krypton.

.

t0

Je me connecte sur le site de cloudbees.

Je commence par ajouter un nouvel utilisateur à mon compte pour ton développeur (Account > Manage Users > Add a user).

Il semble que la personne ne reçoive pas de mail quand elle est inscrite par un tiers (?!?). L’astuce est d’aller sur la page « Forgot your Password? » et d’entrer l’e-mail du nouvel inscrit. Comme ça cloudbees va lui envoyer un lien permettant de saisir un mot de passe et se loguer pour la première fois.

t + 2 min

Je crée un nouveau référentiel Subversion pour mon projet. Un clic sur Create new code Repository.

t + 2 min 30

Le référentiel n’attend plus que son premier commit.

Et comme il me reste encore la moitié des cinq minutes allouées, on va lancer l’importation de ton repository subversion existant. On suit la doc :

svnsync init https://svn-oxiane.forge.cloudbees.com/LeProjetDeJeff/ URL_du_repo_source
svnsync sync https://svn-oxiane.forge.cloudbees.com/LeProjetDeJeff/

Et c’est parti mon kiki !

t + 3 min

La discussion se poursuit pendant que les révisions défilent sur l’écran. On aborde le sujet de l’intégration continue du projet en question chez cloudbees …
la suite au prochain épisode.

Ice Scream Sandwich

Dans la nouvelle version de Android on notera en premier lieu, du point de vue utilisateur, l’amélioration du Look’n Feel et les fonctionnalités du « Multitasking ». La bonne nouvelle pour les développeurs est l’unification de la plateforme qui permet de développer une seule application pour tous les terminaux Android. Pour marquer le coup avec le succès des réseaux sociaux, de nouvelles API – Social API – sont ajoutées pour faciliter le partage des ressources sur Facebook, Google ou tweeter ou l’accès au profil utilisateur. Dans l’API Contacts, tout comme dans l’API Calendar, une nouvelle table et des permissions supplémentaires sont apparues. L’intégration du NFC pour la communication directe entre terminaux et les récentes couches de l’ « Accessibility Features » (la possibilité de faire une description vocale des éléments de l’écran) vont élargir le champ d’utilisation de la plateforme.

Les habitués de Swing, qui ont très tôt croisé le fer avec le TableLayout, apprécieront l’arrivée du Layout passe partout qu’est le GridLayout pour combler les limites du LinearLayout (défaut d’alignement).

(Android Open Source Project)

Daniel Fages est expert en construction de ROM Android, c’est lui qui a présenté le deuxième thème de la soirée, ASOP. D’abord pourquoi compiler Android ? Pour l’adapter à un usage spécifique, pour trouver d’éventuelles failles de sécurité, ou par simple curiosité. Le matériel nécessaire n’est pas à la portée de tout le monde, 16 Go RAM pour une durée de compilation de 30 minutes. Très peu de développeurs poussent leur audace aussi loin. En plus de la difficulté de maitriser la programmation système avec C/C++ il y a l’obstacle de la nature de la licence Apache et l’absence de communication de Google sur les orientations futures de son OS mobile.

Pour revivre la soirée avec beaucoup plus de détails les slides et les vidéos sont disponibles en ligne.

Je vais vous parler de deux sujets dans cet article :
- comment récupérer les informations concernant la musique stockée sur un téléphone android
- comment gérer un chargement en tâche de fond avec les Loader

Obtenir des informations sur vos fichiers musicaux :

Le framework android procède un ContentProvider qui fourni des informations sur la musique stockée sur l’appareil. Il est donc possible de l’interroger comme n’importe quel autre ContentProvider.
Vous trouverez toutes les constantes intéressantes dans les sous classes de MediaStore.Audio.
http://developer.android.com/reference/android/provider/MediaStore.Audio.html

Ce qui vous permettra d’avoir des informations sur les playlists, les genres musicaux, les albums, les artistes, etc…

Par exemple pour obtenir la liste de tous les artistes correspondant à votre musique. Il suffit de faire comme ceci :

public List<String> getArtistsNames(Activity act) {
	ArrayList<String> artists = new ArrayList<String>();

	String[] proj = { MediaStore.Audio.Artists.ARTIST };
	Cursor musicCursor = act.managedQuery(MediaStore.Audio.Artists.EXTERNAL_CONTENT_URI,proj, null, null, null);

	if(musicCursor.moveToFirst()) {
		do {
			String artistName = musicCursor.getString(0);
			artists.add(artistName);

			if( EtLog.isEnabled()) {
				EtLog.d(TAG,String.format("Identified Artist name is [%s]",artistName));
			}
		}
		while(musicCursor.moveToNext());
	}

	return artists;
}

Utiliser le LoaderManager pour gérer la recherche :

Nous allons utiliser une méthode disponible depuis une Activity ou un Fragment pour gérer un chargement en tâche de fonds.
Cette API a été ajoutée à partir du SDK 11, c’est à dire la version 3.0 (HoneyComb). Mais heureusement elle est disponible aussi sur les versions antérieures grâce au package de compatibilité dont j’ai déjà fait mention dans un article précédant.

Il y a plusieurs avantages à utiliser l’ API sur les Loader :
- Elle gère les chargements des données en asynchrone
- Elle gère le rafraîchissement des données
- Elle gère automatiquement le cycle de vie de telle sorte que le Loader n’est pas détruit/reconstruit à chaque changement de configuration

Le dernier point ici (gestion du cycle de vie) est très intéressant, car cela nous affranchit d’une tâche assez périlleuse. Je parle de la gestion d’une tâche asynchrone dans une activité, sans que la tâche soit perturbée par le cycle de vie de l’activité.

La classe LoaderManager est accessible directement depuis une Activity ou un Fragment grâce à la méthode getLoaderManager().

On peut remarquer dans les classes filles de Loader, qu’il existe une implémentation CursorLoader. Elle permet donc d’interroger un ContentProvider de manière asynchrone.
Il est possible cependant de créer son propre Loader en héritant de AsyncTaskLoader.

Pour créer un Loader il faut que votre Activity implémente LoaderManager.LoaderCallbacks, vous aurez donc 3 méthodes à implémenter :

public Loader<C> onCreateLoader(int id, Bundle args) ;
public void onLoadFinished(Loader<C> loader, C data);
public void onLoaderReset(Loader<C> loader);

onCreateLoader() ne sera appelé que si un nouveau Loader a besoin d’être créé. Cela n’est pas le cas lors d’un changement d’orientation puisque le LoaderManager se charge de déconnecter et reconnecter le Loader de l’Activity lors d’un changement de configuration.
onCreateFinished() : permet de récupérer le résultat d’un chargement.
onLoaderReset() est appelé lorsque que l’on quitte l’activité.

La dernière chose à laquelle il faut penser, c’est d’appeler la méthode initLoader.

initLoader (int id, Bundle args, LoaderCallbacks<D> callback)

Cette méthode ce charge de la création du Loader si besoin.
Vous remarquerez qu’il est possible de passer un id à cette méthode. Celui-ci sert à identifier le loader, car le LoaderManager peut gérer plusieurs loader.
On récupère donc cet identifiant dans la callback onCreateLoader().

Conclusion :

Voici un exemple d’utilisation d’un CusorLoader qui affiche la liste des artistes du Téléphone avec le nombre de musique associé à cet artiste.

public class CursorLoaderListFragment extends ListFragment implements LoaderManager.LoaderCallbacks<Cursor>{
	// Adapter utilisé pour afficher la liste
    SimpleCursorAdapter mAdapter;

    @Override public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        // On configure un texte à afficher si il n'y a pas de data
        setEmptyText("No artits music!");

        // On crée un adapter vide (le 3eme paramètre qui doit recevoir un Cursor est null)
        mAdapter = new SimpleCursorAdapter(getActivity(),
                android.R.layout.simple_list_item_2, null,
                new String []{  MediaStore.Audio.Artists.ARTIST , MediaStore.Audio.Artists.NUMBER_OF_ALBUMS},
                new int[] { android.R.id.text1, android.R.id.text2 }, 0);
        setListAdapter(mAdapter);

        // On affiche une progressbar en attendant
        setListShown(false);

        // Prépare le Loader: on se reconnect avec celui existant ou on en cré un nouveau et on le démarre
        getLoaderManager().initLoader(0, null, this);
    }

    // Ce sont sont les colonnes que l'on va recevoir
    static final String[] ARTIST_SUMMARY_PROJECTION = { MediaStore.Audio.Artists._ID, MediaStore.Audio.Artists.ARTIST , MediaStore.Audio.Artists.NUMBER_OF_ALBUMS};

    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
    	//Ceci est applelé lorsqu'on d'un nouveau Loader a besoin d'être créé.
    	//Cet exemple a besoin d'un seul Loader, donc nous ne nous occupons pas de l'ID.
    	//l'ID correspond à celui envoyé dans le 1er argument de la méthode getLoaderManager().initLoader(...)

        String select = null;
        return new CursorLoader(getActivity(), MediaStore.Audio.Artists.EXTERNAL_CONTENT_URI,
        		ARTIST_SUMMARY_PROJECTION, select, null,
                null);
    }

    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
    	//On change le Loader associé à l'adapter (Le framework s'occupe de fermer l'ancien Cursor)
        mAdapter.swapCursor(data);

        // On peut afficher la liste maintenant
        if (isResumed()) {
            setListShown(true);
        } else {
            setListShownNoAnimation(true);
        }
    }

    public void onLoaderReset(Loader<Cursor> loader) {

        mAdapter.swapCursor(null);
    }

Je voudrais vous parler d’une bibliothèque très pratique pour sauvegarder des données dans la base SQLite d’un téléphone Android. Cette bibliothèque s’appelle ORMLite.

Je vous ai déjà parlé d’une autre bibliothèque pratique pour faire un parsing JSON : JacksonPaser.
Les deux bibliothèques peuvent s’associer parfaitement, ce qui offre un bon socle pour commencer un projet Android.

Ormlite supporte les connections JDBC à MySQL, Postgres, H2, SQLite, Derby,
HSQLDB, Microsoft SQL Server.
Mais ce qui nous intéresse ici c’est qu’ORMLite supporte les appels natifs à la base de données SQLite sous Android.

Si vous avez déjà essayé de faire de la sauvegarde en base sous android, vous vous êtes sûrement aperçu combien c’est fastidieux.
Personnellement je ne trouve pas cela très pratique. Je préfère utiliser un ORM (Object Relational Mapping) qui fait un mapping entre mes objets métier et les enregistrements en base de données.

Certes on peut avoir des dégradations de performances, mais au vu du confort apporté au niveau de la programmation, le choix est vite fait.

Installation

Il faudra télécharger 2 fichiers jar, les déposer dans un répertoire lib et les ajouter dans le CLASSPATH.
Vous trouverez les 2 fichiers suivant ici http://ormlite.com/releases/

– ormlite-android-X.XX.jar
– ormlite-core-X.XX.jar

Les Annotations

Pour configurer le mapping objet on utilise des annotations.
Les annotations principales sont :
- @DatabaseTable
- @DatabaseField

L’annotation @DatabaseTable se dépose devant la déclaration d’une classe métier, et prend en paramètre le nom de table sur laquelle on veut faire le mapping.

@DatabaseTable(tableName = "le_nom_de_ma_table")

L’annotation @DatabaseField permet de configurer le mapping entre une colonne d’une table SQL, et le membre d’une classe.
@DatabaseField peut prendre plusieurs paramètres :

• columnName= « le_nom_de_ma_colonne » indique le nom de la colonne sur laquelle on fait le mapping
• generatedId = true/false : indique que le membre de la classe se correspond à un champ index auto-incrémenté
• canBeNull = true/false : indique si champ peut être null, et permet de générer des exceptions
• defaultValue = « 0″ : indique une valeur par défaut si le membre n’a pas été affecté avant l’enregistrement en base de l’objet.
• unique = true pour définir une colonne UNIQUE
• uniqueIndexName = « mon_ensemble_unique » permet de déclarer qu’un ensemble de membres est unique. C’est utile si on dépose l’annotation au moins sur 2 membres de la classe

Voici un exemple de classe métier annoté:

@DatabaseTable(tableName = "category")
public class Category extends DataEnveloppe implements Parcelable{

	public static final String   COLUMN_CATID         = "catID";

	@DatabaseField(generatedId=true)
	private int mRowid;

	@DatabaseField(columnName = COLUMN_CATID, canBeNull=false)
	private String mCatID;

	@DatabaseField(columnName = "title", canBeNull=false)
	private String mTitle;
....
}

Implémentation de OrmLiteSqliteOpenHelper

Vous aurez besoin de créer une classe qui hérite de OrmLiteSqliteOpenHelper.
Cette classe gère la création de la base à la première exécution, et gère la migration de la base lors des mises à jour de l’application.

Pour faire cette gestion, des callback sont appelés automatiquement, il faut implémenter les deux méthodes suivantes:
- onCreate(SQLiteDatabase sqliteDatabase, ConnectionSource
connectionSource)

- onUpgrade(SQLiteDatabase database, ConnectionSource
connectionSource, int oldVersion, int newVersion).

Pour créer les tables, il suffit d’appeler une méthode utilitaire qui va créer pour nous la table associé à une classe ; à condition d’avoir mis les annotations sur cette classe.

Par exemple :

public class DatabaseHelper extends OrmLiteSqliteOpenHelper {

	...
	@Override
	public void onCreate(SQLiteDatabase db, ConnectionSource connectionSource) {
		try {
			EtLog.d(TAG, "Tables created in %s", DATABASE_NAME);
			TableUtils.createTable(connectionSource, Category.class);
			TableUtils.createTable(connectionSource, MonObjetMetier.class);

		} catch (SQLException e) {
			Log.e(TAG, "Can't create database", e);
			throw new RuntimeException(e);
		}
	}
	...

Pour gérer la mise à jour voici un exemple d’implémentation. Attention dans cet exemple, on va supprimer la table et la recréer. Ce n’est pas toujours ce que l’on veut faire. Si on veut garder les données de l’application lors de la mise à jour, il faudra implémenter un algorithme de migration des données.

	@Override
	public void onUpgrade(SQLiteDatabase db, ConnectionSource connectionSource,
		int oldVersion, int newVersion) {
		try {
			TableUtils.dropTable(connectionSource, Category.class, true);
			onCreate(db);
		} catch (SQLException e) {
			Log.e(TAG, "Impossible to drop database", e);
			throw new RuntimeException(e);
		}
	}

Obtenir une instance de OpenHelperManager

Afin d’éviter d’ouvrir plusieurs connections simultanément à la même base, nous allons utiliser la classe OpenHelperManager qui va surveiller les utilisations du Helper.
Pour avoir un accès à une instance de OpenHelperManager il faut appeler getHelper() dans vos activités.
Pour avoir accès à cette méthode cela implique que vos activités doivent hériter de OrmLiteBaseActivity, OrmLiteBaseListActivity, OrmLiteBaseService, ou OrmLiteBaseTabActivity.

Cet héritage obligatoire peut être très contraignant. Notamment si vous utilisez une autre bibliothèque qui, elle aussi, demande à vos activités d’hériter d’une certaine classe.
Pour éviter de se retrouver bloqué ainsi, je vous conseille d’utiliser une autre méthode.
Il est possible de déclarer une classe comme OrmLiteSqliteOpenHelper avec la méthode statique suivante.

setOpenHelperClass(Class openHelperClass)

Il est nécessaire d’appeler cette méthode le plus tôt possible dans votre application, ainsi je recommande de le faire dans le onCreate() de votre classe Application.

Rappel:
Si vous ne le savez pas, il est possible d’avoir une instance qui représente le contexte de votre application. Il faut créer une classe qui hérite de Application et déclarer cette classe dans le manifeste. Je vous conseille de créer cette classe sous la forme d’un singleton.

    
...

Pensez à créer un assesseur pour obtenir l’instance au Helper il sera fournir par un appel à OpenHelperManager.getHelper()

Voilà ce que ça donne au niveau du code :

	private static MonApplication mInstance;
	private OrmLiteSqliteOpenHelper mOrmLiteHelper;

	@Override
	public void onCreate() {
		super.onCreate();
		mInstance = this;
        DataManager.getInstance().setApplicationContext(this);
        PreferencesManager.getInstance().setApplicationContext(this);
        FaceBookUtils.initContext(this);
        initData();
	}

	public static MonApplication getInstance() {
		return mInstance;
	}

	private void initData() {
        DataManager.getInstance().setOpenHelperClass(DatabaseHelper.class);
	}

	public OrmLiteSqliteOpenHelper getHelper() {

        if(mOrmLiteHelper == null) {
            mOrmLiteHelper = OpenHelperManager.getHelper(this);
        }
        return mOrmLiteHelper;
    }

	@Override
	public void onTerminate() {
		super.onTerminate();
		if (mOrmLiteHelper != null) {
			OpenHelperManager.releaseHelper();
		}
	}

Sauvegarder un objet métier

Ensuite pour faire un enregistrement d’une entité d’un objet métier, il suffit d’appeler la méthode save() que l’on aura implémenté comme ci-dessous dans notre classe métier :
Notez que c’est la même méthode pour un update ou un create .

	protected void save() throws SQLException {
		OrmLiteSqliteOpenHelper helper = getHelper();
		if (helper instanceof DatabaseHelper) {
			DatabaseHelper absHelper = (DatabaseHelper) helper;
			@SuppressWarnings("unchecked")
			Dao< MonObjetMetier, String> dao = (Dao< MonObjetMetier, String>) absHelper
					.getDao(getClass());
			dao.createOrUpdate(this);
		} else {
			Log.e("",
					"Object not created nor updated! Your Helper must inherit from AbstractDatabaseHelper.");
		}
	}

Et pour faire un select

Depuis l’objet Dao on appelle la méthode queryBuilder() pour obtenir un QueryBuilder ;
Ensuite il existe plusieurs méthodes utiles pour ajouter une clause WHERE, un LIMIT ou un ORDER BY.

Pour construite une clause WHERE il faudra utiliser également les méthodes disponibles depuis l’objet Where comme dans l’exemple ci-dessous.

public List getListCategoryFromDb() {
	List categoryListFromCache = new ArrayList();
	try {

		QueryBuilder queryBuilder = getDao().queryBuilder();

		@SuppressWarnings("rawtypes")
		Where where = queryBuilder.where();
		where.eq(Category.COLUMN_SUB_CAT, "1"); // Categorie de niveau 1

		PreparedQuery preparedQuery = queryBuilder.prepare();
		categoryListFromCache = getDao().query(preparedQuery);
		setList(categoryListFromCache);
	} catch (Exception e) {
		// TODO: handle exception
	}
	return categoryListFromCache;
}

Conclusion

Avec cette bibliothèque, une fois la classe OrmLiteSqliteOpenHelper implémentée, il ne vous reste plus beaucoup de lignes de code à écrire pour faire de l’enregistrement en base de donnée.
La méthode save() peut même être unifiée dans une classe parente de toutes vos classes métier(que vous avez besoin d’enregistrer en base).

Je vais vous parler d’une librairie très pratique dans les projets Android, lorsque vous avez besoin d’interroger des services JSON.

Cette librairie permet de transformer (on dit dé-sérialiser) le flux JSON en objet métier.
On verra à la fin de cet article que l’on peut même faire l’inverse : c’est à dire transformer (dans ce cas on dit sérialiser) un objet métier en flux JSON.

Cette librairie s’appelle JacksonParser. Elle peut s’utiliser sur Android mais aussi dans projet JAVA standard.
Il existe évidemment d’autres librairies mais les avantages de JacksonParser sont :
– sa vélocité
– ses possibilités de configuration
– c’est open-source

Un petit rappel sur ce qu’est JSON:
JSON est un format d’échange de données,
– facile à écrire et à lire
– c’est un format léger
– facilement analysable par un programme

Je vous invite à vous rendre ici : http://jackson.codehaus.org/

et à télécharger
– jackson-core-asl-X.X.X.jar
– jackson-mapper-asl-X.X.X.jar

Une fois ceci fait il faut inclure les 2 fichiers jar dans votre projet et les ajouter au CLASSPATH.

Ensuite je vous conseille de construire vos objets métiers en fonction de la structure du flux JSON que vous lisez.

Voici l’exemple d’un flux JSON

{
	"typeList": "",
	"collabo": [
		{
			"nom": "Abdennadher", "prenom": "Walid"
		},
		{
			"nom": "Hocq", 	"prenom": "Sylvain"
		}

	]
}

Et voici comment j’ai créé mes objets métiers pour ce flux.

public class CollaborateurList {
	private List listCollabo;

	public List getListCollabo() {
		return listCollabo;
	}

	@JsonProperty("collabo")
	public void setListCollabo(List listCollabo) {
		this.listCollabo = listCollabo;
}} 

public class Collabo {
	String nom;
	@JsonProperty("prenom")
String prenom;

	@JsonProperty("nom")
	public void setNom(String nom) {  this.nom = nom; }

}

Le mapping entre flux JSON et objet métier, se configure à l’aide d’annotations.
Ici j’utilise uniquement l’annotation @JsonProperty.
Si vous avez bien regardé l’exemple ci-dessus, vous remarquerez que l’on peut poser ces annotations sur des setters mais aussi directement sur des propriétés (voir la propriété prénom ).

L’avantage de passer par des setters, c’est de pouvoir faire des conversions, par exemple: convertir une chaîne de caractères en date avant d’affecter un attribut de l’objet. Le désavantage c’est que c’est un peu plus verbeux…

Une fois les classes métier créées et configurées, il faut créer un objet ObjectMapper comme ceci :

	private static ObjectMapper sMapper = new ObjectMapper();
	static {
		sMapper.configure(Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
	}

Ici on configure le mapper pour qu’il ignore les propriétés sur lesquelles on n’a pas configuré de mapping. Sans cela on aurait une erreur.

Ensuite il n’y a plus qu’à appeler la méthode readValue avec le flux en paramètre et le type d’objet attendu.

String collaboJson = "";
CollaborateurList collaboList = null;
try {
	collaboJson = StreamUtils.inputStreamToString(getAssets().open("collabo.json"));
	collaboList = sMapper.readValue(collaboJson,CollaborateurList.class);
} catch (JsonParseException e) {
	e.printStackTrace();
} 

Remarque sur le type de retour

Dans notre exemple le flux commence par une structure c’est à dire une accolade {
Il faut dans ce cas spécifier le type de retour attendu : ici CollaborateurList.class

Si on a un flux commençant directement par un tableau c’est à dire par un [
Par exemple avec le flux suivant :

[
		{
			"nom": "Abdennadher", "prenom": "Walid"
		},
		{
			"nom": "Hocq", 	"prenom": "Sylvain"
		}

]

Dans ce cas on peut utiliser la manière suivante pour faire l’appel à readValue() :

Listlist = sMapper.readValue(collaboJson, new TypeReference>() { });

Et si on veut sérialiser...

Il est possible que vous souhaitiez faire le traitement inverse. Par exemple si vous avez déjà des instances d’objets métiers et que vous souhaitez les convertir en une chaîne JSON, pour par exemple les envoyer dans une requête HTTP POST.
Et bien dans ce cas, il suffit d’appeler la méthode writeValueAsString.

String json = sMapper.writeValueAsString(collaboList);

Dans ce cas il n’y a pas de complication, si l’objet à sérialiser est une liste d’objet métier ou une structure d’objet métier.

Si vous désirez utiliser des annotations sur des méthodes plutôt que sur des attributs (pour faire une transformation en amont par exemple). Il faudra, dans ce cas, déposer des annotations sur les getters.

Résumé :

Un petit résumé pour bien comprendre quand utiliser des getters et setters.
Avant tout, cela est nécessaire uniquement si vous avez besoin de faire une transformation, par exemple convertir une chaîne de caractères en type Date.

Si c’est le cas, il faut bien comprendre ceci: pour sérialiser, le parser à besoin de récupérer les propriétés des objets métier, donc il utilise les getters, donc il faut annoter les getters.
Et pour dé-sérialiser, le parser à besoin d’affecter les propriétés des objets métiers, donc il utilise les setters, qu’il faut annoter.

J’en ai fais l’expérience hier, un moment où l’on se repasse mentalement tous ses mails des 20 dernières années.

Ainsi, il m’arrive très souvent d’écrire des choses comme :

« préparation du cours => je ne viendrai pas sur paris la semaine prochaine »

J’ai découvert hier que le symbole « => » n’est pas nécessairement compris comme l’implication logique par tout le monde.
Quand on relis ce que j’ai écris en traduisant le « => » comme une simple version plus esthétique de la flèche « -> » ou par « faire » ça devient effectivement peu logique.

« préparation du cours : faire : je ne viendrai pas sur paris la semaine prochaine » ça ne veut rien dire.

En discutant un peu, on se rend compte que certains traduisent ce symbole par « donc, conséquence, … » mais effectivement l’implication logique ça relève plutôt des études informatiques (ou peut-être en philosophie).

Dorénavant, je ferai bien plus attention quand j’écrirai mes mails.

Qu’est-ce que SQLite ?

En gros, c’est une base de données légère intégrée au programme stockée dans un fichier.

Plus d’informations sur le site officiel et sur wikipedia.

L’intérêt est donc d’avoir peu de données à mettre dans notre base embarquée car une app trop lourde est souvent rédhibitoire pour une installation sur iPhone.

Je conseillerai de ne pas dépasser les 100 ko pour rester cohérent.

Comment fait-on alors ?

Et bien par chance, SQLite est déjà installée sous Mac !

Pour vérifier, tapez dans le terminal :

sqlite3 -version

Nous allons donc créer une base de données tuto.db avec une table Objet ayant pour champs num et forme, toujours dans le terminal :

sqlite3 tuto.db

puis

Si vous voulez encore vous amusez avec SQLite, tapez .help pour afficher les commandes sinon tapez .quit ou .exit.

Et voilà, nous avons un joli fichier tuto.db à l’endroit où vous avez ouvert le terminal (généralement votre répertoire personnel).

Ouvrez votre projet PageTrick (cf lien plus haut) et glissez/déposez-y votre fichier.
Ajoutez-y également la bibliothèque libsqlite3.0.dylib :
- cliquez sur votre projet dans le menu contextuel
- cliquez sur Targets puis sur Build Phases
- cliquez sur le + du sous-menu Link Binaries With Library
- dans la barre de recherche tapez libsqlite
- déroulez les résultats vous devriez avoir libsqlite3.0.dylib (ne vous trompez pas il y en a deux, l’autre c’est libsqlite3.dylib)
- c’est bon !

Génial et maintenant comment s’en sert-on ? C’est à ce moment que l’on doit faire un choix, en effet SQLite étant une bibliothèque écrite en C, il va falloir insérer des appels de fonction C dans notre joli code Objective-C… pas glop (personnellement) MAIS on peut utiliser un petit framework (2 classes) créer par Th30z et disponible sur GitHub.

Dézippez l’archive et glissez/déposez Sqlite.h et Sqlite.m dans votre projet.

Attention si vous êtes dans un projet avec ARC (Automatic Reference Counting) activé – il faut modifier un peu le Sqlite.m mais c’est trois fois rien :
- supprimez tous les autorelease, retain, release qui traînent
- remplacez la ligne 32 par :

Plus de détails sur ce cast sur clang.llvm.org.

Maintenant vous pouvez utiliser l’objet Sqlite dans votre code.

Dans votre storyboard, déposer un UITableViewController et faîtes un segue depuis un bouton « clickSQLite » (le sosie du bouton « click » du PageTrickController) vers lui et n’oubliez pas de donner un identifiant au segue.

Voici ce que vous devriez avoir modulo les préférences esthétiques de chacun :

Créez une nouvelle classe (UIViewController class) héritant de UITableViewController et appelez la TablePageCurlController par exemple.

Ensuite on reprend le même principe de délégation vu dans mon billet précédent sauf que l’on va créer un fichier pour le protocole genre PageCurlDelegate.h :

on n’oublie pas de synthétiser !

on complète les méthodes de notre contrôleur :

puis dans PageTrickController, on ajoute une propriété tablePage de type TablePageCurlController et on modifie :

Alors heureux ?
« Aaaargh mais nan, on ne voit pas la tableView !!!! »

Ah oui, c’est vrai la tableView est en partie masquée par l’animation et du coup c’est moche.
Rajoutez ceci dans le viewDidAppear de votre TablePageCurlController :

Et voilà deux belles animations pour le prix d’une !

Si vous avez déjà essayé de créer une application sans avoir de machine android physique, vous avez certainement dû éprouver quelques frustrations face à la lenteur de l’émulateur android proposé de base avec le SDK Android.
Si c’est vrai pour faire du développement sur Android 2.x, ça l’est encore plus sur tablette.
L’émulateur HoneyComb est inutilisable, ça rame énormément même avec un corei7, et 8Go de RAM…

En fait le problème c’est que l’émulateur reproduit le comportement d’un processeur ARM, or les PC ont des architectures X86. Sur Apple il n’y a pas de problème car l’iPhone et l’iMac possèdent la même architecture, donc pas besoin de reproduire le comportement du processeur puisque que c’est le même. On parle dans ce cas de simulateur et non plus d’émulateur.
Définition et comparaison wikipédia ici : http://fr.wikipedia.org/wiki/%C3%89mulation.

Heureusement il existe un portage d’android, vers des architectures X86.

Ainsi il est possible d’installer android directement sur un PC avec des archi X86. Sur le site ont retrouve les versions d’android 2.3, 3.0 et même 4.0 en développement.
Chacune de ces versions est déclinée en plusieurs types d’archi : eeepc, AMD brazos, asus laptop, tega v2.

Le but pour nous, c’est d’avoir l’équivalent d’un émulateur HoneyComb, on va donc installer une de ces versions sur une machine virtuelle. On utilisera VirtualBox :
https://www.virtualbox.org/wiki/Downloads

Voilà donc comment procéder pour installer une machine virtuelle qui tourne sous android.

1. Installer VirtualBox

2. Créer une machine virtuelle :

On lui configurera 1Go de RAM, un disque dur (2ou 3 Go devraient suffire), une mémoire video de 8mo(c’est la valeur par défaut), et une carte réseau de type PCnet-FAST III avec un accès par pont.

3. Je vous conseille, si vous pouvez, d’utiliser 2 souris

(dont une dédiée à la machine virtuelle). En effet j’ai l’impression que la gestion de la souris et moins bien gérée que pour les autres systèmes…
Dans l’onglet USB, ajoutez un filtre depuis un périphérique et ajoutez-lui une des 2 souris.

4. Ajouter l’iso que vous avez télécharger depuis le site Android-X86,

dans le lecteur CD de la machine virtuelle.
https://www.virtualbox.org/wiki/Downloads
Je vous conseille de prendre la version eeepc. Dans mon cas pour avoir un HoneyComb, j’ai pris la version : android-x86-3.2-RC2-eeepc.iso

5. Démarrer la machine,

lancer l’installation et suivre les étapes.

Personnellement j’ai formaté le disque en deux partitions, comme sur la plupart des téléphones. Et j’ai créé une carte SD virtuelle comme proposé par l’outil à la dernière étape.

6. A la fin de l’installation, avant de redémarrer, pensez à éjecter l’ISO du lecteur CD.

7. Vous remarquerez que le système démarre rapidement et qu’il est super fluide

. Il est même plus fluide que sur n’importe quelle tablette !!!

8. Il faudra configurer le réseau manuellement.

Pour cela faire un ALT+F1, pour afficher un terminal avec une console.
Récupérer l’adresse IP de votre DNS, à l’aide de la commande

ipconfig /all

sur une commande DOS sous windows.
Vérifiez que vous avez bien une interface eth0 à l’aide de la commande

# netcfg

Si ce n’est pas le cas, alors, il y a un problème dans la configuration de la carte réseau de votre machine virtuelle.

Ensuite taper ces trois commandes (en remplaçant YOUR_DNS_SERVER_IP):

# netcfg eth0 up
# dhcpcd
# setprop net.dns1 YOUR_DNS_SERVER_IP

La combinaison de touche ALT+F7 permet de retrouver l’interface graphique. Et l’accès Internet devrait fonctionner.

Les limitations:

On a quand même quelques contraintes avec cet émulateur.
Certaines ne sont pas très gênantes : on a un clavier qwerty.
D’autres le sont plus : on ne peut pas simuler la rotation de l’écran, c’est vraiment gênant surtout quand on connaît le système de destruction, re-construction d’une activity.
Sans la gestion de l’orientation, on a pas de moyen facile de tester si on a bien géré le cycle de vie…
Et entre autres, on ne peut pas simuler un GPS, ni des appels téléphoniques.

On voit bien que même avec cette solution, il est quand même préférable d’utiliser un appareil physique.

Et si Google nous proposait un simulateur android x86, ce ne serait pas une bonne idée ? … Si c’était le cas, ce serat sûrement mieux intégré qu’une VirtualBox, et on n’aurait pas nécessairement besoin d’une tablette par développeur pour faire des applications HoneyComb ou IceCreamSandwitch.
En plus, rappelez-vous, quand on créé un device Android Virtuelle (AVD), depuis le SDK Tool, Google a prévu un champ pour choisir l’architecture. Ce champ s’appelle CPU/ABI mais on a toujours qu’un seul choix possible…
On peut espérer que Google nous dira « Coming Soon ! » car Intel monte un prototype de smartphone androidX86 en partenariat avec Google…

http://www.01net.com/editorial/551324/intel-montre-un-prototype-de-smartphone-android-x86-sous-medfield/

http://www.frandroid.com/actualites-generales/88941_lg-presentera-au-ces-le-premier-smartphone-android-avec-un-processeur-intel/