Question

我正在尝试制作一个能够捕捉运动检测图像的运动检测器应用程序。它的工作正常＆amp;保存图像。问题是，当我从相机活动按下按钮返回到主页活动时，应用程序崩溃。怎么解决？这是我的代码：

public class MotionDetectionActivity extends SensorsActivity {

private static final String TAG = "MotionDetectionActivity";
private static final String ENABLE_MOTION_DETECTION="switch_md";

private static SurfaceView preview = null;
private static SurfaceHolder previewHolder = null;
private static Camera camera = null;
private static boolean inPreview = false;
private static long mReferenceTime = 0;
private static IMotionDetection detector = null;
public static MediaPlayer song;
public static Vibrator mVibrator;

private static volatile AtomicBoolean processing = new AtomicBoolean(false);
public int  MY_PERMISSIONS_REQUEST_CAMERA;
/**
 * {@inheritDoc}
 */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    setContentView(R.layout.main);

    SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
    boolean enablemotionpref = sharedPref.getBoolean(ENABLE_MOTION_DETECTION, true);


    song = MediaPlayer.create(this, R.raw.sound);
    mVibrator = (Vibrator)this.getSystemService(VIBRATOR_SERVICE);

    preview = (SurfaceView) findViewById(R.id.preview);
    previewHolder = preview.getHolder();
    previewHolder.addCallback(surfaceCallback);
    previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

