Android ProgressBar详解以及自定义

版本：1.0日期：2014.5.16版权：© 2014 kince 转载注明出处
这一次主要说一下Android下的进度条，为何是它呢，由于近期被其各类美轮美奂的设计所倾倒，计划逐渐去实现。另一个因素也是它也是为数很少的直接继承于View类的控件，从中 是否是很漂亮，其实就像上面图形展现的那样，进度条大致上无非就是这几种形式。这样一来确定是须要自定义了，因此方向有两个：要么继承于系统的ProgressBar；要么继承于View类（前者就是如此实现）。那就先看一下系统的进度条吧。
继承于View类，直接子类有AbsSeekBar和ContentLoadingProgressBar，其中AbsSeekBar的子类有SeekBar和RatingBar，可见这两者也是基于ProgressBar实现的。对于ProgressBar的使用，有三个地方须要注意一下： 一、ProgressBar有两个进度，一个是android:progress，另外一个是android:secondaryProgress。后者主要是为缓存须要所涉及的，好比在看网络视频时候都会有一个缓存的进度条以及还要一个播放的进度，在这里缓存的进度就能够是android:secondaryProgress，而播放进度就是android:progress。 二、ProgressBar分为肯定的和不肯定的，上面说的播放进度、缓存等就是肯定的。相反地，不肯定的就是不清楚、不肯定一个操做须要多长时间来完成，这个时候就须要用的不肯定的ProgressBar了。这个是由属性android:indeterminate来控制的，若是设置为true的话，那么ProgressBar就多是圆形的滚动条或者水平的滚动条（由样式决定）。默认状况下，若是是水平进度条，那么就是肯定的。 三、ProgressBar的样式设定其实有两种方式，在API文档中说明的方式以下：

Widget.ProgressBar.HorizontalWidget.ProgressBar.SmallWidget.ProgressBar.LargeWidget.ProgressBar.InverseWidget.ProgressBar.Small.InverseWidget.ProgressBar.Large.Inverse 使用的时候能够这样：style="@android:style/Widget.ProgressBar.Small"。另外还有一种方式就是使用系统的attr，上面的方式是系统的style：
style="?android:attr/progressBarStyle" style="?android:attr/progressBarStyleHorizontal" style="?android:attr/progressBarStyleInverse" style="?android:attr/progressBarStyleLarge" style="?android:attr/progressBarStyleLargeInverse" style="?android:attr/progressBarStyleSmall" style="?android:attr/progressBarStyleSmallInverse" style="?android:attr/progressBarStyleSmallTitle" 而后再看一下ProgressBar的其余经常使用属性，
关于这些属性的使用仍是比较简单，很少作介绍。其中第一个android:animationResolution已经呗舍弃了，因此不要去研究它了。重点说一下android:progressDrawable以及android:indeterminateDrawable。那这个Drawable在ProgressBar中是如何使用的呢，若是咱们是这样在xml中设置ProgressBar的话，

?

1

<progressbar android:id="@+id/progressbar" style="@android:style/Widget.ProgressBar.Horizontal" android:layout_width="match_parent" android:layout_height="wrap_content" android:secondaryprogress="50"></progressbar>

虽然没有设置android:indeterminateDrawable，可是样式Widget.ProgressBar.Horizontal已经帮咱们设置好了。查看源码以下：

?

1

2

3

4

5

6

7

8

<style name="Widget.ProgressBar.Horizontal">

<item name="android:indeterminateOnly">false</item>

<item name="android:progressDrawable">@android:drawable/progress_horizontal</item>

<item name="android:indeterminateDrawable">@android:drawable/progress_indeterminate_horizontal</item>

<item name="android:minHeight">20dip</item>

<item name="android:maxHeight">20dip</item>

<item name="android:mirrorForRtl">true</item>

</style>

先看一下progress_horizontal，源码以下：

?

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

<!--?xml version="1.0" encoding="utf-8"?-->

<!-- Copyright (C) 2008 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

-->

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

<item android:id="@android:id/background">

<shape>

<corners android:radius="5dip">

<gradient android:startcolor="#ff9d9e9d" android:centercolor="#ff5a5d5a" android:centery="0.75" android:endcolor="#ff747674" android:angle="270">

</gradient></corners></shape>

</item>

<item android:id="@android:id/secondaryProgress">

<clip>

<shape>

<corners android:radius="5dip">

<gradient android:startcolor="#80ffd300" android:centercolor="#80ffb600" android:centery="0.75" android:endcolor="#a0ffcb00" android:angle="270">

</gradient></corners></shape>

</clip>

</item>

<item android:id="@android:id/progress">

<clip>

<shape>

<corners android:radius="5dip">

<gradient android:startcolor="#ffffd300" android:centercolor="#ffffb600" android:centery="0.75" android:endcolor="#ffffcb00" android:angle="270">

</gradient></corners></shape>

</clip>

</item>

</layer-list>

能够看到，系统使用的是图层方式，以覆盖的方式进行的。因此若是须要其余的样式的话，改变系统默认的值便可，或者参考一下系统自带的样式设置就好了。
紧接着，说一下ProgressBar的方法，整体来讲，能够分为两个部分。一是和自身属性相关的，好比获取进度、设置进度的最大值、设置插入器等等。二是和绘制相关的部分，如图所示：
因此、因此咱们本次最重要的部分来了，那就是如何自定义一个漂亮ProgressBar。在自定义以前，先看一下系统是如何实现的。Android下ProgressBar的代码量不算多，除去注释估计也就是几百行左右。首先从构造方法看是看，

?

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

/**

* Create a new progress bar with range 0...100 and initial progress of 0.

* @param context the application environment

*/

public ProgressBar(Context context) {

this(context, null);

}

public ProgressBar(Context context, AttributeSet attrs) {

this(context, attrs, com.android.internal.R.attr.progressBarStyle);

}

public ProgressBar(Context context, AttributeSet attrs, int defStyle) {

this(context, attrs, defStyle, 0);

}

/**

* @hide

*/

public ProgressBar(Context context, AttributeSet attrs, int defStyle, int styleRes) {

super(context, attrs, defStyle);

mUiThreadId = Thread.currentThread().getId();

initProgressBar();

TypedArray a =

context.obtainStyledAttributes(attrs, R.styleable.ProgressBar, defStyle, styleRes);

mNoInvalidate = true;

Drawable drawable = a.getDrawable(R.styleable.ProgressBar_progressDrawable);

if (drawable != null) {

drawable = tileify(drawable, false);

// Calling this method can set mMaxHeight, make sure the corresponding

// XML attribute for mMaxHeight is read after calling this method

setProgressDrawable(drawable);

}

mDuration = a.getInt(R.styleable.ProgressBar_indeterminateDuration, mDuration);

mMinWidth = a.getDimensionPixelSize(R.styleable.ProgressBar_minWidth, mMinWidth);

mMaxWidth = a.getDimensionPixelSize(R.styleable.ProgressBar_maxWidth, mMaxWidth);

mMinHeight = a.getDimensionPixelSize(R.styleable.ProgressBar_minHeight, mMinHeight);

mMaxHeight = a.getDimensionPixelSize(R.styleable.ProgressBar_maxHeight, mMaxHeight);

mBehavior = a.getInt(R.styleable.ProgressBar_indeterminateBehavior, mBehavior);

final int resID = a.getResourceId(

com.android.internal.R.styleable.ProgressBar_interpolator,

android.R.anim. linear_interpolator); // default to linear interpolator

if (resID > 0) {

setInterpolator(context, resID);

}

setMax(a.getInt(R.styleable.ProgressBar_max, mMax));

setProgress(a.getInt(R.styleable.ProgressBar_progress, mProgress));

setSecondaryProgress(

a.getInt(R.styleable.ProgressBar_secondaryProgress, mSecondaryProgress));

drawable = a.getDrawable(R.styleable.ProgressBar_indeterminateDrawable);

if (drawable != null) {

drawable = tileifyIndeterminate(drawable);

setIndeterminateDrawable(drawable);

}

mOnlyIndeterminate = a.getBoolean(

R.styleable.ProgressBar_indeterminateOnly, mOnlyIndeterminate);

mNoInvalidate = false;

setIndeterminate( mOnlyIndeterminate || a.getBoolean(

R.styleable.ProgressBar_indeterminate, mIndeterminate));

mMirrorForRtl = a.getBoolean(R.styleable.ProgressBar_mirrorForRtl, mMirrorForRtl);

a.recycle();

}

