/*
|
* 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);
|
}
|
|
}
|
}
|
