26 | *
It is best to call this only when over-scroll isn't currently in-effect - i.e. verify that
27 | * getCurrentState()==IElasticityState.STATE_IDLE as a precondition, or otherwise
28 | * use a state listener previously installed using
29 | * {@link #setOverScrollStateListener(IElasticityStateListener)}.
31 | *
Note: Upon detachment completion, the view in question will return to the default
32 | * Android over-scroll configuration (i.e. {@link View.OVER_SCROLL_ALWAYS} mode). This can be
33 | * overridden by calling View.setOverScrollMode(mode) immediately thereafter.
25 | *
Design-wise, being a standalone class, this decorator powerfully provides the ability to add 26 | * the over-scroll effect over any view without adjusting the view's implementation. In essence, this 27 | * eliminates the need to repeatedly implement the effect per each view type (list-view, 28 | * recycler-view, image-view, etc.). Therefore, using it is highly recommended compared to other 29 | * more intrusive solutions.
30 | *31 | *
Note that this class is abstract, having {@link HorizontalElasticityBounceEffect} and 32 | * {@link VerticalElasticityBounceEffect} providing concrete implementations that are 33 | * view-orientation specific.
34 | *35 | *
38 | *
At it's core, the class simply registers itself as a touch-listener over the decorated view and 39 | * intercepts touch events as needed.
40 | *41 | *
Internally, it delegates the over-scrolling calculations onto 3 state-based classes: 42 | *
212 | *
The state is exited - thus completing over-scroll handling, in one of two cases:
213 | *
When user lets go of the view, it transitions control to the bounce-back state.
214 | *
When user moves the view back onto a potential 'under-scroll' state, it abruptly
215 | * transitions control to the idle-state, so as to return touch-events management to the
216 | * normal over-scroll-less environment (thus preventing under-scrolling and potentially regaining
217 | * regular scrolling).
218 | */
219 | protected class OverScrollingState implements IDecoratorState {
220 |
221 | protected final float mTouchDragRatioFwd;
222 | protected final float mTouchDragRatioBck;
223 |
224 | final MotionAttributes mMoveAttr;
225 | int mCurrDragState;
226 |
227 | public OverScrollingState(float touchDragRatioFwd, float touchDragRatioBck) {
228 | mMoveAttr = createMotionAttributes();
229 | mTouchDragRatioFwd = touchDragRatioFwd;
230 | mTouchDragRatioBck = touchDragRatioBck;
231 | }
232 |
233 | @Override
234 | public int getStateId() {
235 | // This is really a single class that implements 2 states, so our ID depends on what
236 | // it was during the last invocation.
237 | return mCurrDragState;
238 | }
239 |
240 | @Override
241 | public boolean handleMoveTouchEvent(MotionEvent event) {
242 |
243 | // Switching 'pointers' (e.g. fingers) on-the-fly isn't supported -- abort over-scroll
244 | // smoothly using the default bounce-back animation in this case.
245 | if (mOverScrollStartAttr.mPointerId != event.getPointerId(0)) {
246 | issueStateTransition(mBounceBackState);
247 | return true;
248 | }
249 |
250 | final View view = mViewAdapter.getView();
251 | if (!mMoveAttr.init(view, event)) {
252 | // Keep intercepting the touch event as long as we're still over-scrolling...
253 | return true;
254 | }
255 |
256 | float deltaOffset = mMoveAttr.mDeltaOffset / (mMoveAttr.mDir == mOverScrollStartAttr.mDir ? mTouchDragRatioFwd : mTouchDragRatioBck);
257 | float newOffset = mMoveAttr.mAbsOffset + deltaOffset;
258 |
259 | // If moved in counter direction onto a potential under-scroll state -- don't. Instead, abort
260 | // over-scrolling abruptly, thus returning control to which-ever touch handlers there
261 | // are waiting (e.g. regular scroller handlers).
262 | if ((mOverScrollStartAttr.mDir && !mMoveAttr.mDir && (newOffset <= mOverScrollStartAttr.mAbsOffset)) ||
263 | (!mOverScrollStartAttr.mDir && mMoveAttr.mDir && (newOffset >= mOverScrollStartAttr.mAbsOffset))) {
264 | translateViewAndEvent(view, mOverScrollStartAttr.mDir, mOverScrollStartAttr.mAbsOffset, event);
265 | mUpdateListener.onOverScrollUpdate(ElasticityBounceEffectBase.this, mCurrDragState, 0);
266 |
267 | issueStateTransition(mIdleState);
268 | return true;
269 | }
270 |
271 | if (view.getParent() != null) {
272 | view.getParent().requestDisallowInterceptTouchEvent(true);
273 | }
274 |
275 | long dt = event.getEventTime() - event.getHistoricalEventTime(0);
276 | if (dt > 0) { // Sometimes (though rarely) dt==0 cause originally timing is in nanos, but is presented in millis.
277 | mVelocity = deltaOffset / dt;
278 | }
279 |
280 | translateView(view, mOverScrollStartAttr.mDir, newOffset);
281 | mUpdateListener.onOverScrollUpdate(ElasticityBounceEffectBase.this, mCurrDragState, newOffset);
282 |
283 | return true;
284 | }
285 |
286 | @Override
287 | public boolean handleUpOrCancelTouchEvent(MotionEvent event) {
288 | issueStateTransition(mBounceBackState);
289 | return true;
290 | }
291 |
292 | @Override
293 | public void handleEntryTransition(IDecoratorState fromState) {
294 | mCurrDragState = (mOverScrollStartAttr.mDir ? STATE_DRAG_START_SIDE : STATE_DRAG_END_SIDE);
295 | mStateListener.onOverScrollStateChange(ElasticityBounceEffectBase.this, fromState.getStateId(), this.getStateId());
296 | }
297 | }
298 |
299 | /**
300 | * When entered, starts the bounce-back animation.
301 | *
Upon animation completion, transitions control onto the idle state; Does so by
302 | * registering itself as an animation listener.
303 | *
In the meantime, blocks (intercepts) all touch events.
304 | */
305 | protected class BounceBackState implements IDecoratorState, Animator.AnimatorListener, ValueAnimator.AnimatorUpdateListener {
306 |
307 | protected final Interpolator mBounceBackInterpolator = new BounceInterpolator();
308 | protected final float mDecelerateFactor;
309 | protected final float mDoubleDecelerateFactor;
310 |
311 | protected final AnimationAttributes mAnimAttributes;
312 |
313 | public BounceBackState(float decelerateFactor) {
314 | mDecelerateFactor = decelerateFactor;
315 | mDoubleDecelerateFactor = 2f * decelerateFactor;
316 |
317 | mAnimAttributes = createAnimationAttributes();
318 | }
319 |
320 | @Override
321 | public int getStateId() {
322 | return STATE_BOUNCE_BACK;
323 | }
324 |
325 | @Override
326 | public void handleEntryTransition(IDecoratorState fromState) {
327 | mStateListener.onOverScrollStateChange(ElasticityBounceEffectBase.this, fromState.getStateId(), this.getStateId());
328 | Animator bounceBackAnim = createAnimator();
329 | bounceBackAnim.addListener(this);
330 | bounceBackAnim.start();
331 | }
332 |
333 | @Override
334 | public boolean handleMoveTouchEvent(MotionEvent event) {
335 | // Flush all touches down the drain till animation is over.
336 | return true;
337 | }
338 |
339 | @Override
340 | public boolean handleUpOrCancelTouchEvent(MotionEvent event) {
341 | // Flush all touches down the drain till animation is over.
342 | return true;
343 | }
344 |
345 | @Override
346 | public void onAnimationEnd(Animator animation) {
347 | issueStateTransition(mIdleState);
348 | }
349 |
350 | @Override
351 | public void onAnimationUpdate(ValueAnimator animation) {
352 | translateView(mViewAdapter.getView(), mOverScrollStartAttr.mDir, (Float) animation.getAnimatedValue());
353 | mUpdateListener.onOverScrollUpdate(ElasticityBounceEffectBase.this, STATE_BOUNCE_BACK, (Float) animation.getAnimatedValue());
354 | }
355 |
356 | @Override
357 | public void onAnimationStart(Animator animation) {
358 | }
359 |
360 | @Override
361 | public void onAnimationCancel(Animator animation) {
362 | issueStateTransition(mIdleState);
363 | }
364 |
365 | @Override
366 | public void onAnimationRepeat(Animator animation) {
367 | }
368 |
369 | protected Animator createAnimator() {
370 | final View view = mViewAdapter.getView();
371 | mAnimAttributes.init(view);
372 |
373 | // Set up a low-duration slow-down animation IN the drag direction.
374 |
375 | // Exception: If wasn't dragging in 'forward' direction (or velocity=0 -- i.e. not dragging at all),
376 | // skip slow-down anim directly to the bounce-back.
377 | if (mVelocity == 0f || (mVelocity < 0 && mOverScrollStartAttr.mDir) || (mVelocity > 0 && !mOverScrollStartAttr.mDir)) {
378 | return createBounceBackAnimator(mAnimAttributes.mAbsOffset, 0);
379 | }
380 |
381 | // dt = (Vt - Vo) / a; Vt=0 ==> dt = -Vo / a
382 | float slowdownDuration = -mVelocity / mDecelerateFactor;
383 | slowdownDuration = (slowdownDuration < 0 ? 0 : slowdownDuration); // Happens in counter-direction dragging
384 |
385 | // dx = (Vt^2 - Vo^2) / 2a; Vt=0 ==> dx = -Vo^2 / 2a
386 | float slowdownDistance = -mVelocity * mVelocity / mDoubleDecelerateFactor;
387 | float slowdownEndOffset = mAnimAttributes.mAbsOffset + slowdownDistance;
388 |
389 | ValueAnimator slowdownAnim = createSlowdownAnimator((int) slowdownDuration, mAnimAttributes.mAbsOffset, slowdownEndOffset);
390 |
391 | // Set up the bounce back animation, bringing the view back into the original, pre-overscroll position (translation=0).
392 | ValueAnimator bounceBackAnim = createBounceBackAnimator(slowdownEndOffset, 0);
393 |
394 | // Play the 2 animations as a sequence.
395 | AnimatorSet wholeAnim = new AnimatorSet();
396 | wholeAnim.playSequentially(slowdownAnim, bounceBackAnim);
397 | return wholeAnim;
398 | }
399 |
400 | protected ValueAnimator createSlowdownAnimator(int slowdownDuration, float slowdownStartOffset, float slowdownEndOffset) {
401 | ValueAnimator slowdownAnim = ValueAnimator.ofFloat(slowdownStartOffset, slowdownEndOffset);
402 | slowdownAnim.setDuration(slowdownDuration);
403 | slowdownAnim.setInterpolator(new DecelerateInterpolator());
404 | slowdownAnim.addUpdateListener(this);
405 | return slowdownAnim;
406 | }
407 |
408 | protected ValueAnimator createBounceBackAnimator(float startOffset, float endOffset) {
409 | // Duration is proportional to the view's size.
410 | float bounceBackDuration = (Math.abs(startOffset) / mAnimAttributes.mMaxOffset) * MAX_BOUNCE_BACK_DURATION_MS;
411 | ValueAnimator bounceBackAnim = ValueAnimator.ofFloat(startOffset, endOffset);
412 | bounceBackAnim.setDuration(Math.max((int) bounceBackDuration, MIN_BOUNCE_BACK_DURATION_MS));
413 | bounceBackAnim.setInterpolator(mBounceBackInterpolator);
414 | bounceBackAnim.addUpdateListener(this);
415 | return bounceBackAnim;
416 | }
417 | }
418 |
419 | public ElasticityBounceEffectBase(IElasticityAdapter viewAdapter, float decelerateFactor, float scaleFactor ,float touchDragRatioFwd, float touchDragRatioBck) {
420 | mViewAdapter = viewAdapter;
421 |
422 | mIdleState = new IdleState();
423 | mOverScrollingState = new OverScrollingState(touchDragRatioFwd, touchDragRatioBck);
424 | mBounceBackState = new BounceBackState(decelerateFactor);
425 |
426 | mCurrentState = mIdleState;
427 |
428 | maxScaleFactor = scaleFactor;
429 |
430 | attach();
431 | }
432 |
433 | @Override
434 | public boolean onTouch(View v, MotionEvent event) {
435 | switch (event.getAction()) {
436 | case MotionEvent.ACTION_MOVE:
437 | return mCurrentState.handleMoveTouchEvent(event);
438 |
439 | case MotionEvent.ACTION_CANCEL:
440 | case MotionEvent.ACTION_UP:
441 | return mCurrentState.handleUpOrCancelTouchEvent(event);
442 | }
443 |
444 | return false;
445 | }
446 |
447 | @Override
448 | public void setOverScrollStateListener(IElasticityStateListener listener) {
449 | mStateListener = (listener != null ? listener : new ElasticityListenerStubs.ElasticityStateListenerStub());
450 | }
451 |
452 | @Override
453 | public void setOverScrollUpdateListener(IElasticityUpdateListener listener) {
454 | mUpdateListener = (listener != null ? listener : new ElasticityListenerStubs.ElasticityUpdateListenerStub());
455 | }
456 |
457 | @Override
458 | public int getCurrentState() {
459 | return mCurrentState.getStateId();
460 | }
461 |
462 | @Override
463 | public View getView() {
464 | return mViewAdapter.getView();
465 | }
466 |
467 | protected void issueStateTransition(IDecoratorState state) {
468 | IDecoratorState oldState = mCurrentState;
469 | mCurrentState = state;
470 | mCurrentState.handleEntryTransition(oldState);
471 | }
472 |
473 | protected void attach() {
474 | getView().setOnTouchListener(this);
475 | getView().setOverScrollMode(View.OVER_SCROLL_NEVER);
476 | }
477 |
478 | @Override
479 | public void detach() {
480 | if (mCurrentState != mIdleState) {
481 | Log.w(TAG, "Decorator detached while over-scroll is in effect. You might want to add a precondition of that getCurrentState()==STATE_IDLE, first.");
482 | }
483 | getView().setOnTouchListener(null);
484 | getView().setOverScrollMode(View.OVER_SCROLL_ALWAYS);
485 | }
486 |
487 | protected abstract MotionAttributes createMotionAttributes();
488 |
489 | protected abstract AnimationAttributes createAnimationAttributes();
490 |
491 | protected abstract void translateView(View view, boolean dir, float offset);
492 |
493 | protected abstract void translateViewAndEvent(View view, boolean dir, float offset, MotionEvent event);
494 |
495 | protected float getViewOffset(View view) {
496 | if (view.getTag(R.id.offsetValue) != null) {
497 | return (float) view.getTag(R.id.offsetValue);
498 | }
499 | return 0;
500 | }
501 |
502 | protected void setViewOffset(View view, float offset) {
503 | view.setTag(R.id.offsetValue, offset);
504 | }
505 |
506 | protected float getMaxScaleFactor() {
507 | return maxScaleFactor;
508 | }
509 |
510 | }
511 |
--------------------------------------------------------------------------------
/elasticity-lib/src/test/java/xander/elasticity/android/ui/overscroll/VerticalOverScrollBounceEffectDecoratorTest.java:
--------------------------------------------------------------------------------
1 | package xander.elasticity.android.ui.overscroll;
2 |
3 | import android.view.MotionEvent;
4 | import android.view.View;
5 |
6 | import org.junit.Before;
7 | import org.junit.Test;
8 | import org.junit.runner.RunWith;
9 | import org.robolectric.RobolectricTestRunner;
10 | import org.robolectric.annotation.Config;
11 |
12 | import xander.elasticity.HorizontalElasticityBounceEffect;
13 | import xander.elasticity.IElasticityStateListener;
14 | import xander.elasticity.IElasticityUpdateListener;
15 | import xander.elasticity.VerticalElasticityBounceEffect;
16 | import xander.elasticity.adapters.IElasticityAdapter;
17 |
18 | import static xander.elasticity.IElasticityState.*;
19 | import static xander.elasticity.VerticalElasticityBounceEffect.DEFAULT_DECELERATE_FACTOR;
20 | import static xander.elasticity.VerticalElasticityBounceEffect.DEFAULT_TOUCH_DRAG_MOVE_RATIO_FWD;
21 | import static org.junit.Assert.assertEquals;
22 | import static org.junit.Assert.assertFalse;
23 | import static org.junit.Assert.assertTrue;
24 | import static org.mockito.Matchers.*;
25 | import static org.mockito.Mockito.*;
26 |
27 | /**
28 | * @author amitd
29 | */
30 | @RunWith(RobolectricTestRunner.class)
31 | @Config(manifest = Config.NONE)
32 | public class VerticalOverScrollBounceEffectDecoratorTest {
33 |
34 | View mView;
35 | IElasticityAdapter mViewAdapter;
36 | IElasticityStateListener mStateListener;
37 | IElasticityUpdateListener mUpdateListener;
38 |
39 | @Before
40 | public void setUp() throws Exception {
41 | mView = mock(View.class);
42 | mViewAdapter = mock(IElasticityAdapter.class);
43 | when(mViewAdapter.getView()).thenReturn(mView);
44 |
45 | mStateListener = mock(IElasticityStateListener.class);
46 | mUpdateListener = mock(IElasticityUpdateListener.class);
47 | }
48 |
49 | @Test
50 | public void detach_decoratorIsAttached_detachFromView() throws Exception {
51 |
52 | // Arrange
53 |
54 | HorizontalElasticityBounceEffect uut = new HorizontalElasticityBounceEffect(mViewAdapter);
55 |
56 | // Act
57 |
58 | uut.detach();
59 |
60 | // Assert
61 |
62 | verify(mView).setOnTouchListener(eq((View.OnTouchListener) null));
63 | verify(mView).setOverScrollMode(View.OVER_SCROLL_ALWAYS);
64 | }
65 |
66 | @Test
67 | public void detach_overScrollInEffect_detachFromView() throws Exception {
68 |
69 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(true);
70 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(false);
71 |
72 | VerticalElasticityBounceEffect uut = getUUT();
73 | uut.onTouch(mView, createShortDownwardsMoveEvent());
74 |
75 | // Act
76 |
77 | uut.detach();
78 |
79 | // Assert
80 |
81 | verify(mView).setOnTouchListener(eq((View.OnTouchListener) null));
82 | verify(mView).setOverScrollMode(View.OVER_SCROLL_ALWAYS);
83 | }
84 |
85 | /*
86 | * Move-action event
87 | */
88 |
89 | @Test
90 | public void onTouchMoveAction_notInViewEnds_ignoreTouchEvent() throws Exception {
91 |
92 | // Arrange
93 |
94 | MotionEvent event = createShortDownwardsMoveEvent();
95 |
96 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(false);
97 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(false);
98 |
99 | VerticalElasticityBounceEffect uut = getUUT();
100 |
101 | // Act
102 |
103 | boolean ret = uut.onTouch(mView, event);
104 |
105 | // Assert
106 |
107 | verify(mView, never()).setTranslationX(anyFloat());
108 | verify(mView, never()).setTranslationY(anyFloat());
109 | assertFalse(ret);
110 | assertEquals(STATE_IDLE, uut.getCurrentState());
111 |
112 | verify(mStateListener, never()).onOverScrollStateChange(eq(uut),anyInt(), anyInt());
113 | verify(mUpdateListener, never()).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
114 | }
115 |
116 | @Test
117 | public void onTouchMoveAction_dragDownInUpperEnd_overscrollDownwards() throws Exception {
118 |
119 | // Arrange
120 |
121 | MotionEvent event = createShortDownwardsMoveEvent();
122 |
123 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(true);
124 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(false);
125 |
126 | VerticalElasticityBounceEffect uut = getUUT();
127 |
128 | // Act
129 |
130 | boolean ret = uut.onTouch(mView, event);
131 |
132 | // Assert
133 |
134 | float expectedTransY = (event.getY() - event.getHistoricalY(0)) / DEFAULT_TOUCH_DRAG_MOVE_RATIO_FWD;
135 | verify(mView).setTranslationY(expectedTransY);
136 | verify(mView, never()).setTranslationX(anyFloat());
137 | assertTrue(ret);
138 | assertEquals(STATE_DRAG_START_SIDE, uut.getCurrentState());
139 |
140 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_START_SIDE));
141 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_START_SIDE), eq(expectedTransY));
142 | }
143 |
144 | @Test
145 | public void onTouchMoveAction_dragUpInBottomEnd_overscrollUpwards() throws Exception {
146 |
147 | // Arrange
148 |
149 | MotionEvent event = createShortUpwardsMoveEvent();
150 |
151 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(false);
152 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(true);
153 |
154 | VerticalElasticityBounceEffect uut = getUUT();
155 |
156 | // Act
157 |
158 | boolean ret = uut.onTouch(mView, event);
159 |
160 | // Assert
161 |
162 | float expectedTransY = (event.getY() - event.getHistoricalY(0)) / DEFAULT_TOUCH_DRAG_MOVE_RATIO_FWD;
163 | verify(mView).setTranslationY(expectedTransY);
164 | verify(mView, never()).setTranslationX(anyFloat());
165 | assertTrue(ret);
166 | assertEquals(STATE_DRAG_END_SIDE, uut.getCurrentState());
167 |
168 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_END_SIDE));
169 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_END_SIDE), eq(expectedTransY));
170 | }
171 |
172 | @Test
173 | public void onTouchMoveAction_dragUpInUpperEnd_ignoreTouchEvent() throws Exception {
174 |
175 | // Arrange
176 |
177 | MotionEvent event = createShortUpwardsMoveEvent();
178 |
179 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(true);
180 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(false);
181 |
182 | VerticalElasticityBounceEffect uut = getUUT();
183 |
184 | // Act
185 |
186 | boolean ret = uut.onTouch(mView, event);
187 |
188 | // Assert
189 |
190 | verify(mView, never()).setTranslationX(anyFloat());
191 | verify(mView, never()).setTranslationY(anyFloat());
192 | assertFalse(ret);
193 | assertEquals(STATE_IDLE, uut.getCurrentState());
194 |
195 | verify(mStateListener, never()).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
196 | verify(mUpdateListener, never()).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
197 | }
198 |
199 | @Test
200 | public void onTouchMoveAction_dragDownInBottomEnd_ignoreTouchEvent() throws Exception {
201 |
202 | // Arrange
203 |
204 | MotionEvent event = createShortDownwardsMoveEvent();
205 |
206 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(false);
207 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(true);
208 |
209 | VerticalElasticityBounceEffect uut = getUUT();
210 |
211 | // Act
212 |
213 | boolean ret = uut.onTouch(mView, event);
214 |
215 | // Assert
216 |
217 | verify(mView, never()).setTranslationX(anyFloat());
218 | verify(mView, never()).setTranslationY(anyFloat());
219 | assertFalse(ret);
220 | assertEquals(STATE_IDLE, uut.getCurrentState());
221 |
222 | verify(mStateListener, never()).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
223 | verify(mUpdateListener, never()).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
224 | }
225 |
226 | @Test
227 | public void onTouchMoveAction_2ndDownDragInUpperEnd_overscrollDownwardsFurther() throws Exception {
228 |
229 | // Arrange
230 |
231 | // Bring UUT to a downwards-overscroll state
232 | MotionEvent event1 = createShortDownwardsMoveEvent();
233 |
234 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(true);
235 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(false);
236 |
237 | VerticalElasticityBounceEffect uut = getUUT();
238 | uut.onTouch(mView, event1);
239 | reset(mView);
240 |
241 | // Create 2nd downwards-drag event
242 | MotionEvent event2 = createLongDownwardsMoveEvent();
243 |
244 | // Act
245 |
246 | final boolean ret = uut.onTouch(mView, event2);
247 |
248 | // Assert
249 |
250 | final float expectedTransY1 = (event1.getY() - event1.getHistoricalY(0)) / DEFAULT_TOUCH_DRAG_MOVE_RATIO_FWD;
251 | final float expectedTransY2 = (event2.getY() - event2.getHistoricalY(0)) / DEFAULT_TOUCH_DRAG_MOVE_RATIO_FWD;
252 | verify(mView).setTranslationY(expectedTransY2);
253 | verify(mView, never()).setTranslationX(anyFloat());
254 | assertTrue(ret);
255 | assertEquals(STATE_DRAG_START_SIDE, uut.getCurrentState());
256 |
257 | // State-change listener called only once?
258 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_START_SIDE));
259 | verify(mStateListener).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
260 | // Update-listener called exactly twice?
261 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_START_SIDE), eq(expectedTransY1));
262 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_START_SIDE), eq(expectedTransY2));
263 | verify(mUpdateListener, times(2)).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
264 | }
265 |
266 | @Test
267 | public void onTouchMoveAction_2ndUpDragInBottomEnd_overscrollUpwardsFurther() throws Exception {
268 |
269 | // Arrange
270 |
271 | // Bring UUT to an upwards-overscroll state
272 | MotionEvent event1 = createShortUpwardsMoveEvent();
273 |
274 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(false);
275 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(true);
276 |
277 | VerticalElasticityBounceEffect uut = getUUT();
278 | uut.onTouch(mView, event1);
279 | reset(mView);
280 |
281 | // Create 2nd upward-drag event
282 | MotionEvent event2 = createLongUpwardsMoveEvent();
283 |
284 | // Act
285 |
286 | final boolean ret = uut.onTouch(mView, event2);
287 |
288 | // Assert
289 |
290 | final float expectedTransY1 = (event1.getY() - event1.getHistoricalY(0)) / DEFAULT_TOUCH_DRAG_MOVE_RATIO_FWD;
291 | final float expectedTransY2 = (event2.getY() - event2.getHistoricalY(0)) / DEFAULT_TOUCH_DRAG_MOVE_RATIO_FWD;
292 | verify(mView).setTranslationY(expectedTransY2);
293 | verify(mView, never()).setTranslationX(anyFloat());
294 | assertTrue(ret);
295 | assertEquals(STATE_DRAG_END_SIDE, uut.getCurrentState());
296 |
297 | // State-change listener called only once?
298 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_END_SIDE));
299 | verify(mStateListener).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
300 | // Update-listener called exactly twice?
301 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_END_SIDE), eq(expectedTransY1));
302 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_END_SIDE), eq(expectedTransY2));
303 | verify(mUpdateListener, times(2)).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
304 | }
305 |
306 | /**
307 | * When over-scroll has already started (downwards in this case) and suddenly the user changes
308 | * their mind and scrolls a bit in the other direction:
309 | *
We expect the touch to still be intercepted in that case, and the overscroll to remain in effect.
310 | */
311 | @Test
312 | public void onTouchMoveAction_dragUpWhenDownOverscolled_continueOverscrollingUpwards() throws Exception {
313 |
314 | // Arrange
315 |
316 | // In down & up drag tests we use equal ratios to avoid the effect's under-scroll handling
317 | final float touchDragRatioFwd = 3f;
318 | final float touchDragRatioBck = 3f;
319 |
320 | // Bring UUT to a downwrads-overscroll state
321 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(true);
322 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(false);
323 |
324 | VerticalElasticityBounceEffect uut = getUUT(touchDragRatioFwd, touchDragRatioBck);
325 | MotionEvent eventMoveRight = createLongDownwardsMoveEvent();
326 | uut.onTouch(mView, eventMoveRight);
327 | reset(mView);
328 | float startTransY = (eventMoveRight.getY() - eventMoveRight.getHistoricalY(0)) / touchDragRatioFwd;
329 | when(mView.getTranslationY()).thenReturn(startTransY);
330 |
331 | // Create the up-drag event
332 | MotionEvent eventMoveUpwards = createShortUpwardsMoveEvent();
333 |
334 | // Act
335 |
336 | boolean ret = uut.onTouch(mView, eventMoveUpwards);
337 |
338 | // Assert
339 |
340 | float expectedTransY = startTransY +
341 | (eventMoveUpwards.getY() - eventMoveUpwards.getHistoricalY(0)) / touchDragRatioBck;
342 | verify(mView).setTranslationY(expectedTransY);
343 | verify(mView, never()).setTranslationX(anyFloat());
344 | assertTrue(ret);
345 | assertEquals(STATE_DRAG_START_SIDE, uut.getCurrentState());
346 |
347 | // State-change listener called only once?
348 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_START_SIDE));
349 | verify(mStateListener).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
350 | // Update-listener called exactly twice?
351 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_START_SIDE), eq(startTransY));
352 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_START_SIDE), eq(expectedTransY));
353 | verify(mUpdateListener, times(2)).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
354 | }
355 |
356 | /**
357 | * When over-scroll has already started (upwards in this case) and suddenly the user changes
358 | * their mind and scrolls a bit in the other direction:
359 | *
We expect the touch to still be intercepted in that case, and the overscroll to remain in effect.
360 | */
361 | @Test
362 | public void onTouchMoveAction_dragDownWhenUpOverscolled_continueOverscrollingDownwards() throws Exception {
363 |
364 | // Arrange
365 |
366 | // In up & down drag tests we use equal ratios to avoid the effect's under-scroll handling
367 | final float touchDragRatioFwd = 3f;
368 | final float touchDragRatioBck = 3f;
369 |
370 | // Bring UUT to an upwards-overscroll state
371 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(false);
372 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(true);
373 |
374 | VerticalElasticityBounceEffect uut = getUUT(touchDragRatioFwd, touchDragRatioBck);
375 | MotionEvent eventMoveUp = createLongUpwardsMoveEvent();
376 | uut.onTouch(mView, eventMoveUp);
377 | reset(mView);
378 |
379 | float startTransY = (eventMoveUp.getY() - eventMoveUp.getHistoricalY(0)) / touchDragRatioFwd;
380 | when(mView.getTranslationY()).thenReturn(startTransY);
381 |
382 | // Create the down-drag event
383 | MotionEvent eventMoveDown = createShortDownwardsMoveEvent();
384 |
385 | // Act
386 |
387 | boolean ret = uut.onTouch(mView, eventMoveDown);
388 |
389 | // Assert
390 |
391 | float expectedTransY = startTransY + (eventMoveDown.getY() - eventMoveDown.getHistoricalY(0)) / touchDragRatioBck;
392 | verify(mView).setTranslationY(expectedTransY);
393 | verify(mView, never()).setTranslationX(anyFloat());
394 | assertTrue(ret);
395 | assertEquals(STATE_DRAG_END_SIDE, uut.getCurrentState());
396 |
397 | // State-change listener called only once?
398 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_END_SIDE));
399 | verify(mStateListener).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
400 | // Update-listener called exactly twice?
401 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_END_SIDE), eq(startTransY));
402 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_END_SIDE), eq(expectedTransY));
403 | verify(mUpdateListener, times(2)).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
404 | }
405 |
406 | @Test
407 | public void onTouchMoveAction_undragWhenDownOverscrolled_endOverscrolling() throws Exception {
408 |
409 | // Arrange
410 |
411 | // In left & right tests we use equal ratios to avoid the effect's under-scroll handling
412 | final float touchDragRatioFwd = 3f;
413 | final float touchDragRatioBck = 3f;
414 |
415 | // Bring UUT to a downwards-overscroll state
416 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(true);
417 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(false);
418 |
419 | VerticalElasticityBounceEffect uut = getUUT(touchDragRatioFwd, touchDragRatioBck);
420 | MotionEvent eventMoveDown = createLongDownwardsMoveEvent();
421 | uut.onTouch(mView, eventMoveDown);
422 | reset(mView);
423 | float startTransX = (eventMoveDown.getX() - eventMoveDown.getHistoricalX(0)) / touchDragRatioFwd;
424 | when(mView.getTranslationX()).thenReturn(startTransX);
425 |
426 | // Create the (negative) upwards-drag event
427 | MotionEvent eventMoveUp = createLongUpwardsMoveEvent();
428 |
429 | // Act
430 |
431 | boolean ret = uut.onTouch(mView, eventMoveUp);
432 |
433 | // Assert
434 |
435 | verify(mView, never()).setTranslationX(anyFloat());
436 | verify(mView).setTranslationY(0);
437 | assertTrue(ret);
438 | assertEquals(STATE_IDLE, uut.getCurrentState());
439 |
440 | // State-change listener invoked to say drag-on and drag-off (idle).
441 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_START_SIDE));
442 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_DRAG_START_SIDE), eq(STATE_IDLE));
443 | verify(mStateListener, times(2)).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
444 | // Update-listener called exactly twice?
445 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_START_SIDE), eq(startTransX));
446 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_START_SIDE), eq(0f));
447 | verify(mUpdateListener, times(2)).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
448 | }
449 |
450 | @Test
451 | public void onTouchMoveAction_undragWhenUpOverscrolled_endOverscrolling() throws Exception {
452 |
453 | // Arrange
454 |
455 | // In left & right tests we use equal ratios to avoid the effect's under-scroll handling
456 | final float touchDragRatioFwd = 3f;
457 | final float touchDragRatioBck = 3f;
458 |
459 | // Bring UUT to a left-overscroll state
460 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(false);
461 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(true);
462 |
463 | VerticalElasticityBounceEffect uut = getUUT(touchDragRatioFwd, touchDragRatioBck);
464 | MotionEvent eventMoveUp = createLongUpwardsMoveEvent();
465 | uut.onTouch(mView, eventMoveUp);
466 | reset(mView);
467 | float startTransX = (eventMoveUp.getX() - eventMoveUp.getHistoricalX(0)) / touchDragRatioFwd;
468 | when(mView.getTranslationX()).thenReturn(startTransX);
469 |
470 | // Create the (negative) downwards-drag event
471 | MotionEvent eventMoveDown = createLongDownwardsMoveEvent();
472 |
473 | // Act
474 |
475 | boolean ret = uut.onTouch(mView, eventMoveDown);
476 |
477 | // Assert
478 |
479 | verify(mView, never()).setTranslationX(anyFloat());
480 | verify(mView).setTranslationY(0);
481 | assertTrue(ret);
482 | assertEquals(STATE_IDLE, uut.getCurrentState());
483 |
484 | // State-change listener invoked to say drag-on and drag-off (idle).
485 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_IDLE), eq(STATE_DRAG_END_SIDE));
486 | verify(mStateListener).onOverScrollStateChange(eq(uut), eq(STATE_DRAG_END_SIDE), eq(STATE_IDLE));
487 | verify(mStateListener, times(2)).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
488 | // Update-listener called exactly twice?
489 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_END_SIDE), eq(startTransX));
490 | verify(mUpdateListener).onOverScrollUpdate(eq(uut), eq(STATE_DRAG_END_SIDE), eq(0f));
491 | verify(mUpdateListener, times(2)).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
492 | }
493 |
494 | /*
495 | * Up action event
496 | */
497 |
498 | @Test
499 | public void onTouchUpAction_eventWhenNotOverscrolled_ignoreTouchEvent() throws Exception {
500 |
501 | // Arrange
502 |
503 | MotionEvent event = createDefaultUpActionEvent();
504 |
505 | when(mViewAdapter.isInAbsoluteStart()).thenReturn(true);
506 | when(mViewAdapter.isInAbsoluteEnd()).thenReturn(true);
507 |
508 | VerticalElasticityBounceEffect uut = getUUT();
509 |
510 | // Act
511 |
512 | boolean ret = uut.onTouch(mView, event);
513 |
514 | // Assert
515 |
516 | verify(mView, never()).setTranslationX(anyFloat());
517 | verify(mView, never()).setTranslationY(anyFloat());
518 | assertFalse(ret);
519 | assertEquals(STATE_IDLE, uut.getCurrentState());
520 |
521 | verify(mStateListener, never()).onOverScrollStateChange(eq(uut), anyInt(), anyInt());
522 | verify(mUpdateListener, never()).onOverScrollUpdate(eq(uut), anyInt(), anyFloat());
523 | }
524 |
525 | protected MotionEvent createShortDownwardsMoveEvent() {
526 | MotionEvent event = mock(MotionEvent.class);
527 | when(event.getAction()).thenReturn(MotionEvent.ACTION_MOVE);
528 | when(event.getX()).thenReturn(200f);
529 | when(event.getY()).thenReturn(100f);
530 | when(event.getX(0)).thenReturn(200f);
531 | when(event.getY(0)).thenReturn(100f);
532 | when(event.getHistorySize()).thenReturn(1);
533 | when(event.getHistoricalX(eq(0))).thenReturn(190f);
534 | when(event.getHistoricalY(eq(0))).thenReturn(80f);
535 | when(event.getHistoricalX(eq(0), eq(0))).thenReturn(190f);
536 | when(event.getHistoricalY(eq(0), eq(0))).thenReturn(80f);
537 | return event;
538 | }
539 |
540 | protected MotionEvent createLongDownwardsMoveEvent() {
541 | MotionEvent event = mock(MotionEvent.class);
542 | when(event.getAction()).thenReturn(MotionEvent.ACTION_MOVE);
543 | when(event.getX()).thenReturn(250f);
544 | when(event.getY()).thenReturn(150f);
545 | when(event.getX(0)).thenReturn(250f);
546 | when(event.getY(0)).thenReturn(150f);
547 | when(event.getHistorySize()).thenReturn(1);
548 | when(event.getHistoricalX(eq(0))).thenReturn(200f);
549 | when(event.getHistoricalY(eq(0))).thenReturn(100f);
550 | when(event.getHistoricalX(eq(0), eq(0))).thenReturn(200f);
551 | when(event.getHistoricalY(eq(0), eq(0))).thenReturn(100f);
552 | return event;
553 | }
554 |
555 | protected MotionEvent createShortUpwardsMoveEvent() {
556 | MotionEvent event = mock(MotionEvent.class);
557 | when(event.getAction()).thenReturn(MotionEvent.ACTION_MOVE);
558 | when(event.getX()).thenReturn(200f);
559 | when(event.getY()).thenReturn(100f);
560 | when(event.getX(0)).thenReturn(200f);
561 | when(event.getY(0)).thenReturn(100f);
562 | when(event.getHistorySize()).thenReturn(1);
563 | when(event.getHistoricalX(eq(0))).thenReturn(220f);
564 | when(event.getHistoricalY(eq(0))).thenReturn(120f);
565 | when(event.getHistoricalX(eq(0), eq(0))).thenReturn(220f);
566 | when(event.getHistoricalY(eq(0), eq(0))).thenReturn(120f);
567 | return event;
568 | }
569 |
570 | protected MotionEvent createLongUpwardsMoveEvent() {
571 | MotionEvent event = mock(MotionEvent.class);
572 | when(event.getAction()).thenReturn(MotionEvent.ACTION_MOVE);
573 | when(event.getX()).thenReturn(200f);
574 | when(event.getY()).thenReturn(100f);
575 | when(event.getX(0)).thenReturn(200f);
576 | when(event.getY(0)).thenReturn(100f);
577 | when(event.getHistorySize()).thenReturn(1);
578 | when(event.getHistoricalX(eq(0))).thenReturn(250f);
579 | when(event.getHistoricalY(eq(0))).thenReturn(150f);
580 | when(event.getHistoricalX(eq(0), eq(0))).thenReturn(250f);
581 | when(event.getHistoricalY(eq(0), eq(0))).thenReturn(150f);
582 | return event;
583 | }
584 |
585 | protected MotionEvent createDefaultUpActionEvent() {
586 | MotionEvent event = mock(MotionEvent.class);
587 | when(event.getAction()).thenReturn(MotionEvent.ACTION_UP);
588 | return event;
589 | }
590 |
591 | protected VerticalElasticityBounceEffect getUUT() {
592 | VerticalElasticityBounceEffect uut = new VerticalElasticityBounceEffect(mViewAdapter);
593 | uut.setOverScrollStateListener(mStateListener);
594 | uut.setOverScrollUpdateListener(mUpdateListener);
595 | return uut;
596 | }
597 |
598 | protected VerticalElasticityBounceEffect getUUT(float touchDragRatioFwd, float touchDragRatioBck) {
599 | VerticalElasticityBounceEffect uut = new VerticalElasticityBounceEffect(mViewAdapter, touchDragRatioFwd, touchDragRatioBck, DEFAULT_DECELERATE_FACTOR);
600 | uut.setOverScrollStateListener(mStateListener);
601 | uut.setOverScrollUpdateListener(mUpdateListener);
602 | return uut;
603 | }
604 | }
--------------------------------------------------------------------------------