Java Examples for android.hardware.camera2.CameraDevice

/**
     * Creates a request responsible to trigger an auto focus request.
     *
     * @return The camera request.
     * @throws CameraAccessException If the camera device has been disconnected.
     */
public CaptureRequest createLockRequest() throws CameraAccessException {
    CameraDevice camera = cameraConnection.getCamera();
    Surface surface = textureManager.getSurface();
    Flash flash = parametersProvider.getFlash();
    boolean triggerAutoExposure = !cameraConnection.getCharacteristics().isLegacyDevice();
    return CaptureRequestBuilder.create(camera, CameraDevice.TEMPLATE_STILL_CAPTURE).into(surface).flash(flash).triggerAutoFocus(true).triggerPrecaptureExposure(triggerAutoExposure).build();
}

/**
     * Start the camera preview.
     */
private void startPreview() {
    if (null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) {
        return;
    }
    try {
        Log.d(TAG, "preview size: " + mPreviewSize.getWidth() + ", " + mPreviewSize.getHeight());
        setUpMediaRecorder();
        SurfaceTexture texture = mRenderer.getVideoTexture();
        assert texture != null;
        texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
        List<Surface> surfaces = new ArrayList<>();
        Surface previewSurface = new Surface(texture);
        surfaces.add(previewSurface);
        mPreviewBuilder.addTarget(previewSurface);
        Surface recorderSurface = mMediaRecorder.getSurface();
        surfaces.add(recorderSurface);
        mPreviewBuilder.addTarget(recorderSurface);
        mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {

            @Override
            public void onConfigured(CameraCaptureSession cameraCaptureSession) {
                mPreviewSession = cameraCaptureSession;
                updatePreview();
            }

            @Override
            public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
                Activity activity = getActivity();
                if (null != activity) {
                    Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
                }
            }
        }, mBackgroundHandler);
    } catch (CameraAccessExceptionIOException |  e) {
        e.printStackTrace();
    }
}

