在android中获取闭合画布形状

我正在尝试用android在地图上画一个形状。如果用户绘制了一条闭合的路径，则可以。如果用户绘制了一个打开的路径，那么如何关闭该路径以使其看起来更好

请看图片

我在这里画了一条开阔的道路

一旦onTouch动作启动，路径就应该自行关闭

像这样,

public boolean onTouch(View v, MotionEvent event) {
    int action = event.getAction();
    path = new Path();
    float upX;
    float upY;
    Log.d("", "OnTouch");
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        downx = event.getX();
        downy = event.getY();
        eventX = downx;
        eventY = downy;
        Log.d("", "startx" + eventX);
        break;
    case MotionEvent.ACTION_MOVE:
        upx = event.getX();
        upy = event.getY();
        canvas.drawLine(downx, downy, upx, upy, paint);
        drawable.invalidate();
        downx = upx;
        downy = upy;
        break;
    case MotionEvent.ACTION_UP:
        upX = event.getX();
        upY = event.getY();
        Log.d("", "Action Up");
        Log.d("", "endx" + upX);
        //path.moveTo(eventX, eventY);
        canvas.drawLine(eventX, eventY, upX, upY, paint);
        drawable.invalidate();
        return true;
    case MotionEvent.ACTION_CANCEL:
        break;
    default:
        break;

    }
    return true;
}

有没有办法做到这一点？我已经做了裁判， 但这对我没有帮助

这是我的密码

public boolean onTouch(View v, MotionEvent event) {
    int action = event.getAction();
    Log.d("","OnTouch");
    switch (action) {
    case MotionEvent.ACTION_DOWN:
      downx = event.getX();
      downy = event.getY();
      break;
    case MotionEvent.ACTION_MOVE:
        upx = event.getX();
          upy = event.getY();
          canvas.drawLine(downx, downy, upx, upy, paint);
          drawable.invalidate();
          downx=upx;
          downy=upy;
      break;
    case MotionEvent.ACTION_UP:

      break;
    case MotionEvent.ACTION_CANCEL:
      break;
    default:
      break;

    }
    return true;
  }

请推荐我。我不完全了解这幅油画

---

感谢您的帮助。

请尝试以下方法

public class MainActivity extends Activity {
    private ArrayList<Path> _graphics = new ArrayList<Path>();
    private Paint mPaint;
    float x1, x2, y1, y2;
    boolean isDraw;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new DrawingPanel(this));
        System.out.println(x1 + " " + x2 + " " + y1 + " " + y2);
        mPaint = new Paint();
        mPaint.setDither(true);
        mPaint.setColor(0xFFFFFF00);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeJoin(Paint.Join.ROUND);
        mPaint.setStrokeCap(Paint.Cap.ROUND);
        mPaint.setStrokeWidth(3);

    }

    class DrawingPanel extends SurfaceView implements SurfaceHolder.Callback {
        private DrawingThread _thread;
        private Path path;

        public DrawingPanel(Context context) {
            super(context);
            getHolder().addCallback(this);
            _thread = new DrawingThread(getHolder(), this);
        }

        public boolean onTouchEvent(MotionEvent event) {
            synchronized (_thread.getSurfaceHolder()) {
                if (event.getAction() == MotionEvent.ACTION_DOWN) {
                    path = new Path();
                    x1 = event.getX();
                    y1 = event.getY();
                    path.moveTo(event.getX(), event.getY());
                    path.lineTo(event.getX(), event.getY());
                } else if (event.getAction() == MotionEvent.ACTION_MOVE) {
                    path.lineTo(event.getX(), event.getY());
                } else if (event.getAction() == MotionEvent.ACTION_UP) {
                    x2 = event.getX();
                    y2 = event.getY();
                    path.lineTo(event.getX(), event.getY());
                    _graphics.add(path);
                    isDraw = true;
                }

                return true;
            }
        }

        @Override
        public void onDraw(Canvas canvas) {
            for (Path path : _graphics) {
                // canvas.drawPoint(graphic.x, graphic.y, mPaint);
                canvas.drawPath(path, mPaint);
                if (isDraw) {
                    canvas.drawLine(x1, y1, x2, y2, mPaint);
                    isDraw = false;
                }
            }
        }

        public void surfaceChanged(SurfaceHolder holder, int format, int width,
                int height) {
            // TODO Auto-generated method stub

        }

        public void surfaceCreated(SurfaceHolder holder) {
            // TODO Auto-generated method stub
            _thread.setRunning(true);
            _thread.start();
        }

        public void surfaceDestroyed(SurfaceHolder holder) {
            // TODO Auto-generated method stub
            boolean retry = true;
            _thread.setRunning(false);
            while (retry) {
                try {
                    _thread.join();
                    retry = false;
                } catch (InterruptedException e) {
                    // we will try it again and again...
                }
            }
        }
    }

    class DrawingThread extends Thread {
        private SurfaceHolder _surfaceHolder;
        private DrawingPanel _panel;
        private boolean _run = false;

        public DrawingThread(SurfaceHolder surfaceHolder, DrawingPanel panel) {
            _surfaceHolder = surfaceHolder;
            _panel = panel;
        }

        public void setRunning(boolean run) {
            _run = run;
        }

        public SurfaceHolder getSurfaceHolder() {
            return _surfaceHolder;
        }

        @Override
        public void run() {
            Canvas c;
            while (_run) {
                c = null;
                try {
                    c = _surfaceHolder.lockCanvas(null);
                    synchronized (_surfaceHolder) {
                        _panel.onDraw(c);
                    }
                } finally {
                    // do this in a finally so that if an exception is thrown
                    // during the above, we don't leave the Surface in an
                    // inconsistent state
                    if (c != null) {
                        _surfaceHolder.unlockCanvasAndPost(c);
                    }
                }
            }
        }
    }
}

