Données

a. Classe Personne

Dans un nouveau projet Flutter, un fichier nommé personne.dart contenant une classe intitulée Personne est créé dans le dossier lib. Elle comprend trois attributs (nom, prénom et âge), un constructeur et les accesseurs.

class Personne { 
 String _nom; 
 String _prenom; 
 String _age; 
 
 Personne(this._nom, this._prenom, this._age); 
 
 String get age => _age; 
 
 set age(String value) { 
   _age = value; 
 } 
 
 String get prenom => _prenom; 
 
 set prenom(String value) { 
   _prenom = value; 
 } 
 
 String get nom => _nom; 
 
 set nom(String value) { 
   _nom = value; 
 } 
} 

Cette classe servira de support à la création d’une nouvelle personne qui sera utilisée...

a. Classe Personne

Dans le dossier lib, un fichier nommé personne.dart est créé.

L’application s’appuiera donc sur la classe Personne qui y est décrite :

final String tablePersonne = 'personne'; 
final String colonneId = 'id'; 
final String colonneNom = 'nom';  
final String colonnePrenom = 'prenom'; 
final String colonneAge = 'age'; 
 
class Personne { 
 int id; 
 String nom; 
 String prenom; 
 String age; 
 
 Personne(); 
 
 Personne.fromMap(Map<String, dynamic> map) { 
   id = map[colonneId]; 
   nom = map[colonneNom]; 
   prenom = map[colonnePrenom]; 
   age = map[colonneAge]; 
 } 
 
 Map<String, dynamic> toMap() { 
   var map = <String, dynamic>{ 
     colonneNom: nom, 
     colonnePrenom: prenom, 
     colonneAge: age 
   }; 
   if (id != null) { 
     map[colonneId] = id; 
   } 
   return map; 
 } 
} 

La classe prend une forme un peu différente que celle présentée dans l’exemple précédent. Dans le fichier, pour simplifier le code présenté, deux classes vont être intégrées. La première est donc Personne. La seconde sera dévoilée juste après. En tout état de cause, ces deux classes vont utiliser des informations communes qui sont placées en début de fichier. Elles correspondent aux éléments SQL comme le nom de la table, celui des colonnes…

La classe Personne est dotée d’un attribut supplémentaire, id, qui servira de clé primaire lors du stockage. Comme cette fois l’objectif va être de stocker des valeurs au sein de colonnes, l’utilisation d’une Map est plus judicieuse. Elle permet d’associer un couple clé/valeur. La clé correspondra au nom de la colonne. 

Pour manipuler cette Map, deux méthodes sont prévues. Une première (toMap) servira à la lecture des informations contenues dans les attributs et renverra le tout sous la forme de l’objet map. La seconde (Personne.fromMap) aura pour but d’affecter les valeurs contenues dans l’objet map aux attributs de Personne. Elle agira donc comme un constructeur nommé.

Noter que dans la méthode toMap une condition est posée sur l’id. En effet, au moment où l’on voudra récupérer les informations contenues dans une instance, la valeur pour id ne sera pas toujours renseignée. Elle le sera si les données ont été insérées dans la base SQLite puisqu’elle sera générée automatiquement par celle-ci.

b. Classe PersonneProvider

L’autre classe contenue dans ce fichier va être la pierre angulaire de la manipulation de la base de données. Elle est donc assez technique. Elle est nommée PersonneProvider.

Pour faciliter son utilisation, une variante du design pattern Singleton est mise en place. Cette pratique courante consiste à doter la classe d’un constructeur privé, inaccessible donc de l’extérieur.

PersonneProvider._privateConstructor(); 
 
static final PersonneProvider instance = 
   PersonneProvider._privateConstructor(); 

Ici, le pattern n’est que partiellement respecté pour simplifier les choses. L’avantage de cette syntaxe est de pouvoir faire s’exécuter le contrôleur directement ici via l’appel à instance. En appelant instance ailleurs, ce qui est possible car la variable est static, le constructeur va s’exécuter. Ainsi, que ce soit ici, dans PersonneProvider, ou dans une autre classe où instance est appelée, c’est la même instance qui sera manipulée.

Au-delà, dans le fichier qui contient les classes Personne et PersonneProvider, plusieurs variables avaient été déclarées de manière globale pour profiter aux deux classes.

Il convient d’en rajouter deux :

final String databaseName = 'PersonneDB.db'; 
final int databaseVersion = 1; 

Il s’agit du nom de la base de données ainsi que son numéro de version.

Maintenant, plusieurs choses restent à prévoir. Il faut, dans un premier temps, initialiser la base de données. Et pour cela, il nous faut une base :

Database _db; 

Cette base de données est privée. Elle ne pourra donc pas être appelée en dehors de cette classe. Pour travailler avec, il faut mettre en place un getter qui, outre le fait de pouvoir récupérer la valeur de la variable _db, gérera son initialisation :

Future<Database> get db async { 
 if (_db != null) { 
   return _db; 
 } else { 
   _db = await _initDatabase(); 
   return _db; 
 } 
} 

La condition vérifie si la base est initialisée. Si elle l’est, alors la valeur de _db est retournée. Si elle ne l’est pas, la méthode _initDatabase est exécutée.

Voici cette méthode qui sera expliquée juste après :

