public class CircularProgressLayout extends FrameLayout {
private static final long DEFAULT_UPDATE_INTERVAL = 16L;
private static final float DEFAULT_ROTATION = 0.75F;
private CircularProgressDrawable mProgressDrawable;
private CircularProgressLayoutController mController;
private float mStartingRotation;
private long mTotalTime;

public CircularProgressLayout(Context context) {
this(context, (AttributeSet) null);
}

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

public CircularProgressLayout(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}

public CircularProgressLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs);
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
// super(context, attrs, defStyleAttr, defStyleRes);
// } else {
// super(context, attrs);
// }

this.mStartingRotation = 0.75F;
this.mProgressDrawable = new CircularProgressDrawable(context);
this.mProgressDrawable.setProgressRotation(0.75F);
this.mProgressDrawable.setStrokeCap(Cap.BUTT);
this.setBackground(this.mProgressDrawable);
this.setOnHierarchyChangeListener(new OnHierarchyChangeListener() {

@Override
public void onChildViewAdded(View parent, View child) {
LayoutParams params = (LayoutParams) child.getLayoutParams();
params.gravity = 17;
child.setLayoutParams(params);
}

@Override
public void onChildViewRemoved(View parent, View child) {
}
});
this.mController = new CircularProgressLayoutController(this);
Resources r = context.getResources();
TypedArray a = r.obtainAttributes(attrs, R.styleable.CircularProgressLayout);
int type = 0;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
type = a.getType(R.styleable.CircularProgressLayout_colorSchemeColors);
} else {
type = a.getInt(R.styleable.CircularProgressLayout_colorSchemeColors, 0);
}
if (type != 1 && a.hasValue(R.styleable.CircularProgressLayout_colorSchemeColors)) {
this.setColorSchemeColors(a.getColor(R.styleable.CircularProgressLayout_colorSchemeColors, -16777216));
} else {
int arrayResId = a.getResourceId(R.styleable.CircularProgressLayout_colorSchemeColors, R.array.circular_progress_layout_color_scheme_colors);
this.setColorSchemeColors(this.getColorListFromResources(r, arrayResId));
}

this.setStrokeWidth((float) a.getDimensionPixelSize(R.styleable.CircularProgressLayout_strokeWidth, r.getDimensionPixelSize(R.dimen.circular_progress_layout_stroke_width)));
this.setBackgroundColor(a.getColor(R.styleable.CircularProgressLayout_backgroundColor, ContextCompat.getColor(context, R.color.circular_progress_layout_background_color)));
this.setIndeterminate(a.getBoolean(R.styleable.CircularProgressLayout_indeterminate, false));
a.recycle();
}
}

private int[] getColorListFromResources(Resources resources, int arrayResId) {
TypedArray colorArray = resources.obtainTypedArray(arrayResId);
int[] colors = new int[colorArray.length()];

for (int i = 0; i < colorArray.length(); ++i) {
colors[i] = colorArray.getColor(i, 0);
}

colorArray.recycle();
return colors;
}

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
if (this.getChildCount() != 0) {
View childView = this.getChildAt(0);
this.mProgressDrawable.setCenterRadius((float) Math.min(childView.getWidth(), childView.getHeight()) / 2.0F);
} else {
this.mProgressDrawable.setCenterRadius(0.0F);
}
}

@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
this.mController.reset();
}

@Override
public void setBackgroundColor(@ColorInt int color) {
this.mProgressDrawable.setBackgroundColor(color);
}

@ColorInt
public int getBackgroundColor() {
return this.mProgressDrawable.getBackgroundColor();
}

@NonNull
public CircularProgressDrawable getProgressDrawable() {
return this.mProgressDrawable;
}

public void setIndeterminate(boolean indeterminate) {
this.mController.setIndeterminate(indeterminate);
}

public boolean isIndeterminate() {
return this.mController.isIndeterminate();
}

public void setTotalTime(long totalTime) {
if (totalTime <= 0L) {
throw new IllegalArgumentException("Total time should be greater than zero.");
} else {
this.mTotalTime = totalTime;
}
}

public long getTotalTime() {
return this.mTotalTime;
}

public void startTimer() {
this.mController.startTimer(this.mTotalTime, 16L);
this.mProgressDrawable.setProgressRotation(this.mStartingRotation);
}

public void stopTimer() {
this.mController.stopTimer();
}

public boolean isTimerRunning() {
return this.mController.isTimerRunning();
}

public void setStartingRotation(float rotation) {
this.mStartingRotation = rotation;
}

public float getStartingRotation() {
return this.mStartingRotation;
}

public void setStrokeWidth(float strokeWidth) {
this.mProgressDrawable.setStrokeWidth(strokeWidth);
}

public float getStrokeWidth() {
return this.mProgressDrawable.getStrokeWidth();
}

public void setColorSchemeColors(int... colors) {
this.mProgressDrawable.setColorSchemeColors(colors);
}

public int[] getColorSchemeColors() {
return this.mProgressDrawable.getColorSchemeColors();
}

