devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 可左右滑动的动态赛贝尔曲线，纵坐标可设置刻度不均匀_android动态曲线图

作者：Monodyee | 2024-05-17 00:01:20

赞

踩

android动态曲线图

最近项目中遇到，需要绘制温度实时显示的曲线，纵坐标有三个区间，刻度分别不一致。中间的区域为温度适宜区，显示高度不变，但是刻度会根据实际情况改变。并且要绘制圆滑的曲线，这里使用的是赛贝尔曲线。同时需要在绘制过程中能够左右滑动曲线。下面直接上效果：

赛贝尔曲线使用的是path的方法

path.cubicTo(firstControlPointX, firstControlPointY, secondControlPointX, secondControlPointY, currentPointX, currentPointY);

这里需要使用现有的数据点求出控制点的坐标再绘制

  1. // 求出控制点坐标
  2. final float firstDiffX = (currentPointX - prePreviousPointX);
  3. final float firstDiffY = (currentPointY - prePreviousPointY);
  4. final float secondDiffX = (nextPointX - previousPointX);
  5. final float secondDiffY = (nextPointY - previousPointY);
  6. final float firstControlPointX = previousPointX + (mLineSmoothness * firstDiffX);
  7. final float firstControlPointY = previousPointY + (mLineSmoothness * firstDiffY);
  8. final float secondControlPointX = currentPointX - (mLineSmoothness * secondDiffX);
  9. final float secondControlPointY = currentPointY - (mLineSmoothness * secondDiffY);

自动左右滑动引入了一个第一个点的X坐标变量firstPointX来控制，在添加数据addValue方法的最后判断点是否超过了屏幕宽度，这个时候需要重新计算第一个点的横坐标，重绘时来让曲线看上去在自动往后移动，intervalX变量是每个数据点固定移动的横坐标宽度

  1. firstMinX = CHARTW - originX - (m_plist.size() - 1) * intervalX - leftRightExtra;
  2. if (nx > CHARTW - OFFSET_RIGHT) {
  3.     firstPointX = firstPointX - intervalX;
  4. }

手动滑动，重写onTouchEvent方法，postDelayed方法是手抬起后，过几秒会自动回到最后的点，继续自动滑动0

  1.     @Override
  2.     public boolean onTouchEvent(MotionEvent event) {
  3.         if (event.getAction() == MotionEvent.ACTION_UP) {
  4.             Log.d("jokey", "onTouchEvent-->ACTION_UP");
  5.             myHander.postDelayed(new Runnable() {
  6.                 @Override
  7.                 public void run() {
  8.                     if (m_plist != null && m_plist.size() > 0 && m_plist.get(m_plist.size() - 1).x > CHARTW - OFFSET_RIGHT) {
  9.                         firstPointX = originX - (intervalX * m_plist.size() - (CHARTW - OFFSET_RIGHT));
  10.                     }
  11.                 }
  12.             }, 2000);
  13.         } else if (event.getAction() == MotionEvent.ACTION_DOWN) {
  14.             Log.d("jokey", "onTouchEvent-->ACTION_DOWN");
  15.             myHander.removeCallbacksAndMessages(null);
  16.         }
  17.         if (m_plist != null && m_plist.size() > 0 && m_plist.get(m_plist.size() - 1).x < CHARTW - OFFSET_RIGHT) {
  18.             return false;
  19.         }
  20.         gestureDetector.onTouchEvent(event);
  21.         return true;
  22.     }

手势事件的控制

  1. /**
  2.      * 手势事件
  3.      */
  4.     class MyOnGestureListener implements GestureDetector.OnGestureListener {
  5.         @Override
  6.         public boolean onDown(MotionEvent e) { // 按下事件
  7.             return false;
  8.         }
  9.  
  10.         // 按下停留时间超过瞬时，并且按下时没有松开或拖动，就会执行此方法
  11.         @Override
  12.         public void onShowPress(MotionEvent motionEvent) {
  13.         }
  14.  
  15.         @Override
  16.         public boolean onSingleTapUp(MotionEvent motionEvent) { // 单击抬起
  17.             return false;
  18.         }
  19.  
  20.         @Override
  21.         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
  22.             if (e1.getX() > originX && e1.getX() < CHARTW - OFFSET_RIGHT &&
  23.                     e1.getY() > OFFSET_TOP && e1.getY() < CHARTH - OFFSET_BOTTOM) {
  24.                 //注意：这里的distanceX是e1.getX()-e2.getX()
  25.                 distanceX = -distanceX;
  26.                 if (firstPointX + distanceX > firstMaxX) {
  27.                     firstPointX = firstMaxX;
  28.                 } else if (firstPointX + distanceX < firstMinX) {
  29.                     firstPointX = firstMinX;
  30.                 } else {
  31.                     firstPointX = (int) (firstPointX + distanceX);
  32.                 }
  33.                 Log.d("jokey", "onScroll-->firstPointX: " + firstPointX);
  34.                 Log.d("jokey", "onScroll-->firstMaxX: " + firstMaxX);
  35.                 Log.d("jokey", "onScroll-->firstMinX: " + firstMinX);
  36.                 invalidate();
  37.             }
  38.             return false;
  39.         }
  40.  
  41.         @Override
  42.         public void onLongPress(MotionEvent motionEvent) {
  43.         } // 长按事件
  44.  
  45.         @Override
  46.         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
  47.             return false;
  48.         }
  49.     }

