Gemeinsame Einstellungen zum Erstellen einer einmaligen Aktivität

Ich habe drei Aktivitäten A, B und C, wobei A und B Formulare sind und nach dem Ausfüllen und Speichern der Formulardaten in der Datenbank (SQLite). Ich verwende die Absicht von A nach B und dann von B nach C. Was ich möchte, ist, dass ich jedes Mal, wenn ich meine App öffne, C als meinen Startbildschirm haben möchte und nicht mehr A und B.

Ich denke, gemeinsame Präferenzen würden dafür funktionieren, aber ich kann kein gutes Beispiel finden, um mir einen Startplatz zu geben.

Einstellwerte in Präferenz:

// 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();

Daten aus Präferenz abrufen:

SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE); 
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.

Mehr Info:

Gemeinsame Einstellungen verwenden

Gemeinsame Einstellungen

Wie wird initialisiert?

// 0 - for private mode`
SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0); 

Editor editor = pref.edit();

Wie speichert man Daten in gemeinsamen Präferenzen?

editor.putString("key_name", "string value"); // Storing string

ODER

editor.putInt("key_name", "int value"); //Storing integer

Und Bewerbung nicht vergessen:

editor.apply();

Wie rufe ich Daten aus freigegebenen Einstellungen ab?

pref.getString("key_name", null); // getting String

pref.getInt("key_name", 0); // getting Integer

Hoffe das hilft dir 🙂

Sie können Ihre benutzerdefinierte SharedPreference-Klasse erstellen

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 "";         
    }
}

Sie können die YourPrefrence-Instanz wie folgt abrufen:

YourPreference yourPrefrence = YourPreference.getInstance(context);
yourPreference.saveData(YOUR_KEY,YOUR_VALUE);

String value = yourPreference.getData(YOUR_KEY);

Ich fand all die obigen Beispiele einfach zu verwirrend, also habe ich meine eigenen geschrieben. Codefragmente sind in Ordnung, wenn Sie wissen, was Sie tun, aber was ist mit Leuten wie mir, die das nicht tun?

Möchten Sie stattdessen eine Cut-n-Paste-Lösung? Nun, hier ist es!

Erstellen Sie eine neue Java-Datei und nennen Sie sie Keystore. Dann diesen Code einfügen:

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();
}
}

Speichern Sie diese Datei jetzt und vergessen Sie sie. Du bist fertig damit. Gehen Sie jetzt zurück zu Ihrer Aktivität und verwenden Sie sie wie folgt:

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 Preferences sind XML-Dateien zum Speichern privater primitiver Daten in Schlüssel-Wert-Paaren. Zu den Datentypen gehören Boolesche Werte, schwimmt, int, sehnt sichund Saiten.

Wenn wir einige Daten speichern möchten, auf die in der gesamten Anwendung zugegriffen werden kann, besteht eine Möglichkeit darin, sie in einer globalen Variablen zu speichern. Aber es verschwindet, sobald die Anwendung geschlossen wird. Eine andere und empfohlene Methode ist das Speichern SharedPreference. Auf die in der SharedPreferences-Datei gespeicherten Daten kann in der gesamten Anwendung zugegriffen werden, und sie bleiben auch nach dem Schließen der Anwendung oder nach Neustarts erhalten.

Gemeinsame Einstellungen speichert die Daten in Schlüssel-Wert-Paaren und kann auf die gleiche Weise aufgerufen werden.

Sie können ein Objekt von erstellen SharedPreferences mit zwei Methoden,

1).getSharedPreferences() : Mit dieser Methode können Sie mehrere SharedPreferences und ihre ersten Parameter im Namen von erstellen SharedPreferences.

2).getPreferences() : Mit dieser Methode können Sie Single erstellen SharedPreferences.

Daten speichern

Fügen Sie eine Variablendeklaration hinzu/erstellen Sie eine Einstellungsdatei

public static final String PREFERENCES_FILE_NAME = "MyAppPreferences";

Abrufen eines Handles für den Dateinamen (mit getSharedPreferences)

SharedPreferences settingsfile= getSharedPreferences(PREFERENCES_FILE_NAME,0);

Öffnen Sie den Editor und fügen Sie Schlüssel-Wert-Paare hinzu

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(); 

Anwenden/Speichern mit nicht vergessen myeditor.apply() wie oben gezeigt.

Abrufen von Daten

 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();
}

}

****Verwenden Sie Einstellungen zum Schreiben von Werten mit:-****

Preferences.writeString(getApplicationContext(),
                    Preferences.NAME, "dev");

****Verwenden Sie Einstellungen zum Lesen des Werts mit:-****

Preferences.readString(getApplicationContext(), Preferences.NAME,
                    "");

Beste Art zu erstellen SharedPreference und für die globale Verwendung müssen Sie eine Klasse wie folgt erstellen:

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.apply();
    }

}