Android Can'；t在工程视图中执行撤消/重做操作

我想在绘图应用程序中执行撤消/重做操作，但它仍然不起作用

我知道关于这个主题有很多线索，但我尝试了很多。因此，请不要将此线程标记为重复线程。

以下是执行绘图的代码：

public class Drawing extends View {
    private Path mPath;
    private static Canvas canvas;
    public static Paint mPaint;
    private static Paint mBitmapPaint;
    public static Bitmap mBitmap;
    private BlurMaskFilter mBlur;
    private MaskFilter mEmboss;

    public static String drawKreis;
    public static int radius;
    public static String kreisFarbe;
    public static String hintergrundFarbe;

    private int paintColor = 0xFF660000;

    private float mX, mY;
    private static final float TOUCH_TOLERANCE = 4;
    public static String strichFarbeHex;

    public static int stroke = 12;
    /*
     * ArrayList<Pair<Path, Paint>> paths = new ArrayList<Pair<Path, Paint>>();
     * 
     * ArrayList<Pair<Path, Paint>> undonePaths = new ArrayList<Pair<Path, Paint>>();
     * 
     * // ArrayList<Pair<Rect, Paint>> rectPaths = new ArrayList<Pair<Rect, Paint>>();
     */

    public ArrayList<Path> paths = new ArrayList<Path>();
    public ArrayList<Paint> paints = new ArrayList<Paint>();
    public ArrayList<Path> undonePaths = new ArrayList<Path>();
    public ArrayList<Paint> undonePaints = new ArrayList<Paint>();

    // private Map<Path, Integer> colorsMap = new HashMap<Path, Integer>();

    public Drawing(final Context context, AttributeSet attrs) {

        super(context, attrs);

        mPaint = new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setDither(true);
        mPaint.setStrokeWidth(stroke);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(paintColor);
        mPath = new Path();

        mPaint.setXfermode(null);

        mBitmapPaint = new Paint(Paint.DITHER_FLAG);

        // paths.add(new Pair<Path, Paint>(mPath, mPaint));

        this.setDrawingCacheEnabled(true);

        mEmboss = new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);

        mBlur = new BlurMaskFilter(8, BlurMaskFilter.Blur.NORMAL);

        this.setOnTouchListener(new OnTouchListener() {

            public boolean onTouch(View v, MotionEvent event) {
                float x = event.getX();
                float y = event.getY();
                Log.d("onTouch", "onTouch");
                Log.d("x", String.valueOf(x));
                Log.d("y", String.valueOf(y));

                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        Log.d("a", "down");
                        Log.d("hier", "hier1");
                        touch_start(x, y, context);
                        invalidate();
                        break;
                    case MotionEvent.ACTION_MOVE:
                        Log.d("onTouch", "onTouch2");
                        touch_move(x, y);
                        invalidate();
                        break;
                    case MotionEvent.ACTION_UP:
                        Log.d("onTouch", "onTouch3");
                        touch_up();
                        invalidate();
                        break;
                }
                return true;
            }
        });
    }

    // mBlur = new BlurMaskFilter(8, BlurMaskFilter.Blur.NORMAL);

    private void touch_start(float x, float y, Context context) {
        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);
        // commit the path to our offscreen
        canvas.drawPath(mPath, mPaint);

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

    }

    public static int getStroke() {
        return stroke;

    }

    @Override
    public void onDraw(Canvas c) {

        int strichdicke = OpenProject.getStrichdicke();
        int durchsichtigkeitswert = OpenProject.getDurchsichtigkeit() * 255 / 100;

        Log.d("strichdicke", "strichdicke " + strichdicke);

        for (/* Pair<Path, Paint> p */Path p : paths) {

            if (strichdicke == 0) {
                mPaint.setStrokeWidth(stroke);
            } else {
                mPaint.setStrokeWidth(strichdicke);
            }
            mPaint.setAlpha(durchsichtigkeitswert);

            c.drawPath(p, mPaint);

        }

        c.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
        c.drawPath(mPath, mPaint);

    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        mBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
        canvas = new Canvas(mBitmap);

        if (hintergrundFarbe != null) {
            mBitmap.eraseColor(Color.parseColor(hintergrundFarbe));

        } else {
            mBitmap.eraseColor(Color.WHITE);
        }

    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        // wenn die Zurücktaste das erste Mal gedrückt wurde
        if (keyCode == KeyEvent.KEYCODE_BACK) {

        }
        return true;
    }

    public void onClickUndo() {
        Log.d("onClickUndo5", "onClickUndo5 " + paths.size());
        if (paths.size() > 0) {
            Log.d("onClickUndo", "onClickUndo " + paths.size());
            undonePaths.add(this.paths.remove(this.paths.size() - 1));
            clearCanvasCache();
            this.invalidate();
            Log.d("onClickUndo1", "onClickUndo1 " + paths.size());
        } else {

        }
    }

    public static String setStrichFarbe(String strichFarbe) {

        strichFarbeHex = strichFarbe;
        Log.d("strichFarbeHex", "strichFarbeHex " + strichFarbeHex);
        return strichFarbeHex;
    }

    // update color
    public void setColor(String newColor) {
        Log.d("setColor", "setColor " + newColor);
        invalidate();
        paintColor = Color.parseColor(newColor);
        Log.d("paintColor", "paintColor " + paintColor);
        mPaint.setColor(paintColor);
        int color = mPaint.getColor();
        Log.d("color", "color " + color);
    }

    public void drawKreis(Drawing drawing) {
        invalidate();
        drawing.canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);

        drawing.canvas.drawCircle(30, 30, 5, mPaint);
        invalidate();
        Log.d("drawKreis", "drawKreis " + canvas + "|" + mPaint.getColor());
    }

    public static void erase() {
        // mBitmapPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
        mBitmap.eraseColor(Color.TRANSPARENT);
        canvas = new Canvas(mBitmap);

    }

    public static void startErasing() {
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
    }

    public String getStrichFarbe() {
        return strichFarbeHex;
    }

    public void clearCanvasCache() {

        mBitmap = Bitmap.createBitmap((int) 400, (int) 400, Bitmap.Config.ARGB_8888);
        canvas = new Canvas(mBitmap);
    }

}

