Come utilizzare SharedPreferences in Android per archiviare, recuperare e modificare i valori [chiuso]


599

Voglio memorizzare un valore temporale e devo recuperarlo e modificarlo. Come posso usare SharedPreferencesper fare questo?


Ho implementato un wrapper GenericPreferences generico, dai un'occhiata: android-know-how-to.blogspot.co.il/2014/03/…
TacB0sS

Un approccio semplificato sarebbe usando questa libreria: github.com/viralypatel/Android-SharedPreferences-Helper ... maggiori dettagli tecnici nella mia risposta qui ...
AndroidMechanic - Viral Patel

Risposte:


838

Per ottenere preferenze condivise, utilizzare il seguente metodo Nella propria attività:

SharedPreferences prefs = this.getSharedPreferences(
      "com.example.app", Context.MODE_PRIVATE);

Per leggere le preferenze:

String dateTimeKey = "com.example.app.datetime";

// use a default value using new Date()
long l = prefs.getLong(dateTimeKey, new Date().getTime()); 

Per modificare e salvare le preferenze

Date dt = getSomeDate();
prefs.edit().putLong(dateTimeKey, dt.getTime()).apply();

La directory di esempio di Android SDK contiene un esempio di recupero e memorizzazione delle preferenze condivise. Si trova in:

<android-sdk-home>/samples/android-<platformversion>/ApiDemos directory

Modifica ==>

Ho notato che è importante scrivere la differenza tra commit()e anche apply()qui.

commit()ritorna truese il valore è stato salvato con successo altrimenti false. Salva i valori in SharedPreferences in modo sincrono .

apply()è stato aggiunto in 2.3 e non restituisce alcun valore in caso di successo o fallimento. Salva immediatamente i valori in SharedPreferences ma avvia un commit asincrono . Maggiori dettagli sono qui .


Quindi la prossima volta che l'utente esegue la mia app, il valore memorizzato è già presente e posso recuperarlo ... giusto?
Muhammad Maqsoodur Rehman,

4
(Per chiunque legga quanto sopra) Sì, è arbitrario. Questo esempio salva solo la data corrente come preferenza con il tasto "com.example.app.datetime".
MSpeed,

1
this.getSharedPreferencesmi dà il seguente errore:The method getSharedPreferences(String, int) is undefined for the type MyActivity
Si8,

15
SharedPreferences.Editor.apply () è stato introdotto in Gingerbread a novembre 2010 (dopo che questa risposta è stata pubblicata). Usalo invece di commit () ove possibile poiché apply () è più efficiente.
UpLate

4
Editor.apply () richiede il livello API 9 o successivo. sotto che usa Editor.commit ()
Lennart Rolland,

283

Per memorizzare i valori nelle preferenze condivise:

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Name","Harneet");
editor.apply();

Per recuperare i valori dalle preferenze condivise:

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
String name = preferences.getString("Name", "");
if(!name.equalsIgnoreCase(""))
{
    name = name + "  Sethi";  /* Edit the value here*/
}

17
Mi piace questa risposta al meglio perché utilizza getDefaultSharedPreferences. Per la maggior parte degli utenti questo semplificherà le cose perché è possibile accedere alle stesse preferenze nell'intera app e non devi preoccuparti di nominare il tuo file delle preferenze. Maggiori informazioni qui: stackoverflow.com/a/6310080/1839500
Dick Lucas,

Concordo ... L'ho trovato dopo aver strappato i capelli cercando di capire perché non potevo accedere alle mie preferenze condivise da un'altra attività usando il metodo nella risposta accettata. Grazie mille!
SeiAGitForNotUsingGit il

Come posso usarlo per salvare e caricare Map<DateTime, Integer>?
Dmitry,

Usa github.com/AliEsaAssadi/Android-Power-Preference per semplificare l'implementazione
Ali Asadi

164

Per modificare i dati dasharedpreference

 SharedPreferences.Editor editor = getPreferences(MODE_PRIVATE).edit();
 editor.putString("text", mSaved.getText().toString());
 editor.putInt("selection-start", mSaved.getSelectionStart());
 editor.putInt("selection-end", mSaved.getSelectionEnd());
 editor.apply();

Per recuperare i dati dasharedpreference

SharedPreferences prefs = getPreferences(MODE_PRIVATE); 
String restoredText = prefs.getString("text", null);
if (restoredText != null) 
{
  //mSaved.setText(restoredText, TextView.BufferType.EDITABLE);
  int selectionStart = prefs.getInt("selection-start", -1);
  int selectionEnd = prefs.getInt("selection-end", -1);
  /*if (selectionStart != -1 && selectionEnd != -1)
  {
     mSaved.setSelection(selectionStart, selectionEnd);
  }*/
}

modificare

Ho preso questo frammento dal campione Demo API. Aveva una EditTextscatola lì. In questo contextnon è richiesto. Sto commentando lo stesso.


12
+1, ma usa getPreferences (MODE_PRIVATE); invece di getPreferences (0); per leggibilità.
Chiave

