Mise en place de la base SQLite - ListViewJson

On va voir maintenant la mise en place de la base de donnée interne de l'application de la class java, à la datasource en passant par le SQLiteOpenHelper.

La classe Contact

La classe contact contiendra tout les champs de notre base de donnée SQLite. Elle se crée comme une classe Java classique :

com.androiddev.listviewjson/Contact.java

package com.androiddev.listviewjson; public class Contact { private long id; private String nom; private String prenom; private String mail; private String adresse; private String telPerso; private String telPro; private long idContact; public long getIdContact() { return idContact; } public void setIdContact(long idContact) { this.idContact = idContact; } public long getId() { return id; } public void setId(long 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; } public String getMail() { return mail; } public void setMail(String mail) { this.mail = mail; } public String getAdresse() { return adresse; } public void setAdresse(String adresse) { this.adresse = adresse; } public String getTelPerso() { return telPerso; } public void setTelPerso(String telPerso) { this.telPerso = telPerso; } public String getTelPro() { return telPro; } public void setTelPro(String telPro) { this.telPro = telPro; } @Override public String toString() { return nom +' '+prenom; } }

Rien de bien compliqué : on crée nos attributs avec leurs getter/setter ainsi que la fonction toString().

SQLiteOpenHelper

On doit ensuite crée notre classe qui étend SQLiteOpenHelper. Son objectif est de gérer la création et la mise à jour de la structure de la base de donnée mais aussi la liaison avec la classe contact et le datasource que l'on créera ensuite.

com.androiddev.listviewjson/MySQLiteHelper.java

package com.androiddev.listviewjson; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.util.Log; class MySQLiteHelper extends SQLiteOpenHelper { public static final String TABLE_CONTACT = "contact"; public static final String COLUMN_ID = "id"; public static final String COLUMN_NOM = "nom"; public static final String COLUMN_PRENOM = "prenom"; public static final String COLUMN_MAIL = "mail"; public static final String COLUMN_ADRESSE = "adresse"; public static final String COLUMN_PHONE_PRO = "phone_pro"; public static final String COLUMN_PHONE_PERSO = "phone_perso"; public static final String COLUMN_ID_CONTACT = "id_contact"; private static final String DATABASE_NAME = "contact.db"; private static final int DATABASE_VERSION = 1; private static final String DATABASE_CREATE = "create table " + TABLE_CONTACT + "(" + COLUMN_ID + " integer primary key autoincrement, " + COLUMN_NOM + " text not null, " + COLUMN_PRENOM + " text not null, " + COLUMN_MAIL + " text not null, " + COLUMN_ADRESSE + " text not null, " + COLUMN_PHONE_PRO + " text not null, " + COLUMN_PHONE_PERSO + " text not null, " + COLUMN_ID_CONTACT + " integer);"; public MySQLiteHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); } @Override public void onCreate(SQLiteDatabase database) { database.execSQL(DATABASE_CREATE); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { Log.w(MySQLiteHelper.class.getName(), "Upgrading database from version " + oldVersion + " to " + newVersion + ", which will destroy all old data"); db.execSQL("DROP TABLE IF EXISTS " + TABLE_CONTACT); onCreate(db); } }

Implémenter la classe SQLiteOpenHelper impose d'utiliser le constructeur, et les fonctions onCreate et onUpgrade. On déclare aussi tout nos champs de base de donnée, on donne un nom de fichier, un numéro de version mais aussi la requête de création de la base de donnée.

Le constructeur, à travers de la méthode super, appelle soit la faction onCreate ou onUpgrade au cas où la BDD n'existe pas ou n'est pas à jour.

ContactsDataSource

La classe ContactsDataSource est une classe Java qui va s'occuper de toute les opérations CRUD (lecture, écriture, mise à jour et suppression) sur notre BDD.

On créer tout d'abord notre classe ContactsDataSource.java dans le package com.androiddev.listviewjson :

