PDM Xestión de Eventos

Introdución

• Máis información neste enlace.

• Nos móbiles, o usuario normalmente interactúa coas aplicacións tocando sobre a pantalla táctil.

Este tipo de eventos denomínanse Input Events.

• A forma en que Android ten para xestionar os eventos é mediante o uso de Interfaces.

Este tipo de interface denomínanse xestores de eventos ou EventListener.

• A idea é que aquela compoñente que se queira xestionar algún evento, terá que rexistrar a interface asociada para dito evento.

Unha vez rexistrada (iso se fai facendo uso dun método, o veremos a continuación) poderemos implementar o código da Interface, no que estarán definidos os métodos que conforman o evento a controlar.

Ditos métodos serán chamados polo S.O. Android cando se produza o evento sobre o compoñente gráfico.

• Para xestionar os eventos de calquera compoñente gráfico teremos que dirixirnos a páxina dese compoñente e ver cales son as interfaces que pode implementar para xestionar os diferentes tipos de evento.

Se ides á paxina de referencia de AndroidDeveloper e escolledes a categoría de Android.View => Interfaces, podedes ver todos os eventos que poden xestionar os view e por extensión, calquera compoñente gráfico. Podedes consultar este enlace.

• Como dixemos antes, os eventos no que o usuario iteraciona son os Event Listener.

Estes eventos se atopan definidos en interfaces e dentro delas están definidos algún dos seguintes métodos:

Imaxe obtida dende developer.android.com

Na imaxe anterior están suliñadas as interfaces asociadas a cada evento.

Neste enlace tedes os método que deberíamos empregar nun view para rexistrar algunha das interfaces anteriores.

• Cabe indicar que poden producirse varios eventos 'á vez' e estes son xestionados por medio dunha cola FIFO.

Por exemplo, cando prememos unha lista na pantalla e mantemos premido durante un rato, normalmente aparece un menú emerxente con opcións sobre a lista.

Nese caso produciuse dous eventos: OnLongClick e Click sobre a lista. Primeiro se lanzará o 'Long Click' e despois o 'Click'.

Preparación proxecto

• Partimos que xa temos creado o proxecto inicial como xa indicamos anteriormente.
• Comezaremos creando un novo paquete de nome: Eventos.

• Para informar ao usuario imos facer uso da clase Toast.

É un tipo de notificación e serve para amosar unha mensaxe curta que aparece e desaparece automaticamente. Non require intervención por parte do usuario.

A forma mais sinxela de chamala é:

1    Toast.makeText(getApplicationContext(),"AVISO",Toast.LENGTH_LONG).show();

• O primeiro parámetro é unha referencia ao contexto. O contexto é unha interface (todas as activities derivan dela) que nos vai servir para acceder aos recursos da aplicación.

Normalmente se obtén chamando ao método getApplicationContext()

• O segundo parámetro é o texto que queremos amosar ao usuario.

Lembrade que no voso proxecto tedes que ter soporte para varios idiomas, polo tanto as mensaxes teñen que referenciarse da forma: R.id.

• O terceiro parámetro é o tempo que vai amosarse a mensaxe. Pode ser Toast.LENGTH_LONG ou Toast.LENGTH_SHORT
• Por último se chama ao método show() do obxecto creado para amosar a mensaxe.

Xestión Eventos: 1ª Opción-Clases anónimas

• Dentro do paquete Eventos crear unha nova activity de nome: UD02_01_Eventos de tipo Launcher e sen compatibilidade.

Modifica o arquivo AndroidManifiest.xml e engade unha label á activity como xa vimos na creación do proxecto base.

• Para xestionar calquera dos eventos temos que asociar dito evento ao view, por medio do rexistro dunha das intercaces anteriores, onde estará definido o método ao que o S.O. chamará cando se produza o evento.

Para iso podemos facer uso das Clases anónimas.

A forma de implementar anonimante unha interface é: obxectoView.setXXXXXXListener(new XXXXXXXListener(){ ....................});

• Como vemos teremos:

• Ter unha referencia ao view sobre o que queremos xestionar o evento.
• Chamar ao método setXXXXInterface, por exemplo, setOnCLickListener sería o evento para xestionar o evento de click sobre un botón.
• Dito método espera como parámetro un obxecto dunha clase que implemente a interface. No noso caso faremos uso das clases anónimas e faremos un new XXXXXXXListener, é dicir, da interface. No caso anterior do botón, a interface se chama OnClickListener (mirar imaxe anterior).
• Ao facer o new, automaticamente o AndroidStudio implementa os métodos da Interface. No caso do exemplo, o método onClick.