Cos'è mSaved qui? Devo salvare 2 valori di stringa.
Muhammad Maqsoodur Rehman,

Vorrei anche sapere cos'è mSaved. Nvm penso che sia la
casella di modifica

1
cosa significa -1 in getInt ??
Amr Osama,

1
Questo è il valore predefinito che verrà restituito se la chiave (selection-start) non esiste nelle preferenze condivise. Può essere qualsiasi cosa ed è solo per riferimento.
DeRagan,

39

Scrivere :

SharedPreferences preferences = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_WORLD_WRITEABLE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Authentication_Id",userid.getText().toString());
editor.putString("Authentication_Password",password.getText().toString());
editor.putString("Authentication_Status","true");
editor.apply();

Leggere :

SharedPreferences prfs = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_PRIVATE);
String Astatus = prfs.getString("Authentication_Status", "");

MODE_WORLD_WRITEABLE è obsoleto.
Christopher Smit,

28

Il modo più semplice:

Salvare:

getPreferences(MODE_PRIVATE).edit().putString("Name of variable",value).commit();

Recuperare:

your_variable = getPreferences(MODE_PRIVATE).getString("Name of variable",default value);

Ho provato questo tra le attività e non ha funzionato. La struttura del pacchetto deve essere inclusa nel nome var?
Gaʀʀʏ

Per usare questa struttura tra le attività sostituisci getPreferences (MODE_PRIVATE) con PreferenceManager.getDefaultSharedPreferences (la tua attività)
Lucian Novac,

Usa apply () invece di commit ()
Vaibhav il

18

Impostazione dei valori in Preferenze:

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

Recupera i dati dalle preferenze:

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.
}

Ulteriori informazioni:

Utilizzo delle preferenze condivise

Preferenze condivise


Che cos'è MyPrefsFile? L'xml dell'attività delle preferenze?
Martin Erlic,

17

Classe di preferenze condivise Singleton. potrebbe aiutare per gli altri in futuro.

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

Basta chiamare SharedPref.init()il MainActivitytempo

SharedPref.init(getApplicationContext());

Scrivere dati

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.

Leggere i dati

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

15

Per memorizzare informazioni

SharedPreferences preferences = getSharedPreferences(PREFS_NAME,Context.MODE_PRIVATE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("username", username.getText().toString());
editor.putString("password", password.getText().toString());
editor.putString("logged", "logged");
editor.commit();

Per ripristinare le tue preferenze

SharedPreferences.Editor editor = preferences.edit();
editor.clear();
editor.commit();

12

Se stai creando una grande applicazione con altri sviluppatori nel tuo team e intendi avere tutto ben organizzato senza codice sparso o istanze diverse di SharedPreferences, puoi fare qualcosa del genere:

//SharedPreferences manager class
public class SharedPrefs {

    //SharedPreferences file name
    private static String SHARED_PREFS_FILE_NAME = "my_app_shared_prefs";

    //here you can centralize all your shared prefs keys
    public static String KEY_MY_SHARED_BOOLEAN = "my_shared_boolean";
    public static String KEY_MY_SHARED_FOO = "my_shared_foo";

    //get the SharedPreferences object instance
    //create SharedPreferences file if not present


    private static SharedPreferences getPrefs(Context context) {
        return context.getSharedPreferences(SHARED_PREFS_FILE_NAME, Context.MODE_PRIVATE);
    }

    //Save Booleans
    public static void savePref(Context context, String key, boolean value) {
        getPrefs(context).edit().putBoolean(key, value).commit();       
    }

    //Get Booleans
    public static boolean getBoolean(Context context, String key) {
        return getPrefs(context).getBoolean(key, false);
    }

    //Get Booleans if not found return a predefined default value
    public static boolean getBoolean(Context context, String key, boolean defaultValue) {
        return getPrefs(context).getBoolean(key, defaultValue);
    }

    //Strings
    public static void save(Context context, String key, String value) {
        getPrefs(context).edit().putString(key, value).commit();
    }

    public static String getString(Context context, String key) {
        return getPrefs(context).getString(key, "");
    }

    public static String getString(Context context, String key, String defaultValue) {
        return getPrefs(context).getString(key, defaultValue);
    }

    //Integers
    public static void save(Context context, String key, int value) {
        getPrefs(context).edit().putInt(key, value).commit();
    }

    public static int getInt(Context context, String key) {
        return getPrefs(context).getInt(key, 0);
    }

    public static int getInt(Context context, String key, int defaultValue) {
        return getPrefs(context).getInt(key, defaultValue);
    }

    //Floats
    public static void save(Context context, String key, float value) {
        getPrefs(context).edit().putFloat(key, value).commit();
    }

    public static float getFloat(Context context, String key) {
        return getPrefs(context).getFloat(key, 0);
    }

    public static float getFloat(Context context, String key, float defaultValue) {
        return getPrefs(context).getFloat(key, defaultValue);
    }

    //Longs
    public static void save(Context context, String key, long value) {
        getPrefs(context).edit().putLong(key, value).commit();
    }

    public static long getLong(Context context, String key) {
        return getPrefs(context).getLong(key, 0);
    }

    public static long getLong(Context context, String key, long defaultValue) {
        return getPrefs(context).getLong(key, defaultValue);
    }

    //StringSets
    public static void save(Context context, String key, Set<String> value) {
        getPrefs(context).edit().putStringSet(key, value).commit();
    }

    public static Set<String> getStringSet(Context context, String key) {
        return getPrefs(context).getStringSet(key, null);
    }

    public static Set<String> getStringSet(Context context, String key, Set<String> defaultValue) {
        return getPrefs(context).getStringSet(key, defaultValue);
    }
}

Nella tua attività puoi salvare SharedPreferences in questo modo

//saving a boolean into prefs
SharedPrefs.savePref(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN, booleanVar);

e puoi recuperare le tue SharedPreferences in questo modo

//getting a boolean from prefs
booleanVar = SharedPrefs.getBoolean(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN);

12

In qualsiasi applicazione, esistono preferenze predefinite a cui è possibile accedere tramite l' PreferenceManageristanza e il relativo metodo getDefaultSharedPreferences(Context).

Con l' SharedPreferenceistanza è possibile recuperare il valore int di qualsiasi preferenza con getInt (chiave String, int defVal) . La preferenza che ci interessa in questo caso è contro.

Nel nostro caso, possiamo modificare l' SharedPreferenceistanza nel nostro caso usando edit () e usare il fileputInt(String key, int newVal) Abbiamo aumentato il conteggio per la nostra applicazione che esiste oltre l'applicazione e visualizzata di conseguenza.

Per ulteriore dimostrazione, riavvia e nuovamente l'applicazione, noterai che il conteggio aumenterà ogni volta che riavvii l'applicazione.

PreferencesDemo.java

Codice:

package org.example.preferences;
import android.app.Activity;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.widget.TextView;

public class PreferencesDemo extends Activity {
   /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get the app's shared preferences
        SharedPreferences app_preferences = 
        PreferenceManager.getDefaultSharedPreferences(this);

        // Get the value for the run counter
        int counter = app_preferences.getInt("counter", 0);

        // Update the TextView
        TextView text = (TextView) findViewById(R.id.text);
        text.setText("This app has been started " + counter + " times.");

        // Increment the counter
        SharedPreferences.Editor editor = app_preferences.edit();
        editor.putInt("counter", ++counter);
        editor.commit(); // Very important
    }
}

