Bonjour ! Dans ce nouveau tutoriel je vais vous expliquer comment stocker des données de votre application de différentes façons. Il existe plusieurs manières de procéder.

Vous avez tout d’abord les préférences partagées .
Ce système permet de stocker des valeurs dans un fichier.

Voici un exemple complet:

public class Calc extends Activity {
        public static final String PREFS_NAME = "MyPrefsFile";
        @Override protected void onCreate(Bundle state){
                super.onCreate(state);
                . . .

L’objet Context permet de récupérer une instance de l’objet SharedPreferences avec
en paramètres le nom que l’on veut lui donner ainsi que le mode de création du fichier, il en existe 3:
* MODE_PRIVATE -> seule cette application pourra lire et écrire les données
* MODE_WORLD_READABLE -> permet la lecture du fichier par toutes les autres applications
* MODE_WORLD_WRITEABLE -> permet l’ écriture du fichier par toutes les autres applications

// Ici on permet donc la lecture de notre fichier de préférence à toutes les applications
SharedPreferences myPrefs = this.getSharedPreferences(PREFS_NAME, MODE_WORLD_READABLE);

On instancie un éditeur à partir de notre objet de préférence, celui-ci nous permettra d’écrire dans le fichier de préférences

SharedPreferences.Editor prefsEditor = myPrefs.edit();

Il existe plusieurs fonctions permettant d ‘insérer des valeurs dans notre fichier de préférences:

• putFloat (String key, float value)
• putBoolean (String key, boolean value)
• putInt (String key, int value)
• putLong (String key, long value)
• putString (String key, String value)

Pour supprimer une valeur utilisez cette méthode:

• remove(String key)

prefsEditor.putString("mon_nom, "Thibault");

Pour valider les modifications (ajout suppression) utilisez cette méthode.

prefsEditor.commit();

Désormais, la valeur est sauvegardée!

Pour récupérer des valeurs il existe plusieurs fonctions:

• getBoolean (String key, boolean defValue)
• getFloat (String key, float defValue)
• getInt (String key, int defValue)
• getLong (String key, long defValue)
• getString (String key, String defValue)

SharedPreferences myPrefs = this.getSharedPreferences(PREFS_NAME, MODE_WORLD_READABLE);
String prefName = myPrefs.getString("mon_nom", "nothing");
// On affiche le nom dans un message
ToastToast.makeText(this, "Hello: " +prefName , Toast.LENGTH_LONG).show();

Voila pour les préférences partagées !

Voyons maintenant comment utiliser une base SQLite. Pour ce faire, j’utilise une librairie qui simplifie grandement la tâche. La libraire se nomme: AndroidDataFramework.
Vous trouverez le .jar ici .

Cette librairie permet de gérer simplement votre base SQLite grace à des fichiers XML.

Vous devez ajouter le fichier .jar à votre projet:

Dans notre exemple nous allons gérer une base de clients:
Voici le fichier XML table.xml:

Vous remarquez qu’il n’y a pas de champs id, ce champs est géré automatiquement par la librairie. Nous verrons plus tard dans le tutoriel comment récupérer cette information.

Pour gérer une clé étrangère, voici la ligne a utiliser:

Ici nous n’en auront pas besoin.

Nous allons maintenant créer une classe Client :

        package fr.thibaultKoprowski.android;
	import com.android.dataframework.Entity;
	public class Client {
		private String nom;
		private String prenom;
		private String addresse;
		private String idBase;
		private Long id;
		public Client(String nom, String prenom, String addresse, Long id) {
			super();
			this.id = id;
			this.nom = nom;
			this.prenom = prenom;
			this.addresse = addresse;
			this.idBase="";
		}	

		// Ici Entity est une classe de la librairie elle sera notre structure de données
		public Client(Entity e){
			this.id = e.getId();
			this.nom = (String) e.getValue("nom");
			this.prenom = (String) e.getValue("prenom");
			this.addresse = (String) e.getValue("addresse");
			this.idBase=(String) e.getValue("idBase");
		}	

		public Client() {
			super();
			this.id = (long)0;
			this.nom = "";
			this.prenom = "";
			this.addresse = "";
			this.idBase="";
		}	

		public Client(String nom, String prenom, String addresse, String idBase) {
			super();
			this.id=(long)0;
			this.idBase = idBase;
			this.nom = nom;
			this.prenom = prenom;
			this.addresse = addresse;
		}	

		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 getAddresse() {
			return addresse;
		}	

		public void setAddresse(String addresse) {
			this.addresse = addresse;
		}	

		public Long getId() {
			return id;
		}	

		public void setId(Long id) {
			this.id = id;
		}	

		public String getIdBase() {
			return idBase;
		}	

		@Override	public String toString() {
			return this.getNom().substring(0, 1).toUpperCase()+
			this.getNom().substring(1, this.getNom().length())+" "+
			this.getPrenom().substring(0, 1).toUpperCase()+
			this.getPrenom().substring(1, this.getPrenom().length());
		}	

	}

Nous allons ensuite créer une classe SQLiteProvider qui nous permettra d’ajouter modifier des clients.

Il est toujours conseillé de créer une classe permettant de travailler sur les données. Cela facilite le code.
Vous avez un seul objet permettant d’accéder aux données de la base.
Dans une plus grosse application,pour optimiser les accès en base, cette classe aurait pu être en statique avec une array liste contenant tous
les clients en statique également. Comme cela, à l’instanciation on ajoute tous les clients dans l’array list.
Puis on travaille uniquement sur cette array list par la suite.
A la fin du cycle de vie de l’application (Méthode onDestroy de l’activity), on affecte tous les changements en base de données.
Ici j’ai simplifier pour ne pas trop compliquer.

package fr.thibaultKoprowski.android;

import java.util.ArrayList;
import android.content.Context;
import com.android.dataframework.DataFramework;
import com.android.dataframework.Entity;
import fr.thibaultKoprowski.android.Client;

public class SqliteProvider {
	private Context ctx;
	public SqliteProvider(Context ctx){
        // Ici on ouvre la connexion avec la base sqlite
 		this.ctx = ctx;
		try {
			// Le deuxième paramètre correspond au paquet où est situé la classe
            DataFramework.getInstance().open(ctx, "fr.thibaultKoprowski.scanner.android");
		}
		catch (Exception e) {		}
	}

	// Ajoute un client passé en paramètre puis retourne son ID
	public long addClient(Client c){
		// On créé un objet Entity avec en paramètre le nom de la table (ici client)
		Entity ent = new Entity("clients"); 

		// Il existe une methode setValue pour tous les types de données
		ent.setValue("nom", c.getNom());
		ent.setValue("prenom", c.getPrenom());
		ent.setValue("adresse", c.getAddresse());
		ent.save();
		// Pour récupérer l'id il faut toujours passer par cette fonction et non une requête
		return ent.getId();
	}

	// Met à jour le client à partir de l'objet passé en paramètre
	public boolean updateClient(Client c,long id){

		// Pour récupérer un enregistrement il faut juste instancier l'objet Entity avec
		// un paramètre Long correspondant à l'id de l'enregistrement
		Entity ent = new Entity("clients",id);

		// On peut ensuite modifier les valeurs
		ent.setValue("nom", c.getNom());
		ent.setValue("prenom", c.getPrenom());
		ent.setValue("adresse", c.getAddresse());

		// Il ne faut surtout pas oublier de sauvegarder les changements
		return ent.save();
	}

	// Supprime le client avec l'id en paramètre
	public boolean removeClient(long id){
		Entity ent = new Entity("clients", id);
		return ent.delete();
	}                 

	// Retourne le client avec l'ID en paramètre
	public Client getClient(Long id){
		Entity ent = new Entity("clients", id);
		if(ent!=null)
			return new Client((String)ent.getValue("nom"), (String)ent.getValue("prenom"), (String)ent.getValue("adresse"),ent.getId());
		else
			return new Client();
	}

	// Retourne la liste de tout les clients
 	public ArrayList getClientList(){
		// La méthode getEntityList(String table, String where, String order_by) permet d"effectuer un select sans la base
		// Ici je n'avais pas besoin de filtrer
		// pour info voici un exemple de requête filtrée:
		// DataFramework.getInstance().getEntityList("produits", "devis_id = 3", "qte asc");
		// Voici un exemple de parcours des résultats
		// Iterator iter = categories.iterator();
		// while (iter.hasNext()){
		//      Entity ent = (Entity)iter.next();
		//      System.out.println(ent.getString("nombre"));
		// }

		ArrayList clients_entities = DataFramework.getInstance().getEntityList("clients", "", "");
		ArrayList liste_clients= new ArrayList();
		for (Entity entity : clients_entities) {
			liste_clients.add(new Client(entity));
		}
		return liste_clients;
	} 

	// Fermeture de la base de données
	protected void destroy() {
		DataFramework.getInstance().close();
	}
}