src/com/android/gallery3d/ui/ActionModeHandler.java - LeafOS-Project/android_packages_apps_Gallery2 - Gitiles

 /*
  * Copyright (C) 2010 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.gallery3d.ui;

 import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.Intent;
 import android.net.Uri;
 import android.nfc.NfcAdapter;
 import android.os.Handler;
 import android.view.ActionMode;
 import android.view.ActionMode.Callback;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
 import android.widget.Button;
 import android.widget.Toolbar;

 import org.codeaurora.gallery.R;
 import com.android.gallery3d.app.AbstractGalleryActivity;
 import com.android.gallery3d.common.ApiHelper;
 import com.android.gallery3d.common.Utils;
 import com.android.gallery3d.data.DataManager;
 import com.android.gallery3d.data.MediaObject;
 import com.android.gallery3d.data.MediaObject.PanoramaSupportCallback;
 import com.android.gallery3d.data.MediaSet;
 import com.android.gallery3d.data.Path;
 import com.android.gallery3d.ui.MenuExecutor.ProgressListener;
 import com.android.gallery3d.util.Future;
 import com.android.gallery3d.util.GalleryUtils;
 import com.android.gallery3d.util.ThreadPool.Job;
 import com.android.gallery3d.util.ThreadPool.JobContext;

 import java.util.ArrayList;

 public class ActionModeHandler implements Callback, PopupList.OnPopupItemClickListener {

     @SuppressWarnings("unused")
     private static final String TAG = "ActionModeHandler";

     private static final int MAX_SELECTED_ITEMS_FOR_SHARE_INTENT = 300;
     private static final int MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT = 10;

     private static final int SUPPORT_MULTIPLE_MASK = MediaObject.SUPPORT_DELETE
             | MediaObject.SUPPORT_ROTATE | MediaObject.SUPPORT_SHARE
             | MediaObject.SUPPORT_CACHE;

     public interface ActionModeListener {
         public boolean onActionItemClicked(MenuItem item);
     }

     public static boolean isThreadComplete = false;

     private final AbstractGalleryActivity mActivity;
     private final MenuExecutor mMenuExecutor;
     private final SelectionManager mSelectionManager;
     private final NfcAdapter mNfcAdapter;
     private Menu mMenu;
     private MenuItem mSharePanoramaMenuItem;
     private MenuItem mShareMenuItem;
     private SelectionMenu mSelectionMenu;
     private ActionModeListener mListener;
     private Future<?> mMenuTask;
     private final Handler mMainHandler;
     private ActionMode mActionMode;
     private boolean mShareMaxDialog = false;
     private Toolbar mToolbar;
     private Intent mShareIntent;
     private Intent mSharePanoramaIntent;

     private static class GetAllPanoramaSupports implements PanoramaSupportCallback {
         private int mNumInfoRequired;
         private JobContext mJobContext;
         public boolean mAllPanoramas = true;
         public boolean mAllPanorama360 = true;
         public boolean mHasPanorama360 = false;
         private Object mLock = new Object();

         public GetAllPanoramaSupports(ArrayList<MediaObject> mediaObjects, JobContext jc) {
             mJobContext = jc;
             mNumInfoRequired = mediaObjects.size();
             for (MediaObject mediaObject : mediaObjects) {
                 mediaObject.getPanoramaSupport(this);
             }
         }

         @Override
         public void panoramaInfoAvailable(MediaObject mediaObject, boolean isPanorama,
                 boolean isPanorama360) {
             synchronized (mLock) {
                 mNumInfoRequired--;
                 mAllPanoramas = isPanorama && mAllPanoramas;
                 mAllPanorama360 = isPanorama360 && mAllPanorama360;
                 mHasPanorama360 = mHasPanorama360 || isPanorama360;
                 if (mNumInfoRequired == 0 || mJobContext.isCancelled()) {
                     mLock.notifyAll();
                 }
             }
         }

         public void waitForPanoramaSupport() {
             synchronized (mLock) {
                 while (mNumInfoRequired != 0 && !mJobContext.isCancelled()) {
                     try {
                         mLock.wait();
                     } catch (InterruptedException e) {
                         // May be a cancelled job context
                     }
                 }
             }
         }
     }

     public ActionModeHandler(
             AbstractGalleryActivity activity, SelectionManager selectionManager) {
         mActivity = Utils.checkNotNull(activity);
         mSelectionManager = Utils.checkNotNull(selectionManager);
         mMenuExecutor = new MenuExecutor(activity, selectionManager);
         mMainHandler = new Handler(activity.getMainLooper());
         mNfcAdapter = NfcAdapter.getDefaultAdapter(mActivity.getAndroidContext());
         mToolbar = mActivity.getToolbar();
     }

     public void startActionMode() {
         mMenuExecutor.setLeaving(false);
         Activity a = mActivity;
 //      mActionMode = a.startActionMode(this);
         mActionMode = mActivity.getToolbar().startActionMode(this);
         View customView = LayoutInflater.from(a).inflate(
                 R.layout.action_mode, null);
         mActionMode.setCustomView(customView);
         mSelectionMenu = new SelectionMenu(a,
                 (Button) customView.findViewById(R.id.selection_menu), this);
         updateSelectionMenu();
     }

     public void finishActionMode() {
         mActionMode.finish();
     }

     public void setTitle(String title) {
         mSelectionMenu.setTitle(title);
     }

     public void setActionModeListener(ActionModeListener listener) {
         mListener = listener;
     }

     private WakeLockHoldingProgressListener mDeleteProgressListener;

     @Override
     public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
         GLRoot root = mActivity.getGLRoot();
         root.lockRenderThread();
         try {
             boolean result;
             // Give listener a chance to process this command before it's routed to
             // ActionModeHandler, which handles command only based on the action id.
             // Sometimes the listener may have more background information to handle
             // an action command.
             if (mListener != null) {
                 result = mListener.onActionItemClicked(item);
                 if (result) {
                     mSelectionManager.leaveSelectionMode();
                     return result;
                 }
             }
             ProgressListener listener = null;
             String confirmMsg = null;
             int action = item.getItemId();
             if (action == R.id.action_delete) {
                 confirmMsg = mActivity.getResources().getQuantityString(
                         R.plurals.delete_selection, mSelectionManager.getSelectedCount());
                 if (mDeleteProgressListener == null) {
                     mDeleteProgressListener = new WakeLockHoldingProgressListener(mActivity,
                             "Gallery Delete Progress Listener");
                 }
                 listener = mDeleteProgressListener;
             } else if (action == R.id.action_share) {
                 String shareTitle = mActivity.getResources().
                         getString(R.string.share_dialogue_title);
                 mActivity.startActivity(Intent.createChooser(
                         mShareIntent, shareTitle));
                 return true;
             }
             mMenuExecutor.onMenuClicked(item, confirmMsg, listener);
         } finally {
             root.unlockRenderThread();
         }
         return true;
     }

     @Override
     public boolean onPopupItemClick(int itemId) {
         GLRoot root = mActivity.getGLRoot();
         root.lockRenderThread();
         try {
             if (itemId == R.id.action_select_all) {
                 updateSupportedOperation();
                 mMenuExecutor.onMenuClicked(itemId, null, false, true);
                 mSelectionMenu.setLeaving(mMenuExecutor.isLeaving());
             }
             return true;
         } finally {
             root.unlockRenderThread();
         }
     }

     private void updateSelectionMenu() {
         // update title
         int count = mSelectionManager.getSelectedCount();
         String format = mActivity.getResources().getQuantityString(
                 R.plurals.number_of_items_selected, count);
         setTitle(String.format(format, count));
         if (count == 0) {
             mShareMaxDialog = false;
         }

         // For clients who call SelectionManager.selectAll() directly, we need to ensure the
         // menu status is consistent with selection manager.
         mSelectionMenu.updateSelectAllMode(mSelectionManager.inSelectAllMode());
     }

     @Override
     public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
         return false;
     }

     @Override
     public boolean onCreateActionMode(ActionMode mode, Menu menu) {
         mode.getMenuInflater().inflate(R.menu.operation, menu);
         mActivity.getToolbar().setVisibility(View.INVISIBLE);

         mMenu = menu;
         mSharePanoramaMenuItem = menu.findItem(R.id.action_share_panorama);
         if (mSharePanoramaMenuItem != null) {
             mSharePanoramaMenuItem.setOnMenuItemClickListener(
                     new MenuItem.OnMenuItemClickListener() {
                 @Override
                 public boolean onMenuItemClick(MenuItem item) {
                     mSelectionManager.leaveSelectionMode();
                     if (mSharePanoramaIntent != null) {
                         Intent intent = Intent.createChooser(mSharePanoramaIntent, null);
                         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                         mActivity.startActivity(intent);
                     }
                     return true;
                 }
             });
         }
         mShareMenuItem = menu.findItem(R.id.action_share);
         return true;
     }

     @Override
     public void onDestroyActionMode(ActionMode mode) {
         mSelectionManager.leaveSelectionMode();
         mActivity.getToolbar().setVisibility(View.VISIBLE);

     }

     private ArrayList<MediaObject> getSelectedMediaObjects(JobContext jc) {
         ArrayList<Path> unexpandedPaths = mSelectionManager.getSelected(false);
         if (unexpandedPaths.isEmpty()) {
             // This happens when starting selection mode from overflow menu
             // (instead of long press a media object)
             return null;
         }
         ArrayList<MediaObject> selected = new ArrayList<MediaObject>();
         DataManager manager = mActivity.getDataManager();
         for (Path path : unexpandedPaths) {
             if (jc.isCancelled() || !mSelectionManager.inSelectionMode()) {
                 return null;
             }
             MediaObject mediaObject = manager.getMediaObject(path);
             if (mediaObject != null && mediaObject.isSelectable()) {
                 selected.add(mediaObject);
             }
         }
         return selected;
     }

     // Menu options are determined by selection set itself.
     // We cannot expand it because MenuExecuter executes it based on
     // the selection set instead of the expanded result.
     // e.g. LocalImage can be rotated but collections of them (LocalAlbum) can't.
     private int computeMenuOptions(ArrayList<MediaObject> selected) {
         int operation = MediaObject.SUPPORT_ALL;
         int type = 0;
         for (MediaObject mediaObject: selected) {
             int support = mediaObject.getSupportedOperations();
             type |= mediaObject.getMediaType();
             operation &= support;
         }

         switch (selected.size()) {
             case 1:
                 final String mimeType = MenuExecutor.getMimeType(type);
                 if (!GalleryUtils.isEditorAvailable(mActivity, mimeType)) {
                     operation &= ~MediaObject.SUPPORT_EDIT;
                 }
                 break;
             default:
                 operation = computeMenuOptionsMultiple(operation, selected.size());
         }
         return operation;
     }

     private int computeMenuOptionsMultiple(int operationBefore, int selectedSize) {
         int operation = operationBefore;
         if (selectedSize > 1) {
             operation &= SUPPORT_MULTIPLE_MASK;
         }
         return operation;
     }

     private boolean computeCanShare(ArrayList<MediaObject> selected, int max) {
         int numSelected = selected.size();
         boolean ret = computeCanShare(numSelected, max);
         if (!ret) return false;

         numSelected = 0;
         for (MediaObject mediaObject : selected) {
             if (mediaObject instanceof MediaSet) {
                 numSelected = numSelected + ((MediaSet) mediaObject).getTotalMediaItemCount();
             } else {
                 numSelected = numSelected + 1;
             }
             ret = computeCanShare(numSelected, max);
             if (!ret) return false;
         }
         return true;
     }

     private boolean computeCanShare(int size, int max) {
         return size <= max;
     }

     @TargetApi(ApiHelper.VERSION_CODES.JELLY_BEAN)
     private void setNfcBeamPushUris(Uri[] uris) {
         if (mNfcAdapter != null && ApiHelper.HAS_SET_BEAM_PUSH_URIS) {
             mNfcAdapter.setBeamPushUrisCallback(null, mActivity);
             mNfcAdapter.setBeamPushUris(uris, mActivity);
         }
     }

     // Share intent needs to expand the selection set so we can get URI of
     // each media item
     private Intent computePanoramaSharingIntent(JobContext jc, int maxItems) {
         ArrayList<Path> expandedPaths = mSelectionManager.getSelected(true, maxItems);
         if (expandedPaths == null || expandedPaths.size() == 0) {
             return new Intent();
         }
         final ArrayList<Uri> uris = new ArrayList<Uri>();
         DataManager manager = mActivity.getDataManager();
         final Intent intent = new Intent();
         for (Path path : expandedPaths) {
             if (jc.isCancelled()) return null;
             Uri uri = manager.getContentUri(path);
             if (uri != null) {
                 uris.add(uri);
             }
         }

         final int size = uris.size();
         if (size > 0) {
             if (size > 1) {
                 intent.setAction(Intent.ACTION_SEND_MULTIPLE);
                 intent.setType(GalleryUtils.MIME_TYPE_PANORAMA360);
                 intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
             } else {
                 intent.setAction(Intent.ACTION_SEND);
                 intent.setType(GalleryUtils.MIME_TYPE_PANORAMA360);
                 intent.putExtra(Intent.EXTRA_STREAM, uris.get(0));
             }
             intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
         }

         return intent;
     }

     private Intent computeSharingIntent(JobContext jc, int maxItems) {
         ArrayList<Path> expandedPaths = mSelectionManager.getSelected(true, maxItems);
         if (expandedPaths == null || expandedPaths.size() == 0) {
             setNfcBeamPushUris(null);
             return new Intent();
         }
         final ArrayList<Uri> uris = new ArrayList<Uri>();
         DataManager manager = mActivity.getDataManager();
         int type = 0;
         final Intent intent = new Intent();
         for (Path path : expandedPaths) {
             if (jc.isCancelled()) return null;
             int support = manager.getSupportedOperations(path);
             type |= manager.getMediaType(path);

             if ((support & MediaObject.SUPPORT_SHARE) != 0) {
                 Uri uri = manager.getContentUri(path);
                 if (uri != null) {
                     uris.add(uri);
                 }
             }
         }

         final int size = uris.size();
         if (size > 0) {
             final String mimeType = MenuExecutor.getMimeType(type);
             if (size > 1) {
                 intent.setAction(Intent.ACTION_SEND_MULTIPLE).setType(mimeType);
                 intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
             } else {
                 intent.setAction(Intent.ACTION_SEND).setType(mimeType);
                 intent.putExtra(Intent.EXTRA_STREAM, uris.get(0));
             }
             intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
             setNfcBeamPushUris(uris.toArray(new Uri[uris.size()]));
         } else {
             setNfcBeamPushUris(null);
         }

         return intent;
     }

     public void updateSupportedOperation(Path path, boolean selected) {
         // TODO: We need to improve the performance
         updateSupportedOperation();
     }

     public void updateSupportedOperation() {
         // Interrupt previous unfinished task, mMenuTask is only accessed in main thread
         if (mMenuTask != null) mMenuTask.cancel();

         updateSelectionMenu();

         // Disable share actions until share intent is in good shape
         if (mSharePanoramaMenuItem != null) mSharePanoramaMenuItem.setEnabled(false);
         if (mShareMenuItem != null) mShareMenuItem.setEnabled(false);
         isThreadComplete = false;

         // Generate sharing intent and update supported operations in the background
         // The task can take a long time and be canceled in the mean time.
         mMenuTask = mActivity.getThreadPool().submit(new Job<Void>() {
             @Override
             public Void run(final JobContext jc) {
                 // use selected count to disable menu options and share items if need
                 // to enhance performance.
                 int multipleOperation = SUPPORT_MULTIPLE_MASK;
                 int count = mSelectionManager.getSelectedCount();
                 final int operationPre = computeMenuOptionsMultiple(multipleOperation, count);
                 final boolean canSharePanoramasPre = computeCanShare(count,
                         MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT);
                 final boolean canSharePre = computeCanShare(count,
                         MAX_SELECTED_ITEMS_FOR_SHARE_INTENT);

                 mMainHandler.post(new Runnable() {
                     @Override
                     public void run() {
                         if (jc.isCancelled()) return;
                         MenuExecutor.updateMenuOperation(mMenu, operationPre);
                         if (mShareMenuItem != null && !canSharePre) {
                             mShareMenuItem.setEnabled(false);
                             showShareMaxDialogIfNeed(false);
                         }
                     }
                 });

                 // Pass1: Deal with unexpanded media object list for menu operation.
                 ArrayList<MediaObject> selected = getSelectedMediaObjects(jc);
                 if (selected == null) {
                     mMainHandler.post(new Runnable() {
                         @Override
                         public void run() {
                             mMenuTask = null;
                             if (jc.isCancelled()) return;
                             // Disable all the operations when no item is selected
                             MenuExecutor.updateMenuOperation(mMenu, 0);
                         }
                     });
                     return null;
                 }
                 final int operation = computeMenuOptions(selected);
                 if (jc.isCancelled()) {
                     return null;
                 }

                 // use selected items to compute menu options and share items again.
                 final boolean canShare = canSharePre
                         && computeCanShare(selected, MAX_SELECTED_ITEMS_FOR_SHARE_INTENT);
                 final boolean canSharePanoramas = canSharePanoramasPre
                         && computeCanShare(selected, MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT);

                 final GetAllPanoramaSupports supportCallback = canSharePanoramas ?
                         new GetAllPanoramaSupports(selected, jc)
                         : null;

                 // Pass2: Deal with expanded media object list for sharing operation.
                 final Intent share_panorama_intent = canSharePanoramas ?
                         computePanoramaSharingIntent(jc, MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT)
                         : new Intent();
                 final Intent share_intent = canShare ?
                         computeSharingIntent(jc, MAX_SELECTED_ITEMS_FOR_SHARE_INTENT)
                         : new Intent();

                 if (canSharePanoramas) {
                     supportCallback.waitForPanoramaSupport();
                 }
                 if (jc.isCancelled()) {
                     return null;
                 }
                 mMainHandler.post(new Runnable() {
                     @Override
                     public void run() {
                         mMenuTask = null;
                         if (jc.isCancelled()) return;
                         MenuExecutor.updateMenuOperation(mMenu, operation);
                         MenuExecutor.updateMenuForPanorama(mMenu,
                                 canSharePanoramas && supportCallback.mAllPanorama360,
                                 canSharePanoramas && supportCallback.mHasPanorama360);
                         if (mSharePanoramaMenuItem != null) {
                             mSharePanoramaMenuItem.setEnabled(true);
                             if (canSharePanoramas && supportCallback.mAllPanorama360) {
                                 mShareMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
                                 mShareMenuItem.setTitle(
                                     mActivity.getResources().getString(R.string.share_as_photo));
                             } else {
                                 mSharePanoramaMenuItem.setVisible(false);
                                 mShareMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
                                 mShareMenuItem.setTitle(
                                     mActivity.getResources().getString(R.string.share));
                             }
                             mSharePanoramaIntent = share_panorama_intent;
                         }
                         if (mShareMenuItem != null) {
                             showShareMaxDialogIfNeed(canShare);

                             mShareMenuItem.setEnabled(canShare);
                             isThreadComplete = true;
                             mShareIntent = share_intent;
                         }
                     }
                 });
                 return null;
             }
         });
     }

     private void showShareMaxDialogIfNeed(boolean canShare) {
         if (!canShare && !mShareMaxDialog) {
             AlertDialog.Builder shareMaxDialog = new AlertDialog.Builder(mActivity);
             shareMaxDialog
                     .setMessage(R.string.cannot_share_items)
                     .setPositiveButton(R.string.ok, null)
                     .create();
             shareMaxDialog.show();
             mShareMaxDialog = true;
         }
         if (canShare && mShareMaxDialog) {
             mShareMaxDialog = false;
         }
     }

     public void pause() {
         if (mMenuTask != null) {
             mMenuTask.cancel();
             mMenuTask = null;
         }
         mMenuExecutor.pause();
     }

     public void destroy() {
         mMenuExecutor.destroy();
     }

     public void resume() {
         if (mSelectionManager.inSelectionMode()) {
             mActivity.getToolbar().setVisibility(View.INVISIBLE);
             updateSupportedOperation();
         }
         mMenuExecutor.resume();
     }
 }
	/*
	* Copyright (C) 2010 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.gallery3d.ui;

	import android.annotation.TargetApi;
	import android.app.Activity;
	import android.app.AlertDialog;
	import android.content.Intent;
	import android.net.Uri;
	import android.nfc.NfcAdapter;
	import android.os.Handler;
	import android.view.ActionMode;
	import android.view.ActionMode.Callback;
	import android.view.LayoutInflater;
	import android.view.Menu;
	import android.view.MenuItem;
	import android.view.View;
	import android.widget.Button;
	import android.widget.Toolbar;

	import org.codeaurora.gallery.R;
	import com.android.gallery3d.app.AbstractGalleryActivity;
	import com.android.gallery3d.common.ApiHelper;
	import com.android.gallery3d.common.Utils;
	import com.android.gallery3d.data.DataManager;
	import com.android.gallery3d.data.MediaObject;
	import com.android.gallery3d.data.MediaObject.PanoramaSupportCallback;
	import com.android.gallery3d.data.MediaSet;
	import com.android.gallery3d.data.Path;
	import com.android.gallery3d.ui.MenuExecutor.ProgressListener;
	import com.android.gallery3d.util.Future;
	import com.android.gallery3d.util.GalleryUtils;
	import com.android.gallery3d.util.ThreadPool.Job;
	import com.android.gallery3d.util.ThreadPool.JobContext;

	import java.util.ArrayList;

	public class ActionModeHandler implements Callback, PopupList.OnPopupItemClickListener {

	@SuppressWarnings("unused")
	private static final String TAG = "ActionModeHandler";

	private static final int MAX_SELECTED_ITEMS_FOR_SHARE_INTENT = 300;
	private static final int MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT = 10;

	private static final int SUPPORT_MULTIPLE_MASK = MediaObject.SUPPORT_DELETE
	\| MediaObject.SUPPORT_ROTATE \| MediaObject.SUPPORT_SHARE
	\| MediaObject.SUPPORT_CACHE;

	public interface ActionModeListener {
	public boolean onActionItemClicked(MenuItem item);
	}

	public static boolean isThreadComplete = false;

	private final AbstractGalleryActivity mActivity;
	private final MenuExecutor mMenuExecutor;
	private final SelectionManager mSelectionManager;
	private final NfcAdapter mNfcAdapter;
	private Menu mMenu;
	private MenuItem mSharePanoramaMenuItem;
	private MenuItem mShareMenuItem;
	private SelectionMenu mSelectionMenu;
	private ActionModeListener mListener;
	private Future<?> mMenuTask;
	private final Handler mMainHandler;
	private ActionMode mActionMode;
	private boolean mShareMaxDialog = false;
	private Toolbar mToolbar;
	private Intent mShareIntent;
	private Intent mSharePanoramaIntent;

	private static class GetAllPanoramaSupports implements PanoramaSupportCallback {
	private int mNumInfoRequired;
	private JobContext mJobContext;
	public boolean mAllPanoramas = true;
	public boolean mAllPanorama360 = true;
	public boolean mHasPanorama360 = false;
	private Object mLock = new Object();

	public GetAllPanoramaSupports(ArrayList<MediaObject> mediaObjects, JobContext jc) {
	mJobContext = jc;
	mNumInfoRequired = mediaObjects.size();
	for (MediaObject mediaObject : mediaObjects) {
	mediaObject.getPanoramaSupport(this);
	}
	}

	@Override
	public void panoramaInfoAvailable(MediaObject mediaObject, boolean isPanorama,
	boolean isPanorama360) {
	synchronized (mLock) {
	mNumInfoRequired--;
	mAllPanoramas = isPanorama && mAllPanoramas;
	mAllPanorama360 = isPanorama360 && mAllPanorama360;
	mHasPanorama360 = mHasPanorama360 \|\| isPanorama360;
	if (mNumInfoRequired == 0 \|\| mJobContext.isCancelled()) {
	mLock.notifyAll();
	}
	}
	}

	public void waitForPanoramaSupport() {
	synchronized (mLock) {
	while (mNumInfoRequired != 0 && !mJobContext.isCancelled()) {
	try {
	mLock.wait();
	} catch (InterruptedException e) {
	// May be a cancelled job context
	}
	}
	}
	}
	}

	public ActionModeHandler(
	AbstractGalleryActivity activity, SelectionManager selectionManager) {
	mActivity = Utils.checkNotNull(activity);
	mSelectionManager = Utils.checkNotNull(selectionManager);
	mMenuExecutor = new MenuExecutor(activity, selectionManager);
	mMainHandler = new Handler(activity.getMainLooper());
	mNfcAdapter = NfcAdapter.getDefaultAdapter(mActivity.getAndroidContext());
	mToolbar = mActivity.getToolbar();
	}

	public void startActionMode() {
	mMenuExecutor.setLeaving(false);
	Activity a = mActivity;
	// mActionMode = a.startActionMode(this);
	mActionMode = mActivity.getToolbar().startActionMode(this);
	View customView = LayoutInflater.from(a).inflate(
	R.layout.action_mode, null);
	mActionMode.setCustomView(customView);
	mSelectionMenu = new SelectionMenu(a,
	(Button) customView.findViewById(R.id.selection_menu), this);
	updateSelectionMenu();
	}

	public void finishActionMode() {
	mActionMode.finish();
	}

	public void setTitle(String title) {
	mSelectionMenu.setTitle(title);
	}

	public void setActionModeListener(ActionModeListener listener) {
	mListener = listener;
	}

	private WakeLockHoldingProgressListener mDeleteProgressListener;

	@Override
	public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
	GLRoot root = mActivity.getGLRoot();
	root.lockRenderThread();
	try {
	boolean result;
	// Give listener a chance to process this command before it's routed to
	// ActionModeHandler, which handles command only based on the action id.
	// Sometimes the listener may have more background information to handle
	// an action command.
	if (mListener != null) {
	result = mListener.onActionItemClicked(item);
	if (result) {
	mSelectionManager.leaveSelectionMode();
	return result;
	}
	}
	ProgressListener listener = null;
	String confirmMsg = null;
	int action = item.getItemId();
	if (action == R.id.action_delete) {
	confirmMsg = mActivity.getResources().getQuantityString(
	R.plurals.delete_selection, mSelectionManager.getSelectedCount());
	if (mDeleteProgressListener == null) {
	mDeleteProgressListener = new WakeLockHoldingProgressListener(mActivity,
	"Gallery Delete Progress Listener");
	}
	listener = mDeleteProgressListener;
	} else if (action == R.id.action_share) {
	String shareTitle = mActivity.getResources().
	getString(R.string.share_dialogue_title);
	mActivity.startActivity(Intent.createChooser(
	mShareIntent, shareTitle));
	return true;
	}
	mMenuExecutor.onMenuClicked(item, confirmMsg, listener);
	} finally {
	root.unlockRenderThread();
	}
	return true;
	}

	@Override
	public boolean onPopupItemClick(int itemId) {
	GLRoot root = mActivity.getGLRoot();
	root.lockRenderThread();
	try {
	if (itemId == R.id.action_select_all) {
	updateSupportedOperation();
	mMenuExecutor.onMenuClicked(itemId, null, false, true);
	mSelectionMenu.setLeaving(mMenuExecutor.isLeaving());
	}
	return true;
	} finally {
	root.unlockRenderThread();
	}
	}

	private void updateSelectionMenu() {
	// update title
	int count = mSelectionManager.getSelectedCount();
	String format = mActivity.getResources().getQuantityString(
	R.plurals.number_of_items_selected, count);
	setTitle(String.format(format, count));
	if (count == 0) {
	mShareMaxDialog = false;
	}

	// For clients who call SelectionManager.selectAll() directly, we need to ensure the
	// menu status is consistent with selection manager.
	mSelectionMenu.updateSelectAllMode(mSelectionManager.inSelectAllMode());
	}

	@Override
	public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
	return false;
	}

	@Override
	public boolean onCreateActionMode(ActionMode mode, Menu menu) {
	mode.getMenuInflater().inflate(R.menu.operation, menu);
	mActivity.getToolbar().setVisibility(View.INVISIBLE);

	mMenu = menu;
	mSharePanoramaMenuItem = menu.findItem(R.id.action_share_panorama);
	if (mSharePanoramaMenuItem != null) {
	mSharePanoramaMenuItem.setOnMenuItemClickListener(
	new MenuItem.OnMenuItemClickListener() {
	@Override
	public boolean onMenuItemClick(MenuItem item) {
	mSelectionManager.leaveSelectionMode();
	if (mSharePanoramaIntent != null) {
	Intent intent = Intent.createChooser(mSharePanoramaIntent, null);
	intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
	mActivity.startActivity(intent);
	}
	return true;
	}
	});
	}
	mShareMenuItem = menu.findItem(R.id.action_share);
	return true;
	}

	@Override
	public void onDestroyActionMode(ActionMode mode) {
	mSelectionManager.leaveSelectionMode();
	mActivity.getToolbar().setVisibility(View.VISIBLE);

	}

	private ArrayList<MediaObject> getSelectedMediaObjects(JobContext jc) {
	ArrayList<Path> unexpandedPaths = mSelectionManager.getSelected(false);
	if (unexpandedPaths.isEmpty()) {
	// This happens when starting selection mode from overflow menu
	// (instead of long press a media object)
	return null;
	}
	ArrayList<MediaObject> selected = new ArrayList<MediaObject>();
	DataManager manager = mActivity.getDataManager();
	for (Path path : unexpandedPaths) {
	if (jc.isCancelled() \|\| !mSelectionManager.inSelectionMode()) {
	return null;
	}
	MediaObject mediaObject = manager.getMediaObject(path);
	if (mediaObject != null && mediaObject.isSelectable()) {
	selected.add(mediaObject);
	}
	}
	return selected;
	}

	// Menu options are determined by selection set itself.
	// We cannot expand it because MenuExecuter executes it based on
	// the selection set instead of the expanded result.
	// e.g. LocalImage can be rotated but collections of them (LocalAlbum) can't.
	private int computeMenuOptions(ArrayList<MediaObject> selected) {
	int operation = MediaObject.SUPPORT_ALL;
	int type = 0;
	for (MediaObject mediaObject: selected) {
	int support = mediaObject.getSupportedOperations();
	type \|= mediaObject.getMediaType();
	operation &= support;
	}

	switch (selected.size()) {
	case 1:
	final String mimeType = MenuExecutor.getMimeType(type);
	if (!GalleryUtils.isEditorAvailable(mActivity, mimeType)) {
	operation &= ~MediaObject.SUPPORT_EDIT;
	}
	break;
	default:
	operation = computeMenuOptionsMultiple(operation, selected.size());
	}
	return operation;
	}

	private int computeMenuOptionsMultiple(int operationBefore, int selectedSize) {
	int operation = operationBefore;
	if (selectedSize > 1) {
	operation &= SUPPORT_MULTIPLE_MASK;
	}
	return operation;
	}

	private boolean computeCanShare(ArrayList<MediaObject> selected, int max) {
	int numSelected = selected.size();
	boolean ret = computeCanShare(numSelected, max);
	if (!ret) return false;

	numSelected = 0;
	for (MediaObject mediaObject : selected) {
	if (mediaObject instanceof MediaSet) {
	numSelected = numSelected + ((MediaSet) mediaObject).getTotalMediaItemCount();
	} else {
	numSelected = numSelected + 1;
	}
	ret = computeCanShare(numSelected, max);
	if (!ret) return false;
	}
	return true;
	}

	private boolean computeCanShare(int size, int max) {
	return size <= max;
	}

	@TargetApi(ApiHelper.VERSION_CODES.JELLY_BEAN)
	private void setNfcBeamPushUris(Uri[] uris) {
	if (mNfcAdapter != null && ApiHelper.HAS_SET_BEAM_PUSH_URIS) {
	mNfcAdapter.setBeamPushUrisCallback(null, mActivity);
	mNfcAdapter.setBeamPushUris(uris, mActivity);
	}
	}

	// Share intent needs to expand the selection set so we can get URI of
	// each media item
	private Intent computePanoramaSharingIntent(JobContext jc, int maxItems) {
	ArrayList<Path> expandedPaths = mSelectionManager.getSelected(true, maxItems);
	if (expandedPaths == null \|\| expandedPaths.size() == 0) {
	return new Intent();
	}
	final ArrayList<Uri> uris = new ArrayList<Uri>();
	DataManager manager = mActivity.getDataManager();
	final Intent intent = new Intent();
	for (Path path : expandedPaths) {
	if (jc.isCancelled()) return null;
	Uri uri = manager.getContentUri(path);
	if (uri != null) {
	uris.add(uri);
	}
	}

	final int size = uris.size();
	if (size > 0) {
	if (size > 1) {
	intent.setAction(Intent.ACTION_SEND_MULTIPLE);
	intent.setType(GalleryUtils.MIME_TYPE_PANORAMA360);
	intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
	} else {
	intent.setAction(Intent.ACTION_SEND);
	intent.setType(GalleryUtils.MIME_TYPE_PANORAMA360);
	intent.putExtra(Intent.EXTRA_STREAM, uris.get(0));
	}
	intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
	}

	return intent;
	}

	private Intent computeSharingIntent(JobContext jc, int maxItems) {
	ArrayList<Path> expandedPaths = mSelectionManager.getSelected(true, maxItems);
	if (expandedPaths == null \|\| expandedPaths.size() == 0) {
	setNfcBeamPushUris(null);
	return new Intent();
	}
	final ArrayList<Uri> uris = new ArrayList<Uri>();
	DataManager manager = mActivity.getDataManager();
	int type = 0;
	final Intent intent = new Intent();
	for (Path path : expandedPaths) {
	if (jc.isCancelled()) return null;
	int support = manager.getSupportedOperations(path);
	type \|= manager.getMediaType(path);

	if ((support & MediaObject.SUPPORT_SHARE) != 0) {
	Uri uri = manager.getContentUri(path);
	if (uri != null) {
	uris.add(uri);
	}
	}
	}

	final int size = uris.size();
	if (size > 0) {
	final String mimeType = MenuExecutor.getMimeType(type);
	if (size > 1) {
	intent.setAction(Intent.ACTION_SEND_MULTIPLE).setType(mimeType);
	intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
	} else {
	intent.setAction(Intent.ACTION_SEND).setType(mimeType);
	intent.putExtra(Intent.EXTRA_STREAM, uris.get(0));
	}
	intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
	setNfcBeamPushUris(uris.toArray(new Uri[uris.size()]));
	} else {
	setNfcBeamPushUris(null);
	}

	return intent;
	}

	public void updateSupportedOperation(Path path, boolean selected) {
	// TODO: We need to improve the performance
	updateSupportedOperation();
	}

	public void updateSupportedOperation() {
	// Interrupt previous unfinished task, mMenuTask is only accessed in main thread
	if (mMenuTask != null) mMenuTask.cancel();

	updateSelectionMenu();

	// Disable share actions until share intent is in good shape
	if (mSharePanoramaMenuItem != null) mSharePanoramaMenuItem.setEnabled(false);
	if (mShareMenuItem != null) mShareMenuItem.setEnabled(false);
	isThreadComplete = false;

	// Generate sharing intent and update supported operations in the background
	// The task can take a long time and be canceled in the mean time.
	mMenuTask = mActivity.getThreadPool().submit(new Job<Void>() {
	@Override
	public Void run(final JobContext jc) {
	// use selected count to disable menu options and share items if need
	// to enhance performance.
	int multipleOperation = SUPPORT_MULTIPLE_MASK;
	int count = mSelectionManager.getSelectedCount();
	final int operationPre = computeMenuOptionsMultiple(multipleOperation, count);
	final boolean canSharePanoramasPre = computeCanShare(count,
	MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT);
	final boolean canSharePre = computeCanShare(count,
	MAX_SELECTED_ITEMS_FOR_SHARE_INTENT);

	mMainHandler.post(new Runnable() {
	@Override
	public void run() {
	if (jc.isCancelled()) return;
	MenuExecutor.updateMenuOperation(mMenu, operationPre);
	if (mShareMenuItem != null && !canSharePre) {
	mShareMenuItem.setEnabled(false);
	showShareMaxDialogIfNeed(false);
	}
	}
	});

	// Pass1: Deal with unexpanded media object list for menu operation.
	ArrayList<MediaObject> selected = getSelectedMediaObjects(jc);
	if (selected == null) {
	mMainHandler.post(new Runnable() {
	@Override
	public void run() {
	mMenuTask = null;
	if (jc.isCancelled()) return;
	// Disable all the operations when no item is selected
	MenuExecutor.updateMenuOperation(mMenu, 0);
	}
	});
	return null;
	}
	final int operation = computeMenuOptions(selected);
	if (jc.isCancelled()) {
	return null;
	}

	// use selected items to compute menu options and share items again.
	final boolean canShare = canSharePre
	&& computeCanShare(selected, MAX_SELECTED_ITEMS_FOR_SHARE_INTENT);
	final boolean canSharePanoramas = canSharePanoramasPre
	&& computeCanShare(selected, MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT);

	final GetAllPanoramaSupports supportCallback = canSharePanoramas ?
	new GetAllPanoramaSupports(selected, jc)
	: null;

	// Pass2: Deal with expanded media object list for sharing operation.
	final Intent share_panorama_intent = canSharePanoramas ?
	computePanoramaSharingIntent(jc, MAX_SELECTED_ITEMS_FOR_PANORAMA_SHARE_INTENT)
	: new Intent();
	final Intent share_intent = canShare ?
	computeSharingIntent(jc, MAX_SELECTED_ITEMS_FOR_SHARE_INTENT)
	: new Intent();

	if (canSharePanoramas) {
	supportCallback.waitForPanoramaSupport();
	}
	if (jc.isCancelled()) {
	return null;
	}
	mMainHandler.post(new Runnable() {
	@Override
	public void run() {
	mMenuTask = null;
	if (jc.isCancelled()) return;
	MenuExecutor.updateMenuOperation(mMenu, operation);
	MenuExecutor.updateMenuForPanorama(mMenu,
	canSharePanoramas && supportCallback.mAllPanorama360,
	canSharePanoramas && supportCallback.mHasPanorama360);
	if (mSharePanoramaMenuItem != null) {
	mSharePanoramaMenuItem.setEnabled(true);
	if (canSharePanoramas && supportCallback.mAllPanorama360) {
	mShareMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
	mShareMenuItem.setTitle(
	mActivity.getResources().getString(R.string.share_as_photo));
	} else {
	mSharePanoramaMenuItem.setVisible(false);
	mShareMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
	mShareMenuItem.setTitle(
	mActivity.getResources().getString(R.string.share));
	}
	mSharePanoramaIntent = share_panorama_intent;
	}
	if (mShareMenuItem != null) {
	showShareMaxDialogIfNeed(canShare);

	mShareMenuItem.setEnabled(canShare);
	isThreadComplete = true;
	mShareIntent = share_intent;
	}
	}
	});
	return null;
	}
	});
	}

	private void showShareMaxDialogIfNeed(boolean canShare) {
	if (!canShare && !mShareMaxDialog) {
	AlertDialog.Builder shareMaxDialog = new AlertDialog.Builder(mActivity);
	shareMaxDialog
	.setMessage(R.string.cannot_share_items)
	.setPositiveButton(R.string.ok, null)
	.create();
	shareMaxDialog.show();
	mShareMaxDialog = true;
	}
	if (canShare && mShareMaxDialog) {
	mShareMaxDialog = false;
	}
	}

	public void pause() {
	if (mMenuTask != null) {
	mMenuTask.cancel();
	mMenuTask = null;
	}
	mMenuExecutor.pause();
	}

	public void destroy() {
	mMenuExecutor.destroy();
	}

	public void resume() {
	if (mSelectionManager.inSelectionMode()) {
	mActivity.getToolbar().setVisibility(View.INVISIBLE);
	updateSupportedOperation();
	}
	mMenuExecutor.resume();
	}
	}