private boolean getFlashMode(CallbackContext callbackContext) {
  if(this.hasCamera(callbackContext) == false){
    return true;
  }

  Camera camera = fragment.getCamera();
  Camera.Parameters params = camera.getParameters();

  String flashMode = params.getFlashMode();

  if (flashMode != null ) {
    callbackContext.success(flashMode);
  } else {
    callbackContext.error("FlashMode not supported");
  }

  return true;
}
 

public int getCameraDisplayOrientation() {
    Camera.CameraInfo info =
            new Camera.CameraInfo();
    Camera.getCameraInfo(currentCameraId, info);
    int rotation = context.getWindowManager().getDefaultDisplay()
            .getRotation();
    int degrees = 0;
    switch (rotation) {
        case Surface.ROTATION_0: degrees = 0; break;
        case Surface.ROTATION_90: degrees = 90; break;
        case Surface.ROTATION_180: degrees = 180; break;
        case Surface.ROTATION_270: degrees = 270; break;
    }

    int result;
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        result = (info.orientation + degrees) % 360;
        result = (360 - result) % 360;  // compensate the mirror
    } else {  // back-facing
        result = (info.orientation - degrees + 360) % 360;
    }
    return result;
}
 

public VideoCaptureAndroid(int id, long native_capturer) {
  this.id = id;
  this.native_capturer = native_capturer;
  this.info = new Camera.CameraInfo();
  Camera.getCameraInfo(id, info);

  // Must be the last thing in the ctor since we pass a reference to |this|!
  final VideoCaptureAndroid self = this;
  orientationListener = new OrientationEventListener(GetContext()) {
      @Override public void onOrientationChanged(int degrees) {
        if (degrees == OrientationEventListener.ORIENTATION_UNKNOWN) {
          return;
        }
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
          degrees = (info.orientation - degrees + 360) % 360;
        } else {  // back-facing
          degrees = (info.orientation + degrees) % 360;
        }
        self.OnOrientationChanged(self.native_capturer, degrees);
      }
    };
  // Don't add any code here; see the comment above |self| above!
}
 

public void setZoom(int zoom) {
    if (!isZoomSupported()){
        Log.d("setZoom","false");
        return;
    }
    try {
        Camera.Parameters params = mCamera.getParameters();
        final int MAX = params.getMaxZoom();
        if(MAX==0)return;

        int zoomValue = params.getZoom();
        zoomValue += zoom;
        params.setZoom(zoomValue);
        mCamera.setParameters(params);

    }catch (Exception e){
        Log.d(TAG,"变焦异常");
    }

}
 

public static boolean isFlashSupported(Camera camera) {
    /* Credits: Top answer at http://stackoverflow.com/a/19599365/868173 */
    if (camera != null) {
        Camera.Parameters parameters = camera.getParameters();

        if (parameters.getFlashMode() == null) {
            return false;
        }

        List<String> supportedFlashModes = parameters.getSupportedFlashModes();
        if (supportedFlashModes == null || supportedFlashModes.isEmpty() || supportedFlashModes.size() == 1 && supportedFlashModes.get(0).equals(Camera.Parameters.FLASH_MODE_OFF)) {
            return false;
        }
    } else {
        return false;
    }

    return true;
}
 

public static void setBestExposure(Camera.Parameters parameters,
		boolean lightOn) {
	int minExposure = parameters.getMinExposureCompensation();
	int maxExposure = parameters.getMaxExposureCompensation();
	float step = parameters.getExposureCompensationStep();
	if ((minExposure != 0 || maxExposure != 0) && step > 0.0f) {
		// Set low when light is on
		float targetCompensation = lightOn ? MIN_EXPOSURE_COMPENSATION
				: MAX_EXPOSURE_COMPENSATION;
		int compensationSteps = Math.round(targetCompensation / step);
		float actualCompensation = step * compensationSteps;
		// Clamp value:
		compensationSteps = Math.max(
				Math.min(compensationSteps, maxExposure), minExposure);
		if (parameters.getExposureCompensation() == compensationSteps) {
			Log.i(TAG, "Exposure compensation already set to "
					+ compensationSteps + " / " + actualCompensation);
		} else {
			Log.i(TAG, "Setting exposure compensation to "
					+ compensationSteps + " / " + actualCompensation);
			parameters.setExposureCompensation(compensationSteps);
		}
	} else {
		Log.i(TAG, "Camera does not support exposure compensation");
	}
}
 

