Home | History | Annotate | Download | only in camera
      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
    297     public CameraAppUI getCameraAppUI() {
    298         return mCameraAppUI;
    299     }
    300 
    301     @Override
    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
    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 
    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
    545     public void onCameraDisabled(int cameraId) {
    546         Log.w(TAG, "Camera disabled: " + cameraId);
    547         mFatalErrorHandler.onCameraDisabledFailure();
    548     }
    549 
    550     @Override
    551     public void onDeviceOpenFailure(int cameraId, String info) {
    552         Log.w(TAG, "Camera open failure: " + info);
    553         mFatalErrorHandler.onCameraOpenFailure();
    554     }
    555 
    556     @Override
    557     public void onDeviceOpenedAlready(int cameraId, String info) {
    558         Log.w(TAG, "Camera open already: " + cameraId + "," + info);
    559         mFatalErrorHandler.onGenericCameraAccessFailure();
    560     }
    561 
    562     @Override
    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 
    571         public MainHandler(CameraActivity activity, Looper looper) {
    572             super(looper);
    573             mActivity = new WeakReference<CameraActivity>(activity);
    574         }
    575 
    576         @Override
    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 
    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 
    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 
    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      */
    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 
    825     private void hideSessionProgress() {
    826         mCameraAppUI.getFilmstripBottomControls().hideProgress();
    827     }
    828 
    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 
    837     private void showProcessError(int messageId) {
    838         mCameraAppUI.getFilmstripBottomControls().showProgressError(
    839                 messageId > 0 ? getString(messageId) : "");
    840     }
    841 
    842     private void updateSessionProgress(int progress) {
    843         mCameraAppUI.getFilmstripBottomControls().setProgress(progress);
    844     }
    845 
    846     private void updateSessionProgressText(int messageId) {
    847         mCameraAppUI.getFilmstripBottomControls().setProgressText(
    848                 messageId > 0 ? getString(messageId) : "");
    849     }
    850 
    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
    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
   1020     public Context getAndroidContext() {
   1021         return mAppContext;
   1022     }
   1023 
   1024     @Override
   1025     public OneCameraFeatureConfig getCameraFeatureConfig() {
   1026         return mFeatureConfig;
   1027     }
   1028 
   1029     @Override
   1030     public Dialog createDialog() {
   1031         return new Dialog(this, android.R.style.Theme_Black_NoTitleBar_Fullscreen);
   1032     }
   1033 
   1034     @Override
   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
   1044     public int getCurrentModuleIndex() {
   1045         return mCurrentModeIndex;
   1046     }
   1047 
   1048     @Override
   1049     public String getModuleScope() {
   1050         ModuleAgent agent = mModuleManager.getModuleAgent(mCurrentModeIndex);
   1051         return SettingsManager.getModuleSettingScope(agent.getScopeNamespace());
   1052     }
   1053 
   1054     @Override
   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
   1072     public ModuleController getCurrentModuleController() {
   1073         return mCurrentModule;
   1074     }
   1075 
   1076     @Override
   1077     public int getQuickSwitchToModuleId(int currentModuleIndex) {
   1078         return mModuleManager.getQuickSwitchToModuleId(currentModuleIndex, mSettingsManager,
   1079                 mAppContext);
   1080     }
   1081 
   1082     @Override
   1083     public SurfaceTexture getPreviewBuffer() {
   1084         // TODO: implement this
   1085         return null;
   1086     }
   1087 
   1088     @Override
   1089     public void onPreviewReadyToStart() {
   1090         mCameraAppUI.onPreviewReadyToStart();
   1091     }
   1092 
   1093     @Override
   1094     public void onPreviewStarted() {
   1095         mCameraAppUI.onPreviewStarted();
   1096     }
   1097 
   1098     @Override
   1099     public void addPreviewAreaSizeChangedListener(
   1100             PreviewStatusListener.PreviewAreaChangedListener listener) {
   1101         mCameraAppUI.addPreviewAreaChangedListener(listener);
   1102     }
   1103 
   1104     @Override
   1105     public void removePreviewAreaSizeChangedListener(
   1106             PreviewStatusListener.PreviewAreaChangedListener listener) {
   1107         mCameraAppUI.removePreviewAreaChangedListener(listener);
   1108     }
   1109 
   1110     @Override
   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
   1124     public void updatePreviewAspectRatio(float aspectRatio) {
   1125         mCameraAppUI.updatePreviewAspectRatio(aspectRatio);
   1126     }
   1127 
   1128     @Override
   1129     public void updatePreviewTransformFullscreen(Matrix matrix, float aspectRatio) {
   1130         mCameraAppUI.updatePreviewTransformFullscreen(matrix, aspectRatio);
   1131     }
   1132 
   1133     @Override
   1134     public RectF getFullscreenRect() {
   1135         return mCameraAppUI.getFullscreenRect();
   1136     }
   1137 
   1138     @Override
   1139     public void updatePreviewTransform(Matrix matrix) {
   1140         mCameraAppUI.updatePreviewTransform(matrix);
   1141     }
   1142 
   1143     @Override
   1144     public void setPreviewStatusListener(PreviewStatusListener previewStatusListener) {
   1145         mCameraAppUI.setPreviewStatusListener(previewStatusListener);
   1146     }
   1147 
   1148     @Override
   1149     public FrameLayout getModuleLayoutRoot() {
   1150         return mCameraAppUI.getModuleRootView();
   1151     }
   1152 
   1153     @Override
   1154     public void setShutterEventsListener(ShutterEventsListener listener) {
   1155         // TODO: implement this
   1156     }
   1157 
   1158     @Override
   1159     public void setShutterEnabled(boolean enabled) {
   1160         mCameraAppUI.setShutterButtonEnabled(enabled);
   1161     }
   1162 
   1163     @Override
   1164     public boolean isShutterEnabled() {
   1165         return mCameraAppUI.isShutterButtonEnabled();
   1166     }
   1167 
   1168     @Override
   1169     public void startFlashAnimation(boolean shortFlash) {
   1170         mCameraAppUI.startFlashAnimation(shortFlash);
   1171     }
   1172 
   1173     @Override
   1174     public void startPreCaptureAnimation() {
   1175         // TODO: implement this
   1176     }
   1177 
   1178     @Override
   1179     public void cancelPreCaptureAnimation() {
   1180         // TODO: implement this
   1181     }
   1182 
   1183     @Override
   1184     public void startPostCaptureAnimation() {
   1185         // TODO: implement this
   1186     }
   1187 
   1188     @Override
   1189     public void startPostCaptureAnimation(Bitmap thumbnail) {
   1190         // TODO: implement this
   1191     }
   1192 
   1193     @Override
   1194     public void cancelPostCaptureAnimation() {
   1195         // TODO: implement this
   1196     }
   1197 
   1198     @Override
   1199     public OrientationManager getOrientationManager() {
   1200         return mOrientationManager;
   1201     }
   1202 
   1203     @Override
   1204     public LocationManager getLocationManager() {
   1205         return mLocationManager;
   1206     }
   1207 
   1208     @Override
   1209     public void lockOrientation() {
   1210         if (mOrientationManager != null) {
   1211             mOrientationManager.lockOrientation();
   1212         }
   1213     }
   1214 
   1215     @Override
   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      */
   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
   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
   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
   1327     public CameraProvider getCameraProvider() {
   1328         return mCameraController;
   1329     }
   1330 
   1331     @Override
   1332     public OneCameraOpener getCameraOpener() {
   1333         return mOneCameraOpener;
   1334     }
   1335 
   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
   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 
   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
   1425     public void onNewIntentTasks(Intent intent) {
   1426         onModeSelected(getModeIndex());
   1427     }
   1428 
   1429     @Override
   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      */
   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      */
   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 
   1746     private void updatePreviewRendering(int visibility) {
   1747         if (visibility == ModuleController.VISIBILITY_HIDDEN) {
   1748             mCameraAppUI.pausePreviewRendering();
   1749         } else {
   1750             mCameraAppUI.resumePreviewRendering();
   1751         }
   1752     }
   1753 
   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 
   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
   1774     public void onUserInteraction() {
   1775         super.onUserInteraction();
   1776         if (!isFinishing()) {
   1777             keepScreenOnForAWhile();
   1778         }
   1779     }
   1780 
   1781     @Override
   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
   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
   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      */
   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 
   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 
   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 
   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
   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
   2151     protected void onStopTasks() {
   2152         mIsActivityRunning = false;
   2153         mPanoramaViewHelper.onStop();
   2154 
   2155         mLocationManager.disconnect();
   2156     }
   2157 
   2158     @Override
   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
   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
   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
   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
   2262     public void onBackPressed() {
   2263         if (!mCameraAppUI.onBackPressed()) {
   2264             if (!mCurrentModule.onBackPressed()) {
   2265                 super.onBackPressed();
   2266             }
   2267         }
   2268     }
   2269 
   2270     @Override
   2271     public boolean isAutoRotateScreen() {
   2272         // TODO: Move to OrientationManager.
   2273         return mAutoRotateScreen;
   2274     }
   2275 
   2276     @Override
   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
   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 
   2311     protected long getStorageSpaceBytes() {
   2312         synchronized (mStorageSpaceLock) {
   2313             return mStorageSpaceBytes;
   2314         }
   2315     }
   2316 
   2317     protected interface OnStorageUpdateDoneListener {
   2318         public void onStorageUpdateDone(long bytes);
   2319     }
   2320 
   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 
   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 
   2396     protected void setResultEx(int resultCode) {
   2397         mResultCodeForTesting = resultCode;
   2398         setResult(resultCode);
   2399     }
   2400 
   2401     protected void setResultEx(int resultCode, Intent data) {
   2402         mResultCodeForTesting = resultCode;
   2403         mResultDataForTesting = data;
   2404         setResult(resultCode, data);
   2405     }
   2406 
   2407     public int getResultCode() {
   2408         return mResultCodeForTesting;
   2409     }
   2410 
   2411     public Intent getResultData() {
   2412         return mResultDataForTesting;
   2413     }
   2414 
   2415     public boolean isSecureCamera() {
   2416         return mSecureCamera;
   2417     }
   2418 
   2419     @Override
   2420     public boolean isPaused() {
   2421         return mPaused;
   2422     }
   2423 
   2424     @Override
   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
   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
   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
   2477     public void freezeScreenUntilPreviewReady() {
   2478         mCameraAppUI.freezeScreenUntilPreviewReady();
   2479     }
   2480 
   2481     @Override
   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      */
   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
   2507     public SettingsManager getSettingsManager() {
   2508         return mSettingsManager;
   2509     }
   2510 
   2511     @Override
   2512     public ResolutionSetting getResolutionSetting() {
   2513         return mResolutionSetting;
   2514     }
   2515 
   2516     @Override
   2517     public CameraServices getServices() {
   2518         return CameraServicesImpl.instance();
   2519     }
   2520 
   2521     @Override
   2522     public FatalErrorHandler getFatalErrorHandler() {
   2523         return mFatalErrorHandler;
   2524     }
   2525 
   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
   2540     public ButtonManager getButtonManager() {
   2541         if (mButtonManager == null) {
   2542             mButtonManager = new ButtonManager(this);
   2543         }
   2544         return mButtonManager;
   2545     }
   2546 
   2547     @Override
   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      */
   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
   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
   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      */
   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      */
   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 
   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 
   2651     private void closeModule(CameraModule module) {
   2652         module.pause();
   2653         mCameraAppUI.clearModuleUI();
   2654     }
   2655 
   2656     private void performDeletion() {
   2657         if (!mPendingDeletion) {
   2658             return;
   2659         }
   2660         hideUndoDeletionBar(false);
   2661         mDataAdapter.executeDeletion();
   2662     }
   2663 
   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 
   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      */
   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
   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 
   2769     public long getAutoFocusTime() {
   2770         return (mCurrentModule instanceof PhotoModule) ?
   2771                 ((PhotoModule) mCurrentModule).mAutoFocusTime : -1;
   2772     }
   2773 
   2774     public long getShutterLag() {
   2775         return (mCurrentModule instanceof PhotoModule) ?
   2776                 ((PhotoModule) mCurrentModule).mShutterLag : -1;
   2777     }
   2778 
   2779     public long getShutterToPictureDisplayedTime() {
   2780         return (mCurrentModule instanceof PhotoModule) ?
   2781                 ((PhotoModule) mCurrentModule).mShutterToPictureDisplayedTime : -1;
   2782     }
   2783 
   2784     public long getPictureDisplayedToJpegCallbackTime() {
   2785         return (mCurrentModule instanceof PhotoModule) ?
   2786                 ((PhotoModule) mCurrentModule).mPictureDisplayedToJpegCallbackTime : -1;
   2787     }
   2788 
   2789     public long getJpegCallbackFinishTime() {
   2790         return (mCurrentModule instanceof PhotoModule) ?
   2791                 ((PhotoModule) mCurrentModule).mJpegCallbackFinishTime : -1;
   2792     }
   2793 
   2794     public long getCaptureStartTime() {
   2795         return (mCurrentModule instanceof PhotoModule) ?
   2796                 ((PhotoModule) mCurrentModule).mCaptureStartTime : -1;
   2797     }
   2798 
   2799     public boolean isRecording() {
   2800         return (mCurrentModule instanceof VideoModule) ?
   2801                 ((VideoModule) mCurrentModule).isRecording() : false;
   2802     }
   2803 
   2804     public CameraAgent.CameraOpenCallback getCameraOpenErrorCallback() {
   2805         return mCameraController;
   2806     }
   2807 
   2808     // For debugging purposes only.
   2809     public CameraModule getCurrentModule() {
   2810         return mCurrentModule;
   2811     }
   2812 
   2813     @Override
   2814     public void showTutorial(AbstractTutorialOverlay tutorial) {
   2815         mCameraAppUI.showTutorial(tutorial, getLayoutInflater());
   2816     }
   2817 
   2818     @Override
   2819     public void finishActivityWithIntentCompleted(Intent resultIntent) {
   2820         finishActivityWithIntentResult(Activity.RESULT_OK, resultIntent);
   2821     }
   2822 
   2823     @Override
   2824     public void finishActivityWithIntentCanceled() {
   2825         finishActivityWithIntentResult(Activity.RESULT_CANCELED, new Intent());
   2826     }
   2827 
   2828     private void finishActivityWithIntentResult(int resultCode, Intent resultIntent) {
   2829         mResultCodeForTesting = resultCode;
   2830         mResultDataForTesting = resultIntent;
   2831         setResult(resultCode, resultIntent);
   2832         finish();
   2833     }
   2834 
   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 
   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      */
   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 
   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      */
   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      */
   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 
   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      */
   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