Android SurfaceView摄像头预览代码在棒棒糖制作前运行良好，但在棒棒糖设备上崩溃

我实现了一个定制的SurfaceView来绘制相机预览，并对其进行了所有的捕获和手动对焦操作。它在Lolipop之前的设备上运行得很好，但问题是它在Lolipop设备上崩溃了。 发生的最奇怪的事情是，应用程序抛出一个ANR，当我单击“确定”时，应用程序从我离开它的那一点开始运行。
LogCat显示“未能连接到相机错误，跳过ANR后，我可以轻松连接甚至操作我的相机”。是因为我使用了不推荐的CameraAPI，而不是Camera2和棒棒糖设备吗

我的代码是这样的：

public class CameraPreview
implements
SurfaceHolder.Callback {
private int cameratype=Camera.CameraInfo.CAMERA_FACING_BACK;
private Camera mCamera = null;
public Camera.Parameters params;
private SurfaceHolder sHolder;
private String TAG="CameraPreview";
public List<Camera.Size> supportedSizes;

public int isCamOpen = 0;
public boolean isSizeSupported = false;
private int previewWidth, previewHeight;
private List<String> mSupportedFlashModes;
private boolean flashon=false;
private final static String MYTAG = "CameraPreview";
private ProgressDialog loading;

public CameraPreview(int width, int height) {
    Log.i("campreview", "Width = " + String.valueOf(width));
    Log.i("campreview", "Height = " + String.valueOf(height));
    previewWidth = width;
    previewHeight = height;
}

private int openCamera() {
    if (isCamOpen == 1) {
        releaseCamera();
    }

    mCamera = Camera.open(cameratype);

    if (mCamera == null) {
        return -1;
    }

    if (TouchActivity.reference.getResources().getConfiguration().orientation != Configuration.ORIENTATION_LANDSCAPE) {
        mCamera.setDisplayOrientation(90);
    } else {
        mCamera.setDisplayOrientation(0);
    }

    params = mCamera.getParameters();
    params.setPreviewSize(previewWidth, previewHeight);

    try {
        mCamera.setParameters(params);
    } catch (RuntimeException e) {
        e.printStackTrace();
    }

    mCamera.startPreview();
    try {
        mCamera.setPreviewDisplay(sHolder);
    } catch (IOException e) {
        mCamera.release();
        mCamera = null;
        return -1;
    }
    isCamOpen = 1;
    return isCamOpen;
}
public int isCamOpen() {
    return isCamOpen;
}

public void releaseCamera() {
    if (mCamera != null) {
        mCamera.stopPreview();
        mCamera.setPreviewCallback(null);
        mCamera.release();
        mCamera = null;
    }
    isCamOpen = 0;
}

@Override
public void surfaceCreated(SurfaceHolder holder) {
    sHolder = holder;
    isCamOpen = openCamera();
}

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

}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {

    releaseCamera();

}

/**
 * Called from PreviewSurfaceView to set touch focus.
 * 
 * @param - Rect - new area for auto focus
 */
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public void doTouchFocus(final Rect tfocusRect) {
    Log.i(TAG, "TouchFocus");
    try {
        final List<Camera.Area> focusList = new ArrayList<Camera.Area>();
        Camera.Area focusArea = new Camera.Area(tfocusRect, 1000);
        focusList.add(focusArea);

        Camera.Parameters para = mCamera.getParameters();
        para.setFocusAreas(focusList);
        para.setMeteringAreas(focusList);
        mCamera.setParameters(para);

        mCamera.autoFocus(myAutoFocusCallback);
    } catch (Exception e) {
        e.printStackTrace();
        Log.i(TAG, "Unable to autofocus");
    }

}

/**
 * AutoFocus callback
 */
AutoFocusCallback myAutoFocusCallback = new AutoFocusCallback(){

      @Override
      public void onAutoFocus(boolean arg0, Camera arg1) {
       if (arg0){
        mCamera.cancelAutoFocus();      
       }
    }
};




public void capturePicture(){
    mCamera.takePicture(null, null, mPicture);


}

private File getOutputMediaFile(){

    File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(
            Environment.DIRECTORY_PICTURES), "UltimateCameraGuideApp");

    if (! mediaStorageDir.exists()){
        if (! mediaStorageDir.mkdirs()){
            Log.d("Camera Guide", "Required media storage does not exist");
            return null;
        }
    }

    // Create a media file name
    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
    File mediaFile;
    mediaFile = new File(mediaStorageDir.getPath() + File.separator +
            "IMG_"+ timeStamp + ".jpg");

    //DialogHelper.showDialog("Success!", "Your picture has been saved!", TouchActivity.reference.getActivity());

    return mediaFile;
}

