Artigos Mobile Tratando eventos sofisticados na plataforma Android
Por que eu devo ler este artigo:Este artigo apresenta o tratamento de eventos avançados na plataforma Android. No início serão apresentados eventos simples, como receber e perder foco, pressionamento de tecla sobre um determinado componente visual e evento de toque, assim como algumas de suas variações e aplicabilidades. Na sequência, aumentaremos um pouco a complexidade e será apresentada a utilização de menus simples, assim como menus de contexto, sendo desenvolvido inclusive exemplos com a utilização dos novos ActionBar. Por fim, serão apresentados os eventos de seleção de itens em lista, com um estudo de caso envolvendo imagens e componentes de seleção. Desta forma, o leitor aumentará ainda mais as possibilidades de interação entre o usuário e o aplicativo desenvolvido para dispositivos móveis.

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).

BOX 1. Retorno do método onTouch()

O método onTouch() possui um retorno booleano, como pode ser observado na linha 22. Este retorno define se os eventos subsequentes ao atual também serão tratados ou não. Sabemos que, ao clicar e arrastar na tela, três tipos de eventos ocorreram no onTouch(): evento de toque (MotionEvent.ACTION_DOWN), um ou mais eventos de movimentação (MotionEvent.ACTION_MOVE) e um movimento de soltura (MotionEvent.ACTION_UP). Assim, ao receber um evento do tipo MotionEvent.ACTION_DOWN, se o retorno do método for false, os eventos seguintes serão ignorados, reto ...

Quer ler esse conteúdo completo? Tenha acesso completo