Java Examples for android.hardware.camera2.CameraCaptureSession

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();
    }
}

/**
     * Configure a new camera session with output surfaces and type.
     *
     * @param camera The CameraDevice to be configured.
     * @param outputSurfaces The surface list that used for camera output.
     * @param listener The callback CameraDevice will notify when capture results are available.
     */
public static CameraCaptureSession configureCameraSession(CameraDevice camera, List<Surface> outputSurfaces, boolean isHighSpeed, CameraCaptureSession.StateCallback listener, Handler handler) throws CameraAccessException {
    BlockingSessionCallback sessionListener = new BlockingSessionCallback(listener);
    if (isHighSpeed) {
        camera.createConstrainedHighSpeedCaptureSession(outputSurfaces, sessionListener, handler);
    } else {
        camera.createCaptureSession(outputSurfaces, sessionListener, handler);
    }
    CameraCaptureSession session = sessionListener.waitAndGetSession(SESSION_CONFIGURE_TIMEOUT_MS);
    assertFalse("Camera session should not be a reprocessable session", session.isReprocessable());
    String sessionType = isHighSpeed ? "High Speed" : "Normal";
    assertTrue("Capture session type must be " + sessionType, isHighSpeed == CameraConstrainedHighSpeedCaptureSession.class.isAssignableFrom(session.getClass()));
    return session;
}

public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
    // Only update UI every so many frames
    // Use an odd number here to ensure both even and odd exposures get an occasional update
    long frameNumber = result.getFrameNumber();
    if (frameNumber % 3 != 0)
        return;
    long exposureTime = result.get(CaptureResult.SENSOR_EXPOSURE_TIME);
    // Format exposure time nicely
    String exposureText;
    if (exposureTime > ONE_SECOND) {
        exposureText = String.format("%.2f s", exposureTime / 1e9);
    } else if (exposureTime > MILLI_SECOND) {
        exposureText = String.format("%.2f ms", exposureTime / 1e6);
    } else if (exposureTime > MICRO_SECOND) {
        exposureText = String.format("%.2f us", exposureTime / 1e3);
    } else {
        exposureText = String.format("%d ns", exposureTime);
    }
    Object tag = request.getTag();
    Log.i(TAG, "Exposure: " + exposureText);
    if (tag == mEvenExposureTag) {
        mEvenExposureText.setText(exposureText);
        mEvenExposureText.setEnabled(true);
        mOddExposureText.setEnabled(true);
        mAutoExposureText.setEnabled(false);
    } else if (tag == mOddExposureTag) {
        mOddExposureText.setText(exposureText);
        mEvenExposureText.setEnabled(true);
        mOddExposureText.setEnabled(true);
        mAutoExposureText.setEnabled(false);
    } else {
        mAutoExposureText.setText(exposureText);
        mEvenExposureText.setEnabled(false);
        mOddExposureText.setEnabled(false);
        mAutoExposureText.setEnabled(true);
    }
}

