android.hardware.camera2.TotalCaptureResult Java Examples

@Override
public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
    if(request.getTag() == ("FOCUS_TAG")) {
        //The focus trigger is complete!
        //Resume repeating request, clear AF trigger.
        mAutoFocusCallback.onAutoFocus(true);
        mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, null);
        mPreviewRequestBuilder.setTag("");
        mPreviewRequest = mPreviewRequestBuilder.build();
        try {
            mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, mBackgroundHandler);
        } catch(CameraAccessException ex) {
            Log.d(TAG, "AUTO FOCUS FAILURE: "+ex);
        }
    } else {
        process(result);
    }
}
 

/**
 * Enforces the invariant by sweeping all internal queues when a TotalCaptureResult arrives.
 * result cannot be null.
 */
private void handleCaptureResultLocked(TotalCaptureResult result) {
  // TODO(jiawen): Add annotations.
  CaptureRequestTag crt = CaptureRequestTag.getCaptureRequestTag(result);
  if (crt == null) {
    throw new IllegalArgumentException("CaptureResult is missing a CaptureRequestTag.");
  }

  // It has no targets, doesn't affect the queue.
  if (crt.targets.isEmpty()) {
    return;
  }

  pendingCaptureResultQueue.addLast(result);
  sweepQueuesLocked();
}
 

private void updatePreview(final OBVideoPlayer videoPlayer)
{
    if (null == cameraDevice)
    {
        return;
    }
    try
    {
        setUpCaptureRequestBuilder(previewBuilder);

        captureSession.setRepeatingRequest(previewBuilder.build(),
                new CameraCaptureSession.CaptureCallback()
                {
                    @Override
                    public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result)
                    {
                        videoPlayer.invalidate();
                        super.onCaptureCompleted(session, request, result);
                    }
                }
                , backgroundHandler);
    } catch (CameraAccessException e)
    {
        e.printStackTrace();
    }
}
 

/**
 * @param callback A thread-safe callback to receive partial and final
 *                 metadata for each frame. Metadata may be received
 *                 out-of-order.
 */
public static ResponseListener forPartialMetadata(final Updatable<CaptureResultProxy> callback)
{
    return new ResponseListenerBase<CaptureResultProxy>(callback)
    {
        @Override
        public void onProgressed(CaptureResult partialResult)
        {
            callback.update(new AndroidCaptureResultProxy(partialResult));
        }

        @Override
        public void onCompleted(TotalCaptureResult result)
        {
            callback.update(new AndroidTotalCaptureResultProxy(result));
        }
    };
}
 

@Override
public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
    if (request.getTag() == ("FOCUS_TAG")) {
        //The focus trigger is complete!
        //Resume repeating request, clear AF trigger.
        mAutoFocusCallback.onAutoFocus(true);
        mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, null);
        mPreviewRequestBuilder.setTag("");
        mPreviewRequest = mPreviewRequestBuilder.build();
        try {
            mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, mBackgroundHandler);
        } catch (CameraAccessException ex) {
            Log.d(TAG, "AUTO FOCUS FAILURE: " + ex);
        }
    } else {
        process(result);
    }
}
 

@Override
public void onCompleted(TotalCaptureResult result)
{
    mConsecutiveErrorCount = 0;
    if (mFailureLevel > 0)
    {
        if (result.getFrameNumber() > mFailureFrameNumber)
        {
            // Success! Recovery worked, and a frame was completed
            // successfully.
            mRecoverySuccessCallback.onCallback(mRecoveryStrategies.get(mFailureLevel)
                    .toString());
            mFailureLevel = 0;
            mFailureFrameNumber = -1;
        }
    }
}
 

/**
 * Tries to capture a pinned image for the given key from the ring-buffer.
 *
 * @return the pair of (image, captureResult) if image is found, null
 * otherwise.
 */
public Pair<Image, TotalCaptureResult>
tryCapturePinnedImage(long timestamp)
{
    final Pair<Long, CapturedImage> toCapture =
            mCapturedImageBuffer.tryGetPinned(timestamp);
    Image pinnedImage = null;
    TotalCaptureResult imageCaptureResult = null;
    // Return an Image
    if (toCapture != null && toCapture.second != null)
    {
        pinnedImage = toCapture.second.tryGetImage();
        imageCaptureResult = toCapture.second.tryGetMetadata();
    }
    return Pair.create(pinnedImage, imageCaptureResult);
}
 

@Override
public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request,
                               TotalCaptureResult result) {
    super.onCaptureCompleted(session, request, result);
    Toast.makeText(MainActivity.this, "Picture Saved", Toast.LENGTH_SHORT).show();
    startPreview(session);
}
 

@Override
public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                               @NonNull CaptureRequest request,
                               @NonNull TotalCaptureResult result) {
    session.close();
    mCaptureSession = null;
    Log.d(TAG, "CaptureSession closed");
}
 

