TouchListener PK OnTouchEvent + multi-touch


Introduction à cette section :

Comme le titre l'indique, cette section vous propose également une comparaison entre TouchListener et OnTouchEvent. plus de points touchent des points de connaissance ! TouchListener est basé sur l'écoute, tandis qu'OnTouchEvent est basé sur les rappels ! Utilisons deux exemples simples pour approfondir Tout le monde comprend !

1. TouchListener basé sur l'écoute

Exemple de code :

Rendu d'implémentation :

1.jpg

Code d'implémentation : main.xml

<RelativeLayout xmlns:android="http:// schémas .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:padding Bottom="@ dimen/activity_vertical_margin"
tools:context=".MyActivity">

<ImageView
android:layout_width="wrap_content"
android:layout_height="w rap_content"
android :id="@+id/imgtouch"
android:background="../style/images/touch"/>
</RelativeLayout>

MainAcitivity.java

classe publique MyActivity étend 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, événement MotionEvent) {  
                Toast.makeText(getApplicationContext(),"你通过监听器模式:OnTouchListener摸了伦家~",Toast.LENGTH_LONG.show();  
                return true;  
            }  
         });  
    }  
}

Analyse du code :

Il s'agit simplement de définir un ImageView, puis de setOnTouchListener, et de réécrire la méthode onTouch. En fait, c'est déjà là ! la section de mise en page du cadre Il y a un exemple. Vous souvenez-vous encore de la jolie fille qui bougeait avec son doigt ?

Méthodes et propriétés associées à OnTouchListener :

onTouch(View v, événement MotionEvent) : les paramètres ici sont les composants qui déclenchent l'événement tactile . , événement d'événement tactile Encapsule les informations détaillées de l’événement déclencheur, y compris le type d’événement, l’heure de déclenchement et d’autres informations. Par exemple, event.getX(), event.getY()
Nous pouvons également juger le type d'action tactile et utiliser event.getAction() pour juger à nouveau, par exemple :
event.getAction == MotionEvent. ACTION_DOWN : événement de presse
event.getAction == MotionEvent.ACTION_MOVE : événement de déplacement
event.getAction == MotionEvent.ACTION_UP : pop- up event

2. La méthode onTouchEvent() basée sur le rappel

est également un événement tactile, mais onTouchEvent est davantage destiné aux vues personnalisées, donc cette méthode a a été remplacé dans la classe view, et cet événement tactile est basé sur des rappels, c'est-à-dire : si la valeur que nous renvoyons est fausse, alors l'événement continuera à se propager vers l'extérieur et à être traité par le conteneur externe ou l'activité !Bien sûr, il implique également des gestes, que nous expliquerons en détail plus tard ! onTouchEvent est en fait similaire à onTouchListener, sauf que le mécanisme de traitement n'est pas utilisé. Le premier est un rappel et le second est en mode écoute !

Exemple de code : Définissez une vue simple et dessinez un petit cercle bleu qui peut se déplacer avec votre doigt

Code d'implémentation :MyView .java

