Jon Miranda
89137e7bb8
- Added flag PROMISE_APPS_NEW_INSTALLS - Promise icons only added if flag (above) is on, as well as the setting for "Add icon to Home screen" - Maintains a list of session ids of promise icons that have been added to the home screen, so that if the user manually removes the icon, we do not add it back to the home screen when the install is completed. - Queues all applications as promise icons, and replaces with actual app info when its being added to the workspace. Bug: 135633159 Change-Id: Idf2fc9033f890afef924628b76b89ad4692f529c Merged-In: I411db59f9bd1b346d98b9bb73f5376a5983b8de5
464 lines
17 KiB
Java
464 lines
17 KiB
Java
/*
|
|
* Copyright (C) 2017 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.launcher3.model;
|
|
|
|
import android.content.ComponentName;
|
|
import android.content.ContentValues;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.Intent.ShortcutIconResource;
|
|
import android.content.pm.LauncherActivityInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.database.Cursor;
|
|
import android.database.CursorWrapper;
|
|
import android.graphics.BitmapFactory;
|
|
import android.os.UserHandle;
|
|
import android.provider.BaseColumns;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.util.LongSparseArray;
|
|
|
|
import com.android.launcher3.AppInfo;
|
|
import com.android.launcher3.WorkspaceItemInfo;
|
|
import com.android.launcher3.icons.IconCache;
|
|
import com.android.launcher3.InvariantDeviceProfile;
|
|
import com.android.launcher3.ItemInfo;
|
|
import com.android.launcher3.LauncherAppState;
|
|
import com.android.launcher3.LauncherSettings;
|
|
import com.android.launcher3.Utilities;
|
|
import com.android.launcher3.Workspace;
|
|
import com.android.launcher3.compat.LauncherAppsCompat;
|
|
import com.android.launcher3.config.FeatureFlags;
|
|
import com.android.launcher3.icons.BitmapInfo;
|
|
import com.android.launcher3.icons.LauncherIcons;
|
|
import com.android.launcher3.logging.FileLog;
|
|
import com.android.launcher3.util.ContentWriter;
|
|
import com.android.launcher3.util.GridOccupancy;
|
|
import com.android.launcher3.util.IntArray;
|
|
import com.android.launcher3.util.IntSparseArrayMap;
|
|
|
|
import java.net.URISyntaxException;
|
|
import java.security.InvalidParameterException;
|
|
|
|
/**
|
|
* Extension of {@link Cursor} with utility methods for workspace loading.
|
|
*/
|
|
public class LoaderCursor extends CursorWrapper {
|
|
|
|
private static final String TAG = "LoaderCursor";
|
|
|
|
public final LongSparseArray<UserHandle> allUsers = new LongSparseArray<>();
|
|
|
|
private final Context mContext;
|
|
private final PackageManager mPM;
|
|
private final IconCache mIconCache;
|
|
private final InvariantDeviceProfile mIDP;
|
|
|
|
private final IntArray itemsToRemove = new IntArray();
|
|
private final IntArray restoredRows = new IntArray();
|
|
private final IntSparseArrayMap<GridOccupancy> occupied = new IntSparseArrayMap<>();
|
|
|
|
private final int iconPackageIndex;
|
|
private final int iconResourceIndex;
|
|
private final int iconIndex;
|
|
public final int titleIndex;
|
|
|
|
private final int idIndex;
|
|
private final int containerIndex;
|
|
private final int itemTypeIndex;
|
|
private final int screenIndex;
|
|
private final int cellXIndex;
|
|
private final int cellYIndex;
|
|
private final int profileIdIndex;
|
|
private final int restoredIndex;
|
|
private final int intentIndex;
|
|
|
|
// Properties loaded per iteration
|
|
public long serialNumber;
|
|
public UserHandle user;
|
|
public int id;
|
|
public int container;
|
|
public int itemType;
|
|
public int restoreFlag;
|
|
|
|
public LoaderCursor(Cursor c, LauncherAppState app) {
|
|
super(c);
|
|
mContext = app.getContext();
|
|
mIconCache = app.getIconCache();
|
|
mIDP = app.getInvariantDeviceProfile();
|
|
mPM = mContext.getPackageManager();
|
|
|
|
// Init column indices
|
|
iconIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.ICON);
|
|
iconPackageIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.ICON_PACKAGE);
|
|
iconResourceIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.ICON_RESOURCE);
|
|
titleIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.TITLE);
|
|
|
|
idIndex = getColumnIndexOrThrow(LauncherSettings.Favorites._ID);
|
|
containerIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.CONTAINER);
|
|
itemTypeIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.ITEM_TYPE);
|
|
screenIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.SCREEN);
|
|
cellXIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.CELLX);
|
|
cellYIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.CELLY);
|
|
profileIdIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.PROFILE_ID);
|
|
restoredIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.RESTORED);
|
|
intentIndex = getColumnIndexOrThrow(LauncherSettings.Favorites.INTENT);
|
|
}
|
|
|
|
@Override
|
|
public boolean moveToNext() {
|
|
boolean result = super.moveToNext();
|
|
if (result) {
|
|
// Load common properties.
|
|
itemType = getInt(itemTypeIndex);
|
|
container = getInt(containerIndex);
|
|
id = getInt(idIndex);
|
|
serialNumber = getInt(profileIdIndex);
|
|
user = allUsers.get(serialNumber);
|
|
restoreFlag = getInt(restoredIndex);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public Intent parseIntent() {
|
|
String intentDescription = getString(intentIndex);
|
|
try {
|
|
return TextUtils.isEmpty(intentDescription) ?
|
|
null : Intent.parseUri(intentDescription, 0);
|
|
} catch (URISyntaxException e) {
|
|
Log.e(TAG, "Error parsing Intent");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public WorkspaceItemInfo loadSimpleWorkspaceItem() {
|
|
final WorkspaceItemInfo info = new WorkspaceItemInfo();
|
|
// Non-app shortcuts are only supported for current user.
|
|
info.user = user;
|
|
info.itemType = itemType;
|
|
info.title = getTitle();
|
|
// the fallback icon
|
|
if (!loadIcon(info)) {
|
|
info.applyFrom(mIconCache.getDefaultIcon(info.user));
|
|
}
|
|
|
|
// TODO: If there's an explicit component and we can't install that, delete it.
|
|
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* Loads the icon from the cursor and updates the {@param info} if the icon is an app resource.
|
|
*/
|
|
protected boolean loadIcon(WorkspaceItemInfo info) {
|
|
try (LauncherIcons li = LauncherIcons.obtain(mContext)) {
|
|
return loadIcon(info, li);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads the icon from the cursor and updates the {@param info} if the icon is an app resource.
|
|
*/
|
|
protected boolean loadIcon(WorkspaceItemInfo info, LauncherIcons li) {
|
|
if (itemType == LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT) {
|
|
String packageName = getString(iconPackageIndex);
|
|
String resourceName = getString(iconResourceIndex);
|
|
if (!TextUtils.isEmpty(packageName) || !TextUtils.isEmpty(resourceName)) {
|
|
info.iconResource = new ShortcutIconResource();
|
|
info.iconResource.packageName = packageName;
|
|
info.iconResource.resourceName = resourceName;
|
|
BitmapInfo iconInfo = li.createIconBitmap(info.iconResource);
|
|
if (iconInfo != null) {
|
|
info.applyFrom(iconInfo);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Failed to load from resource, try loading from DB.
|
|
byte[] data = getBlob(iconIndex);
|
|
try {
|
|
info.applyFrom(li.createIconBitmap(BitmapFactory.decodeByteArray(data, 0, data.length)));
|
|
return true;
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Failed to decode byte array for info " + info, e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the title or empty string
|
|
*/
|
|
private String getTitle() {
|
|
String title = getString(titleIndex);
|
|
return TextUtils.isEmpty(title) ? "" : Utilities.trim(title);
|
|
}
|
|
|
|
/**
|
|
* Make an WorkspaceItemInfo object for a restored application or shortcut item that points
|
|
* to a package that is not yet installed on the system.
|
|
*/
|
|
public WorkspaceItemInfo getRestoredItemInfo(Intent intent) {
|
|
final WorkspaceItemInfo info = new WorkspaceItemInfo();
|
|
info.user = user;
|
|
info.intent = intent;
|
|
|
|
// the fallback icon
|
|
if (!loadIcon(info)) {
|
|
mIconCache.getTitleAndIcon(info, false /* useLowResIcon */);
|
|
}
|
|
|
|
if (hasRestoreFlag(WorkspaceItemInfo.FLAG_RESTORED_ICON)) {
|
|
String title = getTitle();
|
|
if (!TextUtils.isEmpty(title)) {
|
|
info.title = Utilities.trim(title);
|
|
}
|
|
} else if (hasRestoreFlag(WorkspaceItemInfo.FLAG_AUTOINSTALL_ICON)) {
|
|
if (TextUtils.isEmpty(info.title)) {
|
|
info.title = getTitle();
|
|
}
|
|
} else {
|
|
throw new InvalidParameterException("Invalid restoreType " + restoreFlag);
|
|
}
|
|
|
|
info.contentDescription = mPM.getUserBadgedLabel(info.title, info.user);
|
|
info.itemType = itemType;
|
|
info.status = restoreFlag;
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* Make an WorkspaceItemInfo object for a shortcut that is an application.
|
|
*/
|
|
public WorkspaceItemInfo getAppShortcutInfo(
|
|
Intent intent, boolean allowMissingTarget, boolean useLowResIcon) {
|
|
if (user == null) {
|
|
Log.d(TAG, "Null user found in getShortcutInfo");
|
|
return null;
|
|
}
|
|
|
|
ComponentName componentName = intent.getComponent();
|
|
if (componentName == null) {
|
|
Log.d(TAG, "Missing component found in getShortcutInfo");
|
|
return null;
|
|
}
|
|
|
|
Intent newIntent = new Intent(Intent.ACTION_MAIN, null);
|
|
newIntent.addCategory(Intent.CATEGORY_LAUNCHER);
|
|
newIntent.setComponent(componentName);
|
|
LauncherActivityInfo lai = LauncherAppsCompat.getInstance(mContext)
|
|
.resolveActivity(newIntent, user);
|
|
if ((lai == null) && !allowMissingTarget) {
|
|
Log.d(TAG, "Missing activity found in getShortcutInfo: " + componentName);
|
|
return null;
|
|
}
|
|
|
|
final WorkspaceItemInfo info = new WorkspaceItemInfo();
|
|
info.itemType = LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
|
|
info.user = user;
|
|
info.intent = newIntent;
|
|
|
|
mIconCache.getTitleAndIcon(info, lai, useLowResIcon);
|
|
if (mIconCache.isDefaultIcon(info.iconBitmap, user)) {
|
|
loadIcon(info);
|
|
}
|
|
|
|
if (lai != null) {
|
|
AppInfo.updateRuntimeFlagsForActivityTarget(info, lai);
|
|
}
|
|
|
|
// from the db
|
|
if (TextUtils.isEmpty(info.title)) {
|
|
info.title = getTitle();
|
|
}
|
|
|
|
// fall back to the class name of the activity
|
|
if (info.title == null) {
|
|
info.title = componentName.getClassName();
|
|
}
|
|
|
|
info.contentDescription = mPM.getUserBadgedLabel(info.title, info.user);
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link ContentWriter} which can be used to update the current item.
|
|
*/
|
|
public ContentWriter updater() {
|
|
return new ContentWriter(mContext, new ContentWriter.CommitParams(
|
|
BaseColumns._ID + "= ?", new String[]{Integer.toString(id)}));
|
|
}
|
|
|
|
/**
|
|
* Marks the current item for removal
|
|
*/
|
|
public void markDeleted(String reason) {
|
|
FileLog.e(TAG, reason);
|
|
itemsToRemove.add(id);
|
|
}
|
|
|
|
/**
|
|
* Removes any items marked for removal.
|
|
* @return true is any item was removed.
|
|
*/
|
|
public boolean commitDeleted() {
|
|
if (itemsToRemove.size() > 0) {
|
|
// Remove dead items
|
|
mContext.getContentResolver().delete(LauncherSettings.Favorites.CONTENT_URI,
|
|
Utilities.createDbSelectionQuery(
|
|
LauncherSettings.Favorites._ID, itemsToRemove), null);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Marks the current item as restored
|
|
*/
|
|
public void markRestored() {
|
|
if (restoreFlag != 0) {
|
|
restoredRows.add(id);
|
|
restoreFlag = 0;
|
|
}
|
|
}
|
|
|
|
public boolean hasRestoreFlag(int flagMask) {
|
|
return (restoreFlag & flagMask) != 0;
|
|
}
|
|
|
|
public void commitRestoredItems() {
|
|
if (restoredRows.size() > 0) {
|
|
// Update restored items that no longer require special handling
|
|
ContentValues values = new ContentValues();
|
|
values.put(LauncherSettings.Favorites.RESTORED, 0);
|
|
mContext.getContentResolver().update(LauncherSettings.Favorites.CONTENT_URI, values,
|
|
Utilities.createDbSelectionQuery(
|
|
LauncherSettings.Favorites._ID, restoredRows), null);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true is the item is on workspace or hotseat
|
|
*/
|
|
public boolean isOnWorkspaceOrHotseat() {
|
|
return container == LauncherSettings.Favorites.CONTAINER_DESKTOP ||
|
|
container == LauncherSettings.Favorites.CONTAINER_HOTSEAT;
|
|
}
|
|
|
|
/**
|
|
* Applies the following properties:
|
|
* {@link ItemInfo#id}
|
|
* {@link ItemInfo#container}
|
|
* {@link ItemInfo#screenId}
|
|
* {@link ItemInfo#cellX}
|
|
* {@link ItemInfo#cellY}
|
|
*/
|
|
public void applyCommonProperties(ItemInfo info) {
|
|
info.id = id;
|
|
info.container = container;
|
|
info.screenId = getInt(screenIndex);
|
|
info.cellX = getInt(cellXIndex);
|
|
info.cellY = getInt(cellYIndex);
|
|
}
|
|
|
|
/**
|
|
* Adds the {@param info} to {@param dataModel} if it does not overlap with any other item,
|
|
* otherwise marks it for deletion.
|
|
*/
|
|
public void checkAndAddItem(ItemInfo info, BgDataModel dataModel) {
|
|
if (checkItemPlacement(info)) {
|
|
dataModel.addItem(mContext, info, false);
|
|
} else {
|
|
markDeleted("Item position overlap");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* check & update map of what's occupied; used to discard overlapping/invalid items
|
|
*/
|
|
protected boolean checkItemPlacement(ItemInfo item) {
|
|
int containerIndex = item.screenId;
|
|
if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
|
|
final GridOccupancy hotseatOccupancy =
|
|
occupied.get(LauncherSettings.Favorites.CONTAINER_HOTSEAT);
|
|
|
|
if (item.screenId >= mIDP.numHotseatIcons) {
|
|
Log.e(TAG, "Error loading shortcut " + item
|
|
+ " into hotseat position " + item.screenId
|
|
+ ", position out of bounds: (0 to " + (mIDP.numHotseatIcons - 1)
|
|
+ ")");
|
|
return false;
|
|
}
|
|
|
|
if (hotseatOccupancy != null) {
|
|
if (hotseatOccupancy.cells[(int) item.screenId][0]) {
|
|
Log.e(TAG, "Error loading shortcut into hotseat " + item
|
|
+ " into position (" + item.screenId + ":" + item.cellX + ","
|
|
+ item.cellY + ") already occupied");
|
|
return false;
|
|
} else {
|
|
hotseatOccupancy.cells[item.screenId][0] = true;
|
|
return true;
|
|
}
|
|
} else {
|
|
final GridOccupancy occupancy = new GridOccupancy(mIDP.numHotseatIcons, 1);
|
|
occupancy.cells[item.screenId][0] = true;
|
|
occupied.put(LauncherSettings.Favorites.CONTAINER_HOTSEAT, occupancy);
|
|
return true;
|
|
}
|
|
} else if (item.container != LauncherSettings.Favorites.CONTAINER_DESKTOP) {
|
|
// Skip further checking if it is not the hotseat or workspace container
|
|
return true;
|
|
}
|
|
|
|
final int countX = mIDP.numColumns;
|
|
final int countY = mIDP.numRows;
|
|
if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP &&
|
|
item.cellX < 0 || item.cellY < 0 ||
|
|
item.cellX + item.spanX > countX || item.cellY + item.spanY > countY) {
|
|
Log.e(TAG, "Error loading shortcut " + item
|
|
+ " into cell (" + containerIndex + "-" + item.screenId + ":"
|
|
+ item.cellX + "," + item.cellY
|
|
+ ") out of screen bounds ( " + countX + "x" + countY + ")");
|
|
return false;
|
|
}
|
|
|
|
if (!occupied.containsKey(item.screenId)) {
|
|
GridOccupancy screen = new GridOccupancy(countX + 1, countY + 1);
|
|
if (item.screenId == Workspace.FIRST_SCREEN_ID) {
|
|
// Mark the first row as occupied (if the feature is enabled)
|
|
// in order to account for the QSB.
|
|
screen.markCells(0, 0, countX + 1, 1, FeatureFlags.QSB_ON_FIRST_SCREEN);
|
|
}
|
|
occupied.put(item.screenId, screen);
|
|
}
|
|
final GridOccupancy occupancy = occupied.get(item.screenId);
|
|
|
|
// Check if any workspace icons overlap with each other
|
|
if (occupancy.isRegionVacant(item.cellX, item.cellY, item.spanX, item.spanY)) {
|
|
occupancy.markCells(item, true);
|
|
return true;
|
|
} else {
|
|
Log.e(TAG, "Error loading shortcut " + item
|
|
+ " into cell (" + containerIndex + "-" + item.screenId + ":"
|
|
+ item.cellX + "," + item.cellX + "," + item.spanX + "," + item.spanY
|
|
+ ") already occupied");
|
|
return false;
|
|
}
|
|
}
|
|
}
|