private void startPreview(CameraDevice cameraDevice) {
    try {
        cameraDevice.createCaptureSession(Arrays.asList(surfaceView.getHolder().getSurface(), surface), new CameraCaptureSession.StateCallback() {

            @Override
            public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                try {
                    cameraCaptureSession.setRepeatingBurst(Arrays.asList(drawPreview(surfaceView), drawInputSurface(surface)), null, cameraHandler);
                    Log.i(TAG, "camera configured");
                } catch (CameraAccessException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
                cameraCaptureSession.close();
                Log.e(TAG, "configuration failed");
            }
        }, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

/**
     * Block until the camera is opened.
     *
     * <p>Don't use this to test #onDisconnected/#onError since this will throw
     * an AssertionError if it fails to open the camera device.</p>
     *
     * @return CameraDevice opened camera device
     *
     * @throws IllegalArgumentException
     *            If the handler is null, or if the handler's looper is current.
     * @throws CameraAccessException
     *            If open fails immediately.
     * @throws BlockingOpenException
     *            If open fails after blocking for some amount of time.
     * @throws TimeoutRuntimeException
     *            If opening times out. Typically unrecoverable.
     */
public static CameraDevice openCamera(CameraManager manager, String cameraId, CameraDevice.StateCallback listener, Handler handler) throws CameraAccessException, BlockingOpenException {
    /**
         * Although camera2 API allows 'null' Handler (it will just use the current
         * thread's Looper), this is not what we want for CTS.
         *
         * In Camera framework test the default looper is used only to process events
         * in between test runs,
         * so anything sent there would not be executed inside a test and the test would fail.
         *
         * In this case, BlockingCameraManager#openCamera performs the check for us.
         */
    return (new BlockingCameraManager(manager)).openCamera(cameraId, listener, handler);
}

@Override
public void onOpened(CameraDevice cameraDevice) {
    Log.d(TAG, "相机已经打开");
    try {
        mPreViewBuidler = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        SurfaceTexture texture = mTextureView.getSurfaceTexture();
        texture.setDefaultBufferSize(mPreViewSize.getWidth(), mPreViewSize.getHeight());
        surface = new Surface(texture);
        mPreViewBuidler.addTarget(surface);
        cameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()), mSessionStateCallBack, mHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
    Log.i(TAG, "Finished configuring camera outputs");
    mCaptureSession = session;
    SurfaceHolder holder = mSurfaceView.getHolder();
    if (holder != null) {
        try {
            // Build a request for preview footage
            CaptureRequest.Builder requestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            requestBuilder.addTarget(holder.getSurface());
            CaptureRequest previewRequest = requestBuilder.build();
            // Start displaying preview images
            try {
                session.setRepeatingRequest(previewRequest, /*listener*/
                null, /*handler*/
                null);
            } catch (CameraAccessException ex) {
                Log.e(TAG, "Failed to make repeating preview request", ex);
            }
        } catch (CameraAccessException ex) {
            Log.e(TAG, "Failed to build preview request", ex);
        }
    } else {
        Log.e(TAG, "Holder didn't exist when trying to formulate preview request");
    }
}

public CameraDevice openCamera(int cameraId) {
    try {
        CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId + "");
        //支持的STREAM CONFIGURATION
        StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        mPreviewSize = setSize(cameraId, map);
        mCameraDevice = null;
        while (mCameraDevice == null) {
            mCameraManager.openCamera(cameraId + "", mDeviceStateCallback, mHandler);
            synchronized (lock) {
                try {
                    Log.e("camera2", "wait");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    } catch (CameraAccessExceptionSecurityException |  e) {
        e.printStackTrace();
    }
    Log.e("camera2", "reture device" + (mCameraDevice == null));
    return mCameraDevice;
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public CameraSupport open() {
    try {
        startCamera2Thread();
        if (mIsInPreview) {
            reconfigureCamera();
            return this;
        }
        mIsInPreview = true;
        if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MICROSECONDS)) {
            throw new RuntimeException("Time out waiting to lock camera opening.");
        }
        printSupportFormats();
        String[] cameraIds = manager.getCameraIdList();
        CameraDevice.StateCallback deviceCallback = new CameraDevice.StateCallback() {

            @Override
            public void onOpened(@NonNull CameraDevice camera) {
                cameraOpenCloseLock.release();
                mCamera = camera;
                createCameraPreviewSession();
            }

            @Override
            public void onDisconnected(@NonNull CameraDevice camera) {
                Log.d(TAG, "onDisconnected:  open");
                cameraOpenCloseLock.release();
                camera.close();
                mCamera = null;
            }

            @Override
            public void onError(@NonNull CameraDevice camera, int error) {
                cameraOpenCloseLock.release();
                camera.close();
                mCamera = null;
            }
        };
        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "open: jjjj");
        }
        // TODO 先只预览背面的摄像头
        manager.openCamera(cameraIds[0], deviceCallback, mHandler);
    } catch (Exception e) {
        Log.e(TAG, "open: " + Log.getStackTraceString(e));
    }
    return this;
}

/**
     * Execute a new capture request within the active session
     */
private void triggerImageCapture() {
    try {
        final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureBuilder.addTarget(mImageReader.getSurface());
        captureBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON);
        captureBuilder.set(CaptureRequest.CONTROL_AWB_MODE, CaptureRequest.CONTROL_AWB_MODE_AUTO);
        Log.d(TAG, "Capture request created.");
        mCaptureSession.capture(captureBuilder.build(), mCaptureCallback, null);
    } catch (CameraAccessException cae) {
        Log.d(TAG, "camera capture exception");
    }
}

/**
   * Creates a new {@link CameraCaptureSession} for camera preview.
   */
private void createCameraPreviewSession() {
    try {
        final SurfaceTexture texture = textureView.getSurfaceTexture();
        assert texture != null;
        // We configure the size of default buffer to be the size of camera preview we want.
        texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
        // This is the output Surface we need to start preview.
        final Surface surface = new Surface(texture);
        // We set up a CaptureRequest.Builder with the output Surface.
        previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        previewRequestBuilder.addTarget(surface);
        LOGGER.i("Opening camera preview: " + previewSize.getWidth() + "x" + previewSize.getHeight());
        // Create the reader for the preview frames.
        previewReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(), ImageFormat.YUV_420_888, 2);
        previewReader.setOnImageAvailableListener(tfPreviewListener, backgroundHandler);
        previewRequestBuilder.addTarget(previewReader.getSurface());
        // Here, we create a CameraCaptureSession for camera preview.
        cameraDevice.createCaptureSession(Arrays.asList(surface, previewReader.getSurface()), new CameraCaptureSession.StateCallback() {

            @Override
            public void onConfigured(final CameraCaptureSession cameraCaptureSession) {
                // The camera is already closed
                if (null == cameraDevice) {
                    return;
                }
                // When the session is ready, we start displaying the preview.
                captureSession = cameraCaptureSession;
                try {
                    // Auto focus should be continuous for camera preview.
                    previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                    // Flash is automatically enabled when necessary.
                    previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
                    // Finally, we start displaying the camera preview.
                    previewRequest = previewRequestBuilder.build();
                    captureSession.setRepeatingRequest(previewRequest, captureCallback, backgroundHandler);
                } catch (final CameraAccessException e) {
                    LOGGER.e(e, "Exception!");
                }
            }

            @Override
            public void onConfigureFailed(final CameraCaptureSession cameraCaptureSession) {
                showToast("Failed");
            }
        }, null);
    } catch (final CameraAccessException e) {
        LOGGER.e(e, "Exception!");
    }
    LOGGER.i("Getting assets.");
    tfPreviewListener.initialize(getActivity().getAssets(), scoreView, inferenceHandler);
    LOGGER.i("Tensorflow initialized.");
}

