Android 使用surfaceView中的onTouchEvent暂停后重新启动应用程序

大家好，我是Android编程新手，我一直在看一个关于Android游戏编程的节目，问题是这个特定的课程在期中结束了，所以游戏还没有结束，所以我尝试自己添加一些东西。就在我开始新的旅程时，我遇到了一个自己无法解决的问题，所以如果有人能帮我解决，我会在这里尝试

问题是游戏的视觉部分，我有一个surfaceView和一个event onTouchEvent。问题出现在我暂停游戏时（方法onPause from The activity），发生了surfaceHolder被破坏（来自方法surfaceDestroyed），但为了不陷入麻烦，我必须停止更新游戏的线程（GameLoopThread）。当游戏取消暂停时，它调用onResume 方法创建一个新的surfaceFolder并初始化GameLoopeThread线程

我遇到的问题是，在调用onResume（）方法并重新初始化所有内容后，surfaceView中的onTouchEvent事件停止工作，因此单击它不工作，过了一段时间，我收到一条消息，说应用程序没有响应，我可以在等待（什么都没有发生）之间进行选择或者强制关闭应用程序

我把surfaceView中的代码留给你（有些东西现在已经不需要了，有些东西已经被注释了以供试用）

package net.balanze.tutorialjuego；
导入java.util.ArrayList；
导入java.util.List；
导入android.content.Context；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.graphics.Canvas；
导入android.graphics.Color；
导入android.graphics.Paint；
导入android.graphics.Typeface；
导入android.media.AudioManager；
导入android.media.SoundPool；
导入android.view.MotionEvent；
导入android.view.SurfaceHolder；
导入android.view.SurfaceHolder.Callback；
导入android.view.SurfaceView；
/*
*请参阅音频与ToneGenerator、MediaPlayer y SoundPool。
*/
公共类GameView扩展了SurfaceView{
私人土地持有人；
私有GameLoopThread GameLoopThread；
私有列表精灵=新的ArrayList（）；
私人长点击；
私家血；
private List temps=new ArrayList（）；
私有int puntos=0；
私人油漆；
/*
*最大限度地利用16个模拟流体
*el audio sera del flujo音乐剧（el ultimo Parametero no
*功能是一个电话号码（电话号码）和一个电话号码（电话号码）。
*/
私有声音池sndPool=新声音池（16，AudioManager.STREAM_MUSIC，0）；
索尼多马洛私人酒店；
/*私有整数x=0；
私有int xSpeed=1*/
公共游戏视图（上下文）{
超级（上下文）；
gameLoopThread=新gameLoopThread（此）；
holder=getHolder（）；
holder.addCallback（新回调（）{
@凌驾
公共空间表面覆盖（表面覆盖物持有人）{
gameLoopThread.setRunning（false）；
布尔意图=真；
虽然（打算）{
试一试{
gameLoopThread.join（）；
}捕捉（中断异常e）{
//e.printStackTrace（）；
System.out.println（“错误-->Problema al-destruir la view.”）；
}
意图=错误；
}
//gameLoopThread=null；
}
@凌驾
已创建的公共空白表面（表面持有人）{
createSprites（）；
/*
*这是一个非常有趣的故事
*在卡达的恩皮耶萨酒店
*阿尔托和安科·德拉科尼西塔莫斯雪碧酒店
*pantalla和si no se acabo de crear la view no conocemos
*sus维度。
*/
gameLoopThread=（！gameLoopThread.isAlive（））？新gameLoopThread（devolveVista（））：gameLoopThread；
如果（！gameLoopThread.isRunning（））{
gameLoopThread.setRunning（true）；
gameLoopThread.start（）；
}
}
@凌驾
公共无效表面更改（表面文件夹持有者，整型格式，整型宽度，
整数高度）{
//TODO自动生成的方法存根
}
});
bmpBlood=BitmapFactory.decodeResource（getResources（），R.drawable.blood1）；
sonidoMalo=sndPool.load（上下文，R.raw.baddeath，1）；
油漆=新油漆（）；
setARGB（255,255,0,0）；
油漆.尺寸（30）；
油漆.设置字体（字体.无衬线）；
}
/**
*私有void createSprites（）

*Añade A al数组列表精灵todos los sprites que veremos
*恩潘塔拉

*/
私有void createSprites（）{
//艾尔·格拉菲科·奎雷莫斯·平塔庄园。
add（createSprite（R.drawable.bad1，false））；
add（createSprite（R.drawable.bad2，false））；
add（createSprite（R.drawable.bad3，false））；
add（createSprite（R.drawable.bad4，false））；
add（createSprite（R.drawable.bad5，false））；
添加（createSprite（R.drawable.bad6，false））；
添加（createSprite（R.drawable.good1，true））；
添加（createSprite（R.drawable.good2，true））；
添加（createSprite（R.drawable.good3，true））；
添加（createSprite（R.drawable.good4，true））；
添加（createSprite（R.drawable.good5，true））；
添加（createSprite（R.drawable.good6，true））；
}
/**
*私有Sprite createSprite（int资源）

*

*@param Resource Recurso de imagen que queremos pintar en el Sprite。
*@return Sprite creador con imagen pasada。
*/
私有Sprite createSprite（int资源，布尔esBueno）{
位图bmp=BitmapFactory.decodeResource（getResources（），Resource）；
返回新精灵（此、bmp、esBueno）；
}
@凌驾
受保护的void onDraw（画布）{
画布。drawColor（颜色。黑色）；
canvas.drawText（“Puntuacion:+puntos，0,30，paint”）；
对于（int i=临时大小（）
package net.balanze.tutorialjuego;
import java.util.ArrayList;
import java.util.List;
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.media.AudioManager;
import android.media.SoundPool;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;
/*
* See audio with ToneGenerator, MediaPlayer y SoundPool.
*/
public class GameView extends SurfaceView {

private SurfaceHolder holder; 
private GameLoopThread gameLoopThread; 
private List<Sprite> sprites=new ArrayList<Sprite>(); 
private long lastClick; 
private Bitmap bmpBlood; 
private List<TempSprite> temps = new ArrayList<TempSprite>(); 
private int puntos=0;
private Paint paint;
/*
 * iniciamos sndPool con un maximo de 16 flujos simultanios
 * el audio sera del flujo musical, (el ultimo parametro no
 * funciona asi que pongo 0 que es el conversor por defecto).
 */
private SoundPool sndPool = new SoundPool(16, AudioManager.STREAM_MUSIC, 0);
private int sonidoMalo;
/*private int x=0; 
private int xSpeed=1;*/

public GameView(Context context) {
    super(context);
    gameLoopThread = new GameLoopThread(this);
    holder = getHolder();
    holder.addCallback(new Callback() {

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            gameLoopThread.setRunning(false);
            boolean intento=true;
            while(intento){
                try {
                    gameLoopThread.join();
                } catch (InterruptedException e) {
                    // e.printStackTrace();
                    System.out.println("ERROR --> Problema al destruir la view.");
                }
                intento=false;
            }
            //gameLoopThread=null;
        }

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
             createSprites();
            /*
             * La asignacion de los Sprites se hace aqui ya que 
             * para calcular las posiciones en las que empieza cada
             * sprite necesitamos conocer el alto y el ancho de la 
             * pantalla y si no se acabo de crear la view no conocemos
             * sus dimensiones. 
             */
             gameLoopThread=(!gameLoopThread.isAlive())?new GameLoopThread(devolverVista()):gameLoopThread;
            if(!gameLoopThread.isRunning()){
                gameLoopThread.setRunning(true);
                gameLoopThread.start();
            }
        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width,
                int height) {
            // TODO Auto-generated method stub

        }
    });
    bmpBlood = BitmapFactory.decodeResource(getResources(), R.drawable.blood1);
    sonidoMalo=sndPool.load(context, R.raw.baddeath, 1);
    paint=new Paint();
    paint.setARGB(255, 255, 0, 0);
    paint.setTextSize(30);
    paint.setTypeface(Typeface.SANS_SERIF);
}
/**
 * <p><b>private void createSprites()</b></p>
 * <p>Añade a al array list sprites todos los sprites que veremos
 * en pantalla.</p>
 */