package com.androiddev.listviewjson; import java.util.ArrayList; import java.util.List; import android.content.ContentValues; import android.content.Context; import android.database.Cursor; import android.database.SQLException; import android.database.sqlite.SQLiteDatabase; public class ContactsDataSource { // Database fields private SQLiteDatabase database; private MySQLiteHelper dbHelper; private String[] allColumns = { MySQLiteHelper.COLUMN_ID, MySQLiteHelper.COLUMN_NOM, MySQLiteHelper.COLUMN_PRENOM, MySQLiteHelper.COLUMN_MAIL, MySQLiteHelper.COLUMN_ADRESSE, MySQLiteHelper.COLUMN_PHONE_PERSO, MySQLiteHelper.COLUMN_PHONE_PRO, MySQLiteHelper.COLUMN_ID_CONTACT }; public ContactsDataSource(Context context) { dbHelper = new MySQLiteHelper(context); } public void open() throws SQLException { database = dbHelper.getWritableDatabase(); } public void close() { dbHelper.close(); } }

On place tout les imports qui nous seront nécessaire, ainsi que des attributs. Trois attributs dont le premier qui est une instance de SQLiteDatabase, utiliser pour réaliser des requête. Le deuxième est simplement une instance de notre classe créée précédement, MySQLiteHelper et le troisième est un tableau de chaîne de caractère qui contient tout les champs qui nous seront utile.

Ensuite dans le constructeur on créer notre dbHelper qui est un objet MySQLiteHelper  en lui passant le context en paramètre.

Puis on créer deux fonctions open et close qui auront pour objectif d'ouvrir en écriture et de fermer la connexion à la base de donnée.

Création d'un contact

On place maintenant notre fonction de création de Contact (qui correspond à l'insertion de celui-ci dans la base de donnée).

ContactsDataSource.java

... public class ContactsDataSource { ... public Contact createContact(String nom, String prenom, String mail, String adresse, String phonePerso, String phonePro, Long idContact) { Boolean exist = existContactWithId(idContact); if(exist == true){ Contact existContact = getContactWithId(idContact); Contact updatedContact = updateContact(idContact, existContact); return updatedContact; } else { ContentValues values = new ContentValues(); values.put(MySQLiteHelper.COLUMN_NOM, nom); values.put(MySQLiteHelper.COLUMN_PRENOM, prenom); values.put(MySQLiteHelper.COLUMN_MAIL, mail); values.put(MySQLiteHelper.COLUMN_ADRESSE, adresse); values.put(MySQLiteHelper.COLUMN_PHONE_PERSO, phonePerso); values.put(MySQLiteHelper.COLUMN_PHONE_PRO, phonePro); values.put(MySQLiteHelper.COLUMN_ID_CONTACT, idContact); long insertId = database.insert(MySQLiteHelper.TABLE_CONTACT, null, values); Cursor cursor = database.query(MySQLiteHelper.TABLE_CONTACT, allColumns, MySQLiteHelper.COLUMN_ID + " = " + insertId, null, null, null, null); cursor.moveToFirst(); Contact newContact = cursorToContact(cursor); cursor.close(); return newContact; } } ... }

Cette fonction createContact appel dés le départ une autre fonction (existContactWithId) dont le but est de vérifier si le contact existe déjà. Si c'est le cas on appel la fonction de mise à jour (updateContact). Sinon on réalise l'insertion.

1. L'insertion se réalise en utilisant un objet de type ContentValues. C'est un objet fournit par le SDK Android qui est totalement personnalisable. C'est à dire qu'a la base il est vide mais qu'on peut lui ajouté les attributs que l'on souhaite :
   values.put(MySQLiteHelper.COLUMN_NOM, nom);
   values étant notre ContentValues, on lui ajoute un attribut aillant le nom de la COLUMN_NOM de la BDD ('nom') avec en valeur le nom du contact à insérer.
2. Ensuite on exécute la requète d'insertion avec database.insert qui prend en paramètre le nom de la table, la valeur par défaut et le ContentValues. Cette fonction retourne l'ID de la ligne insérer.
3. Avec l'id retourné on recherche dans la BDD le Contact pour ensuite le retourné. A noté que query retourne un Cursor donc il faut le convertir en objet Contact, c'est l'objectif de la fonction cursorToContact.

Mise à jour d'un contact

La fonction de  mise à jour sera plus simple.

ContactsDataSource.java

... public class ContactsDataSource { ... public Contact updateContact(Long id, Contact contact){ ContentValues values = new ContentValues(); values.put(MySQLiteHelper.COLUMN_NOM, contact.getNom()); values.put(MySQLiteHelper.COLUMN_PRENOM, contact.getPrenom()); values.put(MySQLiteHelper.COLUMN_MAIL, contact.getMail()); values.put(MySQLiteHelper.COLUMN_ADRESSE, contact.getAdresse()); values.put(MySQLiteHelper.COLUMN_PHONE_PERSO, contact.getTelPerso()); values.put(MySQLiteHelper.COLUMN_PHONE_PRO, contact.getTelPro()); database.update(MySQLiteHelper.TABLE_CONTACT, values, MySQLiteHelper.COLUMN_ID_CONTACT + " = " +contact.getId(), null); return getContactWithId(contact.getIdContact()); } ... }

updateContact prend en paramètre l'ID de l'enregistrement a modifié de la BDD et le Contact à mettre à jour.

1. Cette fonction va comme pour l'insertion, utilisé un ContentValues.
2. Ensuite on exécute la requète de mise à jour database.update qui prend en paramètre le nom de la table, le ContentValues, la condition Where et les valeurs de paramètre Where si nécessaire.
3. On returne le Contact modifié avec la fonction que l'on créera ultérieurement getContactWithId.

Récupérer un contact

On passe maintenant à la fonction de récupération d'un Contact avec un id.

ContactsDataSource.java

... public class ContactsDataSource { ... public Contact getContactWithId(Long id){ Cursor c = database.query(MySQLiteHelper.TABLE_CONTACT, allColumns, MySQLiteHelper.COLUMN_ID_CONTACT + " = \"" + id +"\"", null, null, null, null); c.moveToFirst(); Contact contact = cursorToContact(c); c.close(); return contact; } ... }

1. On fait la requête sur la base de donnée SQLite avec database.query qui prend en paramètre le nom de la table, les colonnes à retourner, le filtre (Where), les valeurs de paramètres du filtre si nécessaire, le groupement (group by), un filtre (having), le trie (order by) et la limite (limit).
2. La requête retourne un Cursor que l'on place sur le premier résultat (obligatoire sinon ne retourne rien)
3. On convertie le Cursor en Contact, on ferme le Cursor et on retourne le Contact.

Test d'existance de contact

Une fonction simple qui vérifie l'existence ou non d'un contact.

ContactsDataSource.java

... public class ContactsDataSource { ... public Boolean existContactWithId(Long id){ Cursor c = database.query(MySQLiteHelper.TABLE_CONTACT, allColumns, MySQLiteHelper.COLUMN_ID_CONTACT + " = \"" + id +"\"", null, null, null, null); if(c.getCount()>0){ c.close(); return true; } else { c.close(); return false; } } ... }

Cette fonction est à peu près la même que la précedente, la différence est que l'on compte le nombre de résultat et qu'on retourne false si aucune ligne ou true pour l'inverse.

Supprimer un contact

Encore une fonction simple mais qui supprimer un contact.

ContactsDataSource.java

... public class ContactsDataSource { ... public void deleteContact(Contact contact) { long id = contact.getId(); System.out.println("Contact deleted with id: " + id); database.delete(MySQLiteHelper.TABLE_CONTACT, MySQLiteHelper.COLUMN_ID + " = " + id, null); } ... }

Pour la suppression on utilise database.delete qui prend en paramètre le nom de la table, la clause Where et les valeurs pour les paramètres de la clause Where si nécessaire.

Récupération de tout les contacts

Une fonction qui nous servira à lister tout les contacts enregistrés dans la BDD.

ContactsDataSource.java

... public class ContactsDataSource { ... public List<Contact> getAllContacts() { List<Contact> contacts = new ArrayList<Contact>(); Cursor cursor = database.query(MySQLiteHelper.TABLE_CONTACT, allColumns, null, null, null, null, null); cursor.moveToFirst(); while (!cursor.isAfterLast()) { Contact contact = cursorToContact(cursor); contacts.add(contact); cursor.moveToNext(); } cursor.close(); return contacts; } ... }

1. On créer la liste de Contact que l'on retournera.
2. On fait la requête database.query comme réalisé pour récupérer un seul contact mais sans clause Where.
3. On plasse le Cursor sur la première ligne de résultat et on boucle sur toutes les lignes en convertissant le Cursor en Contact pour ensuite l'ajouter dans la liste créer précedemment.
4. On ferme le Cursor et on retourne la liste.

Conversion de Cursor en Contact

La fonction cursorToContact convertira le Cursor en Contact.

ContactsDataSource.java

... public class ContactsDataSource { ... private Contact cursorToContact(Cursor cursor) { Contact contact = new Contact(); contact.setId(cursor.getLong(0)); contact.setNom(cursor.getString(1)); contact.setPrenom(cursor.getString(2)); contact.setMail(cursor.getString(3)); contact.setAdresse(cursor.getString(4)); contact.setTelPerso(cursor.getString(5)); contact.setTelPro(cursor.getString(6)); contact.setIdContact(cursor.getLong(7)); return contact; } ... }

1. Pour convertir un Cursor en Contact, on crée d'abord un Contact vide.
2. On lui attributs les valeurs du Cursor en prenant en compte le type de la valeur : getLong, getString, getInt, ...
3. Le Cursor est un tableau de valeur dont les colonnes correspondent à celle que l'on a demandé dans nos requête database.query.
4. On retourne le Contact.