/**
 * 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 == mCameraDevice) {
            return;
        }
        if(mShutterCallback != null) {
            mShutterCallback.onShutter();
        }
        // This is the CaptureRequest.Builder that we use to take a picture.
        final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureBuilder.addTarget(mImageReaderStill.getSurface());

        // Use the same AE and AF modes as the preview.
        captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, mFocusMode);
        if(mFlashSupported) {
            captureBuilder.set(CaptureRequest.CONTROL_AE_MODE, mFlashMode);
        }

        // Orientation
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(mDisplayOrientation));

        CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() {

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

        mCaptureSession.stopRepeating();
        mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
 

private void captureStillPicture() {
    MLog.d(TAG, "captureStillPicture");

    try {
        if (null == mCameraDevice) {
            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, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        // setAutoFlash(captureBuilder);

        // Orientation
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, 0);

        CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() {
            @Override
            public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                Log.d(TAG, "saved to: "); // + mFile.toString());
                unlockFocus();
            }
        };

        mCaptureSession.stopRepeating();
        mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
 

/**
 * 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 {
        final Activity activity = getActivity();
        if (null == activity || null == mCameraDevice) {
            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,
                CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        setAutoFlash(captureBuilder);

        // Orientation
        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(rotation));

        CameraCaptureSession.CaptureCallback CaptureCallback
                = new CameraCaptureSession.CaptureCallback() {

            @Override
            public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                                           @NonNull CaptureRequest request,
                                           @NonNull TotalCaptureResult result) {
                showToast("Saved: " + mFile);
                Log.d(TAG, mFile.toString());
                unlockFocus();
            }
        };

        mCaptureSession.stopRepeating();
        mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
 

@Override
public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request,
                               TotalCaptureResult result) {
    int requestId = (int) request.getTag();
    ImageSaver.ImageSaverBuilder jpegBuilder;
    ImageSaver.ImageSaverBuilder rawBuilder;
    StringBuilder sb = new StringBuilder();

    // Look up the ImageSaverBuilder for this request and update it with the CaptureResult
    synchronized (mCameraStateLock) {
        jpegBuilder = mJpegResultQueue.get(requestId);
        rawBuilder = mRawResultQueue.get(requestId);

        if (jpegBuilder != null) {
            jpegBuilder.setResult(result);
            sb.append("Saving JPEG as: ");
            sb.append(jpegBuilder.getSaveLocation());
        }
        if (rawBuilder != null) {
            rawBuilder.setResult(result);
            if (jpegBuilder != null) sb.append(", ");
            sb.append("Saving RAW as: ");
            sb.append(rawBuilder.getSaveLocation());
        }

        // If we have all the results necessary, save the image to a file in the background.
        handleCompletionLocked(requestId, jpegBuilder, mJpegResultQueue);
        handleCompletionLocked(requestId, rawBuilder, mRawResultQueue);

        finishedCaptureLocked();
    }

    showToast(sb.toString());
}
 

/**
 * 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 == mCameraDevice) {
            return;
        }
        if (mShutterCallback != null) {
            mShutterCallback.onShutter();
        }
        // This is the CaptureRequest.Builder that we use to take a picture.
        final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureBuilder.addTarget(mImageReaderStill.getSurface());

        // Use the same AE and AF modes as the preview.
        captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, mFocusMode);
        if (mFlashSupported) {
            captureBuilder.set(CaptureRequest.CONTROL_AE_MODE, mFlashMode);
        }

        // Orientation
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(mDisplayOrientation));

        CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() {

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

        mCaptureSession.stopRepeating();
        mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
 

@Override
public void onCompleted(TotalCaptureResult totalCaptureResult)
{
    V newValue = totalCaptureResult.get(mKey);
    if (newValue != null)
    {
        mUpdatable.update(newValue);
    }
}
 

@Override
public void onCaptureCompleted(CameraCaptureSession session,
                               CaptureRequest request,
                               TotalCaptureResult result) {
    if (session != null) {
        session.close();
        mCaptureSession = null;
        Log.d(TAG, "CaptureSession closed");
    }
}
 

/**
     * 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 {
            final Activity activity = (Activity) mContext;
            if (null == activity || null == mCamera) {
                return;
            }
            // This is the CaptureRequest.Builder that we use to take a picture.
            final CaptureRequest.Builder captureBuilder =
                    mCamera.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,
                    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
            setAutoFlash(captureBuilder);

            // Orientation
//            captureBuilder.set(CaptureRequest.JPEG_ORIENTATION,
//                    mCameraCharacteristic.get(CameraCharacteristics.SENSOR_ORIENTATION));

            CameraCaptureSession.CaptureCallback CaptureCallback
                    = new CameraCaptureSession.CaptureCallback() {

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

            mCaptureSession.stopRepeating();
            mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
 

@Override
public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                               @NonNull CaptureRequest request,
                               @NonNull TotalCaptureResult result) {
    session.close();
    mCaptureSession = null;
    Log.d(TAG, "CaptureSession closed");
}
 

@Override
public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                               @NonNull CaptureRequest request,
                               @NonNull TotalCaptureResult result) {
    session.close();
    mCaptureSession = null;
    Log.d(TAG, "CaptureSession closed");
}
 

/**
 * Returs the timestamp of the image if present, -1 otherwise.
 */
