Android游戏（暂停屏幕）-致命异常：主

我正在为Android编写一个简单的游戏（见上一篇文章）。我现在想添加一个暂停屏幕，当按下后退按钮时会出现。但现在当我开始一个新游戏时，游戏崩溃了。应用程序启动，菜单屏幕显示没有问题，但当我按下“播放”时，屏幕变黑，应用程序崩溃

这是LogCat所说的：

04-07 09:23:04.759: E/AndroidRuntime(1134): FATAL EXCEPTION: main
04-07 09:23:04.759: E/AndroidRuntime(1134): Process: com.skies.game, PID: 1134
04-07 09:23:04.759: E/AndroidRuntime(1134): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.skies.game/com.skies.game.GameActivity}: java.lang.ClassCastException: com.skies.game.GameActivity cannot be cast to android.content.DialogInterface$OnDismissListener
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2176)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2226)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.ActivityThread.access$700(ActivityThread.java:135)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1397)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.os.Handler.dispatchMessage(Handler.java:102)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.os.Looper.loop(Looper.java:137)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.ActivityThread.main(ActivityThread.java:4998)
04-07 09:23:04.759: E/AndroidRuntime(1134): at java.lang.reflect.Method.invokeNative(Native Method)
04-07 09:23:04.759: E/AndroidRuntime(1134): at java.lang.reflect.Method.invoke(Method.java:515)
04-07 09:23:04.759: E/AndroidRuntime(1134): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:777)
04-07 09:23:04.759: E/AndroidRuntime(1134): at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:593)
04-07 09:23:04.759: E/AndroidRuntime(1134): at dalvik.system.NativeStart.main(Native Method)
04-07 09:23:04.759: E/AndroidRuntime(1134): Caused by: java.lang.ClassCastException: com.skies.game.GameActivity cannot be cast to android.content.DialogInterface$OnDismissListener
04-07 09:23:04.759: E/AndroidRuntime(1134): at com.skies.game.GameActivity.onCreate(GameActivity.java:35)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.Activity.performCreate(Activity.java:5243)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1087)
04-07 09:23:04.759: E/AndroidRuntime(1134): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2140)
04-07 09:23:04.759: E/AndroidRuntime(1134):     ... 11 more

这是我的游戏活动课

import android.os.Bundle;
import android.app.Activity;
import android.app.Dialog;
import android.app.SearchManager.OnDismissListener;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ToggleButton;

public class GameActivity extends Activity implements OnClickListener, OnDismissListener    
{

private GameView theGameView;

private Button resume, menu, exit, newTry, pause;
private ToggleButton vibrationToggle, soundToggle;
private Dialog dialog;

private boolean firstStart = true;
private boolean dialogIsActive = false;

public void onCreate(Bundle savedInstanceState) 
{
    super.onCreate(savedInstanceState);
    theGameView = new GameView(this);
    setContentView(theGameView);  

    dialog = new Dialog(this, android.R.style.Theme_Translucent_NoTitleBar_Fullscreen);
    dialog.setContentView(R.layout.pausescreen);
    dialog.hide(); 
    dialog.setOnDismissListener((android.content.DialogInterface.OnDismissListener) this);
    initialize();
}

public void onGameOver()
{
    compareScore();
    Intent theNextIntent = new Intent (getApplicationContext(), GameOverActivity.class);
    theNextIntent.putExtra("score", theGameView.getScore());
    startActivity(theNextIntent);
    this.finish();
}

public int readHighscore()
{
    SharedPreferences pref = getSharedPreferences("GAME", 0);
    return pref.getInt("HIGHSCORE", 0);
(default)
}

public void writeHighscore(int highscore)
{
    SharedPreferences pref = getSharedPreferences("GAME", 0);
    SharedPreferences.Editor editor = pref.edit();
    editor.putInt("HIGHSCORE", highscore);
    editor.commit(); 
}

public void compareScore()
{
    if(theGameView.getScore() > readHighscore())
    {
        writeHighscore(theGameView.getScore());
    }
}

private void initialize()
{
    resume = (Button) dialog.findViewById(R.id.bContinue);
    menu = (Button) dialog.findViewById(R.id.bMainMenu);
    newTry = (Button) dialog.findViewById(R.id.bNewTry);
    resume.setOnClickListener(this);
    menu.setOnClickListener(this);
    newTry.setOnClickListener(this);
}




public void onClick(View v) {

    switch (v.getId()) 
    {
    case R.id.bContinue:
        dialog.hide();
        dialogState();
        break;
    case R.id.bMainMenu:
        compareScore();
        dialog.dismiss();
        Intent menuIntent = new Intent(getApplicationContext(), MenuActivity.class);
        startActivity(menuIntent);
        finish();
        break;
    case R.id.bNewTry:
        compareScore();
        Intent newGameScreen = new Intent(this, GameActivity.class);
        startActivity(newGameScreen);
        dialog.dismiss();
        finish();
    }

}



protected void onDestroy() {

    super.onDestroy();
}


protected void onPause() { 

    super.onPause();
    theGameView.pauseThread();
    firstStart = false;
}



@Override
protected void onResume() {

    super.onResume();
    if(!firstStart) {
        dialog.show();
        dialogIsActive = true;
    }
}

@Override
public void onBackPressed() {
    dialogState();
}


public void dialogState() {
    if(dialogIsActive) {
        dialog.hide();
        dialogIsActive = false;
        theGameView.resumeThread();
    } else if (!dialogIsActive) {
        theGameView.pauseThread();
        dialog.show();
        dialogIsActive = true;
    }
}

public void onDismiss(DialogInterface dialog) {
    dialogState();
}



@Override
public void onDismiss() {

}
}

