Aller au contenu

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

Développement Applications Mobiles - Chapitre 6 : Persistance des Données

Mobile Application Development · PDF · 32 pages · 2013

Afficher l'aperçu du document

Consulter le document original →

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.

Partager

Commentaires

Aucun commentaire pour le moment. Posez la première question.

Les commentaires sont relus avant publication. Votre e-mail n'est jamais affiché.

← Toutes les révisions