    if (enablemotionpref) {

        if (Preferences.USE_RGB) {
            detector = new RgbMotionDetection();
        } else if (Preferences.USE_LUMA) {
            detector = new LumaMotionDetection();
        } else {
            // Using State based (aggregate map)
            detector = new AggregateLumaMotionDetection();
        }
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
}

/**
 * {@inheritDoc}
 */
@Override
public void onPause() {
    super.onPause();
    if(song!=null && song.isPlaying())
    {
        song.stop();}

    camera.setPreviewCallback(null);
    if (inPreview) camera.stopPreview();
    inPreview = false;
    camera.release();
    camera = null;
}

/**
 * {@inheritDoc}
 */
@Override
public void onResume() {
    super.onResume();

    camera = Camera.open();
}

private PreviewCallback previewCallback = new PreviewCallback() {

    /**
     * {@inheritDoc}
     */
    @Override
    public void onPreviewFrame(byte[] data, Camera cam) {
        if (data == null) return;
        Camera.Size size = cam.getParameters().getPreviewSize();
        if (size == null) return;

        if (!GlobalData.isPhoneInMotion()) {
            DetectionThread thread = new DetectionThread(data, size.width, size.height);
            thread.start();
        }
    }
};

private SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {

    /**
     * {@inheritDoc}
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        try {
            camera.setPreviewDisplay(previewHolder);
            camera.setPreviewCallback(previewCallback);
        } catch (Throwable t) {
            Log.e("Callback", "Exception in setPreviewDisplay()", t);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        Camera.Parameters parameters = camera.getParameters();
        Camera.Size size = getBestPreviewSize(width, height, parameters);
        if (size != null) {
            parameters.setPreviewSize(size.width, size.height);
            Log.d(TAG, "Using width=" + size.width + " height=" + size.height);
        }
        camera.setParameters(parameters);
        camera.startPreview();
        inPreview = true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // Ignore
    }
};

private static Camera.Size getBestPreviewSize(int width, int height, Camera.Parameters parameters) {
    Camera.Size result = null;

    for (Camera.Size size : parameters.getSupportedPreviewSizes()) {
        if (size.width <= width && size.height <= height) {
            if (result == null) {
                result = size;
            } else {
                int resultArea = result.width * result.height;
                int newArea = size.width * size.height;

                if (newArea > resultArea) result = size;
            }
        }
    }

    return result;
}

private static final class DetectionThread extends Thread {

    private byte[] data;
    private int width;
    private int height;

    public DetectionThread(byte[] data, int width, int height) {
        this.data = data;
        this.width = width;
        this.height = height;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void run() {
        if (!processing.compareAndSet(false, true)) return;

        // Log.d(TAG, "BEGIN PROCESSING...");
        try {
            // Previous frame
            int[] pre = null;
            if (Preferences.SAVE_PREVIOUS) pre = detector.getPrevious();

            // Current frame (with changes)
            // long bConversion = System.currentTimeMillis();
            int[] img = null;
            if (Preferences.USE_RGB) {
                img = ImageProcessing.decodeYUV420SPtoRGB(data, width, height);

                if (img != null && detector.detect(img, width, height))
                {
                    if(song!=null && !song.isPlaying())
                    {
                        song.start();
                        mVibrator.vibrate(50);
                    }
                }
                else
                {
                    if(song!=null && song.isPlaying())
                    {
                        song.pause();

                    }
                }
            }

            // Current frame (without changes)
            int[] org = null;
            if (Preferences.SAVE_ORIGINAL && img != null) org = img.clone();

            if (img != null && detector.detect(img, width, height)) {
                // The delay is necessary to avoid taking a picture while in
                // the
                // middle of taking another. This problem can causes some
                // phones
                // to reboot.
                long now = System.currentTimeMillis();
                if (now > (mReferenceTime + Preferences.PICTURE_DELAY)) {
                    mReferenceTime = now;

                    Bitmap previous = null;
                    if (Preferences.SAVE_PREVIOUS && pre != null) {
                        if (Preferences.USE_RGB) previous = ImageProcessing.rgbToBitmap(pre, width, height);
                        else previous = ImageProcessing.lumaToGreyscale(pre, width, height);
                    }

                    Bitmap original = null;
                    if (Preferences.SAVE_ORIGINAL && org != null) {
                        if (Preferences.USE_RGB) original = ImageProcessing.rgbToBitmap(org, width, height);
                        else original = ImageProcessing.lumaToGreyscale(org, width, height);
                    }

                    Bitmap bitmap = null;
                    if (Preferences.SAVE_CHANGES) {
                        if (Preferences.USE_RGB) bitmap = ImageProcessing.rgbToBitmap(img, width, height);
                        else bitmap = ImageProcessing.lumaToGreyscale(img, width, height);
                    }

                    Log.i(TAG, "Saving.. previous=" + previous + " original=" + original + " bitmap=" + bitmap);
                    Looper.prepare();
                    new SavePhotoTask().execute(previous, original, bitmap);
                } else {
                    Log.i(TAG, "Not taking picture because not enough time has passed since the creation of the Surface");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            processing.set(false);
        }
        // Log.d(TAG, "END PROCESSING...");

        processing.set(false);
    }
};

private static final class SavePhotoTask extends AsyncTask<Bitmap, Integer, Integer> {

    /**
     * {@inheritDoc}
     */
    @Override
    protected Integer doInBackground(Bitmap... data) {
        for (int i = 0; i < data.length; i++) {
            Bitmap bitmap = data[i];
            String name = "MotDet_"+String.valueOf(System.currentTimeMillis());
            if (bitmap != null) createDirectoryAndSaveFile(name, bitmap);
        }
        return 1;
    }

private void createDirectoryAndSaveFile(String name, Bitmap bitmap) {

File folder = new File(Environment.getExternalStorageDirectory() +
        File.separator + "MD");//here you have created different name
boolean success = true;
if (!folder.exists()) {
    success = folder.mkdirs();
}
if (success) {
    // Do something on success

} else {
    // Do something else on failure
}

File photo = new File(folder.getAbsolutePath(), name+ ".jpg"); //use path of above created folder
if (photo.exists()) {
    photo.delete();
}
try {
    FileOutputStream out = new FileOutputStream(photo.getPath());
    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
    out.flush();
    out.close();
} catch (Exception e) {
    e.printStackTrace();
}
}
}
}

HomeActivity

public class HomeActivity extends AppCompatActivity {


@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    setContentView(R.layout.home_layout);



    Button bt1 = (Button) findViewById(R.id.button);
    Button bt2= (Button)findViewById(R.id.button1);
    bt1.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            Intent i = new Intent(view.getContext(), MotionDetectionActivity.class);
            startActivity(i);
        }
    });

    bt2.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View vew) {
            Intent b=new Intent(vew.getContext(),SettingsActivity.class);
            startActivity(b);

        }
    });
}
}

Stacktrace

Answer 1

像这样处理，看看它是否仍然崩溃

   @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        if(camera != null) {
        Camera.Parameters parameters = camera.getParameters();
        Camera.Size size = getBestPreviewSize(width, height, parameters);
        if (size != null) {
            parameters.setPreviewSize(size.width, size.height);
            Log.d(TAG, "Using width=" + size.width + " height=" + size.height);
        }
        camera.setParameters(parameters);
        camera.startPreview();
        inPreview = true;
        }
    }

从相机活动

1 个答案: