Java Examples for android.hardware.camera2.CaptureRequest

/**
     * Builds a {@link CaptureRequest} based on the builder parameters.
     *
     * @return The capture request.
     * @throws CameraAccessException If the camera device has been disconnected.
     */
CaptureRequest build() throws CameraAccessException {
    captureRequest = cameraDevice.createCaptureRequest(requestTemplate);
    setCaptureIntent();
    setControlMode();
    setTarget();
    triggerAutoFocus();
    triggerPrecaptureExposure();
    cancelPrecaptureExposure();
    setFlash();
    setExposure();
    setFocus();
    return captureRequest.build();
}

/**
     * Returns the list of keys supported by this {@link CameraDevice} for querying
     * with a {@link CaptureRequest}.
     *
     * <p>The list returned is not modifiable, so any attempts to modify it will throw
     * a {@code UnsupportedOperationException}.</p>
     *
     * <p>Each key is only listed once in the list. The order of the keys is undefined.</p>
     *
     * <p>Note that there is no {@code getAvailableCameraCharacteristicsKeys()} -- use
     * {@link #getKeys()} instead.</p>
     *
     * @return List of keys supported by this CameraDevice for CaptureRequests.
     */
@SuppressWarnings({ "unchecked" })
@NonNull
public List<CaptureRequest.Key<?>> getAvailableCaptureRequestKeys() {
    if (mAvailableRequestKeys == null) {
        Object crKey = CaptureRequest.Key.class;
        Class<CaptureRequest.Key<?>> crKeyTyped = (Class<CaptureRequest.Key<?>>) crKey;
        int[] filterTags = get(REQUEST_AVAILABLE_REQUEST_KEYS);
        if (filterTags == null) {
            throw new AssertionError("android.request.availableRequestKeys must be non-null " + "in the characteristics");
        }
        mAvailableRequestKeys = getAvailableKeyList(CaptureRequest.class, crKeyTyped, filterTags);
    }
    return mAvailableRequestKeys;
}

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

@Override
public void run() {
    try {
        // This is how to tell the camera to lock focus.
        s.previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
        s.captureSession.setRepeatingRequest(s.previewRequestBuilder.build(), new RequestCaptureTransaction(s), handler);
    } catch (Exception e) {
        getBus().post(new PictureTakenEvent(e));
        if (isDebug()) {
            Log.e(getClass().getSimpleName(), "Exception taking picture", e);
        }
    }
}

/**
         * Get an array of {@link #TotalCaptureResult total capture results} for a given list of
         * {@link #CaptureRequest capture requests}. This can be used when the order of results
         * may not the same as the order of requests.
         *
         * @param captureRequests The list of {@link #CaptureRequest capture requests} whose
         *            corresponding {@link #TotalCaptureResult capture results} are
         *            being waited for.
         * @param numResultsWait Number of frames to wait for the capture results
         *            before timeout.
         * @throws TimeoutRuntimeException If more than numResultsWait results are
         *            seen before all the results matching captureRequests arrives.
         */
public TotalCaptureResult[] getTotalCaptureResultsForRequests(List<CaptureRequest> captureRequests, int numResultsWait) {
    if (numResultsWait < 0) {
        throw new IllegalArgumentException("numResultsWait must be no less than 0");
    }
    if (captureRequests == null || captureRequests.size() == 0) {
        throw new IllegalArgumentException("captureRequests must have at least 1 request.");
    }
    // Create a request -> a list of result indices map that it will wait for.
    HashMap<CaptureRequest, ArrayList<Integer>> remainingResultIndicesMap = new HashMap<>();
    for (int i = 0; i < captureRequests.size(); i++) {
        CaptureRequest request = captureRequests.get(i);
        ArrayList<Integer> indices = remainingResultIndicesMap.get(request);
        if (indices == null) {
            indices = new ArrayList<>();
            remainingResultIndicesMap.put(request, indices);
        }
        indices.add(i);
    }
    TotalCaptureResult[] results = new TotalCaptureResult[captureRequests.size()];
    int i = 0;
    do {
        TotalCaptureResult result = getTotalCaptureResult(CAPTURE_RESULT_TIMEOUT_MS);
        CaptureRequest request = result.getRequest();
        ArrayList<Integer> indices = remainingResultIndicesMap.get(request);
        if (indices != null) {
            results[indices.get(0)] = result;
            indices.remove(0);
            // Remove the entry if all results for this request has been fulfilled.
            if (indices.isEmpty()) {
                remainingResultIndicesMap.remove(request);
            }
        }
        if (remainingResultIndicesMap.isEmpty()) {
            return results;
        }
    } while (i++ < numResultsWait);
    throw new TimeoutRuntimeException("Unable to get the expected capture result after " + "waiting for " + numResultsWait + " results");
}