main.xml

Codice:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:orientation="vertical"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent" >

        <TextView
            android:id="@+id/text"  
            android:layout_width="fill_parent" 
            android:layout_height="wrap_content" 
            android:text="@string/hello" />
</LinearLayout>

8

Semplice soluzione su come memorizzare il valore di accesso in SharedPreferences.

Puoi estendere la MainActivityclasse o altra classe in cui memorizzerai il "valore di qualcosa che vuoi conservare". Metti questo nelle classi di scrittori e lettori:

public static final String GAME_PREFERENCES_LOGIN = "Login";

Ecco l' InputClassinput e OutputClassla classe di output, rispettivamente.

// This is a storage, put this in a class which you can extend or in both classes:
//(input and output)
public static final String GAME_PREFERENCES_LOGIN = "Login";

// String from the text input (can be from anywhere)
String login = inputLogin.getText().toString();

// then to add a value in InputCalss "SAVE",
SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
Editor editor = example.edit();
editor.putString("value", login);
editor.commit();

Ora puoi usarlo da qualche altra parte, come altre classi. Quanto segue è OutputClass.

SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
String userString = example.getString("value", "defValue");

// the following will print it out in console
Logger.getLogger("Name of a OutputClass".class.getName()).log(Level.INFO, userString);

8

Archivia in SharedPreferences

SharedPreferences preferences = getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
Editor editor = preferences.edit();
editor.putString("name", name);
editor.commit();

Scarica in SharedPreferences

SharedPreferences preferences=getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
String name=preferences.getString("name",null);

Nota: "temp" è il nome delle preferenze condivise e "name" è il valore di input. se il valore non esce, restituisce null


Molto buono e facile da usare. Ma qui è Context.MODE_PRIVATE non getApplicationContext (). MODE_PRIVATE
Maria Gheorghe,

7

modificare

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
editor.putString("yourValue", value);
editor.commit();

Leggere

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
value= pref.getString("yourValue", "");

6

L'idea di base di SharedPreferences è di archiviare oggetti su file XML.

  1. Dichiarare il percorso del file xml (se non si dispone di questo file, Android lo creerà. Se si dispone di questo file, Android accederà a esso.)

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
  2. Scrivi valore in Preferenze condivise

    prefs.edit().putLong("preference_file_key", 1010101).apply();

    il preference_file_keyè il nome del file delle preferenze condivisi. E 1010101è il valore che devi memorizzare.

    apply()alla fine è salvare le modifiche. Se ricevi un errore da apply(), modificalo in commit(). Quindi questa frase alternativa è

    prefs.edit().putLong("preference_file_key", 1010101).commit();
  3. Leggi dalle preferenze condivise

    SharedPreferences sp = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
    long lsp = sp.getLong("preference_file_key", -1);

    lspsarà -1se preference_file_keynon ha valore. Se 'preferenza_file_key' ha un valore, restituirà il valore di questo.

