package com.hdl.widget; import android.annotation.SuppressLint; import android.content.Context; import android.content.res.TypedArray; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.Path; import android.graphics.PathMeasure; import android.graphics.Point; import android.graphics.RectF; import android.graphics.Region; import android.graphics.SweepGradient; import android.os.Bundle; import android.os.Parcelable; import android.util.AttributeSet; import android.util.Log; import android.util.TypedValue; import android.view.GestureDetector; import android.view.MotionEvent; import android.view.View; import com.hdl.widgetxm.R; import static android.view.MotionEvent.ACTION_CANCEL; import static android.view.MotionEvent.ACTION_DOWN; import static android.view.MotionEvent.ACTION_MOVE; import static android.view.MotionEvent.ACTION_UP; public class HDLArcSeekBar extends View { private static final int DEFAULT_EDGE_LENGTH = 260; // 默认宽高 private static final float CIRCLE_ANGLE = 360; // 圆周角 private static final int DEFAULT_ARC_WIDTH = 15; // 默认宽度 dp private static final float DEFAULT_OPEN_ANGLE = 30; // 开口角度 private static final float DEFAULT_ROTATE_ANGLE = 90; // 旋转角度 private static final int DEFAULT_BORDER_WIDTH = 0; // 默认描边宽度 private static final int DEFAULT_BORDER_COLOR = 0xffffffff; // 默认描边颜色 private static final int DEFAULT_THUMB_COLOR = 0xffffffff; // 拖动按钮颜色 private static final int DEFAULT_THUMB_WIDTH = 5; // 拖动按钮描边宽度 dp private static final int DEFAULT_THUMB_RADIUS = 7; // 拖动按钮半径 dp private static final int DEFAULT_THUMB_SHADOW_RADIUS = 0; // 拖动按钮阴影半径 dp private static final int DEFAULT_THUMB_SHADOW_COLOR = 0xFF000000; // 拖动按钮阴影颜色 private static final int DEFAULT_SHADOW_RADIUS = 0; // 默认阴影半径 dp public static final int THUMB_MODE_STROKE = 0; // 拖动按钮模式 - 描边 public static final int THUMB_MODE_FILL = 1; // 拖动按钮模式 - 填充 public static final int THUMB_MODE_FILL_STROKE = 2; // 拖动按钮模式 - 填充+描边 private static final int DEFAULT_MAX_VALUE = 100; // 默认最大数值 private static final int DEFAULT_MIN_VALUE = 0; // 默认最小数值 private static final String KEY_PROGRESS_PRESENT = "PRESENT"; // 用于存储和获取当前百分比 // 可配置数据 private int[] mArcColors; // Seek 颜色 private float mArcWidth; // Seek 宽度 private float mOpenAngle; // 开口的角度大小 0 - 360 private float mRotateAngle; // 旋转角度 private int mBorderWidth; // 描边宽度 private int mBorderColor; // 描边颜色 private int mThumbColor; // 拖动按钮颜色 private float mThumbWidth; // 拖动按钮宽度 private float mThumbRadius; // 拖动按钮半径 private float mThumbShadowRadius;// 拖动按钮阴影半径 private int mThumbShadowColor;// 拖动按钮阴影颜色 private int mThumbMode; // 拖动按钮模式 private int mShadowRadius; // 阴影半径 private int mMaxValue; // 最大数值 private int mMinValue; // 最小数值 private float mCenterX; // 圆弧 SeekBar 中心点 X private float mCenterY; // 圆弧 SeekBar 中心点 Y private float mThumbX; // 拖动按钮 中心点 X private float mThumbY; // 拖动按钮 中心点 Y private Path mSeekPath; private Path mBorderPath; private Paint mArcPaint; private Paint mThumbPaint; private Paint mBorderPaint; private Paint mShadowPaint; private float[] mTempPos; private float[] mTempTan; private PathMeasure mSeekPathMeasure; private float mProgressPresent = 0; // 当前进度百分比 private boolean mCanDrag = false; // 是否允许拖动 private boolean mAllowTouchSkip = false; // 是否允许越过边界 // private GestureDetector mDetector; private Matrix mInvertMatrix; // 逆向 Matrix, 用于计算触摸坐标和绘制坐标的转换 private Region mArcRegion; // ArcPath的实际区域大小,用于判定单击事件 //***********************新增*********************************** private static final int DEFAULT_THUMB_DISTANCE_MULTIPLE = 5; //点击的坐标离与mThumb圆心坐标距离，小于5*半径，则可以拖动 private static final int DEFAULT_ARC_PROGRESS_BAR_COLOR = 0xFFFFFFFF; // 进度条颜色 private static final String DEFAULT_ARC_PROGRESS_BAR_UNIT_STRING = "%"; // 默认显示单位 // private static final int DEFAULT_DISTANCE_BETWEEN_TEXTPOINT_AND_ARC = 70; private static final int DEFAULT_PADDING = 80; //圆弧自带PADDING值，为了显示进度test文字 private Point mTextPoint; //旋转90度后的坐标 private Paint mTextPaint; //进度文字显示内容 private RectF content; //显示内容区域 private float mSweepAngle = 0; //与开始角度的夹角 private int mArcProgressBarColor; //当前进度圆弧颜色 private Paint mArcProgressBarPaint; //当前进度圆弧画笔 private String mProgressBarUnitSring; //进度单位符号 private double mArcProgressBarRadius; //圆弧的半径 private boolean isClickable = true; private int mTextDefaultDistance = 70; // 进度显示文字坐标与进度圆弧的距离 DEFAULT_DISTANCE_BETWEEN_TEXTPOINT_AND_ARC private int[] mArcProgressBarColors; // 当前进度圆弧渐变颜色数组 // private int mTextColor; // 拖动按钮颜色 //***********************新增*********************************** public HDLArcSeekBar(Context context) { this(context, null); } public HDLArcSeekBar(Context context, AttributeSet attrs) { this(context, attrs, 0); } public HDLArcSeekBar(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); setSaveEnabled(true); setLayerType(LAYER_TYPE_SOFTWARE, null); initAttrs(context, attrs); initData(); initPaint(); } //--- 初始化 ----------------------------------------------------------------------------------- // 初始化各种属性 private void initAttrs(Context context, AttributeSet attrs) { TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.HDLArcSeekBar); mArcColors = getArcColors(context, ta); mArcWidth = ta.getDimensionPixelSize(R.styleable.HDLArcSeekBar_arc_width, dp2px(DEFAULT_ARC_WIDTH)); mOpenAngle = ta.getFloat(R.styleable.HDLArcSeekBar_arc_open_angle, DEFAULT_OPEN_ANGLE); mRotateAngle = ta.getFloat(R.styleable.HDLArcSeekBar_arc_rotate_angle, DEFAULT_ROTATE_ANGLE); mMaxValue = ta.getInt(R.styleable.HDLArcSeekBar_arc_max, DEFAULT_MAX_VALUE); mMinValue = ta.getInt(R.styleable.HDLArcSeekBar_arc_min, DEFAULT_MIN_VALUE); // 如果用户设置的最大值和最小值不合理，则直接按照默认进行处理 if (mMaxValue <= mMinValue) { mMaxValue = DEFAULT_MAX_VALUE; mMinValue = DEFAULT_MIN_VALUE; } int progress = ta.getInt(R.styleable.HDLArcSeekBar_arc_progress, mMinValue); setProgress(progress); mBorderWidth = ta.getDimensionPixelSize(R.styleable.HDLArcSeekBar_arc_border_width, dp2px(DEFAULT_BORDER_WIDTH)); mBorderColor = ta.getColor(R.styleable.HDLArcSeekBar_arc_border_color, DEFAULT_BORDER_COLOR); mThumbColor = ta.getColor(R.styleable.HDLArcSeekBar_arc_thumb_color, DEFAULT_THUMB_COLOR); mThumbRadius = ta.getDimensionPixelSize(R.styleable.HDLArcSeekBar_arc_thumb_radius, dp2px(DEFAULT_THUMB_RADIUS)); mThumbShadowRadius = ta.getDimensionPixelSize(R.styleable.HDLArcSeekBar_arc_thumb_shadow_radius, dp2px(DEFAULT_THUMB_SHADOW_RADIUS)); mThumbShadowColor = ta.getColor(R.styleable.HDLArcSeekBar_arc_thumb_shadow_color, DEFAULT_THUMB_SHADOW_COLOR); mThumbWidth = ta.getDimensionPixelSize(R.styleable.HDLArcSeekBar_arc_thumb_width, dp2px(DEFAULT_THUMB_WIDTH)); mThumbMode = ta.getInt(R.styleable.HDLArcSeekBar_hdl_arc_thumb_mode, THUMB_MODE_STROKE); mShadowRadius = ta.getDimensionPixelSize(R.styleable.HDLArcSeekBar_arc_shadow_radius, dp2px(DEFAULT_SHADOW_RADIUS)); mArcProgressBarColor = ta.getColor(R.styleable.HDLArcSeekBar_arc_progress_bar_color, DEFAULT_ARC_PROGRESS_BAR_COLOR); mArcProgressBarColors = new int[]{mArcProgressBarColor,mArcProgressBarColor}; ta.recycle(); } // 获取 Arc 颜色数组 private int[] getArcColors(Context context, TypedArray ta) { int[] ret; int resId = ta.getResourceId(R.styleable.HDLArcSeekBar_arc_colors, 0); if (0 == resId) { resId = R.array.arc_colors_default; } ret = getColorsByArrayResId(context, resId); return ret; } // 根据 resId 获取颜色数组 private int[] getColorsByArrayResId(Context context, int resId) { int[] ret; TypedArray colorArray = context.getResources().obtainTypedArray(resId); ret = new int[colorArray.length()]; for (int i = 0; i < colorArray.length(); i++) { ret[i] = colorArray.getColor(i, 0); } return ret; } // 初始化数据 private void initData() { mSeekPath = new Path(); mBorderPath = new Path(); mSeekPathMeasure = new PathMeasure(); mTempPos = new float[2]; mTempTan = new float[2]; // mDetector = new GestureDetector(getContext(), new OnClickListener()); mInvertMatrix = new Matrix(); mArcRegion = new Region(); mProgressBarUnitSring = DEFAULT_ARC_PROGRESS_BAR_UNIT_STRING; } // 初始化画笔 private void initPaint() { initArcPaint(); initThumbPaint(); initTextPanit(); initProgressBarPaint(); initBorderPaint(); initShadowPaint(); } // 初始化圆弧画笔 private void initArcPaint() { mArcPaint = new Paint(); mArcPaint.setAntiAlias(true); mArcPaint.setStrokeWidth(mArcWidth); mArcPaint.setStyle(Paint.Style.STROKE); mArcPaint.setStrokeCap(Paint.Cap.ROUND); } // 初始化拖动按钮画笔 private void initThumbPaint() { mThumbPaint = new Paint(); mThumbPaint.setAntiAlias(true); mThumbPaint.setColor(mThumbColor); mThumbPaint.setStrokeWidth(mThumbWidth); mThumbPaint.setStrokeCap(Paint.Cap.ROUND); if (mThumbMode == THUMB_MODE_FILL) { mThumbPaint.setStyle(Paint.Style.FILL_AND_STROKE); } else if (mThumbMode == THUMB_MODE_FILL_STROKE) { mThumbPaint.setStyle(Paint.Style.FILL_AND_STROKE); } else { mThumbPaint.setStyle(Paint.Style.STROKE); } mThumbPaint.setTextSize(56); } private float getTextSizeDip(float value) { return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, value, getResources().getDisplayMetrics()); } // 初始化进度圆弧画笔 private void initProgressBarPaint() { mArcProgressBarPaint = new Paint(); //初始化进度圆弧画笔 mArcProgressBarPaint.setAntiAlias(true); mArcProgressBarPaint.setStyle(Paint.Style.STROKE); mArcProgressBarPaint.setStrokeCap(Paint.Cap.ROUND); mArcProgressBarPaint.setStrokeWidth(mArcWidth - 1); // mArcProgressBarPaint.setColor(mArcProgressBarColor); } // 初始化拖动按钮顶部文字画笔和进度圆弧画笔 private void initTextPanit() { mTextPaint = new Paint(); mTextPaint.setAntiAlias(true); mTextPaint.setStrokeWidth(1); mTextPaint.setTextSize(getTextSizeDip(12)); mTextPaint.setColor(mThumbColor); mTextPaint.setTextAlign(Paint.Align.CENTER); } // 初始化拖动按钮画笔 private void initBorderPaint() { mBorderPaint = new Paint(); mBorderPaint.setAntiAlias(true); mBorderPaint.setColor(mBorderColor); mBorderPaint.setStrokeWidth(mBorderWidth); mBorderPaint.setStyle(Paint.Style.STROKE); } // 初始化阴影画笔 private void initShadowPaint() { mShadowPaint = new Paint(); mShadowPaint.setAntiAlias(true); mShadowPaint.setStrokeWidth(mBorderWidth); mShadowPaint.setStyle(Paint.Style.FILL_AND_STROKE); } //--- 初始化结束 ------------------------------------------------------------------------------- //--- 状态存储 --------------------------------------------------------------------------------- @Override protected Parcelable onSaveInstanceState() { Bundle bundle = new Bundle(); bundle.putParcelable("superState", super.onSaveInstanceState()); bundle.putFloat(KEY_PROGRESS_PRESENT, mProgressPresent); return bundle; } @Override protected void onRestoreInstanceState(Parcelable state) { if (state instanceof Bundle) { Bundle bundle = (Bundle) state; this.mProgressPresent = bundle.getFloat(KEY_PROGRESS_PRESENT); state = bundle.getParcelable("superState"); } if (null != mOnProgressChangeListener) { mOnProgressChangeListener.onProgressChanged(this, getProgress(), false); } super.onRestoreInstanceState(state); } //--- 状态存储结束 ----------------------------------------------------------------------------- @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { int ws = MeasureSpec.getSize(widthMeasureSpec); //取出宽度的确切数值 int wm = MeasureSpec.getMode(widthMeasureSpec); //取出宽度的测量模式 int hs = MeasureSpec.getSize(heightMeasureSpec); //取出高度的确切数值 int hm = MeasureSpec.getMode(heightMeasureSpec); //取出高度的测量模 if (wm == MeasureSpec.UNSPECIFIED) { wm = MeasureSpec.EXACTLY; ws = dp2px(DEFAULT_EDGE_LENGTH); } else if (wm == MeasureSpec.AT_MOST) { wm = MeasureSpec.EXACTLY; ws = Math.min(dp2px(DEFAULT_EDGE_LENGTH), ws); } if (hm == MeasureSpec.UNSPECIFIED) { hm = MeasureSpec.EXACTLY; hs = dp2px(DEFAULT_EDGE_LENGTH); } else if (hm == MeasureSpec.AT_MOST) { hm = MeasureSpec.EXACTLY; hs = Math.min(dp2px(DEFAULT_EDGE_LENGTH), hs); } setMeasuredDimension(MeasureSpec.makeMeasureSpec(ws, wm), MeasureSpec.makeMeasureSpec(hs, hm)); } @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh); // 计算在当前大小下,内容应该显示的大小和起始位置 int safeW = w - getPaddingLeft() - getPaddingRight(); int safeH = h - getPaddingTop() - getPaddingBottom(); float edgeLength, startX, startY; float fix = mArcWidth / 2 + mBorderWidth + mShadowRadius * 2; // 修正距离,画笔宽度的修正 if (safeW < safeH) { // 宽度小于高度,以宽度为准 edgeLength = safeW - fix; startX = getPaddingLeft(); startY = (safeH - safeW) / 2.0f + getPaddingTop(); } else { // 宽度大于高度,以高度为准 edgeLength = safeH - fix; startX = (safeW - safeH) / 2.0f + getPaddingLeft(); startY = getPaddingTop(); } // 得到显示区域和中心的 content = new RectF(startX + fix + DEFAULT_PADDING, startY + fix + DEFAULT_PADDING, startX + edgeLength - DEFAULT_PADDING, startY + edgeLength - DEFAULT_PADDING); mCenterX = content.centerX(); mCenterY = content.centerY(); // 得到路径 mSeekPath.reset(); mSeekPath.addArc(content, mOpenAngle / 2, CIRCLE_ANGLE - mOpenAngle); mSeekPathMeasure.setPath(mSeekPath, false); computeThumbPos(mProgressPresent); mArcProgressBarRadius = getDistanceWithCenter(mThumbX, mThumbY);//计算出圆弧的半径 resetShaderColor(); mInvertMatrix.reset(); mInvertMatrix.preRotate(-mRotateAngle, mCenterX, mCenterY); mArcPaint.getFillPath(mSeekPath, mBorderPath); mBorderPath.close(); mArcRegion.setPath(mBorderPath, new Region(0, 0, w, h)); } /** * 重置 mArcProgressBarColors 颜色 * 2019-8-14 */ private void resetmArcProgressBarColor() { // // 计算渐变数组 // float startPos = (mOpenAngle / 2) / CIRCLE_ANGLE; // float stopPos = (CIRCLE_ANGLE - (mOpenAngle / 2)) / CIRCLE_ANGLE; // int len = mArcProgressBarColors.length - 1; // float distance = (stopPos - startPos) / len; // float pos[] = new float[mArcProgressBarColors.length]; // for (int i = 0; i < mArcProgressBarColors.length; i++) { // pos[i] = startPos + (distance * i); // } // SweepGradient gradient = new SweepGradient(mCenterX, mCenterY, mArcProgressBarColors, pos); SweepGradient gradient = new SweepGradient(mCenterX, mCenterY, mArcProgressBarColors, null); mArcProgressBarPaint.setShader(gradient); } // 重置 shader 颜色 private void resetShaderColor() { // 计算渐变数组 float startPos = (mOpenAngle / 2) / CIRCLE_ANGLE; float stopPos = (CIRCLE_ANGLE - (mOpenAngle / 2)) / CIRCLE_ANGLE; int len = mArcColors.length - 1; float distance = (stopPos - startPos) / len; float pos[] = new float[mArcColors.length]; for (int i = 0; i < mArcColors.length; i++) { pos[i] = startPos + (distance * i); } SweepGradient gradient = new SweepGradient(mCenterX, mCenterY, mArcColors, pos); mArcPaint.setShader(gradient); } // 具体绘制 @Override protected void onDraw(Canvas canvas) { canvas.save(); canvas.drawText(String.valueOf(getProgress()) + mProgressBarUnitSring, mTextPoint.x, mTextPoint.y, mTextPaint); canvas.rotate(mRotateAngle, mCenterX, mCenterY); // mShadowPaint.setShadowLayer(mShadowRadius * 2, 0, 0, getColor()); canvas.drawPath(mBorderPath, mShadowPaint); canvas.drawPath(mSeekPath, mArcPaint); //当前进度 resetmArcProgressBarColor();//渐变颜色 canvas.drawArc(content, mOpenAngle / 2, mSweepAngle, false, mArcProgressBarPaint); if (mBorderWidth > 0) { canvas.drawPath(mBorderPath, mBorderPaint); } if (mThumbShadowRadius > 0) { mThumbPaint.setShadowLayer(mThumbShadowRadius, 0, 0, mThumbShadowColor); canvas.drawCircle(mThumbX, mThumbY, mThumbRadius, mThumbPaint); mThumbPaint.clearShadowLayer(); } canvas.drawCircle(mThumbX, mThumbY, mThumbRadius, mThumbPaint); canvas.restore(); } private boolean moved = false; private int lastProgress = -1; @SuppressLint("ClickableViewAccessibility") @Override public boolean onTouchEvent(MotionEvent event) { super.onTouchEvent(event); if(!isClickable) return false; int action = event.getActionMasked(); switch (action) { case ACTION_DOWN: moved = false; judgeCanDrag(event); if (null != mOnProgressChangeListener) { mOnProgressChangeListener.onStartTrackingTouch(this); } break; case ACTION_MOVE: if (!mCanDrag) { break; } float tempProgressPresent = getCurrentProgress(event.getX(), event.getY()); if (!mAllowTouchSkip) { // 不允许突变 if (Math.abs(tempProgressPresent - mProgressPresent) > 0.5f) { break; } } // 允许突变 或者非突变 mProgressPresent = tempProgressPresent; computeThumbPos(mProgressPresent); // 事件回调 if (null != mOnProgressChangeListener && getProgress() != lastProgress) { mOnProgressChangeListener.onProgressChanged(this, getProgress(), true); lastProgress = getProgress(); } moved = true; break; case ACTION_UP: case ACTION_CANCEL: if(!moved){ if (isInArcProgress(event.getX(), event.getY())) { // 点击允许突变 mProgressPresent = getCurrentProgress(event.getX(), event.getY()); computeThumbPos(mProgressPresent); } } if (null != mOnProgressChangeListener) { mOnProgressChangeListener.onStopTrackingTouch(this); } break; } // mDetector.onTouchEvent(event); invalidate(); return true; } // 判断是否允许拖动 private void judgeCanDrag(MotionEvent event) { float[] pos = {event.getX(), event.getY()}; mInvertMatrix.mapPoints(pos); if (getDistance(pos[0], pos[1]) <= mThumbRadius * DEFAULT_THUMB_DISTANCE_MULTIPLE) { mCanDrag = true; } else { mCanDrag = false; } } private class OnClickListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onSingleTapUp(MotionEvent e) { // 判断是否点击在了进度区域 if (!isInArcProgress(e.getX(), e.getY())) { return false; } // 点击允许突变 mProgressPresent = getCurrentProgress(e.getX(), e.getY()); computeThumbPos(mProgressPresent); Log.i("onSingleTapUp","onSingleTapUp"); // // 事件回调 // if (null != mOnProgressChangeListener) { // mOnProgressChangeListener.onProgressChanged(HDLArcSeekBar.this, getProgress(), true); //// mOnProgressChangeListener.onStopTrackingTouch(HDLArcSeekBar.this); // } return true; } } // // 判断该点是否在进度条上面 // private boolean isInArcProgress(float px, float py) { // float[] pos = {px, py}; // mInvertMatrix.mapPoints(pos); // return mArcRegion.contains((int) pos[0], (int) pos[1]); // } /** * 判断该点是否在进度条附近 2019-07-17 * 对比判断该点是否在进度条上面，增大可点击区域 * * @param px 当前坐标x * @param py 当前坐标y * @return */ private boolean isInArcProgress(float px, float py) { float[] pos = {px, py}; mInvertMatrix.mapPoints(pos); double mDistance = getDistanceWithCenter(pos[0], pos[1]); // Log.i("kkk" ,"KmArcProgressBarRadiusmDistance"+mDistance); if ((mDistance >= (mArcProgressBarRadius * 2 / 3)) && (mDistance <= (mArcProgressBarRadius * 4 / 3))) { return true; } else { return false; } } // 获取当前进度理论进度数值 private float getCurrentProgress(float px, float py) { float diffAngle = getDiffAngle(px, py); float progress = diffAngle / (CIRCLE_ANGLE - mOpenAngle); if (progress < 0) progress = 0; if (progress > 1) progress = 1; return progress; } // 获得当前点击位置所成角度与开始角度之间的数值差 private float getDiffAngle(float px, float py) { float angle = getAngle(px, py); float diffAngle; diffAngle = angle - mRotateAngle; if (diffAngle < 0) { diffAngle = (diffAngle + CIRCLE_ANGLE) % CIRCLE_ANGLE; } diffAngle = diffAngle - mOpenAngle / 2; return diffAngle; } // 计算指定位置与内容区域中心点的夹角 private float getAngle(float px, float py) { float angle = (float) ((Math.atan2(py - mCenterY, px - mCenterX)) * 180 / 3.14f); if (angle < 0) { angle += 360; } return angle; } // 计算指定位置与上次位置的距离 private float getDistance(float px, float py) { return (float) Math.sqrt((px - mThumbX) * (px - mThumbX) + (py - mThumbY) * (py - mThumbY)); } // 计算坐标圆点的距离 private double getDistanceWithCenter(float px, float py) { return Math.sqrt((px - mCenterX) * (px - mCenterX) + (py - mCenterY) * (py - mCenterY)); } private int dp2px(int dp) { return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, getContext().getResources().getDisplayMetrics()); } /** * 获取相同距离下，圆弧对应的第三点坐标 * * @param mPoint 圆弧坐标 * 第三点距离第二点的距离 * DEFAULT_DISTANCE_BETWEEN_TEXTPOINT_AND_ARC 距离 */ private Point calcOutsidePoint(Point mPoint) { double newX = (mPoint.x * (mArcProgressBarRadius + mTextDefaultDistance) - mCenterX * mTextDefaultDistance) / mArcProgressBarRadius; double newY = (mPoint.y * (mArcProgressBarRadius + mTextDefaultDistance) - mCenterY * mTextDefaultDistance) / mArcProgressBarRadius; return new Point((int) newX, (int) newY); } // 计算拖动块应该显示的位置 private void computeThumbPos(float present) { if (present < 0) present = 0; if (present > 1) present = 1; if (null == mSeekPathMeasure) return; float distance = mSeekPathMeasure.getLength() * present; mSeekPathMeasure.getPosTan(distance, mTempPos, mTempTan); mThumbX = mTempPos[0]; mThumbY = mTempPos[1]; Point mmTextPoint = calcNewPoint(new Point((int) mThumbX, (int) mThumbY), new Point((int) mCenterX, (int) mCenterY), mRotateAngle); mSweepAngle = getDiffAngle(mmTextPoint.x, mmTextPoint.y); if (mSweepAngle < 0) mSweepAngle = 0; // Log.i("mSweepAngle", "mSweepAngle：" + mSweepAngle); mTextPoint = calcOutsidePoint(mmTextPoint); } //--- 线性取色 --------------------------------------------------------------------------------- /** * 获取当前进度的具体颜色 * * @return 当前进度在渐变中的颜色 */ public int getColor() { return getColor(mProgressPresent); } /** * 获取某个百分比位置的颜色 * * @param radio 取值[0,1] * @return 最终颜色 */ private int getColor(float radio) { float diatance = 1.0f / (mArcColors.length - 1); int startColor; int endColor; if (radio >= 1) { return mArcColors[mArcColors.length - 1]; } for (int i = 0; i < mArcColors.length; i++) { if (radio <= i * diatance) { if (i == 0) { return mArcColors[0]; } startColor = mArcColors[i - 1]; endColor = mArcColors[i]; float areaRadio = getAreaRadio(radio, diatance * (i - 1), diatance * i); return getColorFrom(startColor, endColor, areaRadio); } } return -1; } /** * 计算当前比例在子区间的比例 * * @param radio 总比例 * @param startPosition 子区间开始位置 * @param endPosition 子区间结束位置 * @return 自区间比例[0, 1] */ private float getAreaRadio(float radio, float startPosition, float endPosition) { return (radio - startPosition) / (endPosition - startPosition); } /** * 取两个颜色间的渐变区间 中的某一点的颜色 * * @param startColor 开始的颜色 * @param endColor 结束的颜色 * @param radio 比例 [0, 1] * @return 选中点的颜色 */ private int getColorFrom(int startColor, int endColor, float radio) { int redStart = Color.red(startColor); int blueStart = Color.blue(startColor); int greenStart = Color.green(startColor); int redEnd = Color.red(endColor); int blueEnd = Color.blue(endColor); int greenEnd = Color.green(endColor); int red = (int) (redStart + ((redEnd - redStart) * radio + 0.5)); int greed = (int) (greenStart + ((greenEnd - greenStart) * radio + 0.5)); int blue = (int) (blueStart + ((blueEnd - blueStart) * radio + 0.5)); return Color.argb(255, red, greed, blue); } /** * 计算某点绕中心点旋转一个角度后的坐标 * * @param pCenter 中心坐标 */ private static Point calcNewPoint(Point p, Point pCenter, float angle) { // calc arc float l = (float) ((angle * Math.PI) / 180); //sin/cos value float cosv = (float) Math.cos(l); float sinv = (float) Math.sin(l); // calc new point float newX = (float) ((p.x - pCenter.x) * cosv - (p.y - pCenter.y) * sinv + pCenter.x); float newY = (float) ((p.x - pCenter.x) * sinv + (p.y - pCenter.y) * cosv + pCenter.y); return new Point((int) newX, (int) newY); } // /** // * 求第三点坐标 // * // * @param pCenter 中心坐标 // * @param distance 第三点距离第二点的距离 // */ // private static Point calcOutsidePoint(Point p, Point pCenter, double distance) { // //计算2点之间的距离 // double ll = Math.sqrt((p.x - pCenter.x) * (p.x - pCenter.x) + (p.y - pCenter.y) * (p.y - pCenter.y)); // // // calc new point // double newX = (p.x * (ll + distance) - pCenter.x * distance) / ll; // double newY = (p.y * (ll + distance) - pCenter.y * distance) / ll; // return new Point((int) newX, (int) newY); // } // //****************************对外接口**************************************************** /** * 设置控件是否可用点击 * @param isClickable */ public void setIsClickable(boolean isClickable) { this.isClickable = isClickable; } /** * 设置进度 * * @param progress 进度值 */ public void setProgress(int progress) { System.out.println("setProgress = " + progress); if (progress > mMaxValue) progress = mMaxValue; if (progress < mMinValue) progress = mMinValue; mProgressPresent = (progress - mMinValue) * 1.0f / (mMaxValue - mMinValue); // System.out.println("setProgress present = " + mProgressPresent); // if (null != mOnProgressChangeListener) { // mOnProgressChangeListener.onProgressChanged(this, progress, false); // } computeThumbPos(mProgressPresent); postInvalidate(); } /** * 获取当前进度数值 * * @return 当前进度数值 */ public int getProgress() { return (int) (mProgressPresent * (mMaxValue - mMinValue)) + mMinValue; } /** * 设置颜色 * 3个颜色 渐变效果 * @param colors 颜色 */ public void setProgressBarColors(int[] colors) { if(colors.length < 2) return; mArcProgressBarColors = colors; resetmArcProgressBarColor(); postInvalidate(); } /** * 设置颜色 单种颜色 * 2019-8-15 * @param colors 颜色 */ public void setProgressBarColor(int colors) { int[] colorsArray = new int[]{colors, colors}; mArcProgressBarColors = colorsArray; resetmArcProgressBarColor(); postInvalidate(); } /** * 设置颜色 2个颜色以上 * 2019-8-15 * @param colors 颜色 */ public void setArcColors(int[] colors) { if(colors.length < 2) return; mArcColors = colors; resetShaderColor(); postInvalidate(); } /** * 设置颜色 * 单种颜色 * @param colors 颜色 */ public void setArcColor(int colors) { int[] colorsArray = new int[]{colors, colors, colors}; mArcColors = colorsArray; resetShaderColor(); postInvalidate(); } /** * 设置最大数值 * * @param max 最大数值 */ public void setMaxValue(int max) { mMaxValue = max; } /** * 设置最小数值 * * @param min 最小数值 */ public void setMinValue(int min) { mMinValue = min; } // /** // * 设置进度条颜色 // * // * @param arcProgressPainColor 进度条颜色 // */ // public void setProgressBarColor(int arcProgressPainColor) { // mArcProgressBarColor = arcProgressPainColor; // mArcProgressBarPaint.setColor(mArcProgressBarColor); // } /** * 设置进度显示值单位 * * @param progressBarUnitSring 进度显示值单位 */ public void setProgressBarUnitSring(String progressBarUnitSring) { mProgressBarUnitSring = progressBarUnitSring; } // /** // * 设置颜色 // * // * @param colorArrayRes 颜色资源 R.array.arc_color // */ // public void setArcColors(int colorArrayRes) { // setArcColors(getColorsByArrayResId(getContext(), colorArrayRes)); // } /** * 设置圆弧宽度，同时同步拖到按钮宽度 * @param arcWidth */ public void setArcWidthDefaultStyle(int arcWidth) { mArcWidth = dp2px(arcWidth); mThumbRadius = mArcWidth / 3; mThumbWidth = mArcWidth * 2 / 9; mArcPaint.setStrokeWidth(mArcWidth); mArcProgressBarPaint.setStrokeWidth(mArcWidth - 1); mThumbPaint.setStrokeWidth(mThumbWidth); } /** * 开口角度 * @param openAngle */ public void setOpenAngle(float openAngle) { mOpenAngle = openAngle; } /** * * @param thumbMode */ public void setThumbMode(int thumbMode) { mThumbMode = thumbMode; if (mThumbMode == THUMB_MODE_FILL) { mThumbPaint.setStyle(Paint.Style.FILL_AND_STROKE); } else if (mThumbMode == THUMB_MODE_FILL_STROKE) { mThumbPaint.setStyle(Paint.Style.FILL_AND_STROKE); } else { mThumbMode = THUMB_MODE_STROKE; mThumbPaint.setStyle(Paint.Style.STROKE); } } /** * * @param arcWidth */ public void setArcWidth(int arcWidth) { mArcWidth = dp2px(arcWidth); mArcPaint.setStrokeWidth(mArcWidth); mArcProgressBarPaint.setStrokeWidth(mArcWidth - 1); } /** * 拖动滑块半径 * @param thumbRadius */ public void setThumbRadius(int thumbRadius) { mThumbRadius = dp2px(thumbRadius); mThumbWidth = mThumbRadius * 2 / 3; mThumbPaint.setStrokeWidth(mThumbWidth); // initThumbPaint(); } /** * 拖动滑块颜色 * @param thumbColor */ public void setThumbColor(int thumbColor) { mThumbColor = thumbColor; mThumbPaint.setColor(mThumbColor); } /** * 进度文字大小 * @param textSize */ public void setProgressTextSize(int textSize){ mTextPaint.setTextSize(getTextSizeDip(textSize)); } /** * 进度文字颜色 * @param textPaintColor */ public void setProgressTextColor(int textPaintColor){ mTextPaint.setColor(textPaintColor); } /** * 进度文字与圆弧距离 * @param textDefaultDistance */ public void setTextDefaultDistance(int textDefaultDistance) { mTextDefaultDistance = dp2px(textDefaultDistance); } // endregion ----------------------------------------------------------------------------------- // region 状态回调 ------------------------------------------------------------------------------ private OnProgressChangeListener mOnProgressChangeListener; public void setOnProgressChangeListener(OnProgressChangeListener onProgressChangeListener) { mOnProgressChangeListener = onProgressChangeListener; } public interface OnProgressChangeListener { /** * 进度发生变化 * * @param seekBar 拖动条 * @param progress 当前进度数值 * @param isUser 是否是用户操作, true 表示用户拖动, false 表示通过代码设置 */ void onProgressChanged(HDLArcSeekBar seekBar, int progress, boolean isUser); /** * 用户开始拖动 * * @param seekBar 拖动条 */ void onStartTrackingTouch(HDLArcSeekBar seekBar); /** * 用户结束拖动 * * @param seekBar 拖动条 */ void onStopTrackingTouch(HDLArcSeekBar seekBar); } // endregion ----------------------------------------------------------------------------------- }