@Override
public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
    if (null == mCameraDevice) {
        return;
    }
    mCaptureSession = cameraCaptureSession;
    try {
        mPreviewRequestBuilder = CaptureRequestFactory.createPreviewBuilder(mCameraDevice, surface);
        CaptureRequestFactory.setPreviewBuilderPreview(mPreviewRequestBuilder);
        updatePreview(mPreviewRequestBuilder.build(), captureSessionCaptureCallback);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

@Override
public void handleMessage(final Message msg) {
    super.handleMessage(msg);
    Log.v(TAG, "handleMessage - action = '" + CameraActions.stringify(msg.what) + "'");
    int cameraAction = msg.what;
    try {
        switch(cameraAction) {
            case CameraActions.OPEN_CAMERA:
            case CameraActions.RECONNECT:
                {
                    CameraOpenCallback openCallback = (CameraOpenCallback) msg.obj;
                    int cameraIndex = msg.arg1;
                    if (mCameraState.getState() > AndroidCamera2StateHolder.CAMERA_UNOPENED) {
                        openCallback.onDeviceOpenedAlready(cameraIndex, generateHistoryString(cameraIndex));
                        break;
                    }
                    mOpenCallback = openCallback;
                    mCameraIndex = cameraIndex;
                    mCameraId = mCameraDevices.get(mCameraIndex);
                    Log.i(TAG, String.format("Opening camera index %d (id %s) with camera2 API", cameraIndex, mCameraId));
                    if (mCameraId == null) {
                        mOpenCallback.onCameraDisabled(msg.arg1);
                        break;
                    }
                    mCameraManager.openCamera(mCameraId, mCameraDeviceStateCallback, this);
                    break;
                }
            case CameraActions.RELEASE:
                {
                    if (mCameraState.getState() == AndroidCamera2StateHolder.CAMERA_UNOPENED) {
                        Log.w(TAG, "Ignoring release at inappropriate time");
                        break;
                    }
                    if (mSession != null) {
                        closePreviewSession();
                        mSession = null;
                    }
                    if (mCamera != null) {
                        mCamera.close();
                        mCamera = null;
                    }
                    mCameraProxy = null;
                    mPersistentSettings = null;
                    mActiveArray = null;
                    if (mPreviewSurface != null) {
                        mPreviewSurface.release();
                        mPreviewSurface = null;
                    }
                    mPreviewTexture = null;
                    if (mCaptureReader != null) {
                        mCaptureReader.close();
                        mCaptureReader = null;
                    }
                    mPreviewSize = null;
                    mPhotoSize = null;
                    mCameraIndex = 0;
                    mCameraId = null;
                    changeState(AndroidCamera2StateHolder.CAMERA_UNOPENED);
                    break;
                }
            case CameraActions.SET_PREVIEW_TEXTURE_ASYNC:
                {
                    setPreviewTexture((SurfaceTexture) msg.obj);
                    break;
                }
            case CameraActions.START_PREVIEW_ASYNC:
                {
                    if (mCameraState.getState() != AndroidCamera2StateHolder.CAMERA_PREVIEW_READY) {
                        // TODO: Provide better feedback here?
                        Log.w(TAG, "Refusing to start preview at inappropriate time");
                        break;
                    }
                    mOneshotPreviewingCallback = (CameraStartPreviewCallback) msg.obj;
                    changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE);
                    try {
                        mSession.setRepeatingRequest(mPersistentSettings.createRequest(mCamera, CameraDevice.TEMPLATE_PREVIEW, mPreviewSurface), /*listener*/
                        mCameraResultStateCallback, /*handler*/
                        this);
                    } catch (CameraAccessException ex) {
                        Log.w(TAG, "Unable to start preview", ex);
                        changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY);
                    }
                    break;
                }
            // changed again while no preview is running.
            case CameraActions.STOP_PREVIEW:
                {
                    if (mCameraState.getState() < AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE) {
                        Log.w(TAG, "Refusing to stop preview at inappropriate time");
                        break;
                    }
                    mSession.stopRepeating();
                    changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY);
                    break;
                }
            case CameraActions.APPLY_SETTINGS:
                {
                    AndroidCamera2Settings settings = (AndroidCamera2Settings) msg.obj;
                    applyToRequest(settings);
                    break;
                }
            case CameraActions.AUTO_FOCUS:
                {
                    if (mCancelAfPending > 0) {
                        Log.v(TAG, "handleMessage - Ignored AUTO_FOCUS because there was " + mCancelAfPending + " pending CANCEL_AUTO_FOCUS messages");
                        // ignore AF because a CANCEL_AF is queued after this
                        break;
                    }
                    // and most notably, this is the only case where the callback isn't invoked.
                    if (mCameraState.getState() < AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE) {
                        Log.w(TAG, "Ignoring attempt to autofocus without preview");
                        break;
                    }
                    // The earliest we can reliably tell whether the autofocus has locked in
                    // response to our latest request is when our one-time capture progresses.
                    // However, it will probably take longer than that, so once that happens,
                    // just start checking the repeating preview requests as they complete.
                    final CameraAFCallback callback = (CameraAFCallback) msg.obj;
                    CameraCaptureSession.CaptureCallback deferredCallbackSetter = new CameraCaptureSession.CaptureCallback() {

                        private boolean mAlreadyDispatched = false;

                        @Override
                        public void onCaptureProgressed(CameraCaptureSession session, CaptureRequest request, CaptureResult result) {
                            checkAfState(result);
                        }

                        @Override
                        public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
                            checkAfState(result);
                        }

                        private void checkAfState(CaptureResult result) {
                            if (result.get(CaptureResult.CONTROL_AF_STATE) != null && !mAlreadyDispatched) {
                                // Now our mCameraResultStateCallback will invoke the callback
                                // the first time it finds the focus motor to be locked.
                                mAlreadyDispatched = true;
                                mOneshotAfCallback = callback;
                                // This is an optimization: check the AF state of this frame
                                // instead of simply waiting for the next.
                                mCameraResultStateCallback.monitorControlStates(result);
                            }
                        }

                        @Override
                        public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
                            Log.e(TAG, "Focusing failed with reason " + failure.getReason());
                            callback.onAutoFocus(false, mCameraProxy);
                        }
                    };
                    // Send a one-time capture to trigger the camera driver to lock focus.
                    changeState(AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED);
                    Camera2RequestSettingsSet trigger = new Camera2RequestSettingsSet(mPersistentSettings);
                    trigger.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AF_TRIGGER_START);
                    try {
                        mSession.capture(trigger.createRequest(mCamera, CameraDevice.TEMPLATE_PREVIEW, mPreviewSurface), /*listener*/
                        deferredCallbackSetter, /*handler*/
                        this);
                    } catch (CameraAccessException ex) {
                        Log.e(TAG, "Unable to lock autofocus", ex);
                        changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE);
                    }
                    break;
                }
            case CameraActions.CANCEL_AUTO_FOCUS:
                {
                    // Ignore all AFs that were already queued until we see
                    // a CANCEL_AUTO_FOCUS_FINISH
                    mCancelAfPending++;
                    // Why would you want to unlock the lens if it isn't already locked?
                    if (mCameraState.getState() < AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE) {
                        Log.w(TAG, "Ignoring attempt to release focus lock without preview");
                        break;
                    }
                    // Send a one-time capture to trigger the camera driver to resume scanning.
                    changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE);
                    Camera2RequestSettingsSet cancel = new Camera2RequestSettingsSet(mPersistentSettings);
                    cancel.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AF_TRIGGER_CANCEL);
                    try {
                        mSession.capture(cancel.createRequest(mCamera, CameraDevice.TEMPLATE_PREVIEW, mPreviewSurface), /*listener*/
                        null, /*handler*/
                        this);
                    } catch (CameraAccessException ex) {
                        Log.e(TAG, "Unable to cancel autofocus", ex);
                        changeState(AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED);
                    }
                    break;
                }
            case CameraActions.CANCEL_AUTO_FOCUS_FINISH:
                {
                    // Stop ignoring AUTO_FOCUS messages unless there are additional
                    // CANCEL_AUTO_FOCUSes that were added
                    mCancelAfPending--;
                    break;
                }
            case CameraActions.SET_AUTO_FOCUS_MOVE_CALLBACK:
                {
                    mPassiveAfCallback = (CameraAFMoveCallback) msg.obj;
                    break;
                }
            case CameraActions.SET_DISPLAY_ORIENTATION:
                {
                    // Only set the JPEG capture orientation if requested to do so; otherwise,
                    // capture in the sensor's physical orientation. (e.g., JPEG rotation is
                    // necessary in auto-rotate mode.
                    mPersistentSettings.set(CaptureRequest.JPEG_ORIENTATION, msg.arg2 > 0 ? mCameraProxy.getCharacteristics().getJpegOrientation(msg.arg1) : 0);
                    break;
                }
            case CameraActions.SET_JPEG_ORIENTATION:
                {
                    mPersistentSettings.set(CaptureRequest.JPEG_ORIENTATION, msg.arg1);
                    break;
                }
            case CameraActions.CAPTURE_PHOTO:
                {
                    if (mCameraState.getState() < AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE) {
                        Log.e(TAG, "Photos may only be taken when a preview is active");
                        break;
                    }
                    if (mCameraState.getState() != AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED) {
                        Log.w(TAG, "Taking a (likely blurry) photo without the lens locked");
                    }
                    final CaptureAvailableListener listener = (CaptureAvailableListener) msg.obj;
                    if (mLegacyDevice || (mCurrentAeState == CaptureResult.CONTROL_AE_STATE_CONVERGED && !mPersistentSettings.matches(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_ALWAYS_FLASH) && !mPersistentSettings.matches(CaptureRequest.FLASH_MODE, CaptureRequest.FLASH_MODE_SINGLE))) {
                        // Legacy devices don't support the precapture state keys and instead
                        // perform autoexposure convergence automatically upon capture.
                        // On other devices, as long as it has already converged, it determined
                        // that flash was not required, and we're not going to invalidate the
                        // current exposure levels by forcing the force on, we can save
                        // significant capture time by not forcing a recalculation.
                        Log.i(TAG, "Skipping pre-capture autoexposure convergence");
                        mCaptureReader.setOnImageAvailableListener(listener, /*handler*/
                        this);
                        try {
                            mSession.capture(mPersistentSettings.createRequest(mCamera, CameraDevice.TEMPLATE_STILL_CAPTURE, mCaptureReader.getSurface()), listener, /*handler*/
                            this);
                        } catch (CameraAccessException ex) {
                            Log.e(TAG, "Unable to initiate immediate capture", ex);
                        }
                    } else {
                        // We need to let AE converge before capturing. Once our one-time
                        // trigger capture has made it into the pipeline, we'll start checking
                        // for the completion of that convergence, capturing when that happens.
                        Log.i(TAG, "Forcing pre-capture autoexposure convergence");
                        CameraCaptureSession.CaptureCallback deferredCallbackSetter = new CameraCaptureSession.CaptureCallback() {

                            private boolean mAlreadyDispatched = false;

                            @Override
                            public void onCaptureProgressed(CameraCaptureSession session, CaptureRequest request, CaptureResult result) {
                                checkAeState(result);
                            }

                            @Override
                            public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
                                checkAeState(result);
                            }

                            private void checkAeState(CaptureResult result) {
                                if (result.get(CaptureResult.CONTROL_AE_STATE) != null && !mAlreadyDispatched) {
                                    // Now our mCameraResultStateCallback will invoke the
                                    // callback once the autoexposure routine has converged.
                                    mAlreadyDispatched = true;
                                    mOneshotCaptureCallback = listener;
                                    // This is an optimization: check the AE state of this frame
                                    // instead of simply waiting for the next.
                                    mCameraResultStateCallback.monitorControlStates(result);
                                }
                            }

                            @Override
                            public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
                                Log.e(TAG, "Autoexposure and capture failed with reason " + failure.getReason());
                            // TODO: Make an error callback?
                            }
                        };
                        // Set a one-time capture to trigger the camera driver's autoexposure:
                        Camera2RequestSettingsSet expose = new Camera2RequestSettingsSet(mPersistentSettings);
                        expose.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);
                        try {
                            mSession.capture(expose.createRequest(mCamera, CameraDevice.TEMPLATE_PREVIEW, mPreviewSurface), /*listener*/
                            deferredCallbackSetter, /*handler*/
                            this);
                        } catch (CameraAccessException ex) {
                            Log.e(TAG, "Unable to run autoexposure and perform capture", ex);
                        }
                    }
                    break;
                }
            default:
                {
                    // TODO: Rephrase once everything has been implemented
                    throw new RuntimeException("Unimplemented CameraProxy message=" + msg.what);
                }
        }
    } catch (final Exception ex) {
        if (cameraAction != CameraActions.RELEASE && mCamera != null) {
            mCamera.close();
            mCamera = null;
        } else if (mCamera == null) {
            if (cameraAction == CameraActions.OPEN_CAMERA) {
                if (mOpenCallback != null) {
                    mOpenCallback.onDeviceOpenFailure(mCameraIndex, generateHistoryString(mCameraIndex));
                }
            } else {
                Log.w(TAG, "Cannot handle message " + msg.what + ", mCamera is null");
            }
            return;
        }
        if (ex instanceof RuntimeException) {
            String commandHistory = generateHistoryString(Integer.parseInt(mCameraId));
            mExceptionHandler.onCameraException((RuntimeException) ex, commandHistory, cameraAction, mCameraState.getState());
        }
    } finally {
        WaitDoneBundle.unblockSyncWaiters(msg);
    }
}

@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");
    }
}

/**
     * Begin a still image capture
     */
public void takePicture() {
    if (mCameraDevice == null) {
        Log.w(TAG, "Cannot capture image. Camera not initialized.");
        return;
    }
    // Here, we create a CameraCaptureSession for capturing still images.
    try {
        mCameraDevice.createCaptureSession(Collections.singletonList(mImageReader.getSurface()), mSessionCallback, null);
    } catch (CameraAccessException cae) {
        Log.d(TAG, "access exception while preparing pic", cae);
    }
}

/**
     * 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();
    }
}

/**
     * 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();
    }
}

@Override
public void onConfigured(CameraCaptureSession session) {
    if (null == mCameraDevice) {
        return;
    }
    mSession = session;
    try {
        mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        CaptureRequest previewRequest = mPreviewRequestBuilder.build();
        mSession.setRepeatingRequest(previewRequest, mCameraCaptureSessionCaptureCallback4Preview, null);
        mCameraState = STATE_CAMERA_PREVIEW;
    } catch (CameraAccessException e) {
        YLog.e(e);
    }
    mCamera2FocusModel = new Camera2FocusModel(mCamera2SettingModel.isFocusSupported(), mPreviewRequestBuilder, mCamera2SettingModel.getActiveArraySize());
    mCamera2FocusModel.setOnParameterChangedListener(Camera2ModelImpl.this);
    mCamera2CaptureModel = new Camera2CaptureModel();
    callback.onPreview(mCamera2CaptureModel, mCamera2FocusModel);
}

/**
	 * Creates a new {@link CameraCaptureSession} for camera preview.
	 */
private void createCameraPreviewSession() {
    try {
        SurfaceTexture texture = mTextureView.getSurfaceTexture();
        assert texture != null;
        // We configure the size of default buffer to be the size of camera preview we want.
        texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        // This is the output Surface we need to start preview.
        mSurface = new Surface(texture);
        // Here, we create a CameraCaptureSession for camera preview.
        mCameraDevice.createCaptureSession(Arrays.asList(mSurface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {

            @Override
            public void onConfigured(@NonNull final CameraCaptureSession cameraCaptureSession) {
                // The camera is already closed
                if (mCameraDevice == null) {
                    return;
                }
                // When the session is ready, we start displaying the preview.
                mCaptureSession = cameraCaptureSession;
                doPreviewConfiguration();
            }

            @Override
            public void onConfigureFailed(@NonNull final CameraCaptureSession cameraCaptureSession) {
                mActivity.runOnUiThread(new Runnable() {

                    @Override
                    public void run() {
                        mCameraCallback.onCameraError("Failed to create capture session", "pre3", null);
                    }
                });
            }
        }, mBackgroundHandler);
    } catch (CameraAccessExceptionIllegalStateException | AssertionError |  e) {
        mCameraCallback.onCameraError("Failed to create preview session", "pre4", e);
    }
}

@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 onConfigured(CameraCaptureSession session) {
    try {
        if (!s.isClosed()) {
            s.captureSession = session;
            s.previewRequestBuilder = session.getDevice().createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            s.previewRequestBuilder.addTarget(surface);
            s.previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
            s.previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
            Descriptor camera = (Descriptor) s.getDescriptor();
            CameraCharacteristics cc = mgr.getCameraCharacteristics(camera.cameraId);
            if (s.getZoomRect() != null) {
                s.previewRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, s.getZoomRect());
            }
            s.addToPreviewRequest(cc, s.previewRequestBuilder);
            s.previewRequest = s.previewRequestBuilder.build();
            session.setRepeatingRequest(s.previewRequest, null, handler);
            getBus().post(new OpenedEvent());
        }
    } catch (CameraAccessException e) {
        getBus().post(new OpenedEvent(e));
    } catch (IllegalStateException e) {
        if (isDebug()) {
            Log.w(getClass().getSimpleName(), "Exception resetting focus", e);
        }
    }
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public void setupJPEGCaptureListener() {
    mCaptureCallback = new CameraCaptureSession.CaptureCallback() {

        private void process(CaptureResult result) {
            switch(mState) {
                case STATE_PREVIEW:
                    {
                        // We have nothing to do when the camera preview is working normally.
                        break;
                    }
                case STATE_WAITING_LOCK:
                    {
                        int afState = result.get(CaptureResult.CONTROL_AF_STATE);
                        if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState || CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
                            // CONTROL_AE_STATE can be null on some devices
                            Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                            if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
                                mState = STATE_WAITING_NON_PRECAPTURE;
                                captureStillPicture();
                            } else {
                                runPrecaptureSequence();
                            }
                        }
                        break;
                    }
                case STATE_WAITING_PRECAPTURE:
                    {
                        // CONTROL_AE_STATE can be null on some devices
                        Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                        if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE || aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
                            mState = STATE_WAITING_NON_PRECAPTURE;
                        }
                        break;
                    }
                case STATE_WAITING_NON_PRECAPTURE:
                    {
                        // CONTROL_AE_STATE can be null on some devices
                        Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                        if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
                            mState = STATE_PICTURE_TAKEN;
                            captureStillPicture();
                        }
                        break;
                    }
            }
        }
    };
}

