Introducción a esta sección:

Como dice el título, en esta sección les traemosTouchListeneryOnTouchEventla comparación y los puntos de conocimiento sobre multi-touch. TouchListener se basa en escucha, mientras que OnTouchEvent se basa en devolución de llamada. ¡A continuación, mediante dos simples ejemplos para profundizar la comprensión de todos!

1. TouchListener basado en escucha

Ejemplo de código:

Imagen del efecto de implementación:

Código de implementación: main.xml

<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"  
    android:paddingLeft="@dimen/activity_horizontal_margin"  
    android:paddingRight="@dimen/activity_horizontal_margin"  
    android:paddingTop="@dimen/activity_vertical_margin"  
    android:paddingBottom="@dimen/activity_vertical_margin"  
    tools:context=".MyActivity">  
  
    <ImageView  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:id="@+id/imgtouch"  
        android:background="@drawable/touch"/>  
</RelativeLayout> 

MainAcitivity.java

public class MyActivity extends ActionBarActivity {  
  
    private ImageView imgtouch;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_my);  
  
        imgtouch = (ImageView)findViewById(R.id.imgtouch);  
        imgtouch.setOnTouchListener(new View.OnTouchListener() {  
            @Override  
            public boolean onTouch(View v, MotionEvent event) {  
                Toast.makeText(getApplicationContext(),"你通过监听器模式:OnTouchListener摸了伦家~",Toast.LENGTH_LONG).show();  
                return true;  
            }  
        });  
    }  
}

Análisis del código:

Es simplemente configurar un ImageView, luego setOnTouchListener, y sobrescribir el método onTouch. ¡Muy sencillo! De hecho, esto ya fue un ejemplo en la sección de FrameLayout, ¿recuerdan a la chica linda que se movía con el dedo?

Métodos y propiedades relacionados con OnTouchListener:

onTouch(View v, MotionEvent event): los parámetros aquí son, en orden, el componente que desencadena el evento táctil y el evento táctil event que encapsula la información detallada del evento disparado, incluyendo el tipo de evento, el tiempo de activación, etc. Por ejemplo, event.getX(), event.getY()
También podemos juzgar el tipo de acción táctil usando event.getAction() para determinar, por ejemplo:
event.getAction == MotionEvent.ACTION_DOWN: evento de presión
event.getAction == MotionEvent.ACTION_MOVE: evento de movimiento
event.getAction == MotionEvent.ACTION_UP: evento de liberación


2. Método onTouchEvent() basado en devolución de llamada

También es un evento táctil, pero onTouchEvent se usa más para vistas personalizadas; todas las clases de vista sobrescriben este método. Y este tipo de evento táctil se basa en devolución de llamada, es decir: si devolvemos false, el evento continuará propagándose hacia afuera, para que el contenedor externo o Activity lo maneje. ¡Por supuesto, también involucra gestos (Gesture), que explicaremos en detalle más adelante! onTouchEvent en realidad es similar a onTouchListener, solo que el mecanismo de procesamiento es diferente: el primero es devolución de llamada, el segundo es modo de escucha.

Ejemplo de código:Define una vista simple, dibuja un pequeño círculo azul que puede seguir el movimiento del dedo.

Código de implementación: MyView.java

public class MyView extends View{  
    public float X = 50;  
    public float Y = 50;  
  
    //创建画笔  
    Paint paint = new Paint();  
  
    public MyView(Context context,AttributeSet set)  
    {  
        super(context,set);  
    }  
  
    @Override  
    public void onDraw(Canvas canvas) {  
        super.onDraw(canvas);  
        paint.setColor(Color.BLUE);  
        canvas.drawCircle(X,Y,30,paint);  
    }  
  
    @Override  
    public boolean onTouchEvent(MotionEvent event) {  
        this.X = event.getX();  
        this.Y = event.getY();  
        //通知组件进行重绘  
        this.invalidate();  
        return true;  
    }  
}

main.xml:

<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.touch2.MyView  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content" />  
</RelativeLayout> 

Imagen del efecto de implementación:

Usa el dedo para tocar y mover ~


3. Multi-touch

Cosas sobre el principio:

