Skip to content

Most visited

Recently visited

navigation

Eventos de entrada

En Android, existe más de una forma de interceptar los eventos desde una interacción del usuario con tu aplicación. Al considerar los eventos dentro de tu interfaz de usuario, el enfoque consiste en capturar los eventos desde el objeto de vista específico con el que el usuario interactúa. La clase de vista proporciona los medios para hacerlo.

Dentro de las diversas clases de objetos View que usarás para componer tu diseño, quizá observes varios métodos de callback públicos que pueden ser útiles para eventos de IU. El framework de Android llama a estos métodos cuando la acción respectiva ocurre en ese objeto. Por ejemplo, cuando se toca una vista (por ejemplo, un botón), se llama al método onTouchEvent() en ese objeto. Sin embargo, para interceptar esto, debes extender la clase y reemplazar el método. No obstante, extender todos los objetos de vista para manejar tal evento no sería práctico. Es por ello que la clase de vista también contiene una colección de interfaces anidadas con callbacks que puedes definir más fácilmente. Estas interfaces, llamadas gestores de eventos, te permiten capturar la interacción del usuario con tu IU.

Si bien generalmente usarás los receptores de eventos para escuchar la interacción del usuario, es posible que en algún momento desees ampliar una clase de objeto View para crear un componente personalizado. Quizá desees ampliar la clase Button para crear algo más elaborado. En este caso, podrás definir los comportamientos de eventos predeterminados para tu clase utilizando los controladores de eventos de la clase.

Gestores de eventos

Un receptor de eventos es una interfaz en la clase View que contiene un solo método de callback. Estos métodos serán llamados por el framework de Android cuando la vista con la cual se ha registrado el gestor sea iniciada por la interacción del usuario con el elemento en la IU.

En las interfaces de los gestores de eventos, se incluyen los siguientes métodos de callback:

onClick()
Desde View.OnClickListener. Este método se llama cuando el usuario toca el elemento (en el modo táctil), o selecciona el elemento con las teclas de navegación o la bola de seguimiento y presiona la tecla “Entrar” adecuada o la bola de seguimiento.
onLongClick()
Desde View.OnLongClickListener. Este método se llama cuando el usuario toca y mantiene presionado el elemento (en el modo táctil), o selecciona el elemento con las teclas de navegación o la bola de seguimiento y mantiene presionada la tecla “Entrar” adecuada o la bola de seguimiento (durante un segundo).
onFocusChange()
Desde View.OnFocusChangeListener. Este método se llama cuando el usuario navega hacia el elemento o sale de este utilizando las teclas de navegación o la bola de seguimiento.
onKey()
Desde View.OnKeyListener. Este método se llama cuando el usuario se centra en el elemento y presiona o libera una tecla física en el dispositivo.
onTouch()
Desde View.OnTouchListener. Este método se llama cuando el usuario realiza una acción calificada como un evento táctil, por ejemplo, presionar, liberar o cualquier gesto de movimiento en la pantalla (dentro de los límites del elemento).
onCreateContextMenu()
Desde View.OnCreateContextMenuListener. Este método es llamado cuando se crea un Context Menu (como resultado de un "clic largo" sostenido). Consulta la explicación sobre menús contextuales en la guía para desarrolladores Menus.

Estos métodos son los únicos habitantes de su respectiva interfaz. Para definir uno de estos métodos y manejar sus eventos, implementa la interfaz anidada en su actividad o defínela como una clase anónima. Luego, pasa una instancia de tu implementación al método View.set...Listener() respectivo. (P. ej., llama a setOnClickListener() y pasa tu implementación deOnClickListener).

En el ejemplo siguiente, se muestra cómo registrar un gestor onClick para un botón.

// Create an anonymous implementation of OnClickListener
private OnClickListener mCorkyListener = new OnClickListener() {
    public void onClick(View v) {
      // do something when the button is clicked
    }
};

protected void onCreate(Bundle savedValues) {
    ...
    // Capture our button from layout
    Button button = (Button)findViewById(R.id.corky);
    // Register the onClick listener with the implementation above
    button.setOnClickListener(mCorkyListener);
    ...
}

Quizá también te parezca más conveniente implementar OnClickListener como parte de tu actividad. Esto evitará la carga extra de la clase y la asignación de objetos. Por ejemplo:

public class ExampleActivity extends Activity implements OnClickListener {
    protected void onCreate(Bundle savedValues) {
        ...
        Button button = (Button)findViewById(R.id.corky);
        button.setOnClickListener(this);
    }

    // Implement the OnClickListener callback
    public void onClick(View v) {
      // do something when the button is clicked
    }
    ...
}

Ten en cuenta que el callback onClick() del ejemplo anterior no tiene valor de retorno, pero algunos otros métodos de gestores de eventos deben devolver un valor booleano. El motivo depende del evento. A continuación, se explican los motivos de los pocos casos que lo hacen:

Recuerda que los eventos de teclas de hardware siempre se entregan a la vista actualmente en foco. Se distribuyen comenzando desde la parte superior de la jerarquía de vistas y luego hacia abajo, hasta llegar al destino correspondiente. Si tu vista (o un elemento secundario de tu vista) actualmente tiene foco, puedes ver al evento viajar a través del método dispatchKeyEvent(). Como alternativa a capturar eventos de teclas a través de tu vista, también puedes recibir todos los eventos dentro de tu actividad con onKeyDown() y onKeyUp().

