Android 自定义横向进度条
一、工具类如下代码,可自定义进度条背景色,边框颜色,进度值设置等
public class ZzHorizontalProgressBar extends View {
private int max;
private double progress;
private int bgColor;
private int progressColor;
private int padding;
private boolean openGradient;
private int gradientFrom;
private int gradientTo;
private boolean showSecondProgress;
private int secondProgress;
private int secondProgressShape;
private boolean showZeroPoint;
private Paint secondProgressPaint;
private Paint secondGradientPaint;
private Paint progressPaint;
private Paint gradientPaint;
private Paint bgPaint;
private boolean openSecondGradient;
private int secondGradientFrom;
private int secondGradientTo;
private int secondProgressColor;
private int radius;
private boolean drawBorder = false ;
private int borderColor;
private int borderWidth;
/**
* 文字百分比的字体大小(sp)
*/
private int paintTextSize;
/**
* 百分比文字的颜色
*/
private int paintTextColor;
/**
* 画中间的百分比文字的画笔
*/
private Paint paintText;
/**
* 要画的文字的宽度
*/
private int textWidth;
/**
* 画文字时底部的坐标
*/
private float textBottomY;
/**
* 得到自定义视图的Y轴中心点
*/
private int viewCenterY;
/**
* 包裹文字的矩形
*/
private Rect rect = new Rect( ) ;
/**
* 得到自定义视图的宽度
*/
private int viewWidth;
/**
* 文字总共移动的长度(即从0%到100%文字左侧移动的长度)
*/
private int totalMovedLength;
/**
* Contxt
*/
private Context context;
// private boolean useRectMode = false ;
private int showMode = 0 ;
private Paint borderPaint;
public static enum ShowMode {
ROUND, RECT, ROUND_RECT
}
private String mText;
private OnProgressChangedListener onProgressChangedListener;
public interface OnProgressChangedListener {
void onProgressChanged( ZzHorizontalProgressBar progressBar, int max, double progress) ;
void onSecondProgressChanged( ZzHorizontalProgressBar progressBar, int max, double progress) ;
}
public ZzHorizontalProgressBar( Context context) {
super( context) ;
this.context = context;
init( context, null) ;
}
public ZzHorizontalProgressBar( Context context, AttributeSet attrs) {
super( context, attrs) ;
init( context, attrs) ;
}
public ZzHorizontalProgressBar( Context context, AttributeSet attrs, int defStyleAttr) {
super( context, attrs, defStyleAttr) ;
init( context, attrs) ;
}
private void init( Context context, AttributeSet attrs) {
initAttrs( context, attrs) ;
initPaths( ) ;
}
private void initAttrs( Context context, AttributeSet attrs) {
TypedArray a = context.obtainStyledAttributes( attrs, R.styleable.ZzHorizontalProgressBar) ;
max = a.getInteger( R.styleable.ZzHorizontalProgressBar_zpb_max, 100 ) ;
progress = a.getInteger( R.styleable.ZzHorizontalProgressBar_zpb_progress, 0 ) ;
bgColor = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_bg_color, 0xffB8B8B8) ;
progressColor = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_pb_color, 0xffFF4081) ;
secondProgressColor = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_second_pb_color, 0xffFF4081) ;
padding = a.getDimensionPixelSize( R.styleable.ZzHorizontalProgressBar_zpb_padding, 0 ) ;
showZeroPoint = a.getBoolean( R.styleable.ZzHorizontalProgressBar_zpb_show_zero_point, false ) ;
showSecondProgress = a.getBoolean( R.styleable.ZzHorizontalProgressBar_zpb_show_second_progress, false ) ;
secondProgress = a.getInteger( R.styleable.ZzHorizontalProgressBar_zpb_second_progress, 0 ) ;
secondProgressShape = a.getInteger( R.styleable.ZzHorizontalProgressBar_zpb_show_second_point_shape, 0 ) ;
openGradient = a.getBoolean( R.styleable.ZzHorizontalProgressBar_zpb_open_gradient, false ) ;
gradientFrom = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_gradient_from, 0xffFF4081) ;
paintTextColor = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_text, 0xffcd5c5c) ;
gradientTo = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_gradient_to, 0xffFF4081) ;
openSecondGradient = a.getBoolean( R.styleable.ZzHorizontalProgressBar_zpb_open_second_gradient, false ) ;
showMode = a.getInt( R.styleable.ZzHorizontalProgressBar_zpb_show_mode, 0 ) ;
secondGradientFrom = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_second_gradient_from, 0xffFF4081) ;
secondGradientTo = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_second_gradient_to, 0xffFF4081) ;
radius = a.getDimensionPixelSize( R.styleable.ZzHorizontalProgressBar_zpb_round_rect_radius, 20 ) ;
drawBorder = a.getBoolean( R.styleable.ZzHorizontalProgressBar_zpb_draw_border, false ) ;
borderWidth = a.getDimensionPixelSize( R.styleable.ZzHorizontalProgressBar_zpb_border_width, 1 ) ;
paintTextSize = a.getDimensionPixelSize( R.styleable.ZzHorizontalProgressBar_zpb_border_width, 20 ) ;
borderColor = a.getColor( R.styleable.ZzHorizontalProgressBar_zpb_border_color, 0xffff001f) ;
a.recycle( ) ;
}
private void initPaths ( ) {
progressPaint = new Paint( ) ;
progressPaint.setColor( progressColor) ;
progressPaint.setStyle( Paint.Style.FILL) ;
progressPaint.setAntiAlias( true) ;
secondProgressPaint = new Paint( ) ;
secondProgressPaint.setColor( secondProgressColor) ;
secondProgressPaint.setStyle( Paint.Style.FILL) ;
secondProgressPaint.setAntiAlias( true) ;
gradientPaint = new Paint( ) ;
gradientPaint.setStyle( Paint.Style.FILL) ;
gradientPaint.setAntiAlias( true) ;
secondGradientPaint = new Paint( ) ;
secondGradientPaint.setStyle( Paint.Style.FILL) ;
secondGradientPaint.setAntiAlias( true) ;
bgPaint = new Paint( ) ;
bgPaint.setColor( bgColor) ;
bgPaint.setStyle( Paint.Style.FILL) ;
bgPaint.setAntiAlias( true) ;
borderPaint = new Paint( ) ;
borderPaint.setColor( borderColor) ;
borderPaint.setStyle( Paint.Style.STROKE) ;
borderPaint.setStrokeWidth( borderWidth) ;
borderPaint.setAntiAlias( true) ;
//设置百分比文字的尺寸
// int paintTextSizePx = sp2px( context, paintTextSize) ;
// 百分比文字画笔的属性
paintText = new Paint( ) ;
mText = "Udf32fA" ;
// paintText.setColor( Color.BLACK) ;
paintText.setColor( Color.parseColor( "#333333" )) ;
paintText.setTextSize( 30 ) ;
paintText.setAntiAlias( true) ;
paintText.setTypeface( Typeface.DEFAULT_BOLD) ;
//获得绘制文本的宽和高
rect = new Rect( ) ;
paintText.getTextBounds( mText, 0 , mText.length( ) , rect) ;
}
/**
* 得到视图等的高度宽度尺寸数据
*/
private void getWidthAndHeight ( ) {
//得到包围文字的矩形的宽高
paintText.getTextBounds( "000%" , 0 , "000%" .length( ) , rect) ;
textWidth = rect.width( ) ;
textBottomY = viewCenterY + rect.height( ) / 2 ;
//得到自定义视图的高度
int viewHeight = getMeasuredHeight( ) ;
viewWidth = getMeasuredWidth( ) ;
viewCenterY = viewHeight / 2 ;
totalMovedLength = viewWidth - textWidth;
}
@Override
protected void onDraw( Canvas canvas) {
super.onDraw( canvas) ;
switch ( showMode) {
case 0 :
//half cicle
drawBackground( canvas) ;
drawProgress( canvas) ;
drawBorder( canvas) ;
break ;
case 1 :
//rect
drawBackgroundRectMode( canvas) ;
drawProgressRectMode( canvas) ;
drawBorderRect( canvas) ;
break ;
case 2 :
//custom radius
drawBackgroundRoundRectMode( canvas) ;
drawProgressRoundRectMode( canvas) ;
drawBorderRoundRect( canvas) ;
break ;
}
// canvas.drawText( progress + "%" ,progress, padding + progressHeight / 2 , paintText) ;
// canvas.drawText( mText + "%" , percent, width, paintText) ;
// canvas.drawText( progress + "%" , getWidth( ) / 2 - rect.width( ) / 2 , getHeight( ) / 2 + rect.height( ) / 2 , paintText) ;
Log.i( "aaaa" , "onDraw: " + ( getWidth( ) / 2 - rect.width( ) / 2 ) + "------------" + ( getHeight( ) / 2 + rect.height( ) / 2 )) ;
}
private void drawProgress( Canvas canvas) {
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
double percent = 0 ;
if ( max != 0 ) {
percent = progress * 1 .0f / max;
}
int progressHeight = getHeight( ) - padding * 2 ;
if ( progressHeight % 2 != 0 ) {
progressHeight = progressHeight - 1 ;
}
if ( openGradient) {
int progressWidth = width - padding * 2 ;
float mDx = convertToFloat( progressWidth * percent) ;
int colors[ ] = new int[ 2 ] ;
float positions[ ] = new float[ 2 ] ;
//from color
colors[ 0 ] = gradientFrom;
positions[ 0 ] = 0 ;
//to color
colors[ 1 ] = gradientTo;
positions[ 1 ] = 1 ;
LinearGradient shader = new LinearGradient(
padding + progressHeight / 2 , padding, padding + progressHeight / 2 + mDx, padding + progressHeight,
colors,
positions,
Shader.TileMode.MIRROR) ;
//gradient
gradientPaint.setShader( shader) ;
int radius = width > getHeight( ) ? getHeight( ) / 2 : width / 2 ;
if ( mDx < getHeight( )) {
//left circle
if ( progress == 0 ) {
if ( showZeroPoint) {
canvas.drawCircle( padding + progressHeight / 2 , padding + progressHeight / 2 , progressHeight / 2 , gradientPaint) ;
}
} else {
canvas.drawCircle( padding + progressHeight / 2 , padding + progressHeight / 2 , progressHeight / 2 , gradientPaint) ;
}
} else {
//progress line
RectF rectF = new RectF( padding, padding, padding + mDx, padding + progressHeight) ;
canvas.drawRoundRect( rectF, radius, radius, gradientPaint) ;
}
} else {
int progressWidth = width - padding * 2 - progressHeight;
float dx = convertToFloat( progressWidth * percent) ;
progressPaint.setColor( progressColor) ;
//left circle
if ( progress == 0 ) {
if ( showZeroPoint) {
canvas.drawCircle( padding + progressHeight / 2 , padding + progressHeight / 2 , progressHeight / 2 , progressPaint) ;
}
} else {
canvas.drawCircle( padding + progressHeight / 2 , padding + progressHeight / 2 , progressHeight / 2 , progressPaint) ;
}
//right circle
if ( progress == 0 ) {
if ( showZeroPoint) {
canvas.drawCircle( padding + progressHeight / 2 + dx, padding + progressHeight / 2 , progressHeight / 2 , progressPaint) ;
}
} else {
canvas.drawCircle( padding + progressHeight / 2 + dx, padding + progressHeight / 2 , progressHeight / 2 , progressPaint) ;
}
//middle line
RectF midRecf = new RectF( padding + progressHeight / 2 , padding, padding + progressHeight / 2 + dx, padding + progressHeight) ;
canvas.drawRect( midRecf, progressPaint) ;
//得到float型进度
float progressFloat = convertToFloat( progress / 100 .0f) ;
//当前文字移动的长度
float currentMovedLentgh = totalMovedLength * progressFloat;
// canvas.drawText( progress + "%" , ( getWidth( ) / 2 - rect.width( ) / 2 ) + progress, getHeight( ) / 2 + rect.height( ) / 2 , paintText) ;
if ( progress > 95 ) {
canvas.drawText( progress + "%" , currentMovedLentgh - textWidth / 2 , getHeight( ) / 2 + rect.height( ) / 2 , paintText) ;
} else {
canvas.drawText( progress + "%" , currentMovedLentgh + textWidth, getHeight( ) / 2 + rect.height( ) / 2 , paintText) ;
}
}
//draw second progress
if ( showSecondProgress) {
float s_percent = 0 ;
if ( max != 0 ) {
s_percent = secondProgress * 1 .0f / max;
}
int s_progressHeight = getHeight( ) - padding * 2 ;
if ( s_progressHeight % 2 != 0 ) {
s_progressHeight = s_progressHeight - 1 ;
}
if ( openSecondGradient) {
int s_progressWidth = width - padding * 2 ;
float s_mDx = s_progressWidth * s_percent;
int s_colors[ ] = new int[ 2 ] ;
float s_positions[ ] = new float[ 2 ] ;
//from color
s_colors[ 0 ] = secondGradientFrom;
s_positions[ 0 ] = 0 ;
//to color
s_colors[ 1 ] = secondGradientTo;
s_positions[ 1 ] = 1 ;
LinearGradient s_shader = new LinearGradient(
padding + s_progressHeight / 2 , padding, padding + s_progressHeight / 2 + s_mDx, padding + s_progressHeight,
s_colors,
s_positions,
Shader.TileMode.MIRROR) ;
//gradient
secondGradientPaint.setShader( s_shader) ;
int s_radius = width > getHeight( ) ? getHeight( ) / 2 : width / 2 ;
if ( s_mDx < getHeight( )) {
//left circle
if ( secondProgress == 0 ) {
if ( showZeroPoint) {
canvas.drawCircle( padding + s_progressHeight / 2 , padding + s_progressHeight / 2 , s_progressHeight / 2 , secondGradientPaint) ;
}
} else {
canvas.drawCircle( padding + s_progressHeight / 2 , padding + s_progressHeight / 2 , s_progressHeight / 2 , secondGradientPaint) ;
}
} else {
//progress line
RectF rectF = new RectF( padding, padding, padding + s_mDx, padding + s_progressHeight) ;
canvas.drawRoundRect( rectF, s_radius, s_radius, secondGradientPaint) ;
}
} else {
//no gradient
if ( secondProgressShape == 0 ) {
//point shape
int s_progressWidth = width - padding * 2 ;
float s_mDx = s_progressWidth * s_percent;
//progress line
float px = padding + s_progressHeight / 2 + s_mDx;
if ( px < width - padding - s_progressHeight / 2 ) {
if ( secondProgress == 0 ) {
if ( showZeroPoint) {
canvas.drawCircle( px, padding + s_progressHeight / 2 , s_progressHeight / 2 , secondProgressPaint) ;
}
} else {
canvas.drawCircle( px, padding + s_progressHeight / 2 , s_progressHeight / 2 , secondProgressPaint) ;
}
} else {
canvas.drawCircle( px - s_progressHeight, padding + s_progressHeight / 2 , s_progressHeight / 2 , secondProgressPaint) ;
}
} else {
//line shape
int s_progressWidth = width - padding * 2 - s_progressHeight;
float dx = s_progressWidth * s_percent;
secondProgressPaint.setColor( secondProgressColor) ;
//left circle
if ( secondProgress == 0 ) {
if ( showZeroPoint) {
canvas.drawCircle( padding + s_progressHeight / 2 , padding + s_progressHeight / 2 , s_progressHeight / 2 , secondProgressPaint) ;
}
} else {
canvas.drawCircle( padding + s_progressHeight / 2 , padding + s_progressHeight / 2 , s_progressHeight / 2 , secondProgressPaint) ;
}
//right circle
if ( secondProgress == 0 ) {
if ( showZeroPoint) {
canvas.drawCircle( padding + s_progressHeight / 2 + dx, padding + s_progressHeight / 2 , s_progressHeight / 2 , secondProgressPaint) ;
}
} else {
canvas.drawCircle( padding + s_progressHeight / 2 + dx, padding + s_progressHeight / 2 , s_progressHeight / 2 , secondProgressPaint) ;
}
//middle line
RectF midRecf = new RectF( padding + s_progressHeight / 2 , padding, padding + s_progressHeight / 2 + dx, padding + s_progressHeight) ;
canvas.drawRect( midRecf, secondProgressPaint) ;
}
}
}
}
public static Float convertToFloat( Double doubleValue) {
return doubleValue == null ? null : doubleValue.floatValue( ) ;
}
//
private void drawProgressRectMode( Canvas canvas) {
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
float percent = 0 ;
if ( max != 0 ) {
percent = convertToFloat( progress * 1 .0f / max) ;
}
int progressHeight = getHeight( ) - padding * 2 ;
if ( progressHeight % 2 != 0 ) {
progressHeight = progressHeight - 1 ;
}
if ( openGradient) {
int progressWidth = width - padding * 2 ;
float mDx = progressWidth * percent;
int colors[ ] = new int[ 2 ] ;
float positions[ ] = new float[ 2 ] ;
//from color
colors[ 0 ] = gradientFrom;
positions[ 0 ] = 0 ;
//to color
colors[ 1 ] = gradientTo;
positions[ 1 ] = 1 ;
LinearGradient shader = new LinearGradient(
padding + progressHeight / 2 , padding, padding + progressHeight / 2 + mDx, padding + progressHeight,
colors,
positions,
Shader.TileMode.MIRROR) ;
//gradient
gradientPaint.setShader( shader) ;
int radius = width > getHeight( ) ? getHeight( ) / 2 : width / 2 ;
//progress line
RectF rectF = new RectF( padding, padding, padding + mDx, padding + progressHeight) ;
canvas.drawRect( rectF, gradientPaint) ;
} else {
int progressWidth = width - padding * 2 ;
float dx = progressWidth * percent;
progressPaint.setColor( progressColor) ;
RectF midRecf = new RectF( padding, padding, padding + dx, padding + progressHeight) ;
canvas.drawRect( midRecf, progressPaint) ;
}
//draw second progress
if ( showSecondProgress) {
float s_percent = 0 ;
if ( max != 0 ) {
s_percent = secondProgress * 1 .0f / max;
}
int s_progressHeight = getHeight( ) - padding * 2 ;
if ( s_progressHeight % 2 != 0 ) {
s_progressHeight = s_progressHeight - 1 ;
}
if ( openSecondGradient) {
int s_progressWidth = width - padding * 2 ;
float s_mDx = s_progressWidth * s_percent;
int s_colors[ ] = new int[ 2 ] ;
float s_positions[ ] = new float[ 2 ] ;
//from color
s_colors[ 0 ] = secondGradientFrom;
s_positions[ 0 ] = 0 ;
//to color
s_colors[ 1 ] = secondGradientTo;
s_positions[ 1 ] = 1 ;
LinearGradient s_shader = new LinearGradient(
padding + s_progressHeight / 2 , padding, padding + s_progressHeight / 2 + s_mDx, padding + s_progressHeight,
s_colors,
s_positions,
Shader.TileMode.MIRROR) ;
//gradient
secondGradientPaint.setShader( s_shader) ;
//progress line
RectF rectF = new RectF( padding, padding, padding + s_mDx, padding + s_progressHeight) ;
canvas.drawRect( rectF, secondGradientPaint) ;
} else {
//no gradient
//line shape
int s_progressWidth = width - padding * 2 ;
float dx = s_progressWidth * s_percent;
secondProgressPaint.setColor( secondProgressColor) ;
RectF midRecf = new RectF( padding, padding, padding + dx, padding + s_progressHeight) ;
canvas.drawRect( midRecf, secondProgressPaint) ;
}
}
}
private void drawProgressRoundRectMode( Canvas canvas) {
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
float percent = 0 ;
if ( max != 0 ) {
percent = convertToFloat( progress * 1 .0f / max) ;
}
int progressHeight = getHeight( ) - padding * 2 ;
if ( progressHeight % 2 != 0 ) {
progressHeight = progressHeight - 1 ;
}
if ( openGradient) {
int progressWidth = width - padding * 2 - borderWidth;
float mDx = progressWidth * percent;
int colors[ ] = new int[ 2 ] ;
float positions[ ] = new float[ 2 ] ;
//from color
colors[ 0 ] = gradientFrom;
positions[ 0 ] = 0 ;
//to color
colors[ 1 ] = gradientTo;
positions[ 1 ] = 1 ;
LinearGradient shader = new LinearGradient(
padding + progressHeight / 2 , padding, padding + progressHeight / 2 + mDx, padding + progressHeight,
colors,
positions,
Shader.TileMode.MIRROR) ;
//gradient
gradientPaint.setShader( shader) ;
//progress line
RectF rectF = new RectF( padding + borderWidth / 2 , padding + borderWidth / 2 , padding + mDx + borderWidth / 2 , padding + progressHeight - borderWidth / 2 ) ;
canvas.drawRoundRect( rectF, radius, radius, gradientPaint) ;
} else {
int progressWidth = width - padding * 2 - borderWidth;
float dx = progressWidth * percent;
progressPaint.setColor( progressColor) ;
RectF rectF = new RectF( padding + borderWidth / 2 , padding + borderWidth / 2 , padding + dx + borderWidth / 2 , padding + progressHeight - borderWidth / 2 ) ;
canvas.drawRoundRect( rectF, radius, radius, progressPaint) ;
}
//draw second progress
if ( showSecondProgress) {
float s_percent = 0 ;
if ( max != 0 ) {
s_percent = secondProgress * 1 .0f / max;
}
int s_progressHeight = getHeight( ) - padding * 2 ;
if ( s_progressHeight % 2 != 0 ) {
s_progressHeight = s_progressHeight - 1 ;
}
if ( openSecondGradient) {
int s_progressWidth = width - padding * 2 ;
float s_mDx = s_progressWidth * s_percent;
int s_colors[ ] = new int[ 2 ] ;
float s_positions[ ] = new float[ 2 ] ;
//from color
s_colors[ 0 ] = secondGradientFrom;
s_positions[ 0 ] = 0 ;
//to color
s_colors[ 1 ] = secondGradientTo;
s_positions[ 1 ] = 1 ;
LinearGradient s_shader = new LinearGradient(
padding + s_progressHeight / 2 + borderWidth / 2 , padding + borderWidth / 2 , padding + s_progressHeight / 2 + s_mDx - borderWidth / 2 , padding + s_progressHeight - borderWidth / 2 ,
s_colors,
s_positions,
Shader.TileMode.MIRROR) ;
//gradient
secondGradientPaint.setShader( s_shader) ;
//progress line
RectF rectF = new RectF( padding + borderWidth / 2 , padding + borderWidth / 2 , padding + s_mDx - borderWidth / 2 , padding + s_progressHeight - borderWidth / 2 ) ;
canvas.drawRoundRect( rectF, radius, radius, secondGradientPaint) ;
} else {
//no gradient
//line shape
int s_progressWidth = width - padding * 2 ;
float dx = s_progressWidth * s_percent;
secondProgressPaint.setColor( secondProgressColor) ;
RectF midRecf = new RectF( padding + borderWidth / 2 , padding + borderWidth / 2 , padding + dx - borderWidth / 2 , padding + s_progressHeight - borderWidth / 2 ) ;
canvas.drawRoundRect( midRecf, radius, radius, secondProgressPaint) ;
}
}
}
private void drawBackground( Canvas canvas) {
int bgHeight = getHeight( ) ;
if ( bgHeight % 2 != 0 ) {
bgHeight = bgHeight - 1 ;
}
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
//left circle
canvas.drawCircle( bgHeight / 2 , bgHeight / 2 , bgHeight / 2 , bgPaint) ;
//right circle
canvas.drawCircle( width - bgHeight / 2 , bgHeight / 2 , bgHeight / 2 , bgPaint) ;
//middle line
RectF midRecf = new RectF( bgHeight / 2 , 0 , width - bgHeight / 2 , bgHeight) ;
canvas.drawRect( midRecf, bgPaint) ;
}
private void drawBorder( Canvas canvas) {
if ( drawBorder) {
int bgHeight = getHeight( ) ;
if ( bgHeight % 2 != 0 ) {
bgHeight = bgHeight - 1 ;
}
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
RectF rect = new RectF( 0 , 0 , width, bgHeight) ;
canvas.drawRoundRect( rect, bgHeight / 2 , bgHeight / 2 , borderPaint) ;
}
}
private void drawBorderRect( Canvas canvas) {
if ( drawBorder) {
int bgHeight = getHeight( ) ;
if ( bgHeight % 2 != 0 ) {
bgHeight = bgHeight - 1 ;
}
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
RectF rect = new RectF( 0 , 0 , width, bgHeight) ;
canvas.drawRect( rect, borderPaint) ;
}
}
private void drawBorderRoundRect( Canvas canvas) {
if ( drawBorder) {
int bgHeight = getHeight( ) ;
if ( bgHeight % 2 != 0 ) {
bgHeight = bgHeight - 1 ;
}
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
RectF rect = new RectF( borderWidth / 2 , borderWidth / 2 , width - borderWidth / 2 , bgHeight - borderWidth / 2 ) ;
canvas.drawRoundRect( rect, radius, radius, borderPaint) ;
}
}
private void drawBackgroundRectMode( Canvas canvas) {
int bgHeight = getHeight( ) ;
if ( bgHeight % 2 != 0 ) {
bgHeight = bgHeight - 1 ;
}
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
RectF midRecf = new RectF( 0 , 0 , width, bgHeight) ;
canvas.drawRect( midRecf, bgPaint) ;
}
private void drawBackgroundRoundRectMode( Canvas canvas) {
int bgHeight = getHeight( ) ;
if ( bgHeight % 2 != 0 ) {
bgHeight = bgHeight - 1 ;
}
int width = getWidth( ) ;
if ( width % 2 != 0 ) {
//Fix Me
width = width - 1 ;
}
RectF midRecf = new RectF( borderWidth / 2 , borderWidth / 2 , width - borderWidth / 2 , bgHeight - borderWidth / 2 ) ;
canvas.drawRoundRect( midRecf, radius, radius, bgPaint) ;
}
@Override
protected void onMeasure( int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure( widthMeasureSpec, heightMeasureSpec) ;
getWidthAndHeight( ) ;
}
@Override
protected void onLayout( boolean changed, int left, int top, int right, int bottom) {
super.onLayout( changed, left, top, right, bottom) ;
}
public int getMax ( ) {
return max;
}
public void setMax( int max) {
this.max = max;
invalidate( ) ;
}
public double getProgress ( ) {
return progress;
}
public void setProgress( double progress) {
if ( progress < 0 ) {
this.progress = 0 ;
} else if ( progress > max) {
this.progress = max;
} else {
this.progress = progress;
}
invalidate( ) ;
if ( onProgressChangedListener != null) {
onProgressChangedListener.onProgressChanged( this, max, this.progress) ;
}
}
public boolean isShowSecondProgress ( ) {
return showSecondProgress;
}
public void setShowSecondProgress( boolean showSecondProgress) {
this.showSecondProgress = showSecondProgress;
invalidate( ) ;
}
public int getSecondProgress ( ) {
return secondProgress;
}
public void setSecondProgress( int secondProgress) {
if ( secondProgress < 0 ) {
this.secondProgress = 0 ;
} else if ( secondProgress > max) {
this.secondProgress = max;
} else {
this.secondProgress = secondProgress;
}
invalidate( ) ;
if ( onProgressChangedListener != null) {
onProgressChangedListener.onSecondProgressChanged( this, max, this.secondProgress) ;
}
}
public int getSecondProgressShape ( ) {
return secondProgressShape;
}
public void setSecondProgressShape( int secondProgressShape) {
this.secondProgressShape = secondProgressShape;
invalidate( ) ;
}
public int getBgColor ( ) {
return bgColor;
}
public void setBgColor( int bgColor) {
this.bgColor = bgColor;
bgPaint.setColor( bgColor) ;
invalidate( ) ;
}
public boolean isOpenSecondGradient ( ) {
return openSecondGradient;
}
public void setOpenSecondGradient( boolean openSecondGradient) {
this.openSecondGradient = openSecondGradient;
invalidate( ) ;
}
public int getSecondGradientFrom ( ) {
return secondGradientFrom;
}
public void setSecondGradientFrom( int secondGradientFrom) {
this.secondGradientFrom = secondGradientFrom;
invalidate( ) ;
}
public int getSecondGradientTo ( ) {
return secondGradientTo;
}
public void setSecondGradientTo( int secondGradientTo) {
this.secondGradientTo = secondGradientTo;
invalidate( ) ;
}
public int getSecondProgressColor ( ) {
return secondProgressColor;
}
public void setSecondProgressColor( int secondProgressColor) {
this.secondProgressColor = secondProgressColor;
secondProgressPaint.setColor( secondProgressColor) ;
invalidate( ) ;
}
public int getProgressColor ( ) {
return progressColor;
}
public void setProgressColor( int progressColor) {
this.progressColor = progressColor;
progressPaint.setColor( progressColor) ;
invalidate( ) ;
}
public int getPadding ( ) {
return padding;
}
public void setPadding( int padding) {
this.padding = padding;
invalidate( ) ;
}
public void setShowMode( ShowMode showMode) {
switch ( showMode) {
case ROUND:
this.showMode = 0 ;
break ;
case RECT:
this.showMode = 1 ;
break ;
case ROUND_RECT:
this.showMode = 2 ;
break ;
}
invalidate( ) ;
}
/**
* get the percentage value of progress and max.
*
* @return percentage value
*/
public int getPercentage ( ) {
if ( max == 0 ) {
return 0 ;
}
return ( int) ( progress * 100.0 / max) ;
}
public boolean isOpenGradient ( ) {
return openGradient;
}
public void setOpenGradient( boolean openGradient) {
this.openGradient = openGradient;
invalidate( ) ;
}
public int getGradientFrom ( ) {
return gradientFrom;
}
public void setGradientFrom( int gradientFrom) {
this.gradientFrom = gradientFrom;
invalidate( ) ;
}
public int getGradientTo ( ) {
return gradientTo;
}
public void setGradientTo( int gradientTo) {
this.gradientTo = gradientTo;
invalidate( ) ;
}
public void setBorderColor( int borderColor) {
this.borderColor = borderColor;
this.borderPaint.setColor( this.borderColor) ;
invalidate( ) ;
}
public void setGradientColor( int from, int to) {
this.gradientFrom = from;
this.gradientTo = to;
invalidate( ) ;
}
public void setSecondGradientColor( int from, int to) {
this.secondGradientFrom = from;
this.secondGradientTo = to;
invalidate( ) ;
}
public void setGradientColorAndBorderColor( int from, int to, int borderColor) {
this.gradientFrom = from;
this.gradientTo = to;
this.borderColor = borderColor;
this.borderPaint.setColor( this.borderColor) ;
invalidate( ) ;
}
public int getBorderColor ( ) {
return borderColor;
}
public void setOnProgressChangedListener( OnProgressChangedListener onProgressChangedListener) {
this.onProgressChangedListener = onProgressChangedListener;
}
}
二、把下面代码拷贝到styles文件中
< declare-styleable name = "ZzHorizontalProgressBar" >
< attr name = "zpb_padding" format = "dimension" />
< attr name = "zpb_bg_color" format = "color|reference" />
< attr name = "zpb_pb_color" format = "color|reference" />
< attr name = "zpb_second_pb_color" format = "color|reference" />
< attr name = "zpb_max" format = "integer" />
< attr name = "zpb_text" format = "color|reference" />
< attr name = "zpb_progress" format = "integer" />
< attr name = "zpb_show_zero_point" format = "boolean" />
< attr name = "zpb_show_second_progress" format = "boolean" />
< attr name = "zpb_second_progress" format = "integer" />
< attr name = "zpb_show_second_point_shape" format = "enum" >
< enum name = "point" value = "0" />
< enum name = "line" value = "1" />
< /attr>
< attr name = "zpb_open_gradient" format = "boolean" />
< attr name = "zpb_gradient_from" format = "color|reference" />
< attr name = "zpb_gradient_to" format = "color|reference" />
< attr name = "zpb_open_second_gradient" format = "boolean" />
< attr name = "zpb_second_gradient_from" format = "color|reference" />
< attr name = "zpb_second_gradient_to" format = "color|reference" />
< attr name = "zpb_show_mode" format = "enum" >
< enum name = "round" value = "0" />
< enum name = "rect" value = "1" />
< enum name = "round_rect" value = "2" />
< /attr>
< attr name = "zpb_round_rect_radius" format = "dimension|reference" />
< attr name = "zpb_draw_border" format = "boolean" />
< attr name = "zpb_border_width" format = "dimension|reference" />
< attr name = "zpb_border_color" format = "color|reference" />
< /declare-styleable>
三、效果图如下: