src/com/android/gallery3d/ui/MenuExecutor.java

   1 /*
   2  * Copyright (C) 2010 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.gallery3d.ui;
  18
  19 import android.app.Activity;
  20 import android.app.AlertDialog;
  21 import android.app.ProgressDialog;
  22 import android.content.Context;
  23 import android.content.DialogInterface;
  24 import android.content.DialogInterface.OnCancelListener;
  25 import android.content.DialogInterface.OnClickListener;
  26 import android.content.Intent;
  27 import android.os.Handler;
  28 import android.os.Message;
  29 import android.support.v4.print.PrintHelper;
  30 import android.view.Menu;
  31 import android.view.MenuItem;
  32
  33 import com.android.gallery3d.R;
  34 import com.android.gallery3d.app.AbstractGalleryActivity;
  35 import com.android.gallery3d.common.Utils;
  36 import com.android.gallery3d.data.DataManager;
  37 import com.android.gallery3d.data.MediaItem;
  38 import com.android.gallery3d.data.MediaObject;
  39 import com.android.gallery3d.data.Path;
  40 import com.android.gallery3d.filtershow.crop.CropActivity;
  41 import com.android.gallery3d.util.Future;
  42 import com.android.gallery3d.util.GalleryUtils;
  43 import com.android.gallery3d.util.ThreadPool.Job;
  44 import com.android.gallery3d.util.ThreadPool.JobContext;
  45
  46 import java.util.ArrayList;
  47
  48 public class MenuExecutor {
  49     private static final String TAG = "MenuExecutor";
  50
  51     private static final int MSG_TASK_COMPLETE = 1;
  52     private static final int MSG_TASK_UPDATE = 2;
  53     private static final int MSG_TASK_START = 3;
  54     private static final int MSG_DO_SHARE = 4;
  55
  56     public static final int EXECUTION_RESULT_SUCCESS = 1;
  57     public static final int EXECUTION_RESULT_FAIL = 2;
  58     public static final int EXECUTION_RESULT_CANCEL = 3;
  59
  60     private ProgressDialog mDialog;
  61     private Future<?> mTask;
  62     // wait the operation to finish when we want to stop it.
  63     private boolean mWaitOnStop;
  64     private boolean mPaused;
  65
  66     private final AbstractGalleryActivity mActivity;
  67     private final SelectionManager mSelectionManager;
  68     private final Handler mHandler;
  69
  70     private static ProgressDialog createProgressDialog(
  71             Context context, int titleId, int progressMax) {
  72         ProgressDialog dialog = new ProgressDialog(context);
  73         dialog.setTitle(titleId);
  74         dialog.setMax(progressMax);
  75         dialog.setCancelable(false);
  76         dialog.setIndeterminate(false);
  77         if (progressMax > 1) {
  78             dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
  79         }
  80         return dialog;
  81     }
  82
  83     public interface ProgressListener {
  84         public void onConfirmDialogShown();
  85         public void onConfirmDialogDismissed(boolean confirmed);
  86         public void onProgressStart();
  87         public void onProgressUpdate(int index);
  88         public void onProgressComplete(int result);
  89     }
  90
  91     public MenuExecutor(
  92             AbstractGalleryActivity activity, SelectionManager selectionManager) {
  93         mActivity = Utils.checkNotNull(activity);
  94         mSelectionManager = Utils.checkNotNull(selectionManager);
  95         mHandler = new SynchronizedHandler(mActivity.getGLRoot()) {
  96             @Override
  97             public void handleMessage(Message message) {
  98                 switch (message.what) {
  99                     case MSG_TASK_START: {
 100                         if (message.obj != null) {
 101                             ProgressListener listener = (ProgressListener) message.obj;
 102                             listener.onProgressStart();
 103                         }
 104                         break;
 105                     }
 106                     case MSG_TASK_COMPLETE: {
 107                         stopTaskAndDismissDialog();
 108                         if (message.obj != null) {
 109                             ProgressListener listener = (ProgressListener) message.obj;
 110                             listener.onProgressComplete(message.arg1);
 111                         }
 112                         mSelectionManager.leaveSelectionMode();
 113                         break;
 114                     }
 115                     case MSG_TASK_UPDATE: {
 116                         if (mDialog != null && !mPaused) mDialog.setProgress(message.arg1);
 117                         if (message.obj != null) {
 118                             ProgressListener listener = (ProgressListener) message.obj;
 119                             listener.onProgressUpdate(message.arg1);
 120                         }
 121                         break;
 122                     }
 123                     case MSG_DO_SHARE: {
 124                         ((Activity) mActivity).startActivity((Intent) message.obj);
 125                         break;
 126                     }
 127                 }
 128             }
 129         };
 130     }
 131
 132     private void stopTaskAndDismissDialog() {
 133         if (mTask != null) {
 134             if (!mWaitOnStop) mTask.cancel();
 135             if (mDialog != null && mDialog.isShowing()) mDialog.dismiss();
 136             mDialog = null;
 137             mTask = null;
 138         }
 139     }
 140
 141     public void resume() {
 142         mPaused = false;
 143         if (mDialog != null) mDialog.show();
 144     }
 145
 146     public void pause() {
 147         mPaused = true;
 148         if (mDialog != null && mDialog.isShowing()) mDialog.hide();
 149     }
 150
 151     public void destroy() {
 152         stopTaskAndDismissDialog();
 153     }
 154
 155     private void onProgressUpdate(int index, ProgressListener listener) {
 156         mHandler.sendMessage(
 157                 mHandler.obtainMessage(MSG_TASK_UPDATE, index, 0, listener));
 158     }
 159
 160     private void onProgressStart(ProgressListener listener) {
 161         mHandler.sendMessage(mHandler.obtainMessage(MSG_TASK_START, listener));
 162     }
 163
 164     private void onProgressComplete(int result, ProgressListener listener) {
 165         mHandler.sendMessage(mHandler.obtainMessage(MSG_TASK_COMPLETE, result, 0, listener));
 166     }
 167
 168     public static void updateMenuOperation(Menu menu, int supported) {
 169         boolean supportDelete = (supported & MediaObject.SUPPORT_DELETE) != 0;
 170         boolean supportRotate = (supported & MediaObject.SUPPORT_ROTATE) != 0;
 171         boolean supportCrop = (supported & MediaObject.SUPPORT_CROP) != 0;
 172         boolean supportTrim = (supported & MediaObject.SUPPORT_TRIM) != 0;
 173         boolean supportMute = (supported & MediaObject.SUPPORT_MUTE) != 0;
 174         boolean supportShare = (supported & MediaObject.SUPPORT_SHARE) != 0;
 175         boolean supportSetAs = (supported & MediaObject.SUPPORT_SETAS) != 0;
 176         boolean supportShowOnMap = (supported & MediaObject.SUPPORT_SHOW_ON_MAP) != 0;
 177         boolean supportCache = (supported & MediaObject.SUPPORT_CACHE) != 0;
 178         boolean supportEdit = (supported & MediaObject.SUPPORT_EDIT) != 0;
 179         boolean supportInfo = (supported & MediaObject.SUPPORT_INFO) != 0;
 180         boolean supportPrint = (supported & MediaObject.SUPPORT_PRINT) != 0;
 181         supportPrint &= PrintHelper.systemSupportsPrint();
 182
 183         setMenuItemVisible(menu, R.id.action_delete, supportDelete);
 184         setMenuItemVisible(menu, R.id.action_rotate_ccw, supportRotate);
 185         setMenuItemVisible(menu, R.id.action_rotate_cw, supportRotate);
 186         setMenuItemVisible(menu, R.id.action_crop, supportCrop);
 187         setMenuItemVisible(menu, R.id.action_trim, supportTrim);
 188         setMenuItemVisible(menu, R.id.action_mute, supportMute);
 189         // Hide panorama until call to updateMenuForPanorama corrects it
 190         setMenuItemVisible(menu, R.id.action_share_panorama, false);
 191         setMenuItemVisible(menu, R.id.action_share, supportShare);
 192         setMenuItemVisible(menu, R.id.action_setas, supportSetAs);
 193         setMenuItemVisible(menu, R.id.action_show_on_map, supportShowOnMap);
 194         setMenuItemVisible(menu, R.id.action_edit, supportEdit);
 195         // setMenuItemVisible(menu, R.id.action_simple_edit, supportEdit);
 196         setMenuItemVisible(menu, R.id.action_details, supportInfo);
 197         setMenuItemVisible(menu, R.id.print, supportPrint);
 198     }
 199
 200     public static void updateMenuForPanorama(Menu menu, boolean shareAsPanorama360,
 201             boolean disablePanorama360Options) {
 202         setMenuItemVisible(menu, R.id.action_share_panorama, shareAsPanorama360);
 203         if (disablePanorama360Options) {
 204             setMenuItemVisible(menu, R.id.action_rotate_ccw, false);
 205             setMenuItemVisible(menu, R.id.action_rotate_cw, false);
 206         }
 207     }
 208
 209     private static void setMenuItemVisible(Menu menu, int itemId, boolean visible) {
 210         MenuItem item = menu.findItem(itemId);
 211         if (item != null) item.setVisible(visible);
 212     }
 213
 214     private Path getSingleSelectedPath() {
 215         ArrayList<Path> ids = mSelectionManager.getSelected(true);
 216         Utils.assertTrue(ids.size() == 1);
 217         return ids.get(0);
 218     }
 219
 220     private Intent getIntentBySingleSelectedPath(String action) {
 221         DataManager manager = mActivity.getDataManager();
 222         Path path = getSingleSelectedPath();
 223         String mimeType = getMimeType(manager.getMediaType(path));
 224         return new Intent(action).setDataAndType(manager.getContentUri(path), mimeType);
 225     }
 226
 227     private void onMenuClicked(int action, ProgressListener listener) {
 228         onMenuClicked(action, listener, false, true);
 229     }
 230
 231     public void onMenuClicked(int action, ProgressListener listener,
 232             boolean waitOnStop, boolean showDialog) {
 233         int title;
 234         switch (action) {
 235             case R.id.action_select_all:
 236                 if (mSelectionManager.inSelectAllMode()) {
 237                     mSelectionManager.deSelectAll();
 238                 } else {
 239                     mSelectionManager.selectAll();
 240                 }
 241                 return;
 242             case R.id.action_crop: {
 243                 Intent intent = getIntentBySingleSelectedPath(CropActivity.CROP_ACTION);
 244                 ((Activity) mActivity).startActivity(intent);
 245                 return;
 246             }
 247             case R.id.action_edit: {
 248                 Intent intent = getIntentBySingleSelectedPath(Intent.ACTION_EDIT)
 249                         .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
 250                 ((Activity) mActivity).startActivity(Intent.createChooser(intent, null));
 251                 return;
 252             }
 253             case R.id.action_setas: {
 254                 Intent intent = getIntentBySingleSelectedPath(Intent.ACTION_ATTACH_DATA)
 255                         .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
 256                 intent.putExtra("mimeType", intent.getType());
 257                 Activity activity = mActivity;
 258                 activity.startActivity(Intent.createChooser(
 259                         intent, activity.getString(R.string.set_as)));
 260                 return;
 261             }
 262             case R.id.action_delete:
 263                 title = R.string.delete;
 264                 break;
 265             case R.id.action_rotate_cw:
 266                 title = R.string.rotate_right;
 267                 break;
 268             case R.id.action_rotate_ccw:
 269                 title = R.string.rotate_left;
 270                 break;
 271             case R.id.action_show_on_map:
 272                 title = R.string.show_on_map;
 273                 break;
 274             default:
 275                 return;
 276         }
 277         startAction(action, title, listener, waitOnStop, showDialog);
 278     }
 279
 280     private class ConfirmDialogListener implements OnClickListener, OnCancelListener {
 281         private final int mActionId;
 282         private final ProgressListener mListener;
 283
 284         public ConfirmDialogListener(int actionId, ProgressListener listener) {
 285             mActionId = actionId;
 286             mListener = listener;
 287         }
 288
 289         @Override
 290         public void onClick(DialogInterface dialog, int which) {
 291             if (which == DialogInterface.BUTTON_POSITIVE) {
 292                 if (mListener != null) {
 293                     mListener.onConfirmDialogDismissed(true);
 294                 }
 295                 onMenuClicked(mActionId, mListener);
 296             } else {
 297                 if (mListener != null) {
 298                     mListener.onConfirmDialogDismissed(false);
 299                 }
 300             }
 301         }
 302
 303         @Override
 304         public void onCancel(DialogInterface dialog) {
 305             if (mListener != null) {
 306                 mListener.onConfirmDialogDismissed(false);
 307             }
 308         }
 309     }
 310
 311     public void onMenuClicked(MenuItem menuItem, String confirmMsg,
 312             final ProgressListener listener) {
 313         final int action = menuItem.getItemId();
 314
 315         if (confirmMsg != null) {
 316             if (listener != null) listener.onConfirmDialogShown();
 317             ConfirmDialogListener cdl = new ConfirmDialogListener(action, listener);
 318             new AlertDialog.Builder(mActivity.getAndroidContext())
 319                     .setMessage(confirmMsg)
 320                     .setOnCancelListener(cdl)
 321                     .setPositiveButton(R.string.ok, cdl)
 322                     .setNegativeButton(R.string.cancel, cdl)
 323                     .create().show();
 324         } else {
 325             onMenuClicked(action, listener);
 326         }
 327     }
 328
 329     public void startAction(int action, int title, ProgressListener listener) {
 330         startAction(action, title, listener, false, true);
 331     }
 332
 333     public void startAction(int action, int title, ProgressListener listener,
 334             boolean waitOnStop, boolean showDialog) {
 335         ArrayList<Path> ids = mSelectionManager.getSelected(false);
 336         stopTaskAndDismissDialog();
 337
 338         Activity activity = mActivity;
 339         if (showDialog) {
 340             mDialog = createProgressDialog(activity, title, ids.size());
 341             mDialog.show();
 342         } else {
 343             mDialog = null;
 344         }
 345         MediaOperation operation = new MediaOperation(action, ids, listener);
 346         mTask = mActivity.getBatchServiceThreadPoolIfAvailable().submit(operation, null);
 347         mWaitOnStop = waitOnStop;
 348     }
 349
 350     public void startSingleItemAction(int action, Path targetPath) {
 351         ArrayList<Path> ids = new ArrayList<Path>(1);
 352         ids.add(targetPath);
 353         mDialog = null;
 354         MediaOperation operation = new MediaOperation(action, ids, null);
 355         mTask = mActivity.getBatchServiceThreadPoolIfAvailable().submit(operation, null);
 356         mWaitOnStop = false;
 357     }
 358
 359     public static String getMimeType(int type) {
 360         switch (type) {
 361             case MediaObject.MEDIA_TYPE_IMAGE :
 362                 return GalleryUtils.MIME_TYPE_IMAGE;
 363             case MediaObject.MEDIA_TYPE_VIDEO :
 364                 return GalleryUtils.MIME_TYPE_VIDEO;
 365             default: return GalleryUtils.MIME_TYPE_ALL;
 366         }
 367     }
 368
 369     private boolean execute(
 370             DataManager manager, JobContext jc, int cmd, Path path) {
 371         boolean result = true;
 372         Log.v(TAG, "Execute cmd: " + cmd + " for " + path);
 373         long startTime = System.currentTimeMillis();
 374
 375         switch (cmd) {
 376             case R.id.action_delete:
 377                 manager.delete(path);
 378                 break;
 379             case R.id.action_rotate_cw:
 380                 manager.rotate(path, 90);
 381                 break;
 382             case R.id.action_rotate_ccw:
 383                 manager.rotate(path, -90);
 384                 break;
 385             case R.id.action_toggle_full_caching: {
 386                 MediaObject obj = manager.getMediaObject(path);
 387                 int cacheFlag = obj.getCacheFlag();
 388                 if (cacheFlag == MediaObject.CACHE_FLAG_FULL) {
 389                     cacheFlag = MediaObject.CACHE_FLAG_SCREENNAIL;
 390                 } else {
 391                     cacheFlag = MediaObject.CACHE_FLAG_FULL;
 392                 }
 393                 obj.cache(cacheFlag);
 394                 break;
 395             }
 396             case R.id.action_show_on_map: {
 397                 MediaItem item = (MediaItem) manager.getMediaObject(path);
 398                 double latlng[] = new double[2];
 399                 item.getLatLong(latlng);
 400                 if (GalleryUtils.isValidLocation(latlng[0], latlng[1])) {
 401                     GalleryUtils.showOnMap(mActivity, latlng[0], latlng[1]);
 402                 }
 403                 break;
 404             }
 405             default:
 406                 throw new AssertionError();
 407         }
 408         Log.v(TAG, "It takes " + (System.currentTimeMillis() - startTime) +
 409                 " ms to execute cmd for " + path);
 410         return result;
 411     }
 412
 413     private class MediaOperation implements Job<Void> {
 414         private final ArrayList<Path> mItems;
 415         private final int mOperation;
 416         private final ProgressListener mListener;
 417
 418         public MediaOperation(int operation, ArrayList<Path> items,
 419                 ProgressListener listener) {
 420             mOperation = operation;
 421             mItems = items;
 422             mListener = listener;
 423         }
 424
 425         @Override
 426         public Void run(JobContext jc) {
 427             int index = 0;
 428             DataManager manager = mActivity.getDataManager();
 429             int result = EXECUTION_RESULT_SUCCESS;
 430             try {
 431                 onProgressStart(mListener);
 432                 for (Path id : mItems) {
 433                     if (jc.isCancelled()) {
 434                         result = EXECUTION_RESULT_CANCEL;
 435                         break;
 436                     }
 437                     if (!execute(manager, jc, mOperation, id)) {
 438                         result = EXECUTION_RESULT_FAIL;
 439                     }
 440                     onProgressUpdate(index++, mListener);
 441                 }
 442             } catch (Throwable th) {
 443                 Log.e(TAG, "failed to execute operation " + mOperation
 444                         + " : " + th);
 445             } finally {
 446                onProgressComplete(result, mListener);
 447             }
 448             return null;
 449         }
 450     }
 451 }