最后来段完整的代码

  1. public class WarmAreDrawChart extends View {
  2.     public int CHARTH = 0;
  3.     public int CHARTW = 0;
  4.     private int originX; // 原点x坐标
  5.     private int originY; // 原点y坐标
  6.     private int firstPointX;//第一个点x坐标
  7.  
  8.     private int firstMinX; // 移动时第一个点的最小x值
  9.     private int firstMaxX; //移动时第一个点的最大x值
  10.     private int leftRightExtra = 0;//x轴左右向外延伸的长度
  11.  
  12.     private int OFFSET_LEFT = 0;
  13.     private int OFFSET_TOP = 10;
  14.     private int OFFSET_RIGHT = 0;
  15.     private int OFFSET_BOTTOM = 10;
  16.     private int TEXT_OFFSET = 5;
  17.     private int intervalX = 25; // x坐标刻度的间隔
  18.  
  19.     private int areWarmMin = 38;//温度适宜区低值
  20.     private int areWarmMax = 48;//温度适宜区高值
  21.     public int m_nCurrMovePos = 0;            //当前点的个数
  22.     private int Y_MAX = 50;//Y轴最大值
  23.     private int Y_MIN = 35;  //Y轴最小值
  24.     public List<Point> m_plist, m_plist2, m_plist3;
  25.     private Paint paint1, paintBack;
  26.     private SimpleDateFormat format = new SimpleDateFormat("mm:ss", Locale.getDefault());
  27.     private boolean isFreshTable;
  28.     //    private int addCount = 0;
  29.     private Bitmap bitmap;
  30.     public int warmMin, warmMax;
  31.     private GestureDetector gestureDetector;
  32.     private Handler myHander = new Handler();
  33.     //    private boolean isGolden;
  34.     //曲线切率
  35.     private float mLineSmoothness = 0.18f;
  36.     private int intervalTimeMs = 100;//数据时间间隔，多少毫秒上传一个数据
  37.  
  38.     public WarmAreDrawChart(Activity activity, int warmMin, int warmMax, int intervalTimeMs) {
  39.         super(activity);
  40.         this.warmMin = warmMin;
  41.         this.warmMax = warmMax;
  42.         this.intervalTimeMs = intervalTimeMs;
  43. //        this.isGolden = isGolden;
  44.         m_plist = new ArrayList<>();
  45.         m_plist2 = new ArrayList<>();
  46.         m_plist3 = new ArrayList<>();
  47.         //画左边的文字
  48.         paint1 = new Paint();
  49.         paint1.setStyle(Paint.Style.FILL);
  50.         paint1.setColor(getResources().getColor(R.color.text_color_666));
  51.         paint1.setAntiAlias(true);
  52.         paint1.setTextSize(10);
  53.         paintBack = new Paint(Paint.ANTI_ALIAS_FLAG);
  54.         paintBack.setColor(Color.parseColor("#ffffff"));
  55.         paintBack.setStyle(Paint.Style.FILL);
  56.         isFreshTable = true;
  57.         gestureDetector = new GestureDetector(activity, new MyOnGestureListener());
  58.     }
  59.  
  60.     @Override
  61.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
  62.         if (changed) {
  63.             CHARTW = getWidth();
  64.             CHARTH = getHeight();
  65.             Log.d("jokey", "onLayout-->CHARTW: " + CHARTW);
  66.             Log.d("jokey", "onLayout-->CHARTH: " + CHARTH);
  67.             originX = OFFSET_LEFT;
  68.             originY = CHARTH - OFFSET_BOTTOM;
  69.  
  70.             firstPointX = originX;
  71.             Log.d("jokey", "onLayout-->firstPointX: " + firstPointX);
  72.             firstMinX = CHARTW - originX - (m_plist.size() - 1) * intervalX - leftRightExtra;
  73.             // 滑动时，第一个点x值最大为paddingLeft，在大于这个值就不能滑动了
  74.             firstMaxX = firstPointX;
  75.             Log.d("jokey", "onLayout-->firstMaxX: " + firstMaxX);
  76.             Log.d("jokey", "onLayout-->firstMinX: " + firstMinX);
  77.             setBackgroundColor(Color.parseColor("#ffffff"));
  78.         }
  79.         super.onLayout(changed, left, top, right, bottom);
  80.     }
  81.  
  82.     @SuppressLint("DrawAllocation")
  83.     @Override
  84.     protected void onDraw(Canvas canvas) {
  85.         super.onDraw(canvas);
  86.         init();
  87.         if (bitmap == null) {
  88.             return;
  89.         }
  90.         canvas.drawBitmap(bitmap, 0, 0, null);
  91.  
  92.         drawCurve(canvas);
  93.         drawLeftText(canvas);
  94.     }
  95.  
  96.     private void init() {
  97.         if (isFreshTable) {
  98.             if (bitmap != null) {
  99.                 bitmap.recycle();
  100.                 bitmap = null;
  101.             }
  102.             bitmap = Bitmap.createBitmap(CHARTW + OFFSET_LEFT * 2, CHARTH + OFFSET_TOP * 2, Bitmap.Config.ARGB_8888);
  103.             Canvas bufferCanvas = new Canvas(bitmap);
  104.             drawTable(bufferCanvas);
  105.             drawWarmAre(bufferCanvas);
  106.  
  107.             //画模板曲线
  108.             isFreshTable = false;
  109.             invalidate();
  110.         }
  111.     }
  112.  
  113.     /**
  114.      * 温度适宜区域
  115.      *
  116.      * @param bufferCanvas
  117.      */
  118.     private void drawWarmAre(Canvas bufferCanvas) {
  119.         //定义画笔
  120.         Paint paint = new Paint();
  121.         //设置颜色
  122.         paint.setColor(0x1A0CACDD);
  123.         //设置画笔类型
  124.         paint.setStyle(Paint.Style.FILL);
  125.         int gapMin = (areWarmMin - Y_MIN);
  126.         int gapMax = (areWarmMax - Y_MIN);
  127.         //使用画笔在画布上画矩形
  128.         bufferCanvas.drawRect(OFFSET_LEFT,
  129.                 originY - (originY - OFFSET_TOP) * gapMax / 15 + 5,
  130.                 CHARTW,
  131.                 originY - (originY - OFFSET_TOP) * gapMin / 15 + 5, paint);
  132.  
  133.         //画温度适宜区文字
  134.         Paint paintAreText = new Paint();
  135.         paintAreText.setStyle(Paint.Style.FILL);
  136.         paintAreText.setColor(getResources().getColor(R.color.color_warm));
  137.         paintAreText.setAntiAlias(true);
  138.         paintAreText.setTextSize(40);
  139.         bufferCanvas.drawText("温 度 适 宜 区 域", (CHARTW - OFFSET_LEFT) / 3, originY - (originY - OFFSET_TOP) * 7 / 15 + 10, paintAreText);
  140.     }
  141.  
  142.     private void drawTable(Canvas canvas) {
  143. //        paint1.setStyle(Paint.Style.STROKE);
  144. //        paint1.setStrokeWidth(2);
  145. //        paint1.setColor(getResources().getColor(R.color.red));
  146. //        Path path = new Path();
  147. //        path.moveTo(originX, OFFSET_TOP);
  148. //        path.lineTo(OFFSET_LEFT + CHARTW, OFFSET_TOP);
  149. //        for (int i = 1; i < 15; i++) {
  150. //            path.moveTo(originX, originY - (originY - OFFSET_TOP) * i / 15);
  151. //            path.lineTo(OFFSET_LEFT + CHARTW, originY - (originY - OFFSET_TOP) * i / 15);
  152. //        }
  153. //        path.moveTo(originX, originY);
  154. //        path.lineTo(OFFSET_LEFT + CHARTW, originY);
  155. //        canvas.drawPath(path, paint1);
  156.     }
  157.  
  158.     private void drawLeftText(Canvas canvas) {
  159.         //画左侧数字
  160.         canvas.drawText(Y_MAX + "", TEXT_OFFSET, OFFSET_TOP + 5, paint1);
  161.         int gapMin = (areWarmMin - Y_MIN);
  162.         int gapMax = (areWarmMax - Y_MIN);
  163.         canvas.drawText(String.valueOf(warmMin), TEXT_OFFSET, originY - (originY - OFFSET_TOP) * gapMin / 15 + 5, paint1);
  164.         canvas.drawText(String.valueOf(warmMax), TEXT_OFFSET, originY - (originY - OFFSET_TOP) * gapMax / 15 + 5, paint1);
  165.  
  166.         canvas.drawText(Y_MIN + "", TEXT_OFFSET, CHARTH - OFFSET_BOTTOM + 7, paint1);
  167.         canvas.drawText("℃/min", OFFSET_LEFT + 18, CHARTH, paint1);
  168.     }
  169.  
  170.     private void drawCurve(Canvas canvas) {
  171.  
  172.         Paint paintBlue = new Paint(Paint.ANTI_ALIAS_FLAG);
  173.         paintBlue.setColor(getResources().getColor(R.color.colorAccent));
  174.         paintBlue.setStrokeWidth(2f);
  175.         paintBlue.setStyle(Paint.Style.STROKE);
  176.  
  177.         Paint paintGreen = new Paint(Paint.ANTI_ALIAS_FLAG);
  178.         paintGreen.setColor(getResources().getColor(R.color.color_19D9CB));
  179.         paintGreen.setStrokeWidth(2f);
  180.         paintGreen.setStyle(Paint.Style.STROKE);
  181.  
  182.         Paint paintRed = new Paint(Paint.ANTI_ALIAS_FLAG);
  183.         paintRed.setColor(getResources().getColor(R.color.color_FE6085));
  184.         paintRed.setStrokeWidth(2f);
  185.         paintRed.setStyle(Paint.Style.STROKE);
  186.  
  187.         int size = m_plist.size();
  188.         //画线
  189. //        if (size > 0) {
  190. //            for (int i = 0; i < size - 2; i++) {
  191. //                canvas.drawLine(firstPointX + i * intervalX, m_plist.get(i).y, firstPointX + (i + 1) * intervalX, m_plist.get(i + 1).y, paintBlue);
  192. //                if (m_plist2.size() > 0) {
  193. //                    canvas.drawLine(firstPointX + i * intervalX, m_plist2.get(i).y, firstPointX + (i + 1) * intervalX, m_plist2.get(i + 1).y, paintGreen);
  194. //                }
  195. //                if (m_plist3.size() > 0) {
  196. //                    canvas.drawLine(firstPointX + i * intervalX, m_plist3.get(i).y, firstPointX + (i + 1) * intervalX, m_plist3.get(i + 1).y, paintRed);
  197. //                }
  198. //            }
  199. //        }
  200.  
  201.         Path path = new Path();
  202. //        Path path2 = new Path();
  203. //        Path path3 = new Path();
  204.         float prePreviousPointX = Float.NaN;
  205.         float prePreviousPointY = Float.NaN;
  206.         float previousPointX = Float.NaN;
  207.         float previousPointY = Float.NaN;
  208.         float currentPointX = Float.NaN;
  209.         float currentPointY = Float.NaN;
  210.         float nextPointX;
  211.         float nextPointY;
  212.  
  213.         int lineSize = m_plist.size();
  214.         for (int i = 0; i < lineSize; i++) {
  215.             if (firstPointX + i * intervalX < 0) {
  216.                 continue;
  217.             }
  218.             if (firstPointX + i * intervalX > CHARTW) {
  219.                 break;
  220.             }
  221.             if (Float.isNaN(currentPointX)) {
  222.                 currentPointX = firstPointX + i * intervalX;
  223.                 currentPointY = m_plist.get(i).y;
  224.             }
  225.             if (Float.isNaN(previousPointX)) {
  226.                 //是第一个点?
  227.                 if (i > 0) {
  228.                     previousPointX = firstPointX + (i - 1) * intervalX;
  229.                     previousPointY = m_plist.get(i - 1).y;
  230.                 } else {
  231.                     //用当前点表示上一个点
  232.                     previousPointX = currentPointX;
  233.                     previousPointY = currentPointY;
  234.                 }
  235.             }
  236.             if (Float.isNaN(prePreviousPointX)) {
  237.                 //是前两个点?
  238.                 if (i > 1) {
  239.                     prePreviousPointX = firstPointX + (i - 2) * intervalX;
  240.                     prePreviousPointY = m_plist.get(i - 2).y;
  241.                 } else {
  242.                     //当前点表示上上个点
  243.                     prePreviousPointX = previousPointX;
  244.                     prePreviousPointY = previousPointY;
  245.                 }
  246.             }
  247.             // 判断是不是最后一个点了
  248.             if (i < lineSize - 1) {
  249.                 nextPointX = firstPointX + (i + 1) * intervalX;
  250.                 nextPointY = m_plist.get(i + 1).y;
  251.             } else {
  252.                 //用当前点表示下一个点
  253.                 nextPointX = currentPointX;
  254.                 nextPointY = currentPointY;
  255.             }
  256.             if (i == 0) {
  257.                 // 将Path移动到开始点
  258.                 path.moveTo(currentPointX, currentPointY);
  259.             } else {
  260.                 // 求出控制点坐标
  261.                 final float firstDiffX = (currentPointX - prePreviousPointX);
  262.                 final float firstDiffY = (currentPointY - prePreviousPointY);
  263.                 final float secondDiffX = (nextPointX - previousPointX);
  264.                 final float secondDiffY = (nextPointY - previousPointY);
  265.                 final float firstControlPointX = previousPointX + (mLineSmoothness * firstDiffX);
  266.                 final float firstControlPointY = previousPointY + (mLineSmoothness * firstDiffY);
  267.                 final float secondControlPointX = currentPointX - (mLineSmoothness * secondDiffX);
  268.                 final float secondControlPointY = currentPointY - (mLineSmoothness * secondDiffY);
  269.                 //画出曲线
  270.                 path.cubicTo(firstControlPointX, firstControlPointY, secondControlPointX, secondControlPointY,
  271.                         currentPointX, currentPointY);
  272.             }
  273.  
  274.             // 更新
  275.             prePreviousPointX = previousPointX;
  276.             prePreviousPointY = previousPointY;
  277.             previousPointX = currentPointX;
  278.             previousPointY = currentPointY;
  279.             currentPointX = nextPointX;
  280.             currentPointY = nextPointY;
  281.             //显示时间
  282.  
  283.             if (i != 0 && i % (60 * (1000 / intervalTimeMs)) == 0) {
  284.                 canvas.drawText((i / (60 * (1000 / intervalTimeMs))) + "min", firstPointX + i * intervalX, CHARTH - 5, paint1);
  285.             }
  286.         }
  287.  
  288.         canvas.drawPath(path, paintBlue);
  289. //        for (int i = 0; i < size; i++) {
  290. //            if (i == 0) {
  291. //                path.moveTo(firstPointX, m_plist.get(i).y);
  292. //                if (m_plist2 != null && m_plist2.size() > 0) {
  293. //                    path2.moveTo(firstPointX, m_plist2.get(i).y);
  294. //                }
  295. //                if (m_plist3 != null && m_plist3.size() > 0) {
  296. //                    path3.moveTo(firstPointX, m_plist3.get(i).y);
  297. //                }
  298. //            } else {
  299. //                path.lineTo(firstPointX + i * intervalX, m_plist.get(i).y);
  300. //                if (m_plist2 != null && m_plist2.size() > 0) {
  301. //                    path2.lineTo(firstPointX + i * intervalX, m_plist2.get(i).y);
  302. //                }
  303. //                if (m_plist3 != null && m_plist3.size() > 0) {
  304. //                    path3.lineTo(firstPointX + i * intervalX, m_plist3.get(i).y);
  305. //                }
  306. //            }
  307. //        }
  308. //        canvas.drawPath(path, paintBlue);
  309. //        if (m_plist2 != null && m_plist2.size() > 0) {
  310. //            paintBlue.setColor(getResources().getColor(R.color.color_19D9CB));
  311. //            canvas.drawPath(path2, paintBlue);
  312. //        }
  313. //        if (m_plist3 != null && m_plist3.size() > 0) {
  314. //            paintBlue.setColor(getResources().getColor(R.color.color_FE6085));
  315. //            canvas.drawPath(path3, paintBlue);
  316. //        }
  317.  
  318.  
  319.         // 截取折线超出部分（右边）
  320.         paintBack.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_OVER));
  321.         RectF rectF = new RectF(CHARTW - OFFSET_RIGHT, 0, CHARTW, CHARTH);
  322.         canvas.drawRect(rectF, paintBack);
  323.         canvas.save();
  324.         canvas.restore();
  325.         //将折线超出x轴坐标的部分截取掉（左边）
  326.         paintBack.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_OVER));
  327.         rectF = new RectF(0, 0, originX, CHARTH);
  328.         canvas.drawRect(rectF, paintBack);
  329.         canvas.save();
  330.         canvas.restore();
  331.     }
  332.  
  333.     public void addValue(ArrayList<List<Integer>> arrayList) {
  334.         if (arrayList != null && arrayList.size() > 0) {
  335.             if (arrayList.get(0) != null) {
  336.                 for (int i = 0; i < arrayList.get(0).size(); i++) {
  337.                     if (arrayList.size() > 1 && arrayList.get(1) != null && arrayList.get(1).size() > 0) {
  338.                         if (arrayList.size() > 2 && arrayList.get(2) != null && arrayList.get(2).size() > 0) {
  339.                             addValue(arrayList.get(0).get(i) / 10, arrayList.get(1).get(i) / 10, arrayList.get(2).get(i) / 10);
  340.                         } else {
  341.                             addValue(arrayList.get(0).get(i) / 10, arrayList.get(1).get(i) / 10);
  342.                         }
  343.                     } else {
  344.                         addValue(arrayList.get(0).get(i) / 10);
  345.                     }
  346.                 }
  347.             }
  348.         }
  349.     }
  350.  
  351.     private int getScreenPosY(double y) {
  352.         int gapMin = (areWarmMin - Y_MIN);
  353.         int gapMax = (areWarmMax - Y_MIN);
  354.         if (y <= warmMin) {
  355.             //底部的区域
  356.             double ratio = (y - Y_MIN) / (warmMin - Y_MIN);
  357.             int height = originY - (originY - OFFSET_TOP) * gapMin / 15 + 5;
  358.             int bottom = originY;
  359.             return bottom - (int) Math.ceil((bottom - height) * ratio);
  360.         } else if (y <= warmMax) {
  361.             //中间适宜区
  362.             double ratio = (y - warmMin) / (warmMax - warmMin);
  363.             int height = originY - (originY - OFFSET_TOP) * gapMax / 15 + 5;
  364.             int bottom = originY - (originY - OFFSET_TOP) * gapMin / 15 + 5;
  365.             return bottom - (int) Math.ceil((bottom - height) * ratio);
  366.         } else {
  367.             //顶端区域
  368.             double ratio = (y - warmMax) / (Y_MAX - warmMax);
  369.             int height = OFFSET_TOP + 5;
  370.             int bottom = originY - (originY - OFFSET_TOP) * gapMax / 15 + 5;
  371.             return bottom - (int) Math.ceil((bottom - height) * ratio);
  372.         }
  373.     }
  374.  
  375.     public void addValue(double nValue) {
  376.         if (nValue > Y_MAX) {
  377.             nValue = Y_MAX;
  378.         }
  379.         if (nValue > 0 && nValue < Y_MIN) {
  380.             nValue = Y_MIN;
  381.         }
  382.         int ny = getScreenPosY(nValue);
  383.         //X坐标一样就不绘制
  384.         int nx = OFFSET_LEFT + m_nCurrMovePos * intervalX;
  385.         m_nCurrMovePos++;
  386.         if (m_plist.size() == 0) {
  387.             Point p = new Point(nx, ny);
  388.             m_plist.add(p);
  389.         } else {
  390.             Point p = new Point(nx, ny);
  391.             m_plist.add(p);
  392.         }
  393.         firstMinX = CHARTW - originX - (m_plist.size() - 1) * intervalX - leftRightExtra;
  394.         if (nx > CHARTW - OFFSET_RIGHT) {
  395.             firstPointX = firstPointX - intervalX;
  396.         }
  397. //        Log.d("jokey", "addValue-->firstPointX: " + firstPointX);
  398.         invalidate();
  399.     }
  400.  
  401.     public void addValue(double nValueA, double nValueB) {
  402.         if (nValueA >= Y_MAX) {
  403.             nValueA = Y_MAX;
  404.         }
  405.         if (nValueA > 0 && nValueA <= Y_MIN) {
  406.             nValueA = Y_MIN;
  407.         }
  408.         int ny = getScreenPosY(nValueA);
  409.  
  410.         if (nValueB >= Y_MAX) {
  411.             nValueB = Y_MAX;
  412.         }
  413.         if (nValueB > 0 && nValueB <= Y_MIN) {
  414.             nValueB = Y_MIN;
  415.         }
  416.         int ny2 = getScreenPosY(nValueB);
  417.         //X坐标一样就不绘制
  418.         int nx = OFFSET_LEFT + m_nCurrMovePos * intervalX;
  419.         m_nCurrMovePos++;
  420.         if (m_plist.size() == 0) {
  421.             Point p = new Point(nx, ny);
  422.             Point p2 = new Point(nx, ny2);
  423.             m_plist.add(p);
  424.             m_plist2.add(p2);
  425.         } else if ((nx - m_plist.get(m_plist.size() - 1).x) >= 5) {
  426.             Point p = new Point(nx, ny);
  427.             Point p2 = new Point(nx, ny2);
  428.             m_plist.add(p);
  429.             m_plist2.add(p2);
  430.         }
  431.         firstMinX = CHARTW - originX - (m_plist.size() - 1) * intervalX - leftRightExtra;
  432.         if (nx > CHARTW - OFFSET_RIGHT) {
  433.             firstPointX = firstPointX - intervalX;
  434.         }
  435.         invalidate();
  436.     }
  437.  
  438.     public void addValue(double nValueA, double nValueB, double nValueC) {
  439.         Log.d("jokey", "nValueA: " + nValueA + ",nValueB: " + nValueB + ",nValueC: " + nValueC);
  440.         if (nValueA >= Y_MAX) {
  441.             nValueA = Y_MAX;
  442.         }
  443.         if (nValueA > 0 && nValueA <= Y_MIN) {
  444.             nValueA = Y_MIN;
  445.         }
  446.         int ny = getScreenPosY(nValueA);
  447.  
  448.         if (nValueB >= Y_MAX) {
  449.             nValueB = Y_MAX;
  450.         }
  451.         if (nValueB > 0 && nValueB <= Y_MIN) {
  452.             nValueB = Y_MIN;
  453.         }
  454.         int ny2 = getScreenPosY(nValueB);
  455.  
  456.         if (nValueC >= Y_MAX) {
  457.             Log.d("jokey", "nValueC1: " + nValueC);
  458.             nValueC = Y_MAX;
  459.         }
  460.         if (nValueC > 0 && nValueC <= Y_MIN) {
  461.             Log.d("jokey", "nValueC2: " + nValueC);
  462.             nValueC = Y_MIN;
  463.         }
  464.         int ny3 = getScreenPosY(nValueC);
  465.         Log.d("jokey", "ny3: " + ny3);
  466.         //X坐标一样就不绘制
  467.         int nx = OFFSET_LEFT + m_nCurrMovePos * intervalX;
  468.         m_nCurrMovePos++;
  469.         if (m_plist.size() == 0) {
  470.             Point p = new Point(nx, ny);
  471.             Point p2 = new Point(nx, ny2);
  472.             Point p3 = new Point(nx, ny3);
  473.             m_plist.add(p);
  474.             m_plist2.add(p2);
  475.             m_plist3.add(p3);
  476.         } else if ((nx - m_plist.get(m_plist.size() - 1).x) >= 5) {
  477.             Point p = new Point(nx, ny);
  478.             Point p2 = new Point(nx, ny2);
  479.             Point p3 = new Point(nx, ny3);
  480.             m_plist.add(p);
  481.             m_plist2.add(p2);
  482.             m_plist3.add(p3);
  483.         }
  484.         firstMinX = CHARTW - originX - (m_plist.size() - 1) * intervalX - leftRightExtra;
  485.         if (nx > CHARTW - OFFSET_RIGHT) {
  486.             firstPointX = firstPointX - intervalX;
  487.         }
  488.         invalidate();
  489.     }
  490.  
  491.     /**
  492.      * 手势事件
  493.      */
  494.     class MyOnGestureListener implements GestureDetector.OnGestureListener {
  495.         @Override
  496.         public boolean onDown(MotionEvent e) { // 按下事件
  497.             return false;
  498.         }
  499.  
  500.         // 按下停留时间超过瞬时，并且按下时没有松开或拖动，就会执行此方法
  501.         @Override
  502.         public void onShowPress(MotionEvent motionEvent) {
  503.         }
  504.  
  505.         @Override
  506.         public boolean onSingleTapUp(MotionEvent motionEvent) { // 单击抬起
  507.             return false;
  508.         }
  509.  
  510.         @Override
  511.         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
  512.             if (e1.getX() > originX && e1.getX() < CHARTW - OFFSET_RIGHT &&
  513.                     e1.getY() > OFFSET_TOP && e1.getY() < CHARTH - OFFSET_BOTTOM) {
  514.                 //注意：这里的distanceX是e1.getX()-e2.getX()
  515.                 distanceX = -distanceX;
  516.                 if (firstPointX + distanceX > firstMaxX) {
  517.                     firstPointX = firstMaxX;
  518.                 } else if (firstPointX + distanceX < firstMinX) {
  519.                     firstPointX = firstMinX;
  520.                 } else {
  521.                     firstPointX = (int) (firstPointX + distanceX);
  522.                 }
  523.                 Log.d("jokey", "onScroll-->firstPointX: " + firstPointX);
  524.                 Log.d("jokey", "onScroll-->firstMaxX: " + firstMaxX);
  525.                 Log.d("jokey", "onScroll-->firstMinX: " + firstMinX);
  526.                 invalidate();
  527.             }
  528.             return false;
  529.         }
  530.  
  531.         @Override
  532.         public void onLongPress(MotionEvent motionEvent) {
  533.         } // 长按事件
  534.  
  535.         @Override
  536.         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
  537.             return false;
  538.         }
  539.     }
  540.  
  541.     @Override
  542.     public boolean onTouchEvent(MotionEvent event) {
  543.         if (event.getAction() == MotionEvent.ACTION_UP) {
  544.             Log.d("jokey", "onTouchEvent-->ACTION_UP");
  545.             myHander.postDelayed(new Runnable() {
  546.                 @Override
  547.                 public void run() {
  548.                     if (m_plist != null && m_plist.size() > 0 && m_plist.get(m_plist.size() - 1).x > CHARTW - OFFSET_RIGHT) {
  549.                         firstPointX = originX - (intervalX * m_plist.size() - (CHARTW - OFFSET_RIGHT));
  550.                     }
  551.                 }
  552.             }, 2000);
  553.         } else if (event.getAction() == MotionEvent.ACTION_DOWN) {
  554.             Log.d("jokey", "onTouchEvent-->ACTION_DOWN");
  555.             myHander.removeCallbacksAndMessages(null);
  556.         }
  557.         if (m_plist != null && m_plist.size() > 0 && m_plist.get(m_plist.size() - 1).x < CHARTW - OFFSET_RIGHT) {
  558.             return false;
  559.         }
  560.         gestureDetector.onTouchEvent(event);
  561.         return true;
  562.     }
  563. }