L'intero codice per la scrittura è

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    prefs.edit().putLong("preference_file_key", 1010101).apply();    // Write the value to key.

Il codice per la lettura è

    SharedPreferences sf = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    long lsp = sp.getLong("preference_file_key", -1);    // Read the key and store in lsp

Editor.apply () richiede il livello API 9 o successivo. sotto che usa Editor.commit ()
Lennart Rolland,

6

Puoi salvare il valore usando questo metodo:

public void savePreferencesForReasonCode(Context context,
    String key, String value) {
    SharedPreferences sharedPreferences = PreferenceManager
    .getDefaultSharedPreferences(context);
    SharedPreferences.Editor editor = sharedPreferences.edit();
    editor.putString(key, value);
    editor.commit();
    }

E usando questo metodo puoi ottenere valore da SharedPreferences:

public String getPreferences(Context context, String prefKey) {
  SharedPreferences sharedPreferences = PreferenceManager
 .getDefaultSharedPreferences(context);
 return sharedPreferences.getString(prefKey, "");
}

Ecco prefKeyla chiave che hai usato per salvare il valore specifico. Grazie.


E i booleani?
Yousha Aleayoub,

salva usando questa riga: editor.putString (chiave, valore); usa questa linea: Boolean yourLocked = prefs.getBoolean ("bloccato", falso);
Md. Sajedul Karim,

6
editor.putString("text", mSaved.getText().toString());

Qui, mSavedpuò essere qualsiasi TextViewo EditTextda dove possiamo estrarre una stringa. puoi semplicemente specificare una stringa. Qui il testo sarà la chiave che contiene il valore ottenuto dal mSaved( TextViewo EditText).

SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);

Inoltre, non è necessario salvare il file delle preferenze utilizzando il nome del pacchetto, ad esempio "com.example.app". Puoi menzionare il tuo nome preferito. Spero che sia di aiuto !


5

Ci sono molti modi in cui le persone raccomandano come usare SharedPreferences . Ho realizzato un progetto demo qui . Il punto chiave nell'esempio è usare ApplicationContext e un singolo oggetto sharedpreferences . Questo dimostra come utilizzare SharedPreferences con le seguenti funzionalità: -

  • Utilizzo della classe singelton per accedere / aggiornare SharedPreferences
  • Non è necessario passare il contesto sempre per le preferenze condivise in lettura / scrittura
  • Usa apply () invece di commit ()
  • apply () è un salvataggio asincrono, non restituisce nulla, aggiorna prima il valore in memoria e le modifiche vengono scritte successivamente sul disco in modo asincrono.
  • commit () è sincrono save, restituisce vero / falso in base al risultato. Le modifiche vengono scritte sul disco in modo sincronizzato
  • funziona su Android 2.3+ versioni

Esempio di utilizzo come di seguito: -

MyAppPreference.getInstance().setSampleStringKey("some_value");
String value= MyAppPreference.getInstance().getSampleStringKey();

Ottieni il codice sorgente qui e le API dettagliate sono disponibili qui su developer.android.com


Ehi, ho una domanda sulle preferenze condivise. Ti dispiace rispondere? stackoverflow.com/questions/35713822/…
Ruchir Baronia

5

Le migliori pratiche di sempre

Crea un'interfaccia denominata con PreferenceManager :

// Interface to save values in shared preferences and also for retrieve values from shared preferences
public interface PreferenceManager {

    SharedPreferences getPreferences();
    Editor editPreferences();

    void setString(String key, String value);
    String getString(String key);

    void setBoolean(String key, boolean value);
    boolean getBoolean(String key);

    void setInteger(String key, int value);
    int getInteger(String key);

    void setFloat(String key, float value);
    float getFloat(String key);

}

Come usare con Attività / Frammento :

public class HomeActivity extends AppCompatActivity implements PreferenceManager{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout_activity_home);
    }

    @Override
    public SharedPreferences getPreferences(){
        return getSharedPreferences("SP_TITLE", Context.MODE_PRIVATE);
    }

    @Override
    public SharedPreferences.Editor editPreferences(){
        return getPreferences().edit();
    }

    @Override
    public void setString(String key, String value) {
        editPreferences().putString(key, value).commit();
    }

    @Override
    public String getString(String key) {
        return getPreferences().getString(key, "");
    }

    @Override
    public void setBoolean(String key, boolean value) {
        editPreferences().putBoolean(key, value).commit();
    }

    @Override
    public boolean getBoolean(String key) {
        return  getPreferences().getBoolean(key, false);
    }

    @Override
    public void setInteger(String key, int value) {
        editPreferences().putInt(key, value).commit();
    }

    @Override
    public int getInteger(String key) {
        return getPreferences().getInt(key, 0);
    }

    @Override
    public void setFloat(String key, float value) {
        editPreferences().putFloat(key, value).commit();
    }

    @Override
    public float getFloat(String key) {
        return getPreferences().getFloat(key, 0);
    }
}