Además, al considerar la entrada de texto para tu aplicación, recuerda que muchos dispositivos solo tienen métodos de entrada de software . No es necesario que tales métodos se basen en teclas; algunos pueden utilizar entrada de voz, escritura a mano, etc. Incluso si un método de entrada presenta una interfaz similar a un teclado, generalmente no desencadenará la familia de eventos onKeyDown(). Nunca debes construir una IU que requiera que se presionen teclas específicas para controlarla, salvo que desees limitar tu aplicación a dispositivos con un teclado de hardware. En particular, no utilices estos métodos para validar la entrada cuando el usuario presiona la tecla de entrada; en cambio, utiliza acciones como IME_ACTION_DONE para señalar al método de entrada cómo tu aplicación espera reaccionar, para que pueda cambiar su IU de forma significativa. Evita los supuestos sobre la forma en la que un método de entrada de software debe funcionar y simplemente confía en él para proporcionar texto ya formateado a tu aplicación.

Nota: Android llamará en primer lugar a los controladores de eventos, y en segundo lugar, a los controladores predeterminados correspondientes de la definición de clase. Por lo tanto, al devolver true desde estos gestores de eventos, se detendrá la propagación del evento a otros gestores de eventos y también se bloqueará el callback al controlador de eventos predeterminado en la vista. Por lo tanto, asegúrate de que deseas finalizar el evento cuando devuelvas true.

Controladores de eventos

Si estás creando un componente personalizado desde Vista, podrás definir varios métodos de callback utilizados como controladores de eventos predeterminados. En el documento Componentes personalizados, aprenderás sobre algunas de las callbacks que se utilizan comúnmente para controlar eventos, incluidas las siguientes:

Existen otros métodos que debes conocer; métodos que no forman parte de la clase de vista, pero que pueden afectar directamente la forma en la que puedes usar los eventos. Por lo tanto, cuando administres eventos más complejos dentro de un diseño, considera estos otros métodos:

Modo táctil

Cuando un usuario navega en una interfaz de usuario con teclas direccionales o una bola de seguimiento, es necesario poner el foco en los elementos que se pueden accionar (como los botones) para que el usuario pueda ver lo que aceptará una entrada. Sin embargo, si el dispositivo tiene funciones táctiles y el usuario comienza a interactuar con la interfaz tocándola, ya no es necesario resaltar los elementos o poner el foco en una vista determinada. Por ende, existe un modo de interacción denominado "modo táctil".

En el caso de un dispositivo con funciones táctiles, una vez que el usuario toca la pantalla, el dispositivo entra en el modo táctil. Desde este momento en adelante, solo las vistas para las cuales el isFocusableInTouchMode() es verdadero serán enfocables, por ejemplo, los widgets de edición de texto. Otras vistas que son táctiles, como los botones, no se enfocarán cuando se las toca; simplemente activan sus gestores onClick cuando se las presiona.

Cuando un usuario toca una tecla direccional o se desplaza con una bola de seguimiento, el dispositivo saldrá del modo táctil y encontrará una vista para poner el foco. Ahora, el usuario puede reanudar la interacción con la interfaz de usuario sin tocar la pantalla.

El estado del modo táctil se mantiene en todo el sistema (todas las ventanas y actividades). Para consultar el estado actual, puedes llamar a isInTouchMode() a fin de ver si el dispositivo se encuentra actualmente en el modo táctil.

Cómo manejar el foco

El framework manejará el movimiento del foco de rutina en respuesta a las entradas del usuario. Esto incluye cambiar el foco a medida que se eliminan o se ocultan las vistas, o a medida que existen vistas nuevas disponibles. Las vistas indican su disposición a tomar foco a través del método isFocusable(). Para cambiar si una vista puede tomar foco, llama a setFocusable(). En el modo táctil, puedes consultar si una vista permite el foco con isFocusableInTouchMode(). Puedes cambiar esto con setFocusableInTouchMode().

El movimiento del foco se basa en un algoritmo que encuentra el vecino más próximo en una dirección determinada. En casos poco frecuentes, es posible que el algoritmo predeterminado no coincida con el comportamiento previsto del desarrollador. En estas situaciones, puedes proporcionar anulaciones explícitas con los siguientes atributos XML en el archivo de diseño: nextFocusDown, nextFocusLeft, nextFocusRight y nextFocusUp. Agrega uno de estos atributos a la vista desde la cual se elimina el foco. Define el valor del atributo que será el id. de la vista en la cual se pondrá el foco. Por ejemplo:

<LinearLayout
    android:orientation="vertical"
    ... >
  <Button android:id="@+id/top"
          android:nextFocusUp="@+id/bottom"
          ... />
  <Button android:id="@+id/bottom"
          android:nextFocusDown="@+id/top"
          ... />
</LinearLayout>

Generalmente, en este diseño vertical, al navegar hacia arriba desde el primer botón no se llegaría a ningún lado, como tampoco navegando hacia abajo desde el segundo botón. Ahora que el botón superior ha definido al botón inferior como nextFocusUp (y viceversa), el foco de navegación pasará de arriba hacia abajo y de abajo hacia arriba.

Si deseas declarar una vista como enfocable en tu IU (cuando tradicionalmente no lo es), agrega el atributo XML android:focusable a la vista en tu declaración de diseño. Fija el valor en true. También puedes declarar una vista como enfocable en el modo táctil con android:focusableInTouchMode.

Para solicitar que se enfoque una vista en particular, llama a requestFocus().

Para escuchar eventos de foco (ser notificado cuando una vista recibe o pierde foco), utiliza onFocusChange(), como se explica en la sección Gestores de eventos que aparece anteriormente.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a one-minute survey?
Help us improve Android tools and documentation.