自定义进度条带数字 ProgressBar

最新推荐文章于 2024-06-28 17:11:03 发布
最新推荐文章于 2024-06-28 17:11:03 发布
阅读量720 收藏
点赞数
分类专栏： Android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36425505/article/details/129118922
版权

直接上图看效果

xml 代码

  <com.zltech.customprogressbar.NumberProgressBar
        xmlns:custom="http://schemas.android.com/apk/res-auto"
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/pb_update_progress"
        style="@style/NumberProgressBar_Default"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingTop="40dp"
        android:paddingBottom="30dp"
        android:paddingLeft="10dp"
        android:paddingRight="10dp"
        custom:progress_current="10">
    </com.zltech.customprogressbar.NumberProgressBar>

 在attrs文件下添加（如果没有则先创建attrs）

 <!-- 数字进度条参数：用于版本更新中 -->
    <declare-styleable name="NumberProgressBar">
        <attr name="progress_current" format="integer" />
        <attr name="progress_max" format="integer" />
        <attr name="progress_unreached_color" format="color" />
        <attr name="progress_reached_color" format="color" />
        <attr name="progress_reached_bar_height" format="dimension" />
        <attr name="progress_unreached_bar_height" format="dimension" />
        <attr name="progress_text_size" format="dimension" />
        <attr name="progress_text_color" format="color" />
        <attr name="progress_text_offset" format="dimension" />
        <attr name="progress_text_bg_color" format="color" />
        <attr name="progress_dot_color" format="color" />
        <attr name="progress_dot_radius" format="dimension" />
        <attr name="progress_text_visibility" format="enum">
            <enum name="visible" value="0" />
            <enum name="invisible" value="1" />
        </attr>
    </declare-styleable>
    <declare-styleable name="Themes">
        <attr name="numberProgressBarStyle" format="reference" />
    </declare-styleable>

在styles文件中添加

<!--数字进度条样式：用于版本更新  -->
<style name="NumberProgressBar_Default">
    <item name="android:layout_height">wrap_content</item>
    <item name="android:layout_width">match_parent</item>

    <item name="progress_max">100</item>
    <item name="progress_current">0</item>

    <item name="progress_unreached_color">#800F35AF</item>
    <item name="progress_reached_color">#0B3DE0</item>

    <item name="progress_text_size">10sp</item>
    <item name="progress_text_color">#fff</item>
    <item name="progress_reached_bar_height">10dp</item>
    <item name="progress_unreached_bar_height">9dp</item>
    <item name="progress_dot_radius">5.5dp</item>
    <item name="progress_dot_color">#F44336</item>
    <item name="progress_text_bg_color">#F44336</item>
</style>
在包名下创建 NumberProgressBar 类
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.RectF;
import android.graphics.Typeface;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.View;

/**
 * Created by daimajia on 14-4-30.
 */
public class NumberProgressBar extends View {

    private int mMaxProgress = 100;

    /**
     * Current progress, can not exceed the max progress.
     */
    private int mCurrentProgress = 0;

    /**
     * The progress area bar color.
     */
    private int mReachedBarColor;

    /**
     * The bar unreached area color.
     */
    private int mUnreachedBarColor;

    /**
     * The bar dot color.
     */
    private int mDotColor;

    /**
     * The progress text color.
     */
    private int mTextColor;
    /**
     * The progress text bg color.
     */
    private int mTextBgColor;

    /**
     * The progress text size.
     */
    private float mTextSize;

    /**
     * The height of the reached area.
     */
    private float mReachedBarHeight;

    /**
     * The height of the unreached area.
     */
    private float mUnreachedBarHeight;

    /**
     * The radius of the Dot radius .
     */
    private float mDotRadius;

    /**
     * The suffix of the number.
     */
    private String mSuffix = "%";

    /**
     * The prefix.
     */
    private String mPrefix = "";

    private final int default_dot_color = Color.rgb(255, 255, 255);
    private final int default_text_bg_color = Color.rgb(255, 255, 255);
    private final int default_text_color = Color.rgb(66, 145, 241);
    private final int default_reached_color = Color.rgb(66, 145, 241);
    private final int default_unreached_color = Color.rgb(204, 204, 204);
    private final float default_progress_text_offset;
    private final float default_text_size;
    private final float default_reached_bar_height;
    private final float default_unreached_bar_height;

