/*
* 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 android.app.Activity;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
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.preference.PreferenceManager;
import android.provider.MediaStore.Images;
import android.util.Config;
import android.util.Log;
import android.util.SparseArray;
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.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;
public class GalleryPicker extends Activity {
static private final String TAG = "GalleryPicker";
private View mNoImagesView;
GridView mGridView;
Drawable mFrameGalleryMask;
Drawable mCellOutline;
Drawable mVideoOverlay;
BroadcastReceiver mReceiver;
GalleryPickerAdapter mAdapter;
Dialog mMediaScanningDialog;
SharedPreferences mPrefs;
boolean mPausing = false;
private static long LOW_STORAGE_THRESHOLD = 1024 * 1024 * 2;
public GalleryPicker() {
}
private void rebake(boolean unmounted, boolean scanning) {
if (mMediaScanningDialog != null) {
mMediaScanningDialog.cancel();
mMediaScanningDialog = null;
}
if (scanning) {
mMediaScanningDialog = ProgressDialog.show(
this,
null,
getResources().getString(R.string.wait),
true,
true);
}
if (mAdapter != null) {
mAdapter.notifyDataSetChanged();
mAdapter.init(!unmounted && !scanning);
}
if (!unmounted) {
// Warn the user if space is getting low
Thread t = new Thread(new Runnable() {
public void run() {
// 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() {
Toast.makeText(GalleryPicker.this.getApplicationContext(),
R.string.not_enough_space, 5000).show();
}
});
}
}
}
});
t.start();
}
// If we just have zero or one folder, open it. (We shouldn't have just one folder
// any more, but we can have zero folders.)
mNoImagesView.setVisibility(View.GONE);
if (!scanning) {
int numItems = mAdapter.mItems.size();
if (numItems == 0) {
mNoImagesView.setVisibility(View.VISIBLE);
} else if (numItems == 1) {
mAdapter.mItems.get(0).launch(this);
finish();
return;
}
}
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
mPrefs = PreferenceManager.getDefaultSharedPreferences(this);
setContentView(R.layout.gallerypicker);
mNoImagesView = findViewById(R.id.no_images);
mGridView = (GridView) findViewById(R.id.albums);
mGridView.setSelector(android.R.color.transparent);
mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (Config.LOGV) Log.v(TAG, "onReceiveIntent " + intent.getAction());
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
if (Config.LOGV) Log.v(TAG, "sd card no longer available");
Toast.makeText(GalleryPicker.this, getResources().getString(R.string.wait), 5000);
rebake(true, false);
} else if (action.equals(Intent.ACTION_MEDIA_SCANNER_STARTED)) {
Toast.makeText(GalleryPicker.this, getResources().getString(R.string.wait), 5000);
rebake(false, true);
} else if (action.equals(Intent.ACTION_MEDIA_SCANNER_FINISHED)) {
if (Config.LOGV)
Log.v(TAG, "rebake because of ACTION_MEDIA_SCANNER_FINISHED");
rebake(false, false);
} else if (action.equals(Intent.ACTION_MEDIA_EJECT)) {
if (Config.LOGV)
Log.v(TAG, "rebake because of ACTION_MEDIA_EJECT");
rebake(true, false);
}
}
};
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 ContextMenu.ContextMenuInfo menuInfo) {
int position = ((AdapterContextMenuInfo)menuInfo).position;
menu.setHeaderTitle(mAdapter.baseTitleForPosition(position));
if ((mAdapter.getIncludeMediaTypes(position) & ImageManager.INCLUDE_IMAGES) != 0) {
menu.add(0, 207, 0, R.string.slide_show)
.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
int position = info.position;
Uri targetUri;
synchronized (mAdapter.mItems) {
if (position < 0 || position >= mAdapter.mItems.size()) {
return true;
}
// the mFirstImageUris list includes the "all" uri
targetUri = mAdapter.mItems.get(position).mFirstImageUri;
}
if (targetUri != null && position > 0) {
targetUri = targetUri.buildUpon().appendQueryParameter("bucketId",
mAdapter.mItems.get(info.position).mId).build();
}
// Log.v(TAG, "URI to launch slideshow " + targetUri);
Intent intent = new Intent(Intent.ACTION_VIEW, targetUri);
intent.putExtra("slideshow", true);
startActivity(intent);
return true;
}
});
}
menu.add(0, 208, 0, R.string.view)
.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
launchFolderGallery(info.position);
return true;
}
});
}
});
ImageManager.ensureOSXCompatibleFolder();
}
private void launchFolderGallery(int position) {
mAdapter.mItems.get(position).launch(this);
}
class ItemInfo {
Bitmap bitmap;
int count;
}
static class Item implements Comparable<Item>{
// The type is also used as the sort order
public final static int TYPE_NONE = -1;
public final static int TYPE_ALL_IMAGES = 0;
public final static int TYPE_ALL_VIDEOS = 1;
public final static int TYPE_CAMERA_IMAGES = 2;
public final static int TYPE_CAMERA_VIDEOS = 3;
public final static int TYPE_NORMAL_FOLDERS = 4;
public int mType;
public String mId;
public String mName;
public Uri mFirstImageUri;
public ItemInfo mThumb;
public Item(int type, String id, String name) {
mType = type;
mId = id;
mName = name;
}
public boolean needsBucketId() {
return mType >= TYPE_CAMERA_IMAGES;
}
public void launch(Activity activity) {
android.net.Uri uri = Images.Media.INTERNAL_CONTENT_URI;
if (needsBucketId()) {
uri = uri.buildUpon().appendQueryParameter("bucketId",mId).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:
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:
return R.drawable.frame_overlay_gallery_video;
case TYPE_NORMAL_FOLDERS:
return R.drawable.frame_overlay_gallery_folder;
default:
return -1;
}
}
// sort based on the sort order, then the case-insensitive display name, then the id.
public int compareTo(Item other) {
int x = mType - other.mType;
if (x == 0) {
x = mName.compareToIgnoreCase(other.mName);
if (x == 0) {
x = mId.compareTo(other.mId);
}
}
return x;
}
}
class GalleryPickerAdapter extends BaseAdapter {
ArrayList<Item> mItems = new ArrayList<Item>();
boolean mDone = false;
CameraThread mWorkerThread;
public void init(boolean assumeMounted) {
mItems.clear();
ImageManager.IImageList images;
if (assumeMounted) {
images = ImageManager.instance().allImages(
GalleryPicker.this,
getContentResolver(),
ImageManager.DataLocation.ALL,
ImageManager.INCLUDE_IMAGES | ImageManager.INCLUDE_VIDEOS,
ImageManager.SORT_DESCENDING);
} else {
images = ImageManager.instance().emptyImageList();
}
if (mWorkerThread != null) {
try {
mDone = true;
if (Config.LOGV)
Log.v(TAG, "about to call join on thread " + mWorkerThread.getId());
mWorkerThread.join();
} finally {
mWorkerThread = null;
}
}
String cameraItem = ImageManager.CAMERA_IMAGE_BUCKET_ID;
final HashMap<String, String> hashMap = images.getBucketIds();
String cameraBucketId = null;
for (Map.Entry<String, String> entry: hashMap.entrySet()) {
String key = entry.getKey();
if (key == null) {
continue;
}
if (key.equals(cameraItem)) {
cameraBucketId = key;
} else {
mItems.add(new Item(Item.TYPE_NORMAL_FOLDERS, key, entry.getValue()));
}
}
images.deactivate();
notifyDataSetInvalidated();
// Conditionally add all-images and all-videos folders.
addBucket(Item.TYPE_ALL_IMAGES, null,
Item.TYPE_CAMERA_IMAGES, cameraBucketId, R.string.all_images);
addBucket(Item.TYPE_ALL_VIDEOS, null,
Item.TYPE_CAMERA_VIDEOS, cameraBucketId, R.string.all_videos);
if (cameraBucketId != null) {
addBucket(Item.TYPE_CAMERA_IMAGES, cameraBucketId,
R.string.gallery_camera_bucket_name);
addBucket(Item.TYPE_CAMERA_VIDEOS, cameraBucketId,
R.string.gallery_camera_videos_bucket_name);
}
java.util.Collections.sort(mItems);
mDone = false;
mWorkerThread = new CameraThread(new Runnable() {
public void run() {
try {
// no images, nothing to do
if (mItems.size() == 0)
return;
for (int i = 0; i < mItems.size() && !mDone; i++) {
final Item item = mItems.get(i);
ImageManager.IImageList list = createImageList(
item.getIncludeMediaTypes(), item.mId);
try {
if (mPausing) {
break;
}
if (list.getCount() > 0)
item.mFirstImageUri = list.getImageAt(0).fullSizeImageUri();
final Bitmap b = makeMiniThumbBitmap(142, 142, list);
final int pos = i;
final int count = list.getCount();
final Thread currentThread = Thread.currentThread();
mHandler.post(new Runnable() {
public void run() {
if (mPausing || currentThread != mWorkerThread.realThread()) {
if (b != null) {
b.recycle();
}
return;
}
ItemInfo info = new ItemInfo();
info.bitmap = b;
info.count = count;
item.mThumb = info;
final GridView grid = GalleryPicker.this.mGridView;
final int firstVisible = grid.getFirstVisiblePosition();
// Minor optimization -- only notify if the specified position is visible
if ((pos >= firstVisible) && (pos < firstVisible + grid.getChildCount())) {
GalleryPickerAdapter.this.notifyDataSetChanged();
}
}
});
} finally {
list.deactivate();
}
}
} catch (Exception ex) {
Log.e(TAG, "got exception generating collage views ", ex);
}
}
});
mWorkerThread.start();
mWorkerThread.toBackground();
}
/**
* Add a bucket, but only if it's interesting.
* Interesting means non-empty and not duplicated by the
* corresponding camera bucket.
*/
private void addBucket(int itemType, String bucketId,
int cameraItemType, String cameraBucketId,
int labelId) {
int itemCount = bucketItemCount(
Item.convertItemTypeToIncludedMediaType(itemType), bucketId);
if (itemCount == 0) {
return; // Bucket is empty, so don't show it.
}
int cameraItemCount = 0;
if (cameraBucketId != null) {
cameraItemCount = bucketItemCount(
Item.convertItemTypeToIncludedMediaType(cameraItemType), cameraBucketId);
}
if (cameraItemCount == itemCount) {
return; // Bucket is the same as the camera bucket, so don't show it.
}
mItems.add(new Item(itemType, bucketId, getResources().getString(labelId)));
}
/**
* Add a bucket, but only if it's interesting.
* Interesting means non-empty.
*/
private void addBucket(int itemType, String bucketId,
int labelId) {
if (!isEmptyBucket(Item.convertItemTypeToIncludedMediaType(itemType), bucketId)) {
mItems.add(new Item(itemType, bucketId, getResources().getString(labelId)));
}
}
public int getCount() {
return mItems.size();
}
public Object getItem(int position) {
return null;
}
public long getItemId(int position) {
return position;
}
private String baseTitleForPosition(int position) {
return mItems.get(position).mName;
}
private int getIncludeMediaTypes(int position) {
return mItems.get(position).getIncludeMediaTypes();
}
public View getView(final int position, View convertView, ViewGroup parent) {
View v;
if (convertView == null) {
LayoutInflater vi = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
v = vi.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);
iv.setOverlay(mItems.get(position).getOverlay());
ItemInfo info = mItems.get(position).mThumb;
if (info != null) {
iv.setImageBitmap(info.bitmap);
String title = baseTitleForPosition(position) + " (" + info.count + ")";
titleView.setText(title);
} else {
iv.setImageResource(android.R.color.transparent);
titleView.setText(baseTitleForPosition(position));
}
return v;
}
};
@Override
public void onPause() {
super.onPause();
mPausing = true;
unregisterReceiver(mReceiver);
// free up some ram
mAdapter = null;
mGridView.setAdapter(null);
System.gc();
}
@Override
public void onResume() {
super.onResume();
mPausing = false;
mAdapter = new GalleryPickerAdapter();
mGridView.setAdapter(mAdapter);
setBackgrounds(getResources());
boolean scanning = ImageManager.isMediaScannerScanning(this);
rebake(false, scanning);
// 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");
registerReceiver(mReceiver, intentFilter);
MenuHelper.requestOrientation(this, mPrefs);
}
private void setBackgrounds(Resources r) {
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);
}
Handler mHandler = new Handler();
private 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);
}
private Bitmap makeMiniThumbBitmap(int width, int height, ImageManager.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);
// draw the mask normally
p.setColor(0xFFFFFFFF);
mFrameGalleryMask.setBounds(0, 0, width, height);
mFrameGalleryMask.draw(c);
Paint pdpaint = new Paint();
pdpaint.setXfermode(new android.graphics.PorterDuffXfermode(
android.graphics.PorterDuff.Mode.SRC_IN));
pdpaint.setStyle(Paint.Style.FILL);
c.drawRect(0, 0, width, height, pdpaint);
for (int i = 0; i < 4; i++) {
if (mPausing) {
return null;
}
Bitmap temp = null;
ImageManager.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;
}
Bitmap temp2 = ImageLoader.transform(m, temp, imageWidth, imageHeight, true);
if (temp2 != temp)
temp.recycle();
temp = temp2;
}
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(0, 0, 5, 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;
}
private boolean isEmptyBucket(int mediaTypes, String bucketId) {
// TODO: Find a more efficient way of calculating this
ImageManager.IImageList list = createImageList(mediaTypes, bucketId);
try {
return list.isEmpty();
}
finally {
list.deactivate();
}
}
private int bucketItemCount(int mediaTypes, String bucketId) {
// TODO: Find a more efficient way of calculating this
ImageManager.IImageList list = createImageList(mediaTypes, bucketId);
try {
return list.getCount();
}
finally {
list.deactivate();
}
}
private ImageManager.IImageList createImageList(int mediaTypes, String bucketId) {
return ImageManager.instance().allImages(
this,
getContentResolver(),
ImageManager.DataLocation.ALL,
mediaTypes,
ImageManager.SORT_DESCENDING,
bucketId);
}
}
|
