android开发之自定义加载进度条

最近，有点闲，一闲就出事！没事就想去论坛呀，贴吧呀，去逛逛，看看有没有关于我大安卓的一些新的技术或者好用的开源框架，这不，下面我要和大家聊的就是关于加载数据时会出现的一个用户友好的进度条，如图1-1：



想这样的自定义的进度条，它只能支持到Android 4.0及以上版本，因此会有一些局限性，当然下面的下面我会讲一个兼容到Android 2.3版本的进度条！耐心等着吧，各位！

首先，让我们一起来瞧瞧这个进度条怎么破：

第一步：上布局！

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
>

<ryancheng.example.progressbar.CircularProgress
android:layout_width="60dp"
android:layout_height="60dp"
app:borderWidth="6dp"
android:layout_centerInParent="true" />

</RelativeLayout>

在布局中，引用了自定义属性和自定义View，那么，首先先说说自定义属性：

①.自定义属性：/res/values/attrs.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="CircularProgress">
<attr name="borderWidth" format="dimension" />
</declare-styleable>
</resources>

②.自定义View：

import android.animation.Animator;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Cap;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.Property;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.Interpolator;
import android.view.animation.LinearInterpolator;

public class CircularProgress extends View {

private static final Interpolator ANGLE_INTERPOLATOR = new LinearInterpolator();
private static final Interpolator SWEEP_INTERPOLATOR = new AccelerateDecelerateInterpolator();
private static final int ANGLE_ANIMATOR_DURATION = 2000;
private static final int SWEEP_ANIMATOR_DURATION = 900;
private static final int MIN_SWEEP_ANGLE = 30;
private static final int DEFAULT_BORDER_WIDTH = 3;
private final RectF fBounds = new RectF();

private ObjectAnimator mObjectAnimatorSweep;
private ObjectAnimator mObjectAnimatorAngle;
private boolean mModeAppearing = true;
private Paint mPaint;
private float mCurrentGlobalAngleOffset;
private float mCurrentGlobalAngle;
private float mCurrentSweepAngle;
private float mBorderWidth;
private boolean mRunning;
private int[] mColors;
private int mCurrentColorIndex;
private int mNextColorIndex;

public CircularProgress(Context context) {
this(context, null);
}

public CircularProgress(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}

public CircularProgress(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);

float density = context.getResources().getDisplayMetrics().density;
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CircularProgress, defStyleAttr, 0);
mBorderWidth = a.getDimension(R.styleable.CircularProgress_borderWidth, DEFAULT_BORDER_WIDTH * density);
a.recycle();
mColors = new int[4];
mColors[0] = context.getResources().getColor(R.color.red);
mColors[1] = context.getResources().getColor(R.color.yellow);
mColors[2] = context.getResources().getColor(R.color.green);
mColors[3] = context.getResources().getColor(R.color.blue);
mCurrentColorIndex = 0;
mNextColorIndex = 1;

mPaint = new Paint();
mPaint.setAntiAlias(true);
mPaint.setStyle(Paint.Style.STROKE);
mPaint.setStrokeCap(Cap.ROUND);
mPaint.setStrokeWidth(mBorderWidth);
mPaint.setColor(mColors[mCurrentColorIndex]);

setupAnimations();
}

private void start() {
if (isRunning()) {
return;
}
mRunning = true;
mObjectAnimatorAngle.start();
mObjectAnimatorSweep.start();
invalidate();
}

private void stop() {
if (!isRunning()) {
return;
}
mRunning = false;
mObjectAnimatorAngle.cancel();
mObjectAnimatorSweep.cancel();
invalidate();
}

private boolean isRunning() {
return mRunning;
}

@Override
protected void onVisibilityChanged(View changedView, int visibility) {
super.onVisibilityChanged(changedView, visibility);
if (visibility == VISIBLE) {
start();
} else {
stop();
}
}

@Override
protected void onAttachedToWindow() {
start();
super.onAttachedToWindow();
}

@Override
protected void onDetachedFromWindow() {
stop();
super.onDetachedFromWindow();
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
fBounds.left = mBorderWidth / 2f + .5f;
fBounds.right = w - mBorderWidth / 2f - .5f;
fBounds.top = mBorderWidth / 2f + .5f;
fBounds.bottom = h - mBorderWidth / 2f - .5f;
}