Nota: sostituire la chiave di SharedPreference con SP_TITLE .

Esempi:

Memorizza stringa in shareperence :

setString("my_key", "my_value");

Ottieni stringa da shareperence :

String strValue = getString("my_key");

Spero che questo ti possa aiutare.


Uso lo stesso oggetto preferenza condiviso per archiviare tutto o creo nuovi oggetti pref condivisi per ogni diverso dato?
Ruchir Baronia,

@Ruchir Baronia, non è necessario creare oggetti diversi, dal momento che non è necessario inizializzare l'oggetto delle preferenze condivise. Puoi salvare sopra. Fammi sapere se qualcosa richiesto dalla mia parte.
Hiren Patel,

Va bene, grazie. Puoi aiutarmi con questo? stackoverflow.com/questions/35235759/…
Ruchir Baronia,

@Ruchir Baronia, puoi annullare la discussione. Spero che questo ti aiuti.
Hiren Patel,

Oh, mi dispiace così tanto, ho posto la domanda sbagliata. Volevo fare una domanda su questo, è sulle preferenze condivise :) stackoverflow.com/questions/35244256/issue-with-if-statement/…
Ruchir Baronia

5

Per memorizzare i valori nelle preferenze condivise:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = sp.edit();
editor.putString("Name","Jayesh");
editor.commit();

Per recuperare i valori dalle preferenze condivise:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
String name = sp.getString("Name", ""); // Second parameter is the default value.

4

salvare

PreferenceManager.getDefaultSharedPreferences(this).edit().putString("VarName","your value").apply();

per recuperare:

String name = PreferenceManager.getDefaultSharedPreferences(this).getString("VarName","defaultValue");

il valore predefinito è: valori da restituire se questa preferenza non esiste.

è possibile modificare " this " con getActivity () o getApplicationContext () in alcuni casi


Ehi, ho una domanda sulle preferenze condivise. Ti dispiace rispondere? stackoverflow.com/questions/35713822/…
Ruchir Baronia

Sì, l'ho fatto ... :)
Ruchir Baronia

3

Scrivo una classe di supporto per le preferenze condivise:

import android.content.Context;
import android.content.SharedPreferences;

/**
 * Created by mete_ on 23.12.2016.
 */
public class HelperSharedPref {

Context mContext;

public HelperSharedPref(Context mContext) {
    this.mContext = mContext;
}

/**
 *
 * @param key Constant RC
 * @param value Only String, Integer, Long, Float, Boolean types
 */
public void saveToSharedPref(String key, Object value) throws Exception {
    SharedPreferences.Editor editor = mContext.getSharedPreferences(key, Context.MODE_PRIVATE).edit();
    if (value instanceof String) {
        editor.putString(key, (String) value);
    } else if (value instanceof Integer) {
        editor.putInt(key, (Integer) value);
    } else if (value instanceof Long) {
        editor.putLong(key, (Long) value);
    } else if (value instanceof Float) {
        editor.putFloat(key, (Float) value);
    } else if (value instanceof Boolean) {
        editor.putBoolean(key, (Boolean) value);
    } else {
        throw new Exception("Unacceptable object type");
    }

    editor.commit();
}

/**
 * Return String
 * @param key
 * @return null default is null
 */
public String loadStringFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    String restoredText = prefs.getString(key, null);

    return restoredText;
}

/**
 * Return int
 * @param key
 * @return null default is -1
 */
public Integer loadIntegerFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Integer restoredText = prefs.getInt(key, -1);

    return restoredText;
}

/**
 * Return float
 * @param key
 * @return null default is -1
 */
public Float loadFloatFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Float restoredText = prefs.getFloat(key, -1);

    return restoredText;
}

/**
 * Return long
 * @param key
 * @return null default is -1
 */
public Long loadLongFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Long restoredText = prefs.getLong(key, -1);

    return restoredText;
}

/**
 * Return boolean
 * @param key
 * @return null default is false
 */
public Boolean loadBooleanFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Boolean restoredText = prefs.getBoolean(key, false);

    return restoredText;
}

}

3

Usa usato questo esempio semplice, chiaro e controllato

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.sairamkrishna.myapplication" >

   <application
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:theme="@style/AppTheme" >

      <activity
         android:name=".MainActivity"
         android:label="@string/app_name" >

         <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>

      </activity>

   </application>
</manifest>
public class MainActivity extends AppCompatActivity {
   EditText ed1,ed2,ed3;
   Button b1;

   public static final String MyPREFERENCES = "MyPrefs" ;
   public static final String Name = "nameKey";
   public static final String Phone = "phoneKey";
   public static final String Email = "emailKey";

   SharedPreferences sharedpreferences;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      ed1=(EditText)findViewById(R.id.editText);
      ed2=(EditText)findViewById(R.id.editText2);
      ed3=(EditText)findViewById(R.id.editText3);

