Android App Configuration: Rapid Development

When developing mobile applications, it is often necessary to store the settings of the application (the color theme chosen by the user, the password to access the application, the synchronization settings with the server, etc.). Since such tasks occur quite often, Google took care of the developers and created a mechanism for quick and easy implementation of this functionality. This mechanism allows you to easily create, save, display and produce various manipulations with the settings of the application. Moreover, it allows you to automatically create a user interface. When describing the type of the settings parameter, a part of the user interface is automatically generated depending on the type of the parameter (boolean - checkbox, String - input field, ...) without writing code. Sounds good for fast development, right?

The first step in implementing the application settings mechanism is inheriting the activity of your application's screen from the PreferenceActivity class. This class is inherited from the ListActivity class .
and allows you to create a user interface as described in the XML resource file. Moreover, this class allows you to automatically save settings in SharedPreferences imperceptibly for you. SharedPreferences - an interface that allows you to access and manipulate application configuration data manually by calling the getSharedPreferences method from your Activity (read more Android Essentials: Application Preferences ). In order to link together our class inherited from PreferenceActivity and an XML file describing configuration parameters, use the addPreferencesFromResource method:

1. ...
2. @Override
3. public void onCreate ( Bundle savedInstanceState ) {
4. super . onCreate ( savedInstanceState ) ;
5. addPreferencesFromResource ( R. xml . preferences ) ;
6. }
7. ...

Now you need to create a res / xml / preferences.xml file which is a description of our list of application configuration options and will be picked up by our PreferenceActivity . This XML file has a specific format allowing the description of configuration parameter types. All types derive from the Preference class, which is the base unit of the user interface and generates a View that will subsequently appear in the right place of the user interface and will be associated with a SharedPreferences object that can be retrieved and saved. Consider the frequently used subclasses used to describe the types of configuration parameters:

• CheckBoxPreference : the checkbox represents a boolean type parameter.
• RingtonePreference : allows you to select a ringtone from those available on your device. The URI of the selected ringtone file will be represented as a string.
• EditTextPreference : text input string, represents parameters of type String .
• ListPreference : shows the list of possible parameter values ​​in the form of a dialog, represents parameters of type String .

It should also be noted that individual parameters can be grouped into categories using the PreferenceCategory class, which groups Preference objects and displays an inactive group header.

Now we describe what we want to see in our XML description. We will have two categories. In the first place a CheckBoxPreference which will activate / deactivate the data synchronization of our hypothetical application and the ListPreference in which we will set the data synchronization frequency. As you have probably noticed, there is a dependency between these two parameters; if the first is not selected, then the second must be deactivated. This is achieved by using the android: dependency attribute. In the second category we will place the EditTextPreference with which we will set the greeting text. Imagine all this in the form of XML:

1. <? xml version = "1.0" encoding = "utf-8" ?>
3. <PreferenceScreen xmlns: android = " schemas.android.com/apk/res/android" >
5. <PreferenceCategory
6. android: title = "First Category"
7. android: key = "first_category" >
9. <CheckBoxPreference
10. android: key = "perform_updates"
11. android: summary = "Enable or disable data updates"
12. android: title = "Enable updates"
13. android: defaultValue = "true"
14. />
16. <ListPreference
17. android: key = "updates_interval"
18. android: title = "Updates interval"
19. android: summary = "Define how often updates will be performed"
20. android: defaultValue = "1000"
21. android: entries = "@ array / updateInterval"
22. android: entryValues = "@ array / updateIntervalValues"
23. android: dependency = "perform_updates"
24. />
26. </ PreferenceCategory >
28. <PreferenceCategory
29. android: title = "Second Category"
30. android: key = "second_category" >
32. <EditTextPreference
33. android: key = "welcome_message"
34. android: title = "Welcome Message"
35. android: summary = "Define
36. android: dialogTitle = "Welcome Message"
37. android: dialogMessage = "Provide a message"
38. android: defaultValue = "Default welcome message" />
40. </ PreferenceCategory >
42. </ PreferenceScreen >

Notice that for the ListPreference we specified an attribute android: entries which indicates where the possible values ​​of the list are stored. These values ​​are stored in the res / values ​​/ arrays.xml XML file. The values ​​of “updateInterval” and “updateIntervalValue” are stored in this file. In fact, these are just key-value pairs, the keys are stored in the first array, and the values ​​are in the second:

1. <? xml version = "1.0" encoding = "utf-8" ?>
3. <resources >
5. <string-array name = "updateInterval" >
6. <item name = "1000" > Every 1 second </ item >
7. <item name = "5000" > Every 5 seconds </ item >
8. <item name = "30000" > Every 30 seconds </ item >
9. <item name = "60000" > Every 1 minute </ item >
10. <item name = "300000" > Every 5 minutes </ item >
11. </ string-array >
13. <string-array name = "updateIntervalValues" >
14. <item name = "1000" > 1000 </ item >
15. <item name = "5000" > 5000 </ item >
16. <item name = "30000" > 30000 </ item >
17. <item name = "60000" > 60000 </ item >
18. <item name = "300000" > 300000 </ item >
19. </ string-array >
21. </ resources >

I will add one more useful point that can be useful. It is often necessary to restrict access to the application using a password or PIN code that is set in the application configuration. It is obvious that for these purposes EditTextPreference is used. But it would be nice in the case of a password or PIN-code to hide the entered characters, and for the code also to restrict input to numbers only. To do this, you can use the attributes android: password and android: inputType respectively:

