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

Chapter 3. Threads, Services, Receivers, and Alerts

This chapter continues the introduction of the basic building blocks of an application. First, the explicit specification of threads is introduced as a method to separate tasks. Then, services and broadcast receivers are introduced. As shown in some recipes, services and broadcast receivers benefit from using threads. The application widget, which uses receivers, is then covered. This leads naturally to the discussion of various alerts available to the developer.

Threads

Every application by default runs a single process upon creation that contains all the tasks. To avoid hanging the user interface, time-consuming tasks, such as network downloads or computationally intensive calculations, should reside in a separate background thread. It is up to the developer to implement this properly, but then the Android OS prioritizes the threads accordingly.

Most applications can benefit from the use of threads. If such occasions are not detected in the software design phase, they quickly display during testing because the Android system provides an alert to the user when the UI hangs, as shown in Figure 3.1.

Figure 3.1 An example message that displays when a thread hangs

Recipe: Launching a Secondary Thread

In this recipe, a ringtone song is played when an on-screen button is pressed. This provides a simple illustration of how threads can be used with a time-consuming operation. In the following, calling the play_music() function without specifying a separate thread blocks the application during music playback:

Button startButton = (Button) findViewById(R.id.trigger);
startButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View view){
// BAD USAGE: function call too time-consuming
// function causes main thread to hang
play_music();
}
});

This means that any user request such as navigating back to the home screen or multiple pushes of an on-screen button are not registered until the music is completely finished playing. The unresponsive UI might even cause the Android system to display an error such as the one shown inFigure 3.1.

This is resolved by launching a secondary thread to call the play_music() function as follows:

1. Create a new thread to hold a Runnable object:

Thread initBkgdThread = new Thread(
//Insert runnable object here
);

2. Create a Runnable object that overrides the run() method to call the time-consuming task:

new Runnable() {
public void run() {
play_music();
}
}

3. Start the thread, which then runs the task:

initBkgdThread.start();

The setup of the secondary thread to contain the time-consuming task is quick, so the main thread can continue servicing other events.

Before the code for the full activity is shown, the supporting files are discussed. Media playback is covered more fully in Chapter 8, “Multimedia Techniques,” but for illustration, the song is implemented here as a sequence of notes specified using ringtone text transfer language (RTTTL). For example, the following RTTTL code describes a quarter-note of the A (220Hz) just below middle C. Putting this in a single-line text file in the res/raw/ directory registers it as the R.raw.a4 resource.

a4:d=4,o=5,b=250:a4

Then, a call in the activity to the media player plays this ringtone note:

m_mediaPlayer = MediaPlayer.create(this, R.raw.a4);
m_mediaPlayer.start();

This recipe uses four different notes in four separate RTTTL files: g4.rtttl, a4.rtttl, b4.rtttl, and c5.rtttl. These are just exact copies of the preceding example with the a4 changed in the file to reflect the new note in each case, but it can also be expanded to other notes or formats.

One aside is that MediaPlayer launches its own background thread to play the media. So, if this were a single longer file, it would be possible to avoid the use of an explicit thread as explained in Chapter 8, “Multimedia Techniques.” That fact does not help when multiple files need to be played quickly, as here, but it is important to know that threads are not always necessary.

The trigger for starting the music is a button press. The Button widget needs to be specified in the main layout file (here called main.xml) and is identified with the name trigger, as shown in Listing 3.1.

Listing 3.1. res/layout/main.xml