公共类图形扩展视图{
专用路径mPath；
私有静态画布；
公共静电涂料；
私人静电涂料；
公共静态位图mBitmap；
私人模糊过滤器mBlur；
私人MaskFilter mEmboss；
公共静态字符串drawKreis；
公共静态int半径；
公共静态字符串kreisFarbe；
公共静态字符串hinterGrundArbe；
私有int paintColor=0xFF660000；
私人浮动mX，我的；
专用静态最终浮动接触公差=4；
公共静态字符串strichFarbeHex；
公共静态int冲程=12；
/*
*ArrayList路径=新的ArrayList（）；
* 
*ArrayList undonePaths=新建ArrayList（）；
* 
*//ArrayList rectPaths=new ArrayList（）；
*/
公共ArrayList路径=新建ArrayList（）；
public ArrayList paints=new ArrayList（）；
public ArrayList undonePaths=new ArrayList（）；
public ArrayList undonePaints=new ArrayList（）；
//私有映射colorsMap=newhashmap（）；
公共绘图（最终上下文，属性集属性）{
超级（上下文，attrs）；
mPaint=新油漆（）；
mPaint.setAntiAlias（true）；
mPaint.setDither（true）；
mPaint.设置行程宽度（行程）；
mPaint.setStyle（油漆、样式、笔划）；
mPaint.setColor（paintColor）；
mPath=新路径（）；
mPaint.setXfermode（null）；
mBitmapPaint=新油漆（油漆抖动标志）；
//添加（新对（mPath，mpain））；
此.setDrawingCacheEnabled（true）；
mEmboss=新的浮雕maskfilter（新的float[]{1,1,1}，0.4f,6,3.5f）；
mBlur=新的模糊过滤器（8，BlurMaskFilter.Blur.NORMAL）；
this.setOnTouchListener（新的OnTouchListener（）{
公共布尔onTouch（视图v，运动事件）{
float x=event.getX（）；
float y=event.getY（）；
Log.d（“onTouch”、“onTouch”）；
Log.d（“x”，String.valueOf（x））；
Log.d（“y”，String.valueOf（y））；
开关（event.getAction（））{
case MotionEvent.ACTION\u DOWN：
对数d（“a”、“向下”）；
日志d（“hier”、“hier1”）；
触摸启动（x、y、上下文）；
使无效（）；
打破
case MotionEvent.ACTION\u移动：
Log.d（“onTouch”、“onTouch2”）；
触摸移动（x，y）；
使无效（）；
打破
case MotionEvent.ACTION\u UP：
Log.d（“onTouch”、“onTouch3”）；
润色；
使无效（）；
打破
}
返回true；
}
});
}
//mBlur=新的模糊过滤器（8，BlurMaskFilter.Blur.NORMAL）；
私有void touch_start（浮点x、浮点y、上下文）{
撤销海王星。清除（）；
mPath.reset（）；
移动到（x，y）的速度；
mX=x；
mY=y；
}
私有无效触摸移动（浮动x、浮动y）{
float dx=Math.abs（x-mX）；
float dy=Math.abs（y-mY）；
如果（dx>=接触公差| | dy>=接触公差）{
兆帕四分之一秒（mX，mY，（x+mX）/2，（y+mY）/2）；
mX=x；
mY=y；
}
}
私人空间修补（）{
mPath.lineTo（mX，mY）；
//将路径提交到我们的屏幕外
画布绘制路径（mPath，mPaint）；
路径。添加（mPath）；
mPath=新路径（）；
}
公共静态int getStroke（）{
回击；
}
@凌驾
公共空白onDraw（画布c）{
int strichdick=OpenProject.getstrichdick（）；
int durchichstigkeitswert=OpenProject.getdurchichstigkeit（）*255/100；
Log.d（“strichdick”、“strichdick”+strichdick）；
对于（/*对p*/路径p:路径）{
if（strichdick==0）{
mPaint.设置行程宽度（行程）；
}否则{
mPaint.设定行程宽度（行程）；
}
mPaint.setAlpha（Durchichtigkeitswert）；
c、 绘制路径（p，mPaint）；
}
c、 drawBitmap（mBitmap、0、0、MbitMapPoint）；
c、 绘图路径（mPath，mPaint）；
}
@凌驾
已更改尺寸的受保护空心（整数w、整数h、整数oldw、整数oldh）{
super.onSizeChanged（w，h，oldw，oldh）；
mBitmap=Bitmap.createBitmap（w，h，Bitmap.Config.ARGB_8888）；
画布=新画布（mBitmap）；
if（hintergrundFarbe！=null）{
mBitmap.eraseColor（Color.parseColor（hintergrundFarbe））；
}否则{
mBitmap.橡皮擦颜色（颜色.白色）；
}
}
@凌驾
公共布尔onKeyDown（int-keyCode，KeyEvent事件）{
//这是一个非常有趣的故事
if（keyCode==KeyEvent.keyCode\u BACK）{
}
返回true；
}
公共void onClickUndo（）{
Log.d（“onClickUndo5”、“onClickUndo5”+path.size（））；
if（path.size（）>0）{
Log.d（“onClickUndo”，“onClickUndo”+path.size（））；
undonePaths.add（this.paths.remove（this.paths.size（）-1））；
clearCanvasCache（）；
这个。使无效（）；
Log.d（“onClickUndo1”、“onClickUndo1”+path.size（））；
}否则{
}
}
公共静态字符串setStrichArbe（字符串StrichArbe）{
StrichArbehex=StrichArbe；
Log.d（“strichFarbeHex”、“strichFarbeHex”+strichFarbeHex）；
返回strichFarbeHex；
}
//更新颜色
公共void setColor（字符串newC