@Override
public void draw(Canvas canvas) {
super.draw(canvas);
float startAngle = mCurrentGlobalAngle - mCurrentGlobalAngleOffset;
float sweepAngle = mCurrentSweepAngle;
if (mModeAppearing) {
mPaint.setColor(gradient(mColors[mCurrentColorIndex], mColors[mNextColorIndex],
mCurrentSweepAngle / (360 - MIN_SWEEP_ANGLE * 2)));
sweepAngle += MIN_SWEEP_ANGLE;
} else {
startAngle = startAngle + sweepAngle;
sweepAngle = 360 - sweepAngle - MIN_SWEEP_ANGLE;
}
canvas.drawArc(fBounds, startAngle, sweepAngle, false, mPaint);
}

private static int gradient(int color1, int color2, float p) {
int r1 = (color1 & 0xff0000) >> 16;
int g1 = (color1 & 0xff00) >> 8;
int b1 = color1 & 0xff;
int r2 = (color2 & 0xff0000) >> 16;
int g2 = (color2 & 0xff00) >> 8;
int b2 = color2 & 0xff;
int newr = (int) (r2 * p + r1 * (1 - p));
int newg = (int) (g2 * p + g1 * (1 - p));
int newb = (int) (b2 * p + b1 * (1 - p));
return Color.argb(255, newr, newg, newb);
}

private void toggleAppearingMode() {
mModeAppearing = !mModeAppearing;
if (mModeAppearing) {
mCurrentColorIndex = ++mCurrentColorIndex % 4;
mNextColorIndex = ++mNextColorIndex % 4;
mCurrentGlobalAngleOffset = (mCurrentGlobalAngleOffset + MIN_SWEEP_ANGLE * 2) % 360;
}
}
// ////////////////////////////////////////////////////////////////////////////
// ////////////// Animation

private Property<CircularProgress, Float> mAngleProperty = new Property<CircularProgress, Float>(Float.class, "angle") {
@Override
public Float get(CircularProgress object) {
return object.getCurrentGlobalAngle();
}

@Override
public void set(CircularProgress object, Float value) {
object.setCurrentGlobalAngle(value);
}
};

private Property<CircularProgress, Float> mSweepProperty = new Property<CircularProgress, Float>(Float.class, "arc") {
@Override
public Float get(CircularProgress object) {
return object.getCurrentSweepAngle();
}

@Override
public void set(CircularProgress 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();
}
});
}

public void setCurrentGlobalAngle(float currentGlobalAngle) {
mCurrentGlobalAngle = currentGlobalAngle;
invalidate();
}

public float getCurrentGlobalAngle() {
return mCurrentGlobalAngle;
}

public void setCurrentSweepAngle(float currentSweepAngle) {
mCurrentSweepAngle = currentSweepAngle;
invalidate();
}

public float getCurrentSweepAngle() {
return mCurrentSweepAngle;
}
}

那么，这里有引用到颜色，我也给大家粘贴过来：

<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="red">#FFC93437</color>
<color name="blue">#FF375BF1</color>
<color name="yellow">#FFF7D23E</color>
<color name="green">#FF34A350</color>
</resources>

最后，如何去使用它，我想大家心里都有底咯！OK，搞定！当然，该项目只能Android 4.0以上版本才能使用哦！

import android.app.Activity;
import android.os.Bundle;

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}

想让Android 2.3都能兼容的进度条就跟我来吧！

第一步：上布局！

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:wheel="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#ffffff">
<com.zanelove.load_progress.view.ProgressWheel
android:id="@+id/progress_wheel"
android:layout_width="80dp"
android:layout_height="80dp"
android:layout_centerHorizontal="true"
wheel:matProg_barColor="#5588FF"
wheel:matProg_progressIndeterminate="true"
android:layout_centerInParent="true"
/>
</RelativeLayout>

同样的这里也引用了自定义属性和自定义View：

①.自定义属性：/res/values/attrs.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="ProgressWheel">
<attr name="matProg_progressIndeterminate" format="boolean"/>
<attr name="matProg_barColor" format="color"/>
<attr name="matProg_rimColor" format="color"/>
<attr name="matProg_rimWidth" format="dimension"/>
<attr name="matProg_spinSpeed" format="float"/>
<attr name="matProg_barSpinCycleTime" format="integer"/>
<attr name="matProg_circleRadius" format="dimension"/>
<attr name="matProg_fillRadius" format="boolean"/>
<attr name="matProg_barWidth" format="dimension"/>
<attr name="matProg_linearProgress" format="boolean"/>
</declare-styleable>
</resources>

②.自定义View：

public class ProgressWheel extends View {
private static final String TAG = ProgressWheel.class.getSimpleName();

//Sizes (with defaults in DP)
private int circleRadius = 28;
private int barWidth = 4;
private int rimWidth = 4;

private final int barLength = 16;
private final int barMaxLength = 270;

private boolean fillRadius = false;

private double timeStartGrowing = 0;
private double barSpinCycleTime = 460;
private float barExtraLength = 0;
private boolean barGrowingFromFront = true;

private long pausedTimeWithoutGrowing = 0;
private final long pauseGrowingTime = 200;

//Colors (with defaults)
private int barColor = 0xAA000000;
private int rimColor = 0x00FFFFFF;

//Paints
private Paint barPaint = new Paint();
private Paint rimPaint = new Paint();

//Rectangles
private RectF circleBounds = new RectF();

//Animation
//The amount of degrees per second
private float spinSpeed = 230.0f;
//private float spinSpeed = 120.0f;
// The last time the spinner was animated
private long lastTimeAnimated = 0;

private boolean linearProgress;

private float mProgress = 0.0f;
private float mTargetProgress = 0.0f;
private boolean isSpinning = false;

private ProgressCallback callback;

/**
* The constructor for the ProgressWheel
*
* @param context
* @param attrs
*/
public ProgressWheel(Context context, AttributeSet attrs) {
super(context, attrs);

parseAttributes(context.obtainStyledAttributes(attrs,
R.styleable.ProgressWheel));
}

/**
* The constructor for the ProgressWheel
*
* @param context
*/
public ProgressWheel(Context context) {
super(context);
}

//----------------------------------
//Setting up stuff
//----------------------------------

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);

int viewWidth = circleRadius + this.getPaddingLeft() + this.getPaddingRight();
int viewHeight = circleRadius + this.getPaddingTop() + this.getPaddingBottom();

int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);

int width;
int height;

//Measure Width
if (widthMode == MeasureSpec.EXACTLY) {
//Must be this size
width = widthSize;
} else if (widthMode == MeasureSpec.AT_MOST) {
//Can't be bigger than...
width = Math.min(viewWidth, widthSize);
} else {
//Be whatever you want
width = viewWidth;
}

//Measure Height
if (heightMode == MeasureSpec.EXACTLY || widthMode == MeasureSpec.EXACTLY) {
//Must be this size
height = heightSize;
} else if (heightMode == MeasureSpec.AT_MOST) {
//Can't be bigger than...
height = Math.min(viewHeight, heightSize);
} else {
//Be whatever you want
height = viewHeight;
}

setMeasuredDimension(width, height);
}

/**
* Use onSizeChanged instead of onAttachedToWindow to get the dimensions of the view,
* because this method is called after measuring the dimensions of MATCH_PARENT & WRAP_CONTENT.
* Use this dimensions to setup the bounds and paints.
*/
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);

setupBounds(w, h);
setupPaints();
invalidate();
}

/**
* Set the properties of the paints we're using to
* draw the progress wheel
*/
private void setupPaints() {
barPaint.setColor(barColor);
barPaint.setAntiAlias(true);
barPaint.setStyle(Paint.Style.STROKE);
barPaint.setStrokeWidth(barWidth);

rimPaint.setColor(rimColor);
rimPaint.setAntiAlias(true);
rimPaint.setStyle(Paint.Style.STROKE);
rimPaint.setStrokeWidth(rimWidth);
}

/**
* Set the bounds of the component
*/
private void setupBounds(int layout_width, int layout_height) {
int paddingTop = getPaddingTop();
int paddingBottom = getPaddingBottom();
int paddingLeft = getPaddingLeft();
int paddingRight = getPaddingRight();

if (!fillRadius) {
// Width should equal to Height, find the min value to setup the circle
int minValue = Math.min(layout_width - paddingLeft - paddingRight,
layout_height - paddingBottom - paddingTop);

int circleDiameter = Math.min(minValue, circleRadius * 2 - barWidth * 2);

// Calc the Offset if needed for centering the wheel in the available space
int xOffset = (layout_width - paddingLeft - paddingRight - circleDiameter) / 2 + paddingLeft;
int yOffset = (layout_height - paddingTop - paddingBottom - circleDiameter) / 2 + paddingTop;

circleBounds = new RectF(xOffset + barWidth,
yOffset + barWidth,
xOffset + circleDiameter - barWidth,
yOffset + circleDiameter - barWidth);
} else {
circleBounds = new RectF(paddingLeft + barWidth,
paddingTop + barWidth,
layout_width - paddingRight - barWidth,
layout_height - paddingBottom - barWidth);
}
}