classe publique MyView étend View{  
    public float X = 50 ;  
    flotteur public 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>

Rendu d'implémentation :

2.jpg

Utilisez votre doigt pour toucher pour vous déplacer~

3 .Multi-touch

Principes des choses :

Ce qu'on appelle le multi-touch signifie que plusieurs doigts opèrent sur l'écran. La fonction la plus couramment utilisée est probablement la fonction de zoom, telle que Many. les navigateurs d'images prennent en charge le zoom ! En théorie, le système Android lui-même peut gérer le toucher de jusqu'à 256 doigts, bien sûr, cela dépend de la prise en charge du matériel du téléphone mobile, cependant, les téléphones mobiles prenant en charge le multi-touch prennent généralement en charge 2 à 4 points, et bien sûr ; certains en ont plus ! Nous avons constaté que MotionEvent est utilisé dans les deux premiers points et que MotionEvent représente un événement tactile ; nous pouvons juger sur quel type d'opération il est basé sur event.getAction() & MotionEvent.ACTION_MASK, en plus du trois introduits ci-dessus En plus des opérations monopoint, il existe deux opérations dédiées multipoints :

  • MotionEvent.ACTION_POINTER_DOWN : Lorsqu'un point de l'écran est déjà enfoncé, appuyez sur à nouveau à ce moment Déclenché à d'autres moments.
  • MotionEvent.ACTION_POINTER_UP : Déclenché lorsque plusieurs points sur l'écran sont enfoncés et que l'un des points est relâché (c'est-à-dire lorsque le non-dernier point est relâché).

Le processus simple est probablement le suivant :

  • Lorsque nous touchons l'écran avec un doigt ->
    • Ensuite, un autre doigt touche également l'écran——> L'événement ACTION_POINTER_DOWN est déclenché. S'il y a d'autres doigts qui se touchent, continuez à déclencher
  • Un doigt quitte l'écran——> . Si le doigt continue de partir, continuez le déclenchement
  • Lorsque le dernier doigt quitte l'écran——> Déclenchez l'événement ACTION_UP
  • Et pendant tout le processus, l'événement ACTION_MOVE sera déclenché en continu<🎜. >
  • Nous pouvons obtenir les positions des différents points de contact via event.
getX

(int) ou event.getY(int): Par exemple, event.getX(0) peut obtenir la coordonnée X du premier point de contact, event.getX(1) peut obtenir la coordonnée X du deuxième point de contact comme ceci... De plus, nous pouvons également déterminer combien de doigts se touchent actuellement en appelant la méthode getPointerCount() de l'objet MotionEvent~

Exemple de code :

OK , Écrivons l'exemple le plus courant de glisser une image avec un doigt et de zoomer sur une image avec deux doigts :

Rendu d'implémentation :

3.gifImplémentation Code :

<?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" />

< ;/RelativeLayout>

MainActivity.java

package com.jay.example.edittextdemo;

importer android.app.Activity;
importer android.graphics.Matrix;
importer android.graphics.PointF;
importer android.os.Bundle;
importer android.util.FloatMath;
importer android.view.MotionEvent;
importer android.view.View;
importer android.view.View.OnTouchListener;
Import Android.widget.imageView;

Public Class MainActivity Extends Activity IMPLEMECHLIISTENENER Img_test;

// Un contrôle de zoom
Private Matrix Matrix = new Matrix();
private Matrix savingMatrix = new Matrix();

// Représentation des différents états :
private static final int NONE = 0;
private static final int DRAG = 1;
private static final int ZOOM = 2;
private int mode = NONE;

// Définir le premier point appuyé, le foyer des deux points de contact, et la cause de l'accident La distance entre deux doigts appuyant :
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 savingInstanceState ) {
super. onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
img_test = (ImageView) this.findViewById(R.id.img_test);
im g_test.setOnTouchListener( this);
>

@Override
public boolean onTouch(View v, événement MotionEvent) {
ImageView view = (ImageView) v;
switch (event.getAction () & MotionEvent.ACTION_MASK) {
// Un seul doigt
        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(événement);
            if (oriDis > 10f) {
saveMatrix.set(matrix);
                midPoint = middle(event);
                mode = ZOOM;
            }
            break;
        // 手指放开
        cas 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);
            } autre if (mode == ZOOM) {
                // 两个手指滑动
float newDist = distance(event);
if (newDist > 10f) {
matrice.set(savedMatrix);
float scale = newDist / oriDis;
matrice.postScale(scale, scale, midPoint.x, midPoint.y);
                                                                          view.setImageMatrix(matrix);
return true ;
}

// Calculer la distance entre deux points de contact
distance flottante privée (Événement MotionEvent) {
float x = event.getX(0) - event.getX( 1);
float y = event.getY(0) - event.getY(1);
return FloatMath .sqrt(x * x + y * y);
}

// Calculer le point médian de deux points de contact
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);
>

}



Résumé de cette section :
D'accord,
C'est tout pour TouchListener

et OnTouchEvent

et multi-touch ~

←
→