package software.sitb.react.camera2; import android.Manifest; import android.annotation.TargetApi; import android.content.Context; import android.content.pm.PackageManager; import android.content.res.Configuration; import android.graphics.*; import android.hardware.camera2.*; import android.hardware.camera2.params.StreamConfigurationMap; import android.media.Image; import android.media.ImageReader; import android.os.AsyncTask; import android.os.Build; import android.os.Handler; import android.os.HandlerThread; import android.support.annotation.NonNull; import android.support.v4.content.ContextCompat; import android.util.Base64; import android.util.Log; import android.util.Size; import android.util.SparseIntArray; import android.view.Surface; import android.view.TextureView; import android.view.WindowManager; import com.facebook.react.bridge.*; import com.facebook.react.uimanager.events.RCTEventEmitter; import software.sitb.react.camera.commons.BaseCameraView; import software.sitb.react.camera.commons.CameraFacing; import software.sitb.react.camera.commons.Orientation; import software.sitb.react.camera.commons.Quality; import java.nio.ByteBuffer; import java.util.*; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import static software.sitb.react.camera2.Camera2ViewManager.CAPTURE_OUTPUT_BUFFER_EVENT; /** * @author 田尘殇Sean sean.snow@live.com */ @TargetApi(Build.VERSION_CODES.LOLLIPOP) public class Camera2View extends TextureView implements BaseCameraView, TextureView.SurfaceTextureListener { private static final String TAG = "Camera2View"; private static final SparseIntArray ORIENTATIONS = new SparseIntArray(); static { ORIENTATIONS.append(Surface.ROTATION_0, 90); ORIENTATIONS.append(Surface.ROTATION_90, 0); ORIENTATIONS.append(Surface.ROTATION_180, 270); ORIENTATIONS.append(Surface.ROTATION_270, 180); } /** * Camera state: Showing camera preview. */ private static final int STATE_PREVIEW = 0; /** * Camera state: Waiting for the focus to be locked. */ private static final int STATE_WAITING_LOCK = 1; /** * Camera state: Waiting for the exposure to be precapture state. */ private static final int STATE_WAITING_PRECAPTURE = 2; /** * Camera state: Waiting for the exposure state to be something other than precapture. */ private static final int STATE_WAITING_NON_PRECAPTURE = 3; /** * Camera state: Picture was taken. */ private static final int STATE_PICTURE_TAKEN = 4; /** * Max preview width that is guaranteed by Camera2 API */ private static final int MAX_PREVIEW_WIDTH = 1920; /** * Max preview height that is guaranteed by Camera2 API */ private static final int MAX_PREVIEW_HEIGHT = 1080; /** * Orientation of the camera sensor */ private int sensorOrientation; /** * Whether the current camera device supports Flash or not. */ private boolean flashSupported; /** * A {@link Semaphore} to prevent the app from exiting before closing the camera. */ private Semaphore cameraOpenCloseLock = new Semaphore(1); /** * The current state of camera state for taking pictures. * * @see #cameraCaptureSessionCaptureCallback */ private int state = STATE_PREVIEW; private int ratioWidth = 0; private int ratioHeight = 0; private CameraManager cameraManager; private CameraDevice cameraDevice; private CameraCaptureSession captureSession; private Handler handler; /** * 相机ID */ private String cameraId; /** * 相机预览大小 */ private Size previewSize; private ImageReader imageReader; private ImageReader captureOutputBufferImageReader; /** * 实时预览相机图像回调函数 */ private Callback onCaptureOutputBuffer; /** * {@link CaptureRequest.Builder} for the camera preview */ private CaptureRequest.Builder previewRequestBuilder; /** * {@link CaptureRequest} generated by {@link #previewRequestBuilder} */ private CaptureRequest previewRequest; private CameraDevice.StateCallback cameraDeviceStateCallback = new CameraDeviceStateCallback(); /** * A {@link CameraCaptureSession.CaptureCallback} that handles events related to JPEG capture. */ private CameraCaptureSession.CaptureCallback cameraCaptureSessionCaptureCallback = new CameraCaptureSessionCaptureCallback(); /** * This a callback object for the {@link ImageReader}. "onImageAvailable" will be called when a * still image is ready to be saved. */ private final ImageReader.OnImageAvailableListener onImageAvailableListener = new ImageReaderOnImageAvailableListener(); public Camera2View(Context context) { super(context); setSurfaceTextureListener(this); HandlerThread threadHandler = new HandlerThread("SitbRCTCamera2View"); threadHandler.start(); handler = new Handler(threadHandler.getLooper()); } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { super.onMeasure(widthMeasureSpec, heightMeasureSpec); int width = MeasureSpec.getSize(widthMeasureSpec); int height = MeasureSpec.getSize(heightMeasureSpec); if (0 == ratioWidth || 0 == ratioHeight) { setMeasuredDimension(width, height); } else { if (width < height * ratioWidth / ratioHeight) { setMeasuredDimension(width, width * ratioHeight / ratioWidth); } else { setMeasuredDimension(height * ratioWidth / ratioHeight, height); } } } @Override public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) { openCamera(width, height); } @Override public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) { configureTransform(width, height); } @Override public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) { return true; } @Override public void onSurfaceTextureUpdated(SurfaceTexture surface) { } /** * Initiate a still image capture. */ public void takePicture() { lockFocus(); } /** * 打开相机 * * @param width The width of available size for camera preview * @param height The height of available size for camera preview */ private void openCamera(int width, int height) { if (ContextCompat.checkSelfPermission(getContext(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { Log.e(TAG, "没有相机访问权限"); requestCameraPermission(); return; } setUpCameraOutputs(width, height); configureTransform(width, height); try { if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) { throw new RuntimeException("Time out waiting to lock camera opening."); } cameraManager.openCamera(cameraId, cameraDeviceStateCallback, handler); } catch (CameraAccessException e) { Log.e(TAG, e.getMessage(), e); e.printStackTrace(); } catch (InterruptedException e) { throw new RuntimeException("Interrupted while trying to lock camera opening.", e); } } /** * Closes the current {@link CameraDevice}. */ private void closeCamera() { try { cameraOpenCloseLock.acquire(); if (null != captureSession) { captureSession.close(); captureSession = null; } if (null != cameraDevice) { cameraDevice.close(); cameraDevice = null; } if (null != imageReader) { imageReader.close(); imageReader = null; } } catch (InterruptedException e) { throw new RuntimeException("Interrupted while trying to lock camera closing.", e); } finally { cameraOpenCloseLock.release(); } } /** * Sets the aspect ratio for this view. The size of the view will be measured based on the ratio * calculated from the parameters. Note that the actual sizes of parameters don't matter, that * is, calling setAspectRatio(2, 3) and setAspectRatio(4, 6) make the same result. * * @param width Relative horizontal size * @param height Relative vertical size */ private void setAspectRatio(int width, int height) { if (width < 0 || height < 0) { throw new IllegalArgumentException("Size cannot be negative."); } ratioWidth = width; ratioHeight = height; requestLayout(); } /** * Sets up member variables related to camera. * * @param width The width of available size for camera preview * @param height The height of available size for camera preview */ private void setUpCameraOutputs(int width, int height) { try { CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId); StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); if (map == null) { return; } // For still image captures, we use the largest available size. Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea()); imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, 1); imageReader.setOnImageAvailableListener(onImageAvailableListener, handler); captureOutputBufferImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, 1); // Find out if we need to swap dimension to get the preview size relative to sensor // coordinate. int displayRotation = getWindowManager().getDefaultDisplay().getRotation(); //noinspection ConstantConditions sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION); boolean swappedDimensions = false; switch (displayRotation) { case Surface.ROTATION_0: case Surface.ROTATION_180: if (sensorOrientation == 90 || sensorOrientation == 270) { swappedDimensions = true; } break; case Surface.ROTATION_90: case Surface.ROTATION_270: if (sensorOrientation == 0 || sensorOrientation == 180) { swappedDimensions = true; } break; default: Log.e(TAG, "Display rotation is invalid: " + displayRotation); } Point displaySize = new Point(); getWindowManager().getDefaultDisplay().getSize(displaySize); int rotatedPreviewWidth = width; int rotatedPreviewHeight = height; int maxPreviewWidth = displaySize.x; int maxPreviewHeight = displaySize.y; if (swappedDimensions) { rotatedPreviewWidth = height; rotatedPreviewHeight = width; maxPreviewWidth = displaySize.y; maxPreviewHeight = displaySize.x; } if (maxPreviewWidth > MAX_PREVIEW_WIDTH) { maxPreviewWidth = MAX_PREVIEW_WIDTH; } if (maxPreviewHeight > MAX_PREVIEW_HEIGHT) { maxPreviewHeight = MAX_PREVIEW_HEIGHT; } // Danger, W.R.! Attempting to use too large a preview size could exceed the camera // bus' bandwidth limitation, resulting in gorgeous previews but the storage of // garbage capture data. previewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), rotatedPreviewWidth, rotatedPreviewHeight, maxPreviewWidth, maxPreviewHeight, largest); // We fit the aspect ratio of TextureView to the size of preview we picked. int orientation = getResources().getConfiguration().orientation; if (orientation == Configuration.ORIENTATION_LANDSCAPE) { setAspectRatio(previewSize.getWidth(), previewSize.getHeight()); } else { setAspectRatio(previewSize.getHeight(), previewSize.getWidth()); } // Check if the flash is supported. Boolean available = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE); flashSupported = available == null ? false : available; } catch (CameraAccessException | NullPointerException e) { Log.e(TAG, e.getMessage(), e); } } /** * Configures the necessary {@link Matrix} transformation to `mTextureView`. * This method should be called after the camera preview size is determined in * setUpCameraOutputs and also the size of `mTextureView` is fixed. * * @param viewWidth The width of `mTextureView` * @param viewHeight The height of `mTextureView` */ private void configureTransform(int viewWidth, int viewHeight) { int rotation = getWindowManager().getDefaultDisplay().getRotation(); Matrix matrix = new Matrix(); RectF viewRect = new RectF(0, 0, viewWidth, viewHeight); RectF bufferRect = new RectF(0, 0, previewSize.getHeight(), previewSize.getWidth()); float centerX = viewRect.centerX(); float centerY = viewRect.centerY(); if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) { bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY()); matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL); float scale = Math.max((float) viewHeight / previewSize.getHeight(), (float) viewWidth / previewSize.getWidth()); matrix.postScale(scale, scale, centerX, centerY); matrix.postRotate(90 * (rotation - 2), centerX, centerY); } else if (Surface.ROTATION_180 == rotation) { matrix.postRotate(180, centerX, centerY); } setTransform(matrix); } /** * Creates a new {@link CameraCaptureSession} for camera preview. */ protected void createCameraPreviewSession() { try { SurfaceTexture texture = 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. Surface surface = new Surface(texture); // We set up a CaptureRequest.Builder with the output Surface. previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); previewRequestBuilder.addTarget(surface); // Here, we create a CameraCaptureSession for camera preview. cameraDevice.createCaptureSession(Arrays.asList( surface, imageReader.getSurface(), captureOutputBufferImageReader.getSurface() ), new CameraCaptureSession.StateCallback() { @Override public void onConfigured(@NonNull 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. setAutoFlash(previewRequestBuilder); // Finally, we start displaying the camera preview. previewRequest = previewRequestBuilder.build(); captureSession.setRepeatingRequest(previewRequest, cameraCaptureSessionCaptureCallback, handler); } catch (CameraAccessException e) { e.printStackTrace(); } } @Override public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) { Log.e(TAG, "onConfigureFailed"); } }, handler); } catch (CameraAccessException e) { Log.e(TAG, e.getMessage(), e); } } /** * Capture a still picture. This method should be called when we get a response in * {@link #cameraCaptureSessionCaptureCallback} from both {@link #lockFocus()}. */ protected void captureStillPicture() { try { if (null == cameraDevice) { return; } // This is the CaptureRequest.Builder that we use to take a picture. final CaptureRequest.Builder captureBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE); captureBuilder.addTarget(imageReader.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 = 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(); } }; captureSession.stopRepeating(); captureSession.capture(captureBuilder.build(), captureCallback, null); } catch (CameraAccessException e) { e.printStackTrace(); } } /** * Retrieves the JPEG orientation from the specified screen rotation. * * @param rotation The screen rotation. * @return The JPEG orientation (one of 0, 90, 270, and 360) */ private int getOrientation(int rotation) { // Sensor orientation is 90 for most devices, or 270 for some devices (eg. Nexus 5X) // We have to take that into account and rotate JPEG properly. // For devices with orientation of 90, we simply return our mapping from ORIENTATIONS. // For devices with orientation of 270, we need to rotate the JPEG 180 degrees. return (ORIENTATIONS.get(rotation) + sensorOrientation + 270) % 360; } /** * Lock the focus as the first step for a still image capture. */ private void lockFocus() { try { // This is how to tell the camera to lock focus. previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START); // Tell #mCaptureCallback to wait for the lock. state = STATE_WAITING_LOCK; captureSession.capture(previewRequestBuilder.build(), cameraCaptureSessionCaptureCallback, handler); } catch (CameraAccessException e) { e.printStackTrace(); } } /** * Unlock the focus. This method should be called when still image capture sequence is * finished. */ private void unlockFocus() { try { // Reset the auto-focus trigger previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL); setAutoFlash(previewRequestBuilder); captureSession.capture(previewRequestBuilder.build(), cameraCaptureSessionCaptureCallback, handler); // After this, the camera will go back to the normal state of preview. state = STATE_PREVIEW; captureSession.setRepeatingRequest(previewRequest, cameraCaptureSessionCaptureCallback, handler); } catch (CameraAccessException e) { e.printStackTrace(); } } private WindowManager getWindowManager() { return ((WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE)); } private void setAutoFlash(CaptureRequest.Builder requestBuilder) { if (flashSupported) { requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH); } } /** * Run the precapture sequence for capturing a still image. This method should be called when * we get a response in {@link #cameraCaptureSessionCaptureCallback} from {@link #lockFocus()}. */ private void runPrecaptureSequence() { try { // This is how to tell the camera to trigger. previewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START); // Tell #mCaptureCallback to wait for the precapture sequence to be set. state = STATE_WAITING_PRECAPTURE; captureSession.capture(previewRequestBuilder.build(), cameraCaptureSessionCaptureCallback, handler); } catch (CameraAccessException e) { e.printStackTrace(); } } @Override public void setCameraFacing(CameraFacing cameraFacing) { } @Override public void setOrientation(Orientation orientation) { } @Override public void setQuality(Quality quality) { } /** * Compares two {@code Size}s based on their areas. */ static class CompareSizesByArea implements Comparator { @Override public int compare(Size lhs, Size rhs) { // We cast here to ensure the multiplications won't overflow return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight()); } } /** * Given {@code choices} of {@code Size}s supported by a camera, choose the smallest one that * is at least as large as the respective texture view size, and that is at most as large as the * respective max size, and whose aspect ratio matches with the specified value. If such size * doesn't exist, choose the largest one that is at most as large as the respective max size, * and whose aspect ratio matches with the specified value. * * @param choices The list of sizes that the camera supports for the intended output * class * @param textureViewWidth The width of the texture view relative to sensor coordinate * @param textureViewHeight The height of the texture view relative to sensor coordinate * @param maxWidth The maximum width that can be chosen * @param maxHeight The maximum height that can be chosen * @param aspectRatio The aspect ratio * @return The optimal {@code Size}, or an arbitrary one if none were big enough */ private static Size chooseOptimalSize(Size[] choices, int textureViewWidth, int textureViewHeight, int maxWidth, int maxHeight, Size aspectRatio) { // Collect the supported resolutions that are at least as big as the preview Surface List bigEnough = new ArrayList<>(); // Collect the supported resolutions that are smaller than the preview Surface List notBigEnough = new ArrayList<>(); int w = aspectRatio.getWidth(); int h = aspectRatio.getHeight(); for (Size option : choices) { if (option.getWidth() <= maxWidth && option.getHeight() <= maxHeight && option.getHeight() == option.getWidth() * h / w) { if (option.getWidth() >= textureViewWidth && option.getHeight() >= textureViewHeight) { bigEnough.add(option); } else { notBigEnough.add(option); } } } // Pick the smallest of those big enough. If there is no one big enough, pick the // largest of those not big enough. if (bigEnough.size() > 0) { return Collections.min(bigEnough, new CompareSizesByArea()); } else if (notBigEnough.size() > 0) { return Collections.max(notBigEnough, new CompareSizesByArea()); } else { Log.e(TAG, "Couldn't find any suitable preview size"); return choices[0]; } } private void requestCameraPermission() { // if (FragmentCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) { // new ConfirmationDialog().show(getChildFragmentManager(), FRAGMENT_DIALOG); // } else { // FragmentCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, // REQUEST_CAMERA_PERMISSION); // } } /** * 处理实时捕获摄像机数据 * * @param session session * @param request request * @param result result */ private void handleCaptureOutputBuffer(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) { // if (null == this.onCaptureOutputBuffer) { // } if (result.get(CaptureResult.CONTROL_AF_STATE) == CaptureRequest.CONTROL_AF_STATE_PASSIVE_FOCUSED) { previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START); previewRequestBuilder.addTarget(captureOutputBufferImageReader.getSurface()); try { captureSession.setRepeatingRequest(previewRequestBuilder.build(), new CaptureOutputBufferCameraCaptureSessionCaptureCallback(), handler); } catch (CameraAccessException e) { Log.e(TAG, e.getMessage(), e); } } } private class CameraDeviceStateCallback extends CameraDevice.StateCallback { @Override public void onOpened(@NonNull CameraDevice camera) { // This method is called when the camera is opened. We start camera preview here. cameraOpenCloseLock.release(); cameraDevice = camera; createCameraPreviewSession(); } @Override public void onDisconnected(@NonNull CameraDevice camera) { Log.i(TAG, "Camera Disconnected"); cameraOpenCloseLock.release(); cameraDevice.close(); cameraDevice = null; } @Override public void onError(@NonNull CameraDevice camera, int error) { Log.e(TAG, "Camera Error = " + error); cameraOpenCloseLock.release(); cameraDevice.close(); cameraDevice = null; } } private class CameraCaptureSessionCaptureCallback extends CameraCaptureSession.CaptureCallback { private void process(CaptureResult result) { switch (state) { 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) { 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) { state = STATE_PICTURE_TAKEN; 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) { state = 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) { state = STATE_PICTURE_TAKEN; captureStillPicture(); } break; } } } @Override public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) { process(partialResult); } @Override public void onCaptureCompleted(@NonNull final CameraCaptureSession session, @NonNull final CaptureRequest request, @NonNull final TotalCaptureResult result) { process(result); new GuardedResultAsyncTask((ReactContext) getContext()) { @Override protected Void doInBackgroundGuarded() { handleCaptureOutputBuffer(session, request, result); return null; } @Override protected void onPostExecuteGuarded(Void o) { } }.execute(); } } /** * 实时捕获图像CameraCaptureSession.CaptureCallback */ private class CaptureOutputBufferCameraCaptureSessionCaptureCallback extends CameraCaptureSession.CaptureCallback { @Override public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) { Image image = imageReader.acquireLatestImage(); if (null != image) { Image.Plane[] planes = image.getPlanes(); ByteBuffer byteBuffer = planes[0].getBuffer(); byte[] bytes = new byte[byteBuffer.remaining()]; byteBuffer.get(bytes); String imgBase64 = Base64.encodeToString(bytes, Base64.DEFAULT); image.close(); WritableMap response = Arguments.createMap(); response.putString("buffer", imgBase64); RCTEventEmitter eventEmitter = ((ReactContext) getContext()).getJSModule(RCTEventEmitter.class); eventEmitter.receiveEvent(getId(), CAPTURE_OUTPUT_BUFFER_EVENT, response); } } } private class ImageReaderOnImageAvailableListener implements ImageReader.OnImageAvailableListener { @Override public void onImageAvailable(ImageReader reader) { Log.d(TAG, "ImageReader.OnImageAvailableListener"); } } public void setCameraManager(CameraManager cameraManager) { this.cameraManager = cameraManager; } public void setCameraId(String cameraId) { this.cameraId = cameraId; } public ImageReader getImageReader() { return imageReader; } public CaptureRequest.Builder getPreviewRequestBuilder() { return previewRequestBuilder; } public void setPreviewRequestBuilder(CaptureRequest.Builder previewRequestBuilder) { this.previewRequestBuilder = previewRequestBuilder; } public CaptureRequest getPreviewRequest() { return previewRequest; } public CameraDevice getCameraDevice() { return cameraDevice; } public void setPreviewRequest(CaptureRequest previewRequest) { this.previewRequest = previewRequest; } public Handler getBackgroundHandler() { return handler; } public CameraCaptureSession getCaptureSession() { return captureSession; } public void setCaptureSession(CameraCaptureSession captureSession) { this.captureSession = captureSession; } public Callback getOnCaptureOutputBuffer() { return onCaptureOutputBuffer; } public void setOnCaptureOutputBuffer(Callback onCaptureOutputBuffer) { this.onCaptureOutputBuffer = onCaptureOutputBuffer; } }