如何使用单独的线程部分重绘自定义 SurfaceView 而不会丢失以前的编辑？

我目前在按照自定义绘图时遇到问题SurfaceView来自不在我的主 UI 上的线程。这SurfaceView占据整个屏幕（Galaxy S3 全屏）并且必须从多个来源进行更新。

问题是习惯SurfaceView不会保存 UI 更新之间的更改。

习俗SurfaceView类是在使用它的活动和线程（我们称之为DrawingThread）运行定期检查更新是在自定义中定义的SurfaceView班级。我做了类似的事情本教程 http://danielnadeau.blogspot.com/2012/01/android-canvas-beginners-tutorial.html.

另一个外部线程正在更新必须对 UI 进行的更改列表。DrawingThread每 50 毫秒左右检查一次此列表，如果列表不为空，则计算必须重绘的矩形。

// Thread waits for change request to UI or kill order
// Build Rect at point of Touch
try {
    Canvas = _surfaceHolder.lockCanvas(Rect); 
    synchronized (_surfaceHolder) {
        postInvalidate(); //Calls custom SurfaceView's onDraw() with the correct Canvas
    }
} finally {
    if (Canvas != null) {
        _surfaceHolder.unlockCanvasAndPost(Canvas);
    }
}
// Loop

My onDraw()定制方法SurfaceView在下面：

@Override
public void onDraw(Canvas canvas) {
    // Initialize vars for rectangle
    Paint.setStyle(Style.FILL);

    for (MapChanges change : ExternalClass.getMapChanges()) {
        // Build Rect at point of Touch
        // Select Color for Paint   
        canvas.drawRect(Rect, Paint);
        ExternalClass.removeMapChange(change); //Thread safe
    }
}

除了忘记之前的任何更改之外，它的工作完美无缺onDraw()称呼。我目前正在使用OnTouchListener.

据我理解，代码流程：

• Touch 将对 UI 的更改请求添加到列表中ExternalClass.
• DrawingThread看到列表不再为空，安全地抓取 Canvas，并且postInvalidates()调用自定义SurfaceView's onDraw().
• onDraw()更新 UI 并从中删除更改请求ExternalClass.
• DrawingThread发布Canvas然后继续等待。

我的预期行为是，通过连续触摸，我会在屏幕上积累点。相反，每次触摸都会清除屏幕，只留下背景和我上次触摸屏幕的一个点。

我发现这非常令人困惑lockCanvas(Rect)特别提到它将通过指定“脏”部分来保存锁之间的更改。谷歌搜索让我相信大多数用户发现了相反的问题：他们想要View重绘，但每次更新都必须手动重绘。

为什么程序画得很干净SurfaceView尽管我指定了要重绘的“脏”部分，但每次 UI 更新还是从头开始？

毫无疑问有人会提到我这个之前回答过的问题 https://stackoverflow.com/questions/2949036/android-how-to-get-a-custom-view-to-redraw-partially建议程序员使用位图。我试图避免这种情况，因为我对此很陌生，并且我不想使用大量内存（更新 UI 只是我代码的一小部分）。直接在平面上处理简单的形状View对我来说是理想的。此外，它是作为一种解决方法提出的。这是 Android API 中的缺陷吗？

已经在这里和谷歌搜索了几个小时了。希望我没有错过任何明显的事情。

我设法找到了解决方法OnDraw()出等式。新的DrawingPanel below:

class DrawingPanel extends SurfaceView implements Runnable, SurfaceHolder.Callback {

    Thread thread = null;
    SurfaceHolder surfaceHolder;
    volatile boolean running = false;

    private Paint myPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    Random random;

    public DrawingPanel(Context context) {
        super(context);
        getHolder().addCallback(this);

        surfaceHolder = getHolder();
    }

    @Override 
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
        int height) { 


    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {          
        setWillNotDraw(false); //Allows us to use invalidate() to call onDraw()

        if (!running) {
            running = true;
            thread = new Thread(this);
            thread.start();
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        try {
            running = false;    //Tells thread to stop
            thread.join();      //Removes thread from mem.
        } catch (InterruptedException e) {}
    }   

    @Override
    public void run() {
        Canvas canvas;
        Rect myRect = new Rect();
        boolean firstRun = true;

        ChangeRequest ChangeReq;

        myPaint.setStyle(Style.FILL);

        while(running) {
            try {
                Thread.sleep(50);
            } catch (Exception e) {}

            canvas = null;

            ChangeReq = getUIChangeRequests();

            if (!ChangeReq.isEmpty() || (firstRun)) {                   
                if(surfaceHolder.getSurface().isValid()) {
                    if (!firstRun) {  

                        // Calculate dirty space for editing
                        x = ChangeReq.getX();
                        y = ChangeReq.getY();

                        try {
                            myRect.set(x*RectSize, y*RectSize, x*RectSize + RectSize, y*RectSize + RectSize);
                            myPaint.setColor(Color.RED);

                            canvas = surfaceHolder.lockCanvas(myRect);

                            synchronized (surfaceHolder) {
                                // Draw
                                canvas.drawRect(myRect, myPaint);

                            }

                            // Remove ChangeRequest
                            ChangeReq.remove();

                        } finally {
                            if (canvas != null) {
                                surfaceHolder.unlockCanvasAndPost(canvas);
                            }
                        }
                    } else {
                        try {
                            // Initialize canvas as all one color
                            myRect.set(0, 0, getWidth(), getHeight());
                            myPaint.setColor(Color.DKGRAY);

                            canvas = surfaceHolder.lockCanvas();

                            synchronized (surfaceHolder) {
                                //Draw
                                canvas.drawRect(myRect, myPaint); 
                            }

                            firstRun = false;
                        } finally {
                            if (canvas != null) {
                                surfaceHolder.unlockCanvasAndPost(canvas);
                            }
                        }
                    }
                }
            }
        }
    }   
}

这解决了我的绘图问题，但提出了一个有趣的问题：为什么我必须使用surfaceHolder.lockCanvas();只有这样我才能使用surfaceHolder.lockCanvas(Rect);我会在另一个问题中问这个问题。