1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 
18 package com.android.camera;
19 
20 import android.Manifest;
21 import android.animation.Animator;
22 import android.app.ActionBar;
23 import android.app.Activity;
24 import android.app.Dialog;
25 import android.content.ActivityNotFoundException;
26 import android.content.BroadcastReceiver;
27 import android.content.ContentResolver;
28 import android.content.Context;
29 import android.content.Intent;
30 import android.content.IntentFilter;
31 import android.content.pm.ActivityInfo;
32 import android.content.pm.PackageManager;
33 import android.content.res.Configuration;
34 import android.graphics.Bitmap;
35 import android.graphics.Matrix;
36 import android.graphics.RectF;
37 import android.graphics.SurfaceTexture;
38 import android.graphics.drawable.ColorDrawable;
39 import android.graphics.drawable.Drawable;
40 import android.net.Uri;
41 import android.nfc.NfcAdapter;
42 import android.nfc.NfcAdapter.CreateBeamUrisCallback;
43 import android.nfc.NfcEvent;
44 import android.os.AsyncTask;
45 import android.os.Build;
46 import android.os.Bundle;
47 import android.os.Handler;
48 import android.os.Looper;
49 import android.os.Message;
50 import android.provider.MediaStore;
51 import android.provider.Settings;
52 import android.text.TextUtils;
53 import android.util.CameraPerformanceTracker;
54 import android.view.ContextMenu;
55 import android.view.ContextMenu.ContextMenuInfo;
56 import android.view.KeyEvent;
57 import android.view.Menu;
58 import android.view.MenuInflater;
59 import android.view.MenuItem;
60 import android.view.MotionEvent;
61 import android.view.View;
62 import android.view.View.OnSystemUiVisibilityChangeListener;
63 import android.view.ViewGroup;
64 import android.view.Window;
65 import android.view.WindowManager;
66 import android.widget.FrameLayout;
67 import android.widget.ImageView;
68 import android.widget.ShareActionProvider;
69 
70 import com.android.camera.app.AppController;
71 import com.android.camera.app.CameraAppUI;
72 import com.android.camera.app.CameraController;
73 import com.android.camera.app.CameraProvider;
74 import com.android.camera.app.CameraServices;
75 import com.android.camera.app.CameraServicesImpl;
76 import com.android.camera.app.FirstRunDialog;
77 import com.android.camera.app.LocationManager;
78 import com.android.camera.app.MemoryManager;
79 import com.android.camera.app.MemoryQuery;
80 import com.android.camera.app.ModuleManager;
81 import com.android.camera.app.ModuleManager.ModuleAgent;
82 import com.android.camera.app.ModuleManagerImpl;
83 import com.android.camera.app.MotionManager;
84 import com.android.camera.app.OrientationManager;
85 import com.android.camera.app.OrientationManagerImpl;
86 import com.android.camera.data.CameraFilmstripDataAdapter;
87 import com.android.camera.data.FilmstripContentObserver;
88 import com.android.camera.data.FilmstripItem;
89 import com.android.camera.data.FilmstripItemData;
90 import com.android.camera.data.FilmstripItemType;
91 import com.android.camera.data.FilmstripItemUtils;
92 import com.android.camera.data.FixedLastProxyAdapter;
93 import com.android.camera.data.GlideFilmstripManager;
94 import com.android.camera.data.LocalFilmstripDataAdapter;
95 import com.android.camera.data.LocalFilmstripDataAdapter.FilmstripItemListener;
96 import com.android.camera.data.MediaDetails;
97 import com.android.camera.data.MetadataLoader;
98 import com.android.camera.data.PhotoDataFactory;
99 import com.android.camera.data.PhotoItem;
100 import com.android.camera.data.PhotoItemFactory;
101 import com.android.camera.data.PlaceholderItem;
102 import com.android.camera.data.SessionItem;
103 import com.android.camera.data.VideoDataFactory;
104 import com.android.camera.data.VideoItemFactory;
105 import com.android.camera.debug.Log;
106 import com.android.camera.device.ActiveCameraDeviceTracker;
107 import com.android.camera.device.CameraId;
108 import com.android.camera.filmstrip.FilmstripContentPanel;
109 import com.android.camera.filmstrip.FilmstripController;
110 import com.android.camera.module.ModuleController;
111 import com.android.camera.module.ModulesInfo;
112 import com.android.camera.one.OneCameraException;
113 import com.android.camera.one.OneCameraManager;
114 import com.android.camera.one.OneCameraModule;
115 import com.android.camera.one.OneCameraOpener;
116 import com.android.camera.one.config.OneCameraFeatureConfig;
117 import com.android.camera.one.config.OneCameraFeatureConfigCreator;
118 import com.android.camera.session.CaptureSession;
119 import com.android.camera.session.CaptureSessionManager;
120 import com.android.camera.session.CaptureSessionManager.SessionListener;
121 import com.android.camera.settings.AppUpgrader;
122 import com.android.camera.settings.CameraSettingsActivity;
123 import com.android.camera.settings.Keys;
124 import com.android.camera.settings.PictureSizeLoader;
125 import com.android.camera.settings.ResolutionSetting;
126 import com.android.camera.settings.ResolutionUtil;
127 import com.android.camera.settings.SettingsManager;
128 import com.android.camera.stats.UsageStatistics;
129 import com.android.camera.stats.profiler.Profile;
130 import com.android.camera.stats.profiler.Profiler;
131 import com.android.camera.stats.profiler.Profilers;
132 import com.android.camera.tinyplanet.TinyPlanetFragment;
133 import com.android.camera.ui.AbstractTutorialOverlay;
134 import com.android.camera.ui.DetailsDialog;
135 import com.android.camera.ui.MainActivityLayout;
136 import com.android.camera.ui.ModeListView;
137 import com.android.camera.ui.ModeListView.ModeListVisibilityChangedListener;
138 import com.android.camera.ui.PreviewStatusListener;
139 import com.android.camera.util.ApiHelper;
140 import com.android.camera.util.Callback;
141 import com.android.camera.util.CameraUtil;
142 import com.android.camera.util.GalleryHelper;
143 import com.android.camera.util.GcamHelper;
144 import com.android.camera.util.GoogleHelpHelper;
145 import com.android.camera.util.IntentHelper;
146 import com.android.camera.util.PhotoSphereHelper.PanoramaViewHelper;
147 import com.android.camera.util.QuickActivity;
148 import com.android.camera.util.ReleaseHelper;
149 import com.android.camera.widget.FilmstripView;
150 import com.android.camera.widget.Preloader;
151 import com.android.camera2.R;
152 import com.android.ex.camera2.portability.CameraAgent;
153 import com.android.ex.camera2.portability.CameraAgentFactory;
154 import com.android.ex.camera2.portability.CameraExceptionHandler;
155 import com.android.ex.camera2.portability.CameraSettings;
156 import com.bumptech.glide.Glide;
157 import com.bumptech.glide.GlideBuilder;
158 import com.bumptech.glide.MemoryCategory;
159 import com.bumptech.glide.load.DecodeFormat;
160 import com.bumptech.glide.load.engine.executor.FifoPriorityThreadPoolExecutor;
161 
162 import com.google.common.base.Optional;
163 import com.google.common.logging.eventprotos;
164 import com.google.common.logging.eventprotos.ForegroundEvent.ForegroundSource;
165 import com.google.common.logging.eventprotos.MediaInteraction;
166 import com.google.common.logging.eventprotos.NavigationChange;
167 
168 import java.io.File;
169 import java.lang.ref.WeakReference;
170 import java.util.ArrayList;
171 import java.util.HashMap;
172 import java.util.List;
173 
174 public class CameraActivity extends QuickActivity
175         implements AppController, CameraAgent.CameraOpenCallback,
176         ShareActionProvider.OnShareTargetSelectedListener {
177 
178     private static final Log.Tag TAG = new Log.Tag("CameraActivity");
179 
180     private static final String INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE =
181             "android.media.action.STILL_IMAGE_CAMERA_SECURE";
182     public static final String ACTION_IMAGE_CAPTURE_SECURE =
183             "android.media.action.IMAGE_CAPTURE_SECURE";
184 
185     // The intent extra for camera from secure lock screen. True if the gallery
186     // should only show newly captured pictures. sSecureAlbumId does not
187     // increment. This is used when switching between camera, camcorder, and
188     // panorama. If the extra is not set, it is in the normal camera mode.
189     public static final String SECURE_CAMERA_EXTRA = "secure_camera";
190 
191     private static final int MSG_CLEAR_SCREEN_ON_FLAG = 2;
192     private static final long SCREEN_DELAY_MS = 2 * 60 * 1000; // 2 mins.
193     /** Load metadata for 10 items ahead of our current. */
194     private static final int FILMSTRIP_PRELOAD_AHEAD_ITEMS = 10;
195     private static final int PERMISSIONS_ACTIVITY_REQUEST_CODE = 1;
196     private static final int PERMISSIONS_RESULT_CODE_OK = 1;
197     private static final int PERMISSIONS_RESULT_CODE_FAILED = 2;
198 
199     /** Should be used wherever a context is needed. */
200     private Context mAppContext;
201 
202     /**
203      * Camera fatal error handling:
204      * 1) Present error dialog to guide users to exit the app.
205      * 2) If users hit home button, onPause should just call finish() to exit the app.
206      */
207     private boolean mCameraFatalError = false;
208 
209     /**
210      * Whether onResume should reset the view to the preview.
211      */
212     private boolean mResetToPreviewOnResume = true;
213 
214     /**
215      * This data adapter is used by FilmStripView.
216      */
217     private VideoItemFactory mVideoItemFactory;
218     private PhotoItemFactory mPhotoItemFactory;
219     private LocalFilmstripDataAdapter mDataAdapter;
220 
221     private ActiveCameraDeviceTracker mActiveCameraDeviceTracker;
222     private OneCameraOpener mOneCameraOpener;
223     private OneCameraManager mOneCameraManager;
224     private SettingsManager mSettingsManager;
225     private ResolutionSetting mResolutionSetting;
226     private ModeListView mModeListView;
227     private boolean mModeListVisible = false;
228     private int mCurrentModeIndex;
229     private CameraModule mCurrentModule;
230     private ModuleManagerImpl mModuleManager;
231     private FrameLayout mAboveFilmstripControlLayout;
232     private FilmstripController mFilmstripController;
233     private boolean mFilmstripVisible;
234     /** Whether the filmstrip fully covers the preview. */
235     private boolean mFilmstripCoversPreview = false;
236     private int mResultCodeForTesting;
237     private Intent mResultDataForTesting;
238     private OnScreenHint mStorageHint;
239     private final Object mStorageSpaceLock = new Object();
240     private long mStorageSpaceBytes = Storage.LOW_STORAGE_THRESHOLD_BYTES;
241     private boolean mAutoRotateScreen;
242     private boolean mSecureCamera;
243     private OrientationManagerImpl mOrientationManager;
244     private LocationManager mLocationManager;
245     private ButtonManager mButtonManager;
246     private Handler mMainHandler;
247     private PanoramaViewHelper mPanoramaViewHelper;
248     private ActionBar mActionBar;
249     private ViewGroup mUndoDeletionBar;
250     private boolean mIsUndoingDeletion = false;
251     private boolean mIsActivityRunning = false;
252     private FatalErrorHandler mFatalErrorHandler;
253     private boolean mHasCriticalPermissions;
254 
255     private final Uri[] mNfcPushUris = new Uri[1];
256 
257     private FilmstripContentObserver mLocalImagesObserver;
258     private FilmstripContentObserver mLocalVideosObserver;
259 
260     private boolean mPendingDeletion = false;
261 
262     private CameraController mCameraController;
263     private boolean mPaused;
264     private CameraAppUI mCameraAppUI;
265 
266     private Intent mGalleryIntent;
267     private long mOnCreateTime;
268 
269     private Menu mActionBarMenu;
270     private Preloader<Integer, AsyncTask> mPreloader;
271 
272     /** Can be used to play custom sounds. */
273     private SoundPlayer mSoundPlayer;
274 
275     /** Holds configuration for various OneCamera features. */
276     private OneCameraFeatureConfig mFeatureConfig;
277 
278     private static final int LIGHTS_OUT_DELAY_MS = 4000;
279     private final int BASE_SYS_UI_VISIBILITY =
280             View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
281             | View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
282     private final Runnable mLightsOutRunnable = new Runnable() {
283         @Override
284         public void run() {
285             getWindow().getDecorView().setSystemUiVisibility(
286                     BASE_SYS_UI_VISIBILITY | View.SYSTEM_UI_FLAG_LOW_PROFILE);
287         }
288     };
289     private MemoryManager mMemoryManager;
290     private MotionManager mMotionManager;
291     private final Profiler mProfiler = Profilers.instance().guard();
292 
293     /** First run dialog */
294     private FirstRunDialog mFirstRunDialog;
295 
296     @Override
getCameraAppUI()297     public CameraAppUI getCameraAppUI() {
298         return mCameraAppUI;
299     }
300 
301     @Override
getModuleManager()302     public ModuleManager getModuleManager() {
303         return mModuleManager;
304     }
305 
306     /**
307      * Close activity when secure app passes lock screen or screen turns
308      * off.
309      */
310     private final BroadcastReceiver mShutdownReceiver = new BroadcastReceiver() {
311         @Override
312         public void onReceive(Context context, Intent intent) {
313             finish();
314         }
315     };
316 
317     /**
318      * Whether the screen is kept turned on.
319      */
320     private boolean mKeepScreenOn;
321     private int mLastLayoutOrientation;
322     private final CameraAppUI.BottomPanel.Listener mMyFilmstripBottomControlListener =
323             new CameraAppUI.BottomPanel.Listener() {
324 
325                 /**
326                  * If the current photo is a photo sphere, this will launch the
327                  * Photo Sphere panorama viewer.
328                  */
329                 @Override
330                 public void onExternalViewer() {
331                     if (mPanoramaViewHelper == null) {
332                         return;
333                     }
334                     final FilmstripItem data = getCurrentLocalData();
335                     if (data == null) {
336                         Log.w(TAG, "Cannot open null data.");
337                         return;
338                     }
339                     final Uri contentUri = data.getData().getUri();
340                     if (contentUri == Uri.EMPTY) {
341                         Log.w(TAG, "Cannot open empty URL.");
342                         return;
343                     }
344 
345                     if (data.getMetadata().isUsePanoramaViewer()) {
346                         mPanoramaViewHelper.showPanorama(CameraActivity.this, contentUri);
347                     } else if (data.getMetadata().isHasRgbzData()) {
348                         mPanoramaViewHelper.showRgbz(contentUri);
349                         if (mSettingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL,
350                                 Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING)) {
351                             mSettingsManager.set(SettingsManager.SCOPE_GLOBAL,
352                                     Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING, false);
353                             mCameraAppUI.clearClingForViewer(
354                                     CameraAppUI.BottomPanel.VIEWER_REFOCUS);
355                         }
356                     }
357                 }
358 
359                 @Override
360                 public void onEdit() {
361                     FilmstripItem data = getCurrentLocalData();
362                     if (data == null) {
363                         Log.w(TAG, "Cannot edit null data.");
364                         return;
365                     }
366                     final int currentDataId = getCurrentDataId();
367                     UsageStatistics.instance().mediaInteraction(fileNameFromAdapterAtIndex(
368                                 currentDataId),
369                             MediaInteraction.InteractionType.EDIT,
370                             NavigationChange.InteractionCause.BUTTON,
371                             fileAgeFromAdapterAtIndex(currentDataId));
372                     launchEditor(data);
373                 }
374 
375                 @Override
376                 public void onTinyPlanet() {
377                     FilmstripItem data = getCurrentLocalData();
378                     if (data == null) {
379                         Log.w(TAG, "Cannot edit tiny planet on null data.");
380                         return;
381                     }
382                     launchTinyPlanetEditor(data);
383                 }
384 
385                 @Override
386                 public void onDelete() {
387                     final int currentDataId = getCurrentDataId();
388                     UsageStatistics.instance().mediaInteraction(fileNameFromAdapterAtIndex(
389                                 currentDataId),
390                             MediaInteraction.InteractionType.DELETE,
391                             NavigationChange.InteractionCause.BUTTON,
392                             fileAgeFromAdapterAtIndex(currentDataId));
393                     removeItemAt(currentDataId);
394                 }
395 
396                 @Override
397                 public void onShare() {
398                     final FilmstripItem data = getCurrentLocalData();
399                     if (data == null) {
400                         Log.w(TAG, "Cannot share null data.");
401                         return;
402                     }
403 
404                     final int currentDataId = getCurrentDataId();
405                     UsageStatistics.instance().mediaInteraction(fileNameFromAdapterAtIndex(
406                                 currentDataId),
407                             MediaInteraction.InteractionType.SHARE,
408                             NavigationChange.InteractionCause.BUTTON,
409                             fileAgeFromAdapterAtIndex(currentDataId));
410                     // If applicable, show release information before this item
411                     // is shared.
412                     if (ReleaseHelper.shouldShowReleaseInfoDialogOnShare(data)) {
413                         ReleaseHelper.showReleaseInfoDialog(CameraActivity.this,
414                                 new Callback<Void>() {
415                                     @Override
416                                     public void onCallback(Void result) {
417                                         share(data);
418                                     }
419                                 });
420                     } else {
421                         share(data);
422                     }
423                 }
424 
425                 private void share(FilmstripItem data) {
426                     Intent shareIntent = getShareIntentByData(data);
427                     if (shareIntent != null) {
428                         try {
429                             launchActivityByIntent(shareIntent);
430                             mCameraAppUI.getFilmstripBottomControls().setShareEnabled(false);
431                         } catch (ActivityNotFoundException ex) {
432                             // Nothing.
433                         }
434                     }
435                 }
436 
437                 private int getCurrentDataId() {
438                     return mFilmstripController.getCurrentAdapterIndex();
439                 }
440 
441                 private FilmstripItem getCurrentLocalData() {
442                     return mDataAdapter.getItemAt(getCurrentDataId());
443                 }
444 
445                 /**
446                  * Sets up the share intent and NFC properly according to the
447                  * data.
448                  *
449                  * @param item The data to be shared.
450                  */
451                 private Intent getShareIntentByData(final FilmstripItem item) {
452                     Intent intent = null;
453                     final Uri contentUri = item.getData().getUri();
454                     final String msgShareTo = getResources().getString(R.string.share_to);
455 
456                     if (item.getMetadata().isPanorama360() &&
457                           item.getData().getUri() != Uri.EMPTY) {
458                         intent = new Intent(Intent.ACTION_SEND);
459                         intent.setType(FilmstripItemData.MIME_TYPE_PHOTOSPHERE);
460                         intent.putExtra(Intent.EXTRA_STREAM, contentUri);
461                     } else if (item.getAttributes().canShare()) {
462                         final String mimeType = item.getData().getMimeType();
463                         intent = getShareIntentFromType(mimeType);
464                         if (intent != null) {
465                             intent.putExtra(Intent.EXTRA_STREAM, contentUri);
466                             intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
467                         }
468                         intent = Intent.createChooser(intent, msgShareTo);
469                     }
470                     return intent;
471                 }
472 
473                 /**
474                  * Get the share intent according to the mimeType
475                  *
476                  * @param mimeType The mimeType of current data.
477                  * @return the video/image's ShareIntent or null if mimeType is
478                  *         invalid.
479                  */
480                 private Intent getShareIntentFromType(String mimeType) {
481                     // Lazily create the intent object.
482                     Intent intent = new Intent(Intent.ACTION_SEND);
483                     if (mimeType.startsWith("video/")) {
484                         intent.setType("video/*");
485                     } else {
486                         if (mimeType.startsWith("image/")) {
487                             intent.setType("image/*");
488                         } else {
489                             Log.w(TAG, "unsupported mimeType " + mimeType);
490                         }
491                     }
492                     return intent;
493                 }
494 
495                 @Override
496                 public void onProgressErrorClicked() {
497                     FilmstripItem data = getCurrentLocalData();
498                     getServices().getCaptureSessionManager().removeErrorMessage(
499                             data.getData().getUri());
500                     updateBottomControlsByData(data);
501                 }
502             };
503 
504     @Override
onCameraOpened(CameraAgent.CameraProxy camera)505     public void onCameraOpened(CameraAgent.CameraProxy camera) {
506         Log.v(TAG, "onCameraOpened");
507         if (mPaused) {
508             // We've paused, but just asynchronously opened the camera. Close it
509             // because we should be releasing the camera when paused to allow
510             // other apps to access it.
511             Log.v(TAG, "received onCameraOpened but activity is paused, closing Camera");
512             mCameraController.closeCamera(false);
513             return;
514         }
515 
516         if (!mModuleManager.getModuleAgent(mCurrentModeIndex).requestAppForCamera()) {
517             // We shouldn't be here. Just close the camera and leave.
518             mCameraController.closeCamera(false);
519             throw new IllegalStateException("Camera opened but the module shouldn't be " +
520                     "requesting");
521         }
522         if (mCurrentModule != null) {
523             resetExposureCompensationToDefault(camera);
524             try {
525                 mCurrentModule.onCameraAvailable(camera);
526             } catch (RuntimeException ex) {
527                 Log.e(TAG, "Error connecting to camera", ex);
528                 mFatalErrorHandler.onCameraOpenFailure();
529             }
530         } else {
531             Log.v(TAG, "mCurrentModule null, not invoking onCameraAvailable");
532         }
533         Log.v(TAG, "invoking onChangeCamera");
534         mCameraAppUI.onChangeCamera();
535     }
536 
resetExposureCompensationToDefault(CameraAgent.CameraProxy camera)537     private void resetExposureCompensationToDefault(CameraAgent.CameraProxy camera) {
538         // Reset the exposure compensation before handing the camera to module.
539         CameraSettings cameraSettings = camera.getSettings();
540         cameraSettings.setExposureCompensationIndex(0);
541         camera.applySettings(cameraSettings);
542     }
543 
544     @Override
onCameraDisabled(int cameraId)545     public void onCameraDisabled(int cameraId) {
546         Log.w(TAG, "Camera disabled: " + cameraId);
547         mFatalErrorHandler.onCameraDisabledFailure();
548     }
549 
550     @Override
onDeviceOpenFailure(int cameraId, String info)551     public void onDeviceOpenFailure(int cameraId, String info) {
552         Log.w(TAG, "Camera open failure: " + info);
553         mFatalErrorHandler.onCameraOpenFailure();
554     }
555 
556     @Override
onDeviceOpenedAlready(int cameraId, String info)557     public void onDeviceOpenedAlready(int cameraId, String info) {
558         Log.w(TAG, "Camera open already: " + cameraId + "," + info);
559         mFatalErrorHandler.onGenericCameraAccessFailure();
560     }
561 
562     @Override
onReconnectionFailure(CameraAgent mgr, String info)563     public void onReconnectionFailure(CameraAgent mgr, String info) {
564         Log.w(TAG, "Camera reconnection failure:" + info);
565         mFatalErrorHandler.onCameraReconnectFailure();
566     }
567 
568     private static class MainHandler extends Handler {
569         final WeakReference<CameraActivity> mActivity;
570 
MainHandler(CameraActivity activity, Looper looper)571         public MainHandler(CameraActivity activity, Looper looper) {
572             super(looper);
573             mActivity = new WeakReference<CameraActivity>(activity);
574         }
575 
576         @Override
handleMessage(Message msg)577         public void handleMessage(Message msg) {
578             CameraActivity activity = mActivity.get();
579             if (activity == null) {
580                 return;
581             }
582             switch (msg.what) {
583 
584                 case MSG_CLEAR_SCREEN_ON_FLAG: {
585                     if (!activity.mPaused) {
586                         activity.getWindow().clearFlags(
587                                 WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
588                     }
589                     break;
590                 }
591             }
592         }
593     }
594 
fileNameFromAdapterAtIndex(int index)595     private String fileNameFromAdapterAtIndex(int index) {
596         final FilmstripItem filmstripItem = mDataAdapter.getItemAt(index);
597         if (filmstripItem == null) {
598             return "";
599         }
600 
601         File localFile = new File(filmstripItem.getData().getFilePath());
602         return localFile.getName();
603     }
604 
fileAgeFromAdapterAtIndex(int index)605     private float fileAgeFromAdapterAtIndex(int index) {
606         final FilmstripItem filmstripItem = mDataAdapter.getItemAt(index);
607         if (filmstripItem == null) {
608             return 0;
609         }
610 
611         File localFile = new File(filmstripItem.getData().getFilePath());
612         return 0.001f * (System.currentTimeMillis() - localFile.lastModified());
613     }
614 
615     private final FilmstripContentPanel.Listener mFilmstripListener =
616             new FilmstripContentPanel.Listener() {
617 
618                 @Override
619                 public void onSwipeOut() {
620                 }
621 
622                 @Override
623                 public void onSwipeOutBegin() {
624                     mActionBar.hide();
625                     mCameraAppUI.hideBottomControls();
626                     mFilmstripCoversPreview = false;
627                     updatePreviewVisibility();
628                 }
629 
630                 @Override
631                 public void onFilmstripHidden() {
632                     mFilmstripVisible = false;
633                     UsageStatistics.instance().changeScreen(currentUserInterfaceMode(),
634                             NavigationChange.InteractionCause.SWIPE_RIGHT);
635                     CameraActivity.this.setFilmstripUiVisibility(false);
636                     // When the user hide the filmstrip (either swipe out or
637                     // tap on back key) we move to the first item so next time
638                     // when the user swipe in the filmstrip, the most recent
639                     // one is shown.
640                     mFilmstripController.goToFirstItem();
641                 }
642 
643                 @Override
644                 public void onFilmstripShown() {
645                     mFilmstripVisible = true;
646                     mCameraAppUI.hideCaptureIndicator();
647                     UsageStatistics.instance().changeScreen(currentUserInterfaceMode(),
648                             NavigationChange.InteractionCause.SWIPE_LEFT);
649                     updateUiByData(mFilmstripController.getCurrentAdapterIndex());
650                 }
651 
652                 @Override
653                 public void onFocusedDataLongPressed(int adapterIndex) {
654                     // Do nothing.
655                 }
656 
657                 @Override
658                 public void onFocusedDataPromoted(int adapterIndex) {
659                     UsageStatistics.instance().mediaInteraction(fileNameFromAdapterAtIndex(
660                                 adapterIndex),
661                             MediaInteraction.InteractionType.DELETE,
662                             NavigationChange.InteractionCause.SWIPE_UP, fileAgeFromAdapterAtIndex(
663                                 adapterIndex));
664                     removeItemAt(adapterIndex);
665                 }
666 
667                 @Override
668                 public void onFocusedDataDemoted(int adapterIndex) {
669                     UsageStatistics.instance().mediaInteraction(fileNameFromAdapterAtIndex(
670                                 adapterIndex),
671                             MediaInteraction.InteractionType.DELETE,
672                             NavigationChange.InteractionCause.SWIPE_DOWN,
673                             fileAgeFromAdapterAtIndex(adapterIndex));
674                     removeItemAt(adapterIndex);
675                 }
676 
677                 @Override
678                 public void onEnterFullScreenUiShown(int adapterIndex) {
679                     if (mFilmstripVisible) {
680                         CameraActivity.this.setFilmstripUiVisibility(true);
681                     }
682                 }
683 
684                 @Override
685                 public void onLeaveFullScreenUiShown(int adapterIndex) {
686                     // Do nothing.
687                 }
688 
689                 @Override
690                 public void onEnterFullScreenUiHidden(int adapterIndex) {
691                     if (mFilmstripVisible) {
692                         CameraActivity.this.setFilmstripUiVisibility(false);
693                     }
694                 }
695 
696                 @Override
697                 public void onLeaveFullScreenUiHidden(int adapterIndex) {
698                     // Do nothing.
699                 }
700 
701                 @Override
702                 public void onEnterFilmstrip(int adapterIndex) {
703                     if (mFilmstripVisible) {
704                         CameraActivity.this.setFilmstripUiVisibility(true);
705                     }
706                 }
707 
708                 @Override
709                 public void onLeaveFilmstrip(int adapterIndex) {
710                     // Do nothing.
711                 }
712 
713                 @Override
714                 public void onDataReloaded() {
715                     if (!mFilmstripVisible) {
716                         return;
717                     }
718                     updateUiByData(mFilmstripController.getCurrentAdapterIndex());
719                 }
720 
721                 @Override
722                 public void onDataUpdated(int adapterIndex) {
723                     if (!mFilmstripVisible) {
724                         return;
725                     }
726                     updateUiByData(mFilmstripController.getCurrentAdapterIndex());
727                 }
728 
729                 @Override
730                 public void onEnterZoomView(int adapterIndex) {
731                     if (mFilmstripVisible) {
732                         CameraActivity.this.setFilmstripUiVisibility(false);
733                     }
734                 }
735 
736                 @Override
737                 public void onZoomAtIndexChanged(int adapterIndex, float zoom) {
738                     final FilmstripItem filmstripItem = mDataAdapter.getItemAt(adapterIndex);
739                     long ageMillis = System.currentTimeMillis()
740                           - filmstripItem.getData().getLastModifiedDate().getTime();
741 
742                     // Do not log if items is to old or does not have a path (which is
743                     // being used as a key).
744                     if (TextUtils.isEmpty(filmstripItem.getData().getFilePath()) ||
745                             ageMillis > UsageStatistics.VIEW_TIMEOUT_MILLIS) {
746                         return;
747                     }
748                     File localFile = new File(filmstripItem.getData().getFilePath());
749                     UsageStatistics.instance().mediaView(localFile.getName(),
750                           filmstripItem.getData().getLastModifiedDate().getTime(), zoom);
751                }
752 
753                 @Override
754                 public void onDataFocusChanged(final int prevIndex, final int newIndex) {
755                     if (!mFilmstripVisible) {
756                         return;
757                     }
758                     // TODO: This callback is UI event callback, should always
759                     // happen on UI thread. Find the reason for this
760                     // runOnUiThread() and fix it.
761                     runOnUiThread(new Runnable() {
762                         @Override
763                         public void run() {
764                             updateUiByData(newIndex);
765                         }
766                     });
767                 }
768 
769                 @Override
770                 public void onScroll(int firstVisiblePosition, int visibleItemCount, int totalItemCount) {
771                     mPreloader.onScroll(null /*absListView*/, firstVisiblePosition, visibleItemCount, totalItemCount);
772                 }
773             };
774 
775     private final FilmstripItemListener mFilmstripItemListener =
776             new FilmstripItemListener() {
777                 @Override
778                 public void onMetadataUpdated(List<Integer> indexes) {
779                     if (mPaused) {
780                         // Callback after the activity is paused.
781                         return;
782                     }
783                     int currentIndex = mFilmstripController.getCurrentAdapterIndex();
784                     for (Integer index : indexes) {
785                         if (index == currentIndex) {
786                             updateUiByData(index);
787                             // Currently we have only 1 data can be matched.
788                             // No need to look for more, break.
789                             break;
790                         }
791                     }
792                 }
793             };
794 
gotoGallery()795     public void gotoGallery() {
796         UsageStatistics.instance().changeScreen(NavigationChange.Mode.FILMSTRIP,
797                 NavigationChange.InteractionCause.BUTTON);
798 
799         mFilmstripController.goToNextItem();
800     }
801 
802     /**
803      * If 'visible' is false, this hides the action bar. Also maintains
804      * lights-out at all times.
805      *
806      * @param visible is false, this hides the action bar and filmstrip bottom
807      *            controls.
808      */
setFilmstripUiVisibility(boolean visible)809     private void setFilmstripUiVisibility(boolean visible) {
810         mLightsOutRunnable.run();
811         mCameraAppUI.getFilmstripBottomControls().setVisible(visible);
812         if (visible != mActionBar.isShowing()) {
813             if (visible) {
814                 mActionBar.show();
815                 mCameraAppUI.showBottomControls();
816             } else {
817                 mActionBar.hide();
818                 mCameraAppUI.hideBottomControls();
819             }
820         }
821         mFilmstripCoversPreview = visible;
822         updatePreviewVisibility();
823     }
824 
hideSessionProgress()825     private void hideSessionProgress() {
826         mCameraAppUI.getFilmstripBottomControls().hideProgress();
827     }
828 
showSessionProgress(int messageId)829     private void showSessionProgress(int messageId) {
830         CameraAppUI.BottomPanel controls = mCameraAppUI.getFilmstripBottomControls();
831         controls.setProgressText(messageId > 0 ? getString(messageId) : "");
832         controls.hideControls();
833         controls.hideProgressError();
834         controls.showProgress();
835     }
836 
showProcessError(int messageId)837     private void showProcessError(int messageId) {
838         mCameraAppUI.getFilmstripBottomControls().showProgressError(
839                 messageId > 0 ? getString(messageId) : "");
840     }
841 
updateSessionProgress(int progress)842     private void updateSessionProgress(int progress) {
843         mCameraAppUI.getFilmstripBottomControls().setProgress(progress);
844     }
845 
updateSessionProgressText(int messageId)846     private void updateSessionProgressText(int messageId) {
847         mCameraAppUI.getFilmstripBottomControls().setProgressText(
848                 messageId > 0 ? getString(messageId) : "");
849     }
850 
setupNfcBeamPush()851     private void setupNfcBeamPush() {
852         NfcAdapter adapter = NfcAdapter.getDefaultAdapter(mAppContext);
853         if (adapter == null) {
854             return;
855         }
856 
857         if (!ApiHelper.HAS_SET_BEAM_PUSH_URIS) {
858             // Disable beaming
859             adapter.setNdefPushMessage(null, CameraActivity.this);
860             return;
861         }
862 
863         adapter.setBeamPushUris(null, CameraActivity.this);
864         adapter.setBeamPushUrisCallback(new CreateBeamUrisCallback() {
865             @Override
866             public Uri[] createBeamUris(NfcEvent event) {
867                 return mNfcPushUris;
868             }
869         }, CameraActivity.this);
870     }
871 
872     @Override
onShareTargetSelected(ShareActionProvider shareActionProvider, Intent intent)873     public boolean onShareTargetSelected(ShareActionProvider shareActionProvider, Intent intent) {
874         int currentIndex = mFilmstripController.getCurrentAdapterIndex();
875         if (currentIndex < 0) {
876             return false;
877         }
878         UsageStatistics.instance().mediaInteraction(fileNameFromAdapterAtIndex(currentIndex),
879                 MediaInteraction.InteractionType.SHARE,
880                 NavigationChange.InteractionCause.BUTTON, fileAgeFromAdapterAtIndex(currentIndex));
881         // TODO add intent.getComponent().getPackageName()
882         return true;
883     }
884 
885     // Note: All callbacks come back on the main thread.
886     private final SessionListener mSessionListener =
887             new SessionListener() {
888                 @Override
889                 public void onSessionQueued(final Uri uri) {
890                     Log.v(TAG, "onSessionQueued: " + uri);
891                     if (!Storage.isSessionUri(uri)) {
892                         return;
893                     }
894                     Optional<SessionItem> newData = SessionItem.create(getApplicationContext(), uri);
895                     if (newData.isPresent()) {
896                         mDataAdapter.addOrUpdate(newData.get());
897                     }
898                 }
899 
900                 @Override
901                 public void onSessionUpdated(Uri uri) {
902                     Log.v(TAG, "onSessionUpdated: " + uri);
903                     mDataAdapter.refresh(uri);
904                 }
905 
906                 @Override
907                 public void onSessionDone(final Uri sessionUri) {
908                     Log.v(TAG, "onSessionDone:" + sessionUri);
909                     Uri contentUri = Storage.getContentUriForSessionUri(sessionUri);
910                     if (contentUri == null) {
911                         mDataAdapter.refresh(sessionUri);
912                         return;
913                     }
914                     PhotoItem newData = mPhotoItemFactory.queryContentUri(contentUri);
915 
916                     // This can be null if e.g. a session is canceled (e.g.
917                     // through discard panorama). It might be worth adding
918                     // onSessionCanceled or the like this interface.
919                     if (newData == null) {
920                         Log.i(TAG, "onSessionDone: Could not find LocalData for URI: " + contentUri);
921                         return;
922                     }
923 
924                     final int pos = mDataAdapter.findByContentUri(sessionUri);
925                     if (pos == -1) {
926                         // We do not have a placeholder for this image, perhaps
927                         // due to the activity crashing or being killed.
928                         mDataAdapter.addOrUpdate(newData);
929                     } else {
930                         // Make the PhotoItem aware of the session placeholder, to
931                         // allow it to make a smooth transition to its content if it
932                         // the session item is currently visible.
933                         FilmstripItem oldSessionData = mDataAdapter.getFilmstripItemAt(pos);
934                         if (mCameraAppUI.getFilmstripVisibility() == View.VISIBLE
935                                 && mFilmstripController.isVisible(oldSessionData)) {
936                             Log.v(TAG, "session item visible, setting transition placeholder");
937                             newData.setSessionPlaceholderBitmap(
938                                     Storage.getPlaceholderForSession(sessionUri));
939                         }
940                         mDataAdapter.updateItemAt(pos, newData);
941                     }
942                 }
943 
944                 @Override
945                 public void onSessionProgress(final Uri uri, final int progress) {
946                     if (progress < 0) {
947                         // Do nothing, there is no task for this URI.
948                         return;
949                     }
950                     int currentIndex = mFilmstripController.getCurrentAdapterIndex();
951                     if (currentIndex == -1) {
952                         return;
953                     }
954                     if (uri.equals(
955                             mDataAdapter.getItemAt(currentIndex).getData().getUri())) {
956                         updateSessionProgress(progress);
957                     }
958                 }
959 
960                 @Override
961                 public void onSessionProgressText(final Uri uri, final int messageId) {
962                     int currentIndex = mFilmstripController.getCurrentAdapterIndex();
963                     if (currentIndex == -1) {
964                         return;
965                     }
966                     if (uri.equals(
967                             mDataAdapter.getItemAt(currentIndex).getData().getUri())) {
968                         updateSessionProgressText(messageId);
969                     }
970                 }
971 
972                 @Override
973                 public void onSessionCaptureIndicatorUpdate(Bitmap indicator, int rotationDegrees) {
974                     // Don't show capture indicator in Photo Sphere.
975                     final int photosphereModuleId = getApplicationContext().getResources()
976                             .getInteger(
977                                     R.integer.camera_mode_photosphere);
978                     if (mCurrentModeIndex == photosphereModuleId) {
979                         return;
980                     }
981                     indicateCapture(indicator, rotationDegrees);
982                 }
983 
984                 @Override
985                 public void onSessionFailed(Uri uri, int failureMessageId,
986                         boolean removeFromFilmstrip) {
987                     Log.v(TAG, "onSessionFailed:" + uri);
988 
989                     int failedIndex = mDataAdapter.findByContentUri(uri);
990                     int currentIndex = mFilmstripController.getCurrentAdapterIndex();
991 
992                     if (currentIndex == failedIndex) {
993                         updateSessionProgress(0);
994                         showProcessError(failureMessageId);
995                         mDataAdapter.refresh(uri);
996                     }
997                     if (removeFromFilmstrip) {
998                         mFatalErrorHandler.onMediaStorageFailure();
999                         mDataAdapter.removeAt(failedIndex);
1000                     }
1001                 }
1002 
1003                 @Override
1004                 public void onSessionCanceled(Uri uri) {
1005                     Log.v(TAG, "onSessionCanceled:" + uri);
1006                     int failedIndex = mDataAdapter.findByContentUri(uri);
1007                     mDataAdapter.removeAt(failedIndex);
1008                 }
1009 
1010                 @Override
1011                 public void onSessionThumbnailUpdate(Bitmap bitmap) {
1012                 }
1013 
1014                 @Override
1015                 public void onSessionPictureDataUpdate(byte[] pictureData, int orientation) {
1016                 }
1017             };
1018 
1019     @Override
getAndroidContext()1020     public Context getAndroidContext() {
1021         return mAppContext;
1022     }
1023 
1024     @Override
getCameraFeatureConfig()1025     public OneCameraFeatureConfig getCameraFeatureConfig() {
1026         return mFeatureConfig;
1027     }
1028 
1029     @Override
createDialog()1030     public Dialog createDialog() {
1031         return new Dialog(this, android.R.style.Theme_Black_NoTitleBar_Fullscreen);
1032     }
1033 
1034     @Override
launchActivityByIntent(Intent intent)1035     public void launchActivityByIntent(Intent intent) {
1036         // Starting from L, we prefer not to start edit activity within camera's task.
1037         mResetToPreviewOnResume = false;
1038         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);
1039 
1040         startActivity(intent);
1041     }
1042 
1043     @Override
getCurrentModuleIndex()1044     public int getCurrentModuleIndex() {
1045         return mCurrentModeIndex;
1046     }
1047 
1048     @Override
getModuleScope()1049     public String getModuleScope() {
1050         ModuleAgent agent = mModuleManager.getModuleAgent(mCurrentModeIndex);
1051         return SettingsManager.getModuleSettingScope(agent.getScopeNamespace());
1052     }
1053 
1054     @Override
getCameraScope()1055     public String getCameraScope() {
1056         // if an unopen camera i.e. negative ID is returned, which we've observed in
1057         // some automated scenarios, just return it as a valid separate scope
1058         // this could cause user issues, so log a stack trace noting the call path
1059         // which resulted in this scenario.
1060 
1061         CameraId cameraId =  mCameraController.getCurrentCameraId();
1062 
1063         if(cameraId == null) {
1064             Log.e(TAG,  "Retrieving Camera Setting Scope with -1");
1065             return SettingsManager.getCameraSettingScope("-1");
1066         }
1067 
1068         return SettingsManager.getCameraSettingScope(cameraId.getValue());
1069     }
1070 
1071     @Override
getCurrentModuleController()1072     public ModuleController getCurrentModuleController() {
1073         return mCurrentModule;
1074     }
1075 
1076     @Override
getQuickSwitchToModuleId(int currentModuleIndex)1077     public int getQuickSwitchToModuleId(int currentModuleIndex) {
1078         return mModuleManager.getQuickSwitchToModuleId(currentModuleIndex, mSettingsManager,
1079                 mAppContext);
1080     }
1081 
1082     @Override
getPreviewBuffer()1083     public SurfaceTexture getPreviewBuffer() {
1084         // TODO: implement this
1085         return null;
1086     }
1087 
1088     @Override
onPreviewReadyToStart()1089     public void onPreviewReadyToStart() {
1090         mCameraAppUI.onPreviewReadyToStart();
1091     }
1092 
1093     @Override
onPreviewStarted()1094     public void onPreviewStarted() {
1095         mCameraAppUI.onPreviewStarted();
1096     }
1097 
1098     @Override
addPreviewAreaSizeChangedListener( PreviewStatusListener.PreviewAreaChangedListener listener)1099     public void addPreviewAreaSizeChangedListener(
1100             PreviewStatusListener.PreviewAreaChangedListener listener) {
1101         mCameraAppUI.addPreviewAreaChangedListener(listener);
1102     }
1103 
1104     @Override
removePreviewAreaSizeChangedListener( PreviewStatusListener.PreviewAreaChangedListener listener)1105     public void removePreviewAreaSizeChangedListener(
1106             PreviewStatusListener.PreviewAreaChangedListener listener) {
1107         mCameraAppUI.removePreviewAreaChangedListener(listener);
1108     }
1109 
1110     @Override
setupOneShotPreviewListener()1111     public void setupOneShotPreviewListener() {
1112         mCameraController.setOneShotPreviewCallback(mMainHandler,
1113                 new CameraAgent.CameraPreviewDataCallback() {
1114                     @Override
1115                     public void onPreviewFrame(byte[] data, CameraAgent.CameraProxy camera) {
1116                         mCurrentModule.onPreviewInitialDataReceived();
1117                         mCameraAppUI.onNewPreviewFrame();
1118                     }
1119                 }
1120         );
1121     }
1122 
1123     @Override
updatePreviewAspectRatio(float aspectRatio)1124     public void updatePreviewAspectRatio(float aspectRatio) {
1125         mCameraAppUI.updatePreviewAspectRatio(aspectRatio);
1126     }
1127 
1128     @Override
updatePreviewTransformFullscreen(Matrix matrix, float aspectRatio)1129     public void updatePreviewTransformFullscreen(Matrix matrix, float aspectRatio) {
1130         mCameraAppUI.updatePreviewTransformFullscreen(matrix, aspectRatio);
1131     }
1132 
1133     @Override
getFullscreenRect()1134     public RectF getFullscreenRect() {
1135         return mCameraAppUI.getFullscreenRect();
1136     }
1137 
1138     @Override
updatePreviewTransform(Matrix matrix)1139     public void updatePreviewTransform(Matrix matrix) {
1140         mCameraAppUI.updatePreviewTransform(matrix);
1141     }
1142 
1143     @Override
setPreviewStatusListener(PreviewStatusListener previewStatusListener)1144     public void setPreviewStatusListener(PreviewStatusListener previewStatusListener) {
1145         mCameraAppUI.setPreviewStatusListener(previewStatusListener);
1146     }
1147 
1148     @Override
getModuleLayoutRoot()1149     public FrameLayout getModuleLayoutRoot() {
1150         return mCameraAppUI.getModuleRootView();
1151     }
1152 
1153     @Override
setShutterEventsListener(ShutterEventsListener listener)1154     public void setShutterEventsListener(ShutterEventsListener listener) {
1155         // TODO: implement this
1156     }
1157 
1158     @Override
setShutterEnabled(boolean enabled)1159     public void setShutterEnabled(boolean enabled) {
1160         mCameraAppUI.setShutterButtonEnabled(enabled);
1161     }
1162 
1163     @Override
isShutterEnabled()1164     public boolean isShutterEnabled() {
1165         return mCameraAppUI.isShutterButtonEnabled();
1166     }
1167 
1168     @Override
startFlashAnimation(boolean shortFlash)1169     public void startFlashAnimation(boolean shortFlash) {
1170         mCameraAppUI.startFlashAnimation(shortFlash);
1171     }
1172 
1173     @Override
startPreCaptureAnimation()1174     public void startPreCaptureAnimation() {
1175         // TODO: implement this
1176     }
1177 
1178     @Override
cancelPreCaptureAnimation()1179     public void cancelPreCaptureAnimation() {
1180         // TODO: implement this
1181     }
1182 
1183     @Override
startPostCaptureAnimation()1184     public void startPostCaptureAnimation() {
1185         // TODO: implement this
1186     }
1187 
1188     @Override
startPostCaptureAnimation(Bitmap thumbnail)1189     public void startPostCaptureAnimation(Bitmap thumbnail) {
1190         // TODO: implement this
1191     }
1192 
1193     @Override
cancelPostCaptureAnimation()1194     public void cancelPostCaptureAnimation() {
1195         // TODO: implement this
1196     }
1197 
1198     @Override
getOrientationManager()1199     public OrientationManager getOrientationManager() {
1200         return mOrientationManager;
1201     }
1202 
1203     @Override
getLocationManager()1204     public LocationManager getLocationManager() {
1205         return mLocationManager;
1206     }
1207 
1208     @Override
lockOrientation()1209     public void lockOrientation() {
1210         if (mOrientationManager != null) {
1211             mOrientationManager.lockOrientation();
1212         }
1213     }
1214 
1215     @Override
unlockOrientation()1216     public void unlockOrientation() {
1217         if (mOrientationManager != null) {
1218             mOrientationManager.unlockOrientation();
1219         }
1220     }
1221 
1222     /**
1223      * If not in filmstrip, this shows the capture indicator.
1224      */
indicateCapture(final Bitmap indicator, final int rotationDegrees)1225     private void indicateCapture(final Bitmap indicator, final int rotationDegrees) {
1226         if (mFilmstripVisible) {
1227             return;
1228         }
1229 
1230         // Don't show capture indicator in Photo Sphere.
1231         // TODO: Don't reach into resources to figure out the current mode.
1232         final int photosphereModuleId = getApplicationContext().getResources().getInteger(
1233                 R.integer.camera_mode_photosphere);
1234         if (mCurrentModeIndex == photosphereModuleId) {
1235             return;
1236         }
1237 
1238         mMainHandler.post(new Runnable() {
1239             @Override
1240             public void run() {
1241                 mCameraAppUI.startCaptureIndicatorRevealAnimation(mCurrentModule
1242                         .getPeekAccessibilityString());
1243                 mCameraAppUI.updateCaptureIndicatorThumbnail(indicator, rotationDegrees);
1244             }
1245         });
1246     }
1247 
1248     @Override
notifyNewMedia(Uri uri)1249     public void notifyNewMedia(Uri uri) {
1250         // TODO: This method is running on the main thread. Also we should get
1251         // rid of that AsyncTask.
1252 
1253         updateStorageSpaceAndHint(null);
1254         ContentResolver cr = getContentResolver();
1255         String mimeType = cr.getType(uri);
1256         FilmstripItem newData = null;
1257         if (FilmstripItemUtils.isMimeTypeVideo(mimeType)) {
1258             sendBroadcast(new Intent(CameraUtil.ACTION_NEW_VIDEO, uri));
1259             newData = mVideoItemFactory.queryContentUri(uri);
1260             if (newData == null) {
1261                 Log.e(TAG, "Can't find video data in content resolver:" + uri);
1262                 return;
1263             }
1264         } else if (FilmstripItemUtils.isMimeTypeImage(mimeType)) {
1265             CameraUtil.broadcastNewPicture(mAppContext, uri);
1266             newData = mPhotoItemFactory.queryContentUri(uri);
1267             if (newData == null) {
1268                 Log.e(TAG, "Can't find photo data in content resolver:" + uri);
1269                 return;
1270             }
1271         } else {
1272             Log.w(TAG, "Unknown new media with MIME type:" + mimeType + ", uri:" + uri);
1273             return;
1274         }
1275 
1276         // We are preloading the metadata for new video since we need the
1277         // rotation info for the thumbnail.
1278         new AsyncTask<FilmstripItem, Void, FilmstripItem>() {
1279             @Override
1280             protected FilmstripItem doInBackground(FilmstripItem... params) {
1281                 FilmstripItem data = params[0];
1282                 MetadataLoader.loadMetadata(getAndroidContext(), data);
1283                 return data;
1284             }
1285 
1286             @Override
1287             protected void onPostExecute(final FilmstripItem data) {
1288                 // TODO: Figure out why sometimes the data is aleady there.
1289                 mDataAdapter.addOrUpdate(data);
1290 
1291                 // Legacy modules don't use CaptureSession, so we show the capture indicator when
1292                 // the item was safed.
1293                 if (mCurrentModule instanceof PhotoModule ||
1294                         mCurrentModule instanceof VideoModule) {
1295                     AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() {
1296                         @Override
1297                         public void run() {
1298                             final Optional<Bitmap> bitmap = data.generateThumbnail(
1299                                     mAboveFilmstripControlLayout.getWidth(),
1300                                     mAboveFilmstripControlLayout.getMeasuredHeight());
1301                             if (bitmap.isPresent()) {
1302                                 indicateCapture(bitmap.get(), 0);
1303                             }
1304                         }
1305                     });
1306                 }
1307             }
1308         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, newData);
1309     }
1310 
1311     @Override
enableKeepScreenOn(boolean enabled)1312     public void enableKeepScreenOn(boolean enabled) {
1313         if (mPaused) {
1314             return;
1315         }
1316 
1317         mKeepScreenOn = enabled;
1318         if (mKeepScreenOn) {
1319             mMainHandler.removeMessages(MSG_CLEAR_SCREEN_ON_FLAG);
1320             getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
1321         } else {
1322             keepScreenOnForAWhile();
1323         }
1324     }
1325 
1326     @Override
getCameraProvider()1327     public CameraProvider getCameraProvider() {
1328         return mCameraController;
1329     }
1330 
1331     @Override
getCameraOpener()1332     public OneCameraOpener getCameraOpener() {
1333         return mOneCameraOpener;
1334     }
1335 
removeItemAt(int index)1336     private void removeItemAt(int index) {
1337         mDataAdapter.removeAt(index);
1338         if (mDataAdapter.getTotalNumber() > 1) {
1339             showUndoDeletionBar();
1340         } else {
1341             // If camera preview is the only view left in filmstrip,
1342             // no need to show undo bar.
1343             mPendingDeletion = true;
1344             performDeletion();
1345             if (mFilmstripVisible) {
1346                 mCameraAppUI.getFilmstripContentPanel().animateHide();
1347             }
1348         }
1349     }
1350 
1351     @Override
onOptionsItemSelected(MenuItem item)1352     public boolean onOptionsItemSelected(MenuItem item) {
1353         // Handle presses on the action bar items
1354         switch (item.getItemId()) {
1355             case android.R.id.home:
1356                 onBackPressed();
1357                 return true;
1358             case R.id.action_details:
1359                 showDetailsDialog(mFilmstripController.getCurrentAdapterIndex());
1360                 return true;
1361             case R.id.action_help_and_feedback:
1362                 mResetToPreviewOnResume = false;
1363                 new GoogleHelpHelper(this).launchGoogleHelp();
1364                 return true;
1365             default:
1366                 return super.onOptionsItemSelected(item);
1367         }
1368     }
1369 
isCaptureIntent()1370     private boolean isCaptureIntent() {
1371         if (MediaStore.ACTION_VIDEO_CAPTURE.equals(getIntent().getAction())
1372                 || MediaStore.ACTION_IMAGE_CAPTURE.equals(getIntent().getAction())
1373                 || MediaStore.ACTION_IMAGE_CAPTURE_SECURE.equals(getIntent().getAction())) {
1374             return true;
1375         } else {
1376             return false;
1377         }
1378     }
1379 
1380     /**
1381      * Note: Make sure this callback is unregistered properly when the activity
1382      * is destroyed since we're otherwise leaking the Activity reference.
1383      */
1384     private final CameraExceptionHandler.CameraExceptionCallback mCameraExceptionCallback
1385         = new CameraExceptionHandler.CameraExceptionCallback() {
1386                 @Override
1387                 public void onCameraError(int errorCode) {
1388                     // Not a fatal error. only do Log.e().
1389                     Log.e(TAG, "Camera error callback. error=" + errorCode);
1390                 }
1391                 @Override
1392                 public void onCameraException(
1393                         RuntimeException ex, String commandHistory, int action, int state) {
1394                     Log.e(TAG, "Camera Exception", ex);
1395                     UsageStatistics.instance().cameraFailure(
1396                             eventprotos.CameraFailure.FailureReason.API_RUNTIME_EXCEPTION,
1397                             commandHistory, action, state);
1398                     onFatalError();
1399                 }
1400                 @Override
1401                 public void onDispatchThreadException(RuntimeException ex) {
1402                     Log.e(TAG, "DispatchThread Exception", ex);
1403                     UsageStatistics.instance().cameraFailure(
1404                             eventprotos.CameraFailure.FailureReason.API_TIMEOUT,
1405                             null, UsageStatistics.NONE, UsageStatistics.NONE);
1406                     onFatalError();
1407                 }
1408                 private void onFatalError() {
1409                     if (mCameraFatalError) {
1410                         return;
1411                     }
1412                     mCameraFatalError = true;
1413 
1414                     // If the activity receives exception during onPause, just exit the app.
1415                     if (mPaused && !isFinishing()) {
1416                         Log.e(TAG, "Fatal error during onPause, call Activity.finish()");
1417                         finish();
1418                     } else {
1419                         mFatalErrorHandler.handleFatalError(FatalErrorHandler.Reason.CANNOT_CONNECT_TO_CAMERA);
1420                     }
1421                 }
1422             };
1423 
1424     @Override
onNewIntentTasks(Intent intent)1425     public void onNewIntentTasks(Intent intent) {
1426         onModeSelected(getModeIndex());
1427     }
1428 
1429     @Override
onCreateTasks(Bundle state)1430     public void onCreateTasks(Bundle state) {
1431         Profile profile = mProfiler.create("CameraActivity.onCreateTasks").start();
1432         CameraPerformanceTracker.onEvent(CameraPerformanceTracker.ACTIVITY_START);
1433         mOnCreateTime = System.currentTimeMillis();
1434         mAppContext = getApplicationContext();
1435         mMainHandler = new MainHandler(this, getMainLooper());
1436         mLocationManager = new LocationManager(mAppContext);
1437         mOrientationManager = new OrientationManagerImpl(this, mMainHandler);
1438         mSettingsManager = getServices().getSettingsManager();
1439         mSoundPlayer = new SoundPlayer(mAppContext);
1440         mFeatureConfig = OneCameraFeatureConfigCreator.createDefault(getContentResolver(),
1441                 getServices().getMemoryManager());
1442         mFatalErrorHandler = new FatalErrorHandlerImpl(this);
1443         checkPermissions();
1444         if (!mHasCriticalPermissions) {
1445             Log.v(TAG, "onCreate: Missing critical permissions.");
1446             finish();
1447             return;
1448         }
1449         profile.mark();
1450         if (!Glide.isSetup()) {
1451             Context context = getAndroidContext();
1452             Glide.setup(new GlideBuilder(context)
1453                 .setDecodeFormat(DecodeFormat.ALWAYS_ARGB_8888)
1454                 .setResizeService(new FifoPriorityThreadPoolExecutor(2)));
1455 
1456             Glide glide = Glide.get(context);
1457 
1458             // As a camera we will use a large amount of memory
1459             // for displaying images.
1460             glide.setMemoryCategory(MemoryCategory.HIGH);
1461         }
1462         profile.mark("Glide.setup");
1463 
1464         mActiveCameraDeviceTracker = ActiveCameraDeviceTracker.instance();
1465         try {
1466             mOneCameraOpener = OneCameraModule.provideOneCameraOpener(
1467                     mFeatureConfig,
1468                     mAppContext,
1469                     mActiveCameraDeviceTracker,
1470                     ResolutionUtil.getDisplayMetrics(this));
1471             mOneCameraManager = OneCameraModule.provideOneCameraManager();
1472         } catch (OneCameraException e) {
1473             // Log error and continue start process while showing error dialog..
1474             Log.e(TAG, "Creating camera manager failed.", e);
1475             mFatalErrorHandler.onGenericCameraAccessFailure();
1476         }
1477         profile.mark("OneCameraManager.get");
1478 
1479         try {
1480             mCameraController = new CameraController(mAppContext, this, mMainHandler,
1481                     CameraAgentFactory.getAndroidCameraAgent(mAppContext,
1482                             CameraAgentFactory.CameraApi.API_1),
1483                     CameraAgentFactory.getAndroidCameraAgent(mAppContext,
1484                             CameraAgentFactory.CameraApi.AUTO),
1485                     mActiveCameraDeviceTracker);
1486             mCameraController.setCameraExceptionHandler(
1487                     new CameraExceptionHandler(mCameraExceptionCallback, mMainHandler));
1488         } catch (AssertionError e) {
1489             Log.e(TAG, "Creating camera controller failed.", e);
1490             mFatalErrorHandler.onGenericCameraAccessFailure();
1491         }
1492 
1493         // TODO: Try to move all the resources allocation to happen as soon as
1494         // possible so we can call module.init() at the earliest time.
1495         mModuleManager = new ModuleManagerImpl();
1496 
1497         ModulesInfo.setupModules(mAppContext, mModuleManager, mFeatureConfig);
1498 
1499         AppUpgrader appUpgrader = new AppUpgrader(this);
1500         appUpgrader.upgrade(mSettingsManager);
1501 
1502         // Make sure the picture sizes are correctly cached for the current OS
1503         // version.
1504         profile.mark();
1505         try {
1506             (new PictureSizeLoader(mAppContext)).computePictureSizes();
1507         } catch (AssertionError e) {
1508             Log.e(TAG, "Creating camera controller failed.", e);
1509             mFatalErrorHandler.onGenericCameraAccessFailure();
1510         }
1511         profile.mark("computePictureSizes");
1512         Keys.setDefaults(mSettingsManager, mAppContext);
1513 
1514         mResolutionSetting = new ResolutionSetting(mSettingsManager, mOneCameraManager,
1515                 getContentResolver());
1516 
1517         getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
1518         // We suppress this flag via theme when drawing the system preview
1519         // background, but once we create activity here, reactivate to the
1520         // default value. The default is important for L, we don't want to
1521         // change app behavior, just starting background drawable layout.
1522         if (ApiHelper.isLOrHigher()) {
1523             getWindow().addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
1524         }
1525 
1526         profile.mark();
1527         setContentView(R.layout.activity_main);
1528         profile.mark("setContentView()");
1529         // A window background is set in styles.xml for the system to show a
1530         // drawable background with gray color and camera icon before the
1531         // activity is created. We set the background to null here to prevent
1532         // overdraw, all views must take care of drawing backgrounds if
1533         // necessary. This call to setBackgroundDrawable must occur after
1534         // setContentView, otherwise a background may be set again from the
1535         // style.
1536         getWindow().setBackgroundDrawable(null);
1537 
1538         mActionBar = getActionBar();
1539         // set actionbar background to 100% or 50% transparent
1540         if (ApiHelper.isLOrHigher()) {
1541             mActionBar.setBackgroundDrawable(new ColorDrawable(0x00000000));
1542         } else {
1543             mActionBar.setBackgroundDrawable(new ColorDrawable(0x80000000));
1544         }
1545 
1546         mModeListView = (ModeListView) findViewById(R.id.mode_list_layout);
1547         mModeListView.init(mModuleManager.getSupportedModeIndexList());
1548         if (ApiHelper.HAS_ROTATION_ANIMATION) {
1549             setRotationAnimation();
1550         }
1551         mModeListView.setVisibilityChangedListener(new ModeListVisibilityChangedListener() {
1552             @Override
1553             public void onVisibilityChanged(boolean visible) {
1554                 mModeListVisible = visible;
1555                 mCameraAppUI.setShutterButtonImportantToA11y(!visible);
1556                 updatePreviewVisibility();
1557             }
1558         });
1559 
1560         // Check if this is in the secure camera mode.
1561         Intent intent = getIntent();
1562         String action = intent.getAction();
1563         if (INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE.equals(action)
1564                 || ACTION_IMAGE_CAPTURE_SECURE.equals(action)) {
1565             mSecureCamera = true;
1566         } else {
1567             mSecureCamera = intent.getBooleanExtra(SECURE_CAMERA_EXTRA, false);
1568         }
1569 
1570         if (mSecureCamera) {
1571             // Change the window flags so that secure camera can show when
1572             // locked
1573             Window win = getWindow();
1574             WindowManager.LayoutParams params = win.getAttributes();
1575             params.flags |= WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
1576             win.setAttributes(params);
1577 
1578             // Filter for screen off so that we can finish secure camera
1579             // activity when screen is off.
1580             IntentFilter filter_screen_off = new IntentFilter(Intent.ACTION_SCREEN_OFF);
1581             registerReceiver(mShutdownReceiver, filter_screen_off);
1582 
1583             // Filter for phone unlock so that we can finish secure camera
1584             // via this UI path:
1585             //    1. from secure lock screen, user starts secure camera
1586             //    2. user presses home button
1587             //    3. user unlocks phone
1588             IntentFilter filter_user_unlock = new IntentFilter(Intent.ACTION_USER_PRESENT);
1589             registerReceiver(mShutdownReceiver, filter_user_unlock);
1590         }
1591         mCameraAppUI = new CameraAppUI(this,
1592                 (MainActivityLayout) findViewById(R.id.activity_root_view), isCaptureIntent());
1593 
1594         mCameraAppUI.setFilmstripBottomControlsListener(mMyFilmstripBottomControlListener);
1595 
1596         mAboveFilmstripControlLayout =
1597                 (FrameLayout) findViewById(R.id.camera_filmstrip_content_layout);
1598 
1599         // Add the session listener so we can track the session progress
1600         // updates.
1601         getServices().getCaptureSessionManager().addSessionListener(mSessionListener);
1602         mFilmstripController = ((FilmstripView) findViewById(R.id.filmstrip_view)).getController();
1603         mFilmstripController.setImageGap(
1604                 getResources().getDimensionPixelSize(R.dimen.camera_film_strip_gap));
1605         profile.mark("Configure Camera UI");
1606 
1607         mPanoramaViewHelper = new PanoramaViewHelper(this);
1608         mPanoramaViewHelper.onCreate();
1609 
1610         ContentResolver appContentResolver = mAppContext.getContentResolver();
1611         GlideFilmstripManager glideManager = new GlideFilmstripManager(mAppContext);
1612         mPhotoItemFactory = new PhotoItemFactory(mAppContext, glideManager, appContentResolver,
1613               new PhotoDataFactory());
1614         mVideoItemFactory = new VideoItemFactory(mAppContext, glideManager, appContentResolver,
1615               new VideoDataFactory());
1616         mCameraAppUI.getFilmstripContentPanel().setFilmstripListener(mFilmstripListener);
1617         if (mSettingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL,
1618                                         Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING)) {
1619             mCameraAppUI.setupClingForViewer(CameraAppUI.BottomPanel.VIEWER_REFOCUS);
1620         }
1621 
1622         setModuleFromModeIndex(getModeIndex());
1623 
1624         profile.mark();
1625         mCameraAppUI.prepareModuleUI();
1626         profile.mark("Init Current Module UI");
1627         mCurrentModule.init(this, isSecureCamera(), isCaptureIntent());
1628         profile.mark("Init CurrentModule");
1629 
1630         preloadFilmstripItems();
1631 
1632         setupNfcBeamPush();
1633 
1634         mLocalImagesObserver = new FilmstripContentObserver();
1635         mLocalVideosObserver = new FilmstripContentObserver();
1636 
1637         getContentResolver().registerContentObserver(
1638                 MediaStore.Images.Media.EXTERNAL_CONTENT_URI, true,
1639                 mLocalImagesObserver);
1640         getContentResolver().registerContentObserver(
1641               MediaStore.Video.Media.EXTERNAL_CONTENT_URI, true,
1642               mLocalVideosObserver);
1643 
1644         mMemoryManager = getServices().getMemoryManager();
1645 
1646         AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() {
1647             @Override
1648             public void run() {
1649                 HashMap memoryData = mMemoryManager.queryMemory();
1650                 UsageStatistics.instance().reportMemoryConsumed(memoryData,
1651                       MemoryQuery.REPORT_LABEL_LAUNCH);
1652             }
1653         });
1654 
1655         mMotionManager = getServices().getMotionManager();
1656 
1657         mFirstRunDialog = new FirstRunDialog(this,
1658               getAndroidContext(),
1659               mResolutionSetting,
1660               mSettingsManager,
1661               mOneCameraManager,
1662               new FirstRunDialog.FirstRunDialogListener() {
1663             @Override
1664             public void onFirstRunStateReady() {
1665                 // Run normal resume tasks.
1666                 resume();
1667             }
1668 
1669             @Override
1670             public void onFirstRunDialogCancelled() {
1671                 // App isn't functional until users finish first run dialog.
1672                 // We need to finish here since users hit back button during
1673                 // first run dialog (b/19593942).
1674                 finish();
1675             }
1676 
1677             @Override
1678             public void onCameraAccessException() {
1679                 mFatalErrorHandler.onGenericCameraAccessFailure();
1680             }
1681         });
1682         profile.stop();
1683     }
1684 
1685     /**
1686      * Get the current mode index from the Intent or from persistent
1687      * settings.
1688      */
getModeIndex()1689     private int getModeIndex() {
1690         int modeIndex = -1;
1691         int photoIndex = getResources().getInteger(R.integer.camera_mode_photo);
1692         int videoIndex = getResources().getInteger(R.integer.camera_mode_video);
1693         int gcamIndex = getResources().getInteger(R.integer.camera_mode_gcam);
1694         int captureIntentIndex =
1695                 getResources().getInteger(R.integer.camera_mode_capture_intent);
1696         String intentAction = getIntent().getAction();
1697         if (MediaStore.INTENT_ACTION_VIDEO_CAMERA.equals(intentAction)
1698                 || MediaStore.ACTION_VIDEO_CAPTURE.equals(intentAction)) {
1699             modeIndex = videoIndex;
1700         } else if (MediaStore.ACTION_IMAGE_CAPTURE.equals(intentAction)
1701                 || MediaStore.ACTION_IMAGE_CAPTURE_SECURE.equals(intentAction)) {
1702             // Capture intent.
1703             modeIndex = captureIntentIndex;
1704         } else if (MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA.equals(intentAction)
1705                 ||MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE.equals(intentAction)
1706                 || MediaStore.ACTION_IMAGE_CAPTURE_SECURE.equals(intentAction)) {
1707             modeIndex = mSettingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
1708                 Keys.KEY_CAMERA_MODULE_LAST_USED);
1709 
1710             // For upgraders who have not seen the aspect ratio selection screen,
1711             // we need to drop them back in the photo module and have them select
1712             // aspect ratio.
1713             // TODO: Move this to SettingsManager as an upgrade procedure.
1714             if (!mSettingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL,
1715                     Keys.KEY_USER_SELECTED_ASPECT_RATIO)) {
1716                 modeIndex = photoIndex;
1717             }
1718         } else {
1719             // If the activity has not been started using an explicit intent,
1720             // read the module index from the last time the user changed modes
1721             modeIndex = mSettingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
1722                                                     Keys.KEY_STARTUP_MODULE_INDEX);
1723             if ((modeIndex == gcamIndex &&
1724                     !GcamHelper.hasGcamAsSeparateModule(mFeatureConfig)) || modeIndex < 0) {
1725                 modeIndex = photoIndex;
1726             }
1727         }
1728         return modeIndex;
1729     }
1730 
1731     /**
1732      * Call this whenever the mode drawer or filmstrip change the visibility
1733      * state.
1734      */
updatePreviewVisibility()1735     private void updatePreviewVisibility() {
1736         if (mCurrentModule == null) {
1737             return;
1738         }
1739 
1740         int visibility = getPreviewVisibility();
1741         mCameraAppUI.onPreviewVisiblityChanged(visibility);
1742         updatePreviewRendering(visibility);
1743         mCurrentModule.onPreviewVisibilityChanged(visibility);
1744     }
1745 
updatePreviewRendering(int visibility)1746     private void updatePreviewRendering(int visibility) {
1747         if (visibility == ModuleController.VISIBILITY_HIDDEN) {
1748             mCameraAppUI.pausePreviewRendering();
1749         } else {
1750             mCameraAppUI.resumePreviewRendering();
1751         }
1752     }
1753 
getPreviewVisibility()1754     private int getPreviewVisibility() {
1755         if (mFilmstripCoversPreview) {
1756             return ModuleController.VISIBILITY_HIDDEN;
1757         } else if (mModeListVisible){
1758             return ModuleController.VISIBILITY_COVERED;
1759         } else {
1760             return ModuleController.VISIBILITY_VISIBLE;
1761         }
1762     }
1763 
setRotationAnimation()1764     private void setRotationAnimation() {
1765         int rotationAnimation = WindowManager.LayoutParams.ROTATION_ANIMATION_ROTATE;
1766         rotationAnimation = WindowManager.LayoutParams.ROTATION_ANIMATION_CROSSFADE;
1767         Window win = getWindow();
1768         WindowManager.LayoutParams winParams = win.getAttributes();
1769         winParams.rotationAnimation = rotationAnimation;
1770         win.setAttributes(winParams);
1771     }
1772 
1773     @Override
onUserInteraction()1774     public void onUserInteraction() {
1775         super.onUserInteraction();
1776         if (!isFinishing()) {
1777             keepScreenOnForAWhile();
1778         }
1779     }
1780 
1781     @Override
dispatchTouchEvent(MotionEvent ev)1782     public boolean dispatchTouchEvent(MotionEvent ev) {
1783         boolean result = super.dispatchTouchEvent(ev);
1784         if (ev.getActionMasked() == MotionEvent.ACTION_DOWN) {
1785             // Real deletion is postponed until the next user interaction after
1786             // the gesture that triggers deletion. Until real deletion is
1787             // performed, users can click the undo button to bring back the
1788             // image that they chose to delete.
1789             if (mPendingDeletion && !mIsUndoingDeletion) {
1790                 performDeletion();
1791             }
1792         }
1793         return result;
1794     }
1795 
1796     @Override
onPauseTasks()1797     public void onPauseTasks() {
1798         CameraPerformanceTracker.onEvent(CameraPerformanceTracker.ACTIVITY_PAUSE);
1799         Profile profile = mProfiler.create("CameraActivity.onPause").start();
1800 
1801         /*
1802          * Save the last module index after all secure camera and icon launches,
1803          * not just on mode switches.
1804          *
1805          * Right now we exclude capture intents from this logic, because we also
1806          * ignore the cross-Activity recovery logic in onStart for capture intents.
1807          */
1808         if (!isCaptureIntent()) {
1809             mSettingsManager.set(SettingsManager.SCOPE_GLOBAL,
1810                                  Keys.KEY_STARTUP_MODULE_INDEX,
1811                 mCurrentModeIndex);
1812         }
1813 
1814         mPaused = true;
1815         mCameraAppUI.hideCaptureIndicator();
1816         mFirstRunDialog.dismiss();
1817 
1818         // Delete photos that are pending deletion
1819         performDeletion();
1820         mCurrentModule.pause();
1821         mOrientationManager.pause();
1822         mPanoramaViewHelper.onPause();
1823 
1824         mLocalImagesObserver.setForegroundChangeListener(null);
1825         mLocalImagesObserver.setActivityPaused(true);
1826         mLocalVideosObserver.setActivityPaused(true);
1827         if (mPreloader != null) {
1828             mPreloader.cancelAllLoads();
1829         }
1830         resetScreenOn();
1831 
1832         mMotionManager.stop();
1833 
1834         // Always stop recording location when paused. Resume will start
1835         // location recording again if the location setting is on.
1836         mLocationManager.recordLocation(false);
1837 
1838         UsageStatistics.instance().backgrounded();
1839 
1840         // Camera is in fatal state. A fatal dialog is presented to users, but users just hit home
1841         // button. Let's just kill the process.
1842         if (mCameraFatalError && !isFinishing()) {
1843             Log.v(TAG, "onPause when camera is in fatal state, call Activity.finish()");
1844             finish();
1845         } else {
1846             // Close the camera and wait for the operation done.
1847             Log.v(TAG, "onPause closing camera");
1848             if (mCameraController != null) {
1849                 mCameraController.closeCamera(true);
1850             }
1851         }
1852 
1853         profile.stop();
1854     }
1855 
1856     @Override
onResumeTasks()1857     public void onResumeTasks() {
1858         mPaused = false;
1859         checkPermissions();
1860         if (!mHasCriticalPermissions) {
1861             Log.v(TAG, "onResume: Missing critical permissions.");
1862             finish();
1863             return;
1864         }
1865         if (!mSecureCamera) {
1866             // Show the dialog if necessary. The rest resume logic will be invoked
1867             // at the onFirstRunStateReady() callback.
1868             try {
1869                 mFirstRunDialog.showIfNecessary();
1870             } catch (AssertionError e) {
1871                 Log.e(TAG, "Creating camera controller failed.", e);
1872                 mFatalErrorHandler.onGenericCameraAccessFailure();
1873             }
1874         } else {
1875             // In secure mode from lockscreen, we go straight to camera and will
1876             // show first run dialog next time user enters launcher.
1877             Log.v(TAG, "in secure mode, skipping first run dialog check");
1878             resume();
1879         }
1880     }
1881 
1882     /**
1883      * Checks if any of the needed Android runtime permissions are missing.
1884      * If they are, then launch the permissions activity under one of the following conditions:
1885      * a) The permissions dialogs have not run yet. We will ask for permission only once.
1886      * b) If the missing permissions are critical to the app running, we will display a fatal error dialog.
1887      * Critical permissions are: camera, microphone and storage. The app cannot run without them.
1888      * Non-critical permission is location.
1889      */
checkPermissions()1890     private void checkPermissions() {
1891         if (!ApiHelper.isMOrHigher()) {
1892             Log.v(TAG, "not running on M, skipping permission checks");
1893             mHasCriticalPermissions = true;
1894             return;
1895         }
1896 
1897         if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED &&
1898                 checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED &&
1899                 checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
1900             mHasCriticalPermissions = true;
1901         } else {
1902             mHasCriticalPermissions = false;
1903         }
1904 
1905         if ((checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
1906                 !mSettingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL, Keys.KEY_HAS_SEEN_PERMISSIONS_DIALOGS)) ||
1907                 !mHasCriticalPermissions) {
1908             Intent intent = new Intent(this, PermissionsActivity.class);
1909             startActivity(intent);
1910             finish();
1911         }
1912     }
1913 
preloadFilmstripItems()1914     private void preloadFilmstripItems() {
1915         if (mDataAdapter == null) {
1916             mDataAdapter = new CameraFilmstripDataAdapter(mAppContext,
1917                     mPhotoItemFactory, mVideoItemFactory);
1918             mDataAdapter.setLocalDataListener(mFilmstripItemListener);
1919             mPreloader = new Preloader<Integer, AsyncTask>(FILMSTRIP_PRELOAD_AHEAD_ITEMS, mDataAdapter,
1920                     mDataAdapter);
1921             if (!mSecureCamera) {
1922                 mFilmstripController.setDataAdapter(mDataAdapter);
1923                 if (!isCaptureIntent()) {
1924                     mDataAdapter.requestLoad(new Callback<Void>() {
1925                         @Override
1926                         public void onCallback(Void result) {
1927                             fillTemporarySessions();
1928                         }
1929                     });
1930                 }
1931             } else {
1932                 // Put a lock placeholder as the last image by setting its date to
1933                 // 0.
1934                 ImageView v = (ImageView) getLayoutInflater().inflate(
1935                         R.layout.secure_album_placeholder, null);
1936                 v.setTag(R.id.mediadata_tag_viewtype, FilmstripItemType.SECURE_ALBUM_PLACEHOLDER.ordinal());
1937                 v.setOnClickListener(new View.OnClickListener() {
1938                     @Override
1939                     public void onClick(View view) {
1940                         UsageStatistics.instance().changeScreen(NavigationChange.Mode.GALLERY,
1941                                 NavigationChange.InteractionCause.BUTTON);
1942                         startGallery();
1943                         finish();
1944                     }
1945                 });
1946                 v.setContentDescription(getString(R.string.accessibility_unlock_to_camera));
1947                 mDataAdapter = new FixedLastProxyAdapter(
1948                         mAppContext,
1949                         mDataAdapter,
1950                         new PlaceholderItem(
1951                                 v,
1952                                 FilmstripItemType.SECURE_ALBUM_PLACEHOLDER,
1953                                 v.getDrawable().getIntrinsicWidth(),
1954                                 v.getDrawable().getIntrinsicHeight()));
1955                 // Flush out all the original data.
1956                 mDataAdapter.clear();
1957                 mFilmstripController.setDataAdapter(mDataAdapter);
1958             }
1959         }
1960     }
1961 
resume()1962     private void resume() {
1963         Profile profile = mProfiler.create("CameraActivity.resume").start();
1964         CameraPerformanceTracker.onEvent(CameraPerformanceTracker.ACTIVITY_RESUME);
1965         Log.v(TAG, "Build info: " + Build.DISPLAY);
1966         updateStorageSpaceAndHint(null);
1967 
1968         mLastLayoutOrientation = getResources().getConfiguration().orientation;
1969 
1970         // TODO: Handle this in OrientationManager.
1971         // Auto-rotate off
1972         if (Settings.System.getInt(getContentResolver(),
1973                 Settings.System.ACCELEROMETER_ROTATION, 0) == 0) {
1974             setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
1975             mAutoRotateScreen = false;
1976         } else {
1977             setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR);
1978             mAutoRotateScreen = true;
1979         }
1980 
1981         // Foreground event logging.  ACTION_STILL_IMAGE_CAMERA and
1982         // INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE are double logged due to
1983         // lockscreen onResume->onPause->onResume sequence.
1984         int source;
1985         String action = getIntent().getAction();
1986         if (action == null) {
1987             source = ForegroundSource.UNKNOWN_SOURCE;
1988         } else {
1989             switch (action) {
1990                 case MediaStore.ACTION_IMAGE_CAPTURE:
1991                     source = ForegroundSource.ACTION_IMAGE_CAPTURE;
1992                     break;
1993                 case MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA:
1994                     // was UNKNOWN_SOURCE in Fishlake.
1995                     source = ForegroundSource.ACTION_STILL_IMAGE_CAMERA;
1996                     break;
1997                 case MediaStore.INTENT_ACTION_VIDEO_CAMERA:
1998                     // was UNKNOWN_SOURCE in Fishlake.
1999                     source = ForegroundSource.ACTION_VIDEO_CAMERA;
2000                     break;
2001                 case MediaStore.ACTION_VIDEO_CAPTURE:
2002                     source = ForegroundSource.ACTION_VIDEO_CAPTURE;
2003                     break;
2004                 case MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE:
2005                     // was ACTION_IMAGE_CAPTURE_SECURE in Fishlake.
2006                     source = ForegroundSource.ACTION_STILL_IMAGE_CAMERA_SECURE;
2007                     break;
2008                 case MediaStore.ACTION_IMAGE_CAPTURE_SECURE:
2009                     source = ForegroundSource.ACTION_IMAGE_CAPTURE_SECURE;
2010                     break;
2011                 case Intent.ACTION_MAIN:
2012                     source = ForegroundSource.ACTION_MAIN;
2013                     break;
2014                 default:
2015                     source = ForegroundSource.UNKNOWN_SOURCE;
2016                     break;
2017             }
2018         }
2019         UsageStatistics.instance().foregrounded(source, currentUserInterfaceMode(),
2020                 isKeyguardSecure(), isKeyguardLocked(),
2021                 mStartupOnCreate, mExecutionStartNanoTime);
2022 
2023         mGalleryIntent = IntentHelper.getGalleryIntent(mAppContext);
2024         if (ApiHelper.isLOrHigher()) {
2025             // hide the up affordance for L devices, it's not very Materially
2026             mActionBar.setDisplayShowHomeEnabled(false);
2027         }
2028 
2029         mOrientationManager.resume();
2030 
2031         mCurrentModule.hardResetSettings(mSettingsManager);
2032 
2033         profile.mark();
2034         mCurrentModule.resume();
2035         UsageStatistics.instance().changeScreen(currentUserInterfaceMode(),
2036                 NavigationChange.InteractionCause.BUTTON);
2037         setSwipingEnabled(true);
2038         profile.mark("mCurrentModule.resume");
2039 
2040         if (!mResetToPreviewOnResume) {
2041             FilmstripItem item = mDataAdapter.getItemAt(
2042                   mFilmstripController.getCurrentAdapterIndex());
2043             if (item != null) {
2044                 mDataAdapter.refresh(item.getData().getUri());
2045             }
2046         }
2047 
2048         // The share button might be disabled to avoid double tapping.
2049         mCameraAppUI.getFilmstripBottomControls().setShareEnabled(true);
2050         // Default is showing the preview, unless disabled by explicitly
2051         // starting an activity we want to return from to the filmstrip rather
2052         // than the preview.
2053         mResetToPreviewOnResume = true;
2054 
2055         if (mLocalVideosObserver.isMediaDataChangedDuringPause()
2056                 || mLocalImagesObserver.isMediaDataChangedDuringPause()) {
2057             if (!mSecureCamera) {
2058                 // If it's secure camera, requestLoad() should not be called
2059                 // as it will load all the data.
2060                 if (!mFilmstripVisible) {
2061                     mDataAdapter.requestLoad(new Callback<Void>() {
2062                         @Override
2063                         public void onCallback(Void result) {
2064                             fillTemporarySessions();
2065                         }
2066                     });
2067                 } else {
2068                     mDataAdapter.requestLoadNewPhotos();
2069                 }
2070             }
2071         }
2072         mLocalImagesObserver.setActivityPaused(false);
2073         mLocalVideosObserver.setActivityPaused(false);
2074         if (!mSecureCamera) {
2075             mLocalImagesObserver.setForegroundChangeListener(
2076                     new FilmstripContentObserver.ChangeListener() {
2077                 @Override
2078                 public void onChange() {
2079                     mDataAdapter.requestLoadNewPhotos();
2080                 }
2081             });
2082         }
2083 
2084         keepScreenOnForAWhile();
2085 
2086         // Lights-out mode at all times.
2087         final View rootView = findViewById(R.id.activity_root_view);
2088         mLightsOutRunnable.run();
2089         getWindow().getDecorView().setOnSystemUiVisibilityChangeListener(
2090               new OnSystemUiVisibilityChangeListener() {
2091                   @Override
2092                   public void onSystemUiVisibilityChange(int visibility) {
2093                       mMainHandler.removeCallbacks(mLightsOutRunnable);
2094                       mMainHandler.postDelayed(mLightsOutRunnable, LIGHTS_OUT_DELAY_MS);
2095                   }
2096               });
2097 
2098         profile.mark();
2099         mPanoramaViewHelper.onResume();
2100         profile.mark("mPanoramaViewHelper.onResume()");
2101 
2102         ReleaseHelper.showReleaseInfoDialogOnStart(this, mSettingsManager);
2103         // Enable location recording if the setting is on.
2104         final boolean locationRecordingEnabled =
2105                 mSettingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION);
2106         mLocationManager.recordLocation(locationRecordingEnabled);
2107 
2108         final int previewVisibility = getPreviewVisibility();
2109         updatePreviewRendering(previewVisibility);
2110 
2111         mMotionManager.start();
2112         profile.stop();
2113     }
2114 
fillTemporarySessions()2115     private void fillTemporarySessions() {
2116         if (mSecureCamera) {
2117             return;
2118         }
2119         // There might be sessions still in flight (processed by our service).
2120         // Make sure they're added to the filmstrip.
2121         getServices().getCaptureSessionManager().fillTemporarySession(mSessionListener);
2122     }
2123 
2124     @Override
onStartTasks()2125     public void onStartTasks() {
2126         mIsActivityRunning = true;
2127         mPanoramaViewHelper.onStart();
2128 
2129         /*
2130          * If we're starting after launching a different Activity (lockscreen),
2131          * we need to use the last mode used in the other Activity, and
2132          * not the old one from this Activity.
2133          *
2134          * This needs to happen before CameraAppUI.resume() in order to set the
2135          * mode cover icon to the actual last mode used.
2136          *
2137          * Right now we exclude capture intents from this logic.
2138          */
2139         int modeIndex = getModeIndex();
2140         if (!isCaptureIntent() && mCurrentModeIndex != modeIndex) {
2141             onModeSelected(modeIndex);
2142         }
2143 
2144         if (mResetToPreviewOnResume) {
2145             mCameraAppUI.resume();
2146             mResetToPreviewOnResume = false;
2147         }
2148     }
2149 
2150     @Override
onStopTasks()2151     protected void onStopTasks() {
2152         mIsActivityRunning = false;
2153         mPanoramaViewHelper.onStop();
2154 
2155         mLocationManager.disconnect();
2156     }
2157 
2158     @Override
onDestroyTasks()2159     public void onDestroyTasks() {
2160         if (mSecureCamera) {
2161             unregisterReceiver(mShutdownReceiver);
2162         }
2163 
2164         // Ensure anything that checks for "isPaused" returns true.
2165         mPaused = true;
2166 
2167         mSettingsManager.removeAllListeners();
2168         if (mCameraController != null) {
2169             mCameraController.removeCallbackReceiver();
2170             mCameraController.setCameraExceptionHandler(null);
2171         }
2172         if (mLocalImagesObserver != null) {
2173             getContentResolver().unregisterContentObserver(mLocalImagesObserver);
2174         }
2175         if (mLocalVideosObserver != null) {
2176             getContentResolver().unregisterContentObserver(mLocalVideosObserver);
2177         }
2178         getServices().getCaptureSessionManager().removeSessionListener(mSessionListener);
2179         if (mCameraAppUI != null) {
2180             mCameraAppUI.onDestroy();
2181         }
2182         if (mModeListView != null) {
2183             mModeListView.setVisibilityChangedListener(null);
2184         }
2185         mCameraController = null;
2186         mSettingsManager = null;
2187         mOrientationManager = null;
2188         mButtonManager = null;
2189         if (mSoundPlayer != null) {
2190           mSoundPlayer.release();
2191         }
2192         CameraAgentFactory.recycle(CameraAgentFactory.CameraApi.API_1);
2193         CameraAgentFactory.recycle(CameraAgentFactory.CameraApi.AUTO);
2194     }
2195 
2196     @Override
onConfigurationChanged(Configuration config)2197     public void onConfigurationChanged(Configuration config) {
2198         super.onConfigurationChanged(config);
2199         Log.v(TAG, "onConfigurationChanged");
2200         if (config.orientation == Configuration.ORIENTATION_UNDEFINED) {
2201             return;
2202         }
2203 
2204         if (mLastLayoutOrientation != config.orientation) {
2205             mLastLayoutOrientation = config.orientation;
2206             mCurrentModule.onLayoutOrientationChanged(
2207                     mLastLayoutOrientation == Configuration.ORIENTATION_LANDSCAPE);
2208         }
2209     }
2210 
2211     @Override
onKeyDown(int keyCode, KeyEvent event)2212     public boolean onKeyDown(int keyCode, KeyEvent event) {
2213         if (!mFilmstripVisible) {
2214             if (mCurrentModule.onKeyDown(keyCode, event)) {
2215                 return true;
2216             }
2217             // Prevent software keyboard or voice search from showing up.
2218             if (keyCode == KeyEvent.KEYCODE_SEARCH
2219                     || keyCode == KeyEvent.KEYCODE_MENU) {
2220                 if (event.isLongPress()) {
2221                     return true;
2222                 }
2223             }
2224         }
2225 
2226         return super.onKeyDown(keyCode, event);
2227     }
2228 
2229     @Override
onKeyUp(int keyCode, KeyEvent event)2230     public boolean onKeyUp(int keyCode, KeyEvent event) {
2231         if (!mFilmstripVisible) {
2232             // If a module is in the middle of capture, it should
2233             // consume the key event.
2234             if (mCurrentModule.onKeyUp(keyCode, event)) {
2235                 return true;
2236             } else if (keyCode == KeyEvent.KEYCODE_MENU
2237                     || keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
2238                 // Let the mode list view consume the event.
2239                 mCameraAppUI.openModeList();
2240                 return true;
2241             } else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
2242                 mCameraAppUI.showFilmstrip();
2243                 return true;
2244             }
2245         } else {
2246             if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
2247                 mFilmstripController.goToNextItem();
2248                 return true;
2249             } else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
2250                 boolean wentToPrevious = mFilmstripController.goToPreviousItem();
2251                 if (!wentToPrevious) {
2252                   // at beginning of filmstrip, hide and go back to preview
2253                   mCameraAppUI.hideFilmstrip();
2254                 }
2255                 return true;
2256             }
2257         }
2258         return super.onKeyUp(keyCode, event);
2259     }
2260 
2261     @Override
onBackPressed()2262     public void onBackPressed() {
2263         if (!mCameraAppUI.onBackPressed()) {
2264             if (!mCurrentModule.onBackPressed()) {
2265                 super.onBackPressed();
2266             }
2267         }
2268     }
2269 
2270     @Override
isAutoRotateScreen()2271     public boolean isAutoRotateScreen() {
2272         // TODO: Move to OrientationManager.
2273         return mAutoRotateScreen;
2274     }
2275 
2276     @Override
onCreateOptionsMenu(Menu menu)2277     public boolean onCreateOptionsMenu(Menu menu) {
2278         MenuInflater inflater = getMenuInflater();
2279         inflater.inflate(R.menu.filmstrip_menu, menu);
2280         mActionBarMenu = menu;
2281 
2282         // add a button for launching the gallery
2283         if (mGalleryIntent != null) {
2284             CharSequence appName =  IntentHelper.getGalleryAppName(mAppContext, mGalleryIntent);
2285             if (appName != null) {
2286                 MenuItem menuItem = menu.add(appName);
2287                 menuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
2288                 menuItem.setIntent(mGalleryIntent);
2289 
2290                 Drawable galleryLogo = IntentHelper.getGalleryIcon(mAppContext, mGalleryIntent);
2291                 if (galleryLogo != null) {
2292                     menuItem.setIcon(galleryLogo);
2293                 }
2294             }
2295         }
2296 
2297         return super.onCreateOptionsMenu(menu);
2298     }
2299 
2300     @Override
onPrepareOptionsMenu(Menu menu)2301     public boolean onPrepareOptionsMenu(Menu menu) {
2302         if (isSecureCamera() && !ApiHelper.isLOrHigher()) {
2303             // Compatibility pre-L: launching new activities right above
2304             // lockscreen does not reliably work, only show help if not secure
2305             menu.removeItem(R.id.action_help_and_feedback);
2306         }
2307 
2308         return super.onPrepareOptionsMenu(menu);
2309     }
2310 
getStorageSpaceBytes()2311     protected long getStorageSpaceBytes() {
2312         synchronized (mStorageSpaceLock) {
2313             return mStorageSpaceBytes;
2314         }
2315     }
2316 
2317     protected interface OnStorageUpdateDoneListener {
onStorageUpdateDone(long bytes)2318         public void onStorageUpdateDone(long bytes);
2319     }
2320 
updateStorageSpaceAndHint(final OnStorageUpdateDoneListener callback)2321     protected void updateStorageSpaceAndHint(final OnStorageUpdateDoneListener callback) {
2322         /*
2323          * We execute disk operations on a background thread in order to
2324          * free up the UI thread.  Synchronizing on the lock below ensures
2325          * that when getStorageSpaceBytes is called, the main thread waits
2326          * until this method has completed.
2327          *
2328          * However, .execute() does not ensure this execution block will be
2329          * run right away (.execute() schedules this AsyncTask for sometime
2330          * in the future. executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)
2331          * tries to execute the task in parellel with other AsyncTasks, but
2332          * there's still no guarantee).
2333          * e.g. don't call this then immediately call getStorageSpaceBytes().
2334          * Instead, pass in an OnStorageUpdateDoneListener.
2335          */
2336         (new AsyncTask<Void, Void, Long>() {
2337             @Override
2338             protected Long doInBackground(Void ... arg) {
2339                 synchronized (mStorageSpaceLock) {
2340                     mStorageSpaceBytes = Storage.getAvailableSpace();
2341                     return mStorageSpaceBytes;
2342                 }
2343             }
2344 
2345             @Override
2346             protected void onPostExecute(Long bytes) {
2347                 updateStorageHint(bytes);
2348                 // This callback returns after I/O to check disk, so we could be
2349                 // pausing and shutting down. If so, don't bother invoking.
2350                 if (callback != null && !mPaused) {
2351                     callback.onStorageUpdateDone(bytes);
2352                 } else {
2353                     Log.v(TAG, "ignoring storage callback after activity pause");
2354                 }
2355             }
2356         }).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
2357     }
2358 
updateStorageHint(long storageSpace)2359     protected void updateStorageHint(long storageSpace) {
2360         if (!mIsActivityRunning) {
2361             return;
2362         }
2363 
2364         String message = null;
2365         if (storageSpace == Storage.UNAVAILABLE) {
2366             message = getString(R.string.no_storage);
2367         } else if (storageSpace == Storage.PREPARING) {
2368             message = getString(R.string.preparing_sd);
2369         } else if (storageSpace == Storage.UNKNOWN_SIZE) {
2370             message = getString(R.string.access_sd_fail);
2371         } else if (storageSpace <= Storage.LOW_STORAGE_THRESHOLD_BYTES) {
2372             message = getString(R.string.spaceIsLow_content);
2373         }
2374 
2375         if (message != null) {
2376             Log.w(TAG, "Storage warning: " + message);
2377             if (mStorageHint == null) {
2378                 mStorageHint = OnScreenHint.makeText(CameraActivity.this, message);
2379             } else {
2380                 mStorageHint.setText(message);
2381             }
2382             mStorageHint.show();
2383             UsageStatistics.instance().storageWarning(storageSpace);
2384 
2385             // Disable all user interactions,
2386             mCameraAppUI.setDisableAllUserInteractions(true);
2387         } else if (mStorageHint != null) {
2388             mStorageHint.cancel();
2389             mStorageHint = null;
2390 
2391             // Re-enable all user interactions.
2392             mCameraAppUI.setDisableAllUserInteractions(false);
2393         }
2394     }
2395 
setResultEx(int resultCode)2396     protected void setResultEx(int resultCode) {
2397         mResultCodeForTesting = resultCode;
2398         setResult(resultCode);
2399     }
2400 
setResultEx(int resultCode, Intent data)2401     protected void setResultEx(int resultCode, Intent data) {
2402         mResultCodeForTesting = resultCode;
2403         mResultDataForTesting = data;
2404         setResult(resultCode, data);
2405     }
2406 
getResultCode()2407     public int getResultCode() {
2408         return mResultCodeForTesting;
2409     }
2410 
getResultData()2411     public Intent getResultData() {
2412         return mResultDataForTesting;
2413     }
2414 
isSecureCamera()2415     public boolean isSecureCamera() {
2416         return mSecureCamera;
2417     }
2418 
2419     @Override
isPaused()2420     public boolean isPaused() {
2421         return mPaused;
2422     }
2423 
2424     @Override
getPreferredChildModeIndex(int modeIndex)2425     public int getPreferredChildModeIndex(int modeIndex) {
2426         if (modeIndex == getResources().getInteger(R.integer.camera_mode_photo)) {
2427             boolean hdrPlusOn = Keys.isHdrPlusOn(mSettingsManager);
2428             if (hdrPlusOn && GcamHelper.hasGcamAsSeparateModule(mFeatureConfig)) {
2429                 modeIndex = getResources().getInteger(R.integer.camera_mode_gcam);
2430             }
2431         }
2432         return modeIndex;
2433     }
2434 
2435     @Override
onModeSelected(int modeIndex)2436     public void onModeSelected(int modeIndex) {
2437         if (mCurrentModeIndex == modeIndex) {
2438             return;
2439         }
2440 
2441         CameraPerformanceTracker.onEvent(CameraPerformanceTracker.MODE_SWITCH_START);
2442         // Record last used camera mode for quick switching
2443         if (modeIndex == getResources().getInteger(R.integer.camera_mode_photo)
2444                 || modeIndex == getResources().getInteger(R.integer.camera_mode_gcam)) {
2445             mSettingsManager.set(SettingsManager.SCOPE_GLOBAL,
2446                                  Keys.KEY_CAMERA_MODULE_LAST_USED,
2447                                  modeIndex);
2448         }
2449 
2450         closeModule(mCurrentModule);
2451 
2452         // Select the correct module index from the mode switcher index.
2453         modeIndex = getPreferredChildModeIndex(modeIndex);
2454         setModuleFromModeIndex(modeIndex);
2455 
2456         mCameraAppUI.resetBottomControls(mCurrentModule, modeIndex);
2457         mCameraAppUI.addShutterListener(mCurrentModule);
2458         openModule(mCurrentModule);
2459         // Store the module index so we can use it the next time the Camera
2460         // starts up.
2461         mSettingsManager.set(SettingsManager.SCOPE_GLOBAL,
2462                              Keys.KEY_STARTUP_MODULE_INDEX, modeIndex);
2463     }
2464 
2465     /**
2466      * Shows the settings dialog.
2467      */
2468     @Override
onSettingsSelected()2469     public void onSettingsSelected() {
2470         UsageStatistics.instance().controlUsed(
2471                 eventprotos.ControlEvent.ControlType.OVERALL_SETTINGS);
2472         Intent intent = new Intent(this, CameraSettingsActivity.class);
2473         startActivity(intent);
2474     }
2475 
2476     @Override
freezeScreenUntilPreviewReady()2477     public void freezeScreenUntilPreviewReady() {
2478         mCameraAppUI.freezeScreenUntilPreviewReady();
2479     }
2480 
2481     @Override
getModuleId(int modeIndex)2482     public int getModuleId(int modeIndex) {
2483         ModuleManagerImpl.ModuleAgent agent = mModuleManager.getModuleAgent(modeIndex);
2484         if (agent == null) {
2485             return -1;
2486         }
2487         return agent.getModuleId();
2488     }
2489 
2490     /**
2491      * Sets the mCurrentModuleIndex, creates a new module instance for the given
2492      * index an sets it as mCurrentModule.
2493      */
setModuleFromModeIndex(int modeIndex)2494     private void setModuleFromModeIndex(int modeIndex) {
2495         ModuleManagerImpl.ModuleAgent agent = mModuleManager.getModuleAgent(modeIndex);
2496         if (agent == null) {
2497             return;
2498         }
2499         if (!agent.requestAppForCamera()) {
2500             mCameraController.closeCamera(true);
2501         }
2502         mCurrentModeIndex = agent.getModuleId();
2503         mCurrentModule = (CameraModule) agent.createModule(this, getIntent());
2504     }
2505 
2506     @Override
getSettingsManager()2507     public SettingsManager getSettingsManager() {
2508         return mSettingsManager;
2509     }
2510 
2511     @Override
getResolutionSetting()2512     public ResolutionSetting getResolutionSetting() {
2513         return mResolutionSetting;
2514     }
2515 
2516     @Override
getServices()2517     public CameraServices getServices() {
2518         return CameraServicesImpl.instance();
2519     }
2520 
2521     @Override
getFatalErrorHandler()2522     public FatalErrorHandler getFatalErrorHandler() {
2523         return mFatalErrorHandler;
2524     }
2525 
getSupportedModeNames()2526     public List<String> getSupportedModeNames() {
2527         List<Integer> indices = mModuleManager.getSupportedModeIndexList();
2528         List<String> supported = new ArrayList<String>();
2529 
2530         for (Integer modeIndex : indices) {
2531             String name = CameraUtil.getCameraModeText(modeIndex, mAppContext);
2532             if (name != null && !name.equals("")) {
2533                 supported.add(name);
2534             }
2535         }
2536         return supported;
2537     }
2538 
2539     @Override
getButtonManager()2540     public ButtonManager getButtonManager() {
2541         if (mButtonManager == null) {
2542             mButtonManager = new ButtonManager(this);
2543         }
2544         return mButtonManager;
2545     }
2546 
2547     @Override
getSoundPlayer()2548     public SoundPlayer getSoundPlayer() {
2549         return mSoundPlayer;
2550     }
2551 
2552     /**
2553      * Launches an ACTION_EDIT intent for the given local data item. If
2554      * 'withTinyPlanet' is set, this will show a disambig dialog first to let
2555      * the user start either the tiny planet editor or another photo editor.
2556      *
2557      * @param data The data item to edit.
2558      */
launchEditor(FilmstripItem data)2559     public void launchEditor(FilmstripItem data) {
2560         Intent intent = new Intent(Intent.ACTION_EDIT)
2561                 .setDataAndType(data.getData().getUri(), data.getData().getMimeType())
2562                 .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
2563         try {
2564             launchActivityByIntent(intent);
2565         } catch (ActivityNotFoundException e) {
2566             final String msgEditWith = getResources().getString(R.string.edit_with);
2567             launchActivityByIntent(Intent.createChooser(intent, msgEditWith));
2568         }
2569     }
2570 
2571     @Override
onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo)2572     public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
2573         super.onCreateContextMenu(menu, v, menuInfo);
2574 
2575         MenuInflater inflater = getMenuInflater();
2576         inflater.inflate(R.menu.filmstrip_context_menu, menu);
2577     }
2578 
2579     @Override
onContextItemSelected(MenuItem item)2580     public boolean onContextItemSelected(MenuItem item) {
2581         switch (item.getItemId()) {
2582             case R.id.tiny_planet_editor:
2583                 mMyFilmstripBottomControlListener.onTinyPlanet();
2584                 return true;
2585             case R.id.photo_editor:
2586                 mMyFilmstripBottomControlListener.onEdit();
2587                 return true;
2588         }
2589         return false;
2590     }
2591 
2592     /**
2593      * Launch the tiny planet editor.
2594      *
2595      * @param data The data must be a 360 degree stereographically mapped
2596      *            panoramic image. It will not be modified, instead a new item
2597      *            with the result will be added to the filmstrip.
2598      */
launchTinyPlanetEditor(FilmstripItem data)2599     public void launchTinyPlanetEditor(FilmstripItem data) {
2600         TinyPlanetFragment fragment = new TinyPlanetFragment();
2601         Bundle bundle = new Bundle();
2602         bundle.putString(TinyPlanetFragment.ARGUMENT_URI, data.getData().getUri().toString());
2603         bundle.putString(TinyPlanetFragment.ARGUMENT_TITLE, data.getData().getTitle());
2604         fragment.setArguments(bundle);
2605         fragment.show(getFragmentManager(), "tiny_planet");
2606     }
2607 
2608     /**
2609      * Returns what UI mode (capture mode or filmstrip) we are in.
2610      * Returned number one of {@link com.google.common.logging.eventprotos.NavigationChange.Mode}
2611      */
currentUserInterfaceMode()2612     private int currentUserInterfaceMode() {
2613         int mode = NavigationChange.Mode.UNKNOWN_MODE;
2614         if (mCurrentModeIndex == getResources().getInteger(R.integer.camera_mode_photo)) {
2615             mode = NavigationChange.Mode.PHOTO_CAPTURE;
2616         }
2617         if (mCurrentModeIndex == getResources().getInteger(R.integer.camera_mode_video)) {
2618             mode = NavigationChange.Mode.VIDEO_CAPTURE;
2619         }
2620         if (mCurrentModeIndex == getResources().getInteger(R.integer.camera_mode_refocus)) {
2621             mode = NavigationChange.Mode.LENS_BLUR;
2622         }
2623         if (mCurrentModeIndex == getResources().getInteger(R.integer.camera_mode_gcam)) {
2624             mode = NavigationChange.Mode.HDR_PLUS;
2625         }
2626         if (mCurrentModeIndex == getResources().getInteger(R.integer.camera_mode_photosphere)) {
2627             mode = NavigationChange.Mode.PHOTO_SPHERE;
2628         }
2629         if (mCurrentModeIndex == getResources().getInteger(R.integer.camera_mode_panorama)) {
2630             mode = NavigationChange.Mode.PANORAMA;
2631         }
2632         if (mFilmstripVisible) {
2633             mode = NavigationChange.Mode.FILMSTRIP;
2634         }
2635         return mode;
2636     }
2637 
openModule(CameraModule module)2638     private void openModule(CameraModule module) {
2639         module.init(this, isSecureCamera(), isCaptureIntent());
2640         module.hardResetSettings(mSettingsManager);
2641         // Hide accessibility zoom UI by default. Modules will enable it themselves if required.
2642         getCameraAppUI().hideAccessibilityZoomUI();
2643         if (!mPaused) {
2644             module.resume();
2645             UsageStatistics.instance().changeScreen(currentUserInterfaceMode(),
2646                     NavigationChange.InteractionCause.BUTTON);
2647             updatePreviewVisibility();
2648         }
2649     }
2650 
closeModule(CameraModule module)2651     private void closeModule(CameraModule module) {
2652         module.pause();
2653         mCameraAppUI.clearModuleUI();
2654     }
2655 
performDeletion()2656     private void performDeletion() {
2657         if (!mPendingDeletion) {
2658             return;
2659         }
2660         hideUndoDeletionBar(false);
2661         mDataAdapter.executeDeletion();
2662     }
2663 
showUndoDeletionBar()2664     public void showUndoDeletionBar() {
2665         if (mPendingDeletion) {
2666             performDeletion();
2667         }
2668         Log.v(TAG, "showing undo bar");
2669         mPendingDeletion = true;
2670         if (mUndoDeletionBar == null) {
2671             ViewGroup v = (ViewGroup) getLayoutInflater().inflate(R.layout.undo_bar,
2672                     mAboveFilmstripControlLayout, true);
2673             mUndoDeletionBar = (ViewGroup) v.findViewById(R.id.camera_undo_deletion_bar);
2674             View button = mUndoDeletionBar.findViewById(R.id.camera_undo_deletion_button);
2675             button.setOnClickListener(new View.OnClickListener() {
2676                 @Override
2677                 public void onClick(View view) {
2678                     mDataAdapter.undoDeletion();
2679                     // Fix for b/21666018: When undoing a delete in Fullscreen
2680                     // mode, just flip
2681                     // back to the filmstrip to force a refresh.
2682                     if (mFilmstripController.inFullScreen()) {
2683                         mFilmstripController.goToFilmstrip();
2684                     }
2685                     hideUndoDeletionBar(true);
2686                 }
2687             });
2688             // Setting undo bar clickable to avoid touch events going through
2689             // the bar to the buttons (eg. edit button, etc) underneath the bar.
2690             mUndoDeletionBar.setClickable(true);
2691             // When there is user interaction going on with the undo button, we
2692             // do not want to hide the undo bar.
2693             button.setOnTouchListener(new View.OnTouchListener() {
2694                 @Override
2695                 public boolean onTouch(View v, MotionEvent event) {
2696                     if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
2697                         mIsUndoingDeletion = true;
2698                     } else if (event.getActionMasked() == MotionEvent.ACTION_UP) {
2699                         mIsUndoingDeletion = false;
2700                     }
2701                     return false;
2702                 }
2703             });
2704         }
2705         mUndoDeletionBar.setAlpha(0f);
2706         mUndoDeletionBar.setVisibility(View.VISIBLE);
2707         mUndoDeletionBar.animate().setDuration(200).alpha(1f).setListener(null).start();
2708     }
2709 
hideUndoDeletionBar(boolean withAnimation)2710     private void hideUndoDeletionBar(boolean withAnimation) {
2711         Log.v(TAG, "Hiding undo deletion bar");
2712         mPendingDeletion = false;
2713         if (mUndoDeletionBar != null) {
2714             if (withAnimation) {
2715                 mUndoDeletionBar.animate().setDuration(200).alpha(0f)
2716                         .setListener(new Animator.AnimatorListener() {
2717                             @Override
2718                             public void onAnimationStart(Animator animation) {
2719                                 // Do nothing.
2720                             }
2721 
2722                             @Override
2723                             public void onAnimationEnd(Animator animation) {
2724                                 mUndoDeletionBar.setVisibility(View.GONE);
2725                             }
2726 
2727                             @Override
2728                             public void onAnimationCancel(Animator animation) {
2729                                 // Do nothing.
2730                             }
2731 
2732                             @Override
2733                             public void onAnimationRepeat(Animator animation) {
2734                                 // Do nothing.
2735                             }
2736                         }).start();
2737             } else {
2738                 mUndoDeletionBar.setVisibility(View.GONE);
2739             }
2740         }
2741     }
2742 
2743     /**
2744      * Enable/disable swipe-to-filmstrip. Will always disable swipe if in
2745      * capture intent.
2746      *
2747      * @param enable {@code true} to enable swipe.
2748      */
setSwipingEnabled(boolean enable)2749     public void setSwipingEnabled(boolean enable) {
2750         // TODO: Bring back the functionality.
2751         if (isCaptureIntent()) {
2752             // lockPreview(true);
2753         } else {
2754             // lockPreview(!enable);
2755         }
2756     }
2757 
2758     // Accessor methods for getting latency times used in performance testing
getFirstPreviewTime()2759     public long getFirstPreviewTime() {
2760         if (mCurrentModule instanceof PhotoModule) {
2761             long coverHiddenTime = getCameraAppUI().getCoverHiddenTime();
2762             if (coverHiddenTime != -1) {
2763                 return coverHiddenTime - mOnCreateTime;
2764             }
2765         }
2766         return -1;
2767     }
2768 
getAutoFocusTime()2769     public long getAutoFocusTime() {
2770         return (mCurrentModule instanceof PhotoModule) ?
2771                 ((PhotoModule) mCurrentModule).mAutoFocusTime : -1;
2772     }
2773 
getShutterLag()2774     public long getShutterLag() {
2775         return (mCurrentModule instanceof PhotoModule) ?
2776                 ((PhotoModule) mCurrentModule).mShutterLag : -1;
2777     }
2778 
getShutterToPictureDisplayedTime()2779     public long getShutterToPictureDisplayedTime() {
2780         return (mCurrentModule instanceof PhotoModule) ?
2781                 ((PhotoModule) mCurrentModule).mShutterToPictureDisplayedTime : -1;
2782     }
2783 
getPictureDisplayedToJpegCallbackTime()2784     public long getPictureDisplayedToJpegCallbackTime() {
2785         return (mCurrentModule instanceof PhotoModule) ?
2786                 ((PhotoModule) mCurrentModule).mPictureDisplayedToJpegCallbackTime : -1;
2787     }
2788 
getJpegCallbackFinishTime()2789     public long getJpegCallbackFinishTime() {
2790         return (mCurrentModule instanceof PhotoModule) ?
2791                 ((PhotoModule) mCurrentModule).mJpegCallbackFinishTime : -1;
2792     }
2793 
getCaptureStartTime()2794     public long getCaptureStartTime() {
2795         return (mCurrentModule instanceof PhotoModule) ?
2796                 ((PhotoModule) mCurrentModule).mCaptureStartTime : -1;
2797     }
2798 
isRecording()2799     public boolean isRecording() {
2800         return (mCurrentModule instanceof VideoModule) ?
2801                 ((VideoModule) mCurrentModule).isRecording() : false;
2802     }
2803 
getCameraOpenErrorCallback()2804     public CameraAgent.CameraOpenCallback getCameraOpenErrorCallback() {
2805         return mCameraController;
2806     }
2807 
2808     // For debugging purposes only.
getCurrentModule()2809     public CameraModule getCurrentModule() {
2810         return mCurrentModule;
2811     }
2812 
2813     @Override
showTutorial(AbstractTutorialOverlay tutorial)2814     public void showTutorial(AbstractTutorialOverlay tutorial) {
2815         mCameraAppUI.showTutorial(tutorial, getLayoutInflater());
2816     }
2817 
2818     @Override
finishActivityWithIntentCompleted(Intent resultIntent)2819     public void finishActivityWithIntentCompleted(Intent resultIntent) {
2820         finishActivityWithIntentResult(Activity.RESULT_OK, resultIntent);
2821     }
2822 
2823     @Override
finishActivityWithIntentCanceled()2824     public void finishActivityWithIntentCanceled() {
2825         finishActivityWithIntentResult(Activity.RESULT_CANCELED, new Intent());
2826     }
2827 
finishActivityWithIntentResult(int resultCode, Intent resultIntent)2828     private void finishActivityWithIntentResult(int resultCode, Intent resultIntent) {
2829         mResultCodeForTesting = resultCode;
2830         mResultDataForTesting = resultIntent;
2831         setResult(resultCode, resultIntent);
2832         finish();
2833     }
2834 
keepScreenOnForAWhile()2835     private void keepScreenOnForAWhile() {
2836         if (mKeepScreenOn) {
2837             return;
2838         }
2839         mMainHandler.removeMessages(MSG_CLEAR_SCREEN_ON_FLAG);
2840         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
2841         mMainHandler.sendEmptyMessageDelayed(MSG_CLEAR_SCREEN_ON_FLAG, SCREEN_DELAY_MS);
2842     }
2843 
resetScreenOn()2844     private void resetScreenOn() {
2845         mKeepScreenOn = false;
2846         mMainHandler.removeMessages(MSG_CLEAR_SCREEN_ON_FLAG);
2847         getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
2848     }
2849 
2850     /**
2851      * @return {@code true} if the Gallery is launched successfully.
2852      */
startGallery()2853     private boolean startGallery() {
2854         if (mGalleryIntent == null) {
2855             return false;
2856         }
2857         try {
2858             UsageStatistics.instance().changeScreen(NavigationChange.Mode.GALLERY,
2859                     NavigationChange.InteractionCause.BUTTON);
2860             Intent startGalleryIntent = new Intent(mGalleryIntent);
2861             int currentIndex = mFilmstripController.getCurrentAdapterIndex();
2862             FilmstripItem currentFilmstripItem = mDataAdapter.getItemAt(currentIndex);
2863             if (currentFilmstripItem != null) {
2864                 GalleryHelper.setContentUri(startGalleryIntent,
2865                       currentFilmstripItem.getData().getUri());
2866             }
2867             launchActivityByIntent(startGalleryIntent);
2868         } catch (ActivityNotFoundException e) {
2869             Log.w(TAG, "Failed to launch gallery activity, closing");
2870         }
2871         return false;
2872     }
2873 
setNfcBeamPushUriFromData(FilmstripItem data)2874     private void setNfcBeamPushUriFromData(FilmstripItem data) {
2875         final Uri uri = data.getData().getUri();
2876         if (uri != Uri.EMPTY) {
2877             mNfcPushUris[0] = uri;
2878         } else {
2879             mNfcPushUris[0] = null;
2880         }
2881     }
2882 
2883     /**
2884      * Updates the visibility of the filmstrip bottom controls and action bar.
2885      */
updateUiByData(final int index)2886     private void updateUiByData(final int index) {
2887         final FilmstripItem currentData = mDataAdapter.getItemAt(index);
2888         if (currentData == null) {
2889             Log.w(TAG, "Current data ID not found.");
2890             hideSessionProgress();
2891             return;
2892         }
2893         updateActionBarMenu(currentData);
2894 
2895         /* Bottom controls. */
2896         updateBottomControlsByData(currentData);
2897 
2898         if (isSecureCamera()) {
2899             // We cannot show buttons in secure camera since go to other
2900             // activities might create a security hole.
2901             mCameraAppUI.getFilmstripBottomControls().hideControls();
2902             return;
2903         }
2904 
2905         setNfcBeamPushUriFromData(currentData);
2906 
2907         if (!mDataAdapter.isMetadataUpdatedAt(index)) {
2908             mDataAdapter.updateMetadataAt(index);
2909         }
2910     }
2911 
2912     /**
2913      * Updates the bottom controls based on the data.
2914      */
updateBottomControlsByData(final FilmstripItem currentData)2915     private void updateBottomControlsByData(final FilmstripItem currentData) {
2916 
2917         final CameraAppUI.BottomPanel filmstripBottomPanel =
2918                 mCameraAppUI.getFilmstripBottomControls();
2919         filmstripBottomPanel.showControls();
2920         filmstripBottomPanel.setEditButtonVisibility(
2921                 currentData.getAttributes().canEdit());
2922         filmstripBottomPanel.setShareButtonVisibility(
2923               currentData.getAttributes().canShare());
2924         filmstripBottomPanel.setDeleteButtonVisibility(
2925                 currentData.getAttributes().canDelete());
2926 
2927         /* Progress bar */
2928 
2929         Uri contentUri = currentData.getData().getUri();
2930         CaptureSessionManager sessionManager = getServices()
2931                 .getCaptureSessionManager();
2932 
2933         if (sessionManager.hasErrorMessage(contentUri)) {
2934             showProcessError(sessionManager.getErrorMessageId(contentUri));
2935         } else {
2936             filmstripBottomPanel.hideProgressError();
2937             CaptureSession session = sessionManager.getSession(contentUri);
2938 
2939             if (session != null) {
2940                 int sessionProgress = session.getProgress();
2941 
2942                 if (sessionProgress < 0) {
2943                     hideSessionProgress();
2944                 } else {
2945                     int progressMessageId = session.getProgressMessageId();
2946                     showSessionProgress(progressMessageId);
2947                     updateSessionProgress(sessionProgress);
2948                 }
2949             } else {
2950                 hideSessionProgress();
2951             }
2952         }
2953 
2954         /* View button */
2955 
2956         // We need to add this to a separate DB.
2957         final int viewButtonVisibility;
2958         if (currentData.getMetadata().isUsePanoramaViewer()) {
2959             viewButtonVisibility = CameraAppUI.BottomPanel.VIEWER_PHOTO_SPHERE;
2960         } else if (currentData.getMetadata().isHasRgbzData()) {
2961             viewButtonVisibility = CameraAppUI.BottomPanel.VIEWER_REFOCUS;
2962         } else {
2963             viewButtonVisibility = CameraAppUI.BottomPanel.VIEWER_NONE;
2964         }
2965 
2966         filmstripBottomPanel.setTinyPlanetEnabled(
2967                 currentData.getMetadata().isPanorama360());
2968         filmstripBottomPanel.setViewerButtonVisibility(viewButtonVisibility);
2969     }
2970 
showDetailsDialog(int index)2971     private void showDetailsDialog(int index) {
2972         final FilmstripItem data = mDataAdapter.getItemAt(index);
2973         if (data == null) {
2974             return;
2975         }
2976         Optional<MediaDetails> details = data.getMediaDetails();
2977         if (!details.isPresent()) {
2978             return;
2979         }
2980         Dialog detailDialog = DetailsDialog.create(CameraActivity.this, details.get());
2981         detailDialog.show();
2982         UsageStatistics.instance().mediaInteraction(
2983                 fileNameFromAdapterAtIndex(index), MediaInteraction.InteractionType.DETAILS,
2984                 NavigationChange.InteractionCause.BUTTON, fileAgeFromAdapterAtIndex(index));
2985     }
2986 
2987     /**
2988      * Show or hide action bar items depending on current data type.
2989      */
updateActionBarMenu(FilmstripItem data)2990     private void updateActionBarMenu(FilmstripItem data) {
2991         if (mActionBarMenu == null) {
2992             return;
2993         }
2994 
2995         MenuItem detailsMenuItem = mActionBarMenu.findItem(R.id.action_details);
2996         if (detailsMenuItem == null) {
2997             return;
2998         }
2999 
3000         boolean showDetails = data.getAttributes().hasDetailedCaptureInfo();
3001         detailsMenuItem.setVisible(showDetails);
3002     }
3003 }
3004