Exemple de préférences partagées Android
Je souhaite récupérer les entrées de l'utilisateur dans une application pour une utilisation ultérieure.
Par exemple, l'utilisateur est invité à entrer tous les 7 jours de la semaine et à taper dans la zone d'édition "Lundi", "Mardi" etc. Plus tard dans l'application, une question s'affichera et vous demandera quel est votre jour préféré? Et le compteur affichera une liste déroulante des jours saisis par l’utilisateur.
Je suppose que des préférences partagées fonctionneraient pour cela, mais je ne trouve pas un bon exemple pour me donner une place de départ. Toute aide serait appréciée.
Définir des valeurs dans Préférence:
// MY_PREFS_NAME - a static String variable like:
//public static final String MY_PREFS_NAME = "MyPrefsFile";
SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit();
editor.putString("name", "Elena");
editor.putInt("idName", 12);
editor.apply();
Récupérer des données de préférence:
SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE);
String restoredText = prefs.getString("text", null);
if (restoredText != null) {
String name = prefs.getString("name", "No name defined");//"No name defined" is the default value.
int idName = prefs.getInt("idName", 0); //0 is the default value.
}
plus d'informations:
Créer des préférences partagées
SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", MODE_PRIVATE);
Editor editor = pref.edit();
Stockage des données sous forme de paire KEY/VALUE
editor.putBoolean("key_name1", true); // Saving boolean - true/false
editor.putInt("key_name2", "int value"); // Saving integer
editor.putFloat("key_name3", "float value"); // Saving float
editor.putLong("key_name4", "long value"); // Saving long
editor.putString("key_name5", "string value"); // Saving string
// Save the changes in SharedPreferences
editor.commit(); // commit changes
Obtenir des données SharedPreferences
// Si la valeur de la clé n'existe pas, alors retourne la deuxième valeur param - Dans ce cas, null
boolean userFirstLogin= pref.getBoolean("key_name1", true); // getting boolean
int pageNumber=pref.getInt("key_name2", 0); // getting Integer
float amount=pref.getFloat("key_name3", null); // getting Float
long distance=pref.getLong("key_name4", null); // getting Long
String email=pref.getString("key_name5", null); // getting String
Suppression de la valeur de clé de SharedPreferences
editor.remove("key_name3"); // will delete key key_name3
editor.remove("key_name4"); // will delete key key_name4
// Save the changes in SharedPreferences
editor.commit(); // commit changes
Effacer toutes les données de SharedPreferences
editor.clear();
editor.commit(); // commit changes
Comment initier?
// 0 - for private mode`
SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0);
Editor editor = pref.edit();
Comment stocker des données dans les préférences partagées?
editor.putString("key_name", "string value"); // Storing string
OR
editor.putInt("key_name", "int value"); //Storing integer
Et n'oubliez pas de postuler:
editor.apply();
Comment récupérer des données à partir de préférences partagées?
pref.getString("key_name", null); // getting String
pref.getInt("key_name", 0); // getting Integer
J'espère que cela vous aidera :)
Vous pouvez créer votre classe SharedPreference personnalisée.
public class YourPreference {
private static YourPreference yourPreference;
private SharedPreferences sharedPreferences;
public static YourPreference getInstance(Context context) {
if (yourPreference == null) {
yourPreference = new YourPreference(context);
}
return yourPreference;
}
private YourPreference(Context context) {
sharedPreferences = context.getSharedPreferences("YourCustomNamedPreference",Context.MODE_PRIVATE);
}
public void saveData(String key,String value) {
SharedPreferences.Editor prefsEditor = sharedPreferences.edit();
prefsEditor .putString(key, value);
prefsEditor.commit();
}
public String getData(String key) {
if (sharedPreferences!= null) {
return sharedPreferences.getString(key, "");
}
return "";
}
}
Vous pouvez obtenir une instance de YourPrefrence comme ceci:
YourPreference yourPrefrence = YourPreference.getInstance(context);
yourPreference.saveData(YOUR_KEY,YOUR_VALUE);
String value = yourPreference.getData(YOUR_KEY);
Je viens de trouver tous les exemples ci-dessus trop déroutants et j'ai donc écrit le mien. Les fragments de code sont bien si vous savez ce que vous faites, mais qu'en est-il des personnes comme moi qui ne le savent pas?
Vous voulez plutôt une solution couper-coller? Eh bien voilà!
Créez un nouveau fichier Java et appelez-le Keystore. Puis collez dans ce code:
import Android.content.Context;
import Android.content.SharedPreferences;
import Android.content.SharedPreferences.Editor;
import Android.util.Log;
public class Keystore { //Did you remember to vote up my example?
private static Keystore store;
private SharedPreferences SP;
private static String filename="Keys";
private Keystore(Context context) {
SP = context.getApplicationContext().getSharedPreferences(filename,0);
}
public static Keystore getInstance(Context context) {
if (store == null) {
Log.v("Keystore","NEW STORE");
store = new Keystore(context);
}
return store;
}
public void put(String key, String value) {//Log.v("Keystore","PUT "+key+" "+value);
Editor editor = SP.edit();
editor.putString(key, value);
editor.commit(); // Stop everything and do an immediate save!
// editor.apply();//Keep going and save when you are not busy - Available only in APIs 9 and above. This is the preferred way of saving.
}
public String get(String key) {//Log.v("Keystore","GET from "+key);
return SP.getString(key, null);
}
public int getInt(String key) {//Log.v("Keystore","GET INT from "+key);
return SP.getInt(key, 0);
}
public void putInt(String key, int num) {//Log.v("Keystore","PUT INT "+key+" "+String.valueOf(num));
Editor editor = SP.edit();
editor.putInt(key, num);
editor.commit();
}
public void clear(){ // Delete all shared preferences
Editor editor = SP.edit();
editor.clear();
editor.commit();
}
public void remove(){ // Delete only the shared preference that you want
Editor editor = SP.edit();
editor.remove(filename);
editor.commit();
}
}
Sauvegardez maintenant ce fichier et oubliez-le. Vous avez fini avec ça. Maintenant, retournez dans votre activité et utilisez-la comme ceci:
public class YourClass extends Activity{
private Keystore store;//Holds our key pairs
public YourSub(Context context){
store = Keystore.getInstance(context);//Creates or Gets our key pairs. You MUST have access to current context!
int= store.getInt("key name to get int value");
string = store.get("key name to get string value");
store.putInt("key name to store int value",int_var);
store.put("key name to store string value",string_var);
}
}
Shared Preferencessont des fichiers XML permettant de stocker des données primitives privées dans des paires clé-valeur. Les types de données incluent Booleans, floats, ints, longs et strings.
Lorsque nous voulons enregistrer des données accessibles dans l’ensemble de l’application, une solution consiste à les enregistrer sous forme de variable globale. Mais il disparaîtra une fois l'application fermée. Une autre méthode recommandée consiste à enregistrer dans SharedPreference. Les données enregistrées dans le fichier SharedPreferences sont accessibles dans l’ensemble de l’application et persistent même après la fermeture ou le redémarrage de l’application.
SharedPreferences enregistre les données dans une paire clé-valeur et est accessible de la même manière.
Vous pouvez créer un objet deSharedPreferencesen utilisant deux méthodes,
1) . getSharedPreferences () : Cette méthode permet de créer plusieurs SharedPreferences.et ses premiers paramètres au nom de SharedPreferences.
2) . getPreferences () : Cette méthode permet de créer une variable unique SharedPreferences.
Stocker des données
Ajouter une déclaration Variable/Créer un fichier de préférences
public static final String PREFERENCES_FILE_NAME = "MyAppPreferences";
Récupérer un descripteur dans le nom de fichier (à l'aide de getSharedPreferences)
SharedPreferences settingsfile= getSharedPreferences(PREFERENCES_FILE_NAME,0);
Ouvrez l'éditeur et ajoutez des paires clé-valeur
SharedPreferences.Editor myeditor = settingsfile.edit();
myeditor.putBoolean("IITAMIYO", true);
myeditor.putFloat("VOLUME", 0.7)
myeditor.putInt("BORDER", 2)
myeditor.putLong("SIZE", 12345678910L)
myeditor.putString("Name", "Amiyo")
myeditor.apply();
N’oubliez pas d’appliquer/enregistrer en utilisant myeditor.apply() comme indiqué ci-dessus.
Récupération des données
SharedPreferences mysettings= getSharedPreferences(PREFERENCES_FILE_NAME, 0);
IITAMIYO = mysettings.getBoolean("IITAMIYO", false);
//returns value for the given key.
//second parameter gives the default value if no user preference found
// (set to false in above case)
VOLUME = mysettings.getFloat("VOLUME", 0.5)
//0.5 being the default value if no volume preferences found
// and similarly there are get methods for other data types
public class Preferences {
public static final String PREF_NAME = "your preferences name";
@SuppressWarnings("deprecation")
public static final int MODE = Context.MODE_WORLD_WRITEABLE;
public static final String USER_ID = "USER_ID_NEW";
public static final String USER_NAME = "USER_NAME";
public static final String NAME = "NAME";
public static final String EMAIL = "EMAIL";
public static final String PHONE = "PHONE";
public static final String address = "address";
public static void writeBoolean(Context context, String key, boolean value) {
getEditor(context).putBoolean(key, value).commit();
}
public static boolean readBoolean(Context context, String key,
boolean defValue) {
return getPreferences(context).getBoolean(key, defValue);
}
public static void writeInteger(Context context, String key, int value) {
getEditor(context).putInt(key, value).commit();
}
public static int readInteger(Context context, String key, int defValue) {
return getPreferences(context).getInt(key, defValue);
}
public static void writeString(Context context, String key, String value) {
getEditor(context).putString(key, value).commit();
}
public static String readString(Context context, String key, String defValue) {
return getPreferences(context).getString(key, defValue);
}
public static void writeFloat(Context context, String key, float value) {
getEditor(context).putFloat(key, value).commit();
}
public static float readFloat(Context context, String key, float defValue) {
return getPreferences(context).getFloat(key, defValue);
}
public static void writeLong(Context context, String key, long value) {
getEditor(context).putLong(key, value).commit();
}
public static long readLong(Context context, String key, long defValue) {
return getPreferences(context).getLong(key, defValue);
}
public static SharedPreferences getPreferences(Context context) {
return context.getSharedPreferences(PREF_NAME, MODE);
}
public static Editor getEditor(Context context) {
return getPreferences(context).edit();
}
}
**** Utilisez les préférences pour écrire la valeur en utilisant: - ****
Preferences.writeString(getApplicationContext(),
Preferences.NAME, "dev");
**** Utilisez les préférences pour lire la valeur en utilisant: - ****
Preferences.readString(getApplicationContext(), Preferences.NAME,
"");
Le meilleur moyen de créer SharedPreference et pour une utilisation globale, vous devez créer une classe comme ci-dessous:
public class PreferenceHelperDemo {
private final SharedPreferences mPrefs;
public PreferenceHelperDemo(Context context) {
mPrefs = PreferenceManager.getDefaultSharedPreferences(context);
}
private String PREF_Key= "Key";
public String getKey() {
String str = mPrefs.getString(PREF_Key, "");
return str;
}
public void setKey(String pREF_Key) {
Editor mEditor = mPrefs.edit();
mEditor.putString(PREF_Key, pREF_Key);
mEditor.commit();
}
}
SharedPreferences mPref;
SharedPreferences.Editor editor;
public SharedPrefrences(Context mContext) {
mPref = mContext.getSharedPreferences(Constant.SharedPreferences, Context.MODE_PRIVATE);
editor=mPref.edit();
}
public void setLocation(String latitude, String longitude) {
SharedPreferences.Editor editor = mPref.edit();
editor.putString("latitude", latitude);
editor.putString("longitude", longitude);
editor.apply();
}
public String getLatitude() {
return mPref.getString("latitude", "");
}
public String getLongitude() {
return mPref.getString("longitude", "");
}
public void setGCM(String gcm_id, String device_id) {
editor.putString("gcm_id", gcm_id);
editor.putString("device_id", device_id);
editor.apply();
}
public String getGCMId() {
return mPref.getString("gcm_id", "");
}
public String getDeviceId() {
return mPref.getString("device_id", "");
}
public void setUserData(User user){
Gson gson = new Gson();
String json = gson.toJson(user);
editor.putString("user", json);
editor.apply();
}
public User getUserData(){
Gson gson = new Gson();
String json = mPref.getString("user", "");
User user = gson.fromJson(json, User.class);
return user;
}
public void setSocialMediaStatus(SocialMedialStatus status){
Gson gson = new Gson();
String json = gson.toJson(status);
editor.putString("status", json);
editor.apply();
}
public SocialMedialStatus getSocialMediaStatus(){
Gson gson = new Gson();
String json = mPref.getString("status", "");
SocialMedialStatus status = gson.fromJson(json, SocialMedialStatus.class);
return status;
}
Écrire dans les préférences partagées
SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putInt(getString(R.string.saved_high_score), newHighScore);
editor.commit();
Lecture à partir des préférences partagées
SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
int defaultValue = getResources().getInteger(R.string.saved_high_score_default);
long highScore = sharedPref.getInt(getString(R.string.saved_high_score), defaultValue);
// Create object of SharedPreferences.
SharedPreferences sharedPref = getSharedPreferences("mypref", 0);
//now get Editor
SharedPreferences.Editor editor = sharedPref.edit();
//put your value
editor.putString("name", required_Text);
//commits your edits
editor.commit();
// Its used to retrieve data
SharedPreferences sharedPref = getSharedPreferences("mypref", 0);
String name = sharedPref.getString("name", "");
if (name.equalsIgnoreCase("required_Text")) {
Log.v("Matched","Required Text Matched");
} else {
Log.v("Not Matched","Required Text Not Matched");
}
Vous pouvez également jeter un coup d'œil sur un passé exemple de projet du mien, écrit à cet effet. J'enregistre localement un nom et le récupère à la demande de l'utilisateur ou au démarrage de l'application.
Mais, à ce stade, il serait préférable d’utiliser commit (au lieu de apply) pour conserver les données. Plus d'infos ici .
Initialise here..
SharedPreferences msharedpref = getSharedPreferences("msh",
MODE_PRIVATE);
Editor editor = msharedpref.edit();
store data...
editor.putString("id",uida); //uida is your string to be stored
editor.commit();
finish();
fetch...
SharedPreferences prefs = this.getSharedPreferences("msh", Context.MODE_PRIVATE);
uida = prefs.getString("id", "");
Les préférences partagées sont si faciles à apprendre, alors jetez un œil à ce simple tutoriel sur sharedpreference
import Android.os.Bundle;
import Android.preference.PreferenceActivity;
public class UserSettingActivity extends PreferenceActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.settings);
}
}
SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putInt(getString(R.string.saved_high_score), newHighScore);
editor.commit();