| /* |
| * Copyright (C) 2014 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.content.Context; |
| import android.graphics.Matrix; |
| import android.graphics.Point; |
| import android.graphics.RectF; |
| import android.graphics.SurfaceTexture; |
| import android.location.Location; |
| import android.media.MediaActionSound; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.SystemClock; |
| import android.view.GestureDetector; |
| import android.view.KeyEvent; |
| import android.view.MotionEvent; |
| import android.view.Surface; |
| import android.view.View; |
| |
| import com.android.camera.app.AppController; |
| import com.android.camera.app.CameraAppUI; |
| import com.android.camera.app.CameraAppUI.BottomBarUISpec; |
| import com.android.camera.app.LocationManager; |
| import com.android.camera.app.OrientationManager.DeviceOrientation; |
| import com.android.camera.async.MainThread; |
| import com.android.camera.burst.BurstFacade; |
| import com.android.camera.burst.BurstFacadeFactory; |
| import com.android.camera.burst.BurstReadyStateChangeListener; |
| import com.android.camera.burst.OrientationLockController; |
| import com.android.camera.captureintent.PreviewTransformCalculator; |
| import com.android.camera.debug.DebugPropertyHelper; |
| import com.android.camera.debug.Log; |
| import com.android.camera.debug.Log.Tag; |
| import com.android.camera.device.CameraId; |
| import com.android.camera.hardware.HardwareSpec; |
| import com.android.camera.hardware.HeadingSensor; |
| import com.android.camera.module.ModuleController; |
| import com.android.camera.one.OneCamera; |
| import com.android.camera.one.OneCamera.AutoFocusState; |
| import com.android.camera.one.OneCamera.CaptureReadyCallback; |
| import com.android.camera.one.OneCamera.Facing; |
| import com.android.camera.one.OneCamera.OpenCallback; |
| import com.android.camera.one.OneCamera.PhotoCaptureParameters; |
| import com.android.camera.one.OneCameraAccessException; |
| import com.android.camera.one.OneCameraCaptureSetting; |
| import com.android.camera.one.OneCameraCharacteristics; |
| import com.android.camera.one.OneCameraException; |
| import com.android.camera.one.OneCameraManager; |
| import com.android.camera.one.OneCameraModule; |
| import com.android.camera.one.OneCameraOpener; |
| import com.android.camera.one.config.OneCameraFeatureConfig; |
| import com.android.camera.one.v2.photo.ImageRotationCalculator; |
| import com.android.camera.one.v2.photo.ImageRotationCalculatorImpl; |
| import com.android.camera.remote.RemoteCameraModule; |
| import com.android.camera.session.CaptureSession; |
| import com.android.camera.settings.Keys; |
| import com.android.camera.settings.SettingsManager; |
| import com.android.camera.stats.CaptureStats; |
| import com.android.camera.stats.UsageStatistics; |
| import com.android.camera.stats.profiler.Profile; |
| import com.android.camera.stats.profiler.Profiler; |
| import com.android.camera.stats.profiler.Profilers; |
| import com.android.camera.ui.CountDownView; |
| import com.android.camera.ui.PreviewStatusListener; |
| import com.android.camera.ui.TouchCoordinate; |
| import com.android.camera.ui.focus.FocusController; |
| import com.android.camera.ui.focus.FocusSound; |
| import com.android.camera.util.AndroidServices; |
| import com.android.camera.util.ApiHelper; |
| import com.android.camera.util.CameraUtil; |
| import com.android.camera.util.GcamHelper; |
| import com.android.camera.util.Size; |
| import com.android.camera2.R; |
| import com.android.ex.camera2.portability.CameraAgent.CameraProxy; |
| import com.google.common.logging.eventprotos; |
| |
| import java.util.concurrent.Semaphore; |
| import java.util.concurrent.TimeUnit; |
| |
| import javax.annotation.Nonnull; |
| |
| /** |
| * New Capture module that is made to support photo and video capture on top of |
| * the OneCamera API, to transparently support GCam. |
| * <p> |
| * This has been a re-write with pieces taken and improved from GCamModule and |
| * PhotoModule, which are to be retired eventually. |
| * <p> |
| */ |
| public class CaptureModule extends CameraModule implements |
| ModuleController, |
| CountDownView.OnCountDownStatusListener, |
| OneCamera.PictureCallback, |
| OneCamera.FocusStateListener, |
| OneCamera.ReadyStateChangedListener, |
| RemoteCameraModule { |
| |
| private static final Tag TAG = new Tag("CaptureModule"); |
| /** Enable additional debug output. */ |
| private static final boolean DEBUG = true; |
| /** Workaround Flag for b/19271661 to use autotransformation in Capture Layout in Nexus4 **/ |
| private static final boolean USE_AUTOTRANSFORM_UI_LAYOUT = ApiHelper.IS_NEXUS_4; |
| |
| /** Timeout for camera open/close operations. */ |
| private static final int CAMERA_OPEN_CLOSE_TIMEOUT_MILLIS = 2500; |
| |
| /** System Properties switch to enable debugging focus UI. */ |
| private static final boolean CAPTURE_DEBUG_UI = DebugPropertyHelper.showCaptureDebugUI(); |
| |
| private final Object mDimensionLock = new Object(); |
| |
| /** |
| * Sticky Gcam mode is when this module's sole purpose it to be the Gcam |
| * mode. If true, the device uses {@link PhotoModule} for normal picture |
| * taking. |
| */ |
| private final boolean mStickyGcamCamera; |
| |
| /** Controller giving us access to other services. */ |
| private final AppController mAppController; |
| /** The applications settings manager. */ |
| private final SettingsManager mSettingsManager; |
| /** Application context. */ |
| private final Context mContext; |
| /** Module UI. */ |
| private CaptureModuleUI mUI; |
| /** The camera manager used to open cameras. */ |
| private OneCameraOpener mOneCameraOpener; |
| /** The manager to query for camera device information */ |
| private OneCameraManager mOneCameraManager; |
| /** The currently opened camera device, or null if the camera is closed. */ |
| private OneCamera mCamera; |
| /** The selected picture size. */ |
| private Size mPictureSize; |
| /** Fair semaphore held when opening or closing the camera. */ |
| private final Semaphore mCameraOpenCloseLock = new Semaphore(1, true); |
| /** The direction the currently opened camera is facing to. */ |
| private Facing mCameraFacing; |
| /** Whether HDR Scene mode is currently enabled. */ |
| private boolean mHdrSceneEnabled = false; |
| private boolean mHdrPlusEnabled = false; |
| private final Object mSurfaceTextureLock = new Object(); |
| /** |
| * Flag that is used when Fatal Error Handler is running and the app should |
| * not continue execution |
| */ |
| private boolean mShowErrorAndFinish; |
| private TouchCoordinate mLastShutterTouchCoordinate = null; |
| |
| private FocusController mFocusController; |
| private OneCameraCharacteristics mCameraCharacteristics; |
| final private PreviewTransformCalculator mPreviewTransformCalculator; |
| |
| /** The listener to listen events from the CaptureModuleUI. */ |
| private final CaptureModuleUI.CaptureModuleUIListener mUIListener = |
| new CaptureModuleUI.CaptureModuleUIListener() { |
| @Override |
| public void onZoomRatioChanged(float zoomRatio) { |
| mZoomValue = zoomRatio; |
| if (mCamera != null) { |
| mCamera.setZoom(zoomRatio); |
| } |
| } |
| }; |
| |
| /** The listener to respond preview area changes. */ |
| private final PreviewStatusListener.PreviewAreaChangedListener mPreviewAreaChangedListener = |
| new PreviewStatusListener.PreviewAreaChangedListener() { |
| @Override |
| public void onPreviewAreaChanged(RectF previewArea) { |
| mPreviewArea = previewArea; |
| mFocusController.configurePreviewDimensions(previewArea); |
| } |
| }; |
| |
| /** The listener to listen events from the preview. */ |
| private final PreviewStatusListener mPreviewStatusListener = new PreviewStatusListener() { |
| @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; |
| updatePreviewTransform(width, height, false); |
| } |
| |
| @Override |
| public boolean shouldAutoAdjustTransformMatrixOnLayout() { |
| return USE_AUTOTRANSFORM_UI_LAYOUT; |
| } |
| |
| @Override |
| public void onPreviewFlipped() { |
| // Do nothing because when preview is flipped, TextureView will lay |
| // itself out again, which will then trigger a transform matrix |
| // update. |
| } |
| |
| @Override |
| public GestureDetector.OnGestureListener getGestureListener() { |
| return new GestureDetector.SimpleOnGestureListener() { |
| @Override |
| public boolean onSingleTapUp(MotionEvent ev) { |
| Point tapPoint = new Point((int) ev.getX(), (int) ev.getY()); |
| Log.v(TAG, "onSingleTapUpPreview location=" + tapPoint); |
| if (!mCameraCharacteristics.isAutoExposureSupported() && |
| !mCameraCharacteristics.isAutoFocusSupported()) { |
| return false; |
| } |
| startActiveFocusAt(tapPoint.x, tapPoint.y); |
| return true; |
| } |
| }; |
| } |
| |
| @Override |
| public View.OnTouchListener getTouchListener() { |
| return null; |
| } |
| |
| @Override |
| public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) { |
| Log.d(TAG, "onSurfaceTextureAvailable"); |
| // Force to re-apply transform matrix here as a workaround for |
| // b/11168275 |
| updatePreviewTransform(width, height, true); |
| synchronized (mSurfaceTextureLock) { |
| mPreviewSurfaceTexture = surface; |
| } |
| reopenCamera(); |
| } |
| |
| @Override |
| public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) { |
| Log.d(TAG, "onSurfaceTextureDestroyed"); |
| synchronized (mSurfaceTextureLock) { |
| mPreviewSurfaceTexture = null; |
| } |
| closeCamera(); |
| return true; |
| } |
| |
| @Override |
| public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) { |
| Log.d(TAG, "onSurfaceTextureSizeChanged"); |
| updatePreviewBufferSize(); |
| } |
| |
| @Override |
| public void onSurfaceTextureUpdated(SurfaceTexture surface) { |
| if (mState == ModuleState.UPDATE_TRANSFORM_ON_NEXT_SURFACE_TEXTURE_UPDATE) { |
| Log.d(TAG, "onSurfaceTextureUpdated --> updatePreviewTransform"); |
| mState = ModuleState.IDLE; |
| CameraAppUI appUI = mAppController.getCameraAppUI(); |
| updatePreviewTransform(appUI.getSurfaceWidth(), appUI.getSurfaceHeight(), true); |
| } |
| } |
| }; |
| |
| private final OneCamera.PictureSaverCallback mPictureSaverCallback = |
| new OneCamera.PictureSaverCallback() { |
| @Override |
| public void onRemoteThumbnailAvailable(final byte[] jpegImage) { |
| mMainThread.execute(new Runnable() { |
| @Override |
| public void run() { |
| mAppController.getServices().getRemoteShutterListener() |
| .onPictureTaken(jpegImage); |
| } |
| }); |
| } |
| }; |
| |
| /** State by the module state machine. */ |
| private static enum ModuleState { |
| IDLE, |
| WATCH_FOR_NEXT_FRAME_AFTER_PREVIEW_STARTED, |
| UPDATE_TRANSFORM_ON_NEXT_SURFACE_TEXTURE_UPDATE, |
| } |
| |
| /** The current state of the module. */ |
| private ModuleState mState = ModuleState.IDLE; |
| /** Current zoom value. */ |
| private float mZoomValue = 1f; |
| |
| /** Records beginning frame of each AF scan. */ |
| private long mAutoFocusScanStartFrame = -1; |
| /** Records beginning time of each AF scan in uptimeMillis. */ |
| private long mAutoFocusScanStartTime; |
| |
| /** Heading sensor. */ |
| private HeadingSensor mHeadingSensor; |
| |
| /** Used to fetch and embed the location into captured images. */ |
| private final LocationManager mLocationManager; |
| /** Plays sounds for countdown timer. */ |
| private SoundPlayer mSoundPlayer; |
| private final MediaActionSound mMediaActionSound; |
| |
| /** Whether the module is paused right now. */ |
| private boolean mPaused; |
| |
| /** Main thread. */ |
| private final MainThread mMainThread; |
| /** Handler thread for camera-related operations. */ |
| private Handler mCameraHandler; |
| |
| /** Current display rotation in degrees. */ |
| private int mDisplayRotation; |
| /** Current screen width in pixels. */ |
| private int mScreenWidth; |
| /** Current screen height in pixels. */ |
| private int mScreenHeight; |
| /** Current width of preview frames from camera. */ |
| private int mPreviewBufferWidth; |
| /** Current height of preview frames from camera.. */ |
| private int mPreviewBufferHeight; |
| /** Area used by preview. */ |
| RectF mPreviewArea; |
| |
| /** The surface texture for the preview. */ |
| private SurfaceTexture mPreviewSurfaceTexture; |
| |
| /** The burst manager for controlling the burst. */ |
| private final BurstFacade mBurstController; |
| private static final String BURST_SESSIONS_DIR = "burst_sessions"; |
| |
| private final Profiler mProfiler = Profilers.instance().guard(); |
| |
| public CaptureModule(AppController appController) { |
| this(appController, false); |
| } |
| |
| /** Constructs a new capture module. */ |
| public CaptureModule(AppController appController, boolean stickyHdr) { |
| super(appController); |
| Profile guard = mProfiler.create("new CaptureModule").start(); |
| mPaused = true; |
| mMainThread = MainThread.create(); |
| mAppController = appController; |
| mContext = mAppController.getAndroidContext(); |
| mSettingsManager = mAppController.getSettingsManager(); |
| mStickyGcamCamera = stickyHdr; |
| mLocationManager = mAppController.getLocationManager(); |
| mPreviewTransformCalculator = new PreviewTransformCalculator( |
| mAppController.getOrientationManager()); |
| |
| mBurstController = BurstFacadeFactory.create(mContext, |
| new OrientationLockController() { |
| @Override |
| public void unlockOrientation() { |
| mAppController.getOrientationManager().unlockOrientation(); |
| } |
| |
| @Override |
| public void lockOrientation() { |
| mAppController.getOrientationManager().lockOrientation(); |
| } |
| }, |
| new BurstReadyStateChangeListener() { |
| @Override |
| public void onBurstReadyStateChanged(boolean ready) { |
| // TODO: This needs to take into account the state of |
| // the whole system, not just burst. |
| onReadyStateChanged(false); |
| } |
| }); |
| mMediaActionSound = new MediaActionSound(); |
| guard.stop(); |
| } |
| |
| private boolean updateCameraCharacteristics() { |
| try { |
| CameraId cameraId = mOneCameraManager.findFirstCameraFacing(mCameraFacing); |
| if (cameraId != null && cameraId.getValue() != null) { |
| mCameraCharacteristics = mOneCameraManager.getOneCameraCharacteristics(cameraId); |
| return mCameraCharacteristics != null; |
| } |
| } catch (OneCameraAccessException ignored) { } |
| mAppController.getFatalErrorHandler().onGenericCameraAccessFailure(); |
| return false; |
| } |
| |
| @Override |
| public void init(CameraActivity activity, boolean isSecureCamera, boolean isCaptureIntent) { |
| Profile guard = mProfiler.create("CaptureModule.init").start(); |
| Log.d(TAG, "init UseAutotransformUiLayout = " + USE_AUTOTRANSFORM_UI_LAYOUT); |
| HandlerThread thread = new HandlerThread("CaptureModule.mCameraHandler"); |
| thread.start(); |
| mCameraHandler = new Handler(thread.getLooper()); |
| mOneCameraOpener = mAppController.getCameraOpener(); |
| |
| try { |
| mOneCameraManager = OneCameraModule.provideOneCameraManager(); |
| } catch (OneCameraException e) { |
| Log.e(TAG, "Unable to provide a OneCameraManager. ", e); |
| } |
| mDisplayRotation = CameraUtil.getDisplayRotation(activity); |
| mCameraFacing = getFacingFromCameraId( |
| mSettingsManager.getInteger(mAppController.getModuleScope(), Keys.KEY_CAMERA_ID)); |
| mShowErrorAndFinish = !updateCameraCharacteristics(); |
| if (mShowErrorAndFinish) { |
| return; |
| } |
| mUI = new CaptureModuleUI(activity, mAppController.getModuleLayoutRoot(), mUIListener); |
| mAppController.setPreviewStatusListener(mPreviewStatusListener); |
| synchronized (mSurfaceTextureLock) { |
| mPreviewSurfaceTexture = mAppController.getCameraAppUI().getSurfaceTexture(); |
| } |
| mSoundPlayer = new SoundPlayer(mContext); |
| |
| FocusSound focusSound = new FocusSound(mSoundPlayer, R.raw.material_camera_focus); |
| mFocusController = new FocusController(mUI.getFocusRing(), focusSound, mMainThread); |
| |
| mHeadingSensor = new HeadingSensor(AndroidServices.instance().provideSensorManager()); |
| |
| View cancelButton = activity.findViewById(R.id.shutter_cancel_button); |
| cancelButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| cancelCountDown(); |
| } |
| }); |
| |
| mMediaActionSound.load(MediaActionSound.SHUTTER_CLICK); |
| guard.stop(); |
| } |
| |
| @Override |
| public void onShutterButtonLongPressed() { |
| try { |
| OneCameraCharacteristics cameraCharacteristics; |
| CameraId cameraId = mOneCameraManager.findFirstCameraFacing(mCameraFacing); |
| cameraCharacteristics = mOneCameraManager.getOneCameraCharacteristics(cameraId); |
| DeviceOrientation deviceOrientation = mAppController.getOrientationManager() |
| .getDeviceOrientation(); |
| ImageRotationCalculator imageRotationCalculator = ImageRotationCalculatorImpl |
| .from(mAppController.getOrientationManager(), cameraCharacteristics); |
| |
| mBurstController.startBurst( |
| new CaptureSession.CaptureSessionCreator() { |
| @Override |
| public CaptureSession createAndStartEmpty() { |
| return createAndStartUntrackedCaptureSession(); |
| } |
| }, |
| deviceOrientation, |
| mCamera.getDirection(), |
| imageRotationCalculator.toImageRotation().getDegrees()); |
| |
| } catch (OneCameraAccessException e) { |
| Log.e(TAG, "Cannot start burst", e); |
| return; |
| } |
| } |
| |
| @Override |
| public void onShutterButtonFocus(boolean pressed) { |
| if (!pressed) { |
| // the shutter button was released, stop any bursts. |
| mBurstController.stopBurst(); |
| } |
| } |
| |
| @Override |
| public void onShutterCoordinate(TouchCoordinate coord) { |
| mLastShutterTouchCoordinate = coord; |
| } |
| |
| @Override |
| public void onShutterButtonClick() { |
| if (mCamera == null) { |
| return; |
| } |
| |
| int countDownDuration = mSettingsManager |
| .getInteger(SettingsManager.SCOPE_GLOBAL, Keys.KEY_COUNTDOWN_DURATION); |
| if (countDownDuration > 0) { |
| // Start count down. |
| mAppController.getCameraAppUI().transitionToCancel(); |
| mAppController.getCameraAppUI().hideModeOptions(); |
| mUI.setCountdownFinishedListener(this); |
| mUI.startCountdown(countDownDuration); |
| // Will take picture later via listener callback. |
| } else { |
| takePictureNow(); |
| } |
| } |
| |
| |
| private void decorateSessionAtCaptureTime(CaptureSession session) { |
| String flashSetting = |
| mSettingsManager.getString(mAppController.getCameraScope(), |
| Keys.KEY_FLASH_MODE); |
| boolean gridLinesOn = Keys.areGridLinesOn(mSettingsManager); |
| float timerDuration = mSettingsManager |
| .getInteger(SettingsManager.SCOPE_GLOBAL, Keys.KEY_COUNTDOWN_DURATION); |
| |
| session.getCollector().decorateAtTimeCaptureRequest( |
| eventprotos.NavigationChange.Mode.PHOTO_CAPTURE, |
| session.getTitle() + ".jpg", |
| (mCameraFacing == Facing.FRONT), |
| mHdrSceneEnabled, |
| mZoomValue, |
| flashSetting, |
| gridLinesOn, |
| timerDuration, |
| mLastShutterTouchCoordinate, |
| null /* TODO: Implement Volume Button Shutter Click Instrumentation */, |
| mCameraCharacteristics.getSensorInfoActiveArraySize() |
| ); |
| } |
| |
| private void takePictureNow() { |
| if (mCamera == null) { |
| Log.i(TAG, "Not taking picture since Camera is closed."); |
| return; |
| } |
| |
| CaptureSession session = createAndStartCaptureSession(); |
| int orientation = mAppController.getOrientationManager().getDeviceOrientation() |
| .getDegrees(); |
| |
| // TODO: This should really not use getExternalCacheDir and instead use |
| // the SessionStorage API. Need to sync with gcam if that's OK. |
| PhotoCaptureParameters params = new PhotoCaptureParameters( |
| session.getTitle(), orientation, session.getLocation(), |
| mContext.getExternalCacheDir(), this, mPictureSaverCallback, |
| mHeadingSensor.getCurrentHeading(), mZoomValue, 0); |
| decorateSessionAtCaptureTime(session); |
| mCamera.takePicture(params, session); |
| } |
| |
| /** |
| * Creates, starts and returns a new capture session. The returned session |
| * will have been started with an empty placeholder image. |
| */ |
| private CaptureSession createAndStartCaptureSession() { |
| long sessionTime = getSessionTime(); |
| Location location = mLocationManager.getCurrentLocation(); |
| String title = CameraUtil.instance().createJpegName(sessionTime); |
| CaptureSession session = getServices().getCaptureSessionManager() |
| .createNewSession(title, sessionTime, location); |
| |
| session.startEmpty(new CaptureStats(mHdrPlusEnabled), |
| new Size((int) mPreviewArea.width(), (int) mPreviewArea.height())); |
| return session; |
| } |
| |
| private CaptureSession createAndStartUntrackedCaptureSession() { |
| long sessionTime = getSessionTime(); |
| Location location = mLocationManager.getCurrentLocation(); |
| String title = CameraUtil.instance().createJpegName(sessionTime); |
| CaptureSession session = getServices().getCaptureSessionManager() |
| .createNewSession(title, sessionTime, location); |
| |
| session.startEmpty(null, |
| new Size((int) mPreviewArea.width(), (int) mPreviewArea.height())); |
| return session; |
| } |
| |
| private long getSessionTime() { |
| // TODO: Replace with a mockable TimeProvider interface. |
| return System.currentTimeMillis(); |
| } |
| |
| @Override |
| public void onCountDownFinished() { |
| mAppController.getCameraAppUI().transitionToCapture(); |
| mAppController.getCameraAppUI().showModeOptions(); |
| if (mPaused) { |
| return; |
| } |
| takePictureNow(); |
| } |
| |
| @Override |
| public void onRemainingSecondsChanged(int remainingSeconds) { |
| if (remainingSeconds == 1) { |
| mSoundPlayer.play(R.raw.timer_final_second, 0.6f); |
| } else if (remainingSeconds == 2 || remainingSeconds == 3) { |
| mSoundPlayer.play(R.raw.timer_increment, 0.6f); |
| } |
| } |
| |
| private void cancelCountDown() { |
| if (mUI.isCountingDown()) { |
| // Cancel on-going countdown. |
| mUI.cancelCountDown(); |
| } |
| |
| if (!mPaused) { |
| mAppController.getCameraAppUI().showModeOptions(); |
| mAppController.getCameraAppUI().transitionToCapture(); |
| } |
| } |
| |
| @Override |
| public void onQuickExpose() { |
| mMainThread.execute(new Runnable() { |
| @Override |
| public void run() { |
| // Starts the short version of the capture animation UI. |
| mAppController.startFlashAnimation(true); |
| mMediaActionSound.play(MediaActionSound.SHUTTER_CLICK); |
| } |
| }); |
| } |
| |
| @Override |
| public void onRemoteShutterPress() { |
| Log.d(TAG, "onRemoteShutterPress"); |
| // TODO: Check whether shutter is enabled. |
| takePictureNow(); |
| } |
| |
| private void initSurfaceTextureConsumer() { |
| synchronized (mSurfaceTextureLock) { |
| if (mPreviewSurfaceTexture != null) { |
| mPreviewSurfaceTexture.setDefaultBufferSize( |
| mAppController.getCameraAppUI().getSurfaceWidth(), |
| mAppController.getCameraAppUI().getSurfaceHeight()); |
| } |
| } |
| reopenCamera(); |
| } |
| |
| private void reopenCamera() { |
| if (mPaused) { |
| return; |
| } |
| AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() { |
| @Override |
| public void run() { |
| closeCamera(); |
| if(!mAppController.isPaused()) { |
| openCameraAndStartPreview(); |
| } |
| } |
| }); |
| } |
| |
| private SurfaceTexture getPreviewSurfaceTexture() { |
| synchronized (mSurfaceTextureLock) { |
| return mPreviewSurfaceTexture; |
| } |
| } |
| |
| private void updatePreviewBufferSize() { |
| synchronized (mSurfaceTextureLock) { |
| if (mPreviewSurfaceTexture != null) { |
| mPreviewSurfaceTexture.setDefaultBufferSize(mPreviewBufferWidth, |
| mPreviewBufferHeight); |
| } |
| } |
| } |
| |
| @Override |
| public void resume() { |
| if (mShowErrorAndFinish) { |
| return; |
| } |
| Profile guard = mProfiler.create("CaptureModule.resume").start(); |
| |
| // We'll transition into 'ready' once the preview is started. |
| onReadyStateChanged(false); |
| mPaused = false; |
| mAppController.addPreviewAreaSizeChangedListener(mPreviewAreaChangedListener); |
| mAppController.addPreviewAreaSizeChangedListener(mUI); |
| |
| guard.mark(); |
| getServices().getRemoteShutterListener().onModuleReady(this); |
| guard.mark("getRemoteShutterListener.onModuleReady"); |
| mBurstController.initialize(new SurfaceTexture(0)); |
| |
| // TODO: Check if we can really take a photo right now (memory, camera |
| // state, ... ). |
| mAppController.getCameraAppUI().enableModeOptions(); |
| mAppController.setShutterEnabled(true); |
| mAppController.getCameraAppUI().showAccessibilityZoomUI( |
| mCameraCharacteristics.getAvailableMaxDigitalZoom()); |
| |
| mHdrPlusEnabled = mStickyGcamCamera || mAppController.getSettingsManager().getInteger( |
| SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS) == 1; |
| |
| mHdrSceneEnabled = !mStickyGcamCamera && mAppController.getSettingsManager().getBoolean( |
| SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR); |
| |
| // This means we are resuming with an existing preview texture. This |
| // means we will never get the onSurfaceTextureAvailable call. So we |
| // have to open the camera and start the preview here. |
| SurfaceTexture texture = getPreviewSurfaceTexture(); |
| |
| guard.mark(); |
| if (texture != null) { |
| initSurfaceTextureConsumer(); |
| guard.mark("initSurfaceTextureConsumer"); |
| } |
| |
| mSoundPlayer.loadSound(R.raw.timer_final_second); |
| mSoundPlayer.loadSound(R.raw.timer_increment); |
| |
| guard.mark(); |
| mHeadingSensor.activate(); |
| guard.stop("mHeadingSensor.activate()"); |
| } |
| |
| @Override |
| public void pause() { |
| if (mShowErrorAndFinish) { |
| return; |
| } |
| cancelCountDown(); |
| mPaused = true; |
| mHeadingSensor.deactivate(); |
| |
| mAppController.removePreviewAreaSizeChangedListener(mUI); |
| mAppController.removePreviewAreaSizeChangedListener(mPreviewAreaChangedListener); |
| getServices().getRemoteShutterListener().onModuleExit(); |
| mBurstController.release(); |
| closeCamera(); |
| resetTextureBufferSize(); |
| mSoundPlayer.unloadSound(R.raw.timer_final_second); |
| mSoundPlayer.unloadSound(R.raw.timer_increment); |
| } |
| |
| @Override |
| public void destroy() { |
| mSoundPlayer.release(); |
| mMediaActionSound.release(); |
| mCameraHandler.getLooper().quitSafely(); |
| } |
| |
| @Override |
| public void onLayoutOrientationChanged(boolean isLandscape) { |
| Log.d(TAG, "onLayoutOrientationChanged"); |
| } |
| |
| @Override |
| public void onCameraAvailable(CameraProxy cameraProxy) { |
| // Ignore since we manage the camera ourselves until we remove this. |
| } |
| |
| @Override |
| public void hardResetSettings(SettingsManager settingsManager) { |
| if (mStickyGcamCamera) { |
| // Sticky HDR+ mode should hard reset HDR+ to on, and camera back |
| // facing. |
| settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS, true); |
| settingsManager.set(mAppController.getModuleScope(), Keys.KEY_CAMERA_ID, |
| mOneCameraManager.findFirstCameraFacing(Facing.BACK).getValue()); |
| } |
| } |
| |
| @Override |
| public HardwareSpec getHardwareSpec() { |
| return new HardwareSpec() { |
| @Override |
| public boolean isFrontCameraSupported() { |
| return mOneCameraManager.hasCameraFacing(Facing.FRONT); |
| } |
| |
| @Override |
| public boolean isHdrSupported() { |
| if (ApiHelper.IS_NEXUS_4 && is16by9AspectRatio(mPictureSize)) { |
| Log.v(TAG, "16:9 N4, no HDR support"); |
| return false; |
| } else { |
| return mCameraCharacteristics.isHdrSceneSupported(); |
| } |
| } |
| |
| @Override |
| public boolean isHdrPlusSupported() { |
| OneCameraFeatureConfig featureConfig = mAppController.getCameraFeatureConfig(); |
| return featureConfig.getHdrPlusSupportLevel(mCameraFacing) != |
| OneCameraFeatureConfig.HdrPlusSupportLevel.NONE; |
| } |
| |
| @Override |
| public boolean isFlashSupported() { |
| return mCameraCharacteristics.isFlashSupported(); |
| } |
| }; |
| } |
| |
| @Override |
| public BottomBarUISpec getBottomBarSpec() { |
| HardwareSpec hardwareSpec = getHardwareSpec(); |
| BottomBarUISpec bottomBarSpec = new BottomBarUISpec(); |
| bottomBarSpec.enableGridLines = true; |
| bottomBarSpec.enableCamera = true; |
| bottomBarSpec.cameraCallback = getCameraCallback(); |
| bottomBarSpec.enableHdr = |
| hardwareSpec.isHdrSupported() || hardwareSpec.isHdrPlusSupported(); |
| bottomBarSpec.hdrCallback = getHdrButtonCallback(); |
| bottomBarSpec.enableSelfTimer = true; |
| bottomBarSpec.showSelfTimer = true; |
| bottomBarSpec.isExposureCompensationSupported = mCameraCharacteristics |
| .isExposureCompensationSupported(); |
| bottomBarSpec.enableExposureCompensation = bottomBarSpec.isExposureCompensationSupported; |
| |
| // We must read the key from the settings because the button callback |
| // is not executed until after this method is called. |
| if ((hardwareSpec.isHdrPlusSupported() && |
| mAppController.getSettingsManager().getBoolean( |
| SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS)) || |
| ( hardwareSpec.isHdrSupported() && |
| mAppController.getSettingsManager().getBoolean( |
| SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR))) { |
| // Disable flash if this is a sticky gcam camera, or if |
| // HDR is enabled. |
| bottomBarSpec.enableFlash = false; |
| // Disable manual exposure if HDR is enabled. |
| bottomBarSpec.enableExposureCompensation = false; |
| } else { |
| // If we are not in HDR / GCAM mode, fallback on the |
| // flash supported property and manual exposure supported property |
| // for this camera. |
| bottomBarSpec.enableFlash = mCameraCharacteristics.isFlashSupported(); |
| } |
| |
| bottomBarSpec.minExposureCompensation = |
| mCameraCharacteristics.getMinExposureCompensation(); |
| bottomBarSpec.maxExposureCompensation = |
| mCameraCharacteristics.getMaxExposureCompensation(); |
| bottomBarSpec.exposureCompensationStep = |
| mCameraCharacteristics.getExposureCompensationStep(); |
| bottomBarSpec.exposureCompensationSetCallback = |
| new BottomBarUISpec.ExposureCompensationSetCallback() { |
| @Override |
| public void setExposure(int value) { |
| mSettingsManager.set( |
| mAppController.getCameraScope(), Keys.KEY_EXPOSURE, value); |
| } |
| }; |
| |
| return bottomBarSpec; |
| } |
| |
| @Override |
| public boolean isUsingBottomBar() { |
| return true; |
| } |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_CAMERA: |
| case KeyEvent.KEYCODE_DPAD_CENTER: |
| if (mUI.isCountingDown()) { |
| cancelCountDown(); |
| } else if (event.getRepeatCount() == 0) { |
| onShutterButtonClick(); |
| } |
| return true; |
| case KeyEvent.KEYCODE_VOLUME_UP: |
| case KeyEvent.KEYCODE_VOLUME_DOWN: |
| // Prevent default. |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean onKeyUp(int keyCode, KeyEvent event) { |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_VOLUME_UP: |
| case KeyEvent.KEYCODE_VOLUME_DOWN: |
| onShutterButtonClick(); |
| return true; |
| } |
| return false; |
| } |
| |
| // TODO: Consider refactoring FocusOverlayManager. |
| // Currently AF state transitions are controlled in OneCameraImpl. |
| // PhotoModule uses FocusOverlayManager which uses API1/portability |
| // logic and coordinates. |
| private void startActiveFocusAt(int viewX, int viewY) { |
| if (mCamera == null) { |
| // If we receive this after the camera is closed, do nothing. |
| return; |
| } |
| |
| // TODO: make mFocusController final and remove null check. |
| if (mFocusController == null) { |
| Log.v(TAG, "CaptureModule mFocusController is null!"); |
| return; |
| } |
| mFocusController.showActiveFocusAt(viewX, viewY); |
| |
| // Normalize coordinates to [0,1] per CameraOne API. |
| float points[] = new float[2]; |
| points[0] = (viewX - mPreviewArea.left) / mPreviewArea.width(); |
| points[1] = (viewY - mPreviewArea.top) / mPreviewArea.height(); |
| |
| // Rotate coordinates to portrait orientation per CameraOne API. |
| Matrix rotationMatrix = new Matrix(); |
| rotationMatrix.setRotate(mDisplayRotation, 0.5f, 0.5f); |
| rotationMatrix.mapPoints(points); |
| |
| // Invert X coordinate on front camera since the display is mirrored. |
| if (mCameraCharacteristics.getCameraDirection() == Facing.FRONT) { |
| points[0] = 1 - points[0]; |
| } |
| |
| mCamera.triggerFocusAndMeterAtPoint(points[0], points[1]); |
| |
| // Log touch (screen coordinates). |
| if (mZoomValue == 1f) { |
| TouchCoordinate touchCoordinate = new TouchCoordinate( |
| viewX - mPreviewArea.left, |
| viewY - mPreviewArea.top, |
| mPreviewArea.width(), |
| mPreviewArea.height()); |
| // TODO: Add to logging: duration, rotation. |
| UsageStatistics.instance().tapToFocus(touchCoordinate, null); |
| } |
| } |
| |
| /** |
| * Show AF target in center of preview. |
| */ |
| private void startPassiveFocus() { |
| // TODO: make mFocusController final and remove null check. |
| if (mFocusController == null) { |
| return; |
| } |
| |
| // TODO: Some passive focus scans may trigger on a location |
| // instead of the center of the screen. |
| mFocusController.showPassiveFocusAtCenter(); |
| } |
| |
| /** |
| * Update UI based on AF state changes. |
| */ |
| @Override |
| public void onFocusStatusUpdate(final AutoFocusState state, long frameNumber) { |
| Log.v(TAG, "AF status is state:" + state); |
| |
| switch (state) { |
| case PASSIVE_SCAN: |
| startPassiveFocus(); |
| break; |
| case ACTIVE_SCAN: |
| // Unused, manual scans are triggered via the UI |
| break; |
| case PASSIVE_FOCUSED: |
| case PASSIVE_UNFOCUSED: |
| // Unused |
| break; |
| case ACTIVE_FOCUSED: |
| case ACTIVE_UNFOCUSED: |
| // Unused |
| break; |
| } |
| |
| if (CAPTURE_DEBUG_UI) { |
| measureAutoFocusScans(state, frameNumber); |
| } |
| } |
| |
| private void measureAutoFocusScans(final AutoFocusState state, long frameNumber) { |
| // Log AF scan lengths. |
| boolean passive = false; |
| switch (state) { |
| case PASSIVE_SCAN: |
| case ACTIVE_SCAN: |
| if (mAutoFocusScanStartFrame == -1) { |
| mAutoFocusScanStartFrame = frameNumber; |
| mAutoFocusScanStartTime = SystemClock.uptimeMillis(); |
| } |
| break; |
| case PASSIVE_FOCUSED: |
| case PASSIVE_UNFOCUSED: |
| passive = true; |
| case ACTIVE_FOCUSED: |
| case ACTIVE_UNFOCUSED: |
| if (mAutoFocusScanStartFrame != -1) { |
| long frames = frameNumber - mAutoFocusScanStartFrame; |
| long dt = SystemClock.uptimeMillis() - mAutoFocusScanStartTime; |
| int fps = Math.round(frames * 1000f / dt); |
| String report = String.format("%s scan: fps=%d frames=%d", |
| passive ? "CAF" : "AF", fps, frames); |
| Log.v(TAG, report); |
| mUI.showDebugMessage(String.format("%d / %d", frames, fps)); |
| mAutoFocusScanStartFrame = -1; |
| } |
| break; |
| } |
| } |
| |
| @Override |
| public void onReadyStateChanged(boolean readyForCapture) { |
| if (readyForCapture) { |
| mAppController.getCameraAppUI().enableModeOptions(); |
| } |
| mAppController.setShutterEnabled(readyForCapture); |
| } |
| |
| @Override |
| public String getPeekAccessibilityString() { |
| return mAppController.getAndroidContext() |
| .getResources().getString(R.string.photo_accessibility_peek); |
| } |
| |
| @Override |
| public void onThumbnailResult(byte[] jpegData) { |
| getServices().getRemoteShutterListener().onPictureTaken(jpegData); |
| } |
| |
| @Override |
| public void onPictureTaken(CaptureSession session) { |
| mAppController.getCameraAppUI().enableModeOptions(); |
| } |
| |
| @Override |
| public void onPictureSaved(Uri uri) { |
| mAppController.notifyNewMedia(uri); |
| } |
| |
| @Override |
| public void onTakePictureProgress(float progress) { |
| mUI.setPictureTakingProgress((int) (progress * 100)); |
| } |
| |
| @Override |
| public void onPictureTakingFailed() { |
| mAppController.getFatalErrorHandler().onMediaStorageFailure(); |
| } |
| |
| /** |
| * Updates the preview transform matrix to adapt to the current preview |
| * width, height, and orientation. |
| */ |
| public void updatePreviewTransform() { |
| int width; |
| int height; |
| synchronized (mDimensionLock) { |
| width = mScreenWidth; |
| height = mScreenHeight; |
| } |
| updatePreviewTransform(width, height); |
| } |
| |
| /** |
| * @return Depending on whether we're in sticky-HDR mode or not, return the |
| * proper callback to be used for when the HDR/HDR+ button is |
| * pressed. |
| */ |
| private ButtonManager.ButtonCallback getHdrButtonCallback() { |
| if (mStickyGcamCamera) { |
| return new ButtonManager.ButtonCallback() { |
| @Override |
| public void onStateChanged(int state) { |
| if (mPaused) { |
| return; |
| } |
| if (state == ButtonManager.ON) { |
| throw new IllegalStateException( |
| "Can't leave hdr plus mode if switching to hdr plus mode."); |
| } |
| SettingsManager settingsManager = mAppController.getSettingsManager(); |
| settingsManager.set(mAppController.getModuleScope(), |
| Keys.KEY_REQUEST_RETURN_HDR_PLUS, false); |
| switchToRegularCapture(); |
| } |
| }; |
| } else { |
| return new ButtonManager.ButtonCallback() { |
| @Override |
| public void onStateChanged(int hdrEnabled) { |
| if (mPaused) { |
| return; |
| } |
| |
| // Only reload the camera if we are toggling HDR+. |
| if (GcamHelper.hasGcamCapture(mAppController.getCameraFeatureConfig())) { |
| mHdrPlusEnabled = hdrEnabled == 1; |
| switchCamera(); |
| } else { |
| mHdrSceneEnabled = hdrEnabled == 1; |
| } |
| } |
| }; |
| } |
| } |
| |
| /** |
| * @return Depending on whether we're in sticky-HDR mode or not, this |
| * returns the proper callback to be used for when the camera |
| * (front/back switch) button is pressed. |
| */ |
| private ButtonManager.ButtonCallback getCameraCallback() { |
| if (mStickyGcamCamera) { |
| return new ButtonManager.ButtonCallback() { |
| @Override |
| public void onStateChanged(int state) { |
| if (mPaused) { |
| return; |
| } |
| |
| // At the time this callback is fired, the camera id setting |
| // has changed to the desired camera. |
| SettingsManager settingsManager = mAppController.getSettingsManager(); |
| if (Keys.isCameraBackFacing(settingsManager, |
| mAppController.getModuleScope())) { |
| throw new IllegalStateException( |
| "Hdr plus should never be switching from front facing camera."); |
| } |
| |
| // Switch to photo mode, but request a return to hdr plus on |
| // switching to back camera again. |
| settingsManager.set(mAppController.getModuleScope(), |
| Keys.KEY_REQUEST_RETURN_HDR_PLUS, true); |
| switchToRegularCapture(); |
| } |
| }; |
| } else { |
| return new ButtonManager.ButtonCallback() { |
| @Override |
| public void onStateChanged(int cameraId) { |
| if (mPaused) { |
| return; |
| } |
| |
| ButtonManager buttonManager = mAppController.getButtonManager(); |
| buttonManager.disableCameraButtonAndBlock(); |
| |
| // At the time this callback is fired, the camera id |
| // has be set to the desired camera. |
| mSettingsManager.set(mAppController.getModuleScope(), Keys.KEY_CAMERA_ID, |
| cameraId); |
| |
| Log.d(TAG, "Start to switch camera. cameraId=" + cameraId); |
| mCameraFacing = getFacingFromCameraId(cameraId); |
| mShowErrorAndFinish = !updateCameraCharacteristics(); |
| switchCamera(); |
| } |
| }; |
| } |
| } |
| |
| /** |
| * Switches to PhotoModule to do regular photo captures. |
| * <p> |
| * TODO: Remove this once we use CaptureModule for photo taking. |
| */ |
| private void switchToRegularCapture() { |
| // Turn off HDR+ before switching back to normal photo mode. |
| SettingsManager settingsManager = mAppController.getSettingsManager(); |
| settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS, false); |
| |
| // Disable this button to prevent callbacks from this module from firing |
| // while we are transitioning modules. |
| ButtonManager buttonManager = mAppController.getButtonManager(); |
| buttonManager.disableButtonClick(ButtonManager.BUTTON_HDR_PLUS); |
| mAppController.getCameraAppUI().freezeScreenUntilPreviewReady(); |
| mAppController.onModeSelected(mContext.getResources().getInteger( |
| R.integer.camera_mode_photo)); |
| buttonManager.enableButtonClick(ButtonManager.BUTTON_HDR_PLUS); |
| } |
| |
| /** |
| * Called when the preview started. Informs the app controller and queues a |
| * transform update when the next preview frame arrives. |
| */ |
| private void onPreviewStarted() { |
| if (mState == ModuleState.WATCH_FOR_NEXT_FRAME_AFTER_PREVIEW_STARTED) { |
| mState = ModuleState.UPDATE_TRANSFORM_ON_NEXT_SURFACE_TEXTURE_UPDATE; |
| } |
| mAppController.onPreviewStarted(); |
| } |
| |
| /** |
| * Update the preview transform based on the new dimensions. Will not force |
| * an update, if it's not necessary. |
| */ |
| private void updatePreviewTransform(int incomingWidth, int incomingHeight) { |
| updatePreviewTransform(incomingWidth, incomingHeight, false); |
| } |
| |
| /** |
| * Returns whether it is necessary to apply device-specific fix for b/19271661 |
| * on the AutoTransform Path, i.e. USE_AUTOTRANSFORM_UI_LAYOUT == true |
| * |
| * @return whether to apply workaround fix for b/19271661 |
| */ |
| private boolean requiresNexus4SpecificFixFor16By9Previews() { |
| return USE_AUTOTRANSFORM_UI_LAYOUT && ApiHelper.IS_NEXUS_4 |
| && is16by9AspectRatio(mPictureSize); |
| } |
| |
| /*** |
| * Update the preview transform based on the new dimensions. TODO: Make work |
| * with all: aspect ratios/resolutions x screens/cameras. |
| */ |
| private void updatePreviewTransform(int incomingWidth, int incomingHeight, |
| boolean forceUpdate) { |
| Log.d(TAG, "updatePreviewTransform: " + incomingWidth + " x " + incomingHeight); |
| |
| synchronized (mDimensionLock) { |
| int incomingRotation = CameraUtil.getDisplayRotation(mUI.getActivity()); |
| // Check for an actual change: |
| if (mScreenHeight == incomingHeight && mScreenWidth == incomingWidth && |
| incomingRotation == mDisplayRotation && !forceUpdate) { |
| return; |
| } |
| // Update display rotation and dimensions |
| mDisplayRotation = incomingRotation; |
| mScreenWidth = incomingWidth; |
| mScreenHeight = incomingHeight; |
| updatePreviewBufferDimension(); |
| |
| // Assumptions: |
| // - Aspect ratio for the sensor buffers is in landscape |
| // orientation, |
| // - Dimensions of buffers received are rotated to the natural |
| // device orientation. |
| // - The contents of each buffer are rotated by the inverse of |
| // the display rotation. |
| // - Surface scales the buffer to fit the current view bounds. |
| |
| // Get natural orientation and buffer dimensions |
| |
| if(USE_AUTOTRANSFORM_UI_LAYOUT) { |
| // Use PhotoUI-based AutoTransformation Interface |
| if (mPreviewBufferWidth != 0 && mPreviewBufferHeight != 0) { |
| if (requiresNexus4SpecificFixFor16By9Previews()) { |
| // Force preview size to be 16:9, even though surface is 4:3 |
| // Surface content is assumed to be 16:9. |
| mAppController.updatePreviewAspectRatio(16.f / 9.f); |
| } else { |
| mAppController.updatePreviewAspectRatio( |
| mPreviewBufferWidth / (float) mPreviewBufferHeight); |
| } |
| } |
| } else { |
| Matrix transformMatrix = mPreviewTransformCalculator.toTransformMatrix( |
| new Size(mScreenWidth, mScreenHeight), |
| new Size(mPreviewBufferWidth, mPreviewBufferHeight)); |
| mAppController.updatePreviewTransform(transformMatrix); |
| } |
| } |
| } |
| |
| |
| /** |
| * Calculates whether a picture size is 16:9 ratio, regardless of its |
| * orientation. |
| * |
| * @param size the size of the picture to be considered |
| * @return true, if the picture is 16:9; false if it's invalid or size is null |
| */ |
| private boolean is16by9AspectRatio(Size size) { |
| if (size == null || size.getWidth() == 0 || size.getHeight() == 0) { |
| return false; |
| } |
| |
| // Normalize aspect ratio to be greater than 1. |
| final float aspectRatio = (size.getHeight() > size.getWidth()) |
| ? (size.getHeight() / (float) size.getWidth()) |
| : (size.getWidth() / (float) size.getHeight()); |
| |
| return Math.abs(aspectRatio - (16.f / 9.f)) < 0.001f; |
| } |
| |
| /** |
| * Based on the current picture size, selects the best preview dimension and |
| * stores it in {@link #mPreviewBufferWidth} and |
| * {@link #mPreviewBufferHeight}. |
| */ |
| private void updatePreviewBufferDimension() { |
| if (mCamera == null) { |
| return; |
| } |
| |
| Size previewBufferSize = mCamera.pickPreviewSize(mPictureSize, mUI.getActivity()); |
| mPreviewBufferWidth = previewBufferSize.getWidth(); |
| mPreviewBufferHeight = previewBufferSize.getHeight(); |
| |
| // Workaround for N4 TextureView/HAL issues b/19271661 for 16:9 preview |
| // streams. |
| if (requiresNexus4SpecificFixFor16By9Previews()) { |
| // Override the preview selection logic to the largest N4 4:3 |
| // preview size but pass in 16:9 aspect ratio in |
| // UpdatePreviewAspectRatio later. |
| mPreviewBufferWidth = 1280; |
| mPreviewBufferHeight = 960; |
| } |
| updatePreviewBufferSize(); |
| } |
| |
| /** |
| * Open camera and start the preview. |
| */ |
| private void openCameraAndStartPreview() { |
| Profile guard = mProfiler.create("CaptureModule.openCameraAndStartPreview()").start(); |
| try { |
| // TODO Given the current design, we cannot guarantee that one of |
| // CaptureReadyCallback.onSetupFailed or onReadyForCapture will |
| // be called (see below), so it's possible that |
| // mCameraOpenCloseLock.release() is never called under extremely |
| // rare cases. If we leak the lock, this timeout ensures that we at |
| // least crash so we don't deadlock the app. |
| if (!mCameraOpenCloseLock.tryAcquire(CAMERA_OPEN_CLOSE_TIMEOUT_MILLIS, |
| TimeUnit.MILLISECONDS)) { |
| throw new RuntimeException("Time out waiting to acquire camera-open lock."); |
| } |
| } catch (InterruptedException e) { |
| throw new RuntimeException("Interrupted while waiting to acquire camera-open lock.", e); |
| } |
| |
| guard.mark("Acquired mCameraOpenCloseLock"); |
| |
| if (mOneCameraOpener == null) { |
| Log.e(TAG, "no available OneCameraManager, showing error dialog"); |
| mCameraOpenCloseLock.release(); |
| mAppController.getFatalErrorHandler().onGenericCameraAccessFailure(); |
| guard.stop("No OneCameraManager"); |
| return; |
| } |
| if (mCamera != null) { |
| // If the camera is already open, do nothing. |
| Log.d(TAG, "Camera already open, not re-opening."); |
| mCameraOpenCloseLock.release(); |
| guard.stop("Camera is already open"); |
| return; |
| } |
| |
| // Derive objects necessary for camera creation. |
| MainThread mainThread = MainThread.create(); |
| ImageRotationCalculator imageRotationCalculator = ImageRotationCalculatorImpl |
| .from(mAppController.getOrientationManager(), mCameraCharacteristics); |
| |
| // Only enable GCam on the back camera |
| boolean useHdr = mHdrPlusEnabled && mCameraFacing == Facing.BACK; |
| |
| CameraId cameraId = mOneCameraManager.findFirstCameraFacing(mCameraFacing); |
| final String settingScope = SettingsManager.getCameraSettingScope(cameraId.getValue()); |
| |
| OneCameraCaptureSetting captureSetting; |
| // Read the preferred picture size from the setting. |
| try { |
| mPictureSize = mAppController.getResolutionSetting().getPictureSize( |
| cameraId, mCameraFacing); |
| captureSetting = OneCameraCaptureSetting.create(mPictureSize, mSettingsManager, |
| getHardwareSpec(), settingScope, useHdr); |
| } catch (OneCameraAccessException ex) { |
| mAppController.getFatalErrorHandler().onGenericCameraAccessFailure(); |
| return; |
| } |
| |
| mOneCameraOpener.open(cameraId, captureSetting, mCameraHandler, mainThread, |
| imageRotationCalculator, mBurstController, mSoundPlayer, |
| new OpenCallback() { |
| @Override |
| public void onFailure() { |
| Log.e(TAG, "Could not open camera."); |
| // Sometimes the failure happens due to the controller |
| // being in paused state but mCamera is already |
| // initialized. In these cases we just need to close the |
| // camera device without showing the error dialog. |
| // Application will properly reopen the camera on the next |
| // resume operation (b/21025113). |
| boolean isControllerPaused = mAppController.isPaused(); |
| if (mCamera != null) { |
| mCamera.close(); |
| } |
| mCamera = null; |
| mCameraOpenCloseLock.release(); |
| if (!isControllerPaused) { |
| mAppController.getFatalErrorHandler().onCameraOpenFailure(); |
| } |
| } |
| |
| @Override |
| public void onCameraClosed() { |
| mCamera = null; |
| mCameraOpenCloseLock.release(); |
| } |
| |
| @Override |
| public void onCameraOpened(@Nonnull final OneCamera camera) { |
| Log.d(TAG, "onCameraOpened: " + camera); |
| mCamera = camera; |
| |
| // A race condition exists where the camera may be in the process |
| // of opening (blocked), but the activity gets destroyed. If the |
| // preview is initialized or callbacks are invoked on a destroyed |
| // activity, bad things can happen. |
| if (mAppController.isPaused()) { |
| onFailure(); |
| return; |
| } |
| |
| // When camera is opened, the zoom is implicitly reset to 1.0f |
| mZoomValue = 1.0f; |
| |
| updatePreviewBufferDimension(); |
| |
| // If the surface texture is not destroyed, it may have |
| // the last frame lingering. We need to hold off setting |
| // transform until preview is started. |
| updatePreviewBufferSize(); |
| mState = ModuleState.WATCH_FOR_NEXT_FRAME_AFTER_PREVIEW_STARTED; |
| Log.d(TAG, "starting preview ..."); |
| |
| // TODO: make mFocusController final and remove null |
| // check. |
| if (mFocusController != null) { |
| camera.setFocusDistanceListener(mFocusController); |
| } |
| |
| mMainThread.execute(new Runnable() { |
| @Override |
| public void run() { |
| mAppController.getCameraAppUI().onChangeCamera(); |
| mAppController.getButtonManager().enableCameraButton(); |
| } |
| }); |
| |
| // TODO: Consider rolling these two calls into one. |
| camera.startPreview(new Surface(getPreviewSurfaceTexture()), |
| new CaptureReadyCallback() { |
| @Override |
| public void onSetupFailed() { |
| // We must release this lock here, |
| // before posting to the main handler |
| // since we may be blocked in pause(), |
| // getting ready to close the camera. |
| mCameraOpenCloseLock.release(); |
| Log.e(TAG, "Could not set up preview."); |
| mMainThread.execute(new Runnable() { |
| @Override |
| public void run() { |
| if (mCamera == null) { |
| Log.d(TAG, "Camera closed, aborting."); |
| return; |
| } |
| mCamera.close(); |
| mCamera = null; |
| // TODO: Show an error message |
| // and exit. |
| } |
| }); |
| } |
| |
| @Override |
| public void onReadyForCapture() { |
| // We must release this lock here, |
| // before posting to the main handler |
| // since we may be blocked in pause(), |
| // getting ready to close the camera. |
| mCameraOpenCloseLock.release(); |
| mMainThread.execute(new Runnable() { |
| @Override |
| public void run() { |
| Log.d(TAG, "Ready for capture."); |
| if (mCamera == null) { |
| Log.d(TAG, "Camera closed, aborting."); |
| return; |
| } |
| onPreviewStarted(); |
| // May be overridden by |
| // subsequent call to |
| // onReadyStateChanged(). |
| onReadyStateChanged(true); |
| mCamera.setReadyStateChangedListener( |
| CaptureModule.this); |
| // Enable zooming after preview |
| // has started. |
| mUI.initializeZoom(mCamera.getMaxZoom()); |
| mCamera.setFocusStateListener(CaptureModule.this); |
| } |
| }); |
| } |
| }); |
| } |
| }, mAppController.getFatalErrorHandler()); |
| guard.stop("mOneCameraOpener.open()"); |
| } |
| |
| private void closeCamera() { |
| Profile profile = mProfiler.create("CaptureModule.closeCamera()").start(); |
| try { |
| mCameraOpenCloseLock.acquire(); |
| } catch (InterruptedException e) { |
| throw new RuntimeException("Interrupted while waiting to acquire camera-open lock.", e); |
| } |
| profile.mark("mCameraOpenCloseLock.acquire()"); |
| try { |
| if (mCamera != null) { |
| mCamera.close(); |
| profile.mark("mCamera.close()"); |
| mCamera.setFocusStateListener(null); |
| mCamera = null; |
| } |
| } finally { |
| mCameraOpenCloseLock.release(); |
| } |
| profile.stop(); |
| } |
| |
| /** |
| * Re-initialize the camera if e.g. the HDR mode or facing property changed. |
| */ |
| private void switchCamera() { |
| if (mShowErrorAndFinish) { |
| return; |
| } |
| if (mPaused) { |
| return; |
| } |
| cancelCountDown(); |
| mAppController.freezeScreenUntilPreviewReady(); |
| initSurfaceTextureConsumer(); |
| } |
| |
| /** |
| * Returns which way around the camera is facing, based on it's ID. |
| */ |
| private Facing getFacingFromCameraId(int cameraId) { |
| return mAppController.getCameraProvider().getCharacteristics(cameraId) |
| .isFacingFront() ? Facing.FRONT : Facing.BACK; |
| } |
| |
| private void resetTextureBufferSize() { |
| // According to the documentation for |
| // SurfaceTexture.setDefaultBufferSize, |
| // photo and video based image producers (presumably only Camera 1 api), |
| // override this buffer size. Any module that uses egl to render to a |
| // SurfaceTexture must have these buffer sizes reset manually. Otherwise |
| // the SurfaceTexture cannot be transformed by matrix set on the |
| // TextureView. |
| updatePreviewBufferSize(); |
| } |
| } |
