Camera2 同时打开两个摄像头Demo讲解

背景       

        首先要指出，虽然强大的谷歌已经兼容了同时打开两个物理相机的场景，但并不是所有机器都具备这样的功能，这个还跟平台有这紧密的关系，这里面可能是ISP的处理能力的关系，本人目前参与做了qcom、MTK、sprd平台的相机开发，但是只有高通支持这样的功能，原因就在于使用的高通平台拥有两个强大的ISP处理器，服服服。。。

同时打开多个摄像头谷歌在官网中已经描述了原理，这里就不在赘述了，附上一张总结性的原理图片，去那边看看吧。

 谷歌官网：多摄像头支持  |  Android 开源项目  |  Android Open Source Project

        强大的谷歌让开发成了傻子，同时打开多摄像头也是这样，基本可以理解所有的操作全部double一下就行，主要还是处理线程问题，一个线程尝试过很吃力，然后整两个线程呗！废话不多说，介绍demo 开干！

一、初始化变量

        记住，double就行，当然大神不必跟从，你肯定有更好的办法；创建了两个textureView用于接收预览回调数据，两个imageview用于拍照回调显示，分别给两个相机设置一个线程，这样可以分别打开camera1和camera2，避免阻塞挂掉。

private ImageView image_view1;
private ImageView image_view2;

private TextureView textureview1;
private TextureView textureview2;

private ImageReader imagereader1;
private ImageReader imagereader2;

private Surface textureview1_surface;
private Surface textureview2_surface;

private Surface imagereader1_surface;
private Surface imagereader2_surface;

private SurfaceTexture texture_surfacetextture1;
private SurfaceTexture texture_surfacetextture2;

private CameraManager mcameramanager;

private CameraDevice mCameraDevice;
private CameraDevice mCameraDevice1;

private  CameraCaptureSession mcamerasession0;
private  CameraCaptureSession mcamerasession1;

Button camera1_button;
Button camera2_button;

private HandlerThread mBackgroundforcamera0Thread;
private Handler mBackgroundforcamera0Handler;

private HandlerThread mBackgroundforcamera1Thread;
private Handler mBackgroundforcamera1Handler;

        这里面的逻辑就是配置UI，然后获取cameramanager，直接开看textureView的监视器，这俩面分别实例化可一个surface空间，并把预览分辨率设置为1920*1080，以及创建了imagereader，同时设置jpeg的分辨率，且实例化imagereader的surface；最后open_camera()。textureListener2和textureListener1完全是一样的，不表述。

mBackgroundforcamera0Thread = new HandlerThread("CameraBackgroundForCamera0");
mBackgroundforcamera0Thread.start();
mBackgroundforcamera0Handler = new Handler(mBackgroundforcamera0Thread.getLooper());

//创立线程2
mBackgroundforcamera1Thread = new HandlerThread("CameraBackgroundForCamera1");
mBackgroundforcamera1Thread.start();
mBackgroundforcamera1Handler = new Handler(mBackgroundforcamera1Thread.getLooper());

image_view1 = findViewById(R.id.imageView);
image_view2 = findViewById(R.id.imageView2);
textureview1 = findViewById(R.id.textureView);
textureview2 = findViewById(R.id.textureView2);

//按键拍照
camera1_button = findViewById(R.id.button);
camera2_button = findViewById(R.id.button_2);
//按键拍照
camera1_button = findViewById(R.id.button);
camera2_button = findViewById(R.id.button_2);

mcameramanager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

textureview1.setSurfaceTextureListener(textureListener1);
textureview2.setSurfaceTextureListener(textureListener2);

private final TextureView.SurfaceTextureListener textureListener1 = new TextureView.SurfaceTextureListener() {
    @Override
    public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surface, int width, int height) {
        texture_surfacetextture1 = textureview1.getSurfaceTexture();
        texture_surfacetextture1.setDefaultBufferSize(1920, 1080);
        textureview1_surface = new Surface(texture_surfacetextture1);

        //创建imagereader
        imagereader1 = ImageReader.newInstance(1920, 1080, ImageFormat.JPEG, 2);
        imagereader1_surface = imagereader1.getSurface();
        imagereader1.setOnImageAvailableListener(imagereader_available1, null);

        Log.i(TAG, "opencamera1 start!");
        open_camera("0");
        Log.i(TAG, "opencamera1 finish!");

    }
};

二、打开相机

        记得在这里做好区分就行，还有获取camera权限；

private final void open_camera(String cameraId) {

    try {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(new String[]{Manifest.permission.CAMERA}, 100);
            Log.i(TAG,"[open_camera] 正在申请权限");
            return;
        } else {
            Log.i(TAG,"[open_camera] 已经获取权限");
        }
        CameraId = cameraId;
        Log.i(TAG,"opencamera id is :"+cameraId);
        if (cameraId == "0") {
            mcameramanager.openCamera(cameraId, mStateCallback, mBackgroundforcamera0Handler);
        } else {
            mcameramanager.openCamera(cameraId, mStateCallback2, mBackgroundforcamera1Handler);
        }
    } catch(CameraAccessException e) {
        e.printStackTrace();
    }

};