/**
     * Start the camera preview.
     */
private void startPreview() {
    if (null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) {
        return;
    }
    try {
        closePreviewSession();
        SurfaceTexture texture = mTextureView.getSurfaceTexture();
        assert texture != null;
        texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        Surface previewSurface = new Surface(texture);
        mPreviewBuilder.addTarget(previewSurface);
        mCameraDevice.createCaptureSession(Collections.singletonList(previewSurface), new CameraCaptureSession.StateCallback() {

            @Override
            public void onConfigured(@NonNull CameraCaptureSession session) {
                mPreviewSession = session;
                updatePreview();
            }

            @Override
            public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                Activity activity = getActivity();
                if (null != activity) {
                    Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
                }
            }
        }, mBackgroundHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private void updateFlashlight(boolean forceDisable) {
    try {
        boolean enabled;
        /* SPRD: fixbug421956 make this method to be thread-safety @{ */
        synchronized (this) {
            enabled = mFlashlightEnabled && !forceDisable;
            if (enabled) {
                registerListenerBroadcast();
            } else {
                unresisterListenerBroadcast();
            }
            mFlashLightManager.setFlashlightEnabled(enabled);
        /*if (enabled) {
                if (mCameraDevice == null) {
                    startDevice();
                    return;
                }
                if (mSession == null) {
                    startSession();
                    return;
                }
                if (mFlashlightRequest == null) {
                    CaptureRequest.Builder builder = mCameraDevice.createCaptureRequest(
                            CameraDevice.TEMPLATE_PREVIEW);
                    builder.set(CaptureRequest.FLASH_MODE, CameraMetadata.FLASH_MODE_TORCH);
                    builder.addTarget(mSurface);
                    CaptureRequest request = builder.build();
                    mSession.capture(request, null, mHandler);
                    mFlashlightRequest = request;
                }
            } else {
                if (mCameraDevice != null) {
                    mCameraDevice.close();
                    teardown();
                }
            }*/
        }
    /* @} */
    //} catch (CameraAccessException|IllegalStateException|UnsupportedOperationException e) {
    } catch (Exception e) {
        Log.e(TAG, "Error in updateFlashlight", e);
        handleError();
    }
}

/**
     * Helper for opening a connection to a camera with the given ID.
     *
     * @param cameraId The unique identifier of the camera device to open
     * @param callback The callback for the camera. Must not be null.
     * @param handler  The handler to invoke the callback on. Must not be null.
     *
     * @throws CameraAccessException if the camera is disabled by device policy,
     * too many camera devices are already open, or the cameraId does not match
     * any currently available camera device.
     *
     * @throws SecurityException if the application does not have permission to
     * access the camera
     * @throws IllegalArgumentException if callback or handler is null.
     * @return A handle to the newly-created camera device.
     *
     * @see #getCameraIdList
     * @see android.app.admin.DevicePolicyManager#setCameraDisabled
     */
private CameraDevice openCameraDeviceUserAsync(String cameraId, CameraDevice.StateCallback callback, Handler handler) throws CameraAccessException {
    CameraCharacteristics characteristics = getCameraCharacteristics(cameraId);
    CameraDevice device = null;
    try {
        synchronized (mLock) {
            ICameraDeviceUser cameraUser = null;
            android.hardware.camera2.impl.CameraDeviceImpl deviceImpl = new android.hardware.camera2.impl.CameraDeviceImpl(cameraId, callback, handler, characteristics);
            BinderHolder holder = new BinderHolder();
            ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks();
            int id = Integer.parseInt(cameraId);
            try {
                if (supportsCamera2ApiLocked(cameraId)) {
                    // Use cameraservice's cameradeviceclient implementation for HAL3.2+ devices
                    ICameraService cameraService = CameraManagerGlobal.get().getCameraService();
                    if (cameraService == null) {
                        throw new CameraRuntimeException(CameraAccessException.CAMERA_DISCONNECTED, "Camera service is currently unavailable");
                    }
                    cameraService.connectDevice(callbacks, id, mContext.getOpPackageName(), USE_CALLING_UID, holder);
                    cameraUser = ICameraDeviceUser.Stub.asInterface(holder.getBinder());
                } else {
                    // Use legacy camera implementation for HAL1 devices
                    Log.i(TAG, "Using legacy camera HAL.");
                    cameraUser = CameraDeviceUserShim.connectBinderShim(callbacks, id);
                }
            } catch (CameraRuntimeException e) {
                if (e.getReason() == CameraAccessException.CAMERA_DEPRECATED_HAL) {
                    throw new AssertionError("Should've gone down the shim path");
                } else if (e.getReason() == CameraAccessException.CAMERA_IN_USE || e.getReason() == CameraAccessException.MAX_CAMERAS_IN_USE || e.getReason() == CameraAccessException.CAMERA_DISABLED || e.getReason() == CameraAccessException.CAMERA_DISCONNECTED || e.getReason() == CameraAccessException.CAMERA_ERROR) {
                    deviceImpl.setRemoteFailure(e);
                    if (e.getReason() == CameraAccessException.CAMERA_DISABLED || e.getReason() == CameraAccessException.CAMERA_DISCONNECTED || e.getReason() == CameraAccessException.CAMERA_IN_USE) {
                        throw e.asChecked();
                    }
                } else {
                    throw e;
                }
            } catch (RemoteException e) {
                CameraRuntimeException ce = new CameraRuntimeException(CameraAccessException.CAMERA_DISCONNECTED, "Camera service is currently unavailable", e);
                deviceImpl.setRemoteFailure(ce);
                throw ce.asChecked();
            }
            // TODO: factor out callback to be non-nested, then move setter to constructor
            // For now, calling setRemoteDevice will fire initial
            // onOpened/onUnconfigured callbacks.
            deviceImpl.setRemoteDevice(cameraUser);
            device = deviceImpl;
        }
    } catch (NumberFormatException e) {
        throw new IllegalArgumentException("Expected cameraId to be numeric, but it was: " + cameraId);
    } catch (CameraRuntimeException e) {
        throw e.asChecked();
    }
    return device;
}

@Override
public void onOpened(CameraDevice camera) {
    mCameraState = STATE_CAMERA_OPEN;
    mCameraDevice = camera;
    mCamera2PreviewModel = new Camera2PreviewModel();
    try {
        mCamera2SettingModel = new Camera2SettingModel(mCameraManager.getCameraCharacteristics(id), mCameraManager.getCameraIdList().length);
        mCamera2SettingModel.setOnParameterChangedListener(Camera2ModelImpl.this);
        Size picSize = null;
        if (pictureSize == null) {
            List<Size> list = mCamera2SettingModel.getSupportPictureSizes();
            Collections.sort(list, new SizeComparator());
            picSize = list.get(list.size() - 1);
        } else {
            picSize = pictureSize;
        }
        mJpgImageReader = ImageReader.newInstance(picSize.getWidth(), picSize.getHeight(), ImageFormat.JPEG, 2);
        mJpegPictureCallback = new PictureCallback();
        mJpgImageReader.setOnImageAvailableListener(mJpegPictureCallback, null);
    } catch (CameraAccessException e) {
        YLog.e(e);
    }
    callback.onOpen(mCamera2PreviewModel, mCamera2SettingModel);
}

/**
     * Callbacks for CameraOps
     */
@Override
public void onCameraReady() {
    // Ready to send requests in, so set them up
    try {
        CaptureRequest.Builder previewBuilder = mCameraOps.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        previewBuilder.addTarget(mProcessingNormalSurface);
        previewBuilder.setTag(mAutoExposureTag);
        mPreviewRequest = previewBuilder.build();
        mHdrBuilder = mCameraOps.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        mHdrBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_OFF);
        mHdrBuilder.addTarget(mProcessingHdrSurface);
        switchRenderMode(0);
    } catch (CameraAccessException e) {
        String errorMessage = getErrorString(e);
        showErrorDialog(errorMessage);
    }
}

@Override
public void onOpened(CameraDevice cameraDevice) {
    lock.release();
    s.cameraDevice = cameraDevice;
    s.reader = s.buildImageReader();
    Descriptor camera = (Descriptor) s.getDescriptor();
    camera.setDevice(cameraDevice);
    try {
        cameraDevice.createCaptureSession(Arrays.asList(surface, s.reader.getSurface()), new StartPreviewTransaction(s, surface), handler);
    } catch (CameraAccessException e) {
        getBus().post(new OpenedEvent(e));
    } catch (IllegalStateException e2) {
        getBus().post(new DeepImpactEvent(e2));
    }
}

@Override
public void onOpened(CameraDevice cameraDevice) {
    Log.d(TAG, "******************************");
    Log.d(TAG, "onOpened camera status!");
    Log.d(TAG, "******************************");
    mCameraDevice = cameraDevice;
    startPreview();
    mCameraOpenCloseLock.release();
    if (null != mTextureView) {
        configureTransform(mTextureView.getWidth(), mTextureView.getHeight());
    }
}

/**
     * Opens the camera specified by {@link Camera2BasicFragment#mCameraId}.
     */
private void openCamera() {
    Activity activity = getActivity();
    CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
    BlockingCameraManager blockingManager = new BlockingCameraManager(manager);
    try {
        mDeviceCallback = new BlockingStateCallback() {

            @Override
            public void onDisconnected(CameraDevice camera) {
                camera.close();
                mCameraDevice = null;
            }

            @Override
            public void onError(CameraDevice camera, int error) {
                camera.close();
                mCameraDevice = null;
                Activity activity = getActivity();
                if (activity != null) {
                    activity.finish();
                }
            }
        };
        mCameraDevice = blockingManager.openCamera(mCameraId, mDeviceCallback, mBackgroundHandler);
        createCameraPreviewSession();
    } catch (BlockingOpenExceptionTimeoutRuntimeException |  e) {
        showToast("Timed out opening camera.");
    } catch (CameraAccessException e) {
        showToast("Failed to open camera.");
    }
}

/**
	 * Capture a still picture. This method should be called when we get a response in
	 * {@link #mCaptureCallback} from both {@link #lockFocus()}.
	 */
private void captureStillPicture() {
    try {
        if (null == mActivity || null == mCameraDevice || null == mCaptureSession) {
            return;
        }
        // This is the CaptureRequest.Builder that we use to take a picture.
        final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureBuilder.addTarget(mImageReader.getSurface());
        // Use the same AE and AF modes as the preview.
        captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, mCurrentFocusMode);
        captureBuilder.set(CaptureRequest.FLASH_MODE, mCurrentFlashMode);
        captureBuilder.set(CaptureRequest.CONTROL_AE_MODE, mCurrentAutoExposureMode);
        captureBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, mMinimalFocalDistance * mCurrentRelativeFocalDistance);
        captureBuilder.set(CaptureRequest.SCALER_CROP_REGION, getCroppingRect(mCurrentRelativeZoom));
        if (mMaximalFocalLength > 0) {
            captureBuilder.set(CaptureRequest.LENS_FOCAL_LENGTH, mMaximalFocalLength);
        }
        captureBuilder.set(CaptureRequest.NOISE_REDUCTION_MODE, CaptureRequest.NOISE_REDUCTION_MODE_OFF);
        captureBuilder.set(CaptureRequest.EDGE_MODE, CaptureRequest.EDGE_MODE_OFF);
        mCaptureSession.stopRepeating();
        mState = CameraState.STATE_WAITING_UNLOCK;
        mCaptureSession.capture(captureBuilder.build(), mCaptureCallback, mBackgroundHandler);
        mCameraCallback.onTakingPicture();
    } catch (CameraAccessExceptionIllegalStateException |  e) {
        mCameraCallback.onCameraError("Failed to capture picture", "cap1", e);
    }
}