    /**
     * For save and restore instance of progressbar.
     */
    private static final String INSTANCE_STATE = "saved_instance";
    private static final String INSTANCE_TEXT_COLOR = "text_color";
    private static final String INSTANCE_TEXT_SIZE = "text_size";
    private static final String INSTANCE_REACHED_BAR_HEIGHT = "reached_bar_height";
    private static final String INSTANCE_REACHED_BAR_COLOR = "reached_bar_color";
    private static final String INSTANCE_UNREACHED_BAR_HEIGHT = "unreached_bar_height";
    private static final String INSTANCE_UNREACHED_BAR_COLOR = "unreached_bar_color";
    private static final String INSTANCE_MAX = "max";
    private static final String INSTANCE_PROGRESS = "progress";
    private static final String INSTANCE_SUFFIX = "suffix";
    private static final String INSTANCE_PREFIX = "prefix";
    private static final String INSTANCE_TEXT_VISIBILITY = "text_visibility";

    private static final int PROGRESS_TEXT_VISIBLE = 0;

    /**
     * The width of the text that to be drawn.
     */
    private float mDrawTextWidth;

    /**
     * The drawn text start.
     */
    private float mDrawTextStart;

    /**
     * The drawn text end.
     */
    private float mDrawTextEnd;

    /**
     * The text that to be drawn in onDraw().
     */
    private String mCurrentDrawText;

    /**
     * The Paint of the reached area.
     */
    private Paint mReachedBarPaint;
    /**
     * The Paint of the unreached area.
     */
    private Paint mUnreachedBarPaint;
    /**
     * The Paint of the progress text.
     */
    private Paint mTextPaint;

    /**
     * The Paint of the Dot.
     */
    private Paint mDotPaint;


    /**
     * The Paint of the rectangle.
     */
    private Paint mRectanglePaint;

    /**
     * Unreached bar area to draw rect.
     */
    private RectF mUnreachedRectF = new RectF(0, 0, 0, 0);
    /**
     * Reached bar area rect.
     */
    private RectF mReachedRectF = new RectF(0, 0, 0, 0);

    /**
     * dot area rect.
     */
    private RectF mDotRectF = new RectF(0, 0, 0, 0);


    /**
     * text bg path.
     */
    private Path path = new Path();

    /**
     * The progress text offset.
     */
    private float mOffset;

    /**
     * Determine if need to draw unreached area.
     */
    private boolean mDrawUnreachedBar = true;

    private boolean mDrawReachedBar = true;

    private boolean mIfDrawText = true;

    private boolean mIfDrawDot = true;

    /**
     * Listener
     */
    private OnProgressBarListener mListener;

    public enum ProgressTextVisibility {
        Visible, Invisible
    }

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

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

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

        default_reached_bar_height = dp2px(1.5f);
        default_unreached_bar_height = dp2px(1.0f);
        default_text_size = sp2px(10);
        default_progress_text_offset = dp2px(3.0f);

        // load styled attributes.
        final TypedArray attributes = context.getTheme().obtainStyledAttributes(attrs,
                R.styleable.NumberProgressBar, defStyleAttr, 0);

        mReachedBarColor = attributes.getColor(R.styleable.NumberProgressBar_progress_reached_color,
                default_reached_color);
        mUnreachedBarColor = attributes.getColor(R.styleable.NumberProgressBar_progress_unreached_color,
                default_unreached_color);
        mTextColor = attributes.getColor(R.styleable.NumberProgressBar_progress_text_color,
                default_text_color);
        mTextBgColor = attributes.getColor(R.styleable.NumberProgressBar_progress_text_bg_color,
                default_text_bg_color);
        mDotColor = attributes.getColor(R.styleable.NumberProgressBar_progress_dot_color,
                default_dot_color);
        mDotRadius = attributes.getDimension(R.styleable.NumberProgressBar_progress_dot_radius,
                14);
        mTextSize = attributes.getDimension(R.styleable.NumberProgressBar_progress_text_size,
                default_text_size);

