The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2007 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.camera; |
| 18 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 19 | import android.app.Activity; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 20 | import android.app.AlertDialog; |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 21 | import android.app.Dialog; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 22 | import android.app.ProgressDialog; |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 23 | import android.content.ActivityNotFoundException; |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 24 | import android.content.BroadcastReceiver; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 25 | import android.content.Context; |
| 26 | import android.content.DialogInterface; |
| 27 | import android.content.Intent; |
| 28 | import android.content.IntentFilter; |
| 29 | import android.content.SharedPreferences; |
| 30 | import android.content.pm.ActivityInfo; |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 31 | import android.content.res.Configuration; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 32 | import android.graphics.Bitmap; |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 33 | import android.graphics.BitmapFactory; |
| 34 | import android.graphics.Canvas; |
| 35 | import android.graphics.Paint; |
| 36 | import android.graphics.Rect; |
| 37 | import android.graphics.drawable.Drawable; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 38 | import android.net.Uri; |
| 39 | import android.os.Bundle; |
| 40 | import android.os.Handler; |
Owen Lin | 8f8cf38 | 2009-07-29 13:45:42 +0800 | [diff] [blame] | 41 | import android.os.Parcelable; |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 42 | import android.preference.PreferenceManager; |
| 43 | import android.provider.MediaStore; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 44 | import android.util.Log; |
| 45 | import android.view.ContextMenu; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 46 | import android.view.KeyEvent; |
| 47 | import android.view.Menu; |
| 48 | import android.view.MenuItem; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 49 | import android.view.View; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 50 | import android.view.Window; |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 51 | import android.view.View.OnClickListener; |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 52 | import android.view.animation.Animation; |
| 53 | import android.view.animation.AnimationUtils; |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 54 | import android.widget.Button; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 55 | import android.widget.TextView; |
Owen Lin | 8f8cf38 | 2009-07-29 13:45:42 +0800 | [diff] [blame] | 56 | import android.widget.Toast; |
| 57 | |
| 58 | import com.android.camera.gallery.IImage; |
| 59 | import com.android.camera.gallery.IImageList; |
| 60 | import com.android.camera.gallery.VideoObject; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 61 | |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 62 | import java.util.ArrayList; |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 63 | import java.util.HashSet; |
| 64 | |
Ray Chen | 91acb5b | 2009-04-24 12:12:04 +0800 | [diff] [blame] | 65 | public class ImageGallery extends Activity implements |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 66 | GridViewSpecial.Listener, GridViewSpecial.DrawAdapter { |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 67 | private static final String STATE_SCROLL_POSITION = "scroll_position"; |
| 68 | private static final String STATE_SELECTED_INDEX = "first_index"; |
| 69 | |
Ray Chen | 91acb5b | 2009-04-24 12:12:04 +0800 | [diff] [blame] | 70 | private static final String TAG = "ImageGallery"; |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 71 | private static final float INVALID_POSITION = -1f; |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 72 | private ImageManager.ImageListParam mParam; |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 73 | private IImageList mAllImages; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 74 | private int mInclusion; |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 75 | boolean mSortAscending = false; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 76 | private View mNoImagesView; |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 77 | public static final int CROP_MSG = 2; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 78 | |
| 79 | private Dialog mMediaScanningDialog; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 80 | private MenuItem mSlideShowItem; |
| 81 | private SharedPreferences mPrefs; |
| 82 | private long mVideoSizeLimit = Long.MAX_VALUE; |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 83 | private View mFooterOrganizeView; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 84 | |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 85 | private BroadcastReceiver mReceiver = null; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 86 | |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 87 | private final Handler mHandler = new Handler(); |
| 88 | private boolean mLayoutComplete; |
Chih-Chung Chang | a3be1aa | 2009-05-11 19:09:14 +0800 | [diff] [blame] | 89 | private boolean mPausing = true; |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 90 | private ImageLoader mLoader; |
| 91 | private GridViewSpecial mGvs; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 92 | |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 93 | private Uri mCropResultUri; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 94 | |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 95 | // The index of the first picture in GridViewSpecial. |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 96 | private int mSelectedIndex = GridViewSpecial.INDEX_NONE; |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 97 | private float mScrollPosition = INVALID_POSITION; |
| 98 | private boolean mConfigurationChanged = false; |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 99 | |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 100 | private HashSet<IImage> mMultiSelected = null; |
| 101 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 102 | @Override |
| 103 | public void onCreate(Bundle icicle) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 104 | super.onCreate(icicle); |
| 105 | |
| 106 | mPrefs = PreferenceManager.getDefaultSharedPreferences(this); |
| 107 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 108 | // Must be called before setContentView(). |
| 109 | requestWindowFeature(Window.FEATURE_CUSTOM_TITLE); |
| 110 | |
Owen Lin | 8f8cf38 | 2009-07-29 13:45:42 +0800 | [diff] [blame] | 111 | setContentView(R.layout.image_gallery); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 112 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 113 | getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, |
| 114 | R.layout.custom_gallery_title); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 115 | |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 116 | mNoImagesView = findViewById(R.id.no_images); |
| 117 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 118 | mGvs = (GridViewSpecial) findViewById(R.id.grid); |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 119 | mGvs.setListener(this); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 120 | |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 121 | mFooterOrganizeView = findViewById(R.id.footer_organize); |
| 122 | |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 123 | // consume all click events on the footer view |
| 124 | mFooterOrganizeView.setOnClickListener(Util.getNullOnClickListener()); |
| 125 | initializeFooterButtons(); |
| 126 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 127 | if (isPickIntent()) { |
| 128 | mVideoSizeLimit = getIntent().getLongExtra( |
| 129 | MediaStore.EXTRA_SIZE_LIMIT, Long.MAX_VALUE); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 130 | } else { |
| 131 | mVideoSizeLimit = Long.MAX_VALUE; |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 132 | mGvs.setOnCreateContextMenuListener( |
| 133 | new CreateContextMenuListener()); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 134 | } |
Chih-Chung Chang | ff9922f | 2009-04-27 19:43:36 +0800 | [diff] [blame] | 135 | |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 136 | setupInclusion(); |
| 137 | |
Ray Chen | bde544f | 2009-09-30 14:33:15 -0700 | [diff] [blame] | 138 | mLoader = new ImageLoader(getContentResolver(), mHandler); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 139 | } |
| 140 | |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 141 | private void initializeFooterButtons() { |
| 142 | Button deleteButton = (Button) findViewById(R.id.button_delete); |
| 143 | deleteButton.setOnClickListener(new OnClickListener() { |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 144 | public void onClick(View v) { |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 145 | onDeleteMultipleClicked(); |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 146 | } |
| 147 | }); |
| 148 | |
Owen Lin | 8f8cf38 | 2009-07-29 13:45:42 +0800 | [diff] [blame] | 149 | Button shareButton = (Button) findViewById(R.id.button_share); |
| 150 | shareButton.setOnClickListener(new OnClickListener() { |
| 151 | public void onClick(View v) { |
| 152 | onShareMultipleClicked(); |
| 153 | } |
| 154 | }); |
| 155 | |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 156 | Button closeButton = (Button) findViewById(R.id.button_close); |
Chih-Chung Chang | 91acfc9 | 2009-07-06 15:37:24 +0800 | [diff] [blame] | 157 | closeButton.setOnClickListener(new OnClickListener() { |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 158 | public void onClick(View v) { |
| 159 | closeMultiSelectMode(); |
| 160 | } |
| 161 | }); |
| 162 | } |
| 163 | |
Chih-Chung Chang | d189083 | 2009-09-08 13:32:52 +0800 | [diff] [blame] | 164 | private MenuItem addSlideShowMenu(Menu menu) { |
| 165 | return menu.add(Menu.NONE, Menu.NONE, MenuHelper.POSITION_SLIDESHOW, |
| 166 | R.string.slide_show) |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 167 | .setOnMenuItemClickListener( |
| 168 | new MenuItem.OnMenuItemClickListener() { |
| 169 | public boolean onMenuItemClick(MenuItem item) { |
| 170 | return onSlideShowClicked(); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 171 | } |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 172 | }).setIcon(android.R.drawable.ic_menu_slideshow); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 173 | } |
| 174 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 175 | public boolean onSlideShowClicked() { |
repo sync | cd34001 | 2009-06-02 12:32:33 +0800 | [diff] [blame] | 176 | if (!canHandleEvent()) { |
| 177 | return false; |
| 178 | } |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 179 | IImage img = getCurrentImage(); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 180 | if (img == null) { |
| 181 | img = mAllImages.getImageAt(0); |
| 182 | if (img == null) { |
| 183 | return true; |
| 184 | } |
| 185 | } |
| 186 | Uri targetUri = img.fullSizeImageUri(); |
| 187 | Uri thisUri = getIntent().getData(); |
| 188 | if (thisUri != null) { |
| 189 | String bucket = thisUri.getQueryParameter("bucketId"); |
| 190 | if (bucket != null) { |
| 191 | targetUri = targetUri.buildUpon() |
| 192 | .appendQueryParameter("bucketId", bucket) |
| 193 | .build(); |
| 194 | } |
| 195 | } |
| 196 | Intent intent = new Intent(Intent.ACTION_VIEW, targetUri); |
| 197 | intent.putExtra("slideshow", true); |
| 198 | startActivity(intent); |
| 199 | return true; |
| 200 | } |
Owen Lin | 937fc48 | 2009-04-14 02:02:51 -0700 | [diff] [blame] | 201 | |
Chih-Chung Chang | 74be052 | 2009-04-14 18:00:10 +0800 | [diff] [blame] | 202 | private final Runnable mDeletePhotoRunnable = new Runnable() { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 203 | public void run() { |
Chih-Chung Chang | 1809136 | 2009-06-16 12:11:31 +0800 | [diff] [blame] | 204 | if (!canHandleEvent()) return; |
Chih-Chung Chang | 30f17b2 | 2009-06-29 15:24:13 +0800 | [diff] [blame] | 205 | |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 206 | IImage currentImage = getCurrentImage(); |
Chih-Chung Chang | 05f863c | 2009-07-10 13:16:22 +0800 | [diff] [blame] | 207 | |
| 208 | // The selection will be cleared when mGvs.stop() is called, so |
| 209 | // we need to call getCurrentImage() before mGvs.stop(). |
| 210 | mGvs.stop(); |
| 211 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 212 | if (currentImage != null) { |
| 213 | mAllImages.removeImage(currentImage); |
| 214 | } |
Chih-Chung Chang | a3be1aa | 2009-05-11 19:09:14 +0800 | [diff] [blame] | 215 | mGvs.setImageList(mAllImages); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 216 | mGvs.start(); |
Chih-Chung Chang | 30f17b2 | 2009-06-29 15:24:13 +0800 | [diff] [blame] | 217 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 218 | mNoImagesView.setVisibility(mAllImages.isEmpty() |
| 219 | ? View.VISIBLE |
| 220 | : View.GONE); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 221 | } |
| 222 | }; |
| 223 | |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 224 | private Uri getCurrentImageUri() { |
| 225 | IImage image = getCurrentImage(); |
| 226 | if (image != null) { |
| 227 | return image.fullSizeImageUri(); |
| 228 | } else { |
| 229 | return null; |
| 230 | } |
| 231 | } |
| 232 | |
| 233 | private IImage getCurrentImage() { |
Chih-Chung Chang | a3be1aa | 2009-05-11 19:09:14 +0800 | [diff] [blame] | 234 | int currentSelection = mGvs.getCurrentSelection(); |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 235 | if (currentSelection < 0 |
| 236 | || currentSelection >= mAllImages.getCount()) { |
| 237 | return null; |
| 238 | } else { |
| 239 | return mAllImages.getImageAt(currentSelection); |
| 240 | } |
| 241 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 242 | |
| 243 | @Override |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 244 | public void onConfigurationChanged(Configuration newConfig) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 245 | super.onConfigurationChanged(newConfig); |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 246 | mConfigurationChanged = true; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 247 | } |
| 248 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 249 | boolean canHandleEvent() { |
The Android Open Source Project | de365d8 | 2009-03-18 17:39:48 -0700 | [diff] [blame] | 250 | // Don't process event in pause state. |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 251 | return (!mPausing) && (mLayoutComplete); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 252 | } |
Owen Lin | 937fc48 | 2009-04-14 02:02:51 -0700 | [diff] [blame] | 253 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 254 | @Override |
| 255 | public boolean onKeyDown(int keyCode, KeyEvent event) { |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 256 | if (!canHandleEvent()) return false; |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 257 | switch (keyCode) { |
| 258 | case KeyEvent.KEYCODE_DEL: |
Chih-Chung Chang | c476b25 | 2009-07-02 17:18:24 +0800 | [diff] [blame] | 259 | IImage image = getCurrentImage(); |
| 260 | if (image != null) { |
| 261 | MenuHelper.deleteImage( |
| 262 | this, mDeletePhotoRunnable, getCurrentImage()); |
| 263 | } |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 264 | return true; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 265 | } |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 266 | return super.onKeyDown(keyCode, event); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 267 | } |
| 268 | |
Chih-Chung Chang | 58e94ed | 2009-04-17 11:02:01 +0800 | [diff] [blame] | 269 | private boolean isPickIntent() { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 270 | String action = getIntent().getAction(); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 271 | return (Intent.ACTION_PICK.equals(action) |
| 272 | || Intent.ACTION_GET_CONTENT.equals(action)); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 273 | } |
| 274 | |
Chih-Chung Chang | 58e94ed | 2009-04-17 11:02:01 +0800 | [diff] [blame] | 275 | private void launchCropperOrFinish(IImage img) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 276 | Bundle myExtras = getIntent().getExtras(); |
| 277 | |
The Android Open Source Project | 9c9be2e | 2009-03-05 14:34:37 -0800 | [diff] [blame] | 278 | long size = MenuHelper.getImageFileSize(img); |
| 279 | if (size < 0) { |
Wu-cheng Li | 8463583 | 2009-05-07 16:07:10 +0800 | [diff] [blame] | 280 | // Return if the image file is not available. |
The Android Open Source Project | 9c9be2e | 2009-03-05 14:34:37 -0800 | [diff] [blame] | 281 | return; |
| 282 | } |
Owen Lin | 937fc48 | 2009-04-14 02:02:51 -0700 | [diff] [blame] | 283 | |
The Android Open Source Project | 9c9be2e | 2009-03-05 14:34:37 -0800 | [diff] [blame] | 284 | if (size > mVideoSizeLimit) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 285 | DialogInterface.OnClickListener buttonListener = |
| 286 | new DialogInterface.OnClickListener() { |
| 287 | public void onClick(DialogInterface dialog, int which) { |
| 288 | dialog.dismiss(); |
| 289 | } |
| 290 | }; |
| 291 | new AlertDialog.Builder(this) |
| 292 | .setIcon(android.R.drawable.ic_dialog_info) |
| 293 | .setTitle(R.string.file_info_title) |
| 294 | .setMessage(R.string.video_exceed_mms_limit) |
| 295 | .setNeutralButton(R.string.details_ok, buttonListener) |
| 296 | .show(); |
| 297 | return; |
| 298 | } |
| 299 | |
| 300 | String cropValue = myExtras != null ? myExtras.getString("crop") : null; |
| 301 | if (cropValue != null) { |
| 302 | Bundle newExtras = new Bundle(); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 303 | if (cropValue.equals("circle")) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 304 | newExtras.putString("circleCrop", "true"); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 305 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 306 | |
| 307 | Intent cropIntent = new Intent(); |
| 308 | cropIntent.setData(img.fullSizeImageUri()); |
| 309 | cropIntent.setClass(this, CropImage.class); |
| 310 | cropIntent.putExtras(newExtras); |
| 311 | |
| 312 | /* pass through any extras that were passed in */ |
| 313 | cropIntent.putExtras(myExtras); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 314 | startActivityForResult(cropIntent, CROP_MSG); |
| 315 | } else { |
| 316 | Intent result = new Intent(null, img.fullSizeImageUri()); |
Wu-cheng Li | 8463583 | 2009-05-07 16:07:10 +0800 | [diff] [blame] | 317 | if (myExtras != null && myExtras.getBoolean("return-data")) { |
| 318 | // The size of a transaction should be below 100K. |
Chih-Chung Chang | ce033a5 | 2009-07-27 13:03:29 +0800 | [diff] [blame] | 319 | Bitmap bitmap = img.fullSizeBitmap( |
| 320 | IImage.UNCONSTRAINED, 100 * 1024); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 321 | if (bitmap != null) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 322 | result.putExtra("data", bitmap); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 323 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 324 | } |
| 325 | setResult(RESULT_OK, result); |
| 326 | finish(); |
| 327 | } |
| 328 | } |
| 329 | |
| 330 | @Override |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 331 | protected void onActivityResult(int requestCode, int resultCode, |
| 332 | Intent data) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 333 | switch (requestCode) { |
| 334 | case MenuHelper.RESULT_COMMON_MENU_CROP: { |
| 335 | if (resultCode == RESULT_OK) { |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 336 | |
| 337 | // The CropImage activity passes back the Uri of the cropped |
| 338 | // image as the Action rather than the Data. |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 339 | // We store this URI so we can move the selection box to it |
| 340 | // later. |
| 341 | mCropResultUri = Uri.parse(data.getAction()); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 342 | } |
| 343 | break; |
| 344 | } |
| 345 | case CROP_MSG: { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 346 | if (resultCode == RESULT_OK) { |
| 347 | setResult(resultCode, data); |
| 348 | finish(); |
| 349 | } |
| 350 | break; |
| 351 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 352 | } |
| 353 | } |
| 354 | |
| 355 | @Override |
| 356 | public void onPause() { |
| 357 | super.onPause(); |
| 358 | mPausing = true; |
Owen Lin | 937fc48 | 2009-04-14 02:02:51 -0700 | [diff] [blame] | 359 | |
Ray Chen | 896182a | 2009-05-13 16:21:52 +0800 | [diff] [blame] | 360 | mLoader.stop(); |
| 361 | |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 362 | mGvs.stop(); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 363 | |
| 364 | if (mReceiver != null) { |
| 365 | unregisterReceiver(mReceiver); |
| 366 | mReceiver = null; |
| 367 | } |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 368 | |
| 369 | // Now that we've paused the threads that are using the cursor it is |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 370 | // safe to close it. |
| 371 | mAllImages.close(); |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 372 | mAllImages = null; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | private void rebake(boolean unmounted, boolean scanning) { |
Chih-Chung Chang | a3be1aa | 2009-05-11 19:09:14 +0800 | [diff] [blame] | 376 | mGvs.stop(); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 377 | if (mAllImages != null) { |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 378 | mAllImages.close(); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 379 | mAllImages = null; |
| 380 | } |
repo sync | 62ca191 | 2009-07-01 18:37:14 +0800 | [diff] [blame] | 381 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 382 | if (mMediaScanningDialog != null) { |
| 383 | mMediaScanningDialog.cancel(); |
| 384 | mMediaScanningDialog = null; |
| 385 | } |
repo sync | 62ca191 | 2009-07-01 18:37:14 +0800 | [diff] [blame] | 386 | |
Ray Chen | 2f84ae8 | 2009-07-08 16:54:54 +0800 | [diff] [blame] | 387 | if (scanning) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 388 | mMediaScanningDialog = ProgressDialog.show( |
| 389 | this, |
| 390 | null, |
| 391 | getResources().getString(R.string.wait), |
| 392 | true, |
| 393 | true); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 394 | } |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 395 | |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 396 | mParam = allImages(!unmounted && !scanning); |
| 397 | mAllImages = ImageManager.makeImageList(getContentResolver(), mParam); |
Ray Chen | 2f84ae8 | 2009-07-08 16:54:54 +0800 | [diff] [blame] | 398 | |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 399 | mGvs.setImageList(mAllImages); |
| 400 | mGvs.setDrawAdapter(this); |
| 401 | mGvs.setLoader(mLoader); |
| 402 | mGvs.start(); |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 403 | mNoImagesView.setVisibility(mAllImages.getCount() > 0 |
| 404 | ? View.GONE |
| 405 | : View.VISIBLE); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 406 | } |
| 407 | |
| 408 | @Override |
| 409 | protected void onSaveInstanceState(Bundle state) { |
| 410 | super.onSaveInstanceState(state); |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 411 | state.putFloat(STATE_SCROLL_POSITION, mScrollPosition); |
| 412 | state.putInt(STATE_SELECTED_INDEX, mSelectedIndex); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 413 | } |
| 414 | |
| 415 | @Override |
| 416 | protected void onRestoreInstanceState(Bundle state) { |
| 417 | super.onRestoreInstanceState(state); |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 418 | mScrollPosition = state.getFloat( |
| 419 | STATE_SCROLL_POSITION, INVALID_POSITION); |
| 420 | mSelectedIndex = state.getInt(STATE_SELECTED_INDEX, 0); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 421 | } |
| 422 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 423 | @Override |
| 424 | public void onResume() { |
| 425 | super.onResume(); |
Owen Lin | 937fc48 | 2009-04-14 02:02:51 -0700 | [diff] [blame] | 426 | |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 427 | mGvs.setSizeChoice(Integer.parseInt( |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 428 | mPrefs.getString("pref_gallery_size_key", "1"))); |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 429 | mGvs.requestFocus(); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 430 | |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 431 | String sortOrder = mPrefs.getString("pref_gallery_sort_key", null); |
| 432 | if (sortOrder != null) { |
| 433 | mSortAscending = sortOrder.equals("ascending"); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 434 | } |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 435 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 436 | mPausing = false; |
| 437 | |
| 438 | // install an intent filter to receive SD card related events. |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 439 | IntentFilter intentFilter = |
| 440 | new IntentFilter(Intent.ACTION_MEDIA_MOUNTED); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 441 | intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED); |
| 442 | intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_STARTED); |
| 443 | intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_FINISHED); |
| 444 | intentFilter.addAction(Intent.ACTION_MEDIA_EJECT); |
| 445 | intentFilter.addDataScheme("file"); |
| 446 | |
| 447 | mReceiver = new BroadcastReceiver() { |
| 448 | @Override |
| 449 | public void onReceive(Context context, Intent intent) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 450 | String action = intent.getAction(); |
| 451 | if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) { |
| 452 | // SD card available |
| 453 | // TODO put up a "please wait" message |
| 454 | // TODO also listen for the media scanner finished message |
| 455 | } else if (action.equals(Intent.ACTION_MEDIA_UNMOUNTED)) { |
| 456 | // SD card unavailable |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 457 | rebake(true, false); |
| 458 | } else if (action.equals(Intent.ACTION_MEDIA_SCANNER_STARTED)) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 459 | rebake(false, true); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 460 | } else if (action.equals( |
| 461 | Intent.ACTION_MEDIA_SCANNER_FINISHED)) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 462 | rebake(false, false); |
| 463 | } else if (action.equals(Intent.ACTION_MEDIA_EJECT)) { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 464 | rebake(true, false); |
| 465 | } |
| 466 | } |
| 467 | }; |
| 468 | registerReceiver(mReceiver, intentFilter); |
Chih-Chung Chang | a6e2144 | 2009-04-17 23:18:09 +0800 | [diff] [blame] | 469 | rebake(false, ImageManager.isMediaScannerScanning( |
| 470 | getContentResolver())); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 471 | } |
| 472 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 473 | @Override |
Chih-Chung Chang | 58e94ed | 2009-04-17 11:02:01 +0800 | [diff] [blame] | 474 | public boolean onCreateOptionsMenu(Menu menu) { |
The Android Open Source Project | de365d8 | 2009-03-18 17:39:48 -0700 | [diff] [blame] | 475 | if (isPickIntent()) { |
Chih-Chung Chang | 02e2b0b | 2009-04-20 12:06:53 +0800 | [diff] [blame] | 476 | String type = getIntent().resolveType(this); |
| 477 | if (type != null) { |
| 478 | if (isImageType(type)) { |
| 479 | MenuHelper.addCapturePictureMenuItems(menu, this); |
Chih-Chung Chang | 6b27050 | 2009-04-29 11:57:06 +0800 | [diff] [blame] | 480 | } else if (isVideoType(type)) { |
Chih-Chung Chang | 02e2b0b | 2009-04-20 12:06:53 +0800 | [diff] [blame] | 481 | MenuHelper.addCaptureVideoMenuItems(menu, this); |
| 482 | } |
| 483 | } |
The Android Open Source Project | de365d8 | 2009-03-18 17:39:48 -0700 | [diff] [blame] | 484 | } else { |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 485 | MenuHelper.addCaptureMenuItems(menu, this); |
| 486 | if ((mInclusion & ImageManager.INCLUDE_IMAGES) != 0) { |
Chih-Chung Chang | d189083 | 2009-09-08 13:32:52 +0800 | [diff] [blame] | 487 | mSlideShowItem = addSlideShowMenu(menu); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 488 | } |
Chih-Chung Chang | 02e2b0b | 2009-04-20 12:06:53 +0800 | [diff] [blame] | 489 | |
Chih-Chung Chang | d189083 | 2009-09-08 13:32:52 +0800 | [diff] [blame] | 490 | MenuItem item = menu.add(Menu.NONE, Menu.NONE, |
| 491 | MenuHelper.POSITION_GALLERY_SETTING, |
| 492 | R.string.camerasettings); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 493 | item.setOnMenuItemClickListener( |
| 494 | new MenuItem.OnMenuItemClickListener() { |
Chih-Chung Chang | 02e2b0b | 2009-04-20 12:06:53 +0800 | [diff] [blame] | 495 | public boolean onMenuItemClick(MenuItem item) { |
| 496 | Intent preferences = new Intent(); |
Chih-Chung Chang | 6b27050 | 2009-04-29 11:57:06 +0800 | [diff] [blame] | 497 | preferences.setClass(ImageGallery.this, |
| 498 | GallerySettings.class); |
Chih-Chung Chang | 02e2b0b | 2009-04-20 12:06:53 +0800 | [diff] [blame] | 499 | startActivity(preferences); |
| 500 | return true; |
| 501 | } |
| 502 | }); |
| 503 | item.setAlphabeticShortcut('p'); |
| 504 | item.setIcon(android.R.drawable.ic_menu_preferences); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 505 | |
Chih-Chung Chang | d189083 | 2009-09-08 13:32:52 +0800 | [diff] [blame] | 506 | item = menu.add(Menu.NONE, Menu.NONE, |
| 507 | MenuHelper.POSITION_MULTISELECT, |
| 508 | R.string.multiselect); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 509 | item.setOnMenuItemClickListener( |
| 510 | new MenuItem.OnMenuItemClickListener() { |
| 511 | public boolean onMenuItemClick(MenuItem item) { |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 512 | if (isInMultiSelectMode()) { |
| 513 | closeMultiSelectMode(); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 514 | } else { |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 515 | openMultiSelectMode(); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 516 | } |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 517 | return true; |
| 518 | } |
| 519 | }); |
| 520 | item.setIcon(R.drawable.ic_menu_multiselect_gallery); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 521 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 522 | return true; |
| 523 | } |
| 524 | |
| 525 | @Override |
Chih-Chung Chang | 58e94ed | 2009-04-17 11:02:01 +0800 | [diff] [blame] | 526 | public boolean onPrepareOptionsMenu(Menu menu) { |
Chih-Chung Chang | 938aad0 | 2009-05-22 13:32:46 +0800 | [diff] [blame] | 527 | if (!canHandleEvent()) return false; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 528 | if ((mInclusion & ImageManager.INCLUDE_IMAGES) != 0) { |
| 529 | boolean videoSelected = isVideoSelected(); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 530 | // TODO: Only enable slide show if there is at least one image in |
| 531 | // the folder. |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 532 | if (mSlideShowItem != null) { |
| 533 | mSlideShowItem.setEnabled(!videoSelected); |
| 534 | } |
| 535 | } |
| 536 | |
| 537 | return true; |
| 538 | } |
| 539 | |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 540 | private boolean isVideoSelected() { |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 541 | IImage image = getCurrentImage(); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 542 | return (image != null) && ImageManager.isVideo(image); |
| 543 | } |
| 544 | |
Chih-Chung Chang | 02e2b0b | 2009-04-20 12:06:53 +0800 | [diff] [blame] | 545 | private boolean isImageType(String type) { |
| 546 | return type.equals("vnd.android.cursor.dir/image") |
| 547 | || type.equals("image/*"); |
| 548 | } |
| 549 | |
| 550 | private boolean isVideoType(String type) { |
| 551 | return type.equals("vnd.android.cursor.dir/video") |
| 552 | || type.equals("video/*"); |
| 553 | } |
| 554 | |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 555 | // According to the intent, setup what we include (image/video) in the |
| 556 | // gallery and the title of the gallery. |
| 557 | private void setupInclusion() { |
| 558 | mInclusion = ImageManager.INCLUDE_IMAGES | ImageManager.INCLUDE_VIDEOS; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 559 | |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 560 | Intent intent = getIntent(); |
| 561 | if (intent != null) { |
| 562 | String type = intent.resolveType(this); |
| 563 | TextView leftText = (TextView) findViewById(R.id.left_text); |
| 564 | if (type != null) { |
| 565 | if (isImageType(type)) { |
| 566 | mInclusion = ImageManager.INCLUDE_IMAGES; |
| 567 | if (isPickIntent()) { |
| 568 | leftText.setText(R.string.pick_photos_gallery_title); |
| 569 | } else { |
| 570 | leftText.setText(R.string.photos_gallery_title); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 571 | } |
| 572 | } |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 573 | if (isVideoType(type)) { |
| 574 | mInclusion = ImageManager.INCLUDE_VIDEOS; |
| 575 | if (isPickIntent()) { |
| 576 | leftText.setText(R.string.pick_videos_gallery_title); |
| 577 | } else { |
| 578 | leftText.setText(R.string.videos_gallery_title); |
| 579 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 580 | } |
| 581 | } |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 582 | Bundle extras = intent.getExtras(); |
| 583 | String title = (extras != null) |
| 584 | ? extras.getString("windowTitle") |
| 585 | : null; |
| 586 | if (title != null && title.length() > 0) { |
| 587 | leftText.setText(title); |
| 588 | } |
| 589 | |
| 590 | if (extras != null) { |
| 591 | mInclusion = (ImageManager.INCLUDE_IMAGES |
| 592 | | ImageManager.INCLUDE_VIDEOS) |
| 593 | & extras.getInt("mediaTypes", mInclusion); |
| 594 | } |
| 595 | |
| 596 | if (extras != null && extras.getBoolean("pick-drm")) { |
| 597 | Log.d(TAG, "pick-drm is true"); |
| 598 | mInclusion = ImageManager.INCLUDE_DRM_IMAGES; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 599 | } |
| 600 | } |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 601 | } |
| 602 | |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 603 | // Returns the image list parameter which contains the subset of image/video |
| 604 | // we want. |
| 605 | private ImageManager.ImageListParam allImages(boolean storageAvailable) { |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 606 | if (!storageAvailable) { |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 607 | return ImageManager.getEmptyImageListParam(); |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 608 | } else { |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 609 | Uri uri = getIntent().getData(); |
| 610 | return ImageManager.getImageListParam( |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 611 | ImageManager.DataLocation.EXTERNAL, |
| 612 | mInclusion, |
| 613 | mSortAscending |
| 614 | ? ImageManager.SORT_ASCENDING |
| 615 | : ImageManager.SORT_DESCENDING, |
| 616 | (uri != null) |
| 617 | ? uri.getQueryParameter("bucketId") |
| 618 | : null); |
| 619 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 620 | } |
| 621 | |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 622 | private void toggleMultiSelected(IImage image) { |
| 623 | int original = mMultiSelected.size(); |
| 624 | if (!mMultiSelected.add(image)) { |
| 625 | mMultiSelected.remove(image); |
| 626 | } |
| 627 | mGvs.invalidate(); |
| 628 | if (original == 0) showFooter(); |
| 629 | if (mMultiSelected.size() == 0) hideFooter(); |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 630 | } |
| 631 | |
| 632 | public void onImageClicked(int index) { |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 633 | if (index < 0 || index >= mAllImages.getCount()) { |
| 634 | return; |
| 635 | } |
| 636 | mSelectedIndex = index; |
| 637 | mGvs.setSelectedIndex(index); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 638 | |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 639 | IImage image = mAllImages.getImageAt(index); |
| 640 | |
| 641 | if (isInMultiSelectMode()) { |
| 642 | toggleMultiSelected(image); |
| 643 | return; |
| 644 | } |
| 645 | |
| 646 | if (isPickIntent()) { |
| 647 | launchCropperOrFinish(image); |
| 648 | } else { |
| 649 | Intent intent; |
| 650 | if (image instanceof VideoObject) { |
| 651 | intent = new Intent( |
| 652 | Intent.ACTION_VIEW, image.fullSizeImageUri()); |
| 653 | intent.putExtra(MediaStore.EXTRA_SCREEN_ORIENTATION, |
| 654 | ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); |
Chih-Chung Chang | 74be052 | 2009-04-14 18:00:10 +0800 | [diff] [blame] | 655 | } else { |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 656 | intent = new Intent(this, ViewImage.class); |
Chih-Chung Chang | f5bf8ca | 2009-08-25 18:28:29 +0800 | [diff] [blame] | 657 | intent.putExtra(ViewImage.KEY_IMAGE_LIST, mParam); |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 658 | intent.setData(image.fullSizeImageUri()); |
Chih-Chung Chang | 74be052 | 2009-04-14 18:00:10 +0800 | [diff] [blame] | 659 | } |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 660 | startActivity(intent); |
| 661 | } |
| 662 | } |
| 663 | |
| 664 | public void onImageTapped(int index) { |
| 665 | // In the multiselect mode, once the finger finishes tapping, we hide |
| 666 | // the selection box by setting the selected index to none. However, if |
| 667 | // we use the dpad center key, we will keep the selected index in order |
| 668 | // to show the the selection box. We do this because we have the |
Chih-Chung Chang | 9b93bcb | 2009-09-04 19:46:14 +0800 | [diff] [blame] | 669 | // multiselect marker on the images to indicate which of them are |
| 670 | // selected, so we don't need the selection box, but in the dpad case |
| 671 | // we still need the selection box to show as a "cursor". |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 672 | |
| 673 | if (isInMultiSelectMode()) { |
| 674 | mGvs.setSelectedIndex(GridViewSpecial.INDEX_NONE); |
| 675 | toggleMultiSelected(mAllImages.getImageAt(index)); |
| 676 | } else { |
| 677 | onImageClicked(index); |
Chih-Chung Chang | 74be052 | 2009-04-14 18:00:10 +0800 | [diff] [blame] | 678 | } |
| 679 | } |
| 680 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 681 | private class CreateContextMenuListener implements |
| 682 | View.OnCreateContextMenuListener { |
| 683 | public void onCreateContextMenu(ContextMenu menu, View v, |
| 684 | ContextMenu.ContextMenuInfo menuInfo) { |
Chih-Chung Chang | 938aad0 | 2009-05-22 13:32:46 +0800 | [diff] [blame] | 685 | if (!canHandleEvent()) return; |
| 686 | |
Chih-Chung Chang | 120bf58 | 2009-09-07 18:51:47 +0800 | [diff] [blame] | 687 | IImage image = getCurrentImage(); |
| 688 | |
| 689 | if (image == null) { |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 690 | return; |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 691 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 692 | |
Chih-Chung Chang | 120bf58 | 2009-09-07 18:51:47 +0800 | [diff] [blame] | 693 | boolean isImage = ImageManager.isImage(image); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 694 | if (isImage) { |
Chih-Chung Chang | d189083 | 2009-09-08 13:32:52 +0800 | [diff] [blame] | 695 | menu.add(R.string.view) |
| 696 | .setOnMenuItemClickListener( |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 697 | new MenuItem.OnMenuItemClickListener() { |
| 698 | public boolean onMenuItemClick(MenuItem item) { |
Chih-Chung Chang | 0b803c0 | 2009-06-24 15:14:33 +0800 | [diff] [blame] | 699 | if (!canHandleEvent()) return false; |
Chih-Chung Chang | a3be1aa | 2009-05-11 19:09:14 +0800 | [diff] [blame] | 700 | onImageClicked(mGvs.getCurrentSelection()); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 701 | return true; |
| 702 | } |
| 703 | }); |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 704 | } |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 705 | |
| 706 | menu.setHeaderTitle(isImage |
| 707 | ? R.string.context_menu_header |
| 708 | : R.string.video_context_menu_header); |
| 709 | if ((mInclusion & (ImageManager.INCLUDE_IMAGES |
| 710 | | ImageManager.INCLUDE_VIDEOS)) != 0) { |
| 711 | MenuHelper.MenuItemsResult r = MenuHelper.addImageMenuItems( |
| 712 | menu, |
| 713 | MenuHelper.INCLUDE_ALL, |
Ray Chen | 91acb5b | 2009-04-24 12:12:04 +0800 | [diff] [blame] | 714 | ImageGallery.this, |
Ray Chen | 993105a | 2009-04-10 02:11:35 -0700 | [diff] [blame] | 715 | mHandler, |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 716 | mDeletePhotoRunnable, |
| 717 | new MenuHelper.MenuInvoker() { |
| 718 | public void run(MenuHelper.MenuCallback cb) { |
repo sync | cd34001 | 2009-06-02 12:32:33 +0800 | [diff] [blame] | 719 | if (!canHandleEvent()) { |
| 720 | return; |
| 721 | } |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 722 | cb.run(getCurrentImageUri(), getCurrentImage()); |
Ray Chen | 92eedd6 | 2009-07-15 18:38:29 +0800 | [diff] [blame] | 723 | mGvs.invalidateImage(mGvs.getCurrentSelection()); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 724 | } |
| 725 | }); |
Chih-Chung Chang | 120bf58 | 2009-09-07 18:51:47 +0800 | [diff] [blame] | 726 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 727 | if (r != null) { |
Chih-Chung Chang | 120bf58 | 2009-09-07 18:51:47 +0800 | [diff] [blame] | 728 | r.gettingReadyToOpen(menu, image); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 729 | } |
| 730 | |
| 731 | if (isImage) { |
Chih-Chung Chang | 120bf58 | 2009-09-07 18:51:47 +0800 | [diff] [blame] | 732 | MenuHelper.enableShowOnMapMenuItem( |
| 733 | menu, MenuHelper.hasLatLngData(image)); |
Chih-Chung Chang | d189083 | 2009-09-08 13:32:52 +0800 | [diff] [blame] | 734 | addSlideShowMenu(menu); |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 735 | } |
| 736 | } |
The Android Open Source Project | b64d345 | 2009-03-03 19:32:20 -0800 | [diff] [blame] | 737 | } |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 738 | } |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 739 | |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 740 | public void onLayoutComplete(boolean changed) { |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 741 | mLayoutComplete = true; |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 742 | if (mCropResultUri != null) { |
| 743 | IImage image = mAllImages.getImageForUri(mCropResultUri); |
| 744 | mCropResultUri = null; |
| 745 | if (image != null) { |
Owen Lin | bbc2f2f | 2009-05-05 22:11:15 -0700 | [diff] [blame] | 746 | mSelectedIndex = mAllImages.getImageIndex(image); |
Chih-Chung Chang | 605f7e6 | 2009-05-21 11:05:38 +0800 | [diff] [blame] | 747 | } |
| 748 | } |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 749 | mGvs.setSelectedIndex(mSelectedIndex); |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 750 | if (mScrollPosition == INVALID_POSITION) { |
| 751 | if (mSortAscending) { |
| 752 | mGvs.scrollTo(0, mGvs.getHeight()); |
| 753 | } else { |
| 754 | mGvs.scrollToImage(0); |
| 755 | } |
| 756 | } else if (mConfigurationChanged) { |
| 757 | mConfigurationChanged = false; |
| 758 | mGvs.scrollTo(mScrollPosition); |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 759 | if (mGvs.getCurrentSelection() != GridViewSpecial.INDEX_NONE) { |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 760 | mGvs.scrollToVisible(mSelectedIndex); |
| 761 | } |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 762 | } else { |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 763 | mGvs.scrollTo(mScrollPosition); |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 764 | } |
| 765 | } |
| 766 | |
Owen Lin | 0e27f8d | 2009-04-29 01:11:45 -0700 | [diff] [blame] | 767 | public void onScroll(float scrollPosition) { |
| 768 | mScrollPosition = scrollPosition; |
Owen Lin | f310a3d | 2009-04-20 14:05:17 +0800 | [diff] [blame] | 769 | } |
| 770 | |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 771 | private Drawable mVideoOverlay; |
| 772 | private Drawable mVideoMmsErrorOverlay; |
| 773 | private Drawable mMultiSelectTrue; |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 774 | private Drawable mMultiSelectFalse; |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 775 | |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 776 | // mSrcRect and mDstRect are only used in drawImage, but we put them as |
| 777 | // instance variables to reduce the memory allocation overhead because |
| 778 | // drawImage() is called a lot. |
Owen Lin | deb5725 | 2009-05-27 14:55:45 -0700 | [diff] [blame] | 779 | private final Rect mSrcRect = new Rect(); |
| 780 | private final Rect mDstRect = new Rect(); |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 781 | |
Chih-Chung Chang | df30071 | 2009-09-04 15:54:50 +0800 | [diff] [blame] | 782 | private final Paint mPaint = new Paint(Paint.FILTER_BITMAP_FLAG); |
| 783 | |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 784 | public void drawImage(Canvas canvas, IImage image, |
| 785 | Bitmap b, int xPos, int yPos, int w, int h) { |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 786 | if (b != null) { |
| 787 | // if the image is close to the target size then crop, |
| 788 | // otherwise scale both the bitmap and the view should be |
| 789 | // square but I suppose that could change in the future. |
| 790 | |
| 791 | int bw = b.getWidth(); |
| 792 | int bh = b.getHeight(); |
| 793 | |
| 794 | int deltaW = bw - w; |
| 795 | int deltaH = bh - h; |
| 796 | |
Chih-Chung Chang | df30071 | 2009-09-04 15:54:50 +0800 | [diff] [blame] | 797 | if (deltaW >= 0 && deltaW < 10 && |
| 798 | deltaH >= 0 && deltaH < 10) { |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 799 | int halfDeltaW = deltaW / 2; |
| 800 | int halfDeltaH = deltaH / 2; |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 801 | mSrcRect.set(0 + halfDeltaW, 0 + halfDeltaH, |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 802 | bw - halfDeltaW, bh - halfDeltaH); |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 803 | mDstRect.set(xPos, yPos, xPos + w, yPos + h); |
| 804 | canvas.drawBitmap(b, mSrcRect, mDstRect, null); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 805 | } else { |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 806 | mSrcRect.set(0, 0, bw, bh); |
| 807 | mDstRect.set(xPos, yPos, xPos + w, yPos + h); |
Chih-Chung Chang | df30071 | 2009-09-04 15:54:50 +0800 | [diff] [blame] | 808 | canvas.drawBitmap(b, mSrcRect, mDstRect, mPaint); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 809 | } |
| 810 | } else { |
| 811 | // If the thumbnail cannot be drawn, put up an error icon |
| 812 | // instead |
| 813 | Bitmap error = getErrorBitmap(image); |
| 814 | int width = error.getWidth(); |
| 815 | int height = error.getHeight(); |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 816 | mSrcRect.set(0, 0, width, height); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 817 | int left = (w - width) / 2 + xPos; |
| 818 | int top = (w - height) / 2 + yPos; |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 819 | mDstRect.set(left, top, left + width, top + height); |
| 820 | canvas.drawBitmap(error, mSrcRect, mDstRect, null); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 821 | } |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 822 | |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 823 | if (ImageManager.isVideo(image)) { |
| 824 | Drawable overlay = null; |
| 825 | long size = MenuHelper.getImageFileSize(image); |
| 826 | if (size >= 0 && size <= mVideoSizeLimit) { |
| 827 | if (mVideoOverlay == null) { |
| 828 | mVideoOverlay = getResources().getDrawable( |
| 829 | R.drawable.ic_gallery_video_overlay); |
| 830 | } |
| 831 | overlay = mVideoOverlay; |
| 832 | } else { |
| 833 | if (mVideoMmsErrorOverlay == null) { |
| 834 | mVideoMmsErrorOverlay = getResources().getDrawable( |
| 835 | R.drawable.ic_error_mms_video_overlay); |
| 836 | } |
| 837 | overlay = mVideoMmsErrorOverlay; |
Chih-Chung Chang | 3d6c628 | 2009-04-30 14:35:02 +0800 | [diff] [blame] | 838 | Paint paint = new Paint(); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 839 | paint.setARGB(0x80, 0x00, 0x00, 0x00); |
| 840 | canvas.drawRect(xPos, yPos, xPos + w, yPos + h, paint); |
| 841 | } |
| 842 | int width = overlay.getIntrinsicWidth(); |
| 843 | int height = overlay.getIntrinsicHeight(); |
| 844 | int left = (w - width) / 2 + xPos; |
| 845 | int top = (h - height) / 2 + yPos; |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 846 | mSrcRect.set(left, top, left + width, top + height); |
| 847 | overlay.setBounds(mSrcRect); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 848 | overlay.draw(canvas); |
| 849 | } |
Chih-Chung Chang | cb4b88e | 2009-07-07 20:01:55 +0800 | [diff] [blame] | 850 | } |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 851 | |
Chih-Chung Chang | cb4b88e | 2009-07-07 20:01:55 +0800 | [diff] [blame] | 852 | public boolean needsDecoration() { |
| 853 | return (mMultiSelected != null); |
| 854 | } |
Ray Chen | 24588aa | 2009-07-10 18:36:48 +0800 | [diff] [blame] | 855 | |
Chih-Chung Chang | cb4b88e | 2009-07-07 20:01:55 +0800 | [diff] [blame] | 856 | public void drawDecoration(Canvas canvas, IImage image, |
| 857 | int xPos, int yPos, int w, int h) { |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 858 | if (mMultiSelected != null) { |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 859 | initializeMultiSelectDrawables(); |
| 860 | |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 861 | Drawable checkBox = mMultiSelected.contains(image) |
| 862 | ? mMultiSelectTrue |
| 863 | : mMultiSelectFalse; |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 864 | int width = checkBox.getIntrinsicWidth(); |
| 865 | int height = checkBox.getIntrinsicHeight(); |
| 866 | int left = 5 + xPos; |
| 867 | int top = h - height - 5 + yPos; |
Chih-Chung Chang | dd42edf | 2009-05-13 17:51:11 +0800 | [diff] [blame] | 868 | mSrcRect.set(left, top, left + width, top + height); |
| 869 | checkBox.setBounds(mSrcRect); |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 870 | checkBox.draw(canvas); |
| 871 | } |
| 872 | } |
| 873 | |
| 874 | private void initializeMultiSelectDrawables() { |
| 875 | if (mMultiSelectTrue == null) { |
| 876 | mMultiSelectTrue = getResources() |
| 877 | .getDrawable(R.drawable.btn_check_buttonless_on); |
| 878 | } |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 879 | if (mMultiSelectFalse == null) { |
| 880 | mMultiSelectFalse = getResources() |
| 881 | .getDrawable(R.drawable.btn_check_buttonless_off); |
| 882 | } |
Owen Lin | b5d87cf | 2009-04-22 07:58:43 +0800 | [diff] [blame] | 883 | } |
| 884 | |
| 885 | private Bitmap mMissingImageThumbnailBitmap; |
| 886 | private Bitmap mMissingVideoThumbnailBitmap; |
| 887 | |
| 888 | // Create this bitmap lazily, and only once for all the ImageBlocks to |
| 889 | // use |
| 890 | public Bitmap getErrorBitmap(IImage image) { |
| 891 | if (ImageManager.isImage(image)) { |
| 892 | if (mMissingImageThumbnailBitmap == null) { |
| 893 | mMissingImageThumbnailBitmap = BitmapFactory.decodeResource( |
| 894 | getResources(), |
| 895 | R.drawable.ic_missing_thumbnail_picture); |
| 896 | } |
| 897 | return mMissingImageThumbnailBitmap; |
| 898 | } else { |
| 899 | if (mMissingVideoThumbnailBitmap == null) { |
| 900 | mMissingVideoThumbnailBitmap = BitmapFactory.decodeResource( |
| 901 | getResources(), R.drawable.ic_missing_thumbnail_video); |
| 902 | } |
| 903 | return mMissingVideoThumbnailBitmap; |
| 904 | } |
| 905 | } |
Owen Lin | 228f132 | 2009-04-23 16:24:26 -0700 | [diff] [blame] | 906 | |
| 907 | private Animation mFooterAppear; |
| 908 | private Animation mFooterDisappear; |
| 909 | |
| 910 | private void showFooter() { |
| 911 | mFooterOrganizeView.setVisibility(View.VISIBLE); |
| 912 | if (mFooterAppear == null) { |
| 913 | mFooterAppear = AnimationUtils.loadAnimation( |
| 914 | this, R.anim.footer_appear); |
| 915 | } |
| 916 | mFooterOrganizeView.startAnimation(mFooterAppear); |
| 917 | } |
| 918 | |
| 919 | private void hideFooter() { |
| 920 | if (mFooterOrganizeView.getVisibility() != View.GONE) { |
| 921 | mFooterOrganizeView.setVisibility(View.GONE); |
| 922 | if (mFooterDisappear == null) { |
| 923 | mFooterDisappear = AnimationUtils.loadAnimation( |
| 924 | this, R.anim.footer_disappear); |
| 925 | } |
| 926 | mFooterOrganizeView.startAnimation(mFooterDisappear); |
| 927 | } |
| 928 | } |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 929 | |
Owen Lin | 8f8cf38 | 2009-07-29 13:45:42 +0800 | [diff] [blame] | 930 | private String getShareMultipleMimeType() { |
| 931 | final int FLAG_IMAGE = 1, FLAG_VIDEO = 2; |
| 932 | int flag = 0; |
| 933 | for (IImage image : mMultiSelected) { |
| 934 | flag |= ImageManager.isImage(image) ? FLAG_IMAGE : FLAG_VIDEO; |
| 935 | } |
| 936 | return flag == FLAG_IMAGE |
| 937 | ? "image/*" |
| 938 | : flag == FLAG_VIDEO ? "video/*" : "*/*"; |
| 939 | } |
| 940 | |
| 941 | private void onShareMultipleClicked() { |
Chih-Chung Chang | c04ffcd | 2009-10-09 17:40:22 +0800 | [diff] [blame] | 942 | if (mMultiSelected == null) return; |
Owen Lin | c0a98e8 | 2009-09-04 14:49:05 +0800 | [diff] [blame] | 943 | if (mMultiSelected.size() > 1) { |
| 944 | Intent intent = new Intent(); |
| 945 | intent.setAction(Intent.ACTION_SEND_MULTIPLE); |
Owen Lin | 8f8cf38 | 2009-07-29 13:45:42 +0800 | [diff] [blame] | 946 | |
Owen Lin | c0a98e8 | 2009-09-04 14:49:05 +0800 | [diff] [blame] | 947 | String mimeType = getShareMultipleMimeType(); |
| 948 | intent.setType(mimeType); |
| 949 | ArrayList<Parcelable> list = new ArrayList<Parcelable>(); |
| 950 | for (IImage image : mMultiSelected) { |
| 951 | list.add(image.fullSizeImageUri()); |
| 952 | } |
| 953 | intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, list); |
| 954 | try { |
| 955 | startActivity(Intent.createChooser( |
| 956 | intent, getText(R.string.send_media_files))); |
| 957 | } catch (android.content.ActivityNotFoundException ex) { |
| 958 | Toast.makeText(this, R.string.no_way_to_share, |
| 959 | Toast.LENGTH_SHORT).show(); |
| 960 | } |
| 961 | } else if (mMultiSelected.size() == 1) { |
| 962 | IImage image = mMultiSelected.iterator().next(); |
| 963 | Intent intent = new Intent(); |
| 964 | intent.setAction(Intent.ACTION_SEND); |
| 965 | String mimeType = image.getMimeType(); |
| 966 | intent.setType(mimeType); |
| 967 | intent.putExtra(Intent.EXTRA_STREAM, image.fullSizeImageUri()); |
| 968 | boolean isImage = ImageManager.isImage(image); |
| 969 | try { |
| 970 | startActivity(Intent.createChooser(intent, getText( |
| 971 | isImage ? R.string.sendImage : R.string.sendVideo))); |
| 972 | } catch (android.content.ActivityNotFoundException ex) { |
| 973 | Toast.makeText(this, isImage |
| 974 | ? R.string.no_way_to_share_image |
| 975 | : R.string.no_way_to_share_video, |
| 976 | Toast.LENGTH_SHORT).show(); |
| 977 | } |
Owen Lin | 8f8cf38 | 2009-07-29 13:45:42 +0800 | [diff] [blame] | 978 | } |
| 979 | } |
| 980 | |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 981 | private void onDeleteMultipleClicked() { |
| 982 | Runnable action = new Runnable() { |
| 983 | public void run() { |
| 984 | ArrayList<Uri> uriList = new ArrayList<Uri>(); |
| 985 | for (IImage image : mMultiSelected) { |
| 986 | uriList.add(image.fullSizeImageUri()); |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 987 | } |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 988 | closeMultiSelectMode(); |
| 989 | Intent intent = new Intent(ImageGallery.this, |
| 990 | DeleteImage.class); |
| 991 | intent.putExtra("delete-uris", uriList); |
| 992 | try { |
| 993 | startActivity(intent); |
| 994 | } catch (ActivityNotFoundException ex) { |
| 995 | Log.e(TAG, "Delete images fail", ex); |
| 996 | } |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 997 | } |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 998 | }; |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 999 | MenuHelper.deleteMultiple(this, action); |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 1000 | } |
| 1001 | |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 1002 | private boolean isInMultiSelectMode() { |
| 1003 | return mMultiSelected != null; |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 1004 | } |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 1005 | |
| 1006 | private void closeMultiSelectMode() { |
| 1007 | if (mMultiSelected == null) return; |
| 1008 | mMultiSelected = null; |
Chih-Chung Chang | cb4b88e | 2009-07-07 20:01:55 +0800 | [diff] [blame] | 1009 | mGvs.invalidate(); |
Owen Lin | 601ce56 | 2009-04-29 17:47:19 -0700 | [diff] [blame] | 1010 | hideFooter(); |
| 1011 | } |
| 1012 | |
| 1013 | private void openMultiSelectMode() { |
| 1014 | if (mMultiSelected != null) return; |
| 1015 | mMultiSelected = new HashSet<IImage>(); |
Chih-Chung Chang | cb4b88e | 2009-07-07 20:01:55 +0800 | [diff] [blame] | 1016 | mGvs.invalidate(); |
Chih-Chung Chang | 0e48fe6 | 2009-06-26 19:23:56 +0800 | [diff] [blame] | 1017 | } |
Owen Lin | 4c2f857 | 2009-07-08 15:13:54 -0700 | [diff] [blame] | 1018 | |
Chih-Chung Chang | 9ae6df0 | 2009-04-08 01:51:45 -0700 | [diff] [blame] | 1019 | } |