Camera2Controller.java

/*
 * Copyright 2016 Maxst, Inc. All Rights Reserved.
 */
package com.maxst.ar;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.ImageFormat;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.Image;
import android.media.ImageReader;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.util.Size;
import android.view.Surface;

import junit.framework.Assert;

import java.util.ArrayList;
import java.util.List;

@TargetApi(Build.VERSION_CODES.M)
class Camera2Controller extends CameraController /*implements SurfaceHolder.Callback*/ {
    private static final String TAG = Camera2Controller.class.getSimpleName();

    private CameraSize cameraSize = new CameraSize(0, 0);
    private byte[] yuvBuffer = null;

    private static final int REQUEST_CAMERA_PERMISSION = 1;

    private HandlerThread backgroundThread;
    private Handler backgroundHandler;
    private ImageReader previewReader;
    private CameraDevice cameraDevice;

    private CaptureRequest.Builder previewRequestBuilder;
    private CameraCaptureSession captureSession;
    private CaptureRequest previewRequest;
    private boolean keepSendNewFrame = false;

    Camera2Controller() {
//      cameraHandler = new Handler(Looper.getMainLooper());
    }

    private void startInternal(int id, int width, int height) {
        startBackgroundThread();

        try {
            CameraManager manager = (CameraManager) MaxstARJNI.getContext().getSystemService(Context.CAMERA_SERVICE);
            String strCameraId = manager.getCameraIdList()[id];
            CameraCharacteristics characteristics = manager.getCameraCharacteristics(strCameraId);

            StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            Size[] sizes = map.getOutputSizes(ImageFormat.YUV_420_888);

            ArrayList<CameraSize> cameraSizes = new ArrayList<>();
            for (Size size : sizes) {
                cameraSizes.add(new CameraSize(size.getWidth(), size.getHeight()));
            }

            cameraSize = getOptimalPreviewSize(cameraSizes, width, height);

            previewReader = ImageReader.newInstance(cameraSize.width, cameraSize.height, ImageFormat.YUV_420_888, 2);
            previewReader.setOnImageAvailableListener(mOnPreviewFrameListener, null);
//          manager.openCamera(strCameraId, mStateCallback, backgroundHandler);
            manager.openCamera(strCameraId, mStateCallback, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
            cameraState = CameraState.None;
        }
    }

    private int testCount = 0;

    @Override
    public int start(final int cameraId, final int width, final int height) {
        if (!checkPermission()) {
            return ResultCode.CameraPermissionIsNotGranted.getValue();
        } else {
//      cameraHandler.post(new Runnable() {
//          @Override
//          public void run() {
            if (cameraState != CameraState.None && cameraState != CameraState.Closed) {
                return ResultCode.CameraAlreadyOpened.getValue();
            }

            cameraState = CameraState.Opening;
            startInternal(cameraId, width, height);
//          }
//      });
            return ResultCode.Success.getValue();
        }
    }

    @Override
    public void stop() {

        keepSendNewFrame = false;

//      cameraHandler.post(new Runnable() {
//          @Override
//          public void run() {
                if (cameraState != CameraState.Opened) {
                    return;
                }

                cameraState = CameraState.Closing;

                closeCamera();
                stopBackgroundThread();
                cameraSize.width = 0;
                cameraSize.height = 0;
                if (cameraSurfaceTexture != null) {
                    cameraSurfaceTexture.release();
                    cameraSurfaceTexture = null;
                }

                cameraState = CameraState.Closed;
//          }
//      });
    }

    private final ImageReader.OnImageAvailableListener mOnPreviewFrameListener = new ImageReader.OnImageAvailableListener() {
        @Override
        public void onImageAvailable(final ImageReader reader) {
            ColorFormat colorFormat = ColorFormat.YUV420_888;

            Image acquiredImage = reader.acquireNextImage();
            if (acquiredImage == null) {
                return;
            }

            Assert.assertTrue("Image format is not ImageFormat.YUV_420_888", acquiredImage.getFormat() == ImageFormat.YUV_420_888);

            int width = acquiredImage.getWidth();
            int height = acquiredImage.getHeight();


            Image.Plane yPlane = acquiredImage.getPlanes()[0];
            int ySize = yPlane.getBuffer().remaining();

            Image.Plane uPlane = acquiredImage.getPlanes()[1];
            Image.Plane vPlane = acquiredImage.getPlanes()[2];

            // be aware that this size does not include the padding at the end, if there is any
            // (e.g. if pixel stride is 2 the size is ySize / 2 - 1)
            int uSize = uPlane.getBuffer().remaining();
            int vSize = vPlane.getBuffer().remaining();

            int margin = 0;
            if (ySize / 2 - vSize > 0) {
                margin = ySize / 2 - vSize;
            }

            if (yuvBuffer == null || yuvBuffer.length < ySize + uSize + vSize) {
                yuvBuffer = new byte[ySize + uSize + vSize + 100]; // Preventing overflow. 100 has no meaning.
            }

            yPlane.getBuffer().get(yuvBuffer, 0, ySize);

            int uvPixelStride = uPlane.getPixelStride(); //stride guaranteed to be the same for u and v planes
            if (uvPixelStride == 1) {
                uPlane.getBuffer().get(yuvBuffer, ySize, uSize);
                vPlane.getBuffer().get(yuvBuffer, ySize + uSize, vSize);
                colorFormat = ColorFormat.YUV420;
            } else {
                vPlane.getBuffer().get(yuvBuffer, ySize, vSize);
                uPlane.getBuffer().get(yuvBuffer, ySize + vSize + margin, uSize);
                colorFormat = ColorFormat.YUV420_888;

                // Below code consume cpu very high!!
//              vPlane.getBuffer().get(yuvBuffer, ySize, vSize);
//              for (int i = 0; i < uSize; i += 2) {
//                  yuvBuffer[ySize + i + 1] = uPlane.getBuffer().get(i);
//              }
            }

            if (keepSendNewFrame) {
                CameraController.setNewCameraFrame(yuvBuffer, yuvBuffer.length, width, height, colorFormat.getValue());
            }

            acquiredImage.close();
        }
    };

    private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {

        @Override
        public void onOpened(CameraDevice cameraDevice) {
            Camera2Controller.this.cameraDevice = cameraDevice;
            createCameraPreviewSession();
        }

        @Override
        public void onDisconnected(CameraDevice cameraDevice) {
            cameraDevice.close();
            Camera2Controller.this.cameraDevice = null;
            cameraState = CameraState.None;
        }

        @Override
        public void onError(CameraDevice cameraDevice, int error) {
            cameraDevice.close();
            Camera2Controller.this.cameraDevice = null;
            cameraState = CameraState.None;
        }
    };

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void createCameraPreviewSession() {
        try {
//          int[] textureID = new int[1];
//          GLES20.glGenTextures(1, textureID, 0);
//          GLES20.glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureID[0]);
//          GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
//          GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
//          GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
//          GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
//          GLES20.glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
//
//          if (cameraSurfaceTexture == null) {
//              cameraSurfaceTexture = new SurfaceTexture(textureID[0]);
//          }
//
//          Surface surface = new Surface(cameraSurfaceTexture);
            Surface surface = previewReader.getSurface();
            List<Surface> surfaces = new ArrayList<Surface>();
            surfaces.add(surface);

            previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            previewRequestBuilder.addTarget(surface);
//          previewRequestBuilder.addTarget(previewReader.getSurface());

            cameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
                        @Override
                        public void onConfigured(CameraCaptureSession cameraCaptureSession) {
                            if (null == cameraDevice) {
                                return;
                            }
                            captureSession = cameraCaptureSession;
                            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//                          previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_VIDEO);
//                          previewRequestBuilder.set(CaptureRequest.CONTROL_SCENE_MODE, CaptureRequest.CONTROL_SCENE_MODE_SPORTS);
                            previewRequest = previewRequestBuilder.build();
                            try {
//                              captureSession.setRepeatingRequest(previewRequest, null, backgroundHandler);
                                captureSession.setRepeatingRequest(previewRequest, null, null);
                                cameraState = CameraState.Opened;
                                keepSendNewFrame = true;
                            } catch (CameraAccessException e) {
                                e.printStackTrace();
                                cameraState = CameraState.None;
                            }

//                          cameraOpenCloseLock.release();
                        }

                        @Override
                        public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
//                          cameraOpenCloseLock.release();
                            cameraState = CameraState.None;
                        }
                    }, null
            );
        } catch (CameraAccessException e) {
            e.printStackTrace();
            cameraState = CameraState.None;
        }
    }

    private void closeCamera() {
        if (null != captureSession) {
            captureSession.close();
            captureSession = null;
        }

        if (null != previewReader) {
            previewReader.setOnImageAvailableListener(null, null);
            previewReader.close();
            previewReader = null;
        }

        if (null != cameraDevice) {
            cameraDevice.close();
            cameraDevice = null;
        }

        Log.i(TAG, "Android closeCamera completed");

        yuvBuffer = null;
    }

    private void startBackgroundThread() {
        backgroundThread = new HandlerThread("CameraBackground");
        backgroundThread.start();
        backgroundHandler = new Handler(backgroundThread.getLooper());
    }

    private void stopBackgroundThread() {
        backgroundThread.quitSafely();
        try {
            backgroundThread.join();
            backgroundThread = null;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    int getWidth() {
        return cameraSize.width;
    }

    @Override
    int getHeight() {
        return cameraSize.height;
    }

    @Override
    boolean setFocusMode(int focusMode) {
        return false;
    }

    @Override
    boolean setFlashLightMode(boolean on) {
        return false;
    }

    @Override
    boolean setAutoWhiteBalanceLock(boolean toggle) {
        return false;
    }

    @Override
    Object[] getParamList() {
        return new String[0];
    }

    @Override
    boolean setParam(String key, String value) {
        return false;
    }

    private boolean checkPermission() {
        Context androidContext = MaxstARJNI.getContext();
        PackageManager pm = androidContext.getPackageManager();
        int permissionIsGranted = pm.checkPermission("android.permission.CAMERA", androidContext.getPackageName());
        return permissionIsGranted == 0;
    }
}