Android:启动结果的新活动时无响应线程

Question

我是Android的新手，所以我正在制作一个涂色书应用程序，只是为了让自己熟悉Android编程。我已经广泛地查找了我的问题并实施了解决方案，但仍然没有进展。

我有一个活动“着色活动”，它调用了一个扩展表面视图的类“绘画视图”。我试图在一个单独的线程中更新画布。我在布局中也有一个按钮，将用户带到另一个活动中选择颜色。问题是，当html" target="_blank">用户选择颜色后返回时，画布变成空的，我不能再在画布上画画了。我想我不知何故在活动之间松动了线程，虽然线程在后台运行，但我无法访问它。

我在这个论坛上读到，我必须在线程类中实现pause（）和resume（）方法，基本上在我转到另一个活动时杀死线程，并在我返回时重新启动它。我还读到，我必须重写活动类中的onPause（）和onResume（）方法，并在onResume（）中构造surfaceview，以便每次用户返回该活动时都构造它。

如果这没有多大意义，我很抱歉，因为我也迷路了。

我的“着色活动”：

package com.ali.coloryourself;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Toast;

public class ColoringActivity extends Activity {

private static final int COLOR_REQUEST_CODE = 100;
public static String file;
public static Bitmap bitmap;
BitmapFactory.Options options;
PaintView paintView;

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

    Intent intent = getIntent();
    file = intent.getStringExtra("fileName");

//      paintView = (PaintView) findViewById(R.id.drawingSurface);


}

@Override
protected void onResume() {
    paintView = (PaintView) findViewById(R.id.drawingSurface);
    paintView.getThread().resume();
    super.onResume();
}

@Override
protected void onPause() {
    paintView.getThread().pause();
    super.onPause();
}

public void pickColor(View v) {
    paintView.getThread().pause();
    Intent colorIntent = new Intent(this, ColorPickerActivity.class);
    startActivityForResult(colorIntent, COLOR_REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (resultCode != RESULT_CANCELED) {
        if (requestCode == COLOR_REQUEST_CODE) {
            int color = data.getIntExtra("Color", -1);
//              paintView.getPaint().setColor(color);
        }
    }

}

}

我的'PaintView'类：

package com.ali.coloryourself;

import android.R.color;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

class PaintView extends SurfaceView implements SurfaceHolder.Callback {
private Paint paint = new Paint();
private Canvas canvas;
private PaintThread thread;
private Path path = new Path();

private Bitmap bitmap;

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

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

    paint.setColor(Color.WHITE);
    paint.setStyle(Paint.Style.STROKE);
    paint.setStrokeJoin(Paint.Join.ROUND);
    paint.setStrokeCap(Paint.Cap.ROUND);
    paint.setStrokeWidth(3);

    setThread(new PaintThread(holder));
}

class PaintThread extends Thread {
    private boolean mRun;
    private SurfaceHolder mSurfaceHolder;
    private int mMode;

    public static final int STATE_PAUSE = 2;
    public static final int STATE_RUNNING = 4;

    public PaintThread(SurfaceHolder surfaceHolder) {
        mSurfaceHolder = surfaceHolder;
    }

    @Override
    public void run() {
        while (mRun) {
            try {
                canvas = mSurfaceHolder.lockCanvas(null);
                if (mMode == STATE_RUNNING) {
                    if (bitmap == null) {
                        bitmap = Bitmap.createBitmap(1, 1,
                                Bitmap.Config.ARGB_8888);
                    }
                }
                doDraw(canvas);
                canvas.drawBitmap(bitmap, 0, 0, null);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (canvas != null) {
                    mSurfaceHolder.unlockCanvasAndPost(canvas);
                }
            }
        }
    }

    private void doDraw(Canvas canvas) {
        canvas.drawPath(path, paint);
    }

    public void setRunning(boolean b) {
        mRun = b;
    }

    public void pause() {
            if (mMode == STATE_RUNNING)
                setState(STATE_PAUSE);
    }

    public void resume() {
        setState(STATE_RUNNING);
    }

    public void setState(int mode) {
        synchronized (mSurfaceHolder) {
            mMode = mode;
        }
    }
}

public void surfaceChanged(SurfaceHolder holder, int format, int width,
        int height) {
    bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    // Log.d("Touch", "I am touching");
    float eventX = event.getX();
    float eventY = event.getY();

    int action = event.getAction();

    switch (action) {
    case MotionEvent.ACTION_DOWN:
        path.moveTo(eventX, eventY);
        return true;
    case MotionEvent.ACTION_MOVE:
        path.lineTo(eventX, eventY);
        break;
    case MotionEvent.ACTION_UP:
        // nothing to do
        break;
    default:
        return false;
    }
    return true;
}

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

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

public Paint getPaint() {
    return paint;
}

public void setPaint(int color) {
    this.paint.setColor(color);
}

public PaintThread getThread() {
    return thread;
}

public void setThread(PaintThread thread) {
    this.thread = thread;
}

}

我的“activity_draw.xml”

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >

 <Button
    android:id="@+id/button1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    android:layout_marginTop="10dp"
    android:onClick="pickColor"
    android:text="Pick Color" />

<com.ali.coloryourself.PaintView
    android:id="@+id/drawingSurface"
    android:layout_width="match_parent"
    android:layout_height="match_parent" 
    android:layout_below="@+id/button1"
    android:layout_marginTop="10dp"/>

</RelativeLayout>

我知道我缺少一些非常基本的线程概念。我需要允许用户选择颜色并返回并能够继续绘制。我将非常感谢您的帮助。

Answer 1

我想我已经找到了一个答案，尽管我不确定这是否是一种好的编程实践。我发现我的表面视图和线程是在创建“着色活动”后创建的，每次“着色活动”进入背景时都会销毁。但是，一旦重新启动并恢复了“着色活动”，就不会重新创建曲面视图和线程。所以我移动了以下行

setContentView(R.layout.activity_draw);

到onResume（）方法，现在我每次都可以在画布上绘制。现在，我只需要保存画布，并在活动重新启动时重新加载它，以开始用户留下的颜色。