| /* |
| * Copyright (C) 2012 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.ActionBar; |
| import android.app.Activity; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.ServiceConnection; |
| import android.content.SharedPreferences; |
| import android.content.pm.ActivityInfo; |
| import android.content.res.Configuration; |
| import android.graphics.drawable.ColorDrawable; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.preference.PreferenceManager; |
| import android.provider.MediaStore; |
| import android.provider.Settings; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.Menu; |
| import android.view.MenuInflater; |
| import android.view.MenuItem; |
| import android.view.OrientationEventListener; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.Window; |
| import android.view.WindowManager; |
| import android.widget.FrameLayout; |
| import android.widget.ImageView; |
| import android.widget.ProgressBar; |
| import android.widget.ShareActionProvider; |
| |
| import com.android.camera.app.AppManagerFactory; |
| import com.android.camera.app.PanoramaStitchingManager; |
| import com.android.camera.data.CameraDataAdapter; |
| import com.android.camera.data.CameraPreviewData; |
| import com.android.camera.data.FixedFirstDataAdapter; |
| import com.android.camera.data.FixedLastDataAdapter; |
| import com.android.camera.data.LocalData; |
| import com.android.camera.data.LocalDataAdapter; |
| import com.android.camera.data.MediaDetails; |
| import com.android.camera.data.SimpleViewData; |
| import com.android.camera.ui.ModuleSwitcher; |
| import com.android.camera.ui.DetailsDialog; |
| import com.android.camera.ui.FilmStripView; |
| import com.android.camera.util.ApiHelper; |
| import com.android.camera.util.CameraUtil; |
| import com.android.camera.util.PhotoSphereHelper; |
| import com.android.camera.util.PhotoSphereHelper.PanoramaViewHelper; |
| import com.android.camera2.R; |
| |
| public class CameraActivity extends Activity |
| implements ModuleSwitcher.ModuleSwitchListener { |
| |
| private static final String TAG = "CAM_Activity"; |
| |
| private static final String INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE = |
| "android.media.action.STILL_IMAGE_CAMERA_SECURE"; |
| public static final String ACTION_IMAGE_CAPTURE_SECURE = |
| "android.media.action.IMAGE_CAPTURE_SECURE"; |
| public static final String ACTION_TRIM_VIDEO = |
| "com.android.camera.action.TRIM"; |
| public static final String MEDIA_ITEM_PATH = "media-item-path"; |
| |
| private static final String PREF_STARTUP_MODULE_INDEX = "camera.startup_module"; |
| |
| // The intent extra for camera from secure lock screen. True if the gallery |
| // should only show newly captured pictures. sSecureAlbumId does not |
| // increment. This is used when switching between camera, camcorder, and |
| // panorama. If the extra is not set, it is in the normal camera mode. |
| public static final String SECURE_CAMERA_EXTRA = "secure_camera"; |
| |
| // Supported operations at FilmStripView. Different data has different |
| // set of supported operations. |
| private static final int SUPPORT_DELETE = 1 << 0; |
| private static final int SUPPORT_ROTATE = 1 << 1; |
| private static final int SUPPORT_INFO = 1 << 2; |
| private static final int SUPPORT_CROP = 1 << 3; |
| private static final int SUPPORT_SETAS = 1 << 4; |
| private static final int SUPPORT_EDIT = 1 << 5; |
| private static final int SUPPORT_TRIM = 1 << 6; |
| private static final int SUPPORT_SHARE = 1 << 7; |
| private static final int SUPPORT_SHARE_PANORAMA360 = 1 << 8; |
| private static final int SUPPORT_SHOW_ON_MAP = 1 << 9; |
| private static final int SUPPORT_ALL = 0xffffffff; |
| |
| /** This data adapter is used by FilmStripView. */ |
| private LocalDataAdapter mDataAdapter; |
| /** This data adapter represents the real local camera data. */ |
| private LocalDataAdapter mWrappedDataAdapter; |
| |
| private PanoramaStitchingManager mPanoramaManager; |
| private int mCurrentModuleIndex; |
| private CameraModule mCurrentModule; |
| private FrameLayout mLayoutRoot; |
| private FrameLayout mAboveFilmstripControlLayout; |
| private View mCameraModuleRootView; |
| private FilmStripView mFilmStripView; |
| private ProgressBar mBottomProgress; |
| private View mPanoStitchingPanel; |
| private int mResultCodeForTesting; |
| private Intent mResultDataForTesting; |
| private OnScreenHint mStorageHint; |
| private long mStorageSpace = Storage.LOW_STORAGE_THRESHOLD; |
| private boolean mAutoRotateScreen; |
| private boolean mSecureCamera; |
| // This is a hack to speed up the start of SecureCamera. |
| private static boolean sFirstStartAfterScreenOn = true; |
| private int mLastRawOrientation; |
| private MyOrientationEventListener mOrientationListener; |
| private Handler mMainHandler; |
| private PanoramaViewHelper mPanoramaViewHelper; |
| private CameraPreviewData mCameraPreviewData; |
| private ActionBar mActionBar; |
| private Menu mActionBarMenu; |
| private ViewGroup mUndoDeletionBar; |
| |
| private ShareActionProvider mStandardShareActionProvider; |
| private Intent mStandardShareIntent; |
| private ShareActionProvider mPanoramaShareActionProvider; |
| private Intent mPanoramaShareIntent; |
| |
| public void gotoGallery() { |
| mFilmStripView.getController().goToNextItem(); |
| } |
| |
| private class MyOrientationEventListener |
| extends OrientationEventListener { |
| public MyOrientationEventListener(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; |
| mLastRawOrientation = orientation; |
| mCurrentModule.onOrientationChanged(orientation); |
| } |
| } |
| |
| private MediaSaveService mMediaSaveService; |
| private ServiceConnection mConnection = new ServiceConnection() { |
| @Override |
| public void onServiceConnected(ComponentName className, IBinder b) { |
| mMediaSaveService = ((MediaSaveService.LocalBinder) b).getService(); |
| mCurrentModule.onMediaSaveServiceConnected(mMediaSaveService); |
| } |
| @Override |
| public void onServiceDisconnected(ComponentName className) { |
| if (mMediaSaveService != null) { |
| mMediaSaveService.setListener(null); |
| mMediaSaveService = null; |
| } |
| }}; |
| |
| // close activity when screen turns off |
| private BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| finish(); |
| } |
| }; |
| |
| private static BroadcastReceiver sScreenOffReceiver; |
| private static class ScreenOffReceiver extends BroadcastReceiver { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| sFirstStartAfterScreenOn = true; |
| } |
| } |
| |
| public static boolean isFirstStartAfterScreenOn() { |
| return sFirstStartAfterScreenOn; |
| } |
| |
| public static void resetFirstStartAfterScreenOn() { |
| sFirstStartAfterScreenOn = false; |
| } |
| |
| private FilmStripView.Listener mFilmStripListener = |
| new FilmStripView.Listener() { |
| @Override |
| public void onDataPromoted(int dataID) { |
| removeData(dataID); |
| } |
| |
| @Override |
| public void onDataDemoted(int dataID) { |
| removeData(dataID); |
| } |
| |
| @Override |
| public void onDataFullScreenChange(int dataID, boolean full) { |
| } |
| |
| @Override |
| public void onSwitchMode(boolean toCamera) { |
| mCurrentModule.onSwitchMode(toCamera); |
| if (toCamera) { |
| mActionBar.hide(); |
| } else { |
| mActionBar.show(); |
| } |
| } |
| |
| @Override |
| public void onCurrentDataChanged(int dataID, boolean current) { |
| if (!current) { |
| hidePanoStitchingProgress(); |
| } else { |
| LocalData currentData = mDataAdapter.getLocalData(dataID); |
| if (currentData == null) { |
| Log.w(TAG, "Current data ID not found."); |
| hidePanoStitchingProgress(); |
| return; |
| } |
| |
| if (currentData.getLocalDataType() == |
| LocalData.LOCAL_CAMERA_PREVIEW) { |
| // Don't show the action bar in Camera preview. |
| mActionBar.hide(); |
| } else { |
| updateActionBarMenu(dataID); |
| } |
| |
| Uri contentUri = currentData.getContentUri(); |
| if (contentUri == null) { |
| hidePanoStitchingProgress(); |
| return; |
| } |
| int panoStitchingProgress = mPanoramaManager.getTaskProgress(contentUri); |
| if (panoStitchingProgress < 0) { |
| hidePanoStitchingProgress(); |
| return; |
| } |
| showPanoStitchingProgress(); |
| updateStitchingProgress(panoStitchingProgress); |
| } |
| } |
| |
| @Override |
| public boolean onToggleActionBarVisibility() { |
| if (mActionBar.isShowing()) { |
| mActionBar.hide(); |
| } else { |
| // In the preview, don't show the action bar if that is |
| // a capture intent. |
| if (!isCaptureIntent()) { |
| mActionBar.show(); |
| } |
| } |
| return mActionBar.isShowing(); |
| } |
| }; |
| |
| private void hidePanoStitchingProgress() { |
| mPanoStitchingPanel.setVisibility(View.GONE); |
| } |
| |
| private void showPanoStitchingProgress() { |
| mPanoStitchingPanel.setVisibility(View.VISIBLE); |
| } |
| |
| private void updateStitchingProgress(int progress) { |
| mBottomProgress.setProgress(progress); |
| } |
| |
| private void setStandardShareIntent(Uri contentUri, String mimeType) { |
| if (mStandardShareIntent == null) { |
| mStandardShareIntent = new Intent(Intent.ACTION_SEND); |
| } |
| mStandardShareIntent.setType(mimeType); |
| mStandardShareIntent.putExtra(Intent.EXTRA_STREAM, contentUri); |
| if (mStandardShareActionProvider != null) { |
| mStandardShareActionProvider.setShareIntent(mStandardShareIntent); |
| } |
| } |
| |
| private void setPanoramaShareIntent(Uri contentUri) { |
| if (mPanoramaShareIntent == null) { |
| mPanoramaShareIntent = new Intent(Intent.ACTION_SEND); |
| } |
| mPanoramaShareIntent.setType("application/vnd.google.panorama360+jpg"); |
| mPanoramaShareIntent.putExtra(Intent.EXTRA_STREAM, contentUri); |
| if (mPanoramaShareActionProvider != null) { |
| mPanoramaShareActionProvider.setShareIntent(mPanoramaShareIntent); |
| } |
| } |
| |
| /** |
| * According to the data type, make the menu items for supported operations |
| * visible. |
| * @param dataID the data ID of the current item. |
| */ |
| private void updateActionBarMenu(int dataID) { |
| LocalData currentData = mDataAdapter.getLocalData(dataID); |
| int type = currentData.getLocalDataType(); |
| |
| if (mActionBarMenu == null) { |
| return; |
| } |
| |
| int supported = 0; |
| switch (type) { |
| case LocalData.LOCAL_IMAGE: |
| supported |= SUPPORT_DELETE | SUPPORT_ROTATE | SUPPORT_INFO |
| | SUPPORT_CROP | SUPPORT_SETAS | SUPPORT_EDIT |
| | SUPPORT_SHARE | SUPPORT_SHOW_ON_MAP; |
| break; |
| case LocalData.LOCAL_VIDEO: |
| supported |= SUPPORT_DELETE | SUPPORT_INFO | SUPPORT_TRIM |
| | SUPPORT_SHARE; |
| break; |
| case LocalData.LOCAL_PHOTO_SPHERE: |
| supported |= SUPPORT_DELETE | SUPPORT_ROTATE | SUPPORT_INFO |
| | SUPPORT_CROP | SUPPORT_SETAS | SUPPORT_EDIT |
| | SUPPORT_SHARE | SUPPORT_SHOW_ON_MAP; |
| break; |
| case LocalData.LOCAL_360_PHOTO_SPHERE: |
| supported |= SUPPORT_DELETE | SUPPORT_ROTATE | SUPPORT_INFO |
| | SUPPORT_CROP | SUPPORT_SETAS | SUPPORT_EDIT |
| | SUPPORT_SHARE | SUPPORT_SHARE_PANORAMA360 |
| | SUPPORT_SHOW_ON_MAP; |
| break; |
| default: |
| break; |
| } |
| |
| setMenuItemVisible(mActionBarMenu, R.id.action_delete, |
| (supported & SUPPORT_DELETE) != 0); |
| setMenuItemVisible(mActionBarMenu, R.id.action_rotate_ccw, |
| (supported & SUPPORT_ROTATE) != 0); |
| setMenuItemVisible(mActionBarMenu, R.id.action_rotate_cw, |
| (supported & SUPPORT_ROTATE) != 0); |
| setMenuItemVisible(mActionBarMenu, R.id.action_details, |
| (supported & SUPPORT_INFO) != 0); |
| setMenuItemVisible(mActionBarMenu, R.id.action_crop, |
| (supported & SUPPORT_CROP) != 0); |
| setMenuItemVisible(mActionBarMenu, R.id.action_setas, |
| (supported & SUPPORT_SETAS) != 0); |
| setMenuItemVisible(mActionBarMenu, R.id.action_edit, |
| (supported & SUPPORT_EDIT) != 0); |
| setMenuItemVisible(mActionBarMenu, R.id.action_trim, |
| (supported & SUPPORT_TRIM) != 0); |
| |
| if ((supported & SUPPORT_SHARE) != 0) { |
| setMenuItemVisible(mActionBarMenu, R.id.action_share, true); |
| setStandardShareIntent(currentData.getContentUri(), currentData.getMimeType()); |
| } |
| if ((supported & SUPPORT_SHARE_PANORAMA360) != 0) { |
| setMenuItemVisible(mActionBarMenu, R.id.action_share_panorama, true); |
| setPanoramaShareIntent(currentData.getContentUri()); |
| } |
| |
| boolean itemHasLocation = currentData.getLatLong() != null; |
| setMenuItemVisible(mActionBarMenu, R.id.action_show_on_map, |
| itemHasLocation && (supported & SUPPORT_SHOW_ON_MAP) != 0); |
| } |
| |
| private void setMenuItemVisible(Menu menu, int itemId, boolean visible) { |
| MenuItem item = menu.findItem(itemId); |
| if (item != null) |
| item.setVisible(visible); |
| } |
| |
| private Runnable mDeletionRunnable = new Runnable() { |
| @Override |
| public void run() { |
| hideUndoDeletionBar(); |
| mDataAdapter.executeDeletion(CameraActivity.this); |
| } |
| }; |
| |
| private ImageTaskManager.TaskListener mStitchingListener = |
| new ImageTaskManager.TaskListener() { |
| @Override |
| public void onTaskQueued(String filePath, final Uri imageUri) { |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| notifyNewMedia(imageUri); |
| } |
| }); |
| } |
| |
| @Override |
| public void onTaskDone(String filePath, final Uri imageUri) { |
| Log.v(TAG, "onTaskDone:" + filePath); |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| int doneID = mDataAdapter.findDataByContentUri(imageUri); |
| int currentDataId = mFilmStripView.getCurrentId(); |
| |
| if (currentDataId == doneID) { |
| hidePanoStitchingProgress(); |
| updateStitchingProgress(0); |
| } |
| |
| mDataAdapter.refresh(getContentResolver(), imageUri); |
| } |
| }); |
| } |
| |
| @Override |
| public void onTaskProgress( |
| String filePath, final Uri imageUri, final int progress) { |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| int currentDataId = mFilmStripView.getCurrentId(); |
| if (currentDataId == -1) { |
| return; |
| } |
| if (imageUri.equals( |
| mDataAdapter.getLocalData(currentDataId).getContentUri())) { |
| updateStitchingProgress(progress); |
| } |
| } |
| }); |
| } |
| }; |
| |
| public MediaSaveService getMediaSaveService() { |
| return mMediaSaveService; |
| } |
| |
| public void notifyNewMedia(Uri uri) { |
| ContentResolver cr = getContentResolver(); |
| String mimeType = cr.getType(uri); |
| if (mimeType.startsWith("video/")) { |
| sendBroadcast(new Intent(CameraUtil.ACTION_NEW_VIDEO, uri)); |
| mDataAdapter.addNewVideo(cr, uri); |
| } else if (mimeType.startsWith("image/")) { |
| CameraUtil.broadcastNewPicture(this, uri); |
| mDataAdapter.addNewPhoto(cr, uri); |
| } else if (mimeType.startsWith("application/stitching-preview")) { |
| mDataAdapter.addNewPhoto(cr, uri); |
| } else { |
| android.util.Log.w(TAG, "Unknown new media with MIME type:" |
| + mimeType + ", uri:" + uri); |
| } |
| } |
| |
| private void removeData(int dataID) { |
| mDataAdapter.removeData(CameraActivity.this, dataID); |
| showUndoDeletionBar(); |
| mMainHandler.removeCallbacks(mDeletionRunnable); |
| mMainHandler.postDelayed(mDeletionRunnable, 3000); |
| } |
| |
| private void bindMediaSaveService() { |
| Intent intent = new Intent(this, MediaSaveService.class); |
| bindService(intent, mConnection, Context.BIND_AUTO_CREATE); |
| } |
| |
| private void unbindMediaSaveService() { |
| if (mConnection != null) { |
| unbindService(mConnection); |
| } |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| // Inflate the menu items for use in the action bar |
| MenuInflater inflater = getMenuInflater(); |
| inflater.inflate(R.menu.operations, menu); |
| mActionBarMenu = menu; |
| |
| // Configure the standard share action provider |
| MenuItem item = menu.findItem(R.id.action_share); |
| mStandardShareActionProvider = (ShareActionProvider) item.getActionProvider(); |
| if (mStandardShareIntent != null) { |
| mStandardShareActionProvider.setShareIntent(mStandardShareIntent); |
| } |
| |
| // Configure the panorama share action provider |
| item = menu.findItem(R.id.action_share_panorama); |
| mPanoramaShareActionProvider = (ShareActionProvider) item.getActionProvider(); |
| if (mPanoramaShareIntent != null) { |
| mPanoramaShareActionProvider.setShareIntent(mPanoramaShareIntent); |
| } |
| |
| return super.onCreateOptionsMenu(menu); |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| int currentDataId = mFilmStripView.getCurrentId(); |
| if (currentDataId < 0) { |
| return false; |
| } |
| final LocalData localData = mDataAdapter.getLocalData(currentDataId); |
| |
| // Handle presses on the action bar items |
| switch (item.getItemId()) { |
| case android.R.id.home: |
| // ActionBar's Up/Home button was clicked |
| mFilmStripView.getController().goToFirstItem(); |
| return true; |
| case R.id.action_delete: |
| removeData(currentDataId); |
| return true; |
| case R.id.action_edit: |
| launchEditor(localData); |
| return true; |
| case R.id.action_trim: { |
| // This is going to be handled by the Gallery app. |
| Intent intent = new Intent(ACTION_TRIM_VIDEO); |
| LocalData currentData = mDataAdapter.getLocalData( |
| mFilmStripView.getCurrentId()); |
| intent.setData(currentData.getContentUri()); |
| // We need the file path to wrap this into a RandomAccessFile. |
| intent.putExtra(MEDIA_ITEM_PATH, currentData.getPath()); |
| startActivity(intent); |
| return true; |
| } |
| case R.id.action_rotate_ccw: |
| localData.rotate90Degrees(this, mDataAdapter, currentDataId, false); |
| return true; |
| case R.id.action_rotate_cw: |
| localData.rotate90Degrees(this, mDataAdapter, currentDataId, true); |
| return true; |
| case R.id.action_crop: |
| // TODO: add the functionality. |
| return true; |
| case R.id.action_setas: { |
| Intent intent = new Intent(Intent.ACTION_ATTACH_DATA) |
| .setDataAndType(localData.getContentUri(), |
| localData.getMimeType()) |
| .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); |
| intent.putExtra("mimeType", intent.getType()); |
| startActivity(Intent.createChooser( |
| intent, getString(R.string.set_as))); |
| return true; |
| } |
| case R.id.action_details: |
| (new AsyncTask<Void, Void, MediaDetails>() { |
| @Override |
| protected MediaDetails doInBackground(Void... params) { |
| return localData.getMediaDetails(CameraActivity.this); |
| } |
| |
| @Override |
| protected void onPostExecute(MediaDetails mediaDetails) { |
| DetailsDialog.create(CameraActivity.this, mediaDetails).show(); |
| } |
| }).execute(); |
| return true; |
| case R.id.action_show_on_map: |
| double[] latLong = localData.getLatLong(); |
| if (latLong != null) { |
| CameraUtil.showOnMap(this, latLong); |
| } |
| return true; |
| default: |
| return super.onOptionsItemSelected(item); |
| } |
| } |
| |
| private boolean isCaptureIntent() { |
| if (MediaStore.ACTION_VIDEO_CAPTURE.equals(getIntent().getAction()) |
| || MediaStore.ACTION_IMAGE_CAPTURE.equals(getIntent().getAction()) |
| || MediaStore.ACTION_IMAGE_CAPTURE_SECURE.equals(getIntent().getAction())) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| @Override |
| public void onCreate(Bundle state) { |
| super.onCreate(state); |
| getWindow().requestFeature(Window.FEATURE_ACTION_BAR); |
| setContentView(R.layout.camera_filmstrip); |
| mActionBar = getActionBar(); |
| // Hide action bar first since we are in full screen mode first. |
| mActionBar.hide(); |
| |
| if (ApiHelper.HAS_ROTATION_ANIMATION) { |
| setRotationAnimation(); |
| } |
| // Check if this is in the secure camera mode. |
| Intent intent = getIntent(); |
| String action = intent.getAction(); |
| if (INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE.equals(action) |
| || ACTION_IMAGE_CAPTURE_SECURE.equals(action)) { |
| mSecureCamera = true; |
| } else { |
| mSecureCamera = intent.getBooleanExtra(SECURE_CAMERA_EXTRA, false); |
| } |
| |
| if (mSecureCamera) { |
| // Change the window flags so that secure camera can show when locked |
| Window win = getWindow(); |
| WindowManager.LayoutParams params = win.getAttributes(); |
| params.flags |= WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED; |
| win.setAttributes(params); |
| |
| // Filter for screen off so that we can finish secure camera activity |
| // when screen is off. |
| IntentFilter filter = new IntentFilter(Intent.ACTION_SCREEN_OFF); |
| registerReceiver(mScreenOffReceiver, filter); |
| // TODO: This static screen off event receiver is a workaround to the |
| // double onResume() invocation (onResume->onPause->onResume). We should |
| // find a better solution to this. |
| if (sScreenOffReceiver == null) { |
| sScreenOffReceiver = new ScreenOffReceiver(); |
| registerReceiver(sScreenOffReceiver, filter); |
| } |
| } |
| mLayoutRoot = (FrameLayout) findViewById(R.id.camera_layout_root); |
| |
| mAboveFilmstripControlLayout = |
| (FrameLayout) findViewById(R.id.camera_above_filmstrip_layout); |
| mAboveFilmstripControlLayout.setFitsSystemWindows(true); |
| mAboveFilmstripControlLayout.setSystemUiVisibility( |
| View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
| | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION); |
| mPanoramaManager = AppManagerFactory.getInstance(this) |
| .getPanoramaStitchingManager(); |
| mPanoramaManager.addTaskListener(mStitchingListener); |
| LayoutInflater inflater = getLayoutInflater(); |
| View rootLayout = inflater.inflate(R.layout.camera, null, false); |
| mCameraModuleRootView = rootLayout.findViewById(R.id.camera_app_root); |
| mPanoStitchingPanel = findViewById(R.id.pano_stitching_progress_panel); |
| mBottomProgress = (ProgressBar) findViewById(R.id.pano_stitching_progress_bar); |
| mCameraPreviewData = new CameraPreviewData(rootLayout, |
| FilmStripView.ImageData.SIZE_FULL, |
| FilmStripView.ImageData.SIZE_FULL); |
| // Put a CameraPreviewData at the first position. |
| mWrappedDataAdapter = new FixedFirstDataAdapter( |
| new CameraDataAdapter(new ColorDrawable( |
| getResources().getColor(R.color.photo_placeholder))), |
| mCameraPreviewData); |
| mFilmStripView = (FilmStripView) findViewById(R.id.filmstrip_view); |
| mFilmStripView.setViewGap( |
| getResources().getDimensionPixelSize(R.dimen.camera_film_strip_gap)); |
| mPanoramaViewHelper = new PanoramaViewHelper(this); |
| mPanoramaViewHelper.onCreate(); |
| mFilmStripView.setPanoramaViewHelper(mPanoramaViewHelper); |
| // Set up the camera preview first so the preview shows up ASAP. |
| mFilmStripView.setListener(mFilmStripListener); |
| |
| int moduleIndex = -1; |
| if (MediaStore.INTENT_ACTION_VIDEO_CAMERA.equals(getIntent().getAction()) |
| || MediaStore.ACTION_VIDEO_CAPTURE.equals(getIntent().getAction())) { |
| moduleIndex = ModuleSwitcher.VIDEO_MODULE_INDEX; |
| } else if (MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA.equals(getIntent().getAction()) |
| || MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE.equals(getIntent() |
| .getAction()) |
| || MediaStore.ACTION_IMAGE_CAPTURE.equals(getIntent().getAction()) |
| || MediaStore.ACTION_IMAGE_CAPTURE_SECURE.equals(getIntent().getAction())) { |
| moduleIndex = ModuleSwitcher.PHOTO_MODULE_INDEX; |
| } else { |
| // If the activity has not been started using an explicit intent, |
| // read the module index from the last time the user changed modes |
| SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); |
| moduleIndex = prefs.getInt(PREF_STARTUP_MODULE_INDEX, -1); |
| if (moduleIndex < 0) { |
| moduleIndex = ModuleSwitcher.PHOTO_MODULE_INDEX; |
| } |
| } |
| |
| mOrientationListener = new MyOrientationEventListener(this); |
| setModuleFromIndex(moduleIndex); |
| mCurrentModule.init(this, mCameraModuleRootView); |
| mMainHandler = new Handler(getMainLooper()); |
| |
| if (!mSecureCamera) { |
| mDataAdapter = mWrappedDataAdapter; |
| mFilmStripView.setDataAdapter(mDataAdapter); |
| mDataAdapter.requestLoad(getContentResolver()); |
| } else { |
| // Put a lock placeholder as the last image by setting its date to 0. |
| ImageView v = (ImageView) getLayoutInflater().inflate( |
| R.layout.secure_album_placeholder, null); |
| mDataAdapter = new FixedLastDataAdapter( |
| mWrappedDataAdapter, |
| new SimpleViewData( |
| v, |
| v.getDrawable().getIntrinsicWidth(), |
| v.getDrawable().getIntrinsicHeight(), |
| 0, 0)); |
| // Flush out all the original data. |
| mDataAdapter.flush(); |
| mFilmStripView.setDataAdapter(mDataAdapter); |
| } |
| } |
| |
| private void setRotationAnimation() { |
| int rotationAnimation = WindowManager.LayoutParams.ROTATION_ANIMATION_ROTATE; |
| rotationAnimation = WindowManager.LayoutParams.ROTATION_ANIMATION_CROSSFADE; |
| Window win = getWindow(); |
| WindowManager.LayoutParams winParams = win.getAttributes(); |
| winParams.rotationAnimation = rotationAnimation; |
| win.setAttributes(winParams); |
| } |
| |
| @Override |
| public void onUserInteraction() { |
| super.onUserInteraction(); |
| mCurrentModule.onUserInteraction(); |
| } |
| |
| @Override |
| public void onPause() { |
| mOrientationListener.disable(); |
| mCurrentModule.onPauseBeforeSuper(); |
| super.onPause(); |
| mCurrentModule.onPauseAfterSuper(); |
| } |
| |
| @Override |
| public void onResume() { |
| if (Settings.System.getInt(getContentResolver(), |
| Settings.System.ACCELEROMETER_ROTATION, 0) == 0) {// auto-rotate off |
| setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED); |
| mAutoRotateScreen = false; |
| } else { |
| setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR); |
| mAutoRotateScreen = true; |
| } |
| mOrientationListener.enable(); |
| mCurrentModule.onResumeBeforeSuper(); |
| super.onResume(); |
| mCurrentModule.onResumeAfterSuper(); |
| |
| setSwipingEnabled(true); |
| } |
| |
| @Override |
| public void onStart() { |
| super.onStart(); |
| bindMediaSaveService(); |
| mPanoramaViewHelper.onStart(); |
| } |
| |
| @Override |
| protected void onStop() { |
| super.onStop(); |
| mPanoramaViewHelper.onStop(); |
| unbindMediaSaveService(); |
| } |
| |
| @Override |
| public void onDestroy() { |
| if (mSecureCamera) unregisterReceiver(mScreenOffReceiver); |
| super.onDestroy(); |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration config) { |
| super.onConfigurationChanged(config); |
| mCurrentModule.onConfigurationChanged(config); |
| } |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| if (mCurrentModule.onKeyDown(keyCode, event)) return true; |
| // Prevent software keyboard or voice search from showing up. |
| if (keyCode == KeyEvent.KEYCODE_SEARCH |
| || keyCode == KeyEvent.KEYCODE_MENU) { |
| if (event.isLongPress()) return true; |
| } |
| |
| return super.onKeyDown(keyCode, event); |
| } |
| |
| @Override |
| public boolean onKeyUp(int keyCode, KeyEvent event) { |
| if (mCurrentModule.onKeyUp(keyCode, event)) return true; |
| return super.onKeyUp(keyCode, event); |
| } |
| |
| @Override |
| public void onBackPressed() { |
| if (!mFilmStripView.inCameraFullscreen()) { |
| mFilmStripView.getController().goToFirstItem(); |
| } else if (!mCurrentModule.onBackPressed()) { |
| super.onBackPressed(); |
| } |
| } |
| |
| public boolean isAutoRotateScreen() { |
| return mAutoRotateScreen; |
| } |
| |
| protected void updateStorageSpace() { |
| mStorageSpace = Storage.getAvailableSpace(); |
| } |
| |
| protected long getStorageSpace() { |
| return mStorageSpace; |
| } |
| |
| protected void updateStorageSpaceAndHint() { |
| updateStorageSpace(); |
| updateStorageHint(mStorageSpace); |
| } |
| |
| protected void updateStorageHint() { |
| updateStorageHint(mStorageSpace); |
| } |
| |
| protected boolean updateStorageHintOnResume() { |
| return true; |
| } |
| |
| protected void updateStorageHint(long storageSpace) { |
| String message = null; |
| if (storageSpace == Storage.UNAVAILABLE) { |
| message = getString(R.string.no_storage); |
| } else if (storageSpace == Storage.PREPARING) { |
| message = getString(R.string.preparing_sd); |
| } else if (storageSpace == Storage.UNKNOWN_SIZE) { |
| message = getString(R.string.access_sd_fail); |
| } else if (storageSpace <= Storage.LOW_STORAGE_THRESHOLD) { |
| message = getString(R.string.spaceIsLow_content); |
| } |
| |
| if (message != null) { |
| if (mStorageHint == null) { |
| mStorageHint = OnScreenHint.makeText(this, message); |
| } else { |
| mStorageHint.setText(message); |
| } |
| mStorageHint.show(); |
| } else if (mStorageHint != null) { |
| mStorageHint.cancel(); |
| mStorageHint = null; |
| } |
| } |
| |
| protected void setResultEx(int resultCode) { |
| mResultCodeForTesting = resultCode; |
| setResult(resultCode); |
| } |
| |
| protected void setResultEx(int resultCode, Intent data) { |
| mResultCodeForTesting = resultCode; |
| mResultDataForTesting = data; |
| setResult(resultCode, data); |
| } |
| |
| public int getResultCode() { |
| return mResultCodeForTesting; |
| } |
| |
| public Intent getResultData() { |
| return mResultDataForTesting; |
| } |
| |
| public boolean isSecureCamera() { |
| return mSecureCamera; |
| } |
| |
| @Override |
| public void onModuleSelected(int moduleIndex) { |
| if (mCurrentModuleIndex == moduleIndex) return; |
| |
| CameraHolder.instance().keep(); |
| closeModule(mCurrentModule); |
| setModuleFromIndex(moduleIndex); |
| |
| openModule(mCurrentModule); |
| mCurrentModule.onOrientationChanged(mLastRawOrientation); |
| if (mMediaSaveService != null) { |
| mCurrentModule.onMediaSaveServiceConnected(mMediaSaveService); |
| } |
| |
| // Store the module index so we can use it the next time the Camera |
| // starts up. |
| SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); |
| prefs.edit().putInt(PREF_STARTUP_MODULE_INDEX, moduleIndex).apply(); |
| } |
| |
| /** |
| * Sets the mCurrentModuleIndex, creates a new module instance for the |
| * given index an sets it as mCurrentModule. |
| */ |
| private void setModuleFromIndex(int moduleIndex) { |
| mCurrentModuleIndex = moduleIndex; |
| switch (moduleIndex) { |
| case ModuleSwitcher.VIDEO_MODULE_INDEX: { |
| mCurrentModule = new VideoModule(); |
| break; |
| } |
| |
| case ModuleSwitcher.PHOTO_MODULE_INDEX: { |
| mCurrentModule = new PhotoModule(); |
| break; |
| } |
| |
| case ModuleSwitcher.WIDE_ANGLE_PANO_MODULE_INDEX: { |
| mCurrentModule = new WideAnglePanoramaModule(); |
| break; |
| } |
| |
| case ModuleSwitcher.LIGHTCYCLE_MODULE_INDEX: { |
| mCurrentModule = PhotoSphereHelper.createPanoramaModule(); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| } |
| |
| /** |
| * Launches an ACTION_EDIT intent for the given local data item. |
| */ |
| public void launchEditor(LocalData data) { |
| Intent intent = new Intent(Intent.ACTION_EDIT) |
| .setDataAndType(data.getContentUri(), data.getMimeType()) |
| .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); |
| startActivity(Intent.createChooser(intent, null)); |
| } |
| |
| private void openModule(CameraModule module) { |
| module.init(this, mCameraModuleRootView); |
| module.onResumeBeforeSuper(); |
| module.onResumeAfterSuper(); |
| } |
| |
| private void closeModule(CameraModule module) { |
| module.onPauseBeforeSuper(); |
| module.onPauseAfterSuper(); |
| ((ViewGroup) mCameraModuleRootView).removeAllViews(); |
| } |
| |
| private void showUndoDeletionBar() { |
| if (mUndoDeletionBar == null) { |
| Log.v(TAG, "showing undo bar"); |
| ViewGroup v = (ViewGroup) getLayoutInflater().inflate( |
| R.layout.undo_bar, mAboveFilmstripControlLayout, true); |
| mUndoDeletionBar = (ViewGroup) v.findViewById(R.id.camera_undo_deletion_bar); |
| View button = mUndoDeletionBar.findViewById(R.id.camera_undo_deletion_button); |
| button.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| mDataAdapter.undoDataRemoval(); |
| mMainHandler.removeCallbacks(mDeletionRunnable); |
| hideUndoDeletionBar(); |
| } |
| }); |
| } |
| mUndoDeletionBar.setAlpha(0f); |
| mUndoDeletionBar.setVisibility(View.VISIBLE); |
| mUndoDeletionBar.animate().setDuration(200).alpha(1f).start(); |
| } |
| |
| private void hideUndoDeletionBar() { |
| Log.v(TAG, "Hiding undo deletion bar"); |
| if (mUndoDeletionBar != null) { |
| mUndoDeletionBar.animate() |
| .setDuration(200) |
| .alpha(0f) |
| .withEndAction(new Runnable() { |
| @Override |
| public void run() { |
| mUndoDeletionBar.setVisibility(View.GONE); |
| } |
| }) |
| .start(); |
| } |
| } |
| |
| @Override |
| public void onShowSwitcherPopup() { |
| } |
| |
| public void setSwipingEnabled(boolean enable) { |
| mCameraPreviewData.lockPreview(!enable); |
| } |
| |
| // Accessor methods for getting latency times used in performance testing |
| public long getAutoFocusTime() { |
| return (mCurrentModule instanceof PhotoModule) ? |
| ((PhotoModule) mCurrentModule).mAutoFocusTime : -1; |
| } |
| |
| public long getShutterLag() { |
| return (mCurrentModule instanceof PhotoModule) ? |
| ((PhotoModule) mCurrentModule).mShutterLag : -1; |
| } |
| |
| public long getShutterToPictureDisplayedTime() { |
| return (mCurrentModule instanceof PhotoModule) ? |
| ((PhotoModule) mCurrentModule).mShutterToPictureDisplayedTime : -1; |
| } |
| |
| public long getPictureDisplayedToJpegCallbackTime() { |
| return (mCurrentModule instanceof PhotoModule) ? |
| ((PhotoModule) mCurrentModule).mPictureDisplayedToJpegCallbackTime : -1; |
| } |
| |
| public long getJpegCallbackFinishTime() { |
| return (mCurrentModule instanceof PhotoModule) ? |
| ((PhotoModule) mCurrentModule).mJpegCallbackFinishTime : -1; |
| } |
| |
| public long getCaptureStartTime() { |
| return (mCurrentModule instanceof PhotoModule) ? |
| ((PhotoModule) mCurrentModule).mCaptureStartTime : -1; |
| } |
| |
| public boolean isRecording() { |
| return (mCurrentModule instanceof VideoModule) ? |
| ((VideoModule) mCurrentModule).isRecording() : false; |
| } |
| } |