@Override
public synchronized void start() {
theCamera = Camera.open();
Camera.Parameters myParameters = theCamera.getParameters();
myParameters.setPreviewSize(theCamPreviewWidth, theCamPreviewHeight);
myParameters.setPreviewFpsRange(MIN_FPS, MAX_FPS);
myParameters.setSceneMode(SCENE_MODE_NIGHT);
myParameters.setFocusMode(FOCUS_MODE_AUTO);
myParameters.setWhiteBalance(WHITE_BALANCE_AUTO);
theCamera.setParameters(myParameters);
theCamera.setDisplayOrientation(DISPLAY_ORIENTATION);
}
// Called when holder has changed
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
Camera.Parameters parameters = camera.getParameters();
List<String> focusModes = parameters.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
Log.d("camera", "focus_mode_auto");
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
} else {
Log.d("camera", "focus_mode_macro");
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_MACRO);
}
Log.d("camera", "orientation: " + getResources().getConfiguration().orientation);
int orientation = getResources().getConfiguration().orientation;
switch (orientation) {
case Surface.ROTATION_0:
Log.d("camera", "ROTATION_0");
camera.setDisplayOrientation(180);
break;
case Surface.ROTATION_90:
Log.d("camera", "ROTATION_90");
camera.setDisplayOrientation(90);
break;
case Surface.ROTATION_180:
Log.d("camera", "ROTATION_180");
camera.setDisplayOrientation(0);
break;
case Surface.ROTATION_270:
Log.d("camera", "ROTATION_270");
camera.setDisplayOrientation(270);
break;
}
camera.setParameters(parameters);
camera.startPreview();
}
private void setCameraFocusMode(Camera.Parameters parameters) {
// MODE_INFINITY is preferred mode.
List<String> supportedFocusModes = parameters.getSupportedFocusModes();
if (supportedFocusModes != null) {
if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_INFINITY)) {
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_INFINITY);
Log.v(TAG, "Set focus mode INFINITY");
} else if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_FIXED)) {
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_FIXED);
Log.v(TAG, "Set focus mode FIXED");
} else if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
Log.v(TAG, "Set focus mode AUTO");
}
}
}
@Override
public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i2, int i3) {
Log.e("ok", "surfaceChanged => w=" + i2 + ", h=" + i3);
// before changing the application orientation, you need to stop the preview, rotate and then
// start it again
if (surfaceHolder.getSurface() == null) // check if the surface is ready to receive camera data
return;
try {
mCamera.stopPreview();
} catch (Exception e) {
// this will happen when you are trying the camera if it's not running
}
// now, recreate the camera preview
try {
Camera.Parameters parameters = mCamera.getParameters();
List<String> focusModes = parameters.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
}
parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
mCamera.setParameters(parameters);
mCamera.setDisplayOrientation(90);
mCamera.startPreview(mHolder);
} catch (IOException e) {
Log.d("ERROR", "Camera error on surfaceChanged " + e.getMessage());
}
}
private void initPreview(int width, int height) {
if (camera != null && previewHolder.getSurface() != null) {
try {
camera.setPreviewDisplay(previewHolder);
} catch (Throwable t) {
}
if (!cameraConfigured) {
Camera.Parameters parameters = camera.getParameters();
Camera.Size size = getBestPreviewSize(width, height, parameters);
Camera.Size pictureSize = getLargestPictureSize(parameters);
if (size != null && pictureSize != null) {
if (parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
// set the focus mode
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
}
parameters.setPreviewSize(size.width, size.height);
parameters.setPictureSize(pictureSize.width, pictureSize.height);
parameters.setPictureFormat(ImageFormat.JPEG);
camera.setParameters(parameters);
cameraConfigured = true;
}
}
}
}
@SuppressLint("InlinedApi")
private static void setDesiredCameraParameters(
final Camera camera, final Camera.Size cameraResolution, final boolean continuousAutoFocus) {
final Camera.Parameters parameters = camera.getParameters();
if (parameters == null) return;
final List<String> supportedFocusModes = parameters.getSupportedFocusModes();
final String focusMode =
continuousAutoFocus
? findValue(
supportedFocusModes,
Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE,
Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO,
Camera.Parameters.FOCUS_MODE_AUTO,
Camera.Parameters.FOCUS_MODE_MACRO)
: findValue(
supportedFocusModes,
Camera.Parameters.FOCUS_MODE_AUTO,
Camera.Parameters.FOCUS_MODE_MACRO);
if (focusMode != null) parameters.setFocusMode(focusMode);
parameters.setPreviewSize(cameraResolution.width, cameraResolution.height);
camera.setParameters(parameters);
}
public CustomeCamera(
Activity activity, FrameLayout cameraPreviewLayout, Integer size, Integer quality)
throws Exception {
this.activity = activity;
this.size = size;
this.quality = quality;
// Create an instance of Camera
try {
mCamera = getCameraInstance();
} catch (Exception e) {
throw new Exception(e.getMessage());
}
try {
mCamera.setDisplayOrientation(90);
} catch (Exception e) {
Log.d(TAG, e.getMessage());
}
Camera.CameraInfo info = new Camera.CameraInfo();
Camera.getCameraInfo(Camera.CameraInfo.CAMERA_FACING_BACK, info);
int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break; // Natural orientation
case Surface.ROTATION_90:
degrees = 90;
break; // Landscape left
case Surface.ROTATION_180:
degrees = 180;
break; // Upside down
case Surface.ROTATION_270:
degrees = 270;
break; // Landscape right
}
int rotate = (info.orientation - degrees + 360) % 360;
// STEP #2: Set the 'rotation' parameter
Camera.Parameters params = mCamera.getParameters();
params.setRotation(rotate);
List<String> focusModes = params.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
}
if (params.getFocusMode() == Camera.Parameters.FOCUS_MODE_AUTO) autoFocusEnabled = true;
else autoFocusEnabled = false;
// TODO for the test
autoFocusEnabled = false;
mCamera.setParameters(params);
// Create our Preview view and set it as the content of our activity.
mPreview = new CameraPreview(activity, mCamera);
cameraPreviewLayout.addView(mPreview);
}
void setDesiredCameraParameters(Camera camera, boolean safeMode) {
Camera.Parameters parameters = camera.getParameters();
if (parameters == null) {
Log.w(
TAG,
"Device error: no camera parameters are available. Proceeding without configuration.");
return;
}
Log.i(TAG, "Initial camera parameters: " + parameters.flatten());
if (safeMode) {
Log.w(TAG, "In camera config safe mode -- most settings will not be honored");
}
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
initializeTorch(parameters, prefs, safeMode);
String focusMode = null;
if (prefs.getBoolean(PreferencesActivity.KEY_AUTO_FOCUS, true)) {
if (safeMode || prefs.getBoolean(PreferencesActivity.KEY_DISABLE_CONTINUOUS_FOCUS, false)) {
focusMode =
findSettableValue(
parameters.getSupportedFocusModes(), Camera.Parameters.FOCUS_MODE_AUTO);
} else {
focusMode =
findSettableValue(
parameters.getSupportedFocusModes(),
"continuous-picture", // Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE in 4.0+
"continuous-video", // Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO in 4.0+
Camera.Parameters.FOCUS_MODE_AUTO);
}
}
// Maybe selected auto-focus but not available, so fall through here:
if (!safeMode && focusMode == null) {
focusMode =
findSettableValue(
parameters.getSupportedFocusModes(),
Camera.Parameters.FOCUS_MODE_MACRO,
"edof"); // Camera.Parameters.FOCUS_MODE_EDOF in 2.2+
}
if (focusMode != null) {
parameters.setFocusMode(focusMode);
}
if (prefs.getBoolean(PreferencesActivity.KEY_INVERT_SCAN, false)) {
String colorMode =
findSettableValue(
parameters.getSupportedColorEffects(), Camera.Parameters.EFFECT_NEGATIVE);
if (colorMode != null) {
parameters.setColorEffect(colorMode);
}
}
parameters.setPreviewSize(cameraResolution.x, cameraResolution.y);
camera.setParameters(parameters);
}
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
private boolean prepareVideoRecorder() {
// BEGIN_INCLUDE (configure_preview)
mCamera = CameraHelper.getDefaultCameraInstance();
Camera.Parameters parameters = mCamera.getParameters();
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
mCamera.setDisplayOrientation(90);
mCamera.setParameters(parameters);
// BEGIN_INCLUDE (configure_media_recorder)
mMediaRecorder = new MediaRecorder();
// Step 1: Unlock and set camera to MediaRecorder
mCamera.unlock();
// Camera.Parameters parameters = mCamera.getParameters();
mMediaRecorder.setCamera(mCamera);
CamcorderProfile profile = CamcorderProfile.get(CamcorderProfile.QUALITY_QVGA);
// Log.d(TAG, profile.videoBitRate+"<- videoBitRate r");
profile.videoBitRate = 1024000;
// Step 2: Set sources
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
// Step 3: Set all values contained in profile except audio settings
mMediaRecorder.setOutputFormat(profile.fileFormat);
mMediaRecorder.setVideoEncoder(profile.videoCodec);
mMediaRecorder.setVideoEncodingBitRate(profile.videoBitRate);
mMediaRecorder.setVideoFrameRate(profile.videoFrameRate);
mMediaRecorder.setVideoSize(profile.videoFrameWidth, profile.videoFrameHeight);
mMediaRecorder.setOrientationHint(90);
mMediaRecorder.setVideoFrameRate(24);
// Step 4: Set output file
save_to = CameraHelper.getOutputMediaFile(CameraHelper.MEDIA_TYPE_VIDEO).toString();
mMediaRecorder.setOutputFile(save_to);
mMediaRecorder.setPreviewDisplay(mPreview.getHolder().getSurface());
// Step 5: Prepare configured MediaRecorder
try {
mMediaRecorder.prepare();
} catch (IllegalStateException e) {
Log.d(TAG, "IllegalStateException preparing MediaRecorder: " + e.getMessage());
releaseMediaRecorder();
return false;
} catch (IOException e) {
Log.d(TAG, "IOException preparing MediaRecorder: " + e.getMessage());
releaseMediaRecorder();
return false;
}
return true;
}
private void setupCameraParams() {
if (mCamera != null) {
mCamera.setPreviewCallback(this);
Camera.Parameters params = mCamera.getParameters();
if (params != null) {
List<String> supportedFocusModes = mCamera.getParameters().getSupportedFocusModes();
if (supportedFocusModes != null
&& supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
} else if (supportedFocusModes != null
&& supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)
&& !supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_FIXED)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
mHandler.post(cameraFocusRunner);
}
mCamera.setParameters(params);
}
}
}
private void setIfAutoFocusSupported() {
// get Camera parameters
Camera.Parameters params = mCamera.getParameters();
List<String> focusModes = params.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
mCamera.setParameters(params);
}
}
/** Initialize camera with all good paramters. */
private void initializeCamera() {
// - Open camera.
mEasyCamera = DefaultEasyCamera.open();
// - Make sure preview is not started.
mEasyCamera.stopPreview();
// - Set good parameters.
Camera.Parameters params = mEasyCamera.getParameters();
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
mEasyCamera.setParameters(params);
mEasyCamera.setDisplayOrientation(90);
}
// ---------------------------- CAMERA FUNCTIONS ----------------------------------
private static Camera setCameraInstance() {
Camera c = null;
try {
c = Camera.open(); // attempt to get a Camera instance
Camera.Parameters params = c.getParameters();
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
c.setParameters(params);
} catch (Exception e) {
Log.e(LOG_TAG, "Camera is not available or does not exist.");
e.printStackTrace();
}
return c;
}
/** A safe way to get an instance of the Camera object. */
private Camera getCameraInstance() {
Camera c = null;
try {
cameraId = 0;
c = Camera.open(); // attempt to get a Camera instance
Camera.Parameters p = c.getParameters();
p.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
c.setParameters(p);
} catch (Exception e) {
// Camera is not available (in use or does not exist)
}
return c; // returns null if camera is unavailable
}
public synchronized void setupCamera(int width, int height) {
if (mCamera != null) {
Log.i(TAG, "Setup Camera - " + width + "x" + height);
Camera.Parameters params = mCamera.getParameters();
List<Camera.Size> sizes = params.getSupportedPreviewSizes();
mFrameWidth = width;
mFrameHeight = height;
// selecting optimal camera preview size
{
int minDiff = Integer.MAX_VALUE;
for (Camera.Size size : sizes) {
if (Math.abs(size.height - height) < minDiff) {
mFrameWidth = size.width;
mFrameHeight = size.height;
minDiff = Math.abs(size.height - height);
}
}
}
params.setPreviewSize(getFrameWidth(), getFrameHeight());
List<String> FocusModes = params.getSupportedFocusModes();
if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
}
mCamera.setParameters(params);
/* Now allocate the buffer */
params = mCamera.getParameters();
int size = params.getPreviewSize().width * params.getPreviewSize().height;
size = size * ImageFormat.getBitsPerPixel(params.getPreviewFormat()) / 8;
mBuffer = new byte[size];
/* The buffer where the current frame will be copied */
mFrame = new byte[size];
mCamera.addCallbackBuffer(mBuffer);
/* Notify that the preview is about to be started and deliver preview size */
onPreviewStarted(params.getPreviewSize().width, params.getPreviewSize().height);
try {
setPreview();
} catch (IOException e) {
Log.e(TAG, "mCamera.setPreviewDisplay/setPreviewTexture fails: " + e);
}
/* Now we can start a preview */
mCamera.startPreview();
}
}
/**
* 设置焦点和测光区域
*
* @param event
*/
public void focusOnTouch(MotionEvent event) {
try {
if (mCamera == null) {
return;
}
Camera.Parameters parameters = mCamera.getParameters();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
int[] location = new int[2];
mSurfaceView.getLocationOnScreen(location);
Rect focusRect =
calculateTapArea(
view_focus.getWidth(),
view_focus.getHeight(),
1f,
event.getRawX(),
event.getRawY(),
location[0],
location[0] + mSurfaceView.getWidth(),
location[1],
location[1] + mSurfaceView.getHeight());
Rect meteringRect =
calculateTapArea(
view_focus.getWidth(),
view_focus.getHeight(),
1.5f,
event.getRawX(),
event.getRawY(),
location[0],
location[0] + mSurfaceView.getWidth(),
location[1],
location[1] + mSurfaceView.getHeight());
if (parameters.getMaxNumFocusAreas() > 0) {
List<Camera.Area> focusAreas = new ArrayList<Camera.Area>();
focusAreas.add(new Camera.Area(focusRect, 1000));
parameters.setFocusAreas(focusAreas);
}
if (parameters.getMaxNumMeteringAreas() > 0) {
List<Camera.Area> meteringAreas = new ArrayList<Camera.Area>();
meteringAreas.add(new Camera.Area(meteringRect, 1000));
parameters.setMeteringAreas(meteringAreas);
}
}
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
mCamera.setParameters(parameters);
mCamera.autoFocus(this);
} catch (Exception e) {
e.printStackTrace();
}
}
/** Handles camera opening */
private void openCamera(int which) {
if (mCamera != null) {
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
if (mCameraId >= 0) {
Camera.getCameraInfo(mCameraId, mCameraInfo);
if (which == FRONT) mCamera = Camera.open(Camera.CameraInfo.CAMERA_FACING_FRONT);
else mCamera = Camera.open(Camera.CameraInfo.CAMERA_FACING_BACK);
params = mCamera.getParameters();
params.setRotation(0);
/** set focus mode */
List<String> FocusModes = params.getSupportedFocusModes();
if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
}
mCamera.setParameters(params);
try {
if (mSurfaceTexture != null) {
mCamera.setPreviewTexture(mSurfaceTexture);
mCamera.startPreview();
}
} catch (Exception ex) {
}
}
if (mCamera == null || mSharedData == null) {
return;
}
int orientation = mCameraInfo.orientation + rot_angle;
Matrix.setRotateM(mSharedData.mOrientationM, 0, orientation, 0f, 0f, 1f);
Camera.Size size = mCamera.getParameters().getPreviewSize();
if (orientation % 90 == 0) {
int w = size.width;
size.width = size.height;
size.height = w;
}
mSharedData.mAspectRatioPreview[0] = (float) Math.min(size.width, size.height) / size.width;
mSharedData.mAspectRatioPreview[1] = (float) Math.min(size.width, size.height) / size.height;
}
/**
* Sets the focus mode.
*
* @param mode the focus mode
* @return {@code true} if the focus mode is set, {@code false} otherwise
* @see #getFocusMode()
*/
public boolean setFocusMode(@FocusMode String mode) {
synchronized (mCameraLock) {
if (mCamera != null && mode != null) {
Camera.Parameters parameters = mCamera.getParameters();
if (parameters.getSupportedFocusModes().contains(mode)) {
parameters.setFocusMode(mode);
mCamera.setParameters(parameters);
mFocusMode = mode;
return true;
}
}
return false;
}
}
// zoom in and enable flash
protected boolean initializeCamera(int width, int height) {
boolean ret = super.initializeCamera(width, height);
Camera.Parameters params = mCamera.getParameters();
List<String> FocusModes = params.getSupportedFocusModes();
if (FocusModes != null && FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
} else if (FocusModes != null
&& FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
}
List<String> FlashModes = params.getSupportedFlashModes();
if (FlashModes != null && FlashModes.contains(Camera.Parameters.FLASH_MODE_TORCH)) {
params.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
}
if (params.isZoomSupported()) enableZoomControls(params);
mCamera.setParameters(params);
return ret;
}
private void initCameraParameters() {
Camera.Parameters parameters = mCamera.getParameters();
String mod = Build.MODEL;
if (Build.VERSION.SDK_INT >= 8) {
// MZ 180， other 90...
if ("M9".equalsIgnoreCase(mod) || "MX".equalsIgnoreCase(mod)) {
setDisplayOrientation(mCamera, 180);
} else {
setDisplayOrientation(mCamera, 90);
}
} else {
parameters.set("orientation", "portrait");
parameters.set("rotation", 90);
}
if (cameraCurrentlyLocked == CameraInfo.CAMERA_FACING_FRONT) {
ismCameraCanFlash = false;
} else {
ismCameraCanFlash = true;
}
if (!ismCameraCanFlash) {
mBtnFlash1.setVisibility(View.INVISIBLE);
mBtnFlash2.setVisibility(View.INVISIBLE);
mBtnFlash3.setVisibility(View.INVISIBLE);
} else {
mBtnFlash1.setVisibility(View.VISIBLE);
}
List<String> focusModes = parameters.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
// Autofocus mode is supported
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
}
if (parameters.isZoomSupported()) {
parameters.setZoom(parameters.getZoom()); // 测试通过
}
Camera.Size previewSize = getFitParametersSize(parameters.getSupportedPreviewSizes());
parameters.setPreviewSize(previewSize.width, previewSize.height);
Camera.Size pictureSize = getFitParametersSize(parameters.getSupportedPictureSizes());
parameters.setPictureSize(pictureSize.width, pictureSize.height);
try {
mCamera.setParameters(parameters);
} catch (Exception e) {
e.printStackTrace();
}
}
public int setCameraProperty(String key, String value) {
if (mCamera == null) {
return MAAPI_consts.MA_CAMERA_RES_FAILED;
}
try {
Camera.Parameters param = getCurrentParameters();
if (key.equals(MAAPI_consts.MA_CAMERA_IMAGE_FORMAT)) {
if (value.equals(MAAPI_consts.MA_CAMERA_IMAGE_RAW)) {
rawMode = true;
} else {
// default mode is jpeg
rawMode = false;
}
} else if (key.equals(MAAPI_consts.MA_CAMERA_FOCUS_MODE)) {
if (value.equals(MAAPI_consts.MA_CAMERA_FOCUS_AUTO)) {
if (false == param.getSupportedFocusModes().contains(value)) {
return MAAPI_consts.MA_CAMERA_RES_VALUE_NOTSUPPORTED;
}
mCamera.autoFocus(autoFocusCallback);
} else if (value.equals(MAAPI_consts.MA_CAMERA_FOCUS_MACRO)) {
if (false == param.getSupportedFocusModes().contains(value)) {
return MAAPI_consts.MA_CAMERA_RES_VALUE_NOTSUPPORTED;
}
mCamera.autoFocus(autoFocusCallback);
} else if (false == param.getSupportedFocusModes().contains(value)) {
mCamera.cancelAutoFocus();
return MAAPI_consts.MA_CAMERA_RES_VALUE_NOTSUPPORTED;
} else mCamera.cancelAutoFocus();
param.setFocusMode(value);
} else if (key.equals(MAAPI_consts.MA_CAMERA_FLASH_MODE)) {
if (true == param.getSupportedFlashModes().contains(value)) {
param.setFlashMode(value);
} else {
return MAAPI_consts.MA_CAMERA_RES_VALUE_NOTSUPPORTED;
}
} else {
param.set(key, value);
}
mCamera.setParameters(param);
} catch (Exception e) {
return MAAPI_consts.MA_CAMERA_RES_FAILED;
}
return MAAPI_consts.MA_CAMERA_RES_OK;
}
// 设置相机的属性 抓取图像
private void setCameraParameters() {
Camera.Parameters caParameters = camera.getParameters();
caParameters.setPictureFormat(ImageFormat.JPEG);
caParameters.setPreviewSize(400, 500);
caParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
camera.autoFocus(
new Camera.AutoFocusCallback() {
@Override
public void onAutoFocus(boolean success, Camera camera) {
if (success) {
camera.takePicture(null, null, pictureCallback);
}
}
});
}
public void setCamera(Camera camera) {
mCamera = camera;
if (mCamera != null) {
mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
requestLayout();
// get Camera parameters
Camera.Parameters params = mCamera.getParameters();
List<String> focusModes = params.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
// set the focus mode
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
// set Camera parameters
mCamera.setParameters(params);
}
}
}
public void surfaceCreated(SurfaceHolder holder) {
camera = Camera.open();
parameters = camera.getParameters();
parameters.setPreviewSize(640, 480);
parameters.setPreviewFrameRate(30);
parameters.setJpegQuality(100);
parameters.setFocusMode("continuous-video");
parameters.setPictureSize(2048, 1536);
camera.setParameters(parameters); // /!!!!!
try {
camera.setPreviewDisplay(holder);
} catch (IOException exception) {
camera.release();
camera = null;
}
}
void setDesiredCameraParameters(Camera camera) {
Camera.Parameters parameters = camera.getParameters();
if (parameters == null) {
Log.w(
TAG,
"Device error: no camera parameters are available. Proceeding without configuration.");
return;
}
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
initializeTorch(parameters, prefs);
String focusMode = null;
if (prefs.getBoolean(PreferencesActivity.KEY_AUTO_FOCUS, true)) {
if (prefs.getBoolean(PreferencesActivity.KEY_DISABLE_CONTINUOUS_FOCUS, false)) {
focusMode =
findSettableValue(
parameters.getSupportedFocusModes(), Camera.Parameters.FOCUS_MODE_AUTO);
} else {
focusMode =
findSettableValue(
parameters.getSupportedFocusModes(),
"continuous-picture", // Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE in 4.0+
"continuous-video", // Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO in 4.0+
Camera.Parameters.FOCUS_MODE_AUTO);
}
}
// Maybe selected auto-focus but not available, so fall through here:
if (focusMode == null) {
focusMode =
findSettableValue(
parameters.getSupportedFocusModes(),
Camera.Parameters.FOCUS_MODE_MACRO,
"edof"); // Camera.Parameters.FOCUS_MODE_EDOF in 2.2+
}
if (focusMode != null) {
parameters.setFocusMode(focusMode);
}
parameters.setPreviewSize(cameraResolution.x, cameraResolution.y);
camera.setParameters(parameters);
}
public void takePhoto(View v) {
Camera.Parameters p = mCamera.getParameters();
p.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
mCamera.setParameters(p);
mCamera.autoFocus(
new Camera.AutoFocusCallback() {
@Override
public void onAutoFocus(boolean success, Camera camera) {
if (success) {
// captureButton.setEnabled(false);
mCamera.takePicture(null, null, mPicture);
} else {
// captureButton.setEnabled(false);
mCamera.takePicture(null, null, mPicture);
}
}
});
}
public CameraPreview(ImageView CameraPreview) {
if (mCamera == null) {
mCamera = Camera.open();
}
Camera.Parameters parameters;
parameters = mCamera.getParameters();
List<String> af = parameters.getSupportedFocusModes();
System.out.println(af);
if (af.contains("continuous-video")) {
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
System.out.println("FocusModeTrue-Auto");
// TODO log this
}
List<Camera.Size> sizes = parameters.getSupportedPreviewSizes();
Camera.Size cs = sizes.get(0);
PreviewSizeWidth = cs.width;
PreviewSizeHeight = cs.height;
MyCameraPreview = CameraPreview;
bitmap = Bitmap.createBitmap(PreviewSizeWidth, PreviewSizeHeight, Bitmap.Config.ARGB_8888);
pixels = new int[PreviewSizeWidth * PreviewSizeHeight];
}
@Override
public void surfaceCreated(SurfaceHolder arg0) {
camera = Camera.open();
Camera.Parameters params = camera.getParameters();
camera.setDisplayOrientation(90);
params.setRotation(90);
params.set("orientation", "landscape");
params.set("rotation", 90);
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
Camera.Size previewSize = params.getPreviewSize();
List<Camera.Size> previewSizes = params.getSupportedPreviewSizes();
int i = 0;
for (Camera.Size cs : previewSizes) {
Log.d(MarvinActivity.TAG, "Camera - supports:(" + (i++) + ") " + cs.width + "x" + cs.height);
}
previewSize.width = 720;
previewSize.height = 480;
params.setSceneMode("portrait");
Log.d(MarvinActivity.TAG, "w: " + previewSize.width + " h: " + previewSize.height);
List<Integer> formats = params.getSupportedPreviewFormats();
for (Integer format : formats) {
Log.d(MarvinActivity.TAG, "Camera - supports preview format: " + format);
}
params.setPreviewSize(previewSize.width, previewSize.height);
camera.setParameters(params);
detectThread = new FaceDetectThread(context, user, params);
detectThread.start();
camera.setPreviewCallback(detectThread);
try {
camera.setPreviewDisplay(cameraView.getHolder());
camera.startPreview();
Log.d(MarvinActivity.TAG, "preview started");
} catch (Exception e) {
Log.e(MarvinActivity.TAG, e.getMessage(), e);
}
user.onEyeStarted();
}
public static void setFocus(
Camera.Parameters parameters,
boolean autoFocus,
boolean disableContinuous,
boolean safeMode) {
List<String> supportedFocusModes = parameters.getSupportedFocusModes();
String focusMode = null;
if (autoFocus) {
if (safeMode || disableContinuous) {
focusMode =
findSettableValue("focus mode", supportedFocusModes, Camera.Parameters.FOCUS_MODE_AUTO);
} else {
focusMode =
findSettableValue(
"focus mode",
supportedFocusModes,
Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE,
Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO,
Camera.Parameters.FOCUS_MODE_AUTO);
}
}
// Maybe selected auto-focus but not available, so fall through here:
if (!safeMode && focusMode == null) {
focusMode =
findSettableValue(
"focus mode",
supportedFocusModes,
Camera.Parameters.FOCUS_MODE_MACRO,
Camera.Parameters.FOCUS_MODE_EDOF);
}
if (focusMode != null) {
if (focusMode.equals(parameters.getFocusMode())) {
Log.i(TAG, "Focus mode already set to " + focusMode);
} else {
parameters.setFocusMode(focusMode);
}
}
}
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
Log.i("TAG", "surfaceChanged");
// TODO Auto-generated method stub
Camera.Parameters parameters = mCamera.getParameters();
parameters.setFocusMode(Parameters.FOCUS_MODE_MACRO);
parameters.setPictureFormat(PixelFormat.JPEG); // 设置图片格式
// Camera.Size picSize = parameters.getSupportedPictureSizes().get(0);
// parameters.setPictureSize(picSize.width, picSize.height);
mCamera.setParameters(parameters);
List<Camera.Size> sizes = parameters.getSupportedPictureSizes();
mFrameWidth = width;
mFrameHeight = height;
// selecting optimal camera preview size
{
double minDiff = Double.MAX_VALUE;
for (Camera.Size size : sizes) {
if (Math.abs(size.height - height) < minDiff) {
mFrameWidth = size.width;
mFrameHeight = size.height;
Log.d(
"Size",
"width = "
+ Integer.toString(mFrameWidth)
+ "height = "
+ Integer.toString(mFrameHeight));
minDiff = Math.abs(size.height - height);
}
}
}
parameters.setPreviewSize(getFrameWidth(), getFrameHeight());
mCamera.setParameters(parameters);
mCamera.startPreview(); // 开始预览
}