三、创建session

        从上面的openCamera()函数可以看出，针对不同的cameraId，创建不同的回调，或许这就是傻瓜式开发的我吧，莫学。createCameraPreviewSession就是创建session函数，我们进入其中。当然再来句废话，mStateCallback2和mStateCallback是一样的；

private final CameraDevice.StateCallback mStateCallback2 = new CameraDevice.StateCallback() {
    @Override
    public void onOpened(@NonNull CameraDevice camera) {
        mCameraDevice1 = camera;
        Log.i(TAG,"[open_camera:1] get CameraDevice! cameraId:"+mCameraDevice1);
        createCameraPreviewSession("1");

    }
};

        这里面的核心思想就是针对不同cameraId，用不同的cameradevice和各种surface，创建session，直接过；然后这里你又会看到傻瓜式的msessionstatecallback1和msessionstatecallback0，哈哈；

private void createCameraPreviewSession( String cameraId) {
    Surface previewsurface = null;
    Surface imagesurface = null;

    if (cameraId == "0") {
        try {
            Log.i(TAG,"[------createCameraPreviewSession-------] choose surface:"+previewsurface.toString()
                    +" imagesurface:"+imagesurface.toString()+" device:"+McameraDevice.toString());
            mCameraDevice.createCaptureSession(Arrays.asList(textureview1_surface,imagereader1_surface),msessionstatecallback0,mBackgroundforcamera0Handler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }

    } else {
        try {
            Log.i(TAG,"[+++++++createCameraPreviewSession++++++++] choose surface:"+textureview2_surface.toString()
                    +" imagesurface:"+imagereader2_surface.toString()+" device:"+mCameraDevice1.toString());
            mCameraDevice1.createCaptureSession(Arrays.asList(textureview2_surface,imagereader2_surface),msessionstatecallback1,mBackgroundforcamera1Handler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
};

四、创建预览Request

        记得添加的surface和创建的session中的surface对应就行，一般操作；至于预览回调，无所谓，不用写，整个null；

CameraCaptureSession.StateCallback msessionstatecallback0 = new CameraCaptureSession.StateCallback() {
    @Override
    public void onConfigured(@NonNull CameraCaptureSession session) {
        try {
            Log.i(TAG,"[createCameraPreviewSession] create session successful for camera: 0");
            CaptureRequest.Builder PreviewRequest_builder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
PreviewRequest_builder.addTarget(textureview1_surface);
            //创建request并开始预览
            CaptureRequest request = PreviewRequest_builder.build();
            Log.i(TAG,"[camerasession] begin preview!---"+session);
            session.setRepeatingRequest(request, mPreviewCallback, mBackgroundforcamera0Handler);
            mcamerasession0 = session;
            Log.i(TAG,"[camerasession] send preview request!");

        } catch (CameraAccessException e) {
            e.printStackTrace();
        }

    }
}；

五、创建CaptureRequest

        给button创建click事件，然后点击拍照，注意的是要将拍照的回调数据添加到imagereader中，不赘述，最后在imagereader回调中将我们早期创建imageview利用上，要把回调的数据压缩成bitmap并设置到imageview中，就像下面。

private  void take_camera1() throws CameraAccessException {
    Log.i(TAG,"开始camera0拍照");
    CaptureRequest.Builder picture_request_builder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
    picture_request_builder.addTarget(imagereader1_surface);
    picture_request_builder.set(CaptureRequest.CONTROL_MODE, CaptureRequest.CONTROL_MODE_AUTO);
    CaptureRequest picture_reuqest = picture_request_builder.build();
    //session
    mcamerasession0.capture(picture_reuqest, mPreviewCallback,mBackgroundforcamera0Handler);
    Log.i(TAG,"camera0 完成拍照，开始图片回调");
}

private final ImageReader.OnImageAvailableListener imagereader_available1
        = new ImageReader.OnImageAvailableListener() {

    @Override
    public void onImageAvailable(ImageReader reader) {
        //TODO zhb
        Log.i(TAG,"camera 0 回调已经获取到imagereader 图片");
        Image image = reader.acquireLatestImage();
        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
        int number_buffer = buffer.remaining();
        byte[] bytes = new byte[number_buffer];
        buffer.get(bytes);
        image.close();
        Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, number_buffer);

        Log.i(TAG,"camera 0 完成bitmap生成");
        image_view1.setImageBitmap(bitmap);
    }
};

总结

        其实demo就是在实践验证同时打开两个相机的功能，以上代码不可能ctrl+c和ctrl+v就能够跑起来，你们按照自己工程，double打开一个相机的流程就行，当然前提是机器支持这样的功能。最后附上一张图验证结果。

 

 （谢谢大家，欢迎指正）