public boolean turnOnFlashLight() {
    if (camera == null) {
        camera = Camera.open();
        camera.startPreview();
        Camera.Parameters parameter = camera.getParameters();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ECLAIR) {
            parameter.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
        } else {
            parameter.set("flash-mode", "torch");
        }
        camera.setParameters(parameter);
        handler.removeCallbacksAndMessages(null);
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                turnOffFlashLight();
            }
        }, OFF_TIME);
    }
    return true;
}
 

private int determineCameraId() {
    final int cameraCount = Camera.getNumberOfCameras();
    final CameraInfo cameraInfo = new CameraInfo();

    // prefer back-facing camera
    for (int i = 0; i < cameraCount; i++) {
        Camera.getCameraInfo(i, cameraInfo);
        if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK)
            return i;
    }

    // fall back to front-facing camera
    for (int i = 0; i < cameraCount; i++) {
        Camera.getCameraInfo(i, cameraInfo);
        if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT)
            return i;
    }

    return -1;
}
 

private void openCamera() {
    Camera.CameraInfo info = new Camera.CameraInfo();

    // Try to find a front-facing camera (e.g. for videoconferencing).
    int numCameras = Camera.getNumberOfCameras();
    for (int i = 0; i < numCameras; i++) {
        Camera.getCameraInfo(i, info);
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            mCamera = Camera.open(i);
            break;
        }
    }
    if (mCamera == null) {
        mCamera = Camera.open();    // opens first back-facing camera
    }

    Camera.Parameters parms = mCamera.getParameters();

    CameraUtils.choosePreviewSize(parms, 1280, 720);
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	
	// Force switch to landscape orientation
	setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

	// Check which camera to use
	for (int i = 0, cameras = Camera.getNumberOfCameras(); i < cameras; i++) {
		Camera.CameraInfo info = new Camera.CameraInfo();
		Camera.getCameraInfo(i, info);
		
		if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
			_cameraid = i;
			break;
		}
	}
	
	_surface = new GLSurfaceView(this);
	_surface.setEGLContextClientVersion(2);

	_renderer = new PreviewRenderer(this);
	_surface.setRenderer(_renderer);

	setContentView(_surface);
}
 

public void requestZoom(double zoomValue){
    Log.d(TAG, "requestZoom: "+zoomValue+" "+lastZoomValueRec+" "+lastZoomValue);
    synchronized (this) {
        if (camera != null) {
            Camera.Parameters p = camera.getParameters();
            if(p.isZoomSupported()){
                lastZoomValueRec +=zoomValue;
                lastZoomValueRec=Math.max(0,Math.min(lastZoomValueRec,1.0));
                int curZoom= (int) (lastZoomValueRec*p.getMaxZoom());
                if(Math.abs(curZoom-lastZoomValue)>=1){
                    lastZoomValue= curZoom;
                    p.setZoom(lastZoomValue);
                }
            }else return;
            camera.setParameters(p);
        }
    }
}
 

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
    Log.d(TAG, "onCreateView for Camera2VideoFragment");
    View view = inflater.inflate(R.layout.fragment_camera2_video, container, false);

    if (mVideoPreviewFrame != null) {
        if (mCurrentApiVersion  >= Build.VERSION_CODES.JELLY_BEAN_MR2 &&
            mCurrentApiVersion  <= Build.VERSION_CODES.KITKAT) {
            createVideoPreviewWindow(Camera.CameraInfo.CAMERA_FACING_BACK);
        }
        if (mCurrentApiVersion >= Build.VERSION_CODES.LOLLIPOP) {
            createVideoPreviewWindowEnhanced();
        }
    }

    return view;
}
 

public void startPreview(final CameraSession session) {
    if (session == null) {
        return;
    }
    threadPool.execute(new Runnable() {
        @SuppressLint("NewApi")
        @Override
        public void run() {
            Camera camera = session.cameraInfo.camera;
            try {
                if (camera == null) {
                    camera = session.cameraInfo.camera = Camera.open(session.cameraInfo.cameraId);
                }
                camera.startPreview();
            } catch (Exception e) {
                session.cameraInfo.camera = null;
                if (camera != null) {
                    camera.release();
                }
                FileLog.e(e);
            }
        }
    });
}
 

private int getPhotoRotation() {
    int rotation;
    int orientation = mPhotoAngle;

    Camera.CameraInfo info = new Camera.CameraInfo();
    if (cameraFacing == 0) {
        Camera.getCameraInfo(0, info);
    } else {
        Camera.getCameraInfo(1, info);
    }

    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        rotation = (info.orientation - orientation + 360) % 360;
    } else {
        rotation = (info.orientation + orientation) % 360;
    }

    return rotation;
}
 

/**
 * Sets the flash mode.
 *
 * @param mode flash mode.
 * @return {@code true} if the flash mode is set, {@code false} otherwise
 * @see #getFlashMode()
 */
public boolean setFlashMode(@FlashMode String mode) {
    synchronized (cameraLock) {
        if (camera != null && mode != null) {
            Camera.Parameters parameters = camera.getParameters();
            if (parameters.getSupportedFlashModes().contains(mode)) {
                parameters.setFlashMode(mode);
                camera.setParameters(parameters);
                flashMode = mode;
                return true;
            }
        }

        return false;
    }
}
 

@SuppressLint("NewApi")
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
		Bundle savedInstanceState) {
	View view = super.onCreateView(inflater, container, savedInstanceState);

	nv21 = new byte[PREVIEW_WIDTH * PREVIEW_HEIGHT * 2];

	this.setPreviewCallback(new PreviewCallback() {
		@Override
		public void onPreviewFrame(byte[] data, Camera camera) {
			synchronized (nv21) {
				System.arraycopy(data, 0, nv21, 0, data.length);
				isNV21ready = true;
			}
		}

	});
	return view;
}
 

/**
 * Reads, one time, values from the camera that are needed by the app.
 */
void initFromCameraParameters(Camera camera) {
    Camera.Parameters parameters = camera.getParameters();
    previewFormat = parameters.getPreviewFormat();
    previewFormatString = parameters.get("preview-format");
    Log.d(TAG, "Default preview format: " + previewFormat + '/' + previewFormatString);
    WindowManager manager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = manager.getDefaultDisplay();
    screenResolution = new Point(display.getWidth(), display.getHeight());
    Log.d(TAG, "Screen resolution: " + screenResolution);

    //图片拉伸
    Point screenResolutionForCamera = new Point();
    screenResolutionForCamera.x = screenResolution.x;
    screenResolutionForCamera.y = screenResolution.y;
    // preview size is always something like 480*320, other 320*480
    if (screenResolution.x < screenResolution.y) {
        screenResolutionForCamera.x = screenResolution.y;
        screenResolutionForCamera.y = screenResolution.x;
    }

    cameraResolution = getCameraResolution(parameters, screenResolutionForCamera);
    Log.d(TAG, "Camera resolution: " + screenResolution);

}
 

private static String toString(Iterable<Camera.Area> areas) {
  if (areas == null) {
    return null;
  }
  StringBuilder result = new StringBuilder();
  for (Camera.Area area : areas) {
    result.append(area.rect).append(':').append(area.weight).append(' ');
  }
  return result.toString();
}
 

public void setCamera(Camera camera) {
    mCamera = camera;
    if (mCamera != null) {
        mSupportedPreviewSizes = mCamera.getParameters()
                .getSupportedPreviewSizes();
        requestLayout();
    }
}
 

private Point[] toPointArray(List<Camera.Size> supportedPictureSizes) {
    ArrayList<Point> result = new ArrayList<>();
    for (Camera.Size s : supportedPictureSizes) {
        result.add(new Point(s.width, s.height));
    }
    return result.toArray(new Point[0]);
}
 

public void switchCamera(Camera camera) {
    setCamera(camera);
    try {
        camera.setPreviewDisplay(mHolder);
    } catch (IOException exception) {
        Log.e(TAG, "IOException caused by setPreviewDisplay()", exception);
    }
}
 

@Override
public void onResume() {
    super.onResume();

    // Open the default i.e. the first rear facing camera.
    mCamera = Camera.open(mDefaultCameraId);
    mCameraCurrentlyLocked = mDefaultCameraId;
    mPreview.setCamera(mCamera);
}
 

@Override
   public void onConfigurationChanged(Configuration newConfig) {
     if (mCamera != null) {
       PictureCallback cb = new PictureCallback() {
  @Override
  public void onPictureTaken(byte[] data, Camera camera) {}
};
mCamera.takePicture(null, null, cb);
     }
   }
 

