Beim Umgang mit Touch-Ereignissen in ViewGroup ist besondere Vorsicht geboten, da es für eine ViewGroup häufig vorkommen, dass untergeordnete Elemente für andere Touch-Ereignisse als das ViewGroup selbst angelegt sind. Damit die entsprechenden Touch-Ereignisse in jeder Ansicht richtig empfangen werden, muss die Methode onInterceptTouchEvent() überschrieben werden.
Weitere Informationen finden Sie in den folgenden Ressourcen:
Touch-Ereignisse in einer ViewGroup abfangen
Die Methode onInterceptTouchEvent() wird immer dann aufgerufen, wenn ein Berührungsereignis auf der Oberfläche eines ViewGroup erkannt wird, auch auf der Oberfläche der untergeordneten Elemente. Wenn onInterceptTouchEvent() true zurückgibt, wird die MotionEvent abgefangen. Das bedeutet, dass sie nicht an das untergeordnete Element, sondern an die Methode onTouchEvent() des übergeordneten Elements übergeben wird.
Die Methode onInterceptTouchEvent() gibt einem übergeordneten Element die Möglichkeit, Touch-Ereignisse vor den untergeordneten Elementen zu sehen. Wenn Sie true von onInterceptTouchEvent() zurückgeben, erhält die untergeordnete Ansicht, die zuvor Touchereignisse verarbeitet hat, ein 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 in der Ansichtshierarchie zu ihren üblichen Zielen hinuntergehen, die die Ereignisse mit ihrer eigenen onTouchEvent() verarbeiten.
Im folgenden Snippet erweitert die MyViewGroup-Klasse ViewGroup.
MyViewGroup enthält mehrere untergeordnete Ansichten. Wenn Sie den Finger horizontal über eine untergeordnete Ansicht ziehen, werden in der untergeordneten Ansicht keine Touch-Ereignisse mehr erfasst. In MyViewGroup werden diese durch Scrollen im Inhalt verarbeitet. Wenn Sie jedoch in der untergeordneten Ansicht auf Schaltflächen tippen oder in der untergeordneten Ansicht vertikal scrollen, fängt die übergeordnete Ansicht diese Touch-Ereignisse nicht ab, da das untergeordnete Ziel das beabsichtigte Ziel ist. In diesen Fällen gibt onInterceptTouchEvent() false zurück und der onTouchEvent() 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.
...
}
}
ViewGroup bietet auch die Methode requestDisallowInterceptTouchEvent(). ViewGroup ruft diese Methode auf, wenn ein untergeordnetes Element nicht möchte, dass das übergeordnete Element und seine Ancestors Touch-Ereignisse mit onInterceptTouchEvent() abfangen.
Ereignisse vom Typ ACTION_OUTSIDE verarbeiten
Wenn ein ViewGroup ein MotionEvent mit einem ACTION_OUTSIDE empfängt, wird das Ereignis nicht standardmäßig an seine untergeordneten Elemente gesendet. Wenn ein MotionEvent mit ACTION_OUTSIDE verarbeitet werden soll, musst du dispatchTouchEvent(MotionEvent event) entweder überschreiben und an die entsprechende View senden oder im entsprechenden Window.Callback verarbeiten, z. B. Activity.
ViewConfiguration-Konstanten verwenden
Das vorherige Snippet verwendet den aktuellen ViewConfiguration, um eine Variable namens mTouchSlop zu initialisieren. Mit der Klasse ViewConfiguration kannst du auf gängige Entfernungen, Geschwindigkeiten und Zeiten zugreifen, die vom Android-System verwendet werden.
„Touch Slop“ bezieht sich auf den Abstand in Pixeln, den ein Nutzer bei einer Berührung bewegen kann, bevor die Geste als Scrollen interpretiert wird. Touch Slop wird normalerweise verwendet, um versehentliches Scrollen zu verhindern, wenn der Nutzer einen anderen Touchvorgang ausführt, z. B. das Berühren von Bildschirmelementen.
Zwei weitere häufig verwendete ViewConfiguration-Methoden sind getScaledMinimumFlingVelocity() und getScaledMaximumFlingVelocity().
Diese Methoden geben die minimale bzw. maximale Geschwindigkeit zurück, um eine FLing-Messung in Pixel pro Sekunde zu initiieren. Beispiele:
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ührungsbereich einer Kinderansicht vergrößern
Android bietet die Klasse TouchDelegate, damit übergeordnete Nutzer den antippbaren Bereich einer untergeordneten Ansicht über die Grenzen des untergeordneten Elements hinaus erweitern können. Dies ist nützlich, wenn das Kind klein sein muss, aber einen größeren Touchbereich benötigt. Sie können so auch den Touchbereich des Kindes verkleinern.
Im folgenden Beispiel ist ein ImageButton die _delegate-View_, d. h. das untergeordnete Element, dessen Touchbereich der übergeordnete Bereich 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>
Das folgende Snippet führt diese Aufgaben aus:
- Ruft die übergeordnete Ansicht ab und postet einen
Runnableim UI-Thread. Dadurch wird sichergestellt, dass das übergeordnete Element die untergeordneten Elemente festlegt, bevor die MethodegetHitRect()aufgerufen wird. Mit der MethodegetHitRect()wird das Trefferrechteck (oder der antippbare Bereich) des untergeordneten Elements in den Koordinaten des übergeordneten Elements abgerufen. - Ermittelt die untergeordnete Ansicht
ImageButtonund ruftgetHitRect()auf, um die Grenzen des berührbaren Bereichs des untergeordneten Elements abzurufen. - Erweitert die Grenzen des Trefferrechtecks der untergeordneten Ansicht
ImageButton. - Instanziiert ein
TouchDelegateund übergibt das erweiterte Trefferrechteck sowie die untergeordneteImageButton-Ansicht als Parameter. - Legt den
TouchDelegatein der übergeordneten Ansicht fest, sodass Berührungen innerhalb der Touch-Delegate-Grenzen an die untergeordnete Ansicht 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 Ereignis 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);
}
}
});
}
}