公共类MainActivity扩展活动{
private ArrayList_graphics=new ArrayList（）；
私人油漆；
浮球x1、x2、y1、y2；
布尔isDraw；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（新绘图面板（本））；
系统输出打印LN（x1+“”+x2+“”+y1+“”+y2）；
mPaint=新油漆（）；
mPaint.setDither（true）；
mPaint.setColor（0xFFFFFF00）；
mPaint.setStyle（油漆、样式、笔划）；
mPaint.setStrokeJoin（油漆.连接.圆形）；
mPaint.setStrokeCap（油漆盖圆形）；
mPaint.设定行程宽度（3）；
}
类DrawingPanel扩展SurfaceView实现SurfaceHolder.Callback{
私有DrawingThread\u线程；
专用路径；
公共绘图面板（上下文）{
超级（上下文）；
getHolder（）.addCallback（此）；
_thread=newdrawingthread（getHolder（），this）；
}
公共布尔onTouchEvent（运动事件）{
已同步（\u thread.getSurfaceHolder（））{
if（event.getAction（）==MotionEvent.ACTION\u向下）{
路径=新路径（）；
x1=event.getX（）；
y1=event.getY（）；
moveTo（event.getX（），event.getY（））；
lineTo（event.getX（），event.getY（））；
}else if（event.getAction（）==MotionEvent.ACTION\u MOVE）{
lineTo（event.getX（），event.getY（））；
}else if（event.getAction（）==MotionEvent.ACTION\u UP）{
x2=event.getX（）；
y2=event.getY（）；
lineTo（event.getX（），event.getY（））；
_添加（路径）；
isDraw=真；
}
返回true；
}
}
@凌驾
公共空白onDraw（画布）{
用于（路径：_图形）{
//画布绘制点（graphic.x、graphic.y、mPaint）；
canvas.drawPath（路径，mPaint）；
如果（isDraw）{
帆布.抽绳（x1，y1，x2，y2，mPaint）；
isDraw=假；
}
}
}
公共无效表面更改（表面文件夹持有者，整型格式，整型宽度，
整数高度）{
//TODO自动生成的方法存根
}
已创建的公共空白表面（表面持有人）{
//TODO自动生成的方法存根
_thread.setRunning（true）；
_thread.start（）；
}
公共空间表面覆盖（表面覆盖物持有人）{
//TODO自动生成的方法存根
布尔重试=真；
_thread.setRunning（false）；
while（重试）{
试一试{
_thread.join（）；
重试=错误；
}捕捉（中断异常e）{
//我们会一次又一次的尝试。。。
}
}
}
}
类DrawingThread扩展线程{
私人表面股东(SurfaceHolder);；
专用绘图面板(U面板),；
私有布尔值_run=false；
公共绘图线程（SurfaceHolder SurfaceHolder、DrawingPanel面板）{
_surfaceHolder=surfaceHolder；
_面板=面板；
}
公共void setRunning（布尔运行）{
_跑=跑；
}
publicssurfaceholder getSurfaceHolder（）{
返回(surfaceHolder);；
}
@凌驾
公开募捐{
帆布c；
while（_run）{
c=零；
试一试{
c=_surfaceHolder.lockCanvas（null）；
已同步（_surfaceHolder）{
_专家组：onDraw（c）；
}
}最后{
//在finally中执行此操作，以便在引发异常时
//在上述过程中，我们不会将曲面保留在
//不一致状态
如果（c！=null）{
_打开CanvasandPost（c）的锁；
}
}
}
}
}
}

我不知道这在地图上是否有效。但这在正常情况下是可行的。就这样试试。我得到了这个编码的以下输出。我希望这对你有帮助

像这样解决

public boolean onTouch(View v, MotionEvent event) {
    int action = event.getAction();
    path = new Path();
    float upX;
    float upY;
    Log.d("", "OnTouch");
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        downx = event.getX();
        downy = event.getY();
        eventX = downx;
        eventY = downy;
        Log.d("", "startx" + eventX);
        break;
    case MotionEvent.ACTION_MOVE:
        upx = event.getX();
        upy = event.getY();
        canvas.drawLine(downx, downy, upx, upy, paint);
        drawable.invalidate();
        downx = upx;
        downy = upy;
        break;
    case MotionEvent.ACTION_UP:
        upX = event.getX();
        upY = event.getY();
        Log.d("", "Action Up");
        Log.d("", "endx" + upX);
        //path.moveTo(eventX, eventY);
        canvas.drawLine(eventX, eventY, upX, upY, paint);
        drawable.invalidate();
        return true;
    case MotionEvent.ACTION_CANCEL:
        break;
    default:
        break;

    }
    return true;
}

---

记住第一个接触点，并手动将其拉回到动作事件中的坐标。谢谢回答。May你的代码正在运行，但我无法跟踪你的代码。我没有时间。我解决了我的问题。无论如何，这对其他人都有帮助+我对你的答案有信心。