private CaptureRequest drawPreview(SurfaceView surfaceView) {
    try {
        CaptureRequest.Builder captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        captureRequestBuilder.addTarget(surfaceView.getHolder().getSurface());
        captureRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
        return captureRequestBuilder.build();
    } catch (CameraAccessException e) {
        e.printStackTrace();
        return null;
    }
}

/**
     * Start running an HDR burst on a configured camera session
     */
public void setHdrBurst() {
    mHdrBuilder.set(CaptureRequest.SENSOR_SENSITIVITY, 1600);
    mHdrBuilder.set(CaptureRequest.SENSOR_FRAME_DURATION, ONE_SECOND / 30);
    mHdrBuilder.set(CaptureRequest.SENSOR_EXPOSURE_TIME, mEvenExposure);
    mHdrBuilder.setTag(mEvenExposureTag);
    mHdrRequests.set(0, mHdrBuilder.build());
    mHdrBuilder.set(CaptureRequest.SENSOR_EXPOSURE_TIME, mOddExposure);
    mHdrBuilder.setTag(mOddExposureTag);
    mHdrRequests.set(1, mHdrBuilder.build());
    mCameraOps.setRepeatingBurst(mHdrRequests, mCaptureCallback, mUiHandler);
}

/**
     * 设置连拍的参数
     *
     * @return
     */
private CaptureRequest.Builder initDngBuilder() {
    CaptureRequest.Builder captureBuilder = null;
    try {
        captureBuilder = mCameraSession.getDevice().createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        captureBuilder.addTarget(mImageReader.getSurface());
        captureBuilder.addTarget(surface);
        // Required for RAW capture
        captureBuilder.set(CaptureRequest.STATISTICS_LENS_SHADING_MAP_MODE, CaptureRequest.STATISTICS_LENS_SHADING_MAP_MODE_ON);
        captureBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_OFF);
        captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        captureBuilder.set(CaptureRequest.SENSOR_EXPOSURE_TIME, (long) ((214735991 - 13231) / 2));
        captureBuilder.set(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, 0);
        //设置 ISO，感光度
        captureBuilder.set(CaptureRequest.SENSOR_SENSITIVITY, (10000 - 100) / 2);
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, 90);
        //设置每秒30帧
        CameraManager cameraManager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE);
        String cameraid = CameraCharacteristics.LENS_FACING_FRONT + "";
        CameraCharacteristics cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraid);
        Range<Integer> fps[] = cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
        captureBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fps[fps.length - 1]);
    } catch (CameraAccessException e) {
        Toast.makeText(getActivity(), "请求相机权限被拒绝", Toast.LENGTH_SHORT).show();
    } catch (NullPointerException e) {
        Toast.makeText(getActivity(), "打开相机失败", Toast.LENGTH_SHORT).show();
    }
    return captureBuilder;
}

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