样式文件以下：

?

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

R.styleable.Progre：

<declare-styleable name="ProgressBar">

<!-- Defines the maximum value the progress can take. -->

<!-- Defines the default progress value, between 0 and max. -->

<!-- Defines the secondary progress value, between 0 and max. This progress is drawn between

the primary progress and the background.  It can be ideal for media scenarios such as

showing the buffering progress while the default progress shows the play progress. -->

<!-- Allows to enable the indeterminate mode. In this mode the progress

bar plays an infinite looping animation. -->

<!-- Restricts to ONLY indeterminate mode (state-keeping progress mode will not work). -->

<!-- Drawable used for the indeterminate mode. -->

<!-- Drawable used for the progress mode. -->

<!-- Duration of the indeterminate animation. -->

<!-- Defines how the indeterminate mode should behave when the progress

reaches max. -->

<!-- Progress starts over from 0. -->

<enum name="repeat" value="1">

<!-- Progress keeps the current value and goes back to 0. -->

<enum name="cycle" value="2">

</enum></enum></attr>

<!-- Timeout between frames of animation in milliseconds

{@deprecated Not used by the framework.} -->

</attr></attr></attr></attr></attr></attr></attr></attr></attr></attr></attr></attr></attr></attr></declare-styleable>

ProgressBar把三个构造方法都列出来了，并使用了递归调用的方式，还有一个方式就是分别在每个构造方法中都调用初始化的代码，我的以为仍是此处比较正规。而后看一下第三个构造方法，在这里主要作了两件事情，一个是从attrs文件中读取设置的属性；一个是initProgressBar()方法，为ProgressBar设置一些默认的属性值。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

private void initProgressBar() {

mMax = 100;

mProgress = 0;

mSecondaryProgress = 0;

mIndeterminate = false;

mOnlyIndeterminate = false;

mDuration = 4000;

mBehavior = AlphaAnimation.RESTART;

mMinWidth = 24;

mMaxWidth = 48;

mMinHeight = 24;

mMaxHeight = 48;

}

这就是默认的属性值。这在自定义View中算是最基础的了，很少说，不过在这里须要注意两个地方。一是mUiThreadId，他是干吗的呢，它获取的是当前UI线程的id，而后在更新ProgressBar进度的时候进行一个判断，若是是UI线程，那么直接进行更新，若是不是就post出去，使用Handler等进行更新。二是tileify(drawable, false)方法和tileifyIndeterminate(drawable)方法。这两个方法主要是对Drawable进行一个解析、转换的过程。在这里须要重点强调一下，在ProgressBar中，最重要的部分就是Drawable的使用了，由于不只是它的背景包括进度等都是使用Drawable来完成的，因此在源码中也能够看到基本上百分之七八十的代码都是和Drawable有关的。由于这一部分篇幅较多，因此就不详细介绍了，下面重点说一下如何绘制ProgressBar，首先看onMeasure()方法，

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

@Override

protected synchronized void onMeasure( int widthMeasureSpec, int heightMeasureSpec) {

Drawable d = mCurrentDrawable;

int dw = 0;

int dh = 0;

if (d != null) {

dw = Math. max(mMinWidth , Math.min( mMaxWidth, d.getIntrinsicWidth()));

dh = Math. max(mMinHeight , Math.min( mMaxHeight, d.getIntrinsicHeight()));

}

updateDrawableState();

dw += mPaddingLeft + mPaddingRight;

dh += mPaddingTop + mPaddingBottom;

setMeasuredDimension( resolveSizeAndState(dw, widthMeasureSpec, 0),

resolveSizeAndState(dh, heightMeasureSpec, 0));

}

这是测量View大小的方法，也就是ProgressBar的大小，由于每个ProgressBar默认都会使用Drawable。因此ProgressBar的大小便是Drawable的大小加上Padding的大小，若是没有Padding，那很显然就是Drawable的大小。最后使用setMeasuredDimension()方法设置ProgressBar的大小。 按照正常的流程，有些朋友可能会想到重写onLayout()方法了，可是这里ProgressBar只是一个View，不须要进行位置的处理。因此直接进入onDraw()方法，在