private Camera.PictureCallback mPicture = new Camera.PictureCallback() {

    @Override
    public void onPictureTaken(byte[] data, Camera camera) {

        //This One is Just for Getting a File Named after it
         loading=new ProgressDialog(BaseImagesContainer.reference);
        loading.setMessage("Getting Image Ready");
        loading.show();
        File pictureFile =getOutputMediaFile();
        if (pictureFile == null){
            Toast.makeText(TouchActivity.reference.getActivity(), "Image retrieval failed.", Toast.LENGTH_SHORT)
                    .show();
            return;
        }
        Bitmap bmp = BitmapFactory.decodeByteArray(data, 0, data.length);
        if(cameratype==Camera.CameraInfo.CAMERA_FACING_BACK){
            bmp=rotateImage(90,bmp);
        }else{
            bmp=rotateImage(270,bmp);

        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        bmp.compress(Bitmap.CompressFormat.PNG,1, stream);
        byte[] flippedImageByteArray = stream.toByteArray();
        try {
            FileOutputStream fos = new FileOutputStream(pictureFile);
            fos.write(flippedImageByteArray);
            fos.close();
            // Restart the camera preview.
            //safeCameraOpenInView(mCameraView);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        Uri destination = Uri.fromFile(new File(TouchActivity.reference.getActivity().getCacheDir(), "cropped"));
        Uri source = Uri.fromFile(new File(pictureFile.getPath()));
        Crop.of(source, destination).withMaxSize(800,800).start(TouchActivity.reference.getActivity());
    }
};


public Bitmap rotateImage(int angle, Bitmap bitmapSrc) {
    Matrix matrix = new Matrix();
    matrix.postRotate(angle);
    return Bitmap.createBitmap(bitmapSrc, 0, 0,
            bitmapSrc.getWidth(), bitmapSrc.getHeight(), matrix, true);
}


public void switchCamera(){

    mCamera.stopPreview();
    //NB: if you don't release the current camera before switching, you app will crash
    mCamera.release();

    //swap the id of the camera to be used
    if(cameratype==Camera.CameraInfo.CAMERA_FACING_BACK){
        cameratype=Camera.CameraInfo.CAMERA_FACING_FRONT;
    }else{
        cameratype=Camera.CameraInfo.CAMERA_FACING_BACK;
    }
    try{
        mCamera = Camera.open(cameratype);
    }catch (Exception e){
        e.printStackTrace();
        Toast.makeText(TouchActivity.reference.getActivity(),"Can't Open the Camera",Toast.LENGTH_LONG).show();
    }

    if (TouchActivity.reference.getResources().getConfiguration().orientation != Configuration.ORIENTATION_LANDSCAPE) {

        mCamera.setDisplayOrientation(90);

    } else {

        mCamera.setDisplayOrientation(0);

    }

    try{
        mCamera.setPreviewDisplay(sHolder);
        mCamera.startPreview();
    }
    catch(Exception e){
        e.printStackTrace();
    }

}

public void switchflash(){
    //Do the On Flash for now
    if(!flashon){
        mSupportedFlashModes = mCamera.getParameters().getSupportedFlashModes();
        if (mSupportedFlashModes != null && mSupportedFlashModes.contains(Camera.Parameters.FLASH_MODE_AUTO)){
            Camera.Parameters parameters = mCamera.getParameters();
            parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
            mCamera.setParameters(parameters);
        }
    }else{
        //flash on
        //do teh off now
        Camera.Parameters parameters = mCamera.getParameters();
        parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
        mCamera.setParameters(parameters);
    }
    flashon=!flashon;

}

public void stopLoading(){
    loading.dismiss();
    //DialogHelper.showDialog("Oops!", "Your crop had been cancelled !", TouchActivity.reference.getActivity());

}

public类CameraPreview
工具
SurfaceHolder，回拨{
private int cameratype=Camera.CameraInfo.Camera\u面朝后；
专用摄像机mCamera=null；
公共摄像机。参数参数；
私人地面商；
私有字符串TAG=“CameraPreview”；
支持的公共列表大小；
public int isCamOpen=0；
支持的公共布尔值=false；
私有int previewWidth，PreviewWight；
私有列表MSSupportedFlashModes；
私有布尔flashon=false；
私有最终静态字符串MYTAG=“CameraPreview”；
私有对话框加载；
公共CameraPreview（整数宽度、整数高度）{
Log.i（“campreview”，“Width=“+String.valueOf（Width））；
Log.i（“campreview”，“Height=“+String.valueOf（Height））；
预览宽度=宽度；
视力=高度；
}
私有int openCamera（）{
如果（isCamOpen==1）{
松开摄像头（）；
}
mCamera=Camera.open（cameratype）；
if（mCamera==null）{
返回-1；
}
if（TouchActivity.reference.getResources（）.getConfiguration（）.orientation！=Configuration.orientation\u横向）{
mCamera.setDisplayOrientation（90）；
}否则{
mCamera.setDisplayOrientation（0）；
}
params=mCamera.getParameters（）；
参数设置PreviewSize（previewWidth、PreviewWight）；
试一试{
mCamera.setParameters（参数）；
}捕获（运行时异常e）{
e、 printStackTrace（）；
}
mCamera.startPreview（）；
试一试{
mCamera.setPreviewDisplay（sHolder）；
}捕获（IOE异常）{
mCamera.release（）；
mCamera=null；
返回-1；
}
isCamOpen=1；
返回isCamOpen；
}
public int isCamOpen（）{
返回isCamOpen；
}
公共无效释放摄影机（）{
if（mCamera！=null）{
mCamera.stopPreview（）；
mCamera.setPreviewCallback（null）；
mCamera.release（）；
mCamera=null；
}
isCamOpen=0；
}
@凌驾
已创建的公共空白表面（表面持有人）{
支架=支架；
isCamOpen=openCamera（）；
}
@凌驾
公共无效表面更改（表面文件夹持有者，整型格式，整型宽度，
整数高度）{
}
@凌驾
公共空间表面覆盖（表面覆盖物持有人）{
松开摄像头（）；
}
/**
*从PreviewSurfaceView调用以设置触摸焦点。
* 
*@param-Rect-自动对焦的新区域
*/
@TargetApi（构建版本代码冰淇淋三明治）
公共无效doTouchFocus（最终Rect TFOCURECT）{
Log.i（标签“TouchFocus”）；
试一试{
最终列表焦点列表=新的ArrayList（）；
摄像头区域焦距面积=新摄像头区域（tfocusRect，1000）；
focusList.add（focusrea）；
Camera.Parameters para=mCamera.getParameters（）；
第2.2段（焦点列表）；
第2段设置计量区域（焦点列表）；
mCamera.setParameters（第2段）；
自动对焦（myAutoFocusCallback）；
}捕获（例外e）{
e、 printStackTrace（）；
Log.i（标记“无法自动对焦”）；
}
}
/**
*自动对焦回调
*/
AutoFocusCallback myAutoFocusCallback=新的AutoFocusCallback（）{
@凌驾
自动对焦上的公共空白（布尔值arg0，相机arg1）{
如果（arg0）{
mCamera.cancelAutoFocus（）；
}
}
};
公共无效捕获图片（）{
takePicture（null，null，mPicture）；
}
私有文件getOutputMediaFile（）{
File mediaStorageDir=新文件（Environment.getExternalStoragePublicDirectory(
环境。目录（图片），“UltimateCameraGuideApp”）；
如果（！mediaStorageDir.exists（））{
如果（！mediaStorageDir.mkdirs（））{
Log.d（“摄像机指南”，“所需媒体存储不存在”）；
返回null；
}
}
//创建媒体文件名
字符串时间戳=新的SimpleDateFormat（“yyyyMMdd_HHmmss”）。格式（新日期（）；
文件媒体文件；
mediaFile=新文件（mediaStorageDir.getPath（）+File.separator+
“IMG_”+时间戳+”.jpg”）；
//DialogHelper.showDialog（“成功！”，“您的图片已保存！”，TouchActivity.reference.getActivity（））；
返回媒体文件；
}
private Camera.PictureCallback mPicture=新建Camera.PictureCallback（）{
@凌驾
公共void onPictureTaken（字节[]数据，摄像头）{
//这只是为了得到一个以它命名的文件
加载=新建进度对话框（BaseImagesContainer.reference）；
正在加载.setMessage（“正在准备图像”）；
loading.show（）；
File pictureFile=getOutputMediaFile（）；
如果（pictureFile==null）{
Toast.makeText（TouchActivity.reference.getActivity（），“图像检索失败”，Toast.LENGTH\u SHORT）
.show（）；
返回；
}
位图bmp=BitmapFactory.decodeByteArray（数据，0，数据.长度）；
if（cameratype==Camera.CameraInfo.Camera\u面朝后）{
bmp=旋转图像（90，bmp）；
}否则{
bmp=旋转图像（270，bmp）；
}
ByteArrayOutputStream=新建ByteArrayOutputStream（）；
压缩（Bitmap.CompressFormat.PNG，1，流）；
字节[]flippedImageByteArray=stream.toByteArray（）；
试一试{
FileOutputStream fos=新的FileOutputStream（pictureFile）；
fos.write（flippedImageByteArray）；
fos.close（）；
//重新启动相机预览。