/**
* Parse the attributes passed to the view from the XML
*
* @param a the attributes to parse
*/
private void parseAttributes(TypedArray a) {
// We transform the default values from DIP to pixels
DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
barWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, barWidth, metrics);
rimWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, rimWidth, metrics);
circleRadius = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, circleRadius, metrics);

circleRadius = (int) a.getDimension(R.styleable.ProgressWheel_matProg_circleRadius, circleRadius);

fillRadius = a.getBoolean(R.styleable.ProgressWheel_matProg_fillRadius, false);

barWidth = (int) a.getDimension(R.styleable.ProgressWheel_matProg_barWidth, barWidth);

rimWidth = (int) a.getDimension(R.styleable.ProgressWheel_matProg_rimWidth, rimWidth);

float baseSpinSpeed = a.getFloat(R.styleable.ProgressWheel_matProg_spinSpeed, spinSpeed / 360.0f);
spinSpeed = baseSpinSpeed * 360;

barSpinCycleTime = a.getInt(R.styleable.ProgressWheel_matProg_barSpinCycleTime, (int) barSpinCycleTime);

barColor = a.getColor(R.styleable.ProgressWheel_matProg_barColor, barColor);

rimColor = a.getColor(R.styleable.ProgressWheel_matProg_rimColor, rimColor);

linearProgress = a.getBoolean(R.styleable.ProgressWheel_matProg_linearProgress, false);

if (a.getBoolean(R.styleable.ProgressWheel_matProg_progressIndeterminate, false)) {
spin();
}

// Recycle
a.recycle();
}

public void setCallback(ProgressCallback progressCallback) {
callback = progressCallback;

if (!isSpinning) {
runCallback();
}
}

//----------------------------------
//Animation stuff
//----------------------------------

protected void onDraw(Canvas canvas) {
super.onDraw(canvas);

canvas.drawArc(circleBounds, 360, 360, false, rimPaint);

boolean mustInvalidate = false;

if (isSpinning) {
//Draw the spinning bar
mustInvalidate = true;

long deltaTime = (SystemClock.uptimeMillis() - lastTimeAnimated);
float deltaNormalized = deltaTime * spinSpeed / 1000.0f;

updateBarLength(deltaTime);

mProgress += deltaNormalized;
if (mProgress > 360) {
mProgress -= 360f;
}
lastTimeAnimated = SystemClock.uptimeMillis();

float from = mProgress - 90;
float length = barLength + barExtraLength;

if (isInEditMode()) {
from = 0;
length = 135;
}

canvas.drawArc(circleBounds, from, length, false,
barPaint);
} else {
float oldProgress = mProgress;

if (mProgress != mTargetProgress) {
//We smoothly increase the progress bar
mustInvalidate = true;

float deltaTime = (float) (SystemClock.uptimeMillis() - lastTimeAnimated) / 1000;
float deltaNormalized = deltaTime * spinSpeed;

mProgress = Math.min(mProgress + deltaNormalized, mTargetProgress);
lastTimeAnimated = SystemClock.uptimeMillis();
}

if (oldProgress != mProgress) {
runCallback();
}

float offset = 0.0f;
float progress = mProgress;
if (!linearProgress) {
float factor = 2.0f;
offset = (float) (1.0f - Math.pow(1.0f - mProgress / 360.0f, 2.0f * factor)) * 360.0f;
progress = (float) (1.0f - Math.pow(1.0f - mProgress / 360.0f, factor)) * 360.0f;
;
}

if (isInEditMode()) {
progress = 360;
}

canvas.drawArc(circleBounds, offset - 90, progress, false, barPaint);
}

if (mustInvalidate) {
invalidate();
}
}

@Override
protected void onVisibilityChanged(View changedView, int visibility) {
super.onVisibilityChanged(changedView, visibility);

if (visibility == VISIBLE) {
lastTimeAnimated = SystemClock.uptimeMillis();
}
}