private void createSprites(){
    // establecemos el grafico que queremos pintar.
    sprites.add(createSprite(R.drawable.bad1, false));
    sprites.add(createSprite(R.drawable.bad2, false));
    sprites.add(createSprite(R.drawable.bad3, false));
    sprites.add(createSprite(R.drawable.bad4, false));
    sprites.add(createSprite(R.drawable.bad5, false));
    sprites.add(createSprite(R.drawable.bad6, false));
    sprites.add(createSprite(R.drawable.good1, true));
    sprites.add(createSprite(R.drawable.good2, true));
    sprites.add(createSprite(R.drawable.good3, true));
    sprites.add(createSprite(R.drawable.good4, true));
    sprites.add(createSprite(R.drawable.good5, true));
    sprites.add(createSprite(R.drawable.good6, true));
}
/**
 * <p><b>private Sprite createSprite(int Resource)</b></p>
 * <p>Devuelve un sprite con la imagen que se le pasa como recurso.</p>
 * @param Resource Recurso de imagen que queremos pintar en el Sprite.
 * @return Sprite creador con imagen pasada.
 */
private Sprite createSprite(int Resource, boolean esBueno){
    Bitmap bmp = BitmapFactory.decodeResource(getResources(), Resource);
    return new Sprite(this, bmp, esBueno);
}

