Applications Android - cours 12 : Persistance de données SQLite

Université Constantine 2
Dr. CHAOUCHE A.-C.
Faculté des nouvelles technologies
ahmed.chaouche@univ-constantine2.dz
– Cours 12 –
Chapitre 8 : Persistance de données sous Android
Base de données SQLite
Développement d’applications mobiles
2018/2019. Semestre 1

Université Constantine 2
Etudiants concernés
Faculté/Institut Département Niveau Spécialité
2018/2019. Semestre 1
Dr. CHAOUCHE A.-C.
Faculté des nouvelles technologies
ahmed.chaouche@univ-constantine2.dz
Développement d’applications mobiles
Licence 3 Technologies de l’information (TI)Nouvelles technologies IFA
Licence 3 Science de l’informatique (SCI)Nouvelles technologies IFA
– Cours 12 –
Chapitre 8 : Persistance de données sous Android
Base de données SQLite

Université Constantine 2 3
Prérequis
Maîtrise de la programmation Android
Maîtrise du langage SQL
Objectifs du cours
Connaître les sources de données possibles sous Android
Mettre en œuvre l’API Helper pour exploiter une BD SQLite
Persister des données dans une BD SQLite
Résumé
© Dr. Chaouche A.-C.

Fichiers bruts
java.io.*
Préférences partagées
android.content.SharedPreferences
Bases de données SQLite
android.database.sqlite.SQLiteOpenHelper
Fournisseurs de contenu
android.content.ContentProvider
Stockage dans un cloud
Voir Chapitre 9 (Bonus)
Stockage de données sous Android

Les principaux SGBD relationnels :
MySQL, PostgreSQL
SQL Server, Oracle
SQLite, Access
Les SGBD objet :
Oracle, SQL Server, Informix, IBM
Les SGBD NoSQL :
Cassandra, Redis, MongoDB
Types de SGBDs
Une BD relationnelle est organisée dans des
tableaux à deux dimensions appelés des
relations ou tables. Elle est structurée suivant
les principes de l’algèbre relationnelle.
Une BD à objets est un stock d'informations
groupées sous formes de collections d'objets
persistants.
Une BD NoSQL (Not only SQL) n'est pas fondée
sur une architecture relationnelle. Elle
manipule généralement des BigData, tels que
Google, Amazon, Facebook ou eBay.

un SGBD relationnel open source
embarqué (Android, iOS, Symbian OS, …)
stocké dans un fichier
le plus distribué dans le monde (Firefox, Skype, Google Gears, …)
léger et sans dépendances externes
ne nécessite que peu de mémoire lors de l’exécution ( <300 Ko)
pas de configuration et pas de gestion des droits d’accès
supporte le langage SQL (+ requêtes préparées)
SQLite (1/2)

ne supporte que les types primitifs : INTEGER, REAL, TEXT, et BLOB
dépend du système de fichier (FAT32, NTFS, …)
pas d'extension propre (les plus utilisées : *.sqlite et *.db)
la BD est sauvegardée dans le stockage interne
privée à l’application (inaccessibles à partir d’autres applications)
par exemple dans
Nexus 5 : /data/user/0/[APP_NAME]/databases/FILE_NAME.db
Samsung : /data/data/[APP_NAME]/databases/FILE_NAME.db
SQLite (2/2)

Le langage SQL permet d’interroger une BD SQLite
Les commandes SQL supportées par SQLite :
Donnés (ordres LMD) : SELECT, INSERT, UPDATE, DELETE
Tables (ordres LDD) : CREATE, RENAME, ALTER, TRUNCATE, DROP
SQL : Structured Query Language

INTEGER :
entiers signés, stockés sur 1, 2, 3, 4, 6, ou 8 octets
REAL :
valeurs flottantes, stockés sur 8 octets
TEXT :
strings, stockés en utilisant l’encodage de la BD (UTF-8, UTF-16BE or UTF-16LE)
BLOB :
blobs de données (objets binaires), stockés exactement comme elles étaient
entrées dans la BD (limités à 1 Mo)
Types de données

Android fournit une classe d'assistance qui aide l’utilisateur à créer et
manipuler une BD SQLite de manière simple
Création de la BD
La classe abstraite SQLiteOpenHelper : permet de gérer la connexion à
la base, la création des tables, et la gestion des versions
Méthodes abstraites : onCreate(…), onUpgrate(…)
Manipulation de la BD
La classe SQLiteDatabase : instance depuis getReadableDatabase()
ou getWriteableDatabase()
Méthodes : execSQL(…), insert(…), update(…), delete(…), rawQuery(…)
résultats de requête : Cursor.moveToNext()
SQLite sous Android