private void updateBarLength(long deltaTimeInMilliSeconds) {
if (pausedTimeWithoutGrowing >= pauseGrowingTime) {
timeStartGrowing += deltaTimeInMilliSeconds;

if (timeStartGrowing > barSpinCycleTime) {
// We completed a size change cycle
// (growing or shrinking)
timeStartGrowing -= barSpinCycleTime;
//if(barGrowingFromFront) {
pausedTimeWithoutGrowing = 0;
//}
barGrowingFromFront = !barGrowingFromFront;
}

float distance = (float) Math.cos((timeStartGrowing / barSpinCycleTime + 1) * Math.PI) / 2 + 0.5f;
float destLength = (barMaxLength - barLength);

if (barGrowingFromFront) {
barExtraLength = distance * destLength;
} else {
float newLength = destLength * (1 - distance);
mProgress += (barExtraLength - newLength);
barExtraLength = newLength;
}
} else {
pausedTimeWithoutGrowing += deltaTimeInMilliSeconds;
}
}

/**
* Check if the wheel is currently spinning
*/

public boolean isSpinning() {
return isSpinning;
}

/**
* Reset the count (in increment mode)
*/
public void resetCount() {
mProgress = 0.0f;
mTargetProgress = 0.0f;
invalidate();
}

/**
* Turn off spin mode
*/
public void stopSpinning() {
isSpinning = false;
mProgress = 0.0f;
mTargetProgress = 0.0f;
invalidate();
}

/**
* Puts the view on spin mode
*/
public void spin() {
lastTimeAnimated = SystemClock.uptimeMillis();
isSpinning = true;
invalidate();
}

private void runCallback() {
if (callback != null) {
float normalizedProgress = (float) Math.round(mProgress * 100 / 360.0f) / 100;
callback.onProgressUpdate(normalizedProgress);
}
}

/**
* Set the progress to a specific value,
* the bar will smoothly animate until that value
*
* @param progress the progress between 0 and 1
*/
public void setProgress(float progress) {
if (isSpinning) {
mProgress = 0.0f;
isSpinning = false;

runCallback();
}

if (progress > 1.0f) {
progress -= 1.0f;
} else if (progress < 0) {
progress = 0;
}

if (progress == mTargetProgress) {
return;
}

// If we are currently in the right position
// we set again the last time animated so the
// animation starts smooth from here
if (mProgress == mTargetProgress) {
lastTimeAnimated = SystemClock.uptimeMillis();
}

mTargetProgress = Math.min(progress * 360.0f, 360.0f);

invalidate();
}

/**
* Set the progress to a specific value,
* the bar will be set instantly to that value
*
* @param progress the progress between 0 and 1
*/
public void setInstantProgress(float progress) {
if (isSpinning) {
mProgress = 0.0f;
isSpinning = false;
}

if (progress > 1.0f) {
progress -= 1.0f;
} else if (progress < 0) {
progress = 0;
}

if (progress == mTargetProgress) {
return;
}

mTargetProgress = Math.min(progress * 360.0f, 360.0f);
mProgress = mTargetProgress;
lastTimeAnimated = SystemClock.uptimeMillis();
invalidate();
}

// Great way to save a view's state http://stackoverflow.com/a/7089687/1991053 @Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();

WheelSavedState ss = new WheelSavedState(superState);

// We save everything that can be changed at runtime
ss.mProgress = this.mProgress;
ss.mTargetProgress = this.mTargetProgress;
ss.isSpinning = this.isSpinning;
ss.spinSpeed = this.spinSpeed;
ss.barWidth = this.barWidth;
ss.barColor = this.barColor;
ss.rimWidth = this.rimWidth;
ss.rimColor = this.rimColor;
ss.circleRadius = this.circleRadius;
ss.linearProgress = this.linearProgress;
ss.fillRadius = this.fillRadius;

return ss;
}

@Override
public void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof WheelSavedState)) {
super.onRestoreInstanceState(state);
return;
}

WheelSavedState ss = (WheelSavedState) state;
super.onRestoreInstanceState(ss.getSuperState());

this.mProgress = ss.mProgress;
this.mTargetProgress = ss.mTargetProgress;
this.isSpinning = ss.isSpinning;
this.spinSpeed = ss.spinSpeed;
this.barWidth = ss.barWidth;
this.barColor = ss.barColor;
this.rimWidth = ss.rimWidth;
this.rimColor = ss.rimColor;
this.circleRadius = ss.circleRadius;
this.linearProgress = ss.linearProgress;
this.fillRadius = ss.fillRadius;
}

//----------------------------------
//Getters + setters
//----------------------------------

/**
* @return the current progress between 0.0 and 1.0,
* if the wheel is indeterminate, then the result is -1
*/
public float getProgress() {
return isSpinning ? -1 : mProgress / 360.0f;
}

