How to Get the Sharedpreferences from a Preferenceactivity in Android

How do I get the SharedPreferences from a PreferenceActivity in Android?

import android.preference.PreferenceManager;
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
// then you use
prefs.getBoolean("keystring", true);

Update

According to Shared Preferences | Android Developer Tutorial (Part 13) by Sai Geetha M N,

Many applications may provide a way to capture user preferences on the
settings of a specific application or an activity. For supporting
this, Android provides a simple set of APIs.

Preferences are typically name value pairs. They can be stored as
“Shared Preferences” across various activities in an application (note
currently it cannot be shared across processes). Or it can be
something that needs to be stored specific to an activity.

Shared Preferences: The shared preferences can be used by all the components (activities, services etc) of the applications.
Activity handled preferences: These preferences can only be used within the particular activity and can not be used by other components of the application.

Shared Preferences:

The shared preferences are managed with the help of getSharedPreferences method of the Context class. The preferences are stored in a default file (1) or you can specify a file name (2) to be used to refer to the preferences.

(1) The recommended way is to use by the default mode, without specifying the file name

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);

(2) Here is how you get the instance when you specify the file name

public static final String PREF_FILE_NAME = "PrefFile";
SharedPreferences preferences = getSharedPreferences(PREF_FILE_NAME, MODE_PRIVATE);

MODE_PRIVATE is the operating mode for the preferences. It is the default mode and means the created file will be accessed by only the calling application. Other two modes supported are MODE_WORLD_READABLE and MODE_WORLD_WRITEABLE. In MODE_WORLD_READABLE other application can read the created file but can not modify it. In case of MODE_WORLD_WRITEABLE other applications also have write permissions for the created file.

Finally, once you have the preferences instance, here is how you can retrieve the stored values from the preferences:

int storedPreference = preferences.getInt("storedInt", 0);

To store values in the preference file SharedPreference.Editor object has to be used. Editor is a nested interface in the SharedPreference class.

SharedPreferences.Editor editor = preferences.edit();
editor.putInt("storedInt", storedPreference); // value to store
editor.commit();

Editor also supports methods like remove() and clear() to delete the preference values from the file.

Activity Preferences:

The shared preferences can be used by other application components. But if you do not need to share the preferences with other components and want to have activity private preferences you can do that with the help of getPreferences() method of the activity. The getPreference method uses the getSharedPreferences() method with the name of the activity class for the preference file name.

Following is the code to get preferences

SharedPreferences preferences = getPreferences(MODE_PRIVATE);
int storedPreference = preferences.getInt("storedInt", 0);

The code to store values is also the same as in case of shared preferences.

SharedPreferences preferences = getPreference(MODE_PRIVATE);
SharedPreferences.Editor editor = preferences.edit();
editor.putInt("storedInt", storedPreference); // value to store
editor.commit();

You can also use other methods like storing the activity state in database. Note Android also contains a package called android.preference. The package defines classes to implement application preferences UI.

To see some more examples check Android's Data Storage post on developers site.

Android - How do I get sharedpreferences from another activity?

Use the following functions to add shared preferences and to fetch the saved values from all activities.

public static void setDefaults(String key, String value, Context context) {
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
    SharedPreferences.Editor editor = preferences.edit();
    editor.putString(key, value);
    editor.apply(); // or editor.commit() in case you want to write data instantly
}

public static String getDefaults(String key, Context context) {
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
    return preferences.getString(key, null);
}

add specific named SharedPreferences from resource in PreferenceActivity or PreferenceFragment

If you want to have a custom preference xml file, you need to set preference name before adding it to screen from xml in your PreferenceFragment class.

public class CustomNamePreferenceFragment extends PreferenceFragment {

    private static final String PREF_FILE_NAME = "custom_name_xml";

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        PreferenceManager preferenceManager = getPreferenceManager();
        preferenceManager.setSharedPreferencesName(PREF_FILE_NAME);
        addPreferencesFromResource(R.xml.prefs);
        ... //rest of the code
    }
}

Note : You need to set shared preference name just after the super call of onCreate() and before calling addPreferencesFromResource() method.

Android Shared preferences for creating one time activity (example)

Setting values in Preference:

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

Retrieve data from preference:

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.

More info:

Using Shared Preferences

Shared Preferences

Getting preferences outside of PreferenceActivity

Instead of

getPreferences(MODE_PRIVATE).edit().putString("otherKey","value").commit();

do:

PreferenceManager.getDefaultSharedPreferences( this ).edit().putString("otherKey","value").commit();

getPreferences() returns a "SharedPreferences object for accessing preferences that are private to this activity", according to the documentation.

Get Android shared preferences value in activity/normal class

