Android 使用camera类捕获图像

我想使用camera类捕获图像，然后将其显示在曲面视图中。最初，我有一个问题，相机在横向视图中运行，所以我添加了一个方法来设置相机的方向。现在相机工作正常，但拍摄的图像是旋转的

下面是我的代码

public class MainActivity extends AppCompatActivity {

    private ImageView imageResult;
    private CameraPreview cameraView;
    private FrameLayout frameNew;
    private Button snapPhoto;
    boolean takePicture = false;
    private Bitmap image = null;
    private static final String TAG = "MyActivity";


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

        setupCamera();
    }

    public void setupCamera() {
        cameraView = new CameraPreview(getApplicationContext(), this);

        imageResult = new ImageView(getApplicationContext());
        imageResult.setBackgroundColor(Color.GRAY);

        frameNew = (FrameLayout) findViewById(R.id.frame);
        snapPhoto = (Button) findViewById(R.id.capture);

        frameNew.addView(imageResult);
        frameNew.addView(cameraView);
        frameNew.bringChildToFront(imageResult);
    }

    public void captureHandler(View view) {
        if (takePicture) {

            cameraView.capture(jpegHandler);

        } else {
            takePicture = true;
            frameNew.bringChildToFront(cameraView);
            imageResult.setImageBitmap(null);

            snapPhoto.setText("Capture");

        }
    }

    public Camera.PictureCallback jpegHandler = new Camera.PictureCallback() {
        @Override
        public void onPictureTaken(byte[] data, Camera camera) {
            image = BitmapFactory.decodeByteArray(data, 0, data.length);
            imageResult.setImageBitmap(image);
            frameNew.bringChildToFront(imageResult);

            snapPhoto.setText("take a picture");
            takePicture = false;

            File pictureFile = getOuputMediaFile();

            if (pictureFile == null) {
                Log.d(TAG, "Error creating media file ");
                return;
            }
            try {
                FileOutputStream fos = new FileOutputStream(pictureFile);
                fos.write(data);
                fos.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    };

    public File getOuputMediaFile() {
        File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "Divyeshs");

        if (!mediaStorageDir.exists()) {
            Log.d("Divyeshs", "failed to create directory");
            return null;
        }

        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        File mediaFile = new File(mediaStorageDir.getPath() + File.separator + "IMG_" + timeStamp + ".jpg");
        return mediaFile;
    }

}

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback2 {

    private SurfaceHolder mHolder;
    public Camera camera = null;
    Activity activity;
    int camid;

    public CameraPreview(Context context, Activity activity) {
        super(context);
        this.activity = activity;
        mHolder = getHolder();
        mHolder.addCallback(this);
    }

    @Override
    public void surfaceRedrawNeeded(SurfaceHolder holder) {

    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        int camCount;

        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        camCount = Camera.getNumberOfCameras();

        for (int i = 0; i < camCount; i++) {
            Camera.getCameraInfo(i, cameraInfo);
            if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                try {
                    camera = Camera.open(i);
                    camid = i;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        try {
            camera.setPreviewDisplay(mHolder);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

        camera.startPreview();
        CameraPreview.setCameraDisplayOrientation(activity, camid, camera);
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        camera.stopPreview();
        camera = null;
    }

    public void capture(Camera.PictureCallback jpegHandler) {
        camera.takePicture(null, null, jpegHandler);
    }

    public static void setCameraDisplayOrientation(Activity activity, int cameraId, android.hardware.Camera camera) {
        Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
        android.hardware.Camera.getCameraInfo(cameraId, info);
        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
        int degrees = 0;
        switch (rotation) {
            case Surface.ROTATION_0:
                degrees = 0;
                break;
            case Surface.ROTATION_90:
                degrees = 90;
                break;
            case Surface.ROTATION_180:
                degrees = 180;
                break;
            case Surface.ROTATION_270:
                degrees = 270;
                break;
        }

        int result;
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            result = (info.orientation + degrees) % 360;
            result = (360 - result) % 360;  // compensate the mirror
        } else {  // back-facing
            result = (info.orientation - degrees + 360) % 360;
        }
        camera.setDisplayOrientation(result);
    }

}

public类MainActivity扩展了AppCompatActivity{
私有图像查看图像结果；
私人摄像师；
私有框架布局框架新建；
私人按钮快照；
布尔takePicture=false；
私有位图图像=空；
私有静态最终字符串TAG=“MyActivity”；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
设置摄像头（）；
}
公共摄像机（）{
cameraView=新的CameraPreview（getApplicationContext（），this）；
imageResult=新的ImageView（getApplicationContext（））；
imageResult.setBackgroundColor（颜色：灰色）；
frameNew=（FrameLayout）findviewbyd（R.id.frame）；
snapPhoto=（按钮）findViewById（R.id.capture）；
frameNew.addView（imageResult）；
frameNew.addView（cameraView）；
frameNew.bringChildToFront（imageResult）；
}
公共无效captureHandler（视图）{
如果（拍照）{
cameraView.capture（JPEG处理程序）；
}否则{
拍摄照片=真实；
frameNew.bringChildToFront（cameraView）；
imageResult.setImageBitmap（空）；
snapPhoto.setText（“捕获”）；
}
}
public Camera.PictureCallback jpegHandler=新建Camera.PictureCallback（）{
@凌驾
公共void onPictureTaken（字节[]数据，摄像头）{
image=BitmapFactory.decodeByteArray（数据，0，数据.长度）；
设置图像位图（图像）；
frameNew.bringChildToFront（imageResult）；
snapPhoto.setText（“拍照”）；
拍照=假；
File pictureFile=getOutMediaFile（）；
如果（pictureFile==null）{
Log.d（标记“创建媒体文件时出错”）；
返回；
}
试一试{
FileOutputStream fos=新的FileOutputStream（pictureFile）；
写入（数据）；
fos.close（）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
};
公共文件getOutMediaFile（）{
File mediaStorageDir=新文件（Environment.getExternalStoragePublicDirectory（Environment.DIRECTORY_PICTURES），“Divyeshs”）；
如果（！mediaStorageDir.exists（））{
Log.d（“Divyeshs”，“创建目录失败”）；
返回null；
}
字符串时间戳=新的SimpleDateFormat（“yyyyMMdd_HHmmss”）。格式（新日期（）；
File mediaFile=new File（mediaStorageDir.getPath（）+File.separator+“IMG_”+timeStamp+”.jpg”）；
返回媒体文件；
}
}
公共类CameraPreview扩展了SurfaceView实现了SurfaceHolder.Callback2{
私人地勤人员；
公共摄像机=空；
活动；
int camid；
公共CameraPreview（上下文、活动）{
超级（上下文）；
这个。活动=活动；
mHolder=getHolder（）；
mHolder.addCallback（this）；
}
@凌驾
需要使用公共空隙表面浮雕（表面浮雕支架）{
}
@凌驾
已创建的公共空白表面（表面持有人）{
int camCount；
Camera.CameraInfo CameraInfo=新的Camera.CameraInfo（）；
camCount=Camera.getNumberOfCameras（）；
对于（int i=0；i

你真的希望有人会