aboutsummaryrefslogtreecommitdiffstats
path: root/libs/SwipyRefreshLayout
diff options
context:
space:
mode:
authorsteckbrief <steckbrief@chefmail.de>2015-12-04 23:19:33 +0100
committersteckbrief <steckbrief@chefmail.de>2015-12-04 23:19:33 +0100
commit734511b0fa15fa6ceb88c6b0ab4791139f7ffc8d (patch)
treeae49823ebe987a260a7432292700a5918b26953e /libs/SwipyRefreshLayout
parent9265d6718e83e2d8d29809cbec4f8fb1f3a29960 (diff)
parent0086d5dc80dd95b1e8e4dcfe2d3d3090d260bb88 (diff)
Merge remote-tracking branch 'remotes/origin/trz/rename' into trz/rebase
Diffstat (limited to 'libs/SwipyRefreshLayout')
-rw-r--r--libs/SwipyRefreshLayout/.gitignore1
-rw-r--r--libs/SwipyRefreshLayout/build.gradle24
-rw-r--r--libs/SwipyRefreshLayout/proguard-rules.pro17
-rw-r--r--libs/SwipyRefreshLayout/src/main/AndroidManifest.xml8
-rw-r--r--libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/CircleImageView.java149
-rw-r--r--libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/MaterialProgressDrawable.java722
-rw-r--r--libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayout.java1152
-rw-r--r--libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayoutDirection.java27
-rw-r--r--libs/SwipyRefreshLayout/src/main/res/values/attrs.xml12
9 files changed, 2112 insertions, 0 deletions
diff --git a/libs/SwipyRefreshLayout/.gitignore b/libs/SwipyRefreshLayout/.gitignore
new file mode 100644
index 00000000..796b96d1
--- /dev/null
+++ b/libs/SwipyRefreshLayout/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/libs/SwipyRefreshLayout/build.gradle b/libs/SwipyRefreshLayout/build.gradle
new file mode 100644
index 00000000..68a75ec9
--- /dev/null
+++ b/libs/SwipyRefreshLayout/build.gradle
@@ -0,0 +1,24 @@
+apply plugin: 'com.android.library'
+
+android {
+ compileSdkVersion 22
+ buildToolsVersion "22.0.1"
+
+ defaultConfig {
+ minSdkVersion 9
+ targetSdkVersion 22
+ versionCode 1
+ versionName "1.2.1"
+ }
+ buildTypes {
+ release {
+ minifyEnabled false
+ proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+ }
+ }
+}
+
+dependencies {
+ compile fileTree(dir: 'libs', include: ['*.jar'])
+ compile 'com.android.support:appcompat-v7:22.0.+'
+}
diff --git a/libs/SwipyRefreshLayout/proguard-rules.pro b/libs/SwipyRefreshLayout/proguard-rules.pro
new file mode 100644
index 00000000..7c07ec21
--- /dev/null
+++ b/libs/SwipyRefreshLayout/proguard-rules.pro
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /Users/oliviergoutay/Documents/sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
diff --git a/libs/SwipyRefreshLayout/src/main/AndroidManifest.xml b/libs/SwipyRefreshLayout/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..a2916954
--- /dev/null
+++ b/libs/SwipyRefreshLayout/src/main/AndroidManifest.xml
@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.orangegangsters.github.swipyrefreshlayout.library">
+
+ <application android:allowBackup="true">
+
+ </application>
+
+</manifest>
diff --git a/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/CircleImageView.java b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/CircleImageView.java
new file mode 100644
index 00000000..2609655b
--- /dev/null
+++ b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/CircleImageView.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.orangegangsters.github.swipyrefreshlayout.library;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.RadialGradient;
+import android.graphics.Shader;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.OvalShape;
+import android.support.v4.view.ViewCompat;
+import android.view.animation.Animation;
+import android.widget.ImageView;
+
+/**
+ * Private class created to work around issues with AnimationListeners being
+ * called before the animation is actually complete and support shadows on older
+ * platforms.
+ *
+ * @hide
+ */
+class CircleImageView extends ImageView {
+
+ private static final int KEY_SHADOW_COLOR = 0x1E000000;
+ private static final int FILL_SHADOW_COLOR = 0x3D000000;
+ // PX
+ private static final float X_OFFSET = 0f;
+ private static final float Y_OFFSET = 1.75f;
+ private static final float SHADOW_RADIUS = 3.5f;
+ private static final int SHADOW_ELEVATION = 4;
+
+ private Animation.AnimationListener mListener;
+ private int mShadowRadius;
+
+ public CircleImageView(Context context, int color, final float radius) {
+ super(context);
+ final float density = getContext().getResources().getDisplayMetrics().density;
+ final int diameter = (int) (radius * density * 2);
+ final int shadowYOffset = (int) (density * Y_OFFSET);
+ final int shadowXOffset = (int) (density * X_OFFSET);
+
+ mShadowRadius = (int) (density * SHADOW_RADIUS);
+
+ ShapeDrawable circle;
+ if (elevationSupported()) {
+ circle = new ShapeDrawable(new OvalShape());
+ ViewCompat.setElevation(this, SHADOW_ELEVATION * density);
+ } else {
+ OvalShape oval = new OvalShadow(mShadowRadius, diameter);
+ circle = new ShapeDrawable(oval);
+ ViewCompat.setLayerType(this, ViewCompat.LAYER_TYPE_SOFTWARE, circle.getPaint());
+ circle.getPaint().setShadowLayer(mShadowRadius, shadowXOffset, shadowYOffset,
+ KEY_SHADOW_COLOR);
+ final int padding = (int) mShadowRadius;
+ // set padding so the inner image sits correctly within the shadow.
+ setPadding(padding, padding, padding, padding);
+ }
+ circle.getPaint().setColor(color);
+ setBackgroundDrawable(circle);
+ }
+
+ private boolean elevationSupported() {
+ return android.os.Build.VERSION.SDK_INT >= 21;
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+ if (!elevationSupported()) {
+ setMeasuredDimension(getMeasuredWidth() + mShadowRadius*2, getMeasuredHeight()
+ + mShadowRadius*2);
+ }
+ }
+
+ public void setAnimationListener(Animation.AnimationListener listener) {
+ mListener = listener;
+ }
+
+ @Override
+ public void onAnimationStart() {
+ super.onAnimationStart();
+ if (mListener != null) {
+ mListener.onAnimationStart(getAnimation());
+ }
+ }
+
+ @Override
+ public void onAnimationEnd() {
+ super.onAnimationEnd();
+ if (mListener != null) {
+ mListener.onAnimationEnd(getAnimation());
+ }
+ }
+
+ /**
+ * Update the background color of the circle image view.
+ */
+ public void setBackgroundColor(int colorRes) {
+ if (getBackground() instanceof ShapeDrawable) {
+ final Resources res = getResources();
+ ((ShapeDrawable) getBackground()).getPaint().setColor(res.getColor(colorRes));
+ }
+ }
+
+ private class OvalShadow extends OvalShape {
+ private RadialGradient mRadialGradient;
+ private int mShadowRadius;
+ private Paint mShadowPaint;
+ private int mCircleDiameter;
+
+ public OvalShadow(int shadowRadius, int circleDiameter) {
+ super();
+ mShadowPaint = new Paint();
+ mShadowRadius = shadowRadius;
+ mCircleDiameter = circleDiameter;
+ mRadialGradient = new RadialGradient(mCircleDiameter / 2, mCircleDiameter / 2,
+ mShadowRadius, new int[] {
+ FILL_SHADOW_COLOR, Color.TRANSPARENT
+ }, null, Shader.TileMode.CLAMP);
+ mShadowPaint.setShader(mRadialGradient);
+ }
+
+ @Override
+ public void draw(Canvas canvas, Paint paint) {
+ final int viewWidth = CircleImageView.this.getWidth();
+ final int viewHeight = CircleImageView.this.getHeight();
+ canvas.drawCircle(viewWidth / 2, viewHeight / 2, (mCircleDiameter / 2 + mShadowRadius),
+ mShadowPaint);
+ canvas.drawCircle(viewWidth / 2, viewHeight / 2, (mCircleDiameter / 2), paint);
+ }
+ }
+}
diff --git a/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/MaterialProgressDrawable.java b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/MaterialProgressDrawable.java
new file mode 100644
index 00000000..c7eef8c1
--- /dev/null
+++ b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/MaterialProgressDrawable.java
@@ -0,0 +1,722 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.orangegangsters.github.swipyrefreshlayout.library;
+
+import android.view.animation.AccelerateDecelerateInterpolator;
+import android.view.animation.Interpolator;
+import android.view.animation.Animation;
+import android.view.animation.LinearInterpolator;
+import android.view.animation.Transformation;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.Paint.Style;
+import android.graphics.Path;
+import android.graphics.PixelFormat;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.Animatable;
+import android.support.annotation.IntDef;
+import android.support.annotation.NonNull;
+import android.util.DisplayMetrics;
+import android.view.View;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+
+/**
+ * Fancy progress indicator for Material theme.
+ *
+ * @hide
+ */
+class MaterialProgressDrawable extends Drawable implements Animatable {
+ private static final Interpolator LINEAR_INTERPOLATOR = new LinearInterpolator();
+ private static final Interpolator END_CURVE_INTERPOLATOR = new EndCurveInterpolator();
+ private static final Interpolator START_CURVE_INTERPOLATOR = new StartCurveInterpolator();
+ private static final Interpolator EASE_INTERPOLATOR = new AccelerateDecelerateInterpolator();
+
+ @Retention(RetentionPolicy.CLASS)
+ @IntDef({LARGE, DEFAULT})
+ public @interface ProgressDrawableSize {}
+ // Maps to ProgressBar.Large style
+ static final int LARGE = 0;
+ // Maps to ProgressBar default style
+ static final int DEFAULT = 1;
+
+ // Maps to ProgressBar default style
+ private static final int CIRCLE_DIAMETER = 40;
+ private static final float CENTER_RADIUS = 8.75f; //should add up to 10 when + stroke_width
+ private static final float STROKE_WIDTH = 2.5f;
+
+ // Maps to ProgressBar.Large style
+ private static final int CIRCLE_DIAMETER_LARGE = 56;
+ private static final float CENTER_RADIUS_LARGE = 12.5f;
+ private static final float STROKE_WIDTH_LARGE = 3f;
+
+ private final int[] COLORS = new int[] {
+ Color.BLACK
+ };
+
+ /** The duration of a single progress spin in milliseconds. */
+ private static final int ANIMATION_DURATION = 1000 * 80 / 60;
+
+ /** The number of points in the progress "star". */
+ private static final float NUM_POINTS = 5f;
+ /** The list of animators operating on this drawable. */
+ private final ArrayList<Animation> mAnimators = new ArrayList<Animation>();
+
+ /** The indicator ring, used to manage animation state. */
+ private final Ring mRing;
+
+ /** Canvas rotation in degrees. */
+ private float mRotation;
+
+ /** Layout info for the arrowhead in dp */
+ private static final int ARROW_WIDTH = 10;
+ private static final int ARROW_HEIGHT = 5;
+ private static final float ARROW_OFFSET_ANGLE = 5;
+
+ /** Layout info for the arrowhead for the large spinner in dp */
+ private static final int ARROW_WIDTH_LARGE = 12;
+ private static final int ARROW_HEIGHT_LARGE = 6;
+ private static final float MAX_PROGRESS_ARC = .8f;
+
+ private Resources mResources;
+ private View mParent;
+ private Animation mAnimation;
+ private float mRotationCount;
+ private double mWidth;
+ private double mHeight;
+ private Animation mFinishAnimation;
+
+ public MaterialProgressDrawable(Context context, View parent) {
+ mParent = parent;
+ mResources = context.getResources();
+
+ mRing = new Ring(mCallback);
+ mRing.setColors(COLORS);
+
+ updateSizes(DEFAULT);
+ setupAnimators();
+ }
+
+ private void setSizeParameters(double progressCircleWidth, double progressCircleHeight,
+ double centerRadius, double strokeWidth, float arrowWidth, float arrowHeight) {
+ final Ring ring = mRing;
+ final DisplayMetrics metrics = mResources.getDisplayMetrics();
+ final float screenDensity = metrics.density;
+
+ mWidth = progressCircleWidth * screenDensity;
+ mHeight = progressCircleHeight * screenDensity;
+ ring.setStrokeWidth((float) strokeWidth * screenDensity);
+ ring.setCenterRadius(centerRadius * screenDensity);
+ ring.setColorIndex(0);
+ ring.setArrowDimensions(arrowWidth * screenDensity, arrowHeight * screenDensity);
+ ring.setInsets((int) mWidth, (int) mHeight);
+ }
+
+ /**
+ * Set the overall size for the progress spinner. This updates the radius
+ * and stroke width of the ring.
+ *
+ * @param size One of {@link com.orangegangsters.github.swiperefreshlayout.MaterialProgressDrawable.LARGE} or
+ * {@link com.orangegangsters.github.swiperefreshlayout.MaterialProgressDrawable.DEFAULT}
+ */
+ public void updateSizes(@ProgressDrawableSize int size) {
+ if (size == LARGE) {
+ setSizeParameters(CIRCLE_DIAMETER_LARGE, CIRCLE_DIAMETER_LARGE, CENTER_RADIUS_LARGE,
+ STROKE_WIDTH_LARGE, ARROW_WIDTH_LARGE, ARROW_HEIGHT_LARGE);
+ } else {
+ setSizeParameters(CIRCLE_DIAMETER, CIRCLE_DIAMETER, CENTER_RADIUS, STROKE_WIDTH,
+ ARROW_WIDTH, ARROW_HEIGHT);
+ }
+ }
+
+ /**
+ * @param show Set to true to display the arrowhead on the progress spinner.
+ */
+ public void showArrow(boolean show) {
+ mRing.setShowArrow(show);
+ }
+
+ /**
+ * @param scale Set the scale of the arrowhead for the spinner.
+ */
+ public void setArrowScale(float scale) {
+ mRing.setArrowScale(scale);
+ }
+
+ /**
+ * Set the start and end trim for the progress spinner arc.
+ *
+ * @param startAngle start angle
+ * @param endAngle end angle
+ */
+ public void setStartEndTrim(float startAngle, float endAngle) {
+ mRing.setStartTrim(startAngle);
+ mRing.setEndTrim(endAngle);
+ }
+
+ /**
+ * Set the amount of rotation to apply to the progress spinner.
+ *
+ * @param rotation Rotation is from [0..1]
+ */
+ public void setProgressRotation(float rotation) {
+ mRing.setRotation(rotation);
+ }
+
+ /**
+ * Update the background color of the circle image view.
+ */
+ public void setBackgroundColor(int color) {
+ mRing.setBackgroundColor(color);
+ }
+
+ /**
+ * Set the colors used in the progress animation from color resources.
+ * The first color will also be the color of the bar that grows in response
+ * to a user swipe gesture.
+ *
+ * @param colors
+ */
+ public void setColorSchemeColors(int... colors) {
+ mRing.setColors(colors);
+ mRing.setColorIndex(0);
+ }
+
+ @Override
+ public int getIntrinsicHeight() {
+ return (int) mHeight;
+ }
+
+ @Override
+ public int getIntrinsicWidth() {
+ return (int) mWidth;
+ }
+
+ @Override
+ public void draw(Canvas c) {
+ final Rect bounds = getBounds();
+ final int saveCount = c.save();
+ c.rotate(mRotation, bounds.exactCenterX(), bounds.exactCenterY());
+ mRing.draw(c, bounds);
+ c.restoreToCount(saveCount);
+ }
+
+ @Override
+ public void setAlpha(int alpha) {
+ mRing.setAlpha(alpha);
+ }
+
+ public int getAlpha() {
+ return mRing.getAlpha();
+ }
+
+ @Override
+ public void setColorFilter(ColorFilter colorFilter) {
+ mRing.setColorFilter(colorFilter);
+ }
+
+ @SuppressWarnings("unused")
+ void setRotation(float rotation) {
+ mRotation = rotation;
+ invalidateSelf();
+ }
+
+ @SuppressWarnings("unused")
+ private float getRotation() {
+ return mRotation;
+ }
+
+ @Override
+ public int getOpacity() {
+ return PixelFormat.TRANSLUCENT;
+ }
+
+ @Override
+ public boolean isRunning() {
+ final ArrayList<Animation> animators = mAnimators;
+ final int N = animators.size();
+ for (int i = 0; i < N; i++) {
+ final Animation animator = animators.get(i);
+ if (animator.hasStarted() && !animator.hasEnded()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public void start() {
+ mAnimation.reset();
+ mRing.storeOriginals();
+ // Already showing some part of the ring
+ if (mRing.getEndTrim() != mRing.getStartTrim()) {
+ mParent.startAnimation(mFinishAnimation);
+ } else {
+ mRing.setColorIndex(0);
+ mRing.resetOriginals();
+ mParent.startAnimation(mAnimation);
+ }
+ }
+
+ @Override
+ public void stop() {
+ mParent.clearAnimation();
+ setRotation(0);
+ mRing.setShowArrow(false);
+ mRing.setColorIndex(0);
+ mRing.resetOriginals();
+ }
+
+ private void setupAnimators() {
+ final Ring ring = mRing;
+ final Animation finishRingAnimation = new Animation() {
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ // shrink back down and complete a full rotation before starting other circles
+ // Rotation goes between [0..1].
+ float targetRotation = (float) (Math.floor(ring.getStartingRotation()
+ / MAX_PROGRESS_ARC) + 1f);
+ final float startTrim = ring.getStartingStartTrim()
+ + (ring.getStartingEndTrim() - ring.getStartingStartTrim())
+ * interpolatedTime;
+ ring.setStartTrim(startTrim);
+ final float rotation = ring.getStartingRotation()
+ + ((targetRotation - ring.getStartingRotation()) * interpolatedTime);
+ ring.setRotation(rotation);
+ ring.setArrowScale(1 - interpolatedTime);
+ }
+ };
+ finishRingAnimation.setInterpolator(EASE_INTERPOLATOR);
+ finishRingAnimation.setDuration(ANIMATION_DURATION/2);
+ finishRingAnimation.setAnimationListener(new Animation.AnimationListener() {
+
+ @Override
+ public void onAnimationStart(Animation animation) {
+ }
+
+ @Override
+ public void onAnimationEnd(Animation animation) {
+ ring.goToNextColor();
+ ring.storeOriginals();
+ ring.setShowArrow(false);
+ mParent.startAnimation(mAnimation);
+ }
+
+ @Override
+ public void onAnimationRepeat(Animation animation) {
+ }
+ });
+ final Animation animation = new Animation() {
+ @Override
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ // The minProgressArc is calculated from 0 to create an angle that
+ // matches the stroke width.
+ final float minProgressArc = (float) Math.toRadians(ring.getStrokeWidth()
+ / (2 * Math.PI * ring.getCenterRadius()));
+ final float startingEndTrim = ring.getStartingEndTrim();
+ final float startingTrim = ring.getStartingStartTrim();
+ final float startingRotation = ring.getStartingRotation();
+
+ // Offset the minProgressArc to where the endTrim is located.
+ final float minArc = MAX_PROGRESS_ARC - minProgressArc;
+ final float endTrim = startingEndTrim
+ + (minArc * START_CURVE_INTERPOLATOR.getInterpolation(interpolatedTime));
+ ring.setEndTrim(endTrim);
+
+ final float startTrim = startingTrim
+ + (MAX_PROGRESS_ARC * END_CURVE_INTERPOLATOR
+ .getInterpolation(interpolatedTime));
+ ring.setStartTrim(startTrim);
+
+ final float rotation = startingRotation + (0.25f * interpolatedTime);
+ ring.setRotation(rotation);
+
+ float groupRotation = ((720.0f / NUM_POINTS) * interpolatedTime)
+ + (720.0f * (mRotationCount / NUM_POINTS));
+ setRotation(groupRotation);
+ }
+ };
+ animation.setRepeatCount(Animation.INFINITE);
+ animation.setRepeatMode(Animation.RESTART);
+ animation.setInterpolator(LINEAR_INTERPOLATOR);
+ animation.setDuration(ANIMATION_DURATION);
+ animation.setAnimationListener(new Animation.AnimationListener() {
+
+ @Override
+ public void onAnimationStart(Animation animation) {
+ mRotationCount = 0;
+ }
+
+ @Override
+ public void onAnimationEnd(Animation animation) {
+ // do nothing
+ }
+
+ @Override
+ public void onAnimationRepeat(Animation animation) {
+ ring.storeOriginals();
+ ring.goToNextColor();
+ ring.setStartTrim(ring.getEndTrim());
+ mRotationCount = (mRotationCount + 1) % (NUM_POINTS);
+ }
+ });
+ mFinishAnimation = finishRingAnimation;
+ mAnimation = animation;
+ }
+
+ private final Callback mCallback = new Callback() {
+ @Override
+ public void invalidateDrawable(Drawable d) {
+ invalidateSelf();
+ }
+
+ @Override
+ public void scheduleDrawable(Drawable d, Runnable what, long when) {
+ scheduleSelf(what, when);
+ }
+
+ @Override
+ public void unscheduleDrawable(Drawable d, Runnable what) {
+ unscheduleSelf(what);
+ }
+ };
+
+ private static class Ring {
+ private final RectF mTempBounds = new RectF();
+ private final Paint mPaint = new Paint();
+ private final Paint mArrowPaint = new Paint();
+
+ private final Callback mCallback;
+
+ private float mStartTrim = 0.0f;
+ private float mEndTrim = 0.0f;
+ private float mRotation = 0.0f;
+ private float mStrokeWidth = 5.0f;
+ private float mStrokeInset = 2.5f;
+
+ private int[] mColors;
+ // mColorIndex represents the offset into the available mColors that the
+ // progress circle should currently display. As the progress circle is
+ // animating, the mColorIndex moves by one to the next available color.
+ private int mColorIndex;
+ private float mStartingStartTrim;
+ private float mStartingEndTrim;
+ private float mStartingRotation;
+ private boolean mShowArrow;
+ private Path mArrow;
+ private float mArrowScale;
+ private double mRingCenterRadius;
+ private int mArrowWidth;
+ private int mArrowHeight;
+ private int mAlpha;
+ private final Paint mCirclePaint = new Paint();
+ private int mBackgroundColor;
+
+ public Ring(Callback callback) {
+ mCallback = callback;
+
+ mPaint.setStrokeCap(Paint.Cap.SQUARE);
+ mPaint.setAntiAlias(true);
+ mPaint.setStyle(Style.STROKE);
+
+ mArrowPaint.setStyle(Style.FILL);
+ mArrowPaint.setAntiAlias(true);
+ }
+
+ public void setBackgroundColor(int color) {
+ mBackgroundColor = color;
+ }
+
+ /**
+ * Set the dimensions of the arrowhead.
+ *
+ * @param width Width of the hypotenuse of the arrow head
+ * @param height Height of the arrow point
+ */
+ public void setArrowDimensions(float width, float height) {
+ mArrowWidth = (int) width;
+ mArrowHeight = (int) height;
+ }
+
+ /**
+ * Draw the progress spinner
+ */
+ public void draw(Canvas c, Rect bounds) {
+ final RectF arcBounds = mTempBounds;
+ arcBounds.set(bounds);
+ arcBounds.inset(mStrokeInset, mStrokeInset);
+
+ final float startAngle = (mStartTrim + mRotation) * 360;
+ final float endAngle = (mEndTrim + mRotation) * 360;
+ float sweepAngle = endAngle - startAngle;
+
+ mPaint.setColor(mColors[mColorIndex]);
+ c.drawArc(arcBounds, startAngle, sweepAngle, false, mPaint);
+
+ drawTriangle(c, startAngle, sweepAngle, bounds);
+
+ if (mAlpha < 255) {
+ mCirclePaint.setColor(mBackgroundColor);
+ mCirclePaint.setAlpha(255 - mAlpha);
+ c.drawCircle(bounds.exactCenterX(), bounds.exactCenterY(), bounds.width() / 2,
+ mCirclePaint);
+ }
+ }
+
+ private void drawTriangle(Canvas c, float startAngle, float sweepAngle, Rect bounds) {
+ if (mShowArrow) {
+ if (mArrow == null) {
+ mArrow = new Path();
+ mArrow.setFillType(Path.FillType.EVEN_ODD);
+ } else {
+ mArrow.reset();
+ }
+
+ // Adjust the position of the triangle so that it is inset as
+ // much as the arc, but also centered on the arc.
+ float inset = (int) mStrokeInset / 2 * mArrowScale;
+ float x = (float) (mRingCenterRadius * Math.cos(0) + bounds.exactCenterX());
+ float y = (float) (mRingCenterRadius * Math.sin(0) + bounds.exactCenterY());
+
+ // Update the path each time. This works around an issue in SKIA
+ // where concatenating a rotation matrix to a scale matrix
+ // ignored a starting negative rotation. This appears to have
+ // been fixed as of API 21.
+ mArrow.moveTo(0, 0);
+ mArrow.lineTo(mArrowWidth * mArrowScale, 0);
+ mArrow.lineTo((mArrowWidth * mArrowScale / 2), (mArrowHeight
+ * mArrowScale));
+ mArrow.offset(x - inset, y);
+ mArrow.close();
+ // draw a triangle
+ mArrowPaint.setColor(mColors[mColorIndex]);
+ c.rotate(startAngle + sweepAngle - ARROW_OFFSET_ANGLE, bounds.exactCenterX(),
+ bounds.exactCenterY());
+ c.drawPath(mArrow, mArrowPaint);
+ }
+ }
+
+ /**
+ * Set the colors the progress spinner alternates between.
+ *
+ * @param colors Array of integers describing the colors. Must be non-<code>null</code>.
+ */
+ public void setColors(@NonNull int[] colors) {
+ mColors = colors;
+ // if colors are reset, make sure to reset the color index as well
+ setColorIndex(0);
+ }
+
+ /**
+ * @param index Index into the color array of the color to display in
+ * the progress spinner.
+ */
+ public void setColorIndex(int index) {
+ mColorIndex = index;
+ }
+
+ /**
+ * Proceed to the next available ring color. This will automatically
+ * wrap back to the beginning of colors.
+ */
+ public void goToNextColor() {
+ mColorIndex = (mColorIndex + 1) % (mColors.length);
+ }
+
+ public void setColorFilter(ColorFilter filter) {
+ mPaint.setColorFilter(filter);
+ invalidateSelf();
+ }
+
+ /**
+ * @param alpha Set the alpha of the progress spinner and associated arrowhead.
+ */
+ public void setAlpha(int alpha) {
+ mAlpha = alpha;
+ }
+
+ /**
+ * @return Current alpha of the progress spinner and arrowhead.
+ */
+ public int getAlpha() {
+ return mAlpha;
+ }
+
+ /**
+ * @param strokeWidth Set the stroke width of the progress spinner in pixels.
+ */
+ public void setStrokeWidth(float strokeWidth) {
+ mStrokeWidth = strokeWidth;
+ mPaint.setStrokeWidth(strokeWidth);
+ invalidateSelf();
+ }
+
+ @SuppressWarnings("unused")
+ public float getStrokeWidth() {
+ return mStrokeWidth;
+ }
+
+ @SuppressWarnings("unused")
+ public void setStartTrim(float startTrim) {
+ mStartTrim = startTrim;
+ invalidateSelf();
+ }
+
+ @SuppressWarnings("unused")
+ public float getStartTrim() {
+ return mStartTrim;
+ }
+
+ public float getStartingStartTrim() {
+ return mStartingStartTrim;
+ }
+
+ public float getStartingEndTrim() {
+ return mStartingEndTrim;
+ }
+
+ @SuppressWarnings("unused")
+ public void setEndTrim(float endTrim) {
+ mEndTrim = endTrim;
+ invalidateSelf();
+ }
+
+ @SuppressWarnings("unused")
+ public float getEndTrim() {
+ return mEndTrim;
+ }
+
+ @SuppressWarnings("unused")
+ public void setRotation(float rotation) {
+ mRotation = rotation;
+ invalidateSelf();
+ }
+
+ @SuppressWarnings("unused")
+ public float getRotation() {
+ return mRotation;
+ }
+
+ public void setInsets(int width, int height) {
+ final float minEdge = (float) Math.min(width, height);
+ float insets;
+ if (mRingCenterRadius <= 0 || minEdge < 0) {
+ insets = (float) Math.ceil(mStrokeWidth / 2.0f);
+ } else {
+ insets = (float) (minEdge / 2.0f - mRingCenterRadius);
+ }
+ mStrokeInset = insets;
+ }
+
+ @SuppressWarnings("unused")
+ public float getInsets() {
+ return mStrokeInset;
+ }
+
+ /**
+ * @param centerRadius Inner radius in px of the circle the progress
+ * spinner arc traces.
+ */
+ public void setCenterRadius(double centerRadius) {
+ mRingCenterRadius = centerRadius;
+ }
+
+ public double getCenterRadius() {
+ return mRingCenterRadius;
+ }
+
+ /**
+ * @param show Set to true to show the arrow head on the progress spinner.
+ */
+ public void setShowArrow(boolean show) {
+ if (mShowArrow != show) {
+ mShowArrow = show;
+ invalidateSelf();
+ }
+ }
+
+ /**
+ * @param scale Set the scale of the arrowhead for the spinner.
+ */
+ public void setArrowScale(float scale) {
+ if (scale != mArrowScale) {
+ mArrowScale = scale;
+ invalidateSelf();
+ }
+ }
+
+ /**
+ * @return The amount the progress spinner is currently rotated, between [0..1].
+ */
+ public float getStartingRotation() {
+ return mStartingRotation;
+ }
+
+ /**
+ * If the start / end trim are offset to begin with, store them so that
+ * animation starts from that offset.
+ */
+ public void storeOriginals() {
+ mStartingStartTrim = mStartTrim;
+ mStartingEndTrim = mEndTrim;
+ mStartingRotation = mRotation;
+ }
+
+ /**
+ * Reset the progress spinner to default rotation, start and end angles.
+ */
+ public void resetOriginals() {
+ mStartingStartTrim = 0;
+ mStartingEndTrim = 0;
+ mStartingRotation = 0;
+ setStartTrim(0);
+ setEndTrim(0);
+ setRotation(0);
+ }
+
+ private void invalidateSelf() {
+ mCallback.invalidateDrawable(null);
+ }
+ }
+
+ /**
+ * Squishes the interpolation curve into the second half of the animation.
+ */
+ private static class EndCurveInterpolator extends AccelerateDecelerateInterpolator {
+ @Override
+ public float getInterpolation(float input) {
+ return super.getInterpolation(Math.max(0, (input - 0.5f) * 2.0f));
+ }
+ }
+
+ /**
+ * Squishes the interpolation curve into the first half of the animation.
+ */
+ private static class StartCurveInterpolator extends AccelerateDecelerateInterpolator {
+ @Override
+ public float getInterpolation(float input) {
+ return super.getInterpolation(Math.min(1, input * 2.0f));
+ }
+ }
+}
diff --git a/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayout.java b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayout.java
new file mode 100644
index 00000000..f193a0e1
--- /dev/null
+++ b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayout.java
@@ -0,0 +1,1152 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.orangegangsters.github.swipyrefreshlayout.library;
+
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.support.v4.view.MotionEventCompat;
+import android.support.v4.view.ViewCompat;
+import android.util.AttributeSet;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.Animation.AnimationListener;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Transformation;
+import android.widget.AbsListView;
+
+/**
+ * The SwipeRefreshLayout should be used whenever the user can refresh the
+ * contents of a view via a vertical swipe gesture. The activity that
+ * instantiates this view should add an OnRefreshListener to be notified
+ * whenever the swipe to refresh gesture is completed. The SwipeRefreshLayout
+ * will notify the listener each and every time the gesture is completed again;
+ * the listener is responsible for correctly determining when to actually
+ * initiate a refresh of its content. If the listener determines there should
+ * not be a refresh, it must call setRefreshing(false) to cancel any visual
+ * indication of a refresh. If an activity wishes to show just the progress
+ * animation, it should call setRefreshing(true). To disable the gesture and
+ * progress animation, call setEnabled(false) on the view.
+ * <p>
+ * This layout should be made the parent of the view that will be refreshed as a
+ * result of the gesture and can only support one direct child. This view will
+ * also be made the target of the gesture and will be forced to match both the
+ * width and the height supplied in this layout. The SwipeRefreshLayout does not
+ * provide accessibility events; instead, a menu item must be provided to allow
+ * refresh of the content wherever this gesture is used.
+ * </p>
+ */
+public class SwipyRefreshLayout extends ViewGroup {
+
+ public static final String TAG = "SwipyRefreshLayout";
+
+ private static final float MAX_SWIPE_DISTANCE_FACTOR = .6f;
+ private static final int REFRESH_TRIGGER_DISTANCE = 120;
+
+ // Maps to ProgressBar.Large style
+ public static final int LARGE = MaterialProgressDrawable.LARGE;
+ // Maps to ProgressBar default style
+ public static final int DEFAULT = MaterialProgressDrawable.DEFAULT;
+
+ private static final String LOG_TAG = SwipyRefreshLayout.class.getSimpleName();
+
+ private static final int MAX_ALPHA = 255;
+ private static final int STARTING_PROGRESS_ALPHA = (int) (.3f * MAX_ALPHA);
+
+ private static final int CIRCLE_DIAMETER = 40;
+ private static final int CIRCLE_DIAMETER_LARGE = 56;
+
+ private static final float DECELERATE_INTERPOLATION_FACTOR = 2f;
+ private static final int INVALID_POINTER = -1;
+ private static final float DRAG_RATE = .5f;
+
+ // Max amount of circle that can be filled by progress during swipe gesture,
+ // where 1.0 is a full circle
+ private static final float MAX_PROGRESS_ANGLE = .8f;
+
+ private static final int SCALE_DOWN_DURATION = 150;
+
+ private static final int ALPHA_ANIMATION_DURATION = 300;
+
+ private static final int ANIMATE_TO_TRIGGER_DURATION = 200;
+
+ private static final int ANIMATE_TO_START_DURATION = 200;
+
+ // Default background for the progress spinner
+ private static final int CIRCLE_BG_LIGHT = 0xFFFAFAFA;
+ // Default offset in dips from the top of the view to where the progress spinner should stop
+ private static final int DEFAULT_CIRCLE_TARGET = 64;
+
+ private View mTarget; // the target of the gesture
+ private SwipyRefreshLayoutDirection mDirection;
+ private boolean mBothDirection;
+ private OnRefreshListener mListener;
+ private boolean mRefreshing = false;
+ private int mTouchSlop;
+ private float mTotalDragDistance = -1;
+ private int mMediumAnimationDuration;
+ private int mCurrentTargetOffsetTop;
+ // Whether or not the starting offset has been determined.
+ private boolean mOriginalOffsetCalculated = false;
+
+ private float mInitialMotionY;
+ private float mInitialDownY;
+ private boolean mIsBeingDragged;
+ private int mActivePointerId = INVALID_POINTER;
+ // Whether this item is scaled up rather than clipped
+ private boolean mScale;
+
+ // Target is returning to its start offset because it was cancelled or a
+ // refresh was triggered.
+ private boolean mReturningToStart;
+ private final DecelerateInterpolator mDecelerateInterpolator;
+ private static final int[] LAYOUT_ATTRS = new int[]{
+ android.R.attr.enabled
+ };
+
+ private CircleImageView mCircleView;
+ private int mCircleViewIndex = -1;
+
+ protected int mFrom;
+
+ private float mStartingScale;
+
+ protected int mOriginalOffsetTop;
+
+ private MaterialProgressDrawable mProgress;
+
+ private Animation mScaleAnimation;
+
+ private Animation mScaleDownAnimation;
+
+ private Animation mAlphaStartAnimation;
+
+ private Animation mAlphaMaxAnimation;
+
+ private Animation mScaleDownToStartAnimation;
+
+ private float mSpinnerFinalOffset;
+
+ private boolean mNotify;
+
+ private int mCircleWidth;
+
+ private int mCircleHeight;
+
+ // Whether the client has set a custom starting position;
+ private boolean mUsingCustomStart;
+
+ private AnimationListener mRefreshListener = new AnimationListener() {
+ @Override
+ public void onAnimationStart(Animation animation) {
+ }
+
+ @Override
+ public void onAnimationRepeat(Animation animation) {
+ }
+
+ @Override
+ public void onAnimationEnd(Animation animation) {
+ if (mRefreshing) {
+ // Make sure the progress view is fully visible
+ mProgress.setAlpha(MAX_ALPHA);
+ mProgress.start();
+ if (mNotify) {
+ if (mListener != null) {
+ mListener.onRefresh(mDirection);
+ }
+ }
+ } else {
+ mProgress.stop();
+ mCircleView.setVisibility(View.GONE);
+ setColorViewAlpha(MAX_ALPHA);
+ // Return the circle to its start position
+ if (mScale) {
+ setAnimationProgress(0 /* animation complete and view is hidden */);
+ } else {
+ setTargetOffsetTopAndBottom(mOriginalOffsetTop - mCurrentTargetOffsetTop,
+ true /* requires update */);
+ }
+ }
+ mCurrentTargetOffsetTop = mCircleView.getTop();
+ }
+ };
+
+ private void setColorViewAlpha(int targetAlpha) {
+ mCircleView.getBackground().setAlpha(targetAlpha);
+ mProgress.setAlpha(targetAlpha);
+ }
+
+ /**
+ * The refresh indicator starting and resting position is always positioned
+ * near the top of the refreshing content. This position is a consistent
+ * location, but can be adjusted in either direction based on whether or not
+ * there is a toolbar or actionbar present.
+ *
+ * @param scale Set to true if there is no view at a higher z-order than
+ * where the progress spinner is set to appear.
+ * @param start The offset in pixels from the top of this view at which the
+ * progress spinner should appear.
+ * @param end The offset in pixels from the top of this view at which the
+ * progress spinner should come to rest after a successful swipe
+ * gesture.
+ */
+ /*
+ public void setProgressViewOffset(boolean scale, int start, int end) {
+ mScale = scale;
+ mCircleView.setVisibility(View.GONE);
+ mOriginalOffsetTop = mCurrentTargetOffsetTop = start;
+ mSpinnerFinalOffset = end;
+ mUsingCustomStart = true;
+ mCircleView.invalidate();
+ }*/
+
+ /**
+ * The refresh indicator resting position is always positioned near the top
+ * of the refreshing content. This position is a consistent location, but
+ * can be adjusted in either direction based on whether or not there is a
+ * toolbar or actionbar present.
+ *
+ * @param scale Set to true if there is no view at a higher z-order than
+ * where the progress spinner is set to appear.
+ * @param end The offset in pixels from the top of this view at which the
+ * progress spinner should come to rest after a successful swipe
+ * gesture.
+ */
+ /*
+ public void setProgressViewEndTarget(boolean scale, int end) {
+ mSpinnerFinalOffset = end;
+ mScale = scale;
+ mCircleView.invalidate();
+ }*/
+
+ /**
+ * One of DEFAULT, or LARGE.
+ */
+ public void setSize(int size) {
+ if (size != MaterialProgressDrawable.LARGE && size != MaterialProgressDrawable.DEFAULT) {
+ return;
+ }
+ final DisplayMetrics metrics = getResources().getDisplayMetrics();
+ if (size == MaterialProgressDrawable.LARGE) {
+ mCircleHeight = mCircleWidth = (int) (CIRCLE_DIAMETER_LARGE * metrics.density);
+ } else {
+ mCircleHeight = mCircleWidth = (int) (CIRCLE_DIAMETER * metrics.density);
+ }
+ // force the bounds of the progress circle inside the circle view to
+ // update by setting it to null before updating its size and then
+ // re-setting it
+ mCircleView.setImageDrawable(null);
+ mProgress.updateSizes(size);
+ mCircleView.setImageDrawable(mProgress);
+ }
+
+ /**
+ * Simple constructor to use when creating a SwipeRefreshLayout from code.
+ *
+ * @param context
+ */
+ public SwipyRefreshLayout(Context context) {
+ this(context, null);
+ }
+
+ /**
+ * Constructor that is called when inflating SwipeRefreshLayout from XML.
+ *
+ * @param context
+ * @param attrs
+ */
+ public SwipyRefreshLayout(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
+
+ mMediumAnimationDuration = getResources().getInteger(
+ android.R.integer.config_mediumAnimTime);
+
+ setWillNotDraw(false);
+ mDecelerateInterpolator = new DecelerateInterpolator(DECELERATE_INTERPOLATION_FACTOR);
+
+ final TypedArray a = context.obtainStyledAttributes(attrs, LAYOUT_ATTRS);
+ setEnabled(a.getBoolean(0, true));
+ a.recycle();
+
+ final TypedArray a2 = context.obtainStyledAttributes(attrs, R.styleable.SwipyRefreshLayout);
+ SwipyRefreshLayoutDirection direction
+ = SwipyRefreshLayoutDirection.getFromInt(a2.getInt(R.styleable.SwipyRefreshLayout_direction, 0));
+ if (direction != SwipyRefreshLayoutDirection.BOTH) {
+ mDirection = direction;
+ mBothDirection = false;
+ } else {
+ mDirection = SwipyRefreshLayoutDirection.TOP;
+ mBothDirection = true;
+ }
+ a2.recycle();
+
+ final DisplayMetrics metrics = getResources().getDisplayMetrics();
+ mCircleWidth = (int) (CIRCLE_DIAMETER * metrics.density);
+ mCircleHeight = (int) (CIRCLE_DIAMETER * metrics.density);
+
+ createProgressView();
+ ViewCompat.setChildrenDrawingOrderEnabled(this, true);
+ // the absolute offset has to take into account that the circle starts at an offset
+ mSpinnerFinalOffset = DEFAULT_CIRCLE_TARGET * metrics.density;
+ }
+
+ protected int getChildDrawingOrder(int childCount, int i) {
+ if (mCircleViewIndex < 0) {
+ return i;
+ } else if (i == childCount - 1) {
+ // Draw the selected child last
+ return mCircleViewIndex;
+ } else if (i >= mCircleViewIndex) {
+ // Move the children after the selected child earlier one
+ return i + 1;
+ } else {
+ // Keep the children before the selected child the same
+ return i;
+ }
+ }
+
+ private void createProgressView() {
+ mCircleView = new CircleImageView(getContext(), CIRCLE_BG_LIGHT, CIRCLE_DIAMETER / 2);
+ mProgress = new MaterialProgressDrawable(getContext(), this);
+ mProgress.setBackgroundColor(CIRCLE_BG_LIGHT);
+ mCircleView.setImageDrawable(mProgress);
+ mCircleView.setVisibility(View.GONE);
+ addView(mCircleView);
+ }
+
+ /**
+ * Set the listener to be notified when a refresh is triggered via the swipe
+ * gesture.
+ */
+ public void setOnRefreshListener(OnRefreshListener listener) {
+ mListener = listener;
+ }
+
+ /**
+ * Pre API 11, alpha is used to make the progress circle appear instead of scale.
+ */
+ private boolean isAlphaUsedForScale() {
+ return android.os.Build.VERSION.SDK_INT < 11;
+ }
+
+ /**
+ * Notify the widget that refresh state has changed. Do not call this when
+ * refresh is triggered by a swipe gesture.
+ *
+ * @param refreshing Whether or not the view should show refresh progress.
+ */
+ public void setRefreshing(boolean refreshing) {
+ if (refreshing && mRefreshing != refreshing) {
+ // scale and show
+ mRefreshing = refreshing;
+ int endTarget = 0;
+ if (!mUsingCustomStart) {
+ switch (mDirection) {
+ case BOTTOM:
+ endTarget = getMeasuredHeight() - (int) (mSpinnerFinalOffset);
+ break;
+ case TOP:
+ default:
+ endTarget = (int) (mSpinnerFinalOffset - Math.abs(mOriginalOffsetTop));
+ break;
+ }
+ } else {
+ endTarget = (int) mSpinnerFinalOffset;
+ }
+ setTargetOffsetTopAndBottom(endTarget - mCurrentTargetOffsetTop,
+ true /* requires update */);
+ mNotify = false;
+ startScaleUpAnimation(mRefreshListener);
+ } else {
+ setRefreshing(refreshing, false /* notify */);
+ }
+ }
+
+ private void startScaleUpAnimation(AnimationListener listener) {
+ mCircleView.setVisibility(View.VISIBLE);
+ if (android.os.Build.VERSION.SDK_INT >= 11) {
+ // Pre API 11, alpha is used in place of scale up to show the
+ // progress circle appearing.
+ // Don't adjust the alpha during appearance otherwise.
+ mProgress.setAlpha(MAX_ALPHA);
+ }
+ mScaleAnimation = new Animation() {
+ @Override
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ setAnimationProgress(interpolatedTime);
+ }
+ };
+ mScaleAnimation.setDuration(mMediumAnimationDuration);
+ if (listener != null) {
+ mCircleView.setAnimationListener(listener);
+ }
+ mCircleView.clearAnimation();
+ mCircleView.startAnimation(mScaleAnimation);
+ }
+
+ /**
+ * Pre API 11, this does an alpha animation.
+ *
+ * @param progress
+ */
+ private void setAnimationProgress(float progress) {
+ if (isAlphaUsedForScale()) {
+ setColorViewAlpha((int) (progress * MAX_ALPHA));
+ } else {
+ ViewCompat.setScaleX(mCircleView, progress);
+ ViewCompat.setScaleY(mCircleView, progress);
+ }
+ }
+
+ private void setRefreshing(boolean refreshing, final boolean notify) {
+ if (mRefreshing != refreshing) {
+ mNotify = notify;
+ ensureTarget();
+ mRefreshing = refreshing;
+ if (mRefreshing) {
+ animateOffsetToCorrectPosition(mCurrentTargetOffsetTop, mRefreshListener);
+ } else {
+ startScaleDownAnimation(mRefreshListener);
+ }
+ }
+ }
+
+ private void startScaleDownAnimation(AnimationListener listener) {
+ mScaleDownAnimation = new Animation() {
+ @Override
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ setAnimationProgress(1 - interpolatedTime);
+ }
+ };
+ mScaleDownAnimation.setDuration(SCALE_DOWN_DURATION);
+ mCircleView.setAnimationListener(listener);
+ mCircleView.clearAnimation();
+ mCircleView.startAnimation(mScaleDownAnimation);
+ }
+
+ private void startProgressAlphaStartAnimation() {
+ mAlphaStartAnimation = startAlphaAnimation(mProgress.getAlpha(), STARTING_PROGRESS_ALPHA);
+ }
+
+ private void startProgressAlphaMaxAnimation() {
+ mAlphaMaxAnimation = startAlphaAnimation(mProgress.getAlpha(), MAX_ALPHA);
+ }
+
+ private Animation startAlphaAnimation(final int startingAlpha, final int endingAlpha) {
+ // Pre API 11, alpha is used in place of scale. Don't also use it to
+ // show the trigger point.
+ if (mScale && isAlphaUsedForScale()) {
+ return null;
+ }
+ Animation alpha = new Animation() {
+ @Override
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ mProgress
+ .setAlpha((int) (startingAlpha + ((endingAlpha - startingAlpha)
+ * interpolatedTime)));
+ }
+ };
+ alpha.setDuration(ALPHA_ANIMATION_DURATION);
+ // Clear out the previous animation listeners.
+ mCircleView.setAnimationListener(null);
+ mCircleView.clearAnimation();
+ mCircleView.startAnimation(alpha);
+ return alpha;
+ }
+
+ /**
+ * Set the background color of the progress spinner disc.
+ *
+ * @param colorRes Resource id of the color.
+ */
+ public void setProgressBackgroundColor(int colorRes) {
+ mCircleView.setBackgroundColor(colorRes);
+ mProgress.setBackgroundColor(getResources().getColor(colorRes));
+ }
+
+ /**
+ * @deprecated Use {@link #setColorSchemeResources(int...)}
+ */
+ @Deprecated
+ public void setColorScheme(int... colors) {
+ setColorSchemeResources(colors);
+ }
+
+ /**
+ * Set the color resources used in the progress animation from color resources.
+ * The first color will also be the color of the bar that grows in response
+ * to a user swipe gesture.
+ *
+ * @param colorResIds
+ */
+ public void setColorSchemeResources(int... colorResIds) {
+ final Resources res = getResources();
+ int[] colorRes = new int[colorResIds.length];
+ for (int i = 0; i < colorResIds.length; i++) {
+ colorRes[i] = res.getColor(colorResIds[i]);
+ }
+ setColorSchemeColors(colorRes);
+ }
+
+ /**
+ * Set the colors used in the progress animation. The first
+ * color will also be the color of the bar that grows in response to a user
+ * swipe gesture.
+ *
+ * @param colors
+ */
+ public void setColorSchemeColors(int... colors) {
+ ensureTarget();
+ mProgress.setColorSchemeColors(colors);
+ }
+
+ /**
+ * @return Whether the SwipeRefreshWidget is actively showing refresh
+ * progress.
+ */
+ public boolean isRefreshing() {
+ return mRefreshing;
+ }
+
+ private void ensureTarget() {
+ // Don't bother getting the parent height if the parent hasn't been laid
+ // out yet.
+ if (mTarget == null) {
+ for (int i = 0; i < getChildCount(); i++) {
+ View child = getChildAt(i);
+ if (!child.equals(mCircleView)) {
+ mTarget = child;
+ break;
+ }
+ }
+ }
+ if (mTotalDragDistance == -1) {
+ if (getParent() != null && ((View) getParent()).getHeight() > 0) {
+ final DisplayMetrics metrics = getResources().getDisplayMetrics();
+ mTotalDragDistance = (int) Math.min(
+ ((View) getParent()).getHeight() * MAX_SWIPE_DISTANCE_FACTOR,
+ REFRESH_TRIGGER_DISTANCE * metrics.density);
+ }
+ }
+ }
+
+ /**
+ * Set the distance to trigger a sync in dips
+ *
+ * @param distance
+ */
+ public void setDistanceToTriggerSync(int distance) {
+ mTotalDragDistance = distance;
+ }
+
+ @Override
+ protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+ final int width = getMeasuredWidth();
+ final int height = getMeasuredHeight();
+ if (getChildCount() == 0) {
+ return;
+ }
+ if (mTarget == null) {
+ ensureTarget();
+ }
+ if (mTarget == null) {
+ return;
+ }
+ final View child = mTarget;
+ final int childLeft = getPaddingLeft();
+ final int childTop = getPaddingTop();
+ final int childWidth = width - getPaddingLeft() - getPaddingRight();
+ final int childHeight = height - getPaddingTop() - getPaddingBottom();
+ child.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight);
+ int circleWidth = mCircleView.getMeasuredWidth();
+ int circleHeight = mCircleView.getMeasuredHeight();
+ mCircleView.layout((width / 2 - circleWidth / 2), mCurrentTargetOffsetTop,
+ (width / 2 + circleWidth / 2), mCurrentTargetOffsetTop + circleHeight);
+ }
+
+ @Override
+ public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+ if (mTarget == null) {
+ ensureTarget();
+ }
+ if (mTarget == null) {
+ return;
+ }
+ mTarget.measure(MeasureSpec.makeMeasureSpec(
+ getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),
+ MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(
+ getMeasuredHeight() - getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY));
+ mCircleView.measure(MeasureSpec.makeMeasureSpec(mCircleWidth, MeasureSpec.EXACTLY),
+ MeasureSpec.makeMeasureSpec(mCircleHeight, MeasureSpec.EXACTLY));
+ if (!mUsingCustomStart && !mOriginalOffsetCalculated) {
+ mOriginalOffsetCalculated = true;
+
+ switch (mDirection) {
+ case BOTTOM:
+ mCurrentTargetOffsetTop = mOriginalOffsetTop = getMeasuredHeight();
+ break;
+ case TOP:
+ default:
+ mCurrentTargetOffsetTop = mOriginalOffsetTop = -mCircleView.getMeasuredHeight();
+ break;
+ }
+ }
+ mCircleViewIndex = -1;
+ // Get the index of the circleview.
+ for (int index = 0; index < getChildCount(); index++) {
+ if (getChildAt(index) == mCircleView) {
+ mCircleViewIndex = index;
+ break;
+ }
+ }
+ }
+
+ /**
+ * @return Whether it is possible for the child view of this layout to
+ * scroll up. Override this if the child view is a custom view.
+ */
+ public boolean canChildScrollUp() {
+ if (android.os.Build.VERSION.SDK_INT < 14) {
+ if (mTarget instanceof AbsListView) {
+ final AbsListView absListView = (AbsListView) mTarget;
+ return absListView.getChildCount() > 0
+ && (absListView.getFirstVisiblePosition() > 0 || absListView.getChildAt(0)
+ .getTop() < absListView.getPaddingTop());
+ } else {
+ return mTarget.getScrollY() > 0;
+ }
+ } else {
+ return ViewCompat.canScrollVertically(mTarget, -1);
+ }
+ }
+// public boolean canChildScrollUp() {
+// if (android.os.Build.VERSION.SDK_INT < 14) {
+// if (mTarget instanceof AbsListView) {
+// final AbsListView absListView = (AbsListView) mTarget;
+// if (absListView.getLastVisiblePosition() + 1 == absListView.getCount()) {
+// int lastIndex = absListView.getLastVisiblePosition() - absListView.getFirstVisiblePosition();
+//
+// boolean res = absListView.getChildAt(lastIndex).getBottom() == absListView.getPaddingBottom();
+//
+// return res;
+// }
+// return true;
+// } else {
+// return mTarget.getScrollY() > 0;
+// }
+// } else {
+// return ViewCompat.canScrollVertically(mTarget, 1);
+// }
+// }
+
+
+ public boolean canChildScrollDown() {
+ if (android.os.Build.VERSION.SDK_INT < 14) {
+ if (mTarget instanceof AbsListView) {
+ final AbsListView absListView = (AbsListView) mTarget;
+ try {
+ if (absListView.getCount() > 0) {
+ if (absListView.getLastVisiblePosition() + 1 == absListView.getCount()) {
+ int lastIndex = absListView.getLastVisiblePosition() - absListView.getFirstVisiblePosition();
+ return absListView.getChildAt(lastIndex).getBottom() == absListView.getPaddingBottom();
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return true;
+ } else {
+ return true;
+ }
+ } else {
+ return ViewCompat.canScrollVertically(mTarget, 1);
+ }
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ ensureTarget();
+
+ final int action = MotionEventCompat.getActionMasked(ev);
+
+ if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
+ mReturningToStart = false;
+ }
+
+ switch (mDirection) {
+ case BOTTOM:
+ if (!isEnabled() || mReturningToStart || (!mBothDirection && canChildScrollDown()) || mRefreshing) {
+ // Fail fast if we're not in a state where a swipe is possible
+ return false;
+ }
+ break;
+ case TOP:
+ default:
+ if (!isEnabled() || mReturningToStart || (!mBothDirection && canChildScrollUp()) || mRefreshing) {
+ // Fail fast if we're not in a state where a swipe is possible
+ return false;
+ }
+ break;
+ }
+
+ switch (action) {
+ case MotionEvent.ACTION_DOWN:
+ setTargetOffsetTopAndBottom(mOriginalOffsetTop - mCircleView.getTop(), true);
+ mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
+ mIsBeingDragged = false;
+ final float initialDownY = getMotionEventY(ev, mActivePointerId);
+ if (initialDownY == -1) {
+ return false;
+ }
+ mInitialDownY = initialDownY;
+
+ case MotionEvent.ACTION_MOVE:
+ if (mActivePointerId == INVALID_POINTER) {
+ return false;
+ }
+
+ final float y = getMotionEventY(ev, mActivePointerId);
+ if (y == -1) {
+ return false;
+ }
+ if (mBothDirection) {
+ if (y > mInitialDownY) {
+ setRawDirection(SwipyRefreshLayoutDirection.TOP);
+ } else if (y < mInitialDownY) {
+ setRawDirection(SwipyRefreshLayoutDirection.BOTTOM);
+ }
+ if ((mDirection == SwipyRefreshLayoutDirection.BOTTOM && canChildScrollDown())
+ || (mDirection == SwipyRefreshLayoutDirection.TOP && canChildScrollUp())) {
+ mInitialDownY = y;
+ return false;
+ }
+ }
+ float yDiff;
+ switch (mDirection) {
+ case BOTTOM:
+ yDiff = mInitialDownY - y;
+ break;
+ case TOP:
+ default:
+ yDiff = y - mInitialDownY;
+ break;
+ }
+ if (yDiff > mTouchSlop && !mIsBeingDragged) {
+ switch (mDirection) {
+ case BOTTOM:
+ mInitialMotionY = mInitialDownY - mTouchSlop;
+ break;
+ case TOP:
+ default:
+ mInitialMotionY = mInitialDownY + mTouchSlop;
+ break;
+ }
+ mIsBeingDragged = true;
+ mProgress.setAlpha(STARTING_PROGRESS_ALPHA);
+ }
+ break;
+
+ case MotionEventCompat.ACTION_POINTER_UP:
+ onSecondaryPointerUp(ev);
+ break;
+
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_CANCEL:
+ mIsBeingDragged = false;
+ mActivePointerId = INVALID_POINTER;
+ break;
+ }
+
+ return mIsBeingDragged;
+ }
+
+ private float getMotionEventY(MotionEvent ev, int activePointerId) {
+ final int index = MotionEventCompat.findPointerIndex(ev, activePointerId);
+ if (index < 0) {
+ return -1;
+ }
+ return MotionEventCompat.getY(ev, index);
+ }
+
+ @Override
+ public void requestDisallowInterceptTouchEvent(boolean b) {
+ // Nope.
+ }
+
+ private boolean isAnimationRunning(Animation animation) {
+ return animation != null && animation.hasStarted() && !animation.hasEnded();
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ try {
+ final int action = MotionEventCompat.getActionMasked(ev);
+
+ if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
+ mReturningToStart = false;
+ }
+
+ switch (mDirection) {
+ case BOTTOM:
+ if (!isEnabled() || mReturningToStart || canChildScrollDown() || mRefreshing) {
+ // Fail fast if we're not in a state where a swipe is possible
+ return false;
+ }
+ break;
+ case TOP:
+ default:
+ if (!isEnabled() || mReturningToStart || canChildScrollUp() || mRefreshing) {
+ // Fail fast if we're not in a state where a swipe is possible
+ return false;
+ }
+ break;
+ }
+
+ switch (action) {
+ case MotionEvent.ACTION_DOWN:
+ mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
+ mIsBeingDragged = false;
+ break;
+
+ case MotionEvent.ACTION_MOVE: {
+ final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
+ if (pointerIndex < 0) {
+ return false;
+ }
+
+ final float y = MotionEventCompat.getY(ev, pointerIndex);
+
+ float overscrollTop;
+ switch (mDirection) {
+ case BOTTOM:
+ overscrollTop = (mInitialMotionY - y) * DRAG_RATE;
+ break;
+ case TOP:
+ default:
+ overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
+ break;
+ }
+ if (mIsBeingDragged) {
+ mProgress.showArrow(true);
+ float originalDragPercent = overscrollTop / mTotalDragDistance;
+ if (originalDragPercent < 0) {
+ return false;
+ }
+ float dragPercent = Math.min(1f, Math.abs(originalDragPercent));
+ float adjustedPercent = (float) Math.max(dragPercent - .4, 0) * 5 / 3;
+ float extraOS = Math.abs(overscrollTop) - mTotalDragDistance;
+ float slingshotDist = mUsingCustomStart ? mSpinnerFinalOffset
+ - mOriginalOffsetTop : mSpinnerFinalOffset;
+ float tensionSlingshotPercent = Math.max(0,
+ Math.min(extraOS, slingshotDist * 2) / slingshotDist);
+ float tensionPercent = (float) ((tensionSlingshotPercent / 4) - Math.pow(
+ (tensionSlingshotPercent / 4), 2)) * 2f;
+ float extraMove = (slingshotDist) * tensionPercent * 2;
+
+ // int targetY = mOriginalOffsetTop + (int) ((slingshotDist * dragPercent) + extraMove);
+ int targetY;
+ if (mDirection == SwipyRefreshLayoutDirection.TOP) {
+ targetY = mOriginalOffsetTop + (int) ((slingshotDist * dragPercent) + extraMove);
+ } else {
+ targetY = mOriginalOffsetTop - (int) ((slingshotDist * dragPercent) + extraMove);
+ }
+ // where 1.0f is a full circle
+ if (mCircleView.getVisibility() != View.VISIBLE) {
+ mCircleView.setVisibility(View.VISIBLE);
+ }
+ if (!mScale) {
+ ViewCompat.setScaleX(mCircleView, 1f);
+ ViewCompat.setScaleY(mCircleView, 1f);
+ }
+ if (overscrollTop < mTotalDragDistance) {
+ if (mScale) {
+ setAnimationProgress(overscrollTop / mTotalDragDistance);
+ }
+ if (mProgress.getAlpha() > STARTING_PROGRESS_ALPHA
+ && !isAnimationRunning(mAlphaStartAnimation)) {
+ // Animate the alpha
+ startProgressAlphaStartAnimation();
+ }
+ float strokeStart = (float) (adjustedPercent * .8f);
+ mProgress.setStartEndTrim(0f, Math.min(MAX_PROGRESS_ANGLE, strokeStart));
+ mProgress.setArrowScale(Math.min(1f, adjustedPercent));
+ } else {
+ if (mProgress.getAlpha() < MAX_ALPHA
+ && !isAnimationRunning(mAlphaMaxAnimation)) {
+ // Animate the alpha
+ startProgressAlphaMaxAnimation();
+ }
+ }
+ float rotation = (-0.25f + .4f * adjustedPercent + tensionPercent * 2) * .5f;
+ mProgress.setProgressRotation(rotation);
+ setTargetOffsetTopAndBottom(targetY - mCurrentTargetOffsetTop,
+ true /* requires update */);
+ }
+ break;
+ }
+ case MotionEventCompat.ACTION_POINTER_DOWN: {
+ final int index = MotionEventCompat.getActionIndex(ev);
+ mActivePointerId = MotionEventCompat.getPointerId(ev, index);
+ break;
+ }
+
+ case MotionEventCompat.ACTION_POINTER_UP:
+ onSecondaryPointerUp(ev);
+ break;
+
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_CANCEL: {
+ if (mActivePointerId == INVALID_POINTER) {
+ if (action == MotionEvent.ACTION_UP) {
+ }
+ return false;
+ }
+ final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
+ final float y = MotionEventCompat.getY(ev, pointerIndex);
+
+ float overscrollTop;
+ switch (mDirection) {
+ case BOTTOM:
+ overscrollTop = (mInitialMotionY - y) * DRAG_RATE;
+ break;
+ case TOP:
+ default:
+ overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
+ break;
+ }
+ mIsBeingDragged = false;
+ if (overscrollTop > mTotalDragDistance) {
+ setRefreshing(true, true /* notify */);
+ } else {
+ // cancel refresh
+ mRefreshing = false;
+ mProgress.setStartEndTrim(0f, 0f);
+ AnimationListener listener = null;
+ if (!mScale) {
+ listener = new AnimationListener() {
+
+ @Override
+ public void onAnimationStart(Animation animation) {
+ }
+
+ @Override
+ public void onAnimationEnd(Animation animation) {
+ if (!mScale) {
+ startScaleDownAnimation(null);
+ }
+ }
+
+ @Override
+ public void onAnimationRepeat(Animation animation) {
+ }
+
+ };
+ }
+ animateOffsetToStartPosition(mCurrentTargetOffsetTop, listener);
+ mProgress.showArrow(false);
+ }
+ mActivePointerId = INVALID_POINTER;
+ return false;
+ }
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "An exception occured during SwipyRefreshLayout onTouchEvent " + e.toString());
+ }
+
+ return true;
+ }
+
+ private void animateOffsetToCorrectPosition(int from, AnimationListener listener) {
+ mFrom = from;
+ mAnimateToCorrectPosition.reset();
+ mAnimateToCorrectPosition.setDuration(ANIMATE_TO_TRIGGER_DURATION);
+ mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator);
+ if (listener != null) {
+ mCircleView.setAnimationListener(listener);
+ }
+ mCircleView.clearAnimation();
+ mCircleView.startAnimation(mAnimateToCorrectPosition);
+ }
+
+ private void animateOffsetToStartPosition(int from, AnimationListener listener) {
+ if (mScale) {
+ // Scale the item back down
+ startScaleDownReturnToStartAnimation(from, listener);
+ } else {
+ mFrom = from;
+ mAnimateToStartPosition.reset();
+ mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
+ mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
+ if (listener != null) {
+ mCircleView.setAnimationListener(listener);
+ }
+ mCircleView.clearAnimation();
+ mCircleView.startAnimation(mAnimateToStartPosition);
+ }
+ }
+
+ private final Animation mAnimateToCorrectPosition = new Animation() {
+ @Override
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ int targetTop = 0;
+ int endTarget = 0;
+ if (!mUsingCustomStart) {
+ switch (mDirection) {
+ case BOTTOM:
+ endTarget = getMeasuredHeight() - (int) (mSpinnerFinalOffset);
+ break;
+ case TOP:
+ default:
+ endTarget = (int) (mSpinnerFinalOffset - Math.abs(mOriginalOffsetTop));
+ break;
+ }
+ } else {
+ endTarget = (int) mSpinnerFinalOffset;
+ }
+ targetTop = (mFrom + (int) ((endTarget - mFrom) * interpolatedTime));
+ int offset = targetTop - mCircleView.getTop();
+ setTargetOffsetTopAndBottom(offset, false /* requires update */);
+ }
+ };
+
+ private void moveToStart(float interpolatedTime) {
+ int targetTop = 0;
+ targetTop = (mFrom + (int) ((mOriginalOffsetTop - mFrom) * interpolatedTime));
+ int offset = targetTop - mCircleView.getTop();
+ setTargetOffsetTopAndBottom(offset, false /* requires update */);
+ }
+
+ private final Animation mAnimateToStartPosition = new Animation() {
+ @Override
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ moveToStart(interpolatedTime);
+ }
+ };
+
+ private void startScaleDownReturnToStartAnimation(int from,
+ AnimationListener listener) {
+ mFrom = from;
+ if (isAlphaUsedForScale()) {
+ mStartingScale = mProgress.getAlpha();
+ } else {
+ mStartingScale = ViewCompat.getScaleX(mCircleView);
+ }
+ mScaleDownToStartAnimation = new Animation() {
+ @Override
+ public void applyTransformation(float interpolatedTime, Transformation t) {
+ float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
+ setAnimationProgress(targetScale);
+ moveToStart(interpolatedTime);
+ }
+ };
+ mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
+ if (listener != null) {
+ mCircleView.setAnimationListener(listener);
+ }
+ mCircleView.clearAnimation();
+ mCircleView.startAnimation(mScaleDownToStartAnimation);
+ }
+
+ private void setTargetOffsetTopAndBottom(int offset, boolean requiresUpdate) {
+ mCircleView.bringToFront();
+ mCircleView.offsetTopAndBottom(offset);
+
+// switch (mDirection) {
+// case BOTTOM:
+// mCurrentTargetOffsetTop = getMeasuredHeight() - mCircleView.getMeasuredHeight();
+// break;
+// case TOP:
+// default:
+// mCurrentTargetOffsetTop = mCircleView.getTop();
+// break;
+// }
+ mCurrentTargetOffsetTop = mCircleView.getTop();
+ if (requiresUpdate && android.os.Build.VERSION.SDK_INT < 11) {
+ invalidate();
+ }
+ }
+
+ private void onSecondaryPointerUp(MotionEvent ev) {
+ final int pointerIndex = MotionEventCompat.getActionIndex(ev);
+ final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
+ if (pointerId == mActivePointerId) {
+ // This was our active pointer going up. Choose a new
+ // active pointer and adjust accordingly.
+ final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
+ mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
+ }
+ }
+
+ /**
+ * Classes that wish to be notified when the swipe gesture correctly
+ * triggers a refresh should implement this interface.
+ */
+ public interface OnRefreshListener {
+ public void onRefresh(SwipyRefreshLayoutDirection direction);
+ }
+
+ public SwipyRefreshLayoutDirection getDirection() {
+ return mBothDirection ? SwipyRefreshLayoutDirection.BOTH : mDirection;
+ }
+
+ public void setDirection(SwipyRefreshLayoutDirection direction) {
+ if (direction == SwipyRefreshLayoutDirection.BOTH) {
+ mBothDirection = true;
+ } else {
+ mBothDirection = false;
+ mDirection = direction;
+ }
+
+ switch (mDirection) {
+ case BOTTOM:
+ mCurrentTargetOffsetTop = mOriginalOffsetTop = getMeasuredHeight();
+ break;
+ case TOP:
+ default:
+ mCurrentTargetOffsetTop = mOriginalOffsetTop = -mCircleView.getMeasuredHeight();
+ break;
+ }
+ }
+
+ // only TOP or Bottom
+ private void setRawDirection(SwipyRefreshLayoutDirection direction) {
+ if (mDirection == direction) {
+ return;
+ }
+
+ mDirection = direction;
+ switch (mDirection) {
+ case BOTTOM:
+ mCurrentTargetOffsetTop = mOriginalOffsetTop = getMeasuredHeight();
+ break;
+ case TOP:
+ default:
+ mCurrentTargetOffsetTop = mOriginalOffsetTop = -mCircleView.getMeasuredHeight();
+ break;
+ }
+ }
+}
diff --git a/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayoutDirection.java b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayoutDirection.java
new file mode 100644
index 00000000..af5d6c2d
--- /dev/null
+++ b/libs/SwipyRefreshLayout/src/main/java/com/orangegangsters/github/swipyrefreshlayout/library/SwipyRefreshLayoutDirection.java
@@ -0,0 +1,27 @@
+package com.orangegangsters.github.swipyrefreshlayout.library;
+
+/**
+ * Created by oliviergoutay on 1/23/15.
+ */
+public enum SwipyRefreshLayoutDirection {
+
+ TOP(0),
+ BOTTOM(1),
+ BOTH(2);
+
+ private int mValue;
+
+ SwipyRefreshLayoutDirection(int value) {
+ this.mValue = value;
+ }
+
+ public static SwipyRefreshLayoutDirection getFromInt(int value) {
+ for (SwipyRefreshLayoutDirection direction : SwipyRefreshLayoutDirection.values()) {
+ if (direction.mValue == value) {
+ return direction;
+ }
+ }
+ return BOTH;
+ }
+
+}
diff --git a/libs/SwipyRefreshLayout/src/main/res/values/attrs.xml b/libs/SwipyRefreshLayout/src/main/res/values/attrs.xml
new file mode 100644
index 00000000..db0c1d32
--- /dev/null
+++ b/libs/SwipyRefreshLayout/src/main/res/values/attrs.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+ <declare-styleable name="SwipyRefreshLayout">
+ <attr name="direction">
+ <enum name="top" value="0" />
+ <enum name="bottom" value="1" />
+ <enum name="both" value="2" />
+ </attr>
+ </declare-styleable>
+
+</resources> \ No newline at end of file