null.
530 | */
531 | public void setColors(@NonNull int[] colors) {
532 | mColors = colors;
533 | // if colors are reset, make sure to reset the color index as well
534 | setColorIndex(0);
535 | }
536 |
537 | /**
538 | * @param index Index into the color array of the color to display in
539 | * the progress spinner.
540 | */
541 | public void setColorIndex(int index) {
542 | mColorIndex = index;
543 | }
544 |
545 | /**
546 | * Proceed to the next available ring color. This will automatically
547 | * wrap back to the beginning of colors.
548 | */
549 | public void goToNextColor() {
550 | mColorIndex = (mColorIndex + 1) % (mColors.length);
551 | }
552 |
553 | public void setColorFilter(ColorFilter filter) {
554 | mPaint.setColorFilter(filter);
555 | invalidateSelf();
556 | }
557 |
558 | /**
559 | * @param alpha Set the alpha of the progress spinner and associated arrowhead.
560 | */
561 | public void setAlpha(int alpha) {
562 | mAlpha = alpha;
563 | }
564 |
565 | /**
566 | * @return Current alpha of the progress spinner and arrowhead.
567 | */
568 | public int getAlpha() {
569 | return mAlpha;
570 | }
571 |
572 | /**
573 | * @param strokeWidth Set the stroke width of the progress spinner in pixels.
574 | */
575 | public void setStrokeWidth(float strokeWidth) {
576 | mStrokeWidth = strokeWidth;
577 | mPaint.setStrokeWidth(strokeWidth);
578 | invalidateSelf();
579 | }
580 |
581 | @SuppressWarnings("unused")
582 | public float getStrokeWidth() {
583 | return mStrokeWidth;
584 | }
585 |
586 | @SuppressWarnings("unused")
587 | public void setStartTrim(float startTrim) {
588 | mStartTrim = startTrim;
589 | invalidateSelf();
590 | }
591 |
592 | @SuppressWarnings("unused")
593 | public float getStartTrim() {
594 | return mStartTrim;
595 | }
596 |
597 | public float getStartingStartTrim() {
598 | return mStartingStartTrim;
599 | }
600 |
601 | public float getStartingEndTrim() {
602 | return mStartingEndTrim;
603 | }
604 |
605 | @SuppressWarnings("unused")
606 | public void setEndTrim(float endTrim) {
607 | mEndTrim = endTrim;
608 | invalidateSelf();
609 | }
610 |
611 | @SuppressWarnings("unused")
612 | public float getEndTrim() {
613 | return mEndTrim;
614 | }
615 |
616 | @SuppressWarnings("unused")
617 | public void setRotation(float rotation) {
618 | mRotation = rotation;
619 | invalidateSelf();
620 | }
621 |
622 | @SuppressWarnings("unused")
623 | public float getRotation() {
624 | return mRotation;
625 | }
626 |
627 | public void setInsets(int width, int height) {
628 | final float minEdge = (float) Math.min(width, height);
629 | float insets;
630 | if (mRingCenterRadius <= 0 || minEdge < 0) {
631 | insets = (float) Math.ceil(mStrokeWidth / 2.0f);
632 | } else {
633 | insets = (float) (minEdge / 2.0f - mRingCenterRadius);
634 | }
635 | mStrokeInset = insets;
636 | }
637 |
638 | @SuppressWarnings("unused")
639 | public float getInsets() {
640 | return mStrokeInset;
641 | }
642 |
643 | /**
644 | * @param centerRadius Inner radius in px of the circle the progress
645 | * spinner arc traces.
646 | */
647 | public void setCenterRadius(double centerRadius) {
648 | mRingCenterRadius = centerRadius;
649 | }
650 |
651 | public double getCenterRadius() {
652 | return mRingCenterRadius;
653 | }
654 |
655 | /**
656 | * @param show Set to true to show the arrow head on the progress spinner.
657 | */
658 | public void setShowArrow(boolean show) {
659 | if (mShowArrow != show) {
660 | mShowArrow = show;
661 | invalidateSelf();
662 | }
663 | }
664 |
665 | /**
666 | * @param scale Set the scale of the arrowhead for the spinner.
667 | */
668 | public void setArrowScale(float scale) {
669 | if (scale != mArrowScale) {
670 | mArrowScale = scale;
671 | invalidateSelf();
672 | }
673 | }
674 |
675 | /**
676 | * @return The amount the progress spinner is currently rotated, between [0..1].
677 | */
678 | public float getStartingRotation() {
679 | return mStartingRotation;
680 | }
681 |
682 | /**
683 | * If the start / end trim are offset to begin with, store them so that
684 | * animation starts from that offset.
685 | */
686 | public void storeOriginals() {
687 | mStartingStartTrim = mStartTrim;
688 | mStartingEndTrim = mEndTrim;
689 | mStartingRotation = mRotation;
690 | }
691 |
692 | /**
693 | * Reset the progress spinner to default rotation, start and end angles.
694 | */
695 | public void resetOriginals() {
696 | mStartingStartTrim = 0;
697 | mStartingEndTrim = 0;
698 | mStartingRotation = 0;
699 | setStartTrim(0);
700 | setEndTrim(0);
701 | setRotation(0);
702 | }
703 |
704 | private void invalidateSelf() {
705 | mCallback.invalidateDrawable(null);
706 | }
707 | }
708 |
709 | /**
710 | * Squishes the interpolation curve into the second half of the animation.
711 | */
712 | private static class EndCurveInterpolator extends AccelerateDecelerateInterpolator {
713 | @Override
714 | public float getInterpolation(float input) {
715 | return super.getInterpolation(Math.max(0, (input - 0.5f) * 2.0f));
716 | }
717 | }
718 |
719 | /**
720 | * Squishes the interpolation curve into the first half of the animation.
721 | */
722 | private static class StartCurveInterpolator extends AccelerateDecelerateInterpolator {
723 | @Override
724 | public float getInterpolation(float input) {
725 | return super.getInterpolation(Math.min(1, input * 2.0f));
726 | }
727 | }
728 | }
729 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayout.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.orangegangsters.github.swipyrefreshlayout.library;
18 |
19 |
20 | import android.content.Context;
21 | import android.content.res.Resources;
22 | import android.content.res.TypedArray;
23 | import android.support.v4.view.MotionEventCompat;
24 | import android.support.v4.view.ViewCompat;
25 | import android.util.AttributeSet;
26 | import android.util.DisplayMetrics;
27 | import android.util.Log;
28 | import android.view.MotionEvent;
29 | import android.view.View;
30 | import android.view.ViewConfiguration;
31 | import android.view.ViewGroup;
32 | import android.view.animation.Animation;
33 | import android.view.animation.Animation.AnimationListener;
34 | import android.view.animation.DecelerateInterpolator;
35 | import android.view.animation.Transformation;
36 | import android.widget.AbsListView;
37 |
38 | /**
39 | * The SwipeRefreshLayout should be used whenever the user can refresh the
40 | * contents of a view via a vertical swipe gesture. The activity that
41 | * instantiates this view should add an OnRefreshListener to be notified
42 | * whenever the swipe to refresh gesture is completed. The SwipeRefreshLayout
43 | * will notify the listener each and every time the gesture is completed again;
44 | * the listener is responsible for correctly determining when to actually
45 | * initiate a refresh of its content. If the listener determines there should
46 | * not be a refresh, it must call setRefreshing(false) to cancel any visual
47 | * indication of a refresh. If an activity wishes to show just the progress
48 | * animation, it should call setRefreshing(true). To disable the gesture and
49 | * progress animation, call setEnabled(false) on the view.
50 | * 51 | * This layout should be made the parent of the view that will be refreshed as a 52 | * result of the gesture and can only support one direct child. This view will 53 | * also be made the target of the gesture and will be forced to match both the 54 | * width and the height supplied in this layout. The SwipeRefreshLayout does not 55 | * provide accessibility events; instead, a menu item must be provided to allow 56 | * refresh of the content wherever this gesture is used. 57 | *
58 | */ 59 | public class SwipyRefreshLayout extends ViewGroup { 60 | 61 | public static final String TAG = "SwipyRefreshLayout"; 62 | 63 | private static final float MAX_SWIPE_DISTANCE_FACTOR = .6f; 64 | private static final int REFRESH_TRIGGER_DISTANCE = 120; 65 | 66 | // Maps to ProgressBar.Large style 67 | public static final int LARGE = MaterialProgressDrawable.LARGE; 68 | // Maps to ProgressBar default style 69 | public static final int DEFAULT = MaterialProgressDrawable.DEFAULT; 70 | 71 | private static final String LOG_TAG = SwipyRefreshLayout.class.getSimpleName(); 72 | 73 | private static final int MAX_ALPHA = 255; 74 | private static final int STARTING_PROGRESS_ALPHA = (int) (.3f * MAX_ALPHA); 75 | 76 | private static final int CIRCLE_DIAMETER = 40; 77 | private static final int CIRCLE_DIAMETER_LARGE = 56; 78 | 79 | private static final float DECELERATE_INTERPOLATION_FACTOR = 2f; 80 | private static final int INVALID_POINTER = -1; 81 | private static final float DRAG_RATE = .5f; 82 | 83 | // Max amount of circle that can be filled by progress during swipe gesture, 84 | // where 1.0 is a full circle 85 | private static final float MAX_PROGRESS_ANGLE = .8f; 86 | 87 | private static final int SCALE_DOWN_DURATION = 150; 88 | 89 | private static final int ALPHA_ANIMATION_DURATION = 300; 90 | 91 | private static final int ANIMATE_TO_TRIGGER_DURATION = 200; 92 | 93 | private static final int ANIMATE_TO_START_DURATION = 200; 94 | 95 | // Default background for the progress spinner 96 | private static final int CIRCLE_BG_LIGHT = 0xFFFAFAFA; 97 | // Default offset in dips from the top of the view to where the progress spinner should stop 98 | private static final int DEFAULT_CIRCLE_TARGET = 64; 99 | 100 | private View mTarget; // the target of the gesture 101 | private SwipyRefreshLayoutDirection mDirection; 102 | private boolean mBothDirection; 103 | private OnRefreshListener mListener; 104 | private boolean mRefreshing = false; 105 | private int mTouchSlop; 106 | private float mTotalDragDistance = -1; 107 | private int mMediumAnimationDuration; 108 | private int mCurrentTargetOffsetTop; 109 | // Whether or not the starting offset has been determined. 110 | private boolean mOriginalOffsetCalculated = false; 111 | 112 | private float mInitialMotionY; 113 | private float mInitialDownY; 114 | private boolean mIsBeingDragged; 115 | private int mActivePointerId = INVALID_POINTER; 116 | // Whether this item is scaled up rather than clipped 117 | private boolean mScale; 118 | 119 | // Target is returning to its start offset because it was cancelled or a 120 | // refresh was triggered. 121 | private boolean mReturningToStart; 122 | private final DecelerateInterpolator mDecelerateInterpolator; 123 | private static final int[] LAYOUT_ATTRS = new int[]{ 124 | android.R.attr.enabled 125 | }; 126 | 127 | private CircleImageView mCircleView; 128 | private int mCircleViewIndex = -1; 129 | 130 | protected int mFrom; 131 | 132 | private float mStartingScale; 133 | 134 | protected int mOriginalOffsetTop; 135 | 136 | private MaterialProgressDrawable mProgress; 137 | 138 | private Animation mScaleAnimation; 139 | 140 | private Animation mScaleDownAnimation; 141 | 142 | private Animation mAlphaStartAnimation; 143 | 144 | private Animation mAlphaMaxAnimation; 145 | 146 | private Animation mScaleDownToStartAnimation; 147 | 148 | private float mSpinnerFinalOffset; 149 | 150 | private boolean mNotify; 151 | 152 | private int mCircleWidth; 153 | 154 | private int mCircleHeight; 155 | 156 | // Whether the client has set a custom starting position; 157 | private boolean mUsingCustomStart; 158 | 159 | private AnimationListener mRefreshListener = new AnimationListener() { 160 | @Override 161 | public void onAnimationStart(Animation animation) { 162 | } 163 | 164 | @Override 165 | public void onAnimationRepeat(Animation animation) { 166 | } 167 | 168 | @Override 169 | public void onAnimationEnd(Animation animation) { 170 | if (mRefreshing) { 171 | // Make sure the progress view is fully visible 172 | mProgress.setAlpha(MAX_ALPHA); 173 | mProgress.start(); 174 | if (mNotify) { 175 | if (mListener != null) { 176 | mListener.onRefresh(mDirection); 177 | } 178 | } 179 | } else { 180 | mProgress.stop(); 181 | mCircleView.setVisibility(View.GONE); 182 | setColorViewAlpha(MAX_ALPHA); 183 | // Return the circle to its start position 184 | if (mScale) { 185 | setAnimationProgress(0 /* animation complete and view is hidden */); 186 | } else { 187 | setTargetOffsetTopAndBottom(mOriginalOffsetTop - mCurrentTargetOffsetTop, 188 | true /* requires update */); 189 | } 190 | } 191 | mCurrentTargetOffsetTop = mCircleView.getTop(); 192 | } 193 | }; 194 | 195 | private void setColorViewAlpha(int targetAlpha) { 196 | mCircleView.getBackground().setAlpha(targetAlpha); 197 | mProgress.setAlpha(targetAlpha); 198 | } 199 | 200 | /** 201 | * The refresh indicator starting and resting position is always positioned 202 | * near the top of the refreshing content. This position is a consistent 203 | * location, but can be adjusted in either direction based on whether or not 204 | * there is a toolbar or actionbar present. 205 | * 206 | * @param scale Set to true if there is no view at a higher z-order than 207 | * where the progress spinner is set to appear. 208 | * @param start The offset in pixels from the top of this view at which the 209 | * progress spinner should appear. 210 | * @param end The offset in pixels from the top of this view at which the 211 | * progress spinner should come to rest after a successful swipe 212 | * gesture. 213 | */ 214 | /* 215 | public void setProgressViewOffset(boolean scale, int start, int end) { 216 | mScale = scale; 217 | mCircleView.setVisibility(View.GONE); 218 | mOriginalOffsetTop = mCurrentTargetOffsetTop = start; 219 | mSpinnerFinalOffset = end; 220 | mUsingCustomStart = true; 221 | mCircleView.invalidate(); 222 | }*/ 223 | 224 | /** 225 | * The refresh indicator resting position is always positioned near the top 226 | * of the refreshing content. This position is a consistent location, but 227 | * can be adjusted in either direction based on whether or not there is a 228 | * toolbar or actionbar present. 229 | * 230 | * @param scale Set to true if there is no view at a higher z-order than 231 | * where the progress spinner is set to appear. 232 | * @param end The offset in pixels from the top of this view at which the 233 | * progress spinner should come to rest after a successful swipe 234 | * gesture. 235 | */ 236 | /* 237 | public void setProgressViewEndTarget(boolean scale, int end) { 238 | mSpinnerFinalOffset = end; 239 | mScale = scale; 240 | mCircleView.invalidate(); 241 | }*/ 242 | 243 | /** 244 | * One of DEFAULT, or LARGE. 245 | */ 246 | public void setSize(int size) { 247 | if (size != MaterialProgressDrawable.LARGE && size != MaterialProgressDrawable.DEFAULT) { 248 | return; 249 | } 250 | final DisplayMetrics metrics = getResources().getDisplayMetrics(); 251 | if (size == MaterialProgressDrawable.LARGE) { 252 | mCircleHeight = mCircleWidth = (int) (CIRCLE_DIAMETER_LARGE * metrics.density); 253 | } else { 254 | mCircleHeight = mCircleWidth = (int) (CIRCLE_DIAMETER * metrics.density); 255 | } 256 | // force the bounds of the progress circle inside the circle view to 257 | // update by setting it to null before updating its size and then 258 | // re-setting it 259 | mCircleView.setImageDrawable(null); 260 | mProgress.updateSizes(size); 261 | mCircleView.setImageDrawable(mProgress); 262 | } 263 | 264 | /** 265 | * Simple constructor to use when creating a SwipeRefreshLayout from code. 266 | * 267 | * @param context 268 | */ 269 | public SwipyRefreshLayout(Context context) { 270 | this(context, null); 271 | } 272 | 273 | /** 274 | * Constructor that is called when inflating SwipeRefreshLayout from XML. 275 | * 276 | * @param context 277 | * @param attrs 278 | */ 279 | public SwipyRefreshLayout(Context context, AttributeSet attrs) { 280 | super(context, attrs); 281 | 282 | mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop(); 283 | 284 | mMediumAnimationDuration = getResources().getInteger( 285 | android.R.integer.config_mediumAnimTime); 286 | 287 | setWillNotDraw(false); 288 | mDecelerateInterpolator = new DecelerateInterpolator(DECELERATE_INTERPOLATION_FACTOR); 289 | 290 | final TypedArray a = context.obtainStyledAttributes(attrs, LAYOUT_ATTRS); 291 | setEnabled(a.getBoolean(0, true)); 292 | a.recycle(); 293 | 294 | final TypedArray a2 = context.obtainStyledAttributes(attrs, R.styleable.SwipyRefreshLayout); 295 | SwipyRefreshLayoutDirection direction 296 | = SwipyRefreshLayoutDirection.getFromInt(a2.getInt(R.styleable.SwipyRefreshLayout_srl_direction, 0)); 297 | if (direction != SwipyRefreshLayoutDirection.BOTH) { 298 | mDirection = direction; 299 | mBothDirection = false; 300 | } else { 301 | mDirection = SwipyRefreshLayoutDirection.TOP; 302 | mBothDirection = true; 303 | } 304 | a2.recycle(); 305 | 306 | final DisplayMetrics metrics = getResources().getDisplayMetrics(); 307 | mCircleWidth = (int) (CIRCLE_DIAMETER * metrics.density); 308 | mCircleHeight = (int) (CIRCLE_DIAMETER * metrics.density); 309 | 310 | createProgressView(); 311 | ViewCompat.setChildrenDrawingOrderEnabled(this, true); 312 | // the absolute offset has to take into account that the circle starts at an offset 313 | mSpinnerFinalOffset = DEFAULT_CIRCLE_TARGET * metrics.density; 314 | } 315 | 316 | protected int getChildDrawingOrder(int childCount, int i) { 317 | if (mCircleViewIndex < 0) { 318 | return i; 319 | } else if (i == childCount - 1) { 320 | // Draw the selected child last 321 | return mCircleViewIndex; 322 | } else if (i >= mCircleViewIndex) { 323 | // Move the children after the selected child earlier one 324 | return i + 1; 325 | } else { 326 | // Keep the children before the selected child the same 327 | return i; 328 | } 329 | } 330 | 331 | private void createProgressView() { 332 | mCircleView = new CircleImageView(getContext(), CIRCLE_BG_LIGHT, CIRCLE_DIAMETER / 2); 333 | mProgress = new MaterialProgressDrawable(getContext(), this); 334 | mProgress.setBackgroundColor(CIRCLE_BG_LIGHT); 335 | mCircleView.setImageDrawable(mProgress); 336 | mCircleView.setVisibility(View.GONE); 337 | addView(mCircleView); 338 | } 339 | 340 | /** 341 | * Set the listener to be notified when a refresh is triggered via the swipe 342 | * gesture. 343 | */ 344 | public void setOnRefreshListener(OnRefreshListener listener) { 345 | mListener = listener; 346 | } 347 | 348 | /** 349 | * Pre API 11, alpha is used to make the progress circle appear instead of scale. 350 | */ 351 | private boolean isAlphaUsedForScale() { 352 | return android.os.Build.VERSION.SDK_INT < 11; 353 | } 354 | 355 | /** 356 | * Notify the widget that refresh state has changed. Do not call this when 357 | * refresh is triggered by a swipe gesture. 358 | * 359 | * @param refreshing Whether or not the view should show refresh progress. 360 | */ 361 | public void setRefreshing(boolean refreshing) { 362 | if (refreshing && mRefreshing != refreshing) { 363 | // scale and show 364 | mRefreshing = refreshing; 365 | int endTarget = 0; 366 | if (!mUsingCustomStart) { 367 | switch (mDirection) { 368 | case BOTTOM: 369 | endTarget = getMeasuredHeight() - (int) (mSpinnerFinalOffset); 370 | break; 371 | case TOP: 372 | default: 373 | endTarget = (int) (mSpinnerFinalOffset - Math.abs(mOriginalOffsetTop)); 374 | break; 375 | } 376 | } else { 377 | endTarget = (int) mSpinnerFinalOffset; 378 | } 379 | setTargetOffsetTopAndBottom(endTarget - mCurrentTargetOffsetTop, 380 | true /* requires update */); 381 | mNotify = false; 382 | startScaleUpAnimation(mRefreshListener); 383 | } else { 384 | setRefreshing(refreshing, false /* notify */); 385 | } 386 | } 387 | 388 | private void startScaleUpAnimation(AnimationListener listener) { 389 | mCircleView.setVisibility(View.VISIBLE); 390 | if (android.os.Build.VERSION.SDK_INT >= 11) { 391 | // Pre API 11, alpha is used in place of scale up to show the 392 | // progress circle appearing. 393 | // Don't adjust the alpha during appearance otherwise. 394 | mProgress.setAlpha(MAX_ALPHA); 395 | } 396 | mScaleAnimation = new Animation() { 397 | @Override 398 | public void applyTransformation(float interpolatedTime, Transformation t) { 399 | setAnimationProgress(interpolatedTime); 400 | } 401 | }; 402 | mScaleAnimation.setDuration(mMediumAnimationDuration); 403 | if (listener != null) { 404 | mCircleView.setAnimationListener(listener); 405 | } 406 | mCircleView.clearAnimation(); 407 | mCircleView.startAnimation(mScaleAnimation); 408 | } 409 | 410 | /** 411 | * Pre API 11, this does an alpha animation. 412 | * 413 | * @param progress 414 | */ 415 | private void setAnimationProgress(float progress) { 416 | if (isAlphaUsedForScale()) { 417 | setColorViewAlpha((int) (progress * MAX_ALPHA)); 418 | } else { 419 | ViewCompat.setScaleX(mCircleView, progress); 420 | ViewCompat.setScaleY(mCircleView, progress); 421 | } 422 | } 423 | 424 | private void setRefreshing(boolean refreshing, final boolean notify) { 425 | if (mRefreshing != refreshing) { 426 | mNotify = notify; 427 | ensureTarget(); 428 | mRefreshing = refreshing; 429 | if (mRefreshing) { 430 | animateOffsetToCorrectPosition(mCurrentTargetOffsetTop, mRefreshListener); 431 | } else { 432 | startScaleDownAnimation(mRefreshListener); 433 | } 434 | } 435 | } 436 | 437 | private void startScaleDownAnimation(AnimationListener listener) { 438 | mScaleDownAnimation = new Animation() { 439 | @Override 440 | public void applyTransformation(float interpolatedTime, Transformation t) { 441 | setAnimationProgress(1 - interpolatedTime); 442 | } 443 | }; 444 | mScaleDownAnimation.setDuration(SCALE_DOWN_DURATION); 445 | mCircleView.setAnimationListener(listener); 446 | mCircleView.clearAnimation(); 447 | mCircleView.startAnimation(mScaleDownAnimation); 448 | } 449 | 450 | private void startProgressAlphaStartAnimation() { 451 | mAlphaStartAnimation = startAlphaAnimation(mProgress.getAlpha(), STARTING_PROGRESS_ALPHA); 452 | } 453 | 454 | private void startProgressAlphaMaxAnimation() { 455 | mAlphaMaxAnimation = startAlphaAnimation(mProgress.getAlpha(), MAX_ALPHA); 456 | } 457 | 458 | private Animation startAlphaAnimation(final int startingAlpha, final int endingAlpha) { 459 | // Pre API 11, alpha is used in place of scale. Don't also use it to 460 | // show the trigger point. 461 | if (mScale && isAlphaUsedForScale()) { 462 | return null; 463 | } 464 | Animation alpha = new Animation() { 465 | @Override 466 | public void applyTransformation(float interpolatedTime, Transformation t) { 467 | mProgress 468 | .setAlpha((int) (startingAlpha + ((endingAlpha - startingAlpha) 469 | * interpolatedTime))); 470 | } 471 | }; 472 | alpha.setDuration(ALPHA_ANIMATION_DURATION); 473 | // Clear out the previous animation listeners. 474 | mCircleView.setAnimationListener(null); 475 | mCircleView.clearAnimation(); 476 | mCircleView.startAnimation(alpha); 477 | return alpha; 478 | } 479 | 480 | /** 481 | * Set the background color of the progress spinner disc. 482 | * 483 | * @param colorRes Resource id of the color. 484 | */ 485 | public void setProgressBackgroundColor(int colorRes) { 486 | mCircleView.setBackgroundColor(colorRes); 487 | mProgress.setBackgroundColor(getResources().getColor(colorRes)); 488 | } 489 | 490 | /** 491 | * @deprecated Use {@link #setColorSchemeResources(int...)} 492 | */ 493 | @Deprecated 494 | public void setColorScheme(int... colors) { 495 | setColorSchemeResources(colors); 496 | } 497 | 498 | /** 499 | * Set the color resources used in the progress animation from color resources. 500 | * The first color will also be the color of the bar that grows in response 501 | * to a user swipe gesture. 502 | * 503 | * @param colorResIds 504 | */ 505 | public void setColorSchemeResources(int... colorResIds) { 506 | final Resources res = getResources(); 507 | int[] colorRes = new int[colorResIds.length]; 508 | for (int i = 0; i < colorResIds.length; i++) { 509 | colorRes[i] = res.getColor(colorResIds[i]); 510 | } 511 | setColorSchemeColors(colorRes); 512 | } 513 | 514 | /** 515 | * Set the colors used in the progress animation. The first 516 | * color will also be the color of the bar that grows in response to a user 517 | * swipe gesture. 518 | * 519 | * @param colors 520 | */ 521 | public void setColorSchemeColors(int... colors) { 522 | ensureTarget(); 523 | mProgress.setColorSchemeColors(colors); 524 | } 525 | 526 | /** 527 | * @return Whether the SwipeRefreshWidget is actively showing refresh 528 | * progress. 529 | */ 530 | public boolean isRefreshing() { 531 | return mRefreshing; 532 | } 533 | 534 | private void ensureTarget() { 535 | // Don't bother getting the parent height if the parent hasn't been laid 536 | // out yet. 537 | if (mTarget == null) { 538 | for (int i = 0; i < getChildCount(); i++) { 539 | View child = getChildAt(i); 540 | if (!child.equals(mCircleView)) { 541 | mTarget = child; 542 | break; 543 | } 544 | } 545 | } 546 | if (mTotalDragDistance == -1) { 547 | if (getParent() != null && ((View) getParent()).getHeight() > 0) { 548 | final DisplayMetrics metrics = getResources().getDisplayMetrics(); 549 | mTotalDragDistance = (int) Math.min( 550 | ((View) getParent()).getHeight() * MAX_SWIPE_DISTANCE_FACTOR, 551 | REFRESH_TRIGGER_DISTANCE * metrics.density); 552 | } 553 | } 554 | } 555 | 556 | /** 557 | * Set the distance to trigger a sync in dips 558 | * 559 | * @param distance 560 | */ 561 | public void setDistanceToTriggerSync(int distance) { 562 | mTotalDragDistance = distance; 563 | } 564 | 565 | @Override 566 | protected void onLayout(boolean changed, int left, int top, int right, int bottom) { 567 | final int width = getMeasuredWidth(); 568 | final int height = getMeasuredHeight(); 569 | if (getChildCount() == 0) { 570 | return; 571 | } 572 | if (mTarget == null) { 573 | ensureTarget(); 574 | } 575 | if (mTarget == null) { 576 | return; 577 | } 578 | final View child = mTarget; 579 | final int childLeft = getPaddingLeft(); 580 | final int childTop = getPaddingTop(); 581 | final int childWidth = width - getPaddingLeft() - getPaddingRight(); 582 | final int childHeight = height - getPaddingTop() - getPaddingBottom(); 583 | child.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight); 584 | int circleWidth = mCircleView.getMeasuredWidth(); 585 | int circleHeight = mCircleView.getMeasuredHeight(); 586 | mCircleView.layout((width / 2 - circleWidth / 2), mCurrentTargetOffsetTop, 587 | (width / 2 + circleWidth / 2), mCurrentTargetOffsetTop + circleHeight); 588 | } 589 | 590 | @Override 591 | public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 592 | super.onMeasure(widthMeasureSpec, heightMeasureSpec); 593 | if (mTarget == null) { 594 | ensureTarget(); 595 | } 596 | if (mTarget == null) { 597 | return; 598 | } 599 | mTarget.measure(MeasureSpec.makeMeasureSpec( 600 | getMeasuredWidth() - getPaddingLeft() - getPaddingRight(), 601 | MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec( 602 | getMeasuredHeight() - getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY)); 603 | mCircleView.measure(MeasureSpec.makeMeasureSpec(mCircleWidth, MeasureSpec.EXACTLY), 604 | MeasureSpec.makeMeasureSpec(mCircleHeight, MeasureSpec.EXACTLY)); 605 | if (!mUsingCustomStart && !mOriginalOffsetCalculated) { 606 | mOriginalOffsetCalculated = true; 607 | 608 | switch (mDirection) { 609 | case BOTTOM: 610 | mCurrentTargetOffsetTop = mOriginalOffsetTop = getMeasuredHeight(); 611 | break; 612 | case TOP: 613 | default: 614 | mCurrentTargetOffsetTop = mOriginalOffsetTop = -mCircleView.getMeasuredHeight(); 615 | break; 616 | } 617 | } 618 | mCircleViewIndex = -1; 619 | // Get the index of the circleview. 620 | for (int index = 0; index < getChildCount(); index++) { 621 | if (getChildAt(index) == mCircleView) { 622 | mCircleViewIndex = index; 623 | break; 624 | } 625 | } 626 | } 627 | 628 | /** 629 | * @return Whether it is possible for the child view of this layout to 630 | * scroll up. Override this if the child view is a custom view. 631 | */ 632 | public boolean canChildScrollUp() { 633 | if (android.os.Build.VERSION.SDK_INT < 14) { 634 | if (mTarget instanceof AbsListView) { 635 | final AbsListView absListView = (AbsListView) mTarget; 636 | return absListView.getChildCount() > 0 637 | && (absListView.getFirstVisiblePosition() > 0 || absListView.getChildAt(0) 638 | .getTop() < absListView.getPaddingTop()); 639 | } else { 640 | return mTarget.getScrollY() > 0; 641 | } 642 | } else { 643 | return ViewCompat.canScrollVertically(mTarget, -1); 644 | } 645 | } 646 | // public boolean canChildScrollUp() { 647 | // if (android.os.Build.VERSION.SDK_INT < 14) { 648 | // if (mTarget instanceof AbsListView) { 649 | // final AbsListView absListView = (AbsListView) mTarget; 650 | // if (absListView.getLastVisiblePosition() + 1 == absListView.getCount()) { 651 | // int lastIndex = absListView.getLastVisiblePosition() - absListView.getFirstVisiblePosition(); 652 | // 653 | // boolean res = absListView.getChildAt(lastIndex).getBottom() == absListView.getPaddingBottom(); 654 | // 655 | // return res; 656 | // } 657 | // return true; 658 | // } else { 659 | // return mTarget.getScrollY() > 0; 660 | // } 661 | // } else { 662 | // return ViewCompat.canScrollVertically(mTarget, 1); 663 | // } 664 | // } 665 | 666 | 667 | public boolean canChildScrollDown() { 668 | if (android.os.Build.VERSION.SDK_INT < 14) { 669 | if (mTarget instanceof AbsListView) { 670 | final AbsListView absListView = (AbsListView) mTarget; 671 | try { 672 | if (absListView.getCount() > 0) { 673 | if (absListView.getLastVisiblePosition() + 1 == absListView.getCount()) { 674 | int lastIndex = absListView.getLastVisiblePosition() - absListView.getFirstVisiblePosition(); 675 | return absListView.getChildAt(lastIndex).getBottom() == absListView.getPaddingBottom(); 676 | } 677 | } 678 | } catch (Exception e) { 679 | e.printStackTrace(); 680 | } 681 | return true; 682 | } else { 683 | return true; 684 | } 685 | } else { 686 | return ViewCompat.canScrollVertically(mTarget, 1); 687 | } 688 | } 689 | 690 | @Override 691 | public boolean onInterceptTouchEvent(MotionEvent ev) { 692 | ensureTarget(); 693 | 694 | final int action = MotionEventCompat.getActionMasked(ev); 695 | 696 | if (mReturningToStart && action == MotionEvent.ACTION_DOWN) { 697 | mReturningToStart = false; 698 | } 699 | 700 | switch (mDirection) { 701 | case BOTTOM: 702 | if (!isEnabled() || mReturningToStart || (!mBothDirection && canChildScrollDown()) || mRefreshing) { 703 | // Fail fast if we're not in a state where a swipe is possible 704 | return false; 705 | } 706 | break; 707 | case TOP: 708 | default: 709 | if (!isEnabled() || mReturningToStart || (!mBothDirection && canChildScrollUp()) || mRefreshing) { 710 | // Fail fast if we're not in a state where a swipe is possible 711 | return false; 712 | } 713 | break; 714 | } 715 | 716 | switch (action) { 717 | case MotionEvent.ACTION_DOWN: 718 | setTargetOffsetTopAndBottom(mOriginalOffsetTop - mCircleView.getTop(), true); 719 | mActivePointerId = MotionEventCompat.getPointerId(ev, 0); 720 | mIsBeingDragged = false; 721 | final float initialDownY = getMotionEventY(ev, mActivePointerId); 722 | if (initialDownY == -1) { 723 | return false; 724 | } 725 | mInitialDownY = initialDownY; 726 | 727 | case MotionEvent.ACTION_MOVE: 728 | if (mActivePointerId == INVALID_POINTER) { 729 | return false; 730 | } 731 | 732 | final float y = getMotionEventY(ev, mActivePointerId); 733 | if (y == -1) { 734 | return false; 735 | } 736 | if (mBothDirection) { 737 | if (y > mInitialDownY) { 738 | setRawDirection(SwipyRefreshLayoutDirection.TOP); 739 | } else if (y < mInitialDownY) { 740 | setRawDirection(SwipyRefreshLayoutDirection.BOTTOM); 741 | } 742 | if ((mDirection == SwipyRefreshLayoutDirection.BOTTOM && canChildScrollDown()) 743 | || (mDirection == SwipyRefreshLayoutDirection.TOP && canChildScrollUp())) { 744 | mInitialDownY = y; 745 | return false; 746 | } 747 | } 748 | float yDiff; 749 | switch (mDirection) { 750 | case BOTTOM: 751 | yDiff = mInitialDownY - y; 752 | break; 753 | case TOP: 754 | default: 755 | yDiff = y - mInitialDownY; 756 | break; 757 | } 758 | if (yDiff > mTouchSlop && !mIsBeingDragged) { 759 | switch (mDirection) { 760 | case BOTTOM: 761 | mInitialMotionY = mInitialDownY - mTouchSlop; 762 | break; 763 | case TOP: 764 | default: 765 | mInitialMotionY = mInitialDownY + mTouchSlop; 766 | break; 767 | } 768 | mIsBeingDragged = true; 769 | mProgress.setAlpha(STARTING_PROGRESS_ALPHA); 770 | } 771 | break; 772 | 773 | case MotionEventCompat.ACTION_POINTER_UP: 774 | onSecondaryPointerUp(ev); 775 | break; 776 | 777 | case MotionEvent.ACTION_UP: 778 | case MotionEvent.ACTION_CANCEL: 779 | mIsBeingDragged = false; 780 | mActivePointerId = INVALID_POINTER; 781 | break; 782 | } 783 | 784 | return mIsBeingDragged; 785 | } 786 | 787 | private float getMotionEventY(MotionEvent ev, int activePointerId) { 788 | final int index = MotionEventCompat.findPointerIndex(ev, activePointerId); 789 | if (index < 0) { 790 | return -1; 791 | } 792 | return MotionEventCompat.getY(ev, index); 793 | } 794 | 795 | @Override 796 | public void requestDisallowInterceptTouchEvent(boolean b) { 797 | // Nope. 798 | } 799 | 800 | private boolean isAnimationRunning(Animation animation) { 801 | return animation != null && animation.hasStarted() && !animation.hasEnded(); 802 | } 803 | 804 | @Override 805 | public boolean onTouchEvent(MotionEvent ev) { 806 | try { 807 | final int action = MotionEventCompat.getActionMasked(ev); 808 | 809 | if (mReturningToStart && action == MotionEvent.ACTION_DOWN) { 810 | mReturningToStart = false; 811 | } 812 | 813 | switch (mDirection) { 814 | case BOTTOM: 815 | if (!isEnabled() || mReturningToStart || canChildScrollDown() || mRefreshing) { 816 | // Fail fast if we're not in a state where a swipe is possible 817 | return false; 818 | } 819 | break; 820 | case TOP: 821 | default: 822 | if (!isEnabled() || mReturningToStart || canChildScrollUp() || mRefreshing) { 823 | // Fail fast if we're not in a state where a swipe is possible 824 | return false; 825 | } 826 | break; 827 | } 828 | 829 | switch (action) { 830 | case MotionEvent.ACTION_DOWN: 831 | mActivePointerId = MotionEventCompat.getPointerId(ev, 0); 832 | mIsBeingDragged = false; 833 | break; 834 | 835 | case MotionEvent.ACTION_MOVE: { 836 | final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId); 837 | if (pointerIndex < 0) { 838 | return false; 839 | } 840 | 841 | final float y = MotionEventCompat.getY(ev, pointerIndex); 842 | 843 | float overscrollTop; 844 | switch (mDirection) { 845 | case BOTTOM: 846 | overscrollTop = (mInitialMotionY - y) * DRAG_RATE; 847 | break; 848 | case TOP: 849 | default: 850 | overscrollTop = (y - mInitialMotionY) * DRAG_RATE; 851 | break; 852 | } 853 | if (mIsBeingDragged) { 854 | mProgress.showArrow(true); 855 | float originalDragPercent = overscrollTop / mTotalDragDistance; 856 | if (originalDragPercent < 0) { 857 | return false; 858 | } 859 | float dragPercent = Math.min(1f, Math.abs(originalDragPercent)); 860 | float adjustedPercent = (float) Math.max(dragPercent - .4, 0) * 5 / 3; 861 | float extraOS = Math.abs(overscrollTop) - mTotalDragDistance; 862 | float slingshotDist = mUsingCustomStart ? mSpinnerFinalOffset 863 | - mOriginalOffsetTop : mSpinnerFinalOffset; 864 | float tensionSlingshotPercent = Math.max(0, 865 | Math.min(extraOS, slingshotDist * 2) / slingshotDist); 866 | float tensionPercent = (float) ((tensionSlingshotPercent / 4) - Math.pow( 867 | (tensionSlingshotPercent / 4), 2)) * 2f; 868 | float extraMove = (slingshotDist) * tensionPercent * 2; 869 | 870 | // int targetY = mOriginalOffsetTop + (int) ((slingshotDist * dragPercent) + extraMove); 871 | int targetY; 872 | if (mDirection == SwipyRefreshLayoutDirection.TOP) { 873 | targetY = mOriginalOffsetTop + (int) ((slingshotDist * dragPercent) + extraMove); 874 | } else { 875 | targetY = mOriginalOffsetTop - (int) ((slingshotDist * dragPercent) + extraMove); 876 | } 877 | // where 1.0f is a full circle 878 | if (mCircleView.getVisibility() != View.VISIBLE) { 879 | mCircleView.setVisibility(View.VISIBLE); 880 | } 881 | if (!mScale) { 882 | ViewCompat.setScaleX(mCircleView, 1f); 883 | ViewCompat.setScaleY(mCircleView, 1f); 884 | } 885 | if (overscrollTop < mTotalDragDistance) { 886 | if (mScale) { 887 | setAnimationProgress(overscrollTop / mTotalDragDistance); 888 | } 889 | if (mProgress.getAlpha() > STARTING_PROGRESS_ALPHA 890 | && !isAnimationRunning(mAlphaStartAnimation)) { 891 | // Animate the alpha 892 | startProgressAlphaStartAnimation(); 893 | } 894 | float strokeStart = (float) (adjustedPercent * .8f); 895 | mProgress.setStartEndTrim(0f, Math.min(MAX_PROGRESS_ANGLE, strokeStart)); 896 | mProgress.setArrowScale(Math.min(1f, adjustedPercent)); 897 | } else { 898 | if (mProgress.getAlpha() < MAX_ALPHA 899 | && !isAnimationRunning(mAlphaMaxAnimation)) { 900 | // Animate the alpha 901 | startProgressAlphaMaxAnimation(); 902 | } 903 | } 904 | float rotation = (-0.25f + .4f * adjustedPercent + tensionPercent * 2) * .5f; 905 | mProgress.setProgressRotation(rotation); 906 | setTargetOffsetTopAndBottom(targetY - mCurrentTargetOffsetTop, 907 | true /* requires update */); 908 | } 909 | break; 910 | } 911 | case MotionEventCompat.ACTION_POINTER_DOWN: { 912 | final int index = MotionEventCompat.getActionIndex(ev); 913 | mActivePointerId = MotionEventCompat.getPointerId(ev, index); 914 | break; 915 | } 916 | 917 | case MotionEventCompat.ACTION_POINTER_UP: 918 | onSecondaryPointerUp(ev); 919 | break; 920 | 921 | case MotionEvent.ACTION_UP: 922 | case MotionEvent.ACTION_CANCEL: { 923 | if (mActivePointerId == INVALID_POINTER) { 924 | if (action == MotionEvent.ACTION_UP) { 925 | } 926 | return false; 927 | } 928 | final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId); 929 | final float y = MotionEventCompat.getY(ev, pointerIndex); 930 | 931 | float overscrollTop; 932 | switch (mDirection) { 933 | case BOTTOM: 934 | overscrollTop = (mInitialMotionY - y) * DRAG_RATE; 935 | break; 936 | case TOP: 937 | default: 938 | overscrollTop = (y - mInitialMotionY) * DRAG_RATE; 939 | break; 940 | } 941 | mIsBeingDragged = false; 942 | if (overscrollTop > mTotalDragDistance) { 943 | setRefreshing(true, true /* notify */); 944 | } else { 945 | // cancel refresh 946 | mRefreshing = false; 947 | mProgress.setStartEndTrim(0f, 0f); 948 | AnimationListener listener = null; 949 | if (!mScale) { 950 | listener = new AnimationListener() { 951 | 952 | @Override 953 | public void onAnimationStart(Animation animation) { 954 | } 955 | 956 | @Override 957 | public void onAnimationEnd(Animation animation) { 958 | if (!mScale) { 959 | startScaleDownAnimation(null); 960 | } 961 | } 962 | 963 | @Override 964 | public void onAnimationRepeat(Animation animation) { 965 | } 966 | 967 | }; 968 | } 969 | animateOffsetToStartPosition(mCurrentTargetOffsetTop, listener); 970 | mProgress.showArrow(false); 971 | } 972 | mActivePointerId = INVALID_POINTER; 973 | return false; 974 | } 975 | } 976 | } catch (Exception e) { 977 | Log.e(TAG, "An exception occured during SwipyRefreshLayout onTouchEvent " + e.toString()); 978 | } 979 | 980 | return true; 981 | } 982 | 983 | private void animateOffsetToCorrectPosition(int from, AnimationListener listener) { 984 | mFrom = from; 985 | mAnimateToCorrectPosition.reset(); 986 | mAnimateToCorrectPosition.setDuration(ANIMATE_TO_TRIGGER_DURATION); 987 | mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator); 988 | if (listener != null) { 989 | mCircleView.setAnimationListener(listener); 990 | } 991 | mCircleView.clearAnimation(); 992 | mCircleView.startAnimation(mAnimateToCorrectPosition); 993 | } 994 | 995 | private void animateOffsetToStartPosition(int from, AnimationListener listener) { 996 | if (mScale) { 997 | // Scale the item back down 998 | startScaleDownReturnToStartAnimation(from, listener); 999 | } else { 1000 | mFrom = from; 1001 | mAnimateToStartPosition.reset(); 1002 | mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION); 1003 | mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator); 1004 | if (listener != null) { 1005 | mCircleView.setAnimationListener(listener); 1006 | } 1007 | mCircleView.clearAnimation(); 1008 | mCircleView.startAnimation(mAnimateToStartPosition); 1009 | } 1010 | } 1011 | 1012 | private final Animation mAnimateToCorrectPosition = new Animation() { 1013 | @Override 1014 | public void applyTransformation(float interpolatedTime, Transformation t) { 1015 | int targetTop = 0; 1016 | int endTarget = 0; 1017 | if (!mUsingCustomStart) { 1018 | switch (mDirection) { 1019 | case BOTTOM: 1020 | endTarget = getMeasuredHeight() - (int) (mSpinnerFinalOffset); 1021 | break; 1022 | case TOP: 1023 | default: 1024 | endTarget = (int) (mSpinnerFinalOffset - Math.abs(mOriginalOffsetTop)); 1025 | break; 1026 | } 1027 | } else { 1028 | endTarget = (int) mSpinnerFinalOffset; 1029 | } 1030 | targetTop = (mFrom + (int) ((endTarget - mFrom) * interpolatedTime)); 1031 | int offset = targetTop - mCircleView.getTop(); 1032 | setTargetOffsetTopAndBottom(offset, false /* requires update */); 1033 | } 1034 | }; 1035 | 1036 | private void moveToStart(float interpolatedTime) { 1037 | int targetTop = 0; 1038 | targetTop = (mFrom + (int) ((mOriginalOffsetTop - mFrom) * interpolatedTime)); 1039 | int offset = targetTop - mCircleView.getTop(); 1040 | setTargetOffsetTopAndBottom(offset, false /* requires update */); 1041 | } 1042 | 1043 | private final Animation mAnimateToStartPosition = new Animation() { 1044 | @Override 1045 | public void applyTransformation(float interpolatedTime, Transformation t) { 1046 | moveToStart(interpolatedTime); 1047 | } 1048 | }; 1049 | 1050 | private void startScaleDownReturnToStartAnimation(int from, 1051 | AnimationListener listener) { 1052 | mFrom = from; 1053 | if (isAlphaUsedForScale()) { 1054 | mStartingScale = mProgress.getAlpha(); 1055 | } else { 1056 | mStartingScale = ViewCompat.getScaleX(mCircleView); 1057 | } 1058 | mScaleDownToStartAnimation = new Animation() { 1059 | @Override 1060 | public void applyTransformation(float interpolatedTime, Transformation t) { 1061 | float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime)); 1062 | setAnimationProgress(targetScale); 1063 | moveToStart(interpolatedTime); 1064 | } 1065 | }; 1066 | mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION); 1067 | if (listener != null) { 1068 | mCircleView.setAnimationListener(listener); 1069 | } 1070 | mCircleView.clearAnimation(); 1071 | mCircleView.startAnimation(mScaleDownToStartAnimation); 1072 | } 1073 | 1074 | private void setTargetOffsetTopAndBottom(int offset, boolean requiresUpdate) { 1075 | mCircleView.bringToFront(); 1076 | mCircleView.offsetTopAndBottom(offset); 1077 | 1078 | // switch (mDirection) { 1079 | // case BOTTOM: 1080 | // mCurrentTargetOffsetTop = getMeasuredHeight() - mCircleView.getMeasuredHeight(); 1081 | // break; 1082 | // case TOP: 1083 | // default: 1084 | // mCurrentTargetOffsetTop = mCircleView.getTop(); 1085 | // break; 1086 | // } 1087 | mCurrentTargetOffsetTop = mCircleView.getTop(); 1088 | if (requiresUpdate && android.os.Build.VERSION.SDK_INT < 11) { 1089 | invalidate(); 1090 | } 1091 | } 1092 | 1093 | private void onSecondaryPointerUp(MotionEvent ev) { 1094 | final int pointerIndex = MotionEventCompat.getActionIndex(ev); 1095 | final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex); 1096 | if (pointerId == mActivePointerId) { 1097 | // This was our active pointer going up. Choose a new 1098 | // active pointer and adjust accordingly. 1099 | final int newPointerIndex = pointerIndex == 0 ? 1 : 0; 1100 | mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex); 1101 | } 1102 | } 1103 | 1104 | /** 1105 | * Classes that wish to be notified when the swipe gesture correctly 1106 | * triggers a refresh should implement this interface. 1107 | */ 1108 | public interface OnRefreshListener { 1109 | public void onRefresh(SwipyRefreshLayoutDirection direction); 1110 | } 1111 | 1112 | public SwipyRefreshLayoutDirection getDirection() { 1113 | return mBothDirection ? SwipyRefreshLayoutDirection.BOTH : mDirection; 1114 | } 1115 | 1116 | public void setDirection(SwipyRefreshLayoutDirection direction) { 1117 | if (direction == SwipyRefreshLayoutDirection.BOTH) { 1118 | mBothDirection = true; 1119 | } else { 1120 | mBothDirection = false; 1121 | mDirection = direction; 1122 | } 1123 | 1124 | switch (mDirection) { 1125 | case BOTTOM: 1126 | mCurrentTargetOffsetTop = mOriginalOffsetTop = getMeasuredHeight(); 1127 | break; 1128 | case TOP: 1129 | default: 1130 | mCurrentTargetOffsetTop = mOriginalOffsetTop = -mCircleView.getMeasuredHeight(); 1131 | break; 1132 | } 1133 | } 1134 | 1135 | // only TOP or Bottom 1136 | private void setRawDirection(SwipyRefreshLayoutDirection direction) { 1137 | if (mDirection == direction) { 1138 | return; 1139 | } 1140 | 1141 | mDirection = direction; 1142 | switch (mDirection) { 1143 | case BOTTOM: 1144 | mCurrentTargetOffsetTop = mOriginalOffsetTop = getMeasuredHeight(); 1145 | break; 1146 | case TOP: 1147 | default: 1148 | mCurrentTargetOffsetTop = mOriginalOffsetTop = -mCircleView.getMeasuredHeight(); 1149 | break; 1150 | } 1151 | } 1152 | 1153 | public CircleImageView getCircleView() { 1154 | return mCircleView; 1155 | } 1156 | } 1157 | --------------------------------------------------------------------------------