Get closed canvas shape in android

Question

I am trying to draw a shape on the map in android. If the user draws a closed path, its fine. If the User draws a open path, then how do I close the path to make it look better?

Please see the image,

Here I have drew an open path.

As soon as the onTouch action is ACTION_UP, it the path should get closed by itself,

like this,

Is there any way to do this? I have refereed this, How to draw a closed curved shape? , but it didn't help me.

This is my code,

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;
  }

Please suggest me. I am not completely aware of this canvas drawing.

Any help is appreciated.

Answer 1

Try the following way.

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);
                    }
                }
            }
        }
    }
}

I don't know whether this will work on map or not. But this will work on normal view. Just try this way. I got the following output for this coding. I hope this will help you.

Answer 2

Solved like this,

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;
}