src/com/android/camera/PhotoUI.java - platform/packages/apps/Camera2 - Git at Google

 /*
  * Copyright (C) 2012 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.camera;

 import android.app.Dialog;
 import android.content.DialogInterface;
 import android.graphics.Bitmap;
 import android.graphics.RectF;
 import android.graphics.SurfaceTexture;
 import android.hardware.Camera.Face;
 import android.os.AsyncTask;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 import android.widget.ImageView;

 import com.android.camera.captureintent.PictureDecoder;
 import com.android.camera.debug.DebugPropertyHelper;
 import com.android.camera.debug.Log;
 import com.android.camera.ui.CountDownView;
 import com.android.camera.ui.FaceView;
 import com.android.camera.ui.PreviewOverlay;
 import com.android.camera.ui.PreviewStatusListener;
 import com.android.camera.ui.focus.FocusRing;
 import com.android.camera2.R;
 import com.android.ex.camera2.portability.CameraAgent;
 import com.android.ex.camera2.portability.CameraCapabilities;
 import com.android.ex.camera2.portability.CameraSettings;

 public class PhotoUI implements PreviewStatusListener,
     CameraAgent.CameraFaceDetectionCallback, PreviewStatusListener.PreviewAreaChangedListener {

     private static final Log.Tag TAG = new Log.Tag("PhotoUI");
     private static final int DOWN_SAMPLE_FACTOR = 4;
     private static final float UNSET = 0f;

     private final PreviewOverlay mPreviewOverlay;
     private final FocusRing mFocusRing;
     private final CameraActivity mActivity;
     private final PhotoController mController;

     private final View mRootView;
     private Dialog mDialog = null;

     // TODO: Remove face view logic if UX does not bring it back within a month.
     private final FaceView mFaceView;
     private DecodeImageForReview mDecodeTaskForReview = null;

     private float mZoomMax;

     private int mPreviewWidth = 0;
     private int mPreviewHeight = 0;
     private float mAspectRatio = UNSET;

     private ImageView mIntentReviewImageView;

     private final GestureDetector.OnGestureListener mPreviewGestureListener
             = new GestureDetector.SimpleOnGestureListener() {
         @Override
         public boolean onSingleTapUp(MotionEvent ev) {
             mController.onSingleTapUp(null, (int) ev.getX(), (int) ev.getY());
             return true;
         }
     };
     private final DialogInterface.OnDismissListener mOnDismissListener
             = new DialogInterface.OnDismissListener() {
         @Override
         public void onDismiss(DialogInterface dialog) {
             mDialog = null;
         }
     };
     private final CountDownView mCountdownView;

     @Override
     public GestureDetector.OnGestureListener getGestureListener() {
         return mPreviewGestureListener;
     }

     @Override
     public View.OnTouchListener getTouchListener() {
         return null;
     }

     @Override
     public void onPreviewLayoutChanged(View v, int left, int top, int right,
             int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
         int width = right - left;
         int height = bottom - top;
         if (mPreviewWidth != width || mPreviewHeight != height) {
             mPreviewWidth = width;
             mPreviewHeight = height;
         }
     }

     @Override
     public boolean shouldAutoAdjustTransformMatrixOnLayout() {
         return true;
     }

     @Override
     public void onPreviewFlipped() {
         mController.updateCameraOrientation();
     }

     /**
      * Starts the countdown timer.
      *
      * @param sec seconds to countdown
      */
     public void startCountdown(int sec) {
         mCountdownView.startCountDown(sec);
     }

     /**
      * Sets a listener that gets notified when the countdown is finished.
      */
     public void setCountdownFinishedListener(CountDownView.OnCountDownStatusListener listener) {
         mCountdownView.setCountDownStatusListener(listener);
     }

     /**
      * Returns whether the countdown is on-going.
      */
     public boolean isCountingDown() {
         return mCountdownView.isCountingDown();
     }

     /**
      * Cancels the on-going countdown, if any.
      */
     public void cancelCountDown() {
         mCountdownView.cancelCountDown();
     }

     @Override
     public void onPreviewAreaChanged(RectF previewArea) {
         if (mFaceView != null) {
             mFaceView.onPreviewAreaChanged(previewArea);
         }
         mCountdownView.onPreviewAreaChanged(previewArea);
     }

     private class DecodeTask extends AsyncTask<Void, Void, Bitmap> {
         private final byte [] mData;
         private final int mOrientation;
         private final boolean mMirror;

         public DecodeTask(byte[] data, int orientation, boolean mirror) {
             mData = data;
             mOrientation = orientation;
             mMirror = mirror;
         }

         @Override
         protected Bitmap doInBackground(Void... params) {
             // Decode image in background.
             return PictureDecoder.decode(mData, DOWN_SAMPLE_FACTOR, mOrientation, mMirror);
         }
     }

     private class DecodeImageForReview extends DecodeTask {
         public DecodeImageForReview(byte[] data, int orientation, boolean mirror) {
             super(data, orientation, mirror);
         }

         @Override
         protected void onPostExecute(Bitmap bitmap) {
             if (isCancelled()) {
                 return;
             }

             mIntentReviewImageView.setImageBitmap(bitmap);
             showIntentReviewImageView();

             mDecodeTaskForReview = null;
         }
     }

     public PhotoUI(CameraActivity activity, PhotoController controller, View parent) {
         mActivity = activity;
         mController = controller;
         mRootView = parent;

         ViewGroup moduleRoot = (ViewGroup) mRootView.findViewById(R.id.module_layout);
         mActivity.getLayoutInflater().inflate(R.layout.photo_module,
                  moduleRoot, true);
         initIndicators();
         mFocusRing = (FocusRing) mRootView.findViewById(R.id.focus_ring);
         mPreviewOverlay = (PreviewOverlay) mRootView.findViewById(R.id.preview_overlay);
         mCountdownView = (CountDownView) mRootView.findViewById(R.id.count_down_view);
         // Show faces if we are in debug mode.
         if (DebugPropertyHelper.showCaptureDebugUI()) {
             mFaceView = (FaceView) mRootView.findViewById(R.id.face_view);
         } else {
             mFaceView = null;
         }

         if (mController.isImageCaptureIntent()) {
             initIntentReviewImageView();
         }
     }

     private void initIntentReviewImageView() {
         mIntentReviewImageView = (ImageView) mRootView.findViewById(R.id.intent_review_imageview);
         mActivity.getCameraAppUI().addPreviewAreaChangedListener(
                 new PreviewStatusListener.PreviewAreaChangedListener() {
                     @Override
                     public void onPreviewAreaChanged(RectF previewArea) {
                         FrameLayout.LayoutParams params =
                             (FrameLayout.LayoutParams) mIntentReviewImageView.getLayoutParams();
                         params.width = (int) previewArea.width();
                         params.height = (int) previewArea.height();
                         params.setMargins((int) previewArea.left, (int) previewArea.top, 0, 0);
                         mIntentReviewImageView.setLayoutParams(params);
                     }
                 });
     }

     /**
      * Show the image review over the live preview for intent captures.
      */
     public void showIntentReviewImageView() {
         if (mIntentReviewImageView != null) {
             mIntentReviewImageView.setVisibility(View.VISIBLE);
         }
     }

     /**
      * Hide the image review over the live preview for intent captures.
      */
     public void hideIntentReviewImageView() {
         if (mIntentReviewImageView != null) {
             mIntentReviewImageView.setVisibility(View.INVISIBLE);
         }
     }


     public FocusRing getFocusRing() {
         return mFocusRing;
     }

     public void updatePreviewAspectRatio(float aspectRatio) {
         if (aspectRatio <= 0) {
             Log.e(TAG, "Invalid aspect ratio: " + aspectRatio);
             return;
         }
         if (aspectRatio < 1f) {
             aspectRatio = 1f / aspectRatio;
         }

         if (mAspectRatio != aspectRatio) {
             mAspectRatio = aspectRatio;
             // Update transform matrix with the new aspect ratio.
             mController.updatePreviewAspectRatio(mAspectRatio);
         }
     }

     @Override
     public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
         mController.onPreviewUIReady();
     }

     @Override
     public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
         // Ignored, Camera does all the work for us
     }

     @Override
     public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
         mController.onPreviewUIDestroyed();
         return true;
     }

     @Override
     public void onSurfaceTextureUpdated(SurfaceTexture surface) {
     }

     private void initIndicators() {
         // TODO init toggle buttons on bottom bar here
     }

     public void onCameraOpened(CameraCapabilities capabilities, CameraSettings settings) {
         initializeZoom(capabilities, settings);
     }

     public void animateCapture(final byte[] jpegData, int orientation, boolean mirror) {
         // Decode jpeg byte array and then animate the jpeg
         DecodeTask task = new DecodeTask(jpegData, orientation, mirror);
         task.execute();
     }

     // called from onResume but only the first time
     public void initializeFirstTime() {

     }

     // called from onResume every other time
     public void initializeSecondTime(CameraCapabilities capabilities, CameraSettings settings) {
         initializeZoom(capabilities, settings);
         if (mController.isImageCaptureIntent()) {
             hidePostCaptureAlert();
         }
     }

     public void initializeZoom(CameraCapabilities capabilities, CameraSettings settings) {
         if ((capabilities == null) || settings == null ||
                 !capabilities.supports(CameraCapabilities.Feature.ZOOM)) {
             return;
         }
         mZoomMax = capabilities.getMaxZoomRatio();
         // Currently we use immediate zoom for fast zooming to get better UX and
         // there is no plan to take advantage of the smooth zoom.
         // TODO: Need to setup a path to AppUI to do this
         mPreviewOverlay.setupZoom(mZoomMax, settings.getCurrentZoomRatio(),
                 new ZoomChangeListener());
     }

     public void animateFlash() {
         mController.startPreCaptureAnimation();
     }

     public boolean onBackPressed() {
         // In image capture mode, back button should:
         // 1) if there is any popup, dismiss them, 2) otherwise, get out of
         // image capture
         if (mController.isImageCaptureIntent()) {
             mController.onCaptureCancelled();
             return true;
         } else if (!mController.isCameraIdle()) {
             // ignore backs while we're taking a picture
             return true;
         } else {
             return false;
         }
     }

     protected void showCapturedImageForReview(byte[] jpegData, int orientation, boolean mirror) {
         mDecodeTaskForReview = new DecodeImageForReview(jpegData, orientation, mirror);
         mDecodeTaskForReview.execute();

         mActivity.getCameraAppUI().transitionToIntentReviewLayout();
         pauseFaceDetection();
     }

     protected void hidePostCaptureAlert() {
         if (mDecodeTaskForReview != null) {
             mDecodeTaskForReview.cancel(true);
         }
         resumeFaceDetection();
     }

     public void setDisplayOrientation(int orientation) {
         if (mFaceView != null) {
             mFaceView.setDisplayOrientation(orientation);
         }
     }

     private class ZoomChangeListener implements PreviewOverlay.OnZoomChangedListener {
         @Override
         public void onZoomValueChanged(float ratio) {
             mController.onZoomChanged(ratio);
         }

         @Override
         public void onZoomStart() {
         }

         @Override
         public void onZoomEnd() {
         }
     }

     public void setSwipingEnabled(boolean enable) {
         mActivity.setSwipingEnabled(enable);
     }

     public void onPause() {
         if (mFaceView != null) {
             mFaceView.clear();
         }
         if (mDialog != null) {
             mDialog.dismiss();
         }
         // recalculate aspect ratio when restarting.
         mAspectRatio = 0.0f;
     }

     public void clearFaces() {
         if (mFaceView != null) {
             mFaceView.clear();
         }
     }

     public void pauseFaceDetection() {
         if (mFaceView != null) {
             mFaceView.pause();
         }
     }

     public void resumeFaceDetection() {
         if (mFaceView != null) {
             mFaceView.resume();
         }
     }

     public void onStartFaceDetection(int orientation, boolean mirror) {
         if (mFaceView != null) {
             mFaceView.clear();
             mFaceView.setVisibility(View.VISIBLE);
             mFaceView.setDisplayOrientation(orientation);
             mFaceView.setMirror(mirror);
             mFaceView.resume();
         }
     }

     @Override
     public void onFaceDetection(Face[] faces, CameraAgent.CameraProxy camera) {
         if (mFaceView != null) {
             mFaceView.setFaces(faces);
         }
     }

 }
	/*
	* Copyright (C) 2012 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.camera;

	import android.app.Dialog;
	import android.content.DialogInterface;
	import android.graphics.Bitmap;
	import android.graphics.RectF;
	import android.graphics.SurfaceTexture;
	import android.hardware.Camera.Face;
	import android.os.AsyncTask;
	import android.view.GestureDetector;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.FrameLayout;
	import android.widget.ImageView;

	import com.android.camera.captureintent.PictureDecoder;
	import com.android.camera.debug.DebugPropertyHelper;
	import com.android.camera.debug.Log;
	import com.android.camera.ui.CountDownView;
	import com.android.camera.ui.FaceView;
	import com.android.camera.ui.PreviewOverlay;
	import com.android.camera.ui.PreviewStatusListener;
	import com.android.camera.ui.focus.FocusRing;
	import com.android.camera2.R;
	import com.android.ex.camera2.portability.CameraAgent;
	import com.android.ex.camera2.portability.CameraCapabilities;
	import com.android.ex.camera2.portability.CameraSettings;

	public class PhotoUI implements PreviewStatusListener,
	CameraAgent.CameraFaceDetectionCallback, PreviewStatusListener.PreviewAreaChangedListener {

	private static final Log.Tag TAG = new Log.Tag("PhotoUI");
	private static final int DOWN_SAMPLE_FACTOR = 4;
	private static final float UNSET = 0f;

	private final PreviewOverlay mPreviewOverlay;
	private final FocusRing mFocusRing;
	private final CameraActivity mActivity;
	private final PhotoController mController;

	private final View mRootView;
	private Dialog mDialog = null;

	// TODO: Remove face view logic if UX does not bring it back within a month.
	private final FaceView mFaceView;
	private DecodeImageForReview mDecodeTaskForReview = null;

	private float mZoomMax;

	private int mPreviewWidth = 0;
	private int mPreviewHeight = 0;
	private float mAspectRatio = UNSET;

	private ImageView mIntentReviewImageView;

	private final GestureDetector.OnGestureListener mPreviewGestureListener
	= new GestureDetector.SimpleOnGestureListener() {
	@Override
	public boolean onSingleTapUp(MotionEvent ev) {
	mController.onSingleTapUp(null, (int) ev.getX(), (int) ev.getY());
	return true;
	}
	};
	private final DialogInterface.OnDismissListener mOnDismissListener
	= new DialogInterface.OnDismissListener() {
	@Override
	public void onDismiss(DialogInterface dialog) {
	mDialog = null;
	}
	};
	private final CountDownView mCountdownView;

	@Override
	public GestureDetector.OnGestureListener getGestureListener() {
	return mPreviewGestureListener;
	}

	@Override
	public View.OnTouchListener getTouchListener() {
	return null;
	}

	@Override
	public void onPreviewLayoutChanged(View v, int left, int top, int right,
	int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
	int width = right - left;
	int height = bottom - top;
	if (mPreviewWidth != width \|\| mPreviewHeight != height) {
	mPreviewWidth = width;
	mPreviewHeight = height;
	}
	}

	@Override
	public boolean shouldAutoAdjustTransformMatrixOnLayout() {
	return true;
	}

	@Override
	public void onPreviewFlipped() {
	mController.updateCameraOrientation();
	}

	/**
	* Starts the countdown timer.
	*
	* @param sec seconds to countdown
	*/
	public void startCountdown(int sec) {
	mCountdownView.startCountDown(sec);
	}

	/**
	* Sets a listener that gets notified when the countdown is finished.
	*/
	public void setCountdownFinishedListener(CountDownView.OnCountDownStatusListener listener) {
	mCountdownView.setCountDownStatusListener(listener);
	}

	/**
	* Returns whether the countdown is on-going.
	*/
	public boolean isCountingDown() {
	return mCountdownView.isCountingDown();
	}

	/**
	* Cancels the on-going countdown, if any.
	*/
	public void cancelCountDown() {
	mCountdownView.cancelCountDown();
	}

	@Override
	public void onPreviewAreaChanged(RectF previewArea) {
	if (mFaceView != null) {
	mFaceView.onPreviewAreaChanged(previewArea);
	}
	mCountdownView.onPreviewAreaChanged(previewArea);
	}

	private class DecodeTask extends AsyncTask<Void, Void, Bitmap> {
	private final byte [] mData;
	private final int mOrientation;
	private final boolean mMirror;

	public DecodeTask(byte[] data, int orientation, boolean mirror) {
	mData = data;
	mOrientation = orientation;
	mMirror = mirror;
	}

	@Override
	protected Bitmap doInBackground(Void... params) {
	// Decode image in background.
	return PictureDecoder.decode(mData, DOWN_SAMPLE_FACTOR, mOrientation, mMirror);
	}
	}

	private class DecodeImageForReview extends DecodeTask {
	public DecodeImageForReview(byte[] data, int orientation, boolean mirror) {
	super(data, orientation, mirror);
	}

	@Override
	protected void onPostExecute(Bitmap bitmap) {
	if (isCancelled()) {
	return;
	}

	mIntentReviewImageView.setImageBitmap(bitmap);
	showIntentReviewImageView();

	mDecodeTaskForReview = null;
	}
	}

	public PhotoUI(CameraActivity activity, PhotoController controller, View parent) {
	mActivity = activity;
	mController = controller;
	mRootView = parent;

	ViewGroup moduleRoot = (ViewGroup) mRootView.findViewById(R.id.module_layout);
	mActivity.getLayoutInflater().inflate(R.layout.photo_module,
	moduleRoot, true);
	initIndicators();
	mFocusRing = (FocusRing) mRootView.findViewById(R.id.focus_ring);
	mPreviewOverlay = (PreviewOverlay) mRootView.findViewById(R.id.preview_overlay);
	mCountdownView = (CountDownView) mRootView.findViewById(R.id.count_down_view);
	// Show faces if we are in debug mode.
	if (DebugPropertyHelper.showCaptureDebugUI()) {
	mFaceView = (FaceView) mRootView.findViewById(R.id.face_view);
	} else {
	mFaceView = null;
	}

	if (mController.isImageCaptureIntent()) {
	initIntentReviewImageView();
	}
	}

	private void initIntentReviewImageView() {
	mIntentReviewImageView = (ImageView) mRootView.findViewById(R.id.intent_review_imageview);
	mActivity.getCameraAppUI().addPreviewAreaChangedListener(
	new PreviewStatusListener.PreviewAreaChangedListener() {
	@Override
	public void onPreviewAreaChanged(RectF previewArea) {
	FrameLayout.LayoutParams params =
	(FrameLayout.LayoutParams) mIntentReviewImageView.getLayoutParams();
	params.width = (int) previewArea.width();
	params.height = (int) previewArea.height();
	params.setMargins((int) previewArea.left, (int) previewArea.top, 0, 0);
	mIntentReviewImageView.setLayoutParams(params);
	}
	});
	}

	/**
	* Show the image review over the live preview for intent captures.
	*/
	public void showIntentReviewImageView() {
	if (mIntentReviewImageView != null) {
	mIntentReviewImageView.setVisibility(View.VISIBLE);
	}
	}

	/**
	* Hide the image review over the live preview for intent captures.
	*/
	public void hideIntentReviewImageView() {
	if (mIntentReviewImageView != null) {
	mIntentReviewImageView.setVisibility(View.INVISIBLE);
	}
	}


	public FocusRing getFocusRing() {
	return mFocusRing;
	}

	public void updatePreviewAspectRatio(float aspectRatio) {
	if (aspectRatio <= 0) {
	Log.e(TAG, "Invalid aspect ratio: " + aspectRatio);
	return;
	}
	if (aspectRatio < 1f) {
	aspectRatio = 1f / aspectRatio;
	}

	if (mAspectRatio != aspectRatio) {
	mAspectRatio = aspectRatio;
	// Update transform matrix with the new aspect ratio.
	mController.updatePreviewAspectRatio(mAspectRatio);
	}
	}

	@Override
	public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
	mController.onPreviewUIReady();
	}

	@Override
	public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
	// Ignored, Camera does all the work for us
	}

	@Override
	public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
	mController.onPreviewUIDestroyed();
	return true;
	}

	@Override
	public void onSurfaceTextureUpdated(SurfaceTexture surface) {
	}

	private void initIndicators() {
	// TODO init toggle buttons on bottom bar here
	}

	public void onCameraOpened(CameraCapabilities capabilities, CameraSettings settings) {
	initializeZoom(capabilities, settings);
	}

	public void animateCapture(final byte[] jpegData, int orientation, boolean mirror) {
	// Decode jpeg byte array and then animate the jpeg
	DecodeTask task = new DecodeTask(jpegData, orientation, mirror);
	task.execute();
	}

	// called from onResume but only the first time
	public void initializeFirstTime() {

	}

	// called from onResume every other time
	public void initializeSecondTime(CameraCapabilities capabilities, CameraSettings settings) {
	initializeZoom(capabilities, settings);
	if (mController.isImageCaptureIntent()) {
	hidePostCaptureAlert();
	}
	}

	public void initializeZoom(CameraCapabilities capabilities, CameraSettings settings) {
	if ((capabilities == null) \|\| settings == null \|\|
	!capabilities.supports(CameraCapabilities.Feature.ZOOM)) {
	return;
	}
	mZoomMax = capabilities.getMaxZoomRatio();
	// Currently we use immediate zoom for fast zooming to get better UX and
	// there is no plan to take advantage of the smooth zoom.
	// TODO: Need to setup a path to AppUI to do this
	mPreviewOverlay.setupZoom(mZoomMax, settings.getCurrentZoomRatio(),
	new ZoomChangeListener());
	}

	public void animateFlash() {
	mController.startPreCaptureAnimation();
	}

	public boolean onBackPressed() {
	// In image capture mode, back button should:
	// 1) if there is any popup, dismiss them, 2) otherwise, get out of
	// image capture
	if (mController.isImageCaptureIntent()) {
	mController.onCaptureCancelled();
	return true;
	} else if (!mController.isCameraIdle()) {
	// ignore backs while we're taking a picture
	return true;
	} else {
	return false;
	}
	}

	protected void showCapturedImageForReview(byte[] jpegData, int orientation, boolean mirror) {
	mDecodeTaskForReview = new DecodeImageForReview(jpegData, orientation, mirror);
	mDecodeTaskForReview.execute();

	mActivity.getCameraAppUI().transitionToIntentReviewLayout();
	pauseFaceDetection();
	}

	protected void hidePostCaptureAlert() {
	if (mDecodeTaskForReview != null) {
	mDecodeTaskForReview.cancel(true);
	}
	resumeFaceDetection();
	}

	public void setDisplayOrientation(int orientation) {
	if (mFaceView != null) {
	mFaceView.setDisplayOrientation(orientation);
	}
	}

	private class ZoomChangeListener implements PreviewOverlay.OnZoomChangedListener {
	@Override
	public void onZoomValueChanged(float ratio) {
	mController.onZoomChanged(ratio);
	}

	@Override
	public void onZoomStart() {
	}

	@Override
	public void onZoomEnd() {
	}
	}

	public void setSwipingEnabled(boolean enable) {
	mActivity.setSwipingEnabled(enable);
	}

	public void onPause() {
	if (mFaceView != null) {
	mFaceView.clear();
	}
	if (mDialog != null) {
	mDialog.dismiss();
	}
	// recalculate aspect ratio when restarting.
	mAspectRatio = 0.0f;
	}

	public void clearFaces() {
	if (mFaceView != null) {
	mFaceView.clear();
	}
	}

	public void pauseFaceDetection() {
	if (mFaceView != null) {
	mFaceView.pause();
	}
	}

	public void resumeFaceDetection() {
	if (mFaceView != null) {
	mFaceView.resume();
	}
	}

	public void onStartFaceDetection(int orientation, boolean mirror) {
	if (mFaceView != null) {
	mFaceView.clear();
	mFaceView.setVisibility(View.VISIBLE);
	mFaceView.setDisplayOrientation(orientation);
	mFaceView.setMirror(mirror);
	mFaceView.resume();
	}
	}

	@Override
	public void onFaceDetection(Face[] faces, CameraAgent.CameraProxy camera) {
	if (mFaceView != null) {
	mFaceView.setFaces(faces);
	}
	}

	}