src/com/android/camera/TextureViewHelper.java - fp2-dev/platform/packages/apps/Camera2 - Gitiles

 /*
  * Copyright (C) 2013 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.graphics.Bitmap;
 import android.graphics.Matrix;
 import android.graphics.RectF;
 import android.graphics.SurfaceTexture;
 import android.view.TextureView;
 import android.view.View;
 import android.view.View.OnLayoutChangeListener;

 import com.android.camera.app.AppController;
 import com.android.camera.app.CameraProvider;
 import com.android.camera.app.OrientationManager;
 import com.android.camera.debug.Log;
 import com.android.camera.device.CameraId;
 import com.android.camera.ui.PreviewStatusListener;
 import com.android.camera.util.ApiHelper;
 import com.android.camera.util.CameraUtil;
 import com.android.camera2.R;
 import com.android.ex.camera2.portability.CameraDeviceInfo;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * This class aims to automate TextureView transform change and notify listeners
  * (e.g. bottom bar) of the preview size change.
  */
 public class TextureViewHelper implements TextureView.SurfaceTextureListener,
         OnLayoutChangeListener {

     private static final Log.Tag TAG = new Log.Tag("TexViewHelper");
     public static final float MATCH_SCREEN = 0f;
     private static final int UNSET = -1;
     private final TextureView mPreview;
     private final CameraProvider mCameraProvider;
     private int mWidth = 0;
     private int mHeight = 0;
     private RectF mPreviewArea = new RectF();
     private float mAspectRatio = MATCH_SCREEN;
     private boolean mAutoAdjustTransform = true;
     private TextureView.SurfaceTextureListener mSurfaceTextureListener;

     private final ArrayList<PreviewStatusListener.PreviewAspectRatioChangedListener>
             mAspectRatioChangedListeners =
             new ArrayList<PreviewStatusListener.PreviewAspectRatioChangedListener>();

     private final ArrayList<PreviewStatusListener.PreviewAreaChangedListener>
             mPreviewSizeChangedListeners =
             new ArrayList<PreviewStatusListener.PreviewAreaChangedListener>();
     private OnLayoutChangeListener mOnLayoutChangeListener = null;
     private CaptureLayoutHelper mCaptureLayoutHelper = null;
     private int mOrientation = UNSET;

     // Hack to allow to know which module is running for b/20694189
     private final AppController mAppController;
     private final int mCameraModeId;
     private final int mCaptureIntentModeId;

     public TextureViewHelper(TextureView preview, CaptureLayoutHelper helper,
             CameraProvider cameraProvider, AppController appController) {
         mPreview = preview;
         mCameraProvider = cameraProvider;
         mPreview.addOnLayoutChangeListener(this);
         mPreview.setSurfaceTextureListener(this);
         mCaptureLayoutHelper = helper;
         mAppController = appController;
         mCameraModeId = appController.getAndroidContext().getResources()
                 .getInteger(R.integer.camera_mode_photo);
         mCaptureIntentModeId = appController.getAndroidContext().getResources()
                 .getInteger(R.integer.camera_mode_capture_intent);
     }

     /**
      * If auto adjust transform is enabled, when there is a layout change, the
      * transform matrix will be automatically adjusted based on the preview
      * stream aspect ratio in the new layout.
      *
      * @param enable whether or not auto adjustment should be enabled
      */
     public void setAutoAdjustTransform(boolean enable) {
         mAutoAdjustTransform = enable;
     }

     @Override
     public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft,
             int oldTop, int oldRight, int oldBottom) {
         Log.v(TAG, "onLayoutChange");
         int width = right - left;
         int height = bottom - top;
         int rotation = CameraUtil.getDisplayRotation();
         if (mWidth != width || mHeight != height || mOrientation != rotation) {
             mWidth = width;
             mHeight = height;
             mOrientation = rotation;
             if (!updateTransform()) {
                 clearTransform();
             }
         }
         if (mOnLayoutChangeListener != null) {
             mOnLayoutChangeListener.onLayoutChange(v, left, top, right, bottom, oldLeft, oldTop,
                     oldRight, oldBottom);
         }
     }

     /**
      * Transforms the preview with the identity matrix, ensuring there is no
      * scaling on the preview. It also calls onPreviewSizeChanged, to trigger
      * any necessary preview size changing callbacks.
      */
     public void clearTransform() {
         mPreview.setTransform(new Matrix());
         mPreviewArea.set(0, 0, mWidth, mHeight);
         onPreviewAreaChanged(mPreviewArea);
         setAspectRatio(MATCH_SCREEN);
     }

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

     private void setAspectRatio(float aspectRatio) {
         Log.v(TAG, "setAspectRatio: " + aspectRatio);
         if (mAspectRatio != aspectRatio) {
             Log.v(TAG, "aspect ratio changed from: " + mAspectRatio);
             mAspectRatio = aspectRatio;
             onAspectRatioChanged();
         }
     }

     private void onAspectRatioChanged() {
         mCaptureLayoutHelper.onPreviewAspectRatioChanged(mAspectRatio);
         for (PreviewStatusListener.PreviewAspectRatioChangedListener listener
                 : mAspectRatioChangedListeners) {
             listener.onPreviewAspectRatioChanged(mAspectRatio);
         }
     }

     public void addAspectRatioChangedListener(
             PreviewStatusListener.PreviewAspectRatioChangedListener listener) {
         if (listener != null && !mAspectRatioChangedListeners.contains(listener)) {
             mAspectRatioChangedListeners.add(listener);
         }
     }

     /**
      * This returns the rect that is available to display the preview, and
      * capture buttons
      *
      * @return the rect.
      */
     public RectF getFullscreenRect() {
         return mCaptureLayoutHelper.getFullscreenRect();
     }

     /**
      * This takes a matrix to apply to the texture view and uses the screen
      * aspect ratio as the target aspect ratio
      *
      * @param matrix the matrix to apply
      * @param aspectRatio the aspectRatio that the preview should be
      */
     public void updateTransformFullScreen(Matrix matrix, float aspectRatio) {
         aspectRatio = aspectRatio < 1 ? 1 / aspectRatio : aspectRatio;
         if (aspectRatio != mAspectRatio) {
             setAspectRatio(aspectRatio);
         }

         mPreview.setTransform(matrix);
         mPreviewArea = mCaptureLayoutHelper.getPreviewRect();
         onPreviewAreaChanged(mPreviewArea);

     }

     public void updateTransform(Matrix matrix) {
         RectF previewRect = new RectF(0, 0, mWidth, mHeight);
         matrix.mapRect(previewRect);

         float previewWidth = previewRect.width();
         float previewHeight = previewRect.height();
         if (previewHeight == 0 || previewWidth == 0) {
             Log.e(TAG, "Invalid preview size: " + previewWidth + " x " + previewHeight);
             return;
         }
         float aspectRatio = previewWidth / previewHeight;
         aspectRatio = aspectRatio < 1 ? 1 / aspectRatio : aspectRatio;
         if (aspectRatio != mAspectRatio) {
             setAspectRatio(aspectRatio);
         }

         RectF previewAreaBasedOnAspectRatio = mCaptureLayoutHelper.getPreviewRect();
         Matrix addtionalTransform = new Matrix();
         addtionalTransform.setRectToRect(previewRect, previewAreaBasedOnAspectRatio,
                 Matrix.ScaleToFit.CENTER);
         matrix.postConcat(addtionalTransform);
         mPreview.setTransform(matrix);
         updatePreviewArea(matrix);
     }

     /**
      * Calculates and updates the preview area rect using the latest transform
      * matrix.
      */
     private void updatePreviewArea(Matrix matrix) {
         mPreviewArea.set(0, 0, mWidth, mHeight);
         matrix.mapRect(mPreviewArea);
         onPreviewAreaChanged(mPreviewArea);
     }

     public void setOnLayoutChangeListener(OnLayoutChangeListener listener) {
         mOnLayoutChangeListener = listener;
     }

     public void setSurfaceTextureListener(TextureView.SurfaceTextureListener listener) {
         mSurfaceTextureListener = listener;
     }

     /**
      * Returns a transformation matrix that implements rotation that is
      * consistent with CaptureLayoutHelper and TextureViewHelper. The magical
      * invariant for CaptureLayoutHelper and TextureViewHelper that must be
      * obeyed is that the bounding box of the view must be EXACTLY the bounding
      * box of the surfaceDimensions AFTER the transformation has been applied.
      *
      * @param currentDisplayOrientation The current display orientation,
      *            measured counterclockwise from to the device's natural
      *            orientation (in degrees, always a multiple of 90, and between
      *            0 and 270, inclusive).
      * @param surfaceDimensions The dimensions of the
      *            {@link android.view.Surface} on which the preview image is
      *            being rendered. It usually only makes sense for the upper-left
      *            corner to be at the origin.
      * @param desiredBounds The boundaries within the
      *            {@link android.view.Surface} where the final image should
      *            appear. These can be used to translate and scale the output,
      *            but note that the image will be stretched to fit, possibly
      *            changing its aspect ratio.
      * @return The transform matrix that should be applied to the
      *         {@link android.view.Surface} in order for the image to display
      *         properly in the device's current orientation.
      */
     public Matrix getPreviewRotationalTransform(int currentDisplayOrientation,
             RectF surfaceDimensions,
             RectF desiredBounds) {
         if (surfaceDimensions.equals(desiredBounds)) {
             return new Matrix();
         }

         Matrix transform = new Matrix();
         transform.setRectToRect(surfaceDimensions, desiredBounds, Matrix.ScaleToFit.FILL);

         RectF normalRect = surfaceDimensions;
         // Bounding box of 90 or 270 degree rotation.
         RectF rotatedRect = new RectF(normalRect.width() / 2 - normalRect.height() / 2,
                 normalRect.height() / 2 - normalRect.width() / 2,
                 normalRect.width() / 2 + normalRect.height() / 2,
                 normalRect.height() / 2 + normalRect.width() / 2);

         OrientationManager.DeviceOrientation deviceOrientation =
                 OrientationManager.DeviceOrientation.from(currentDisplayOrientation);

         // This rotation code assumes that the aspect ratio of the content
         // (not of necessarily the surface) equals the aspect ratio of view that is receiving
         // the preview.  So, a 4:3 surface that contains 16:9 data will look correct as
         // long as the view is also 16:9.
         switch (deviceOrientation) {
             case CLOCKWISE_90:
                 transform.setRectToRect(rotatedRect, desiredBounds, Matrix.ScaleToFit.FILL);
                 transform.preRotate(270, mWidth / 2, mHeight / 2);
                 break;
             case CLOCKWISE_180:
                 transform.setRectToRect(normalRect, desiredBounds, Matrix.ScaleToFit.FILL);
                 transform.preRotate(180, mWidth / 2, mHeight / 2);
                 break;
             case CLOCKWISE_270:
                 transform.setRectToRect(rotatedRect, desiredBounds, Matrix.ScaleToFit.FILL);
                 transform.preRotate(90, mWidth / 2, mHeight / 2);
                 break;
             case CLOCKWISE_0:
             default:
                 transform.setRectToRect(normalRect, desiredBounds, Matrix.ScaleToFit.FILL);
                 break;
         }

         return transform;
     }

     /**
      * Updates the transform matrix based current width and height of
      * TextureView and preview stream aspect ratio.
      * <p>
      * If not {@code mAutoAdjustTransform}, this does nothing except return
      * {@code false}. In all other cases, it returns {@code true}, regardless of
      * whether the transform was changed.
      * </p>
      * In {@code mAutoAdjustTransform} and the CameraProvder is invalid, it is assumed
      * that the CaptureModule/PhotoModule is Camera2 API-based and must implements its
      * rotation via matrix transformation implemented in getPreviewRotationalTransform.
      *
      * @return Whether {@code mAutoAdjustTransform}.
      */
     private boolean updateTransform() {
         Log.v(TAG, "updateTransform");
         if (!mAutoAdjustTransform) {
             return false;
         }

         if (mAspectRatio == MATCH_SCREEN || mAspectRatio < 0 || mWidth == 0 || mHeight == 0) {
             return true;
         }

         Matrix matrix = new Matrix();
         CameraId cameraKey = mCameraProvider.getCurrentCameraId();
         int cameraId = -1;

         try {
             cameraId = cameraKey.getLegacyValue();
         } catch (UnsupportedOperationException ignored) {
             Log.e(TAG, "TransformViewHelper does not support Camera API2");
         }


         // Only apply this fix when Current Active Module is Photo module AND
         // Phone is Nexus4 The enhancement fix b/20694189 to original fix to
         // b/19271661 ensures that the fix should only be applied when:
         // 1) the phone is a Nexus4 which requires the specific workaround
         // 2) CaptureModule is enabled.
         // 3) the Camera Photo Mode Or Capture Intent Photo Mode is active
         if (ApiHelper.IS_NEXUS_4 && mAppController.getCameraFeatureConfig().isUsingCaptureModule()
                 && (mAppController.getCurrentModuleIndex() == mCameraModeId ||
                 mAppController.getCurrentModuleIndex() == mCaptureIntentModeId)) {
             Log.v(TAG, "Applying Photo Mode, Capture Module, Nexus-4 specific fix for b/19271661");
             mOrientation = CameraUtil.getDisplayRotation();
             matrix = getPreviewRotationalTransform(mOrientation,
                     new RectF(0, 0, mWidth, mHeight),
                     mCaptureLayoutHelper.getPreviewRect());
         } else if (cameraId >= 0) {
             // Otherwise, do the default, legacy action.
             CameraDeviceInfo.Characteristics info = mCameraProvider.getCharacteristics(cameraId);
             matrix = info.getPreviewTransform(mOrientation, new RectF(0, 0, mWidth, mHeight),
                     mCaptureLayoutHelper.getPreviewRect());
         } else {
             // Do Nothing
         }

         mPreview.setTransform(matrix);
         updatePreviewArea(matrix);
         return true;
     }

     private void onPreviewAreaChanged(final RectF previewArea) {
         // Notify listeners of preview area change
         final List<PreviewStatusListener.PreviewAreaChangedListener> listeners =
                 new ArrayList<PreviewStatusListener.PreviewAreaChangedListener>(
                         mPreviewSizeChangedListeners);
         // This method can be called during layout pass. We post a Runnable so
         // that the callbacks won't happen during the layout pass.
         mPreview.post(new Runnable() {
             @Override
             public void run() {
                 for (PreviewStatusListener.PreviewAreaChangedListener listener : listeners) {
                     listener.onPreviewAreaChanged(previewArea);
                 }
             }
         });
     }

     /**
      * Returns a new copy of the preview area, to avoid internal data being
      * modified from outside of the class.
      */
     public RectF getPreviewArea() {
         return new RectF(mPreviewArea);
     }

     /**
      * Returns a copy of the area of the whole preview, including bits clipped
      * by the view
      */
     public RectF getTextureArea() {

         if (mPreview == null) {
             return new RectF();
         }
         Matrix matrix = new Matrix();
         RectF area = new RectF(0, 0, mWidth, mHeight);
         mPreview.getTransform(matrix).mapRect(area);
         return area;
     }

     public Bitmap getPreviewBitmap(int downsample) {
         RectF textureArea = getTextureArea();
         int width = (int) textureArea.width() / downsample;
         int height = (int) textureArea.height() / downsample;
         Bitmap preview = mPreview.getBitmap(width, height);
         return Bitmap.createBitmap(preview, 0, 0, width, height, mPreview.getTransform(null), true);
     }

     /**
      * Adds a listener that will get notified when the preview area changed.
      * This can be useful for UI elements or focus overlay to adjust themselves
      * according to the preview area change.
      * <p/>
      * Note that a listener will only be added once. A newly added listener will
      * receive a notification of current preview area immediately after being
      * added.
      * <p/>
      * This function should be called on the UI thread and listeners will be
      * notified on the UI thread.
      *
      * @param listener the listener that will get notified of preview area
      *            change
      */
     public void addPreviewAreaSizeChangedListener(
             PreviewStatusListener.PreviewAreaChangedListener listener) {
         if (listener != null && !mPreviewSizeChangedListeners.contains(listener)) {
             mPreviewSizeChangedListeners.add(listener);
             if (mPreviewArea.width() == 0 || mPreviewArea.height() == 0) {
                 listener.onPreviewAreaChanged(new RectF(0, 0, mWidth, mHeight));
             } else {
                 listener.onPreviewAreaChanged(new RectF(mPreviewArea));
             }
         }
     }

     /**
      * Removes a listener that gets notified when the preview area changed.
      *
      * @param listener the listener that gets notified of preview area change
      */
     public void removePreviewAreaSizeChangedListener(
             PreviewStatusListener.PreviewAreaChangedListener listener) {
         if (listener != null && mPreviewSizeChangedListeners.contains(listener)) {
             mPreviewSizeChangedListeners.remove(listener);
         }
     }

     @Override
     public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
         // Workaround for b/11168275, see b/10981460 for more details
         if (mWidth != 0 && mHeight != 0) {
             // Re-apply transform matrix for new surface texture
             updateTransform();
         }
         if (mSurfaceTextureListener != null) {
             mSurfaceTextureListener.onSurfaceTextureAvailable(surface, width, height);
         }
     }

     @Override
     public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
         if (mSurfaceTextureListener != null) {
             mSurfaceTextureListener.onSurfaceTextureSizeChanged(surface, width, height);
         }
     }

     @Override
     public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
         if (mSurfaceTextureListener != null) {
             mSurfaceTextureListener.onSurfaceTextureDestroyed(surface);
         }
         return false;
     }

     @Override
     public void onSurfaceTextureUpdated(SurfaceTexture surface) {
         if (mSurfaceTextureListener != null) {
             mSurfaceTextureListener.onSurfaceTextureUpdated(surface);
         }

     }
 }
	/*
	* Copyright (C) 2013 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.graphics.Bitmap;
	import android.graphics.Matrix;
	import android.graphics.RectF;
	import android.graphics.SurfaceTexture;
	import android.view.TextureView;
	import android.view.View;
	import android.view.View.OnLayoutChangeListener;

	import com.android.camera.app.AppController;
	import com.android.camera.app.CameraProvider;
	import com.android.camera.app.OrientationManager;
	import com.android.camera.debug.Log;
	import com.android.camera.device.CameraId;
	import com.android.camera.ui.PreviewStatusListener;
	import com.android.camera.util.ApiHelper;
	import com.android.camera.util.CameraUtil;
	import com.android.camera2.R;
	import com.android.ex.camera2.portability.CameraDeviceInfo;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* This class aims to automate TextureView transform change and notify listeners
	* (e.g. bottom bar) of the preview size change.
	*/
	public class TextureViewHelper implements TextureView.SurfaceTextureListener,
	OnLayoutChangeListener {

	private static final Log.Tag TAG = new Log.Tag("TexViewHelper");
	public static final float MATCH_SCREEN = 0f;
	private static final int UNSET = -1;
	private final TextureView mPreview;
	private final CameraProvider mCameraProvider;
	private int mWidth = 0;
	private int mHeight = 0;
	private RectF mPreviewArea = new RectF();
	private float mAspectRatio = MATCH_SCREEN;
	private boolean mAutoAdjustTransform = true;
	private TextureView.SurfaceTextureListener mSurfaceTextureListener;

	private final ArrayList<PreviewStatusListener.PreviewAspectRatioChangedListener>
	mAspectRatioChangedListeners =
	new ArrayList<PreviewStatusListener.PreviewAspectRatioChangedListener>();

	private final ArrayList<PreviewStatusListener.PreviewAreaChangedListener>
	mPreviewSizeChangedListeners =
	new ArrayList<PreviewStatusListener.PreviewAreaChangedListener>();
	private OnLayoutChangeListener mOnLayoutChangeListener = null;
	private CaptureLayoutHelper mCaptureLayoutHelper = null;
	private int mOrientation = UNSET;

	// Hack to allow to know which module is running for b/20694189
	private final AppController mAppController;
	private final int mCameraModeId;
	private final int mCaptureIntentModeId;

	public TextureViewHelper(TextureView preview, CaptureLayoutHelper helper,
	CameraProvider cameraProvider, AppController appController) {
	mPreview = preview;
	mCameraProvider = cameraProvider;
	mPreview.addOnLayoutChangeListener(this);
	mPreview.setSurfaceTextureListener(this);
	mCaptureLayoutHelper = helper;
	mAppController = appController;
	mCameraModeId = appController.getAndroidContext().getResources()
	.getInteger(R.integer.camera_mode_photo);
	mCaptureIntentModeId = appController.getAndroidContext().getResources()
	.getInteger(R.integer.camera_mode_capture_intent);
	}

	/**
	* If auto adjust transform is enabled, when there is a layout change, the
	* transform matrix will be automatically adjusted based on the preview
	* stream aspect ratio in the new layout.
	*
	* @param enable whether or not auto adjustment should be enabled
	*/
	public void setAutoAdjustTransform(boolean enable) {
	mAutoAdjustTransform = enable;
	}

	@Override
	public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft,
	int oldTop, int oldRight, int oldBottom) {
	Log.v(TAG, "onLayoutChange");
	int width = right - left;
	int height = bottom - top;
	int rotation = CameraUtil.getDisplayRotation();
	if (mWidth != width \|\| mHeight != height \|\| mOrientation != rotation) {
	mWidth = width;
	mHeight = height;
	mOrientation = rotation;
	if (!updateTransform()) {
	clearTransform();
	}
	}
	if (mOnLayoutChangeListener != null) {
	mOnLayoutChangeListener.onLayoutChange(v, left, top, right, bottom, oldLeft, oldTop,
	oldRight, oldBottom);
	}
	}

	/**
	* Transforms the preview with the identity matrix, ensuring there is no
	* scaling on the preview. It also calls onPreviewSizeChanged, to trigger
	* any necessary preview size changing callbacks.
	*/
	public void clearTransform() {
	mPreview.setTransform(new Matrix());
	mPreviewArea.set(0, 0, mWidth, mHeight);
	onPreviewAreaChanged(mPreviewArea);
	setAspectRatio(MATCH_SCREEN);
	}

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

	private void setAspectRatio(float aspectRatio) {
	Log.v(TAG, "setAspectRatio: " + aspectRatio);
	if (mAspectRatio != aspectRatio) {
	Log.v(TAG, "aspect ratio changed from: " + mAspectRatio);
	mAspectRatio = aspectRatio;
	onAspectRatioChanged();
	}
	}

	private void onAspectRatioChanged() {
	mCaptureLayoutHelper.onPreviewAspectRatioChanged(mAspectRatio);
	for (PreviewStatusListener.PreviewAspectRatioChangedListener listener
	: mAspectRatioChangedListeners) {
	listener.onPreviewAspectRatioChanged(mAspectRatio);
	}
	}

	public void addAspectRatioChangedListener(
	PreviewStatusListener.PreviewAspectRatioChangedListener listener) {
	if (listener != null && !mAspectRatioChangedListeners.contains(listener)) {
	mAspectRatioChangedListeners.add(listener);
	}
	}

	/**
	* This returns the rect that is available to display the preview, and
	* capture buttons
	*
	* @return the rect.
	*/
	public RectF getFullscreenRect() {
	return mCaptureLayoutHelper.getFullscreenRect();
	}

	/**
	* This takes a matrix to apply to the texture view and uses the screen
	* aspect ratio as the target aspect ratio
	*
	* @param matrix the matrix to apply
	* @param aspectRatio the aspectRatio that the preview should be
	*/
	public void updateTransformFullScreen(Matrix matrix, float aspectRatio) {
	aspectRatio = aspectRatio < 1 ? 1 / aspectRatio : aspectRatio;
	if (aspectRatio != mAspectRatio) {
	setAspectRatio(aspectRatio);
	}

	mPreview.setTransform(matrix);
	mPreviewArea = mCaptureLayoutHelper.getPreviewRect();
	onPreviewAreaChanged(mPreviewArea);

	}

	public void updateTransform(Matrix matrix) {
	RectF previewRect = new RectF(0, 0, mWidth, mHeight);
	matrix.mapRect(previewRect);

	float previewWidth = previewRect.width();
	float previewHeight = previewRect.height();
	if (previewHeight == 0 \|\| previewWidth == 0) {
	Log.e(TAG, "Invalid preview size: " + previewWidth + " x " + previewHeight);
	return;
	}
	float aspectRatio = previewWidth / previewHeight;
	aspectRatio = aspectRatio < 1 ? 1 / aspectRatio : aspectRatio;
	if (aspectRatio != mAspectRatio) {
	setAspectRatio(aspectRatio);
	}

	RectF previewAreaBasedOnAspectRatio = mCaptureLayoutHelper.getPreviewRect();
	Matrix addtionalTransform = new Matrix();
	addtionalTransform.setRectToRect(previewRect, previewAreaBasedOnAspectRatio,
	Matrix.ScaleToFit.CENTER);
	matrix.postConcat(addtionalTransform);
	mPreview.setTransform(matrix);
	updatePreviewArea(matrix);
	}

	/**
	* Calculates and updates the preview area rect using the latest transform
	* matrix.
	*/
	private void updatePreviewArea(Matrix matrix) {
	mPreviewArea.set(0, 0, mWidth, mHeight);
	matrix.mapRect(mPreviewArea);
	onPreviewAreaChanged(mPreviewArea);
	}

	public void setOnLayoutChangeListener(OnLayoutChangeListener listener) {
	mOnLayoutChangeListener = listener;
	}

	public void setSurfaceTextureListener(TextureView.SurfaceTextureListener listener) {
	mSurfaceTextureListener = listener;
	}

	/**
	* Returns a transformation matrix that implements rotation that is
	* consistent with CaptureLayoutHelper and TextureViewHelper. The magical
	* invariant for CaptureLayoutHelper and TextureViewHelper that must be
	* obeyed is that the bounding box of the view must be EXACTLY the bounding
	* box of the surfaceDimensions AFTER the transformation has been applied.
	*
	* @param currentDisplayOrientation The current display orientation,
	* measured counterclockwise from to the device's natural
	* orientation (in degrees, always a multiple of 90, and between
	* 0 and 270, inclusive).
	* @param surfaceDimensions The dimensions of the
	* {@link android.view.Surface} on which the preview image is
	* being rendered. It usually only makes sense for the upper-left
	* corner to be at the origin.
	* @param desiredBounds The boundaries within the
	* {@link android.view.Surface} where the final image should
	* appear. These can be used to translate and scale the output,
	* but note that the image will be stretched to fit, possibly
	* changing its aspect ratio.
	* @return The transform matrix that should be applied to the
	* {@link android.view.Surface} in order for the image to display
	* properly in the device's current orientation.
	*/
	public Matrix getPreviewRotationalTransform(int currentDisplayOrientation,
	RectF surfaceDimensions,
	RectF desiredBounds) {
	if (surfaceDimensions.equals(desiredBounds)) {
	return new Matrix();
	}

	Matrix transform = new Matrix();
	transform.setRectToRect(surfaceDimensions, desiredBounds, Matrix.ScaleToFit.FILL);

	RectF normalRect = surfaceDimensions;
	// Bounding box of 90 or 270 degree rotation.
	RectF rotatedRect = new RectF(normalRect.width() / 2 - normalRect.height() / 2,
	normalRect.height() / 2 - normalRect.width() / 2,
	normalRect.width() / 2 + normalRect.height() / 2,
	normalRect.height() / 2 + normalRect.width() / 2);

	OrientationManager.DeviceOrientation deviceOrientation =
	OrientationManager.DeviceOrientation.from(currentDisplayOrientation);

	// This rotation code assumes that the aspect ratio of the content
	// (not of necessarily the surface) equals the aspect ratio of view that is receiving
	// the preview. So, a 4:3 surface that contains 16:9 data will look correct as
	// long as the view is also 16:9.
	switch (deviceOrientation) {
	case CLOCKWISE_90:
	transform.setRectToRect(rotatedRect, desiredBounds, Matrix.ScaleToFit.FILL);
	transform.preRotate(270, mWidth / 2, mHeight / 2);
	break;
	case CLOCKWISE_180:
	transform.setRectToRect(normalRect, desiredBounds, Matrix.ScaleToFit.FILL);
	transform.preRotate(180, mWidth / 2, mHeight / 2);
	break;
	case CLOCKWISE_270:
	transform.setRectToRect(rotatedRect, desiredBounds, Matrix.ScaleToFit.FILL);
	transform.preRotate(90, mWidth / 2, mHeight / 2);
	break;
	case CLOCKWISE_0:
	default:
	transform.setRectToRect(normalRect, desiredBounds, Matrix.ScaleToFit.FILL);
	break;
	}

	return transform;
	}

	/**
	* Updates the transform matrix based current width and height of
	* TextureView and preview stream aspect ratio.
	* <p>
	* If not {@code mAutoAdjustTransform}, this does nothing except return
	* {@code false}. In all other cases, it returns {@code true}, regardless of
	* whether the transform was changed.
	* </p>
	* In {@code mAutoAdjustTransform} and the CameraProvder is invalid, it is assumed
	* that the CaptureModule/PhotoModule is Camera2 API-based and must implements its
	* rotation via matrix transformation implemented in getPreviewRotationalTransform.
	*
	* @return Whether {@code mAutoAdjustTransform}.
	*/
	private boolean updateTransform() {
	Log.v(TAG, "updateTransform");
	if (!mAutoAdjustTransform) {
	return false;
	}

	if (mAspectRatio == MATCH_SCREEN \|\| mAspectRatio < 0 \|\| mWidth == 0 \|\| mHeight == 0) {
	return true;
	}

	Matrix matrix = new Matrix();
	CameraId cameraKey = mCameraProvider.getCurrentCameraId();
	int cameraId = -1;

	try {
	cameraId = cameraKey.getLegacyValue();
	} catch (UnsupportedOperationException ignored) {
	Log.e(TAG, "TransformViewHelper does not support Camera API2");
	}


	// Only apply this fix when Current Active Module is Photo module AND
	// Phone is Nexus4 The enhancement fix b/20694189 to original fix to
	// b/19271661 ensures that the fix should only be applied when:
	// 1) the phone is a Nexus4 which requires the specific workaround
	// 2) CaptureModule is enabled.
	// 3) the Camera Photo Mode Or Capture Intent Photo Mode is active
	if (ApiHelper.IS_NEXUS_4 && mAppController.getCameraFeatureConfig().isUsingCaptureModule()
	&& (mAppController.getCurrentModuleIndex() == mCameraModeId \|\|
	mAppController.getCurrentModuleIndex() == mCaptureIntentModeId)) {
	Log.v(TAG, "Applying Photo Mode, Capture Module, Nexus-4 specific fix for b/19271661");
	mOrientation = CameraUtil.getDisplayRotation();
	matrix = getPreviewRotationalTransform(mOrientation,
	new RectF(0, 0, mWidth, mHeight),
	mCaptureLayoutHelper.getPreviewRect());
	} else if (cameraId >= 0) {
	// Otherwise, do the default, legacy action.
	CameraDeviceInfo.Characteristics info = mCameraProvider.getCharacteristics(cameraId);
	matrix = info.getPreviewTransform(mOrientation, new RectF(0, 0, mWidth, mHeight),
	mCaptureLayoutHelper.getPreviewRect());
	} else {
	// Do Nothing
	}

	mPreview.setTransform(matrix);
	updatePreviewArea(matrix);
	return true;
	}

	private void onPreviewAreaChanged(final RectF previewArea) {
	// Notify listeners of preview area change
	final List<PreviewStatusListener.PreviewAreaChangedListener> listeners =
	new ArrayList<PreviewStatusListener.PreviewAreaChangedListener>(
	mPreviewSizeChangedListeners);
	// This method can be called during layout pass. We post a Runnable so
	// that the callbacks won't happen during the layout pass.
	mPreview.post(new Runnable() {
	@Override
	public void run() {
	for (PreviewStatusListener.PreviewAreaChangedListener listener : listeners) {
	listener.onPreviewAreaChanged(previewArea);
	}
	}
	});
	}

	/**
	* Returns a new copy of the preview area, to avoid internal data being
	* modified from outside of the class.
	*/
	public RectF getPreviewArea() {
	return new RectF(mPreviewArea);
	}

	/**
	* Returns a copy of the area of the whole preview, including bits clipped
	* by the view
	*/
	public RectF getTextureArea() {

	if (mPreview == null) {
	return new RectF();
	}
	Matrix matrix = new Matrix();
	RectF area = new RectF(0, 0, mWidth, mHeight);
	mPreview.getTransform(matrix).mapRect(area);
	return area;
	}

	public Bitmap getPreviewBitmap(int downsample) {
	RectF textureArea = getTextureArea();
	int width = (int) textureArea.width() / downsample;
	int height = (int) textureArea.height() / downsample;
	Bitmap preview = mPreview.getBitmap(width, height);
	return Bitmap.createBitmap(preview, 0, 0, width, height, mPreview.getTransform(null), true);
	}

	/**
	* Adds a listener that will get notified when the preview area changed.
	* This can be useful for UI elements or focus overlay to adjust themselves
	* according to the preview area change.
	* <p/>
	* Note that a listener will only be added once. A newly added listener will
	* receive a notification of current preview area immediately after being
	* added.
	* <p/>
	* This function should be called on the UI thread and listeners will be
	* notified on the UI thread.
	*
	* @param listener the listener that will get notified of preview area
	* change
	*/
	public void addPreviewAreaSizeChangedListener(
	PreviewStatusListener.PreviewAreaChangedListener listener) {
	if (listener != null && !mPreviewSizeChangedListeners.contains(listener)) {
	mPreviewSizeChangedListeners.add(listener);
	if (mPreviewArea.width() == 0 \|\| mPreviewArea.height() == 0) {
	listener.onPreviewAreaChanged(new RectF(0, 0, mWidth, mHeight));
	} else {
	listener.onPreviewAreaChanged(new RectF(mPreviewArea));
	}
	}
	}

	/**
	* Removes a listener that gets notified when the preview area changed.
	*
	* @param listener the listener that gets notified of preview area change
	*/
	public void removePreviewAreaSizeChangedListener(
	PreviewStatusListener.PreviewAreaChangedListener listener) {
	if (listener != null && mPreviewSizeChangedListeners.contains(listener)) {
	mPreviewSizeChangedListeners.remove(listener);
	}
	}

	@Override
	public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
	// Workaround for b/11168275, see b/10981460 for more details
	if (mWidth != 0 && mHeight != 0) {
	// Re-apply transform matrix for new surface texture
	updateTransform();
	}
	if (mSurfaceTextureListener != null) {
	mSurfaceTextureListener.onSurfaceTextureAvailable(surface, width, height);
	}
	}

	@Override
	public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
	if (mSurfaceTextureListener != null) {
	mSurfaceTextureListener.onSurfaceTextureSizeChanged(surface, width, height);
	}
	}

	@Override
	public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
	if (mSurfaceTextureListener != null) {
	mSurfaceTextureListener.onSurfaceTextureDestroyed(surface);
	}
	return false;
	}

	@Override
	public void onSurfaceTextureUpdated(SurfaceTexture surface) {
	if (mSurfaceTextureListener != null) {
	mSurfaceTextureListener.onSurfaceTextureUpdated(surface);
	}

	}
	}