1. <EditTextPreference
2. android: key = "pin"
3. android: title = "PIN code"
4. android: summary = "If login screen is enabled"
5. android: dialogTitle = "PIN code"
6. android: dialogMessage = "Provide a PIN"
7. android: defaultValue = ""
8. android: inputType = "number"
9. android: password = "true"
10. android: dependency = "runLoginScreen"
11. />

As mentioned above, the main part of the work is undertaken by the andriod framework itself. In order to show how to read already set parameters, we will create another screen activity, which will be launched from our main activity. But first look at the main code:

1. package com.javacodegeeks.android.preferences ;
3. import android.content.Intent ;
4. import android.os.Bundle ;
5. import android.preference.PreferenceActivity ;
6. import android.view.Menu ;
7. import android.view.MenuItem ;
9. public class QuickPrefsActivity extends PreferenceActivity {
11. @Override
12. public void onCreate ( Bundle savedInstanceState ) {
13. super . onCreate ( savedInstanceState ) ;
14. addPreferencesFromResource ( R. xml . preferences ) ;
15. }
17. @Override
18. public boolean onCreateOptionsMenu ( Menu menu ) {
19. menu. add ( Menu . NONE , 0 , 0 , "Show current settings" ) ;
20. return super . onCreateOptionsMenu ( menu ) ;
21. }
23. @Override
24. public boolean onOptionsItemSelected ( MenuItem item ) {
25. switch ( item. getItemId ( ) ) {
26. case 0 :
27. startActivity ( new Intent ( this , ShowSettingsActivity. class ) ) ;
28. return true ;
29. }
30. return false ;
31. }
33. }

We created an optional menu with a single MenuItem item using the onCreateOptionsMenu method. When a user clicks on a menu item, we process this event in the onOptionsItemSelected method and start a new activity using the startActivity method. (more details using the options menus and customized dialogs for user interaction , Launching new activities with intents ).
')
Now we will create the second ShowSettingsActivity activity to display the application configuration parameters. But first we need to describe the new activity in the manifest AndroidManifest.xml file:

1. <? xml version = "1.0" encoding = "utf-8" ?>
3. <manifest xmlns: android = " schemas.android.com/apk/res/android"
4. package = "com.javacodegeeks.android.preferences"
5. android: versionCode = "1"
6. android: versionName = "1.0" >
8. <application android: icon = "@ drawable / icon" android: label = "@ string / app_name" >
10. <activity android: name = ".QuickPrefsActivity" android: label = "@ string / app_name" >
11. <intent-filter >
12. <action android: name = "android.intent.action.MAIN" />
13. <category android: name = "android.intent.category.LAUNCHER" />
14. </ intent-filter >
15. </ activity >
17. <activity android: name = ".ShowSettingsActivity" />
19. </ application >
21. <uses-sdk android: minSdkVersion = "3" />
23. </ manifest >

The second activity code looks like this:

1. package com.javacodegeeks.android.preferences ;
3. import android.app.Activity ;
4. import android.content.SharedPreferences ;
5. import android.os.Bundle ;
6. import android.preference.PreferenceManager ;
7. import android.widget.TextView ;
9. public class ShowSettingsActivity extends Activity {
11. @Override
12. protected void onCreate ( Bundle savedInstanceState ) {
14. super . onCreate ( savedInstanceState ) ;
15. setContentView ( R. layout . show_settings_layout ) ;
17. SharedPreferences sharedPrefs = PreferenceManager. getDefaultSharedPreferences ( this ) ;
19. StringBuilder builder = new StringBuilder ( ) ;
21. builder. append ( "n" + sharedPrefs. getBoolean ( "perform_updates" , false ) ) ;
22. builder. append ( "n" + sharedPrefs. getString ( "updates_interval" , "-1" ) ) ;
23. builder. append ( "n" + sharedPrefs. getString ( "welcome_message" , "NULL" ) ) ;
25. TextView settingsTextView = ( TextView ) findViewById ( R. id . Settings_text_view ) ;
26. settingsTextView. setText ( builder. toString ( ) ) ;
28. }
30. }

Here we retrieve application configuration parameters as a SharedPreferences class using the static getDefaultSharedPreferences method of the PreferenceManager class. Further, depending on the data type of the parameter, we use the appropriate data retrieval method (for example, getBoolean or getString ). The second argument in the data extraction method is the default value, in case a parameter with that name has not yet been specified. As parameter names, we use the keys specified in the XML file preferences.xml . Parameter values ​​are concatenated and displayed in a TextView .

Here is a simple user interface description for the second activity:

1. <? xml version = "1.0" encoding = "utf-8" ?>
3. <LinearLayout
4. xmlns: android = " schemas.android.com/apk/res/android"
5. android: orientation = "vertical"
6. android: layout_width = "fill_parent"
7. android: layout_height = "fill_parent"
8. >
10. <Textview
11. android: id = "@ + id / settings_text_view"
12. android: layout_width = "fill_parent"
13. android: layout_height = "wrap_content"
14. />
16. </ LinearLayout >

Let's run the application, we will see a list of our parameters:



Click on “Updates Interval” and see a list of possible values:



Click on the “Welcome Message” and see the editing of the greeting text:



Let's look at the set parameters. Click the menu button and select the single item “Show current settings”. Start the second activity in which we will see the values ​​of our configuration parameters:



It's all. As you can see, it is really easy. Good luck!

Original: Android Quick Preferences Tutorial