MainActivity调用

  1. public class MainActivity extends AppCompatActivity {
  2.     private MyThread myThread;
  3.     private LinearLayout llChart;
  4.     private WarmAreDrawChart warmAreDrawChart;
  5.     private int intervalTimeMs = 100;
  6.  
  7.     @Override
  8.     protected void onCreate(Bundle savedInstanceState) {
  9.         super.onCreate(savedInstanceState);
  10.         setContentView(R.layout.activity_main);
  11.         llChart = findViewById(R.id.ll_chart);
  12.         initChart();
  13.         initListener();
  14.     }
  15.  
  16.  
  17.     private void initListener() {
  18.         findViewById(R.id.btn_open).setOnClickListener(new View.OnClickListener() {
  19.             @Override
  20.             public void onClick(View v) {
  21.                 open();
  22.  
  23.         });
  24.         findViewById(R.id.btn_close).setOnClickListener(new View.OnClickListener() {
  25.             @Override
  26.             public void onClick(View v) {
  27.                 close();
  28.  
  29.             }
  30.         });
  31.         findViewById(R.id.btn_jie_mian2).setOnClickListener(new View.OnClickListener() {
  32.             @Override
  33.             public void onClick(View v) {
  34.                 startActivity(new Intent(MainActivity.this, ListActivity.class));
  35.             }
  36.         });
  37.     }
  38.  
  39.     private void initChart() {
  40.         warmAreDrawChart = new WarmAreDrawChart(this, 38, 42, intervalTimeMs);
  41.         llChart.removeAllViews();
  42.         llChart.addView(warmAreDrawChart);
  43.     }
  44.  
  45.     private void open() {
  46.         if (myThread == null) {
  47.             myThread = new MyThread();
  48.             myThread.setContinue(true);
  49.             myThread.start();
  50.         }
  51.     }
  52.  
  53.     private void close() {
  54.         if (myThread != null) {
  55.             myThread.setContinue(false);
  56.             myThread = null;
  57.         }
  58.     }
  59.  
  60.  
  61.     private class MyThread extends Thread {
  62.         private boolean isContinue;
  63.  
  64.         public void setContinue(boolean aContinue) {
  65.             isContinue = aContinue;
  66.         }
  67.  
  68.         @Override
  69.         public void run() {
  70.             while (isContinue) {
  71.                 int value = new Random().nextInt(16) + 35;
  72.  
  73.                 warmAreDrawChart.addValue(value);
  74.                 SystemClock.sleep(intervalTimeMs);
  75.             }
  76.         }
  77.     }
  78. }

xml布局

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     tools:context=".MainActivity">
  8.  
  9.     <LinearLayout
  10.         android:id="@+id/ll_chart"
  11.         android:layout_width="match_parent"
  12.         android:layout_height="200dp"
  13.         android:orientation="horizontal">
  14.  
  15.     </LinearLayout>
  16.     <LinearLayout
  17.         android:layout_width="match_parent"
  18.         android:layout_height="wrap_content"
  19.         android:layout_alignParentBottom="true"
  20.         android:orientation="horizontal">
  21.         <Button
  22.             android:id="@+id/btn_open"
  23.             android:layout_width="wrap_content"
  24.             android:layout_height="wrap_content"
  25.             android:text="开启"/>
  26.         <Button
  27.             android:id="@+id/btn_close"
  28.             android:layout_width="wrap_content"
  29.             android:layout_height="wrap_content"
  30.             android:text="关闭"/>
  31.         <Button
  32.             android:id="@+id/btn_jie_mian2"
  33.             android:layout_width="wrap_content"
  34.             android:layout_height="wrap_content"
  35.             android:text="界面2"/>
  36.     </LinearLayout>
  37. </RelativeLayout>

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/581000
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号