| /* |
| * 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 com.android.camera.gallery.IImage; |
| import com.android.camera.gallery.IImageList; |
| |
| import android.app.Activity; |
| import android.app.Dialog; |
| import android.app.ProgressDialog; |
| import android.content.BroadcastReceiver; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.res.Resources; |
| import android.database.ContentObserver; |
| import android.graphics.Bitmap; |
| import android.graphics.Canvas; |
| import android.graphics.Matrix; |
| import android.graphics.Paint; |
| import android.graphics.PorterDuff; |
| import android.graphics.PorterDuffXfermode; |
| import android.graphics.Rect; |
| import android.graphics.drawable.Drawable; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Environment; |
| import android.os.Handler; |
| import android.os.StatFs; |
| import android.provider.MediaStore; |
| import android.provider.MediaStore.Images; |
| import android.util.Log; |
| import android.view.ContextMenu; |
| import android.view.LayoutInflater; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.ContextMenu.ContextMenuInfo; |
| import android.view.MenuItem.OnMenuItemClickListener; |
| import android.widget.AdapterView; |
| import android.widget.BaseAdapter; |
| import android.widget.GridView; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| import android.widget.AdapterView.AdapterContextMenuInfo; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| /** |
| * The GalleryPicker activity. |
| */ |
| public class GalleryPicker extends NoSearchActivity { |
| private static final String TAG = "GalleryPicker"; |
| |
| Handler mHandler = new Handler(); // handler for the main thread |
| Thread mWorkerThread; |
| BroadcastReceiver mReceiver; |
| ContentObserver mDbObserver; |
| GridView mGridView; |
| GalleryPickerAdapter mAdapter; // mAdapter is only accessed in main thread. |
| boolean mScanning; |
| boolean mUnmounted; |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| |
| setContentView(R.layout.gallerypicker); |
| |
| mGridView = (GridView) findViewById(R.id.albums); |
| |
| mGridView.setOnItemClickListener(new AdapterView.OnItemClickListener() { |
| public void onItemClick(AdapterView<?> parent, View view, |
| int position, long id) { |
| launchFolderGallery(position); |
| } |
| }); |
| |
| mGridView.setOnCreateContextMenuListener( |
| new View.OnCreateContextMenuListener() { |
| public void onCreateContextMenu(ContextMenu menu, View v, |
| final ContextMenuInfo menuInfo) { |
| onCreateGalleryPickerContextMenu(menu, menuInfo); |
| } |
| }); |
| |
| mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| onReceiveMediaBroadcast(intent); |
| } |
| }; |
| |
| mDbObserver = new ContentObserver(mHandler) { |
| @Override |
| public void onChange(boolean selfChange) { |
| rebake(false, ImageManager.isMediaScannerScanning( |
| getContentResolver())); |
| } |
| }; |
| |
| ImageManager.ensureOSXCompatibleFolder(); |
| } |
| |
| Dialog mMediaScanningDialog; |
| |
| // Display a dialog if the storage is being scanned now. |
| public void updateScanningDialog(boolean scanning) { |
| boolean prevScanning = (mMediaScanningDialog != null); |
| if (prevScanning == scanning && mAdapter.mItems.size() == 0) return; |
| // Now we are certain the state is changed. |
| if (prevScanning) { |
| mMediaScanningDialog.cancel(); |
| mMediaScanningDialog = null; |
| } else if (scanning && mAdapter.mItems.size() == 0) { |
| mMediaScanningDialog = ProgressDialog.show( |
| this, |
| null, |
| getResources().getString(R.string.wait), |
| true, |
| true); |
| } |
| } |
| |
| private View mNoImagesView; |
| |
| // Show/Hide the "no images" icon and text. Load resources on demand. |
| private void showNoImagesView() { |
| if (mNoImagesView == null) { |
| ViewGroup root = (ViewGroup) findViewById(R.id.root); |
| getLayoutInflater().inflate(R.layout.gallerypicker_no_images, root); |
| mNoImagesView = findViewById(R.id.no_images); |
| } |
| mNoImagesView.setVisibility(View.VISIBLE); |
| } |
| |
| private void hideNoImagesView() { |
| if (mNoImagesView != null) { |
| mNoImagesView.setVisibility(View.GONE); |
| } |
| } |
| |
| // The storage status is changed, restart the worker or show "no images". |
| private void rebake(boolean unmounted, boolean scanning) { |
| if (unmounted == mUnmounted && scanning == mScanning) return; |
| abortWorker(); |
| mUnmounted = unmounted; |
| mScanning = scanning; |
| updateScanningDialog(mScanning); |
| if (mUnmounted) { |
| showNoImagesView(); |
| } else { |
| hideNoImagesView(); |
| startWorker(); |
| } |
| } |
| |
| // This is called when we receive media-related broadcast. |
| private void onReceiveMediaBroadcast(Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) { |
| // SD card available |
| // TODO put up a "please wait" 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); |
| } |
| } |
| |
| private void launchFolderGallery(int position) { |
| mAdapter.mItems.get(position).launch(this); |
| } |
| |
| private void onCreateGalleryPickerContextMenu(ContextMenu menu, |
| final ContextMenuInfo menuInfo) { |
| int position = ((AdapterContextMenuInfo) menuInfo).position; |
| menu.setHeaderTitle(mAdapter.baseTitleForPosition(position)); |
| // "Slide Show" |
| if ((mAdapter.getIncludeMediaTypes(position) |
| & ImageManager.INCLUDE_IMAGES) != 0) { |
| menu.add(R.string.slide_show) |
| .setOnMenuItemClickListener(new OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| return onSlideShowClicked(menuInfo); |
| } |
| }); |
| } |
| // "View" |
| menu.add(R.string.view) |
| .setOnMenuItemClickListener(new OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| return onViewClicked(menuInfo); |
| } |
| }); |
| } |
| |
| // This is called when the user clicks "Slideshow" from the context menu. |
| private boolean onSlideShowClicked(ContextMenuInfo menuInfo) { |
| AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo; |
| int position = info.position; |
| |
| if (position < 0 || position >= mAdapter.mItems.size()) { |
| return true; |
| } |
| // Slide show starts from the first image on the list. |
| Item item = mAdapter.mItems.get(position); |
| Uri targetUri = item.mFirstImageUri; |
| |
| if (targetUri != null && item.mBucketId != null) { |
| targetUri = targetUri.buildUpon() |
| .appendQueryParameter("bucketId", item.mBucketId) |
| .build(); |
| } |
| Intent intent = new Intent(Intent.ACTION_VIEW, targetUri); |
| intent.putExtra("slideshow", true); |
| startActivity(intent); |
| return true; |
| } |
| |
| // This is called when the user clicks "View" from the context menu. |
| private boolean onViewClicked(ContextMenuInfo menuInfo) { |
| AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo; |
| launchFolderGallery(info.position); |
| return true; |
| } |
| |
| @Override |
| public void onStop() { |
| super.onStop(); |
| |
| abortWorker(); |
| |
| unregisterReceiver(mReceiver); |
| getContentResolver().unregisterContentObserver(mDbObserver); |
| |
| // free up some ram |
| mAdapter = null; |
| mGridView.setAdapter(null); |
| unloadDrawable(); |
| } |
| |
| @Override |
| public void onStart() { |
| super.onStart(); |
| |
| mAdapter = new GalleryPickerAdapter(getLayoutInflater()); |
| mGridView.setAdapter(mAdapter); |
| |
| // install an intent filter to receive SD card related events. |
| IntentFilter intentFilter = new IntentFilter(); |
| intentFilter.addAction(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"); |
| |
| registerReceiver(mReceiver, intentFilter); |
| |
| getContentResolver().registerContentObserver( |
| MediaStore.Images.Media.EXTERNAL_CONTENT_URI, |
| true, mDbObserver); |
| |
| // Assume the storage is mounted and not scanning. |
| mUnmounted = false; |
| mScanning = false; |
| startWorker(); |
| } |
| |
| // This is used to stop the worker thread. |
| volatile boolean mAbort = false; |
| |
| // Create the worker thread. |
| private void startWorker() { |
| mAbort = false; |
| mWorkerThread = new Thread("GalleryPicker Worker") { |
| @Override |
| public void run() { |
| workerRun(); |
| } |
| }; |
| BitmapManager.instance().allowThreadDecoding(mWorkerThread); |
| mWorkerThread.start(); |
| } |
| |
| private void abortWorker() { |
| if (mWorkerThread != null) { |
| BitmapManager.instance().cancelThreadDecoding(mWorkerThread, getContentResolver()); |
| mAbort = true; |
| try { |
| mWorkerThread.join(); |
| } catch (InterruptedException ex) { |
| Log.e(TAG, "join interrupted"); |
| } |
| mWorkerThread = null; |
| // Remove all runnables in mHandler. |
| // (We assume that the "what" field in the messages are 0 |
| // for runnables). |
| mHandler.removeMessages(0); |
| mAdapter.clear(); |
| mAdapter.updateDisplay(); |
| clearImageLists(); |
| } |
| } |
| |
| // This is run in the worker thread. |
| private void workerRun() { |
| // We collect items from checkImageList() and checkBucketIds() and |
| // put them in allItems. Later we give allItems to checkThumbBitmap() |
| // and generated thumbnail bitmaps for each item. We do this instead of |
| // generating thumbnail bitmaps in checkImageList() and checkBucketIds() |
| // because we want to show all the folders first, then update them with |
| // the thumb bitmaps. (Generating thumbnail bitmaps takes some time.) |
| ArrayList<Item> allItems = new ArrayList<Item>(); |
| |
| checkScanning(); |
| if (mAbort) return; |
| |
| checkImageList(allItems); |
| if (mAbort) return; |
| |
| checkBucketIds(allItems); |
| if (mAbort) return; |
| |
| checkThumbBitmap(allItems); |
| if (mAbort) return; |
| |
| checkLowStorage(); |
| } |
| |
| // This is run in the worker thread. |
| private void checkScanning() { |
| ContentResolver cr = getContentResolver(); |
| final boolean scanning = |
| ImageManager.isMediaScannerScanning(cr); |
| mHandler.post(new Runnable() { |
| public void run() { |
| checkScanningFinished(scanning); |
| } |
| }); |
| } |
| |
| // This is run in the main thread. |
| private void checkScanningFinished(boolean scanning) { |
| updateScanningDialog(scanning); |
| } |
| |
| // This is run in the worker thread. |
| private void checkImageList(ArrayList<Item> allItems) { |
| int length = IMAGE_LIST_DATA.length; |
| IImageList[] lists = new IImageList[length]; |
| for (int i = 0; i < length; i++) { |
| ImageListData data = IMAGE_LIST_DATA[i]; |
| lists[i] = createImageList(data.mInclude, data.mBucketId, |
| getContentResolver()); |
| if (mAbort) return; |
| Item item = null; |
| |
| if (lists[i].isEmpty()) continue; |
| |
| // i >= 3 means we are looking at All Images/All Videos. |
| // lists[i-3] is the corresponding Camera Images/Camera Videos. |
| // We want to add the "All" list only if it's different from |
| // the "Camera" list. |
| if (i >= 3 && lists[i].getCount() == lists[i - 3].getCount()) { |
| continue; |
| } |
| |
| item = new Item(data.mType, |
| data.mBucketId, |
| getResources().getString(data.mStringId), |
| lists[i]); |
| |
| allItems.add(item); |
| |
| final Item finalItem = item; |
| mHandler.post(new Runnable() { |
| public void run() { |
| updateItem(finalItem); |
| } |
| }); |
| } |
| } |
| |
| // This is run in the main thread. |
| private void updateItem(Item item) { |
| // Hide NoImageView if we are going to add the first item |
| if (mAdapter.getCount() == 0) { |
| hideNoImagesView(); |
| } |
| mAdapter.addItem(item); |
| mAdapter.updateDisplay(); |
| } |
| |
| private static final String CAMERA_BUCKET = |
| ImageManager.CAMERA_IMAGE_BUCKET_ID; |
| |
| // This is run in the worker thread. |
| private void checkBucketIds(ArrayList<Item> allItems) { |
| final IImageList allImages; |
| if (!mScanning && !mUnmounted) { |
| allImages = ImageManager.makeImageList( |
| getContentResolver(), |
| ImageManager.DataLocation.ALL, |
| ImageManager.INCLUDE_IMAGES | ImageManager.INCLUDE_VIDEOS, |
| ImageManager.SORT_DESCENDING, |
| null); |
| } else { |
| allImages = ImageManager.makeEmptyImageList(); |
| } |
| |
| if (mAbort) { |
| allImages.close(); |
| return; |
| } |
| |
| HashMap<String, String> hashMap = allImages.getBucketIds(); |
| allImages.close(); |
| if (mAbort) return; |
| |
| for (Map.Entry<String, String> entry : hashMap.entrySet()) { |
| String key = entry.getKey(); |
| if (key == null) { |
| continue; |
| } |
| if (!key.equals(CAMERA_BUCKET)) { |
| IImageList list = createImageList( |
| ImageManager.INCLUDE_IMAGES |
| | ImageManager.INCLUDE_VIDEOS, key, |
| getContentResolver()); |
| if (mAbort) return; |
| |
| Item item = new Item(Item.TYPE_NORMAL_FOLDERS, key, |
| entry.getValue(), list); |
| |
| allItems.add(item); |
| |
| final Item finalItem = item; |
| mHandler.post(new Runnable() { |
| public void run() { |
| updateItem(finalItem); |
| } |
| }); |
| } |
| } |
| |
| mHandler.post(new Runnable() { |
| public void run() { |
| checkBucketIdsFinished(); |
| } |
| }); |
| } |
| |
| // This is run in the main thread. |
| private void checkBucketIdsFinished() { |
| |
| // If we just have one folder, open it. |
| // If we have zero folder, show the "no images" icon. |
| if (!mScanning) { |
| int numItems = mAdapter.mItems.size(); |
| if (numItems == 0) { |
| showNoImagesView(); |
| } else if (numItems == 1) { |
| mAdapter.mItems.get(0).launch(this); |
| finish(); |
| return; |
| } |
| } |
| } |
| |
| private static final int THUMB_SIZE = 142; |
| // This is run in the worker thread. |
| private void checkThumbBitmap(ArrayList<Item> allItems) { |
| for (Item item : allItems) { |
| final Bitmap b = makeMiniThumbBitmap(THUMB_SIZE, THUMB_SIZE, |
| item.mImageList); |
| if (mAbort) { |
| if (b != null) b.recycle(); |
| return; |
| } |
| |
| final Item finalItem = item; |
| mHandler.post(new Runnable() { |
| public void run() { |
| updateThumbBitmap(finalItem, b); |
| } |
| }); |
| } |
| } |
| |
| // This is run in the main thread. |
| private void updateThumbBitmap(Item item, Bitmap b) { |
| item.setThumbBitmap(b); |
| mAdapter.updateDisplay(); |
| } |
| |
| private static final long LOW_STORAGE_THRESHOLD = 1024 * 1024 * 2; |
| |
| // This is run in the worker thread. |
| private void checkLowStorage() { |
| // Check available space only if we are writable |
| if (ImageManager.hasStorage()) { |
| String storageDirectory = Environment |
| .getExternalStorageDirectory().toString(); |
| StatFs stat = new StatFs(storageDirectory); |
| long remaining = (long) stat.getAvailableBlocks() |
| * (long) stat.getBlockSize(); |
| if (remaining < LOW_STORAGE_THRESHOLD) { |
| mHandler.post(new Runnable() { |
| public void run() { |
| checkLowStorageFinished(); |
| } |
| }); |
| } |
| } |
| } |
| |
| // This is run in the main thread. |
| // This is called only if the storage is low. |
| private void checkLowStorageFinished() { |
| Toast.makeText(GalleryPicker.this, R.string.not_enough_space, 5000) |
| .show(); |
| } |
| |
| // IMAGE_LIST_DATA stores the parameters for the four image lists |
| // we are interested in. The order of the IMAGE_LIST_DATA array is |
| // significant (See the implementation of GalleryPickerAdapter.init). |
| private static final class ImageListData { |
| ImageListData(int type, int include, String bucketId, int stringId) { |
| mType = type; |
| mInclude = include; |
| mBucketId = bucketId; |
| mStringId = stringId; |
| } |
| int mType; |
| int mInclude; |
| String mBucketId; |
| int mStringId; |
| } |
| |
| private static final ImageListData[] IMAGE_LIST_DATA = { |
| // Camera Images |
| new ImageListData(Item.TYPE_CAMERA_IMAGES, |
| ImageManager.INCLUDE_IMAGES, |
| ImageManager.CAMERA_IMAGE_BUCKET_ID, |
| R.string.gallery_camera_bucket_name), |
| // Camera Videos |
| new ImageListData(Item.TYPE_CAMERA_VIDEOS, |
| ImageManager.INCLUDE_VIDEOS, |
| ImageManager.CAMERA_IMAGE_BUCKET_ID, |
| R.string.gallery_camera_videos_bucket_name), |
| |
| // Camera Medias |
| new ImageListData(Item.TYPE_CAMERA_MEDIAS, |
| ImageManager.INCLUDE_VIDEOS | ImageManager.INCLUDE_IMAGES, |
| ImageManager.CAMERA_IMAGE_BUCKET_ID, |
| R.string.gallery_camera_media_bucket_name), |
| |
| // All Images |
| new ImageListData(Item.TYPE_ALL_IMAGES, |
| ImageManager.INCLUDE_IMAGES, |
| null, |
| R.string.all_images), |
| |
| // All Videos |
| new ImageListData(Item.TYPE_ALL_VIDEOS, |
| ImageManager.INCLUDE_VIDEOS, |
| null, |
| R.string.all_videos), |
| }; |
| |
| |
| // These drawables are loaded on-demand. |
| Drawable mFrameGalleryMask; |
| Drawable mCellOutline; |
| Drawable mVideoOverlay; |
| |
| private void loadDrawableIfNeeded() { |
| if (mFrameGalleryMask != null) return; // already loaded |
| Resources r = getResources(); |
| mFrameGalleryMask = r.getDrawable( |
| R.drawable.frame_gallery_preview_album_mask); |
| mCellOutline = r.getDrawable(android.R.drawable.gallery_thumb); |
| mVideoOverlay = r.getDrawable(R.drawable.ic_gallery_video_overlay); |
| } |
| |
| private void unloadDrawable() { |
| mFrameGalleryMask = null; |
| mCellOutline = null; |
| mVideoOverlay = null; |
| } |
| |
| private static void placeImage(Bitmap image, Canvas c, Paint paint, |
| int imageWidth, int widthPadding, int imageHeight, |
| int heightPadding, int offsetX, int offsetY, |
| int pos) { |
| int row = pos / 2; |
| int col = pos - (row * 2); |
| |
| int xPos = (col * (imageWidth + widthPadding)) - offsetX; |
| int yPos = (row * (imageHeight + heightPadding)) - offsetY; |
| |
| c.drawBitmap(image, xPos, yPos, paint); |
| } |
| |
| // This is run in worker thread. |
| private Bitmap makeMiniThumbBitmap(int width, int height, |
| IImageList images) { |
| int count = images.getCount(); |
| // We draw three different version of the folder image depending on the |
| // number of images in the folder. |
| // For a single image, that image draws over the whole folder. |
| // For two or three images, we draw the two most recent photos. |
| // For four or more images, we draw four photos. |
| final int padding = 4; |
| int imageWidth = width; |
| int imageHeight = height; |
| int offsetWidth = 0; |
| int offsetHeight = 0; |
| |
| imageWidth = (imageWidth - padding) / 2; // 2 here because we show two |
| // images |
| imageHeight = (imageHeight - padding) / 2; // per row and column |
| |
| final Paint p = new Paint(); |
| final Bitmap b = Bitmap.createBitmap(width, height, |
| Bitmap.Config.ARGB_8888); |
| final Canvas c = new Canvas(b); |
| final Matrix m = new Matrix(); |
| |
| // draw the whole canvas as transparent |
| p.setColor(0x00000000); |
| c.drawPaint(p); |
| |
| // load the drawables |
| loadDrawableIfNeeded(); |
| |
| // draw the mask normally |
| p.setColor(0xFFFFFFFF); |
| mFrameGalleryMask.setBounds(0, 0, width, height); |
| mFrameGalleryMask.draw(c); |
| |
| Paint pdpaint = new Paint(); |
| pdpaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN)); |
| |
| pdpaint.setStyle(Paint.Style.FILL); |
| c.drawRect(0, 0, width, height, pdpaint); |
| |
| for (int i = 0; i < 4; i++) { |
| if (mAbort) { |
| return null; |
| } |
| |
| Bitmap temp = null; |
| IImage image = i < count ? images.getImageAt(i) : null; |
| |
| if (image != null) { |
| temp = image.miniThumbBitmap(); |
| } |
| |
| if (temp != null) { |
| if (ImageManager.isVideo(image)) { |
| Bitmap newMap = temp.copy(temp.getConfig(), true); |
| Canvas overlayCanvas = new Canvas(newMap); |
| int overlayWidth = mVideoOverlay.getIntrinsicWidth(); |
| int overlayHeight = mVideoOverlay.getIntrinsicHeight(); |
| int left = (newMap.getWidth() - overlayWidth) / 2; |
| int top = (newMap.getHeight() - overlayHeight) / 2; |
| Rect newBounds = new Rect(left, top, left + overlayWidth, |
| top + overlayHeight); |
| mVideoOverlay.setBounds(newBounds); |
| mVideoOverlay.draw(overlayCanvas); |
| temp.recycle(); |
| temp = newMap; |
| } |
| |
| temp = Util.transform(m, temp, imageWidth, |
| imageHeight, true, Util.RECYCLE_INPUT); |
| } |
| |
| Bitmap thumb = Bitmap.createBitmap(imageWidth, imageHeight, |
| Bitmap.Config.ARGB_8888); |
| Canvas tempCanvas = new Canvas(thumb); |
| if (temp != null) { |
| tempCanvas.drawBitmap(temp, new Matrix(), new Paint()); |
| } |
| mCellOutline.setBounds(0, 0, imageWidth, imageHeight); |
| mCellOutline.draw(tempCanvas); |
| |
| placeImage(thumb, c, pdpaint, imageWidth, padding, imageHeight, |
| padding, offsetWidth, offsetHeight, i); |
| |
| thumb.recycle(); |
| |
| if (temp != null) { |
| temp.recycle(); |
| } |
| } |
| |
| return b; |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| super.onCreateOptionsMenu(menu); |
| |
| MenuHelper.addCaptureMenuItems(menu, this); |
| |
| menu.add(Menu.NONE, Menu.NONE, MenuHelper.POSITION_GALLERY_SETTING, |
| R.string.camerasettings) |
| .setOnMenuItemClickListener(new OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| Intent preferences = new Intent(); |
| preferences.setClass(GalleryPicker.this, |
| GallerySettings.class); |
| startActivity(preferences); |
| return true; |
| } |
| }) |
| .setAlphabeticShortcut('p') |
| .setIcon(android.R.drawable.ic_menu_preferences); |
| |
| return true; |
| } |
| |
| // image lists created by createImageList() are collected in mAllLists. |
| // They will be closed in clearImageList, so they don't hold open files |
| // on SD card. We will be killed if we don't close files when the SD card |
| // is unmounted. |
| ArrayList<IImageList> mAllLists = new ArrayList<IImageList>(); |
| |
| private IImageList createImageList(int mediaTypes, String bucketId, |
| ContentResolver cr) { |
| IImageList list = ImageManager.makeImageList( |
| cr, |
| ImageManager.DataLocation.ALL, |
| mediaTypes, |
| ImageManager.SORT_DESCENDING, |
| bucketId); |
| mAllLists.add(list); |
| return list; |
| } |
| |
| private void clearImageLists() { |
| for (IImageList list : mAllLists) { |
| list.close(); |
| } |
| mAllLists.clear(); |
| } |
| } |
| |
| // Item is the underlying data for GalleryPickerAdapter. |
| // It is passed from the activity to the adapter. |
| class Item { |
| public static final int TYPE_NONE = -1; |
| public static final int TYPE_ALL_IMAGES = 0; |
| public static final int TYPE_ALL_VIDEOS = 1; |
| public static final int TYPE_CAMERA_IMAGES = 2; |
| public static final int TYPE_CAMERA_VIDEOS = 3; |
| public static final int TYPE_CAMERA_MEDIAS = 4; |
| public static final int TYPE_NORMAL_FOLDERS = 5; |
| |
| public final int mType; |
| public final String mBucketId; |
| public final String mName; |
| public final IImageList mImageList; |
| public final int mCount; |
| public final Uri mFirstImageUri; // could be null if the list is empty |
| |
| // The thumbnail bitmap is set by setThumbBitmap() later because we want |
| // to let the user sees the folder icon as soon as possible (and possibly |
| // select them), then present more detailed information when we have it. |
| public Bitmap mThumbBitmap; // the thumbnail bitmap for the image list |
| |
| public Item(int type, String bucketId, String name, IImageList list) { |
| mType = type; |
| mBucketId = bucketId; |
| mName = name; |
| mImageList = list; |
| mCount = list.getCount(); |
| if (mCount > 0) { |
| mFirstImageUri = list.getImageAt(0).fullSizeImageUri(); |
| } else { |
| mFirstImageUri = null; |
| } |
| } |
| |
| public void setThumbBitmap(Bitmap thumbBitmap) { |
| mThumbBitmap = thumbBitmap; |
| } |
| |
| public boolean needsBucketId() { |
| return mType >= TYPE_CAMERA_IMAGES; |
| } |
| |
| public void launch(Activity activity) { |
| Uri uri = Images.Media.INTERNAL_CONTENT_URI; |
| if (needsBucketId()) { |
| uri = uri.buildUpon() |
| .appendQueryParameter("bucketId", mBucketId).build(); |
| } |
| Intent intent = new Intent(Intent.ACTION_VIEW, uri); |
| intent.putExtra("windowTitle", mName); |
| intent.putExtra("mediaTypes", getIncludeMediaTypes()); |
| activity.startActivity(intent); |
| } |
| |
| public int getIncludeMediaTypes() { |
| return convertItemTypeToIncludedMediaType(mType); |
| } |
| |
| public static int convertItemTypeToIncludedMediaType(int itemType) { |
| switch (itemType) { |
| case TYPE_ALL_IMAGES: |
| case TYPE_CAMERA_IMAGES: |
| return ImageManager.INCLUDE_IMAGES; |
| case TYPE_ALL_VIDEOS: |
| case TYPE_CAMERA_VIDEOS: |
| return ImageManager.INCLUDE_VIDEOS; |
| case TYPE_NORMAL_FOLDERS: |
| case TYPE_CAMERA_MEDIAS: |
| default: |
| return ImageManager.INCLUDE_IMAGES |
| | ImageManager.INCLUDE_VIDEOS; |
| } |
| } |
| |
| public int getOverlay() { |
| switch (mType) { |
| case TYPE_ALL_IMAGES: |
| case TYPE_CAMERA_IMAGES: |
| return R.drawable.frame_overlay_gallery_camera; |
| case TYPE_ALL_VIDEOS: |
| case TYPE_CAMERA_VIDEOS: |
| case TYPE_CAMERA_MEDIAS: |
| return R.drawable.frame_overlay_gallery_video; |
| case TYPE_NORMAL_FOLDERS: |
| default: |
| return R.drawable.frame_overlay_gallery_folder; |
| } |
| } |
| } |
| |
| class GalleryPickerAdapter extends BaseAdapter { |
| ArrayList<Item> mItems = new ArrayList<Item>(); |
| LayoutInflater mInflater; |
| |
| GalleryPickerAdapter(LayoutInflater inflater) { |
| mInflater = inflater; |
| } |
| |
| public void addItem(Item item) { |
| mItems.add(item); |
| } |
| |
| public void updateDisplay() { |
| notifyDataSetChanged(); |
| } |
| |
| public void clear() { |
| mItems.clear(); |
| } |
| |
| public int getCount() { |
| return mItems.size(); |
| } |
| |
| public Object getItem(int position) { |
| return null; |
| } |
| |
| public long getItemId(int position) { |
| return position; |
| } |
| |
| public String baseTitleForPosition(int position) { |
| return mItems.get(position).mName; |
| } |
| |
| public int getIncludeMediaTypes(int position) { |
| return mItems.get(position).getIncludeMediaTypes(); |
| } |
| |
| public View getView(final int position, View convertView, |
| ViewGroup parent) { |
| View v; |
| |
| if (convertView == null) { |
| v = mInflater.inflate(R.layout.gallery_picker_item, null); |
| } else { |
| v = convertView; |
| } |
| |
| TextView titleView = (TextView) v.findViewById(R.id.title); |
| |
| GalleryPickerItem iv = |
| (GalleryPickerItem) v.findViewById(R.id.thumbnail); |
| Item item = mItems.get(position); |
| iv.setOverlay(item.getOverlay()); |
| if (item.mThumbBitmap != null) { |
| iv.setImageBitmap(item.mThumbBitmap); |
| String title = item.mName + " (" + item.mCount + ")"; |
| titleView.setText(title); |
| } else { |
| iv.setImageResource(android.R.color.transparent); |
| titleView.setText(item.mName); |
| } |
| |
| // An workaround due to a bug in TextView. If the length of text is |
| // different from the previous in convertView, the layout would be |
| // wrong. |
| titleView.requestLayout(); |
| |
| return v; |
| } |
| } |
