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

Chapter 6. User Interface Events

The two aspects of a UI are screen layout and event handling. Chapter 5, “User Interface Layout,” discussed how layouts are made up of View objects, such as text and buttons. This chapter shows how to handle events from a user, such as physical key presses, touch events, and menu navigation. It also shows how to use a few advanced user interface libraries, namely, gestures and 3D graphics.

Event Handlers and Event Listeners

Most user interaction with an Android device is captured by the system and sent to a corresponding callback method. For example, if the physical BACK key is pressed, the onBackPressed() method is called. Such events can be handled by extending the class and overriding the methods, called event handlers.

User interaction with View or ViewGroup objects can also support event listeners. These are methods that wait for the registered event and then trigger the system to send the event information to the corresponding callback method. For example, the OnClickListener event listener can be registered for a button and when it is pressed by using setOnClickListener().

Event listeners are the preferred method when available because they avoid the class extension overhead. Furthermore, an activity implementing an event listener gets a callback for all the layout objects it contains, allowing for more concise code. Both event listeners and event handlers are demonstrated in this chapter within the context of handling physical key press events and screen touch events.

Recipe: Intercepting a Physical Key Press

A standard Android device has multiple physical keys that can trigger events, as listed in Table 6.1.

Table 6.1 Possible Physical Keys on an Android Device

The system first sends any KeyEvent to the appropriate callback method in the in-focus activity or view. These callback methods are:

onKeyUp(), onKeyDown(), onKeyLongPress()—Physical key press callbacks

onTrackballEvent(), onTouchEvent()—Trackball and touchscreen press callbacks

onFocusChanged()—Called when the view gains or loses focus

These can be overridden by the application to customize with different actions. For example, to turn off the camera button (to avoid accidental presses), just consume the event in the onKeyDown() callback method for the activity. This is done by intercepting the method for the eventKeyEvent.KEYCODE_CAMERA and returning true:

public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_CAMERA) {
return true; // Consume event, hence do nothing on camera button
}
return super.onKeyDown(keyCode, event);
}

Because the event is consumed, it does not get passed on to other Android components. There are a few exceptions to this:

The power button and HOME key are intercepted by the system and do not reach the application for customization.

The BACK, MENU, HOME, and SEARCH keys should not intercept the KeyDown but instead the KeyUp. This coincides with Android 2.0 suggestions because these buttons might not be physical keys in other platforms.

Listing 6.1 shows a variety of examples of intercepting physical key presses, including the following:

The Camera and DPAD left keys are intercepted in onKeyDown() to show a message to the screen, and then the method is consumed (by returning true).

The Volume Up key is intercepted to show a message to the screen, but it is not consumed (returning false) and hence also actually increases the volume.

The SEARCH key is intercepted in onKeyDown(), and the startTracking() method is used to track it through to the KeyUp where a message is sent to the screen.

The BACK key is intercepted in onBackPressed().

A note on the latter: An Android guideline for usability is that the BACK key should generally not be customized. However, if needed for some reason in an activity or dialog, there is a separate callback method available with API Level 5 (Eclair) and higher to intercept the BACK key:onBackPressed().

For backward compatibility with earlier SDKs, the KeyEvent.KEYCODE_BACK can be intercepted, and the onBackPressed() method can be explicitly called for earlier SDKs, as shown in Listing 6.1. (Note: This code can be compiled only with Android 2.0 or higher due to the explicit mention of Eclair, but it is backward compatible at run-time on all devices.) To intercept the BACK key in a view (not shown here) requires using the startTracking() method, which is similar to the SEARCH key example in Listing 6.1.

Listing 6.1. src/com/cookbook/PhysicalKeyPress.java