Introducción a esta sección
En 3.1 aprendimos sobre un mecanismo de manejo de eventos en Android: el mecanismo de manejo de eventos basado en escuchas. En pocas palabras, es agregar un oyente (listener) a nuestra fuente de eventos (componente). Luego, cuando el usuario dispara un evento, se lo entrega al oyente para que lo maneje, ejecutando diferentes operaciones según el evento. Entonces, ¿cuál es el principio del mecanismo de manejo de eventos basado en devoluciones de llamada? Bien, hay otra pregunta: ¿sabes qué esla devolución de llamada de método? ¿Lo sabes? Creo que muchos amigos lo entienden, pero no pueden expresarlo. Bien, con estas dudas, ¡analicemos el mecanismo de manejo de eventos por devolución de llamada dentro del mecanismo de manejo de eventos de Android!
1. ¿Qué es una devolución de llamada de método?
Explicación textual:
Respuesta: Es un medio para separar la definición de la función de su implementación, una idea de diseño de desacoplamiento. En Java, la devolución de llamada se implementa a través de interfaces. Como arquitectura de sistema, debe tener su propio entorno de ejecución y proporcionar interfaces de implementación para el usuario; la implementación depende del cliente. De esta manera, se puede lograr una interfaz unificada con implementaciones diferentes. El sistema "devuelve a llamar" a nuestras clases de implementación en diferentes estados, logrando así la separación entre interfaz e implementación.
Pongamos un ejemplo sencillo:
Por ejemplo:El viernes al volver a casa después de clases, le preguntas a tu madre si la comida está lista. Ella dice que aún no. Entonces le dices: 'Mamá, veré Xiyangyang, ¡avísame cuando la comida esté lista!'Análisis:Tú y tu madre acordaron una interfaz. A través de esa interfaz le pides que cocine. Cuando la comida está lista, tu madre te informa a través de la misma interfaz: '¡La comida está lista!'
2. Explicación detallada del mecanismo de manejo de eventos basado en devoluciones de llamada en Android:
En Android, hay dos escenarios de uso para el mecanismo de manejo de eventos basado en devoluciones de llamada:
1) view personalizado
Cuando el usuario dispara un evento en un componente de GUI, el componente tiene su propio método específico que se encarga de manejar el evento. Uso habitual: heredar del componente GUI básico y sobrescribir el método de manejo de eventos de ese componente, es decir, un view personalizado. Nota: al usar un view personalizado en un diseño XML, se debe usar el 'nombre de clase totalmente calificado'.
Métodos de devolución de llamada comunes de los componentes View:
Android proporciona algunos métodos de devolución de llamada para el manejo de eventos en los componentes GUI. Tomando View como ejemplo, existen los siguientes métodos:
① Disparar un evento de pantalla en este componente: booleanonTouchEvent(MotionEvent event);
② Al presionar un botón en este componente: booleanonKeyDown(int keyCode,KeyEvent event);
③ Al soltar un botón en el componente: booleanonKeyUp(int keyCode,KeyEvent event);
④ Al mantener presionado un botón del componente: booleanonKeyLongPress(int keyCode,KeyEvent event);
⑤ Cuando ocurre un evento de atajo de teclado: booleanonKeyShortcut(int keyCode,KeyEvent event);
⑥ Al disparar un evento de trackball en el componente: booleanonTrackballEvent(MotionEvent event);
*⑦ Cuando el foco del componente cambia, a diferencia de los 6 anteriores, este método solo se puede sobrescribir en View. protected voidonFocusChanged(boolean gainFocus, int direction, Rect previously FocusedRect)
Además, aquí se explica qué es un trackball, aunque no es de mucha utilidad. Se podía ver en los teléfonos BlackBerry de antaño. Al navegar por páginas web, se puede considerar el trackball como un ratón. Sin embargo, para tales operaciones, podemos usar onTouchEvent para resolverlo, y además no es estéticamente agradable, por lo que ahora se usa muy poco, básicamente no se usa. Si te interesa verlo, puedes presionar F6 en el emulador original de Android y lo verás.

Ejemplo de código:Definimos una clase MyButton que hereda de la clase Button y sobrescribimos el método onKeyLongPress. Luego, en el archivo XML, llamamos al view personalizado mediante el nombre de clase totalmente calificado.
La captura de pantalla del efecto es la siguiente:

Un botón simple. Al hacer clic en el botón se dispara el evento onTouchEvent. Cuando presionamos el teclado en el emulador, al presionar se dispara onKeyDown, y al soltar el teclado se dispara onKeyUp. ¡Lo observamos a través de Logcat!

Código de implementación: MyButton.java
public class MyButton extends Button{
private static String TAG = "呵呵";
public MyButton(Context context, AttributeSet attrs) {
super(context, attrs);
}
//重写键盘按下触发的事件
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
super.onKeyDown(keyCode,event);
Log.i(TAG, "onKeyDown方法被调用");
return true;
}
//重写弹起键盘触发的事件
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
super.onKeyUp(keyCode,event);
Log.i(TAG,"onKeyUp方法被调用");
return true;
}
//组件被触摸了
@Override
public boolean onTouchEvent(MotionEvent event) {
super.onTouchEvent(event);
Log.i(TAG,"onTouchEvent方法被调用");
return true;
}
}
Archivo de diseño:
<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">
<example.jay.com.mybutton.MyButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="按钮"/>
Análisis del código:
Debido a que sobrescribimos directamente los tres métodos de devolución de llamada de Button, cuando ocurre un evento de clic no necesitamos vincular un oyente de eventos en el archivo Java para completar la devolución de llamada. Es decir, el componente maneja el evento correspondiente, o sea, el evento es manejado por la propia fuente del evento (componente).
2) Propagación de eventos basada en devoluciones de llamada:

En resumen, si el evento se propaga hacia afuera depende de si el valor de retorno del método es true o false;
Ejemplo de código:
public class MyButton extends Button{
private static String TAG = "呵呵";
public MyButton(Context context, AttributeSet attrs) {
super(context, attrs);
}
//重写键盘按下触发的事件
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
super.onKeyDown(keyCode,event);
Log.i(TAG, "自定义按钮的onKeyDown方法被调用");
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">
<example.jay.com.mybutton.MyButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="自定义按钮"
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("呵呵","监听器的onKeyDown方法被调用");
}
return false;
}
});
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
super.onKeyDown(keyCode, event);
Log.i("呵呵","Activity的onKeyDown方法被调用");
return false;
}
}
Captura de pantalla de ejecución:

Análisis de resultados: De los resultados de ejecución anteriores, podemos saber que el orden de propagación es:Oyente (listener)--->Métodos de devolución de llamada del componente view--->Métodos de devolución de llamada de Activity;
Resumen de esta sección
Esta sección explica el mecanismo de manejo de eventos basado en devoluciones de llamada dentro del mecanismo de manejo de eventos de Android. El núcleo es el orden de propagación de eventos: primero el oyente (listener), luego el propio componente View y, finalmente, Activity; si el valor de retorno es false, la propagación continúa; si es true, la propagación se detiene~!