| /* |
| * 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.camera.gallery.IImage; |
| import com.android.camera.gallery.IImageList; |
| import com.android.camera.gallery.VideoObject; |
| |
| import android.app.Activity; |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.app.ProgressDialog; |
| 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.content.res.Resources; |
| 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.PowerManager; |
| 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.widget.TextView; |
| import android.widget.Toast; |
| |
| import java.util.HashSet; |
| |
| public class ImageGallery2 extends Activity implements |
| GridViewSpecial.Listener, GridViewSpecial.DrawAdapter { |
| private static final String TAG = "ImageGallery2"; |
| IImageList mAllImages; |
| private int mInclusion; |
| boolean mSortAscending = false; |
| private View mNoImagesView; |
| public static final int CROP_MSG = 2; |
| public static final int VIEW_MSG = 3; |
| private static final String INSTANCE_STATE_TAG = "scrollY"; |
| |
| private Dialog mMediaScanningDialog; |
| |
| private MenuItem mSlideShowItem; |
| private SharedPreferences mPrefs; |
| private long mVideoSizeLimit = Long.MAX_VALUE; |
| |
| BroadcastReceiver mReceiver = null; |
| |
| Handler mHandler = new Handler(); |
| boolean mLayoutComplete; |
| boolean mPausing = false; |
| boolean mStopThumbnailChecking = false; |
| |
| BitmapThread mThumbnailCheckThread; |
| GridViewSpecial mGvs; |
| |
| // The index of the first picture in GridViewSpecial. |
| private int mFirstVisibleIndex = 0; |
| |
| 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_2); |
| |
| getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, |
| R.layout.custom_gallery_title); |
| |
| mGvs = (GridViewSpecial) findViewById(R.id.grid); |
| mGvs.requestFocus(); |
| mGvs.setListener(this); |
| |
| if (isPickIntent()) { |
| mVideoSizeLimit = getIntent().getLongExtra( |
| MediaStore.EXTRA_SIZE_LIMIT, Long.MAX_VALUE); |
| mGvs.mVideoSizeLimit = mVideoSizeLimit; |
| } else { |
| mVideoSizeLimit = Long.MAX_VALUE; |
| mGvs.mVideoSizeLimit = mVideoSizeLimit; |
| mGvs.setOnCreateContextMenuListener( |
| new CreateContextMenuListener()); |
| } |
| } |
| |
| private MenuItem addSlideShowMenu(Menu menu, int position) { |
| return menu.add(0, 207, position, 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() { |
| 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() { |
| mGvs.clearCache(); |
| IImage currentImage = getCurrentImage(); |
| if (currentImage != null) { |
| mAllImages.removeImage(currentImage); |
| } |
| mGvs.invalidate(); |
| mGvs.requestLayout(); |
| 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.mCurrentSelection; |
| if (currentSelection < 0 |
| || currentSelection >= mAllImages.getCount()) { |
| return null; |
| } else { |
| return mAllImages.getImageAt(currentSelection); |
| } |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration newConfig) { |
| super.onConfigurationChanged(newConfig); |
| mTargetScroll = mGvs.getScrollY(); |
| } |
| |
| 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: |
| 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 there 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.getString("return-data") != null) { |
| Bitmap bitmap = img.fullSizeBitmap(1000); |
| 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. |
| Uri dataUri = Uri.parse(data.getAction()); |
| rebake(false, false); |
| IImage image = mAllImages.getImageForUri(dataUri); |
| if (image != null) { |
| int rowId = image.getRow(); |
| mGvs.select(rowId, false); |
| } |
| } |
| break; |
| } |
| case CROP_MSG: { |
| if (resultCode == RESULT_OK) { |
| setResult(resultCode, data); |
| finish(); |
| } |
| break; |
| } |
| case VIEW_MSG: { |
| IImage img = mAllImages.getImageForUri(data.getData()); |
| launchCropperOrFinish(img); |
| break; |
| } |
| } |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| mPausing = true; |
| |
| BitmapManager.instance().cancelAllDecoding(); |
| stopCheckingThumbnails(); |
| 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 deactivate it. |
| mAllImages.deactivate(); |
| } |
| |
| private void rebake(boolean unmounted, boolean scanning) { |
| stopCheckingThumbnails(); |
| mGvs.clearCache(); |
| if (mAllImages != null) { |
| mAllImages.deactivate(); |
| mAllImages = null; |
| } |
| if (mMediaScanningDialog != null) { |
| mMediaScanningDialog.cancel(); |
| mMediaScanningDialog = null; |
| } |
| if (scanning) { |
| mMediaScanningDialog = ProgressDialog.show( |
| this, |
| null, |
| getResources().getString(R.string.wait), |
| true, |
| true); |
| mAllImages = ImageManager.emptyImageList(); |
| } else { |
| mAllImages = allImages(!unmounted); |
| mGvs.setImageList(mAllImages); |
| mGvs.setDrawAdapter(this); |
| mGvs.init(mHandler); |
| mGvs.start(); |
| mGvs.requestLayout(); |
| checkThumbnails(); |
| } |
| } |
| |
| @Override |
| protected void onSaveInstanceState(Bundle state) { |
| super.onSaveInstanceState(state); |
| mTargetScroll = mGvs.getScrollY(); |
| state.putInt(INSTANCE_STATE_TAG, mTargetScroll); |
| } |
| |
| @Override |
| protected void onRestoreInstanceState(Bundle state) { |
| super.onRestoreInstanceState(state); |
| mTargetScroll = state.getInt(INSTANCE_STATE_TAG, 0); |
| } |
| |
| int mTargetScroll; |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| |
| BitmapManager.instance().allowAllDecoding(); |
| |
| mGvs.setSizeChoice(Integer.parseInt( |
| mPrefs.getString("pref_gallery_size_key", "1")), |
| mTargetScroll); |
| 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 |
| Toast.makeText(ImageGallery2.this, |
| getResources().getString(R.string.wait), 5000); |
| rebake(true, false); |
| } else if (action.equals(Intent.ACTION_MEDIA_SCANNER_STARTED)) { |
| Toast.makeText(ImageGallery2.this, |
| getResources().getString(R.string.wait), 5000); |
| 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())); |
| } |
| |
| private void stopCheckingThumbnails() { |
| mStopThumbnailChecking = true; |
| if (mThumbnailCheckThread != null) { |
| mThumbnailCheckThread.join(); |
| } |
| mStopThumbnailChecking = false; |
| } |
| |
| private void checkThumbnails() { |
| final long startTime = System.currentTimeMillis(); |
| mThumbnailCheckThread = new BitmapThread(new Runnable() { |
| public void run() { |
| Resources resources = getResources(); |
| TextView progressTextView = |
| (TextView) findViewById(R.id.loading_text); |
| String progressTextFormatString = |
| resources.getString( |
| R.string.loading_progress_format_string); |
| |
| PowerManager pm = (PowerManager) |
| getSystemService(Context.POWER_SERVICE); |
| PowerManager.WakeLock mWakeLock = pm.newWakeLock( |
| PowerManager.SCREEN_BRIGHT_WAKE_LOCK, |
| "ImageGallery2.checkThumbnails"); |
| mWakeLock.acquire(); |
| IImageList.ThumbCheckCallback r = new MyThumbCheckCallback( |
| progressTextView, startTime, progressTextFormatString); |
| IImageList imageList = allImages(true); |
| imageList.checkThumbnails(r, imageList.getCount()); |
| mWakeLock.release(); |
| mThumbnailCheckThread = null; |
| mHandler.post(new Runnable() { |
| public void run() { |
| findViewById(R.id.loading_indicator).setVisibility( |
| View.GONE); |
| } |
| }); |
| } |
| }); |
| |
| mThumbnailCheckThread.setName("check_thumbnails"); |
| mThumbnailCheckThread.start(); |
| mThumbnailCheckThread.toBackground(); |
| |
| IImageList list = allImages(true); |
| mNoImagesView.setVisibility(list.getCount() > 0 |
| ? View.GONE |
| : View.VISIBLE); |
| } |
| |
| @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, 5); |
| } |
| |
| MenuItem item = menu.add(0, 0, 1000, R.string.camerasettings); |
| item.setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| Intent preferences = new Intent(); |
| preferences.setClass( |
| ImageGallery2.this, GallerySettings.class); |
| startActivity(preferences); |
| return true; |
| } |
| }); |
| item.setAlphabeticShortcut('p'); |
| item.setIcon(android.R.drawable.ic_menu_preferences); |
| |
| item = menu.add(R.string.multiselect); |
| item.setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| if (mMultiSelected == null) { |
| mMultiSelected = new HashSet<IImage>(); |
| } else { |
| mMultiSelected = null; |
| } |
| mGvs.invalidateAllImages(); |
| return true; |
| } |
| }); |
| item.setIcon(R.drawable.ic_menu_multiselect_gallery); |
| |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| 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/*"); |
| } |
| |
| private synchronized IImageList allImages(boolean assumeMounted) { |
| if (mAllImages == null) { |
| mNoImagesView = findViewById(R.id.no_images); |
| |
| 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; |
| } |
| } |
| Uri uri = getIntent().getData(); |
| if (!assumeMounted) { |
| mAllImages = ImageManager.emptyImageList(); |
| } else { |
| mAllImages = ImageManager.allImages( |
| getContentResolver(), |
| ImageManager.DataLocation.NONE, |
| mInclusion, |
| mSortAscending |
| ? ImageManager.SORT_ASCENDING |
| : ImageManager.SORT_DESCENDING, |
| (uri != null) |
| ? uri.getQueryParameter("bucketId") |
| : null); |
| } |
| } |
| return mAllImages; |
| } |
| |
| public void onSelect(int index) { |
| if (index >= 0 && index < mAllImages.getCount()) { |
| IImage img = mAllImages.getImageAt(index); |
| if (img == null) { |
| return; |
| } |
| |
| // if in multiselect mode |
| if (mMultiSelected != null) { |
| if (!mMultiSelected.add(img)) mMultiSelected.remove(img); |
| mGvs.invalidateImage(index); |
| return; |
| } |
| |
| if (isPickIntent()) { |
| launchCropperOrFinish(img); |
| } else { |
| 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); |
| |
| if (img instanceof VideoObject) { |
| intent.putExtra(MediaStore.EXTRA_SCREEN_ORIENTATION, |
| ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); |
| } |
| |
| try { |
| startActivity(intent); |
| } catch (Exception ex) { |
| // sdcard removal?? |
| } |
| } |
| } |
| } |
| |
| private final class MyThumbCheckCallback implements IImageList.ThumbCheckCallback { |
| private final TextView progressTextView; |
| private final long startTime; |
| private final String progressTextFormatString; |
| boolean mDidSetProgress = false; |
| |
| private MyThumbCheckCallback(TextView progressTextView, long startTime, |
| String progressTextFormatString) { |
| this.progressTextView = progressTextView; |
| this.startTime = startTime; |
| this.progressTextFormatString = progressTextFormatString; |
| } |
| |
| public boolean checking(final int count, |
| final int maxCount) { |
| if (mStopThumbnailChecking) { |
| return false; |
| } |
| |
| if (!mLayoutComplete) { |
| return true; |
| } |
| |
| if (!mDidSetProgress) { |
| mHandler.post(new Runnable() { |
| public void run() { |
| findViewById( |
| R.id.loading_indicator) |
| .setVisibility(View.VISIBLE); |
| } |
| }); |
| mDidSetProgress = true; |
| } |
| mGvs.postInvalidate(); |
| |
| // If there is a new image done and it has been |
| // one second, update the progress text. |
| if (System.currentTimeMillis() |
| - startTime > 1000) { |
| mHandler.post(new Runnable() { |
| public void run() { |
| String s = String.format( |
| progressTextFormatString, |
| maxCount - count); |
| progressTextView.setText(s); |
| } |
| }); |
| } |
| |
| return !mPausing; |
| } |
| } |
| |
| private class CreateContextMenuListener implements |
| View.OnCreateContextMenuListener { |
| public void onCreateContextMenu(ContextMenu menu, View v, |
| ContextMenu.ContextMenuInfo menuInfo) { |
| if (getCurrentImage() == null) { |
| return; |
| } |
| |
| boolean isImage = ImageManager.isImage(getCurrentImage()); |
| if (isImage) { |
| menu.add(0, 0, 0, R.string.view).setOnMenuItemClickListener( |
| new MenuItem.OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| onSelect(mGvs.mCurrentSelection); |
| 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, |
| isImage, |
| ImageGallery2.this, |
| mHandler, |
| mDeletePhotoRunnable, |
| new MenuHelper.MenuInvoker() { |
| public void run(MenuHelper.MenuCallback cb) { |
| cb.run(getCurrentImageUri(), getCurrentImage()); |
| |
| mGvs.clearCache(); |
| mGvs.invalidate(); |
| mGvs.requestLayout(); |
| mGvs.start(); |
| mNoImagesView.setVisibility( |
| mAllImages.getCount() > 0 |
| ? View.GONE |
| : View.VISIBLE); |
| } |
| }); |
| if (r != null) { |
| r.gettingReadyToOpen(menu, getCurrentImage()); |
| } |
| |
| if (isImage) { |
| addSlideShowMenu(menu, 1000); |
| } |
| } |
| } |
| } |
| |
| public void onLayout() { |
| mLayoutComplete = true; |
| if (mSortAscending && mTargetScroll == 0) { |
| mGvs.scrollToImage(mAllImages.getCount() - 1); |
| } else { |
| mGvs.scrollToImage(mFirstVisibleIndex); |
| } |
| } |
| |
| public void onScroll(int index) { |
| mFirstVisibleIndex = index; |
| } |
| |
| private Drawable mVideoOverlay; |
| private Drawable mVideoMmsErrorOverlay; |
| private Drawable mMultiSelectTrue; |
| |
| public void drawImage(Canvas canvas, IImage image, |
| Bitmap b, int xPos, int yPos, int w, int h) { |
| Paint paint = new Paint(); |
| |
| 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 < 10 && deltaH < 10) { |
| int halfDeltaW = deltaW / 2; |
| int halfDeltaH = deltaH / 2; |
| Rect src = new Rect(0 + halfDeltaW, 0 + halfDeltaH, |
| bw - halfDeltaW, bh - halfDeltaH); |
| Rect dst = new Rect(xPos, yPos, xPos + w, yPos + h); |
| canvas.drawBitmap(b, src, dst, paint); |
| } else { |
| Rect src = new Rect(0, 0, bw, bh); |
| Rect dst = new Rect(xPos, yPos, xPos + w, yPos + h); |
| canvas.drawBitmap(b, src, dst, paint); |
| } |
| } 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(); |
| Rect source = new Rect(0, 0, width, height); |
| int left = (w - width) / 2 + xPos; |
| int top = (w - height) / 2 + yPos; |
| Rect dest = new Rect(left, top, left + width, top + height); |
| canvas.drawBitmap(error, source, dest, paint); |
| } |
| 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.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; |
| Rect newBounds = |
| new Rect(left, top, left + width, top + height); |
| overlay.setBounds(newBounds); |
| overlay.draw(canvas); |
| } |
| |
| if (mMultiSelected != null && mMultiSelected.contains(image)) { |
| initializeMultiSelectDrawables(); |
| |
| Drawable checkBox = mMultiSelectTrue; |
| int width = checkBox.getIntrinsicWidth(); |
| int height = checkBox.getIntrinsicHeight(); |
| int left = 5 + xPos; |
| int top = h - height - 5 + yPos; |
| checkBox.setBounds(new Rect( |
| left, top, left + width, top + height)); |
| checkBox.draw(canvas); |
| } |
| } |
| |
| private void initializeMultiSelectDrawables() { |
| if (mMultiSelectTrue == null) { |
| mMultiSelectTrue = getResources() |
| .getDrawable(R.drawable.btn_check_buttonless_on); |
| } |
| } |
| |
| 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; |
| } |
| } |
| |
| } |
| |
| |