@Nullable
public CircularProgressLayout.OnTimerFinishedListener getOnTimerFinishedListener() {
return this.mController.getOnTimerFinishedListener();
}

public void setOnTimerFinishedListener(@Nullable CircularProgressLayout.OnTimerFinishedListener listener) {
this.mController.setOnTimerFinishedListener(listener);
}

public interface OnTimerFinishedListener {
void onTimerFinished(CircularProgressLayout var1);
}
}

控制类

class CircularProgressLayoutController {
    final CircularProgressLayout mLayout;
    @VisibleForTesting
    CountDownTimer mTimer;
    private boolean mIsIndeterminate;
    boolean mIsTimerRunning;
    @Nullable
    CircularProgressLayout.OnTimerFinishedListener mOnTimerFinishedListener;

    CircularProgressLayoutController(CircularProgressLayout layout) {
        this.mLayout = layout;
    }

    @Nullable
    public CircularProgressLayout.OnTimerFinishedListener getOnTimerFinishedListener() {
        return this.mOnTimerFinishedListener;
    }

    public void setOnTimerFinishedListener(@Nullable CircularProgressLayout.OnTimerFinishedListener listener) {
        this.mOnTimerFinishedListener = listener;
    }

    boolean isIndeterminate() {
        return this.mIsIndeterminate;
    }

    boolean isTimerRunning() {
        return this.mIsTimerRunning;
    }

    void setIndeterminate(boolean indeterminate) {
        if (this.mIsIndeterminate != indeterminate) {
            this.mIsIndeterminate = indeterminate;
            if (this.mIsIndeterminate) {
                if (this.mIsTimerRunning) {
                    this.stopTimer();
                }

                this.mLayout.getProgressDrawable().start();
            } else {
                this.mLayout.getProgressDrawable().stop();
            }

        }
    }

    void startTimer(long totalTime, long updateInterval) {
        this.reset();
        this.mIsTimerRunning = true;
        this.mTimer = new CircularProgressLayoutController.CircularProgressTimer(totalTime, updateInterval);
        this.mTimer.start();
    }

    void stopTimer() {
        if (this.mIsTimerRunning) {
            this.mTimer.cancel();
            this.mIsTimerRunning = false;
            this.mLayout.getProgressDrawable().setStartEndTrim(0.0F, 0.0F);
        }

    }

    void reset() {
        this.setIndeterminate(false);
        this.stopTimer();
        this.mLayout.getProgressDrawable().setStartEndTrim(0.0F, 0.0F);
    }

    private class CircularProgressTimer extends CountDownTimer {
        private final long mTotalTime;

        CircularProgressTimer(long totalTime, long updateInterval) {
            super(totalTime, updateInterval);
            this.mTotalTime = totalTime;
        }

        @Override
        public void onTick(long millisUntilFinished) {
            CircularProgressLayoutController.this.mLayout.getProgressDrawable().setStartEndTrim(0.0F, 1.0F - (float) millisUntilFinished / (float) this.mTotalTime);
            CircularProgressLayoutController.this.mLayout.invalidate();
        }

        @Override
        public void onFinish() {
            CircularProgressLayoutController.this.mLayout.getProgressDrawable().setStartEndTrim(0.0F, 1.0F);
            if (CircularProgressLayoutController.this.mOnTimerFinishedListener != null) {
                CircularProgressLayoutController.this.mOnTimerFinishedListener.onTimerFinished(CircularProgressLayoutController.this.mLayout);
            }

            CircularProgressLayoutController.this.mIsTimerRunning = false;java
        }
    }
}

资源文件

<declare-styleable name="CircularProgressLayout">
<!-- Sets the color of the background circle. -->
<attr name="backgroundColor" format="color" />
<!-- Sets the stroke width of the progress indicator. -->
<attr name="strokeWidth" format="dimension" />
<!-- Sets the color scheme used by the progress indicator. This may be an array of colors or
a single color. If an array of colors is used, first color will be used for determinate
progress indicator, while the rest will be shown in order during indeterminate spinner. -->
<attr name="colorSchemeColors" format="reference|color" />
<!-- Sets if the progress should be shown as an indeterminate spinner. -->
<attr name="indeterminate" format="boolean" />
</declare-styleable>


<array name="circular_progress_layout_color_scheme_colors">
<item>@color/circular_progress_layout_red</item>
<item>@color/circular_progress_layout_yellow</item>
<item>@color/circular_progress_layout_green</item>
<item>@color/circular_progress_layout_blue</item>
</array>
<color name="circular_progress_layout_background_color">#00000000</color>
<color name="circular_progress_layout_blue">#FF2196F3</color>
<color name="circular_progress_layout_green">#FF4CAF50</color>xml
<color name="circular_progress_layout_red">#FFF44336</color>
<color name="circular_progress_layout_yellow">#FFFFEB3B</color>

<dimen name="circular_progress_layout_stroke_width">4dp</dimen>