private int getCurrentCameraId() {
    int cameraId = -1;
    int numberOfCameras = Camera.getNumberOfCameras();
    for (int i = 0; i < numberOfCameras; i++) {
        CameraInfo info = new CameraInfo();
        Camera.getCameraInfo(i, info);
        if (info.facing == getCurrentCameraFacing()) {
            cameraId = i;
            break;
        }
    }
    return cameraId;
}
 

/**
 * See http://stackoverflow.com/a/19434459/552902
 *
 * @param mCamera
 */
public static void googleGlassXE10WorkAround(Camera camera) {
    Camera.Parameters params = camera.getParameters();
    params.setPreviewFpsRange(30000, 30000);
    params.setPreviewSize(640, 360);
    //        if (params.isZoomSupported()) {
    //            Log.v("@@@@@@@@@", "zoom is supported!");
    //            Log.v("@@@@@@@@@", "zoom max: " + params.getMaxZoom());
    //            params.setZoom(10);
    //        } else {
    //            Log.w("@@@@@@@@@", "zoom is NOT supported!");
    //        }
    camera.setParameters(params);
}
 

@Override
public void onPreviewFrame(byte[] frame, Camera arg1) {
    if (BuildConfig.DEBUG)
        Log.d(TAG, "Preview Frame received. Frame size: " + frame.length);
    synchronized (this) {
        mFrameChain[mChainIdx].put(0, 0, frame);
        mCameraFrameReady = true;
        this.notify();
    }
    if (mCamera != null)
        mCamera.addCallbackBuffer(mBuffer);
}
 

/**
 * @param sizes
 * @param defaultSize
 * @param pictureSize 图片的大小
 * @param minRatio preview短边比长边所接受的最小比例
 * @return
 */
private Camera.Size findBestPreviewSize(List<Camera.Size> sizes, Camera.Size defaultSize,
                                        Camera.Size pictureSize, float minRatio) {
    final int pictureWidth = pictureSize.width;
    final int pictureHeight = pictureSize.height;
    boolean isBestSize = (pictureHeight / (float)pictureWidth) > minRatio;
    sortSizes(sizes);

    Iterator<Camera.Size> it = sizes.iterator();
    while (it.hasNext()) {
        Camera.Size size = it.next();
        if ((float) size.height / size.width <= minRatio) {
            it.remove();
            continue;
        }

        // 找到同样的比例，直接返回
        if (isBestSize && size.width * pictureHeight == size.height * pictureWidth) {
            return size;
        }
    }

    // 未找到同样的比例的，返回尺寸最大的
    if (!sizes.isEmpty()) {
        return sizes.get(0);
    }

    // 没得选，默认吧
    return defaultSize;
}
 

private void openCamera(int CameraFacing){
		if (null != mCamera) {
			mCamera.setPreviewCallback(null);
			mCamera.stopPreview();
			mCamera.release();
			mCamera = null;
		}
		CameraInfo info = new CameraInfo();
		for(int i = 0; i < Camera.getNumberOfCameras(); i++) {
			Camera.getCameraInfo(i, info);
			if(info.facing == CameraFacing) {
				try{
					mCamera = Camera.open(i);
					mCameraInfo = info;
				} catch(RuntimeException e) {
					e.printStackTrace();
					mCamera = null;
					continue;
				}
				break;
			}
		}
		try {
			Log.i(TAG, "SurfaceHolder.Callback?surface Created");
			mCamera.setPreviewDisplay(mSurfaceHolder);// set the surface to be used for live preview
			initCamera();
		} catch (Exception ex) {
			if (null != mCamera) {
				mCamera.release();
				mCamera = null;
			}
//			Log.i(TAG + "initCamera", ex.getMessage());
		}
	}
 

public void onPreviewFrame(byte[] data, Camera camera) {
  Point cameraResolution = configManager.getCameraResolution();
  if (!useOneShotPreviewCallback) {
    camera.setPreviewCallback(null);
  }
  if (previewHandler != null) {
    Message message = previewHandler.obtainMessage(previewMessage, cameraResolution.x,
        cameraResolution.y, data);
    message.sendToTarget();
    previewHandler = null;
  } else {
    Log.d(TAG, "Got preview callback, but no handler for it");
  }
}
 

public void setPreviewCallback(Camera.PreviewCallback previewCallback) {
  this.previewCallback = previewCallback;

  if (isOpen()) {
    openCamera.getCamera().setPreviewCallback(previewCallback);
  }
}