Question

我正在尝试使用线程在画布上绘图来创建一个简单的游戏引擎，但我有一些我无法解释的奇怪问题。这个“游戏”的目的是在画布上每秒画一个圆圈。这是有效的，但不是我希望它的工作方式，似乎应用程序在两个画布之间切换并为每个画布添加一个圆圈，这样你就可以每秒在两个画布之间切换相同数量的圆圈但在不同的地方在画布上。

我不知道我做错了什么，但我对Treadding并不熟悉，是否与我的Android设备有多少核心或类似内容有关？

我的代码如下所示，所以我只使用一个launchthread，它使用一个链接到animationthread的layoutfile，它启动一个线程并在画布上每秒画一个圆圈。（你可以忽略touchevent，它还没有使用）。

该项目存在于主要发布线之外：

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

使用此布局文件：

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">     
        <com.androidtesting.AnimationView
            android:id="@+id/aview"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"/>
</FrameLayout>

我的Surfaceview类有一个内部Thread类：

class AnimationView extends SurfaceView implements SurfaceHolder.Callback {
    private boolean touched = false;
    private float touched_x, touched_y = 0;
    private Paint paint;
    private Canvas c;
    private Random random;
    private AnimationThread thread;

    public AnimationView(Context context, AttributeSet attrs) {
        super(context, attrs);

        SurfaceHolder holder = getHolder();
        holder.addCallback(this);

        thread = new AnimationThread(holder);
    }

    class AnimationThread extends Thread {
        private boolean mRun;       
        private SurfaceHolder mSurfaceHolder;        

        public AnimationThread(SurfaceHolder surfaceHolder) {
            mSurfaceHolder = surfaceHolder;
            paint = new Paint();
            paint.setARGB(255,255,255,255);
            paint.setTextSize(32);
        }

        @Override
        public void run() {
            while (mRun) {
                c = null;
                try {
                    c = mSurfaceHolder.lockCanvas(null);
                    synchronized (mSurfaceHolder) {                 
                        doDraw(c);
                        sleep(1000);
                    }
                } catch (Exception e) {                 
                    e.printStackTrace();
                }finally {
                    if (c != null) {
                        mSurfaceHolder.unlockCanvasAndPost(c);
                    }
                }
            }
        }

        private void doDraw(Canvas canvas) {
            //clear the canvas
            //canvas.drawColor(Color.BLACK);                        

            random = new Random();
            int w = canvas.getWidth();
            int h = canvas.getHeight();
            int x = random.nextInt(w-50); 
            int y = random.nextInt(h-50);
            int r = random.nextInt(255);
            int g = random.nextInt(255);
            int b = random.nextInt(255);
            int size = 20;
            canvas.drawCircle(x,y,size,paint);            
            canvas.restore();
        }
        public void setRunning(boolean b) {
            mRun = b;
        }
    }

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

    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
           touched_x = event.getX();
           touched_y = event.getY();

           int action = event.getAction();

           switch(action){
                case MotionEvent.ACTION_DOWN:           
                    touched = true;
                    break;
                case MotionEvent.ACTION_MOVE:
                    touched = true;
                    break;        
                default:
                    touched = false;
                    break;
           }

           return true;
    }

    public void surfaceCreated(SurfaceHolder holder) {
        thread.setRunning(true);
        thread.start();
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        boolean retry = true;
        thread.setRunning(false);
        while (retry) {
            try {
                thread.join();
                retry = false;
            } catch (InterruptedException e) {
            }
        }
    }
}

Answer 1

似乎应用程序正在两个画布之间切换

是的，这是它的工作原理。它被称为双缓冲，您需要重绘所有帧each time：

在unlockCanvas（）和lockCanvas（）之间永远不会保留Surface的内容，因此，必须写入Surface区域中的每个像素。

因此，您需要在代码中取消注释此行canvas.drawColor(Color.BLACK)。

当画布被锁定时，您不应该调用Thread.sleep(1000)，这会导致starvation问题。

Answer 2

听起来你有这个工作，但我只是注意到一个小错误，我应该指出。

你没有事先调用canvas.save（）而调用canvas.restore（）。来自Canvas的Android开发者参考：“调用restore（）是比调用save（）更多次的错误。”

我认为没有理由在你的情况下调用canvas.save（），因此你应该删除对canvas.restore（）的调用。

带有线程的Android SurfaceView画布

2 个答案: