更新和作品：

1. 去除油漆paintScreen;



2. 在的onDraw不要把 canvas.drawBitmap（位图，0，0，paintScreen）; 或 canvas.drawBitmap（位图， 0，0，paintLine）;

    私人位图位图; //绘图区域显示或保存
   私人帆布bitmapCanvas; //用于绘制位图
   私人涂料paintLine; //用来画线位图上
   私人路径的mpath;
   私人的ArrayList＆LT;路径和GT;路径=新的ArrayList＆LT;路径＆GT;（）;
   私人的ArrayList＆LT;路径和GT; undonePaths =新的ArrayList＆LT;路径＆GT;（）;
   私人浮动MX，我的;
   私有静态最终浮动TOUCH_TOLERANCE = 4;// DoodleView构造函数初始化DoodleView公共DoodleView（上下文的背景下，ATTRS的AttributeSet）
   {
      超（背景下，ATTRS）; //通过上下文来查看的构造
      this.context_new =背景;
      setFocusable（真）;
      setFocusableInTouchMode（真）;   //为画线设置初始显示设置
      paintLine =新的油漆（）;
      paintLine.setAntiAlias​​（真）;画线//边缘光滑
      paintLine.setDither（真）;
      paintLine.setColor（Color.BLACK）; //默认颜色为黑色
      paintLine.setStyle（Paint.Style.STROKE）; // 实线
      paintLine.setStrokeJoin（Paint.Join.ROUND）;
      paintLine.setStrokeWidth（5）; //设置默认线宽
      paintLine.setStrokeCap​​（Paint.Cap.ROUND）; //四舍五入线两端   bitmapCanvas =新的Canvas（）;
      的mpath =新路径（）;
    } //结束DoodleView构造 //的方法OnSizeChanged创建应用程序后显示位图和帆布 @覆盖
    公共无效onSizeChanged（INT W，INT小时，INT oldW，诠释oldH）
    {
       super.onSizeChanged（W，H，oldW，oldH）;
       DoodlzViewWidth = W;
       DoodlzViewHeight = H;
    } @覆盖 保护无效的onDraw（帆布油画）
    {
      对于（路径P：路径）{canvas.drawPath（P，paintLine）;}
      canvas.drawPath（的mpath，paintLine）;
      Log.i（OnDRAWING，达成DRAW）;
   }
    

   //启动触摸：处理触摸事件
        @覆盖

    公共布尔onTouchEvent（MotionEvent事件）
    {
         浮X = event.getX（）;
         浮Y = event.getY（）;      开关（event.getAction（））
         {
             案例MotionEvent.ACTION_DOWN：
                 touch_start（X，Y​​）;
                 无效（）;
                 打破;
             案例MotionEvent.ACTION_MOVE：
                TOUCH_MOVE（X，Y）;
                 无效（）;
                 打破;
             案例MotionEvent.ACTION_UP：
                 润色（）;
                 无效（）;
                 打破;
         }
         返回true;
   } 私人无效touch_start（浮法X，浮法Y）
    {
      undonePaths.clear（）;
      mPath.reset（）;
      mPath.moveTo（X，Y）;
      MX = X;
      我= Y;
   }私人无效TOUCH_MOVE（浮法X，浮法Y）
   {
       浮DX = Math.abs（X  -  MX）;
       浮DY = Math.abs（Y  - 我的）;
       如果（DX＆GT; = || TOUCH_TOLERANCE DY＆GT; = TOUCH_TOLERANCE）
       {
           mPath.quadTo（MX，MY，（X + MX）/ 2，（Y + MY）/ 2）;
           MX = X;
           我= Y;
       }
   }私人无效touch_up（）
   {
       mPath.lineTo（MX，我的）;
       bitmapCanvas.drawPath（的mpath，paintLine）; //提交路径，我们的屏幕外
       paths.add（的mpath）;
       的mpath =新路径（）;
   }公共无效onClickUndo（）
   {
      如果（paths.size（）大于0）
       {
          undonePaths.add（paths.remove（paths.size（） -  1））;
          无效（）;
       }
      其他Toast.makeText（的getContext（），没有更多的撤销，Toast.LENGTH_SHORT）.show（）;
   }
    

I am working on a drawing app but facing some undo problems. The coding is as follows:

public class DoodleView extends View 
{
    Context context_new;

    private static final float TOUCH_TOLERANCE = 5;
    private Bitmap bitmap; // drawing area for display or saving
    private Canvas bitmapCanvas; // used to draw on bitmap
    private Paint paintScreen; // use to draw bitmap onto screen
    private Paint paintLine; // used to draw lines onto bitmap

