/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.camera; import android.app.ActivityManager; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.res.Configuration; import android.content.res.Resources; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.ImageFormat; import android.graphics.PixelFormat; import android.graphics.Point; import android.graphics.Rect; import android.graphics.SurfaceTexture; import android.graphics.YuvImage; import android.hardware.Camera.Parameters; import android.hardware.Camera.Size; import android.location.Location; import android.net.Uri; import android.os.AsyncTask; import android.os.Handler; import android.os.Message; import android.os.PowerManager; import android.util.Log; import android.view.KeyEvent; import android.view.OrientationEventListener; import android.view.View; import android.view.ViewGroup; import android.view.WindowManager; import android.widget.Toast; import com.android.camera.CameraManager.CameraProxy; import com.android.camera.app.OrientationManager; import com.android.camera.data.LocalData; import com.android.camera.exif.ExifInterface; import com.android.camera.ui.RotateTextToast; import com.android.camera.util.CameraUtil; import com.android.camera.util.UsageStatistics; import org.codeaurora.snapcam.R; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.IOException; import java.util.List; import java.util.TimeZone; /** * Activity to handle panorama capturing. */ public class WideAnglePanoramaModule extends BaseModule implements WideAnglePanoramaController, SurfaceTexture.OnFrameAvailableListener { public static final int DEFAULT_SWEEP_ANGLE = 160; public static final int DEFAULT_BLEND_MODE = Mosaic.BLENDTYPE_HORIZONTAL; public static final int DEFAULT_CAPTURE_PIXELS = 1440 * 1080; private static final int MSG_LOW_RES_FINAL_MOSAIC_READY = 1; private static final int MSG_GENERATE_FINAL_MOSAIC_ERROR = 2; private static final int MSG_END_DIALOG_RESET_TO_PREVIEW = 3; private static final int MSG_CLEAR_SCREEN_DELAY = 4; private static final int MSG_RESET_TO_PREVIEW = 5; private static final int SCREEN_DELAY = 2 * 60 * 1000; @SuppressWarnings("unused") private static final String TAG = "CAM_WidePanoModule"; private static final int PREVIEW_STOPPED = 0; private static final int PREVIEW_ACTIVE = 1; public static final int CAPTURE_STATE_VIEWFINDER = 0; public static final int CAPTURE_STATE_MOSAIC = 1; // The unit of speed is degrees per frame. private static final float PANNING_SPEED_THRESHOLD = 2.5f; private static final boolean DEBUG = false; private ContentResolver mContentResolver; private MosaicPreviewRenderer mMosaicPreviewRenderer; private Object mRendererLock = new Object(); private Object mWaitObject = new Object(); private final CameraErrorCallback mErrorCallback = new CameraErrorCallback(); private String mPreparePreviewString; private String mDialogTitle; private String mDialogOkString; private String mDialogPanoramaFailedString; private String mDialogWaitingPreviousString; private int mPreviewUIWidth; private int mPreviewUIHeight; private boolean mUsingFrontCamera; private int mCameraPreviewWidth; private int mCameraPreviewHeight; private int mCameraState; private int mCaptureState; private PowerManager.WakeLock mPartialWakeLock; private MosaicFrameProcessor mMosaicFrameProcessor; private boolean mMosaicFrameProcessorInitialized; private AsyncTask mWaitProcessorTask; private long mTimeTaken; private Handler mMainHandler; private SurfaceTexture mCameraTexture; private boolean mThreadRunning; private boolean mCancelComputation; private float mHorizontalViewAngle; private float mVerticalViewAngle; // Prefer FOCUS_MODE_INFINITY to FOCUS_MODE_CONTINUOUS_VIDEO because of // getting a better image quality by the former. private String mTargetFocusMode = Parameters.FOCUS_MODE_INFINITY; private PanoOrientationEventListener mOrientationEventListener; // The value could be 0, 90, 180, 270 for the 4 different orientations measured in clockwise // respectively. private int mDeviceOrientation; private int mDeviceOrientationAtCapture; private int mCameraOrientation; private int mOrientationCompensation; private boolean mOrientationLocked; private SoundClips.Player mSoundPlayer; private Runnable mOnFrameAvailableRunnable; private CameraActivity mActivity; private View mRootView; private CameraProxy mCameraDevice; private boolean mPaused; private LocationManager mLocationManager; private OrientationManager mOrientationManager; private ComboPreferences mPreferences; private boolean mMosaicPreviewConfigured; private boolean mPreviewFocused = true; private boolean mPreviewLayoutChanged = false; private boolean mDirectionChanged = false; @Override public void onPreviewUIReady() { configMosaicPreview(); } @Override public void onPreviewUIDestroyed() { } private class MosaicJpeg { public MosaicJpeg(byte[] data, int width, int height) { this.data = data; this.width = width; this.height = height; this.isValid = true; } public MosaicJpeg() { this.data = null; this.width = 0; this.height = 0; this.isValid = false; } public final byte[] data; public final int width; public final int height; public final boolean isValid; } private class PanoOrientationEventListener extends OrientationEventListener { public PanoOrientationEventListener(Context context) { super(context); } @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 == ORIENTATION_UNKNOWN) return; int oldOrientation = mDeviceOrientation; mDeviceOrientation = CameraUtil.roundOrientation(orientation, mDeviceOrientation); // When the screen is unlocked, display rotation may change. Always // calculate the up-to-date orientationCompensation. int orientationCompensation = mDeviceOrientation + CameraUtil.getDisplayRotation(mActivity) % 360; if (mOrientationCompensation != orientationCompensation) { mOrientationCompensation = orientationCompensation; } if (oldOrientation != mDeviceOrientation && oldOrientation != OrientationEventListener.ORIENTATION_UNKNOWN) { mPreviewLayoutChanged = true; if (!mOrientationLocked) mUI.setOrientation(mDeviceOrientation, true); } } } private int getPreferredCameraId(ComboPreferences preferences) { int intentCameraId = CameraUtil.getCameraFacingIntentExtras(mActivity); if (intentCameraId != -1) { // Testing purpose. Launch a specific camera through the intent // extras. return intentCameraId; } else { return CameraSettings.readPreferredCameraId(preferences); } } @Override public void init(CameraActivity activity, View parent) { mActivity = activity; mRootView = parent; mOrientationManager = new OrientationManager(activity); mCaptureState = CAPTURE_STATE_VIEWFINDER; mUI = new WideAnglePanoramaUI(mActivity, this, (ViewGroup) mRootView); mUI.setCaptureProgressOnDirectionChangeListener( new PanoProgressBar.OnDirectionChangeListener() { @Override public void onDirectionChange(int direction) { if (mDirectionChanged) { stopCapture(false); return; } if (mCaptureState == CAPTURE_STATE_MOSAIC) { mUI.showDirectionIndicators(direction); } if (direction != PanoProgressBar.DIRECTION_NONE) { mDirectionChanged = true; } } }); mContentResolver = mActivity.getContentResolver(); // This runs in UI thread. mOnFrameAvailableRunnable = new Runnable() { @Override public void run() { // Frames might still be available after the activity is paused. // If we call onFrameAvailable after pausing, the GL thread will crash. if (mPaused) return; MosaicPreviewRenderer renderer = null; synchronized (mRendererLock) { if (mMosaicPreviewRenderer == null) { return; } renderer = mMosaicPreviewRenderer; } if (mRootView.getVisibility() != View.VISIBLE) { renderer.showPreviewFrameSync(); mRootView.setVisibility(View.VISIBLE); } else { if (mCaptureState == CAPTURE_STATE_VIEWFINDER) { if (mPreviewLayoutChanged) { boolean isLandscape = (mDeviceOrientation / 90) % 2 == 1; renderer.previewReset(mPreviewUIWidth, mPreviewUIHeight, isLandscape, mDeviceOrientation); mPreviewLayoutChanged = false; } renderer.showPreviewFrame(); } else { renderer.alignFrameSync(); mMosaicFrameProcessor.processFrame(); } } } }; PowerManager pm = (PowerManager) mActivity.getSystemService(Context.POWER_SERVICE); mPartialWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Panorama"); mOrientationEventListener = new PanoOrientationEventListener(mActivity); mMosaicFrameProcessor = MosaicFrameProcessor.getInstance(); Resources appRes = mActivity.getResources(); mPreparePreviewString = appRes.getString(R.string.pano_dialog_prepare_preview); mDialogTitle = appRes.getString(R.string.pano_dialog_title); mDialogOkString = appRes.getString(R.string.dialog_ok); mDialogPanoramaFailedString = appRes.getString(R.string.pano_dialog_panorama_failed); mDialogWaitingPreviousString = appRes.getString(R.string.pano_dialog_waiting_previous); mPreferences = ComboPreferences.get(mActivity); if (mPreferences == null) { mPreferences = new ComboPreferences(mActivity); } mPreferences.setLocalId(mActivity, getPreferredCameraId(mPreferences)); CameraSettings.upgradeGlobalPreferences(mPreferences.getGlobal(), activity); mLocationManager = new LocationManager(mActivity, null); // Power shutter mActivity.initPowerShutter(mPreferences); mMainHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_LOW_RES_FINAL_MOSAIC_READY: onBackgroundThreadFinished(); saveFinalMosaic((Bitmap) msg.obj); saveHighResMosaic(); break; case MSG_GENERATE_FINAL_MOSAIC_ERROR: onBackgroundThreadFinished(); if (mPaused) { resetToPreviewIfPossible(); } else { mUI.showAlertDialog( mDialogTitle, mDialogPanoramaFailedString, mDialogOkString, new Runnable() { @Override public void run() { resetToPreviewIfPossible(); } }); } clearMosaicFrameProcessorIfNeeded(); break; case MSG_END_DIALOG_RESET_TO_PREVIEW: onBackgroundThreadFinished(); resetToPreviewIfPossible(); clearMosaicFrameProcessorIfNeeded(); break; case MSG_CLEAR_SCREEN_DELAY: mActivity.getWindow().clearFlags(WindowManager.LayoutParams. FLAG_KEEP_SCREEN_ON); break; case MSG_RESET_TO_PREVIEW: resetToPreviewIfPossible(); break; } } }; } @Override public void onPreviewFocusChanged(boolean previewFocused) { super.onPreviewFocusChanged(previewFocused); mPreviewFocused = previewFocused; } /** * Opens camera and sets the parameters. * * @return Whether the camera was opened successfully. */ private boolean setupCamera() { if (!openCamera()) { return false; } Parameters parameters = mCameraDevice.getParameters(); setupCaptureParams(parameters); configureCamera(parameters); return true; } private void releaseCamera() { if (mCameraDevice != null) { if (mActivity.isForceReleaseCamera()) { CameraHolder.instance().strongRelease(); } else { CameraHolder.instance().release(); } mCameraDevice.setErrorCallback(null); mCameraDevice = null; mCameraState = PREVIEW_STOPPED; } } /** * Opens the camera device. The back camera has priority over the front * one. * * @return Whether the camera was opened successfully. */ private boolean openCamera() { int cameraId = CameraHolder.instance().getBackCameraId(); // If there is no back camera, use the first camera. Camera id starts // from 0. Currently if a camera is not back facing, it is front facing. // This is also forward compatible if we have a new facing other than // back or front in the future. if (cameraId == -1) cameraId = 0; // If mCameraDevice has already exist,there is no need to obtain again if (mCameraDevice == null) { mCameraDevice = CameraUtil.openCamera(mActivity, cameraId, mMainHandler, mActivity.getCameraOpenErrorCallback()); if (mCameraDevice == null) { return false; } } mCameraOrientation = CameraUtil.getCameraOrientation(cameraId); if (cameraId == CameraHolder.instance().getFrontCameraId()) mUsingFrontCamera = true; return true; } private boolean findBestPreviewSize(List supportedSizes, boolean need4To3, boolean needSmaller) { int pixelsDiff = DEFAULT_CAPTURE_PIXELS; boolean hasFound = false; for (Size size : supportedSizes) { int h = size.height; int w = size.width; // we only want 4:3 format. int d = DEFAULT_CAPTURE_PIXELS - h * w; if (needSmaller && d < 0) { continue; } if (need4To3 && (h * 4 != w * 3)) { continue; } d = Math.abs(d); if (d < pixelsDiff) { mCameraPreviewWidth = w; mCameraPreviewHeight = h; pixelsDiff = d; hasFound = true; } } return hasFound; } private void setupCaptureParams(Parameters parameters) { List supportedSizes = parameters.getSupportedPreviewSizes(); if (!findBestPreviewSize(supportedSizes, true, true)) { Log.w(TAG, "No 4:3 ratio preview size supported."); if (!findBestPreviewSize(supportedSizes, false, true)) { Log.w(TAG, "Can't find a supported preview size smaller than 960x720."); findBestPreviewSize(supportedSizes, false, false); } } Log.d(TAG, "camera preview h = " + mCameraPreviewHeight + " , w = " + mCameraPreviewWidth); parameters.setPreviewSize(mCameraPreviewWidth, mCameraPreviewHeight); mUI.setPreviewSize(mCameraPreviewWidth, mCameraPreviewHeight); List frameRates = parameters.getSupportedPreviewFpsRange(); int last = frameRates.size() - 1; int minFps = (frameRates.get(last))[Parameters.PREVIEW_FPS_MIN_INDEX]; int maxFps = (frameRates.get(last))[Parameters.PREVIEW_FPS_MAX_INDEX]; parameters.setPreviewFpsRange(minFps, maxFps); Log.d(TAG, "preview fps: " + minFps + ", " + maxFps); List supportedFocusModes = parameters.getSupportedFocusModes(); if (supportedFocusModes.indexOf(mTargetFocusMode) >= 0) { parameters.setFocusMode(mTargetFocusMode); } else { // Use the default focus mode and log a message Log.w(TAG, "Cannot set the focus mode to " + mTargetFocusMode + " becuase the mode is not supported."); } parameters.set(CameraUtil.RECORDING_HINT, CameraUtil.FALSE); mHorizontalViewAngle = parameters.getHorizontalViewAngle(); mVerticalViewAngle = parameters.getVerticalViewAngle(); } public int getPreviewBufSize() { PixelFormat pixelInfo = new PixelFormat(); PixelFormat.getPixelFormatInfo(mCameraDevice.getParameters().getPreviewFormat(), pixelInfo); // TODO: remove this extra 32 byte after the driver bug is fixed. return (mCameraPreviewWidth * mCameraPreviewHeight * pixelInfo.bitsPerPixel / 8) + 32; } private void configureCamera(Parameters parameters) { mCameraDevice.setParameters(parameters); } /** * Configures the preview renderer according to the dimension defined by * {@code mPreviewUIWidth} and {@code mPreviewUIHeight}. * Will stop the camera preview first. */ private void configMosaicPreview() { if (mPreviewUIWidth == 0 || mPreviewUIHeight == 0 || mUI.getSurfaceTexture() == null) { return; } stopCameraPreview(); synchronized (mRendererLock) { if (mMosaicPreviewRenderer != null) { mMosaicPreviewRenderer.release(); } mMosaicPreviewRenderer = null; } final boolean isLandscape = (mDeviceOrientation / 90) % 2 == 1; final boolean enableWarpedPanoPreview = mActivity.getResources().getBoolean(R.bool.enable_warped_pano_preview); mUI.flipPreviewIfNeeded(); MosaicPreviewRenderer renderer = new MosaicPreviewRenderer( mUI.getSurfaceTexture(), mPreviewUIWidth, mPreviewUIHeight, isLandscape, mDeviceOrientation, enableWarpedPanoPreview); synchronized (mRendererLock) { mMosaicPreviewRenderer = renderer; mCameraTexture = mMosaicPreviewRenderer.getInputSurfaceTexture(); mRendererLock.notifyAll(); } mMosaicPreviewConfigured = true; resetToPreviewIfPossible(); } /** * Receives the layout change event from the preview area. So we can * initialize the mosaic preview renderer. */ @Override public void onPreviewUILayoutChange(int l, int t, int r, int b) { Log.d(TAG, "layout change: " + (r - l) + "/" + (b - t)); boolean capturePending = false; if (mCaptureState == CAPTURE_STATE_MOSAIC){ capturePending = true; } int width = r -l; int height = b - t; if (mPreviewUIWidth != width || mPreviewUIHeight != height || mCameraState != PREVIEW_ACTIVE) { mPreviewUIWidth = r - l; mPreviewUIHeight = b - t; configMosaicPreview(); } if (capturePending == true){ mMainHandler.post(new Runnable() { @Override public void run() { if (!mPaused){ mMainHandler.removeMessages(MSG_RESET_TO_PREVIEW); startCapture(); } } }); } } @Override public void onFrameAvailable(SurfaceTexture surface) { /* This function may be called by some random thread, * so let's be safe and jump back to ui thread. * No OpenGL calls can be done here. */ mActivity.runOnUiThread(mOnFrameAvailableRunnable); } public void startCapture() { // Reset values so we can do this again. mCancelComputation = false; mTimeTaken = System.currentTimeMillis(); mActivity.setSwipingEnabled(false); mCaptureState = CAPTURE_STATE_MOSAIC; mUI.onStartCapture(); Parameters parameters = mCameraDevice.getParameters(); parameters.setAutoExposureLock(true); parameters.setAutoWhiteBalanceLock(true); configureCamera(parameters); mMosaicFrameProcessor.setProgressListener(new MosaicFrameProcessor.ProgressListener() { @Override public void onProgress(boolean isFinished, float panningRateX, float panningRateY, float progressX, float progressY) { float accumulatedHorizontalAngle = progressX * mHorizontalViewAngle; float accumulatedVerticalAngle = progressY * mVerticalViewAngle; boolean isRotated = !(mDeviceOrientationAtCapture == mDeviceOrientation); if (isFinished || (Math.abs(accumulatedHorizontalAngle) >= DEFAULT_SWEEP_ANGLE) || (Math.abs(accumulatedVerticalAngle) >= DEFAULT_SWEEP_ANGLE) || isRotated) { stopCapture(false); } else { float panningRateXInDegree = panningRateX * mHorizontalViewAngle; float panningRateYInDegree = panningRateY * mVerticalViewAngle; if (mDeviceOrientation == 180 || mDeviceOrientation == 90) { accumulatedHorizontalAngle = -accumulatedHorizontalAngle; accumulatedVerticalAngle = -accumulatedVerticalAngle; } mUI.updateCaptureProgress(panningRateXInDegree, panningRateYInDegree, accumulatedHorizontalAngle, accumulatedVerticalAngle, PANNING_SPEED_THRESHOLD); } } }); mUI.resetCaptureProgress(); // TODO: calculate the indicator width according to different devices to reflect the actual // angle of view of the camera device. mUI.setMaxCaptureProgress(DEFAULT_SWEEP_ANGLE); mUI.showCaptureProgress(); mDeviceOrientationAtCapture = mDeviceOrientation; keepScreenOn(); mOrientationLocked = true; int degrees = CameraUtil.getDisplayRotation(mActivity); int cameraId = CameraHolder.instance().getBackCameraId(); int orientation = CameraUtil.getDisplayOrientation(degrees, cameraId); mUI.setProgressOrientation(orientation); } private void stopCapture(boolean aborted) { mDirectionChanged = false; mCaptureState = CAPTURE_STATE_VIEWFINDER; mUI.onStopCapture(); Parameters parameters = mCameraDevice.getParameters(); parameters.setAutoExposureLock(false); parameters.setAutoWhiteBalanceLock(false); configureCamera(parameters); mMosaicFrameProcessor.setProgressListener(null); stopCameraPreview(); mCameraTexture.setOnFrameAvailableListener(null); if (!aborted && !mThreadRunning) { mUI.showWaitingDialog(mPreparePreviewString); // Hide shutter button, shutter icon, etc when waiting for // panorama to stitch mUI.hideUI(); runBackgroundThread(new Thread() { @Override public void run() { MosaicJpeg jpeg = generateFinalMosaic(false); if (jpeg != null && jpeg.isValid) { Bitmap bitmap = null; bitmap = BitmapFactory.decodeByteArray(jpeg.data, 0, jpeg.data.length); mMainHandler.sendMessage(mMainHandler.obtainMessage( MSG_LOW_RES_FINAL_MOSAIC_READY, bitmap)); } else { mMainHandler.sendMessage(mMainHandler.obtainMessage( MSG_END_DIALOG_RESET_TO_PREVIEW)); } } }); } keepScreenOnAwhile(); } @Override public void onShutterButtonClick() { // If mCameraTexture == null then GL setup is not finished yet. // No buttons can be pressed. if (mPaused || mThreadRunning || mCameraTexture == null) { return; } // Since this button will stay on the screen when capturing, we need to check the state // right now. switch (mCaptureState) { case CAPTURE_STATE_VIEWFINDER: final long storageSpaceBytes = mActivity.getStorageSpaceBytes(); if(storageSpaceBytes <= Storage.LOW_STORAGE_THRESHOLD_BYTES) { Log.w(TAG, "Low storage warning: " + storageSpaceBytes); return; } mSoundPlayer.play(SoundClips.START_VIDEO_RECORDING); startCapture(); break; case CAPTURE_STATE_MOSAIC: mSoundPlayer.play(SoundClips.STOP_VIDEO_RECORDING); stopCapture(false); break; default: Log.w(TAG, "Unknown capture state: " + mCaptureState); break; } } public void reportProgress() { mUI.showUI(); mUI.resetSavingProgress(); Thread t = new Thread() { @Override public void run() { while (mThreadRunning) { final int progress = mMosaicFrameProcessor.reportProgress( true, mCancelComputation); try { synchronized (mWaitObject) { mWaitObject.wait(50); } } catch (InterruptedException e) { throw new RuntimeException("Panorama reportProgress failed", e); } // Update the progress bar mActivity.runOnUiThread(new Runnable() { @Override public void run() { mUI.updateSavingProgress(progress); } }); } } }; t.start(); } private int getCaptureOrientation() { // The panorama image returned from the library is oriented based on the // natural orientation of a camera. We need to set an orientation for the image // in its EXIF header, so the image can be displayed correctly. // The orientation is calculated from compensating the // device orientation at capture and the camera orientation respective to // the natural orientation of the device. int orientation; if (mUsingFrontCamera) { // mCameraOrientation is negative with respect to the front facing camera. // See document of android.hardware.Camera.Parameters.setRotation. orientation = (mDeviceOrientationAtCapture - mCameraOrientation - 360) % 360; } else { orientation = (mDeviceOrientationAtCapture + mCameraOrientation) % 360; } return orientation; } /** The orientation of the camera image. The value is the angle that the camera * image needs to be rotated clockwise so it shows correctly on the display * in its natural orientation. It should be 0, 90, 180, or 270.*/ public int getCameraOrientation() { return mCameraOrientation; } public void saveHighResMosaic() { runBackgroundThread(new Thread() { @Override public void run() { mPartialWakeLock.acquire(); MosaicJpeg jpeg; try { jpeg = generateFinalMosaic(true); } finally { mPartialWakeLock.release(); } if (jpeg == null) { // Cancelled by user. mMainHandler.sendEmptyMessage(MSG_END_DIALOG_RESET_TO_PREVIEW); } else if (!jpeg.isValid) { // Error when generating mosaic. mMainHandler.sendEmptyMessage(MSG_GENERATE_FINAL_MOSAIC_ERROR); } else { int orientation = getCaptureOrientation(); final Uri uri = savePanorama(jpeg.data, jpeg.width, jpeg.height, orientation); if (uri != null) { mActivity.runOnUiThread(new Runnable() { @Override public void run() { mUI.showFinalMosaic(); mActivity.notifyNewMedia(uri); } }); } mMainHandler.sendMessage( mMainHandler.obtainMessage(MSG_END_DIALOG_RESET_TO_PREVIEW)); } } }); reportProgress(); } private void runBackgroundThread(Thread thread) { mThreadRunning = true; thread.start(); } private void onBackgroundThreadFinished() { mThreadRunning = false; mUI.dismissAllDialogs(); } private void cancelHighResComputation() { mCancelComputation = true; synchronized (mWaitObject) { mWaitObject.notify(); } } // This function will be called upon the first camera frame is available. private void reset() { mCaptureState = CAPTURE_STATE_VIEWFINDER; mDirectionChanged = false; mOrientationLocked = false; mUI.setOrientation(mDeviceOrientation, true); mUI.reset(); mActivity.setSwipingEnabled(true); // Orientation change will trigger onLayoutChange->configMosaicPreview-> // resetToPreview. Do not show the capture UI in film strip. if (mPreviewFocused) { mUI.showPreviewUI(); } mMosaicFrameProcessor.reset(); } private void resetToPreviewIfPossible() { reset(); if (!mMosaicFrameProcessorInitialized || mUI.getSurfaceTexture() == null || !mMosaicPreviewConfigured) { return; } if (!mPaused) { startCameraPreview(); } } private void saveFinalMosaic(Bitmap bitmap) { mUI.saveFinalMosaic(bitmap, getCaptureOrientation()); } private Uri savePanorama(byte[] jpegData, int width, int height, int orientation) { if (jpegData != null) { String filename = PanoUtil.createName( mActivity.getResources().getString(R.string.pano_file_name_format), mTimeTaken); String filepath = Storage.generateFilepath(filename, PhotoModule.PIXEL_FORMAT_JPEG); UsageStatistics.onEvent(UsageStatistics.COMPONENT_PANORAMA, UsageStatistics.ACTION_CAPTURE_DONE, null, 0, UsageStatistics.hashFileName(filename + ".jpg")); Location loc = mLocationManager.getCurrentLocation(); ExifInterface exif = new ExifInterface(); try { exif.readExif(jpegData); exif.addMakeAndModelTag(); exif.addGpsDateTimeStampTag(mTimeTaken); exif.addDateTimeStampTag(ExifInterface.TAG_DATE_TIME, mTimeTaken, TimeZone.getDefault()); exif.setTag(exif.buildTag(ExifInterface.TAG_ORIENTATION, ExifInterface.getOrientationValueForRotation(orientation))); writeLocation(loc, exif); exif.writeExif(jpegData, filepath); } catch (IOException e) { Log.e(TAG, "Cannot set exif for " + filepath, e); Storage.writeFile(filepath, jpegData); } int jpegLength = (int) (new File(filepath).length()); return Storage.addImage(mContentResolver, filename, mTimeTaken, loc, orientation, jpegLength, filepath, width, height, LocalData.MIME_TYPE_JPEG); } return null; } private static void writeLocation(Location location, ExifInterface exif) { if (location == null) { return; } exif.addGpsTags(location.getLatitude(), location.getLongitude()); exif.setTag(exif.buildTag(ExifInterface.TAG_GPS_PROCESSING_METHOD, location.getProvider())); } private void clearMosaicFrameProcessorIfNeeded() { if (!mPaused || mThreadRunning) return; // Only clear the processor if it is initialized by this activity // instance. Other activity instances may be using it. if (mMosaicFrameProcessorInitialized) { mMosaicFrameProcessor.clear(); mMosaicFrameProcessorInitialized = false; } } private void initMosaicFrameProcessorIfNeeded() { if (mPaused || mThreadRunning) { return; } int perct = 100; final ActivityManager am = (ActivityManager) mActivity.getSystemService(Context.ACTIVITY_SERVICE); if (am.isLowRamDevice()) { perct = mActivity.getResources().getInteger(R.integer.panorama_frame_size_reduction); } int width = (mCameraPreviewWidth * perct) / 100; int height = (mCameraPreviewHeight * perct) / 100; if ((0 < width) && (0 < height)) { mMosaicFrameProcessor.initialize(width, height, getPreviewBufSize()); mMosaicFrameProcessorInitialized = true; } else { throw new RuntimeException("Invalid preview dimension"); } } @Override public void waitingLocationPermissionResult(boolean result) { mLocationManager.waitingLocationPermissionResult(result); } @Override public void enableRecordingLocation(boolean enable) { String value = (enable ? RecordLocationPreference.VALUE_ON : RecordLocationPreference.VALUE_OFF); if (mPreferences != null) { mPreferences.edit() .putString(CameraSettings.KEY_RECORD_LOCATION, value) .apply(); } mLocationManager.recordLocation(enable); } @Override public void onPauseBeforeSuper() { mPaused = true; if (mLocationManager != null) mLocationManager.recordLocation(false); mOrientationManager.pause(); } @Override public void onPauseAfterSuper() { mOrientationEventListener.disable(); if (mCameraDevice == null) { // Camera open failed. Nothing should be done here. return; } // Stop the capturing first. if (mCaptureState == CAPTURE_STATE_MOSAIC) { stopCapture(true); reset(); } mUI.showPreviewCover(); releaseCamera(); // Load the power shutter mActivity.initPowerShutter(mPreferences); synchronized (mRendererLock) { mCameraTexture = null; // The preview renderer might not have a chance to be initialized // before onPause(). if (mMosaicPreviewRenderer != null) { mMosaicPreviewRenderer.release(); mMosaicPreviewRenderer = null; } } clearMosaicFrameProcessorIfNeeded(); if (mWaitProcessorTask != null) { mWaitProcessorTask.cancel(true); mWaitProcessorTask = null; } resetScreenOn(); mUI.removeDisplayChangeListener(); if (mSoundPlayer != null) { mSoundPlayer.release(); mSoundPlayer = null; } System.gc(); } @Override public void onConfigurationChanged(Configuration newConfig) { mUI.onConfigurationChanged(newConfig, mThreadRunning); } @Override public void onOrientationChanged(int orientation) { } @Override public void resizeForPreviewAspectRatio() { } @Override public void onSwitchSavePath() { mPreferences.getGlobal().edit().putString(CameraSettings.KEY_CAMERA_SAVEPATH, "1").apply(); RotateTextToast.makeText(mActivity, R.string.on_switch_save_path_to_sdcard, Toast.LENGTH_SHORT).show(); } @Override public void onResumeBeforeSuper() { mPaused = false; mPreferences = ComboPreferences.get(mActivity); if (mPreferences == null) { mPreferences = new ComboPreferences(mActivity); } CameraSettings.upgradeGlobalPreferences(mPreferences.getGlobal(), mActivity); mPreferences.setLocalId(mActivity, getPreferredCameraId(mPreferences)); CameraSettings.upgradeLocalPreferences(mPreferences.getLocal()); } @Override public void onResumeAfterSuper() { mOrientationEventListener.enable(); mCaptureState = CAPTURE_STATE_VIEWFINDER; if (!setupCamera()) { CameraUtil.showErrorAndFinish(mActivity, R.string.cannot_connect_camera); Log.e(TAG, "Failed to open camera, aborting"); return; } // Set up sound playback for shutter button mSoundPlayer = SoundClips.getPlayer(mActivity); // Check if another panorama instance is using the mosaic frame processor. mUI.dismissAllDialogs(); if (mThreadRunning && mMosaicFrameProcessor.isMosaicMemoryAllocated()) { mUI.showWaitingDialog(mDialogWaitingPreviousString); // If stitching is still going on, make sure switcher and shutter button // are not showing mUI.hideUI(); mWaitProcessorTask = new WaitProcessorTask().execute(); } else { // Camera must be initialized before MosaicFrameProcessor is // initialized. The preview size has to be decided by camera device. if (! mMosaicFrameProcessorInitialized) { initMosaicFrameProcessorIfNeeded(); } Point size = mUI.getPreviewAreaSize(); mPreviewUIWidth = size.x; mPreviewUIHeight = size.y; configMosaicPreview(); mMainHandler.post(new Runnable(){ @Override public void run(){ mActivity.updateStorageSpaceAndHint(); } }); } mUI.setSwitcherIndex(); keepScreenOnAwhile(); mOrientationManager.resume(); // Initialize location service. boolean recordLocation = RecordLocationPreference.get(mPreferences); mLocationManager.recordLocation(recordLocation); mUI.initDisplayChangeListener(); UsageStatistics.onContentViewChanged( UsageStatistics.COMPONENT_CAMERA, "PanoramaModule"); } /** * Generate the final mosaic image. * * @param highRes flag to indicate whether we want to get a high-res version. * @return a MosaicJpeg with its isValid flag set to true if successful; null if the generation * process is cancelled; and a MosaicJpeg with its isValid flag set to false if there * is an error in generating the final mosaic. */ public MosaicJpeg generateFinalMosaic(boolean highRes) { int mosaicReturnCode = mMosaicFrameProcessor.createMosaic(highRes); if (mosaicReturnCode == Mosaic.MOSAIC_RET_CANCELLED) { return null; } else if (mosaicReturnCode == Mosaic.MOSAIC_RET_ERROR) { return new MosaicJpeg(); } byte[] imageData = mMosaicFrameProcessor.getFinalMosaicNV21(); if (imageData == null) { Log.e(TAG, "getFinalMosaicNV21() returned null."); return new MosaicJpeg(); } int len = imageData.length - 8; int width = (imageData[len + 0] << 24) + ((imageData[len + 1] & 0xFF) << 16) + ((imageData[len + 2] & 0xFF) << 8) + (imageData[len + 3] & 0xFF); int height = (imageData[len + 4] << 24) + ((imageData[len + 5] & 0xFF) << 16) + ((imageData[len + 6] & 0xFF) << 8) + (imageData[len + 7] & 0xFF); Log.d(TAG, "ImLength = " + (len) + ", W = " + width + ", H = " + height); if (width <= 0 || height <= 0) { // TODO: pop up an error message indicating that the final result is not generated. Log.e(TAG, "width|height <= 0!!, len = " + (len) + ", W = " + width + ", H = " + height); return new MosaicJpeg(); } YuvImage yuvimage = new YuvImage(imageData, ImageFormat.NV21, width, height, null); ByteArrayOutputStream out = new ByteArrayOutputStream(); yuvimage.compressToJpeg(new Rect(0, 0, width, height), 100, out); try { out.close(); } catch (Exception e) { Log.e(TAG, "Exception in storing final mosaic", e); return new MosaicJpeg(); } return new MosaicJpeg(out.toByteArray(), width, height); } private void startCameraPreview() { if (mCameraDevice == null) { // Camera open failed. Return. return; } if (mUI.getSurfaceTexture() == null) { // UI is not ready. return; } mErrorCallback.setActivity(mActivity); mCameraDevice.setErrorCallback(mErrorCallback); // This works around a driver issue. startPreview may fail if // stopPreview/setPreviewTexture/startPreview are called several times // in a row. mCameraTexture can be null after pressing home during // mosaic generation and coming back. Preview will be started later in // onLayoutChange->configMosaicPreview. This also reduces the latency. synchronized (mRendererLock) { if (mCameraTexture == null) return; // If we're previewing already, stop the preview first (this will // blank the screen). if (mCameraState != PREVIEW_STOPPED) stopCameraPreview(); // Set the display orientation to 0, so that the underlying mosaic // library can always get undistorted mCameraPreviewWidth x mCameraPreviewHeight // image data from SurfaceTexture. // as Panoroma will add 90 degree rotation compensation during // postprocessing, we need to consider both camera mount angle and // this compensation angle mCameraDevice.setDisplayOrientation(0); if (mCameraTexture != null) mCameraTexture.setOnFrameAvailableListener(this); mCameraDevice.setPreviewTexture(mCameraTexture); } mCameraDevice.startPreview(); mCameraState = PREVIEW_ACTIVE; } private void stopCameraPreview() { if (mCameraDevice != null && mCameraState != PREVIEW_STOPPED) { mCameraDevice.stopPreview(); } mCameraState = PREVIEW_STOPPED; } @Override public void onUserInteraction() { if (mCaptureState != CAPTURE_STATE_MOSAIC) keepScreenOnAwhile(); } @Override public boolean onBackPressed() { // If panorama is generating low res or high res mosaic, ignore back // key. So the activity will not be destroyed. if (mThreadRunning) return true; return false; } private void resetScreenOn() { mMainHandler.removeMessages(MSG_CLEAR_SCREEN_DELAY); mActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); } private void keepScreenOnAwhile() { mMainHandler.removeMessages(MSG_CLEAR_SCREEN_DELAY); mActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); mMainHandler.sendEmptyMessageDelayed(MSG_CLEAR_SCREEN_DELAY, SCREEN_DELAY); } private void keepScreenOn() { mMainHandler.removeMessages(MSG_CLEAR_SCREEN_DELAY); mActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); } private class WaitProcessorTask extends AsyncTask { @Override protected Void doInBackground(Void... params) { synchronized (mMosaicFrameProcessor) { while (!isCancelled() && mMosaicFrameProcessor.isMosaicMemoryAllocated()) { try { mMosaicFrameProcessor.wait(); } catch (Exception e) { // ignore } } } mActivity.updateStorageSpace(); return null; } @Override protected void onPostExecute(Void result) { mWaitProcessorTask = null; mUI.dismissAllDialogs(); // TODO (shkong): mGLRootView.setVisibility(View.VISIBLE); initMosaicFrameProcessorIfNeeded(); Point size = mUI.getPreviewAreaSize(); mPreviewUIWidth = size.x; mPreviewUIHeight = size.y; configMosaicPreview(); resetToPreviewIfPossible(); mActivity.updateStorageHint(mActivity.getStorageSpaceBytes()); } } @Override public void cancelHighResStitching() { if (mPaused) return; cancelHighResComputation(); } @Override public void onStop() { } @Override public void installIntentFilter() { } @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { } @Override public boolean onKeyDown(int keyCode, KeyEvent event) { // Do not handle any key if the activity is paused // or not in active camera/video mode if (mPaused) { return true; } else if (!mActivity.isInCameraApp()) { return false; } switch (keyCode) { case KeyEvent.KEYCODE_VOLUME_UP: case KeyEvent.KEYCODE_VOLUME_DOWN: case KeyEvent.KEYCODE_MEDIA_NEXT: case KeyEvent.KEYCODE_MEDIA_PREVIOUS: return true; case KeyEvent.KEYCODE_CAMERA: case KeyEvent.KEYCODE_HEADSETHOOK: if (event.getRepeatCount() == 0) { onShutterButtonClick(); } return true; case KeyEvent.KEYCODE_POWER: return true; } return false; } @Override public boolean onKeyUp(int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_VOLUME_UP: case KeyEvent.KEYCODE_VOLUME_DOWN: case KeyEvent.KEYCODE_MEDIA_NEXT: case KeyEvent.KEYCODE_MEDIA_PREVIOUS: if (!CameraActivity.mPowerShutter && !CameraUtil.hasCameraKey()) { onShutterButtonClick(); } return true; case KeyEvent.KEYCODE_POWER: if (CameraActivity.mPowerShutter && !CameraUtil.hasCameraKey()) { onShutterButtonClick(); } return true; } return false; } @Override public void onSingleTapUp(View view, int x, int y) { } @Override public void onPreviewTextureCopied() { } @Override public void onCaptureTextureCopied() { } @Override public boolean updateStorageHintOnResume() { return false; } @Override public void onShowSwitcherPopup() { } @Override public void onMediaSaveServiceConnected(MediaSaveService s) { // do nothing. } }