Vexamos un exemplo.

Código XML do layout da activity:

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3     xmlns:app="http://schemas.android.com/apk/res-auto"
 4     xmlns:tools="http://schemas.android.com/tools"
 5     android:layout_width="match_parent"
 6     android:layout_height="match_parent"
 7     tools:context=".Eventos.UD02_01_Eventos">
 8 
 9     <Button
10         android:id="@+id/btnAceptar_UD02_01"
11         android:layout_width="wrap_content"
12         android:layout_height="wrap_content"
13         android:layout_marginBottom="8dp"
14         android:layout_marginEnd="8dp"
15         android:layout_marginStart="8dp"
16         android:layout_marginTop="8dp"
17         android:text="Button"
18         app:layout_constraintBottom_toBottomOf="parent"
19         app:layout_constraintEnd_toEndOf="parent"
20         app:layout_constraintStart_toStartOf="parent"
21         app:layout_constraintTop_toTopOf="parent" />
22 </android.support.constraint.ConstraintLayout>

Temos un botón de nome btnAceptar_UD02_01.

Nota: Na vosa práctica os controis terán un esquema de nomeamento parecido a este.

• Agora no código da Activity faremos os pasos indicados para xestionar o evento Click():

Sempre despois da chamada a setContentView do método onCreate (que é onde asociamos o layout á activity):

 1 package es.cursoandroid.cifprodolfoucha.aprendiendo.Eventos;
 2 
 3 import android.app.Activity;
 4 import android.os.Bundle;
 5 import android.widget.Button;
 6 
 7 import es.cursoandroid.cifprodolfoucha.aprendiendo.R;
 8 
 9 public class UD02_01_Eventos extends Activity {
10 
11     @Override
12     protected void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         setContentView(R.layout.activity_ud02_01__eventos);
15 
16         // Obtemos a referencia ao botón por medio do método findViewById
17         Button btnAceptar = findViewById(R.id.btnAceptar_UD02_01);
18         
19 
20     }
21 }

Facemos uso do método findViewById para obter unha referencia ao botón.

Como parámetro leva un número. Este o obtemos da clase R (comentada en anteriores puntos) a cal cada vez que compilamos a aplicación, asocia cada recurso do cartafol /res cun número.

Por iso é importante que o nome do control gráfico (o botón neste caso) sexa identificativo, xa que podemos facer referencia a controis de outras activities e polo tanto teríamos un valor null para o control.

• Agora chamamos ao método setOnClickListener da clase View teredes que pasarlle como parámetro un obxecto dunha clase que implemente a interface OnClickListener ou ben crear de forma anónima un obxecto de dita interface, que é o que faremos:

Nota: Ao facer 'enter' no Android Studio cando sea o nome da interface, xa xera automaticamente os métodos da mesma.

 1 public class UD02_01_Eventos extends Activity {
 2 
 3     @Override
 4     protected void onCreate(Bundle savedInstanceState) {
 5         super.onCreate(savedInstanceState);
 6         setContentView(R.layout.activity_ud02_01__eventos);
 7 
 8         // Obtemos a referencia ao botón por medio do método findViewById
 9         Button btnAceptar = findViewById(R.id.btnAceptar_UD02_01);
10         btnAceptar.setOnClickListener(new View.OnClickListener() {
11             @Override
12             public void onClick(View v) {
13                 
14             }
15         });
16 
17     }
18 }

• Agora dentro do método onClick poderemos poñer o código que queiramos.

Comentar que dito método leva como parámetro un obxecto da clase View que é o obxecto que ten rexistrado o evento e sobre o cal se fixo o evento (neste caso o botón).

Podemos facer un cast de dito obxecto para acceder a todas as propiedades e métodos do botón, aínda que no caso das interfaces anónimas non ten moito sentido xa que, como no exemplo, podemos acceder a btnAceptar que é o botón.

1         btnAceptar.setOnClickListener(new View.OnClickListener() {
2             @Override
3             public void onClick(View v) {
4 
5                 Button btn = (Button)v;    // Sería o mesmo que btnAceptar
6                 Toast.makeText(getApplicationContext(),"Botón pulsado: "+ btn.getText(),Toast.LENGTH_LONG).show();
7             }
8         });

Xestión Eventos: 2ª Opción-Implementado a interface

-- Ángel D. Fernández González -- (2018).