3.2 Callback-Based Event Handling Mechanism

❮ Android Tutorial Download2 Programmer Joke 16 ❯

3.2 Callback-Based Event Handling Mechanism

Category Android Basic Beginner Tutorial

Introduction to This Section

In section 3.1, we learned about an event handling mechanism in Android—the listener-based event handling mechanism. Simply put, it involves adding a listener to our event source (component), and when the user triggers an event, the listener handles it, executing different operations based on the event. So, what is the callback-based event handling mechanism? And another question: Do you know what method callback is? I believe many of you understand it but can't explain it clearly. Let's address these questions and analyze the callback event handling mechanism in Android.

1. What is Method Callback?

Textual Explanation:

Answer: It is a method to separate functionality definition from functionality implementation, a design idea for decoupling. In Java, callbacks are implemented through interfaces. As a system architecture, it must have its own runtime environment and provide interfaces for users to implement. The implementation depends on the client, allowing for unified interfaces but different implementations. The system calls our implementation class in different states, achieving separation of interfaces and implementations.

Simple Example:

For instance: On Friday after school, you ask your mom if the rice is ready, and she says it isn't. Then you tell her: Mom, I'm going to watch Pleasant Goat and Big Big Wolf, call me when the rice is ready! Analysis: You and your mom have agreed on an interface. You use this interface to ask your mom to cook rice. When the rice is ready, your mom uses this interface to inform you, "The rice is ready!"

2. Detailed Explanation of Android Callback Event Handling Mechanism:

In Android, the callback-based event handling mechanism is used in two scenarios:

1) Custom View

When a user triggers an event on a GUI component, the component has specific methods to handle the event. Common practice: Extend the basic GUI component and override the event handling methods, i.e., custom view. Note: When using the custom view in the XML layout, you need to use the "fully qualified class name."

Common Callback Methods for View Components:

Android provides some event handling callback methods for GUI components, taking View as an example, including the following methods:

① Triggers screen events on the component: boolean onTouchEvent (MotionEvent event); onKeyDown (int keyCode, KeyEvent event); onKeyUp (int keyCode, KeyEvent event); onKeyLongPress (int keyCode, KeyEvent event); onKeyShortcut (int keyCode, KeyEvent event); onTrackballEvent (MotionEvent event); onFocusChanged (boolean gainFocus, int direction, Rect previouslyFocusedRect)

Additionally, let's explain what a trackball is, though it's not very useful. You could see it on old BlackBerry phones. When browsing web pages, you can think of the trackball as a mouse. However, this operation can be handled with onTouchEvent, and it's not aesthetically pleasing, so it's rarely used now. If you're interested, you can see it in the original Android emulator by pressing F6!

Code Example: We define a MyButton class extending the Button class and override the onKeyLongPress method. Then, call the custom view in the XML file using the fully qualified class name.

Effect Diagram:

A simple button. Clicking the button triggers the onTouchEvent event. When pressing the keyboard on the emulator, onKeyDown is triggered, and onKeyUp is triggered when leaving the keyboard. We view this through Logcat!

Implementation Code: MyButton.java

public class MyButton extends Button{  
    private static String TAG = "呵呵";  
    public MyButton(Context context, AttributeSet attrs) {  
        super(context, attrs);  
    }  

    // Override the event triggered by pressing the keyboard  
    @Override  
    public boolean onKeyDown(int keyCode, KeyEvent event) {  
        super.onKeyDown(keyCode,event);  
        Log.i(TAG, "onKeyDown method is called");  
        return true;  
    }  

    // Override the event triggered by releasing the keyboard  
    @Override  
    public boolean onKeyUp(int keyCode, KeyEvent event) {  
        super.onKeyUp(keyCode,event);  
        Log.i(TAG,"onKeyUp method is called");  
        return true;  
    }  

    // Component is touched  
    @Override  
    public boolean onTouchEvent(MotionEvent event) {  
        super.onTouchEvent(event);  
        Log.i(TAG,"onTouchEvent method is called");  
        return true;  
    }  
}

Layout File:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    tools:context=".MyActivity">  

    &lt;example.jay.com.mybutton.MyButton  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:text="按钮"/>

Code Analysis:

Since we directly override the three callback methods of Button, after a click event occurs, we don't need to bind the event listener in the Java file to complete the callback. The component handles the corresponding event itself, i.e., the event is handled by the event source (component) itself.

2) Event Propagation Based on Callbacks:

In summary, whether the event propagates outward depends on whether the return value of the method is true or false.

Code Example:

public class MyButton extends Button{  
    private static String TAG = "呵呵";  
    public MyButton(Context context, AttributeSet attrs) {  
        super(context, attrs);  
    }  

    // Override the event triggered by pressing the keyboard  
    @Override  
    public boolean onKeyDown(int keyCode, KeyEvent event) {  
        super.onKeyDown(keyCode,event);  
        Log.i(TAG, "Custom button's onKeyDown method is called");  
        return false;  
    }  
}

main.xml:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    tools:context=".MyActivity">  

    &lt;example.jay.com.mybutton.MyButton  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:text="Custom Button"  
        android:id="@+id/btn_my"/>  
</LinearLayout>

MainActivity.java:

public class MyActivity extends ActionBarActivity {  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_my);  

        Button btn = (Button)findViewById(R.id.btn_my);  
        btn.setOnKeyListener(new View.OnKeyListener() {  
            @Override  
            public boolean onKey(View v, int keyCode, KeyEvent event) {  
                if(event.getAction() == KeyEvent.ACTION_DOWN)  
                {  
                    Log.i("呵呵","Listener's onKeyDown method is called");  
                }  
                return false;  
            }  
        });  
    }  

    @Override  
    public boolean onKeyDown(int keyCode, KeyEvent event) {  
        super.onKeyDown(keyCode, event);  
        Log.i("呵呵","Activity's onKeyDown method is called");  
        return false;  
    }  
}

Screenshot:

Result Analysis: From the above results, we can see that the propagation order is: Listener -> View component's callback method -> Activity's callback method.

Summary

This section explained the callback-based event handling mechanism in Android. The key point is the order of event propagation: listener first, then the View component itself, and finally the Activity. The return value of false continues propagation, while true stops it.

-1.0 Android Basic Beginner Tutorial

-1.2 Development Environment Setup

-1.2.1 Developing Android Apps with Eclipse + ADT + SDK

-1.2.2 Developing Android Apps with Android Studio

-1.3 Solving SDK Update Issues

-1.4 Genymotion Emulator Installation

-1.5.1 Git Tutorial: Basic Operations on Local Repositories

-1.5.2 Using GitHub to Set Up a Remote Repository with Git

-1.6 How to Use 9-Patch Images

-1.7 Interface Prototype Design

-1.8 Project Source Analysis (Various Files and Resource Access)

-1.9 Android Application Signing and Packaging