带有细分的圆形自定义进度条

Question

我正在尝试开发自定义进度条或视图，我可以在其中传递部分值，然后它将创建一个部分，然后我将根据我的要求填写。

我累了Progress bar with divider，但不是第一轮......

寻找像这样的东西

编辑： - 我按照我的需要编辑了代码，但它不能像给定的图像那样做

  public class DashedCircularProgress extends RelativeLayout {



public DashedCircularProgress(Context context, AttributeSet attrs) {
    super(context, attrs);
    init(context, attrs);
}

public DashedCircularProgress(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    init(context, attrs);
}

/**
 * All the children must have a max height and width, never bigger than the internal circle
 *
 * @param changed
 * @param left
 * @param top
 * @param right
 * @param bottom
 */
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    super.onLayout(changed, left, top, right, bottom);
    final int count = getChildCount();
    int maxWidth = getWidth() / 2;
    int maxHeight = getHeight() / 2;

    for (int i = 0; i < count; i++) {
        final View child = getChildAt(i);

        int mesaureWidth = child.getMeasuredWidth();
        int measureHeight = child.getMeasuredWidth();

        ViewGroup.LayoutParams layoutParams = child.getLayoutParams();
        child.setTranslationY(padingTop);

        RelativeLayout.LayoutParams relativeLayoutParams =
                (RelativeLayout.LayoutParams) child.getLayoutParams();
        relativeLayoutParams.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE);
        child.setLayoutParams(relativeLayoutParams);

        if (mesaureWidth > maxWidth) {
            layoutParams.width = maxWidth;
        }

        if (measureHeight > maxHeight) {
            layoutParams.height = maxHeight;
        }
    }
}

private void init(Context context, AttributeSet attributeSet) {
    setWillNotDraw(false);
    TypedArray attributes = context.obtainStyledAttributes(attributeSet,
            R.styleable.DashedCircularProgress);
    initAttributes(attributes);
    initPainters();
    initValueAnimator();
}

private void initAttributes(TypedArray attributes) {
    externalColor = attributes.getColor(R.styleable.DashedCircularProgress_external_color,
            externalColor);
    internalBaseColor = attributes.getColor(R.styleable.DashedCircularProgress_base_color,
            internalBaseColor);
    progressColor = attributes.getColor(R.styleable.DashedCircularProgress_progress_color,
            progressColor);
    max = attributes.getFloat(R.styleable.DashedCircularProgress_max, max);
    duration = attributes.getInt(R.styleable.DashedCircularProgress_duration, duration);

}

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);
    progressPainter.onSizeChanged(h, w);
 //   externalCirclePainter.onSizeChanged(h, w);
    internalCirclePainter.onSizeChanged(h, w);
    //iconPainter.onSizeChanged(h, w);
    animateValue();
}

private void initPainters() {
    progressPainter = new ProgressPainterImp(progressColor, min, max);
    //externalCirclePainter = new ExternalCirclePainterImp(externalColor);
    internalCirclePainter = new InternalCirclePainterImp(internalBaseColor);
    //iconPainter = new IconPainter(image);
}

private void initValueAnimator() {
    valueAnimator = new ValueAnimator();
    valueAnimator.setInterpolator(interpolator);
    valueAnimator.addUpdateListener(new ValueAnimatorListenerImp());
}

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    //externalCirclePainter.draw(canvas);
    internalCirclePainter.draw(canvas);
    progressPainter.draw(canvas);
    //iconPainter.draw(canvas);
    invalidate();
}

public void setValue(float value) {
    this.value = value;
    if (value <= max || value >= min) {
        animateValue();
    }
}

private void animateValue() {
    if (valueAnimator != null) {
        valueAnimator.setFloatValues(last, value);
        valueAnimator.setDuration(duration);
        valueAnimator.start();
    }
}

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

public void setOnValueChangeListener(OnValueChangeListener valueChangeListener) {
    this.valueChangeListener = valueChangeListener;
}

public void setInterpolator(Interpolator interpolator) {
    this.interpolator = interpolator;

    if (valueAnimator != null) {
        valueAnimator.setInterpolator(interpolator);
    }
}

public float getMin() {
    return min;
}

public void setMin(float min) {
    this.min = min;
    progressPainter.setMin(min);
}

public float getMax() {
    return max;
}

public void setMax(float max) {
    this.max = max;
    progressPainter.setMax(max);
}

private class ValueAnimatorListenerImp implements ValueAnimator.AnimatorUpdateListener {
    @Override
    public void onAnimationUpdate(ValueAnimator valueAnimator) {
        Float value = (Float) valueAnimator.getAnimatedValue();
        progressPainter.setValue(value);

        if (valueChangeListener != null) {
            valueChangeListener.onValueChange(value);
        }

        last = value;
    }
}

public interface OnValueChangeListener {
    void onValueChange(float value);
}

public void setIcon(int drawable) {

}

public void reset() {
    last = min;
}

public int getProgressColor() {
    return progressColor;
}

public void setProgressColor(int progressColor) {
    this.progressColor = progressColor;
    progressPainter.setColor(progressColor);
}

public int getInternalBaseColor() {
    return internalBaseColor;
}

public void setInternalBaseColor(int internalBaseColor) {
    this.internalBaseColor = internalBaseColor;
    internalCirclePainter.setColor(progressColor);
}

public int getExternalColor() {
    return externalColor;
}

public void setExternalColor(int externalColor) {
    this.externalColor = externalColor;
   // externalCirclePainter.setColor(externalColor);
}

public int getDuration() {
    return duration;
}

public void setDuration(int duration) {
    this.duration = duration;
}

}