PhotoPage.java revision f12a6b9ea3932fb997d0d36605a2ba27de97beb3
1/* 2 * Copyright (C) 2010 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 17package com.android.gallery3d.app; 18 19import android.annotation.TargetApi; 20import android.app.Activity; 21import android.content.ActivityNotFoundException; 22import android.content.Context; 23import android.content.Intent; 24import android.content.pm.PackageManager; 25import android.graphics.Rect; 26import android.net.Uri; 27import android.nfc.NfcAdapter; 28import android.nfc.NfcAdapter.CreateBeamUrisCallback; 29import android.nfc.NfcEvent; 30import android.os.Bundle; 31import android.os.Handler; 32import android.os.Message; 33import android.os.SystemClock; 34import android.widget.RelativeLayout; 35import android.widget.Toast; 36 37import com.android.camera.CameraActivity; 38import com.android.camera.ProxyLauncher; 39 40import com.actionbarsherlock.app.ActionBar.OnMenuVisibilityListener; 41import com.actionbarsherlock.view.Menu; 42import com.actionbarsherlock.view.MenuItem; 43import com.android.gallery3d.R; 44import com.android.gallery3d.common.ApiHelper; 45import com.android.gallery3d.data.ComboAlbum; 46import com.android.gallery3d.data.DataManager; 47import com.android.gallery3d.data.FilterDeleteSet; 48import com.android.gallery3d.data.FilterSource; 49import com.android.gallery3d.data.LocalImage; 50import com.android.gallery3d.data.MediaDetails; 51import com.android.gallery3d.data.MediaItem; 52import com.android.gallery3d.data.MediaObject; 53import com.android.gallery3d.data.MediaObject.PanoramaSupportCallback; 54import com.android.gallery3d.data.MediaSet; 55import com.android.gallery3d.data.MtpSource; 56import com.android.gallery3d.data.Path; 57import com.android.gallery3d.data.SecureAlbum; 58import com.android.gallery3d.data.SecureSource; 59import com.android.gallery3d.data.SnailAlbum; 60import com.android.gallery3d.data.SnailItem; 61import com.android.gallery3d.data.SnailSource; 62import com.android.gallery3d.filtershow.FilterShowActivity; 63import com.android.gallery3d.picasasource.PicasaSource; 64import com.android.gallery3d.ui.DetailsHelper; 65import com.android.gallery3d.ui.DetailsHelper.CloseListener; 66import com.android.gallery3d.ui.DetailsHelper.DetailsSource; 67import com.android.gallery3d.ui.GLView; 68import com.android.gallery3d.ui.ImportCompleteListener; 69import com.android.gallery3d.ui.MenuExecutor; 70import com.android.gallery3d.ui.PhotoView; 71import com.android.gallery3d.ui.SelectionManager; 72import com.android.gallery3d.ui.SynchronizedHandler; 73import com.android.gallery3d.util.GalleryUtils; 74 75public abstract class PhotoPage extends ActivityState implements 76 PhotoView.Listener, AppBridge.Server, 77 PhotoPageBottomControls.Delegate, GalleryActionBar.OnAlbumModeSelectedListener { 78 private static final String TAG = "PhotoPage"; 79 80 private static final int MSG_HIDE_BARS = 1; 81 private static final int MSG_ON_FULL_SCREEN_CHANGED = 4; 82 private static final int MSG_UPDATE_ACTION_BAR = 5; 83 private static final int MSG_UNFREEZE_GLROOT = 6; 84 private static final int MSG_WANT_BARS = 7; 85 private static final int MSG_REFRESH_BOTTOM_CONTROLS = 8; 86 private static final int MSG_ON_CAMERA_CENTER = 9; 87 private static final int MSG_ON_PICTURE_CENTER = 10; 88 private static final int MSG_REFRESH_IMAGE = 11; 89 private static final int MSG_UPDATE_PHOTO_UI = 12; 90 private static final int MSG_UPDATE_PROGRESS = 13; 91 private static final int MSG_UPDATE_DEFERRED = 14; 92 private static final int MSG_UPDATE_SHARE_URI = 15; 93 private static final int MSG_UPDATE_PANORAMA_UI = 16; 94 95 private static final int HIDE_BARS_TIMEOUT = 3500; 96 private static final int UNFREEZE_GLROOT_TIMEOUT = 250; 97 98 private static final int REQUEST_SLIDESHOW = 1; 99 private static final int REQUEST_CROP = 2; 100 private static final int REQUEST_CROP_PICASA = 3; 101 private static final int REQUEST_EDIT = 4; 102 private static final int REQUEST_PLAY_VIDEO = 5; 103 private static final int REQUEST_TRIM = 6; 104 105 public static final String KEY_MEDIA_SET_PATH = "media-set-path"; 106 public static final String KEY_MEDIA_ITEM_PATH = "media-item-path"; 107 public static final String KEY_INDEX_HINT = "index-hint"; 108 public static final String KEY_OPEN_ANIMATION_RECT = "open-animation-rect"; 109 public static final String KEY_APP_BRIDGE = "app-bridge"; 110 public static final String KEY_TREAT_BACK_AS_UP = "treat-back-as-up"; 111 public static final String KEY_START_IN_FILMSTRIP = "start-in-filmstrip"; 112 public static final String KEY_RETURN_INDEX_HINT = "return-index-hint"; 113 public static final String KEY_SHOW_WHEN_LOCKED = "show_when_locked"; 114 public static final String KEY_IN_CAMERA_ROLL = "in_camera_roll"; 115 116 public static final String KEY_ALBUMPAGE_TRANSITION = "albumpage-transition"; 117 public static final int MSG_ALBUMPAGE_NONE = 0; 118 public static final int MSG_ALBUMPAGE_STARTED = 1; 119 public static final int MSG_ALBUMPAGE_RESUMED = 2; 120 public static final int MSG_ALBUMPAGE_PICKED = 4; 121 122 public static final String ACTION_NEXTGEN_EDIT = "action_nextgen_edit"; 123 124 private GalleryApp mApplication; 125 private SelectionManager mSelectionManager; 126 127 private PhotoView mPhotoView; 128 private PhotoPage.Model mModel; 129 private DetailsHelper mDetailsHelper; 130 private boolean mShowDetails; 131 132 // mMediaSet could be null if there is no KEY_MEDIA_SET_PATH supplied. 133 // E.g., viewing a photo in gmail attachment 134 private FilterDeleteSet mMediaSet; 135 136 // The mediaset used by camera launched from secure lock screen. 137 private SecureAlbum mSecureAlbum; 138 139 private int mCurrentIndex = 0; 140 private Handler mHandler; 141 private boolean mShowBars = true; 142 private volatile boolean mActionBarAllowed = true; 143 private GalleryActionBar mActionBar; 144 private boolean mIsMenuVisible; 145 private boolean mHaveImageEditor; 146 private PhotoPageBottomControls mBottomControls; 147 private PhotoPageProgressBar mProgressBar; 148 private MediaItem mCurrentPhoto = null; 149 private MenuExecutor mMenuExecutor; 150 private boolean mIsActive; 151 private boolean mShowSpinner; 152 private String mSetPathString; 153 // This is the original mSetPathString before adding the camera preview item. 154 private String mOriginalSetPathString; 155 private AppBridge mAppBridge; 156 private SnailItem mScreenNailItem; 157 private SnailAlbum mScreenNailSet; 158 private OrientationManager mOrientationManager; 159 private boolean mTreatBackAsUp; 160 private boolean mStartInFilmstrip; 161 private boolean mHasCameraScreennailOrPlaceholder = false; 162 private boolean mRecenterCameraOnResume = true; 163 164 // These are only valid after the panorama callback 165 private boolean mIsPanorama; 166 private boolean mIsPanorama360; 167 168 private long mCameraSwitchCutoff = 0; 169 private boolean mSkipUpdateCurrentPhoto = false; 170 private static final long CAMERA_SWITCH_CUTOFF_THRESHOLD_MS = 300; 171 172 private static final long DEFERRED_UPDATE_MS = 250; 173 private boolean mDeferredUpdateWaiting = false; 174 private long mDeferUpdateUntil = Long.MAX_VALUE; 175 176 // The item that is deleted (but it can still be undeleted before commiting) 177 private Path mDeletePath; 178 private boolean mDeleteIsFocus; // whether the deleted item was in focus 179 180 private Uri[] mNfcPushUris = new Uri[1]; 181 182 private final MyMenuVisibilityListener mMenuVisibilityListener = 183 new MyMenuVisibilityListener(); 184 private UpdateProgressListener mProgressListener; 185 186 private final PanoramaSupportCallback mUpdatePanoramaMenuItemsCallback = new PanoramaSupportCallback() { 187 @Override 188 public void panoramaInfoAvailable(MediaObject mediaObject, boolean isPanorama, 189 boolean isPanorama360) { 190 if (mediaObject == mCurrentPhoto) { 191 mHandler.obtainMessage(MSG_UPDATE_PANORAMA_UI, isPanorama360 ? 1 : 0, 0, 192 mediaObject).sendToTarget(); 193 } 194 } 195 }; 196 197 private final PanoramaSupportCallback mRefreshBottomControlsCallback = new PanoramaSupportCallback() { 198 @Override 199 public void panoramaInfoAvailable(MediaObject mediaObject, boolean isPanorama, 200 boolean isPanorama360) { 201 if (mediaObject == mCurrentPhoto) { 202 mHandler.obtainMessage(MSG_REFRESH_BOTTOM_CONTROLS, isPanorama ? 1 : 0, isPanorama360 ? 1 : 0, 203 mediaObject).sendToTarget(); 204 } 205 } 206 }; 207 208 private final PanoramaSupportCallback mUpdateShareURICallback = new PanoramaSupportCallback() { 209 @Override 210 public void panoramaInfoAvailable(MediaObject mediaObject, boolean isPanorama, 211 boolean isPanorama360) { 212 if (mediaObject == mCurrentPhoto) { 213 mHandler.obtainMessage(MSG_UPDATE_SHARE_URI, isPanorama360 ? 1 : 0, 0, mediaObject) 214 .sendToTarget(); 215 } 216 } 217 }; 218 219 public static interface Model extends PhotoView.Model { 220 public void resume(); 221 public void pause(); 222 public boolean isEmpty(); 223 public void setCurrentPhoto(Path path, int indexHint); 224 } 225 226 private class MyMenuVisibilityListener implements OnMenuVisibilityListener { 227 @Override 228 public void onMenuVisibilityChanged(boolean isVisible) { 229 mIsMenuVisible = isVisible; 230 refreshHidingMessage(); 231 } 232 } 233 234 private class UpdateProgressListener implements StitchingChangeListener { 235 236 @Override 237 public void onStitchingResult(Uri uri) { 238 sendUpdate(uri, MSG_REFRESH_IMAGE); 239 } 240 241 @Override 242 public void onStitchingQueued(Uri uri) { 243 sendUpdate(uri, MSG_UPDATE_PROGRESS); 244 } 245 246 @Override 247 public void onStitchingProgress(Uri uri, final int progress) { 248 sendUpdate(uri, MSG_UPDATE_PROGRESS); 249 } 250 251 private void sendUpdate(Uri uri, int message) { 252 MediaObject currentPhoto = mCurrentPhoto; 253 boolean isCurrentPhoto = currentPhoto instanceof LocalImage 254 && currentPhoto.getContentUri().equals(uri); 255 if (isCurrentPhoto) { 256 mHandler.sendEmptyMessage(message); 257 } 258 } 259 }; 260 261 @Override 262 protected int getBackgroundColorId() { 263 return R.color.photo_background; 264 } 265 266 private final GLView mRootPane = new GLView() { 267 @Override 268 protected void onLayout( 269 boolean changed, int left, int top, int right, int bottom) { 270 mPhotoView.layout(0, 0, right - left, bottom - top); 271 if (mShowDetails) { 272 mDetailsHelper.layout(left, mActionBar.getHeight(), right, bottom); 273 } 274 } 275 }; 276 277 @Override 278 public void onCreate(Bundle data, Bundle restoreState) { 279 super.onCreate(data, restoreState); 280 mActionBar = mActivity.getGalleryActionBar(); 281 mSelectionManager = new SelectionManager(mActivity, false); 282 mMenuExecutor = new MenuExecutor(mActivity, mSelectionManager); 283 284 mPhotoView = new PhotoView(mActivity); 285 mPhotoView.setListener(this); 286 mRootPane.addComponent(mPhotoView); 287 mApplication = (GalleryApp) ((Activity) mActivity).getApplication(); 288 mOrientationManager = mActivity.getOrientationManager(); 289 mActivity.getGLRoot().setOrientationSource(mOrientationManager); 290 291 mHandler = new SynchronizedHandler(mActivity.getGLRoot()) { 292 @Override 293 public void handleMessage(Message message) { 294 switch (message.what) { 295 case MSG_HIDE_BARS: { 296 hideBars(); 297 break; 298 } 299 case MSG_REFRESH_BOTTOM_CONTROLS: { 300 if (mCurrentPhoto == message.obj && mBottomControls != null) { 301 mIsPanorama = message.arg1 == 1; 302 mIsPanorama360 = message.arg2 == 1; 303 mBottomControls.refresh(); 304 } 305 break; 306 } 307 case MSG_ON_FULL_SCREEN_CHANGED: { 308 mAppBridge.onFullScreenChanged(message.arg1 == 1); 309 break; 310 } 311 case MSG_UPDATE_ACTION_BAR: { 312 updateBars(); 313 break; 314 } 315 case MSG_WANT_BARS: { 316 wantBars(); 317 break; 318 } 319 case MSG_UNFREEZE_GLROOT: { 320 mActivity.getGLRoot().unfreeze(); 321 break; 322 } 323 case MSG_UPDATE_DEFERRED: { 324 long nextUpdate = mDeferUpdateUntil - SystemClock.uptimeMillis(); 325 if (nextUpdate <= 0) { 326 mDeferredUpdateWaiting = false; 327 updateUIForCurrentPhoto(); 328 } else { 329 mHandler.sendEmptyMessageDelayed(MSG_UPDATE_DEFERRED, nextUpdate); 330 } 331 break; 332 } 333 case MSG_ON_CAMERA_CENTER: { 334 mSkipUpdateCurrentPhoto = false; 335 boolean stayedOnCamera = false; 336 if (!mPhotoView.getFilmMode()) { 337 stayedOnCamera = true; 338 } else if (SystemClock.uptimeMillis() < mCameraSwitchCutoff && 339 mMediaSet.getMediaItemCount() > 1) { 340 mPhotoView.switchToImage(1); 341 } else { 342 if (mAppBridge != null) mPhotoView.setFilmMode(false); 343 stayedOnCamera = true; 344 } 345 346 if (stayedOnCamera) { 347 if (mAppBridge == null) { 348 launchCamera(); 349 /* We got here by swiping from photo 1 to the 350 placeholder, so make it be the thing that 351 is in focus when the user presses back from 352 the camera app */ 353 mPhotoView.switchToImage(1); 354 } else { 355 updateBars(); 356 updateCurrentPhoto(mModel.getMediaItem(0)); 357 } 358 } 359 break; 360 } 361 case MSG_ON_PICTURE_CENTER: { 362 if (!mPhotoView.getFilmMode() && mCurrentPhoto != null 363 && (mCurrentPhoto.getSupportedOperations() & MediaObject.SUPPORT_ACTION) != 0) { 364 mPhotoView.setFilmMode(true); 365 } 366 break; 367 } 368 case MSG_REFRESH_IMAGE: { 369 final MediaItem photo = mCurrentPhoto; 370 mCurrentPhoto = null; 371 updateCurrentPhoto(photo); 372 break; 373 } 374 case MSG_UPDATE_PHOTO_UI: { 375 updateUIForCurrentPhoto(); 376 break; 377 } 378 case MSG_UPDATE_PROGRESS: { 379 updateProgressBar(); 380 break; 381 } 382 case MSG_UPDATE_SHARE_URI: { 383 if (mCurrentPhoto == message.obj) { 384 boolean isPanorama360 = message.arg1 != 0; 385 Uri contentUri = mCurrentPhoto.getContentUri(); 386 Intent panoramaIntent = null; 387 if (isPanorama360) { 388 panoramaIntent = createSharePanoramaIntent(contentUri); 389 } 390 Intent shareIntent = createShareIntent(mCurrentPhoto); 391 392 mActionBar.setShareIntents(panoramaIntent, shareIntent); 393 setNfcBeamPushUri(contentUri); 394 } 395 break; 396 } 397 case MSG_UPDATE_PANORAMA_UI: { 398 if (mCurrentPhoto == message.obj) { 399 boolean isPanorama360 = message.arg1 != 0; 400 updatePanoramaUI(isPanorama360); 401 } 402 break; 403 } 404 default: throw new AssertionError(message.what); 405 } 406 } 407 }; 408 409 mSetPathString = data.getString(KEY_MEDIA_SET_PATH); 410 mOriginalSetPathString = mSetPathString; 411 setupNfcBeamPush(); 412 String itemPathString = data.getString(KEY_MEDIA_ITEM_PATH); 413 Path itemPath = itemPathString != null ? 414 Path.fromString(data.getString(KEY_MEDIA_ITEM_PATH)) : 415 null; 416 mTreatBackAsUp = data.getBoolean(KEY_TREAT_BACK_AS_UP, false); 417 mStartInFilmstrip = data.getBoolean(KEY_START_IN_FILMSTRIP, false); 418 boolean inCameraRoll = data.getBoolean(KEY_IN_CAMERA_ROLL, false); 419 mCurrentIndex = data.getInt(KEY_INDEX_HINT, 0); 420 if (mSetPathString != null) { 421 mShowSpinner = true; 422 mAppBridge = (AppBridge) data.getParcelable(KEY_APP_BRIDGE); 423 if (mAppBridge != null) { 424 mShowBars = false; 425 mHasCameraScreennailOrPlaceholder = true; 426 mAppBridge.setServer(this); 427 428 // Get the ScreenNail from AppBridge and register it. 429 int id = SnailSource.newId(); 430 Path screenNailSetPath = SnailSource.getSetPath(id); 431 Path screenNailItemPath = SnailSource.getItemPath(id); 432 mScreenNailSet = (SnailAlbum) mActivity.getDataManager() 433 .getMediaObject(screenNailSetPath); 434 mScreenNailItem = (SnailItem) mActivity.getDataManager() 435 .getMediaObject(screenNailItemPath); 436 mScreenNailItem.setScreenNail(mAppBridge.attachScreenNail()); 437 438 if (data.getBoolean(KEY_SHOW_WHEN_LOCKED, false)) { 439 // Set the flag to be on top of the lock screen. 440 mFlags |= FLAG_SHOW_WHEN_LOCKED; 441 } 442 443 // Don't display "empty album" action item for capture intents. 444 if (!mSetPathString.equals("/local/all/0")) { 445 // Check if the path is a secure album. 446 if (SecureSource.isSecurePath(mSetPathString)) { 447 mSecureAlbum = (SecureAlbum) mActivity.getDataManager() 448 .getMediaSet(mSetPathString); 449 mShowSpinner = false; 450 } 451 mSetPathString = "/filter/empty/{"+mSetPathString+"}"; 452 } 453 454 // Combine the original MediaSet with the one for ScreenNail 455 // from AppBridge. 456 mSetPathString = "/combo/item/{" + screenNailSetPath + 457 "," + mSetPathString + "}"; 458 459 // Start from the screen nail. 460 itemPath = screenNailItemPath; 461 } else if (inCameraRoll && GalleryUtils.isCameraAvailable(mActivity)) { 462 mSetPathString = "/combo/item/{" + FilterSource.FILTER_CAMERA_SHORTCUT + 463 "," + mSetPathString + "}"; 464 mCurrentIndex++; 465 mHasCameraScreennailOrPlaceholder = true; 466 } 467 468 MediaSet originalSet = mActivity.getDataManager() 469 .getMediaSet(mSetPathString); 470 if (mHasCameraScreennailOrPlaceholder && originalSet instanceof ComboAlbum) { 471 // Use the name of the camera album rather than the default 472 // ComboAlbum behavior 473 ((ComboAlbum) originalSet).useNameOfChild(1); 474 } 475 mSelectionManager.setSourceMediaSet(originalSet); 476 mSetPathString = "/filter/delete/{" + mSetPathString + "}"; 477 mMediaSet = (FilterDeleteSet) mActivity.getDataManager() 478 .getMediaSet(mSetPathString); 479 if (mMediaSet == null) { 480 Log.w(TAG, "failed to restore " + mSetPathString); 481 } 482 if (itemPath == null) { 483 int mediaItemCount = mMediaSet.getMediaItemCount(); 484 if (mediaItemCount > 0) { 485 if (mCurrentIndex >= mediaItemCount) mCurrentIndex = 0; 486 itemPath = mMediaSet.getMediaItem(mCurrentIndex, 1) 487 .get(0).getPath(); 488 } else { 489 // Bail out, PhotoPage can't load on an empty album 490 return; 491 } 492 } 493 PhotoDataAdapter pda = new PhotoDataAdapter( 494 mActivity, mPhotoView, mMediaSet, itemPath, mCurrentIndex, 495 mAppBridge == null ? -1 : 0, 496 mAppBridge == null ? false : mAppBridge.isPanorama(), 497 mAppBridge == null ? false : mAppBridge.isStaticCamera()); 498 mModel = pda; 499 mPhotoView.setModel(mModel); 500 501 pda.setDataListener(new PhotoDataAdapter.DataListener() { 502 503 @Override 504 public void onPhotoChanged(int index, Path item) { 505 int oldIndex = mCurrentIndex; 506 mCurrentIndex = index; 507 508 if (mHasCameraScreennailOrPlaceholder) { 509 if (mCurrentIndex > 0) { 510 mSkipUpdateCurrentPhoto = false; 511 } 512 513 if (oldIndex == 0 && mCurrentIndex > 0 514 && !mPhotoView.getFilmMode()) { 515 mPhotoView.setFilmMode(true); 516 } else if (oldIndex == 2 && mCurrentIndex == 1) { 517 mCameraSwitchCutoff = SystemClock.uptimeMillis() + 518 CAMERA_SWITCH_CUTOFF_THRESHOLD_MS; 519 mPhotoView.stopScrolling(); 520 } else if (oldIndex >= 1 && mCurrentIndex == 0) { 521 mPhotoView.setWantPictureCenterCallbacks(true); 522 mSkipUpdateCurrentPhoto = true; 523 } 524 } 525 if (!mSkipUpdateCurrentPhoto) { 526 if (item != null) { 527 MediaItem photo = mModel.getMediaItem(0); 528 if (photo != null) updateCurrentPhoto(photo); 529 } 530 updateBars(); 531 } 532 // Reset the timeout for the bars after a swipe 533 refreshHidingMessage(); 534 } 535 536 @Override 537 public void onLoadingFinished(boolean loadingFailed) { 538 if (!mModel.isEmpty()) { 539 MediaItem photo = mModel.getMediaItem(0); 540 if (photo != null) updateCurrentPhoto(photo); 541 } else if (mIsActive) { 542 // We only want to finish the PhotoPage if there is no 543 // deletion that the user can undo. 544 if (mMediaSet.getNumberOfDeletions() == 0) { 545 mActivity.getStateManager().finishState( 546 PhotoPage.this); 547 } 548 } 549 } 550 551 @Override 552 public void onLoadingStarted() { 553 } 554 }); 555 } else { 556 // Get default media set by the URI 557 MediaItem mediaItem = (MediaItem) 558 mActivity.getDataManager().getMediaObject(itemPath); 559 mModel = new SinglePhotoDataAdapter(mActivity, mPhotoView, mediaItem); 560 mPhotoView.setModel(mModel); 561 updateCurrentPhoto(mediaItem); 562 mShowSpinner = false; 563 } 564 565 mPhotoView.setFilmMode(mStartInFilmstrip && mMediaSet.getMediaItemCount() > 1); 566 RelativeLayout galleryRoot = (RelativeLayout) ((Activity) mActivity) 567 .findViewById(mAppBridge != null ? R.id.content : R.id.gallery_root); 568 if (galleryRoot != null) { 569 if (mSecureAlbum == null) { 570 mBottomControls = new PhotoPageBottomControls(this, mActivity, galleryRoot); 571 } 572 StitchingProgressManager progressManager = mApplication.getStitchingProgressManager(); 573 if (progressManager != null) { 574 mProgressBar = new PhotoPageProgressBar(mActivity, galleryRoot); 575 mProgressListener = new UpdateProgressListener(); 576 progressManager.addChangeListener(mProgressListener); 577 if (mSecureAlbum != null) { 578 progressManager.addChangeListener(mSecureAlbum); 579 } 580 } 581 } 582 } 583 584 @Override 585 public void onPictureCenter(boolean isCamera) { 586 isCamera = isCamera || (mHasCameraScreennailOrPlaceholder && mAppBridge == null); 587 mPhotoView.setWantPictureCenterCallbacks(false); 588 mHandler.removeMessages(MSG_ON_CAMERA_CENTER); 589 mHandler.removeMessages(MSG_ON_PICTURE_CENTER); 590 mHandler.sendEmptyMessage(isCamera ? MSG_ON_CAMERA_CENTER : MSG_ON_PICTURE_CENTER); 591 } 592 593 @Override 594 public boolean canDisplayBottomControls() { 595 return mIsActive && !mPhotoView.canUndo(); 596 } 597 598 @Override 599 public boolean canDisplayBottomControl(int control) { 600 if (mCurrentPhoto == null) { 601 return false; 602 } 603 switch(control) { 604 case R.id.photopage_bottom_control_edit: 605 return mHaveImageEditor && mShowBars 606 && !mPhotoView.getFilmMode() 607 && (mCurrentPhoto.getSupportedOperations() & MediaItem.SUPPORT_EDIT) != 0 608 && mCurrentPhoto.getMediaType() == MediaObject.MEDIA_TYPE_IMAGE; 609 case R.id.photopage_bottom_control_panorama: 610 return mIsPanorama; 611 case R.id.photopage_bottom_control_tiny_planet: 612 return mHaveImageEditor && mShowBars 613 && mIsPanorama360 && !mPhotoView.getFilmMode(); 614 default: 615 return false; 616 } 617 } 618 619 @Override 620 public void onBottomControlClicked(int control) { 621 switch(control) { 622 case R.id.photopage_bottom_control_edit: 623 launchPhotoEditor(); 624 return; 625 case R.id.photopage_bottom_control_panorama: 626 mActivity.getPanoramaViewHelper() 627 .showPanorama(mCurrentPhoto.getContentUri()); 628 return; 629 case R.id.photopage_bottom_control_tiny_planet: 630 launchTinyPlanet(); 631 return; 632 default: 633 return; 634 } 635 } 636 637 @TargetApi(ApiHelper.VERSION_CODES.JELLY_BEAN) 638 private void setupNfcBeamPush() { 639 if (!ApiHelper.HAS_SET_BEAM_PUSH_URIS) return; 640 641 NfcAdapter adapter = NfcAdapter.getDefaultAdapter(mActivity); 642 if (adapter != null) { 643 adapter.setBeamPushUris(null, mActivity); 644 adapter.setBeamPushUrisCallback(new CreateBeamUrisCallback() { 645 @Override 646 public Uri[] createBeamUris(NfcEvent event) { 647 return mNfcPushUris; 648 } 649 }, mActivity); 650 } 651 } 652 653 private void setNfcBeamPushUri(Uri uri) { 654 mNfcPushUris[0] = uri; 655 } 656 657 private static Intent createShareIntent(MediaObject mediaObject) { 658 int type = mediaObject.getMediaType(); 659 return new Intent(Intent.ACTION_SEND) 660 .setType(MenuExecutor.getMimeType(type)) 661 .putExtra(Intent.EXTRA_STREAM, mediaObject.getContentUri()) 662 .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); 663 } 664 665 private static Intent createSharePanoramaIntent(Uri contentUri) { 666 return new Intent(Intent.ACTION_SEND) 667 .setType(GalleryUtils.MIME_TYPE_PANORAMA360) 668 .putExtra(Intent.EXTRA_STREAM, contentUri) 669 .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); 670 } 671 672 private void overrideTransitionToEditor() { 673 ((Activity) mActivity).overridePendingTransition(android.R.anim.slide_in_left, 674 android.R.anim.fade_out); 675 } 676 677 private void launchTinyPlanet() { 678 // Deep link into tiny planet 679 MediaItem current = mModel.getMediaItem(0); 680 Intent intent = new Intent(FilterShowActivity.TINY_PLANET_ACTION); 681 intent.setClass(mActivity, FilterShowActivity.class); 682 intent.setDataAndType(current.getContentUri(), current.getMimeType()) 683 .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); 684 intent.putExtra(FilterShowActivity.LAUNCH_FULLSCREEN, 685 mActivity.isFullscreen()); 686 mActivity.startActivityForResult(intent, REQUEST_EDIT); 687 overrideTransitionToEditor(); 688 } 689 690 private void launchCamera() { 691 Intent intent = new Intent(mActivity, CameraActivity.class) 692 .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 693 mRecenterCameraOnResume = false; 694 mActivity.startActivity(intent); 695 } 696 697 private void launchPhotoEditor() { 698 MediaItem current = mModel.getMediaItem(0); 699 if (current == null || (current.getSupportedOperations() 700 & MediaObject.SUPPORT_EDIT) == 0) { 701 return; 702 } 703 704 Intent intent = new Intent(ACTION_NEXTGEN_EDIT); 705 706 intent.setDataAndType(current.getContentUri(), current.getMimeType()) 707 .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); 708 if (mActivity.getPackageManager() 709 .queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY).size() == 0) { 710 intent.setAction(Intent.ACTION_EDIT); 711 } 712 intent.putExtra(FilterShowActivity.LAUNCH_FULLSCREEN, 713 mActivity.isFullscreen()); 714 ((Activity) mActivity).startActivityForResult(Intent.createChooser(intent, null), 715 REQUEST_EDIT); 716 overrideTransitionToEditor(); 717 } 718 719 private void requestDeferredUpdate() { 720 mDeferUpdateUntil = SystemClock.uptimeMillis() + DEFERRED_UPDATE_MS; 721 if (!mDeferredUpdateWaiting) { 722 mDeferredUpdateWaiting = true; 723 mHandler.sendEmptyMessageDelayed(MSG_UPDATE_DEFERRED, DEFERRED_UPDATE_MS); 724 } 725 } 726 727 private void updateUIForCurrentPhoto() { 728 if (mCurrentPhoto == null) return; 729 730 // If by swiping or deletion the user ends up on an action item 731 // and zoomed in, zoom out so that the context of the action is 732 // more clear 733 if ((mCurrentPhoto.getSupportedOperations() & MediaObject.SUPPORT_ACTION) != 0 734 && !mPhotoView.getFilmMode()) { 735 mPhotoView.setWantPictureCenterCallbacks(true); 736 } 737 738 updateMenuOperations(); 739 refreshBottomControlsWhenReady(); 740 if (mShowDetails) { 741 mDetailsHelper.reloadDetails(); 742 } 743 if ((mSecureAlbum == null) 744 && (mCurrentPhoto.getSupportedOperations() & MediaItem.SUPPORT_SHARE) != 0) { 745 mCurrentPhoto.getPanoramaSupport(mUpdateShareURICallback); 746 } 747 updateProgressBar(); 748 } 749 750 private void updateCurrentPhoto(MediaItem photo) { 751 if (mCurrentPhoto == photo) return; 752 mCurrentPhoto = photo; 753 if (mPhotoView.getFilmMode()) { 754 requestDeferredUpdate(); 755 } else { 756 updateUIForCurrentPhoto(); 757 } 758 } 759 760 private void updateProgressBar() { 761 if (mProgressBar != null) { 762 mProgressBar.hideProgress(); 763 StitchingProgressManager progressManager = mApplication.getStitchingProgressManager(); 764 if (progressManager != null && mCurrentPhoto instanceof LocalImage) { 765 Integer progress = progressManager.getProgress(mCurrentPhoto.getContentUri()); 766 if (progress != null) { 767 mProgressBar.setProgress(progress); 768 } 769 } 770 } 771 } 772 773 private void updateMenuOperations() { 774 Menu menu = mActionBar.getMenu(); 775 776 // it could be null if onCreateActionBar has not been called yet 777 if (menu == null) return; 778 779 MenuItem item = menu.findItem(R.id.action_slideshow); 780 if (item != null) { 781 item.setVisible((mSecureAlbum == null) && canDoSlideShow()); 782 } 783 if (mCurrentPhoto == null) return; 784 785 int supportedOperations = mCurrentPhoto.getSupportedOperations(); 786 if (mSecureAlbum != null) { 787 supportedOperations &= MediaObject.SUPPORT_DELETE; 788 } else if (!mHaveImageEditor) { 789 supportedOperations &= ~MediaObject.SUPPORT_EDIT; 790 } 791 MenuExecutor.updateMenuOperation(menu, supportedOperations); 792 mCurrentPhoto.getPanoramaSupport(mUpdatePanoramaMenuItemsCallback); 793 } 794 795 private boolean canDoSlideShow() { 796 if (mMediaSet == null || mCurrentPhoto == null) { 797 return false; 798 } 799 if (mCurrentPhoto.getMediaType() != MediaObject.MEDIA_TYPE_IMAGE) { 800 return false; 801 } 802 if (MtpSource.isMtpPath(mOriginalSetPathString)) { 803 return false; 804 } 805 return true; 806 } 807 808 ////////////////////////////////////////////////////////////////////////// 809 // Action Bar show/hide management 810 ////////////////////////////////////////////////////////////////////////// 811 812 private void showBars() { 813 if (mShowBars) return; 814 mShowBars = true; 815 mOrientationManager.unlockOrientation(); 816 mActionBar.show(); 817 mActivity.getGLRoot().setLightsOutMode(false); 818 refreshHidingMessage(); 819 refreshBottomControlsWhenReady(); 820 } 821 822 private void hideBars() { 823 if (!mShowBars) return; 824 mShowBars = false; 825 mActionBar.hide(); 826 mActivity.getGLRoot().setLightsOutMode(true); 827 mHandler.removeMessages(MSG_HIDE_BARS); 828 refreshBottomControlsWhenReady(); 829 } 830 831 private void refreshHidingMessage() { 832 mHandler.removeMessages(MSG_HIDE_BARS); 833 if (!mIsMenuVisible && !mPhotoView.getFilmMode()) { 834 mHandler.sendEmptyMessageDelayed(MSG_HIDE_BARS, HIDE_BARS_TIMEOUT); 835 } 836 } 837 838 private boolean canShowBars() { 839 // No bars if we are showing camera preview. 840 if (mAppBridge != null && mCurrentIndex == 0 841 && !mPhotoView.getFilmMode()) return false; 842 843 // No bars if it's not allowed. 844 if (!mActionBarAllowed) return false; 845 846 return true; 847 } 848 849 private void wantBars() { 850 if (canShowBars()) showBars(); 851 } 852 853 private void toggleBars() { 854 if (mShowBars) { 855 hideBars(); 856 } else { 857 if (canShowBars()) showBars(); 858 } 859 } 860 861 private void updateBars() { 862 if (!canShowBars()) { 863 hideBars(); 864 } 865 } 866 867 @Override 868 protected void onBackPressed() { 869 if (mShowDetails) { 870 hideDetails(); 871 } else if (mAppBridge == null || !switchWithCaptureAnimation(-1)) { 872 // We are leaving this page. Set the result now. 873 setResult(); 874 if (mStartInFilmstrip && !mPhotoView.getFilmMode()) { 875 mPhotoView.setFilmMode(true); 876 } else if (mTreatBackAsUp) { 877 onUpPressed(); 878 } else { 879 super.onBackPressed(); 880 } 881 } 882 } 883 884 private void onUpPressed() { 885 if ((mStartInFilmstrip || mAppBridge != null) 886 && !mPhotoView.getFilmMode()) { 887 mPhotoView.setFilmMode(true); 888 return; 889 } 890 891 if (mActivity.getStateManager().getStateCount() > 1) { 892 setResult(); 893 super.onBackPressed(); 894 return; 895 } 896 897 if (mOriginalSetPathString == null) return; 898 899 if (mAppBridge == null) { 900 // We're in view mode so set up the stacks on our own. 901 Bundle data = new Bundle(getData()); 902 data.putString(AlbumPage.KEY_MEDIA_PATH, mOriginalSetPathString); 903 data.putString(AlbumPage.KEY_PARENT_MEDIA_PATH, 904 mActivity.getDataManager().getTopSetPath( 905 DataManager.INCLUDE_ALL)); 906 mActivity.getStateManager().switchState(this, AlbumPage.class, data); 907 } else { 908 GalleryUtils.startGalleryActivity(mActivity); 909 } 910 } 911 912 private void setResult() { 913 Intent result = null; 914 result = new Intent(); 915 result.putExtra(KEY_RETURN_INDEX_HINT, mCurrentIndex); 916 setStateResult(Activity.RESULT_OK, result); 917 } 918 919 ////////////////////////////////////////////////////////////////////////// 920 // AppBridge.Server interface 921 ////////////////////////////////////////////////////////////////////////// 922 923 @Override 924 public void setCameraRelativeFrame(Rect frame) { 925 mPhotoView.setCameraRelativeFrame(frame); 926 } 927 928 @Override 929 public boolean switchWithCaptureAnimation(int offset) { 930 return mPhotoView.switchWithCaptureAnimation(offset); 931 } 932 933 @Override 934 public void setSwipingEnabled(boolean enabled) { 935 mPhotoView.setSwipingEnabled(enabled); 936 } 937 938 @Override 939 public void notifyScreenNailChanged() { 940 mScreenNailItem.setScreenNail(mAppBridge.attachScreenNail()); 941 mScreenNailSet.notifyChange(); 942 } 943 944 @Override 945 public void addSecureAlbumItem(boolean isVideo, int id) { 946 mSecureAlbum.addMediaItem(isVideo, id); 947 } 948 949 @Override 950 protected boolean onCreateActionBar(Menu menu) { 951 mActionBar.createActionBarMenu(R.menu.photo, menu); 952 mHaveImageEditor = GalleryUtils.isEditorAvailable(mActivity, "image/*"); 953 updateMenuOperations(); 954 mActionBar.setTitle(mMediaSet != null ? mMediaSet.getName() : ""); 955 return true; 956 } 957 958 private MenuExecutor.ProgressListener mConfirmDialogListener = 959 new MenuExecutor.ProgressListener() { 960 @Override 961 public void onProgressUpdate(int index) {} 962 963 @Override 964 public void onProgressComplete(int result) {} 965 966 @Override 967 public void onConfirmDialogShown() { 968 mHandler.removeMessages(MSG_HIDE_BARS); 969 } 970 971 @Override 972 public void onConfirmDialogDismissed(boolean confirmed) { 973 refreshHidingMessage(); 974 } 975 976 @Override 977 public void onProgressStart() {} 978 }; 979 980 private void switchToGrid() { 981 if (mActivity.getStateManager().hasStateClass(AlbumPage.class)) { 982 onUpPressed(); 983 } else { 984 if (mOriginalSetPathString == null) return; 985 if (mProgressBar != null) { 986 updateCurrentPhoto(null); 987 mProgressBar.hideProgress(); 988 } 989 Bundle data = new Bundle(getData()); 990 data.putString(AlbumPage.KEY_MEDIA_PATH, mOriginalSetPathString); 991 data.putString(AlbumPage.KEY_PARENT_MEDIA_PATH, 992 mActivity.getDataManager().getTopSetPath( 993 DataManager.INCLUDE_ALL)); 994 995 // We only show cluster menu in the first AlbumPage in stack 996 // TODO: Enable this when running from the camera app 997 boolean inAlbum = mActivity.getStateManager().hasStateClass(AlbumPage.class); 998 data.putBoolean(AlbumPage.KEY_SHOW_CLUSTER_MENU, !inAlbum 999 && mAppBridge == null); 1000 1001 data.putBoolean(PhotoPage.KEY_APP_BRIDGE, mAppBridge != null); 1002 1003 // Account for live preview being first item 1004 mActivity.getTransitionStore().put(KEY_RETURN_INDEX_HINT, 1005 mAppBridge != null ? mCurrentIndex - 1 : mCurrentIndex); 1006 1007 if (mHasCameraScreennailOrPlaceholder && mAppBridge != null) { 1008 mActivity.getStateManager().startState(AlbumPage.class, data); 1009 } else { 1010 mActivity.getStateManager().switchState(this, AlbumPage.class, data); 1011 } 1012 } 1013 } 1014 1015 @Override 1016 protected boolean onItemSelected(MenuItem item) { 1017 if (mModel == null) return true; 1018 refreshHidingMessage(); 1019 MediaItem current = mModel.getMediaItem(0); 1020 1021 // This is a shield for monkey when it clicks the action bar 1022 // menu when transitioning from filmstrip to camera 1023 if (current instanceof SnailItem) return true; 1024 // TODO: We should check the current photo against the MediaItem 1025 // that the menu was initially created for. We need to fix this 1026 // after PhotoPage being refactored. 1027 if (current == null) { 1028 // item is not ready, ignore 1029 return true; 1030 } 1031 int currentIndex = mModel.getCurrentIndex(); 1032 Path path = current.getPath(); 1033 1034 DataManager manager = mActivity.getDataManager(); 1035 int action = item.getItemId(); 1036 String confirmMsg = null; 1037 switch (action) { 1038 case android.R.id.home: { 1039 onUpPressed(); 1040 return true; 1041 } 1042 case R.id.action_slideshow: { 1043 Bundle data = new Bundle(); 1044 data.putString(SlideshowPage.KEY_SET_PATH, mMediaSet.getPath().toString()); 1045 data.putString(SlideshowPage.KEY_ITEM_PATH, path.toString()); 1046 data.putInt(SlideshowPage.KEY_PHOTO_INDEX, currentIndex); 1047 data.putBoolean(SlideshowPage.KEY_REPEAT, true); 1048 mActivity.getStateManager().startStateForResult( 1049 SlideshowPage.class, REQUEST_SLIDESHOW, data); 1050 return true; 1051 } 1052 case R.id.action_crop: { 1053 Activity activity = mActivity; 1054 Intent intent = new Intent(FilterShowActivity.CROP_ACTION); 1055 intent.setClass(activity, FilterShowActivity.class); 1056 intent.setDataAndType(manager.getContentUri(path), current.getMimeType()) 1057 .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); 1058 activity.startActivityForResult(intent, PicasaSource.isPicasaImage(current) 1059 ? REQUEST_CROP_PICASA 1060 : REQUEST_CROP); 1061 return true; 1062 } 1063 case R.id.action_trim: { 1064 Intent intent = new Intent(mActivity, TrimVideo.class); 1065 intent.setData(manager.getContentUri(path)); 1066 // We need the file path to wrap this into a RandomAccessFile. 1067 intent.putExtra(KEY_MEDIA_ITEM_PATH, current.getFilePath()); 1068 mActivity.startActivityForResult(intent, REQUEST_TRIM); 1069 return true; 1070 } 1071 case R.id.action_mute: { 1072 MuteVideo muteVideo = new MuteVideo(current, 1073 manager.getContentUri(path), mActivity); 1074 muteVideo.muteInBackground(); 1075 return true; 1076 } 1077 case R.id.action_edit: { 1078 launchPhotoEditor(); 1079 return true; 1080 } 1081 case R.id.action_details: { 1082 if (mShowDetails) { 1083 hideDetails(); 1084 } else { 1085 showDetails(); 1086 } 1087 return true; 1088 } 1089 case R.id.action_delete: 1090 confirmMsg = mActivity.getResources().getQuantityString( 1091 R.plurals.delete_selection, 1); 1092 case R.id.action_setas: 1093 case R.id.action_rotate_ccw: 1094 case R.id.action_rotate_cw: 1095 case R.id.action_show_on_map: 1096 mSelectionManager.deSelectAll(); 1097 mSelectionManager.toggle(path); 1098 mMenuExecutor.onMenuClicked(item, confirmMsg, mConfirmDialogListener); 1099 return true; 1100 case R.id.action_import: 1101 mSelectionManager.deSelectAll(); 1102 mSelectionManager.toggle(path); 1103 mMenuExecutor.onMenuClicked(item, confirmMsg, 1104 new ImportCompleteListener(mActivity)); 1105 return true; 1106 default : 1107 return false; 1108 } 1109 } 1110 1111 private void hideDetails() { 1112 mShowDetails = false; 1113 mDetailsHelper.hide(); 1114 } 1115 1116 private void showDetails() { 1117 mShowDetails = true; 1118 if (mDetailsHelper == null) { 1119 mDetailsHelper = new DetailsHelper(mActivity, mRootPane, new MyDetailsSource()); 1120 mDetailsHelper.setCloseListener(new CloseListener() { 1121 @Override 1122 public void onClose() { 1123 hideDetails(); 1124 } 1125 }); 1126 } 1127 mDetailsHelper.show(); 1128 } 1129 1130 //////////////////////////////////////////////////////////////////////////// 1131 // Callbacks from PhotoView 1132 //////////////////////////////////////////////////////////////////////////// 1133 @Override 1134 public void onSingleTapUp(int x, int y) { 1135 if (mAppBridge != null) { 1136 if (mAppBridge.onSingleTapUp(x, y)) return; 1137 } 1138 1139 MediaItem item = mModel.getMediaItem(0); 1140 if (item == null || item == mScreenNailItem) { 1141 // item is not ready or it is camera preview, ignore 1142 return; 1143 } 1144 1145 int supported = item.getSupportedOperations(); 1146 boolean playVideo = ((supported & MediaItem.SUPPORT_PLAY) != 0); 1147 boolean unlock = ((supported & MediaItem.SUPPORT_UNLOCK) != 0); 1148 boolean goBack = ((supported & MediaItem.SUPPORT_BACK) != 0); 1149 boolean launchCamera = ((supported & MediaItem.SUPPORT_CAMERA_SHORTCUT) != 0); 1150 1151 if (playVideo) { 1152 // determine if the point is at center (1/6) of the photo view. 1153 // (The position of the "play" icon is at center (1/6) of the photo) 1154 int w = mPhotoView.getWidth(); 1155 int h = mPhotoView.getHeight(); 1156 playVideo = (Math.abs(x - w / 2) * 12 <= w) 1157 && (Math.abs(y - h / 2) * 12 <= h); 1158 } 1159 1160 if (playVideo) { 1161 if (mSecureAlbum == null) { 1162 playVideo(mActivity, item.getPlayUri(), item.getName()); 1163 } else { 1164 mActivity.getStateManager().finishState(this); 1165 } 1166 } else if (goBack) { 1167 onBackPressed(); 1168 } else if (unlock) { 1169 mActivity.getStateManager().finishState(this); 1170 } else if (launchCamera) { 1171 launchCamera(); 1172 } else { 1173 toggleBars(); 1174 } 1175 } 1176 1177 @Override 1178 public void onActionBarAllowed(boolean allowed) { 1179 mActionBarAllowed = allowed; 1180 mHandler.sendEmptyMessage(MSG_UPDATE_ACTION_BAR); 1181 } 1182 1183 @Override 1184 public void onActionBarWanted() { 1185 mHandler.sendEmptyMessage(MSG_WANT_BARS); 1186 } 1187 1188 @Override 1189 public void onFullScreenChanged(boolean full) { 1190 Message m = mHandler.obtainMessage( 1191 MSG_ON_FULL_SCREEN_CHANGED, full ? 1 : 0, 0); 1192 m.sendToTarget(); 1193 } 1194 1195 // How we do delete/undo: 1196 // 1197 // When the user choose to delete a media item, we just tell the 1198 // FilterDeleteSet to hide that item. If the user choose to undo it, we 1199 // again tell FilterDeleteSet not to hide it. If the user choose to commit 1200 // the deletion, we then actually delete the media item. 1201 @Override 1202 public void onDeleteImage(Path path, int offset) { 1203 onCommitDeleteImage(); // commit the previous deletion 1204 mDeletePath = path; 1205 mDeleteIsFocus = (offset == 0); 1206 mMediaSet.addDeletion(path, mCurrentIndex + offset); 1207 } 1208 1209 @Override 1210 public void onUndoDeleteImage() { 1211 if (mDeletePath == null) return; 1212 // If the deletion was done on the focused item, we want the model to 1213 // focus on it when it is undeleted. 1214 if (mDeleteIsFocus) mModel.setFocusHintPath(mDeletePath); 1215 mMediaSet.removeDeletion(mDeletePath); 1216 mDeletePath = null; 1217 } 1218 1219 @Override 1220 public void onCommitDeleteImage() { 1221 if (mDeletePath == null) return; 1222 mSelectionManager.deSelectAll(); 1223 mSelectionManager.toggle(mDeletePath); 1224 mMenuExecutor.onMenuClicked(R.id.action_delete, null, true, false); 1225 mDeletePath = null; 1226 } 1227 1228 public void playVideo(Activity activity, Uri uri, String title) { 1229 try { 1230 Intent intent = new Intent(Intent.ACTION_VIEW) 1231 .setDataAndType(uri, "video/*") 1232 .putExtra(Intent.EXTRA_TITLE, title) 1233 .putExtra(MovieActivity.KEY_TREAT_UP_AS_BACK, true); 1234 activity.startActivityForResult(intent, REQUEST_PLAY_VIDEO); 1235 } catch (ActivityNotFoundException e) { 1236 Toast.makeText(activity, activity.getString(R.string.video_err), 1237 Toast.LENGTH_SHORT).show(); 1238 } 1239 } 1240 1241 private void setCurrentPhotoByIntent(Intent intent) { 1242 if (intent == null) return; 1243 Path path = mApplication.getDataManager() 1244 .findPathByUri(intent.getData(), intent.getType()); 1245 if (path != null) { 1246 Path albumPath = mApplication.getDataManager().getDefaultSetOf(path); 1247 if (!albumPath.equalsIgnoreCase(mOriginalSetPathString)) { 1248 // If the edited image is stored in a different album, we need 1249 // to start a new activity state to show the new image 1250 Bundle data = new Bundle(getData()); 1251 data.putString(KEY_MEDIA_SET_PATH, albumPath.toString()); 1252 data.putString(PhotoPage.KEY_MEDIA_ITEM_PATH, path.toString()); 1253 mActivity.getStateManager().startState(SinglePhotoPage.class, data); 1254 return; 1255 } 1256 mModel.setCurrentPhoto(path, mCurrentIndex); 1257 } 1258 } 1259 1260 @Override 1261 protected void onStateResult(int requestCode, int resultCode, Intent data) { 1262 if (resultCode == Activity.RESULT_CANCELED) { 1263 // This is a reset, not a canceled 1264 return; 1265 } 1266 if (resultCode == ProxyLauncher.RESULT_USER_CANCELED) { 1267 // Unmap reset vs. canceled 1268 resultCode = Activity.RESULT_CANCELED; 1269 } 1270 mRecenterCameraOnResume = false; 1271 switch (requestCode) { 1272 case REQUEST_EDIT: 1273 setCurrentPhotoByIntent(data); 1274 break; 1275 case REQUEST_CROP: 1276 if (resultCode == Activity.RESULT_OK) { 1277 setCurrentPhotoByIntent(data); 1278 } 1279 break; 1280 case REQUEST_CROP_PICASA: { 1281 if (resultCode == Activity.RESULT_OK) { 1282 Context context = mActivity.getAndroidContext(); 1283 String message = context.getString(R.string.crop_saved, 1284 context.getString(R.string.folder_edited_online_photos)); 1285 Toast.makeText(context, message, Toast.LENGTH_SHORT).show(); 1286 } 1287 break; 1288 } 1289 case REQUEST_SLIDESHOW: { 1290 if (data == null) break; 1291 String path = data.getStringExtra(SlideshowPage.KEY_ITEM_PATH); 1292 int index = data.getIntExtra(SlideshowPage.KEY_PHOTO_INDEX, 0); 1293 if (path != null) { 1294 mModel.setCurrentPhoto(Path.fromString(path), index); 1295 } 1296 } 1297 } 1298 } 1299 1300 @Override 1301 public void onPause() { 1302 super.onPause(); 1303 mIsActive = false; 1304 1305 mActivity.getGLRoot().unfreeze(); 1306 mHandler.removeMessages(MSG_UNFREEZE_GLROOT); 1307 1308 DetailsHelper.pause(); 1309 // Hide the detail dialog on exit 1310 if (mShowDetails) hideDetails(); 1311 if (mModel != null) { 1312 mModel.pause(); 1313 } 1314 mPhotoView.pause(); 1315 mHandler.removeMessages(MSG_HIDE_BARS); 1316 mHandler.removeMessages(MSG_REFRESH_BOTTOM_CONTROLS); 1317 refreshBottomControlsWhenReady(); 1318 mActionBar.removeOnMenuVisibilityListener(mMenuVisibilityListener); 1319 if (mShowSpinner) { 1320 mActionBar.disableAlbumModeMenu(true); 1321 } 1322 onCommitDeleteImage(); 1323 mMenuExecutor.pause(); 1324 if (mMediaSet != null) mMediaSet.clearDeletion(); 1325 } 1326 1327 @Override 1328 public void onCurrentImageUpdated() { 1329 mActivity.getGLRoot().unfreeze(); 1330 } 1331 1332 @Override 1333 public void onFilmModeChanged(boolean enabled) { 1334 refreshBottomControlsWhenReady(); 1335 if (mShowSpinner) { 1336 if (enabled) { 1337 mActionBar.enableAlbumModeMenu( 1338 GalleryActionBar.ALBUM_FILMSTRIP_MODE_SELECTED, this); 1339 } else { 1340 mActionBar.disableAlbumModeMenu(true); 1341 } 1342 } 1343 if (enabled) { 1344 mHandler.removeMessages(MSG_HIDE_BARS); 1345 } else { 1346 refreshHidingMessage(); 1347 } 1348 } 1349 1350 private void transitionFromAlbumPageIfNeeded() { 1351 TransitionStore transitions = mActivity.getTransitionStore(); 1352 1353 int albumPageTransition = transitions.get( 1354 KEY_ALBUMPAGE_TRANSITION, MSG_ALBUMPAGE_NONE); 1355 1356 if (albumPageTransition == MSG_ALBUMPAGE_NONE && mAppBridge != null 1357 && mRecenterCameraOnResume) { 1358 // Generally, resuming the PhotoPage when in Camera should 1359 // reset to the capture mode to allow quick photo taking 1360 mCurrentIndex = 0; 1361 mPhotoView.resetToFirstPicture(); 1362 } else { 1363 int resumeIndex = transitions.get(KEY_INDEX_HINT, -1); 1364 if (resumeIndex >= 0) { 1365 if (mHasCameraScreennailOrPlaceholder) { 1366 // Account for preview/placeholder being the first item 1367 resumeIndex++; 1368 } 1369 if (resumeIndex < mMediaSet.getMediaItemCount()) { 1370 mCurrentIndex = resumeIndex; 1371 mModel.moveTo(mCurrentIndex); 1372 } 1373 } 1374 } 1375 1376 if (albumPageTransition == MSG_ALBUMPAGE_RESUMED) { 1377 mPhotoView.setFilmMode(mStartInFilmstrip || mAppBridge != null); 1378 } else if (albumPageTransition == MSG_ALBUMPAGE_PICKED) { 1379 mPhotoView.setFilmMode(false); 1380 } 1381 } 1382 1383 @Override 1384 protected void onResume() { 1385 super.onResume(); 1386 1387 if (mModel == null) { 1388 mActivity.getStateManager().finishState(this); 1389 return; 1390 } 1391 transitionFromAlbumPageIfNeeded(); 1392 1393 mActivity.getGLRoot().freeze(); 1394 mIsActive = true; 1395 setContentPane(mRootPane); 1396 1397 mModel.resume(); 1398 mPhotoView.resume(); 1399 mActionBar.setDisplayOptions( 1400 ((mSecureAlbum == null) && (mSetPathString != null)), false); 1401 mActionBar.addOnMenuVisibilityListener(mMenuVisibilityListener); 1402 refreshBottomControlsWhenReady(); 1403 if (mShowSpinner && mPhotoView.getFilmMode()) { 1404 mActionBar.enableAlbumModeMenu( 1405 GalleryActionBar.ALBUM_FILMSTRIP_MODE_SELECTED, this); 1406 } 1407 if (!mShowBars) { 1408 mActionBar.hide(); 1409 mActivity.getGLRoot().setLightsOutMode(true); 1410 } 1411 boolean haveImageEditor = GalleryUtils.isEditorAvailable(mActivity, "image/*"); 1412 if (haveImageEditor != mHaveImageEditor) { 1413 mHaveImageEditor = haveImageEditor; 1414 updateMenuOperations(); 1415 } 1416 1417 mRecenterCameraOnResume = true; 1418 mHandler.sendEmptyMessageDelayed(MSG_UNFREEZE_GLROOT, UNFREEZE_GLROOT_TIMEOUT); 1419 } 1420 1421 @Override 1422 protected void onDestroy() { 1423 if (mAppBridge != null) { 1424 mAppBridge.setServer(null); 1425 mScreenNailItem.setScreenNail(null); 1426 mAppBridge.detachScreenNail(); 1427 mAppBridge = null; 1428 mScreenNailSet = null; 1429 mScreenNailItem = null; 1430 } 1431 mActivity.getGLRoot().setOrientationSource(null); 1432 if (mBottomControls != null) mBottomControls.cleanup(); 1433 1434 // Remove all pending messages. 1435 mHandler.removeCallbacksAndMessages(null); 1436 super.onDestroy(); 1437 } 1438 1439 private class MyDetailsSource implements DetailsSource { 1440 1441 @Override 1442 public MediaDetails getDetails() { 1443 return mModel.getMediaItem(0).getDetails(); 1444 } 1445 1446 @Override 1447 public int size() { 1448 return mMediaSet != null ? mMediaSet.getMediaItemCount() : 1; 1449 } 1450 1451 @Override 1452 public int setIndex() { 1453 return mModel.getCurrentIndex(); 1454 } 1455 } 1456 1457 @Override 1458 public void onAlbumModeSelected(int mode) { 1459 if (mode == GalleryActionBar.ALBUM_GRID_MODE_SELECTED) { 1460 switchToGrid(); 1461 } 1462 } 1463 1464 @Override 1465 public void refreshBottomControlsWhenReady() { 1466 if (mBottomControls == null) { 1467 return; 1468 } 1469 MediaObject currentPhoto = mCurrentPhoto; 1470 if (currentPhoto == null) { 1471 mHandler.obtainMessage(MSG_REFRESH_BOTTOM_CONTROLS, 0, 0, currentPhoto).sendToTarget(); 1472 } else { 1473 currentPhoto.getPanoramaSupport(mRefreshBottomControlsCallback); 1474 } 1475 } 1476 1477 private void updatePanoramaUI(boolean isPanorama360) { 1478 Menu menu = mActionBar.getMenu(); 1479 1480 // it could be null if onCreateActionBar has not been called yet 1481 if (menu == null) { 1482 return; 1483 } 1484 1485 MenuExecutor.updateMenuForPanorama(menu, isPanorama360, isPanorama360); 1486 1487 if (isPanorama360) { 1488 MenuItem item = menu.findItem(R.id.action_share); 1489 if (item != null) { 1490 item.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); 1491 item.setTitle(mActivity.getResources().getString(R.string.share_as_photo)); 1492 } 1493 } else if ((mCurrentPhoto.getSupportedOperations() & MediaObject.SUPPORT_SHARE) != 0) { 1494 MenuItem item = menu.findItem(R.id.action_share); 1495 if (item != null) { 1496 item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM); 1497 item.setTitle(mActivity.getResources().getString(R.string.share)); 1498 } 1499 } 1500 } 1501 1502 @Override 1503 public void onUndoBarVisibilityChanged(boolean visible) { 1504 refreshBottomControlsWhenReady(); 1505 } 1506} 1507