1
2
3
4
5
6
/**
 * Auto-focus mode. Applications should call {@link
 * #autoFocus(AutoFocusCallback)} to start the focus in this mode.
 */
public static final String FOCUS_MODE_AUTO = "auto";

1
2
3

mCameraParameters.getSupportedFocusModes()?.contains(FOCUS_MODE_AUTO);

1
2
3
4
5
6
7
8
9
//1.切换到auto模式
//2.设置相关参数
mCamera.autoFocus(new Camera.AutoFocusCallback() {
    @Override
    public void onAutoFocus(boolean success, Camera camera) {
        //......
    }
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
  * Continuous auto focus mode intended for taking pictures. The camera
  * continuously tries to focus. The speed of focus change is more
  * aggressive than {@link #FOCUS_MODE_CONTINUOUS_VIDEO}. Auto focus
  * starts when the parameter is set.
  *
  * <p>Applications can call {@link #autoFocus(AutoFocusCallback)} in
  * this mode. If the autofocus is in the middle of scanning, the focus
  * callback will return when it completes. If the autofocus is not
  * scanning, the focus callback will immediately return with a boolean
  * that indicates whether the focus is sharp or not. The apps can then
  * decide if they want to take a picture immediately or to change the
  * focus mode to auto, and run a full autofocus cycle. The focus
  * position is locked after autoFocus call. If applications want to
  * resume the continuous focus, cancelAutoFocus must be called.
  * Restarting the preview will not resume the continuous autofocus. To
  * stop continuous focus, applications should change the focus mode to
  * other modes.
  *
  * @see #FOCUS_MODE_CONTINUOUS_VIDEO
  */
 public static final String FOCUS_MODE_CONTINUOUS_PICTURE = "continuous-picture";

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Continuous auto focus mode intended for video recording. The camera
 * continuously tries to focus. This is the best choice for video
 * recording because the focus changes smoothly . Applications still can
 * call {@link #takePicture(Camera.ShutterCallback,
 * Camera.PictureCallback, Camera.PictureCallback)} in this mode but the
 * subject may not be in focus. Auto focus starts when the parameter is
 * set.
 *
 * <p>Since API level 14, applications can call {@link
 * #autoFocus(AutoFocusCallback)} in this mode. The focus callback will
 * immediately return with a boolean that indicates whether the focus is
 * sharp or not. The focus position is locked after autoFocus call. If
 * applications want to resume the continuous focus, cancelAutoFocus
 * must be called. Restarting the preview will not resume the continuous
 * autofocus. To stop continuous focus, applications should change the
 * focus mode to other modes.
 *
 * @see #FOCUS_MODE_CONTINUOUS_PICTURE
 */
public static final String FOCUS_MODE_CONTINUOUS_VIDEO = "continuous-video";

1
2
3
4
5
6
7
 /**
  * Macro (close-up) focus mode. Applications should call
  * {@link #autoFocus(AutoFocusCallback)} to start the focus in this
  * mode.
  */
 public static final String FOCUS_MODE_MACRO = "macro";

1
2
3
4
5
6
7
/**
 * Macro (close-up) focus mode. Applications should call
 * {@link #autoFocus(AutoFocusCallback)} to start the focus in this
 * mode.
 */
public static final String FOCUS_MODE_MACRO = "macro";

1
2
3
4
5
6
7
8
/**
 * Focus is fixed. The camera is always in this mode if the focus is not
 * adjustable. If the camera has auto-focus, this mode can fix the
 * focus, which is usually at hyperfocal distance. Applications should
 * not call {@link #autoFocus(AutoFocusCallback)} in this mode.
 */
public static final String FOCUS_MODE_FIXED = "fixed";

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/**
 * Gets the current focus mode setting.
 *
 * @return current focus mode. This method will always return a non-null
 *         value. Applications should call {@link
 *         #autoFocus(AutoFocusCallback)} to start the focus if focus
 *         mode is FOCUS_MODE_AUTO or FOCUS_MODE_MACRO.
 * @see #FOCUS_MODE_AUTO
 * @see #FOCUS_MODE_INFINITY
 * @see #FOCUS_MODE_MACRO
 * @see #FOCUS_MODE_FIXED
 * @see #FOCUS_MODE_EDOF
 * @see #FOCUS_MODE_CONTINUOUS_VIDEO
 */
public String getFocusMode() {
    return get(KEY_FOCUS_MODE);
}

/**
 * Gets the supported focus modes.
 *
 * @return a list of supported focus modes. This method will always
 *         return a list with at least one element.
 * @see #getFocusMode()
 */
public List<String> getSupportedFocusModes() {
    String str = get(KEY_FOCUS_MODE + SUPPORTED_VALUES_SUFFIX);
    return split(str);
}

/**
 * Sets the focus mode.
 *
 * @param value focus mode.
 * @see #getFocusMode()
 */
public void setFocusMode(String value) {
    set(KEY_FOCUS_MODE, value);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/**
 * <p>Gets the current focus areas. Camera driver uses the areas to decide
 * focus.</p>
 *
 * <p>Before using this API or {@link #setFocusAreas(List)}, apps should
 * call {@link #getMaxNumFocusAreas()} to know the maximum number of
 * focus areas first. If the value is 0, focus area is not supported.</p>
 *
 * <p>Each focus area is a rectangle with specified weight. The direction
 * is relative to the sensor orientation, that is, what the sensor sees.
 * The direction is not affected by the rotation or mirroring of
 * {@link #setDisplayOrientation(int)}. Coordinates of the rectangle
 * range from -1000 to 1000. (-1000, -1000) is the upper left point.
 * (1000, 1000) is the lower right point. The width and height of focus
 * areas cannot be 0 or negative.</p>
 *
 * <p>The weight must range from 1 to 1000. The weight should be
 * interpreted as a per-pixel weight - all pixels in the area have the
 * specified weight. This means a small area with the same weight as a
 * larger area will have less influence on the focusing than the larger
 * area. Focus areas can partially overlap and the driver will add the
 * weights in the overlap region.</p>
 *
 * <p>A special case of a {@code null} focus area list means the driver is
 * free to select focus targets as it wants. For example, the driver may
 * use more signals to select focus areas and change them
 * dynamically. Apps can set the focus area list to {@code null} if they
 * want the driver to completely control focusing.</p>
 *
 * <p>Focus areas are relative to the current field of view
 * ({@link #getZoom()}). No matter what the zoom level is, (-1000,-1000)
 * represents the top of the currently visible camera frame. The focus
 * area cannot be set to be outside the current field of view, even
 * when using zoom.</p>
 *
 * <p>Focus area only has effect if the current focus mode is
 * {@link #FOCUS_MODE_AUTO}, {@link #FOCUS_MODE_MACRO},
 * {@link #FOCUS_MODE_CONTINUOUS_VIDEO}, or
 * {@link #FOCUS_MODE_CONTINUOUS_PICTURE}.</p>
 *
 * @return a list of current focus areas
 */
public List<Area> getFocusAreas() {
    return splitArea(get(KEY_FOCUS_AREAS));
}

public void setFocusAreas(List<Area> focusAreas) {
    set(KEY_FOCUS_AREAS, focusAreas);
}


/**
 * Gets the maximum number of focus areas supported. This is the maximum
 * length of the list in {@link #setFocusAreas(List)} and
 * {@link #getFocusAreas()}.
 *
 * @return the maximum number of focus areas supported by the camera.
 * @see #getFocusAreas()
 */
public int getMaxNumFocusAreas() {
    return getInt(KEY_MAX_NUM_FOCUS_AREAS, 0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/**
 * <p>Gets the distances from the camera to where an object appears to be
 * in focus. The object is sharpest at the optimal focus distance. The
 * depth of field is the far focus distance minus near focus distance.</p>
 *
 * <p>Focus distances may change after calling {@link
 * #autoFocus(AutoFocusCallback)}, {@link #cancelAutoFocus}, or {@link
 * #startPreview()}. Applications can call {@link #getParameters()}
 * and this method anytime to get the latest focus distances. If the
 * focus mode is FOCUS_MODE_CONTINUOUS_VIDEO, focus distances may change
 * from time to time.</p>
 *
 * <p>This method is intended to estimate the distance between the camera
 * and the subject. After autofocus, the subject distance may be within
 * near and far focus distance. However, the precision depends on the
 * camera hardware, autofocus algorithm, the focus area, and the scene.
 * The error can be large and it should be only used as a reference.</p>
 *
 * <p>Far focus distance >= optimal focus distance >= near focus distance.
 * If the focus distance is infinity, the value will be
 * {@code Float.POSITIVE_INFINITY}.</p>
 *
 * @param output focus distances in meters. output must be a float
 *        array with three elements. Near focus distance, optimal focus
 *        distance, and far focus distance will be filled in the array.
 * @see #FOCUS_DISTANCE_NEAR_INDEX
 * @see #FOCUS_DISTANCE_OPTIMAL_INDEX
 * @see #FOCUS_DISTANCE_FAR_INDEX
 */
public void getFocusDistances(float[] output) {
    if (output == null || output.length != 3) {
        throw new IllegalArgumentException(
                "output must be a float array with three elements.");
    }
    splitFloat(get(KEY_FOCUS_DISTANCES), output);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
 * Sets the exposure compensation index.
 *
 * @param value exposure compensation index. The valid value range is
 *        from {@link #getMinExposureCompensation} (inclusive) to {@link
 *        #getMaxExposureCompensation} (inclusive). 0 means exposure is
 *        not adjusted. Application should call
 *        getMinExposureCompensation and getMaxExposureCompensation to
 *        know if exposure compensation is supported.
 */
public void setExposureCompensation(int value) {
    set(KEY_EXPOSURE_COMPENSATION, value);
}

/**
 * Gets the exposure compensation step.
 *
 * @return exposure compensation step. Applications can get EV by
 *         multiplying the exposure compensation index and step. Ex: if
 *         exposure compensation index is -6 and step is 0.333333333, EV
 *         is -2.
 */
public float getExposureCompensationStep() {
    return getFloat(KEY_EXPOSURE_COMPENSATION_STEP, 0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/**
 * <p>Sets the auto-exposure lock state. Applications should check
 * {@link #isAutoExposureLockSupported} before using this method.</p>
 *
 * <p>If set to true, the camera auto-exposure routine will immediately
 * pause until the lock is set to false. Exposure compensation settings
 * changes will still take effect while auto-exposure is locked.</p>
 *
 * <p>If auto-exposure is already locked, setting this to true again has
 * no effect (the driver will not recalculate exposure values).</p>
 *
 * <p>Stopping preview with {@link #stopPreview()}, or triggering still
 * image capture with {@link #takePicture(Camera.ShutterCallback,
 * Camera.PictureCallback, Camera.PictureCallback)}, will not change the
 * lock.</p>
 *
 * <p>Exposure compensation, auto-exposure lock, and auto-white balance
 * lock can be used to capture an exposure-bracketed burst of images,
 * for example.</p>
 *
 * <p>Auto-exposure state, including the lock state, will not be
 * maintained after camera {@link #release()} is called.  Locking
 * auto-exposure after {@link #open()} but before the first call to
 * {@link #startPreview()} will not allow the auto-exposure routine to
 * run at all, and may result in severely over- or under-exposed
 * images.</p>
 *
 * @param toggle new state of the auto-exposure lock. True means that
 *        auto-exposure is locked, false means that the auto-exposure
 *        routine is free to run normally.
 *
 * @see #getAutoExposureLock()
 */
public void setAutoExposureLock(boolean toggle) {
    set(KEY_AUTO_EXPOSURE_LOCK, toggle ? TRUE : FALSE);
}

/**
 * Gets the state of the auto-exposure lock. Applications should check
 * {@link #isAutoExposureLockSupported} before using this method. See
 * {@link #setAutoExposureLock} for details about the lock.
 *
 * @return State of the auto-exposure lock. Returns true if
 *         auto-exposure is currently locked, and false otherwise.
 *
 * @see #setAutoExposureLock(boolean)
 *
 */
public boolean getAutoExposureLock() {
    String str = get(KEY_AUTO_EXPOSURE_LOCK);
    return TRUE.equals(str);
}

/**
 * Returns true if auto-exposure locking is supported. Applications
 * should call this before trying to lock auto-exposure. See
 * {@link #setAutoExposureLock} for details about the lock.
 *
 * @return true if auto-exposure lock is supported.
 * @see #setAutoExposureLock(boolean)
 *
 */
public boolean isAutoExposureLockSupported() {
    String str = get(KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
    return TRUE.equals(str);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/**
 * <p>Gets the current metering areas. Camera driver uses these areas to
 * decide exposure.</p>
 *
 * <p>Before using this API or {@link #setMeteringAreas(List)}, apps should
 * call {@link #getMaxNumMeteringAreas()} to know the maximum number of
 * metering areas first. If the value is 0, metering area is not
 * supported.</p>
 *
 * <p>Each metering area is a rectangle with specified weight. The
 * direction is relative to the sensor orientation, that is, what the
 * sensor sees. The direction is not affected by the rotation or
 * mirroring of {@link #setDisplayOrientation(int)}. Coordinates of the
 * rectangle range from -1000 to 1000. (-1000, -1000) is the upper left
 * point. (1000, 1000) is the lower right point. The width and height of
 * metering areas cannot be 0 or negative.</p>
 *
 * <p>The weight must range from 1 to 1000, and represents a weight for
 * every pixel in the area. This means that a large metering area with
 * the same weight as a smaller area will have more effect in the
 * metering result.  Metering areas can partially overlap and the driver
 * will add the weights in the overlap region.</p>
 *
 * <p>A special case of a {@code null} metering area list means the driver
 * is free to meter as it chooses. For example, the driver may use more
 * signals to select metering areas and change them dynamically. Apps
 * can set the metering area list to {@code null} if they want the
 * driver to completely control metering.</p>
 *
 * <p>Metering areas are relative to the current field of view
 * ({@link #getZoom()}). No matter what the zoom level is, (-1000,-1000)
 * represents the top of the currently visible camera frame. The
 * metering area cannot be set to be outside the current field of view,
 * even when using zoom.</p>
 *
 * <p>No matter what metering areas are, the final exposure are compensated
 * by {@link #setExposureCompensation(int)}.</p>
 *
 * @return a list of current metering areas
 */
public List<Area> getMeteringAreas() {
    return splitArea(get(KEY_METERING_AREAS));
}

/**
 * Sets metering areas. See {@link #getMeteringAreas()} for
 * documentation.
 *
 * @param meteringAreas the metering areas
 * @see #getMeteringAreas()
 */
public void setMeteringAreas(List<Area> meteringAreas) {
    set(KEY_METERING_AREAS, meteringAreas);
}

/**
 * Gets the maximum number of detected faces supported. This is the
 * maximum length of the list returned from {@link FaceDetectionListener}.
 * If the return value is 0, face detection of the specified type is not
 * supported.
 *
 * @return the maximum number of detected face supported by the camera.
 * @see #startFaceDetection()
 */
public int getMaxNumDetectedFaces() {
    return getInt(KEY_MAX_NUM_DETECTED_FACES_HW, 0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
  /**
   * <p>Sets the auto-white balance lock state. Applications should check
   * {@link #isAutoWhiteBalanceLockSupported} before using this
   * method.</p>
   *
   * <p>If set to true, the camera auto-white balance routine will
   * immediately pause until the lock is set to false.</p>
   *
   * <p>If auto-white balance is already locked, setting this to true
   * again has no effect (the driver will not recalculate white balance
   * values).</p>
   *
   * <p>Stopping preview with {@link #stopPreview()}, or triggering still
   * image capture with {@link #takePicture(Camera.ShutterCallback,
   * Camera.PictureCallback, Camera.PictureCallback)}, will not change the
   * the lock.</p>
   *
   * <p> Changing the white balance mode with {@link #setWhiteBalance}
   * will release the auto-white balance lock if it is set.</p>
   *
   * <p>Exposure compensation, AE lock, and AWB lock can be used to
   * capture an exposure-bracketed burst of images, for example.
   * Auto-white balance state, including the lock state, will not be
   * maintained after camera {@link #release()} is called.  Locking
   * auto-white balance after {@link #open()} but before the first call to
   * {@link #startPreview()} will not allow the auto-white balance routine
   * to run at all, and may result in severely incorrect color in captured
   * images.</p>
   *
   * @param toggle new state of the auto-white balance lock. True means
   *        that auto-white balance is locked, false means that the
   *        auto-white balance routine is free to run normally.
   *
   * @see #getAutoWhiteBalanceLock()
   * @see #setWhiteBalance(String)
   */
  public void setAutoWhiteBalanceLock(boolean toggle) {
      set(KEY_AUTO_WHITEBALANCE_LOCK, toggle ? TRUE : FALSE);
  }

  /**
   * Gets the state of the auto-white balance lock. Applications should
   * check {@link #isAutoWhiteBalanceLockSupported} before using this
   * method. See {@link #setAutoWhiteBalanceLock} for details about the
   * lock.
   *
   * @return State of the auto-white balance lock. Returns true if
   *         auto-white balance is currently locked, and false
   *         otherwise.
   *
   * @see #setAutoWhiteBalanceLock(boolean)
   *
   */
  public boolean getAutoWhiteBalanceLock() {
      String str = get(KEY_AUTO_WHITEBALANCE_LOCK);
      return TRUE.equals(str);
  }

  /**
   * Returns true if auto-white balance locking is supported. Applications
   * should call this before trying to lock auto-white balance. See
   * {@link #setAutoWhiteBalanceLock} for details about the lock.
   *
   * @return true if auto-white balance lock is supported.
   * @see #setAutoWhiteBalanceLock(boolean)
   *
   */
  public boolean isAutoWhiteBalanceLockSupported() {
      String str = get(KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
      return TRUE.equals(str);
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * Gets the current white balance setting.
 *
 * @return current white balance. null if white balance setting is not
 *         supported.
 * @see #WHITE_BALANCE_AUTO
 * @see #WHITE_BALANCE_INCANDESCENT
 * @see #WHITE_BALANCE_FLUORESCENT
 * @see #WHITE_BALANCE_WARM_FLUORESCENT
 * @see #WHITE_BALANCE_DAYLIGHT
 * @see #WHITE_BALANCE_CLOUDY_DAYLIGHT
 * @see #WHITE_BALANCE_TWILIGHT
 * @see #WHITE_BALANCE_SHADE
 *
 */
public String getWhiteBalance() {
    return get(KEY_WHITE_BALANCE);
}