| /* |
| * 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.app.AlertDialog; |
| import android.app.Dialog; |
| import android.app.ProgressDialog; |
| import android.content.ActivityNotFoundException; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.SharedPreferences; |
| import android.content.pm.ActivityInfo; |
| import android.content.res.Configuration; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.Canvas; |
| import android.graphics.Paint; |
| import android.graphics.Rect; |
| import android.graphics.drawable.Drawable; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Parcelable; |
| import android.preference.PreferenceManager; |
| import android.provider.MediaStore; |
| import android.util.Log; |
| import android.view.ContextMenu; |
| import android.view.KeyEvent; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.view.Window; |
| import android.view.View.OnClickListener; |
| import android.view.animation.Animation; |
| import android.view.animation.AnimationUtils; |
| import android.widget.Button; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.android.camera.gallery.IImage; |
| import com.android.camera.gallery.IImageList; |
| import com.android.camera.gallery.VideoObject; |
| |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| |
| public class ImageGallery extends NoSearchActivity implements |
| GridViewSpecial.Listener, GridViewSpecial.DrawAdapter { |
| private static final String STATE_SCROLL_POSITION = "scroll_position"; |
| private static final String STATE_SELECTED_INDEX = "first_index"; |
| |
| private static final String TAG = "ImageGallery"; |
| private static final float INVALID_POSITION = -1f; |
| private ImageManager.ImageListParam mParam; |
| private IImageList mAllImages; |
| private int mInclusion; |
| boolean mSortAscending = false; |
| private View mNoImagesView; |
| public static final int CROP_MSG = 2; |
| |
| private Dialog mMediaScanningDialog; |
| private MenuItem mSlideShowItem; |
| private SharedPreferences mPrefs; |
| private long mVideoSizeLimit = Long.MAX_VALUE; |
| private View mFooterOrganizeView; |
| |
| private BroadcastReceiver mReceiver = null; |
| |
| private final Handler mHandler = new Handler(); |
| private boolean mLayoutComplete; |
| private boolean mPausing = true; |
| private ImageLoader mLoader; |
| private GridViewSpecial mGvs; |
| |
| private Uri mCropResultUri; |
| |
| // The index of the first picture in GridViewSpecial. |
| private int mSelectedIndex = GridViewSpecial.INDEX_NONE; |
| private float mScrollPosition = INVALID_POSITION; |
| private boolean mConfigurationChanged = false; |
| |
| private HashSet<IImage> mMultiSelected = null; |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| |
| mPrefs = PreferenceManager.getDefaultSharedPreferences(this); |
| |
| // Must be called before setContentView(). |
| requestWindowFeature(Window.FEATURE_CUSTOM_TITLE); |
| |
| setContentView(R.layout.image_gallery); |
| |
| getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, |
| R.layout.custom_gallery_title); |
| |
| mNoImagesView = findViewById(R.id.no_images); |
| |
| mGvs = (GridViewSpecial) findViewById(R.id.grid); |
| mGvs.setListener(this); |
| |
| mFooterOrganizeView = findViewById(R.id.footer_organize); |
| |
| // consume all click events on the footer view |
| mFooterOrganizeView.setOnClickListener(Util.getNullOnClickListener()); |
| initializeFooterButtons(); |
| |
| if (isPickIntent()) { |
| mVideoSizeLimit = getIntent().getLongExtra( |
| MediaStore.EXTRA_SIZE_LIMIT, Long.MAX_VALUE); |
| } else { |
| mVideoSizeLimit = Long.MAX_VALUE; |
| mGvs.setOnCreateContextMenuListener( |
| new CreateContextMenuListener()); |
| } |
| |
| setupInclusion(); |
| |
| mLoader = new ImageLoader(getContentResolver(), mHandler); |
| } |
| |
| private void initializeFooterButtons() { |
| Button deleteButton = (Button) findViewById(R.id.button_delete); |
| deleteButton.setOnClickListener(new OnClickListener() { |
| public void onClick(View v) { |
| onDeleteMultipleClicked(); |
| } |
| }); |
| |
| Button shareButton = (Button) findViewById(R.id.button_share); |
| shareButton.setOnClickListener(new OnClickListener() { |
| public void onClick(View v) { |
| onShareMultipleClicked(); |
| } |
| }); |
| |
| Button closeButton = (Button) findViewById(R.id.button_close); |
| closeButton.setOnClickListener(new OnClickListener() { |
| public void onClick(View v) { |
| closeMultiSelectMode(); |
| } |
| }); |
| } |
| |
| private MenuItem addSlideShowMenu(Menu menu) { |
| return menu.add(Menu.NONE, Menu.NONE, MenuHelper.POSITION_SLIDESHOW, |
| R.string.slide_show) |
| .setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| return onSlideShowClicked(); |
| } |
| }).setIcon(android.R.drawable.ic_menu_slideshow); |
| } |
| |
| public boolean onSlideShowClicked() { |
| if (!canHandleEvent()) { |
| return false; |
| } |
| IImage img = getCurrentImage(); |
| if (img == null) { |
| img = mAllImages.getImageAt(0); |
| if (img == null) { |
| return true; |
| } |
| } |
| Uri targetUri = img.fullSizeImageUri(); |
| Uri thisUri = getIntent().getData(); |
| if (thisUri != null) { |
| String bucket = thisUri.getQueryParameter("bucketId"); |
| if (bucket != null) { |
| targetUri = targetUri.buildUpon() |
| .appendQueryParameter("bucketId", bucket) |
| .build(); |
| } |
| } |
| Intent intent = new Intent(Intent.ACTION_VIEW, targetUri); |
| intent.putExtra("slideshow", true); |
| startActivity(intent); |
| return true; |
| } |
| |
| private final Runnable mDeletePhotoRunnable = new Runnable() { |
| public void run() { |
| if (!canHandleEvent()) return; |
| |
| IImage currentImage = getCurrentImage(); |
| |
| // The selection will be cleared when mGvs.stop() is called, so |
| // we need to call getCurrentImage() before mGvs.stop(). |
| mGvs.stop(); |
| |
| if (currentImage != null) { |
| mAllImages.removeImage(currentImage); |
| } |
| mGvs.setImageList(mAllImages); |
| mGvs.start(); |
| |
| mNoImagesView.setVisibility(mAllImages.isEmpty() |
| ? View.VISIBLE |
| : View.GONE); |
| } |
| }; |
| |
| private Uri getCurrentImageUri() { |
| IImage image = getCurrentImage(); |
| if (image != null) { |
| return image.fullSizeImageUri(); |
| } else { |
| return null; |
| } |
| } |
| |
| private IImage getCurrentImage() { |
| int currentSelection = mGvs.getCurrentSelection(); |
| if (currentSelection < 0 |
| || currentSelection >= mAllImages.getCount()) { |
| return null; |
| } else { |
| return mAllImages.getImageAt(currentSelection); |
| } |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration newConfig) { |
| super.onConfigurationChanged(newConfig); |
| mConfigurationChanged = true; |
| } |
| |
| boolean canHandleEvent() { |
| // Don't process event in pause state. |
| return (!mPausing) && (mLayoutComplete); |
| } |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| if (!canHandleEvent()) return false; |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_DEL: |
| IImage image = getCurrentImage(); |
| if (image != null) { |
| MenuHelper.deleteImage( |
| this, mDeletePhotoRunnable, getCurrentImage()); |
| } |
| return true; |
| } |
| return super.onKeyDown(keyCode, event); |
| } |
| |
| private boolean isPickIntent() { |
| String action = getIntent().getAction(); |
| return (Intent.ACTION_PICK.equals(action) |
| || Intent.ACTION_GET_CONTENT.equals(action)); |
| } |
| |
| private void launchCropperOrFinish(IImage img) { |
| Bundle myExtras = getIntent().getExtras(); |
| |
| long size = MenuHelper.getImageFileSize(img); |
| if (size < 0) { |
| // Return if the image file is not available. |
| return; |
| } |
| |
| if (size > mVideoSizeLimit) { |
| DialogInterface.OnClickListener buttonListener = |
| new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int which) { |
| dialog.dismiss(); |
| } |
| }; |
| new AlertDialog.Builder(this) |
| .setIcon(android.R.drawable.ic_dialog_info) |
| .setTitle(R.string.file_info_title) |
| .setMessage(R.string.video_exceed_mms_limit) |
| .setNeutralButton(R.string.details_ok, buttonListener) |
| .show(); |
| return; |
| } |
| |
| String cropValue = myExtras != null ? myExtras.getString("crop") : null; |
| if (cropValue != null) { |
| Bundle newExtras = new Bundle(); |
| if (cropValue.equals("circle")) { |
| newExtras.putString("circleCrop", "true"); |
| } |
| |
| Intent cropIntent = new Intent(); |
| cropIntent.setData(img.fullSizeImageUri()); |
| cropIntent.setClass(this, CropImage.class); |
| cropIntent.putExtras(newExtras); |
| |
| /* pass through any extras that were passed in */ |
| cropIntent.putExtras(myExtras); |
| startActivityForResult(cropIntent, CROP_MSG); |
| } else { |
| Intent result = new Intent(null, img.fullSizeImageUri()); |
| if (myExtras != null && myExtras.getBoolean("return-data")) { |
| // The size of a transaction should be below 100K. |
| Bitmap bitmap = img.fullSizeBitmap( |
| IImage.UNCONSTRAINED, 100 * 1024); |
| if (bitmap != null) { |
| result.putExtra("data", bitmap); |
| } |
| } |
| setResult(RESULT_OK, result); |
| finish(); |
| } |
| } |
| |
| @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. |
| // We store this URI so we can move the selection box to it |
| // later. |
| mCropResultUri = Uri.parse(data.getAction()); |
| } |
| break; |
| } |
| case CROP_MSG: { |
| if (resultCode == RESULT_OK) { |
| setResult(resultCode, data); |
| finish(); |
| } |
| break; |
| } |
| } |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| mPausing = true; |
| |
| mLoader.stop(); |
| |
| mGvs.stop(); |
| |
| if (mReceiver != null) { |
| unregisterReceiver(mReceiver); |
| mReceiver = null; |
| } |
| |
| // Now that we've paused the threads that are using the cursor it is |
| // safe to close it. |
| mAllImages.close(); |
| mAllImages = null; |
| } |
| |
| private void rebake(boolean unmounted, boolean scanning) { |
| mGvs.stop(); |
| if (mAllImages != null) { |
| mAllImages.close(); |
| mAllImages = null; |
| } |
| |
| if (mMediaScanningDialog != null) { |
| mMediaScanningDialog.cancel(); |
| mMediaScanningDialog = null; |
| } |
| |
| if (scanning) { |
| mMediaScanningDialog = ProgressDialog.show( |
| this, |
| null, |
| getResources().getString(R.string.wait), |
| true, |
| true); |
| } |
| |
| mParam = allImages(!unmounted && !scanning); |
| mAllImages = ImageManager.makeImageList(getContentResolver(), mParam); |
| |
| mGvs.setImageList(mAllImages); |
| mGvs.setDrawAdapter(this); |
| mGvs.setLoader(mLoader); |
| mGvs.start(); |
| mNoImagesView.setVisibility(mAllImages.getCount() > 0 |
| ? View.GONE |
| : View.VISIBLE); |
| } |
| |
| @Override |
| protected void onSaveInstanceState(Bundle state) { |
| super.onSaveInstanceState(state); |
| state.putFloat(STATE_SCROLL_POSITION, mScrollPosition); |
| state.putInt(STATE_SELECTED_INDEX, mSelectedIndex); |
| } |
| |
| @Override |
| protected void onRestoreInstanceState(Bundle state) { |
| super.onRestoreInstanceState(state); |
| mScrollPosition = state.getFloat( |
| STATE_SCROLL_POSITION, INVALID_POSITION); |
| mSelectedIndex = state.getInt(STATE_SELECTED_INDEX, 0); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| |
| mGvs.setSizeChoice(Integer.parseInt( |
| mPrefs.getString("pref_gallery_size_key", "1"))); |
| mGvs.requestFocus(); |
| |
| String sortOrder = mPrefs.getString("pref_gallery_sort_key", null); |
| if (sortOrder != null) { |
| mSortAscending = sortOrder.equals("ascending"); |
| } |
| |
| mPausing = false; |
| |
| // install an intent filter to receive SD card related events. |
| IntentFilter intentFilter = |
| new IntentFilter(Intent.ACTION_MEDIA_MOUNTED); |
| intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED); |
| intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_STARTED); |
| intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_FINISHED); |
| intentFilter.addAction(Intent.ACTION_MEDIA_EJECT); |
| intentFilter.addDataScheme("file"); |
| |
| mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) { |
| // SD card available |
| // TODO put up a "please wait" message |
| // TODO also listen for the media scanner finished message |
| } else if (action.equals(Intent.ACTION_MEDIA_UNMOUNTED)) { |
| // SD card unavailable |
| rebake(true, false); |
| } else if (action.equals(Intent.ACTION_MEDIA_SCANNER_STARTED)) { |
| rebake(false, true); |
| } else if (action.equals( |
| Intent.ACTION_MEDIA_SCANNER_FINISHED)) { |
| rebake(false, false); |
| } else if (action.equals(Intent.ACTION_MEDIA_EJECT)) { |
| rebake(true, false); |
| } |
| } |
| }; |
| registerReceiver(mReceiver, intentFilter); |
| rebake(false, ImageManager.isMediaScannerScanning( |
| getContentResolver())); |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| if (isPickIntent()) { |
| String type = getIntent().resolveType(this); |
| if (type != null) { |
| if (isImageType(type)) { |
| MenuHelper.addCapturePictureMenuItems(menu, this); |
| } else if (isVideoType(type)) { |
| MenuHelper.addCaptureVideoMenuItems(menu, this); |
| } |
| } |
| } else { |
| MenuHelper.addCaptureMenuItems(menu, this); |
| if ((mInclusion & ImageManager.INCLUDE_IMAGES) != 0) { |
| mSlideShowItem = addSlideShowMenu(menu); |
| } |
| |
| MenuItem 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(ImageGallery.this, |
| GallerySettings.class); |
| startActivity(preferences); |
| return true; |
| } |
| }); |
| item.setAlphabeticShortcut('p'); |
| item.setIcon(android.R.drawable.ic_menu_preferences); |
| |
| item = menu.add(Menu.NONE, Menu.NONE, |
| MenuHelper.POSITION_MULTISELECT, |
| R.string.multiselect); |
| item.setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| if (isInMultiSelectMode()) { |
| closeMultiSelectMode(); |
| } else { |
| openMultiSelectMode(); |
| } |
| return true; |
| } |
| }); |
| item.setIcon(R.drawable.ic_menu_multiselect_gallery); |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| if (!canHandleEvent()) return false; |
| if ((mInclusion & ImageManager.INCLUDE_IMAGES) != 0) { |
| boolean videoSelected = isVideoSelected(); |
| // TODO: Only enable slide show if there is at least one image in |
| // the folder. |
| if (mSlideShowItem != null) { |
| mSlideShowItem.setEnabled(!videoSelected); |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean isVideoSelected() { |
| IImage image = getCurrentImage(); |
| return (image != null) && ImageManager.isVideo(image); |
| } |
| |
| private boolean isImageType(String type) { |
| return type.equals("vnd.android.cursor.dir/image") |
| || type.equals("image/*"); |
| } |
| |
| private boolean isVideoType(String type) { |
| return type.equals("vnd.android.cursor.dir/video") |
| || type.equals("video/*"); |
| } |
| |
| // According to the intent, setup what we include (image/video) in the |
| // gallery and the title of the gallery. |
| private void setupInclusion() { |
| mInclusion = ImageManager.INCLUDE_IMAGES | ImageManager.INCLUDE_VIDEOS; |
| |
| Intent intent = getIntent(); |
| if (intent != null) { |
| String type = intent.resolveType(this); |
| TextView leftText = (TextView) findViewById(R.id.left_text); |
| if (type != null) { |
| if (isImageType(type)) { |
| mInclusion = ImageManager.INCLUDE_IMAGES; |
| if (isPickIntent()) { |
| leftText.setText(R.string.pick_photos_gallery_title); |
| } else { |
| leftText.setText(R.string.photos_gallery_title); |
| } |
| } |
| if (isVideoType(type)) { |
| mInclusion = ImageManager.INCLUDE_VIDEOS; |
| if (isPickIntent()) { |
| leftText.setText(R.string.pick_videos_gallery_title); |
| } else { |
| leftText.setText(R.string.videos_gallery_title); |
| } |
| } |
| } |
| Bundle extras = intent.getExtras(); |
| String title = (extras != null) |
| ? extras.getString("windowTitle") |
| : null; |
| if (title != null && title.length() > 0) { |
| leftText.setText(title); |
| } |
| |
| if (extras != null) { |
| mInclusion = (ImageManager.INCLUDE_IMAGES |
| | ImageManager.INCLUDE_VIDEOS) |
| & extras.getInt("mediaTypes", mInclusion); |
| } |
| |
| if (extras != null && extras.getBoolean("pick-drm")) { |
| Log.d(TAG, "pick-drm is true"); |
| mInclusion = ImageManager.INCLUDE_DRM_IMAGES; |
| } |
| } |
| } |
| |
| // Returns the image list parameter which contains the subset of image/video |
| // we want. |
| private ImageManager.ImageListParam allImages(boolean storageAvailable) { |
| if (!storageAvailable) { |
| return ImageManager.getEmptyImageListParam(); |
| } else { |
| Uri uri = getIntent().getData(); |
| return ImageManager.getImageListParam( |
| ImageManager.DataLocation.EXTERNAL, |
| mInclusion, |
| mSortAscending |
| ? ImageManager.SORT_ASCENDING |
| : ImageManager.SORT_DESCENDING, |
| (uri != null) |
| ? uri.getQueryParameter("bucketId") |
| : null); |
| } |
| } |
| |
| private void toggleMultiSelected(IImage image) { |
| int original = mMultiSelected.size(); |
| if (!mMultiSelected.add(image)) { |
| mMultiSelected.remove(image); |
| } |
| mGvs.invalidate(); |
| if (original == 0) showFooter(); |
| if (mMultiSelected.size() == 0) hideFooter(); |
| } |
| |
| public void onImageClicked(int index) { |
| if (index < 0 || index >= mAllImages.getCount()) { |
| return; |
| } |
| mSelectedIndex = index; |
| mGvs.setSelectedIndex(index); |
| |
| IImage image = mAllImages.getImageAt(index); |
| |
| if (isInMultiSelectMode()) { |
| toggleMultiSelected(image); |
| return; |
| } |
| |
| if (isPickIntent()) { |
| launchCropperOrFinish(image); |
| } else { |
| Intent intent; |
| if (image instanceof VideoObject) { |
| intent = new Intent( |
| Intent.ACTION_VIEW, image.fullSizeImageUri()); |
| intent.putExtra(MediaStore.EXTRA_SCREEN_ORIENTATION, |
| ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); |
| } else { |
| intent = new Intent(this, ViewImage.class); |
| intent.putExtra(ViewImage.KEY_IMAGE_LIST, mParam); |
| intent.setData(image.fullSizeImageUri()); |
| } |
| startActivity(intent); |
| } |
| } |
| |
| public void onImageTapped(int index) { |
| // In the multiselect mode, once the finger finishes tapping, we hide |
| // the selection box by setting the selected index to none. However, if |
| // we use the dpad center key, we will keep the selected index in order |
| // to show the the selection box. We do this because we have the |
| // multiselect marker on the images to indicate which of them are |
| // selected, so we don't need the selection box, but in the dpad case |
| // we still need the selection box to show as a "cursor". |
| |
| if (isInMultiSelectMode()) { |
| mGvs.setSelectedIndex(GridViewSpecial.INDEX_NONE); |
| toggleMultiSelected(mAllImages.getImageAt(index)); |
| } else { |
| onImageClicked(index); |
| } |
| } |
| |
| private class CreateContextMenuListener implements |
| View.OnCreateContextMenuListener { |
| public void onCreateContextMenu(ContextMenu menu, View v, |
| ContextMenu.ContextMenuInfo menuInfo) { |
| if (!canHandleEvent()) return; |
| |
| IImage image = getCurrentImage(); |
| |
| if (image == null) { |
| return; |
| } |
| |
| boolean isImage = ImageManager.isImage(image); |
| if (isImage) { |
| menu.add(R.string.view) |
| .setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| if (!canHandleEvent()) return false; |
| onImageClicked(mGvs.getCurrentSelection()); |
| return true; |
| } |
| }); |
| } |
| |
| menu.setHeaderTitle(isImage |
| ? R.string.context_menu_header |
| : R.string.video_context_menu_header); |
| if ((mInclusion & (ImageManager.INCLUDE_IMAGES |
| | ImageManager.INCLUDE_VIDEOS)) != 0) { |
| MenuHelper.MenuItemsResult r = MenuHelper.addImageMenuItems( |
| menu, |
| MenuHelper.INCLUDE_ALL, |
| ImageGallery.this, |
| mHandler, |
| mDeletePhotoRunnable, |
| new MenuHelper.MenuInvoker() { |
| public void run(MenuHelper.MenuCallback cb) { |
| if (!canHandleEvent()) { |
| return; |
| } |
| cb.run(getCurrentImageUri(), getCurrentImage()); |
| mGvs.invalidateImage(mGvs.getCurrentSelection()); |
| } |
| }); |
| |
| if (r != null) { |
| r.gettingReadyToOpen(menu, image); |
| } |
| |
| if (isImage) { |
| MenuHelper.enableShowOnMapMenuItem( |
| menu, MenuHelper.hasLatLngData(image)); |
| addSlideShowMenu(menu); |
| } |
| } |
| } |
| } |
| |
| public void onLayoutComplete(boolean changed) { |
| mLayoutComplete = true; |
| if (mCropResultUri != null) { |
| IImage image = mAllImages.getImageForUri(mCropResultUri); |
| mCropResultUri = null; |
| if (image != null) { |
| mSelectedIndex = mAllImages.getImageIndex(image); |
| } |
| } |
| mGvs.setSelectedIndex(mSelectedIndex); |
| if (mScrollPosition == INVALID_POSITION) { |
| if (mSortAscending) { |
| mGvs.scrollTo(0, mGvs.getHeight()); |
| } else { |
| mGvs.scrollToImage(0); |
| } |
| } else if (mConfigurationChanged) { |
| mConfigurationChanged = false; |
| mGvs.scrollTo(mScrollPosition); |
| if (mGvs.getCurrentSelection() != GridViewSpecial.INDEX_NONE) { |
| mGvs.scrollToVisible(mSelectedIndex); |
| } |
| } else { |
| mGvs.scrollTo(mScrollPosition); |
| } |
| } |
| |
| public void onScroll(float scrollPosition) { |
| mScrollPosition = scrollPosition; |
| } |
| |
| private Drawable mVideoOverlay; |
| private Drawable mVideoMmsErrorOverlay; |
| private Drawable mMultiSelectTrue; |
| private Drawable mMultiSelectFalse; |
| |
| // mSrcRect and mDstRect are only used in drawImage, but we put them as |
| // instance variables to reduce the memory allocation overhead because |
| // drawImage() is called a lot. |
| private final Rect mSrcRect = new Rect(); |
| private final Rect mDstRect = new Rect(); |
| |
| private final Paint mPaint = new Paint(Paint.FILTER_BITMAP_FLAG); |
| |
| public void drawImage(Canvas canvas, IImage image, |
| Bitmap b, int xPos, int yPos, int w, int h) { |
| if (b != null) { |
| // if the image is close to the target size then crop, |
| // otherwise scale both the bitmap and the view should be |
| // square but I suppose that could change in the future. |
| |
| int bw = b.getWidth(); |
| int bh = b.getHeight(); |
| |
| int deltaW = bw - w; |
| int deltaH = bh - h; |
| |
| if (deltaW >= 0 && deltaW < 10 && |
| deltaH >= 0 && deltaH < 10) { |
| int halfDeltaW = deltaW / 2; |
| int halfDeltaH = deltaH / 2; |
| mSrcRect.set(0 + halfDeltaW, 0 + halfDeltaH, |
| bw - halfDeltaW, bh - halfDeltaH); |
| mDstRect.set(xPos, yPos, xPos + w, yPos + h); |
| canvas.drawBitmap(b, mSrcRect, mDstRect, null); |
| } else { |
| mSrcRect.set(0, 0, bw, bh); |
| mDstRect.set(xPos, yPos, xPos + w, yPos + h); |
| canvas.drawBitmap(b, mSrcRect, mDstRect, mPaint); |
| } |
| } else { |
| // If the thumbnail cannot be drawn, put up an error icon |
| // instead |
| Bitmap error = getErrorBitmap(image); |
| int width = error.getWidth(); |
| int height = error.getHeight(); |
| mSrcRect.set(0, 0, width, height); |
| int left = (w - width) / 2 + xPos; |
| int top = (w - height) / 2 + yPos; |
| mDstRect.set(left, top, left + width, top + height); |
| canvas.drawBitmap(error, mSrcRect, mDstRect, null); |
| } |
| |
| if (ImageManager.isVideo(image)) { |
| Drawable overlay = null; |
| long size = MenuHelper.getImageFileSize(image); |
| if (size >= 0 && size <= mVideoSizeLimit) { |
| if (mVideoOverlay == null) { |
| mVideoOverlay = getResources().getDrawable( |
| R.drawable.ic_gallery_video_overlay); |
| } |
| overlay = mVideoOverlay; |
| } else { |
| if (mVideoMmsErrorOverlay == null) { |
| mVideoMmsErrorOverlay = getResources().getDrawable( |
| R.drawable.ic_error_mms_video_overlay); |
| } |
| overlay = mVideoMmsErrorOverlay; |
| Paint paint = new Paint(); |
| paint.setARGB(0x80, 0x00, 0x00, 0x00); |
| canvas.drawRect(xPos, yPos, xPos + w, yPos + h, paint); |
| } |
| int width = overlay.getIntrinsicWidth(); |
| int height = overlay.getIntrinsicHeight(); |
| int left = (w - width) / 2 + xPos; |
| int top = (h - height) / 2 + yPos; |
| mSrcRect.set(left, top, left + width, top + height); |
| overlay.setBounds(mSrcRect); |
| overlay.draw(canvas); |
| } |
| } |
| |
| public boolean needsDecoration() { |
| return (mMultiSelected != null); |
| } |
| |
| public void drawDecoration(Canvas canvas, IImage image, |
| int xPos, int yPos, int w, int h) { |
| if (mMultiSelected != null) { |
| initializeMultiSelectDrawables(); |
| |
| Drawable checkBox = mMultiSelected.contains(image) |
| ? mMultiSelectTrue |
| : mMultiSelectFalse; |
| int width = checkBox.getIntrinsicWidth(); |
| int height = checkBox.getIntrinsicHeight(); |
| int left = 5 + xPos; |
| int top = h - height - 5 + yPos; |
| mSrcRect.set(left, top, left + width, top + height); |
| checkBox.setBounds(mSrcRect); |
| checkBox.draw(canvas); |
| } |
| } |
| |
| private void initializeMultiSelectDrawables() { |
| if (mMultiSelectTrue == null) { |
| mMultiSelectTrue = getResources() |
| .getDrawable(R.drawable.btn_check_buttonless_on); |
| } |
| if (mMultiSelectFalse == null) { |
| mMultiSelectFalse = getResources() |
| .getDrawable(R.drawable.btn_check_buttonless_off); |
| } |
| } |
| |
| private Bitmap mMissingImageThumbnailBitmap; |
| private Bitmap mMissingVideoThumbnailBitmap; |
| |
| // Create this bitmap lazily, and only once for all the ImageBlocks to |
| // use |
| public Bitmap getErrorBitmap(IImage image) { |
| if (ImageManager.isImage(image)) { |
| if (mMissingImageThumbnailBitmap == null) { |
| mMissingImageThumbnailBitmap = BitmapFactory.decodeResource( |
| getResources(), |
| R.drawable.ic_missing_thumbnail_picture); |
| } |
| return mMissingImageThumbnailBitmap; |
| } else { |
| if (mMissingVideoThumbnailBitmap == null) { |
| mMissingVideoThumbnailBitmap = BitmapFactory.decodeResource( |
| getResources(), R.drawable.ic_missing_thumbnail_video); |
| } |
| return mMissingVideoThumbnailBitmap; |
| } |
| } |
| |
| private Animation mFooterAppear; |
| private Animation mFooterDisappear; |
| |
| private void showFooter() { |
| mFooterOrganizeView.setVisibility(View.VISIBLE); |
| if (mFooterAppear == null) { |
| mFooterAppear = AnimationUtils.loadAnimation( |
| this, R.anim.footer_appear); |
| } |
| mFooterOrganizeView.startAnimation(mFooterAppear); |
| } |
| |
| private void hideFooter() { |
| if (mFooterOrganizeView.getVisibility() != View.GONE) { |
| mFooterOrganizeView.setVisibility(View.GONE); |
| if (mFooterDisappear == null) { |
| mFooterDisappear = AnimationUtils.loadAnimation( |
| this, R.anim.footer_disappear); |
| } |
| mFooterOrganizeView.startAnimation(mFooterDisappear); |
| } |
| } |
| |
| private String getShareMultipleMimeType() { |
| final int FLAG_IMAGE = 1, FLAG_VIDEO = 2; |
| int flag = 0; |
| for (IImage image : mMultiSelected) { |
| flag |= ImageManager.isImage(image) ? FLAG_IMAGE : FLAG_VIDEO; |
| } |
| return flag == FLAG_IMAGE |
| ? "image/*" |
| : flag == FLAG_VIDEO ? "video/*" : "*/*"; |
| } |
| |
| private void onShareMultipleClicked() { |
| if (mMultiSelected == null) return; |
| if (mMultiSelected.size() > 1) { |
| Intent intent = new Intent(); |
| intent.setAction(Intent.ACTION_SEND_MULTIPLE); |
| |
| String mimeType = getShareMultipleMimeType(); |
| intent.setType(mimeType); |
| ArrayList<Parcelable> list = new ArrayList<Parcelable>(); |
| for (IImage image : mMultiSelected) { |
| list.add(image.fullSizeImageUri()); |
| } |
| intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, list); |
| try { |
| startActivity(Intent.createChooser( |
| intent, getText(R.string.send_media_files))); |
| } catch (android.content.ActivityNotFoundException ex) { |
| Toast.makeText(this, R.string.no_way_to_share, |
| Toast.LENGTH_SHORT).show(); |
| } |
| } else if (mMultiSelected.size() == 1) { |
| IImage image = mMultiSelected.iterator().next(); |
| Intent intent = new Intent(); |
| intent.setAction(Intent.ACTION_SEND); |
| String mimeType = image.getMimeType(); |
| intent.setType(mimeType); |
| intent.putExtra(Intent.EXTRA_STREAM, image.fullSizeImageUri()); |
| boolean isImage = ImageManager.isImage(image); |
| try { |
| startActivity(Intent.createChooser(intent, getText( |
| isImage ? R.string.sendImage : R.string.sendVideo))); |
| } catch (android.content.ActivityNotFoundException ex) { |
| Toast.makeText(this, isImage |
| ? R.string.no_way_to_share_image |
| : R.string.no_way_to_share_video, |
| Toast.LENGTH_SHORT).show(); |
| } |
| } |
| } |
| |
| private void onDeleteMultipleClicked() { |
| if (mMultiSelected == null) return; |
| Runnable action = new Runnable() { |
| public void run() { |
| ArrayList<Uri> uriList = new ArrayList<Uri>(); |
| for (IImage image : mMultiSelected) { |
| uriList.add(image.fullSizeImageUri()); |
| } |
| closeMultiSelectMode(); |
| Intent intent = new Intent(ImageGallery.this, |
| DeleteImage.class); |
| intent.putExtra("delete-uris", uriList); |
| try { |
| startActivity(intent); |
| } catch (ActivityNotFoundException ex) { |
| Log.e(TAG, "Delete images fail", ex); |
| } |
| } |
| }; |
| MenuHelper.deleteMultiple(this, action); |
| } |
| |
| private boolean isInMultiSelectMode() { |
| return mMultiSelected != null; |
| } |
| |
| private void closeMultiSelectMode() { |
| if (mMultiSelected == null) return; |
| mMultiSelected = null; |
| mGvs.invalidate(); |
| hideFooter(); |
| } |
| |
| private void openMultiSelectMode() { |
| if (mMultiSelected != null) return; |
| mMultiSelected = new HashSet<IImage>(); |
| mGvs.invalidate(); |
| } |
| |
| } |
