Chapitre 5. La persistance des données

Transcription

1 Chapitre 5 La persistance des données 1

2 Plan du chapitre 5 Comment partager des données entre applications Utilisation des Shared Preferences Utilisation du système de fichiers (dont XML) Utilisation de la base de données (SQLite) 2

3 Introduction On peut sauvegarder des données sur un smartphone (si, si) Plusieurs techniques et API sont proposées : le système de fichiers du smartphone (= un ordinateur sous Linux) les SharedPreferences: les préférences partagées les BDs relationnelles (et les traiter par SQL) : c'est la technologie SQLite Ce sont les "zones internes" On peut sauvegarder sur des "zones externes" qui sont la carte SD ou des zones accessibles par le réseau (serveur distant,...) source : 3

4 Les SharedPreferences = Les préférences partagées Permet d'enregistrer des données qui seront récupérées par les prochaines sessions : elles sont "partagées" entre sessions Elles sont accessibles par l'ensemble des composants de l'application Utilité : donner des exemples "Preferences are available at the Activity level or shared across all of Activity classes for a given application (but not outside of the application package)." (=> si on est dans l'application package, on peut les utiliser, cf. suite de l'exposé) source : id-application-preferences/ 4

5 Types de données dans une SharedPreferences On enregistre sous la forme clé (= nom de la donnée, toujours de classe String) / valeur de cette donnée Les valeurs ne peuvent être que "simples" : de type boolean, int, long, float(et pas double!) ou de classe Stringou Set<String> "You can use SharedPreferences to save any primitive data: booleans, floats, ints, longs, and strings. This data will persist across user sessions (even if your application is killed)." source : a-storage.html#pref 5

6 Récupérer les SharedPreferences Avec une constante comme : private static final String NOM_PREFS = "JMFPrefs"; on récupère les SharedPreferencesde l'application associées à cette constante par : SharedPreferences mesprefs = getsharedpreferences(nom_prefs, Context.MODE_PRIVATE); int lecompteur = mesprefs.getint("compteur", 0); public abstract SharedPreferences getsharedpreferences (String name, int mode)est une méthode de la classe abstraite Context donc implémentée dans les Activity Cette méthode est un singleton : elle retourne toujours le même objet qui modélise le conteneur de préférences partagées name est le nom du fichier de SharedPreferences modeindique la portée de ses préférences. Ici l'application (Context.MODE_PRIVATEvaleur par défaut) Le fichier de préférences (repéré par NOM_PREFS) est un fichier XML rangé dans /data/data/nom_package_appli/shared_prefs/nom_prefs.xml 6

7 Lire dans les SharedPreferences Il suffit alors de lancer sur le SharedPreferencesrécupéré précédemment une des méthodes public abstract XXX getxxx (String key, XXX defvalue) où XXXpeut valoir boolean, int, long, float, Stringou Set<String> defvalue est la valeur par défaut retournée Par exemple : SharedPreferences mesprefs = getsharedpreferences(nom_prefs, Context.MODE_PRIVATE); int lecompteur = mesprefs.getint("compteur", 0); On peut récupérer toutes les valeurs du SharedPreferencesà l'aide de public abstract Map<String,?> getall () 7

8 Ecrire dans les SharedPreferences Il faut passer par un éditeur associé à la SharedPreferences Editor unediteurdessharedprefs = mesprefs.edit(); int lecompteur =...; unediteurdessharedprefs.putint("compteur", lecompteur); unediteurdessharedprefs.commit(); Ne pas oublier de faire commit()(qui est synchrone) ou apply()qui est asynchrone (i.e. est lancé dans une autre thread) pour réellement enregistrer les changements (n'est ce pas jean-marc!) Une démo? : OK projet Ch5SharedPreferencesJMFProjet : lancer l'appli, la personnaliser, lancer une autre appli (ou l'arrêter), la relancer. Ne pas arrêter "brutalement" l'avd! (= on casse le smartphone!) Par contre on peut éteindre un smartphone et le rallumer, le smartphone a gardé les valeurs (normal il les a écrit dans son système de fichiers) 8

9 Manipuler des SharedPreferences entre applications (1/5) C'est possible. Il suffit de récupérer le Contextde l'application dont on veut avoir les SharedPreferences On utilise les types de dépôt de données : Context.MODE_PRIVATE: les données seront privées à l'application Context.MODE_WORLD_READABLE: les données pourront être lues par toutes les applications Context.MODE_WORLD_WRITEABLE: les données pourront être modifiées par toutes les applications Context.MODE_WORLD_READABLE + Context.MODE_WORLD_WRITEABLE: les données pourront être lues et modifiées par toutes les applications Ces modes sont utilisés au moment où on demande de récupérer les SharedPreferences 9

10 Manipuler des SharedPreferences entre applications (2/5) On utilise les constantes : public static final String PREFS_PRIVATE = "PREFS_PRIVATE"; public static final String KEY_PRIVATE = "KEY_PRIVATE"; public static final String PREFS_READ = "PREFS_READ"; public static final String KEY_READ = "KEY_READ"; public static final String PREFS_WRITE = "PREFS_WRITE"; public static final String KEY_WRITE = "KEY_WRITE"; public static final String PREFS_READ_WRITE = "PREFS_READ_WRITE"; public static final String KEY_READ_WRITE = "KEY_READ_WRITE"; 10

11 Manipuler des SharedPreferences entre applications (3/5) Une première appli (Ch5SharedPreferencesJMFDepotProjet) dépose des données suivant différents modes de dépôt : sharedpreferences = getsharedpreferences(prefs_private, Context.MODE_PRIVATE); Editor prefsprivateeditor = sharedpreferences.edit(); prefsprivateeditor.putstring(key_private, "prive"); prefsprivateeditor.commit(); sharedpreferences = getsharedpreferences(prefs_read, Context.MODE_WORLD_READABLE);... prefsreadeditor.putstring(key_read, readfield.gettext().tostring());... sharedpreferences = getsharedpreferences(prefs_write, Context.MODE_WORLD_WRITEABLE);... prefswriteableeditor.putstring(key_write, writefield.gettext().tostring()); sharedpreferences = getsharedpreferences(prefs_read_write, Context.MODE_WORLD_READABLE + Context.MODE_WORLD_WRITEABLE);... prefsreadwriteableeditor.putstring(key_read_write, read_writefield.gettext().tostring()); 11

12 Manipuler des SharedPreferences entre applications (4/5) Une seconde application (Ch5SharedPreferencesJMFLitProjet) récupère le Contextde la première appli par la méthode public abstract Context createpackagecontext(string packagename, int flags) Le packagenameest le nom du package de la première appli (le voir dans l'androidmanifest.xml de la première appli) Context otherappscontext = null; try { otherappscontext = createpackagecontext("nomdupaquetage1ereappli", Context.CONTEXT_IGNORE_SECURITY); } catch (NameNotFoundException e) { } Il suffit alors de lire à l'aide de ce Contextpar : sharedpreferences = otherappscontext.getsharedpreferences(prefs_private, MODE_PRIVATE);... = sharedpreferences.getstring(key_private, "PRIVATE EMPTY"); sharedpreferences = otherappscontext.getsharedpreferences(prefs_read,mode_world_readable);... = sharedpreferences.getstring(key_read, "WORLD READ EMPTY"); sharedpreferences = otherappscontext.getsharedpreferences(prefs_write, MODE_WORLD_WRITEABLE);... = sharedpreferences.getstring(key_write, "WORLD WRITE EMPTY"); sharedpreferences = otherappscontext.getsharedpreferences(prefs_read_write, MODE_WORLD_READABLE + Context.MODE_WORLD_WRITEABLE);... = sharedpreferences.getstring(key_read_write, "WORLD READ WRITE EMPTY"); 12

13 Manipuler des SharedPreferences entre applications (5/5) Une démo? OK! (source : Oleg Mazurashu à La première appli permet de saisir : La seconde appli relit les SharedPreferencesde la première appli : Pourquoi les données Private et Writeable ne sont pas relues? Parce qu'elles ont privées (à la première application) et seulement inscriptible (write) et pas lisibles (read)! D'ailleurs on a : 13

14 Les fichiers sous Android Android étant un système Unix, une API est proposée pour manipuler les fichiers. Elle est similaire à celle proposée par Java SE On utilise public abstract FileOutputStream openfileoutput (String name, int mode)et public abstract FileInputStream openfileinput (String name) de la classe abstraite Contextdonc implémentées par la classe Activity nameest le nom du fichier, modeest le mode d'ouverture. Ce peut être : MODE_PRIVATE(valeur par défaut) : le fichier ne sera accessible que par l'application créatrice, MODE_APPEND: le mode ajout, MODE_WORLD_READABLE: lisible par toutes les applications, MODE_WORLD_WRITEABLE: peut être modifiées par toutes les applications 14

15 Code de manipulations de fichiers try { // Crée un flux de sortie vers un fichier local FileOutputStream ous = openfileoutput(nom_fichier, MODE_PRIVATE); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(ous)); bw.write("chouette titre de JMF"); bw.close(); // Crée un flux d'entrée depuis un fichier local FileInputStream ins = openfileinput(nom_fichier); BufferedReader br = new BufferedReader(new InputStreamReader(ins)); String valeurlue = br.readline(); this.settitle(valeurlue); ins.close(); } catch (Exception e) { // Traitement des exceptions... } On utilise aussi java.io 15

16 Lecture / Ecriture dans un fichier : une démo Une démo? OK! Projet Ch5ProgAndroidFichierJMFProjet : sauvegarde de contenu dans un fichier texte Lorsqu'on lance de nouveau cette application (après l'avoir reconstruite!), le contenu du fichier ainsi que son emplacement est affiché Pour nettoyer (!), tout effacer et cliquer "Et enregistrer le!" 16

17 Un peu plus sur les fichiers Pour connaître où se trouve le fichier, utiliser la méthode public File getfilesdir() public String[] filelist()retourne un tableau des fichiers sauvegardés par l'application Une application peut détruire un de ces fichiers grâce à public boolean deletefile (String nomdufichier) Toutes sont des méthodes de la classe abstraite android.content.context donc implémentée par les Activity 17

18 Une base de données =? Une base de données est un système contenant des données et géré par un logiciel Une base de données (BD) relationnelle présente ces (ses?) informations dans des tables Les tables donnent une vision "ligne colonne" des données Une ligne représente un enregistrement Une colonne est l'ensemble des valeurs d'un champ des enregistrements de la table Les données sont structurées Les colonnes sont typées Le logiciel est le système de gestion de base de données (relationnelles) : SGBD(R) Bref, une BDR est un ensemble de tables, une table est un ensemble d enregistrements (jmf) 18

19 Une table : un exemple Une table de films 19

20 BD : sujet simple ou complexe? Louer un film =? Et si vous êtes plusieurs utilisateurs simultanément? Et si beaucoup (énormément) d'utilisateurs? Lire les données est ce facile? Euh, et si l'administrateur fait des insertions à ce moment là? Bref gestion de concurrence, variation de charge, accès rapide, transaction,... Beaucoup de bases de données relationnelles : DB2, Oracle, Sybase, Microsoft SQL server, MySQL,... 20

21 Remarques sur SQLite La base de données FILENAMEest stockée dans le smartphone sous /data/data/nom_package_appli/databases/filenameoù NOM_PACKAGE_APPLIest le nom du package de l'application Android (celui indiqué au début du fichier AndroidManifest.xml) L'exécution des requêtes est effectuée dans le même processus que l'application Android et une BD est réservée à l'application créatrice : seule cette application créatrice peut y accéder. Si on veut des données partageables entre applications Android, voir les ContentProvider "Any databases you create will be accessible by name to any class in the application, but not outside the application." source : 21

22 Une BD Android = une SQLiteDatabase Dans le code, une base de données est modélisée par un objet de la classe android.database.sqlite.sqlitedatabase Cette classe permet donc d'insérer des données dans des tables (insert()), de les modifier (update()), de les enlever (delete()), de lancer des requêtes SELECT (par query()) ou des requêtes qui ne retournent pas de données par execsql() Les requêtes Create, Read, Update, Delete (~ INSERT, SELECT, UPDATE, DELETE de SQL) sont dites des requêtes CRUD 22

23 Une classe d'aide à l'ouverture (OpenHelper) Pour créer et/ou mettre à jour une BD, on écrit une classe qui hérite de la classe abstraite android.database.sqlite.sqliteopenhelper Cela nécessite de créer un contructeur qui appelera un des constructeurs avec argument de SQLiteOpenHelper: il n'y a pas de constructeur sans argument dans SQLiteOpenHelper Le constructeur de SQLiteOpenHelperutilisé est public SQLiteOpenHelper (Context context, String name, SQLiteDatabase.CursorFactory factory, int version) context est le contexte de l'application nameest le nom du fichier contenant la BD = nom de la BD factoryest utilisé pour créer des Cursor. En général on met null versionest le numéro de version de la BD (commençant à 1) 23

24 Du OpenHelper à SQLiteDatabase = de la classe d'aide à l'ouverture à la base de données Le constructeur précédent est un proxy qui est éxécuté rapidement La BD sera réellement créée au lancement de getwritabledatabase()(pour une base en lecture et écriture) ou de getreadabledatabase() (pour une base en lecture seule) sur cet objet de la classe d'aide Bref on a : private class MaBaseOpenHelper extends SQLiteOpenHelper {... }... MaBaseOpenHelper lehelper = new MaBaseOpenHelper(...); SQLiteDatabase mabasedonnees = lehelper.getxxxabledatabase(); et un OpenHelper est (évidemment) associé à une base de données 24

25 Création, mise à jour d'une BD : code du helper Sur un objet d'une classe héritant de SQLiteOpenHelper(classe d'aide), certaines méthodes sont appelées automatiquement : public void oncreate(sqlitedatabase db)est appelée automatiquement par l'environnement d'exécution quand la BD n'existe pas et qu'elle doit être créée. On met le code de création des tables et leurs contenus dans cette méthode public void onupgrade(sqlitedatabase db, int oldversion, int newversion)quand le numéro de version de la BD a été incrémentée Ces deux méthodes sont abstraites dans la classe de base et doivent donc être implémentées dans la classe d'aide 25

26 Code de la classe d'aide MaBaseOpenHelper private class MaBaseOpenHelper extends SQLiteOpenHelper { private static final String REQUETE_CREATION_TABLE = "create table " + TABLE_PLANETES + " (" + COLONNE_ID + " integer primary key autoincrement, " + COLONNE_NOM + " text not null, " + COLONNE_RAYON + " text not null);"; public MaBaseOpenHelper(Context context, String nom, CursorFactory cursorfactory, int version) { super(context, nom, cursorfactory, version); public void oncreate(sqlitedatabase db) { db.execsql(requete_creation_table); public void onupgrade(sqlitedatabase db, int oldversion, int newversion) { // Dans notre cas, nous supprimons la table et ses données pour en // créer une nouvelle ensuite. Vous pouvez créer une logique de mise // à jour propre à votre base permettant de garder les données à la // place. db.execsql("drop table " + TABLE_PLANETES + ";"); // Création de la nouvelle structure. oncreate(db); } } 26

27 Insérer des données dans une SQLiteDatabase (1/2) Ayant obtenu une SQLiteDatabase, on utilise les méthodes de cette classe pour faire des opérations sur la base de données public long insert (String table, String nullcolumnhack, ContentValues values)insère dans la table table les valeurs indiquées par values values, de classe ContentValues, est une suite de couples (clé, valeur) où la clé, de classe String, est le nom de la colonne et valeur, sa valeur Bref on prépare tout, la ligne à insérer en remplissant valuespar des put()successifs puis on lance insert() Exemple : /** * Insère une planète dans la table des planètes. */ public long insertplanete(planete planete) { ContentValues valeurs = new ContentValues(); valeurs.put(colonne_nom, planete.getnom()); valeurs.put(colonne_rayon, planete.getrayon()); return mabasedonnees.insert(table_planetes, null, valeurs); 27 }

28 Insérer des données dans une SQLiteDatabase (2/2) Le second argument nullcolumnhackest le nom de colonne qui aura la valeur NULL si valuesest vide. Cela est du au fait que SQLite ne permet pas de lignes vides. Ainsi avec cette colonne, au moins un champ dans la ligne aura une valeur (= NULL). Bref cela sert seulement lorsque values est vide! Cette méthode insert() retourne le numéro de la ligne insérée ou - 1 en cas d'erreur En fait cette insertion est le Create (C) de CRUD 28

29 Récupérer des données dans une SQLiteDatabase Un premier moyen pour récupérer des données (~ SELECT) est d'utiliser : public Cursor query (String table, String[] columns, String whereclause, String[] selectionargs, String groupby, String having, String orderby) columnsest la liste des colonnes à retourner. Mettre nullsi on veut toutes les colonnes whereclauseest la clause WHERE d'un SELECT (sans le mot WHERE). Mettre nullsi on veut toutes les lignes selectionargsest utile si dans whereclause(~ WHERE), il y a des paramêtres notés?. Les valeurs de ces paramêtres sont indiquées par selectionargs. Bref en général on met null groupbyest la clause GROUP BY d'un SELECT (sans les mots GROUP BY). Utile pour des SELECT COUT(*). Bref on général on met null havingindique les groupes de lignes à retourner (comme HAVING de SQL = un WHERE sur résultat d'un calcul, pas sur les données) orderbyest la clause ORDER BY d'un SELECT (sans les mots ORDER BY). Mettre nullsi on ne tient pas compte de l'ordre 29

30 Exemple de requête SELECT pour Android Euh, la classe android.database.sqlite.sqlitequerybuilderest (semble) faite pour cela. Voir à Par exemple est l'équivalent de db.query(table_contacts, new String[] { KEY_ID, KEY_NAME, KEY_PH_NO }, KEY_ID + "=?", new String[] { String.valueOf(id) }, null, null, null, null); "SELECT KEY_ID, KEY_NAME, KEY_PH_NO FROM TABLE_CONTACTS WHERE KEY_ID='" + id + "'" Heureusement, il y a plus simple, voir diapo suivante! 30

31 rawquery() : requête SELECT pour Android La méthode rawquery()de SQLiteDatabasepermet de lancer des simples requêtes SELECTcomme "SELECT * FROM " + TABLE_CONTACTS WHERE condition paramétrée Sa signature est public Cursor rawquery (String sql, String[] selectionargs) où sqlest une requête SELECT (qui ne doit pas être terminée par ;) et selectionargsest le tableau qui fixe les valeurs des paramètres (noté?) dans la clause WHERE Par exemple : String countquery = "SELECT * FROM " + TABLE_CONTACTS; SQLiteDatabase db = this.getreadabledatabase(); Cursor cursor = db.rawquery(countquery, null); 31

32 L'objet Cursor (1/3) La méthode query()(resp. rawquery()) retourne un android.database.cursor(~ java.sql.resultset). android.database.cursorest une interface. Ce qui est retourné est un objet d'une classe qui implémente cette interface C'est similaire à JDBC. Le Cursorreprésente un ensemble de "lignes" contenant le résultat de la requête SELECT public int getcount ()retourne le nombre de lignes contenues dans le Cursor On se positionne au début du Cursor(= avant la première ligne) par la méthode public boolean movetofirst ()qui retourne falsesi le Cursorest vide On teste si on a une nouvelle ligne à lire par la méthode public boolean movetonext()(qui retourne falsesi on était positionné après la dernière ligne) et qui fait avancer sur la ligne suivante 32

33 L'objet Cursor (2/3) On récupère la columnindexcellule de la ligne par la méthode : public XXX getxxx(int columnindex). columnindexest (évidemment) le numéro de la cellule dans la requête. XXXest le type retourné (String, Short, Int, Long, Float, Double) On peut avoir le numéro d'une colonne à partir de son nom par public abstract int getcolumnindex (String columnname). Finalement on a le code : ArrayList<Station> arrlist = new ArrayList<Station>(); Cursor c = database.rawquery("select * from Stations", null); if(c.movetofirst()){ do { Station s = new Station(); s.setnumber(c.getint(c.getcolumnindex("number"))); s.setname(c.getstring(c.getcolumnindex("name")));... } while(c.movetonext()); } c.close(); 33

34 L'objet Cursor (3/3) On referme le Cursor(et libère ainsi les ressources) par public void close () On peut avoir des renseignements sur le résultat de la requête SELECT (* FROM...) (Méta données) à l'aide du Cursorcomme : public int getcolumncount ()qui retourne le nombre de colonnes contenues dans le Cursor public String getcolumnname (int columnindex)qui retourne le nom de la columnindex ième colonne 34

35 L'accès aux données : un DAO Manipuler le Cursor, c'est bien. C'est "un peu" de la programmation "bas niveau" Bref un DAO (= Data Access Object), voire une façade s'impose! Pour accéder aux données, on masque les bidouilles sous jacentes (requête SQL, etc.) par un objet d'une classe DAO : un bon design pattern! Les bidouilles SQL masquées par le DAO sont : insérer des données dans la BD par la méthode insert()de la classe SQLiteDatabase retourner toutes les données d'une table par la méthode query() de la classe SQLiteDatabase 35

36 Ce sont : Les constantes de l'application private static final int BASE_VERSION = 1; private static final String BASE_NOM = "planetes.db"; private static final String TABLE_PLANETES = "table_planetes"; public static final String COLONNE_ID = "id"; public static final int COLONNE_ID_ID = 0; public static final String COLONNE_NOM = "nom"; public static final int COLONNE_NOM_ID = 1; public static final String COLONNE_RAYON = "rayon"; public static final int COLONNE_RAYON_ID = 2; Euh, si on les met dans une interface, elles sont évidemment toutes public(static final) 36

37 Le code du DAO (1/4) public class PlanetesDB_DAO { private SQLiteDatabase mabasedonnees; private MaBaseOpenHelper basehelper; public PlanetesDB_DAO(Context ctx) { basehelper = new MaBaseOpenHelper(ctx, BASE_NOM, null, BASE_VERSION); } public SQLiteDatabase open() { mabasedonnees = basehelper.getwritabledatabase(); return mabasedonnees; } public void close() { mabasedonnees.close(); } /** * Récupère une planète en fonction de son nom. nom * Le nom de la planète à retourner. La planète dont le nom est égale au paramètre 'nom'. */ public Planete getplanete(string nom) { Cursor c = mabasedonnees.query(table_planetes, new String[] { COLONNE_ID, COLONNE_NOM, COLONNE_RAYON }, null, null, null, COLONNE_NOM + " LIKE " + nom, null); return cursortoplanete(c); } 37

38 Le code du DAO (2/4) // La méthode qui fait le lien entre les bidouilles Android SQL (Cursor) et // l'objet "métier" Planete private Planete cursortoplanete(cursor c) { // Si la requête ne renvoie pas de résultat if (c.getcount() == 0) { c.close(); return null; } } Planete retplanete = new Planete(); // Extraction des valeurs depuis le curseur retplanete.setid(c.getint(colonne_id_id)); retplanete.setnom(c.getstring(colonne_nom_id)); retplanete.setrayon(c.getfloat(colonne_rayon_id)); // Ferme le curseur pour libérer les ressources c.close(); return retplanete; 38

39 Le code du DAO (3/4) /** * Retourne toutes les planètes de la base de données. * Un ArrayList<Planete> contenant toutes les planètes de la BD */ public ArrayList<Planete> getallplanetes() { Cursor c = mabasedonnees.query(table_planetes, new String[] { COLONNE_ID, COLONNE_NOM, COLONNE_RAYON }, null, null, null, null, null); return cursortoplanetes(c); } private ArrayList<Planete> cursortoplanetes(cursor c) { // Si la requête ne renvoie pas de résultat if (c.getcount() == 0) { c.close(); return new ArrayList<Planete>(0); } } ArrayList<Planete> retplanetes = new ArrayList<Planete>(c.getCount()); c.movetofirst(); do { Planete planete = new Planete(); planete.setid(c.getint(colonne_id_id)); planete.setnom(c.getstring(colonne_nom_id)); planete.setrayon(c.getfloat(colonne_rayon_id)); retplanetes.add(planete); } while (c.movetonext()); // Ferme le curseur pour libérer les ressources c.close(); return retplanetes; 39

40 Le code du DAO (4/4) /** * Insère une planète dans la table des planètes. * planete * La planète à insérer. */ public long insertplanete(planete planete) { ContentValues valeurs = new ContentValues(); valeurs.put(colonne_nom, planete.getnom()); valeurs.put(colonne_rayon, planete.getrayon()); return mabasedonnees.insert(table_planetes, null, valeurs); } public void videlabase() { // Dans notre cas, nous supprimons la base et les données pour en // créer une nouvelle ensuite. Vous pouvez créer une logique de mise // à jour propre à votre base permettant de garder les données à la // place. mabasedonnees.execsql("drop table " + TABLE_PLANETES + ";"); // Création de la nouvelle structure. mabasedonnees.execsql(requete_creation_table); } } 40

41 Démonstration Projet ProgAndroidBDJMFProjet dans...\travail 41

42 Retour sur l'ihm : le TableLayout (1/2) Pour afficher des enregistrements une table est appropriée Android propose le TableLayoutcalqué sur l'attribut tablede HTML : <table> <tr><td>et 1</td><td>et 2</td></tr> </table> a pour équivalent dans les fichiers d'ihm d'android : <TableLayout> <TableRow><TextView...>et 1</TextView><TextView...>et 2</TextView></TableRow> </TableLayout> 42

43 Retour sur l'ihm : le TableLayout (2/2) Néanmoins, il faut souvent construire cette TableLayout dynamiquement (on ne connait pas le nombre d'articles à afficher) : TableLayout table = (TableLayout) findviewbyid(r.id.tablelayoutlescontacts); Iterator<Contact> it = arcontacts.iterator(); while (it.hasnext()) { Contact ct = (Contact)it.next(); // création d'une nouvelle TableRow TableRow row = new TableRow(this); TextView tnom = new TextView(this); tnom.settext(ct.getname()); row.addview(tnom); TextView tnumtel = new TextView(this); tnumtel.settext(ct.getphonenumber()); row.addview(tnumtel); table.addview(row,new TableLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)); } Le LayoutParamsest un android.view.viewgroup.layoutparams 43

44 Modifier une table : UPDATE de SQL pour Android Pour mettre à jour des lignes dans une table, la méthode utilisée (de la classe SQLiteDatabase) est public int update (String table, ContentValues values, String whereclause, String[] whereargs) où : tableest la table qui doit être mise à jour valuesest une suite de couples (clé, valeur) où la clé, de classe String, est le nom de la colonne et valeur, sa valeur whereclauseest la clause WHERE filtrant les lignes à mettre à jour. Si la valeur est null, toutes les lignes sont mises à jour whereargsindiquent les valeurs à passer aux différents arguments de la clause WHERE qui sont notés? dans whereclause Cette méthode retourne le nombre de ligne qui ont été affectées Exemple : SQLiteDatabase db = this.getwritabledatabase(); ContentValues values = new ContentValues(); values.put(key_name, contact.getname()); values.put(key_ph_no, contact.getphonenumber()); db.update(table_contacts, values, KEY_ID + " =?", new String[] { String.valueOf(contact.getID()) }); 44

45 Supprimer des lignes dans une table : DELETE Pour supprimer des lignes dans une table, la méthode utilisée (de la classe SQLiteDatabase) est public int delete (String table, String whereclause, String[] whereargs) table est la table à manipuler whereclauseest la clause WHERE filtrant les lignes à supprimer. Si la valeur est null, toutes les lignes sont détruites whereargsindiquent les valeurs à passer aux différents arguments de la clause WHERE qui sont notés? dans whereclause Cette méthode retourne le nombre de ligne qui ont été supprimées Exemple : public void deletecontact(contact contact) { SQLiteDatabase db = this.getwritabledatabase(); db.delete(table_contacts, KEY_ID + " =?", new String[] { String.valueOf(contact.getID()) }); db.close(); } 45

46 Bibliographie pour ce chapitre (1/2) Sur les Shared Preferences : Linux Magazine Hors Série N 60, Yohann Melo; page 26 Oleg Mazurashu à droid-application-preferences/ 46

47 Bibliographie pour ce chapitre (2/2) Programmation Android, De la conception au déploiement avec le SDK Google Android 2,Damien Guignard, Julien Chable, Emmanuel Robles ; editions Eyrolles, chapitre 6 Sur SQLite : Tutorial de Lars Vogel : cle.html Tutorial BD et SQLite Android : a-storage.html#db 47

48 Résumé du chapitre 5 Il existe plusieurs techniques pour partager des données entre deux sessions d'une même application ou entre deux applications On peut citer Les Shared Preferences, l'utilisation du système de fichiers (et des fichiers XML) ainsi que la base de données SQLite manipulable par le langage SQL 48

49 Fin 49