java/com/android/dialer/callcomposer/camera/camerafocus/FocusOverlayManager.java - platform/packages/apps/Dialer - Gitiles

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.dialer.callcomposer.camera.camerafocus;

 import android.graphics.Matrix;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.hardware.Camera.Area;
 import android.hardware.Camera.Parameters;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 import com.android.dialer.common.Assert;
 import com.android.dialer.common.LogUtil;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * A class that handles everything about focus in still picture mode. This also handles the metering
  * area because it is the same as focus area.
  *
  * <p>The test cases: (1) The camera has continuous autofocus. Move the camera. Take a picture when
  * CAF is not in progress. (2) The camera has continuous autofocus. Move the camera. Take a picture
  * when CAF is in progress. (3) The camera has face detection. Point the camera at some faces. Hold
  * the shutter. Release to take a picture. (4) The camera has face detection. Point the camera at
  * some faces. Single tap the shutter to take a picture. (5) The camera has autofocus. Single tap
  * the shutter to take a picture. (6) The camera has autofocus. Hold the shutter. Release to take a
  * picture. (7) The camera has no autofocus. Single tap the shutter and take a picture. (8) The
  * camera has autofocus and supports focus area. Touch the screen to trigger autofocus. Take a
  * picture. (9) The camera has autofocus and supports focus area. Touch the screen to trigger
  * autofocus. Wait until it times out. (10) The camera has no autofocus and supports metering area.
  * Touch the screen to change metering area.
  */
 public class FocusOverlayManager {
   private static final String TRUE = "true";
   private static final String AUTO_EXPOSURE_LOCK_SUPPORTED = "auto-exposure-lock-supported";
   private static final String AUTO_WHITE_BALANCE_LOCK_SUPPORTED =
       "auto-whitebalance-lock-supported";

   private static final int RESET_TOUCH_FOCUS = 0;
   private static final int RESET_TOUCH_FOCUS_DELAY = 3000;

   private int mState = STATE_IDLE;
   private static final int STATE_IDLE = 0; // Focus is not active.
   private static final int STATE_FOCUSING = 1; // Focus is in progress.
   // Focus is in progress and the camera should take a picture after focus finishes.
   private static final int STATE_FOCUSING_SNAP_ON_FINISH = 2;
   private static final int STATE_SUCCESS = 3; // Focus finishes and succeeds.
   private static final int STATE_FAIL = 4; // Focus finishes and fails.

   private boolean mInitialized;
   private boolean mFocusAreaSupported;
   private boolean mMeteringAreaSupported;
   private boolean mLockAeAwbNeeded;
   private boolean mAeAwbLock;
   private Matrix mMatrix;

   private PieRenderer mPieRenderer;

   private int mPreviewWidth; // The width of the preview frame layout.
   private int mPreviewHeight; // The height of the preview frame layout.
   private boolean mMirror; // true if the camera is front-facing.
   private List<Area> mFocusArea; // focus area in driver format
   private List<Area> mMeteringArea; // metering area in driver format
   private String mFocusMode;
   private Parameters mParameters;
   private Handler mHandler;
   private Listener mListener;

   /** Listener used for the focus indicator to communicate back to the camera. */
   public interface Listener {
     void autoFocus();

     void cancelAutoFocus();

     boolean capture();

     void setFocusParameters();
   }

   private class MainHandler extends Handler {
     public MainHandler(Looper looper) {
       super(looper);
     }

     @Override
     public void handleMessage(Message msg) {
       switch (msg.what) {
         case RESET_TOUCH_FOCUS:
           {
             cancelAutoFocus();
             break;
           }
       }
     }
   }

   public FocusOverlayManager(Listener listener, Looper looper) {
     mHandler = new MainHandler(looper);
     mMatrix = new Matrix();
     mListener = listener;
   }

   public void setFocusRenderer(PieRenderer renderer) {
     mPieRenderer = renderer;
     mInitialized = (mMatrix != null);
   }

   public void setParameters(Parameters parameters) {
     // parameters can only be null when onConfigurationChanged is called
     // before camera is open. We will just return in this case, because
     // parameters will be set again later with the right parameters after
     // camera is open.
     if (parameters == null) {
       return;
     }
     mParameters = parameters;
     mFocusAreaSupported = isFocusAreaSupported(parameters);
     mMeteringAreaSupported = isMeteringAreaSupported(parameters);
     mLockAeAwbNeeded =
         (isAutoExposureLockSupported(mParameters) || isAutoWhiteBalanceLockSupported(mParameters));
   }

   public void setPreviewSize(int previewWidth, int previewHeight) {
     if (mPreviewWidth != previewWidth || mPreviewHeight != previewHeight) {
       mPreviewWidth = previewWidth;
       mPreviewHeight = previewHeight;
       setMatrix();
     }
   }

   public void setMirror(boolean mirror) {
     mMirror = mirror;
     setMatrix();
   }

   private void setMatrix() {
     if (mPreviewWidth != 0 && mPreviewHeight != 0) {
       Matrix matrix = new Matrix();
       prepareMatrix(matrix, mMirror, mPreviewWidth, mPreviewHeight);
       // In face detection, the matrix converts the driver coordinates to UI
       // coordinates. In tap focus, the inverted matrix converts the UI
       // coordinates to driver coordinates.
       matrix.invert(mMatrix);
       mInitialized = (mPieRenderer != null);
     }
   }

   private void lockAeAwbIfNeeded() {
     if (mLockAeAwbNeeded && !mAeAwbLock) {
       mAeAwbLock = true;
       mListener.setFocusParameters();
     }
   }

   public void onAutoFocus(boolean focused, boolean shutterButtonPressed) {
     if (mState == STATE_FOCUSING_SNAP_ON_FINISH) {
       // Take the picture no matter focus succeeds or fails. No need
       // to play the AF sound if we're about to play the shutter
       // sound.
       if (focused) {
         mState = STATE_SUCCESS;
       } else {
         mState = STATE_FAIL;
       }
       updateFocusUI();
       capture();
     } else if (mState == STATE_FOCUSING) {
       // This happens when (1) user is half-pressing the focus key or
       // (2) touch focus is triggered. Play the focus tone. Do not
       // take the picture now.
       if (focused) {
         mState = STATE_SUCCESS;
       } else {
         mState = STATE_FAIL;
       }
       updateFocusUI();
       // If this is triggered by touch focus, cancel focus after a
       // while.
       if (mFocusArea != null) {
         mHandler.sendEmptyMessageDelayed(RESET_TOUCH_FOCUS, RESET_TOUCH_FOCUS_DELAY);
       }
       if (shutterButtonPressed) {
         // Lock AE & AWB so users can half-press shutter and recompose.
         lockAeAwbIfNeeded();
       }
     } else if (mState == STATE_IDLE) {
       // User has released the focus key before focus completes.
       // Do nothing.
     }
   }

   public void onAutoFocusMoving(boolean moving) {
     if (!mInitialized) {
       return;
     }

     // Ignore if we have requested autofocus. This method only handles
     // continuous autofocus.
     if (mState != STATE_IDLE) {
       return;
     }

     if (moving) {
       mPieRenderer.showStart();
     } else {
       mPieRenderer.showSuccess(true);
     }
   }

   private void initializeFocusAreas(
       int focusWidth, int focusHeight, int x, int y, int previewWidth, int previewHeight) {
     if (mFocusArea == null) {
       mFocusArea = new ArrayList<>();
       mFocusArea.add(new Area(new Rect(), 1));
     }

     // Convert the coordinates to driver format.
     calculateTapArea(
         focusWidth, focusHeight, 1f, x, y, previewWidth, previewHeight, mFocusArea.get(0).rect);
   }

   private void initializeMeteringAreas(
       int focusWidth, int focusHeight, int x, int y, int previewWidth, int previewHeight) {
     if (mMeteringArea == null) {
       mMeteringArea = new ArrayList<>();
       mMeteringArea.add(new Area(new Rect(), 1));
     }

     // Convert the coordinates to driver format.
     // AE area is bigger because exposure is sensitive and
     // easy to over- or underexposure if area is too small.
     calculateTapArea(
         focusWidth,
         focusHeight,
         1.5f,
         x,
         y,
         previewWidth,
         previewHeight,
         mMeteringArea.get(0).rect);
   }

   public void onSingleTapUp(int x, int y) {
     if (!mInitialized || mState == STATE_FOCUSING_SNAP_ON_FINISH) {
       return;
     }

     // Let users be able to cancel previous touch focus.
     if ((mFocusArea != null)
         && (mState == STATE_FOCUSING || mState == STATE_SUCCESS || mState == STATE_FAIL)) {
       cancelAutoFocus();
     }
     // Initialize variables.
     int focusWidth = mPieRenderer.getSize();
     int focusHeight = mPieRenderer.getSize();
     if (focusWidth == 0 || mPieRenderer.getWidth() == 0 || mPieRenderer.getHeight() == 0) {
       return;
     }
     int previewWidth = mPreviewWidth;
     int previewHeight = mPreviewHeight;
     // Initialize mFocusArea.
     if (mFocusAreaSupported) {
       initializeFocusAreas(focusWidth, focusHeight, x, y, previewWidth, previewHeight);
     }
     // Initialize mMeteringArea.
     if (mMeteringAreaSupported) {
       initializeMeteringAreas(focusWidth, focusHeight, x, y, previewWidth, previewHeight);
     }

     // Use margin to set the focus indicator to the touched area.
     mPieRenderer.setFocus(x, y);

     // Set the focus area and metering area.
     mListener.setFocusParameters();
     if (mFocusAreaSupported) {
       autoFocus();
     } else { // Just show the indicator in all other cases.
       updateFocusUI();
       // Reset the metering area in 3 seconds.
       mHandler.removeMessages(RESET_TOUCH_FOCUS);
       mHandler.sendEmptyMessageDelayed(RESET_TOUCH_FOCUS, RESET_TOUCH_FOCUS_DELAY);
     }
   }

   public void onPreviewStarted() {
     mState = STATE_IDLE;
   }

   public void onPreviewStopped() {
     // If auto focus was in progress, it would have been stopped.
     mState = STATE_IDLE;
     resetTouchFocus();
     updateFocusUI();
   }

   public void onCameraReleased() {
     onPreviewStopped();
   }

   private void autoFocus() {
     LogUtil.v("FocusOverlayManager.autoFocus", "Start autofocus.");
     mListener.autoFocus();
     mState = STATE_FOCUSING;
     updateFocusUI();
     mHandler.removeMessages(RESET_TOUCH_FOCUS);
   }

   public void cancelAutoFocus() {
     LogUtil.v("FocusOverlayManager.cancelAutoFocus", "Cancel autofocus.");

     // Reset the tap area before calling mListener.cancelAutofocus.
     // Otherwise, focus mode stays at auto and the tap area passed to the
     // driver is not reset.
     resetTouchFocus();
     mListener.cancelAutoFocus();
     mState = STATE_IDLE;
     updateFocusUI();
     mHandler.removeMessages(RESET_TOUCH_FOCUS);
   }

   private void capture() {
     if (mListener.capture()) {
       mState = STATE_IDLE;
       mHandler.removeMessages(RESET_TOUCH_FOCUS);
     }
   }

   public String getFocusMode() {
     List<String> supportedFocusModes = mParameters.getSupportedFocusModes();

     if (mFocusAreaSupported && mFocusArea != null) {
       // Always use autofocus in tap-to-focus.
       mFocusMode = Parameters.FOCUS_MODE_AUTO;
     } else {
       mFocusMode = Parameters.FOCUS_MODE_CONTINUOUS_PICTURE;
     }

     if (!isSupported(mFocusMode, supportedFocusModes)) {
       // For some reasons, the driver does not support the current
       // focus mode. Fall back to auto.
       if (isSupported(Parameters.FOCUS_MODE_AUTO, mParameters.getSupportedFocusModes())) {
         mFocusMode = Parameters.FOCUS_MODE_AUTO;
       } else {
         mFocusMode = mParameters.getFocusMode();
       }
     }
     return mFocusMode;
   }

   public List<Area> getFocusAreas() {
     return mFocusArea;
   }

   public List<Area> getMeteringAreas() {
     return mMeteringArea;
   }

   private void updateFocusUI() {
     if (!mInitialized) {
       return;
     }
     FocusIndicator focusIndicator = mPieRenderer;

     if (mState == STATE_IDLE) {
       if (mFocusArea == null) {
         focusIndicator.clear();
       } else {
         // Users touch on the preview and the indicator represents the
         // metering area. Either focus area is not supported or
         // autoFocus call is not required.
         focusIndicator.showStart();
       }
     } else if (mState == STATE_FOCUSING || mState == STATE_FOCUSING_SNAP_ON_FINISH) {
       focusIndicator.showStart();
     } else {
       if (Parameters.FOCUS_MODE_CONTINUOUS_PICTURE.equals(mFocusMode)) {
         // TODO: check HAL behavior and decide if this can be removed.
         focusIndicator.showSuccess(false);
       } else if (mState == STATE_SUCCESS) {
         focusIndicator.showSuccess(false);
       } else if (mState == STATE_FAIL) {
         focusIndicator.showFail(false);
       }
     }
   }

   private void resetTouchFocus() {
     if (!mInitialized) {
       return;
     }

     // Put focus indicator to the center. clear reset position
     mPieRenderer.clear();

     mFocusArea = null;
     mMeteringArea = null;
   }

   private void calculateTapArea(
       int focusWidth,
       int focusHeight,
       float areaMultiple,
       int x,
       int y,
       int previewWidth,
       int previewHeight,
       Rect rect) {
     int areaWidth = (int) (focusWidth * areaMultiple);
     int areaHeight = (int) (focusHeight * areaMultiple);
     final int maxW = previewWidth - areaWidth;
     int left = maxW > 0 ? clamp(x - areaWidth / 2, 0, maxW) : 0;
     final int maxH = previewHeight - areaHeight;
     int top = maxH > 0 ? clamp(y - areaHeight / 2, 0, maxH) : 0;

     RectF rectF = new RectF(left, top, left + areaWidth, top + areaHeight);
     mMatrix.mapRect(rectF);
     rectFToRect(rectF, rect);
   }

   private int clamp(int x, int min, int max) {
     Assert.checkArgument(max >= min);
     if (x > max) {
       return max;
     }
     if (x < min) {
       return min;
     }
     return x;
   }

   private boolean isAutoExposureLockSupported(Parameters params) {
     return TRUE.equals(params.get(AUTO_EXPOSURE_LOCK_SUPPORTED));
   }

   private boolean isAutoWhiteBalanceLockSupported(Parameters params) {
     return TRUE.equals(params.get(AUTO_WHITE_BALANCE_LOCK_SUPPORTED));
   }

   private boolean isSupported(String value, List<String> supported) {
     return supported != null && supported.indexOf(value) >= 0;
   }

   private boolean isMeteringAreaSupported(Parameters params) {
     return params.getMaxNumMeteringAreas() > 0;
   }

   private boolean isFocusAreaSupported(Parameters params) {
     return (params.getMaxNumFocusAreas() > 0
         && isSupported(Parameters.FOCUS_MODE_AUTO, params.getSupportedFocusModes()));
   }

   private void prepareMatrix(Matrix matrix, boolean mirror, int viewWidth, int viewHeight) {
     // Need mirror for front camera.
     matrix.setScale(mirror ? -1 : 1, 1);
     // Camera driver coordinates range from (-1000, -1000) to (1000, 1000).
     // UI coordinates range from (0, 0) to (width, height).
     matrix.postScale(viewWidth / 2000f, viewHeight / 2000f);
     matrix.postTranslate(viewWidth / 2f, viewHeight / 2f);
   }

   private void rectFToRect(RectF rectF, Rect rect) {
     rect.left = Math.round(rectF.left);
     rect.top = Math.round(rectF.top);
     rect.right = Math.round(rectF.right);
     rect.bottom = Math.round(rectF.bottom);
   }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.dialer.callcomposer.camera.camerafocus;

	import android.graphics.Matrix;
	import android.graphics.Rect;
	import android.graphics.RectF;
	import android.hardware.Camera.Area;
	import android.hardware.Camera.Parameters;
	import android.os.Handler;
	import android.os.Looper;
	import android.os.Message;
	import com.android.dialer.common.Assert;
	import com.android.dialer.common.LogUtil;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* A class that handles everything about focus in still picture mode. This also handles the metering
	* area because it is the same as focus area.
	*
	* <p>The test cases: (1) The camera has continuous autofocus. Move the camera. Take a picture when
	* CAF is not in progress. (2) The camera has continuous autofocus. Move the camera. Take a picture
	* when CAF is in progress. (3) The camera has face detection. Point the camera at some faces. Hold
	* the shutter. Release to take a picture. (4) The camera has face detection. Point the camera at
	* some faces. Single tap the shutter to take a picture. (5) The camera has autofocus. Single tap
	* the shutter to take a picture. (6) The camera has autofocus. Hold the shutter. Release to take a
	* picture. (7) The camera has no autofocus. Single tap the shutter and take a picture. (8) The
	* camera has autofocus and supports focus area. Touch the screen to trigger autofocus. Take a
	* picture. (9) The camera has autofocus and supports focus area. Touch the screen to trigger
	* autofocus. Wait until it times out. (10) The camera has no autofocus and supports metering area.
	* Touch the screen to change metering area.
	*/
	public class FocusOverlayManager {
	private static final String TRUE = "true";
	private static final String AUTO_EXPOSURE_LOCK_SUPPORTED = "auto-exposure-lock-supported";
	private static final String AUTO_WHITE_BALANCE_LOCK_SUPPORTED =
	"auto-whitebalance-lock-supported";

	private static final int RESET_TOUCH_FOCUS = 0;
	private static final int RESET_TOUCH_FOCUS_DELAY = 3000;

	private int mState = STATE_IDLE;
	private static final int STATE_IDLE = 0; // Focus is not active.
	private static final int STATE_FOCUSING = 1; // Focus is in progress.
	// Focus is in progress and the camera should take a picture after focus finishes.
	private static final int STATE_FOCUSING_SNAP_ON_FINISH = 2;
	private static final int STATE_SUCCESS = 3; // Focus finishes and succeeds.
	private static final int STATE_FAIL = 4; // Focus finishes and fails.

	private boolean mInitialized;
	private boolean mFocusAreaSupported;
	private boolean mMeteringAreaSupported;
	private boolean mLockAeAwbNeeded;
	private boolean mAeAwbLock;
	private Matrix mMatrix;

	private PieRenderer mPieRenderer;

	private int mPreviewWidth; // The width of the preview frame layout.
	private int mPreviewHeight; // The height of the preview frame layout.
	private boolean mMirror; // true if the camera is front-facing.
	private List<Area> mFocusArea; // focus area in driver format
	private List<Area> mMeteringArea; // metering area in driver format
	private String mFocusMode;
	private Parameters mParameters;
	private Handler mHandler;
	private Listener mListener;

	/** Listener used for the focus indicator to communicate back to the camera. */
	public interface Listener {
	void autoFocus();

	void cancelAutoFocus();

	boolean capture();

	void setFocusParameters();
	}

	private class MainHandler extends Handler {
	public MainHandler(Looper looper) {
	super(looper);
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case RESET_TOUCH_FOCUS:
	{
	cancelAutoFocus();
	break;
	}
	}
	}
	}

	public FocusOverlayManager(Listener listener, Looper looper) {
	mHandler = new MainHandler(looper);
	mMatrix = new Matrix();
	mListener = listener;
	}

	public void setFocusRenderer(PieRenderer renderer) {
	mPieRenderer = renderer;
	mInitialized = (mMatrix != null);
	}

	public void setParameters(Parameters parameters) {
	// parameters can only be null when onConfigurationChanged is called
	// before camera is open. We will just return in this case, because
	// parameters will be set again later with the right parameters after
	// camera is open.
	if (parameters == null) {
	return;
	}
	mParameters = parameters;
	mFocusAreaSupported = isFocusAreaSupported(parameters);
	mMeteringAreaSupported = isMeteringAreaSupported(parameters);
	mLockAeAwbNeeded =
	(isAutoExposureLockSupported(mParameters) \|\| isAutoWhiteBalanceLockSupported(mParameters));
	}

	public void setPreviewSize(int previewWidth, int previewHeight) {
	if (mPreviewWidth != previewWidth \|\| mPreviewHeight != previewHeight) {
	mPreviewWidth = previewWidth;
	mPreviewHeight = previewHeight;
	setMatrix();
	}
	}

	public void setMirror(boolean mirror) {
	mMirror = mirror;
	setMatrix();
	}

	private void setMatrix() {
	if (mPreviewWidth != 0 && mPreviewHeight != 0) {
	Matrix matrix = new Matrix();
	prepareMatrix(matrix, mMirror, mPreviewWidth, mPreviewHeight);
	// In face detection, the matrix converts the driver coordinates to UI
	// coordinates. In tap focus, the inverted matrix converts the UI
	// coordinates to driver coordinates.
	matrix.invert(mMatrix);
	mInitialized = (mPieRenderer != null);
	}
	}

	private void lockAeAwbIfNeeded() {
	if (mLockAeAwbNeeded && !mAeAwbLock) {
	mAeAwbLock = true;
	mListener.setFocusParameters();
	}
	}

	public void onAutoFocus(boolean focused, boolean shutterButtonPressed) {
	if (mState == STATE_FOCUSING_SNAP_ON_FINISH) {
	// Take the picture no matter focus succeeds or fails. No need
	// to play the AF sound if we're about to play the shutter
	// sound.
	if (focused) {
	mState = STATE_SUCCESS;
	} else {
	mState = STATE_FAIL;
	}
	updateFocusUI();
	capture();
	} else if (mState == STATE_FOCUSING) {
	// This happens when (1) user is half-pressing the focus key or
	// (2) touch focus is triggered. Play the focus tone. Do not
	// take the picture now.
	if (focused) {
	mState = STATE_SUCCESS;
	} else {
	mState = STATE_FAIL;
	}
	updateFocusUI();
	// If this is triggered by touch focus, cancel focus after a
	// while.
	if (mFocusArea != null) {
	mHandler.sendEmptyMessageDelayed(RESET_TOUCH_FOCUS, RESET_TOUCH_FOCUS_DELAY);
	}
	if (shutterButtonPressed) {
	// Lock AE & AWB so users can half-press shutter and recompose.
	lockAeAwbIfNeeded();
	}
	} else if (mState == STATE_IDLE) {
	// User has released the focus key before focus completes.
	// Do nothing.
	}
	}

	public void onAutoFocusMoving(boolean moving) {
	if (!mInitialized) {
	return;
	}

	// Ignore if we have requested autofocus. This method only handles
	// continuous autofocus.
	if (mState != STATE_IDLE) {
	return;
	}

	if (moving) {
	mPieRenderer.showStart();
	} else {
	mPieRenderer.showSuccess(true);
	}
	}

	private void initializeFocusAreas(
	int focusWidth, int focusHeight, int x, int y, int previewWidth, int previewHeight) {
	if (mFocusArea == null) {
	mFocusArea = new ArrayList<>();
	mFocusArea.add(new Area(new Rect(), 1));
	}

	// Convert the coordinates to driver format.
	calculateTapArea(
	focusWidth, focusHeight, 1f, x, y, previewWidth, previewHeight, mFocusArea.get(0).rect);
	}

	private void initializeMeteringAreas(
	int focusWidth, int focusHeight, int x, int y, int previewWidth, int previewHeight) {
	if (mMeteringArea == null) {
	mMeteringArea = new ArrayList<>();
	mMeteringArea.add(new Area(new Rect(), 1));
	}

	// Convert the coordinates to driver format.
	// AE area is bigger because exposure is sensitive and
	// easy to over- or underexposure if area is too small.
	calculateTapArea(
	focusWidth,
	focusHeight,
	1.5f,
	x,
	y,
	previewWidth,
	previewHeight,
	mMeteringArea.get(0).rect);
	}

	public void onSingleTapUp(int x, int y) {
	if (!mInitialized \|\| mState == STATE_FOCUSING_SNAP_ON_FINISH) {
	return;
	}

	// Let users be able to cancel previous touch focus.
	if ((mFocusArea != null)
	&& (mState == STATE_FOCUSING \|\| mState == STATE_SUCCESS \|\| mState == STATE_FAIL)) {
	cancelAutoFocus();
	}
	// Initialize variables.
	int focusWidth = mPieRenderer.getSize();
	int focusHeight = mPieRenderer.getSize();
	if (focusWidth == 0 \|\| mPieRenderer.getWidth() == 0 \|\| mPieRenderer.getHeight() == 0) {
	return;
	}
	int previewWidth = mPreviewWidth;
	int previewHeight = mPreviewHeight;
	// Initialize mFocusArea.
	if (mFocusAreaSupported) {
	initializeFocusAreas(focusWidth, focusHeight, x, y, previewWidth, previewHeight);
	}
	// Initialize mMeteringArea.
	if (mMeteringAreaSupported) {
	initializeMeteringAreas(focusWidth, focusHeight, x, y, previewWidth, previewHeight);
	}

	// Use margin to set the focus indicator to the touched area.
	mPieRenderer.setFocus(x, y);

	// Set the focus area and metering area.
	mListener.setFocusParameters();
	if (mFocusAreaSupported) {
	autoFocus();
	} else { // Just show the indicator in all other cases.
	updateFocusUI();
	// Reset the metering area in 3 seconds.
	mHandler.removeMessages(RESET_TOUCH_FOCUS);
	mHandler.sendEmptyMessageDelayed(RESET_TOUCH_FOCUS, RESET_TOUCH_FOCUS_DELAY);
	}
	}

	public void onPreviewStarted() {
	mState = STATE_IDLE;
	}

	public void onPreviewStopped() {
	// If auto focus was in progress, it would have been stopped.
	mState = STATE_IDLE;
	resetTouchFocus();
	updateFocusUI();
	}

	public void onCameraReleased() {
	onPreviewStopped();
	}

	private void autoFocus() {
	LogUtil.v("FocusOverlayManager.autoFocus", "Start autofocus.");
	mListener.autoFocus();
	mState = STATE_FOCUSING;
	updateFocusUI();
	mHandler.removeMessages(RESET_TOUCH_FOCUS);
	}

	public void cancelAutoFocus() {
	LogUtil.v("FocusOverlayManager.cancelAutoFocus", "Cancel autofocus.");

	// Reset the tap area before calling mListener.cancelAutofocus.
	// Otherwise, focus mode stays at auto and the tap area passed to the
	// driver is not reset.
	resetTouchFocus();
	mListener.cancelAutoFocus();
	mState = STATE_IDLE;
	updateFocusUI();
	mHandler.removeMessages(RESET_TOUCH_FOCUS);
	}

	private void capture() {
	if (mListener.capture()) {
	mState = STATE_IDLE;
	mHandler.removeMessages(RESET_TOUCH_FOCUS);
	}
	}

	public String getFocusMode() {
	List<String> supportedFocusModes = mParameters.getSupportedFocusModes();

	if (mFocusAreaSupported && mFocusArea != null) {
	// Always use autofocus in tap-to-focus.
	mFocusMode = Parameters.FOCUS_MODE_AUTO;
	} else {
	mFocusMode = Parameters.FOCUS_MODE_CONTINUOUS_PICTURE;
	}

	if (!isSupported(mFocusMode, supportedFocusModes)) {
	// For some reasons, the driver does not support the current
	// focus mode. Fall back to auto.
	if (isSupported(Parameters.FOCUS_MODE_AUTO, mParameters.getSupportedFocusModes())) {
	mFocusMode = Parameters.FOCUS_MODE_AUTO;
	} else {
	mFocusMode = mParameters.getFocusMode();
	}
	}
	return mFocusMode;
	}

	public List<Area> getFocusAreas() {
	return mFocusArea;
	}

	public List<Area> getMeteringAreas() {
	return mMeteringArea;
	}

	private void updateFocusUI() {
	if (!mInitialized) {
	return;
	}
	FocusIndicator focusIndicator = mPieRenderer;

	if (mState == STATE_IDLE) {
	if (mFocusArea == null) {
	focusIndicator.clear();
	} else {
	// Users touch on the preview and the indicator represents the
	// metering area. Either focus area is not supported or
	// autoFocus call is not required.
	focusIndicator.showStart();
	}
	} else if (mState == STATE_FOCUSING \|\| mState == STATE_FOCUSING_SNAP_ON_FINISH) {
	focusIndicator.showStart();
	} else {
	if (Parameters.FOCUS_MODE_CONTINUOUS_PICTURE.equals(mFocusMode)) {
	// TODO: check HAL behavior and decide if this can be removed.
	focusIndicator.showSuccess(false);
	} else if (mState == STATE_SUCCESS) {
	focusIndicator.showSuccess(false);
	} else if (mState == STATE_FAIL) {
	focusIndicator.showFail(false);
	}
	}
	}

	private void resetTouchFocus() {
	if (!mInitialized) {
	return;
	}

	// Put focus indicator to the center. clear reset position
	mPieRenderer.clear();

	mFocusArea = null;
	mMeteringArea = null;
	}

	private void calculateTapArea(
	int focusWidth,
	int focusHeight,
	float areaMultiple,
	int x,
	int y,
	int previewWidth,
	int previewHeight,
	Rect rect) {
	int areaWidth = (int) (focusWidth * areaMultiple);
	int areaHeight = (int) (focusHeight * areaMultiple);
	final int maxW = previewWidth - areaWidth;
	int left = maxW > 0 ? clamp(x - areaWidth / 2, 0, maxW) : 0;
	final int maxH = previewHeight - areaHeight;
	int top = maxH > 0 ? clamp(y - areaHeight / 2, 0, maxH) : 0;

	RectF rectF = new RectF(left, top, left + areaWidth, top + areaHeight);
	mMatrix.mapRect(rectF);
	rectFToRect(rectF, rect);
	}

	private int clamp(int x, int min, int max) {
	Assert.checkArgument(max >= min);
	if (x > max) {
	return max;
	}
	if (x < min) {
	return min;
	}
	return x;
	}

	private boolean isAutoExposureLockSupported(Parameters params) {
	return TRUE.equals(params.get(AUTO_EXPOSURE_LOCK_SUPPORTED));
	}

	private boolean isAutoWhiteBalanceLockSupported(Parameters params) {
	return TRUE.equals(params.get(AUTO_WHITE_BALANCE_LOCK_SUPPORTED));
	}

	private boolean isSupported(String value, List<String> supported) {
	return supported != null && supported.indexOf(value) >= 0;
	}

	private boolean isMeteringAreaSupported(Parameters params) {
	return params.getMaxNumMeteringAreas() > 0;
	}

	private boolean isFocusAreaSupported(Parameters params) {
	return (params.getMaxNumFocusAreas() > 0
	&& isSupported(Parameters.FOCUS_MODE_AUTO, params.getSupportedFocusModes()));
	}

	private void prepareMatrix(Matrix matrix, boolean mirror, int viewWidth, int viewHeight) {
	// Need mirror for front camera.
	matrix.setScale(mirror ? -1 : 1, 1);
	// Camera driver coordinates range from (-1000, -1000) to (1000, 1000).
	// UI coordinates range from (0, 0) to (width, height).
	matrix.postScale(viewWidth / 2000f, viewHeight / 2000f);
	matrix.postTranslate(viewWidth / 2f, viewHeight / 2f);
	}

	private void rectFToRect(RectF rectF, Rect rect) {
	rect.left = Math.round(rectF.left);
	rect.top = Math.round(rectF.top);
	rect.right = Math.round(rectF.right);
	rect.bottom = Math.round(rectF.bottom);
	}
	}