      b1=(Button)findViewById(R.id.button);
      sharedpreferences = getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE);

      b1.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View v) {
            String n  = ed1.getText().toString();
            String ph  = ed2.getText().toString();
            String e  = ed3.getText().toString();

            SharedPreferences.Editor editor = sharedpreferences.edit();

            editor.putString(Name, n);
            editor.putString(Phone, ph);
            editor.putString(Email, e);
            editor.commit();
            Toast.makeText(MainActivity.this,"Thanks",Toast.LENGTH_LONG).show();
         }
      });
   }

}

2

Usando questa semplice libreria , ecco come effettuare le chiamate a SharedPreferences.

TinyDB tinydb = new TinyDB(context);

tinydb.putInt("clickCount", 2);

tinydb.putString("userName", "john");
tinydb.putBoolean("isUserMale", true); 

tinydb.putList("MyUsers", mUsersArray);
tinydb.putImagePNG("DropBox/WorkImages", "MeAtlunch.png", lunchBitmap);

//These plus the corresponding get methods are all Included

2

Volevo aggiungere qui che la maggior parte degli snippet per questa domanda avrà qualcosa come MODE_PRIVATE quando si utilizzano le condivisioni condivise. Bene, MODE_PRIVATE significa che tutto ciò che scrivi in ​​questa preferenza condivisa può essere letto solo dalla tua applicazione.

Qualunque sia la chiave che passi al metodo getSharedPreferences (), Android crea un file con quel nome e memorizza i dati delle preferenze al suo interno. Ricorda inoltre che getSharedPreferences () dovrebbe essere usato quando intendi avere più file di preferenze per la tua applicazione. Se si intende utilizzare un singolo file delle preferenze e memorizzare tutte le coppie chiave-valore, utilizzare il metodo getSharedPreference (). È strano il motivo per cui tutti (incluso me stesso) usano semplicemente il sapore getSharedPreferences () senza nemmeno capire la differenza tra i due precedenti.

Il seguente video tutorial dovrebbe aiutare https://www.youtube.com/watch?v=2PcAQ1NBy98


2

Libreria "Android-SharedPreferences-Helper" semplice e senza problemi

Meglio tardi che mai: ho creato la libreria "Android-SharedPreferences-Helper" per aiutare a ridurre la complessità e lo sforzo di utilizzo SharedPreferences. Fornisce inoltre alcune funzionalità estese. Poche cose che offre sono le seguenti:

  • Inizializzazione e configurazione di una riga
  • Selezionare facilmente se utilizzare le preferenze predefinite o un file delle preferenze personalizzato
  • Valori predefiniti predefiniti (tipo di dati predefinito) e personalizzabili (cosa si può scegliere) per ciascun tipo di dati
  • Possibilità di impostare valori predefiniti diversi per uso singolo con solo un parametro aggiuntivo
  • È possibile registrare e annullare la registrazione di OnSharedPreferenceChangeListener come per la classe predefinita
dependencies {
    ...
    ...
    compile(group: 'com.viralypatel.sharedpreferenceshelper', name: 'library', version: '1.1.0', ext: 'aar')
}

Dichiarazione dell'oggetto SharedPreferencesHelper: (consigliata a livello di classe)

SharedPreferencesHelper sph; 

Istantanea dell'oggetto SharedPreferencesHelper: (consigliato nel metodo onCreate ())

// use one of the following ways to instantiate
sph = new SharedPreferencesHelper(this); //this will use default shared preferences
sph = new SharedPreferencesHelper(this, "myappprefs"); // this will create a named shared preference file
sph = new SharedPreferencesHelper(this, "myappprefs", 0); // this will allow you to specify a mode

Inserimento di valori nelle preferenze condivise

Abbastanza semplice! A differenza del modo predefinito (quando si utilizza la classe SharedPreferences) NON è necessario chiamare .edit()e .commit()mai.

sph.putBoolean("boolKey", true);
sph.putInt("intKey", 123);
sph.putString("stringKey", "string value");
sph.putLong("longKey", 456876451);
sph.putFloat("floatKey", 1.51f);

// putStringSet is supported only for android versions above HONEYCOMB
Set name = new HashSet();
name.add("Viral");
name.add("Patel");
sph.putStringSet("name", name);

Questo è tutto! I tuoi valori sono memorizzati nelle preferenze condivise.

Ottenere valori dalle preferenze condivise

Ancora una volta, solo una semplice chiamata di metodo con il nome della chiave.

sph.getBoolean("boolKey");
sph.getInt("intKey");
sph.getString("stringKey");
sph.getLong("longKey");
sph.getFloat("floatKey");

// getStringSet is supported only for android versions above HONEYCOMB
sph.getStringSet("name");

Ha molte altre funzionalità estese

Controlla i dettagli della funzionalità estesa, le istruzioni per l'uso e l'installazione, ecc . Nella Pagina del repository GitHub .


