6

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

我不知道我做错了什么，但我对 Treadding 不太熟悉，这与我的 android 设备有多少内核或类似的东西有关吗？

我的代码如下所示，所以我只使用了一个启动线程，它使用一个链接到动画线程的布局文件，该动画线程启动一个线程并每秒在画布上绘制一个圆圈。（您可以忽略 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) {
            }
        }
    }
}
4

2 回答 2

4

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

是的，这就是它的工作原理。它称为双缓冲，每次都需要重绘所有帧：

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

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

而且你不应该Thread.sleep(1000)在画布被锁定时打电话，这会导致饥饿问题。

于 2012-10-15T13:27:22.550 回答
0

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

您在没有事先调用 canvas.save() 的情况下调用了 canvas.restore()。来自 Canvas 的 Android 开发人员参考：“调用 restore() 的次数多于调用 save() 的次数是错误的。”

在您的情况下，我看不出有任何理由让您调用 canvas.save()，因此您应该删除对 canvas.restore() 的调用。

于 2013-05-03T06:16:38.347 回答