Développement Applications Mobiles - Chapitre 6 : Persistance des Données
Persistance des données android Ce chapitre traite de la persistance des données dans les applications Android, en se concentrant sur la conservation de l'état des applications d'une exécution à l'autre.
D'après le document Développement Applications Mobiles - Chapitre 6 : Persistance des Données
Cet article a été rédigé automatiquement à partir du document source, puis vérifié avant publication.
Document source
Mobile Application Development · PDF · 32 pages · 2013
Afficher l'aperçu du document
Persistance des données android
Ce chapitre traite de la persistance des données dans les applications Android, en se concentrant sur la conservation de l'état des applications d'une exécution à l'autre. Il aborde les différentes méthodes de stockage à long terme des données sur le terminal, y compris la sauvegarde de l'état des applications, la gestion des fichiers, les préférences utilisateur et l'utilisation de bases de données SQLite.
Mécanismes de persistance
Android propose plusieurs mécanismes pour gérer la persistance des données, qui sont au nombre de trois : le système de fichiers, les préférences utilisateur et SQLite. Le choix de l'une ou l'autre méthode dépend du contexte d'utilisation. Chaque méthode offre des espaces de persistance privés aux applications, garantissant ainsi la sécurité des données.
Système de fichiers
L'API d'Android permet de lire et écrire des fichiers, qu'ils soient stockés sur le téléphone ou sur un support amovible tel qu'une carte SD. L'espace de stockage est cloisonné entre les applications, ce qui signifie que chaque application a son propre espace de stockage. Pour manipuler les fichiers, on utilise l'objet Context.
Lecture d'un fichier
Pour lire un fichier, on utilise l'interface java.io.FileInputStream :
FileInputStream inputStream = openFileInput("mon_fichier");
BufferedInputStream in = new BufferedInputStream(inputStream);
final int bufferSize = 1024 * 8;
byte[] data = new byte[bufferSize];
int length;
while ((length = in.read(data)) != -1) {
// les octets lus sont contenus dans data
}
in.close();
Il est conseillé d'encapsuler le FileInputStream dans un BufferedInputStream pour éviter de solliciter le support physique à chaque lecture.
Écriture dans un fichier
Pour écrire dans un fichier, on utilise FileOutputStream :
FileOutputStream outputStream = openFileOutput("mon_fichier", Context.MODE_PRIVATE);
outputStream.write(data);
outputStream.close();
Les modes d'accès pour l'écriture incluent MODE_APPEND et MODE_PRIVATE. Le mode MODE_PRIVATE crée un fichier accessible uniquement par l'application qui l'a écrit.
Préférences utilisateur
Le système de préférences permet de sauvegarder des données sur le mobile de manière plus simple que la manipulation directe des fichiers. Il utilise la classe SharedPreferences pour lire et écrire des valeurs primitives.
Lecture des préférences
Pour lire des préférences, on utilise :
SharedPreferences settings = getPreferences(Context.MODE_PRIVATE);
boolean tvaReduite = settings.getBoolean("TVAReduite", false);
float prixBanane = settings.getFloat("prixBanane", 2.5F);
int stockDisponible = settings.getInt("stockDisponible", 500);
String etiquette = settings.getString("etiquette", null);
Écriture des préférences
L'écriture des préférences se fait de manière atomique grâce à SharedPreferences.Editor :
SharedPreferences settings = getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean("TVAReduite", tvaReduite);
editor.putFloat("prixBanane", prixBanane);
editor.putInt("stockDisponible", stockDisponible);
editor.putString("etiquette", etiquette);
editor.commit();
Utilisation de SQLite
Lorsque le besoin de stockage devient plus complexe, il est conseillé d'utiliser une base de données SQLite. Android fournit des classes dans les packages android.database et android.database.sqlite pour interagir avec SQLite.
Création et mise à jour de la base de données
Pour définir la base de données, il faut créer une classe qui étend SQLiteOpenHelper et implémenter les méthodes onCreate et onUpgrade.
public class DatabaseHandler extends SQLiteOpenHelper {
@Override
public void onCreate(SQLiteDatabase db) {
String CREATE_STOCK_TABLE = "CREATE TABLE STOCK (ID INTEGER PRIMARY KEY, LIBELLE TEXT, TARIF REAL, DATE_CONSOMMATION INTEGER)";
db.execSQL(CREATE_STOCK_TABLE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS STOCK");
onCreate(db);
}
}
Insertion d'enregistrements
Pour insérer un enregistrement dans la base de données :
ContentValues values = new ContentValues();
values.put("LIBELLE", "bananes");
values.put("TARIF", 2.750);
db.insert("STOCK", null, values);
Lecture des enregistrements
Pour récupérer un enregistrement :
Cursor cursor = db.query("STOCK", new String[] { "ID", "LIBELLE", "TARIF" }, "ID=?", new String[] { String.valueOf(id) }, null, null, null);
if (cursor != null) cursor.moveToFirst();
String libelle = cursor.getString(1);
Key takeaways
- Android offre plusieurs mécanismes de persistance des données.
- Le système de fichiers permet de lire et écrire des fichiers de manière sécurisée.
- Les préférences utilisateur simplifient la sauvegarde de données primitives.
- SQLite est utilisé pour des besoins de stockage plus complexes.
Glossaire
- Context : Objet qui fournit des informations sur l'environnement d'exécution.
- SharedPreferences : Classe pour gérer les préférences utilisateur.
- SQLiteOpenHelper : Classe pour gérer la création et la mise à jour de bases de données SQLite.
- Cursor : Objet utilisé pour accéder aux résultats d'une requête SQL.
Questions fréquentes
Comment sauvegarder l'état d'une application Android ?
Pour sauvegarder l'état d'une application Android, on peut utiliser les mécanismes de persistance comme le système de fichiers, les préférences utilisateur ou SQLite, selon le type de données à conserver.
Comment lire un fichier dans une application Android ?
Pour lire un fichier, on utilise FileInputStream et on lit les données à l'aide d'un buffer. Il est important de fermer le flux après la lecture.
Comment écrire des préférences utilisateur dans Android ?
Les préférences utilisateur peuvent être écrites en utilisant SharedPreferences.Editor. On définit les valeurs à sauvegarder et on appelle commit() pour enregistrer les modifications.
Quand utiliser SQLite dans une application Android ?
SQLite est recommandé lorsque les données à sauvegarder sont complexes et ne peuvent pas être modélisées simplement sous forme de paires clé/valeur. Il permet de gérer des tables et des relations entre données.
Commentaires
Aucun commentaire pour le moment. Posez la première question.