@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
    if (mCamera == null) {
        return;
    }
    mCaptureSession = session;
    updateAutoFocus();
    updateFlash();
    try {
        mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), mCaptureCallback, null);
    } catch (CameraAccessException e) {
        Log.e(TAG, "Failed to start camera preview because it couldn't access camera", e);
    } catch (IllegalStateException e) {
        Log.e(TAG, "Failed to start camera preview.", e);
    }
}

/**
     * Creates a new {@link CameraCaptureSession} for camera preview.
     */
private void createCameraPreviewSession() {
    try {
        // This is the output Surface we need to start preview.
        Surface surface = mImageReader.getSurface();
        // We set up a CaptureRequest.Builder with the output Surface.
        mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        mPreviewRequestBuilder.addTarget(surface);
        mSessionCallback = new BlockingSessionCallback();
        // Here, we create a CameraCaptureSession for camera preview.
        Log.d(TAG, "creating capture session");
        mCameraDevice.createCaptureSession(Arrays.asList(surface), mSessionCallback, mBackgroundHandler);
        try {
            Log.d(TAG, "waiting on session.");
            mCaptureSession = mSessionCallback.waitAndGetSession(SESSION_WAIT_TIMEOUT_MS);
            try {
                mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                // Comment out the above and uncomment this to disable continuous autofocus and
                // instead set it to a fixed value of 20 diopters. This should make the picture
                // nice and blurry for denoised edge detection.
                // mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
                //         CaptureRequest.CONTROL_AF_MODE_OFF);
                // mPreviewRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, 20.0f);
                // Finally, we start displaying the camera preview.
                mPreviewRequest = mPreviewRequestBuilder.build();
                Log.d(TAG, "setting repeating request");
                mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, mBackgroundHandler);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        } catch (TimeoutRuntimeException e) {
            showToast("Failed to configure capture session.");
        }
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

@Override
public void onCaptureStarted(CameraCaptureSession session, CaptureRequest request, long timestamp, long frameNumber) {
    String currentDateTime = generateTimestamp();
    File rawFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "RAW_" + currentDateTime + ".dng");
    File jpegFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "JPEG_" + currentDateTime + ".jpg");
    // Look up the ImageSaverBuilder for this request and update it with the file name
    // based on the capture start time.
    ImageSaver.ImageSaverBuilder jpegBuilder;
    ImageSaver.ImageSaverBuilder rawBuilder;
    int requestId = (int) request.getTag();
    synchronized (mCameraStateLock) {
        jpegBuilder = mJpegResultQueue.get(requestId);
        rawBuilder = mRawResultQueue.get(requestId);
    }
    if (jpegBuilder != null)
        jpegBuilder.setFile(jpegFile);
    if (rawBuilder != null)
        rawBuilder.setFile(rawFile);
}

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;
}

@Override
public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
    super.onCaptureCompleted(session, request, result);
    this.cameraCaptureSessionCallback.onCaptureCompleted(session, request, result);
}

/**
     * @return the currently opened capture session of the camera
     */
public CameraCaptureSession getCaptureSession() {
    if (session == null) {
        throw new IllegalStateException("Preview has not been yet started.");
    }
    return session.getCaptureSession();
}

@Override
public void onConfigured(CameraCaptureSession cameraCaptureSession) {
    try {
        mCameraSession = cameraCaptureSession;
        cameraCaptureSession.setRepeatingRequest(mPreViewBuidler.build(), null, mHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

@Override
public void onConfigured(CameraCaptureSession session) {
    mCaptureSession = session;
    try {
        session.setRepeatingRequest(mCaptureRequestBuilder.build(), mCaptureSessionCaptureCallback, mHandler);
        Log.e("camera2", "setRepeatingRequest");
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

@Override
public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
    process(partialResult);
}

@Override
public void onConfigured(CameraCaptureSession session) {
    if (session.getDevice() == mCameraDevice) {
        mSession = session;
    } else {
        session.close();
    }
    postUpdateFlashlight();
}