Forked from castorflex/CircularProgressDrawable.java
Last active
February 23, 2022 02:17
-
-
Save npike/42aebf17f8c1febf2eea to your computer and use it in GitHub Desktop.
An indeterminate progress bar implementation that looks like the Android 5.0 indeterminate progress bar.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<?xml version="1.0" encoding="utf-8"?> | |
<resources> | |
<declare-styleable name="MaterialIndeterminateProgressBar"> | |
<attr name="progressColor" format="color|reference" /> | |
<attr name="borderWidth" format="dimension|reference" /> | |
</declare-styleable> | |
</resources> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import android.animation.Animator; | |
import android.animation.ObjectAnimator; | |
import android.animation.ValueAnimator; | |
import android.graphics.Canvas; | |
import android.graphics.ColorFilter; | |
import android.graphics.Paint; | |
import android.graphics.PixelFormat; | |
import android.graphics.Rect; | |
import android.graphics.RectF; | |
import android.graphics.drawable.Animatable; | |
import android.graphics.drawable.Drawable; | |
import android.util.Property; | |
import android.view.animation.DecelerateInterpolator; | |
import android.view.animation.Interpolator; | |
import android.view.animation.LinearInterpolator; | |
public class CircularProgressDrawable extends Drawable | |
implements Animatable { | |
private static final Interpolator ANGLE_INTERPOLATOR = new LinearInterpolator(); | |
private static final Interpolator SWEEP_INTERPOLATOR = new DecelerateInterpolator(); | |
private static final int ANGLE_ANIMATOR_DURATION = 2000; | |
private static final int SWEEP_ANIMATOR_DURATION = 600; | |
private static final int MIN_SWEEP_ANGLE = 30; | |
private final RectF fBounds = new RectF(); | |
private ObjectAnimator mObjectAnimatorSweep; | |
private ObjectAnimator mObjectAnimatorAngle; | |
private boolean mModeAppearing; | |
private Paint mPaint; | |
private float mCurrentGlobalAngleOffset; | |
private float mCurrentGlobalAngle; | |
private float mCurrentSweepAngle; | |
private float mBorderWidth; | |
private boolean mRunning; | |
public CircularProgressDrawable(int color, float borderWidth) { | |
mBorderWidth = borderWidth; | |
mPaint = new Paint(); | |
mPaint.setAntiAlias(true); | |
mPaint.setStyle(Paint.Style.STROKE); | |
mPaint.setStrokeWidth(borderWidth); | |
mPaint.setColor(color); | |
setupAnimations(); | |
} | |
@Override | |
public void draw(Canvas canvas) { | |
float startAngle = mCurrentGlobalAngle - mCurrentGlobalAngleOffset; | |
float sweepAngle = mCurrentSweepAngle; | |
if (!mModeAppearing) { | |
startAngle = startAngle + sweepAngle; | |
sweepAngle = 360 - sweepAngle - MIN_SWEEP_ANGLE; | |
} else { | |
sweepAngle += MIN_SWEEP_ANGLE; | |
} | |
canvas.drawArc(fBounds, startAngle, sweepAngle, false, mPaint); | |
} | |
@Override | |
public void setAlpha(int alpha) { | |
mPaint.setAlpha(alpha); | |
} | |
@Override | |
public void setColorFilter(ColorFilter cf) { | |
mPaint.setColorFilter(cf); | |
} | |
@Override | |
public int getOpacity() { | |
return PixelFormat.TRANSPARENT; | |
} | |
private void toggleAppearingMode() { | |
mModeAppearing = !mModeAppearing; | |
if (mModeAppearing) { | |
mCurrentGlobalAngleOffset = (mCurrentGlobalAngleOffset + MIN_SWEEP_ANGLE * 2) % 360; | |
} | |
} | |
@Override | |
protected void onBoundsChange(Rect bounds) { | |
super.onBoundsChange(bounds); | |
fBounds.left = bounds.left + mBorderWidth / 2f + .5f; | |
fBounds.right = bounds.right - mBorderWidth / 2f - .5f; | |
fBounds.top = bounds.top + mBorderWidth / 2f + .5f; | |
fBounds.bottom = bounds.bottom - mBorderWidth / 2f - .5f; | |
} | |
////////////////////////////////////////////////////////////////////////////// | |
//////////////// Animation | |
private Property<CircularProgressDrawable, Float> mAngleProperty | |
= new Property<CircularProgressDrawable, Float>(Float.class, "angle") { | |
@Override | |
public Float get(CircularProgressDrawable object) { | |
return object.getCurrentGlobalAngle(); | |
} | |
@Override | |
public void set(CircularProgressDrawable object, Float value) { | |
object.setCurrentGlobalAngle(value); | |
} | |
}; | |
private Property<CircularProgressDrawable, Float> mSweepProperty | |
= new Property<CircularProgressDrawable, Float>(Float.class, "arc") { | |
@Override | |
public Float get(CircularProgressDrawable object) { | |
return object.getCurrentSweepAngle(); | |
} | |
@Override | |
public void set(CircularProgressDrawable object, Float value) { | |
object.setCurrentSweepAngle(value); | |
} | |
}; | |
private void setupAnimations() { | |
mObjectAnimatorAngle = ObjectAnimator.ofFloat(this, mAngleProperty, 360f); | |
mObjectAnimatorAngle.setInterpolator(ANGLE_INTERPOLATOR); | |
mObjectAnimatorAngle.setDuration(ANGLE_ANIMATOR_DURATION); | |
mObjectAnimatorAngle.setRepeatMode(ValueAnimator.RESTART); | |
mObjectAnimatorAngle.setRepeatCount(ValueAnimator.INFINITE); | |
mObjectAnimatorSweep = ObjectAnimator.ofFloat(this, mSweepProperty, 360f - MIN_SWEEP_ANGLE * 2); | |
mObjectAnimatorSweep.setInterpolator(SWEEP_INTERPOLATOR); | |
mObjectAnimatorSweep.setDuration(SWEEP_ANIMATOR_DURATION); | |
mObjectAnimatorSweep.setRepeatMode(ValueAnimator.RESTART); | |
mObjectAnimatorSweep.setRepeatCount(ValueAnimator.INFINITE); | |
mObjectAnimatorSweep.addListener(new Animator.AnimatorListener() { | |
@Override | |
public void onAnimationStart(Animator animation) { | |
} | |
@Override | |
public void onAnimationEnd(Animator animation) { | |
} | |
@Override | |
public void onAnimationCancel(Animator animation) { | |
} | |
@Override | |
public void onAnimationRepeat(Animator animation) { | |
toggleAppearingMode(); | |
} | |
}); | |
} | |
@Override | |
public void start() { | |
if (isRunning()) { | |
return; | |
} | |
mRunning = true; | |
mObjectAnimatorAngle.start(); | |
mObjectAnimatorSweep.start(); | |
invalidateSelf(); | |
} | |
@Override | |
public void stop() { | |
if (!isRunning()) { | |
return; | |
} | |
mRunning = false; | |
mObjectAnimatorAngle.cancel(); | |
mObjectAnimatorSweep.cancel(); | |
invalidateSelf(); | |
} | |
@Override | |
public boolean isRunning() { | |
return mRunning; | |
} | |
public void setCurrentGlobalAngle(float currentGlobalAngle) { | |
mCurrentGlobalAngle = currentGlobalAngle; | |
invalidateSelf(); | |
} | |
public float getCurrentGlobalAngle() { | |
return mCurrentGlobalAngle; | |
} | |
public void setCurrentSweepAngle(float currentSweepAngle) { | |
mCurrentSweepAngle = currentSweepAngle; | |
invalidateSelf(); | |
} | |
public float getCurrentSweepAngle() { | |
return mCurrentSweepAngle; | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import android.content.Context; | |
import android.content.res.TypedArray; | |
import android.graphics.Canvas; | |
import android.graphics.Color; | |
import android.graphics.drawable.Drawable; | |
import android.util.AttributeSet; | |
import android.view.View; | |
import com.phunware.engageme.render.R; | |
/** | |
* Simplest custom view possible, using CircularProgressDrawable | |
*/ | |
public class MaterialIndeterminateProgressBar extends View { | |
private CircularProgressDrawable mDrawable; | |
public MaterialIndeterminateProgressBar(Context context) { | |
this(context, null); | |
} | |
public MaterialIndeterminateProgressBar(Context context, AttributeSet attrs) { | |
this(context, attrs, 0); | |
} | |
public MaterialIndeterminateProgressBar(Context context, AttributeSet attrs, int defStyleAttr) { | |
super(context, attrs, defStyleAttr); | |
TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.MaterialIndeterminateProgressBar); | |
int color = array.getColor(R.styleable.MaterialIndeterminateProgressBar_progressColor, Color.WHITE); | |
float borderWidth = array.getDimension(R.styleable.MaterialIndeterminateProgressBar_borderWidth, 2); | |
array.recycle(); | |
mDrawable = new CircularProgressDrawable(color, borderWidth); | |
mDrawable.setCallback(this); | |
} | |
@Override | |
protected void onVisibilityChanged(View changedView, int visibility) { | |
super.onVisibilityChanged(changedView, visibility); | |
if (visibility == VISIBLE) { | |
mDrawable.start(); | |
} else { | |
mDrawable.stop(); | |
} | |
} | |
@Override | |
protected void onSizeChanged(int w, int h, int oldw, int oldh) { | |
super.onSizeChanged(w, h, oldw, oldh); | |
mDrawable.setBounds(0, 0, w, h); | |
} | |
@Override | |
public void draw(Canvas canvas) { | |
super.draw(canvas); | |
mDrawable.draw(canvas); | |
} | |
@Override | |
protected boolean verifyDrawable(Drawable who) { | |
return who == mDrawable || super.verifyDrawable(who); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment