| /* |
| * 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.app.Activity; |
| import android.content.Context; |
| import android.content.res.Configuration; |
| import android.graphics.Bitmap; |
| import android.graphics.Matrix; |
| import android.graphics.RectF; |
| import android.graphics.SurfaceTexture; |
| import android.hardware.Sensor; |
| import android.hardware.SensorEvent; |
| import android.hardware.SensorEventListener; |
| import android.hardware.SensorManager; |
| import android.location.Location; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.SystemClock; |
| import android.provider.MediaStore; |
| import android.view.KeyEvent; |
| import android.view.OrientationEventListener; |
| import android.view.Surface; |
| import android.view.TextureView; |
| import android.view.View; |
| import android.view.View.OnLayoutChangeListener; |
| |
| 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.MediaSaver; |
| import com.android.camera.debug.DebugPropertyHelper; |
| import com.android.camera.debug.Log; |
| import com.android.camera.debug.Log.Tag; |
| import com.android.camera.hardware.HardwareSpec; |
| 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.OneCamera.PhotoCaptureParameters.Flash; |
| import com.android.camera.one.OneCameraManager; |
| import com.android.camera.one.Settings3A; |
| import com.android.camera.one.v2.OneCameraManagerImpl; |
| 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.ui.CountDownView; |
| import com.android.camera.ui.PreviewStatusListener; |
| import com.android.camera.ui.TouchCoordinate; |
| import com.android.camera.util.CameraUtil; |
| import com.android.camera.util.GcamHelper; |
| import com.android.camera.util.Size; |
| import com.android.camera.util.UsageStatistics; |
| import com.android.camera2.R; |
| import com.android.ex.camera2.portability.CameraAgent.CameraProxy; |
| |
| import java.io.File; |
| import java.util.concurrent.Semaphore; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * 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> |
| * TODO: |
| * <ul> |
| * <li>Server-side logging |
| * <li>Focusing (managed by OneCamera implementations) |
| * <li>Show location dialog on first start |
| * <li>Show resolution dialog on certain devices |
| * <li>Store location |
| * <li>Capture intent |
| * </ul> |
| */ |
| public class CaptureModule extends CameraModule |
| implements MediaSaver.QueueListener, |
| ModuleController, |
| CountDownView.OnCountDownStatusListener, |
| OneCamera.PictureCallback, |
| OneCamera.FocusStateListener, |
| OneCamera.ReadyStateChangedListener, |
| PreviewStatusListener.PreviewAreaChangedListener, |
| RemoteCameraModule, |
| SensorEventListener, |
| SettingsManager.OnSettingChangedListener, |
| TextureView.SurfaceTextureListener { |
| |
| /** |
| * Called on layout changes. |
| */ |
| private final OnLayoutChangeListener mLayoutListener = new OnLayoutChangeListener() { |
| @Override |
| public void onLayoutChange(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); |
| } |
| }; |
| |
| /** |
| * Hide AF target UI element. |
| */ |
| Runnable mHideAutoFocusTargetRunnable = new Runnable() { |
| @Override |
| public void run() { |
| // For debug UI off, showAutoFocusSuccess() just hides the AF UI. |
| if (mFocusedAtEnd) { |
| mUI.showAutoFocusSuccess(); |
| } else { |
| mUI.showAutoFocusFailure(); |
| } |
| } |
| }; |
| |
| private static final Tag TAG = new Tag("CaptureModule"); |
| private static final String PHOTO_MODULE_STRING_ID = "PhotoModule"; |
| /** Enable additional debug output. */ |
| private static final boolean DEBUG = true; |
| /** |
| * This is the delay before we execute onResume tasks when coming from the |
| * lock screen, to allow time for onPause to execute. |
| * <p> |
| * TODO: Make sure this value is in sync with what we see on L. |
| */ |
| private static final int ON_RESUME_TASKS_DELAY_MSEC = 20; |
| |
| /** 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; |
| |
| /** |
| * Lock for race conditions in the SurfaceTextureListener callbacks. |
| */ |
| private final Object mSurfaceLock = new Object(); |
| /** 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; |
| private CaptureModuleUI mUI; |
| /** The camera manager used to open cameras. */ |
| private OneCameraManager mCameraManager; |
| /** The currently opened camera device, or null if the camera is closed. */ |
| private OneCamera mCamera; |
| /** Held when opening or closing the camera. */ |
| private final Semaphore mCameraOpenCloseLock = new Semaphore(1); |
| /** The direction the currently opened camera is facing to. */ |
| private Facing mCameraFacing = Facing.BACK; |
| /** Whether HDR is currently enabled. */ |
| private boolean mHdrEnabled = false; |
| |
| /** The texture used to render the preview in. */ |
| private SurfaceTexture mPreviewTexture; |
| |
| /** 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 orientation of the device. */ |
| private int mOrientation = OrientationEventListener.ORIENTATION_UNKNOWN; |
| /** Current zoom value. */ |
| private float mZoomValue = 1f; |
| /** Current duration of capture timer in seconds. */ |
| private int mTimerDuration; |
| // TODO: Get image capture intent UI working. |
| private boolean mIsImageCaptureIntent; |
| |
| /** True if in AF tap-to-focus sequence. */ |
| private boolean mTapToFocusWaitForActiveScan = false; |
| /** Records beginning frame of each AF scan. */ |
| private long mAutoFocusScanStartFrame = -1; |
| /** Records beginning time of each AF scan in uptimeMillis. */ |
| private long mAutoFocusScanStartTime; |
| |
| /** Persistence of Tap to Focus target UI after scan complete. */ |
| private static final int FOCUS_HOLD_UI_MILLIS = 0; |
| /** Worst case persistence of TTF target UI. */ |
| private static final int FOCUS_UI_TIMEOUT_MILLIS = 2000; |
| /** Results from last tap to focus scan */ |
| private boolean mFocusedAtEnd; |
| /** Sensor manager we use to get the heading of the device. */ |
| private SensorManager mSensorManager; |
| /** Accelerometer. */ |
| private Sensor mAccelerometerSensor; |
| /** Compass. */ |
| private Sensor mMagneticSensor; |
| |
| /** Accelerometer data. */ |
| private final float[] mGData = new float[3]; |
| /** Magnetic sensor data. */ |
| private final float[] mMData = new float[3]; |
| /** Temporary rotation matrix. */ |
| private final float[] mR = new float[16]; |
| /** Current compass heading. */ |
| private int mHeading = -1; |
| |
| /** Used to fetch and embed the location into captured images. */ |
| private LocationManager mLocationManager; |
| /** Plays sounds for countdown timer. */ |
| private SoundPlayer mCountdownSoundPlayer; |
| |
| /** Whether the module is paused right now. */ |
| private boolean mPaused; |
| |
| /** Whether this module was resumed from lockscreen capture intent. */ |
| private boolean mIsResumeFromLockScreen = false; |
| |
| private final Runnable mResumeTaskRunnable = new Runnable() { |
| @Override |
| public void run() { |
| onResumeTasks(); |
| } |
| }; |
| |
| /** Main thread handler. */ |
| private Handler mMainHandler; |
| /** 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 current preview transformation matrix. */ |
| private Matrix mPreviewTranformationMatrix = new Matrix(); |
| /** TODO: This is N5 specific. */ |
| public static final float FULLSCREEN_ASPECT_RATIO = 16 / 9f; |
| |
| /** A directory to store debug information in during development. */ |
| private final File mDebugDataDir; |
| |
| /** CLEAN UP START */ |
| // private boolean mFirstLayout; |
| // private int[] mTargetFPSRanges; |
| // private float mZoomValue; |
| // private int mSensorOrientation; |
| // private int mLensFacing; |
| // private String mFlashMode; |
| /** CLEAN UP END */ |
| |
| public CaptureModule(AppController appController) { |
| this(appController, false); |
| } |
| |
| /** Constructs a new capture module. */ |
| public CaptureModule(AppController appController, boolean stickyHdr) { |
| super(appController); |
| mAppController = appController; |
| mContext = mAppController.getAndroidContext(); |
| mSettingsManager = mAppController.getSettingsManager(); |
| mSettingsManager.addListener(this); |
| mDebugDataDir = mContext.getExternalCacheDir(); |
| mStickyGcamCamera = stickyHdr; |
| } |
| |
| @Override |
| public void init(CameraActivity activity, boolean isSecureCamera, boolean isCaptureIntent) { |
| Log.d(TAG, "init"); |
| mIsResumeFromLockScreen = isResumeFromLockscreen(activity); |
| mMainHandler = new Handler(activity.getMainLooper()); |
| HandlerThread thread = new HandlerThread("CaptureModule.mCameraHandler"); |
| thread.start(); |
| mCameraHandler = new Handler(thread.getLooper()); |
| mCameraManager = mAppController.getCameraManager(); |
| mLocationManager = mAppController.getLocationManager(); |
| mDisplayRotation = CameraUtil.getDisplayRotation(mContext); |
| mCameraFacing = getFacingFromCameraId(mSettingsManager.getInteger( |
| mAppController.getModuleScope(), |
| Keys.KEY_CAMERA_ID)); |
| mUI = new CaptureModuleUI(activity, this, mAppController.getModuleLayoutRoot(), |
| mLayoutListener); |
| mAppController.setPreviewStatusListener(mUI); |
| mPreviewTexture = mAppController.getCameraAppUI().getSurfaceTexture(); |
| mSensorManager = (SensorManager) (mContext.getSystemService(Context.SENSOR_SERVICE)); |
| mAccelerometerSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); |
| mMagneticSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD); |
| mCountdownSoundPlayer = new SoundPlayer(mContext); |
| |
| String action = activity.getIntent().getAction(); |
| mIsImageCaptureIntent = (MediaStore.ACTION_IMAGE_CAPTURE.equals(action) |
| || CameraActivity.ACTION_IMAGE_CAPTURE_SECURE.equals(action)); |
| View cancelButton = activity.findViewById(R.id.shutter_cancel_button); |
| cancelButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| cancelCountDown(); |
| } |
| }); |
| } |
| |
| @Override |
| public void onShutterButtonFocus(boolean pressed) { |
| // TODO Auto-generated method stub |
| } |
| |
| @Override |
| public void onShutterCoordinate(TouchCoordinate coord) { |
| // TODO Auto-generated method stub |
| } |
| |
| @Override |
| public void onShutterButtonClick() { |
| if (mCamera == null) { |
| return; |
| } |
| |
| int countDownDuration = mSettingsManager |
| .getInteger(SettingsManager.SCOPE_GLOBAL, Keys.KEY_COUNTDOWN_DURATION); |
| mTimerDuration = countDownDuration; |
| 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 takePictureNow() { |
| Location location = mLocationManager.getCurrentLocation(); |
| |
| // Set up the capture session. |
| long sessionTime = System.currentTimeMillis(); |
| String title = CameraUtil.createJpegName(sessionTime); |
| CaptureSession session = getServices().getCaptureSessionManager() |
| .createNewSession(title, sessionTime, location); |
| |
| // Set up the parameters for this capture. |
| PhotoCaptureParameters params = new PhotoCaptureParameters(); |
| params.title = title; |
| params.callback = this; |
| params.orientation = getOrientation(); |
| params.flashMode = getFlashModeFromSettings(); |
| params.heading = mHeading; |
| params.debugDataFolder = mDebugDataDir; |
| params.location = location; |
| |
| mCamera.takePicture(params, session); |
| } |
| |
| @Override |
| public void onCountDownFinished() { |
| if (mIsImageCaptureIntent) { |
| mAppController.getCameraAppUI().transitionToIntentReviewLayout(); |
| } else { |
| mAppController.getCameraAppUI().transitionToCapture(); |
| } |
| mAppController.getCameraAppUI().showModeOptions(); |
| if (mPaused) { |
| return; |
| } |
| takePictureNow(); |
| } |
| |
| @Override |
| public void onRemainingSecondsChanged(int remainingSeconds) { |
| if (remainingSeconds == 1) { |
| mCountdownSoundPlayer.play(R.raw.timer_final_second, 0.6f); |
| } else if (remainingSeconds == 2 || remainingSeconds == 3) { |
| mCountdownSoundPlayer.play(R.raw.timer_increment, 0.6f); |
| } |
| } |
| |
| private void cancelCountDown() { |
| if (mUI.isCountingDown()) { |
| // Cancel on-going countdown. |
| mUI.cancelCountDown(); |
| } |
| mAppController.getCameraAppUI().showModeOptions(); |
| mAppController.getCameraAppUI().transitionToCapture(); |
| } |
| |
| @Override |
| public void onQuickExpose() { |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| // Starts the short version of the capture animation UI. |
| mAppController.startPreCaptureAnimation(true); |
| } |
| }); |
| } |
| |
| @Override |
| public void onPreviewAreaChanged(RectF previewArea) { |
| mPreviewArea = previewArea; |
| mUI.onPreviewAreaChanged(previewArea); |
| // mUI.updatePreviewAreaRect(previewArea); |
| mUI.positionProgressOverlay(previewArea); |
| } |
| |
| @Override |
| public void onSensorChanged(SensorEvent event) { |
| // This is literally the same as the GCamModule implementation. |
| int type = event.sensor.getType(); |
| float[] data; |
| if (type == Sensor.TYPE_ACCELEROMETER) { |
| data = mGData; |
| } else if (type == Sensor.TYPE_MAGNETIC_FIELD) { |
| data = mMData; |
| } else { |
| Log.w(TAG, String.format("Unexpected sensor type %s", event.sensor.getName())); |
| return; |
| } |
| for (int i = 0; i < 3; i++) { |
| data[i] = event.values[i]; |
| } |
| float[] orientation = new float[3]; |
| SensorManager.getRotationMatrix(mR, null, mGData, mMData); |
| SensorManager.getOrientation(mR, orientation); |
| mHeading = (int) (orientation[0] * 180f / Math.PI) % 360; |
| |
| if (mHeading < 0) { |
| mHeading += 360; |
| } |
| } |
| |
| @Override |
| public void onAccuracyChanged(Sensor sensor, int accuracy) { |
| // TODO Auto-generated method stub |
| } |
| |
| @Override |
| public void onQueueStatus(boolean full) { |
| // TODO Auto-generated method stub |
| } |
| |
| @Override |
| public void onRemoteShutterPress() { |
| // TODO: Check whether shutter is enabled. |
| onShutterButtonClick(); |
| } |
| |
| @Override |
| public void onSurfaceTextureAvailable(final 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); |
| initSurface(surface); |
| } |
| |
| public void initSurface(final SurfaceTexture surface) { |
| mPreviewTexture = surface; |
| closeCamera(); |
| openCameraAndStartPreview(); |
| } |
| |
| @Override |
| public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) { |
| Log.d(TAG, "onSurfaceTextureSizeChanged"); |
| resetDefaultBufferSize(); |
| } |
| |
| @Override |
| public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) { |
| Log.d(TAG, "onSurfaceTextureDestroyed"); |
| mPreviewTexture = null; |
| closeCamera(); |
| return true; |
| } |
| |
| @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); |
| } |
| } |
| |
| @Override |
| public String getModuleStringIdentifier() { |
| return PHOTO_MODULE_STRING_ID; |
| } |
| |
| @Override |
| public void resume() { |
| // Add delay on resume from lock screen only, in order to to speed up |
| // the onResume --> onPause --> onResume cycle from lock screen. |
| // Don't do always because letting go of thread can cause delay. |
| if (mIsResumeFromLockScreen) { |
| Log.v(TAG, "Delayng onResumeTasks from lock screen. " + System.currentTimeMillis()); |
| // Note: onPauseAfterSuper() will delete this runnable, so we will |
| // at most have 1 copy queued up. |
| mMainHandler.postDelayed(mResumeTaskRunnable, ON_RESUME_TASKS_DELAY_MSEC); |
| } else { |
| onResumeTasks(); |
| } |
| } |
| |
| private void onResumeTasks() { |
| Log.d(TAG, "onResumeTasks + " + System.currentTimeMillis()); |
| mPaused = false; |
| mAppController.getCameraAppUI().onChangeCamera(); |
| mAppController.addPreviewAreaSizeChangedListener(this); |
| resetDefaultBufferSize(); |
| getServices().getRemoteShutterListener().onModuleReady(this); |
| // TODO: Check if we can really take a photo right now (memory, camera |
| // state, ... ). |
| mAppController.getCameraAppUI().enableModeOptions(); |
| mAppController.setShutterEnabled(true); |
| |
| // Get events from the accelerometer and magnetic sensor. |
| if (mAccelerometerSensor != null) { |
| mSensorManager.registerListener(this, mAccelerometerSensor, |
| SensorManager.SENSOR_DELAY_NORMAL); |
| } |
| if (mMagneticSensor != null) { |
| mSensorManager.registerListener(this, mMagneticSensor, |
| SensorManager.SENSOR_DELAY_NORMAL); |
| } |
| mHdrEnabled = mStickyGcamCamera || mAppController.getSettingsManager().getInteger( |
| SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS) == 1; |
| |
| // 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. |
| if (mPreviewTexture != null) { |
| initSurface(mPreviewTexture); |
| } |
| |
| mCountdownSoundPlayer.loadSound(R.raw.timer_final_second); |
| mCountdownSoundPlayer.loadSound(R.raw.timer_increment); |
| } |
| |
| @Override |
| public void pause() { |
| mPaused = true; |
| cancelCountDown(); |
| resetTextureBufferSize(); |
| closeCamera(); |
| mCountdownSoundPlayer.unloadSound(R.raw.timer_final_second); |
| mCountdownSoundPlayer.unloadSound(R.raw.timer_increment); |
| // Remove delayed resume trigger, if it hasn't been executed yet. |
| mMainHandler.removeCallbacksAndMessages(null); |
| |
| // Unregister the sensors. |
| if (mAccelerometerSensor != null) { |
| mSensorManager.unregisterListener(this, mAccelerometerSensor); |
| } |
| if (mMagneticSensor != null) { |
| mSensorManager.unregisterListener(this, mMagneticSensor); |
| } |
| } |
| |
| @Override |
| public void destroy() { |
| mCountdownSoundPlayer.release(); |
| mCameraHandler.getLooper().quitSafely(); |
| } |
| |
| @Override |
| public void onLayoutOrientationChanged(boolean isLandscape) { |
| Log.d(TAG, "onLayoutOrientationChanged"); |
| } |
| |
| @Override |
| public void onOrientationChanged(int orientation) { |
| // We keep the last known orientation. So if the user first orient |
| // the camera then point the camera to floor or sky, we still have |
| // the correct orientation. |
| if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) { |
| return; |
| } |
| |
| // TODO: Document orientation compute logic and unify them in OrientationManagerImpl. |
| // b/17443789 |
| // Flip to counter-clockwise orientation. |
| mOrientation = (360 - orientation) % 360; |
| } |
| |
| @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) { |
| // Sitcky 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, |
| getBackFacingCameraId()); |
| } |
| } |
| |
| @Override |
| public HardwareSpec getHardwareSpec() { |
| return new HardwareSpec() { |
| @Override |
| public boolean isFrontCameraSupported() { |
| return true; |
| } |
| |
| @Override |
| public boolean isHdrSupported() { |
| // TODO: Check if the device has HDR and not HDR+. |
| return false; |
| } |
| |
| @Override |
| public boolean isHdrPlusSupported() { |
| return GcamHelper.hasGcamCapture(); |
| } |
| |
| @Override |
| public boolean isFlashSupported() { |
| return true; |
| } |
| }; |
| } |
| |
| @Override |
| public BottomBarUISpec getBottomBarSpec() { |
| CameraAppUI.BottomBarUISpec bottomBarSpec = new CameraAppUI.BottomBarUISpec(); |
| bottomBarSpec.enableGridLines = true; |
| bottomBarSpec.enableCamera = true; |
| bottomBarSpec.cameraCallback = getCameraCallback(); |
| bottomBarSpec.enableHdr = GcamHelper.hasGcamCapture(); |
| bottomBarSpec.hdrCallback = getHdrButtonCallback(); |
| bottomBarSpec.enableSelfTimer = true; |
| bottomBarSpec.showSelfTimer = true; |
| if (!mHdrEnabled) { |
| bottomBarSpec.enableFlash = true; |
| } |
| // Added to handle case of CaptureModule being used only for Gcam. |
| if (mStickyGcamCamera) { |
| bottomBarSpec.enableFlash = false; |
| } |
| 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; |
| } |
| |
| /** |
| * Focus sequence starts for zone around tap location for single tap. |
| */ |
| @Override |
| public void onSingleTapUp(View view, int x, int y) { |
| Log.v(TAG, "onSingleTapUp x=" + x + " y=" + y); |
| // TODO: This should query actual capability. |
| if (mCameraFacing == Facing.FRONT) { |
| return; |
| } |
| triggerFocusAtScreenCoord(x, y); |
| } |
| |
| // TODO: Consider refactoring FocusOverlayManager. |
| // Currently AF state transitions are controlled in OneCameraImpl. |
| // PhotoModule uses FocusOverlayManager which uses API1/portability |
| // logic and coordinates. |
| private void triggerFocusAtScreenCoord(int x, int y) { |
| if (mCamera == null) { |
| // If we receive this after the camera is closed, do nothing. |
| return; |
| } |
| |
| mTapToFocusWaitForActiveScan = true; |
| // Show UI immediately even though scan has not started yet. |
| float minEdge = Math.min(mPreviewArea.width(), mPreviewArea.height()); |
| mUI.setAutoFocusTarget(x, y, false, |
| (int) (Settings3A.getAutoFocusRegionWidth() * mZoomValue * minEdge), |
| (int) (Settings3A.getMeteringRegionWidth() * mZoomValue * minEdge)); |
| mUI.showAutoFocusInProgress(); |
| |
| // Cancel any scheduled auto focus target UI actions. |
| mMainHandler.removeCallbacks(mHideAutoFocusTargetRunnable); |
| // Timeout in case camera fails to stop (unlikely). |
| mMainHandler.postDelayed(new Runnable() { |
| @Override |
| public void run() { |
| mMainHandler.post(mHideAutoFocusTargetRunnable); |
| } |
| }, FOCUS_UI_TIMEOUT_MILLIS); |
| |
| // Normalize coordinates to [0,1] per CameraOne API. |
| float points[] = new float[2]; |
| points[0] = (x - mPreviewArea.left) / mPreviewArea.width(); |
| points[1] = (y - 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); |
| mCamera.triggerFocusAndMeterAtPoint(points[0], points[1]); |
| |
| // Log touch (screen coordinates). |
| if (mZoomValue == 1f) { |
| TouchCoordinate touchCoordinate = new TouchCoordinate(x - mPreviewArea.left, |
| y - 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 setAutoFocusTargetPassive() { |
| float minEdge = Math.min(mPreviewArea.width(), mPreviewArea.height()); |
| mUI.setAutoFocusTarget((int) mPreviewArea.centerX(), (int) mPreviewArea.centerY(), |
| true, |
| (int) (Settings3A.getAutoFocusRegionWidth() * mZoomValue * minEdge), |
| (int) (Settings3A.getMeteringRegionWidth() * mZoomValue * minEdge)); |
| mUI.showAutoFocusInProgress(); |
| } |
| |
| /** |
| * 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: |
| mMainHandler.removeCallbacks(mHideAutoFocusTargetRunnable); |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| setAutoFocusTargetPassive(); |
| } |
| }); |
| break; |
| case ACTIVE_SCAN: |
| mTapToFocusWaitForActiveScan = false; |
| break; |
| case PASSIVE_FOCUSED: |
| case PASSIVE_UNFOCUSED: |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| mUI.setPassiveFocusSuccess(state == AutoFocusState.PASSIVE_FOCUSED); |
| } |
| }); |
| break; |
| case ACTIVE_FOCUSED: |
| case ACTIVE_UNFOCUSED: |
| if (!mTapToFocusWaitForActiveScan) { |
| mFocusedAtEnd = state != AutoFocusState.ACTIVE_UNFOCUSED; |
| mMainHandler.removeCallbacks(mHideAutoFocusTargetRunnable); |
| mMainHandler.post(mHideAutoFocusTargetRunnable); |
| } |
| 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(Bitmap bitmap) { |
| // TODO |
| } |
| |
| @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 onPictureTakenFailed() { |
| } |
| |
| @Override |
| public void onSettingChanged(SettingsManager settingsManager, String key) { |
| // TODO Auto-generated method stub |
| } |
| |
| /** |
| * 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); |
| } |
| |
| /** |
| * Set zoom value. |
| * |
| * @param zoom Zoom value, must be between 1.0 and mCamera.getMaxZoom(). |
| */ |
| public void setZoom(float zoom) { |
| mZoomValue = zoom; |
| if (mCamera != null) { |
| mCamera.setZoom(zoom); |
| } |
| } |
| |
| /** |
| * TODO: Remove this method once we are in pure CaptureModule land. |
| */ |
| private String getBackFacingCameraId() { |
| if (!(mCameraManager instanceof OneCameraManagerImpl)) { |
| throw new IllegalStateException("This should never be called with Camera API V1"); |
| } |
| OneCameraManagerImpl manager = (OneCameraManagerImpl) mCameraManager; |
| return manager.getFirstBackCameraId(); |
| } |
| |
| /** |
| * @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; |
| } |
| Log.d(TAG, "HDR enabled =" + hdrEnabled); |
| mHdrEnabled = hdrEnabled == 1; |
| switchCamera(); |
| } |
| }; |
| } |
| } |
| |
| /** |
| * @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; |
| } |
| |
| // 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); |
| 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); |
| } |
| |
| /*** |
| * 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(mContext); |
| // 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(); |
| |
| mPreviewTranformationMatrix = mAppController.getCameraAppUI().getPreviewTransform( |
| mPreviewTranformationMatrix); |
| int width = mScreenWidth; |
| int height = mScreenHeight; |
| |
| // 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 |
| int naturalOrientation = CaptureModuleUtil |
| .getDeviceNaturalOrientation(mContext); |
| int effectiveWidth = mPreviewBufferWidth; |
| int effectiveHeight = mPreviewBufferHeight; |
| |
| if (DEBUG) { |
| Log.v(TAG, "Rotation: " + mDisplayRotation); |
| Log.v(TAG, "Screen Width: " + mScreenWidth); |
| Log.v(TAG, "Screen Height: " + mScreenHeight); |
| Log.v(TAG, "Buffer width: " + mPreviewBufferWidth); |
| Log.v(TAG, "Buffer height: " + mPreviewBufferHeight); |
| Log.v(TAG, "Natural orientation: " + naturalOrientation); |
| } |
| |
| // If natural orientation is portrait, rotate the buffer |
| // dimensions |
| if (naturalOrientation == Configuration.ORIENTATION_PORTRAIT) { |
| int temp = effectiveWidth; |
| effectiveWidth = effectiveHeight; |
| effectiveHeight = temp; |
| } |
| |
| // Find and center view rect and buffer rect |
| RectF viewRect = new RectF(0, 0, width, height); |
| RectF bufRect = new RectF(0, 0, effectiveWidth, effectiveHeight); |
| float centerX = viewRect.centerX(); |
| float centerY = viewRect.centerY(); |
| bufRect.offset(centerX - bufRect.centerX(), centerY - bufRect.centerY()); |
| |
| // Undo ScaleToFit.FILL done by the surface |
| mPreviewTranformationMatrix.setRectToRect(viewRect, bufRect, Matrix.ScaleToFit.FILL); |
| |
| // Rotate buffer contents to proper orientation |
| mPreviewTranformationMatrix.postRotate(getPreviewOrientation(mDisplayRotation), |
| centerX, centerY); |
| |
| // TODO: This is probably only working for the N5. Need to test |
| // on a device like N10 with different sensor orientation. |
| if ((mDisplayRotation % 180) == 90) { |
| int temp = effectiveWidth; |
| effectiveWidth = effectiveHeight; |
| effectiveHeight = temp; |
| } |
| |
| // Scale to fit view, cropping the longest dimension |
| float scale = |
| Math.min(width / (float) effectiveWidth, height |
| / (float) effectiveHeight); |
| mPreviewTranformationMatrix.postScale(scale, scale, centerX, centerY); |
| |
| // TODO: Take these quantities from mPreviewArea. |
| float previewWidth = effectiveWidth * scale; |
| float previewHeight = effectiveHeight * scale; |
| float previewCenterX = previewWidth / 2; |
| float previewCenterY = previewHeight / 2; |
| mPreviewTranformationMatrix.postTranslate(previewCenterX - centerX, previewCenterY |
| - centerY); |
| |
| mAppController.updatePreviewTransform(mPreviewTranformationMatrix); |
| mAppController.getCameraAppUI().hideLetterboxing(); |
| // if (mGcamProxy != null) { |
| // mGcamProxy.postSetAspectRatio(mFinalAspectRatio); |
| // } |
| // mUI.updatePreviewAreaRect(new RectF(0, 0, previewWidth, |
| // previewHeight)); |
| |
| // TODO: Add face detection. |
| // Characteristics info = |
| // mapp.getCameraProvider().getCharacteristics(0); |
| // mUI.setupFaceDetection(CameraUtil.getDisplayOrientation(incomingRotation, |
| // info), false); |
| // updateCamera2FaceBoundTransform(new |
| // RectF(mEffectiveCropRegion), |
| // new RectF(0, 0, mBufferWidth, mBufferHeight), |
| // new RectF(0, 0, previewWidth, previewHeight), getRotation()); |
| } |
| } |
| |
| /** |
| * 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 pictureSize = getPictureSizeFromSettings(); |
| Size previewBufferSize = mCamera.pickPreviewSize(pictureSize, mContext); |
| mPreviewBufferWidth = previewBufferSize.getWidth(); |
| mPreviewBufferHeight = previewBufferSize.getHeight(); |
| } |
| |
| /** |
| * Resets the default buffer size to the initially calculated size. |
| */ |
| private void resetDefaultBufferSize() { |
| synchronized (mSurfaceLock) { |
| if (mPreviewTexture != null) { |
| mPreviewTexture.setDefaultBufferSize(mPreviewBufferWidth, mPreviewBufferHeight); |
| } |
| } |
| } |
| |
| /** |
| * Open camera and start the preview. |
| */ |
| private void openCameraAndStartPreview() { |
| // Only enable HDR on the back camera |
| boolean useHdr = mHdrEnabled && mCameraFacing == Facing.BACK; |
| |
| 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); |
| } |
| mCameraManager.open(mCameraFacing, useHdr, getPictureSizeFromSettings(), |
| new OpenCallback() { |
| @Override |
| public void onFailure() { |
| Log.e(TAG, "Could not open camera."); |
| mCamera = null; |
| mCameraOpenCloseLock.release(); |
| mAppController.showErrorAndFinish(R.string.cannot_connect_camera); |
| } |
| |
| @Override |
| public void onCameraClosed() { |
| mCamera = null; |
| mCameraOpenCloseLock.release(); |
| } |
| |
| @Override |
| public void onCameraOpened(final OneCamera camera) { |
| Log.d(TAG, "onCameraOpened: " + camera); |
| mCamera = camera; |
| 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. |
| resetDefaultBufferSize(); |
| mState = ModuleState.WATCH_FOR_NEXT_FRAME_AFTER_PREVIEW_STARTED; |
| Log.d(TAG, "starting preview ..."); |
| |
| // TODO: Consider rolling these two calls into one. |
| camera.startPreview(new Surface(mPreviewTexture), |
| 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."); |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| if (mCamera == null) { |
| Log.d(TAG, "Camera closed, aborting."); |
| return; |
| } |
| mCamera.close(null); |
| 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(); |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| Log.d(TAG, "Ready for capture."); |
| if (mCamera == null) { |
| Log.d(TAG, "Camera closed, aborting."); |
| return; |
| } |
| onPreviewStarted(); |
| // Enable zooming after preview has |
| // started. |
| mUI.initializeZoom(mCamera.getMaxZoom()); |
| mCamera.setFocusStateListener(CaptureModule.this); |
| mCamera.setReadyStateChangedListener(CaptureModule.this); |
| } |
| }); |
| } |
| }); |
| } |
| }, mCameraHandler); |
| } |
| |
| private void closeCamera() { |
| try { |
| mCameraOpenCloseLock.acquire(); |
| } catch(InterruptedException e) { |
| throw new RuntimeException("Interrupted while waiting to acquire camera-open lock.", e); |
| } |
| try { |
| if (mCamera != null) { |
| mCamera.setFocusStateListener(null); |
| mCamera.close(null); |
| mCamera = null; |
| } |
| } finally { |
| mCameraOpenCloseLock.release(); |
| } |
| } |
| |
| private int getOrientation() { |
| if (mAppController.isAutoRotateScreen()) { |
| return mDisplayRotation; |
| } else { |
| return mOrientation; |
| } |
| } |
| |
| /** |
| * @return Whether we are resuming from within the lockscreen. |
| */ |
| private static boolean isResumeFromLockscreen(Activity activity) { |
| String action = activity.getIntent().getAction(); |
| return (MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA.equals(action) |
| || MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE.equals(action)); |
| } |
| |
| /** |
| * Re-initialize the camera if e.g. the HDR mode or facing property changed. |
| */ |
| private void switchCamera() { |
| if (mPaused) { |
| return; |
| } |
| cancelCountDown(); |
| mAppController.freezeScreenUntilPreviewReady(); |
| initSurface(mPreviewTexture); |
| |
| // TODO: Un-comment once we have focus back. |
| // if (mFocusManager != null) { |
| // mFocusManager.removeMessages(); |
| // } |
| // mFocusManager.setMirror(mMirror); |
| } |
| |
| private Size getPictureSizeFromSettings() { |
| String pictureSizeKey = mCameraFacing == Facing.FRONT ? Keys.KEY_PICTURE_SIZE_FRONT |
| : Keys.KEY_PICTURE_SIZE_BACK; |
| return mSettingsManager.getSize(SettingsManager.SCOPE_GLOBAL, pictureSizeKey); |
| } |
| |
| private int getPreviewOrientation(int deviceOrientationDegrees) { |
| // Important: Camera2 buffers are already rotated to the natural |
| // orientation of the device (at least for the back-camera). |
| |
| // TODO: Remove this hack for the front camera as soon as b/16637957 is |
| // fixed. |
| if (mCameraFacing == Facing.FRONT) { |
| deviceOrientationDegrees += 180; |
| } |
| return (360 - deviceOrientationDegrees) % 360; |
| } |
| |
| /** |
| * Returns which way around the camera is facing, based on it's ID. |
| * <p> |
| * TODO: This needs to change so that we store the direction directly in the |
| * settings, rather than a Camera ID. |
| */ |
| private static Facing getFacingFromCameraId(int cameraId) { |
| return cameraId == 1 ? Facing.FRONT : Facing.BACK; |
| } |
| |
| private void resetTextureBufferSize() { |
| // Reset the default buffer sizes on the shared SurfaceTexture |
| // so they are not scaled for gcam. |
| // |
| // 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. |
| if (mPreviewTexture != null) { |
| mPreviewTexture.setDefaultBufferSize(mAppController.getCameraAppUI().getSurfaceWidth(), |
| mAppController.getCameraAppUI().getSurfaceHeight()); |
| } |
| } |
| |
| /** |
| * @return The currently set Flash settings. Defaults to AUTO if the setting |
| * could not be parsed. |
| */ |
| private Flash getFlashModeFromSettings() { |
| String flashSetting = mSettingsManager.getString(mAppController.getCameraScope(), |
| Keys.KEY_FLASH_MODE); |
| try { |
| return Flash.valueOf(flashSetting.toUpperCase()); |
| } catch (IllegalArgumentException ex) { |
| Log.w(TAG, "Could not parse Flash Setting. Defaulting to AUTO."); |
| return Flash.AUTO; |
| } |
| } |
| } |