@Override
public void onOpened(CameraDevice cameraDevice) {
    // the TextureView displaying this has been set up.
    synchronized (mCameraStateLock) {
        mState = STATE_OPENED;
        mCameraOpenCloseLock.release();
        mCameraDevice = cameraDevice;
        // Start the preview session if the TextureView has been set up already.
        if (mPreviewSize != null && mTextureView.isAvailable()) {
            createCameraPreviewSessionLocked();
        }
    }
}

public static boolean createCaptureSession(List<Surface> sfl) {
    try {
        if (!captureSessionOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
            Log.d(TAG, "Create capture session failed. Semaphore is locked");
            return false;
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
        return false;
    }
    try {
        CameraDevice camera = Camera2Controller.getCamera2();
        if (camera == null) {
            captureSessionOpenCloseLock.release();
            return false;
        }
        //			Log.e(TAG, "Create capture session. Surface list size = " + sfl.size());
        // Here, we create a CameraCaptureSession for camera preview.
        camera.createCaptureSession(sfl, Camera2Controller.captureSessionStateCallback, null);
    } catch (IllegalArgumentException e) {
        Log.e(TAG, "Create capture session failed. IllegalArgumentException: " + e.getMessage());
        e.printStackTrace();
    } catch (CameraAccessException e) {
        Log.e(TAG, "Create capture session failed. CameraAccessException: " + e.getMessage());
        e.printStackTrace();
    }
    return true;
}

public void onOpened(CameraDevice camera) {
    try {
        callback.onCameraOpened(camera);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

@Override
public void onOpened(@NonNull CameraDevice cameraDevice) {
    mCameraOpenCloseLock.release();
    mCameraDevice = cameraDevice;
    createCameraPreviewSession();
}