Android - 进度条的使用_android 进度条

---

一、进度条的属性和方法

1.控件常用属性

android:max：进度条的最大值
android:progress：进度条已完成进度值
android:progressDrawable：设置轨道对应的Drawable对象
android:indeterminate：如果设置成true，则进度条不精确显示进度
android:indeterminateDrawable：设置不显示进度的进度条的Drawable对象
android:indeterminateDuration：设置不精确显示进度的持续时间
android:secondaryProgress：二级进度条，类似于视频播放的一条是当前播放进度，一条是缓冲进度，前者通过progress属性进行设置！
1
2
3
4
5
6
7

2.控件常用方法

getMax()：返回这个进度条的范围的上限
getProgress()：返回进度
getSecondaryProgress()：返回次要进度
incrementProgressBy(int diff)：指定增加的进度
isIndeterminate()：指示进度条是否在不确定模式下
setIndeterminate(boolean indeterminate)：设置不确定模式下
1
2
3
4
5
6

二、系统提供的进度条

系统系统了四种进度条：分别是Small，Inverse，Large，Horizontal，前三种是圆形，最后一种是横线形，直接style引用即可
三种圆形的进度条无法显示进度

1.圆形进度条用法：

<ProgressBar
	style="@android:style/Widget.ProgressBar.Small"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerInParent="true" />
1
2
3
4
5

2.横线进度条用法

布局文件

<ProgressBar
	android:id="@+id/prog"
	style="@android:style/Widget.ProgressBar.Horizontal"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:max="100"
    android:progress="0" />
1
2
3
4
5
6
7

java文件
下面的代码中，首先做了一个定时器模拟事务返回进度，每秒钟返回一次当前事务的进度，第二个定时器搭配hander每秒钟更新一次UI上显示的进度条
hander里面：
第一步获取以下当前进度条显示的进度，
第二步通过事务返回的进度计算在进度条上应该显示的进度，
第三步用应该显示的最新进度减去当前已经显示的进度获取当前进度条应该增加的进度
第四步调用进度条的incrementProgressBy方法更新进度条显示

public class MainActivity extends AppCompatActivity {
    ProgressBar prog;
    int a;     //事务执行的总进度
    int b = 0;     //事务执行的初始进度
    int c;     //进度条的总进度
    int h;      //进度条的当前进度

    Handler myHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 111) {
                //获取进度条当前进度
                h = prog.getProgress();

                //计算当前实际进度
                double e = (double) b / a;
                double f = c * e;
                int g = (int) f;

                //计算要增加的进度
                int m = g - h;

                prog.incrementProgressBy(m);    //增加进度显示
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        prog = (ProgressBar) findViewById(R.id.prog);
        c = prog.getMax();

        //执行事务，每秒钟返回一次事务执行进度
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                a = 500;
                b++;
                if (b > a) {
                    cancel();
                }
            }
        }, 0, 1000);

        //每秒钟将事务返回的进度值通过hander更新到UI显示中
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                if (b > a) {
                    cancel();
                }else{
                    //定时循环执行的内容
                    myHandler.sendEmptyMessage(111);
                }
            }
        }, 0, 1000);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

三、自定义进度条

自定义一个类继承View绘制圆形进度条，然后引用，下面的代码可直接复制使用，代码中我暴露出了五个参数可以在使用时修改，java中调用先使用setmTargetProgress()方法修改进度值，然后调用invalidate()重新绘制view即可。

CustomPgBar.java

public class CustomPgBar extends View {

    private Paint mBackPaint;
    private Paint mFrontPaint;
    private Paint mTextPaint;
    private RectF mRect;
    private int mProgress = 0;
    private int mWidth;
    private int mHeight;
    private int mMax = 100;         //总进度值

    //以下五个参数已暴露出去，使用时可修改

    private int mTargetProgress = 0;    //进度值
    private float mRadius = 200;    //圆形大小
    private int mTextPaintColor = Color.GREEN;  //绘制文本字体颜色
    private int mFrontPaintColor = Color.GREEN; //绘制进度颜色
    private int mBackPaintColor = Color.BLUE;   //绘制总进度颜色

    private float pTextSize = (float) (mRadius * 0.6);     //绘制文本字体大小
    private float mStrokeWidth = (float) (mRadius * 0.25);    //进度粗细
    private float mHalfStrokeWidth = mStrokeWidth / 2;

    public CustomPgBar(Context context) {
        super(context);
        init();
    }

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

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

    //完成相关参数初始化
    private void init() {
        //总进度画笔
        mBackPaint = new Paint();
        mBackPaint.setColor(getmBackPaintColor());
        mBackPaint.setAntiAlias(true);
        mBackPaint.setStyle(Paint.Style.STROKE);
        mBackPaint.setStrokeWidth(mStrokeWidth);
        //进度画笔
        mFrontPaint = new Paint();
        mFrontPaint.setColor(getmFrontPaintColor());
        mFrontPaint.setAntiAlias(true);
        mFrontPaint.setStyle(Paint.Style.STROKE);
        mFrontPaint.setStrokeWidth(mStrokeWidth);
        //文本画笔
        mTextPaint = new Paint();
        mTextPaint.setColor(getmTextPaintColor());
        mTextPaint.setAntiAlias(true);
        mTextPaint.setTextSize(pTextSize);
        mTextPaint.setTextAlign(Paint.Align.CENTER);
    }


    //重写测量大小的onMeasure方法和绘制View的核心方法onDraw()
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        mWidth = getRealSize(widthMeasureSpec);
        mHeight = getRealSize(heightMeasureSpec);
        setMeasuredDimension(mWidth, mHeight);

    }

    @Override
    protected void onDraw(Canvas canvas) {
        initRect();
        float angle = mProgress / (float) mMax * 360;
        canvas.drawCircle(mWidth / 2, mHeight / 2, getmRadius(), mBackPaint);
        canvas.drawArc(mRect, -90, angle, false, mFrontPaint);
        canvas.drawText(mProgress + "%", mWidth / 2 + mHalfStrokeWidth, mHeight / 2 + mHalfStrokeWidth, mTextPaint);
        if (mProgress < getmTargetProgress()) {
            mProgress += 1;
            invalidate();
        }
    }

    public int getRealSize(int measureSpec) {
        int result = 1;
        int mode = MeasureSpec.getMode(measureSpec);
        int size = MeasureSpec.getSize(measureSpec);

        if (mode == MeasureSpec.AT_MOST || mode == MeasureSpec.UNSPECIFIED) {
            //自己计算
            result = (int) (getmRadius() * 2 + mStrokeWidth);
        } else {
            result = size;
        }

        return result;
    }

    private void initRect() {
        if (mRect == null) {
            mRect = new RectF();
            int viewSize = (int) (getmRadius() * 2);
            int left = (mWidth - viewSize) / 2;
            int top = (mHeight - viewSize) / 2;
            int right = left + viewSize;
            int bottom = top + viewSize;
            mRect.set(left, top, right, bottom);
        }
    }


    public int getmTargetProgress() {
        return mTargetProgress;
    }

    public void setmTargetProgress(int mTargetProgress) {
        this.mTargetProgress = mTargetProgress;

    }

    public float getmRadius() {
        return mRadius;
    }

    public void setmRadius(float mRadius) {
        if (mRadius != 0) {
            this.mRadius = mRadius;
        }
    }

    public int getmTextPaintColor() {
        return mTextPaintColor;
    }

    public void setmTextPaintColor(int mTextPaintColor) {
        if (mTextPaintColor != 0) {
            this.mTextPaintColor = mTextPaintColor;
        }
    }

    public int getmFrontPaintColor() {
        return mFrontPaintColor;
    }

    public void setmFrontPaintColor(int mFrontPaintColor) {
        if (mFrontPaintColor != 0) {
            this.mFrontPaintColor = mFrontPaintColor;
        }
    }

    public int getmBackPaintColor() {
        return mBackPaintColor;
    }

    public void setmBackPaintColor(int mBackPaintColor) {
        if (mBackPaintColor != 0) {
            this.mBackPaintColor = mBackPaintColor;
        }
    }
    
   public int getmMax() {
        return mMax;
   }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

activity_main.xml引用

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="1">

        <com.example.progressbardemo.CustomPgBar
            android:id="@+id/cusbar"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    </RelativeLayout>
1
2
3
4
5
6
7
8
9
10

---

MainActivity.java

public class MainActivity extends AppCompatActivity {
    CustomPgBar cusbar;
    int a;     //事务执行的总进度
    int b = 0;     //事务执行的初始进度
    int c;     //进度条的总进度

    Handler myHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 111) {

                //计算当前实际进度
                double e = (double) b / a;
                double f = c * e;
                int g = (int) f;

                cusbar.setmTargetProgress(g);   //修改进度值
                cusbar.invalidate();    //重新绘制viwe

            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        cusbar = (CustomPgBar) findViewById(R.id.cusbar);
        c = cusbar.getmMax();
        //执行事务，每秒钟返回一次事务执行进度
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                a = 200;
                b++;
                if (b >= a) {
                    cancel();
                }
            }
        }, 0, 1000);

        //每秒钟将事务返回的进度值通过hander更新到UI显示中
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                if (b > a) {
                    cancel();
                } else {
                    //定时循环执行的内容
                    myHandler.sendEmptyMessage(111);
                }
            }
        }, 0, 1000);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

总结

以上就是今天要讲的内容。