?

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

@Override

protected synchronized void onDraw(Canvas canvas) {

super.onDraw(canvas);

Drawable d = mCurrentDrawable;

if (d != null) {

// Translate canvas so a indeterminate circular progress bar with padding

// rotates properly in its animation

canvas.save();

if(isLayoutRtl() && mMirrorForRtl) {

canvas.translate(getWidth() - mPaddingRight, mPaddingTop);

canvas.scale(-1.0f, 1.0f);

} else {

canvas.translate(mPaddingLeft, mPaddingTop);

}

long time = getDrawingTime();

if ( mHasAnimation) {

mAnimation.getTransformation(time, mTransformation);

float scale = mTransformation.getAlpha();

try {

mInDrawing = true;

d.setLevel(( int) (scale * MAX_LEVEL));

} finally {

mInDrawing = false;

}

postInvalidateOnAnimation();

}

d.draw(canvas);

canvas.restore();

if ( mShouldStartAnimationDrawable && d instanceof Animatable) {

((Animatable) d).start();

mShouldStartAnimationDrawable = false ;

}

}

首先也是先获取当前的Drawable对象，若是不为空就开始绘图，先是一个判断，根据布局的方向来转移画布，isLayoutRtl()是View类的方法，

?

1

2

3

public boolean isLayoutRtl() {

return (getLayoutDirection() == LAYOUT_DIRECTION_RTL);

}

这个LAYOUT_DIRECTION_RTL是LayoutDirection的一个常量，

?

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

package android.util;

/**

* A class for defining layout directions. A layout direction can be left-to-right (LTR)

* or right-to-left (RTL). It can also be inherited (from a parent) or deduced from the default

* language script of a locale.

*/

public final class LayoutDirection {

// No instantiation

private LayoutDirection() {}

/**

* Horizontal layout direction is from Left to Right.

*/

public static final int LTR = 0;

/**

* Horizontal layout direction is from Right to Left.

*/

public static final int RTL = 1;

/**

* Horizontal layout direction is inherited.

*/

public static final int INHERIT = 2;

/**

* Horizontal layout direction is deduced from the default language script for the locale.

*/

public static final int LOCALE = 3;

}

而后再判断有没有动画，若是有的话，就调用View类的postInvalidateOnAnimation()方法去执行一个动画。最后调用Drawable对象去画出来d.draw(canvas)。 总的来讲，系统的ProgressBar是和Drawable紧密相关的，因此说，若是咱们自定义的ProgressBar和Drawable有关，那么彻底能够继承于系统的ProgressBar来开发便可。若是你的自定义ProgressBar和Drawable关系不大，好比是这样的， 其实，就不须要Drawable了，彻底能够直接继承于View类开发。 那下面就从两个方面来自定义ProgressBar，1、继承于系统ProgressBar 首先看一下上面给出的进度条其中的一个， 思路： Mini ProgressBar在原生ProgressBar的基础上加入了一个指示器，而且有文字显示。实现的时候能够这样，也就是说，自定义的ProgressBar包含了两个部分，一部分是默认的；另外一部分是新添加的指示器。其实指示器就是一个Drawable和文本的组合，并且直接画在系统ProgressBar的上面便可。接着，关于自定义的ProgressBar的属性也要定义一下，好比Drawable、好比文本、好比间隔等。因此attrs文件能够这样来写了：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

<!--?xml version= "1.0" encoding ="utf-8"?-->

<resources>

<declare-styleable>

</attr>

<!-- attr-->

<!-- attr-->

</attr>

<flag name="normal" value="0">

<flag name="bold" value="1">

<flag name="italic" value="2">

</flag></flag></flag></attr>

<flag name="left" value="0">

<flag name="center" value="1">

<flag name="right" value="2">

</flag></flag></flag></attr>

</attr></attr></declare-styleable>

</resources>

ps：我发现eclipse在写declare-styleable不会自动提示，不清楚什么缘由，知道的朋友望告知。 以后咱们新建一个类继承于ProgressBar，

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

/**

* @author kince

*

*/

public class IndicatorProgressBar extends ProgressBar {

public IndicatorProgressBar(Context context) {

this(context, null);

}

public IndicatorProgressBar(Context context, AttributeSet attrs) {

this(context, attrs, 0);

}

public IndicatorProgressBar(Context context, AttributeSet attrs,

int defStyle) {

super(context, attrs, defStyle);

}

}

而后在第三个构造方法中初始化数据，由于用到了文本以及Drawable，因此还须要声明全局变量，初始化完毕后代码以下：

?

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

/**

*

*/

package com.example.indicatorprogressbar.widget;

import com.example.indicatorprogressbar.R;

import android.content.Context;

import android.content.res.TypedArray;

import android.graphics.Color;

import android.graphics.Paint;

import android.graphics.Paint.Align;

import android.graphics.drawable.Drawable;

import android.text.TextPaint;

import android.util.AttributeSet;

import android.widget.ProgressBar;

/**

* @author kince

*

*/

public class IndicatorProgressBar extends ProgressBar {

private TextPaint mTextPaint;

private Drawable mDrawableIndicator;

private int offset=5;

public IndicatorProgressBar(Context context) {

this(context, null);

}

public IndicatorProgressBar(Context context, AttributeSet attrs) {

this(context, attrs, 0);

mTextPaint=new TextPaint(Paint.ANTI_ALIAS_FLAG);

mTextPaint.density=getResources().getDisplayMetrics().density;

mTextPaint.setColor(Color.WHITE);

mTextPaint.setTextSize(10);

mTextPaint.setTextAlign(Align.CENTER);

mTextPaint.setFakeBoldText(true);

}

public IndicatorProgressBar(Context context, AttributeSet attrs,

int defStyle) {

super(context, attrs, defStyle);

TypedArray array=context.obtainStyledAttributes(attrs, R.styleable.IndicatorProgressBar, defStyle, 0);

if(array!=null){

mDrawableIndicator=array.getDrawable(R.styleable.IndicatorProgressBar_progressIndicator);

offset=array.getInt(R.styleable.IndicatorProgressBar_offset, 0);

array.recycle();

}

}

}

而后，为全局变量设置set、get方法，方便在程序中调用。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

public Drawable getmDrawableIndicator() {

return mDrawableIndicator ;

}

public void setmDrawableIndicator(Drawable mDrawableIndicator) {

this.mDrawableIndicator = mDrawableIndicator;

}

public int getOffset() {

return offset ;

}

public void setOffset(int offset) {

this.offset = offset;

}

接下来，就是重写onMeasure()、onDraw()方法了。在onMeasure()中，须要对进度条计算好具体大小，那根据上面的图示，这个进度条的宽度和系统进度条的宽度是同样的，也就是getMeasuredWidth()；高度的话，由于加了一个指示器，因此高度是指示器的高度加上系统进度条的高度。所以在onMeasure()方法中就能够这样来写：

?

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

@Override

protected synchronized void onMeasure(int widthMeasureSpec,

int heightMeasureSpec) {

// TODO Auto-generated method stub

super.onMeasure(widthMeasureSpec, heightMeasureSpec);

if(mDrawableIndicator!=null){

//获取系统进度条的宽度 这个宽度也是自定义进度条的宽度 因此在这里直接赋值

final int width=getMeasuredWidth();

final int height=getMeasuredHeight()+getIndicatorHeight();

setMeasuredDimension(width, height);

}

}

/**

* @category 获取指示器的高度

* @return

*/

private int getIndicatorHeight(){

if(mDrawableIndicator==null){

return 0;

}

Rect r=mDrawableIndicator.copyBounds();

int height=r.height();

return height;

}

而后是onDraw()方法，由于在onMeasure()方法中增长了进度条的高度，因此在画的时候须要将系统进度条与指示器分隔开来。在进度条的样式文件中，咱们是这样配置的：

?

1

2

3

4

5

6

7

<style name="Widget.ProgressBar.RegularProgressBar">

<item name="android:indeterminateOnly" >false </item>

<item name="android:progressDrawable" >@drawable/progressbar </item>

<item name="android:indeterminateDrawable" >@android:drawable/progress_indeterminate_horizontal </item>

<item name= "android:minHeight">1dip</item >

<item name= "android:maxHeight">10dip</item >

</style>

在android:progressDrawable的属性中，使用的drawable是这样的：

?

1

2

3

4

5

6

7

8

9

10

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

<item android:id="@android:id/background" android:drawable="@drawable/progressbar_bg">

<item android:id="@+id/progress" android:drawable="@drawable/progressbar_bar">

</item>

<item android:id="@+id/pattern">

<bitmap android:src="@drawable/progressbar_pattern" android:tilemode="repeat">

</bitmap></item>

</item></layer-list>

能够发现，是一个layer类型的drawable，因此在计算大小的时候，须要特别考虑这个状况。代码以下：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

if (m_indicator != null) {

if (progressDrawable != null

&& progressDrawable instanceof LayerDrawable) {

LayerDrawable d = (LayerDrawable) progressDrawable;

for (int i = 0; i < d.getNumberOfLayers(); i++) {

d.getDrawable(i).getBounds(). top = getIndicatorHeight();

d.getDrawable(i).getBounds(). bottom = d.getDrawable(i)

.getBounds().height()

+ getIndicatorHeight();

}

} else if (progressDrawable != null) {

progressDrawable.getBounds(). top = m_indicator

.getIntrinsicHeight();

progressDrawable.getBounds(). bottom = progressDrawable

.getBounds().height() + getIndicatorHeight();

}

}

而后须要更新进度条的位置，

?

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

private void updateProgressBar () {

Drawable progressDrawable = getProgressDrawable();

if (progressDrawable != null

&& progressDrawable instanceof LayerDrawable) {

LayerDrawable d = (LayerDrawable) progressDrawable;

final float scale = getScale(getProgress());

// 获取进度条 更新它的大小

Drawable progressBar = d.findDrawableByLayerId(R.id.progress );

final int width = d.getBounds(). right - d.getBounds().left ;

if (progressBar != null) {

Rect progressBarBounds = progressBar.getBounds();

progressBarBounds. right = progressBarBounds.left

+ ( int ) (width * scale + 0.5f);

progressBar.setBounds(progressBarBounds);

}

// 获取叠加的图层

Drawable patternOverlay = d.findDrawableByLayerId(R.id.pattern );

if (patternOverlay != null) {

if (progressBar != null) {

// 使叠加图层适应进度条大小

Rect patternOverlayBounds = progressBar.copyBounds();

final int left = patternOverlayBounds.left ;

final int right = patternOverlayBounds.right ;

patternOverlayBounds. left = (left + 1 > right) ? left

: left + 1;

patternOverlayBounds. right = (right > 0) ? right - 1

: right;

patternOverlay.setBounds(patternOverlayBounds);

} else {

// 没有叠加图层

Rect patternOverlayBounds = patternOverlay.getBounds();

patternOverlayBounds. right = patternOverlayBounds.left

+ ( int ) (width * scale + 0.5f);

patternOverlay.setBounds(patternOverlayBounds);

}

}

}

}

最后，须要把指示器画出来，

?

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

if (m_indicator != null) {

canvas.save();

int dx = 0;

// 获取系统进度条最右边的位置 也就是头部的位置

if (progressDrawable != null

&& progressDrawable instanceof LayerDrawable) {

LayerDrawable d = (LayerDrawable) progressDrawable;

Drawable progressBar = d.findDrawableByLayerId(R.id.progress );

dx = progressBar.getBounds(). right;

} else if (progressDrawable != null) {

dx = progressDrawable.getBounds().right ;

}

//加入offset

dx = dx - getIndicatorWidth() / 2 - m_offset + getPaddingLeft();

// 移动画笔位置

canvas.translate(dx, 0);

// 画出指示器

m_indicator .draw(canvas);

// 画出进度数字

canvas.drawText(

m_formatter != null ? m_formatter .getText(getProgress())

: Math.round(getScale(getProgress()) * 100.0f)

+ "%" , getIndicatorWidth() / 2,

getIndicatorHeight() / 2 + 1, m_textPaint );

// restore canvas to original

canvas.restore();

}

源码下载：