If the previous few chapters have achieved their objective, it should now be a little clearer as to the importance of saving and restoring the state of a user interface at particular points in the lifetime of an activity. As was demonstrated in the previous chapter, failure to save and restore state can result in the user losing information entered into a screen, even when performing an action as simple as rotating the device between portrait and landscape orientations.

Saving Dynamic State

An activity, as we have already learned, is given the opportunity to save dynamic state information via a call from the runtime system to the activity’s implementation of the onSaveInstanceState() method. Passed through as an argument to the method is a reference to a Bundle object into which the method will need to store any dynamic data that needs to be saved. The Bundle object is then stored by the runtime system on behalf of the activity and subsequently passed through as an argument to the activity’s onCreate() and onRestoreInstanceState() methods if and when they are called. The data can then be retrieved from the Bundle object within these methods and used to restore the state of the activity.

Default Saving of User Interface State

The preceding chapter demonstrated the effects of failing to save state by showing how the text entered into a TextView is lost when the orientation of the device changes. In actual fact most of the view widgets included with the Android SDK already implement the behavior to automatically save and restore state under such circumstances. The only changes that need to be made to the code are to make sure that the onSaveInstanceState() and onRestoreInstanceState() override methods in the activity make calls to the equivalent methods of the super class. To see this in action, modify the two methods in the StateChangeActivity.java file so that they now read as follows:

With the changes made, run the application, enter some text into the EditText view and once again perform the orientation rotation. Note that this time the text is automatically saved and restored.

The automatic saving of state for a user interface view can be disabled in the XML layout file by setting the android:saveEnabled property to false. For the purposes of an example, we will disable the automatic state saving mechanism for the EditText view in the user interface layout and then add code to the application to manually save and restore the state of the view.

Configure the EditText view such that state will not be saved and restored in the event that the activity is restarted by editing the fragment_state_change.xml file so that the entry for the view reads as follows (note that the XML can be edited directly by clicking on the file name tab on the bottom edge of the Graphical editor panel):

After making the change, run the application, enter text and rotate the device to verify that the text is no longer saved and restored before proceeding.

The Bundle Class

The Bundle class provides a container for storing data using a key-value pair mechanism. The keys take the form of string values, whilst the values associated with those keys can be in the form of a primitive value or any object that implements the Android Parcelable interface. A wide range of classes already implements the Parcelable interface. Custom classes may be made “parcelable” by implementing the set of methods defined in the Parcelable interface (details of which can be found in the Android documentation at http://developer.android.com/reference/android/os/Parcelable.html).

The Bundle class also contains a set of methods that can be used to get and set key-value pairs for a variety of data types including both primitive types (including Boolean, char, double and float values) and objects (such as Strings and CharSequences).

For the purposes of this example, we need to make sure that the text entered into the EditText field by the user is saved into the Bundle object and subsequently restored. This will be achieved by using the putCharSequence() and getCharSequence() methods of the Bundle class respectively.

Saving the State

The first step in extending the StateChange application is to make sure that the text entered by the user is extracted from the EditText component within the onSaveInstanceState() method of the StateChangeActivity activity, and then saved as a key-value pair into the Bundle object.

In order to extract the text from the EditText object we first need to identify that object in the user interface. Clearly, this involves bridging the gap between the Java code for the activity (contained in the StateChangeActivity.java source code file) and the XML representation of the user interface (contained within the activity_state_change.xml resource file). In order to extract the text entered into the EditText component we need to gain access to that user interface object.

Each component within a user interface has associated with it a unique identifier. By default, the Graphical Layout tool constructs the ID for a newly added component from the object type followed by a sequential number (though this can, and should, be changed to something more meaningful by the developer). As can be seen by checking the Outline panel within the main Eclipse window when the activity_state_change.xml file is selected and the Graphical Layout tool displayed, the EditText component has been assigned ID editText1.

As outlined in the chapter entitled The Anatomy of an Android Application, all of the resources that make up an application are compiled into a class named R. Amongst those resources are those that define layouts, including the layout for our current activity. Within the R class is a subclass named layout, which contains the layout resources, and within that subclass is our activity_state_change layout. With this knowledge, we can make a call to the findViewById() method of our activity object to get a reference to the EditText1 object as follows:

final EditText textBox = (EditText) findViewById(R.id.editText1);

Having obtained a reference to the EditText object and assigned it to textBox, we can now obtain the text that it contains by calling the object’s getText() method, which, in turn, returns the current text in the form of a CharSequence object:

CharSequence userText = textBox.getText();

Finally, we can save the text using the Bundle object’s putCharSequence() method, passing through the key (this can be any string value but in this instance, we will declare it as “savedText”) and the userText object as arguments:

outState.putCharSequence("savedText", userText);

Bringing this all together gives us a modified onSaveInstanceState() method in the StateChangeActivity.java file that reads as follows (noting also the additional import directive for android.widget.EditText):

Restoring the State

The saved dynamic state can be restored in those lifecycle methods that are passed the Bundle object as an argument. This leaves the developer with the choice of using either onCreate() or onRestoreInstanceState(). The method to use will depend on the nature of the activity. In instances where state is best restored after the activity’s initialization tasks have been performed, the onRestoreInstanceState() method is generally more suitable. For the purposes of this example we will add code to the onRestoreInstanceState() method to extract the saved state from the Bundle using the “savedText” key. We can then display the text on the EditText1 component using the object’s setText() method:

Testing the Application

All that remains is once again to test the StateChange application. Verify that your Android device is connected to the USB port of your development system, right-click on the StateChange item in the Package Explorer window and select Run as -> Android Application. Make any necessary selections to ensure an Android device or emulator is the target device and launch the application.

Once running and in the foreground, touch the EditText component and change the text before rotating the device to another orientation. Whereas the text changes were lost in the previous chapter, the new text is retained within the EditText component thanks to the code we have added to the activity in this chapter.

Summary

The saving and restoration of dynamic state in an Android application is simply a matter of implementing the appropriate code in the right lifecycle methods. This typically consists of extracting values and settings from the components in the user interface within the onSaveInstanceState() method (using the activity’s findViewbyId() method if the user interface is stored in a resource file) and saving the data as key-value pairs within the Bundle object passed through to the activity by the runtime system.

State can be restored in either the onCreate() or the onRestoreInstanceState() method of the activity by extracting values from the Bundle object and updating the user interface accordingly.

In this chapter, we have used these techniques to update the StateChange project so that the user interface retains changes through the destruction and subsequent recreation of an activity.