blob: d90fc20d0b84c8c1a9720b1f2f11ed21f54ec97c [file] [log] [blame]
/*
* 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.content.Intent;
import android.net.Uri;
import android.nfc.NfcAdapter;
import android.os.Handler;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
import com.actionbarsherlock.app.SherlockActivity;
import com.actionbarsherlock.view.ActionMode;
import com.actionbarsherlock.view.ActionMode.Callback;
import com.actionbarsherlock.view.Menu;
import com.actionbarsherlock.view.MenuItem;
import com.actionbarsherlock.widget.ShareActionProvider;
import com.actionbarsherlock.widget.ShareActionProvider.OnShareTargetSelectedListener;
import com.android.gallery3d.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.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 SUPPORT_MULTIPLE_MASK = MediaObject.SUPPORT_DELETE
| MediaObject.SUPPORT_ROTATE | MediaObject.SUPPORT_SHARE
| MediaObject.SUPPORT_CACHE | MediaObject.SUPPORT_IMPORT;
public interface ActionModeListener {
public boolean onActionItemClicked(MenuItem item);
}
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 ShareActionProvider mSharePanoramaActionProvider;
private ShareActionProvider mShareActionProvider;
private SelectionMenu mSelectionMenu;
private ActionModeListener mListener;
private Future<?> mMenuTask;
private final Handler mMainHandler;
private ActionMode mActionMode;
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());
}
public void startActionMode() {
SherlockActivity a = mActivity;
mActionMode = a.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_import) {
listener = new ImportCompleteListener(mActivity);
} else 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;
}
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);
}
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));
// For clients who call SelectionManager.selectAll() directly, we need to ensure the
// menu status is consistent with selection manager.
mSelectionMenu.updateSelectAllMode(mSelectionManager.inSelectAllMode());
}
private final OnShareTargetSelectedListener mShareTargetSelectedListener =
new OnShareTargetSelectedListener() {
@Override
public boolean onShareTargetSelected(ShareActionProvider source, Intent intent) {
mSelectionManager.leaveSelectionMode();
return false;
}
};
@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);
mMenu = menu;
mSharePanoramaMenuItem = menu.findItem(R.id.action_share_panorama);
if (mSharePanoramaMenuItem != null) {
mSharePanoramaActionProvider = (ShareActionProvider) mSharePanoramaMenuItem
.getActionProvider();
mSharePanoramaActionProvider.setOnShareTargetSelectedListener(
mShareTargetSelectedListener);
mSharePanoramaActionProvider.setShareHistoryFileName("panorama_share_history.xml");
}
mShareMenuItem = menu.findItem(R.id.action_share);
if (mShareMenuItem != null) {
mShareActionProvider = (ShareActionProvider) mShareMenuItem
.getActionProvider();
mShareActionProvider.setOnShareTargetSelectedListener(
mShareTargetSelectedListener);
mShareActionProvider.setShareHistoryFileName("share_history.xml");
}
return true;
}
@Override
public void onDestroyActionMode(ActionMode mode) {
mSelectionManager.leaveSelectionMode();
}
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()) {
return null;
}
selected.add(manager.getMediaObject(path));
}
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 &= SUPPORT_MULTIPLE_MASK;
}
return operation;
}
@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) {
ArrayList<Path> expandedPaths = mSelectionManager.getSelected(true);
if (expandedPaths.size() == 0) {
return null;
}
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;
uris.add(manager.getContentUri(path));
}
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) {
ArrayList<Path> expandedPaths = mSelectionManager.getSelected(true);
if (expandedPaths.size() == 0) {
setNfcBeamPushUris(null);
return null;
}
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) {
uris.add(manager.getContentUri(path));
}
}
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);
// 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) {
// 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;
}
final GetAllPanoramaSupports supportCallback = new GetAllPanoramaSupports(selected,
jc);
// Pass2: Deal with expanded media object list for sharing operation.
final Intent share_panorama_intent = computePanoramaSharingIntent(jc);
final Intent share_intent = computeSharingIntent(jc);
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, supportCallback.mAllPanorama360,
supportCallback.mHasPanorama360);
if (mSharePanoramaMenuItem != null) {
mSharePanoramaMenuItem.setEnabled(true);
if (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));
}
mSharePanoramaActionProvider.setShareIntent(share_panorama_intent);
}
if (mShareMenuItem != null) {
mShareMenuItem.setEnabled(true);
mShareActionProvider.setShareIntent(share_intent);
}
}
});
return null;
}
});
}
public void pause() {
if (mMenuTask != null) {
mMenuTask.cancel();
mMenuTask = null;
}
mMenuExecutor.pause();
}
public void destroy() {
mMenuExecutor.destroy();
}
public void resume() {
if (mSelectionManager.inSelectionMode()) updateSupportedOperation();
mMenuExecutor.resume();
}
}