        mReachedBarHeight = attributes.getDimension(
                R.styleable.NumberProgressBar_progress_reached_bar_height, default_reached_bar_height);
        mUnreachedBarHeight = attributes.getDimension(
                R.styleable.NumberProgressBar_progress_unreached_bar_height, default_unreached_bar_height);
        mOffset = attributes.getDimension(R.styleable.NumberProgressBar_progress_text_offset,
                default_progress_text_offset);

        int textVisible = attributes.getInt(R.styleable.NumberProgressBar_progress_text_visibility,
                PROGRESS_TEXT_VISIBLE);
        if (textVisible != PROGRESS_TEXT_VISIBLE) {
            mIfDrawText = false;
        }

        setProgress(attributes.getInt(R.styleable.NumberProgressBar_progress_current, 0));
        setMax(attributes.getInt(R.styleable.NumberProgressBar_progress_max, 100));

        attributes.recycle();
        initializePainters();
    }

    @Override
    protected int getSuggestedMinimumWidth() {
        return (int) mTextSize;
    }

    @Override
    protected int getSuggestedMinimumHeight() {
        return Math.max((int) mTextSize, Math.max((int) mReachedBarHeight, (int) mUnreachedBarHeight));
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(measure(widthMeasureSpec, true), measure(heightMeasureSpec, false));
    }

    private int measure(int measureSpec, boolean isWidth) {
        int result;
        int mode = MeasureSpec.getMode(measureSpec);
        int size = MeasureSpec.getSize(measureSpec);
        int padding = isWidth ? getPaddingLeft() + getPaddingRight() : getPaddingTop() + getPaddingBottom();
        if (mode == MeasureSpec.EXACTLY) {
            result = size;
        } else {
            result = isWidth ? getSuggestedMinimumWidth() : getSuggestedMinimumHeight();
            result += padding;
            if (mode == MeasureSpec.AT_MOST) {
                if (isWidth) {
                    result = Math.max(result, size);
                } else {
                    result = Math.min(result, size);
                }
            }
        }
        return result;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        if (mIfDrawText) {
            calculateDrawRectF();
        } else {
            calculateDrawRectFWithoutProgressText();
        }
        if (mDrawUnreachedBar) {
            canvas.drawRoundRect(mUnreachedRectF,10,10, mUnreachedBarPaint);
        }
        if (mDrawReachedBar) {
            canvas.drawRoundRect(mReachedRectF,10,10, mReachedBarPaint);
        }



        if (mIfDrawText) {
            canvas.drawPath(path, mRectanglePaint);
            canvas.drawText(mCurrentDrawText, mDrawTextStart, mDrawTextEnd, mTextPaint);
//            canvas.drawRect(mTriangleRectF,mTrianglePaint);
        }

        if (mIfDrawDot){
            canvas.drawRoundRect(mDotRectF,mDotRadius,mDotRadius, mDotPaint);
        }
    }

    private void initializePainters() {
        mReachedBarPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mReachedBarPaint.setColor(mReachedBarColor);
        mReachedBarPaint.setStrokeCap(Paint.Cap.ROUND);

        mUnreachedBarPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mUnreachedBarPaint.setColor(mUnreachedBarColor);
        mUnreachedBarPaint.setStrokeCap(Paint.Cap.ROUND);

        mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mTextPaint.setColor(mTextColor);
        mTextPaint.setTextSize(mTextSize);
        Typeface font = Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD);
        mTextPaint.setTypeface( font );

        mDotPaint =new Paint(Paint.ANTI_ALIAS_FLAG);
        mDotPaint.setColor(mDotColor);
        mDotPaint.setStrokeCap(Paint.Cap.ROUND);


        mRectanglePaint =new Paint(Paint.ANTI_ALIAS_FLAG);
        mRectanglePaint.setColor(mTextBgColor);
        mRectanglePaint .setStrokeCap(Paint.Cap.ROUND);
        mRectanglePaint.setStrokeJoin(Paint.Join.ROUND);
    }

    private void calculateDrawRectFWithoutProgressText() {
        mReachedRectF.left = getPaddingLeft();
        mReachedRectF.top = getHeight() / 2.0f - mReachedBarHeight / 2.0f;
        mReachedRectF.right = (getWidth() - getPaddingLeft() - getPaddingRight()) / (getMax() * 1.0f)
                * getProgress() + getPaddingLeft();
        mReachedRectF.bottom = getHeight() / 2.0f + mReachedBarHeight / 2.0f;

        mUnreachedRectF.left = mReachedRectF.right-10;
        mUnreachedRectF.right = getWidth() - getPaddingRight();
        mUnreachedRectF.top = getHeight() / 2.0f + -mUnreachedBarHeight / 2.0f;
        mUnreachedRectF.bottom = getHeight() / 2.0f + mUnreachedBarHeight / 2.0f;
        if (getProgress() == 0){
            path.reset();
        }else {
            mDotRectF.bottom = mReachedRectF.top + ((mReachedRectF.bottom - mReachedRectF.top) / 2) + mDotRadius;
            mDotRectF.top = mReachedRectF.top + ((mReachedRectF.bottom - mReachedRectF.top) / 2) - mDotRadius;
            mDotRectF.right = mReachedRectF.right + 5;
            mDotRectF.left = mReachedRectF.right - (mDotRadius * 2) + 5;
        }
    }

    private void calculateDrawRectF() {

        mCurrentDrawText = String.format("%d", getProgress() * 100 / getMax());
        mCurrentDrawText = mPrefix + mCurrentDrawText + mSuffix;
        mDrawTextWidth = mTextPaint.measureText(mCurrentDrawText);

        if (getProgress() == 0) {
            mDrawReachedBar = false;
            mDrawTextStart = getPaddingLeft();
            mDotRectF.left=0;
            mDotRectF.top=0;
            mDotRectF.right=0;
            mDotRectF.bottom=0;
        } else {
            mDrawReachedBar = true;
            mReachedRectF.left = getPaddingLeft();
            mReachedRectF.top = getHeight() / 2.0f - mReachedBarHeight / 2.0f;
            mReachedRectF.right = (getWidth() - getPaddingLeft() - getPaddingRight()) / (getMax() * 1.0f)
                    * getProgress() + getPaddingLeft();
            mReachedRectF.bottom = getHeight() / 2.0f + mReachedBarHeight / 2.0f;
            mDrawTextStart = (mReachedRectF.right  + mOffset - (mDrawTextWidth/2f) - mDotRadius);
        }

//        mDrawTextEnd = (int) ((getHeight() / 2.0f) - ((mTextPaint.descent() + mTextPaint.ascent()) / 2.0f));
        //descent 是正直  ascent 是负值所以当进度条顶部距离减去 descent 在加上负值ascent 就是文字位置y
        mDrawTextEnd =  (mReachedRectF.top - mTextPaint.descent()  -15);

       if (getProgress()>0){
           mDotRectF.bottom = mReachedRectF.top + ((mReachedRectF.bottom - mReachedRectF.top) / 2) + mDotRadius;
           mDotRectF.top = mReachedRectF.top + ((mReachedRectF.bottom - mReachedRectF.top) / 2) - mDotRadius;
           mDotRectF.right = mReachedRectF.right + 5;
           mDotRectF.left = mReachedRectF.right - (mDotRadius * 2) + 5;
       }

        float leftX = 0,leftY=0,rightX=0,rightY=0;
        if (getProgress()==0){
            path.reset();
        }else {
            leftX = mDrawTextStart-5;
            leftY= mDrawTextEnd+mTextPaint.ascent();
            rightX =  mDrawTextStart+ mDrawTextWidth +5;
            rightY = mDrawTextEnd +mTextPaint.ascent();
            path.reset();
            path.moveTo(leftX, leftY);// 此点为多边形的起点
            path.lineTo(rightX, rightY);//右上边矩形坐标
            path.lineTo(rightX, mDrawTextEnd+8); //右下边矩形坐标
            path.lineTo((leftX+(rightX-leftX)/2)+8, mDrawTextEnd+8); //右下边三角行坐标
            path.lineTo(leftX+(rightX-leftX)/2, mDrawTextEnd +20);//三角形顶点坐标
            path.lineTo((leftX+(rightX-leftX)/2)-8,  mDrawTextEnd+8);//左下边三角行坐标
            path.lineTo(leftX, mDrawTextEnd+8);//左下边矩形坐标
            path.close(); // 使这些点构成封闭的多边形
        }



        float unreachedBarStart = mDrawTextStart  + mOffset;
        if (unreachedBarStart >= getWidth() - getPaddingRight()) {
            mDrawUnreachedBar = false;
        } else {
            mDrawUnreachedBar = true;
            if (getProgress()==0){
                mUnreachedRectF.left = getPaddingLeft();
            }else {
                mUnreachedRectF.left = mReachedRectF.right -10;
            }
            mUnreachedRectF.right = getWidth() - getPaddingRight();
            mUnreachedRectF.top = getHeight() / 2.0f + -mUnreachedBarHeight / 2.0f;
            mUnreachedRectF.bottom = getHeight() / 2.0f + mUnreachedBarHeight / 2.0f;
        }
    }

    /**
     * Get progress text color.
     *
     * @return progress text color.
     */
    public int getTextColor() {
        return mTextColor;
    }

    /**
     * Get progress text size.
     *
     * @return progress text size.
     */
    public float getProgressTextSize() {
        return mTextSize;
    }

    public int getUnreachedBarColor() {
        return mUnreachedBarColor;
    }

    public int getReachedBarColor() {
        return mReachedBarColor;
    }

    public int getProgress() {
        return mCurrentProgress;
    }

    public int getMax() {
        return mMaxProgress;
    }

    public float getReachedBarHeight() {
        return mReachedBarHeight;
    }

    public float getUnreachedBarHeight() {
        return mUnreachedBarHeight;
    }

    public void setProgressTextSize(float textSize) {
        this.mTextSize = textSize;
        mTextPaint.setTextSize(mTextSize);
        invalidate();
    }

    public void setProgressTextColor(int textColor) {
        this.mTextColor = textColor;
        mTextPaint.setColor(mTextColor);
        invalidate();
    }

    public void setUnreachedBarColor(int barColor) {
        this.mUnreachedBarColor = barColor;
        mUnreachedBarPaint.setColor(mUnreachedBarColor);
        invalidate();
    }

    public void setReachedBarColor(int progressColor) {
        this.mReachedBarColor = progressColor;
        mReachedBarPaint.setColor(mReachedBarColor);
        invalidate();
    }

    public void setReachedBarHeight(float height) {
        mReachedBarHeight = height;
    }

    public void setUnreachedBarHeight(float height) {
        mUnreachedBarHeight = height;
    }

    public void setMax(int maxProgress) {
        if (maxProgress > 0) {
            this.mMaxProgress = maxProgress;
            invalidate();
        }
    }

    public void setSuffix(String suffix) {
        if (suffix == null) {
            mSuffix = "";
        } else {
            mSuffix = suffix;
        }
    }

    public String getSuffix() {
        return mSuffix;
    }

    public void setPrefix(String prefix) {
        if (prefix == null)
            mPrefix = "";
        else {
            mPrefix = prefix;
        }
    }

    public String getPrefix() {
        return mPrefix;
    }

    public void incrementProgressBy(int by) {
        if (by > 0) {
            setProgress(getProgress() + by);
        }

        if (mListener != null) {
            mListener.onProgressChange(getProgress(), getMax());
        }
    }

    public void setProgress(int progress) {
        if (progress <= getMax() && progress >= 0) {
            this.mCurrentProgress = progress;
            invalidate();
        }
    }

    @Override
    protected Parcelable onSaveInstanceState() {
        final Bundle bundle = new Bundle();
        bundle.putParcelable(INSTANCE_STATE, super.onSaveInstanceState());
        bundle.putInt(INSTANCE_TEXT_COLOR, getTextColor());
        bundle.putFloat(INSTANCE_TEXT_SIZE, getProgressTextSize());
        bundle.putFloat(INSTANCE_REACHED_BAR_HEIGHT, getReachedBarHeight());
        bundle.putFloat(INSTANCE_UNREACHED_BAR_HEIGHT, getUnreachedBarHeight());
        bundle.putInt(INSTANCE_REACHED_BAR_COLOR, getReachedBarColor());
        bundle.putInt(INSTANCE_UNREACHED_BAR_COLOR, getUnreachedBarColor());
        bundle.putInt(INSTANCE_MAX, getMax());
        bundle.putInt(INSTANCE_PROGRESS, getProgress());
        bundle.putString(INSTANCE_SUFFIX, getSuffix());
        bundle.putString(INSTANCE_PREFIX, getPrefix());
        bundle.putBoolean(INSTANCE_TEXT_VISIBILITY, getProgressTextVisibility());
        return bundle;
    }

    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        if (state instanceof Bundle) {
            final Bundle bundle = (Bundle) state;
            mTextColor = bundle.getInt(INSTANCE_TEXT_COLOR);
            mTextSize = bundle.getFloat(INSTANCE_TEXT_SIZE);
            mReachedBarHeight = bundle.getFloat(INSTANCE_REACHED_BAR_HEIGHT);
            mUnreachedBarHeight = bundle.getFloat(INSTANCE_UNREACHED_BAR_HEIGHT);
            mReachedBarColor = bundle.getInt(INSTANCE_REACHED_BAR_COLOR);
            mUnreachedBarColor = bundle.getInt(INSTANCE_UNREACHED_BAR_COLOR);
            initializePainters();
            setMax(bundle.getInt(INSTANCE_MAX));
            setProgress(bundle.getInt(INSTANCE_PROGRESS));
            setPrefix(bundle.getString(INSTANCE_PREFIX));
            setSuffix(bundle.getString(INSTANCE_SUFFIX));
            setProgressTextVisibility(bundle.getBoolean(INSTANCE_TEXT_VISIBILITY) ? ProgressTextVisibility.Visible : ProgressTextVisibility.Invisible);
            super.onRestoreInstanceState(bundle.getParcelable(INSTANCE_STATE));
            return;
        }
        super.onRestoreInstanceState(state);
    }

    public float dp2px(float dp) {
        final float scale = getResources().getDisplayMetrics().density;
        return dp * scale + 0.5f;
    }

    public float sp2px(float sp) {
        final float scale = getResources().getDisplayMetrics().scaledDensity;
        return sp * scale;
    }

    public void setProgressTextVisibility(ProgressTextVisibility visibility) {
        mIfDrawText = visibility == ProgressTextVisibility.Visible;
        invalidate();
    }

    public void isDrawDot(boolean isDrawDot){
        this.mIfDrawDot = isDrawDot;
        invalidate();
    }
    public boolean getProgressTextVisibility() {
        return mIfDrawText;
    }

    public void setOnProgressBarListener(OnProgressBarListener listener) {
        mListener = listener;
    }
}

interface OnProgressBarListener {

    void onProgressChange(int current, int max);
}

本文参考了NumberProgressBar 开源项目

本文章源码地址 https://github.com/zqMyself/CustomProgressBar

小曾老师
关注
专栏目录
我的Android进阶之旅------＞Android自定义View实现带数字的进度条（NumberProgressBar）
字节卷动
03-11 1万+
今天在Github上面看到一个来自于 daimajia所写的关于Android自定义View实现带数字的进度条（NumberProgressBar）的精彩案例，在这里分享给大家一起来学习学习！同时感谢daimajia的开源奉献！ 第一步、效果展示图1、蓝色的进度条 图2、红色的进度条 图3、多条颜色不同的进度条 图4、多条颜色不同的进度条 版权声明：本文为【欧阳鹏】原创文章，欢迎转载，转载...
Android自定义横向、圆形进度条带数字
08-07
非常有用的自定义横向圆形进度条，可以自己设置进度条的宽度、总长以及数字等
Android进度条样式
tianyitianyi1的专栏
05-13 2084
android 进度条的样式   例1：（默认样式(中等圆形)） Xml代码      android:id="@+id/progressBar1"      android:layout_width="wrap_content"       android:layout_height="wrap_content"       />  例2：（超大圆形） Xml代码
在Android中使用ProgressBar显示进度
最新发布
微赚开发者技术分享博客
06-28 1013
ProgressBar是Android中的一个视图控件，用于显示任务的完成进度。它通常以水平条或圆圈的形式展示，允许用户了解任务的当前状态和进度百分比。
Android NumberProgressBar：动态移动显示百分比进度的进度条
weixin_34293246的博客
06-27 500
 Android NumberProgressBar：动态移动显示百分比进度的进度条 NumberProgressBar是github上一个开源项目，其项目主页是：https://github.com/daimajia/NumberProgressBar NumberProgressBar特点是当进度条在前进时候，显示出来的百分比进度数字随进度条实时显示出来，如图： ...