Uso lo stesso oggetto preferenza condiviso per archiviare tutto o creo nuovi oggetti pref condivisi per ogni diverso dato?
Ruchir Baronia,

Dovresti usare lo stesso il più possibile. Questo è il punto centrale di creare questa libreria.
AndroidMechanic - Viral Patel

Ehi, ho una domanda sulle preferenze condivise. Ti dispiace rispondere? stackoverflow.com/questions/35713822/…
Ruchir Baronia

2
SharedPreferences.Editor editor = getSharedPreferences("identifier", 
MODE_PRIVATE).edit();
//identifier is the unique to fetch data from your SharedPreference.


editor.putInt("keyword", 0); 
// saved value place with 0.
//use this "keyword" to fetch saved value again.
editor.commit();//important line without this line your value is not stored in preference   

// fetch the stored data using ....

SharedPreferences prefs = getSharedPreferences("identifier", MODE_PRIVATE); 
// here both identifier will same

int fetchvalue = prefs.getInt("keyword", 0);
// here keyword will same as used above.
// 0 is default value when you nothing save in preference that time fetch value is 0.

è necessario utilizzare SharedPreferences in AdapterClass o in qualsiasi altro. quella volta basta usare questa dichiarazione e usare lo stesso culo sopra.

SharedPreferences.Editor editor = context.getSharedPreferences("idetifier", 
Context.MODE_PRIVATE).edit();
SharedPreferences prefs = context.getSharedPreferences("identifier", Context.MODE_PRIVATE);

//here context is your application context

per stringa o valore booleano

editor.putString("stringkeyword", "your string"); 
editor.putBoolean("booleankeyword","your boolean value");
editor.commit();

recuperare i dati come sopra

String fetchvalue = prefs.getString("keyword", "");
Boolean fetchvalue = prefs.getBoolean("keyword", "");

2

2.per archiviazione in prefrence condivisa

SharedPreferences.Editor editor = 
getSharedPreferences("DeviceToken",MODE_PRIVATE).edit();
                    editor.putString("DeviceTokenkey","ABABABABABABABB12345");
editor.apply();

2. per recuperare lo stesso uso

    SharedPreferences prefs = getSharedPreferences("DeviceToken", 
 MODE_PRIVATE);
  String deviceToken = prefs.getString("DeviceTokenkey", null);

1

Qui ho creato una classe Helper per utilizzare le preferenze in Android.

Questa è la classe di aiuto:

public class PrefsUtil {

public static SharedPreferences getPreference() {
    return PreferenceManager.getDefaultSharedPreferences(Applicatoin.getAppContext());
}

public static void putBoolean(String key, boolean value) {
    getPreference().edit().putBoolean(key, value)
            .apply();
}

public static boolean getBoolean(String key) {
    return getPreference().getBoolean(key, false);
}

public static void putInt(String key, int value) {

    getPreference().edit().putInt(key, value).apply();

}

public static void delKey(String key) {

    getPreference().edit().remove(key).apply();

}

}

1

Per memorizzare e recuperare variabili globali in modo funzionale. Per verificare, assicurati di avere elementi Textview sulla tua pagina, decommenta le due righe nel codice ed esegui. Quindi commentare nuovamente le due righe ed eseguire.
Qui l'id di TextView è nome utente e password.

In ogni classe in cui si desidera utilizzarlo, aggiungere queste due routine alla fine. Vorrei che questa routine fosse una routine globale, ma non so come. Questo funziona

Le variabili sono disponibili ovunque. Memorizza le variabili in "MyFile". Puoi cambiarlo a modo tuo.

Lo chiami usando

 storeSession("username","frans");
 storeSession("password","!2#4%");***

il nome utente variabile verrà riempito con "frans" e la password con "! 2 # 4%". Anche dopo un riavvio sono disponibili.

e lo recuperi usando

 password.setText(getSession(("password")));
 usernames.setText(getSession(("username")));

sotto l'intero codice del mio grid.java

    package nl.yentel.yenteldb2;
    import android.content.SharedPreferences;
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.Snackbar;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.View;
    import android.widget.EditText;
    import android.widget.TextView;

    public class Grid extends AppCompatActivity {
    private TextView usernames;
    private TextView password;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_grid);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);

      ***//  storeSession("username","frans.eilering@gmail.com");
        //storeSession("password","mijn wachtwoord");***
        password = (TextView) findViewById(R.id.password);
        password.setText(getSession(("password")));
        usernames=(TextView) findViewById(R.id.username);
        usernames.setText(getSession(("username")));
    }

    public void storeSession(String key, String waarde) { 
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        editor.putString(key, waarde);
        editor.commit();
    }

    public String getSession(String key) {
//http://androidexample.com/Android_SharedPreferences_Basics/index.php?view=article_discription&aid=126&aaid=146
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        String output = pref.getString(key, null);
        return output;
    }

    }

