The Tor Browser: comparison mobile/android/base/widget/GeckoSwipeRefreshLayout.java

--1:000000000000
+:0fb8615e8f7b
+/*
+* 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 org.mozilla.gecko.widget;
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.support.v4.view.ViewCompat;
+import android.util.AttributeSet;
+import android.util.DisplayMetrics;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.Animation;
+import android.view.animation.Animation.AnimationListener;
+import android.view.animation.AnimationUtils;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+import android.view.animation.Transformation;
+import android.widget.AbsListView;
+/**
+* GeckoSwipeRefreshLayout is mostly lifted from Android's support library (v4) with these
+* modfications:
+*  - Removes elastic "rubber banding" effect when overscrolling the child view.
+*  - Changes the height of the progress bar to match the height of HomePager's page indicator.
+*  - Uses a rectangle rather than a circle for the SwipeProgressBar indicator.
+*
+* This class also embeds package-access dependent classes SwipeProgressBar and
+* BakedBezierInterpolator.
+*
+* Original source: https://android.googlesource.com/platform/frameworks/support/+/
+* android-support-lib-19.1.0/v4/java/android/support/v4/widget/SwipeRefreshLayout.java
+*/
+public class GeckoSwipeRefreshLayout extends ViewGroup {
+private static final long RETURN_TO_ORIGINAL_POSITION_TIMEOUT = 300;
+private static final float ACCELERATE_INTERPOLATION_FACTOR = 1.5f;
+private static final float DECELERATE_INTERPOLATION_FACTOR = 2f;
+// Reduce the height (from 4 to 3) of the progress bar to match HomePager's page indicator.
+private static final float PROGRESS_BAR_HEIGHT = 3;
+private static final float MAX_SWIPE_DISTANCE_FACTOR = .6f;
+private static final int REFRESH_TRIGGER_DISTANCE = 120;
+private SwipeProgressBar mProgressBar; //the thing that shows progress is going
+private View mTarget; //the content that gets pulled down
+private int mOriginalOffsetTop;
+private OnRefreshListener mListener;
+private MotionEvent mDownEvent;
+private int mFrom;
+private boolean mRefreshing = false;
+private int mTouchSlop;
+private float mDistanceToTriggerSync = -1;
+private float mPrevY;
+private int mMediumAnimationDuration;
+private float mFromPercentage = 0;
+private float mCurrPercentage = 0;
+private int mProgressBarHeight;
+private int mCurrentTargetOffsetTop;
+// Target is returning to its start offset because it was cancelled or a
+// refresh was triggered.
+private boolean mReturningToStart;
+private final DecelerateInterpolator mDecelerateInterpolator;
+private final AccelerateInterpolator mAccelerateInterpolator;
+private static final int[] LAYOUT_ATTRS = new int[] {
+android.R.attr.enabled
+};
+private final Animation mAnimateToStartPosition = new Animation() {
+@Override
+public void applyTransformation(float interpolatedTime, Transformation t) {
+int targetTop = 0;
+if (mFrom != mOriginalOffsetTop) {
+targetTop = (mFrom + (int)((mOriginalOffsetTop - mFrom) * interpolatedTime));
+}
+int offset = targetTop - mTarget.getTop();
+final int currentTop = mTarget.getTop();
+if (offset + currentTop < 0) {
+offset = 0 - currentTop;
+}
+setTargetOffsetTopAndBottom(offset);
+}
+};
+private Animation mShrinkTrigger = new Animation() {
+@Override
+public void applyTransformation(float interpolatedTime, Transformation t) {
+float percent = mFromPercentage + ((0 - mFromPercentage) * interpolatedTime);
+mProgressBar.setTriggerPercentage(percent);
+}
+};
+private final AnimationListener mReturnToStartPositionListener = new BaseAnimationListener() {
+@Override
+public void onAnimationEnd(Animation animation) {
+// Once the target content has returned to its start position, reset
+// the target offset to 0
+mCurrentTargetOffsetTop = 0;
+}
+};
+private final AnimationListener mShrinkAnimationListener = new BaseAnimationListener() {
+@Override
+public void onAnimationEnd(Animation animation) {
+mCurrPercentage = 0;
+}
+};
+private final Runnable mReturnToStartPosition = new Runnable() {
+@Override
+public void run() {
+mReturningToStart = true;
+animateOffsetToStartPosition(mCurrentTargetOffsetTop + getPaddingTop(),
+mReturnToStartPositionListener);
+}
+};
+// Cancel the refresh gesture and animate everything back to its original state.
+private final Runnable mCancel = new Runnable() {
+@Override
+public void run() {
+mReturningToStart = true;
+// Timeout fired since the user last moved their finger; animate the
+// trigger to 0 and put the target back at its original position
+if (mProgressBar != null) {
+mFromPercentage = mCurrPercentage;
+mShrinkTrigger.setDuration(mMediumAnimationDuration);
+mShrinkTrigger.setAnimationListener(mShrinkAnimationListener);
+mShrinkTrigger.reset();
+mShrinkTrigger.setInterpolator(mDecelerateInterpolator);
+startAnimation(mShrinkTrigger);
+}
+animateOffsetToStartPosition(mCurrentTargetOffsetTop + getPaddingTop(),
+mReturnToStartPositionListener);
+}
+};
+/**
+* Simple constructor to use when creating a GeckoSwipeRefreshLayout from code.
+* @param context
+*/
+public GeckoSwipeRefreshLayout(Context context) {
+this(context, null);
+}
+/**
+* Constructor that is called when inflating GeckoSwipeRefreshLayout from XML.
+* @param context
+* @param attrs
+*/
+public GeckoSwipeRefreshLayout(Context context, AttributeSet attrs) {
+super(context, attrs);
+mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
+mMediumAnimationDuration = getResources().getInteger(
+android.R.integer.config_mediumAnimTime);
+setWillNotDraw(false);
+mProgressBar = new SwipeProgressBar(this);
+final DisplayMetrics metrics = getResources().getDisplayMetrics();
+mProgressBarHeight = (int) (metrics.density * PROGRESS_BAR_HEIGHT);
+mDecelerateInterpolator = new DecelerateInterpolator(DECELERATE_INTERPOLATION_FACTOR);
+mAccelerateInterpolator = new AccelerateInterpolator(ACCELERATE_INTERPOLATION_FACTOR);
+final TypedArray a = context.obtainStyledAttributes(attrs, LAYOUT_ATTRS);
+setEnabled(a.getBoolean(0, true));
+a.recycle();
+}
+@Override
+public void onAttachedToWindow() {
+super.onAttachedToWindow();
+removeCallbacks(mCancel);
+removeCallbacks(mReturnToStartPosition);
+}
+@Override
+public void onDetachedFromWindow() {
+super.onDetachedFromWindow();
+removeCallbacks(mReturnToStartPosition);
+removeCallbacks(mCancel);
+}
+private void animateOffsetToStartPosition(int from, AnimationListener listener) {
+mFrom = from;
+mAnimateToStartPosition.reset();
+mAnimateToStartPosition.setDuration(mMediumAnimationDuration);
+mAnimateToStartPosition.setAnimationListener(listener);
+mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
+mTarget.startAnimation(mAnimateToStartPosition);
+}
+/**
+* Set the listener to be notified when a refresh is triggered via the swipe
+* gesture.
+*/
+public void setOnRefreshListener(OnRefreshListener listener) {
+mListener = listener;
+}
+private void setTriggerPercentage(float percent) {
+if (percent == 0f) {
+// No-op. A null trigger means it's uninitialized, and setting it to zero-percent
+// means we're trying to reset state, so there's nothing to reset in this case.
+mCurrPercentage = 0;
+return;
+}
+mCurrPercentage = percent;
+mProgressBar.setTriggerPercentage(percent);
+}
+/**
+* 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 (mRefreshing != refreshing) {
+ensureTarget();
+mCurrPercentage = 0;
+mRefreshing = refreshing;
+if (mRefreshing) {
+mProgressBar.start();
+} else {
+mProgressBar.stop();
+}
+}
+}
+/**
+* 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 colorRes1 Color resource.
+* @param colorRes2 Color resource.
+* @param colorRes3 Color resource.
+* @param colorRes4 Color resource.
+*/
+public void setColorScheme(int colorRes1, int colorRes2, int colorRes3, int colorRes4) {
+ensureTarget();
+final Resources res = getResources();
+final int color1 = res.getColor(colorRes1);
+final int color2 = res.getColor(colorRes2);
+final int color3 = res.getColor(colorRes3);
+final int color4 = res.getColor(colorRes4);
+mProgressBar.setColorScheme(color1, color2, color3,color4);
+}
+/**
+* @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) {
+if (getChildCount() > 1 && !isInEditMode()) {
+throw new IllegalStateException(
+"GeckoSwipeRefreshLayout can host only one direct child");
+}
+mTarget = getChildAt(0);
+mOriginalOffsetTop = mTarget.getTop() + getPaddingTop();
+}
+if (mDistanceToTriggerSync == -1) {
+if (getParent() != null && ((View)getParent()).getHeight() > 0) {
+final DisplayMetrics metrics = getResources().getDisplayMetrics();
+mDistanceToTriggerSync = (int) Math.min(
+((View) getParent()) .getHeight() * MAX_SWIPE_DISTANCE_FACTOR,
+REFRESH_TRIGGER_DISTANCE * metrics.density);
+}
+}
+}
+@Override
+public void draw(Canvas canvas) {
+super.draw(canvas);
+mProgressBar.draw(canvas);
+}
+@Override
+protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+final int width =  getMeasuredWidth();
+final int height = getMeasuredHeight();
+mProgressBar.setBounds(0, 0, width, mProgressBarHeight);
+if (getChildCount() == 0) {
+return;
+}
+final View child = getChildAt(0);
+final int childLeft = getPaddingLeft();
+final int childTop = mCurrentTargetOffsetTop + getPaddingTop();
+final int childWidth = width - getPaddingLeft() - getPaddingRight();
+final int childHeight = height - getPaddingTop() - getPaddingBottom();
+child.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight);
+}
+@Override
+public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+if (getChildCount() > 1 && !isInEditMode()) {
+throw new IllegalStateException("GeckoSwipeRefreshLayout can host only one direct child");
+}
+if (getChildCount() > 0) {
+getChildAt(0).measure(
+MeasureSpec.makeMeasureSpec(
+getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),
+MeasureSpec.EXACTLY),
+MeasureSpec.makeMeasureSpec(
+getMeasuredHeight() - getPaddingTop() - getPaddingBottom(),
+MeasureSpec.EXACTLY));
+}
+}
+/**
+* @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);
+}
+}
+@Override
+public boolean onInterceptTouchEvent(MotionEvent ev) {
+ensureTarget();
+boolean handled = false;
+if (mReturningToStart && ev.getAction() == MotionEvent.ACTION_DOWN) {
+mReturningToStart = false;
+}
+if (isEnabled() && !mReturningToStart && !canChildScrollUp()) {
+handled = onTouchEvent(ev);
+}
+return !handled ? super.onInterceptTouchEvent(ev) : handled;
+}
+@Override
+public void requestDisallowInterceptTouchEvent(boolean b) {
+// Nope.
+}
+@Override
+public boolean onTouchEvent(MotionEvent event) {
+final int action = event.getAction();
+boolean handled = false;
+switch (action) {
+case MotionEvent.ACTION_DOWN:
+mCurrPercentage = 0;
+mDownEvent = MotionEvent.obtain(event);
+mPrevY = mDownEvent.getY();
+break;
+case MotionEvent.ACTION_MOVE:
+if (mDownEvent != null && !mReturningToStart) {
+final float eventY = event.getY();
+float yDiff = eventY - mDownEvent.getY();
+if (yDiff > mTouchSlop) {
+// User velocity passed min velocity; trigger a refresh
+if (yDiff > mDistanceToTriggerSync) {
+// User movement passed distance; trigger a refresh
+startRefresh();
+handled = true;
+break;
+} else {
+// Just track the user's movement
+setTriggerPercentage(
+mAccelerateInterpolator.getInterpolation(
+yDiff / mDistanceToTriggerSync));
+float offsetTop = yDiff;
+if (mPrevY > eventY) {
+offsetTop = yDiff - mTouchSlop;
+}
+// Removed this call to disable "rubber-band" overscroll effect.
+// updateContentOffsetTop((int) offsetTop);
+if (mPrevY > eventY && (mTarget.getTop() < mTouchSlop)) {
+// If the user puts the view back at the top, we
+// don't need to. This shouldn't be considered
+// cancelling the gesture as the user can restart from the top.
+removeCallbacks(mCancel);
+} else {
+updatePositionTimeout();
+}
+mPrevY = event.getY();
+handled = true;
+}
+}
+}
+break;
+case MotionEvent.ACTION_UP:
+case MotionEvent.ACTION_CANCEL:
+if (mDownEvent != null) {
+mDownEvent.recycle();
+mDownEvent = null;
+}
+break;
+}
+return handled;
+}
+private void startRefresh() {
+removeCallbacks(mCancel);
+mReturnToStartPosition.run();
+setRefreshing(true);
+mListener.onRefresh();
+}
+private void updateContentOffsetTop(int targetTop) {
+final int currentTop = mTarget.getTop();
+if (targetTop > mDistanceToTriggerSync) {
+targetTop = (int) mDistanceToTriggerSync;
+} else if (targetTop < 0) {
+targetTop = 0;
+}
+setTargetOffsetTopAndBottom(targetTop - currentTop);
+}
+private void setTargetOffsetTopAndBottom(int offset) {
+mTarget.offsetTopAndBottom(offset);
+mCurrentTargetOffsetTop = mTarget.getTop();
+}
+private void updatePositionTimeout() {
+removeCallbacks(mCancel);
+postDelayed(mCancel, RETURN_TO_ORIGINAL_POSITION_TIMEOUT);
+}
+/**
+* Classes that wish to be notified when the swipe gesture correctly
+* triggers a refresh should implement this interface.
+*/
+public interface OnRefreshListener {
+public void onRefresh();
+}
+/**
+* Simple AnimationListener to avoid having to implement unneeded methods in
+* AnimationListeners.
+*/
+private class BaseAnimationListener implements AnimationListener {
+@Override
+public void onAnimationStart(Animation animation) {
+}
+@Override
+public void onAnimationEnd(Animation animation) {
+}
+@Override
+public void onAnimationRepeat(Animation animation) {
+}
+}
+/**
+* The only modification to this class is the shape of the refresh indicator to be a rectangle
+* rather than a circle.
+*/
+private static 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);
+// Use a rectangle to instead of a circle as per UX.
+// canvas.drawCircle(cx, cy, cx * mTriggerPercentage, mPaint);
+canvas.drawRect(cx - cx * mTriggerPercentage, 0, cx + cx * mTriggerPercentage,
+mBounds.bottom, 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;
+}
+}
+private static 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]);
+}
+}
+}

The Tor Browser / file comparison

comparison: mobile/android/base/widget/GeckoSwipeRefreshLayout.java

mobile/android/base/widget/GeckoSwipeRefreshLayout.java