    private Path mPath; 
    private ArrayList<Path> paths = new ArrayList<Path>();
    private ArrayList<Path> undonePaths = new ArrayList<Path>();
    private float mX, mY;

   // DoodleView constructor initializes the DoodleView
   public DoodleView(Context context, AttributeSet attrs) 
   {
       super(context, attrs); // pass context to View's constructor
       this.context_new=context;

       paintScreen = new Paint(); // used to display bitmap onto screen

       // set the initial display settings for the painted line
       paintLine = new Paint();
       paintLine.setAntiAlias(true); // smooth edges of drawn line
       paintLine.setColor(Color.BLACK); // default color is black
       paintLine.setStyle(Paint.Style.STROKE); // solid line

       mPath = new Path();
       paths.add(mPath);

   } // end DoodleView constructor

OnSizeChanged:

   @Override
   public void onSizeChanged(int w, int h, int oldW, int oldH)
   {
      super.onSizeChanged(w, h, oldW, oldH);
      DoodlzViewWidth = w;     
      DoodlzViewHeight = h;

      bitmap = Bitmap.createBitmap(getWidth(), DoodlzViewHeight, Bitmap.Config.ARGB_8888);

      bitmapCanvas = new Canvas(bitmap);
      bitmap.eraseColor(Color.WHITE); // erase the BitMap with white 
   } 

onDraw:

   @Override
   protected void onDraw(Canvas canvas)  
   {
       canvas.drawBitmap(bitmap, 0, 0, paintScreen); 
       // for each path currently being drawn
       for (Path p : paths){canvas.drawPath(p, paintLine);}                
   } 

onTouchEvent:

   @Override
   public boolean onTouchEvent(MotionEvent event) 
   {          
          float x = event.getX();
          float y = event.getY();

          switch (event.getAction())
          {
              case MotionEvent.ACTION_DOWN:
                  touchStarted(x, y);
                  invalidate();
                  break;
              case MotionEvent.ACTION_MOVE:
                  touchMoved(x, y);
                  invalidate();
                  break;
              case MotionEvent.ACTION_UP:
                  touchEnded();
                  invalidate();
                  break;
          }
          return true;
    }

touchStarted:

   private void touchStarted(float x, float y) 
   {
       mPath.reset();
       mPath.moveTo(x, y);
       mX = x;
       mY = y;
   }

touchMoved:

   private void touchMoved(float x, float y) 
   {
       float dx = Math.abs(x - mX);
       float dy = Math.abs(y - mY);
       if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) 
       {
           mPath.quadTo(mX, mY, (x + mX)/2, (y + mY)/2);
           mX = x;
           mY = y;               
       }
   }

touchEnded:

   private void touchEnded() 
   {
      mPath.lineTo(mX, mY);      
      bitmapCanvas.drawPath(mPath, paintLine);
      mPath = new Path();
      paths.add(mPath);
      Toast.makeText(getContext(), "touchEnded" + paths.size(), Toast.LENGTH_SHORT).show();
   }

Undo:

public void onClickUndo() 
{ 
   Toast.makeText(getContext(), "before undo button pressed " + paths.size(), Toast.LENGTH_SHORT).show();  
   if (paths.size()>0) 
    { 
       undonePaths.add(paths.remove(paths.size()-1));
       Toast.makeText(getContext(), "after undo button pressed " + paths.size(), Toast.LENGTH_SHORT).show();
       Log.i("UNDOING", "PREPARE INVALIDATE");
       invalidate();
       Log.i("UNDOING", "FINISH INVALIDATE");
    }      
   else Toast.makeText(getContext(), "nothing to undo" + paths.size(), Toast.LENGTH_SHORT).show();  
}

Question:

The above is sourced from other examples searched online. Dont know why need to set path.reset() when implementing touchStarted?

Q1. When I press the undo the button, it would properly show the toast undo button pressed, and reporting the path.size() being 0, and hence the immediately previously drawn line is not removed. I really dont know why it is 0?? Isnt it added to the path array already? How could the code be modified?

** code modified after taking android-developer's advice! Thanks!! It now correctly showing path.size(). Sorry for the silly missing out!* But the previous line drawn is still cannot be removed? =(

Q2. While the app is functioning properly when the finger is moving on the screen and showing the line immediately, When I press the undo the button, in addition to the above that previous line is not removed, the lines further draw to the screen after pressing the button will not show out until the finger is lifted.