public long tryGetTimestamp()
{
    if (mImage != null)
    {
        return mImage.getTimestamp();
    }
    if (mMetadata != null)
    {
        return mMetadata.get(TotalCaptureResult.SENSOR_TIMESTAMP);
    }
    return -1;
}
 

private boolean doMetaDataSwap(final TotalCaptureResult newMetadata, final long timestamp)
{
    return mCapturedImageBuffer.swapLeast(timestamp,
            new SwapTask<CapturedImage>()
            {
                @Override
                public CapturedImage create()
                {
                    CapturedImage image = new CapturedImage();
                    image.addMetadata(newMetadata);
                    return image;
                }

                @Override
                public CapturedImage swap(CapturedImage oldElement)
                {
                    oldElement.reset();
                    oldElement.addMetadata(newMetadata);
                    return oldElement;
                }

                @Override
                public void update(CapturedImage existingElement)
                {
                    existingElement.addMetadata(newMetadata);
                }

                @Override
                public long getSwapKey()
                {
                    return -1;
                }
            });
}
 

/**
 * 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 {
        final Activity activity = getActivity();
        if (null == activity || null == mCameraDevice) {
            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,
                CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        setAutoFlash(captureBuilder);

        // Orientation
        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(rotation));

        CameraCaptureSession.CaptureCallback CaptureCallback
                = new CameraCaptureSession.CaptureCallback() {

            @Override
            public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                                           @NonNull CaptureRequest request,
                                           @NonNull TotalCaptureResult result) {
                showToast("拍照成功，图片保存为: " + mFile);
                Log.d(TAG, mFile.toString());
                unlockFocus();
            }
        };

        mCaptureSession.stopRepeating();
        mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
 

/**
 * @param callback A thread-safe callback to receive the final metadata for
 *                 each frame. Metadata will always be received in-order.
 */
public static ResponseListener forFinalMetadata(
        final Updatable<TotalCaptureResultProxy> callback)
{
    return new ResponseListenerBase<TotalCaptureResultProxy>(callback)
    {
        @Override
        public void onCompleted(TotalCaptureResult result)
        {
            callback.update(new AndroidTotalCaptureResultProxy(result));
        }
    };
}
 

@Override
public void onCompleted(TotalCaptureResult result)
{
    for (ResponseListener listener : mListeners)
    {
        listener.onCompleted(result);
    }
}
 

@Override
public void onCaptureCompleted(CameraCaptureSessionProxy session, CaptureRequest request,
                               TotalCaptureResult result)
{
    Object tag = request.getTag();
    mListeners.get(tag).onCompleted(result);
}
 

/**
 * Captures a still picture.
 */
void captureStillPicture() {
    try {
        CaptureRequest.Builder captureRequestBuilder = mCamera.createCaptureRequest(
                CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureRequestBuilder.addTarget(mImageReader.getSurface());
        captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
                mCaptureRequestBuilder.get(CaptureRequest.CONTROL_AF_MODE));
        updateFlashLightState();
        // Calculate JPEG orientation.
        @SuppressWarnings("ConstantConditions")
        int sensorOrientation = mCameraCharacteristics.get(
                CameraCharacteristics.SENSOR_ORIENTATION);
        captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION,
                (sensorOrientation +
                        mDisplayOrientation * (mConfig.getCurrentFacing() == Constants.CAMERA_FACING_FRONT ? 1 : -1) +
                        360) % 360);
        // Stop preview and capture a still picture.
        mCaptureSession.stopRepeating();
        mCaptureSession.capture(captureRequestBuilder.build(),
                new CameraCaptureSession.CaptureCallback() {
                    @Override
                    public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                                                   @NonNull CaptureRequest request,
                                                   @NonNull TotalCaptureResult result) {
                        unlockFocus();
                    }
                }, null);
    } catch (CameraAccessException e) {
        Log.e(TAG, "Cannot capture a still picture.", e);
    }
}
 

@Override
public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                               @NonNull CaptureRequest request,
                               @NonNull TotalCaptureResult result) {
  super.onCaptureCompleted(session, request, result);
  Timber.d("Capture completed.");
  this.session = null;
}
 

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

@Override
public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request,
                               TotalCaptureResult result) {
    Log.d(TAG, "onCaptureCompleted: ");
    process(result);
}
 

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