From da7f63416dfd614cbde4feb15bb44477fcc5554b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Paczos?= Date: Thu, 15 Mar 2018 13:10:07 +0100 Subject: [PATCH 1/5] pointers management tests --- .../gestures/PointersManagementTest.java | 154 ++++++++++++++++++ 1 file changed, 154 insertions(+) create mode 100644 library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java diff --git a/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java b/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java new file mode 100644 index 0000000..56939d0 --- /dev/null +++ b/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java @@ -0,0 +1,154 @@ +package com.mapbox.android.gestures; + +import android.view.MotionEvent; + +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; + +import static com.mapbox.android.gestures.TestUtils.getMotionEvent; +import static org.mockito.Mockito.spy; + +@RunWith(RobolectricTestRunner.class) +public class PointersManagementTest extends + AbstractGestureDetectorTest { + + @Override + StandardScaleGestureDetector getDetectorObject() { + return spy(androidGesturesManager.getStandardScaleGestureDetector()); + } + + private void checkResult(int expected) { + int pointersCount = androidGesturesManager.getStandardScaleGestureDetector().getPointersCount(); + Assert.assertTrue( + String.format("Expected %d pointers, was %d.", expected, pointersCount), + pointersCount == expected + ); + } + + @Test + public void missingDownTest() { + MotionEvent pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + checkResult(0); + } + + @Test + public void missingUpTest() { + MotionEvent downEvent = getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0); + androidGesturesManager.onTouchEvent(downEvent); + + downEvent = getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, downEvent); + androidGesturesManager.onTouchEvent(downEvent); + + checkResult(1); + } + + @Test + public void missingPointerDownTest() { + MotionEvent downEvent = getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0); + androidGesturesManager.onTouchEvent(downEvent); + + MotionEvent pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + MotionEvent pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerUpEvent); + + pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(pointerUpEvent); + + pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + checkResult(0); //expecting 0, because we are waiting for ACTION_DOWN to synchronise again + } + + @Test + public void missingPointerUpTest() { + MotionEvent downEvent = getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0); + androidGesturesManager.onTouchEvent(downEvent); + + MotionEvent pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + MotionEvent pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerUpEvent); + + MotionEvent upEvent = getMotionEvent(MotionEvent.ACTION_UP, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(upEvent); + + checkResult(0); + } + + @Test + public void addingRemovingPointersTest() { + MotionEvent downEvent = getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0); + androidGesturesManager.onTouchEvent(downEvent); + + MotionEvent pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + checkResult(4); + + MotionEvent pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerUpEvent); + + pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(pointerUpEvent); + + pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(pointerUpEvent); + + MotionEvent upEvent = getMotionEvent(MotionEvent.ACTION_UP, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(upEvent); + + checkResult(0); + } + + // TODO: 15.03.18 fix this test + /*@Test + public void stopAnalysisWhenPointersMisalignedTest() { + MotionEvent downEvent = getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0); + androidGesturesManager.onTouchEvent(downEvent); + + MotionEvent pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + + MotionEvent pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerDownEvent); + androidGesturesManager.onTouchEvent(pointerUpEvent); + + MotionEvent upEvent = getMotionEvent(MotionEvent.ACTION_UP, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(upEvent); + + // don't analyze when events out of sync + doReturn(true).when(gestureDetector).checkPressure(); + doReturn(false).when(gestureDetector).isSloppyGesture(); + + MotionEvent moveEvent = getMotionEvent(MotionEvent.ACTION_MOVE, 0, 0, upEvent); + androidGesturesManager.onTouchEvent(moveEvent); + + verify(gestureDetector, times(0)).analyzeMovement(); + + pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerUpEvent); + androidGesturesManager.onTouchEvent(pointerDownEvent); + }*/ +} From f00e6b969c2e0ba3d73a0a1ccecfee96e33f9456 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Paczos?= Date: Thu, 15 Mar 2018 13:15:50 +0100 Subject: [PATCH 2/5] [WIP] missing events impl --- .../android/gestures/MultiFingerGesture.java | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java b/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java index c4f5700..528b35c 100644 --- a/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java +++ b/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java @@ -56,6 +56,11 @@ public MultiFingerGesture(Context context, AndroidGesturesManager gesturesManage @Override protected boolean analyzeEvent(MotionEvent motionEvent) { int action = motionEvent.getActionMasked(); + + if (isMissingEvents(action)) { + return false; + } + switch (action) { case MotionEvent.ACTION_DOWN: case MotionEvent.ACTION_POINTER_DOWN: @@ -85,6 +90,43 @@ protected boolean analyzeEvent(MotionEvent motionEvent) { return false; } + private long allowedActions = MotionEvent.ACTION_DOWN; + + private boolean isMissingEvents(int action) { + if (action == allowedActions) { + return true; + } + for (int i = 0; i < 64 / 4; i++) { + if (allowedActions == 0) { + allowedActions = MotionEvent.ACTION_DOWN; + return true; + } + + long testCase = allowedActions & 0xb1111; + if (action == testCase) { + break; + } + + allowedActions = allowedActions >> 4; + } + + if (pointerIdList.size() == 0) { + allowedActions = MotionEvent.ACTION_DOWN; + } else if (pointerIdList.size() >= 1) { + allowedActions += MotionEvent.ACTION_POINTER_DOWN; + allowedActions = allowedActions << 4; + allowedActions += MotionEvent.ACTION_MOVE; + allowedActions = allowedActions << 4; + allowedActions += MotionEvent.ACTION_UP; + if (pointerIdList.size() > 1) { + allowedActions = allowedActions << 4; + allowedActions += MotionEvent.ACTION_POINTER_UP; + } + } + + return true; + } + boolean checkPressure() { float currentPressure = getCurrentEvent().getPressure(); float previousPressure = getPreviousEvent().getPressure(); From 810e9ea89cedac80d97e77bca5282002e2348ee1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Paczos?= Date: Thu, 15 Mar 2018 20:07:18 +0100 Subject: [PATCH 3/5] added Timber dependency --- gradle/dependencies.gradle | 4 ++++ library/build.gradle | 1 + 2 files changed, 5 insertions(+) diff --git a/gradle/dependencies.gradle b/gradle/dependencies.gradle index 4845aae..7171ef5 100644 --- a/gradle/dependencies.gradle +++ b/gradle/dependencies.gradle @@ -8,6 +8,7 @@ ext { version = [ supportLibVersion: '25.4.0', + timber : '4.6.1', junit : '4.12', mockito : '2.13.0', robolectric : '3.7', @@ -28,6 +29,9 @@ ext { supportV4 : "com.android.support:support-v4:${version.supportLibVersion}", supportDesign : "com.android.support:design:${version.supportLibVersion}", + // timber + timber : "com.jakewharton.timber:timber:${version.timber}", + // instrumentation test testRunner : "com.android.support.test:runner:${version.testRunnerVersion}", testRules : "com.android.support.test:rules:${version.testRunnerVersion}", diff --git a/library/build.gradle b/library/build.gradle index bc238e6..87c2bcc 100644 --- a/library/build.gradle +++ b/library/build.gradle @@ -33,6 +33,7 @@ android { dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation dependenciesList.timber implementation dependenciesList.supportAppcompatV7 testImplementation dependenciesList.junit From 7f7b06fd6692eb6cc44283d7b2b7871210295992 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Paczos?= Date: Thu, 15 Mar 2018 20:38:02 +0100 Subject: [PATCH 4/5] missing event handling implementation --- .../android/gestures/MultiFingerGesture.java | 100 ++++++++++++------ .../android/gestures/ProgressiveGesture.java | 48 +++------ .../gestures/PointersManagementTest.java | 34 ------ 3 files changed, 84 insertions(+), 98 deletions(-) diff --git a/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java b/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java index 528b35c..cd1ffdf 100644 --- a/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java +++ b/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java @@ -13,6 +13,8 @@ import java.util.List; import java.util.NoSuchElementException; +import timber.log.Timber; + /** * Base class for all multi finger gesture detectors. * @@ -46,6 +48,13 @@ public abstract class MultiFingerGesture extends BaseGesture { final HashMap pointersDistanceMap = new HashMap<>(); private PointF focalPoint = new PointF(); + private static final int BITS_PER_ACTION_MASK = 4; + /** + * Variable that holds all possible at this point MotionEvents based on the previous one. + * Each one of them is written on {@link #BITS_PER_ACTION_MASK} successive bits. + */ + private long allowedActions = MotionEvent.ACTION_DOWN; + public MultiFingerGesture(Context context, AndroidGesturesManager gesturesManager) { super(context, gesturesManager); @@ -57,74 +66,99 @@ public MultiFingerGesture(Context context, AndroidGesturesManager gesturesManage protected boolean analyzeEvent(MotionEvent motionEvent) { int action = motionEvent.getActionMasked(); - if (isMissingEvents(action)) { - return false; - } + boolean isMissingActions = isMissingAction(action); + if (isMissingActions) { + // stopping ProgressiveGestures and clearing pointers + if (this instanceof ProgressiveGesture && ((ProgressiveGesture) this).isInProgress()) { + ((ProgressiveGesture) this).gestureStopped(); + } + pointerIdList.clear(); + pointersDistanceMap.clear(); - switch (action) { - case MotionEvent.ACTION_DOWN: - case MotionEvent.ACTION_POINTER_DOWN: - pointerIdList.add(motionEvent.getPointerId(motionEvent.getActionIndex())); - break; + allowedActions = MotionEvent.ACTION_DOWN; + } - case MotionEvent.ACTION_POINTER_UP: - case MotionEvent.ACTION_UP: - pointerIdList.remove(Integer.valueOf(motionEvent.getPointerId(motionEvent.getActionIndex()))); - break; + if (!isMissingActions || action == MotionEvent.ACTION_DOWN) { + // if we are not missing any actions or the invalid one happens + // to be ACTION_DOWN (therefore, we can start over immediately), then update pointers + updatePointerList(motionEvent); + updateAllowedActions(); + } - case MotionEvent.ACTION_MOVE: + if (isMissingActions) { + Timber.w("Some MotionEvents were not passed to the library."); + return false; + } else { + if (action == MotionEvent.ACTION_MOVE) { if (pointerIdList.size() >= getRequiredPointersCount() && checkPressure()) { calculateDistances(); if (!isSloppyGesture()) { focalPoint = Utils.determineFocalPoint(motionEvent); return analyzeMovement(); } - return false; } - break; - - default: - break; + } } return false; } - private long allowedActions = MotionEvent.ACTION_DOWN; + private void updatePointerList(MotionEvent motionEvent) { + int action = motionEvent.getActionMasked(); - private boolean isMissingEvents(int action) { + if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN) { + pointerIdList.add(motionEvent.getPointerId(motionEvent.getActionIndex())); + } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP) { + pointerIdList.remove(Integer.valueOf(motionEvent.getPointerId(motionEvent.getActionIndex()))); + } + } + + private boolean isMissingAction(int action) { if (action == allowedActions) { - return true; + // this will only happen for action == allowedActions == ACTION_DOWN + return false; } - for (int i = 0; i < 64 / 4; i++) { + + for (int i = 0; i < 64 / BITS_PER_ACTION_MASK; i++) { if (allowedActions == 0) { - allowedActions = MotionEvent.ACTION_DOWN; + // no available matching actions, we are missing some! return true; } - long testCase = allowedActions & 0xb1111; + // get one of actions, the one on the first BITS_PER_ACTION_MASK bits + long testCase = allowedActions & ((1 << BITS_PER_ACTION_MASK) - 1); if (action == testCase) { - break; + // we got a match, all good + return false; } - allowedActions = allowedActions >> 4; + // remove the one we just checked and iterate + allowedActions = allowedActions >> BITS_PER_ACTION_MASK; } + return true; + } + + private void updateAllowedActions() { + allowedActions = 0; + if (pointerIdList.size() == 0) { + // only ACTION_DOWN available when no other pointers registered allowedActions = MotionEvent.ACTION_DOWN; } else if (pointerIdList.size() >= 1) { + // add available actions accordingly, shifting by BITS_PER_ACTION_MASK with each addition allowedActions += MotionEvent.ACTION_POINTER_DOWN; - allowedActions = allowedActions << 4; + allowedActions = allowedActions << BITS_PER_ACTION_MASK; allowedActions += MotionEvent.ACTION_MOVE; - allowedActions = allowedActions << 4; - allowedActions += MotionEvent.ACTION_UP; - if (pointerIdList.size() > 1) { - allowedActions = allowedActions << 4; + + if (pointerIdList.size() == 1) { + allowedActions = allowedActions << BITS_PER_ACTION_MASK; + allowedActions += MotionEvent.ACTION_UP; + } else if (pointerIdList.size() > 1) { + allowedActions = allowedActions << BITS_PER_ACTION_MASK; allowedActions += MotionEvent.ACTION_POINTER_UP; } } - - return true; } boolean checkPressure() { diff --git a/library/src/main/java/com/mapbox/android/gestures/ProgressiveGesture.java b/library/src/main/java/com/mapbox/android/gestures/ProgressiveGesture.java index d9887b2..3891b10 100644 --- a/library/src/main/java/com/mapbox/android/gestures/ProgressiveGesture.java +++ b/library/src/main/java/com/mapbox/android/gestures/ProgressiveGesture.java @@ -45,37 +45,23 @@ protected boolean analyzeEvent(MotionEvent motionEvent) { boolean movementHandled = super.analyzeEvent(motionEvent); - if (!movementHandled) { - int action = motionEvent.getActionMasked(); - switch (action) { - case MotionEvent.ACTION_DOWN: - case MotionEvent.ACTION_POINTER_DOWN: - - if (velocityTracker != null) { - velocityTracker.clear(); - } - break; - - case MotionEvent.ACTION_UP: - case MotionEvent.ACTION_POINTER_UP: - if (pointerIdList.size() < getRequiredPointersCount() && isInProgress) { - gestureStopped(); - return true; - } - break; - - case MotionEvent.ACTION_CANCEL: - if (velocityTracker != null) { - velocityTracker.clear(); - } - if (isInProgress) { - gestureStopped(); - return true; - } - break; - - default: - break; + int action = motionEvent.getActionMasked(); + if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN) { + if (velocityTracker != null) { + velocityTracker.clear(); + } + } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP) { + if (pointerIdList.size() < getRequiredPointersCount() && isInProgress) { + gestureStopped(); + return true; + } + } else if (action == MotionEvent.ACTION_CANCEL) { + if (velocityTracker != null) { + velocityTracker.clear(); + } + if (isInProgress) { + gestureStopped(); + return true; } } diff --git a/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java b/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java index 56939d0..11d38af 100644 --- a/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java +++ b/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java @@ -117,38 +117,4 @@ public void addingRemovingPointersTest() { checkResult(0); } - - // TODO: 15.03.18 fix this test - /*@Test - public void stopAnalysisWhenPointersMisalignedTest() { - MotionEvent downEvent = getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0); - androidGesturesManager.onTouchEvent(downEvent); - - MotionEvent pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent); - androidGesturesManager.onTouchEvent(pointerDownEvent); - - pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent); - androidGesturesManager.onTouchEvent(pointerDownEvent); - - pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent); - androidGesturesManager.onTouchEvent(pointerDownEvent); - - MotionEvent pointerUpEvent = getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerDownEvent); - androidGesturesManager.onTouchEvent(pointerUpEvent); - - MotionEvent upEvent = getMotionEvent(MotionEvent.ACTION_UP, 0, 0, pointerUpEvent); - androidGesturesManager.onTouchEvent(upEvent); - - // don't analyze when events out of sync - doReturn(true).when(gestureDetector).checkPressure(); - doReturn(false).when(gestureDetector).isSloppyGesture(); - - MotionEvent moveEvent = getMotionEvent(MotionEvent.ACTION_MOVE, 0, 0, upEvent); - androidGesturesManager.onTouchEvent(moveEvent); - - verify(gestureDetector, times(0)).analyzeMovement(); - - pointerDownEvent = getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerUpEvent); - androidGesturesManager.onTouchEvent(pointerDownEvent); - }*/ } From 42cff8fca464808dd1b82d21eb6682e2d09b2cff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Paczos?= Date: Fri, 16 Mar 2018 07:43:42 +0100 Subject: [PATCH 5/5] missing events implementation refactor --- .../android/gestures/MultiFingerGesture.java | 27 +++++++++---------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java b/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java index cd1ffdf..84ba625 100644 --- a/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java +++ b/library/src/main/java/com/mapbox/android/gestures/MultiFingerGesture.java @@ -48,10 +48,11 @@ public abstract class MultiFingerGesture extends BaseGesture { final HashMap pointersDistanceMap = new HashMap<>(); private PointF focalPoint = new PointF(); - private static final int BITS_PER_ACTION_MASK = 4; + private static final int BITS_PER_ALLOWED_ACTION = 4; + private static final int ALLOWED_ACTION_MASK = ((1 << BITS_PER_ALLOWED_ACTION) - 1); /** * Variable that holds all possible at this point MotionEvents based on the previous one. - * Each one of them is written on {@link #BITS_PER_ACTION_MASK} successive bits. + * Each one of them is written on {@link #BITS_PER_ALLOWED_ACTION} successive bits. */ private long allowedActions = MotionEvent.ACTION_DOWN; @@ -119,23 +120,19 @@ private boolean isMissingAction(int action) { return false; } - for (int i = 0; i < 64 / BITS_PER_ACTION_MASK; i++) { - if (allowedActions == 0) { - // no available matching actions, we are missing some! - return true; - } - - // get one of actions, the one on the first BITS_PER_ACTION_MASK bits - long testCase = allowedActions & ((1 << BITS_PER_ACTION_MASK) - 1); + while (allowedActions != 0) { + // get one of actions, the one on the first BITS_PER_ALLOWED_ACTION bits + long testCase = allowedActions & ALLOWED_ACTION_MASK; if (action == testCase) { // we got a match, all good return false; } // remove the one we just checked and iterate - allowedActions = allowedActions >> BITS_PER_ACTION_MASK; + allowedActions = allowedActions >> BITS_PER_ALLOWED_ACTION; } + // no available matching actions, we are missing some! return true; } @@ -146,16 +143,16 @@ private void updateAllowedActions() { // only ACTION_DOWN available when no other pointers registered allowedActions = MotionEvent.ACTION_DOWN; } else if (pointerIdList.size() >= 1) { - // add available actions accordingly, shifting by BITS_PER_ACTION_MASK with each addition + // add available actions accordingly, shifting by BITS_PER_ALLOWED_ACTION with each addition allowedActions += MotionEvent.ACTION_POINTER_DOWN; - allowedActions = allowedActions << BITS_PER_ACTION_MASK; + allowedActions = allowedActions << BITS_PER_ALLOWED_ACTION; allowedActions += MotionEvent.ACTION_MOVE; if (pointerIdList.size() == 1) { - allowedActions = allowedActions << BITS_PER_ACTION_MASK; + allowedActions = allowedActions << BITS_PER_ALLOWED_ACTION; allowedActions += MotionEvent.ACTION_UP; } else if (pointerIdList.size() > 1) { - allowedActions = allowedActions << BITS_PER_ACTION_MASK; + allowedActions = allowedActions << BITS_PER_ALLOWED_ACTION; allowedActions += MotionEvent.ACTION_POINTER_UP; } }