| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.camera; |
| |
| import com.android.gallery.R; |
| |
| import android.app.Activity; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.SharedPreferences; |
| import android.graphics.Bitmap; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.preference.PreferenceManager; |
| import android.provider.MediaStore; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.view.GestureDetector; |
| import android.view.KeyEvent; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.Window; |
| import android.view.WindowManager; |
| import android.view.View.OnTouchListener; |
| import android.view.animation.AlphaAnimation; |
| import android.view.animation.Animation; |
| import android.view.animation.AnimationUtils; |
| import android.widget.Toast; |
| import android.widget.ZoomButtonsController; |
| |
| import com.android.camera.gallery.IImage; |
| import com.android.camera.gallery.IImageList; |
| import com.android.camera.gallery.VideoObject; |
| |
| import java.util.Random; |
| |
| // This activity can display a whole picture and navigate them in a specific |
| // gallery. It has two modes: normal mode and slide show mode. In normal mode |
| // the user view one image at a time, and can click "previous" and "next" |
| // button to see the previous or next image. In slide show mode it shows one |
| // image after another, with some transition effect. |
| public class ViewImage extends NoSearchActivity implements View.OnClickListener { |
| private static final String PREF_SLIDESHOW_REPEAT = |
| "pref_gallery_slideshow_repeat_key"; |
| private static final String PREF_SHUFFLE_SLIDESHOW = |
| "pref_gallery_slideshow_shuffle_key"; |
| private static final String STATE_URI = "uri"; |
| private static final String STATE_SLIDESHOW = "slideshow"; |
| private static final String EXTRA_SLIDESHOW = "slideshow"; |
| private static final String TAG = "ViewImage"; |
| |
| private ImageGetter mGetter; |
| private Uri mSavedUri; |
| boolean mPaused = true; |
| private boolean mShowControls = true; |
| |
| // Choices for what adjacents to load. |
| private static final int[] sOrderAdjacents = new int[] {0, 1, -1}; |
| private static final int[] sOrderSlideshow = new int[] {0}; |
| |
| final GetterHandler mHandler = new GetterHandler(); |
| |
| private final Random mRandom = new Random(System.currentTimeMillis()); |
| private int [] mShuffleOrder = null; |
| private boolean mUseShuffleOrder = false; |
| private boolean mSlideShowLoop = false; |
| |
| static final int MODE_NORMAL = 1; |
| static final int MODE_SLIDESHOW = 2; |
| private int mMode = MODE_NORMAL; |
| |
| private boolean mFullScreenInNormalMode; |
| private boolean mShowActionIcons; |
| private View mActionIconPanel; |
| |
| private int mSlideShowInterval; |
| private int mLastSlideShowImage; |
| int mCurrentPosition = 0; |
| |
| // represents which style animation to use |
| private int mAnimationIndex; |
| private Animation [] mSlideShowInAnimation; |
| private Animation [] mSlideShowOutAnimation; |
| |
| private SharedPreferences mPrefs; |
| |
| private View mNextImageView; |
| private View mPrevImageView; |
| private final Animation mHideNextImageViewAnimation = |
| new AlphaAnimation(1F, 0F); |
| private final Animation mHidePrevImageViewAnimation = |
| new AlphaAnimation(1F, 0F); |
| private final Animation mShowNextImageViewAnimation = |
| new AlphaAnimation(0F, 1F); |
| private final Animation mShowPrevImageViewAnimation = |
| new AlphaAnimation(0F, 1F); |
| |
| public static final String KEY_IMAGE_LIST = "image_list"; |
| private static final String STATE_SHOW_CONTROLS = "show_controls"; |
| |
| IImageList mAllImages; |
| |
| private ImageManager.ImageListParam mParam; |
| |
| private int mSlideShowImageCurrent = 0; |
| private final ImageViewTouchBase [] mSlideShowImageViews = |
| new ImageViewTouchBase[2]; |
| |
| GestureDetector mGestureDetector; |
| private ZoomButtonsController mZoomButtonsController; |
| |
| // The image view displayed for normal mode. |
| private ImageViewTouch mImageView; |
| // This is the cache for thumbnail bitmaps. |
| private BitmapCache mCache; |
| private MenuHelper.MenuItemsResult mImageMenuRunnable; |
| private final Runnable mDismissOnScreenControlRunner = new Runnable() { |
| public void run() { |
| hideOnScreenControls(); |
| } |
| }; |
| |
| private void updateNextPrevControls() { |
| boolean showPrev = mCurrentPosition > 0; |
| boolean showNext = mCurrentPosition < mAllImages.getCount() - 1; |
| |
| boolean prevIsVisible = mPrevImageView.getVisibility() == View.VISIBLE; |
| boolean nextIsVisible = mNextImageView.getVisibility() == View.VISIBLE; |
| |
| if (showPrev && !prevIsVisible) { |
| Animation a = mShowPrevImageViewAnimation; |
| a.setDuration(500); |
| mPrevImageView.startAnimation(a); |
| mPrevImageView.setVisibility(View.VISIBLE); |
| } else if (!showPrev && prevIsVisible) { |
| Animation a = mHidePrevImageViewAnimation; |
| a.setDuration(500); |
| mPrevImageView.startAnimation(a); |
| mPrevImageView.setVisibility(View.GONE); |
| } |
| |
| if (showNext && !nextIsVisible) { |
| Animation a = mShowNextImageViewAnimation; |
| a.setDuration(500); |
| mNextImageView.startAnimation(a); |
| mNextImageView.setVisibility(View.VISIBLE); |
| } else if (!showNext && nextIsVisible) { |
| Animation a = mHideNextImageViewAnimation; |
| a.setDuration(500); |
| mNextImageView.startAnimation(a); |
| mNextImageView.setVisibility(View.GONE); |
| } |
| } |
| |
| private void hideOnScreenControls() { |
| if (mShowActionIcons |
| && mActionIconPanel.getVisibility() == View.VISIBLE) { |
| Animation animation = new AlphaAnimation(1, 0); |
| animation.setDuration(500); |
| mActionIconPanel.startAnimation(animation); |
| mActionIconPanel.setVisibility(View.INVISIBLE); |
| } |
| |
| if (mNextImageView.getVisibility() == View.VISIBLE) { |
| Animation a = mHideNextImageViewAnimation; |
| a.setDuration(500); |
| mNextImageView.startAnimation(a); |
| mNextImageView.setVisibility(View.INVISIBLE); |
| } |
| |
| if (mPrevImageView.getVisibility() == View.VISIBLE) { |
| Animation a = mHidePrevImageViewAnimation; |
| a.setDuration(500); |
| mPrevImageView.startAnimation(a); |
| mPrevImageView.setVisibility(View.INVISIBLE); |
| } |
| |
| mZoomButtonsController.setVisible(false); |
| } |
| |
| private void showOnScreenControls() { |
| if (mPaused) return; |
| // If the view has not been attached to the window yet, the |
| // zoomButtonControls will not able to show up. So delay it until the |
| // view has attached to window. |
| if (mActionIconPanel.getWindowToken() == null) { |
| mHandler.postGetterCallback(new Runnable() { |
| public void run() { |
| showOnScreenControls(); |
| } |
| }); |
| return; |
| } |
| updateNextPrevControls(); |
| |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| if (image instanceof VideoObject) { |
| mZoomButtonsController.setVisible(false); |
| } else { |
| updateZoomButtonsEnabled(); |
| mZoomButtonsController.setVisible(true); |
| } |
| |
| if (mShowActionIcons |
| && mActionIconPanel.getVisibility() != View.VISIBLE) { |
| Animation animation = new AlphaAnimation(0, 1); |
| animation.setDuration(500); |
| mActionIconPanel.startAnimation(animation); |
| mActionIconPanel.setVisibility(View.VISIBLE); |
| } |
| } |
| |
| @Override |
| public boolean dispatchTouchEvent(MotionEvent m) { |
| if (mPaused) return true; |
| if (mZoomButtonsController.isVisible()) { |
| scheduleDismissOnScreenControls(); |
| } |
| return super.dispatchTouchEvent(m); |
| } |
| |
| private void updateZoomButtonsEnabled() { |
| ImageViewTouch imageView = mImageView; |
| float scale = imageView.getScale(); |
| mZoomButtonsController.setZoomInEnabled(scale < imageView.mMaxZoom); |
| mZoomButtonsController.setZoomOutEnabled(scale > 1); |
| } |
| |
| @Override |
| protected void onDestroy() { |
| // This is necessary to make the ZoomButtonsController unregister |
| // its configuration change receiver. |
| if (mZoomButtonsController != null) { |
| mZoomButtonsController.setVisible(false); |
| } |
| super.onDestroy(); |
| } |
| |
| private void scheduleDismissOnScreenControls() { |
| mHandler.removeCallbacks(mDismissOnScreenControlRunner); |
| mHandler.postDelayed(mDismissOnScreenControlRunner, 2000); |
| } |
| |
| private void setupOnScreenControls(View rootView, View ownerView) { |
| mNextImageView = rootView.findViewById(R.id.next_image); |
| mPrevImageView = rootView.findViewById(R.id.prev_image); |
| |
| mNextImageView.setOnClickListener(this); |
| mPrevImageView.setOnClickListener(this); |
| |
| setupZoomButtonController(ownerView); |
| setupOnTouchListeners(rootView); |
| } |
| |
| private void setupZoomButtonController(final View ownerView) { |
| mZoomButtonsController = new ZoomButtonsController(ownerView); |
| mZoomButtonsController.setAutoDismissed(false); |
| mZoomButtonsController.setZoomSpeed(100); |
| mZoomButtonsController.setOnZoomListener( |
| new ZoomButtonsController.OnZoomListener() { |
| public void onVisibilityChanged(boolean visible) { |
| if (visible) { |
| updateZoomButtonsEnabled(); |
| } |
| } |
| |
| public void onZoom(boolean zoomIn) { |
| if (zoomIn) { |
| mImageView.zoomIn(); |
| } else { |
| mImageView.zoomOut(); |
| } |
| mZoomButtonsController.setVisible(true); |
| updateZoomButtonsEnabled(); |
| } |
| }); |
| } |
| |
| private void setupOnTouchListeners(View rootView) { |
| mGestureDetector = new GestureDetector(this, new MyGestureListener()); |
| |
| // If the user touches anywhere on the panel (including the |
| // next/prev button). We show the on-screen controls. In addition |
| // to that, if the touch is not on the prev/next button, we |
| // pass the event to the gesture detector to detect double tap. |
| final OnTouchListener buttonListener = new OnTouchListener() { |
| public boolean onTouch(View v, MotionEvent event) { |
| scheduleDismissOnScreenControls(); |
| return false; |
| } |
| }; |
| |
| OnTouchListener rootListener = new OnTouchListener() { |
| public boolean onTouch(View v, MotionEvent event) { |
| buttonListener.onTouch(v, event); |
| mGestureDetector.onTouchEvent(event); |
| |
| // We do not use the return value of |
| // mGestureDetector.onTouchEvent because we will not receive |
| // the "up" event if we return false for the "down" event. |
| return true; |
| } |
| }; |
| |
| mNextImageView.setOnTouchListener(buttonListener); |
| mPrevImageView.setOnTouchListener(buttonListener); |
| rootView.setOnTouchListener(rootListener); |
| } |
| |
| private class MyGestureListener extends |
| GestureDetector.SimpleOnGestureListener { |
| |
| @Override |
| public boolean onScroll(MotionEvent e1, MotionEvent e2, |
| float distanceX, float distanceY) { |
| if (mPaused) return false; |
| ImageViewTouch imageView = mImageView; |
| if (imageView.getScale() > 1F) { |
| imageView.postTranslateCenter(-distanceX, -distanceY); |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean onSingleTapUp(MotionEvent e) { |
| if (mPaused) return false; |
| setMode(MODE_NORMAL); |
| return true; |
| } |
| |
| @Override |
| public boolean onSingleTapConfirmed(MotionEvent e) { |
| if (mPaused) return false; |
| showOnScreenControls(); |
| scheduleDismissOnScreenControls(); |
| return true; |
| } |
| |
| @Override |
| public boolean onDoubleTap(MotionEvent e) { |
| if (mPaused) return false; |
| ImageViewTouch imageView = mImageView; |
| |
| // Switch between the original scale and 3x scale. |
| if (imageView.getScale() > 2F) { |
| mImageView.zoomTo(1f); |
| } else { |
| mImageView.zoomToPoint(3f, e.getX(), e.getY()); |
| } |
| return true; |
| } |
| } |
| |
| boolean isPickIntent() { |
| String action = getIntent().getAction(); |
| return (Intent.ACTION_PICK.equals(action) |
| || Intent.ACTION_GET_CONTENT.equals(action)); |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| super.onCreateOptionsMenu(menu); |
| |
| MenuItem item = menu.add(Menu.NONE, Menu.NONE, |
| MenuHelper.POSITION_SLIDESHOW, |
| R.string.slide_show); |
| item.setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| setMode(MODE_SLIDESHOW); |
| mLastSlideShowImage = mCurrentPosition; |
| loadNextImage(mCurrentPosition, 0, true); |
| return true; |
| } |
| }); |
| item.setIcon(android.R.drawable.ic_menu_slideshow); |
| |
| mImageMenuRunnable = MenuHelper.addImageMenuItems( |
| menu, |
| MenuHelper.INCLUDE_ALL, |
| ViewImage.this, |
| mHandler, |
| mDeletePhotoRunnable, |
| new MenuHelper.MenuInvoker() { |
| public void run(final MenuHelper.MenuCallback cb) { |
| if (mPaused) return; |
| setMode(MODE_NORMAL); |
| |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| Uri uri = image.fullSizeImageUri(); |
| cb.run(uri, image); |
| |
| // We might have deleted all images in the callback, so |
| // call setImage() only if we still have some images. |
| if (mAllImages.getCount() > 0) { |
| mImageView.clear(); |
| setImage(mCurrentPosition, false); |
| } |
| } |
| }); |
| |
| item = menu.add(Menu.NONE, Menu.NONE, |
| MenuHelper.POSITION_GALLERY_SETTING, R.string.camerasettings); |
| item.setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| Intent preferences = new Intent(); |
| preferences.setClass(ViewImage.this, GallerySettings.class); |
| startActivity(preferences); |
| return true; |
| } |
| }); |
| item.setAlphabeticShortcut('p'); |
| item.setIcon(android.R.drawable.ic_menu_preferences); |
| |
| return true; |
| } |
| |
| protected Runnable mDeletePhotoRunnable = new Runnable() { |
| public void run() { |
| mAllImages.removeImageAt(mCurrentPosition); |
| if (mAllImages.getCount() == 0) { |
| finish(); |
| return; |
| } else { |
| if (mCurrentPosition == mAllImages.getCount()) { |
| mCurrentPosition -= 1; |
| } |
| } |
| mImageView.clear(); |
| mCache.clear(); // Because the position number is changed. |
| setImage(mCurrentPosition, true); |
| } |
| }; |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| |
| super.onPrepareOptionsMenu(menu); |
| if (mPaused) return false; |
| |
| setMode(MODE_NORMAL); |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| |
| if (mImageMenuRunnable != null) { |
| mImageMenuRunnable.gettingReadyToOpen(menu, image); |
| } |
| |
| Uri uri = mAllImages.getImageAt(mCurrentPosition).fullSizeImageUri(); |
| MenuHelper.enableShareMenuItem(menu, MenuHelper.isWhiteListUri(uri)); |
| |
| MenuHelper.enableShowOnMapMenuItem(menu, MenuHelper.hasLatLngData(image)); |
| |
| return true; |
| } |
| |
| @Override |
| public boolean onMenuItemSelected(int featureId, MenuItem item) { |
| boolean b = super.onMenuItemSelected(featureId, item); |
| if (mImageMenuRunnable != null) { |
| mImageMenuRunnable.aboutToCall(item, |
| mAllImages.getImageAt(mCurrentPosition)); |
| } |
| return b; |
| } |
| |
| void setImage(int pos, boolean showControls) { |
| mCurrentPosition = pos; |
| |
| Bitmap b = mCache.getBitmap(pos); |
| if (b != null) { |
| IImage image = mAllImages.getImageAt(pos); |
| mImageView.setImageRotateBitmapResetBase( |
| new RotateBitmap(b, image.getDegreesRotated()), true); |
| updateZoomButtonsEnabled(); |
| } |
| |
| ImageGetterCallback cb = new ImageGetterCallback() { |
| public void completed() { |
| } |
| |
| public boolean wantsThumbnail(int pos, int offset) { |
| return !mCache.hasBitmap(pos + offset); |
| } |
| |
| public boolean wantsFullImage(int pos, int offset) { |
| return offset == 0; |
| } |
| |
| public int fullImageSizeToUse(int pos, int offset) { |
| // this number should be bigger so that we can zoom. we may |
| // need to get fancier and read in the fuller size image as the |
| // user starts to zoom. |
| // Originally the value is set to 480 in order to avoid OOM. |
| // Now we set it to 2048 because of using |
| // native memory allocation for Bitmaps. |
| final int imageViewSize = 2048; |
| return imageViewSize; |
| } |
| |
| public int [] loadOrder() { |
| return sOrderAdjacents; |
| } |
| |
| public void imageLoaded(int pos, int offset, RotateBitmap bitmap, |
| boolean isThumb) { |
| // shouldn't get here after onPause() |
| |
| // We may get a result from a previous request. Ignore it. |
| if (pos != mCurrentPosition) { |
| bitmap.recycle(); |
| return; |
| } |
| |
| if (isThumb) { |
| mCache.put(pos + offset, bitmap.getBitmap()); |
| } |
| if (offset == 0) { |
| // isThumb: We always load thumb bitmap first, so we will |
| // reset the supp matrix for then thumb bitmap, and keep |
| // the supp matrix when the full bitmap is loaded. |
| mImageView.setImageRotateBitmapResetBase(bitmap, isThumb); |
| updateZoomButtonsEnabled(); |
| } |
| } |
| }; |
| |
| // Could be null if we're stopping a slide show in the course of pausing |
| if (mGetter != null) { |
| mGetter.setPosition(pos, cb, mAllImages, mHandler); |
| } |
| updateActionIcons(); |
| if (showControls) showOnScreenControls(); |
| scheduleDismissOnScreenControls(); |
| } |
| |
| @Override |
| public void onCreate(Bundle instanceState) { |
| super.onCreate(instanceState); |
| |
| Intent intent = getIntent(); |
| mFullScreenInNormalMode = intent.getBooleanExtra( |
| MediaStore.EXTRA_FULL_SCREEN, true); |
| mShowActionIcons = intent.getBooleanExtra( |
| MediaStore.EXTRA_SHOW_ACTION_ICONS, true); |
| |
| mPrefs = PreferenceManager.getDefaultSharedPreferences(this); |
| |
| setDefaultKeyMode(DEFAULT_KEYS_SHORTCUT); |
| requestWindowFeature(Window.FEATURE_NO_TITLE); |
| setContentView(R.layout.viewimage); |
| |
| mImageView = (ImageViewTouch) findViewById(R.id.image); |
| mImageView.setEnableTrackballScroll(true); |
| mCache = new BitmapCache(3); |
| mImageView.setRecycler(mCache); |
| |
| makeGetter(); |
| |
| mAnimationIndex = -1; |
| |
| mSlideShowInAnimation = new Animation[] { |
| makeInAnimation(R.anim.transition_in), |
| makeInAnimation(R.anim.slide_in), |
| makeInAnimation(R.anim.slide_in_vertical), |
| }; |
| |
| mSlideShowOutAnimation = new Animation[] { |
| makeOutAnimation(R.anim.transition_out), |
| makeOutAnimation(R.anim.slide_out), |
| makeOutAnimation(R.anim.slide_out_vertical), |
| }; |
| |
| mSlideShowImageViews[0] = |
| (ImageViewTouchBase) findViewById(R.id.image1_slideShow); |
| mSlideShowImageViews[1] = |
| (ImageViewTouchBase) findViewById(R.id.image2_slideShow); |
| for (ImageViewTouchBase v : mSlideShowImageViews) { |
| v.setVisibility(View.INVISIBLE); |
| v.setRecycler(mCache); |
| } |
| |
| mActionIconPanel = findViewById(R.id.action_icon_panel); |
| |
| mParam = getIntent().getParcelableExtra(KEY_IMAGE_LIST); |
| |
| boolean slideshow; |
| if (instanceState != null) { |
| mSavedUri = instanceState.getParcelable(STATE_URI); |
| slideshow = instanceState.getBoolean(STATE_SLIDESHOW, false); |
| mShowControls = instanceState.getBoolean(STATE_SHOW_CONTROLS, true); |
| } else { |
| mSavedUri = getIntent().getData(); |
| slideshow = intent.getBooleanExtra(EXTRA_SLIDESHOW, false); |
| } |
| |
| // We only show action icons for URIs that we know we can share and |
| // delete. Although we get read permission (for the images) from |
| // applications like MMS, we cannot pass the permission to other |
| // activities due to the current framework design. |
| if (!MenuHelper.isWhiteListUri(mSavedUri)) { |
| mShowActionIcons = false; |
| } |
| |
| if (mShowActionIcons) { |
| int[] pickIds = {R.id.attach, R.id.cancel}; |
| int[] normalIds = {R.id.setas, R.id.play, R.id.share, R.id.discard}; |
| int[] connectIds = isPickIntent() ? pickIds : normalIds; |
| for (int id : connectIds) { |
| View view = mActionIconPanel.findViewById(id); |
| view.setVisibility(View.VISIBLE); |
| view.setOnClickListener(this); |
| } |
| } |
| |
| // Don't show the "delete" icon for SingleImageList. |
| if (ImageManager.isSingleImageMode(mSavedUri.toString())) { |
| mActionIconPanel.findViewById(R.id.discard) |
| .setVisibility(View.GONE); |
| } |
| |
| if (slideshow) { |
| setMode(MODE_SLIDESHOW); |
| } else { |
| if (mFullScreenInNormalMode) { |
| getWindow().addFlags( |
| WindowManager.LayoutParams.FLAG_FULLSCREEN); |
| } |
| if (mShowActionIcons) { |
| mActionIconPanel.setVisibility(View.VISIBLE); |
| } |
| } |
| |
| setupOnScreenControls(findViewById(R.id.rootLayout), mImageView); |
| } |
| |
| private void updateActionIcons() { |
| if (isPickIntent()) return; |
| |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| View panel = mActionIconPanel; |
| if (image instanceof VideoObject) { |
| panel.findViewById(R.id.setas).setVisibility(View.GONE); |
| panel.findViewById(R.id.play).setVisibility(View.VISIBLE); |
| } else { |
| panel.findViewById(R.id.setas).setVisibility(View.VISIBLE); |
| panel.findViewById(R.id.play).setVisibility(View.GONE); |
| } |
| } |
| |
| private Animation makeInAnimation(int id) { |
| Animation inAnimation = AnimationUtils.loadAnimation(this, id); |
| return inAnimation; |
| } |
| |
| private Animation makeOutAnimation(int id) { |
| Animation outAnimation = AnimationUtils.loadAnimation(this, id); |
| return outAnimation; |
| } |
| |
| private static int getPreferencesInteger( |
| SharedPreferences prefs, String key, int defaultValue) { |
| String value = prefs.getString(key, null); |
| try { |
| return value == null ? defaultValue : Integer.parseInt(value); |
| } catch (NumberFormatException ex) { |
| Log.e(TAG, "couldn't parse preference: " + value, ex); |
| return defaultValue; |
| } |
| } |
| |
| void setMode(int mode) { |
| if (mMode == mode) { |
| return; |
| } |
| View slideshowPanel = findViewById(R.id.slideShowContainer); |
| View normalPanel = findViewById(R.id.abs); |
| |
| Window win = getWindow(); |
| mMode = mode; |
| if (mode == MODE_SLIDESHOW) { |
| slideshowPanel.setVisibility(View.VISIBLE); |
| normalPanel.setVisibility(View.GONE); |
| |
| win.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN |
| | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); |
| |
| mImageView.clear(); |
| mActionIconPanel.setVisibility(View.GONE); |
| |
| slideshowPanel.getRootView().requestLayout(); |
| |
| // The preferences we want to read: |
| // mUseShuffleOrder |
| // mSlideShowLoop |
| // mAnimationIndex |
| // mSlideShowInterval |
| |
| mUseShuffleOrder = mPrefs.getBoolean(PREF_SHUFFLE_SLIDESHOW, false); |
| mSlideShowLoop = mPrefs.getBoolean(PREF_SLIDESHOW_REPEAT, false); |
| mAnimationIndex = getPreferencesInteger( |
| mPrefs, "pref_gallery_slideshow_transition_key", 0); |
| mSlideShowInterval = getPreferencesInteger( |
| mPrefs, "pref_gallery_slideshow_interval_key", 3) * 1000; |
| } else { |
| slideshowPanel.setVisibility(View.GONE); |
| normalPanel.setVisibility(View.VISIBLE); |
| |
| win.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); |
| if (mFullScreenInNormalMode) { |
| win.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN); |
| } else { |
| win.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN); |
| } |
| |
| if (mGetter != null) { |
| mGetter.cancelCurrent(); |
| } |
| |
| if (mShowActionIcons) { |
| Animation animation = new AlphaAnimation(0F, 1F); |
| animation.setDuration(500); |
| mActionIconPanel.setAnimation(animation); |
| mActionIconPanel.setVisibility(View.VISIBLE); |
| } |
| |
| ImageViewTouchBase dst = mImageView; |
| for (ImageViewTouchBase ivt : mSlideShowImageViews) { |
| ivt.clear(); |
| } |
| |
| mShuffleOrder = null; |
| |
| // mGetter null is a proxy for being paused |
| if (mGetter != null) { |
| setImage(mCurrentPosition, true); |
| } |
| } |
| } |
| |
| private void generateShuffleOrder() { |
| if (mShuffleOrder == null |
| || mShuffleOrder.length != mAllImages.getCount()) { |
| mShuffleOrder = new int[mAllImages.getCount()]; |
| for (int i = 0, n = mShuffleOrder.length; i < n; i++) { |
| mShuffleOrder[i] = i; |
| } |
| } |
| |
| for (int i = mShuffleOrder.length - 1; i >= 0; i--) { |
| int r = mRandom.nextInt(i + 1); |
| if (r != i) { |
| int tmp = mShuffleOrder[r]; |
| mShuffleOrder[r] = mShuffleOrder[i]; |
| mShuffleOrder[i] = tmp; |
| } |
| } |
| } |
| |
| private void loadNextImage(final int requestedPos, final long delay, |
| final boolean firstCall) { |
| if (firstCall && mUseShuffleOrder) { |
| generateShuffleOrder(); |
| } |
| |
| final long targetDisplayTime = System.currentTimeMillis() + delay; |
| |
| ImageGetterCallback cb = new ImageGetterCallback() { |
| public void completed() { |
| } |
| |
| public boolean wantsThumbnail(int pos, int offset) { |
| return true; |
| } |
| |
| public boolean wantsFullImage(int pos, int offset) { |
| return false; |
| } |
| |
| public int [] loadOrder() { |
| return sOrderSlideshow; |
| } |
| |
| public int fullImageSizeToUse(int pos, int offset) { |
| return 480; // TODO compute this |
| } |
| |
| public void imageLoaded(final int pos, final int offset, |
| final RotateBitmap bitmap, final boolean isThumb) { |
| long timeRemaining = Math.max(0, |
| targetDisplayTime - System.currentTimeMillis()); |
| mHandler.postDelayedGetterCallback(new Runnable() { |
| public void run() { |
| if (mMode == MODE_NORMAL) { |
| return; |
| } |
| |
| ImageViewTouchBase oldView = |
| mSlideShowImageViews[mSlideShowImageCurrent]; |
| |
| if (++mSlideShowImageCurrent |
| == mSlideShowImageViews.length) { |
| mSlideShowImageCurrent = 0; |
| } |
| |
| ImageViewTouchBase newView = |
| mSlideShowImageViews[mSlideShowImageCurrent]; |
| newView.setVisibility(View.VISIBLE); |
| newView.setImageRotateBitmapResetBase(bitmap, true); |
| newView.bringToFront(); |
| |
| int animation = 0; |
| |
| if (mAnimationIndex == -1) { |
| int n = mRandom.nextInt( |
| mSlideShowInAnimation.length); |
| animation = n; |
| } else { |
| animation = mAnimationIndex; |
| } |
| |
| Animation aIn = mSlideShowInAnimation[animation]; |
| newView.startAnimation(aIn); |
| newView.setVisibility(View.VISIBLE); |
| |
| Animation aOut = mSlideShowOutAnimation[animation]; |
| oldView.setVisibility(View.INVISIBLE); |
| oldView.startAnimation(aOut); |
| |
| mCurrentPosition = requestedPos; |
| |
| if (mCurrentPosition == mLastSlideShowImage |
| && !firstCall) { |
| if (mSlideShowLoop) { |
| if (mUseShuffleOrder) { |
| generateShuffleOrder(); |
| } |
| } else { |
| setMode(MODE_NORMAL); |
| return; |
| } |
| } |
| |
| loadNextImage( |
| (mCurrentPosition + 1) % mAllImages.getCount(), |
| mSlideShowInterval, false); |
| } |
| }, timeRemaining); |
| } |
| }; |
| // Could be null if we're stopping a slide show in the course of pausing |
| if (mGetter != null) { |
| int pos = requestedPos; |
| if (mShuffleOrder != null) { |
| pos = mShuffleOrder[pos]; |
| } |
| mGetter.setPosition(pos, cb, mAllImages, mHandler); |
| } |
| } |
| |
| private void makeGetter() { |
| mGetter = new ImageGetter(getContentResolver()); |
| } |
| |
| private IImageList buildImageListFromUri(Uri uri) { |
| String sortOrder = mPrefs.getString( |
| "pref_gallery_sort_key", "descending"); |
| int sort = sortOrder.equals("ascending") |
| ? ImageManager.SORT_ASCENDING |
| : ImageManager.SORT_DESCENDING; |
| return ImageManager.makeImageList(getContentResolver(), uri, sort); |
| } |
| |
| private boolean init(Uri uri) { |
| if (uri == null) return false; |
| mAllImages = (mParam == null) |
| ? buildImageListFromUri(uri) |
| : ImageManager.makeImageList(getContentResolver(), mParam); |
| IImage image = mAllImages.getImageForUri(uri); |
| if (image == null) return false; |
| mCurrentPosition = mAllImages.getImageIndex(image); |
| mLastSlideShowImage = mCurrentPosition; |
| return true; |
| } |
| |
| private Uri getCurrentUri() { |
| if (mAllImages.getCount() == 0) return null; |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| if (image == null) return null; |
| return image.fullSizeImageUri(); |
| } |
| |
| @Override |
| public void onSaveInstanceState(Bundle b) { |
| super.onSaveInstanceState(b); |
| b.putParcelable(STATE_URI, |
| mAllImages.getImageAt(mCurrentPosition).fullSizeImageUri()); |
| b.putBoolean(STATE_SLIDESHOW, mMode == MODE_SLIDESHOW); |
| } |
| |
| @Override |
| public void onStart() { |
| super.onStart(); |
| mPaused = false; |
| |
| if (!init(mSavedUri)) { |
| Log.w(TAG, "init failed: " + mSavedUri); |
| finish(); |
| return; |
| } |
| |
| // normally this will never be zero but if one "backs" into this |
| // activity after removing the sdcard it could be zero. in that |
| // case just "finish" since there's nothing useful that can happen. |
| int count = mAllImages.getCount(); |
| if (count == 0) { |
| finish(); |
| return; |
| } else if (count <= mCurrentPosition) { |
| mCurrentPosition = count - 1; |
| } |
| |
| if (mGetter == null) { |
| makeGetter(); |
| } |
| |
| if (mMode == MODE_SLIDESHOW) { |
| loadNextImage(mCurrentPosition, 0, true); |
| } else { // MODE_NORMAL |
| setImage(mCurrentPosition, mShowControls); |
| mShowControls = false; |
| } |
| } |
| |
| @Override |
| public void onStop() { |
| super.onStop(); |
| mPaused = true; |
| |
| // mGetter could be null if we call finish() and leave early in |
| // onStart(). |
| if (mGetter != null) { |
| mGetter.cancelCurrent(); |
| mGetter.stop(); |
| mGetter = null; |
| } |
| setMode(MODE_NORMAL); |
| |
| // removing all callback in the message queue |
| mHandler.removeAllGetterCallbacks(); |
| |
| if (mAllImages != null) { |
| mSavedUri = getCurrentUri(); |
| mAllImages.close(); |
| mAllImages = null; |
| } |
| |
| hideOnScreenControls(); |
| mImageView.clear(); |
| mCache.clear(); |
| |
| for (ImageViewTouchBase iv : mSlideShowImageViews) { |
| iv.clear(); |
| } |
| } |
| |
| private void startShareMediaActivity(IImage image) { |
| boolean isVideo = image instanceof VideoObject; |
| Intent intent = new Intent(); |
| intent.setAction(Intent.ACTION_SEND); |
| intent.setType(image.getMimeType()); |
| intent.putExtra(Intent.EXTRA_STREAM, image.fullSizeImageUri()); |
| try { |
| startActivity(Intent.createChooser(intent, getText( |
| isVideo ? R.string.sendVideo : R.string.sendImage))); |
| } catch (android.content.ActivityNotFoundException ex) { |
| Toast.makeText(this, isVideo |
| ? R.string.no_way_to_share_image |
| : R.string.no_way_to_share_video, |
| Toast.LENGTH_SHORT).show(); |
| } |
| } |
| |
| private void startPlayVideoActivity() { |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| Intent intent = new Intent( |
| Intent.ACTION_VIEW, image.fullSizeImageUri()); |
| try { |
| startActivity(intent); |
| } catch (android.content.ActivityNotFoundException ex) { |
| Log.e(TAG, "Couldn't view video " + image.fullSizeImageUri(), ex); |
| } |
| } |
| |
| public void onClick(View v) { |
| switch (v.getId()) { |
| case R.id.discard: |
| MenuHelper.deletePhoto(this, mDeletePhotoRunnable); |
| break; |
| case R.id.play: |
| startPlayVideoActivity(); |
| break; |
| case R.id.share: { |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| if (!MenuHelper.isWhiteListUri(image.fullSizeImageUri())) { |
| return; |
| } |
| startShareMediaActivity(image); |
| break; |
| } |
| case R.id.setas: { |
| IImage image = mAllImages.getImageAt(mCurrentPosition); |
| Intent intent = Util.createSetAsIntent(image); |
| try { |
| startActivity(Intent.createChooser( |
| intent, getText(R.string.setImage))); |
| } catch (android.content.ActivityNotFoundException ex) { |
| Toast.makeText(this, R.string.no_way_to_share_video, |
| Toast.LENGTH_SHORT).show(); |
| } |
| break; |
| } |
| case R.id.next_image: |
| moveNextOrPrevious(1); |
| break; |
| case R.id.prev_image: |
| moveNextOrPrevious(-1); |
| break; |
| } |
| } |
| |
| private void moveNextOrPrevious(int delta) { |
| int nextImagePos = mCurrentPosition + delta; |
| if ((0 <= nextImagePos) && (nextImagePos < mAllImages.getCount())) { |
| setImage(nextImagePos, true); |
| showOnScreenControls(); |
| } |
| } |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, |
| Intent data) { |
| switch (requestCode) { |
| case MenuHelper.RESULT_COMMON_MENU_CROP: |
| if (resultCode == RESULT_OK) { |
| // The CropImage activity passes back the Uri of the |
| // cropped image as the Action rather than the Data. |
| mSavedUri = Uri.parse(data.getAction()); |
| |
| // if onStart() runs before, then set the returned |
| // image as currentImage. |
| if (mAllImages != null) { |
| IImage image = mAllImages.getImageForUri(mSavedUri); |
| // image could be null if SD card is removed. |
| if (image == null) { |
| finish(); |
| } else { |
| mCurrentPosition = mAllImages.getImageIndex(image); |
| setImage(mCurrentPosition, false); |
| } |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| class ImageViewTouch extends ImageViewTouchBase { |
| private final ViewImage mViewImage; |
| private boolean mEnableTrackballScroll; |
| |
| public ImageViewTouch(Context context) { |
| super(context); |
| mViewImage = (ViewImage) context; |
| } |
| |
| public ImageViewTouch(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| mViewImage = (ViewImage) context; |
| } |
| |
| public void setEnableTrackballScroll(boolean enable) { |
| mEnableTrackballScroll = enable; |
| } |
| |
| protected void postTranslateCenter(float dx, float dy) { |
| super.postTranslate(dx, dy); |
| center(true, true); |
| } |
| |
| private static final float PAN_RATE = 20; |
| |
| // This is the time we allow the dpad to change the image position again. |
| private long mNextChangePositionTime; |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| if (mViewImage.mPaused) return false; |
| |
| // Don't respond to arrow keys if trackball scrolling is not enabled |
| if (!mEnableTrackballScroll) { |
| if ((keyCode >= KeyEvent.KEYCODE_DPAD_UP) |
| && (keyCode <= KeyEvent.KEYCODE_DPAD_RIGHT)) { |
| return super.onKeyDown(keyCode, event); |
| } |
| } |
| |
| int current = mViewImage.mCurrentPosition; |
| |
| int nextImagePos = -2; // default no next image |
| try { |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_DPAD_CENTER: { |
| if (mViewImage.isPickIntent()) { |
| IImage img = mViewImage.mAllImages |
| .getImageAt(mViewImage.mCurrentPosition); |
| mViewImage.setResult(ViewImage.RESULT_OK, |
| new Intent().setData(img.fullSizeImageUri())); |
| mViewImage.finish(); |
| } |
| break; |
| } |
| case KeyEvent.KEYCODE_DPAD_LEFT: { |
| if (getScale() <= 1F && event.getEventTime() |
| >= mNextChangePositionTime) { |
| nextImagePos = current - 1; |
| mNextChangePositionTime = event.getEventTime() + 500; |
| } else { |
| panBy(PAN_RATE, 0); |
| center(true, false); |
| } |
| return true; |
| } |
| case KeyEvent.KEYCODE_DPAD_RIGHT: { |
| if (getScale() <= 1F && event.getEventTime() |
| >= mNextChangePositionTime) { |
| nextImagePos = current + 1; |
| mNextChangePositionTime = event.getEventTime() + 500; |
| } else { |
| panBy(-PAN_RATE, 0); |
| center(true, false); |
| } |
| return true; |
| } |
| case KeyEvent.KEYCODE_DPAD_UP: { |
| panBy(0, PAN_RATE); |
| center(false, true); |
| return true; |
| } |
| case KeyEvent.KEYCODE_DPAD_DOWN: { |
| panBy(0, -PAN_RATE); |
| center(false, true); |
| return true; |
| } |
| case KeyEvent.KEYCODE_DEL: |
| MenuHelper.deletePhoto( |
| mViewImage, mViewImage.mDeletePhotoRunnable); |
| break; |
| } |
| } finally { |
| if (nextImagePos >= 0 |
| && nextImagePos < mViewImage.mAllImages.getCount()) { |
| synchronized (mViewImage) { |
| mViewImage.setMode(ViewImage.MODE_NORMAL); |
| mViewImage.setImage(nextImagePos, true); |
| } |
| } else if (nextImagePos != -2) { |
| center(true, true); |
| } |
| } |
| |
| return super.onKeyDown(keyCode, event); |
| } |
| } |
| |
| // This is a cache for Bitmap displayed in ViewImage (normal mode, thumb only). |
| class BitmapCache implements ImageViewTouchBase.Recycler { |
| public static class Entry { |
| int mPos; |
| Bitmap mBitmap; |
| public Entry() { |
| clear(); |
| } |
| public void clear() { |
| mPos = -1; |
| mBitmap = null; |
| } |
| } |
| |
| private final Entry[] mCache; |
| |
| public BitmapCache(int size) { |
| mCache = new Entry[size]; |
| for (int i = 0; i < mCache.length; i++) { |
| mCache[i] = new Entry(); |
| } |
| } |
| |
| // Given the position, find the associated entry. Returns null if there is |
| // no such entry. |
| private Entry findEntry(int pos) { |
| for (Entry e : mCache) { |
| if (pos == e.mPos) { |
| return e; |
| } |
| } |
| return null; |
| } |
| |
| // Returns the thumb bitmap if we have it, otherwise return null. |
| public synchronized Bitmap getBitmap(int pos) { |
| Entry e = findEntry(pos); |
| if (e != null) { |
| return e.mBitmap; |
| } |
| return null; |
| } |
| |
| public synchronized void put(int pos, Bitmap bitmap) { |
| // First see if we already have this entry. |
| if (findEntry(pos) != null) { |
| return; |
| } |
| |
| // Find the best entry we should replace. |
| // See if there is any empty entry. |
| // Otherwise assuming sequential access, kick out the entry with the |
| // greatest distance. |
| Entry best = null; |
| int maxDist = -1; |
| for (Entry e : mCache) { |
| if (e.mPos == -1) { |
| best = e; |
| break; |
| } else { |
| int dist = Math.abs(pos - e.mPos); |
| if (dist > maxDist) { |
| maxDist = dist; |
| best = e; |
| } |
| } |
| } |
| |
| // Recycle the image being kicked out. |
| // This only works because our current usage is sequential, so we |
| // do not happen to recycle the image being displayed. |
| if (best.mBitmap != null) { |
| best.mBitmap.recycle(); |
| } |
| |
| best.mPos = pos; |
| best.mBitmap = bitmap; |
| } |
| |
| // Recycle all bitmaps in the cache and clear the cache. |
| public synchronized void clear() { |
| for (Entry e : mCache) { |
| if (e.mBitmap != null) { |
| e.mBitmap.recycle(); |
| } |
| e.clear(); |
| } |
| } |
| |
| // Returns whether the bitmap is in the cache. |
| public synchronized boolean hasBitmap(int pos) { |
| Entry e = findEntry(pos); |
| return (e != null); |
| } |
| |
| // Recycle the bitmap if it's not in the cache. |
| // The input must be non-null. |
| public synchronized void recycle(Bitmap b) { |
| for (Entry e : mCache) { |
| if (e.mPos != -1) { |
| if (e.mBitmap == b) { |
| return; |
| } |
| } |
| } |
| b.recycle(); |
| } |
| } |
