The Android Developer’s Cookbook: Building Applications with the Android SDK, Second Edition (2013)

---

Note that onCreate() also contains Bundle savedInstanceState. In the case of an activity reinitializing after previously being shut down, the bundle saved in onSaveInstanceState() is also passed to onCreate(). In all cases, the saved bundle is passed to the onRestoreInstanceState()function, so it is more natural to use this to restore states.

Recipe: Using Fragments

Fragments are the latest addition to the basic building blocks of an Android application. Fragments are smaller parts of an activity meant for the grouping of views and functionalities. The best analogy for them is to think of smaller building blocks that can be stacked on one another to fill the volume of a bigger block. The need for smaller blocks arose from the introduction of tablets and TV screens.

Fragments allow views to be bundled together and to be mixed and matched within one or two (or even more) activities as needed. The classic use case for this is going from landscape mode with a list and a detail view to portrait mode with a single list and a detail screen. In fact, this pattern has become so mainstream that it is now possible to create a skeleton app like this directly from the Create New Project dialog.

The steps to do this are similar to the ones described in the previous recipe:

1. In Eclipse, choose File → New → Android Application Project.

2. Fill in the project name, such as SimpleFragmentExample.

3. Fill in the application name, such as Example of Basic Fragments.

4. Fill in the package name, such as com.cookbook.simplefragments.

5. Select a minimum required SDK of API Level 11 or Android Honeycomb. Fragments can be used in lower API versions only if the support library extra is installed on the machine.

6. In the Create Activity screen, choose MasterDetailFlow as the start point.

7. Name the items used for demo purposes; for instance, fruits.

8. Press Finish to create the sample project.

Exploring the possibilities of this sample is left to the reader. Here, instead, a few important things about fragments are highlighted.

Fragments come with their own lifecycle, which is dependent on the hosting activities. As fragments can be added, shown, hidden, and removed at any time during the lifecycle of an activity, their existence is much more short-lived than that of other components. Similar to an activity, a fragment has onPause(), onResume(), onDestroy(), and onCreate() methods.

It is to be noted, however, that onCreate(Bundle) is the second method called on a fragment; the first one is onAttach(Activity), which signals that there is a connection to the hosting activity now. Methods can be called on the activity here; however, it is not guaranteed that the activity has been fully initialized itself. Only after onActivityCreated() is called is the activity passed through its own onCreate() method.

Given that fragments can be instantiated and added at much later times, the state of the activity in onAttach() should not be relied upon. The method used to initialize views and start most work is onCreateView(LayoutInflater, ViewGroup, Bundle). The Bundle class given here is the saved instance state, if the fragment is re-created.

Fragments use bundles also for serializing arguments. Every parcelable type of external information a fragment needs can be obtained from the hosting activity by calling setArguments() and can always be read in the fragments with the getArguments() call. This allows information coming from the starting intent of the activity to be passed directly to the fragment to be shown.

Multiple Activities

Even the simplest applications have more than one functionality. Hence, there is often a need to deal with multiple activities. For example, a game can have two activities: a high-scores screen and a game screen. A notepad can have three activities: view a list of notes, read a selected note, and edit a selected or new note.

The main activity, as defined in the AndroidManifest.xml file, is started when the application is started. This activity can launch another activity, usually after a trigger event. This causes the main activity to pause while the secondary activity is active. When the secondary activity ends, the main activity is brought to the foreground and resumed.

To activate a particular component of the application, an intent naming the component explicitly is used. If instead the requirements of an application can be specified by intent filters, an implicit intent can be used. The system then determines the best component or components to use, even if it is in a separate application or native to the OS. Note that unlike other activities, implicit intents that reside in other applications do not need to be declared in the current application’s AndroidManifest.xml file.

Android uses implicit intents as often as possible, providing a powerful framework for modular functionality. When a new component is developed that meets the required implicit intent filter, it can be used in place of an Android internal intent. For example, say a new application for displaying phone contacts is loaded on an Android device. When a user selects a contact, the Android system finds all available activities with the proper intent filter for viewing contacts and asks the user to decide which one should be used.

Recipe: Using Buttons and TextView

To fully demonstrate multiple activities, it is useful to use a trigger event. A button press is introduced here for that purpose. The steps for adding a button to a given layout and assigning an action to a button press follow:

1. Put a button in the designated layout XML file:

<Button android:id="@+id/trigger"
android:layout_width="100dip" android:layout_height="100dip"
android:text="Press this button" />

2. Declare a button that points to the button ID in the layout file:

Button startButton = (Button) findViewById(R.id.trigger);

3. Specify a listener for when the button is clicked:

//Set up button listener
startButton.setOnClickListener(new View.OnClickListener() {
//Insert onClick here
});

4. Override the onClick function for the listener to do the required action:

public void onClick(View view) {
// Do something here
}

To show the result of an action, it is useful to change the text on the screen. The steps for defining a text field and changing it programmatically follow:

1. Put a text field in the designated layout XML file with an ID. It can also be initialized to some value (here, it can be initialized to the string named hello in the strings.xml file):

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

2. Declare a TextView that points to the TextView ID in the layout file:

private TextView tv = (TextView) findViewById(R.id.hello_text);

3. If the text needs to be changed, use the setText function:

tv.setText("new text string");

These two UI techniques are used in the subsequent recipes in this chapter. A more complete demonstration of UI techniques is covered in Chapter 5, “User Interface Layout.”

Recipe: Launching a Second Activity from an Event

In this recipe, MenuScreen is the main activity, as shown in Listing 2.9. It launches the PlayGame activity. Here, the trigger event is implemented as a button click using the Button widget.

When a user clicks the button, the startGame() function runs and launches the PlayGame activity. When a user clicks the button in the PlayGame activity, it calls finish() to return control to the calling activity. Following are the steps for launching an activity:

1. Declare an intent that points to the activity to be launched.

2. Call startActivity on this intent.

3. Declare the additional activity in the AndroidManifest.xml file.

Listing 2.9. src/com/cookbook/launch_activity/MenuScreen.java