@Override
protected void onDraw(Canvas canvas){
    canvas.drawColor(Color.BLACK);
    canvas.drawText("Puntuacion: "+puntos, 0, 30, paint);
    for(int i=temps.size()-1; i>=0; i--) temps.get(i).onDraw(canvas);
    for(Sprite sprite:sprites){
        sprite.onDraw(canvas);
    }
}

@Override
public boolean onTouchEvent(MotionEvent event){
     if(System.currentTimeMillis()-lastClick>300){
        lastClick=System.currentTimeMillis();
        synchronized (getHolder()) {
            float x = event.getX();
            float y = event.getY();
            for(int i=sprites.size()-1; i>=0; i--){
                Sprite sprite=sprites.get(i);
                if(sprite.isColision(x, y)){
                    if(!sprite.esBueno()) sndPool.play(sonidoMalo, 1.0f, 1.0f, 5, 0, 1.0f);
                    puntos+=sprite.puntuar();
                    sprites.remove(sprite);
                    temps.add(new TempSprite(temps, this, x, y, bmpBlood));
                    break;
                }
            }
        }
    }
    //return true;
    return super.onTouchEvent(event);
}
/**
 * <p><b>public boolean quedanMalos()</b><P>
 * <p>Devuelve verdadero si quedan sprites de enemigos y falso en caso contrario.</p>
 * @return true si quedan enemigos, false si solo quedan sprites buenos.
 */
public boolean quedanMalos(){
    boolean soloBuenos=true;
    for(int i=0; i<sprites.size() && soloBuenos; i++)     soloBuenos=sprites.get(i).esBueno();
    return !soloBuenos;        
}
/**
 * <p><b>public void pause()</b></p>
 * <p>Pausa el juego, porque pausa el gameLoop.</p>
 */
public void pause(){
    gameLoopThread.setRunning(false);
    boolean intento=true;
    //synchronized (gameLoopThread) {
        while(intento){
            try{
                gameLoopThread.join();
            }catch (InterruptedException e) {
                //e.printStackTrace();
                System.out.println("ERROR --> No se pudo para el gameLoop.");
            }
            intento=false;
        }
    //}
    gameLoopThread=null;
}
public void resume(){
    if(holder.isCreating()){
        gameLoopThread=(!gameLoopThread.isAlive())?new GameLoopThread(this):gameLoopThread;
        if(!gameLoopThread.isRunning()){
            gameLoopThread.setRunning(true);
            gameLoopThread.start();
        }
    }
}
private GameView devolverVista(){
    return this;
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    return thread.doTouchEvent(event);
}

boolean doTouchEvent(MotionEvent event) {
        synchronized (mSurfaceHolder) 
        {
               (detect ondown etc, do something and return true/false)
            }
       }

@Override
public boolean dispatchTouchEvent(MotionEvent event) {

    /*touchTime = System.currentTimeMillis();       
    if (oldTouchAction == -1)
    {
        lastTouchTime = touchTime;
        oldTouchAction = (event.getAction() & MotionEvent.ACTION_MASK);

        super.dispatchTouchEvent(event);

        try {
            Thread.sleep(32);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       return true;
    }
    else
    {           
        if (oldTouchAction == (event.getAction() & MotionEvent.ACTION_MASK))
        {
            if ((touchTime - lastTouchTime) > 35)
            {
                lastTouchTime = touchTime;

                super.dispatchTouchEvent(event);

                return true;
            }
            lastTouchTime = touchTime;
        }
        else
        {
            lastTouchTime = touchTime;
            super.dispatchTouchEvent(event);

           return true;
        }
    }       
    lastTouchTime = touchTime;*/
    if (touchBool)
    {
        super.dispatchTouchEvent(event);
        try {
            Thread.sleep(32);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    return true;
}