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.
Weitere Informationen finden Sie unter den folgenden Links:
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() true zurückgibt, wird der MotionEvent abgefangen. Das bedeutet, dass er nicht an das untergeordnete Element, sondern an die Methode onTouchEvent() des übergeordneten Elements übergeben wird.
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 ausspionieren, während sie die Ansichtshierarchie zu ihren üblichen Zielen hinunterwandern, die die Ereignisse mit ihren eigenen onTouchEvent() verarbeiten.
Im folgenden Snippet erweitert die Klasse MyViewGroup den 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 auf Schaltflächen in der untergeordneten Ansicht 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 einem ACTION_OUTSIDE empfängt, wird das Ereignis nicht standardmäßig an seine untergeordneten Elemente weitergeleitet. 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 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 gängige ViewConfiguration-Methoden sind getScaledMinimumFlingVelocity() und getScaledMaximumFlingVelocity().
Diese Methoden geben die minimale bzw. maximale Geschwindigkeit zurück, um einen Fling zu initiieren, der in Pixeln pro Sekunde gemessen wird. 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, damit ein übergeordnetes Element den antippbaren Bereich einer untergeordneten Ansicht über die Grenzen des untergeordneten Elements hinaus erweitern kann. Das ist nützlich, wenn das Kind klein sein muss, aber einen größeren Touchbereich benötigt. Sie können diesen Ansatz auch nutzen, um den Touchbereich des Kindes zu verkleinern.
Im folgenden Beispiel ist ImageButton die delegierte Ansicht, also das untergeordnete Element, dessen Touchbereich das übergeordnete Element erweitert. So sieht die Layoutdatei aus:
<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
Runnableim UI-Thread. So wird sichergestellt, dass das übergeordnete Element seine untergeordneten Elemente auslegt, bevor die MethodegetHitRect()aufgerufen wird. Die MethodegetHitRect()ruft das Auftreff-Rechteck (oder den berührbaren Bereich) des untergeordneten Elements in den Koordinaten des übergeordneten Elements ab. - Sucht nach der untergeordneten Ansicht
ImageButtonund ruftgetHitRect()auf, um die Grenzen des berührbaren Bereichs des untergeordneten Elements abzurufen. - Erweitert die Grenzen des Treffer-Rechtecks der untergeordneten Ansicht
ImageButton. - Erzeugt eine
TouchDelegateund übergibt das maximierte Treffer-Rechteck und die untergeordneteImageButton-Ansicht als Parameter. - Legt die
TouchDelegatein 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 Treffer-Rechtecks 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);
}
}
});
}
}