Berührungsereignisse in einer ViewGroup verwalten

Compose ausprobieren
Jetpack Compose ist das empfohlene UI-Toolkit für Android. Informationen zu Touch-Gesten in der Google-Konversation
Touch-Gesten →

Die Verarbeitung von Touch-Ereignissen in einem ViewGroup erfordert besondere Sorgfalt, da ViewGroup-Elemente häufig untergeordnete Elemente haben, die Ziele für andere Touch-Ereignisse als das ViewGroup-Element selbst sind.ViewGroupViewGroup Überschreiben Sie die Methode onInterceptTouchEvent(), damit jede Ansicht die für sie vorgesehenen Touch-Ereignisse korrekt empfängt.

Berührungsereignisse in einer ViewGroup abfangen

Die Methode onInterceptTouchEvent() wird aufgerufen, wenn ein Touch-Ereignis auf der Oberfläche eines ViewGroup erkannt wird, einschließlich der Oberfläche seiner untergeordneten Elemente. Wenn onInterceptTouchEvent() den Wert true zurückgibt, wird MotionEvent abgefangen, d. h., er wird nicht an das untergeordnete Element, sondern an die onTouchEvent()-Methode des übergeordneten Elements übergeben.

Mit der Methode onInterceptTouchEvent() kann ein übergeordnetes Element Touch-Ereignisse sehen, bevor seine untergeordneten Elemente sie sehen. Wenn Sie true von onInterceptTouchEvent() zurückgeben, erhält die untergeordnete Ansicht, die zuvor Touch-Ereignisse verarbeitet hat, eine ACTION_CANCEL. Die Ereignisse werden ab diesem Zeitpunkt zur üblichen Verarbeitung an die onTouchEvent()-Methode des übergeordneten Elements gesendet. onInterceptTouchEvent() kann auch false zurückgeben und Ereignisse beobachten, während sie durch die Ansichtshierarchie zu ihren üblichen Zielen wandern, die die Ereignisse mit ihrer eigenen onTouchEvent() verarbeiten.

Im folgenden Snippet erweitert die Klasse MyViewGroup die Klasse ViewGroup. MyViewGroup enthält mehrere untergeordnete Ansichten. Wenn Sie den Finger horizontal über eine untergeordnete Ansicht ziehen, werden für diese keine Touch-Ereignisse mehr empfangen. MyViewGroup verarbeitet Touch-Ereignisse, indem der Inhalt gescrollt wird. Wenn Sie jedoch in der untergeordneten Ansicht auf Schaltflächen tippen oder vertikal scrollen, werden diese Touch-Ereignisse nicht vom übergeordneten Element abgefangen, da das untergeordnete Element das beabsichtigte Ziel ist. In diesen Fällen gibt onInterceptTouchEvent() false zurück und onTouchEvent() der Klasse MyViewGroup wird nicht aufgerufen.

Kotlin

class MyViewGroup @JvmOverloads constructor(
        context: Context,
        private val mTouchSlop: Int = ViewConfiguration.get(context).scaledTouchSlop
) : ViewGroup(context) {
    ...
    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
        // This method only determines whether you want to intercept the motion.
        // If this method returns true, onTouchEvent is called and you can do
        // the actual scrolling there.
        return when (ev.actionMasked) {
            // Always handle the case of the touch gesture being complete.
            MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_UP -> {
                // Release the scroll.
                mIsScrolling = false
                false // Don't intercept the touch event. Let the child handle it.
            }
            MotionEvent.ACTION_MOVE -> {
                if (mIsScrolling) {
                    // You're currently scrolling, so intercept the touch event.
                    true
                } else {

                    // If the user drags their finger horizontally more than the
                    // touch slop, start the scroll.

                    // Left as an exercise for the reader.
                    val xDiff: Int = calculateDistanceX(ev)

                    // Touch slop is calculated using ViewConfiguration constants.
                    if (xDiff > mTouchSlop) {
                        // Start scrolling!
                        mIsScrolling = true
                        true
                    } else {
                        false
                    }
                }
            }
            ...
            else -> {
                // In general, don't intercept touch events. The child view
                // handles them.
                false
            }
        }
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        // Here, you actually handle the touch event. For example, if the action
        // is ACTION_MOVE, scroll this container. This method is only called if
        // the touch event is intercepted in onInterceptTouchEvent.
        ...
    }
}

Java

public class MyViewGroup extends ViewGroup {

    private int mTouchSlop;
    ...
    ViewConfiguration vc = ViewConfiguration.get(view.getContext());
    mTouchSlop = vc.getScaledTouchSlop();
    ...
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        // This method only determines whether you want to intercept the motion.
        // If this method returns true, onTouchEvent is called and you can do
        // the actual scrolling there.

        final int action = MotionEventCompat.getActionMasked(ev);

        // Always handle the case of the touch gesture being complete.
        if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
            // Release the scroll.
            mIsScrolling = false;
            return false; // Don't intercept touch event. Let the child handle it.
        }

        switch (action) {
            case MotionEvent.ACTION_MOVE: {
                if (mIsScrolling) {
                    // You're currently scrolling, so intercept the touch event.
                    return true;
                }

                // If the user drags their finger horizontally more than the
                // touch slop, start the scroll.

                // Left as an exercise for the reader.
                final int xDiff = calculateDistanceX(ev);

                // Touch slop is calculated using ViewConfiguration constants.
                if (xDiff > mTouchSlop) {
                    // Start scrolling.
                    mIsScrolling = true;
                    return true;
                }
                break;
            }
            ...
        }

        // In general, don't intercept touch events. The child view handles them.
        return false;
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        // Here, you actually handle the touch event. For example, if the
        // action is ACTION_MOVE, scroll this container. This method is only
        // called if the touch event is intercepted in onInterceptTouchEvent.
        ...
    }
}

Beachten Sie, dass ViewGroup auch eine requestDisallowInterceptTouchEvent()-Methode bietet. Die ViewGroup ruft diese Methode auf, wenn ein untergeordnetes Element nicht möchte, dass das übergeordnete Element und seine Vorfahren Touch-Ereignisse mit onInterceptTouchEvent() abfangen.

ACTION_OUTSIDE-Ereignisse verarbeiten

Wenn ein ViewGroup ein MotionEvent mit einer ACTION_OUTSIDE empfängt, wird das Ereignis standardmäßig nicht an seine untergeordneten Elemente gesendet. Wenn Sie eine MotionEvent mit ACTION_OUTSIDE verarbeiten möchten, überschreiben Sie entweder dispatchTouchEvent(MotionEvent event), um sie an die entsprechende View zu senden, oder verarbeiten Sie sie in der entsprechenden Window.Callback, z. B. Activity.

Konstanten für ViewConfiguration verwenden

Im vorherigen Snippet wird der aktuelle Wert von ViewConfiguration verwendet, um eine Variable namens mTouchSlop zu initialisieren. Mit der ViewConfiguration-Klasse können Sie auf gängige Entfernungen, Geschwindigkeiten und Zeiten zugreifen, die vom Android-System verwendet werden.

„Touch Slop“ bezieht sich auf die Entfernung in Pixeln, die der Finger eines Nutzers zurücklegen kann, bevor die Geste als Scrollen interpretiert wird. Mit dem Touch-Slop wird in der Regel verhindert, dass Nutzer versehentlich scrollen, wenn sie einen anderen Touch-Vorgang ausführen, z. B. das Berühren von Elementen auf dem Bildschirm.

Zwei weitere häufig verwendete ViewConfiguration-Methoden sind getScaledMinimumFlingVelocity() und getScaledMaximumFlingVelocity(). Diese Methoden geben die minimale und maximale Geschwindigkeit zurück, um einen „Fling“ zu initiieren, gemessen in Pixeln pro Sekunde. Beispiel:

Kotlin

private val vc: ViewConfiguration = ViewConfiguration.get(context)
private val mSlop: Int = vc.scaledTouchSlop
private val mMinFlingVelocity: Int = vc.scaledMinimumFlingVelocity
private val mMaxFlingVelocity: Int = vc.scaledMaximumFlingVelocity
...
MotionEvent.ACTION_MOVE -> {
    ...
    val deltaX: Float = motionEvent.rawX - mDownX
    if (Math.abs(deltaX) > mSlop) {
        // A swipe occurs, do something.
    }
    return false
}
...
MotionEvent.ACTION_UP -> {
    ...
    if (velocityX in mMinFlingVelocity..mMaxFlingVelocity && velocityY < velocityX) {
        // The criteria are satisfied, do something.
    }
}

Java

ViewConfiguration vc = ViewConfiguration.get(view.getContext());
private int mSlop = vc.getScaledTouchSlop();
private int mMinFlingVelocity = vc.getScaledMinimumFlingVelocity();
private int mMaxFlingVelocity = vc.getScaledMaximumFlingVelocity();
...
case MotionEvent.ACTION_MOVE: {
    ...
    float deltaX = motionEvent.getRawX() - mDownX;
    if (Math.abs(deltaX) > mSlop) {
        // A swipe occurs, do something.
    }
...
case MotionEvent.ACTION_UP: {
    ...
    } if (mMinFlingVelocity <= velocityX && velocityX <= mMaxFlingVelocity
            && velocityY < velocityX) {
        // The criteria are satisfied, do something.
    }
}

Berührbaren Bereich einer untergeordneten Ansicht erweitern

Android bietet die Klasse TouchDelegate, mit der eine übergeordnete Ansicht den berührbaren Bereich einer untergeordneten Ansicht über die Grenzen der untergeordneten Ansicht hinaus erweitern kann. Das ist nützlich, wenn das Kind klein sein muss, aber einen größeren Touchbereich benötigt. Mit dieser Methode können Sie auch den Touchbildschirmbereich des Kindes verkleinern.

Im folgenden Beispiel ist ImageButton die delegierte Ansicht, also das untergeordnete Element, dessen Touchbereich das übergeordnete Element erweitert. Hier ist die Layoutdatei:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/parent_layout"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     tools:context=".MainActivity" >

     <ImageButton android:id="@+id/button"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:background="@null"
          android:src="@drawable/icon" />
</RelativeLayout>

Mit dem folgenden Snippet werden diese Aufgaben ausgeführt:

  • Ruft die übergeordnete Ansicht ab und postet eine Runnable im UI-Thread. So wird sichergestellt, dass das übergeordnete Element seine untergeordneten Elemente auslegt, bevor die Methode getHitRect() aufgerufen wird. Die Methode getHitRect() ruft das Auftreff-Rechteck (oder den berührbaren Bereich) des untergeordneten Elements in den Koordinaten des übergeordneten Elements ab.
  • Sucht die untergeordnete Ansicht ImageButton und ruft getHitRect() auf, um die Grenzen des berührbaren Bereichs des untergeordneten Elements abzurufen.
  • Erweitert die Grenzen des Treffer-Rechtecks der untergeordneten ImageButton-Ansicht.
  • Erstellt eine Instanz von TouchDelegate und übergibt das maximierte Treffer-Rechteck und die untergeordnete ImageButton-Ansicht als Parameter.
  • Legt die TouchDelegate in der übergeordneten Ansicht so fest, dass Berührungen innerhalb der Touch-Delegierung an das untergeordnete Element weitergeleitet werden.

In seiner Funktion als Touch-Delegierter für die untergeordnete Ansicht ImageButton empfängt die übergeordnete Ansicht alle Touch-Ereignisse. Wenn das Touch-Ereignis innerhalb des Trefferbereichs des untergeordneten Elements auftritt, gibt das übergeordnete Element das Touch-Ereignis zur Verarbeitung an das untergeordnete Element weiter.

Kotlin

public class MainActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Post in the parent's message queue to make sure the parent lays out
        // its children before you call getHitRect().
        findViewById<View>(R.id.parent_layout).post {
            // The bounds for the delegate view, which is an ImageButton in this
            // example.
            val delegateArea = Rect()
            val myButton = findViewById<ImageButton>(R.id.button).apply {
                isEnabled = true
                setOnClickListener {
                    Toast.makeText(
                            this@MainActivity,
                            "Touch occurred within ImageButton touch region.",
                            Toast.LENGTH_SHORT
                    ).show()
                }

                // The hit rectangle for the ImageButton.
                getHitRect(delegateArea)
            }

            // Extend the touch area of the ImageButton beyond its bounds on the
            // right and bottom.
            delegateArea.right += 100
            delegateArea.bottom += 100

            // Set the TouchDelegate on the parent view so that touches within
            // the touch delegate bounds are routed to the child.
            (myButton.parent as? View)?.apply {
                // Instantiate a TouchDelegate. "delegateArea" is the bounds in
                // local coordinates of the containing view to be mapped to the
                // delegate view. "myButton" is the child view that receives
                // motion events.
                touchDelegate = TouchDelegate(delegateArea, myButton)
            }
        }
    }
}

Java

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // Get the parent view.
        View parentView = findViewById(R.id.parent_layout);

        parentView.post(new Runnable() {
            // Post in the parent's message queue to make sure the parent lays
            // out its children before you call getHitRect().
            @Override
            public void run() {
                // The bounds for the delegate view, which is an ImageButton in
                // this example.
                Rect delegateArea = new Rect();
                ImageButton myButton = (ImageButton) findViewById(R.id.button);
                myButton.setEnabled(true);
                myButton.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        Toast.makeText(MainActivity.this,
                                "Touch occurred within ImageButton touch region.",
                                Toast.LENGTH_SHORT).show();
                    }
                });

                // The hit rectangle for the ImageButton.
                myButton.getHitRect(delegateArea);

                // Extend the touch area of the ImageButton beyond its bounds on
                // the right and bottom.
                delegateArea.right += 100;
                delegateArea.bottom += 100;

                // Instantiate a TouchDelegate. "delegateArea" is the bounds in
                // local coordinates of the containing view to be mapped to the
                // delegate view. "myButton" is the child view that receives
                // motion events.
                TouchDelegate touchDelegate = new TouchDelegate(delegateArea,
                        myButton);

                // Set the TouchDelegate on the parent view so that touches
                // within the touch delegate bounds are routed to the child.
                if (View.class.isInstance(myButton.getParent())) {
                    ((View) myButton.getParent()).setTouchDelegate(touchDelegate);
                }
            }
        });
    }
}