exclusives : gesturesManager.getMutuallyExclusiveGestures()) {
72 | if (exclusives.contains(invokedGestureType)) {
73 | for (@AndroidGesturesManager.GestureType int gestureType : exclusives) {
74 | for (BaseGesture detector : gesturesManager.getDetectors()) {
75 | if (detector instanceof ProgressiveGesture) {
76 | ProgressiveGesture progressiveDetector = (ProgressiveGesture) detector;
77 | if (progressiveDetector.getHandledTypes().contains(gestureType)
78 | && progressiveDetector.isInProgress()) {
79 | return false;
80 | }
81 | }
82 | }
83 | }
84 | }
85 | }
86 |
87 | return true;
88 | }
89 |
90 | protected void setListener(L listener) {
91 | this.listener = listener;
92 | }
93 |
94 | protected void removeListener() {
95 | listener = null;
96 | }
97 |
98 | /**
99 | * Returns a difference in millis between {@link MotionEvent#getDownTime()} and {@link MotionEvent#getEventTime()}
100 | * (most recent event's time) associated with this gesture.
101 | *
102 | * This is a duration of the user's total interaction with the touch screen,
103 | * accounting for the time before the gesture was recognized by the detector.
104 | *
105 | * @return duration of the gesture in millis.
106 | */
107 | public long getGestureDuration() {
108 | return gestureDuration;
109 | }
110 |
111 | /**
112 | * Returns most recent event in this gesture chain.
113 | *
114 | * @return most recent event
115 | */
116 | public MotionEvent getCurrentEvent() {
117 | return currentEvent;
118 | }
119 |
120 | /**
121 | * Returns previous event in this gesture chain.
122 | *
123 | * @return previous event
124 | */
125 | public MotionEvent getPreviousEvent() {
126 | return previousEvent;
127 | }
128 |
129 | /**
130 | * Check whether this detector accepts and analyzes motion events. Default is true.
131 | *
132 | * @return true if it analyzes, false otherwise
133 | */
134 | public boolean isEnabled() {
135 | return isEnabled;
136 | }
137 |
138 | /**
139 | * Set whether this detector should accept and analyze motion events. Default is true.
140 | *
141 | * @param enabled true if it should analyze, false otherwise
142 | */
143 | public void setEnabled(boolean enabled) {
144 | isEnabled = enabled;
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/Constants.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | public final class Constants {
4 |
5 | /**
6 | * Default angle change required in rotation movement to register rotate gesture./
7 | */
8 | public static final float DEFAULT_ROTATE_ANGLE_THRESHOLD = 15.3f;
9 |
10 | /**
11 | * Default angle between pointers (starting from horizontal line) required to abort shove gesture.
12 | */
13 | public static final float DEFAULT_SHOVE_MAX_ANGLE = 20f;
14 |
15 | /**
16 | * Default time within which pointers need to leave the screen to register tap gesture.
17 | */
18 | public static final long DEFAULT_MULTI_TAP_TIME_THRESHOLD = 150L;
19 |
20 |
21 | /*Private constants*/
22 | static final String internal_scaleGestureDetectorMinSpanField = "mMinSpan";
23 | static final String internal_scaleGestureDetectorSpanSlopField = "mSpanSlop";
24 | }
25 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/MoveDistancesObject.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | /**
4 | * Class that holds initial, previous and current X and Y on-screen coordinates for active pointers.
5 | */
6 | public final class MoveDistancesObject {
7 | private final float initialX;
8 | private final float initialY;
9 |
10 | private float prevX;
11 | private float prevY;
12 | private float currX;
13 | private float currY;
14 |
15 | private float distanceXSinceLast;
16 | private float distanceYSinceLast;
17 | private float distanceXSinceStart;
18 | private float distanceYSinceStart;
19 |
20 | public MoveDistancesObject(float initialX, float initialY) {
21 | this.initialX = initialX;
22 | this.initialY = initialY;
23 | }
24 |
25 | /**
26 | * Add a new position of this pointer and recalculate distances.
27 | * @param x new X coordinate
28 | * @param y new Y coordinate
29 | */
30 | public void addNewPosition(float x, float y) {
31 | prevX = currX;
32 | prevY = currY;
33 |
34 | currX = x;
35 | currY = y;
36 |
37 | distanceXSinceLast = prevX - currX;
38 | distanceYSinceLast = prevY - currY;
39 |
40 | distanceXSinceStart = initialX - currX;
41 | distanceYSinceStart = initialY - currY;
42 | }
43 |
44 | /**
45 | * Get X coordinate of this pointer when it was first register.
46 | * @return X coordinate
47 | */
48 | public float getInitialX() {
49 | return initialX;
50 | }
51 |
52 | /**
53 | * Get Y coordinate of this pointer when it was first register.
54 | * @return Y coordinate
55 | */
56 | public float getInitialY() {
57 | return initialY;
58 | }
59 |
60 | /**
61 | * Get previous X coordinate of this pointer.
62 | * @return X coordinate
63 | */
64 | public float getPreviousX() {
65 | return prevX;
66 | }
67 |
68 | /**
69 | * Get previous Y coordinate of this pointer.
70 | * @return Y coordinate
71 | */
72 | public float getPreviousY() {
73 | return prevY;
74 | }
75 |
76 | /**
77 | * Get current X coordinate of this pointer.
78 | * @return X coordinate
79 | */
80 | public float getCurrentX() {
81 | return currX;
82 | }
83 |
84 | /**
85 | * Get current Y coordinate of this pointer.
86 | * @return Y coordinate
87 | */
88 | public float getCurrentY() {
89 | return currY;
90 | }
91 |
92 | /**
93 | * Get X distance covered by this pointer since previous position.
94 | * @return X distance
95 | */
96 | public float getDistanceXSinceLast() {
97 | return distanceXSinceLast;
98 | }
99 |
100 | /**
101 | * Get Y distance covered by this pointer since previous position.
102 | * @return Y distance
103 | */
104 | public float getDistanceYSinceLast() {
105 | return distanceYSinceLast;
106 | }
107 |
108 | /**
109 | * Get X distance covered by this pointer since start position.
110 | * @return X distance
111 | */
112 | public float getDistanceXSinceStart() {
113 | return distanceXSinceStart;
114 | }
115 |
116 | /**
117 | * Get Y distance covered by this pointer since start position.
118 | * @return Y distance
119 | */
120 | public float getDistanceYSinceStart() {
121 | return distanceYSinceStart;
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/MoveGestureDetector.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import android.graphics.PointF;
5 | import android.graphics.RectF;
6 | import android.view.MotionEvent;
7 |
8 | import androidx.annotation.DimenRes;
9 | import androidx.annotation.NonNull;
10 | import androidx.annotation.Nullable;
11 | import androidx.annotation.UiThread;
12 |
13 | import java.util.HashMap;
14 | import java.util.HashSet;
15 | import java.util.Map;
16 | import java.util.Set;
17 |
18 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_MOVE;
19 |
20 | /**
21 | * Gesture detector handling move gesture.
22 | *
23 | * {@link MoveGestureDetector} serves similar purpose to
24 | * {@link com.mapbox.android.gestures.StandardGestureDetector.StandardOnGestureListener
25 | * #onScroll(MotionEvent, MotionEvent, float, float)}, however, it's a {@link ProgressiveGesture} that
26 | * introduces {@link OnMoveGestureListener#onMoveBegin(MoveGestureDetector)},
27 | * {@link OnMoveGestureListener#onMoveEnd(MoveGestureDetector, float, float)},
28 | * threshold with {@link MoveGestureDetector#setMoveThreshold(float)} and multi finger support thanks to
29 | * {@link MoveDistancesObject}.
30 | */
31 | @UiThread
32 | public class MoveGestureDetector extends ProgressiveGesture {
33 | private static final int MOVE_REQUIRED_POINTERS_COUNT = 1;
34 | private static final Set handledTypes = new HashSet<>();
35 | private PointF previousFocalPoint;
36 | private boolean resetFocal;
37 | float lastDistanceX;
38 | float lastDistanceY;
39 |
40 | static {
41 | handledTypes.add(GESTURE_TYPE_MOVE);
42 | }
43 |
44 | @Nullable
45 | private RectF moveThresholdRect;
46 | private float moveThreshold;
47 |
48 | private final Map moveDistancesObjectMap = new HashMap<>();
49 |
50 | public MoveGestureDetector(Context context, AndroidGesturesManager gesturesManager) {
51 | super(context, gesturesManager);
52 | }
53 |
54 | @NonNull
55 | @Override
56 | protected Set provideHandledTypes() {
57 | return handledTypes;
58 | }
59 |
60 | public interface OnMoveGestureListener {
61 | /**
62 | * Indicates that the move gesture started.
63 | *
64 | * @param detector this detector
65 | * @return true if you want to receive subsequent {@link #onMove(MoveGestureDetector, float, float)} callbacks,
66 | * false if you want to ignore this gesture.
67 | */
68 | boolean onMoveBegin(@NonNull MoveGestureDetector detector);
69 |
70 | /**
71 | * Called for every move change during the gesture.
72 | *
73 | * @param detector this detector
74 | * @param distanceX X distance of the focal point in pixel since last call
75 | * @param distanceY Y distance of the focal point in pixel since last call
76 | * @return true if the gesture was handled, false otherwise
77 | */
78 | boolean onMove(@NonNull MoveGestureDetector detector, float distanceX, float distanceY);
79 |
80 | /**
81 | * Indicates that the move gesture ended.
82 | *
83 | * @param velocityX velocityX of the gesture in the moment of lifting the fingers
84 | * @param velocityY velocityY of the gesture in the moment of lifting the fingers
85 | * @param detector this detector
86 | */
87 | void onMoveEnd(@NonNull MoveGestureDetector detector, float velocityX, float velocityY);
88 | }
89 |
90 | public static class SimpleOnMoveGestureListener implements OnMoveGestureListener {
91 |
92 | @Override
93 | public boolean onMoveBegin(@NonNull MoveGestureDetector detector) {
94 | return true;
95 | }
96 |
97 | @Override
98 | public boolean onMove(@NonNull MoveGestureDetector detector, float distanceX, float distanceY) {
99 | return false;
100 | }
101 |
102 | @Override
103 | public void onMoveEnd(@NonNull MoveGestureDetector detector, float velocityX, float velocityY) {
104 | // No implementation
105 | }
106 | }
107 |
108 | @Override
109 | protected boolean analyzeEvent(@NonNull MotionEvent motionEvent) {
110 | switch (motionEvent.getActionMasked()) {
111 | case MotionEvent.ACTION_DOWN:
112 | case MotionEvent.ACTION_POINTER_DOWN:
113 | resetFocal = true; //recalculating focal point
114 |
115 | float x = motionEvent.getX(motionEvent.getActionIndex());
116 | float y = motionEvent.getY(motionEvent.getActionIndex());
117 | moveDistancesObjectMap.put(
118 | motionEvent.getPointerId(motionEvent.getActionIndex()),
119 | new MoveDistancesObject(x, y)
120 | );
121 | break;
122 |
123 | case MotionEvent.ACTION_UP:
124 | moveDistancesObjectMap.clear();
125 | break;
126 |
127 | case MotionEvent.ACTION_POINTER_UP:
128 | resetFocal = true; //recalculating focal point
129 |
130 | moveDistancesObjectMap.remove(motionEvent.getPointerId(motionEvent.getActionIndex()));
131 | break;
132 |
133 | case MotionEvent.ACTION_CANCEL:
134 | moveDistancesObjectMap.clear();
135 | break;
136 |
137 | default:
138 | break;
139 | }
140 |
141 | return super.analyzeEvent(motionEvent);
142 | }
143 |
144 | @Override
145 | protected boolean analyzeMovement() {
146 | super.analyzeMovement();
147 | updateMoveDistancesObjects();
148 |
149 | if (isInProgress()) {
150 | PointF currentFocalPoint = getFocalPoint();
151 | lastDistanceX = previousFocalPoint.x - currentFocalPoint.x;
152 | lastDistanceY = previousFocalPoint.y - currentFocalPoint.y;
153 | previousFocalPoint = currentFocalPoint;
154 | if (resetFocal) {
155 | resetFocal = false;
156 | return listener.onMove(this, 0, 0);
157 | }
158 | return listener.onMove(this, lastDistanceX, lastDistanceY);
159 | } else if (canExecute(GESTURE_TYPE_MOVE)) {
160 | if (listener.onMoveBegin(this)) {
161 | gestureStarted();
162 | previousFocalPoint = getFocalPoint();
163 | resetFocal = false;
164 | return true;
165 | }
166 | }
167 | return false;
168 | }
169 |
170 | private void updateMoveDistancesObjects() {
171 | for (int pointerId : pointerIdList) {
172 | moveDistancesObjectMap.get(pointerId).addNewPosition(
173 | getCurrentEvent().getX(getCurrentEvent().findPointerIndex(pointerId)),
174 | getCurrentEvent().getY(getCurrentEvent().findPointerIndex(pointerId))
175 | );
176 | }
177 | }
178 |
179 | boolean checkAnyMoveAboveThreshold() {
180 | for (MoveDistancesObject moveDistancesObject : moveDistancesObjectMap.values()) {
181 | boolean thresholdExceeded = Math.abs(moveDistancesObject.getDistanceXSinceStart()) >= moveThreshold
182 | || Math.abs(moveDistancesObject.getDistanceYSinceStart()) >= moveThreshold;
183 |
184 | boolean isInRect = moveThresholdRect != null && moveThresholdRect.contains(getFocalPoint().x, getFocalPoint().y);
185 | return !isInRect && thresholdExceeded;
186 | }
187 | return false;
188 | }
189 |
190 | @Override
191 | protected boolean canExecute(int invokedGestureType) {
192 | return super.canExecute(invokedGestureType) && checkAnyMoveAboveThreshold();
193 | }
194 |
195 | @Override
196 | protected void reset() {
197 | super.reset();
198 | }
199 |
200 | @Override
201 | protected void gestureStopped() {
202 | super.gestureStopped();
203 | listener.onMoveEnd(this, velocityX, velocityY);
204 | }
205 |
206 | @Override
207 | protected int getRequiredPointersCount() {
208 | return MOVE_REQUIRED_POINTERS_COUNT;
209 | }
210 |
211 | /**
212 | * Get the delta pixel threshold required to qualify it as a move gesture.
213 | *
214 | * @return delta pixel threshold
215 | * @see #getMoveThresholdRect()
216 | */
217 | public float getMoveThreshold() {
218 | return moveThreshold;
219 | }
220 |
221 | /**
222 | * Set the delta pixel threshold required to qualify it as a move gesture.
223 | *
224 | * We encourage to set those values from dimens to accommodate for various screen sizes.
225 | *
226 | * @param moveThreshold delta threshold
227 | * @see #setMoveThresholdRect(RectF)
228 | */
229 | public void setMoveThreshold(float moveThreshold) {
230 | this.moveThreshold = moveThreshold;
231 | }
232 |
233 | /**
234 | * Get the screen area in which the move gesture cannot be started.
235 | * If the gesture is already in progress, this value is ignored.
236 | * This condition is evaluated before {@link #setMoveThreshold(float)}.
237 | *
238 | * @return the screen area in which the gesture cannot be started
239 | */
240 | @Nullable
241 | public RectF getMoveThresholdRect() {
242 | return moveThresholdRect;
243 | }
244 |
245 | /**
246 | * Set the screen area in which the move gesture cannot be started.
247 | * If the gesture is already in progress, this value is ignored.
248 | * This condition is evaluated before {@link #setMoveThreshold(float)}.
249 | *
250 | * @param moveThresholdRect the screen area in which the gesture cannot be started
251 | */
252 | public void setMoveThresholdRect(@Nullable RectF moveThresholdRect) {
253 | this.moveThresholdRect = moveThresholdRect;
254 | }
255 |
256 | /**
257 | * Set the delta dp threshold required to qualify it as a move gesture.
258 | *
259 | * @param moveThresholdDimen delta threshold
260 | */
261 | public void setMoveThresholdResource(@DimenRes int moveThresholdDimen) {
262 | setMoveThreshold(context.getResources().getDimension(moveThresholdDimen));
263 | }
264 |
265 | /**
266 | * Returns X distance of the focal point in pixels
267 | * calculated during the last {@link OnMoveGestureListener#onMove(MoveGestureDetector, float, float)} call.
268 | *
269 | * @return X distance of the focal point in pixel
270 | */
271 | public float getLastDistanceX() {
272 | return lastDistanceX;
273 | }
274 |
275 | /**
276 | * Returns Y distance of the focal point in pixels
277 | * calculated during the last {@link OnMoveGestureListener#onMove(MoveGestureDetector, float, float)} call.
278 | *
279 | * @return Y distance of the focal point in pixel
280 | */
281 | public float getLastDistanceY() {
282 | return lastDistanceY;
283 | }
284 |
285 | /**
286 | * Returns {@link MoveDistancesObject} referencing the pointer held under passed index.
287 | *
288 | * Pointers are sorted by the time they were placed on the screen until lifted up.
289 | * This means that index 0 will reflect the oldest added, still active pointer
290 | * and index ({@link #getPointersCount()} - 1) will reflect the latest added, still active pointer.
291 | *
292 | *
293 | * @param pointerIndex pointer's index
294 | * @return distances object of the referenced pointer
295 | */
296 | public MoveDistancesObject getMoveObject(int pointerIndex) {
297 | if (isInProgress()) {
298 | if (pointerIndex >= 0 && pointerIndex < getPointersCount()) {
299 | return moveDistancesObjectMap.get(pointerIdList.get(pointerIndex));
300 | }
301 | }
302 | return null;
303 | }
304 | }
305 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/MultiFingerDistancesObject.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | /**
4 | * Object that holds pixel current and previous distances between a pair of fingers.
5 | */
6 | public class MultiFingerDistancesObject {
7 | private final float prevFingersDiffX;
8 | private final float prevFingersDiffY;
9 | private final float currFingersDiffX;
10 | private final float currFingersDiffY;
11 | private final float prevFingersDiffXY;
12 | private final float currFingersDiffXY;
13 |
14 | public MultiFingerDistancesObject(float prevFingersDiffX, float prevFingersDiffY,
15 | float currFingersDiffX, float currFingersDiffY) {
16 | this.prevFingersDiffX = prevFingersDiffX;
17 | this.prevFingersDiffY = prevFingersDiffY;
18 | this.currFingersDiffX = currFingersDiffX;
19 | this.currFingersDiffY = currFingersDiffY;
20 |
21 | prevFingersDiffXY =
22 | (float) Math.sqrt(prevFingersDiffX * prevFingersDiffX + prevFingersDiffY * prevFingersDiffY);
23 |
24 | currFingersDiffXY =
25 | (float) Math.sqrt(currFingersDiffX * currFingersDiffX + currFingersDiffY * currFingersDiffY);
26 | }
27 |
28 | public float getPrevFingersDiffX() {
29 | return prevFingersDiffX;
30 | }
31 |
32 | public float getPrevFingersDiffY() {
33 | return prevFingersDiffY;
34 | }
35 |
36 | public float getCurrFingersDiffX() {
37 | return currFingersDiffX;
38 | }
39 |
40 | public float getCurrFingersDiffY() {
41 | return currFingersDiffY;
42 | }
43 |
44 | public float getPrevFingersDiffXY() {
45 | return prevFingersDiffXY;
46 | }
47 |
48 | public float getCurrFingersDiffXY() {
49 | return currFingersDiffXY;
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/MultiFingerTapGestureDetector.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 |
5 | import androidx.annotation.DimenRes;
6 | import androidx.annotation.UiThread;
7 | import androidx.annotation.NonNull;
8 |
9 | import android.view.MotionEvent;
10 |
11 | import java.util.HashMap;
12 |
13 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_MULTI_FINGER_TAP;
14 |
15 | /**
16 | * Gesture detector handling multi tap gesture.
17 | */
18 | @UiThread
19 | public class MultiFingerTapGestureDetector extends
20 | MultiFingerGesture {
21 |
22 | /**
23 | * Maximum time in millis to lift the fingers to register a tap event.
24 | */
25 | private long multiFingerTapTimeThreshold;
26 |
27 | /**
28 | * Maximum movement in pixels allowed for any finger before rejecting this gesture.
29 | */
30 | private float multiFingerTapMovementThreshold;
31 | private boolean invalidMovement;
32 | private boolean pointerLifted;
33 | private int lastPointersDownCount;
34 |
35 | public MultiFingerTapGestureDetector(Context context, AndroidGesturesManager gesturesManager) {
36 | super(context, gesturesManager);
37 | }
38 |
39 | public interface OnMultiFingerTapGestureListener {
40 | boolean onMultiFingerTap(@NonNull MultiFingerTapGestureDetector detector, int pointersCount);
41 | }
42 |
43 | @Override
44 | protected boolean analyzeEvent(@NonNull MotionEvent motionEvent) {
45 | super.analyzeEvent(motionEvent);
46 |
47 | int action = motionEvent.getActionMasked();
48 | switch (action) {
49 | case MotionEvent.ACTION_POINTER_DOWN:
50 | if (pointerLifted) {
51 | invalidMovement = true;
52 | }
53 | lastPointersDownCount = pointerIdList.size();
54 | break;
55 |
56 | case MotionEvent.ACTION_POINTER_UP:
57 | pointerLifted = true;
58 | break;
59 |
60 | case MotionEvent.ACTION_UP:
61 | boolean canExecute = canExecute(GESTURE_TYPE_MULTI_FINGER_TAP);
62 | boolean handled = false;
63 | if (canExecute) {
64 | handled = listener.onMultiFingerTap(this, lastPointersDownCount);
65 | }
66 | reset();
67 | return handled;
68 |
69 | case MotionEvent.ACTION_MOVE:
70 | if (invalidMovement) {
71 | break;
72 | }
73 | invalidMovement = exceededMovementThreshold(pointersDistanceMap);
74 | break;
75 |
76 | default:
77 | break;
78 | }
79 |
80 | return false;
81 | }
82 |
83 | boolean exceededMovementThreshold(HashMap map) {
84 | for (MultiFingerDistancesObject distancesObject : map.values()) {
85 | float diffX = Math.abs(distancesObject.getCurrFingersDiffX() - distancesObject.getPrevFingersDiffX());
86 | float diffY = Math.abs(distancesObject.getCurrFingersDiffY() - distancesObject.getPrevFingersDiffY());
87 |
88 | invalidMovement = diffX > multiFingerTapMovementThreshold || diffY > multiFingerTapMovementThreshold;
89 |
90 | if (invalidMovement) {
91 | return true;
92 | }
93 | }
94 |
95 | return false;
96 | }
97 |
98 | @Override
99 | protected boolean canExecute(int invokedGestureType) {
100 | return lastPointersDownCount > 1 && !invalidMovement && getGestureDuration() < multiFingerTapTimeThreshold
101 | && super.canExecute(invokedGestureType);
102 | }
103 |
104 | @Override
105 | protected void reset() {
106 | super.reset();
107 | lastPointersDownCount = 0;
108 | invalidMovement = false;
109 | pointerLifted = false;
110 | }
111 |
112 | /**
113 | * Get maximum time in millis that fingers can have a contact with the screen before rejecting this gesture.
114 | *
115 | * @return maximum touch time for tap gesture.
116 | */
117 | public long getMultiFingerTapTimeThreshold() {
118 | return multiFingerTapTimeThreshold;
119 | }
120 |
121 | /**
122 | * Set maximum time in millis that fingers can have a contact with the screen before rejecting this gesture.
123 | *
124 | * @param multiFingerTapTimeThreshold maximum touch time for tap gesture.
125 | */
126 | public void setMultiFingerTapTimeThreshold(long multiFingerTapTimeThreshold) {
127 | this.multiFingerTapTimeThreshold = multiFingerTapTimeThreshold;
128 | }
129 |
130 | /**
131 | * Get maximum movement allowed for any finger before rejecting this gesture.
132 | *
133 | * @return movement threshold in pixels.
134 | */
135 | public float getMultiFingerTapMovementThreshold() {
136 | return multiFingerTapMovementThreshold;
137 | }
138 |
139 | /**
140 | * Set maximum movement allowed in pixels for any finger before rejecting this gesture.
141 | *
142 | * We encourage to set those values from dimens to accommodate for various screen sizes.
143 | *
144 | * @param multiFingerTapMovementThreshold movement threshold.
145 | */
146 | public void setMultiFingerTapMovementThreshold(float multiFingerTapMovementThreshold) {
147 | this.multiFingerTapMovementThreshold = multiFingerTapMovementThreshold;
148 | }
149 |
150 | /**
151 | * Set maximum movement allowed in dp for any finger before rejecting this gesture.
152 | *
153 | * @param multiFingerTapMovementThresholdDimen movement threshold.
154 | */
155 | public void setMultiFingerTapMovementThresholdResource(@DimenRes int multiFingerTapMovementThresholdDimen) {
156 | setMultiFingerTapMovementThreshold(context.getResources().getDimension(multiFingerTapMovementThresholdDimen));
157 | }
158 | }
159 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/PermittedActionsGuard.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import androidx.annotation.IntRange;
4 | import android.view.MotionEvent;
5 |
6 | class PermittedActionsGuard {
7 |
8 | /**
9 | * Enables to store up to 8 permitted actions in the long type (64 bits / 8 bits per action).
10 | */
11 | private static final int BITS_PER_PERMITTED_ACTION = 8;
12 | private static final int PERMITTED_ACTION_MASK = ((1 << BITS_PER_PERMITTED_ACTION) - 1);
13 | private static final int NO_ACTION_PERMITTED = 0b11111111;
14 |
15 | boolean isMissingActions(int action,
16 | @IntRange(from = 0) int eventPointerCount,
17 | @IntRange(from = 0) int internalPointerCount) {
18 | long permittedActions = updatePermittedActions(eventPointerCount, internalPointerCount);
19 | if (action == permittedActions) {
20 | // this will only happen for action == permittedActions == ACTION_DOWN
21 | return false;
22 | }
23 |
24 | while (permittedActions != 0) {
25 | // get one of actions, the one on the first BITS_PER_PERMITTED_ACTION bits
26 | long testCase = permittedActions & PERMITTED_ACTION_MASK;
27 | if (action == testCase) {
28 | // we got a match, all good
29 | return false;
30 | }
31 |
32 | // remove the one we just checked and iterate
33 | permittedActions = permittedActions >> BITS_PER_PERMITTED_ACTION;
34 | }
35 |
36 | // no available matching actions, we are missing some!
37 | return true;
38 | }
39 |
40 | /**
41 | * Returns all acceptable at this point MotionEvent actions based on the pointers state.
42 | * Each one of them is written on {@link #BITS_PER_PERMITTED_ACTION} successive bits.
43 | */
44 | private long updatePermittedActions(@IntRange(from = 0) int eventPointerCount,
45 | @IntRange(from = 0) int internalPointerCount) {
46 | long permittedActions = MotionEvent.ACTION_DOWN;
47 |
48 | if (internalPointerCount == 0) {
49 | // only ACTION_DOWN available when no other pointers registered
50 | permittedActions = permittedActions << BITS_PER_PERMITTED_ACTION;
51 | permittedActions += MotionEvent.ACTION_DOWN;
52 | } else {
53 | if (Math.abs(eventPointerCount - internalPointerCount) > 1) {
54 | // missing a pointer up/down event, required to start over
55 | return NO_ACTION_PERMITTED;
56 | } else {
57 | if (eventPointerCount > internalPointerCount) {
58 | // event holds one more pointer than we have locally
59 | permittedActions = permittedActions << BITS_PER_PERMITTED_ACTION;
60 | permittedActions += MotionEvent.ACTION_POINTER_DOWN;
61 | } else if (eventPointerCount < internalPointerCount) {
62 | // event holds one less pointer than we have locally. This indicates that we are missing events,
63 | // because ACTION_UP and ACTION_POINTER_UP events still return not decremented pointer count
64 | return NO_ACTION_PERMITTED;
65 | } else {
66 | // event holds an equal number of pointers compared to the local count
67 | if (eventPointerCount == 1) {
68 | permittedActions = permittedActions << BITS_PER_PERMITTED_ACTION;
69 | permittedActions += MotionEvent.ACTION_UP;
70 | } else {
71 | permittedActions = permittedActions << BITS_PER_PERMITTED_ACTION;
72 | permittedActions += MotionEvent.ACTION_POINTER_UP;
73 | }
74 | permittedActions = permittedActions << BITS_PER_PERMITTED_ACTION;
75 | permittedActions += MotionEvent.ACTION_MOVE;
76 | }
77 | }
78 | }
79 |
80 | return permittedActions;
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/PointerDistancePair.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.util.Pair;
4 |
5 | public class PointerDistancePair extends Pair {
6 |
7 | public PointerDistancePair(Integer first, Integer second) {
8 | super(first, second);
9 | }
10 |
11 | @Override
12 | public boolean equals(Object o) {
13 | if (o instanceof PointerDistancePair) {
14 | PointerDistancePair otherPair = (PointerDistancePair) o;
15 | if ((this.first.equals(otherPair.first) && this.second.equals(otherPair.second))
16 | || (this.first.equals(otherPair.second) && this.second.equals(otherPair.first))) {
17 | return true;
18 | }
19 | }
20 |
21 | return false;
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/ProgressiveGesture.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import androidx.annotation.NonNull;
5 | import androidx.annotation.UiThread;
6 | import android.view.MotionEvent;
7 | import android.view.VelocityTracker;
8 |
9 | import java.util.Set;
10 |
11 | /**
12 | * Base class for all progressive gesture detectors.
13 | *
14 | * @param listener that will be called with gesture events/updates.
15 | */
16 | @UiThread
17 | public abstract class ProgressiveGesture extends MultiFingerGesture {
18 |
19 | private final Set handledTypes = provideHandledTypes();
20 |
21 | private boolean isInProgress;
22 | private boolean interrupted;
23 |
24 | VelocityTracker velocityTracker;
25 | float velocityX;
26 | float velocityY;
27 |
28 | public ProgressiveGesture(Context context, AndroidGesturesManager gesturesManager) {
29 | super(context, gesturesManager);
30 | }
31 |
32 | @NonNull
33 | protected abstract Set provideHandledTypes();
34 |
35 | @Override
36 | protected boolean analyzeEvent(@NonNull MotionEvent motionEvent) {
37 | int action = motionEvent.getActionMasked();
38 | if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN
39 | || action == MotionEvent.ACTION_POINTER_UP
40 | || action == MotionEvent.ACTION_CANCEL) {
41 | // configuration changed, reset data
42 | reset();
43 | }
44 |
45 | if (interrupted) {
46 | interrupted = false;
47 | reset();
48 | gestureStopped();
49 | }
50 |
51 | if (velocityTracker != null) {
52 | velocityTracker.addMovement(getCurrentEvent());
53 | }
54 |
55 | boolean movementHandled = super.analyzeEvent(motionEvent);
56 |
57 | if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP) {
58 | if (pointerIdList.size() < getRequiredPointersCount() && isInProgress) {
59 | gestureStopped();
60 | return true;
61 | }
62 | } else if (action == MotionEvent.ACTION_CANCEL) {
63 | if (isInProgress) {
64 | gestureStopped();
65 | return true;
66 | }
67 | }
68 |
69 | return movementHandled;
70 | }
71 |
72 | protected void gestureStarted() {
73 | isInProgress = true;
74 | if (velocityTracker == null) {
75 | velocityTracker = VelocityTracker.obtain();
76 | }
77 | }
78 |
79 | protected void gestureStopped() {
80 | isInProgress = false;
81 | if (velocityTracker != null) {
82 | velocityTracker.computeCurrentVelocity(1000);
83 | velocityX = velocityTracker.getXVelocity();
84 | velocityY = velocityTracker.getYVelocity();
85 | velocityTracker.recycle();
86 | velocityTracker = null;
87 | }
88 | reset();
89 | }
90 |
91 | Set getHandledTypes() {
92 | return handledTypes;
93 | }
94 |
95 | /**
96 | * Check whether a gesture has started and is in progress.
97 | *
98 | * @return true if gesture is in progress, false otherwise.
99 | */
100 | public boolean isInProgress() {
101 | return isInProgress;
102 | }
103 |
104 | @Override
105 | public void setEnabled(boolean enabled) {
106 | super.setEnabled(enabled);
107 | if (!enabled) {
108 | interrupt();
109 | }
110 | }
111 |
112 | /**
113 | * Interrupt a gesture by stopping it's execution immediately.
114 | * Forces gesture detector to meet start conditions again in order to resume.
115 | */
116 | public void interrupt() {
117 | if (isInProgress()) {
118 | this.interrupted = true;
119 | }
120 | }
121 | }
122 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/RotateGestureDetector.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import androidx.annotation.NonNull;
5 | import androidx.annotation.UiThread;
6 |
7 | import java.util.HashSet;
8 | import java.util.Set;
9 |
10 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_ROTATE;
11 |
12 | /**
13 | * Gesture detector handling rotation gesture.
14 | */
15 | @UiThread
16 | public class RotateGestureDetector extends ProgressiveGesture {
17 | private static final Set handledTypes = new HashSet<>();
18 |
19 | static {
20 | handledTypes.add(GESTURE_TYPE_ROTATE);
21 | }
22 |
23 | private float angleThreshold;
24 | float deltaSinceStart;
25 | float deltaSinceLast;
26 |
27 | public RotateGestureDetector(Context context, AndroidGesturesManager gesturesManager) {
28 | super(context, gesturesManager);
29 | }
30 |
31 | @NonNull
32 | @Override
33 | protected Set provideHandledTypes() {
34 | return handledTypes;
35 | }
36 |
37 | /**
38 | * Listener for rotate gesture callbacks.
39 | */
40 | public interface OnRotateGestureListener {
41 | /**
42 | * Indicates that the rotation gesture started.
43 | *
44 | * @param detector this detector
45 | * @return true if you want to receive subsequent {@link #onRotate(RotateGestureDetector, float, float)} callbacks,
46 | * false if you want to ignore this gesture.
47 | */
48 | boolean onRotateBegin(@NonNull RotateGestureDetector detector);
49 |
50 | /**
51 | * Called for every rotation change during the gesture.
52 | *
53 | * @param detector this detector
54 | * @param rotationDegreesSinceLast rotation change since the last call
55 | * @param rotationDegreesSinceFirst rotation change since the start of the gesture
56 | * @return true if the gesture was handled, false otherwise
57 | */
58 | boolean onRotate(@NonNull RotateGestureDetector detector,
59 | float rotationDegreesSinceLast,
60 | float rotationDegreesSinceFirst);
61 |
62 | /**
63 | * Indicates that the rotation gesture ended.
64 | *
65 | * @param velocityX velocityX of the gesture in the moment of lifting the fingers
66 | * @param velocityY velocityY of the gesture in the moment of lifting the fingers
67 | * @param angularVelocity angularVelocity of the gesture in the moment of lifting the fingers
68 | * @param detector this detector
69 | */
70 | void onRotateEnd(@NonNull RotateGestureDetector detector, float velocityX, float velocityY, float angularVelocity);
71 | }
72 |
73 | public static class SimpleOnRotateGestureListener implements OnRotateGestureListener {
74 |
75 | @Override
76 | public boolean onRotateBegin(@NonNull RotateGestureDetector detector) {
77 | return true;
78 | }
79 |
80 | @Override
81 | public boolean onRotate(@NonNull RotateGestureDetector detector, float rotationDegreesSinceLast,
82 | float rotationDegreesSinceFirst) {
83 | return true;
84 | }
85 |
86 | @Override
87 | public void onRotateEnd(@NonNull RotateGestureDetector detector,
88 | float velocityX,
89 | float velocityY,
90 | float angularVelocity) {
91 | // No implementation
92 | }
93 | }
94 |
95 | @Override
96 | protected boolean analyzeMovement() {
97 | super.analyzeMovement();
98 |
99 | deltaSinceLast = getRotationDegreesSinceLast();
100 | deltaSinceStart += deltaSinceLast;
101 |
102 | if (isInProgress() && deltaSinceLast != 0) {
103 | return listener.onRotate(this, deltaSinceLast, deltaSinceStart);
104 | } else if (canExecute(GESTURE_TYPE_ROTATE)) {
105 | if (listener.onRotateBegin(this)) {
106 | gestureStarted();
107 | return true;
108 | }
109 | }
110 |
111 | return false;
112 | }
113 |
114 | @Override
115 | protected boolean canExecute(int invokedGestureType) {
116 | return Math.abs(deltaSinceStart) >= angleThreshold && super.canExecute(invokedGestureType);
117 | }
118 |
119 | @Override
120 | protected void gestureStopped() {
121 | super.gestureStopped();
122 |
123 | if (deltaSinceLast == 0) {
124 | velocityX = 0;
125 | velocityY = 0;
126 | }
127 |
128 | float angularVelocity = calculateAngularVelocityVector(velocityX, velocityY);
129 | listener.onRotateEnd(this, velocityX, velocityY, angularVelocity);
130 | }
131 |
132 | @Override
133 | protected void reset() {
134 | super.reset();
135 | deltaSinceStart = 0f;
136 | }
137 |
138 | float getRotationDegreesSinceLast() {
139 | MultiFingerDistancesObject distancesObject =
140 | pointersDistanceMap.get(new PointerDistancePair(pointerIdList.get(0), pointerIdList.get(1)));
141 |
142 | double diffRadians = Math.atan2(distancesObject.getPrevFingersDiffY(),
143 | distancesObject.getPrevFingersDiffX()) - Math.atan2(
144 | distancesObject.getCurrFingersDiffY(),
145 | distancesObject.getCurrFingersDiffX());
146 | return (float) Math.toDegrees(diffRadians);
147 | }
148 |
149 | float calculateAngularVelocityVector(float velocityX, float velocityY) {
150 | float angularVelocity = Math.abs((float) ((getFocalPoint().x * velocityY + getFocalPoint().y * velocityX)
151 | / (Math.pow(getFocalPoint().x, 2.0) + Math.pow(getFocalPoint().y, 2.0))));
152 |
153 | if (deltaSinceLast < 0) {
154 | angularVelocity = -angularVelocity;
155 | }
156 |
157 | return angularVelocity;
158 | }
159 |
160 | /**
161 | * Returns rotation change in degrees since the start of the gesture.
162 | *
163 | * @return rotation change since the start of the gesture
164 | */
165 | public float getDeltaSinceStart() {
166 | return deltaSinceStart;
167 | }
168 |
169 | /**
170 | * Returns last rotation change difference in degrees
171 | * calculated in {@link OnRotateGestureListener#onRotate(RotateGestureDetector, float, float)}
172 | *
173 | * @return rotation change since last callback
174 | */
175 | public float getDeltaSinceLast() {
176 | return deltaSinceLast;
177 | }
178 |
179 | /**
180 | * Get the threshold angle between first and current fingers position
181 | * for this detector to actually qualify it as a rotation gesture.
182 | *
183 | * @return Angle threshold for rotation gesture
184 | */
185 | public float getAngleThreshold() {
186 | return angleThreshold;
187 | }
188 |
189 | /**
190 | * Set the threshold angle between first and current fingers position
191 | * for this detector to actually qualify it as a rotation gesture.
192 | *
193 | * @param angleThreshold angle threshold for rotation gesture
194 | */
195 | public void setAngleThreshold(float angleThreshold) {
196 | this.angleThreshold = angleThreshold;
197 | }
198 | }
199 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/ShoveGestureDetector.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import androidx.annotation.DimenRes;
5 | import androidx.annotation.NonNull;
6 | import androidx.annotation.UiThread;
7 |
8 | import java.util.HashSet;
9 | import java.util.Set;
10 |
11 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_SHOVE;
12 |
13 | /**
14 | * Gesture detector handling shove gesture.
15 | */
16 | @UiThread
17 | public class ShoveGestureDetector extends ProgressiveGesture {
18 | private static final Set handledTypes = new HashSet<>();
19 |
20 | static {
21 | handledTypes.add(GESTURE_TYPE_SHOVE);
22 | }
23 |
24 | private float maxShoveAngle;
25 | private float pixelDeltaThreshold;
26 | float deltaPixelsSinceStart;
27 | float deltaPixelSinceLast;
28 |
29 | public ShoveGestureDetector(Context context, AndroidGesturesManager gesturesManager) {
30 | super(context, gesturesManager);
31 | }
32 |
33 | @NonNull
34 | @Override
35 | protected Set provideHandledTypes() {
36 | return handledTypes;
37 | }
38 |
39 | /**
40 | * Listener for shove callbacks.
41 | */
42 | public interface OnShoveGestureListener {
43 | /**
44 | * Indicates that the shove gesture started.
45 | *
46 | * @param detector this detector
47 | * @return true if you want to receive subsequent {@link #onShove(ShoveGestureDetector, float, float)} callbacks,
48 | * false if you want to ignore this gesture.
49 | */
50 | boolean onShoveBegin(@NonNull ShoveGestureDetector detector);
51 |
52 | /**
53 | * Called for every shove change during the gesture.
54 | *
55 | * @param detector this detector
56 | * @param deltaPixelsSinceLast pixels delta change since the last call
57 | * @param deltaPixelsSinceStart pixels delta change since the start of the gesture
58 | * @return true if the gesture was handled, false otherwise
59 | */
60 | boolean onShove(@NonNull ShoveGestureDetector detector, float deltaPixelsSinceLast, float deltaPixelsSinceStart);
61 |
62 | /**
63 | * Indicates that the shove gesture ended.
64 | *
65 | * @param velocityX velocityX of the gesture in the moment of lifting the fingers
66 | * @param velocityY velocityY of the gesture in the moment of lifting the fingers
67 | * @param detector this detector
68 | */
69 | void onShoveEnd(@NonNull ShoveGestureDetector detector, float velocityX, float velocityY);
70 | }
71 |
72 | public static class SimpleOnShoveGestureListener implements OnShoveGestureListener {
73 | @Override
74 | public boolean onShoveBegin(@NonNull ShoveGestureDetector detector) {
75 | return true;
76 | }
77 |
78 | @Override
79 | public boolean onShove(@NonNull ShoveGestureDetector detector,
80 | float deltaPixelsSinceLast,
81 | float deltaPixelsSinceStart) {
82 | return false;
83 | }
84 |
85 | @Override
86 | public void onShoveEnd(@NonNull ShoveGestureDetector detector, float velocityX, float velocityY) {
87 | // No Implementation
88 | }
89 | }
90 |
91 | @Override
92 | protected boolean analyzeMovement() {
93 | super.analyzeMovement();
94 |
95 | deltaPixelSinceLast = calculateDeltaPixelsSinceLast();
96 | deltaPixelsSinceStart += deltaPixelSinceLast;
97 |
98 | if (isInProgress() && deltaPixelSinceLast != 0) {
99 | return listener.onShove(this, deltaPixelSinceLast, deltaPixelsSinceStart);
100 | } else if (canExecute(GESTURE_TYPE_SHOVE)) {
101 | if (listener.onShoveBegin(this)) {
102 | gestureStarted();
103 | return true;
104 | }
105 | }
106 |
107 | return false;
108 | }
109 |
110 | @Override
111 | protected boolean canExecute(int invokedGestureType) {
112 | return Math.abs(deltaPixelsSinceStart) >= pixelDeltaThreshold
113 | && super.canExecute(invokedGestureType);
114 | }
115 |
116 | @Override
117 | protected boolean isSloppyGesture() {
118 | return super.isSloppyGesture() || !isAngleAcceptable();
119 | }
120 |
121 | @Override
122 | protected void gestureStopped() {
123 | super.gestureStopped();
124 | listener.onShoveEnd(this, velocityX, velocityY);
125 | }
126 |
127 | @Override
128 | protected void reset() {
129 | super.reset();
130 | deltaPixelsSinceStart = 0;
131 | }
132 |
133 | boolean isAngleAcceptable() {
134 | MultiFingerDistancesObject distancesObject =
135 | pointersDistanceMap.get(new PointerDistancePair(pointerIdList.get(0), pointerIdList.get(1)));
136 |
137 | // Takes values from 0 to 180
138 | double angle = Math.toDegrees(Math.abs(Math.atan2(
139 | distancesObject.getCurrFingersDiffY(), distancesObject.getCurrFingersDiffX())));
140 |
141 | return angle <= maxShoveAngle || 180f - angle <= maxShoveAngle;
142 | }
143 |
144 | float calculateDeltaPixelsSinceLast() {
145 | float py0 = getPreviousEvent().getY(getPreviousEvent().findPointerIndex(pointerIdList.get(0)));
146 | float py1 = getPreviousEvent().getY(getPreviousEvent().findPointerIndex(pointerIdList.get(1)));
147 | float prevAverageY = (py0 + py1) / 2.0f;
148 |
149 | float cy0 = getCurrentEvent().getY(getCurrentEvent().findPointerIndex(pointerIdList.get(0)));
150 | float cy1 = getCurrentEvent().getY(getCurrentEvent().findPointerIndex(pointerIdList.get(1)));
151 | float currAverageY = (cy0 + cy1) / 2.0f;
152 |
153 | return currAverageY - prevAverageY;
154 | }
155 |
156 | /**
157 | * Returns vertical pixel delta change since the start of the gesture.
158 | *
159 | * @return pixels delta change since the start of the gesture
160 | */
161 | public float getDeltaPixelsSinceStart() {
162 | return deltaPixelsSinceStart;
163 | }
164 |
165 | /**
166 | * Returns last vertical pixel delta change
167 | * calculated in {@link OnShoveGestureListener#onShove(ShoveGestureDetector, float, float)}.
168 | *
169 | * @return pixels delta change since the last call
170 | */
171 | public float getDeltaPixelSinceLast() {
172 | return deltaPixelSinceLast;
173 | }
174 |
175 | /**
176 | * Get the delta pixel threshold required to qualify it as a shove gesture.
177 | *
178 | * @return delta pixel threshold
179 | */
180 | public float getPixelDeltaThreshold() {
181 | return pixelDeltaThreshold;
182 | }
183 |
184 | /**
185 | * Set the delta pixel threshold required to qualify it as a shove gesture.
186 | *
187 | * We encourage to set those values from dimens to accommodate for various screen sizes.
188 | *
189 | * @param pixelDeltaThreshold delta threshold
190 | */
191 | public void setPixelDeltaThreshold(float pixelDeltaThreshold) {
192 | this.pixelDeltaThreshold = pixelDeltaThreshold;
193 | }
194 |
195 | /**
196 | * Set the delta dp threshold required to qualify it as a shove gesture.
197 | *
198 | * @param pixelDeltaThresholdDimen delta threshold
199 | */
200 | public void setPixelDeltaThresholdResource(@DimenRes int pixelDeltaThresholdDimen) {
201 | setPixelDeltaThreshold(context.getResources().getDimension(pixelDeltaThresholdDimen));
202 | }
203 |
204 | /**
205 | * Get the maximum allowed angle between fingers, measured from the horizontal line, to qualify it as a shove gesture.
206 | *
207 | * @return maximum allowed angle
208 | */
209 | public float getMaxShoveAngle() {
210 | return maxShoveAngle;
211 | }
212 |
213 | /**
214 | * Set the maximum allowed angle between fingers, measured from the horizontal line, to qualify it as a shove gesture.
215 | *
216 | * @param maxShoveAngle maximum allowed angle
217 | */
218 | public void setMaxShoveAngle(float maxShoveAngle) {
219 | this.maxShoveAngle = maxShoveAngle;
220 | }
221 | }
222 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/SidewaysShoveGestureDetector.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import androidx.annotation.DimenRes;
5 | import androidx.annotation.NonNull;
6 | import androidx.annotation.UiThread;
7 |
8 | import java.util.HashSet;
9 | import java.util.Set;
10 |
11 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_SIDEWAYS_SHOVE;
12 |
13 | /**
14 | * Gesture detector handling sideways shove gesture.
15 | */
16 | @UiThread
17 | public class SidewaysShoveGestureDetector extends
18 | ProgressiveGesture {
19 | private static final Set handledTypes = new HashSet<>();
20 |
21 | static {
22 | handledTypes.add(GESTURE_TYPE_SIDEWAYS_SHOVE);
23 | }
24 |
25 | private float maxShoveAngle;
26 | private float pixelDeltaThreshold;
27 | float deltaPixelsSinceStart;
28 | float deltaPixelSinceLast;
29 |
30 | public SidewaysShoveGestureDetector(Context context, AndroidGesturesManager gesturesManager) {
31 | super(context, gesturesManager);
32 | }
33 |
34 | @NonNull
35 | @Override
36 | protected Set provideHandledTypes() {
37 | return handledTypes;
38 | }
39 |
40 | /**
41 | * Listener for sideways shove gesture callbacks.
42 | */
43 | public interface OnSidewaysShoveGestureListener {
44 | /**
45 | * Indicates that the sideways shove gesture started.
46 | *
47 | * @param detector this detector
48 | * @return true if you want to receive subsequent
49 | * {@link #onSidewaysShove(SidewaysShoveGestureDetector, float, float)} callbacks,
50 | * false if you want to ignore this gesture.
51 | */
52 | boolean onSidewaysShoveBegin(@NonNull SidewaysShoveGestureDetector detector);
53 |
54 | /**
55 | * Called for every sideways shove change during the gesture.
56 | *
57 | * @param detector this detector
58 | * @param deltaPixelsSinceLast pixels delta change since the last call
59 | * @param deltaPixelsSinceStart pixels delta change since the start of the gesture
60 | * @return true if the gesture was handled, false otherwise
61 | */
62 | boolean onSidewaysShove(@NonNull SidewaysShoveGestureDetector detector, float deltaPixelsSinceLast,
63 | float deltaPixelsSinceStart);
64 |
65 | /**
66 | * Indicates that the sideways shove gesture ended.
67 | *
68 | * @param velocityX velocityX of the gesture in the moment of lifting the fingers
69 | * @param velocityY velocityY of the gesture in the moment of lifting the fingers
70 | * @param detector this detector
71 | */
72 | void onSidewaysShoveEnd(@NonNull SidewaysShoveGestureDetector detector, float velocityX, float velocityY);
73 | }
74 |
75 | public static class SimpleOnSidewaysShoveGestureListener implements OnSidewaysShoveGestureListener {
76 | @Override
77 | public boolean onSidewaysShoveBegin(@NonNull SidewaysShoveGestureDetector detector) {
78 | return true;
79 | }
80 |
81 | @Override
82 | public boolean onSidewaysShove(@NonNull SidewaysShoveGestureDetector detector, float deltaPixelsSinceLast,
83 | float deltaPixelsSinceStart) {
84 | return false;
85 | }
86 |
87 | @Override
88 | public void onSidewaysShoveEnd(@NonNull SidewaysShoveGestureDetector detector, float velocityX, float velocityY) {
89 | // No Implementation
90 | }
91 | }
92 |
93 | @Override
94 | protected boolean analyzeMovement() {
95 | super.analyzeMovement();
96 |
97 | deltaPixelSinceLast = calculateDeltaPixelsSinceLast();
98 | deltaPixelsSinceStart += deltaPixelSinceLast;
99 |
100 | if (isInProgress() && deltaPixelSinceLast != 0) {
101 | return listener.onSidewaysShove(this, deltaPixelSinceLast, deltaPixelsSinceStart);
102 | } else if (canExecute(GESTURE_TYPE_SIDEWAYS_SHOVE)) {
103 | if (listener.onSidewaysShoveBegin(this)) {
104 | gestureStarted();
105 | return true;
106 | }
107 | }
108 |
109 | return false;
110 | }
111 |
112 | @Override
113 | protected boolean canExecute(int invokedGestureType) {
114 | return Math.abs(deltaPixelsSinceStart) >= pixelDeltaThreshold
115 | && super.canExecute(invokedGestureType);
116 | }
117 |
118 | @Override
119 | protected boolean isSloppyGesture() {
120 | return super.isSloppyGesture() || !isAngleAcceptable();
121 | }
122 |
123 | @Override
124 | protected void gestureStopped() {
125 | super.gestureStopped();
126 | listener.onSidewaysShoveEnd(this, velocityX, velocityY);
127 | }
128 |
129 | @Override
130 | protected void reset() {
131 | super.reset();
132 | deltaPixelsSinceStart = 0;
133 | }
134 |
135 | boolean isAngleAcceptable() {
136 | MultiFingerDistancesObject distancesObject =
137 | pointersDistanceMap.get(new PointerDistancePair(pointerIdList.get(0), pointerIdList.get(1)));
138 |
139 | // Takes values from 0 to 180
140 | double angle = Math.toDegrees(Math.abs(Math.atan2(
141 | distancesObject.getCurrFingersDiffY(), distancesObject.getCurrFingersDiffX())));
142 |
143 | // Making the axis vertical
144 | angle = Math.abs(angle - 90);
145 |
146 | return angle <= maxShoveAngle;
147 | }
148 |
149 | float calculateDeltaPixelsSinceLast() {
150 | float px0 = getPreviousEvent().getX(getPreviousEvent().findPointerIndex(pointerIdList.get(0)));
151 | float px1 = getPreviousEvent().getX(getPreviousEvent().findPointerIndex(pointerIdList.get(1)));
152 | float prevAverageX = (px0 + px1) / 2.0f;
153 |
154 | float cx0 = getCurrentEvent().getX(getCurrentEvent().findPointerIndex(pointerIdList.get(0)));
155 | float cx1 = getCurrentEvent().getX(getCurrentEvent().findPointerIndex(pointerIdList.get(1)));
156 | float currAverageX = (cx0 + cx1) / 2.0f;
157 |
158 | return currAverageX - prevAverageX;
159 | }
160 |
161 | /**
162 | * Returns horizontal pixel delta change since the start of the gesture.
163 | *
164 | * @return pixels delta change since the start of the gesture
165 | */
166 | public float getDeltaPixelsSinceStart() {
167 | return deltaPixelsSinceStart;
168 | }
169 |
170 | /**
171 | * Returns last horizontal pixel delta change
172 | * calculated in {@link OnSidewaysShoveGestureListener#onSidewaysShove(SidewaysShoveGestureDetector, float, float)}.
173 | *
174 | * @return pixels delta change since the last call
175 | */
176 | public float getDeltaPixelSinceLast() {
177 | return deltaPixelSinceLast;
178 | }
179 |
180 | /**
181 | * Get the delta pixel threshold required to qualify it as a sideways shove gesture.
182 | *
183 | * @return delta pixel threshold
184 | */
185 | public float getPixelDeltaThreshold() {
186 | return pixelDeltaThreshold;
187 | }
188 |
189 | /**
190 | * Set the delta pixel threshold required to qualify it as a sideways shove gesture.
191 | *
192 | * We encourage to set those values from dimens to accommodate for various screen sizes.
193 | *
194 | * @param pixelDeltaThreshold delta threshold
195 | */
196 | public void setPixelDeltaThreshold(float pixelDeltaThreshold) {
197 | this.pixelDeltaThreshold = pixelDeltaThreshold;
198 | }
199 |
200 | /**
201 | * Set the delta dp threshold required to qualify it as a sideways shove gesture.
202 | *
203 | * @param pixelDeltaThresholdDimen delta threshold
204 | */
205 | public void setPixelDeltaThresholdResource(@DimenRes int pixelDeltaThresholdDimen) {
206 | setPixelDeltaThreshold(context.getResources().getDimension(pixelDeltaThresholdDimen));
207 | }
208 |
209 | /**
210 | * Get the maximum allowed angle between fingers, measured from the vertical line,
211 | * to qualify it as a sideways shove gesture.
212 | *
213 | * @return maximum allowed angle
214 | */
215 | public float getMaxShoveAngle() {
216 | return maxShoveAngle;
217 | }
218 |
219 | /**
220 | * Set the maximum allowed angle between fingers, measured from the vertical line,
221 | * to qualify it as a sideways shove gesture.
222 | *
223 | * @param maxShoveAngle maximum allowed angle
224 | */
225 | public void setMaxShoveAngle(float maxShoveAngle) {
226 | this.maxShoveAngle = maxShoveAngle;
227 | }
228 | }
229 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/StandardGestureDetector.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 |
5 | import androidx.annotation.UiThread;
6 | import androidx.annotation.NonNull;
7 |
8 | import android.view.GestureDetector;
9 | import android.view.MotionEvent;
10 |
11 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_DOUBLE_TAP;
12 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_DOUBLE_TAP_EVENT;
13 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_DOWN;
14 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_FLING;
15 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_LONG_PRESS;
16 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_SCROLL;
17 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_SHOW_PRESS;
18 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_SINGLE_TAP_CONFIRMED;
19 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_SINGLE_TAP_UP;
20 |
21 | /**
22 | * Detector that wraps {@link GestureDetector}.
23 | */
24 | @UiThread
25 | public class StandardGestureDetector extends BaseGesture {
26 |
27 | private final GestureDetector gestureDetector;
28 |
29 | public StandardGestureDetector(Context context, AndroidGesturesManager androidGesturesManager) {
30 | super(context, androidGesturesManager);
31 |
32 | this.gestureDetector = new GestureDetector(context, innerListener);
33 | }
34 |
35 | final StandardOnGestureListener innerListener = new StandardOnGestureListener() {
36 |
37 | @Override
38 | public boolean onSingleTapUp(MotionEvent e) {
39 | return canExecute(GESTURE_TYPE_SINGLE_TAP_UP) && listener.onSingleTapUp(e);
40 | }
41 |
42 | @Override
43 | public void onLongPress(MotionEvent e) {
44 | if (canExecute(GESTURE_TYPE_LONG_PRESS)) {
45 | listener.onLongPress(e);
46 | }
47 | }
48 |
49 | @Override
50 | public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
51 | return canExecute(GESTURE_TYPE_SCROLL) && listener.onScroll(e1, e2, distanceX, distanceY);
52 | }
53 |
54 | @Override
55 | public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
56 | return canExecute(GESTURE_TYPE_FLING) && listener.onFling(e1, e2, velocityX, velocityY);
57 | }
58 |
59 | @Override
60 | public void onShowPress(MotionEvent e) {
61 | if (canExecute(GESTURE_TYPE_SHOW_PRESS)) {
62 | listener.onShowPress(e);
63 | }
64 | }
65 |
66 | @Override
67 | public boolean onDown(MotionEvent e) {
68 | return canExecute(GESTURE_TYPE_DOWN) && listener.onDown(e);
69 | }
70 |
71 | @Override
72 | public boolean onDoubleTap(MotionEvent e) {
73 | return canExecute(GESTURE_TYPE_DOUBLE_TAP) && listener.onDoubleTap(e);
74 | }
75 |
76 | @Override
77 | public boolean onDoubleTapEvent(MotionEvent e) {
78 | return canExecute(GESTURE_TYPE_DOUBLE_TAP_EVENT) && listener.onDoubleTapEvent(e);
79 | }
80 |
81 | @Override
82 | public boolean onSingleTapConfirmed(MotionEvent e) {
83 | return canExecute(GESTURE_TYPE_SINGLE_TAP_CONFIRMED) && listener.onSingleTapConfirmed(e);
84 | }
85 | };
86 |
87 | /**
88 | * Listener that merges {@link android.view.GestureDetector.OnGestureListener}
89 | * and {@link android.view.GestureDetector.OnDoubleTapListener}.
90 | */
91 | public interface StandardOnGestureListener extends GestureDetector.OnGestureListener,
92 | GestureDetector.OnDoubleTapListener {
93 | }
94 |
95 | /**
96 | * Listener that mirrors {@link android.view.GestureDetector.SimpleOnGestureListener}.
97 | */
98 | public static class SimpleStandardOnGestureListener implements StandardOnGestureListener {
99 | @Override
100 | public boolean onSingleTapConfirmed(MotionEvent e) {
101 | return false;
102 | }
103 |
104 | @Override
105 | public boolean onDoubleTap(MotionEvent e) {
106 | return false;
107 | }
108 |
109 | @Override
110 | public boolean onDoubleTapEvent(MotionEvent e) {
111 | return false;
112 | }
113 |
114 | @Override
115 | public boolean onDown(MotionEvent e) {
116 | return false;
117 | }
118 |
119 | @Override
120 | public void onShowPress(MotionEvent e) {
121 |
122 | }
123 |
124 | @Override
125 | public boolean onSingleTapUp(MotionEvent e) {
126 | return false;
127 | }
128 |
129 | @Override
130 | public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
131 | return false;
132 | }
133 |
134 | @Override
135 | public void onLongPress(MotionEvent e) {
136 |
137 | }
138 |
139 | @Override
140 | public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
141 | return false;
142 | }
143 | }
144 |
145 | @Override
146 | protected boolean analyzeEvent(@NonNull MotionEvent motionEvent) {
147 | return gestureDetector.onTouchEvent(motionEvent);
148 | }
149 |
150 | /**
151 | * @return True if longpress in enabled, false otherwise.
152 | * @see GestureDetector#isLongpressEnabled()
153 | */
154 | public boolean isLongpressEnabled() {
155 | return gestureDetector.isLongpressEnabled();
156 | }
157 |
158 | /**
159 | * @param enabled True if longpress should be enabled, false otherwise.
160 | * @see GestureDetector#setIsLongpressEnabled(boolean)
161 | */
162 | public void setIsLongpressEnabled(boolean enabled) {
163 | gestureDetector.setIsLongpressEnabled(enabled);
164 | }
165 | }
166 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/StandardScaleGestureDetector.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import android.graphics.PointF;
5 | import androidx.annotation.DimenRes;
6 | import androidx.annotation.NonNull;
7 | import androidx.annotation.UiThread;
8 | import android.view.GestureDetector;
9 | import android.view.MotionEvent;
10 |
11 | import java.util.HashSet;
12 | import java.util.Set;
13 |
14 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_QUICK_SCALE;
15 | import static com.mapbox.android.gestures.AndroidGesturesManager.GESTURE_TYPE_SCALE;
16 |
17 | /**
18 | * Gesture detector handling scale gesture.
19 | */
20 | @UiThread
21 | public class StandardScaleGestureDetector extends
22 | ProgressiveGesture {
23 | private static final Set handledTypes = new HashSet<>();
24 |
25 | static {
26 | handledTypes.add(GESTURE_TYPE_SCALE);
27 | handledTypes.add(GESTURE_TYPE_QUICK_SCALE);
28 | }
29 |
30 | private static final float QUICK_SCALE_MULTIPLIER = 0.5f;
31 |
32 | private final GestureDetector innerGestureDetector;
33 |
34 | private boolean quickScale;
35 | private PointF quickScaleFocalPoint;
36 | private float startSpan;
37 | private float startSpanX;
38 | private float startSpanY;
39 | private float currentSpan;
40 | private float currentSpanX;
41 | private float currentSpanY;
42 | private float previousSpan;
43 | private float previousSpanX;
44 | private float previousSpanY;
45 | private float spanDeltaSinceStart;
46 | private float spanSinceStartThreshold;
47 |
48 | private boolean isScalingOut;
49 | private float scaleFactor;
50 |
51 | public StandardScaleGestureDetector(Context context, AndroidGesturesManager androidGesturesManager) {
52 | super(context, androidGesturesManager);
53 | GestureDetector.OnGestureListener doubleTapEventListener = new GestureDetector.SimpleOnGestureListener() {
54 | @Override
55 | public boolean onDoubleTapEvent(MotionEvent event) {
56 | if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
57 | quickScale = true;
58 | quickScaleFocalPoint = new PointF(event.getX(), event.getY());
59 | }
60 | return true;
61 | }
62 | };
63 | innerGestureDetector = new GestureDetector(context, doubleTapEventListener);
64 | }
65 |
66 | @Override
67 | protected boolean analyzeMovement() {
68 | super.analyzeMovement();
69 |
70 | if (isInProgress() && quickScale && getPointersCount() > 1) {
71 | // additional pointer has been placed during quick scale
72 | // abort and start a traditional pinch next
73 | gestureStopped();
74 | return false;
75 | }
76 |
77 | PointF focal = quickScale ? quickScaleFocalPoint : getFocalPoint();
78 |
79 | currentSpanX = 0;
80 | currentSpanY = 0;
81 | for (int i = 0; i < getPointersCount(); i++) {
82 | currentSpanX += Math.abs(getCurrentEvent().getX(i) - focal.x);
83 | currentSpanY += Math.abs(getCurrentEvent().getY(i) - focal.y);
84 | }
85 | currentSpanX *= 2;
86 | currentSpanY *= 2;
87 |
88 | if (quickScale) {
89 | currentSpan = currentSpanY;
90 | } else {
91 | currentSpan = (float) Math.hypot(currentSpanX, currentSpanY);
92 | }
93 |
94 | if (startSpan == 0) {
95 | startSpan = currentSpan;
96 | startSpanX = currentSpanX;
97 | startSpanY = currentSpanY;
98 | }
99 |
100 | spanDeltaSinceStart = Math.abs(startSpan - currentSpan);
101 |
102 | scaleFactor = calculateScaleFactor();
103 | isScalingOut = scaleFactor < 1f;
104 |
105 | boolean handled = false;
106 | if (isInProgress() && currentSpan > 0) {
107 | handled = listener.onScale(this);
108 | } else if (canExecute(quickScale ? GESTURE_TYPE_QUICK_SCALE : GESTURE_TYPE_SCALE)
109 | && (spanDeltaSinceStart >= spanSinceStartThreshold)) {
110 | handled = listener.onScaleBegin(this);
111 | if (handled) {
112 | gestureStarted();
113 | }
114 | }
115 | previousSpan = currentSpan;
116 | previousSpanX = currentSpanX;
117 | previousSpanY = currentSpanY;
118 | return handled;
119 | }
120 |
121 | @Override
122 | protected void gestureStopped() {
123 | super.gestureStopped();
124 | listener.onScaleEnd(StandardScaleGestureDetector.this, velocityX, velocityY);
125 | quickScale = false;
126 | }
127 |
128 | @Override
129 | protected void reset() {
130 | super.reset();
131 | startSpan = 0;
132 | spanDeltaSinceStart = 0;
133 | currentSpan = 0;
134 | previousSpan = 0;
135 | scaleFactor = 1f;
136 | }
137 |
138 | @Override
139 | protected boolean analyzeEvent(@NonNull MotionEvent motionEvent) {
140 | int action = motionEvent.getActionMasked();
141 |
142 | if (quickScale) {
143 | if (action == MotionEvent.ACTION_POINTER_DOWN || action == MotionEvent.ACTION_CANCEL) {
144 | if (isInProgress()) {
145 | interrupt();
146 | } else {
147 | // since the double tap has been registered and canceled but the gesture wasn't started,
148 | // we need to mark it manually
149 | quickScale = false;
150 | }
151 | } else if (!isInProgress() && action == MotionEvent.ACTION_UP) {
152 | // if double tap has been registered but the threshold was not met and gesture is not in progress,
153 | // we need to manually mark the finish of a double tap
154 | quickScale = false;
155 | }
156 | }
157 |
158 | boolean handled = super.analyzeEvent(motionEvent);
159 | return handled | innerGestureDetector.onTouchEvent(motionEvent);
160 | }
161 |
162 | @Override
163 | protected int getRequiredPointersCount() {
164 | if (isInProgress()) {
165 | return quickScale ? 1 : 2;
166 | } else {
167 | return 1;
168 | }
169 | }
170 |
171 | @Override
172 | protected boolean isSloppyGesture() {
173 | // do not accept move events if there are less than 2 pointers and we are not quick scaling
174 | return super.isSloppyGesture() || (!quickScale && getPointersCount() < 2);
175 | }
176 |
177 | @NonNull
178 | @Override
179 | protected Set provideHandledTypes() {
180 | return handledTypes;
181 | }
182 |
183 | /**
184 | * Listener for scale gesture callbacks.
185 | */
186 | public interface StandardOnScaleGestureListener {
187 | /**
188 | * Indicates that the scale gesture started.
189 | *
190 | * @param detector this detector
191 | * @return true if you want to receive subsequent {@link #onScale(StandardScaleGestureDetector)} callbacks,
192 | * false if you want to ignore this gesture.
193 | */
194 | boolean onScaleBegin(@NonNull StandardScaleGestureDetector detector);
195 |
196 | /**
197 | * Called for every scale change during the gesture.
198 | *
199 | * @param detector this detector
200 | * @return Whether or not the detector should consider this event as handled.
201 | */
202 | boolean onScale(@NonNull StandardScaleGestureDetector detector);
203 |
204 | /**
205 | * Indicates that the scale gesture ended.
206 | *
207 | * @param detector this detector
208 | * @param velocityX velocityX of the gesture in the moment of lifting the fingers
209 | * @param velocityY velocityY of the gesture in the moment of lifting the fingers
210 | */
211 | void onScaleEnd(@NonNull StandardScaleGestureDetector detector, float velocityX, float velocityY);
212 | }
213 |
214 | public static class SimpleStandardOnScaleGestureListener implements StandardOnScaleGestureListener {
215 |
216 | @Override
217 | public boolean onScaleBegin(@NonNull StandardScaleGestureDetector detector) {
218 | return true;
219 | }
220 |
221 | @Override
222 | public boolean onScale(@NonNull StandardScaleGestureDetector detector) {
223 | return false;
224 | }
225 |
226 | @Override
227 | public void onScaleEnd(@NonNull StandardScaleGestureDetector detector, float velocityX, float velocityY) {
228 | // No implementation
229 | }
230 | }
231 |
232 | /**
233 | * Check whether user is scaling out.
234 | *
235 | * @return true if user is scaling out, false if user is scaling in
236 | */
237 | public boolean isScalingOut() {
238 | return isScalingOut;
239 | }
240 |
241 | /**
242 | * Get the threshold span in pixels between initial fingers position and current needed
243 | * for this detector to qualify it as a scale gesture.
244 | *
245 | * @return span threshold
246 | */
247 | public float getSpanSinceStartThreshold() {
248 | return spanSinceStartThreshold;
249 | }
250 |
251 | /**
252 | * Set the threshold span in pixels between initial fingers position and current needed
253 | * for this detector to qualify it as a scale gesture.
254 | *
255 | * We encourage to set those values from dimens to accommodate for various screen sizes.
256 | *
257 | * @param spanSinceStartThreshold delta span threshold
258 | */
259 | public void setSpanSinceStartThreshold(float spanSinceStartThreshold) {
260 | this.spanSinceStartThreshold = spanSinceStartThreshold;
261 | }
262 |
263 | /**
264 | * Set the threshold span in dp between initial fingers position and current needed
265 | * for this detector to qualify it as a scale gesture.
266 | *
267 | * @param spanSinceStartThresholdDimen delta span threshold
268 | */
269 | public void setSpanSinceStartThresholdResource(@DimenRes int spanSinceStartThresholdDimen) {
270 | setSpanSinceStartThreshold(context.getResources().getDimension(spanSinceStartThresholdDimen));
271 | }
272 |
273 | /**
274 | * @return Scale factor.
275 | */
276 | public float getScaleFactor() {
277 | return scaleFactor;
278 | }
279 |
280 | /**
281 | * Return the average distance between each of the pointers forming the
282 | * gesture in progress through the focal point, when the gesture was started.
283 | *
284 | * @return Distance between pointers in pixels.
285 | */
286 | public float getStartSpan() {
287 | return startSpan;
288 | }
289 |
290 | /**
291 | * Return the average X distance between each of the pointers forming the
292 | * gesture in progress through the focal point, when the gesture was started.
293 | *
294 | * @return Distance between pointers in pixels.
295 | */
296 | public float getStartSpanX() {
297 | return startSpanX;
298 | }
299 |
300 | /**
301 | * Return the average Y distance between each of the pointers forming the
302 | * gesture in progress through the focal point, when the gesture was started.
303 | *
304 | * @return Distance between pointers in pixels.
305 | */
306 | public float getStartSpanY() {
307 | return startSpanY;
308 | }
309 |
310 | /**
311 | * Return the average distance between each of the pointers forming the
312 | * gesture in progress through the focal point.
313 | *
314 | * @return Distance between pointers in pixels.
315 | */
316 | public float getCurrentSpan() {
317 | return currentSpan;
318 | }
319 |
320 | /**
321 | * Return the average X distance between each of the pointers forming the
322 | * gesture in progress through the focal point.
323 | *
324 | * @return Distance between pointers in pixels.
325 | */
326 | public float getCurrentSpanX() {
327 | return currentSpanX;
328 | }
329 |
330 | /**
331 | * Return the average Y distance between each of the pointers forming the
332 | * gesture in progress through the focal point.
333 | *
334 | * @return Distance between pointers in pixels.
335 | */
336 | public float getCurrentSpanY() {
337 | return currentSpanY;
338 | }
339 |
340 | /**
341 | * Return the previous average distance between each of the pointers forming the
342 | * gesture in progress through the focal point.
343 | *
344 | * @return Previous distance between pointers in pixels.
345 | */
346 | public float getPreviousSpan() {
347 | return previousSpan;
348 | }
349 |
350 | /**
351 | * Return the previous average X distance between each of the pointers forming the
352 | * gesture in progress through the focal point.
353 | *
354 | * @return Previous distance between pointers in pixels.
355 | */
356 | public float getPreviousSpanX() {
357 | return previousSpanX;
358 | }
359 |
360 | /**
361 | * Return the previous average Y distance between each of the pointers forming the
362 | * gesture in progress through the focal point.
363 | *
364 | * @return Previous distance between pointers in pixels.
365 | */
366 | public float getPreviousSpanY() {
367 | return previousSpanY;
368 | }
369 |
370 | private float calculateScaleFactor() {
371 | if (quickScale) {
372 | final boolean scaleOut =
373 | // below focal point moving up
374 | getCurrentEvent().getY() < quickScaleFocalPoint.y && currentSpan < previousSpan
375 | // above focal point moving up
376 | || getCurrentEvent().getY() > quickScaleFocalPoint.y && currentSpan > previousSpan;
377 | final float spanDiff = Math.abs(1 - (currentSpan / previousSpan)) * QUICK_SCALE_MULTIPLIER;
378 | return previousSpan <= 0 ? 1 : scaleOut ? (1 + spanDiff) : (1 - spanDiff);
379 | } else {
380 | return previousSpan > 0 ? currentSpan / previousSpan : 1;
381 | }
382 | }
383 | }
384 |
--------------------------------------------------------------------------------
/library/src/main/java/com/mapbox/android/gestures/Utils.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import android.content.res.Resources;
5 | import android.graphics.PointF;
6 | import androidx.annotation.NonNull;
7 | import android.util.DisplayMetrics;
8 | import android.util.TypedValue;
9 | import android.view.MotionEvent;
10 |
11 | public class Utils {
12 |
13 | /**
14 | * Calculates the center point of the multi finger gesture.
15 | *
16 | * @param motionEvent event
17 | * @return center point of the gesture
18 | */
19 | public static PointF determineFocalPoint(@NonNull MotionEvent motionEvent) {
20 | int pointersCount = motionEvent.getPointerCount();
21 | float x = 0;
22 | float y = 0;
23 |
24 | for (int i = 0; i < pointersCount; i++) {
25 | x += motionEvent.getX(i);
26 | y += motionEvent.getY(i);
27 | }
28 |
29 | return new PointF(x / pointersCount, y / pointersCount);
30 | }
31 |
32 | /**
33 | * @param event motion event
34 | * @param pointerIndex pointer's index
35 | * @return rawY for a pointer
36 | * @author Almer Thie (code.almeros.com)
37 | *
38 | * MotionEvent has no getRawY(int) method; simulate it pending future API approval.
39 | */
40 | public static float getRawX(MotionEvent event, int pointerIndex) {
41 | float offset = event.getRawX() - event.getX();
42 | if (pointerIndex < event.getPointerCount()) {
43 | return event.getX(pointerIndex) + offset;
44 | }
45 | return 0.0f;
46 | }
47 |
48 | /**
49 | * @param event motion event
50 | * @param pointerIndex pointer's index
51 | * @return rawX for a pointer
52 | * @author Almer Thie (code.almeros.com)
53 | *
54 | * MotionEvent has no getRawX(int) method; simulate it pending future API approval.
55 | */
56 | public static float getRawY(MotionEvent event, int pointerIndex) {
57 | float offset = event.getRawY() - event.getY();
58 | if (pointerIndex < event.getPointerCount()) {
59 | return event.getY(pointerIndex) + offset;
60 | }
61 | return 0.0f;
62 | }
63 |
64 | /**
65 | * Converts DIP to PX.
66 | *
67 | * @param dp initial value
68 | * @return converted value
69 | */
70 | public static float dpToPx(float dp) {
71 | return dp * Resources.getSystem().getDisplayMetrics().density;
72 | }
73 |
74 | /**
75 | * Converts PX to DIP.
76 | *
77 | * @param px initial value
78 | * @return converted value
79 | */
80 | public static float pxToDp(float px) {
81 | return px / Resources.getSystem().getDisplayMetrics().density;
82 | }
83 |
84 | /**
85 | * Converts PX to MM (millimeters).
86 | *
87 | * @param px initial value
88 | * @param context context
89 | * @return converted value
90 | */
91 | public static float pxToMm(final float px, final Context context) {
92 | final DisplayMetrics dm = context.getResources().getDisplayMetrics();
93 | return px / TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_MM, 1, dm);
94 | }
95 | }
96 |
--------------------------------------------------------------------------------
/library/src/main/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | 7dp
5 |
6 |
7 | 16dp
8 |
9 |
10 | 5dp
11 |
12 |
13 | 6mm
14 |
15 |
16 | 10mm
17 |
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/AbstractGestureDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.content.Context;
4 | import android.view.MotionEvent;
5 |
6 | import org.junit.Before;
7 | import org.junit.runner.RunWith;
8 | import org.mockito.Mockito;
9 | import org.robolectric.RobolectricTestRunner;
10 | import org.robolectric.RuntimeEnvironment;
11 |
12 | import java.lang.reflect.ParameterizedType;
13 |
14 | @RunWith(RobolectricTestRunner.class)
15 | public abstract class AbstractGestureDetectorTest, L> {
16 | AndroidGesturesManager androidGesturesManager;
17 | Context context;
18 | MotionEvent emptyMotionEvent;
19 |
20 | K gestureDetector;
21 | L listener;
22 |
23 | @Before
24 | @SuppressWarnings("unchecked")
25 | public void setUp() throws Exception {
26 | // Working around Mockito class cast issue when initializing mocks form annotations
27 | Class listenerClazz =
28 | (Class) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[1];
29 |
30 | listener = Mockito.mock(listenerClazz);
31 |
32 | context = RuntimeEnvironment.application.getApplicationContext();
33 | androidGesturesManager = new AndroidGesturesManager(context);
34 |
35 | // reinitialize dimen thresholds
36 | for (BaseGesture detector : androidGesturesManager.getDetectors()) {
37 | if (detector instanceof MultiFingerTapGestureDetector) {
38 | ((MultiFingerGesture) detector).setSpanThreshold(290f);
39 | }
40 |
41 | if (detector instanceof StandardScaleGestureDetector) {
42 | ((StandardScaleGestureDetector) detector).setSpanSinceStartThreshold(20f);
43 | }
44 |
45 | if (detector instanceof ShoveGestureDetector) {
46 | ((ShoveGestureDetector) detector).setPixelDeltaThreshold(100f);
47 | }
48 |
49 | if (detector instanceof SidewaysShoveGestureDetector) {
50 | ((SidewaysShoveGestureDetector) detector).setPixelDeltaThreshold(100f);
51 | }
52 |
53 | if (detector instanceof MultiFingerTapGestureDetector) {
54 | ((MultiFingerTapGestureDetector) detector).setMultiFingerTapMovementThreshold(15f);
55 | }
56 | }
57 |
58 | gestureDetector = getDetectorObject();
59 | gestureDetector.setListener(listener);
60 | emptyMotionEvent = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 250.0f, 250.0f, 0);
61 | }
62 |
63 | abstract K getDetectorObject();
64 | }
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/AndroidGesturesManagerTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 | import org.junit.runner.RunWith;
6 | import org.robolectric.RobolectricTestRunner;
7 | import org.robolectric.RuntimeEnvironment;
8 |
9 | import java.util.ArrayList;
10 | import java.util.HashSet;
11 | import java.util.List;
12 | import java.util.Set;
13 |
14 | import static junit.framework.Assert.assertEquals;
15 | import static junit.framework.Assert.assertNotNull;
16 |
17 | @RunWith(RobolectricTestRunner.class)
18 | public class AndroidGesturesManagerTest {
19 | private AndroidGesturesManager androidGesturesManager;
20 |
21 | private Set set1 = new HashSet<>();
22 | private Set set2 = new HashSet<>();
23 | private Set set3 = new HashSet<>();
24 | private List> mutuallyExclusivesList = new ArrayList<>();
25 |
26 | @Before
27 | public void setUp() throws Exception {
28 | set1.clear();
29 | set2.clear();
30 | set3.clear();
31 | mutuallyExclusivesList.clear();
32 |
33 | set1.add(AndroidGesturesManager.GESTURE_TYPE_ROTATE);
34 | set1.add(AndroidGesturesManager.GESTURE_TYPE_SCROLL);
35 |
36 | set2.add(AndroidGesturesManager.GESTURE_TYPE_ROTATE);
37 | set2.add(AndroidGesturesManager.GESTURE_TYPE_SCALE);
38 |
39 | set3.add(AndroidGesturesManager.GESTURE_TYPE_ROTATE);
40 | set3.add(AndroidGesturesManager.GESTURE_TYPE_SCALE);
41 |
42 | mutuallyExclusivesList.add(set1);
43 | mutuallyExclusivesList.add(set2);
44 | mutuallyExclusivesList.add(set3);
45 |
46 | androidGesturesManager =
47 | new AndroidGesturesManager(
48 | RuntimeEnvironment.application.getApplicationContext(),
49 | mutuallyExclusivesList, true);
50 | }
51 |
52 | @Test
53 | public void initializeGestureDetectorsTest() throws Exception {
54 | for (BaseGesture detector : androidGesturesManager.getDetectors()) {
55 | assertNotNull(detector);
56 | }
57 | }
58 |
59 | @Test
60 | public void setMutuallyExclusivesTest() throws Exception {
61 | assertEquals(androidGesturesManager.getMutuallyExclusiveGestures(), mutuallyExclusivesList);
62 |
63 | androidGesturesManager.setMutuallyExclusiveGestures(set1, set2, set3);
64 | assertEquals(androidGesturesManager.getMutuallyExclusiveGestures(), mutuallyExclusivesList);
65 |
66 | androidGesturesManager.setMutuallyExclusiveGestures();
67 | assertEquals(androidGesturesManager.getMutuallyExclusiveGestures(), new ArrayList>());
68 |
69 | androidGesturesManager.setMutuallyExclusiveGestures(mutuallyExclusivesList);
70 | assertEquals(androidGesturesManager.getMutuallyExclusiveGestures(), mutuallyExclusivesList);
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/MoveGestureDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.view.MotionEvent;
4 |
5 | import org.junit.Test;
6 |
7 | import static org.mockito.Mockito.doReturn;
8 | import static org.mockito.Mockito.spy;
9 | import static org.mockito.Mockito.times;
10 | import static org.mockito.Mockito.verify;
11 |
12 | public class MoveGestureDetectorTest extends
13 | AbstractGestureDetectorTest {
14 |
15 | @Override
16 | MoveGestureDetector getDetectorObject() {
17 | return spy(androidGesturesManager.getMoveGestureDetector());
18 | }
19 |
20 | @Test
21 | public void analyzeMovementTest() {
22 | doReturn(true).when(listener).onMoveBegin(gestureDetector);
23 | doReturn(true).when(gestureDetector).checkAnyMoveAboveThreshold();
24 |
25 | gestureDetector.analyzeMovement();
26 | gestureDetector.analyzeMovement();
27 | gestureDetector.gestureStopped();
28 |
29 | verify(listener, times(1)).onMoveBegin(gestureDetector);
30 | verify(listener, times(1)).onMove(gestureDetector, 0, 0);
31 | verify(listener, times(1)).onMoveEnd(
32 | gestureDetector, gestureDetector.velocityX, gestureDetector.velocityY);
33 | }
34 |
35 | @Test
36 | public void analyzeEventTest() {
37 | doReturn(true).when(listener).onMoveBegin(gestureDetector);
38 | doReturn(true).when(gestureDetector).checkAnyMoveAboveThreshold();
39 | doReturn(true).when(gestureDetector).checkPressure();
40 | doReturn(false).when(gestureDetector).isSloppyGesture();
41 |
42 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 100, 100, null);
43 | gestureDetector.onTouchEvent(downEvent);
44 | MotionEvent moveEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_MOVE, 105, 100, downEvent);
45 | gestureDetector.onTouchEvent(moveEvent);
46 | verify(listener, times(1)).onMoveBegin(gestureDetector);
47 |
48 | moveEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_MOVE, 110, 100, moveEvent);
49 | gestureDetector.onTouchEvent(moveEvent);
50 | verify(listener, times(1)).onMove(
51 | gestureDetector, gestureDetector.lastDistanceX, gestureDetector.lastDistanceY);
52 |
53 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 200, 100,
54 | moveEvent);
55 | gestureDetector.onTouchEvent(pointerDownEvent);
56 | moveEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_MOVE, 115, 100, pointerDownEvent);
57 | gestureDetector.onTouchEvent(moveEvent);
58 | // checking for 0, 0 difference because focal point should be reset with pointer count change
59 | verify(listener, times(1)).onMove(gestureDetector, 0, 0);
60 |
61 | MotionEvent pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 200, 100, moveEvent);
62 | gestureDetector.onTouchEvent(pointerUpEvent);
63 | MotionEvent upEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 200, 100, pointerUpEvent);
64 | gestureDetector.onTouchEvent(upEvent);
65 | verify(listener, times(1)).onMoveEnd(
66 | gestureDetector, gestureDetector.velocityX, gestureDetector.velocityY
67 | );
68 | }
69 | }
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/MultiFingerTapGestureDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.view.MotionEvent;
4 |
5 | import org.junit.Before;
6 | import org.junit.Test;
7 | import org.mockito.Mockito;
8 |
9 | import java.util.HashMap;
10 |
11 | import static junit.framework.Assert.assertFalse;
12 | import static junit.framework.Assert.assertTrue;
13 | import static org.mockito.Mockito.doReturn;
14 | import static org.mockito.Mockito.times;
15 | import static org.mockito.Mockito.verify;
16 | import static org.mockito.Mockito.when;
17 |
18 | public class MultiFingerTapGestureDetectorTest
19 | extends AbstractGestureDetectorTest {
21 |
22 | private MotionEvent downMotionEvent;
23 | private MotionEvent pointerDownMotionEvent;
24 | private MotionEvent pointerUpMotionEvent;
25 | private MotionEvent upMotionEvent;
26 | private MotionEvent moveMotionEvent;
27 |
28 | @Before
29 | public void setUp() throws Exception {
30 | super.setUp();
31 | doReturn(true).when(gestureDetector).checkPressure();
32 | doReturn(false).when(gestureDetector).isSloppyGesture();
33 | }
34 |
35 | @Override
36 | MultiFingerTapGestureDetector getDetectorObject() {
37 | return Mockito.spy(androidGesturesManager.getMultiFingerTapGestureDetector());
38 | }
39 |
40 | @Test
41 | public void twoFingerTapTest() {
42 | dispatchDown();
43 | dispatchPointerDown(10, downMotionEvent);
44 | dispatchPointerUp((Constants.DEFAULT_MULTI_TAP_TIME_THRESHOLD / 2), pointerDownMotionEvent);
45 | dispatchUp(10, pointerUpMotionEvent);
46 | verify(listener, times(1)).onMultiFingerTap(gestureDetector, 2);
47 | }
48 |
49 | @Test
50 | public void threeFingerTapTest() {
51 | dispatchDown();
52 | dispatchPointerDown(10, downMotionEvent);
53 | dispatchPointerDown(10, pointerDownMotionEvent);
54 | dispatchPointerUp((Constants.DEFAULT_MULTI_TAP_TIME_THRESHOLD / 2), pointerDownMotionEvent);
55 | dispatchPointerUp(10, pointerUpMotionEvent);
56 | dispatchUp(10, pointerUpMotionEvent);
57 | verify(listener, times(1)).onMultiFingerTap(gestureDetector, 3);
58 | }
59 |
60 | @Test
61 | public void twoFingerTapExceededTest() {
62 | dispatchDown();
63 | dispatchPointerDown(25, downMotionEvent);
64 | dispatchPointerUp(Constants.DEFAULT_MULTI_TAP_TIME_THRESHOLD, pointerDownMotionEvent);
65 | dispatchUp(25, pointerUpMotionEvent);
66 | verify(listener, times(0)).onMultiFingerTap(gestureDetector, 2);
67 | }
68 |
69 | @Test
70 | public void twoFingerMissTapTest() {
71 | // Testing for two pointers placed, one lifted and placed again. Should fail.
72 | dispatchDown();
73 | dispatchPointerDown(10, downMotionEvent);
74 | dispatchPointerUp(10, pointerDownMotionEvent);
75 | dispatchPointerDown(10, pointerUpMotionEvent);
76 | dispatchPointerUp(10, pointerDownMotionEvent);
77 | // tricking test setup to not subtract missing pointers
78 | pointerUpMotionEvent.setAction(MotionEvent.ACTION_MOVE);
79 | dispatchUp(10, pointerUpMotionEvent);
80 | verify(listener, times(0)).onMultiFingerTap(gestureDetector, 2);
81 | }
82 |
83 | @Test
84 | public void twoFingerTapMovementTest() {
85 | when(
86 | gestureDetector.exceededMovementThreshold(gestureDetector.pointersDistanceMap))
87 | .thenReturn(false);
88 | dispatchMovement();
89 | verify(listener, times(1)).onMultiFingerTap(gestureDetector, 2);
90 |
91 | when(
92 | gestureDetector.exceededMovementThreshold(gestureDetector.pointersDistanceMap))
93 | .thenReturn(true);
94 | dispatchMovement();
95 | verify(listener, times(1)).onMultiFingerTap(gestureDetector, 2);
96 | }
97 |
98 | private void dispatchMovement() {
99 | dispatchDown();
100 | dispatchPointerDown(10, downMotionEvent);
101 | dispatchMove(10, pointerDownMotionEvent);
102 | dispatchPointerUp(Constants.DEFAULT_MULTI_TAP_TIME_THRESHOLD / 2, moveMotionEvent);
103 | dispatchUp(10, pointerUpMotionEvent);
104 | }
105 |
106 | @Test
107 | public void exceededMovementTest() {
108 | float prevX = 100;
109 | float prevY = 100;
110 | float currX = 100;
111 | float currY = 100;
112 | final HashMap map = new HashMap<>();
113 | map.put(new PointerDistancePair(0, 1), new MultiFingerDistancesObject(
114 | prevX, prevY,
115 | currX, currY
116 | ));
117 | assertFalse(gestureDetector.exceededMovementThreshold(map));
118 |
119 | map.clear();
120 | map.put(new PointerDistancePair(0, 1), new MultiFingerDistancesObject(
121 | prevX, prevY,
122 | currX + gestureDetector.getMultiFingerTapMovementThreshold() + 0.5f, currY
123 | ));
124 | assertTrue(gestureDetector.exceededMovementThreshold(map));
125 | }
126 |
127 | private void dispatchDown() {
128 | downMotionEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
129 | gestureDetector.onTouchEvent(downMotionEvent);
130 | }
131 |
132 | private void dispatchPointerDown(long delay, MotionEvent previous) {
133 | try {
134 | Thread.sleep(delay);
135 | pointerDownMotionEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, previous);
136 | gestureDetector.onTouchEvent(pointerDownMotionEvent);
137 | } catch (InterruptedException ex) {
138 | ex.printStackTrace();
139 | }
140 | }
141 |
142 | private void dispatchPointerUp(long delay, MotionEvent previous) {
143 | try {
144 | Thread.sleep(delay);
145 | pointerUpMotionEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, previous);
146 | gestureDetector.onTouchEvent(pointerUpMotionEvent);
147 | } catch (InterruptedException ex) {
148 | ex.printStackTrace();
149 | }
150 | }
151 |
152 | private void dispatchUp(long delay, MotionEvent previous) {
153 | try {
154 | Thread.sleep(delay);
155 | upMotionEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_UP, 0, 0, previous);
156 | gestureDetector.onTouchEvent(upMotionEvent);
157 | } catch (InterruptedException ex) {
158 | ex.printStackTrace();
159 | }
160 | }
161 |
162 | private void dispatchMove(long delay, MotionEvent previous) {
163 | try {
164 | Thread.sleep(delay);
165 | moveMotionEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_MOVE, 0, 0, previous);
166 | gestureDetector.onTouchEvent(moveMotionEvent);
167 | } catch (InterruptedException ex) {
168 | ex.printStackTrace();
169 | }
170 | }
171 | }
172 |
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/PointersManagementTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.view.MotionEvent;
4 |
5 | import org.junit.Assert;
6 | import org.junit.Test;
7 | import org.junit.runner.RunWith;
8 | import org.robolectric.RobolectricTestRunner;
9 |
10 | import static org.mockito.Mockito.spy;
11 |
12 | @RunWith(RobolectricTestRunner.class)
13 | public class PointersManagementTest extends
14 | AbstractGestureDetectorTest {
16 |
17 | @Override
18 | StandardScaleGestureDetector getDetectorObject() {
19 | return spy(androidGesturesManager.getStandardScaleGestureDetector());
20 | }
21 |
22 | private void checkResult(int expected) {
23 | int pointersCount = androidGesturesManager.getStandardScaleGestureDetector().getPointersCount();
24 | Assert.assertEquals(
25 | String.format("Expected %d pointers, was %d.", expected, pointersCount), pointersCount, expected);
26 | }
27 |
28 | @Test
29 | public void missingDownTest() {
30 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, null);
31 | androidGesturesManager.onTouchEvent(pointerDownEvent);
32 |
33 | checkResult(0);
34 | }
35 |
36 | @Test
37 | public void missingUpTest() {
38 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
39 | androidGesturesManager.onTouchEvent(downEvent);
40 |
41 | downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, downEvent);
42 | androidGesturesManager.onTouchEvent(downEvent);
43 |
44 | checkResult(1);
45 | }
46 |
47 | @Test
48 | public void missingPointerDownTest() {
49 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
50 | androidGesturesManager.onTouchEvent(downEvent);
51 |
52 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent);
53 | androidGesturesManager.onTouchEvent(pointerDownEvent);
54 |
55 | MotionEvent pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0,
56 | pointerDownEvent);
57 | androidGesturesManager.onTouchEvent(pointerUpEvent);
58 |
59 | pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerUpEvent);
60 | androidGesturesManager.onTouchEvent(pointerUpEvent);
61 | // tricking test setup to not subtract missing pointers
62 | pointerUpEvent.setAction(MotionEvent.ACTION_MOVE);
63 |
64 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerUpEvent);
65 | androidGesturesManager.onTouchEvent(pointerDownEvent);
66 |
67 | checkResult(0); //expecting 0, because we are waiting for ACTION_DOWN to synchronise again
68 | }
69 |
70 | @Test
71 | public void missingPointerUpTest() {
72 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
73 | androidGesturesManager.onTouchEvent(downEvent);
74 |
75 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent);
76 | androidGesturesManager.onTouchEvent(pointerDownEvent);
77 |
78 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
79 | androidGesturesManager.onTouchEvent(pointerDownEvent);
80 |
81 | MotionEvent pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0,
82 | pointerDownEvent);
83 | androidGesturesManager.onTouchEvent(pointerUpEvent);
84 |
85 | MotionEvent upEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_UP, 0, 0, pointerUpEvent);
86 | androidGesturesManager.onTouchEvent(upEvent);
87 |
88 | checkResult(0);
89 | }
90 |
91 | @Test
92 | public void addingRemovingPointersTest() {
93 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
94 | androidGesturesManager.onTouchEvent(downEvent);
95 |
96 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent);
97 | androidGesturesManager.onTouchEvent(pointerDownEvent);
98 |
99 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
100 | androidGesturesManager.onTouchEvent(pointerDownEvent);
101 |
102 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
103 | androidGesturesManager.onTouchEvent(pointerDownEvent);
104 |
105 | checkResult(4);
106 |
107 | MotionEvent pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0,
108 | pointerDownEvent);
109 | androidGesturesManager.onTouchEvent(pointerUpEvent);
110 |
111 | pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerUpEvent);
112 | androidGesturesManager.onTouchEvent(pointerUpEvent);
113 |
114 | pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0, pointerUpEvent);
115 | androidGesturesManager.onTouchEvent(pointerUpEvent);
116 |
117 | MotionEvent upEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_UP, 0, 0, pointerUpEvent);
118 | androidGesturesManager.onTouchEvent(upEvent);
119 |
120 | checkResult(0);
121 | }
122 |
123 | @Test
124 | public void eventCanceledTest() {
125 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
126 | androidGesturesManager.onTouchEvent(downEvent);
127 |
128 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent);
129 | androidGesturesManager.onTouchEvent(pointerDownEvent);
130 |
131 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
132 | androidGesturesManager.onTouchEvent(pointerDownEvent);
133 |
134 | MotionEvent pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0,
135 | pointerDownEvent);
136 | androidGesturesManager.onTouchEvent(pointerUpEvent);
137 |
138 | MotionEvent cancelEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_CANCEL, 0, 0, pointerUpEvent);
139 | androidGesturesManager.onTouchEvent(cancelEvent);
140 |
141 | checkResult(0);
142 | }
143 |
144 | @Test
145 | public void movingWithMissingPointersTest() {
146 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
147 | androidGesturesManager.onTouchEvent(downEvent);
148 |
149 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent);
150 | androidGesturesManager.onTouchEvent(pointerDownEvent);
151 |
152 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
153 | androidGesturesManager.onTouchEvent(pointerDownEvent);
154 |
155 | MotionEvent pointerUpEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_UP, 0, 0,
156 | pointerDownEvent);
157 |
158 | MotionEvent moveEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_MOVE, 0, 0, pointerUpEvent);
159 | androidGesturesManager.onTouchEvent(moveEvent);
160 |
161 | checkResult(0);
162 | }
163 |
164 | @Test
165 | public void movingWithTooManyPointersTest() {
166 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
167 | androidGesturesManager.onTouchEvent(downEvent);
168 |
169 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent);
170 | androidGesturesManager.onTouchEvent(pointerDownEvent);
171 |
172 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
173 | androidGesturesManager.onTouchEvent(pointerDownEvent);
174 |
175 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
176 |
177 | MotionEvent moveEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_MOVE, 0, 0, pointerDownEvent);
178 | androidGesturesManager.onTouchEvent(moveEvent);
179 |
180 | checkResult(0);
181 | }
182 |
183 | @Test
184 | public void movingWithRightAmountOfPointersTest() {
185 | MotionEvent downEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_DOWN, 0, 0, null);
186 | androidGesturesManager.onTouchEvent(downEvent);
187 |
188 | MotionEvent pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, downEvent);
189 | androidGesturesManager.onTouchEvent(pointerDownEvent);
190 |
191 | pointerDownEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_POINTER_DOWN, 0, 0, pointerDownEvent);
192 | androidGesturesManager.onTouchEvent(pointerDownEvent);
193 |
194 | MotionEvent moveEvent = TestUtils.INSTANCE.getMotionEvent(MotionEvent.ACTION_MOVE, 0, 0, pointerDownEvent);
195 | androidGesturesManager.onTouchEvent(moveEvent);
196 |
197 | checkResult(3);
198 | }
199 |
200 | @Test
201 | public void missingPointerUpAndMovementTest() {
202 | PermittedActionsGuard guard = new PermittedActionsGuard();
203 | boolean result = guard.isMissingActions(MotionEvent.ACTION_MOVE, 1, 2);
204 | Assert.assertTrue("Should miss action", result);
205 | }
206 |
207 | @Test
208 | public void missingPointerDownAndMovementTest() {
209 | PermittedActionsGuard guard = new PermittedActionsGuard();
210 | boolean result = guard.isMissingActions(MotionEvent.ACTION_MOVE, 2, 1);
211 | Assert.assertTrue("Should miss action", result);
212 | }
213 |
214 | @Test
215 | public void noPointersAndMovementTest() {
216 | PermittedActionsGuard guard = new PermittedActionsGuard();
217 | boolean result = guard.isMissingActions(MotionEvent.ACTION_MOVE, 1, 0);
218 | Assert.assertTrue("Should miss action", result);
219 | }
220 |
221 | @Test
222 | public void onePointerAndDownTest() {
223 | PermittedActionsGuard guard = new PermittedActionsGuard();
224 | boolean result = guard.isMissingActions(MotionEvent.ACTION_DOWN, 0, 1);
225 | Assert.assertTrue("Should miss action", result);
226 | }
227 |
228 | @Test
229 | public void twoPointersAndDownTest() {
230 | PermittedActionsGuard guard = new PermittedActionsGuard();
231 | boolean result = guard.isMissingActions(MotionEvent.ACTION_DOWN, 0, 2);
232 | Assert.assertTrue("Should miss action", result);
233 | }
234 |
235 | @Test
236 | public void onePointerAndPointerUpTest() {
237 | PermittedActionsGuard guard = new PermittedActionsGuard();
238 | boolean result = guard.isMissingActions(MotionEvent.ACTION_POINTER_UP, 1, 1);
239 | Assert.assertTrue("Should miss action", result);
240 | }
241 |
242 | @Test
243 | public void noPointersAndPointerUpTest() {
244 | PermittedActionsGuard guard = new PermittedActionsGuard();
245 | boolean result = guard.isMissingActions(MotionEvent.ACTION_POINTER_DOWN, 2, 0);
246 | Assert.assertTrue("Should miss action", result);
247 | }
248 |
249 | @Test
250 | public void onePointerAndUpTest() {
251 | PermittedActionsGuard guard = new PermittedActionsGuard();
252 | boolean result = guard.isMissingActions(MotionEvent.ACTION_UP, 1, 1);
253 | Assert.assertFalse("Should not miss action", result);
254 | }
255 | }
256 |
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/RotateGestureDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import android.graphics.PointF;
4 |
5 | import org.junit.Test;
6 |
7 | import static junit.framework.Assert.assertEquals;
8 | import static org.mockito.Mockito.doReturn;
9 | import static org.mockito.Mockito.spy;
10 | import static org.mockito.Mockito.times;
11 | import static org.mockito.Mockito.verify;
12 | import static org.mockito.Mockito.when;
13 |
14 | public class RotateGestureDetectorTest extends
15 | AbstractGestureDetectorTest {
16 |
17 | @Override
18 | RotateGestureDetector getDetectorObject() {
19 | return spy(androidGesturesManager.getRotateGestureDetector());
20 | }
21 |
22 | @Test
23 | public void analyzeMovementTest() throws Exception {
24 | when(listener.onRotateBegin(gestureDetector)).thenReturn(true);
25 | when(listener.onRotate(gestureDetector, gestureDetector.deltaSinceLast, gestureDetector.deltaSinceStart))
26 | .thenReturn(true);
27 |
28 | // threshold not met
29 | doReturn(Constants.DEFAULT_ROTATE_ANGLE_THRESHOLD / 2)
30 | .when(gestureDetector).getRotationDegreesSinceLast();
31 | gestureDetector.analyzeMovement();
32 |
33 | // threshold met, starting
34 | doReturn(Constants.DEFAULT_ROTATE_ANGLE_THRESHOLD * 2)
35 | .when(gestureDetector).getRotationDegreesSinceLast();
36 | gestureDetector.analyzeMovement();
37 |
38 | // new event, executing onRotate()
39 | gestureDetector.analyzeMovement();
40 | verify(listener, times(1)).onRotate(gestureDetector,
41 | gestureDetector.deltaSinceLast, gestureDetector.deltaSinceStart);
42 |
43 | // new event, executing onRotate() even though below threshold because already started
44 | doReturn(Constants.DEFAULT_ROTATE_ANGLE_THRESHOLD / 2)
45 | .when(gestureDetector).getRotationDegreesSinceLast();
46 | gestureDetector.analyzeMovement();
47 | //still 1 invocation because parameters changed, but technically 2
48 | verify(listener, times(1)).onRotate(gestureDetector,
49 | gestureDetector.deltaSinceLast, gestureDetector.deltaSinceStart);
50 |
51 | // stopping
52 | gestureDetector.gestureStopped();
53 |
54 | // not starting because threshold not met
55 | gestureDetector.analyzeMovement();
56 |
57 | verify(listener, times(1)).onRotateBegin(gestureDetector);
58 | verify(listener, times(1)).onRotateEnd(
59 | gestureDetector, gestureDetector.velocityX, gestureDetector.velocityY,
60 | gestureDetector.calculateAngularVelocityVector(gestureDetector.velocityX, gestureDetector.velocityY));
61 | }
62 |
63 | @Test
64 | public void getRotationDegreesSinceLastTest() {
65 | gestureDetector.pointerIdList.add(0);
66 | gestureDetector.pointerIdList.add(1);
67 | gestureDetector.pointersDistanceMap.put(
68 | new PointerDistancePair(0, 1),
69 | new MultiFingerDistancesObject(300, 0, 275, 15)
70 | );
71 |
72 | assertEquals(-3.1221304f, gestureDetector.getRotationDegreesSinceLast());
73 | }
74 |
75 | @Test
76 | public void calculateAngularVelocityVectorTest() {
77 | when(gestureDetector.getFocalPoint()).thenReturn(new PointF(150f, 150f));
78 | assertEquals(3.6f, gestureDetector.calculateAngularVelocityVector(725, 355));
79 | }
80 | }
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/ShoveGestureDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertFalse;
6 | import static org.junit.Assert.assertTrue;
7 | import static org.mockito.Mockito.doReturn;
8 | import static org.mockito.Mockito.spy;
9 | import static org.mockito.Mockito.times;
10 | import static org.mockito.Mockito.verify;
11 | import static org.mockito.Mockito.when;
12 |
13 | public class ShoveGestureDetectorTest extends
14 | AbstractGestureDetectorTest {
15 |
16 | @Override
17 | ShoveGestureDetector getDetectorObject() {
18 | return spy(androidGesturesManager.getShoveGestureDetector());
19 | }
20 |
21 | @Test
22 | public void analyzeMovementTest() throws Exception {
23 | when(listener.onShoveBegin(gestureDetector)).thenReturn(true);
24 | when(listener.onShove(gestureDetector, gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart))
25 | .thenReturn(true);
26 | doReturn(true).when(gestureDetector).isAngleAcceptable();
27 |
28 | // threshold not met
29 | doReturn(gestureDetector.getPixelDeltaThreshold() / 2)
30 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
31 | gestureDetector.analyzeMovement();
32 |
33 | // threshold met, starting
34 | doReturn(gestureDetector.getPixelDeltaThreshold() * 2)
35 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
36 | gestureDetector.analyzeMovement();
37 |
38 | // new event, executing onShove()
39 | gestureDetector.analyzeMovement();
40 | verify(listener, times(1)).onShove(gestureDetector,
41 | gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart);
42 |
43 | // new event, executing onShove() even though below threshold because already started
44 | doReturn(gestureDetector.getPixelDeltaThreshold() / 2)
45 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
46 | gestureDetector.analyzeMovement();
47 | //still 1 invocation because parameters changed, but technically 2
48 | verify(listener, times(1)).onShove(gestureDetector,
49 | gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart);
50 |
51 | // angle exceeded don't execute
52 | doReturn(false)
53 | .when(gestureDetector).isAngleAcceptable();
54 | gestureDetector.analyzeMovement();
55 |
56 | // angle acceptable again
57 | doReturn(true)
58 | .when(gestureDetector).isAngleAcceptable();
59 | gestureDetector.analyzeMovement();
60 | // 1 invocation because parameters changed, but technically 3
61 | verify(listener, times(1)).onShove(gestureDetector,
62 | gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart);
63 |
64 | // stopping
65 | gestureDetector.gestureStopped();
66 |
67 | // not starting because threshold not met
68 | gestureDetector.analyzeMovement();
69 |
70 | // threshold met again, starting
71 | doReturn(gestureDetector.getPixelDeltaThreshold() * 2)
72 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
73 | gestureDetector.analyzeMovement();
74 |
75 | verify(listener, times(2)).onShoveBegin(gestureDetector);
76 | verify(listener, times(1)).onShoveEnd(
77 | gestureDetector, gestureDetector.velocityX, gestureDetector.velocityY);
78 | }
79 |
80 | @Test
81 | public void isAngleAcceptableTest() {
82 | gestureDetector.pointerIdList.add(0);
83 | gestureDetector.pointerIdList.add(1);
84 | gestureDetector.pointersDistanceMap.put(
85 | new PointerDistancePair(0, 1),
86 | new MultiFingerDistancesObject(300, 0, 275, 15)
87 | );
88 | assertTrue(gestureDetector.isAngleAcceptable());
89 |
90 | gestureDetector.pointerIdList.clear();
91 | gestureDetector.pointersDistanceMap.clear();
92 | gestureDetector.pointerIdList.add(0);
93 | gestureDetector.pointerIdList.add(1);
94 | gestureDetector.pointersDistanceMap.put(
95 | new PointerDistancePair(0, 1),
96 | new MultiFingerDistancesObject(300, 0, 275, 150)
97 | );
98 | assertFalse(gestureDetector.isAngleAcceptable());
99 | }
100 | }
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/SidewaysShoveGestureDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertFalse;
6 | import static org.junit.Assert.assertTrue;
7 | import static org.mockito.Mockito.doReturn;
8 | import static org.mockito.Mockito.spy;
9 | import static org.mockito.Mockito.times;
10 | import static org.mockito.Mockito.verify;
11 | import static org.mockito.Mockito.when;
12 |
13 | public class SidewaysShoveGestureDetectorTest extends
14 | AbstractGestureDetectorTest {
16 |
17 | @Override
18 | SidewaysShoveGestureDetector getDetectorObject() {
19 | return spy(androidGesturesManager.getSidewaysShoveGestureDetector());
20 | }
21 |
22 | @Test
23 | public void analyzeMovementTest() throws Exception {
24 | when(listener.onSidewaysShoveBegin(gestureDetector)).thenReturn(true);
25 | when(listener.onSidewaysShove(
26 | gestureDetector, gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart)
27 | ).thenReturn(true);
28 | doReturn(true).when(gestureDetector).isAngleAcceptable();
29 |
30 | // threshold not met
31 | doReturn(gestureDetector.getPixelDeltaThreshold() / 2)
32 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
33 | gestureDetector.analyzeMovement();
34 |
35 | // threshold met, starting
36 | doReturn(gestureDetector.getPixelDeltaThreshold() * 2)
37 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
38 | gestureDetector.analyzeMovement();
39 |
40 | // new event, executing onShove()
41 | gestureDetector.analyzeMovement();
42 | verify(listener, times(1)).onSidewaysShove(gestureDetector,
43 | gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart);
44 |
45 | // new event, executing onShove() even though below threshold because already started
46 | doReturn(gestureDetector.getPixelDeltaThreshold() / 2)
47 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
48 | gestureDetector.analyzeMovement();
49 | //still 1 invocation because parameters changed, but technically 2
50 | verify(listener, times(1)).onSidewaysShove(gestureDetector,
51 | gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart);
52 |
53 | // angle exceeded don't execute
54 | doReturn(false)
55 | .when(gestureDetector).isAngleAcceptable();
56 | gestureDetector.analyzeMovement();
57 |
58 | // angle acceptable again
59 | doReturn(true)
60 | .when(gestureDetector).isAngleAcceptable();
61 | gestureDetector.analyzeMovement();
62 | // 1 invocation because parameters changed, but technically 3
63 | verify(listener, times(1)).onSidewaysShove(gestureDetector,
64 | gestureDetector.deltaPixelSinceLast, gestureDetector.deltaPixelsSinceStart);
65 |
66 | // stopping
67 | gestureDetector.gestureStopped();
68 |
69 | // not starting because threshold not met
70 | gestureDetector.analyzeMovement();
71 |
72 | // threshold met again, starting
73 | doReturn(gestureDetector.getPixelDeltaThreshold() * 2)
74 | .when(gestureDetector).calculateDeltaPixelsSinceLast();
75 | gestureDetector.analyzeMovement();
76 |
77 | verify(listener, times(2)).onSidewaysShoveBegin(gestureDetector);
78 | verify(listener, times(1)).onSidewaysShoveEnd(
79 | gestureDetector, gestureDetector.velocityX, gestureDetector.velocityY);
80 | }
81 |
82 | @Test
83 | public void isAngleAcceptableTest() {
84 | gestureDetector.pointerIdList.add(0);
85 | gestureDetector.pointerIdList.add(1);
86 | gestureDetector.pointersDistanceMap.put(
87 | new PointerDistancePair(0, 1),
88 | new MultiFingerDistancesObject(0, 300, 15, 275)
89 | );
90 | assertTrue(gestureDetector.isAngleAcceptable());
91 |
92 | gestureDetector.pointerIdList.clear();
93 | gestureDetector.pointersDistanceMap.clear();
94 | gestureDetector.pointerIdList.add(0);
95 | gestureDetector.pointerIdList.add(1);
96 | gestureDetector.pointersDistanceMap.put(
97 | new PointerDistancePair(0, 1),
98 | new MultiFingerDistancesObject(0, 300, 150, 275)
99 | );
100 | assertFalse(gestureDetector.isAngleAcceptable());
101 | }
102 | }
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/StandardGestureDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures;
2 |
3 | import org.junit.Test;
4 | import org.mockito.Mockito;
5 |
6 | import static junit.framework.Assert.assertFalse;
7 | import static junit.framework.Assert.assertTrue;
8 |
9 | public class StandardGestureDetectorTest extends
10 | AbstractGestureDetectorTest {
11 |
12 | @Override
13 | StandardGestureDetector getDetectorObject() {
14 | return androidGesturesManager.getStandardGestureDetector();
15 | }
16 |
17 | @Test
18 | public void onSingleTapUpTest() {
19 | gestureDetector.innerListener.onSingleTapUp(emptyMotionEvent);
20 | Mockito.verify(listener, Mockito.times(1)).onSingleTapUp(emptyMotionEvent);
21 | }
22 |
23 | @Test
24 | public void onLongPressTest() {
25 | gestureDetector.innerListener.onLongPress(emptyMotionEvent);
26 | Mockito.verify(listener, Mockito.times(1)).onLongPress(emptyMotionEvent);
27 | }
28 |
29 | @Test
30 | public void onScrollTest() {
31 | gestureDetector.innerListener.onScroll(emptyMotionEvent, emptyMotionEvent, 0, 0);
32 | Mockito.verify(listener, Mockito.times(1))
33 | .onScroll(emptyMotionEvent, emptyMotionEvent, 0, 0);
34 | }
35 |
36 | @Test
37 | public void onFlingTest() {
38 | gestureDetector.innerListener.onFling(emptyMotionEvent, emptyMotionEvent, 0, 0);
39 | Mockito.verify(listener, Mockito.times(1))
40 | .onFling(emptyMotionEvent, emptyMotionEvent, 0, 0);
41 | }
42 |
43 | @Test
44 | public void onShowPressTest() {
45 | gestureDetector.innerListener.onShowPress(emptyMotionEvent);
46 | Mockito.verify(listener, Mockito.times(1)).onShowPress(emptyMotionEvent);
47 | }
48 |
49 | @Test
50 | public void onDownTest() {
51 | gestureDetector.innerListener.onDown(emptyMotionEvent);
52 | Mockito.verify(listener, Mockito.times(1)).onDown(emptyMotionEvent);
53 | }
54 |
55 | @Test
56 | public void onDoubleTapTest() {
57 | gestureDetector.innerListener.onDoubleTap(emptyMotionEvent);
58 | Mockito.verify(listener, Mockito.times(1)).onDoubleTap(emptyMotionEvent);
59 | }
60 |
61 | @Test
62 | public void onDoubleTapEventTest() {
63 | gestureDetector.innerListener.onDoubleTapEvent(emptyMotionEvent);
64 | Mockito.verify(listener, Mockito.times(1)).onDoubleTapEvent(emptyMotionEvent);
65 | }
66 |
67 | @Test
68 | public void onSingleTapConfirmedTest() {
69 | gestureDetector.innerListener.onSingleTapConfirmed(emptyMotionEvent);
70 | Mockito.verify(listener, Mockito.times(1)).onSingleTapConfirmed(emptyMotionEvent);
71 | }
72 |
73 | @Test
74 | public void longpressEnabledTest() throws Exception {
75 | assertTrue(gestureDetector.isLongpressEnabled());
76 | gestureDetector.setIsLongpressEnabled(false);
77 | assertFalse(gestureDetector.isLongpressEnabled());
78 | gestureDetector.setIsLongpressEnabled(true);
79 | assertTrue(gestureDetector.isLongpressEnabled());
80 | }
81 | }
--------------------------------------------------------------------------------
/library/src/test/java/com/mapbox/android/gestures/TestUtils.kt:
--------------------------------------------------------------------------------
1 | package com.mapbox.android.gestures
2 |
3 | import android.view.MotionEvent
4 |
5 | object TestUtils {
6 |
7 | fun getMotionEvent(action: Int, x: Float, y: Float, previousEvent: MotionEvent? = null): MotionEvent {
8 | val currentTime = System.currentTimeMillis()
9 | val downTime = previousEvent?.downTime ?: System.currentTimeMillis()
10 |
11 | var pointerCount = previousEvent?.pointerCount ?: 0
12 | if (previousEvent != null && previousEvent.actionMasked == MotionEvent.ACTION_POINTER_UP) {
13 | pointerCount--
14 | } else if (action == MotionEvent.ACTION_POINTER_DOWN) {
15 | pointerCount++
16 | } else if (action == MotionEvent.ACTION_DOWN) {
17 | pointerCount = 1
18 | }
19 |
20 | val properties = arrayOfNulls(pointerCount)
21 | for (i in 0 until pointerCount) {
22 | val pp = MotionEvent.PointerProperties()
23 | pp.id = i
24 | pp.toolType = MotionEvent.TOOL_TYPE_FINGER
25 | properties[i] = pp
26 | }
27 |
28 | val pointerCoords = arrayOfNulls(pointerCount)
29 | for (i in 0 until pointerCount) {
30 | val pc = MotionEvent.PointerCoords()
31 | pc.x = x + i * 50
32 | pc.y = y + i * 50
33 | pc.pressure = 1f
34 | pc.size = 1f
35 | pointerCoords[i] = pc
36 | }
37 |
38 | return MotionEvent.obtain(downTime, currentTime,
39 | action, pointerCount, properties,
40 | pointerCoords, 0, 0, 1f, 1f, 0, 0, 0, 0)
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app', ':library'
2 |
--------------------------------------------------------------------------------