Tratando eventos sofisticados na plataforma Android

A variedade de eventos existentes na plataforma Android é muito grande, podendo ser além dos eventos de clique e clique longo. Este artigo apresentará outros modelos de eventos com a interface visual do usuário, enriquecendo ainda mais a interação do usuário com a aplicação.

Para os testes dos eventos propostos neste artigo, vamos criar um novo projeto Android chamado UsandoEventosAvancados. Este terá um arquivo de interface gráfica (activity_principal.xml) e uma classe Activity (PrincipalActivity.java).

O evento de toque acontece quando o usuário toca em algum componente visual do aplicativo, seja com uma caneta stylus ou com os próprios dedos. É importante não confundir com o evento de clique, que também pode ser acionado com um toque na tela ou com os botões do aparelho, com o evento de toque visto nesta seção. A diferença é que no toque podemos saber em que região da View o contato aconteceu, ao contrário do evento de clique. Com essa informação podemos criar controles direcionais para jogos, por exemplo.

Na maioria das vezes, esse evento é utilizado para capturar um toque na janela do aplicativo, e nessa situação, o listener deve ser atribuído ao componente ViewGroup que corresponde a tela toda como, por exemplo um LinearLayout. Entretanto, é importante lembrar, nesta situação, de nomear o componente LinearLayout no arquivo xml adicionando a ele a propriedade android:id.

Na Listagem 1 é apresentada a definição da interface visual do aplicativo, este sem componentes visuais, formado inicialmente por um único componente LinearLayout com nome de tela.

Listagem 1. activity_principal.xml. Interface gráfica para testes do evento de toque.

  01.  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  02.      xmlns:tools="http://schemas.android.com/tools"
  03.      android:id="@+id/tela"
  04.      android:layout_width="match_parent"
  05.      android:layout_height="match_parent"
  06.      android:orientation="vertical"
  07.      tools:context=".PrincipalActivity" >
  08.  
  09.      
  10.  
  11.  </LinearLayout>

O código apresentado não possui componentes, apenas um LinearLayout que é definido na orientação vertical (linha 06). Na sequência, serão adicionados novos componentes visuais entre as linha 08 e 10. Entretanto, para este exemplo os componentes TextView para apresentação dos dados do toque serão criados dinamicamente, conforme pode ser visualizado na Listagem 2.

Listagem 2. PrincipalActivity.java. Activity para testes do evento de toque.

  01.  import android.app.Activity;
  02.  import android.os.Bundle;
  03.  import android.view.MotionEvent;
  04.  import android.view.View;
  05.  import android.widget.LinearLayout;
  06.  import android.widget.TextView;
  07.  
  08.  public class PrincipalActivity extends Activity {
  09.  
  10.   private LinearLayout tela;
  11.   
  12.   @Override
  13.   protected void onCreate(Bundle savedInstanceState) {
  14.        super.onCreate(savedInstanceState);
  15.        setContentView(R.layout.activity_principal);
  16.        
  17.        tela = (LinearLayout) findViewById( R.id.tela );
  18.        
  19.        tela.setOnTouchListener( new View.OnTouchListener() {
  20.             
  21.             @Override
  22.             public boolean onTouch(View v, MotionEvent motion) {
  23.                   
  24.                   TextView texto = new TextView( getApplicationContext() );
  25.                   String msg = "";
  26.                   
  27.                   if ( motion.getAction() == MotionEvent.ACTION_DOWN ) {
  28.                        msg = "pressionou na tela. ";
  29.                   
  30.                   } else if ( motion.getAction() == MotionEvent.ACTION_MOVE ) {
  31.                        msg = "moveu na tela. ";
  32.                   
  33.                   } else if ( motion.getAction() == MotionEvent.ACTION_UP ) { 
  34.                        msg = "soltou na tela. ";
  35.                        
  36.                   }
  37.                   
  38.                   msg += "x: " + motion.getRawX() + " y: " + motion.getRawY(); 
  39.                   
  40.                   texto.setText( msg );
  41.                   
  42.                   tela.addView( texto );
  43.                   
  44.                   return true;
  45.             }
  46.        } );
  47.   }
  48.  }

A classe apresentada declara (linha 10) e recupera (linha 17) o componente LinearLayout, sendo implementada neste o método onToach (linha 22), a qual implementa a classe interna anônima filha de View.OnTouchLisener (linha 19).

Este evento trata o método onTouch() – linha 22, chamado toda vez que houver um toque na tela. Para identificar o tipo de toque, deve-se utilizar o método getAction(), o qual pode retornar um MotionEvent.ACTION_DOWN (a tela foi pressionada), MotionEvent.ACTION_UP (a tela foi solta) ou MotionEvent.ACTION_MOVE (foi movimentado o toque na tela). É possível, inclusive, tratar multitouch em telas de device Android.

Assim, o exemplo proposto instancia um componente TextView em tempo de execução (linha 24), assim como cria uma String (linha 25) que valorizará o texto deste TextView no final do processamento.

É identificado o tipo de toque (condicionais das linhas 27, 30 e 33), sendo valorizado um texto correspondente na String definida na linha 25.

Na sequência, é recuperada a posição do evento (nos eixos x e y – linha 38), para também fazer parte da String definida na linha 25. Por fim, esta String valorizará o conteúdo do componente TextView (linha 40) e este componente é adicionado à tela (linha 42).

Por último, o método onTouch() retorna true (linha 44), indicando que os eventos subsequentes do onTouch() também serão tratados (ler BOX 1).