Étapes de la persistance :
1. Créer le modèle de données (entités Module, Week et Course)
2. Étendre la classe SQLiteOpenHelper
a. Implémenter le constructeur
b. Implémenter la méthode onCreate()
c. Implémenter la méthode onUpgrade()
3. Implémenter les opérations CRUD
(Create, Read, Update, Delete)
4. Fermer la connexion à la BD
5. Manipuler la BD dans une activité
Persistance de données dans une BD SQLite

1. Créer le modèle de données
/java/Module.java
public class Module {
int id; ...
List<Week> weeks;
}
/java/Week.java
public class Week {
int id; ...
List<Course> courses;
}
/java/Course.java
public class Course {
int id; ...
}

2. Étendre la classe SQLiteOpenHelper
/java/MyHelper.java
public class MyHelper extends SQLiteOpenHelper {
public MyHelper(Context context) { ... }
@Override
public void onCreate(SQLiteDatabase db) { ... }
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion,
int newVersion) { ... }
}
a
b
c

2.a. Implémenter le Constructeur
/java/MyHelper.java
public static final String DATABASE_NAME = "database.db";
public static final int VERSION = 1;
public MyHelper(Context context) {
super(context, DATABASE_NAME, null, VERSION);
} CursorFactory
...
}

2.b. Implémenter la méthode onCreate()
/java/MyHelper.java
...
@Override
public void onCreate(SQLiteDatabase db){
db.execSQL("CREATE TABLE module
(id INTEGER PRIMARY KEY AUTOINCREMENT,
accronym TEXT,
name TEXT,
description TEXT,
credit INTEGER )");
}
...
}

2.c. Implémenter la méthode onUpgrade()
/java/MyHelper.java
...
@Override
public void onUpgrade(SQLiteDatabase db,
int oldVersion,
int newVersion){
db.execSQL("DROP TABLE IF EXISTS module");
onCreate(db);
}
...
}

3. Implémenter les opérations CRUD
/java/MyHelper.java
public MyHelper(Context context) { ... }
public void onCreate(SQLiteDatabase db) { ... }
public void onUpgrade(SQLiteDatabase db, int oldVer, int newVer){...}
public void createModule(Module m) { ... }
public int updateModule(Module m) { ... }
public int deleteModule(Module m) { ... }
public Module getModule(long moduleId) { ... }
public List<Module> getAllModules() { ... }
public void closeDB() { ... }
}
CRUD : Create, Read, Update et Delete

3.a. Create : Insérer un nouveau module
/java/MyHelper.java
public void createModule(Module m) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put("name", m.name);
values.put("acronym", s.acronym);
...
nullColumnHack
db.insert("module", null, values);
⇔ db.execSQL("insert into store(name, ...) values('...', ...)");
}

3.b. Update : Mettre à jour un module
/java/MyHelper.java
public int updateModule(Module m) {
ContentValues values = new ContentValues();
values.put("accronym", m.accronym);
...
return db.update("module", values, "id = ?",
new String[] {m.id + "" });
}

3.c. Delete : Supprimer un module
/java/MyHelper.java
public int deleteModule(Module m) {
return db.delete("module", "id = ?",
new String[] { m.id + "" });
}

3.d. Read : Extraire un module
/java/MyHelper.java
public Module getModule(long moduleId) {
SQLiteDatabase db = this.getReadableDatabase();
String selectQuery = "SELECT * FROM module WHERE id = " + moduleId;
Cursor cursor = db.rawQuery(selectQuery, null);
if(cursor == null) nullColumnHack
return null;
cursor.moveToFirst();
Module m = new Module();
m.id = cursor.getLong(cursor.getColumnIndex("id"));
m.name = (cursor.getString(cursor.getColumnIndex("name")));
...
return m;
}

3.e. Read : Extraire tous les modules
/java/MyHelper.java
public List<Module> getAllModules() {
String selectQuery = "SELECT * FROM module";
List<Module> modules = new ArrayList<>();
Cursor cursor = db.rawQuery(selectQuery, null);
cursor.moveToFirst();
while(!cursor.isAfterLast()) {
modules.add(new Module(cursor.getLong(0), cursor.getString(1),
cursor.getString(2), cursor.getString(3),
cursor.getString(4)));
cursor.moveToNext();
}
return modules;
}

4. Fermer la connexion à la BD
/java/MyHelper.java
public void closeDB() {
if(db != null && db.isOpen())
db.close();
}

5. Manipuler la BD dans une activité
/java/MainActivity.java
...
MyHelper myHelper = new MyHelper(getApplicationContext());
Module dam = new Module(...);
myHelper.createModule(dam);
...
List<Module> modules = myHelper.getAllModules();
for(Module m : modules){ Log.i("MainActivity", m.name); }
...
dam.acronym = "IAM";
myHelper.updateModule(dam);
...
myHelper.deleteModule(dam);
myHelper.closeDB();

Aller plus loin…
Persister une association one-to-many
/java/MyHelper.java
public void createModule(Module m) {
...
for (Week w : m.weeks) {
createWeek(w);
}
...
}

Accès externe à la BD ?

Avec Root

Sans Root via adb shell
Invité de commande
C:>Androidsdkplatform-tools> adb shell
shell@android: ls –al
...
shell@android: cd data/user/
opendir failed, Permission denied
shell@android: run-as sci.iam.learnapp ls –l
/data/user/sci.iam.learnapp/databases/
... ... database.db
shell@android: run-as sci.iam.learnapp cp
/data/user/sci.iam.learnapp/databases/database.db
/storage/emulated/0/
shell@android: ls -al
... ... database.db
shell@android: exit
C:>Androidsdkplatform-tools> adb pull
/storage/emulated/0/database.db c:

SQLScout
https://www.idescout.com
Plugin Android Studio
Payant (~ 50$)
SQLite Studio
https://sqlitestudio.pl/
Sous Windows
ES Explorateur de fichiers
https://play.google.com/
Sous Android
Accès en mode Root
Clients SQLite

Création d'une activité ContentActivity
Un RecyclerView pour afficher les semaines
Le layout de chaque semaine est englobé dans
CardView
Tutoriel (RecyclerView + CardView) :
https://www.androidhive.info/2016/01/android-working-
with-recycler-view/
TP4 : Affichage du contenu d’un module (1/3)

/java/Module.java
public class Week {
int id;
String description;
Date beginDate;
Date endDate;
List<Course> courses;
...
public Week(int id,...){
this.id = id;
...
}
}
/res/layout/item_module.xml
/java/WeekAdapter.java
...

Ouvrir un lien dans "Chrome"
/java/CententActivity.java
...
String urlString = "...";
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(urlString));
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setPackage("com.android.chrome");
try {
startActivity(intent);
} catch (ActivityNotFoundException ex) {
// Chrome browser presumably not installed so allow user to choose instead
intent.setPackage(null);
startActivity(intent);
}

Documents sont accessibles :
Plateforme e-learning de l’université Constantine 2
Lien : http://elearning.univ-constantine2.dz/
Rendus du TP 4 :
Avant le Samedi 4 janvier à 23h59
À : ac.chaouche@misc-umc.org
Nom du fichier à rendre :
DAM_TP4_G%_NOMBINOME1_NOMBINOME2.zip
(Ex : DAM_TP4_G1_CHAOUCHE_NECIBI.zip)
Le fichier zip doit contenir seulement le dossier src
Documents et Rendus

BD SQLite :
www.androidhive.info/2013/09/android-sqlite-database-with-multiple-tables/
SQLite Studio (sous Windows)
https://sqlitestudio.pl/
Utilisation de RecyclerView :
https://www.androidhive.info/2016/01/android-working-with-recycler-view/
Quelques liens utiles

M. Seguy, «Tutoriel Android : apprendre à gérer les fichiers,» 15 Février 2016.
Lien: http://mathias-seguy.developpez.com/tutoriels/android/gerer-fichiers-
applications/.
F. Champigny, «Sauvegarder des éléments – SharedPreferences,» 20 Août 2015.
Lien : http://tutos-android-france.com/sharedpreferences/.
L. Vogel, «Tutoriel sur l'utilisation de base de données SQLite sous Android,» 19
Août 2013. Lien : http://vogella.developpez.com/tutoriels/ android/utilisation-
base-donnees-sqlite/.
W3ii.com, «Android Content Providers,» 2016. Lien :
http://www.w3ii.com/android/android_content_providers.html.
Références

Applications Android - cours 12 : Persistance de données SQLite

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Applications Android - cours 12 : Persistance de données SQLite

Similaire à Applications Android - cours 12 : Persistance de données SQLite (20)

Dernier

Dernier (16)

Applications Android - cours 12 : Persistance de données SQLite