If you have a SharedPreferenceActivity by which you have saved your values

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
String imgSett = prefs.getString(keyChannel, "");

if the value is saved in a SharedPreference in an Activity then this is the correct way to saving it.

SharedPreferences shared = getSharedPreferences(PREF_NAME, MODE_PRIVATE);
SharedPreferences.Editor editor = shared.edit();
editor.putString(keyChannel, email);
editor.commit();// commit is important here.

and this is how you can retrieve the values.

SharedPreferences shared = getSharedPreferences(PREF_NAME, MODE_PRIVATE);
String channel = (shared.getString(keyChannel, ""));

Also be aware that you can do so in a non-Activity class too but the only condition is that you need to pass the context of the Activity. use this context in to get the SharedPreferences.

mContext.getSharedPreferences(PREF_NAME, MODE_PRIVATE);

Confused on Reading SharedPreferences Without a PreferenceActivity

Hey I have used AppCompat for my preference screen too.I did this because I wanted to use Vintage Chroma and this was the only way. But I am able to use PreferenceManager.getDefaultSharedPreference() without any errors.

Also if you want to use default shared preferences in the Fragment you can use :

SharedPreferences preferences = this.getActivity().getSharedPreferences("pref", Context.MODE_PRIVATE);

Here is my full code :

public class PreferencesActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);


    getFragmentManager()
            .beginTransaction()
            .replace(android.R.id.content, new PreferencesScreen())
            .commit();

    ActionBar toolbar = getSupportActionBar();
    if (toolbar != null) {
        toolbar.setDisplayHomeAsUpEnabled(true);
    }
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    if (item.getItemId() == android.R.id.home) {
        onBackPressed();
    }
    return super.onOptionsItemSelected(item);
}

public static class PreferencesScreen extends PreferenceFragment {
    public void onCreate(Bundle savedInstanceState) {




        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.settings_xml);
    }
}

}

Here is my code snippet for MAinActivity

Just the initial part where I set the default text theme.

`public class MainActivity extends AppCompatActivity
implements NavigationView.OnNavigationItemSelectedListener {

AutoCompleteTextView mytextview;
public static String[] list;
ArrayList<String> recent = new ArrayList<String>();
public int recent_index = 0;
Menu mMenu;

@Override
protected void onCreate(Bundle savedInstanceState) {

    /*Setting default theme.*/

    SharedPreferences Sp= PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
    int firstRun=Sp.getInt("firstRun",0);
    if(firstRun==0)
    {

    SharedPreferences.Editor editor=Sp.edit();
    editor.putInt("paragraphFontColor", Color.parseColor("#ffffff"));
    editor.putInt("headingFontColor",Color.parseColor("#DE5246"));
    editor.putInt("subheadingFontColor",Color.parseColor("#597d5e"));
    editor.putInt("hyperlinksFontColor",Color.parseColor("#A5D8F5"));
    editor.putInt("bodyColor",Color.parseColor("#2b2b2b"));
    editor.putString("paragraphFont","PrintClearly.otf");
    editor.putString("headingFont","PrintBold.otf");
    editor.putString("subheadingFont","PrintBold.otf");
    editor.putString("hyperlinkFont","PrintBold.otf");
    editor.putString("paragraphFontStyle","normal");
    editor.putString("headingFontStyle","normal");
    editor.putString("subheadingFontStyle","normal");
    editor.putString("hyperlinkFontStyle","normal");
    editor.putString("actionBarColor","#597d5e");
    editor.putString("paragraphFontSize","20px");
    editor.putString("headingFontSize","30px");
    editor.putString("subheadingFontSize","20px");
    editor.putString("hyperlinkFontSize","20px");
    editor.putString("firstRun",0);
    editor.commit();
  }

SharedPreferences and PreferenceFragment

The Preferences should be saved to the default file.

To access, use PreferenceManager#getDefaultSharedPreferences()

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences (context);

context is any valid Context, including Activities.

From the documentation on PreferenceFragment:

To retrieve an instance of SharedPreferences that the preference
hierarchy in this fragment will use, call
getDefaultSharedPreferences(android.content.Context) with a context in
the same package as this fragment.

How to use SharedPreferences in Android to store, fetch and edit values

To obtain shared preferences, use the following method
In your activity:

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

To read preferences:

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

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

To edit and save preferences

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

The android sdk's sample directory contains an example of retrieving and storing shared preferences. Its located in the:

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

Edit==>

I noticed, it is important to write difference between commit() and apply() here as well.

commit() return true if value saved successfully otherwise false. It save values to SharedPreferences synchronously.

apply() was added in 2.3 and doesn't return any value either on success or failure. It saves values to SharedPreferences immediately but starts an asynchronous commit.
More detail is here.