Add SwypeRefreshLayout.java from android-support-v4 source

README.md

@@ -4,15 +4,6 @@ Ti.SwipeRefreshLayout Titanium Module
 Building the module on Titanium Studio
 -----------
 To be added later on.
-
-Using the compiled zip
------------
-1. Download the module zip from the dist folder
-2. Open Titanium Studio
-3. Go to Help in menu and click on Install Mobile Module
-4. Point to the zip file and install into your project
-5. Rename android_support-v4.jar to android_support-v4.disabled.jar located:
-	* on OS X: **/Users/(your username)/Library/Application Support/Titanium/mobilesdk/osx/(your titanium version)/android/**
 
 
 To initialize

manifest

@@ -2,7 +2,7 @@
 # this is your module manifest and used by Titanium
 # during compilation, packaging, distribution, etc.
 #
-version: 0.1
+version: 0.2
 apiversion: 2
 description: My module
 author: Raymond Kam

src/com/rkam/swiperefreshlayout/BakedBezierInterpolator.java

@@ -0,0 +1,84 @@
+/*
+ * 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.rkam.swiperefreshlayout;
+
+import android.view.animation.Interpolator;
+
+/**
+ * A pre-baked bezier-curved interpolator for indeterminate progress animations.
+ */
+final class BakedBezierInterpolator implements Interpolator {
+    private static final BakedBezierInterpolator INSTANCE = new BakedBezierInterpolator();
+
+    public final static BakedBezierInterpolator getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * Use getInstance instead of instantiating.
+     */
+    private BakedBezierInterpolator() {
+        super();
+    }
+
+    /**
+     * Lookup table values.
+     * Generated using a Bezier curve from (0,0) to (1,1) with control points:
+     * P0 (0,0)
+     * P1 (0.4, 0)
+     * P2 (0.2, 1.0)
+     * P3 (1.0, 1.0)
+     *
+     * Values sampled with x at regular intervals between 0 and 1.
+     */
+    private static final float[] VALUES = new float[] {
+        0.0f, 0.0002f, 0.0009f, 0.0019f, 0.0036f, 0.0059f, 0.0086f, 0.0119f, 0.0157f, 0.0209f,
+        0.0257f, 0.0321f, 0.0392f, 0.0469f, 0.0566f, 0.0656f, 0.0768f, 0.0887f, 0.1033f, 0.1186f,
+        0.1349f, 0.1519f, 0.1696f, 0.1928f, 0.2121f, 0.237f, 0.2627f, 0.2892f, 0.3109f, 0.3386f,
+        0.3667f, 0.3952f, 0.4241f, 0.4474f, 0.4766f, 0.5f, 0.5234f, 0.5468f, 0.5701f, 0.5933f,
+        0.6134f, 0.6333f, 0.6531f, 0.6698f, 0.6891f, 0.7054f, 0.7214f, 0.7346f, 0.7502f, 0.763f,
+        0.7756f, 0.7879f, 0.8f, 0.8107f, 0.8212f, 0.8326f, 0.8415f, 0.8503f, 0.8588f, 0.8672f,
+        0.8754f, 0.8833f, 0.8911f, 0.8977f, 0.9041f, 0.9113f, 0.9165f, 0.9232f, 0.9281f, 0.9328f,
+        0.9382f, 0.9434f, 0.9476f, 0.9518f, 0.9557f, 0.9596f, 0.9632f, 0.9662f, 0.9695f, 0.9722f,
+        0.9753f, 0.9777f, 0.9805f, 0.9826f, 0.9847f, 0.9866f, 0.9884f, 0.9901f, 0.9917f, 0.9931f,
+        0.9944f, 0.9955f, 0.9964f, 0.9973f, 0.9981f, 0.9986f, 0.9992f, 0.9995f, 0.9998f, 1.0f, 1.0f
+    };
+
+    private static final float STEP_SIZE = 1.0f / (VALUES.length - 1);
+
+    @Override
+    public float getInterpolation(float input) {
+        if (input >= 1.0f) {
+            return 1.0f;
+        }
+
+        if (input <= 0f) {
+            return 0f;
+        }
+
+        int position = Math.min(
+                (int)(input * (VALUES.length - 1)),
+                VALUES.length - 2);
+
+        float quantized = position * STEP_SIZE;
+        float difference = input - quantized;
+        float weight = difference / STEP_SIZE;
+
+        return VALUES[position] + weight * (VALUES[position + 1] - VALUES[position]);
+    }
+
+}

src/com/rkam/swiperefreshlayout/MySwipeRefreshLayout.java

@@ -2,7 +2,6 @@
 
 import android.content.Context;
 import android.support.v4.view.ViewCompat;
-import android.support.v4.widget.SwipeRefreshLayout;
 import android.util.AttributeSet;
 import android.view.View;
 import android.widget.AbsListView;

src/com/rkam/swiperefreshlayout/SwipeProgressBar.java

@@ -0,0 +1,273 @@
+/*
+ * 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.rkam.swiperefreshlayout;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.support.v4.view.ViewCompat;
+import android.view.View;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+
+
+/**
+ * Custom progress bar that shows a cycle of colors as widening circles that
+ * overdraw each other. When finished, the bar is cleared from the inside out as
+ * the main cycle continues. Before running, this can also indicate how close
+ * the user is to triggering something (e.g. how far they need to pull down to
+ * trigger a refresh).
+ */
+final class SwipeProgressBar {
+
+    // Default progress animation colors are grays.
+    private final static int COLOR1 = 0xB3000000;
+    private final static int COLOR2 = 0x80000000;
+    private final static int COLOR3 = 0x4d000000;
+    private final static int COLOR4 = 0x1a000000;
+
+    // The duration of the animation cycle.
+    private static final int ANIMATION_DURATION_MS = 2000;
+
+    // The duration of the animation to clear the bar.
+    private static final int FINISH_ANIMATION_DURATION_MS = 1000;
+
+    // Interpolator for varying the speed of the animation.
+    private static final Interpolator INTERPOLATOR = BakedBezierInterpolator.getInstance();
+
+    private final Paint mPaint = new Paint();
+    private final RectF mClipRect = new RectF();
+    private float mTriggerPercentage;
+    private long mStartTime;
+    private long mFinishTime;
+    private boolean mRunning;
+
+    // Colors used when rendering the animation,
+    private int mColor1;
+    private int mColor2;
+    private int mColor3;
+    private int mColor4;
+    private View mParent;
+
+    private Rect mBounds = new Rect();
+
+    public SwipeProgressBar(View parent) {
+        mParent = parent;
+        mColor1 = COLOR1;
+        mColor2 = COLOR2;
+        mColor3 = COLOR3;
+        mColor4 = COLOR4;
+    }
+
+    /**
+     * Set the four 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 color1 Integer representation of a color.
+     * @param color2 Integer representation of a color.
+     * @param color3 Integer representation of a color.
+     * @param color4 Integer representation of a color.
+     */
+    void setColorScheme(int color1, int color2, int color3, int color4) {
+        mColor1 = color1;
+        mColor2 = color2;
+        mColor3 = color3;
+        mColor4 = color4;
+    }
+
+    /**
+     * Update the progress the user has made toward triggering the swipe
+     * gesture. and use this value to update the percentage of the trigger that
+     * is shown.
+     */
+    void setTriggerPercentage(float triggerPercentage) {
+        mTriggerPercentage = triggerPercentage;
+        mStartTime = 0;
+        ViewCompat.postInvalidateOnAnimation(mParent);
+    }
+
+    /**
+     * Start showing the progress animation.
+     */
+    void start() {
+        if (!mRunning) {
+            mTriggerPercentage = 0;
+            mStartTime = AnimationUtils.currentAnimationTimeMillis();
+            mRunning = true;
+            mParent.postInvalidate();
+        }
+    }
+
+    /**
+     * Stop showing the progress animation.
+     */
+    void stop() {
+        if (mRunning) {
+            mTriggerPercentage = 0;
+            mFinishTime = AnimationUtils.currentAnimationTimeMillis();
+            mRunning = false;
+            mParent.postInvalidate();
+        }
+    }
+
+    /**
+     * @return Return whether the progress animation is currently running.
+     */
+    boolean isRunning() {
+        return mRunning || mFinishTime > 0;
+    }
+
+    void draw(Canvas canvas) {
+        final int width = mBounds.width();
+        final int height = mBounds.height();
+        final int cx = width / 2;
+        final int cy = height / 2;
+        boolean drawTriggerWhileFinishing = false;
+        int restoreCount = canvas.save();
+        canvas.clipRect(mBounds);
+
+        if (mRunning || (mFinishTime > 0)) {
+            long now = AnimationUtils.currentAnimationTimeMillis();
+            long elapsed = (now - mStartTime) % ANIMATION_DURATION_MS;
+            long iterations = (now - mStartTime) / ANIMATION_DURATION_MS;
+            float rawProgress = (elapsed / (ANIMATION_DURATION_MS / 100f));
+
+            // If we're not running anymore, that means we're running through
+            // the finish animation.
+            if (!mRunning) {
+                // If the finish animation is done, don't draw anything, and
+                // don't repost.
+                if ((now - mFinishTime) >= FINISH_ANIMATION_DURATION_MS) {
+                    mFinishTime = 0;
+                    return;
+                }
+
+                // Otherwise, use a 0 opacity alpha layer to clear the animation
+                // from the inside out. This layer will prevent the circles from
+                // drawing within its bounds.
+                long finishElapsed = (now - mFinishTime) % FINISH_ANIMATION_DURATION_MS;
+                float finishProgress = (finishElapsed / (FINISH_ANIMATION_DURATION_MS / 100f));
+                float pct = (finishProgress / 100f);
+                // Radius of the circle is half of the screen.
+                float clearRadius = width / 2 * INTERPOLATOR.getInterpolation(pct);
+                mClipRect.set(cx - clearRadius, 0, cx + clearRadius, height);
+                canvas.saveLayerAlpha(mClipRect, 0, 0);
+                // Only draw the trigger if there is a space in the center of
+                // this refreshing view that needs to be filled in by the
+                // trigger. If the progress view is just still animating, let it
+                // continue animating.
+                drawTriggerWhileFinishing = true;
+            }
+
+            // First fill in with the last color that would have finished drawing.
+            if (iterations == 0) {
+                canvas.drawColor(mColor1);
+            } else {
+                if (rawProgress >= 0 && rawProgress < 25) {
+                    canvas.drawColor(mColor4);
+                } else if (rawProgress >= 25 && rawProgress < 50) {
+                    canvas.drawColor(mColor1);
+                } else if (rawProgress >= 50 && rawProgress < 75) {
+                    canvas.drawColor(mColor2);
+                } else {
+                    canvas.drawColor(mColor3);
+                }
+            }
+
+            // Then draw up to 4 overlapping concentric circles of varying radii, based on how far
+            // along we are in the cycle.
+            // progress 0-50 draw mColor2
+            // progress 25-75 draw mColor3
+            // progress 50-100 draw mColor4
+            // progress 75 (wrap to 25) draw mColor1
+            if ((rawProgress >= 0 && rawProgress <= 25)) {
+                float pct = (((rawProgress + 25) * 2) / 100f);
+                drawCircle(canvas, cx, cy, mColor1, pct);
+            }
+            if (rawProgress >= 0 && rawProgress <= 50) {
+                float pct = ((rawProgress * 2) / 100f);
+                drawCircle(canvas, cx, cy, mColor2, pct);
+            }
+            if (rawProgress >= 25 && rawProgress <= 75) {
+                float pct = (((rawProgress - 25) * 2) / 100f);
+                drawCircle(canvas, cx, cy, mColor3, pct);
+            }
+            if (rawProgress >= 50 && rawProgress <= 100) {
+                float pct = (((rawProgress - 50) * 2) / 100f);
+                drawCircle(canvas, cx, cy, mColor4, pct);
+            }
+            if ((rawProgress >= 75 && rawProgress <= 100)) {
+                float pct = (((rawProgress - 75) * 2) / 100f);
+                drawCircle(canvas, cx, cy, mColor1, pct);
+            }
+            if (mTriggerPercentage > 0 && drawTriggerWhileFinishing) {
+                // There is some portion of trigger to draw. Restore the canvas,
+                // then draw the trigger. Otherwise, the trigger does not appear
+                // until after the bar has finished animating and appears to
+                // just jump in at a larger width than expected.
+                canvas.restoreToCount(restoreCount);
+                restoreCount = canvas.save();
+                canvas.clipRect(mBounds);
+                drawTrigger(canvas, cx, cy);
+            }
+            // Keep running until we finish out the last cycle.
+            ViewCompat.postInvalidateOnAnimation(mParent);
+        } else {
+            // Otherwise if we're in the middle of a trigger, draw that.
+            if (mTriggerPercentage > 0 && mTriggerPercentage <= 1.0) {
+                drawTrigger(canvas, cx, cy);
+            }
+        }
+        canvas.restoreToCount(restoreCount);
+    }
+
+    private void drawTrigger(Canvas canvas, int cx, int cy) {
+        mPaint.setColor(mColor1);
+        canvas.drawCircle(cx, cy, cx * mTriggerPercentage, mPaint);
+    }
+
+    /**
+     * Draws a circle centered in the view.
+     *
+     * @param canvas the canvas to draw on
+     * @param cx the center x coordinate
+     * @param cy the center y coordinate
+     * @param color the color to draw
+     * @param pct the percentage of the view that the circle should cover
+     */
+    private void drawCircle(Canvas canvas, float cx, float cy, int color, float pct) {
+        mPaint.setColor(color);
+        canvas.save();
+        canvas.translate(cx, cy);
+        float radiusScale = INTERPOLATOR.getInterpolation(pct);
+        canvas.scale(radiusScale, radiusScale);
+        canvas.drawCircle(0, 0, cx, mPaint);
+        canvas.restore();
+    }
+
+    /**
+     * Set the drawing bounds of this SwipeProgressBar.
+     */
+    void setBounds(int left, int top, int right, int bottom) {
+        mBounds.left = left;
+        mBounds.top = top;
+        mBounds.right = right;
+        mBounds.bottom = bottom;
+    }
+}