private void reconfigureCamera() {
    if (mCamera != null) {
        try {
            mCaptureSession.stopRepeating();
            mPreviewBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
            mCaptureSession.capture(mPreviewBuilder.build(), mPreCaptureCallback, mHandler);
            doPreviewConfiguration();
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
}

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

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

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

/**
     * Update the camera preview. {@link #startPreview()} needs to be called in advance.
     */
private void updatePreview() {
    if (null == mCameraDevice) {
        return;
    }
    try {
        mPreviewBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
        mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), captureCallback, mBackgroundHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private void checkState(CaptureRequest request, CaptureResult result) {
    Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
    switch(mState) {
        case //在preview中处理TextureView的触摸事件
        STATE_PREVIEW:
            if (afState == null) {
                Log.d("Camera2TextureView", "null");
                return;
            }
            //这次的值与之前的一样，忽略掉
            if (afState.intValue() == mAfState) {
                Log.d("Camera2TextureView", "same");
                return;
            }
            mAfState = afState.intValue();
            //聚焦视图
            judgeFocus();
            break;
        case STATE_WAITING_LOCK:
            if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState || CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState || CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED == afState || CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED == afState) {
                if (afState == null) {
                    doStillCapture();
                } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState || CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
                    aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                    if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
                        mState = STATE_PICTURE_TAKEN;
                        doStillCapture();
                    } else {
                        tryCaptureAgain();
                    }
                }
            }
            break;
        case STATE_WAITING_PRECAPTURE:
            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:
            aeState = result.get(CaptureResult.CONTROL_AE_STATE);
            if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
                mState = STATE_PICTURE_TAKEN;
                doStillCapture();
            }
            break;
    }
}

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 onPrecaptureRequired() {
    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);
    setState(STATE_PRECAPTURE);
    try {
        mCaptureSession.capture(mPreviewRequestBuilder.build(), this, null);
        mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_IDLE);
    } catch (CameraAccessException e) {
        Log.e(TAG, "Failed to run precapture sequence.", 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();
    }
}

private void process(@NonNull final CaptureResult result) {
    switch(mState) {
        case STATE_PREVIEW:
            // We have nothing to do when the camera preview is working normally.
            break;
        case STATE_WAITING_LOCK:
            Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
            if (afState == null || mCurrentFocusMode == CaptureRequest.CONTROL_AF_MODE_OFF) {
                mState = CameraState.STATE_PICTURE_TAKEN;
                captureStillPicture();
            } else 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 = CameraState.STATE_PICTURE_TAKEN;
                    captureStillPicture();
                } else {
                    runPrecaptureSequence();
                }
            }
            break;
        case STATE_WAITING_UNLOCK:
            unlockFocus();
            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_CONVERGED) {
                mState = CameraState.STATE_PICTURE_TAKEN;
                captureStillPicture();
            } else if (aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE || aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
                mState = CameraState.STATE_WAITING_NON_PRECAPTURE;
            }
            break;
        case STATE_WAITING_NON_PRECAPTURE:
            // CONTROL_AE_STATE can be null on some devices
            Integer aeState2 = result.get(CaptureResult.CONTROL_AE_STATE);
            if (aeState2 == null || aeState2 != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
                mState = CameraState.STATE_PICTURE_TAKEN;
                captureStillPicture();
            }
            break;
        default:
            break;
    }
}

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

/* 
	 * Camera parameters interfaces (scene mode, white balance, exposure lock and etc)
	 */
public static boolean setAutoExposureLock(boolean lock) {
    if (previewRequestBuilder != null && Camera2Controller.getInstance().camDevice != null) {
        previewRequestBuilder.set(CaptureRequest.CONTROL_AE_LOCK, lock);
        setRepeatingRequest();
        PreferenceManager.getDefaultSharedPreferences(ApplicationScreen.getMainContext()).edit().putBoolean(ApplicationScreen.sAELockPref, lock).commit();
        return true;
    }
    return false;
}

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

@Override
public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
    super.onCaptureCompleted(session, request, result);
    Log.e("camera2", "onCaptureCompleted");
    onPreviewCallback(mCameraDevice, session);
}

private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) {
    builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
}