answer to Q2: moving the below 2 lines from touchEnded() to touchStarted()

mPath = new Path();
paths.add(mPath);

.

   private void touchStarted(float x, float y) 
   {
       mPath.reset();
       mPath = new Path();
       paths.add(mPath);
       mPath.moveTo(x, y);
       mX = x;
       mY = y;
   }

   private void touchEnded() 
   {
       mPath.lineTo(mX, mY);      
       bitmapCanvas.drawPath(mPath, paintLine);// commit the path to our offscreen                   
       Toast.makeText(getContext(), "touchEnded" + paths.size(), Toast.LENGTH_SHORT).show();
   }

Thanks!!!

updated and works:

1. removed Paint paintScreen;

2. in onDraw do not put canvas.drawBitmap(bitmap, 0, 0, paintScreen); or canvas.drawBitmap(bitmap, 0, 0, paintLine);

   private Bitmap bitmap; // drawing area for display or saving
   private Canvas bitmapCanvas; // used to draw on bitmap
   private Paint paintLine; // used to draw lines onto bitmap   
   private Path mPath; 
   private ArrayList<Path> paths = new ArrayList<Path>();
   private ArrayList<Path> undonePaths = new ArrayList<Path>();
   private float mX, mY;
   private static final float TOUCH_TOLERANCE = 4;    
   
   // DoodleView constructor initializes the DoodleView
   
   public DoodleView(Context context, AttributeSet attrs) 
   {
      super(context, attrs); // pass context to View's constructor
      this.context_new=context;
      setFocusable(true);
      setFocusableInTouchMode(true);      
   
      // set the initial display settings for the painted line
      paintLine = new Paint();
      paintLine.setAntiAlias(true); // smooth edges of drawn line
      paintLine.setDither(true);
      paintLine.setColor(Color.BLACK); // default color is black
      paintLine.setStyle(Paint.Style.STROKE); // solid line
      paintLine.setStrokeJoin(Paint.Join.ROUND);
      paintLine.setStrokeWidth(5); // set the default line width
      paintLine.setStrokeCap(Paint.Cap.ROUND); // rounded line ends
   
      bitmapCanvas = new Canvas();
      mPath = new Path();            
    } // end DoodleView constructor
   
    // Method onSizeChanged creates BitMap and Canvas after app displays
   
    @Override
    public void onSizeChanged(int w, int h, int oldW, int oldH)
    {
       super.onSizeChanged(w, h, oldW, oldH);
       DoodlzViewWidth = w;       
       DoodlzViewHeight = h;           
    } 
   
    @Override
   
    protected void onDraw(Canvas canvas) 
    {         
      for (Path p : paths){canvas.drawPath(p, paintLine);}  
      canvas.drawPath(mPath, paintLine);
      Log.i("OnDRAWING", "REACH ON DRAW");        
   } 
   

   // START TOUCH: handle touch event @Override

    public boolean onTouchEvent(MotionEvent event) 
    {            
         float x = event.getX();
         float y = event.getY();
   
         switch (event.getAction())
         {
             case MotionEvent.ACTION_DOWN:
                 touch_start(x, y);
                 invalidate();
                 break;
             case MotionEvent.ACTION_MOVE:
                touch_move(x, y);
                 invalidate();
                 break;
             case MotionEvent.ACTION_UP:
                 touch_up();
                 invalidate();
                 break;
         }
         return true;
   }
   
    private void touch_start(float x, float y) 
    {
      undonePaths.clear();
      mPath.reset();
      mPath.moveTo(x, y);
      mX = x;
      mY = y;
   }
   
   private void touch_move(float x, float y) 
   {
       float dx = Math.abs(x - mX);
       float dy = Math.abs(y - mY);
       if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) 
       {
           mPath.quadTo(mX, mY, (x + mX)/2, (y + mY)/2);
           mX = x;
           mY = y;
       }
   }  
   
   private void touch_up() 
   {
       mPath.lineTo(mX, mY);      
       bitmapCanvas.drawPath(mPath, paintLine);// commit the path to our offscreen  
       paths.add(mPath);
       mPath = new Path(); 
   }
   
   public void onClickUndo() 
   { 
      if (paths.size()>0) 
       { 
          undonePaths.add(paths.remove(paths.size()-1));
          invalidate();
       }      
      else Toast.makeText(getContext(), "nothing more to undo", Toast.LENGTH_SHORT).show();  
   }