Android可显示数字进度的进度条使用教程
五道口
12-20 1万+
Android显示进度数字的进度条，支持动画，支持数字显示，支持颜色搭配自定义等
Android实现带数字的圆形进度条(自定义进度条)
01-20
在实际使用中，你可以通过XML布局文件或者代码动态设置这个自定义进度条的各种属性，比如改变进度条颜色、字体颜色、进度数值等。同时，通过调整`mIfDrawText`和`mIfDrawCircle`变量，可以选择是否绘制进度数字或...
Android带圆形数字进度的自定义进度条示例
01-04
设计搞了一个带圆形进度的进度条，在GitHub上逛了一圈，发现没有，自己撸吧。 先看界面效果： 主要思路是写一个继承ProgressBar的自定义View，不废话，直接上代码： package com.fun.progressbarwithnumber; ...
android 显示数字,android – 在ProgressBar中显示数字
weixin_39930748的博客
05-27 881
我有一个ProgressBar.它工作正常,但我需要显示最大值和当前值.他们不在那里.我需要更改为ProgressDialog吗？澄清：我正在展示ProgressBar.酒吧出现完美,但我希望数字也出现.因此,例如,最大值为1000,当前点为300,然后我想要1000出现,栏的结尾和300出现在栏上或其下方.我使用此类作为List Adapter来填充ListView.显示的行取决于“奖励”数组中...
带数字的进度条
07-12
带数字的进度条
自定义ProgressBar带进度数字效果
05-03
自定义ProgressBar带进度数字效果
Android 绘制带数字进度条形进度条.zip
07-10
Android 绘制带数字进度条形进度条通过绘制，实现进度条，可控性比较高
android 进度条之numberprogressbar
07-19
这个进度条看起来还是很大方简洁的，还不错，有兴趣的可以参考：http://blog.csdn.net/jan_s/article/details/46954603
Android数字进度条NumberProgressBar.zip
07-19
NumberProgressBar 是一个漂亮的 Android 的数字进度条。
我的Android进阶之旅------>Android自定义View实现带数字的进度条
shuhaizhilian的博客
03-12 413
今天在Github上面看到一个来自于 daimajia所写的关于Android自定义View实现带数字的进度条（NumberProgressBar）的精彩案例，在这里分享给大家一起来学习学习！同时感谢daimajia的开源奉献！     第一步、效果展示 图1、蓝色的进度条 图2、红色的进度条 图3、多条颜色不同的进度条 图4、多条颜色不同的进度条
Android自定义ProgressBar
热门推荐
zhaojun的博客
11-30 2万+
好久不写博客了，今天来总结一下自定义ProgressBar的实现。上周做一个游戏资源的在线更新功能，设计给的加载进度条设计图，是无法使用Android原生的ProgressBar来实现的。在百度和GitHub上搜了搜相关的资源，都不符合我的要求。于是，我只能自己去写。先给一下最终的效果： 上面就是我实现的ProgressBar的效果，与业务结合起来，分为几个阶...
Android — NumberProgressBar
农村打工仔的博客
04-02 125
上效果图： Use <com.daimajia.numberprogressbar.NumberProgressBar android:id="@+id/number_progress_bar" style="@style/NumberProgressBar_Default" /> <com.daimajia.numberprogressbar.NumberProgressBar android:lay.
自定义Android圆形进度条带数字实现教程
在Android开发中，创建一个带有圆形数字进度的自定义进度条是一个常见的需求，尤其是在设计用户界面时希望展示更丰富的反馈。这篇文章提供了如何自定义一个名为`HorizontalProgressBarWithNumber`的控件，它继承自...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小曾老师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值