El llamado multi-touch consiste en operar con múltiples dedos en la pantalla; lo más usado probablemente sea la función de ampliar/reducir, por ejemplo, muchos visores de imágenes soportan zoom. En teoría, el sistema Android puede manejar hasta 256 dedos de contacto, claro, depende del soporte del hardware del teléfono; pero los teléfonos con soporte multi-touch generalmente soportan de 2 a 4 puntos, ¡y algunos más! Hemos visto que los dos puntos anteriores usan MotionEvent; MotionEvent representa un evento táctil; podemos segúnevent.getAction() & MotionEvent.ACTION_MASKpara juzgar qué operación es; además de las tres operaciones de un solo punto presentadas anteriormente, hay dos operaciones específicas para multi-touch:

  • MotionEvent.ACTION_POINTER_DOWN: se activa cuando ya hay un punto presionado en la pantalla y luego se presiona otro punto.
  • MotionEvent.ACTION_POINTER_UP: se activa cuando hay varios puntos presionados en la pantalla y se suelta uno de ellos (es decir, cuando se libera un punto que no es el último).

El flujo simple es más o menos así:

  • Cuando un dedo toca la pantalla ——> se dispara el evento ACTION_DOWN
  • Luego otro dedo también toca la pantalla ——> se dispara el evento ACTION_POINTER_DOWN; si hay más dedos tocando, continúa disparándose
  • Un dedo sale de la pantalla ——> se dispara el evento ACTION_POINTER_UP; si continúan saliendo dedos, se sigue disparando
  • Cuando el último dedo sale de la pantalla ——> se dispara el evento ACTION_UP
  • Y durante todo el proceso, el evento ACTION_MOVE se dispara continuamente

Podemos mediante event.getX(int) o event.getY(int) para obtener la posición de los diferentes puntos de contacto:getPointerCount()método para juzgar cuántos dedos están tocando actualmente ~


Ejemplo de código:

Bien, escribamos el ejemplo más común de arrastrar una imagen con un dedo y hacer zoom con dos dedos:

Imagen del efecto de implementación:

Código de implementación:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <ImageView
        android:id="@+id/img_test"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scaleType="matrix"
        android:src="@drawable/pic1.html" />

</RelativeLayout>

MainActivity.java

package com.jay.example.edittextdemo;

import android.app.Activity;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.os.Bundle;
import android.util.FloatMath;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.ImageView;

public class MainActivity extends Activity implements OnTouchListener {

    private ImageView img_test;

    // 縮放控制
    private Matrix matrix = new Matrix();
    private Matrix savedMatrix = new Matrix();

    // 不同状态的表示:
    private static final int NONE = 0;
    private static final int DRAG = 1;
    private static final int ZOOM = 2;
    private int mode = NONE;

    // 定义第一个按下的点,两只接触点的重点,以及出事的两指按下的距离:
    private PointF startPoint = new PointF();
    private PointF midPoint = new PointF();
    private float oriDis = 1f;

    /*
     * (non-Javadoc)
     * 
     * @see android.app.Activity#onCreate(android.os.Bundle)
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        img_test = (ImageView) this.findViewById(R.id.img_test);
        img_test.setOnTouchListener(this);
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        ImageView view = (ImageView) v;
        switch (event.getAction() & MotionEvent.ACTION_MASK) {
        // 单指
        case MotionEvent.ACTION_DOWN:
            matrix.set(view.getImageMatrix());
            savedMatrix.set(matrix);
            startPoint.set(event.getX(), event.getY());
            mode = DRAG;
            break;
        // 双指
        case MotionEvent.ACTION_POINTER_DOWN:
            oriDis = distance(event);
            if (oriDis > 10f) {
                savedMatrix.set(matrix);
                midPoint = middle(event);
                mode = ZOOM;
            }
            break;
        // 手指放开
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_POINTER_UP:
            mode = NONE;
            break;
        // 单指滑动事件
        case MotionEvent.ACTION_MOVE:
            if (mode == DRAG) {
                // 是一个手指拖动
                matrix.set(savedMatrix);
                matrix.postTranslate(event.getX() - startPoint.x, event.getY() - startPoint.y);
            } else if (mode == ZOOM) {
                // 两个手指滑动
                float newDist = distance(event);
                if (newDist > 10f) {
                    matrix.set(savedMatrix);
                    float scale = newDist / oriDis;
                    matrix.postScale(scale, scale, midPoint.x, midPoint.y);
                }
            }
            break;
        }
        // 设置ImageView的Matrix
        view.setImageMatrix(matrix);
        return true;
    }

    // 计算两个触摸点之间的距离
    private float distance(MotionEvent event) {
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return FloatMath.sqrt(x * x + y * y);
    }

    // 计算两个触摸点的中点
    private PointF middle(MotionEvent event) {
        float x = event.getX(0) + event.getX(1);
        float y = event.getY(0) + event.getY(1);
        return new PointF(x / 2, y / 2);
    }

}

Resumen de esta sección:

Bien,Sobre TouchListenery OnTouchEventy el multi-touch, llegamos hasta aquí ~