I've come across two classes being used in a tutorial on splash screens PreferenceManager and SharedPreferences. I didn't gain a great deal of knowledge about them from the tutorial though.
So can someone explain to me what both classes do or are used for?
From the Android Developer site:
PreferenceManager:
Used to help create Preference hierarchies from activities or XML.
SharedPreferences:
Interface for accessing and modifying preference data returned by
getSharedPreferences(String, int). For any particular set of
preferences, there is a single instance of this class that all clients
share.
Put simply, PreferenceManager is normally used when you want to create a PreferenceActivity or load in some Preferences from an .xml file in your application with default values, and holds it's own referenced to SharedPreferences.
SharedPreferences is where you handle the storing and retrieving of key/value pairs that make up your preferences. So you can add variables with keys to retrieve the data later. This feeds into the PreferenceManager which can handle adding default values and setting up the default SharedPreferences.
You can use SharedPreferences throughout your application without needing to use PreferenceManager, but the opposite isn't strictly true.
Further reading:
PreferenceActivity (also PreferenceFragment), which uses
PreferenceManager in the examples.
Android Data Storage which
uses SharedPreferences (as well as other options).
Vogella article on Android Persistence.
StackOverflow issue on using SharedPreferences correctly.
Preferences is an Android lightweight mechanism to store and retrieve pairs
of primitive data types (also called Maps, and Associative Arrays).
In each entry of the form the key is a string and the value must be a primitive data type.
WHEN WE NEED THEM:
PREFERENCES are typically used to keep state information and shared data
among several activities of an application.
Shared Preferences is the storage, in android, that you can use to store some basic things related to functionality, users' customization or its profile.
Suppose you want to save user's name in your app for future purposes. You cant save such a little thing in database, So you better keep it saved in your Preferences. Preferences is just like a file , from which you can retrieve value anytime in application's lifetime in a KEY-VALUE pair manner.
Take another example, If you use whatsapp, we have a wallpaper option there. How the application knows which image serves as wall-paper for you whenever you open your whatsapp. This information is stored in preferences. Whenever you clear data for any app, preferences are deleted.
HOW TO USE THESE PREFERENCES :
final int mode = Activity.MODE_PRIVATE;
final String MYPREFS = "MyPreferences_001";
// create a reference to the shared preferences object
SharedPreferences mySharedPreferences;
// obtain an editor to add data to my SharedPreferences object
SharedPreferences.Editor myEditor;
mySharedPreferences = getSharedPreferences(MYPREFS, 0);
// using this instance you can get any value saved.
mySharedPreferences.getInt("backColor",Color.BLACK); // default value is BLACK set here
EDITING SHARED PREFERENCES :
myEditor = mySharedPreferences.edit();
//edit and commit
myEditor.putString("backColor", Color.RED);
myEditor.commit() //very imp.
As explained Artoo Detoo... Sharedpreferences kinda works like sessions in web development. you can use them to pass values from one activity to another and it stays that way as far as the app is in use except otherwise changed..
it is also use to user value (either after login or registration of the user). thats how much i can talk about it
SharedPreference APIs are used to save key-value pairs. They store them in files and are private or public based on the mode you instantiate the SharedPreference object. They are used to store a small set of key-value pairs. This key here is of type String and the value can be any primitive type.
PreferenceManager is part of the Preference APIs. Preference API allows you to define a complete settings UI. This settings UI is an XML layout. You use a PreferenceManager to manage this Preference object's tree. It uses the SharedPreference APIs to store the various settings a user might change using that graphical layout you created.
Reference - "Android Docs Training"
Related
I have dialog for storing user preferences of the application which is developed using Java Swing. There are 20+ preferences and I would like to notify other modules when the particular preference changes. I know that I can hold a list of listeners and notify them whenever the preferences change. However, I would like to know about two issues:
How can I bind my Swing components to a bean object,
How can I fire an event when the preferences change,
Dependending your experience, how would you resolve that architecture? What are the best practices to follow?
Thanks
I developed a Swing application where the user could modify some parameters to change functionality or the graphic of the application.
I approached it this way:
A general Setting abstract class represent a single value that the user can change.
A subclass is created for different types of value, in my case: boolean, integer, floating points, colors, etc.
I use a Map to keep track of the created Setting and a Preferences object to store the values.
For the actual settings, I create a static attribute somewhere (in my case, dedicated classes for different logical groups of settings) and use that attribute to read and change the values fo the settings.
PRO: The Settings keeps track of all the settings instantiated, so I don't need to code the frame for changing them twice, I just did it once in an indipendent way from the number of the settings
CONS: It clearly requires changing the code to add a new setting. While in my case it was not an issue because a new setting was needed only because of other changes in the code, in your case it might be.
My Android project need share a List<Right> rights between Activities. The value of this list is initiated in LoginActivity. In other Activity, i use this list to check right of user (if user has a correspondence right, app will show correspondence tab or do something else). The problem i meet is how to store List<Right> rights in my Android application. I have read many Post and people use Gson and Flexjson to change this list to String and use SharedPreferences.Editor putString (String key,String value) to store in SharedPreferences. In other Activity, use preferences.getString("girl_heart_key", "DEFAULT"); to get String and Deserialize it to List<Right> rights. But i think we can use a global static variable:
public static List<RightObject>rights = new ArrayList<RightObject>();
to share List<RightObject>rights between Activities.
My question is: can we use global static variable to replace SharePrefrence in this case? and Is there any risk( about performance, security or memory) ?
NO, it's not recommended to do it.
global static variable has same lifetime as your Application, data will be destroyed once Application is finished. SharedPreference on the other hand can persist the data until user has clear the storage/cache of your app through app settings.
The better approach is to have a Repository that can be shared as a DataSource for your application.
In case you accidentally have a static reference to a Context, than there will be a memory leak.
see more Android : Static Fields and Memory Leaks
When to use static variable and sharedpreference in android.
Which is the best to use. Can anyone explain with example.
Thanks in advance.
You can use static when there is not huge amount of data in the application.
sharedpreference can be used if the data is more also and can be stored and retrieved as and when it is required.
If you stored a value in a static variable and kill the application from recent(pressing Home button and clean all the running apps) then your value kept in static variable will be lost. But if you saved it in shared preference then you can read the saved value whether the application is killed from recent or not.
Shared Preferences is used to store and retrieved values.
There are plenty of link available :
1.Shared Preferences
2.Shared Preferences
Thanks for reading. I create a SharedPreferences object from the application context:
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
Is there a problem using this prefs object for the life of the application in a singleton class? or is it better to grab the object as needed?
I don't think that there's any real harm in holding on to a SharedPreferences instance, but I do think that it is poor style.
In general, you should give variables as small a scope as possible - instantiate them where you need them, and get rid of them (have them go out of scope) as soon as you no longer need them.
SharedPreferences already is a singleton - no need for you to duplicate that.
PreferenceManager.getDefaultSharedPreferences(getApplicationContext())
The above code itself is a singleton way to get shared preference object to that particular application. So it is suggested that use a local variable (for a block or a method) and get the access whenever needed through the above call, do the necessary operations and leave it there.
I have an application with 7 separate views. In each of those views there is an option to answer a 'yes' or 'no.' We are trying to save these 'yes' or 'no' values using shared preferences. Then, we want to have a new view/layout and be able to call those values from shared preferences. How do I go about doing that? My group and I have tried several different ways but cannot seem to get it to work. I know I don't have any code posted but it's because my code is just in bits and pieces. Thanks.
In your case I would not use getSharedPreferences() because it creates separate prefs files. Instead, you should use the main preferences file (call getPreferences() from the main Activity). This will be easier for you to manage than using shared preferences files.
I would write some code to show you how to do this, but the Android training page on this is about as clear as can be. Can you look it over and see if it answers your question? If not, post back here for clarification and I'll do what I can to help.
Here's the link to the page: https://developer.android.com/training/basics/data-storage/shared-preferences.html
Simple Do following Steps :
1)call getDefaultSharedPreferences() to create shared preferences
2) for each view just put values
3)in final view just create preference using getDefaultSharedPreferences() and then retrieve all the values
Hope this will help you