Camera1Controller.java

/*
 * Copyright 2016 Maxst, Inc. All Rights Reserved.
 */

package com.maxst.ar;

import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.ImageFormat;
import android.graphics.PixelFormat;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.hardware.Camera.PreviewCallback;
import android.hardware.Camera.Size;
import android.os.Build;
import android.util.Log;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@SuppressWarnings("deprecation")
class Camera1Controller extends CameraController implements PreviewCallback /*, SurfaceHolder.Callback */ {
    private static final String TAG = Camera1Controller.class.getSimpleName();

    private Camera camera;
    private CameraSize cameraSize = new CameraSize(0, 0);
    private boolean keepAlive = true;
    private int cameraId;
    private int preferredWidth = 640;
    private int preferredHeight = 480;
    private static final String TRUE = "true";
    private static final String FALSE = "false";

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

    private int startInternal() {
        if (camera != null && keepAlive != false) {
            return ResultCode.UnknownError.getValue();
        }

        try {

            camera = Camera.open(cameraId);

            Camera.Parameters params = camera.getParameters();
            List<String> focusModes = params.getSupportedFocusModes();

            if (Build.MODEL.equalsIgnoreCase("embt2") || Build.MODEL.equalsIgnoreCase("EMBT3C")) {
                Log.i(TAG, "This is moverio camera. Skip focus mode setting");
            } else {
                if (focusModes != null && focusModes.size() > 0) {
                    if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
                        Log.i(TAG, "FOCUS_MODE_CONTINUOUS_VIDEO");
                    } else if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
                        Log.i(TAG, "FOCUS_MODE_CONTINUOUS_VIDEO");
                    } else if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
                        Log.i(TAG, "FOCUS_MODE_AUTO");
                    }
                }
            }

            List<Integer> formats = params.getSupportedPreviewFormats();

            List<Size> cameraPreviewList = params.getSupportedPreviewSizes();
            ArrayList<CameraSize> cameraSizes = new ArrayList<>();
            for (Size size : cameraPreviewList) {
                cameraSizes.add(new CameraSize(size.width, size.height));
            }

            cameraSize = getOptimalPreviewSize(cameraSizes, preferredWidth, preferredHeight);

            params.setPreviewSize(cameraSize.width, cameraSize.height);
            params.setPreviewFormat(ImageFormat.NV21);

            PixelFormat p = new PixelFormat();
            PixelFormat.getPixelFormatInfo(params.getPreviewFormat(), p);

            int bufSize = (cameraSize.width * cameraSize.height * p.bitsPerPixel) / 8 * 2;
            byte[] buffer = new byte[bufSize];

            camera.addCallbackBuffer(buffer);
            buffer = new byte[bufSize];
            camera.addCallbackBuffer(buffer);
            buffer = new byte[bufSize];
            camera.addCallbackBuffer(buffer);
            buffer = new byte[bufSize];
            camera.addCallbackBuffer(buffer);
            camera.setPreviewCallbackWithBuffer(this);

            try {
                camera.setParameters(params);
            } catch (Exception e) {
                Log.d(Camera1Controller.TAG, "setParameters fails");
            }

            keepAlive = true;

            try {
                int textureID = -1;
                if (cameraSurfaceTexture == null) {
                    cameraSurfaceTexture = new SurfaceTexture(textureID);
                }

                camera.setPreviewTexture(cameraSurfaceTexture);
                camera.startPreview();
            } catch (IOException e) {
                e.printStackTrace();
                return ResultCode.UnknownError.getValue();
            }

        } catch (Exception e) {
            Log.i("JLog", "Camera normal exception");
            return ResultCode.UnknownError.getValue();
        }

        return ResultCode.Success.getValue();

    }

    @Override
    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() {
            Camera1Controller.this.cameraId = cameraId;
            Camera1Controller.this.preferredWidth = width;
            Camera1Controller.this.preferredHeight = height;

            if (camera != null) {
                return ResultCode.CameraAlreadyOpened.getValue();
            }

            keepAlive = true;
            return startInternal();
//          }
//      });
//          return ResultCode.Success.getValue();
        }
    }

    @Override
    void stop() {

//      cameraHandler.post(new Runnable() {
//          @Override
//          public void run() {
                if (camera == null) {
                    return;
                }
                camera.lock();
                camera.setPreviewCallback(null);
                camera.setPreviewCallbackWithBuffer(null);


                if (cameraSurfaceTexture != null) {
                    cameraSurfaceTexture.setOnFrameAvailableListener(null);
                    cameraSurfaceTexture.release();
                    cameraSurfaceTexture = null;
                }

                if(cameraSize != null) {
                    cameraSize.width = 0;
                    cameraSize.height = 0;
                }

                camera.stopPreview();
                camera.release();
                camera = null;
                keepAlive = false;

                Log.i(TAG, "Android camera stop");
//          }
//      });
    }

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

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

    @Override
    public void onPreviewFrame(byte[] data, Camera camera) {
        if (keepAlive) {
            if(data != null) {
                CameraController.setNewCameraFrame(data, data.length, cameraSize.width, cameraSize.height, ColorFormat.YUV420sp.getValue());
                camera.addCallbackBuffer(data);
            }
        }
    }

    @Override
    boolean setFocusMode(int focusMode) {
        boolean doPostSetAction = false;
        if (camera == null) {
            return false;
        }

        try {
            Camera.Parameters params = camera.getParameters();
            List<String> focusModes = params.getSupportedFocusModes();

            camera.cancelAutoFocus();

            CameraDevice.FocusMode focusModeEnum = CameraDevice.FocusMode.values()[focusMode - 1];
            switch (focusModeEnum) {
                case FOCUS_MODE_CONTINUOUS_AUTO:
                    if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
                    } else {
                        return false;
                    }
                    break;

                case FOCUS_MODE_AUTO:
                    params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
                    doPostSetAction = true;
                    break;

                default:
                    // Do nothing
            }

            camera.setParameters(params);

            if (doPostSetAction) {
                camera.autoFocus(new Camera.AutoFocusCallback() {

                    @Override
                    public void onAutoFocus(boolean success, Camera camera) {

                    }
                });
            }

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @Override
    public Object [] getParamList() {
        String [] paramArray = null;
        List<String> paramList = new ArrayList<>();

        try {
            Camera.Parameters params = camera.getParameters();
            paramArray = params.flatten().split("[=;]");
            for (int i = 0; i < paramArray.length / 2; i++) {
                paramList.add(paramArray[i * 2]);
            }
        } catch (Exception e) {
            Log.d(TAG, "Exception : " + e.getMessage());
        }

        return paramList.toArray();
    }

    @Override
    public boolean setParam(String key, String value) {
        try {
            Camera.Parameters params = camera.getParameters();
            params.set(key, value);
            camera.setParameters(params);
        } catch (Exception e) {
            Log.e("CameraDevice", "Set configuration error");
            return false;
        }
        return true;
    }

    @Override
    boolean setFlashLightMode(boolean toggle) {
        if(camera == null) {
            return false;
        }

        Camera.Parameters params = camera.getParameters();
        if (toggle) {
            params.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
        } else {
            params.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
        }

        try {
            camera.setParameters(params);
        } catch (Exception e) {
            Log.e("CameraDevice", "setFlashLightMode error");
            return false;
        }

        return true;
    }

    @Override
    boolean setAutoWhiteBalanceLock(boolean toggle) {
        if(camera == null) {
            return false;
        }

        Camera.Parameters params = camera.getParameters();
        params.setAutoWhiteBalanceLock(toggle);

        try {
            camera.setParameters(params);
        } catch (Exception e) {
            Log.e("CameraDevice", "setAutoWhiteBalanceLock error");
            return false;
        }

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