/**
* Sets the determinate progress mode
*
* @param isLinear if the progress should increase linearly
*/
public void setLinearProgress(boolean isLinear) {
linearProgress = isLinear;
if (!isSpinning) {
invalidate();
}
}

/**
* @return the radius of the wheel in pixels
*/
public int getCircleRadius() {
return circleRadius;
}

/**
* Sets the radius of the wheel
*
* @param circleRadius the expected radius, in pixels
*/
public void setCircleRadius(int circleRadius) {
this.circleRadius = circleRadius;
if (!isSpinning) {
invalidate();
}
}

/**
* @return the width of the spinning bar
*/
public int getBarWidth() {
return barWidth;
}

/**
* Sets the width of the spinning bar
*
* @param barWidth the spinning bar width in pixels
*/
public void setBarWidth(int barWidth) {
this.barWidth = barWidth;
if (!isSpinning) {
invalidate();
}
}

/**
* @return the color of the spinning bar
*/
public int getBarColor() {
return barColor;
}

/**
* Sets the color of the spinning bar
*
* @param barColor The spinning bar color
*/
public void setBarColor(int barColor) {
this.barColor = barColor;
setupPaints();
if (!isSpinning) {
invalidate();
}
}

/**
* @return the color of the wheel's contour
*/
public int getRimColor() {
return rimColor;
}

/**
* Sets the color of the wheel's contour
*
* @param rimColor the color for the wheel
*/
public void setRimColor(int rimColor) {
this.rimColor = rimColor;
setupPaints();
if (!isSpinning) {
invalidate();
}
}

/**
* @return the base spinning speed, in full circle turns per second
* (1.0 equals on full turn in one second), this value also is applied for
* the smoothness when setting a progress
*/
public float getSpinSpeed() {
return spinSpeed / 360.0f;
}

/**
* Sets the base spinning speed, in full circle turns per second
* (1.0 equals on full turn in one second), this value also is applied for
* the smoothness when setting a progress
*
* @param spinSpeed the desired base speed in full turns per second
*/
public void setSpinSpeed(float spinSpeed) {
this.spinSpeed = spinSpeed * 360.0f;
}

/**
* @return the width of the wheel's contour in pixels
*/
public int getRimWidth() {
return rimWidth;
}

/**
* Sets the width of the wheel's contour
*
* @param rimWidth the width in pixels
*/
public void setRimWidth(int rimWidth) {
this.rimWidth = rimWidth;
if (!isSpinning) {
invalidate();
}
}

static class WheelSavedState extends BaseSavedState {
float mProgress;
float mTargetProgress;
boolean isSpinning;
float spinSpeed;
int barWidth;
int barColor;
int rimWidth;
int rimColor;
int circleRadius;
boolean linearProgress;
boolean fillRadius;

WheelSavedState(Parcelable superState) {
super(superState);
}

private WheelSavedState(Parcel in) {
super(in);
this.mProgress = in.readFloat();
this.mTargetProgress = in.readFloat();
this.isSpinning = in.readByte() != 0;
this.spinSpeed = in.readFloat();
this.barWidth = in.readInt();
this.barColor = in.readInt();
this.rimWidth = in.readInt();
this.rimColor = in.readInt();
this.circleRadius = in.readInt();
this.linearProgress = in.readByte() != 0;
this.fillRadius = in.readByte() != 0;
}

@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeFloat(this.mProgress);
out.writeFloat(this.mTargetProgress);
out.writeByte((byte) (isSpinning ? 1 : 0));
out.writeFloat(this.spinSpeed);
out.writeInt(this.barWidth);
out.writeInt(this.barColor);
out.writeInt(this.rimWidth);
out.writeInt(this.rimColor);
out.writeInt(this.circleRadius);
out.writeByte((byte) (linearProgress ? 1 : 0));
out.writeByte((byte) (fillRadius ? 1 : 0));
}

//required field that makes Parcelables from a Parcel
public static final Parcelable.Creator<WheelSavedState> CREATOR =
new Parcelable.Creator<WheelSavedState>() {
public WheelSavedState createFromParcel(Parcel in) {
return new WheelSavedState(in);
}

public WheelSavedState[] newArray(int size) {
return new WheelSavedState[size];
}
};
}

public interface ProgressCallback {
/**
* Method to call when the progress reaches a value
* in order to avoid float precision issues, the progress
* is rounded to a long with two decimals
*
* @param progress a double value between 0.00 and 1.00 both included
*/
public void onProgressUpdate(float progress);
}
}

最后的使用：

public class MyActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}