这是我的GameView课程：

package com.skies.game;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;


public class GameView extends SurfaceView {
private List<Sprite> spriteList = new ArrayList<Sprite>();
private List<Integer> spriteListNum = new ArrayList<Integer>();
private SurfaceHolder surfaceHolder;
private Bitmap bmp;
private Bitmap livesPicture;
private GameLoopThread theGameLoopThread;
private boolean createSprites = true;
private long lastClick;
private int currentColorNum;
private int lives = 4;
private int score = 0;
private Paint paintRed, paintBlue, paintGreen, paintYellow;
private Paint currentColor; 
private String scoreString;
private String livesString;
private float density;
private GameActivity theGameActivity= new GameActivity();
private Typeface font;
private Paint paint;
private boolean transparency;

public GameView(Context context) {
    super(context);
    paint = new Paint(); 
    font = Typeface.create("Arial", Typeface.NORMAL); 
    livesPicture = BitmapFactory.decodeResource(getResources(),
            R.drawable.lives);
    Random rnd = new Random();
    theGameActivity = (GameActivity) context;
    setColors();
    currentColorNum = rnd.nextInt(4);  
    theGameLoopThread = new GameLoopThread(this);
    surfaceHolder = getHolder();
    surfaceHolder.addCallback(new SurfaceHolder.Callback() {

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

                }
            }

        }

        public void surfaceCreated(SurfaceHolder holder) {
            theGameLoopThread.setRunning(true);
            if(theGameLoopThread.getState() == theGameLoopThread
                    .getState().NEW) {
                theGameLoopThread.start();
            }

        }

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

        }
    });
}

@Override
public void draw(Canvas canvas) {
    canvas.drawColor(Color.DKGRAY);
    if (createSprites == true) {
        initialSprites();
    }
    for (Sprite sprite : spriteList) {
        sprite.draw(canvas);
    }
    if (currentColorNum == 0) 
        drawLines(paintBlue, canvas);
    } else if (currentColorNum == 1) {
        drawLines(paintRed, canvas);
    } else if (currentColorNum == 2) {
        drawLines(paintGreen, canvas);
    } else if (currentColorNum == 3) {
        drawLines(paintYellow, canvas);
    }
    final int fontSize = (int) (25 * density);
    int yTextPos = (int) (25 * density);

    paint.setColor(Color.WHITE);
    paint.setTypeface(font);
    paint.setTextSize(fontSize);
    paint.setAntiAlias(true);  
    scoreString = String.valueOf(score);
    int x = (canvas.getWidth() * 5 / 7);
    final String text = "Score: " + scoreString;
    canvas.drawText(text, x, yTextPos, paint);
    drawLives(canvas, paint);
}

private void createSprite(int index) {
    Bitmap bmp = null;
    switch (index) {
    case 0:
        bmp = BitmapFactory.decodeResource(getResources(),
                R.drawable.alienspriteblue);
        break;
    case 1:
        bmp = BitmapFactory.decodeResource(getResources(),
                R.drawable.alienspritered);
        break;
    case 2:
        bmp = BitmapFactory.decodeResource(getResources(),
                R.drawable.alienspritegreen);
        break;
    case 3:
        bmp = BitmapFactory.decodeResource(getResources(),
                R.drawable.alienspriteyellow);
        break;
    }
    Sprite sprite = new Sprite(this, bmp);
    spriteList.add(sprite);
    spriteListNum.add(index);
}

private void initialSprites() {
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 3; j++)
            createSprite(i);
    }
    createSprites = false;
}

