Andras Kloczl
408a54f2e7
Add a new screen ID for the second extra empty page and add that new screen as well when the existing extra empty page is added so that users can put items on both sides of Workspace. Test: manual Bug: 196376162 Change-Id: I0b4f2e818407a10d8a7c032788a7bd7a61267779
541 lines
23 KiB
Java
541 lines
23 KiB
Java
package com.android.launcher3.accessibility;
|
|
|
|
import static android.view.accessibility.AccessibilityNodeInfo.ACTION_LONG_CLICK;
|
|
|
|
import static com.android.launcher3.LauncherState.NORMAL;
|
|
import static com.android.launcher3.anim.AnimatorListeners.forSuccessCallback;
|
|
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.IGNORE;
|
|
|
|
import android.appwidget.AppWidgetProviderInfo;
|
|
import android.graphics.Point;
|
|
import android.graphics.Rect;
|
|
import android.graphics.RectF;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.util.SparseArray;
|
|
import android.view.KeyEvent;
|
|
import android.view.View;
|
|
import android.view.View.AccessibilityDelegate;
|
|
import android.view.accessibility.AccessibilityNodeInfo;
|
|
import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
|
|
|
|
import com.android.launcher3.BubbleTextView;
|
|
import com.android.launcher3.ButtonDropTarget;
|
|
import com.android.launcher3.CellLayout;
|
|
import com.android.launcher3.DropTarget.DragObject;
|
|
import com.android.launcher3.Launcher;
|
|
import com.android.launcher3.LauncherSettings.Favorites;
|
|
import com.android.launcher3.PendingAddItemInfo;
|
|
import com.android.launcher3.R;
|
|
import com.android.launcher3.Workspace;
|
|
import com.android.launcher3.dragndrop.DragController.DragListener;
|
|
import com.android.launcher3.dragndrop.DragOptions;
|
|
import com.android.launcher3.dragndrop.DragView;
|
|
import com.android.launcher3.folder.Folder;
|
|
import com.android.launcher3.keyboard.KeyboardDragAndDropView;
|
|
import com.android.launcher3.model.data.AppInfo;
|
|
import com.android.launcher3.model.data.FolderInfo;
|
|
import com.android.launcher3.model.data.ItemInfo;
|
|
import com.android.launcher3.model.data.LauncherAppWidgetInfo;
|
|
import com.android.launcher3.model.data.WorkspaceItemInfo;
|
|
import com.android.launcher3.notification.NotificationListener;
|
|
import com.android.launcher3.popup.ArrowPopup;
|
|
import com.android.launcher3.popup.PopupContainerWithArrow;
|
|
import com.android.launcher3.touch.ItemLongClickListener;
|
|
import com.android.launcher3.util.IntArray;
|
|
import com.android.launcher3.util.IntSet;
|
|
import com.android.launcher3.util.ShortcutUtil;
|
|
import com.android.launcher3.util.Thunk;
|
|
import com.android.launcher3.views.OptionsPopupView;
|
|
import com.android.launcher3.views.OptionsPopupView.OptionItem;
|
|
import com.android.launcher3.widget.LauncherAppWidgetHostView;
|
|
import com.android.launcher3.widget.util.WidgetSizes;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
|
|
public class LauncherAccessibilityDelegate extends AccessibilityDelegate implements DragListener {
|
|
|
|
private static final String TAG = "LauncherAccessibilityDelegate";
|
|
|
|
public static final int REMOVE = R.id.action_remove;
|
|
public static final int UNINSTALL = R.id.action_uninstall;
|
|
public static final int DISMISS_PREDICTION = R.id.action_dismiss_prediction;
|
|
public static final int PIN_PREDICTION = R.id.action_pin_prediction;
|
|
public static final int RECONFIGURE = R.id.action_reconfigure;
|
|
protected static final int ADD_TO_WORKSPACE = R.id.action_add_to_workspace;
|
|
protected static final int MOVE = R.id.action_move;
|
|
protected static final int MOVE_TO_WORKSPACE = R.id.action_move_to_workspace;
|
|
protected static final int RESIZE = R.id.action_resize;
|
|
public static final int DEEP_SHORTCUTS = R.id.action_deep_shortcuts;
|
|
public static final int SHORTCUTS_AND_NOTIFICATIONS = R.id.action_shortcuts_and_notifications;
|
|
|
|
public enum DragType {
|
|
ICON,
|
|
FOLDER,
|
|
WIDGET
|
|
}
|
|
|
|
public static class DragInfo {
|
|
public DragType dragType;
|
|
public ItemInfo info;
|
|
public View item;
|
|
}
|
|
|
|
protected final SparseArray<LauncherAction> mActions = new SparseArray<>();
|
|
protected final Launcher mLauncher;
|
|
|
|
private DragInfo mDragInfo = null;
|
|
|
|
public LauncherAccessibilityDelegate(Launcher launcher) {
|
|
mLauncher = launcher;
|
|
|
|
mActions.put(REMOVE, new LauncherAction(
|
|
REMOVE, R.string.remove_drop_target_label, KeyEvent.KEYCODE_X));
|
|
mActions.put(UNINSTALL, new LauncherAction(
|
|
UNINSTALL, R.string.uninstall_drop_target_label, KeyEvent.KEYCODE_U));
|
|
mActions.put(DISMISS_PREDICTION, new LauncherAction(DISMISS_PREDICTION,
|
|
R.string.dismiss_prediction_label, KeyEvent.KEYCODE_X));
|
|
mActions.put(RECONFIGURE, new LauncherAction(
|
|
RECONFIGURE, R.string.gadget_setup_text, KeyEvent.KEYCODE_E));
|
|
mActions.put(ADD_TO_WORKSPACE, new LauncherAction(
|
|
ADD_TO_WORKSPACE, R.string.action_add_to_workspace, KeyEvent.KEYCODE_P));
|
|
mActions.put(MOVE, new LauncherAction(
|
|
MOVE, R.string.action_move, KeyEvent.KEYCODE_M));
|
|
mActions.put(MOVE_TO_WORKSPACE, new LauncherAction(MOVE_TO_WORKSPACE,
|
|
R.string.action_move_to_workspace, KeyEvent.KEYCODE_P));
|
|
mActions.put(RESIZE, new LauncherAction(
|
|
RESIZE, R.string.action_resize, KeyEvent.KEYCODE_R));
|
|
mActions.put(DEEP_SHORTCUTS, new LauncherAction(DEEP_SHORTCUTS,
|
|
R.string.action_deep_shortcut, KeyEvent.KEYCODE_S));
|
|
mActions.put(SHORTCUTS_AND_NOTIFICATIONS, new LauncherAction(DEEP_SHORTCUTS,
|
|
R.string.shortcuts_menu_with_notifications_description, KeyEvent.KEYCODE_S));
|
|
}
|
|
|
|
@Override
|
|
public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
|
|
super.onInitializeAccessibilityNodeInfo(host, info);
|
|
if (host.getTag() instanceof ItemInfo) {
|
|
ItemInfo item = (ItemInfo) host.getTag();
|
|
|
|
List<LauncherAction> actions = new ArrayList<>();
|
|
getSupportedActions(host, item, actions);
|
|
actions.forEach(la -> info.addAction(la.accessibilityAction));
|
|
|
|
if (!itemSupportsLongClick(host, item)) {
|
|
info.setLongClickable(false);
|
|
info.removeAction(AccessibilityAction.ACTION_LONG_CLICK);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds all the accessibility actions that can be handled.
|
|
*/
|
|
protected void getSupportedActions(View host, ItemInfo item, List<LauncherAction> out) {
|
|
// If the request came from keyboard, do not add custom shortcuts as that is already
|
|
// exposed as a direct shortcut
|
|
if (ShortcutUtil.supportsShortcuts(item)) {
|
|
out.add(mActions.get(NotificationListener.getInstanceIfConnected() != null
|
|
? SHORTCUTS_AND_NOTIFICATIONS : DEEP_SHORTCUTS));
|
|
}
|
|
|
|
for (ButtonDropTarget target : mLauncher.getDropTargetBar().getDropTargets()) {
|
|
if (target.supportsAccessibilityDrop(item, host)) {
|
|
out.add(mActions.get(target.getAccessibilityAction()));
|
|
}
|
|
}
|
|
|
|
// Do not add move actions for keyboard request as this uses virtual nodes.
|
|
if (itemSupportsAccessibleDrag(item)) {
|
|
out.add(mActions.get(MOVE));
|
|
|
|
if (item.container >= 0) {
|
|
out.add(mActions.get(MOVE_TO_WORKSPACE));
|
|
} else if (item instanceof LauncherAppWidgetInfo) {
|
|
if (!getSupportedResizeActions(host, (LauncherAppWidgetInfo) item).isEmpty()) {
|
|
out.add(mActions.get(RESIZE));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((item instanceof AppInfo) || (item instanceof PendingAddItemInfo)) {
|
|
out.add(mActions.get(ADD_TO_WORKSPACE));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns all the accessibility actions that can be handled by the host.
|
|
*/
|
|
public static List<LauncherAction> getSupportedActions(Launcher launcher, View host) {
|
|
if (host == null || !(host.getTag() instanceof ItemInfo)) {
|
|
return Collections.emptyList();
|
|
}
|
|
PopupContainerWithArrow container = PopupContainerWithArrow.getOpen(launcher);
|
|
LauncherAccessibilityDelegate delegate = container != null
|
|
? container.getAccessibilityDelegate() : launcher.getAccessibilityDelegate();
|
|
List<LauncherAction> result = new ArrayList<>();
|
|
delegate.getSupportedActions(host, (ItemInfo) host.getTag(), result);
|
|
return result;
|
|
}
|
|
|
|
private boolean itemSupportsLongClick(View host, ItemInfo info) {
|
|
return PopupContainerWithArrow.canShow(host, info);
|
|
}
|
|
|
|
private boolean itemSupportsAccessibleDrag(ItemInfo item) {
|
|
if (item instanceof WorkspaceItemInfo) {
|
|
// Support the action unless the item is in a context menu.
|
|
return item.screenId >= 0 && item.container != Favorites.CONTAINER_HOTSEAT_PREDICTION;
|
|
}
|
|
return (item instanceof LauncherAppWidgetInfo)
|
|
|| (item instanceof FolderInfo);
|
|
}
|
|
|
|
@Override
|
|
public boolean performAccessibilityAction(View host, int action, Bundle args) {
|
|
if ((host.getTag() instanceof ItemInfo)
|
|
&& performAction(host, (ItemInfo) host.getTag(), action, false)) {
|
|
return true;
|
|
}
|
|
return super.performAccessibilityAction(host, action, args);
|
|
}
|
|
|
|
/**
|
|
* Performs the provided action on the host
|
|
*/
|
|
protected boolean performAction(final View host, final ItemInfo item, int action,
|
|
boolean fromKeyboard) {
|
|
if (action == ACTION_LONG_CLICK) {
|
|
if (PopupContainerWithArrow.canShow(host, item)) {
|
|
// Long press should be consumed for workspace items, and it should invoke the
|
|
// Shortcuts / Notifications / Actions pop-up menu, and not start a drag as the
|
|
// standard long press path does.
|
|
PopupContainerWithArrow.showForIcon((BubbleTextView) host);
|
|
return true;
|
|
}
|
|
} else if (action == MOVE) {
|
|
return beginAccessibleDrag(host, item, fromKeyboard);
|
|
} else if (action == ADD_TO_WORKSPACE) {
|
|
final int[] coordinates = new int[2];
|
|
final int screenId = findSpaceOnWorkspace(item, coordinates);
|
|
if (screenId == -1) {
|
|
return false;
|
|
}
|
|
mLauncher.getStateManager().goToState(NORMAL, true, forSuccessCallback(() -> {
|
|
if (item instanceof AppInfo) {
|
|
WorkspaceItemInfo info = ((AppInfo) item).makeWorkspaceItem();
|
|
mLauncher.getModelWriter().addItemToDatabase(info,
|
|
Favorites.CONTAINER_DESKTOP,
|
|
screenId, coordinates[0], coordinates[1]);
|
|
|
|
mLauncher.bindItems(
|
|
Collections.singletonList(info),
|
|
/* forceAnimateIcons= */ true,
|
|
/* focusFirstItemForAccessibility= */ true);
|
|
announceConfirmation(R.string.item_added_to_workspace);
|
|
} else if (item instanceof PendingAddItemInfo) {
|
|
PendingAddItemInfo info = (PendingAddItemInfo) item;
|
|
Workspace workspace = mLauncher.getWorkspace();
|
|
workspace.snapToPage(workspace.getPageIndexForScreenId(screenId));
|
|
mLauncher.addPendingItem(info, Favorites.CONTAINER_DESKTOP,
|
|
screenId, coordinates, info.spanX, info.spanY);
|
|
}
|
|
}));
|
|
return true;
|
|
} else if (action == MOVE_TO_WORKSPACE) {
|
|
Folder folder = Folder.getOpen(mLauncher);
|
|
folder.close(true);
|
|
WorkspaceItemInfo info = (WorkspaceItemInfo) item;
|
|
folder.getInfo().remove(info, false);
|
|
|
|
final int[] coordinates = new int[2];
|
|
final int screenId = findSpaceOnWorkspace(item, coordinates);
|
|
if (screenId == -1) {
|
|
return false;
|
|
}
|
|
mLauncher.getModelWriter().moveItemInDatabase(info,
|
|
Favorites.CONTAINER_DESKTOP,
|
|
screenId, coordinates[0], coordinates[1]);
|
|
|
|
// Bind the item in next frame so that if a new workspace page was created,
|
|
// it will get laid out.
|
|
new Handler().post(() -> {
|
|
mLauncher.bindItems(Collections.singletonList(item), true);
|
|
announceConfirmation(R.string.item_moved);
|
|
});
|
|
return true;
|
|
} else if (action == RESIZE) {
|
|
final LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) item;
|
|
List<OptionItem> actions = getSupportedResizeActions(host, info);
|
|
Rect pos = new Rect();
|
|
mLauncher.getDragLayer().getDescendantRectRelativeToSelf(host, pos);
|
|
ArrowPopup popup = OptionsPopupView.show(mLauncher, new RectF(pos), actions, false);
|
|
popup.requestFocus();
|
|
popup.setOnCloseCallback(host::requestFocus);
|
|
return true;
|
|
} else if (action == DEEP_SHORTCUTS || action == SHORTCUTS_AND_NOTIFICATIONS) {
|
|
return PopupContainerWithArrow.showForIcon((BubbleTextView) host) != null;
|
|
} else {
|
|
for (ButtonDropTarget dropTarget : mLauncher.getDropTargetBar().getDropTargets()) {
|
|
if (dropTarget.supportsAccessibilityDrop(item, host)
|
|
&& action == dropTarget.getAccessibilityAction()) {
|
|
dropTarget.onAccessibilityDrop(host, item);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private List<OptionItem> getSupportedResizeActions(View host, LauncherAppWidgetInfo info) {
|
|
List<OptionItem> actions = new ArrayList<>();
|
|
AppWidgetProviderInfo providerInfo = ((LauncherAppWidgetHostView) host).getAppWidgetInfo();
|
|
if (providerInfo == null) {
|
|
return actions;
|
|
}
|
|
|
|
CellLayout layout;
|
|
if (host.getParent() instanceof DragView) {
|
|
layout = (CellLayout) ((DragView) host.getParent()).getContentViewParent().getParent();
|
|
} else {
|
|
layout = (CellLayout) host.getParent().getParent();
|
|
}
|
|
if ((providerInfo.resizeMode & AppWidgetProviderInfo.RESIZE_HORIZONTAL) != 0) {
|
|
if (layout.isRegionVacant(info.cellX + info.spanX, info.cellY, 1, info.spanY) ||
|
|
layout.isRegionVacant(info.cellX - 1, info.cellY, 1, info.spanY)) {
|
|
actions.add(new OptionItem(mLauncher,
|
|
R.string.action_increase_width,
|
|
R.drawable.ic_widget_width_increase,
|
|
IGNORE,
|
|
v -> performResizeAction(R.string.action_increase_width, host, info)));
|
|
}
|
|
|
|
if (info.spanX > info.minSpanX && info.spanX > 1) {
|
|
actions.add(new OptionItem(mLauncher,
|
|
R.string.action_decrease_width,
|
|
R.drawable.ic_widget_width_decrease,
|
|
IGNORE,
|
|
v -> performResizeAction(R.string.action_decrease_width, host, info)));
|
|
}
|
|
}
|
|
|
|
if ((providerInfo.resizeMode & AppWidgetProviderInfo.RESIZE_VERTICAL) != 0) {
|
|
if (layout.isRegionVacant(info.cellX, info.cellY + info.spanY, info.spanX, 1) ||
|
|
layout.isRegionVacant(info.cellX, info.cellY - 1, info.spanX, 1)) {
|
|
actions.add(new OptionItem(mLauncher,
|
|
R.string.action_increase_height,
|
|
R.drawable.ic_widget_height_increase,
|
|
IGNORE,
|
|
v -> performResizeAction(R.string.action_increase_height, host, info)));
|
|
}
|
|
|
|
if (info.spanY > info.minSpanY && info.spanY > 1) {
|
|
actions.add(new OptionItem(mLauncher,
|
|
R.string.action_decrease_height,
|
|
R.drawable.ic_widget_height_decrease,
|
|
IGNORE,
|
|
v -> performResizeAction(R.string.action_decrease_height, host, info)));
|
|
}
|
|
}
|
|
return actions;
|
|
}
|
|
|
|
private boolean performResizeAction(int action, View host, LauncherAppWidgetInfo info) {
|
|
CellLayout.LayoutParams lp = (CellLayout.LayoutParams) host.getLayoutParams();
|
|
CellLayout layout = (CellLayout) host.getParent().getParent();
|
|
layout.markCellsAsUnoccupiedForView(host);
|
|
|
|
if (action == R.string.action_increase_width) {
|
|
if (((host.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL)
|
|
&& layout.isRegionVacant(info.cellX - 1, info.cellY, 1, info.spanY))
|
|
|| !layout.isRegionVacant(info.cellX + info.spanX, info.cellY, 1, info.spanY)) {
|
|
lp.cellX --;
|
|
info.cellX --;
|
|
}
|
|
lp.cellHSpan ++;
|
|
info.spanX ++;
|
|
} else if (action == R.string.action_decrease_width) {
|
|
lp.cellHSpan --;
|
|
info.spanX --;
|
|
} else if (action == R.string.action_increase_height) {
|
|
if (!layout.isRegionVacant(info.cellX, info.cellY + info.spanY, info.spanX, 1)) {
|
|
lp.cellY --;
|
|
info.cellY --;
|
|
}
|
|
lp.cellVSpan ++;
|
|
info.spanY ++;
|
|
} else if (action == R.string.action_decrease_height) {
|
|
lp.cellVSpan --;
|
|
info.spanY --;
|
|
}
|
|
|
|
layout.markCellsAsOccupiedForView(host);
|
|
WidgetSizes.updateWidgetSizeRanges(((LauncherAppWidgetHostView) host), mLauncher,
|
|
info.spanX, info.spanY);
|
|
host.requestLayout();
|
|
mLauncher.getModelWriter().updateItemInDatabase(info);
|
|
announceConfirmation(mLauncher.getString(R.string.widget_resized, info.spanX, info.spanY));
|
|
return true;
|
|
}
|
|
|
|
@Thunk void announceConfirmation(int resId) {
|
|
announceConfirmation(mLauncher.getResources().getString(resId));
|
|
}
|
|
|
|
@Thunk void announceConfirmation(String confirmation) {
|
|
mLauncher.getDragLayer().announceForAccessibility(confirmation);
|
|
|
|
}
|
|
|
|
public boolean isInAccessibleDrag() {
|
|
return mDragInfo != null;
|
|
}
|
|
|
|
public DragInfo getDragInfo() {
|
|
return mDragInfo;
|
|
}
|
|
|
|
/**
|
|
* @param clickedTarget the actual view that was clicked
|
|
* @param dropLocation relative to {@param clickedTarget}. If provided, its center is used
|
|
* as the actual drop location otherwise the views center is used.
|
|
*/
|
|
public void handleAccessibleDrop(View clickedTarget, Rect dropLocation,
|
|
String confirmation) {
|
|
if (!isInAccessibleDrag()) return;
|
|
|
|
int[] loc = new int[2];
|
|
if (dropLocation == null) {
|
|
loc[0] = clickedTarget.getWidth() / 2;
|
|
loc[1] = clickedTarget.getHeight() / 2;
|
|
} else {
|
|
loc[0] = dropLocation.centerX();
|
|
loc[1] = dropLocation.centerY();
|
|
}
|
|
|
|
mLauncher.getDragLayer().getDescendantCoordRelativeToSelf(clickedTarget, loc);
|
|
mLauncher.getDragController().completeAccessibleDrag(loc);
|
|
|
|
if (!TextUtils.isEmpty(confirmation)) {
|
|
announceConfirmation(confirmation);
|
|
}
|
|
}
|
|
|
|
private boolean beginAccessibleDrag(View item, ItemInfo info, boolean fromKeyboard) {
|
|
if (!itemSupportsAccessibleDrag(info)) {
|
|
return false;
|
|
}
|
|
|
|
mDragInfo = new DragInfo();
|
|
mDragInfo.info = info;
|
|
mDragInfo.item = item;
|
|
mDragInfo.dragType = DragType.ICON;
|
|
if (info instanceof FolderInfo) {
|
|
mDragInfo.dragType = DragType.FOLDER;
|
|
} else if (info instanceof LauncherAppWidgetInfo) {
|
|
mDragInfo.dragType = DragType.WIDGET;
|
|
}
|
|
|
|
Rect pos = new Rect();
|
|
mLauncher.getDragLayer().getDescendantRectRelativeToSelf(item, pos);
|
|
mLauncher.getDragController().addDragListener(this);
|
|
|
|
DragOptions options = new DragOptions();
|
|
options.isAccessibleDrag = true;
|
|
options.isKeyboardDrag = fromKeyboard;
|
|
options.simulatedDndStartPoint = new Point(pos.centerX(), pos.centerY());
|
|
|
|
if (fromKeyboard) {
|
|
KeyboardDragAndDropView popup = (KeyboardDragAndDropView) mLauncher.getLayoutInflater()
|
|
.inflate(R.layout.keyboard_drag_and_drop, mLauncher.getDragLayer(), false);
|
|
popup.showForIcon(item, info, options);
|
|
} else {
|
|
ItemLongClickListener.beginDrag(item, mLauncher, info, options);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onDragStart(DragObject dragObject, DragOptions options) {
|
|
// No-op
|
|
}
|
|
|
|
@Override
|
|
public void onDragEnd() {
|
|
mLauncher.getDragController().removeDragListener(this);
|
|
mDragInfo = null;
|
|
}
|
|
|
|
/**
|
|
* Find empty space on the workspace and returns the screenId.
|
|
*/
|
|
protected int findSpaceOnWorkspace(ItemInfo info, int[] outCoordinates) {
|
|
Workspace workspace = mLauncher.getWorkspace();
|
|
IntArray workspaceScreens = workspace.getScreenOrder();
|
|
int screenId;
|
|
|
|
// First check if there is space on the current screen.
|
|
int screenIndex = workspace.getCurrentPage();
|
|
screenId = workspaceScreens.get(screenIndex);
|
|
CellLayout layout = (CellLayout) workspace.getPageAt(screenIndex);
|
|
|
|
boolean found = layout.findCellForSpan(outCoordinates, info.spanX, info.spanY);
|
|
screenIndex = 0;
|
|
while (!found && screenIndex < workspaceScreens.size()) {
|
|
screenId = workspaceScreens.get(screenIndex);
|
|
layout = (CellLayout) workspace.getPageAt(screenIndex);
|
|
found = layout.findCellForSpan(outCoordinates, info.spanX, info.spanY);
|
|
screenIndex++;
|
|
}
|
|
|
|
if (found) {
|
|
return screenId;
|
|
}
|
|
|
|
workspace.addExtraEmptyScreens();
|
|
IntSet emptyScreenIds = workspace.commitExtraEmptyScreens();
|
|
if (emptyScreenIds.isEmpty()) {
|
|
// Couldn't create extra empty screens for some reason (e.g. Workspace is loading)
|
|
return -1;
|
|
}
|
|
|
|
screenId = emptyScreenIds.getArray().get(0);
|
|
layout = workspace.getScreenWithId(screenId);
|
|
found = layout.findCellForSpan(outCoordinates, info.spanX, info.spanY);
|
|
|
|
if (!found) {
|
|
Log.wtf(TAG, "Not enough space on an empty screen");
|
|
}
|
|
return screenId;
|
|
}
|
|
|
|
public class LauncherAction {
|
|
public final int keyCode;
|
|
public final AccessibilityAction accessibilityAction;
|
|
|
|
private final LauncherAccessibilityDelegate mDelegate;
|
|
|
|
public LauncherAction(int id, int labelRes, int keyCode) {
|
|
this.keyCode = keyCode;
|
|
accessibilityAction = new AccessibilityAction(id, mLauncher.getString(labelRes));
|
|
mDelegate = LauncherAccessibilityDelegate.this;
|
|
}
|
|
|
|
/**
|
|
* Invokes the action for the provided host
|
|
*/
|
|
public boolean invokeFromKeyboard(View host) {
|
|
if (host != null && host.getTag() instanceof ItemInfo) {
|
|
return mDelegate.performAction(
|
|
host, (ItemInfo) host.getTag(), accessibilityAction.getId(), true);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|