_initDatabase() async { 
 Directory documentsDirectory = await getApplicationDocumentsDirectory(); 
 String path = join(documentsDirectory.path, databaseName); 
 return await openDatabase(path, version: databaseVersion, onCreate: _open); 
} 

En se servant de path_provider, il est possible de récupérer le chemin de notre application :

Directory documentsDirectory = await getApplicationDocumentsDirectory(); 

À partir de là, grâce à la fonctionnalité join de path, ce chemin est complété par le nom de la base de données :

String path = join(documentsDirectory.path, databaseName); 

Il ne reste plus qu’à exécuter la méthode openDatabase qui prend trois paramètres : le chemin de la base (path), la version de la base de données et enfin une méthode pour sa création (onCreate). Cette dernière méthode est, dans l’exemple, _open.

Future _open(Database db, int version) async { 
 await db.execute(''' 
   create table $tablePersonne ( 
   $colonneId integer primary key autoincrement, 
   $colonneNom text, 
   $colonnePrenom text, 
   $colonneAge text) 
   '''); 
} 

La méthode _open crée la table personne dans la base de données. Celle-ci comportera quatre colonnes. La première, pour l’identifiant (id), est la clé primaire et sera auto-incrémentée. Les autres sont simplement du texte.

La configuration est presque terminée. Puisque l’ouverture de la base est réalisée, il faut prévoir l’inverse, c’est-à-dire la fermeture. Une méthode intitulée close est ajoutée :

Future close() async => _db.close(); 

La base de données est donc opérationnelle à partir de là. Néanmoins, il reste à prévoir les différentes fonctionnalités attendues. Pour l’application qui nous concerne, il faudra que des données puissent être enregistrées. Par la suite, il devra être possible de les lire. Et enfin, il sera nécessaire de prévoir leur suppression. 

Pour l’enregistrement des informations, une méthode nommée insert est intégrée :

Future<int> insert(Personne personne) async { 
 Database db = awaitinstance.db; 
 int id = await db.insert(tablePersonne, personne.toMap()); 
 return id; 
} 

Insert est de type Future. Son traitement est évidemment asynchrone. La première étape consiste à appeler le getter de _db grâce à instance. Sur cette instance de Database il devient possible alors d’appeler la méthode insert. Elle attend deux paramètres. Le premier doit indiquer la table qui est concernée par l’insertion. Le second apporte les données à insérer. Ici, ces données sont fournies sous la forme d’une Map. Cela s’avère très pratique puisque les noms de clés correspondent aux noms des colonnes de la table. La clé primaire étant auto-incrémentée, le retour de la méthode insert sera l’id qui prend la forme d’un entier.

La seconde fonctionnalité importante doit permettre de lire les données contenues dans la table. Plus précisément, de lire la dernière donnée enregistrée puisque c’est ce que l’application requiert. Voici cette méthode :

Future<Personne> getPersonne(int id) async { 
 Database db = awaitinstance.db; 
 List<Map> maps = await db.query(tablePersonne, 
     columns: [colonneId, colonneNom, colonnePrenom, colonneAge], 
     where: '$colonneId = ?', 
     whereArgs: [id]); 
 if (maps.length > 0) { 
   return Personne.fromMap(maps.first); 
 } 
 return null; 
} 

Le début ressemble à insert. C’est une méthode asynchrone qui dans un premier temps fait appel au getter de _db. La différence principale réside dans la récupération d’un paramètre. Il s’agit d’un numéro d’identifiant (id) qui va permettre de rechercher parmi l’ensemble des enregistrements contenus dans la table celui qui correspond.

Le retour attendu est une liste d’objets de type Map, chacun d’eux correspondant à une Personne.

La méthode query de Database permet d’indiquer plusieurs paramètres :

Enfin, une condition permet de vérifier qu’il existe bien au moins une correspondance dans la table. Si c’est le cas, Personne.fromMap est utilisée pour construire une Personne à partir du premier résultat obtenu.

Sinon, null est renvoyé.

La dernière fonctionnalité attendue de la base dans notre exemple est de pouvoir effacer une entrée. Une méthode nommée delete est donc créée à cet effet :

Future<int> delete(int id) async { 
 Database db = awaitinstance.db; 
 return await db 
     .delete(tablePersonne, where: '$colonneId = ?', whereArgs: [id]); 
} 

Encore une fois, il s’agit d’une méthode asynchrone. La première étape consiste toujours à récupérer une instance de Database. Le but est d’appeler sur cette dernière la méthode delete. Les paramètres attendus sont les mêmes que pour query. D’abord, le nom de la table. Puis une clause where avec les arguments de celle-ci dans le paramètre whereArgs. L’argument en question est encore une fois l’id.

Dans la mesure où cette classe est assez complexe, voici, en récapitulatif, son code complet (accompagné de celui de Personne qui se trouve avec) :

import 'dart:io'; 
import 'package:path/path.dart'; 
import 'package:path_provider/path_provider.dart'; 
import 'package:sqflite/sqflite.dart'; 
 
final String tablePersonne = 'personne'; 
final String colonneId = 'id'; 
final String colonneNom = 'nom'; 
final String colonnePrenom = 'prenom'; 
final String colonneAge = 'age'; 
 
final String databaseName = 'PersonneDB.db'; 
final int databaseVersion = 1; 
 
class Personne { 
 int id; 
 String nom; 
 String prenom; ...