private void rndCreateSprite() {
    Random rnd = new Random(System.currentTimeMillis());
    int i = rnd.nextInt(4);
    createSprite(i);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    if (System.currentTimeMillis() - lastClick > 300) {
        lastClick = System.currentTimeMillis();
        synchronized (getHolder()) {
            for (int i = spriteList.size() - 1; i >= 0; i--) {
                Sprite sprite = spriteList.get(i);

                if (sprite.isTouched(event.getX(), event.getY())) {
                    if (currentColorNum == spriteListNum.get(i)) {
                        score++;
                    }else{
                        lives--;
                        if(lives==0){
                            theGameLoopThread.setRunning(false);
                            theGameActivity.onGameOver();
                        }
                    }
                    if(score==3)
                        lives++;
                    rndCreateSprite();
                    removeSprite(i);
                    changeColor();
                    break;
                }
            }
        }
    }
    return true;
}

private void removeSprite(int index) {
    spriteList.remove(index);
    spriteListNum.remove(index);
}

public void setColors() {
    Paint paintRed = new Paint();
    paintRed.setARGB(255, 236, 27, 36);     
    this.paintRed = paintRed;
    Paint paintBlue = new Paint();
    paintBlue.setARGB(255, 36, 72, 204);
    this.paintBlue = paintBlue;
    Paint paintGreen = new Paint();
    paintGreen.setARGB(255, 34, 177, 76);
    this.paintGreen = paintGreen;
    Paint paintYellow = new Paint();
    paintYellow.setARGB(255, 255, 242, 0);
    this.paintYellow = paintYellow;
}

public void drawLines(Paint lineColor, Canvas canvas) {
    int lineWidth = (int) (10*density);
    int screenHeight = getHeight();
    int screenWidth = getWidth();
    canvas.drawRect(0, 0, lineWidth, getHeight(), lineColor);
    canvas.drawRect(0, getHeight() - lineWidth, screenWidth, screenHeight,
            lineColor);
    canvas.drawRect(screenWidth - lineWidth, 0, screenWidth, screenHeight,
            lineColor);
    currentColor = lineColor;
}

public void changeColor() {
    Random rnd = new Random();
    int index = rnd.nextInt(spriteListNum.size());
    this.currentColorNum = spriteListNum.get(index);
    switch (index) {
    case 0:
        currentColor = paintBlue;
        break;
    case 1:
        currentColor = paintRed;
        break;
    case 2:
        currentColor = paintGreen;
        break;
    case 3:
        currentColor = paintYellow;
        break;
    }

}

public float getDensity() {
    density = getResources().getDisplayMetrics().density;
    return density;
}

private void drawLives(Canvas canvas, Paint paint){
    int xHeart= (int) (15*density);
    int yHeart= (int) (12*density);
    if (lives == 3) {
        canvas.drawBitmap(livesPicture, xHeart,
                yHeart, paint);
        canvas.drawBitmap(livesPicture,
                xHeart + livesPicture.getWidth() + 3*density,
                yHeart, paint);
        canvas.drawBitmap(livesPicture, xHeart + 2
                * livesPicture.getWidth() + 6*density, yHeart, paint);
    }
    if (lives == 2) {
        canvas.drawBitmap(livesPicture, xHeart,
                yHeart, paint);
        canvas.drawBitmap(livesPicture,
                xHeart + livesPicture.getWidth() + 3,
                yHeart, paint);
    }
    if (lives == 1) {
        canvas.drawBitmap(livesPicture, xHeart,
                yHeart, paint);
    }
    if (lives > 3) {
        livesString = String.valueOf(lives);
        final String lives = livesString + "x";
        canvas.drawText(lives, 35 * getDensity(), 30 * getDensity(), paint);
        canvas.drawBitmap(livesPicture, 15 * getDensity() + 2
                * livesPicture.getWidth() + 6, 12 * getDensity(), paint);
    }
}

public int getScore() {

    return this.score;
}

public void pauseThread() {
    theGameLoopThread.setRunning(false);
}

public void resumeThread() {
    theGameLoopThread = new GameLoopThread(this);
    theGameLoopThread.setRunning(true);
    theGameLoopThread.start();
}
}

package com.skies.game；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
导入android.content.Context；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.graphics.Canvas；
导入android.graphics.Color；
导入android.graphics.Paint；
导入android.graphics.Typeface；
导入android.view.MotionEvent；
导入android.view.SurfaceHolder；
导入android.view.SurfaceView；
公共类GameView扩展了SurfaceView{
private List spriteList=new ArrayList（）；
private List spriteListNum=new ArrayList（）；
私人地勤人员地勤人员；
私有位图bmp；
私有位图结构；
私有GameLoopThread GameLoopThread；
私有布尔createSprites=true；
私人长点击；
私有int currentColorNum；
私人生活=4；
私人智力得分=0；
私家漆漆红、漆蓝、漆绿、漆黄；
私人油漆颜色；
私有字符串scoreString；
私有字符串livesString；
私有浮动密度；
私人游戏活动theGameActivity=新游戏活动（）；
专用字体；
私人油漆；
私人透明度；
公共游戏视图（上下文）{
超级（上下文）；
油漆=新油漆（）；
font=Typeface.create（“Arial”，Typeface.NORMAL）；
livesPicture=BitmapFactory.decodeResource（getResources（），
R.drawable.lives）；
随机rnd=新随机（）；
游戏活动=（游戏活动）上下文；
设置颜色（）；
currentColorNum=rnd.nextInt（4）；
theGameLoopThread=新GameLoopThread（此）；
surfaceHolder=getHolder（）；
addCallback（新的surfaceHolder.Callback（）{
公共空间表面覆盖（表面覆盖物持有人）{
布尔重试=真；
gameloopthread.setRunning（false）；
while（重试）{
试一试{
调用gameloopthread.interrupt（）；
GameLoopThread.join（）；
重试=错误；
}捕捉（中断异常e）{
}
}
}
已创建的公共空白表面（表面持有人）{
GameLoopThread.setRunning（true）；
如果（theGameLoopThread.getState（）==theGameLoopThread
.getState（）.NEW）{
gameloopthread.start（）；
}
}
公共无效表面更改（表面文件夹持有者，整数格式，
整数宽度，整数高度）{
}
});
}
@凌驾
公共空白绘制（画布）{
画布。drawColor（颜色：灰色）；
if（createSprites==true）{
初始化精灵（）；
}
用于（精灵精灵：精灵列表）{
绘制（画布）；
}
如果（currentColorNum==0）
抽绳（彩蓝、帆布）；
}else if（currentColorNum==1）{
抽绳（漆红色、帆布）；
}else if（currentColorNum==2）{
抽绳（漆绿色、帆布）；
}else if（currentColorNum==3）{
抽绳（漆黄色、帆布）；
}
最终整数fontSize=（整数）（25*密度）；
int yTextPos=（int）（25*密度）；
油漆。设置颜色（颜色。白色）；
绘画。设置字体（字体）；
油漆。setTextSize（fontSize）；
paint.setAntiAlias（真）；
scoreString=String.valueOf（分数）；
intx=（canvas.getWidth（）*5/7）；
最终字符串text=“分数：”+scoreString；
画布.drawText（文本、x、yTextPos、绘画）；
绘画（帆布、油漆）；
}
私有void createSprite（int索引）{
位图bmp=null；
开关（索引）{
案例0：
bmp=BitmapFactory.decodeResource（getResources（），
R.可拉拔。不可拉拔蓝色）；
打破
案例1：
bmp=BitmapFactory.decodeResource（getResources（），
R.可拉拔。不可分离）；
打破
案例2：
bmp=BitmapFactory.decodeResource（getResources（），
R.可拉拔的阿林斯普利特格林）；
打破
案例3：
bmp=BitmapFactory.decodeResource（getResources（），
R.可拉拔。黄绿色）；
打破
}
精灵精灵=新精灵（此为bmp）；
精灵列表。添加（精灵）；
spriteListNum.add（索引）；
}
私有void initialSprites（）{
对于（int i=0；i<4；i++）{
对于（int j=0；j<3；j++）
createSprite（i）；
}
createSprites=false；
}
私有void rndCreateSprite（）{
Random rnd=新的Random（System.currentTimeMillis（））；
int i=rnd.nextInt（4）；
createSprite（i）；
}
@凌驾
公共布尔onTouchEvent（运动事件）{
如果（System.currentTimeMillis（）-lastClick>300）{
lastClick=System.currentTimeMillis（）；
已同步（getHolder（））{
对于（int i=spriteList.size（）-1；i>=0；i--）{
Sprite-Sprite=spriteList.get（i）；
if（sprite.isTouched（event.getX（），event.getY（））{
if（currentColorNum==spriteListNum.get（i））{
分数++；
}否则{
生命--；
如果（寿命==0）{
gameloopthread.setRunning（false）；
游戏活动。onGameOver（）；
}
}
如果（分数=3）
生活++；
rndCreateSprite（）；
移除斯普林特（i）；
变色（）；
打破
}
}
}
}
返回true；
}
私人无效删除