sotto trovi gli elementi di visualizzazione di testo

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="usernames"
    android:id="@+id/username"
    android:layout_below="@+id/textView"
    android:layout_alignParentStart="true"
    android:layout_marginTop="39dp"
    android:hint="hier komt de username" />

 <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="password"
    android:id="@+id/password"
    android:layout_below="@+id/user"
    android:layout_alignParentStart="true"
    android:hint="hier komt het wachtwoord" />

1

Ho creato una classe Helper per semplificarmi la vita. Questa è una classe generica e ha molti metodi che sono comunemente usati in App come Preferenze condivise, Validità e-mail, Formato data e ora. Copia questa classe nel tuo codice e accedi ai suoi metodi ovunque tu abbia bisogno.

 import android.app.AlertDialog;
 import android.app.ProgressDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.SharedPreferences;
 import android.support.v4.app.FragmentActivity;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.EditText;
 import android.widget.Toast;

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Random;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;

/**
* Created by Zohaib Hassan on 3/4/2016.
*/
 public class Helper {

private static ProgressDialog pd;

public static void saveData(String key, String value, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.putString(key, value);
    editor.commit();
}

public static void deleteData(String key, Context context){
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.remove(key);
    editor.commit();

}

public static String getSaveData(String key, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    String data = sp.getString(key, "");
    return data;

}




public static long dateToUnix(String dt, String format) {
    SimpleDateFormat formatter;
    Date date = null;
    long unixtime;
    formatter = new SimpleDateFormat(format);
    try {
        date = formatter.parse(dt);
    } catch (Exception ex) {

        ex.printStackTrace();
    }
    unixtime = date.getTime();
    return unixtime;

}

public static String getData(long unixTime, String formate) {

    long unixSeconds = unixTime;
    Date date = new Date(unixSeconds);
    SimpleDateFormat sdf = new SimpleDateFormat(formate);
    String formattedDate = sdf.format(date);
    return formattedDate;
}

public static String getFormattedDate(String date, String currentFormat,
                                      String desiredFormat) {
    return getData(dateToUnix(date, currentFormat), desiredFormat);
}




public static double distance(double lat1, double lon1, double lat2,
                              double lon2, char unit) {
    double theta = lon1 - lon2;
    double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2))
            + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2))
            * Math.cos(deg2rad(theta));
    dist = Math.acos(dist);
    dist = rad2deg(dist);
    dist = dist * 60 * 1.1515;
    if (unit == 'K') {
        dist = dist * 1.609344;
    } else if (unit == 'N') {
        dist = dist * 0.8684;
    }
    return (dist);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts decimal degrees to radians : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double deg2rad(double deg) {
    return (deg * Math.PI / 180.0);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts radians to decimal degrees : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double rad2deg(double rad) {
    return (rad * 180.0 / Math.PI);
}

public static int getRendNumber() {
    Random r = new Random();
    return r.nextInt(360);
}

public static void hideKeyboard(Context context, EditText editText) {
    InputMethodManager imm = (InputMethodManager) context
            .getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
}

public static void showLoder(Context context, String message) {
    pd = new ProgressDialog(context);

    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void showLoderImage(Context context, String message) {
    pd = new ProgressDialog(context);
    pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void dismissLoder() {
    pd.dismiss();
}

public static void toast(Context context, String text) {

    Toast.makeText(context, text, Toast.LENGTH_LONG).show();
}
/*
     public static Boolean connection(Context context) {
    ConnectionDetector connection = new ConnectionDetector(context);
    if (!connection.isConnectingToInternet()) {

        Helper.showAlert(context, "No Internet access...!");
        //Helper.toast(context, "No internet access..!");
        return false;
    } else
        return true;
}*/

public static void removeMapFrgment(FragmentActivity fa, int id) {

    android.support.v4.app.Fragment fragment;
    android.support.v4.app.FragmentManager fm;
    android.support.v4.app.FragmentTransaction ft;
    fm = fa.getSupportFragmentManager();
    fragment = fm.findFragmentById(id);
    ft = fa.getSupportFragmentManager().beginTransaction();
    ft.remove(fragment);
    ft.commit();

}

public static AlertDialog showDialog(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(message);

    builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            // TODO Auto-generated method stub

        }
    });

    return builder.create();
}

public static void showAlert(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setTitle("Alert");
    builder.setMessage(message)
            .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                    dialog.dismiss();
                }
            }).show();
}

public static boolean isURL(String url) {
    if (url == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern
                .compile(
                        "\\b(?:(https?|ftp|file)://|www\\.)?[-A-Z0-9+&#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]\\.[-A-Z0-9+&@#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]",
                        Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(url);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean atLeastOneChr(String string) {
    if (string == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern.compile("[a-zA-Z0-9]",
                Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(string);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean isValidEmail(String email, Context context) {
    String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        // Helper.toast(context, "Email is not valid..!");

        return false;
    }
}

public static boolean isValidUserName(String email, Context context) {
    String expression = "^[0-9a-zA-Z]+$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        Helper.toast(context, "Username is not valid..!");
        return false;
    }
}

public static boolean isValidDateSlash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd/mm/yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd-mm-yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDot(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd.mm.yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.