Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Berührungsereignisse in einer ViewGroup verwalten

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

Weitere Informationen finden Sie in den folgenden Ressourcen:

Berührungsereignisse in einer ViewGroup abfangen

Die Methode onInterceptTouchEvent() wird immer aufgerufen, wenn auf der Oberfläche eines ViewGroups ein Touch-Ereignis erkannt wird, auch auf der Oberfläche der untergeordneten Elemente. Wenn onInterceptTouchEvent() den Wert true zurückgibt, wird MotionEvent abgefangen. Das bedeutet, dass sie nicht an das untergeordnete Element, sondern an die onTouchEvent()-Methode des übergeordneten Elements übergeben wird.

Mit der Methode onInterceptTouchEvent() haben Eltern die Möglichkeit, Berührungsereignisse vor ihren Kindern zu sehen. Wenn Sie true von onInterceptTouchEvent() zurückgeben, erhält die untergeordnete Ansicht, die zuvor Berührungsereignisse verarbeitet hat, ein ACTION_CANCEL. Die Ereignisse werden ab diesem Zeitpunkt an die onTouchEvent()-Methode des übergeordneten Elements gesendet, um wie gewohnt verarbeitet zu werden. onInterceptTouchEvent() kann auch false zurückgeben und Ereignisse beobachten, während sie in der Ansichtshierarchie zu ihren üblichen Zielen wandern, die die Ereignisse mit ihren eigenen onTouchEvent() verarbeiten.

Im folgenden Snippet wird die Klasse MyViewGroup von ViewGroup abgeleitet. MyViewGroup enthält mehrere untergeordnete Ansichten. Wenn Sie Ihren Finger horizontal über eine untergeordnete Ansicht ziehen, erhält die untergeordnete Ansicht keine Touch-Ereignisse mehr und MyViewGroup verarbeitet Touch-Ereignisse, indem der Inhalt gescrollt wird. Wenn Sie jedoch in der Kinderansicht 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() den Wert false zurück und die onTouchEvent()-Methode der MyViewGroup-Klasse 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 Vorgänger Berührungsereignisse mit onInterceptTouchEvent() abfangen.

ACTION_OUTSIDE-Ereignisse verarbeiten

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

ViewConfiguration-Konstanten verwenden

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

„Touch Slop“ bezieht sich auf die Distanz in Pixeln, die ein Nutzer mit seiner Berührung zurücklegen kann, bevor die Touchgeste als Scrollen interpretiert wird. Die Touch-Toleranz wird in der Regel verwendet, um versehentliches Scrollen zu verhindern, wenn der Nutzer eine andere Touch-Aktion ausführt, 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 bzw. maximale Geschwindigkeit zurück, die zum Starten eines Fling-Vorgangs erforderlich ist (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 ein übergeordnetes Element den berührbaren Bereich einer untergeordneten Ansicht über die Grenzen des untergeordneten Elements hinaus erweitern kann. Das ist nützlich, wenn das Kind klein sein muss, aber eine größere Touch-Region benötigt. Sie können diesen Ansatz auch verwenden, um den Touch-Bereich des untergeordneten Elements zu verkleinern.

Im folgenden Beispiel ist ImageButton die _delegate-Ansicht_, also das untergeordnete Element, dessen Touchbereich das übergeordnete Element erweitert. Hier sehen Sie 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>

Das folgende Snippet führt diese Aufgaben aus:

Ruft die Elternansicht ab und postet ein Runnable im UI-Thread. So wird sichergestellt, dass das übergeordnete Element seine untergeordneten Elemente vor dem Aufrufen der Methode getHitRect() anordnet. Die Methode getHitRect() ruft das Treffer-Rechteck (oder die berührbare Fläche) 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 Trefferrechtecks der untergeordneten ImageButton-Ansicht.
Instanziiert ein TouchDelegate und übergibt das erweiterte Trefferrechteck und die Kinderansicht ImageButton als Parameter.
Legt die TouchDelegate in der Elternansicht so fest, dass Berührungen innerhalb der Grenzen des Touch-Delegaten an das untergeordnete Element weitergeleitet werden.

Als Touch-Delegate für die untergeordnete Ansicht ImageButton empfängt die übergeordnete Ansicht alle Touch-Ereignisse. Wenn das Touch-Ereignis innerhalb des Trefferrechtecks des untergeordneten Elements auftritt, übergibt das übergeordnete Element das Touch-Ereignis zur Verarbeitung an das untergeordnete Element.

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);
                }
            }
        });
    }
}

Berührungsereignisse in einer ViewGroup verwalten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Berührungsereignisse in einer ViewGroup abfangen

Kotlin

Java

ACTION_OUTSIDE-Ereignisse verarbeiten

ViewConfiguration-Konstanten verwenden

Kotlin

Java

Berührbaren Bereich einer untergeordneten Ansicht erweitern

Kotlin

Java

Berührungsereignisse in einer ViewGroup verwalten