L'Écriture De Classe Singleton Pour Gérer Android SharedPreferences

je suis en train d'écrire une classe singleton pour superviser toutes les opérations impliquant des préférences partagées.

J'ai 3 fichiers de préférences, général, paramètres, et temp

Je veux être en mesure d'utiliser cette classe pour écrire une préférence d'un type donné, par exemple:

stg_full_screen: true //as boolean

C'est ce que j'ai fait jusqu'à présent:

import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;
public class SharedPrefManager extends Activity {
//Globals
private int GENERAL             = 1000;
private int SETTINGS            = 2000;
private int TEMP_STORE          = 3000;
private String PREF_GENERAL     = "com.example.general";
private String PREF_SETTINGS    = "com.example.settings";
private String PREF_TEMP_STORE  = "com.example.temp_store";
private SharedPreferences general;
private SharedPreferences settings;
private SharedPreferences tempStore;
private SharedPreferences.Editor general_editor;
private SharedPreferences.Editor settings_editor;
private SharedPreferences.Editor temp_store_editor;
//Instantiate singleton object
private static SharedPrefManager ourInstance = new SharedPrefManager();
public static SharedPrefManager getInstance() { return ourInstance; }
private SharedPrefManager() {
//Get handle on all preference files
general   = getSharedPreferences(PREF_GENERAL, Context.MODE_PRIVATE);
settings  = getSharedPreferences(PREF_SETTINGS, Context.MODE_PRIVATE);
tempStore = getSharedPreferences(PREF_TEMP_STORE, Context.MODE_PRIVATE);
//provision editors for all preference files
general_editor    = general.edit();
settings_editor   = settings.edit();
temp_store_editor = tempStore.edit();
}
private String read_prefs (String pref_name) {
//this method reads a preference and returns it
//ideally, i would want to be able to return appropriate types by request
//e.g boolean, string
return null;
}
private void write_prefs (String pref_name, String pref_val) {
//this method would take a preference and write the appropriate type to prefs
}
//this method determines where to put a preference by checking the name of the key
//this works because i use the following naming conventions
//stg_name for settings, tmp_name for all that goes into tempStore
private String resolve_pref_category (String path) {
if (path.startsWith("stn"))         return PREF_SETTINGS;
else if (path.startsWith("tmp"))    return PREF_TEMP_STORE;
else                                return PREF_GENERAL;
}
}

Ma question est:

Est-ce une chose sage à faire?
Comment puis-je déterminer efficacement le type d'une préférence?

Grâce

"Est-ce une chose sage à faire?" - NON! Le Android Activity classe est un cas particulier de la classe Java et vous ne devez pas créer de static champs ou de méthodes et de s'attendre à des choses à travailler. Un Activity est conçu comme un framework d'INTERFACE - en d'autres termes, si vous n'avez pas besoin d'une INTERFACE, puis ne pas utiliser un Activity. Par tous les moyens, de créer une classe qui étend SharedPreferences fonctionnalités mais ne le faites pas avec un Activity.
Je vous recommande fortement de regarder dans AndroidAnnotations -- je suis un grand fan de leur élégant partagé préférences de gestion. Il semble que vous essayez de faire, mais avec presque aucun code n'est requis.
AndroidAnnotations a l'air vraiment intéressant, je me demande juste si il y a tout connu inconvénients? Je n'ai pas pris assez profond regard, donc ne sais pas comment il fonctionne, donc je vous serais reconnaissant de tout haut niveau idées dans ce domaine. Merci
Je l'ai utilisé sur quelques projets, aucun des inconvénients que je peux voir. Il génère un code basé sur les annotations, que certaines personnes n'aiment pas, mais il fonctionne en douceur et le mode de génération de code signifie qu'aucune exécution des performances. Leur gestion du partage des préférences est génial et permet de réduire le temps qu'il faut pour écrire du code comme vous le mentionnez. C'est certainement la peine d'essayer.
merci, j'aime ce que je vois, je crois que je suis accro 🙂

OriginalL'auteur T. Rex | 2013-10-26

android sharedpreferences

Habituellement, j'utilise quelque chose comme ceci:

Pas statique Context de référence, statique getter/setter pour chaque propriété, lorsque nécessaire, vous pouvez ajouter de la mémoire cache de la valeur de certains biens pour obtenir plus rapidement de la mémoire au lieu de la lecture de SharedPreferences. Claire api.

public class SharedPreferencesManager {
private static final String APP_SETTINGS = "APP_SETTINGS";
//properties
private static final String SOME_STRING_VALUE = "SOME_STRING_VALUE";
//other properties...
private SharedPreferencesManager() {}
private static SharedPreferences getSharedPreferences(Context context) {
return context.getSharedPreferences(APP_SETTINGS, Context.MODE_PRIVATE);
}
public static String getSomeStringValue(Context context) {
return getSharedPreferences(context).getString(SOME_STRING_VALUE , null);
}
public static void setSomeStringValue(Context context, String newValue) {
final SharedPreferences.Editor editor = getSharedPreferences(context).edit();
editor.putString(SOME_STRING_VALUE , newValue);
editor.commit();
}
//other getters/setters
}

Ce qui sur le partage d'un seul SharedPreferences instance sans appel getSharedPreferences() à chaque fois? Est-il fiable?
Oui, vous pouvez le faire, bien sûr
C'est génial, plus facile que de les maintenir à l'aide de 4 lignes de code partout. Merci!

OriginalL'auteur Artem Zinnatullin

Bon Singleton Partagé Les Préférences De La Classe. il peut aider pour d'autres à l'avenir.

import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;
public class SharedPref
{
private static SharedPreferences mSharedPref;
public static final String NAME = "NAME";
public static final String AGE = "AGE";
public static final String IS_SELECT = "IS_SELECT";
private SharedPref()
{
}
public static void init(Context context)
{
if(mSharedPref == null)
mSharedPref = context.getSharedPreferences(context.getPackageName(), Activity.MODE_PRIVATE);
}
public static String read(String key, String defValue) {
return mSharedPref.getString(key, defValue);
}
public static void write(String key, String value) {
SharedPreferences.Editor prefsEditor = mSharedPref.edit();
prefsEditor.putString(key, value);
prefsEditor.commit();
}
public static boolean read(String key, boolean defValue) {
return mSharedPref.getBoolean(key, defValue);
}
public static void write(String key, boolean value) {
SharedPreferences.Editor prefsEditor = mSharedPref.edit();
prefsEditor.putBoolean(key, value);
prefsEditor.commit();
}
public static Integer read(String key, int defValue) {
return mSharedPref.getInt(key, defValue);
}
public static void write(String key, Integer value) {
SharedPreferences.Editor prefsEditor = mSharedPref.edit();
prefsEditor.putInt(key, value).commit();
}
}

Appelez simplement SharedPref.init() sur MainActivity une fois

SharedPref.init(getApplicationContext());

*Écrire les données *

    SharedPref.write(SharedPref.NAME, "XXXX");//save string in shared preference.
SharedPref.write(SharedPref.AGE, "25");//save int in shared preference.
SharedPref.write(SharedPref.IS_SELECT, true);//save boolean in shared preference.

Lire Les Données

    String name = SharedPref.read(SharedPref.NAME, null);//read string in shared preference.
String age = SharedPref.read(SharedPref.AGE, 0);//read int in shared preference.
String isSelect = SharedPref.read(SharedPref.IS_SELECT, false);//read boolean in shared preference.

*Sortie : *

Name : "XXXX";
Age : "25";
IsSelect : "true";

pourquoi cette réponse n'est pas upvoted?
est-il obligatoire d'init dans toutes les activités où que j'utilise
mieux passer contexte de l'application et de ne pas contexte d'activité. j'.e getcontexteapplication()
Fantastique réponse!
Désolé pour le retard de réponse. Puisque toutes les variables et fonctions sont statiques, vous n'avez qu'à initialiser une fois dans votre application.

OriginalL'auteur Magesh Pandian

Kotlin solution:

object PrefsHelper {
private lateinit var prefs: SharedPreferences
private const val PREFS_NAME = "params"
const val ID_USER = "id_user"
const val TOKEN = "token"
fun init(context: Context) {
prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
}
fun read(key: String, value: String): String? {
return prefs.getString(key, value)
}
fun read(key: String, value: Long): Long? {
return prefs.getLong(key, value)
}
fun write(key: String, value: String) {
val prefsEditor: SharedPreferences.Editor = prefs.edit()
with(prefsEditor) {
putString(key, value)
commit()
}
}
fun write(key: String, value: Long) {
val prefsEditor: SharedPreferences.Editor = prefs.edit()
with(prefsEditor) {
putLong(key, value)
commit()
}
}
}

Appel init() fonction première application.

OriginalL'auteur EAMax

Vous devez vous connecter pour publier un commentaire.