diff options
Diffstat (limited to 'src/com/cyanogenmod/trebuchet/LauncherModel.java')
-rw-r--r-- | src/com/cyanogenmod/trebuchet/LauncherModel.java | 2176 |
1 files changed, 2176 insertions, 0 deletions
diff --git a/src/com/cyanogenmod/trebuchet/LauncherModel.java b/src/com/cyanogenmod/trebuchet/LauncherModel.java new file mode 100644 index 000000000..7e0df1435 --- /dev/null +++ b/src/com/cyanogenmod/trebuchet/LauncherModel.java @@ -0,0 +1,2176 @@ +/* + * Copyright (C) 2008 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.cyanogenmod.trebuchet; + +import android.app.SearchManager; +import android.appwidget.AppWidgetManager; +import android.appwidget.AppWidgetProviderInfo; +import android.content.BroadcastReceiver; +import android.content.ComponentName; +import android.content.ContentProviderClient; +import android.content.ContentResolver; +import android.content.ContentValues; +import android.content.Context; +import android.content.Intent; +import android.content.Intent.ShortcutIconResource; +import android.content.pm.ActivityInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.content.pm.ResolveInfo; +import android.content.res.Configuration; +import android.content.res.Resources; +import android.database.Cursor; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.net.Uri; +import android.os.Environment; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.Parcelable; +import android.os.Process; +import android.os.RemoteException; +import android.os.SystemClock; +import android.util.Log; + +import com.cyanogenmod.trebuchet.R; +import com.cyanogenmod.trebuchet.InstallWidgetReceiver.WidgetMimeTypeHandlerData; + +import java.lang.ref.WeakReference; +import java.net.URISyntaxException; +import java.text.Collator; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; + +/** + * Maintains in-memory state of the Launcher. It is expected that there should be only one + * LauncherModel object held in a static. Also provide APIs for updating the database state + * for the Launcher. + */ +public class LauncherModel extends BroadcastReceiver { + static final boolean DEBUG_LOADERS = false; + static final String TAG = "Launcher.Model"; + + private static final int ITEMS_CHUNK = 6; // batch size for the workspace icons + private final boolean mAppsCanBeOnExternalStorage; + private int mBatchSize; // 0 is all apps at once + private int mAllAppsLoadDelay; // milliseconds between batches + + private final LauncherApplication mApp; + private final Object mLock = new Object(); + private DeferredHandler mHandler = new DeferredHandler(); + private LoaderTask mLoaderTask; + + private static final HandlerThread sWorkerThread = new HandlerThread("launcher-loader"); + static { + sWorkerThread.start(); + } + private static final Handler sWorker = new Handler(sWorkerThread.getLooper()); + + // We start off with everything not loaded. After that, we assume that + // our monitoring of the package manager provides all updates and we never + // need to do a requery. These are only ever touched from the loader thread. + private boolean mWorkspaceLoaded; + private boolean mAllAppsLoaded; + + private WeakReference<Callbacks> mCallbacks; + + // < only access in worker thread > + private AllAppsList mAllAppsList; + + // sItemsIdMap maps *all* the ItemInfos (shortcuts, folders, and widgets) created by + // LauncherModel to their ids + static final HashMap<Long, ItemInfo> sItemsIdMap = new HashMap<Long, ItemInfo>(); + + // sItems is passed to bindItems, which expects a list of all folders and shortcuts created by + // LauncherModel that are directly on the home screen (however, no widgets or shortcuts + // within folders). + static final ArrayList<ItemInfo> sWorkspaceItems = new ArrayList<ItemInfo>(); + + // sAppWidgets is all LauncherAppWidgetInfo created by LauncherModel. Passed to bindAppWidget() + static final ArrayList<LauncherAppWidgetInfo> sAppWidgets = + new ArrayList<LauncherAppWidgetInfo>(); + + // sFolders is all FolderInfos created by LauncherModel. Passed to bindFolders() + static final HashMap<Long, FolderInfo> sFolders = new HashMap<Long, FolderInfo>(); + + // sDbIconCache is the set of ItemInfos that need to have their icons updated in the database + static final HashMap<Object, byte[]> sDbIconCache = new HashMap<Object, byte[]>(); + + // </ only access in worker thread > + + private IconCache mIconCache; + private Bitmap mDefaultIcon; + + private static int mCellCountX; + private static int mCellCountY; + + protected int mPreviousConfigMcc; + + public interface Callbacks { + public boolean setLoadOnResume(); + public int getCurrentWorkspaceScreen(); + public void startBinding(); + public void bindItems(ArrayList<ItemInfo> shortcuts, int start, int end); + public void bindFolders(HashMap<Long,FolderInfo> folders); + public void finishBindingItems(); + public void bindAppWidget(LauncherAppWidgetInfo info); + public void bindAllApplications(ArrayList<ApplicationInfo> apps); + public void bindAppsAdded(ArrayList<ApplicationInfo> apps); + public void bindAppsUpdated(ArrayList<ApplicationInfo> apps); + public void bindAppsRemoved(ArrayList<ApplicationInfo> apps, boolean permanent); + public void bindPackagesUpdated(); + public boolean isAllAppsVisible(); + public boolean isAllAppsButtonRank(int rank); + public void bindSearchablesChanged(); + } + + LauncherModel(LauncherApplication app, IconCache iconCache) { + mAppsCanBeOnExternalStorage = !Environment.isExternalStorageEmulated(); + mApp = app; + mAllAppsList = new AllAppsList(iconCache); + mIconCache = iconCache; + + mDefaultIcon = Utilities.createIconBitmap( + mIconCache.getFullResDefaultActivityIcon(), app); + + final Resources res = app.getResources(); + mAllAppsLoadDelay = res.getInteger(R.integer.config_allAppsBatchLoadDelay); + mBatchSize = res.getInteger(R.integer.config_allAppsBatchSize); + Configuration config = res.getConfiguration(); + mPreviousConfigMcc = config.mcc; + } + + public Bitmap getFallbackIcon() { + return Bitmap.createBitmap(mDefaultIcon); + } + + public void unbindWorkspaceItems() { + sWorker.post(new Runnable() { + @Override + public void run() { + unbindWorkspaceItemsOnMainThread(); + } + }); + } + + /** Unbinds all the sWorkspaceItems on the main thread, and return a copy of sWorkspaceItems + * that is save to reference from the main thread. */ + private ArrayList<ItemInfo> unbindWorkspaceItemsOnMainThread() { + // Ensure that we don't use the same workspace items data structure on the main thread + // by making a copy of workspace items first. + final ArrayList<ItemInfo> workspaceItems = new ArrayList<ItemInfo>(sWorkspaceItems); + final ArrayList<ItemInfo> appWidgets = new ArrayList<ItemInfo>(sAppWidgets); + mHandler.post(new Runnable() { + @Override + public void run() { + for (ItemInfo item : workspaceItems) { + item.unbind(); + } + for (ItemInfo item : appWidgets) { + item.unbind(); + } + } + }); + + return workspaceItems; + } + + /** + * Adds an item to the DB if it was not created previously, or move it to a new + * <container, screen, cellX, cellY> + */ + static void addOrMoveItemInDatabase(Context context, ItemInfo item, long container, + int screen, int cellX, int cellY) { + if (item.container == ItemInfo.NO_ID) { + // From all apps + addItemToDatabase(context, item, container, screen, cellX, cellY, false); + } else { + // From somewhere else + moveItemInDatabase(context, item, container, screen, cellX, cellY); + } + } + + static void updateItemInDatabaseHelper(Context context, final ContentValues values, + final ItemInfo item, final String callingFunction) { + final long itemId = item.id; + final Uri uri = LauncherSettings.Favorites.getContentUri(itemId, false); + final ContentResolver cr = context.getContentResolver(); + + Runnable r = new Runnable() { + public void run() { + cr.update(uri, values, null, null); + + ItemInfo modelItem = sItemsIdMap.get(itemId); + if (item != modelItem) { + // the modelItem needs to match up perfectly with item if our model is to be + // consistent with the database-- for now, just require modelItem == item + String msg = "item: " + ((item != null) ? item.toString() : "null") + + "modelItem: " + ((modelItem != null) ? modelItem.toString() : "null") + + "Error: ItemInfo passed to " + callingFunction + " doesn't match original"; + throw new RuntimeException(msg); + } + + // Items are added/removed from the corresponding FolderInfo elsewhere, such + // as in Workspace.onDrop. Here, we just add/remove them from the list of items + // that are on the desktop, as appropriate + if (modelItem.container == LauncherSettings.Favorites.CONTAINER_DESKTOP || + modelItem.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + if (!sWorkspaceItems.contains(modelItem)) { + sWorkspaceItems.add(modelItem); + } + } else { + sWorkspaceItems.remove(modelItem); + } + } + }; + + if (sWorkerThread.getThreadId() == Process.myTid()) { + r.run(); + } else { + sWorker.post(r); + } + } + + /** + * Move an item in the DB to a new <container, screen, cellX, cellY> + */ + static void moveItemInDatabase(Context context, final ItemInfo item, final long container, + final int screen, final int cellX, final int cellY) { + item.container = container; + item.cellX = cellX; + item.cellY = cellY; + + // We store hotseat items in canonical form which is this orientation invariant position + // in the hotseat + if (context instanceof Launcher && screen < 0 && + container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + item.screen = ((Launcher) context).getHotseat().getOrderInHotseat(cellX, cellY); + } else { + item.screen = screen; + } + + final ContentValues values = new ContentValues(); + values.put(LauncherSettings.Favorites.CONTAINER, item.container); + values.put(LauncherSettings.Favorites.CELLX, item.cellX); + values.put(LauncherSettings.Favorites.CELLY, item.cellY); + values.put(LauncherSettings.Favorites.SCREEN, item.screen); + + updateItemInDatabaseHelper(context, values, item, "moveItemInDatabase"); + } + + /** + * Move and/or resize item in the DB to a new <container, screen, cellX, cellY, spanX, spanY> + */ + static void modifyItemInDatabase(Context context, final ItemInfo item, final long container, + final int screen, final int cellX, final int cellY, final int spanX, final int spanY) { + item.container = container; + item.cellX = cellX; + item.cellY = cellY; + item.spanX = spanX; + item.spanY = spanY; + + // We store hotseat items in canonical form which is this orientation invariant position + // in the hotseat + if (context instanceof Launcher && screen < 0 && + container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + item.screen = ((Launcher) context).getHotseat().getOrderInHotseat(cellX, cellY); + } else { + item.screen = screen; + } + + final ContentValues values = new ContentValues(); + values.put(LauncherSettings.Favorites.CONTAINER, item.container); + values.put(LauncherSettings.Favorites.CELLX, item.cellX); + values.put(LauncherSettings.Favorites.CELLY, item.cellY); + values.put(LauncherSettings.Favorites.SPANX, item.spanX); + values.put(LauncherSettings.Favorites.SPANY, item.spanY); + values.put(LauncherSettings.Favorites.SCREEN, item.screen); + + updateItemInDatabaseHelper(context, values, item, "moveItemInDatabase"); + } + + /** + * Update an item to the database in a specified container. + */ + static void updateItemInDatabase(Context context, final ItemInfo item) { + final ContentValues values = new ContentValues(); + item.onAddToDatabase(values); + item.updateValuesWithCoordinates(values, item.cellX, item.cellY); + updateItemInDatabaseHelper(context, values, item, "updateItemInDatabase"); + } + + /** + * Returns true if the shortcuts already exists in the database. + * we identify a shortcut by its title and intent. + */ + static boolean shortcutExists(Context context, String title, Intent intent) { + final ContentResolver cr = context.getContentResolver(); + Cursor c = cr.query(LauncherSettings.Favorites.CONTENT_URI, + new String[] { "title", "intent" }, "title=? and intent=?", + new String[] { title, intent.toUri(0) }, null); + boolean result = false; + try { + result = c.moveToFirst(); + } finally { + c.close(); + } + return result; + } + + /** + * Returns an ItemInfo array containing all the items in the LauncherModel. + * The ItemInfo.id is not set through this function. + */ + static ArrayList<ItemInfo> getItemsInLocalCoordinates(Context context) { + ArrayList<ItemInfo> items = new ArrayList<ItemInfo>(); + final ContentResolver cr = context.getContentResolver(); + Cursor c = cr.query(LauncherSettings.Favorites.CONTENT_URI, new String[] { + LauncherSettings.Favorites.ITEM_TYPE, LauncherSettings.Favorites.CONTAINER, + LauncherSettings.Favorites.SCREEN, LauncherSettings.Favorites.CELLX, LauncherSettings.Favorites.CELLY, + LauncherSettings.Favorites.SPANX, LauncherSettings.Favorites.SPANY }, null, null, null); + + final int itemTypeIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ITEM_TYPE); + final int containerIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CONTAINER); + final int screenIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.SCREEN); + final int cellXIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CELLX); + final int cellYIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CELLY); + final int spanXIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.SPANX); + final int spanYIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.SPANY); + + try { + while (c.moveToNext()) { + ItemInfo item = new ItemInfo(); + item.cellX = c.getInt(cellXIndex); + item.cellY = c.getInt(cellYIndex); + item.spanX = c.getInt(spanXIndex); + item.spanY = c.getInt(spanYIndex); + item.container = c.getInt(containerIndex); + item.itemType = c.getInt(itemTypeIndex); + item.screen = c.getInt(screenIndex); + + items.add(item); + } + } catch (Exception e) { + items.clear(); + } finally { + c.close(); + } + + return items; + } + + /** + * Find a folder in the db, creating the FolderInfo if necessary, and adding it to folderList. + */ + FolderInfo getFolderById(Context context, HashMap<Long,FolderInfo> folderList, long id) { + final ContentResolver cr = context.getContentResolver(); + Cursor c = cr.query(LauncherSettings.Favorites.CONTENT_URI, null, + "_id=? and (itemType=? or itemType=?)", + new String[] { String.valueOf(id), + String.valueOf(LauncherSettings.Favorites.ITEM_TYPE_FOLDER)}, null); + + try { + if (c.moveToFirst()) { + final int itemTypeIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ITEM_TYPE); + final int titleIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.TITLE); + final int containerIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CONTAINER); + final int screenIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.SCREEN); + final int cellXIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CELLX); + final int cellYIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CELLY); + + FolderInfo folderInfo = null; + switch (c.getInt(itemTypeIndex)) { + case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: + folderInfo = findOrMakeFolder(folderList, id); + break; + } + + folderInfo.title = c.getString(titleIndex); + folderInfo.id = id; + folderInfo.container = c.getInt(containerIndex); + folderInfo.screen = c.getInt(screenIndex); + folderInfo.cellX = c.getInt(cellXIndex); + folderInfo.cellY = c.getInt(cellYIndex); + + return folderInfo; + } + } finally { + c.close(); + } + + return null; + } + + /** + * Add an item to the database in a specified container. Sets the container, screen, cellX and + * cellY fields of the item. Also assigns an ID to the item. + */ + static void addItemToDatabase(Context context, final ItemInfo item, final long container, + final int screen, final int cellX, final int cellY, final boolean notify) { + item.container = container; + item.cellX = cellX; + item.cellY = cellY; + // We store hotseat items in canonical form which is this orientation invariant position + // in the hotseat + if (context instanceof Launcher && screen < 0 && + container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + item.screen = ((Launcher) context).getHotseat().getOrderInHotseat(cellX, cellY); + } else { + item.screen = screen; + } + + final ContentValues values = new ContentValues(); + final ContentResolver cr = context.getContentResolver(); + item.onAddToDatabase(values); + + LauncherApplication app = (LauncherApplication) context.getApplicationContext(); + item.id = app.getLauncherProvider().generateNewId(); + values.put(LauncherSettings.Favorites._ID, item.id); + item.updateValuesWithCoordinates(values, item.cellX, item.cellY); + + Runnable r = new Runnable() { + public void run() { + cr.insert(notify ? LauncherSettings.Favorites.CONTENT_URI : + LauncherSettings.Favorites.CONTENT_URI_NO_NOTIFICATION, values); + + if (sItemsIdMap.containsKey(item.id)) { + // we should not be adding new items in the db with the same id + throw new RuntimeException("Error: ItemInfo id (" + item.id + ") passed to " + + "addItemToDatabase already exists." + item.toString()); + } + sItemsIdMap.put(item.id, item); + switch (item.itemType) { + case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: + sFolders.put(item.id, (FolderInfo) item); + // Fall through + case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION: + case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT: + if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP || + item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + sWorkspaceItems.add(item); + } + break; + case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET: + sAppWidgets.add((LauncherAppWidgetInfo) item); + break; + } + } + }; + + if (sWorkerThread.getThreadId() == Process.myTid()) { + r.run(); + } else { + sWorker.post(r); + } + } + + /** + * Creates a new unique child id, for a given cell span across all layouts. + */ + static int getCellLayoutChildId( + long container, int screen, int localCellX, int localCellY, int spanX, int spanY) { + return (((int) container & 0xFF) << 24) + | (screen & 0xFF) << 16 | (localCellX & 0xFF) << 8 | (localCellY & 0xFF); + } + + static int getCellCountX() { + return mCellCountX; + } + + static int getCellCountY() { + return mCellCountY; + } + + /** + * Updates the model orientation helper to take into account the current layout dimensions + * when performing local/canonical coordinate transformations. + */ + static void updateWorkspaceLayoutCells(int shortAxisCellCount, int longAxisCellCount) { + mCellCountX = shortAxisCellCount; + mCellCountY = longAxisCellCount; + } + + /** + * Removes the specified item from the database + * @param context + * @param item + */ + static void deleteItemFromDatabase(Context context, final ItemInfo item) { + final ContentResolver cr = context.getContentResolver(); + final Uri uriToDelete = LauncherSettings.Favorites.getContentUri(item.id, false); + Runnable r = new Runnable() { + public void run() { + cr.delete(uriToDelete, null, null); + switch (item.itemType) { + case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: + sFolders.remove(item.id); + sWorkspaceItems.remove(item); + break; + case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION: + case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT: + sWorkspaceItems.remove(item); + break; + case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET: + sAppWidgets.remove((LauncherAppWidgetInfo) item); + break; + } + sItemsIdMap.remove(item.id); + sDbIconCache.remove(item); + } + }; + if (sWorkerThread.getThreadId() == Process.myTid()) { + r.run(); + } else { + sWorker.post(r); + } + } + + /** + * Remove the contents of the specified folder from the database + */ + static void deleteFolderContentsFromDatabase(Context context, final FolderInfo info) { + final ContentResolver cr = context.getContentResolver(); + + Runnable r = new Runnable() { + public void run() { + cr.delete(LauncherSettings.Favorites.getContentUri(info.id, false), null, null); + sItemsIdMap.remove(info.id); + sFolders.remove(info.id); + sDbIconCache.remove(info); + sWorkspaceItems.remove(info); + + cr.delete(LauncherSettings.Favorites.CONTENT_URI_NO_NOTIFICATION, + LauncherSettings.Favorites.CONTAINER + "=" + info.id, null); + for (ItemInfo childInfo : info.contents) { + sItemsIdMap.remove(childInfo.id); + sDbIconCache.remove(childInfo); + } + } + }; + if (sWorkerThread.getThreadId() == Process.myTid()) { + r.run(); + } else { + sWorker.post(r); + } + } + + /** + * Set this as the current Launcher activity object for the loader. + */ + public void initialize(Callbacks callbacks) { + synchronized (mLock) { + mCallbacks = new WeakReference<Callbacks>(callbacks); + } + } + + /** + * Call from the handler for ACTION_PACKAGE_ADDED, ACTION_PACKAGE_REMOVED and + * ACTION_PACKAGE_CHANGED. + */ + @Override + public void onReceive(Context context, Intent intent) { + if (DEBUG_LOADERS) Log.d(TAG, "onReceive intent=" + intent); + + final String action = intent.getAction(); + + if (Intent.ACTION_PACKAGE_CHANGED.equals(action) + || Intent.ACTION_PACKAGE_REMOVED.equals(action) + || Intent.ACTION_PACKAGE_ADDED.equals(action)) { + final String packageName = intent.getData().getSchemeSpecificPart(); + final boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false); + + int op = PackageUpdatedTask.OP_NONE; + + if (packageName == null || packageName.length() == 0) { + // they sent us a bad intent + return; + } + + if (Intent.ACTION_PACKAGE_CHANGED.equals(action)) { + op = PackageUpdatedTask.OP_UPDATE; + } else if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) { + if (!replacing) { + op = PackageUpdatedTask.OP_REMOVE; + } + // else, we are replacing the package, so a PACKAGE_ADDED will be sent + // later, we will update the package at this time + } else if (Intent.ACTION_PACKAGE_ADDED.equals(action)) { + if (!replacing) { + op = PackageUpdatedTask.OP_ADD; + } else { + op = PackageUpdatedTask.OP_UPDATE; + } + } + + if (op != PackageUpdatedTask.OP_NONE) { + enqueuePackageUpdated(new PackageUpdatedTask(op, new String[] { packageName })); + } + + } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) { + // First, schedule to add these apps back in. + String[] packages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); + enqueuePackageUpdated(new PackageUpdatedTask(PackageUpdatedTask.OP_ADD, packages)); + // Then, rebind everything. + startLoaderFromBackground(); + } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) { + String[] packages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); + enqueuePackageUpdated(new PackageUpdatedTask( + PackageUpdatedTask.OP_UNAVAILABLE, packages)); + } else if (Intent.ACTION_LOCALE_CHANGED.equals(action)) { + // If we have changed locale we need to clear out the labels in all apps/workspace. + forceReload(); + } else if (Intent.ACTION_CONFIGURATION_CHANGED.equals(action)) { + // Check if configuration change was an mcc/mnc change which would affect app resources + // and we would need to clear out the labels in all apps/workspace. Same handling as + // above for ACTION_LOCALE_CHANGED + Configuration currentConfig = context.getResources().getConfiguration(); + if (mPreviousConfigMcc != currentConfig.mcc) { + Log.d(TAG, "Reload apps on config change. curr_mcc:" + + currentConfig.mcc + " prevmcc:" + mPreviousConfigMcc); + forceReload(); + } + // Update previousConfig + mPreviousConfigMcc = currentConfig.mcc; + } else if (SearchManager.INTENT_GLOBAL_SEARCH_ACTIVITY_CHANGED.equals(action) || + SearchManager.INTENT_ACTION_SEARCHABLES_CHANGED.equals(action)) { + if (mCallbacks != null) { + Callbacks callbacks = mCallbacks.get(); + if (callbacks != null) { + callbacks.bindSearchablesChanged(); + } + } + } + } + + private void forceReload() { + resetLoadedState(true, true); + + // Do this here because if the launcher activity is running it will be restarted. + // If it's not running startLoaderFromBackground will merely tell it that it needs + // to reload. + startLoaderFromBackground(); + } + + public void resetLoadedState(boolean resetAllAppsLoaded, boolean resetWorkspaceLoaded) { + synchronized (mLock) { + // Stop any existing loaders first, so they don't set mAllAppsLoaded or + // mWorkspaceLoaded to true later + stopLoaderLocked(); + if (resetAllAppsLoaded) mAllAppsLoaded = false; + if (resetWorkspaceLoaded) mWorkspaceLoaded = false; + } + } + + /** + * When the launcher is in the background, it's possible for it to miss paired + * configuration changes. So whenever we trigger the loader from the background + * tell the launcher that it needs to re-run the loader when it comes back instead + * of doing it now. + */ + public void startLoaderFromBackground() { + boolean runLoader = false; + if (mCallbacks != null) { + Callbacks callbacks = mCallbacks.get(); + if (callbacks != null) { + // Only actually run the loader if they're not paused. + if (!callbacks.setLoadOnResume()) { + runLoader = true; + } + } + } + if (runLoader) { + startLoader(false); + } + } + + // If there is already a loader task running, tell it to stop. + // returns true if isLaunching() was true on the old task + private boolean stopLoaderLocked() { + boolean isLaunching = false; + LoaderTask oldTask = mLoaderTask; + if (oldTask != null) { + if (oldTask.isLaunching()) { + isLaunching = true; + } + oldTask.stopLocked(); + } + return isLaunching; + } + + public void startLoader(boolean isLaunching) { + synchronized (mLock) { + if (DEBUG_LOADERS) { + Log.d(TAG, "startLoader isLaunching=" + isLaunching); + } + + // Don't bother to start the thread if we know it's not going to do anything + if (mCallbacks != null && mCallbacks.get() != null) { + // If there is already one running, tell it to stop. + // also, don't downgrade isLaunching if we're already running + isLaunching = isLaunching || stopLoaderLocked(); + mLoaderTask = new LoaderTask(mApp, isLaunching); + sWorkerThread.setPriority(Thread.NORM_PRIORITY); + sWorker.post(mLoaderTask); + } + } + } + + public void stopLoader() { + synchronized (mLock) { + if (mLoaderTask != null) { + mLoaderTask.stopLocked(); + } + } + } + + public boolean isAllAppsLoaded() { + return mAllAppsLoaded; + } + + boolean isLoadingWorkspace() { + synchronized (mLock) { + if (mLoaderTask != null) { + return mLoaderTask.isLoadingWorkspace(); + } + } + return false; + } + + /** + * Runnable for the thread that loads the contents of the launcher: + * - workspace icons + * - widgets + * - all apps icons + */ + private class LoaderTask implements Runnable { + private Context mContext; + private Thread mWaitThread; + private boolean mIsLaunching; + private boolean mIsLoadingAndBindingWorkspace; + private boolean mStopped; + private boolean mLoadAndBindStepFinished; + private HashMap<Object, CharSequence> mLabelCache; + + LoaderTask(Context context, boolean isLaunching) { + mContext = context; + mIsLaunching = isLaunching; + mLabelCache = new HashMap<Object, CharSequence>(); + } + + boolean isLaunching() { + return mIsLaunching; + } + + boolean isLoadingWorkspace() { + return mIsLoadingAndBindingWorkspace; + } + + private void loadAndBindWorkspace() { + mIsLoadingAndBindingWorkspace = true; + + // Load the workspace + if (DEBUG_LOADERS) { + Log.d(TAG, "loadAndBindWorkspace mWorkspaceLoaded=" + mWorkspaceLoaded); + } + + if (!mWorkspaceLoaded) { + loadWorkspace(); + synchronized (LoaderTask.this) { + if (mStopped) { + return; + } + mWorkspaceLoaded = true; + } + } + + // Bind the workspace + bindWorkspace(); + } + + private void waitForIdle() { + // Wait until the either we're stopped or the other threads are done. + // This way we don't start loading all apps until the workspace has settled + // down. + synchronized (LoaderTask.this) { + final long workspaceWaitTime = DEBUG_LOADERS ? SystemClock.uptimeMillis() : 0; + + mHandler.postIdle(new Runnable() { + public void run() { + synchronized (LoaderTask.this) { + mLoadAndBindStepFinished = true; + if (DEBUG_LOADERS) { + Log.d(TAG, "done with previous binding step"); + } + LoaderTask.this.notify(); + } + } + }); + + while (!mStopped && !mLoadAndBindStepFinished) { + try { + this.wait(); + } catch (InterruptedException ex) { + // Ignore + } + } + if (DEBUG_LOADERS) { + Log.d(TAG, "waited " + + (SystemClock.uptimeMillis()-workspaceWaitTime) + + "ms for previous step to finish binding"); + } + } + } + + public void run() { + // Optimize for end-user experience: if the Launcher is up and // running with the + // All Apps interface in the foreground, load All Apps first. Otherwise, load the + // workspace first (default). + final Callbacks cbk = mCallbacks.get(); + final boolean loadWorkspaceFirst = cbk != null ? (!cbk.isAllAppsVisible()) : true; + + keep_running: { + // Elevate priority when Home launches for the first time to avoid + // starving at boot time. Staring at a blank home is not cool. + synchronized (mLock) { + if (DEBUG_LOADERS) Log.d(TAG, "Setting thread priority to " + + (mIsLaunching ? "DEFAULT" : "BACKGROUND")); + android.os.Process.setThreadPriority(mIsLaunching + ? Process.THREAD_PRIORITY_DEFAULT : Process.THREAD_PRIORITY_BACKGROUND); + } + if (loadWorkspaceFirst) { + if (DEBUG_LOADERS) Log.d(TAG, "step 1: loading workspace"); + loadAndBindWorkspace(); + } else { + if (DEBUG_LOADERS) Log.d(TAG, "step 1: special: loading all apps"); + loadAndBindAllApps(); + } + + if (mStopped) { + break keep_running; + } + + // Whew! Hard work done. Slow us down, and wait until the UI thread has + // settled down. + synchronized (mLock) { + if (mIsLaunching) { + if (DEBUG_LOADERS) Log.d(TAG, "Setting thread priority to BACKGROUND"); + android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); + } + } + waitForIdle(); + + // second step + if (loadWorkspaceFirst) { + if (DEBUG_LOADERS) Log.d(TAG, "step 2: loading all apps"); + loadAndBindAllApps(); + } else { + if (DEBUG_LOADERS) Log.d(TAG, "step 2: special: loading workspace"); + loadAndBindWorkspace(); + } + + // Restore the default thread priority after we are done loading items + synchronized (mLock) { + android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT); + } + } + + + // Update the saved icons if necessary + if (DEBUG_LOADERS) Log.d(TAG, "Comparing loaded icons to database icons"); + for (Object key : sDbIconCache.keySet()) { + updateSavedIcon(mContext, (ShortcutInfo) key, sDbIconCache.get(key)); + } + sDbIconCache.clear(); + + // Clear out this reference, otherwise we end up holding it until all of the + // callback runnables are done. + mContext = null; + + synchronized (mLock) { + // If we are still the last one to be scheduled, remove ourselves. + if (mLoaderTask == this) { + mLoaderTask = null; + } + } + } + + public void stopLocked() { + synchronized (LoaderTask.this) { + mStopped = true; + this.notify(); + } + } + + /** + * Gets the callbacks object. If we've been stopped, or if the launcher object + * has somehow been garbage collected, return null instead. Pass in the Callbacks + * object that was around when the deferred message was scheduled, and if there's + * a new Callbacks object around then also return null. This will save us from + * calling onto it with data that will be ignored. + */ + Callbacks tryGetCallbacks(Callbacks oldCallbacks) { + synchronized (mLock) { + if (mStopped) { + return null; + } + + if (mCallbacks == null) { + return null; + } + + final Callbacks callbacks = mCallbacks.get(); + if (callbacks != oldCallbacks) { + return null; + } + if (callbacks == null) { + Log.w(TAG, "no mCallbacks"); + return null; + } + + return callbacks; + } + } + + // check & update map of what's occupied; used to discard overlapping/invalid items + private boolean checkItemPlacement(ItemInfo occupied[][][], ItemInfo item) { + int containerIndex = item.screen; + if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + // Return early if we detect that an item is under the hotseat button + if (mCallbacks == null || mCallbacks.get().isAllAppsButtonRank(item.screen)) { + return false; + } + + // We use the last index to refer to the hotseat and the screen as the rank, so + // test and update the occupied state accordingly + if (occupied[Launcher.SCREEN_COUNT][item.screen][0] != null) { + Log.e(TAG, "Error loading shortcut into hotseat " + item + + " into position (" + item.screen + ":" + item.cellX + "," + item.cellY + + ") occupied by " + occupied[Launcher.SCREEN_COUNT][item.screen][0]); + return false; + } else { + occupied[Launcher.SCREEN_COUNT][item.screen][0] = item; + return true; + } + } else if (item.container != LauncherSettings.Favorites.CONTAINER_DESKTOP) { + // Skip further checking if it is not the hotseat or workspace container + return true; + } + + // Check if any workspace icons overlap with each other + for (int x = item.cellX; x < (item.cellX+item.spanX); x++) { + for (int y = item.cellY; y < (item.cellY+item.spanY); y++) { + if (occupied[containerIndex][x][y] != null) { + Log.e(TAG, "Error loading shortcut " + item + + " into cell (" + containerIndex + "-" + item.screen + ":" + + x + "," + y + + ") occupied by " + + occupied[containerIndex][x][y]); + return false; + } + } + } + for (int x = item.cellX; x < (item.cellX+item.spanX); x++) { + for (int y = item.cellY; y < (item.cellY+item.spanY); y++) { + occupied[containerIndex][x][y] = item; + } + } + + return true; + } + + private void loadWorkspace() { + final long t = DEBUG_LOADERS ? SystemClock.uptimeMillis() : 0; + + final Context context = mContext; + final ContentResolver contentResolver = context.getContentResolver(); + final PackageManager manager = context.getPackageManager(); + final AppWidgetManager widgets = AppWidgetManager.getInstance(context); + final boolean isSafeMode = manager.isSafeMode(); + + // Make sure the default workspace is loaded, if needed + mApp.getLauncherProvider().loadDefaultFavoritesIfNecessary(); + + sWorkspaceItems.clear(); + sAppWidgets.clear(); + sFolders.clear(); + sItemsIdMap.clear(); + sDbIconCache.clear(); + + final ArrayList<Long> itemsToRemove = new ArrayList<Long>(); + + final Cursor c = contentResolver.query( + LauncherSettings.Favorites.CONTENT_URI, null, null, null, null); + + // +1 for the hotseat (it can be larger than the workspace) + // Load workspace in reverse order to ensure that latest items are loaded first (and + // before any earlier duplicates) + final ItemInfo occupied[][][] = + new ItemInfo[Launcher.SCREEN_COUNT + 1][mCellCountX + 1][mCellCountY + 1]; + + try { + final int idIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites._ID); + final int intentIndex = c.getColumnIndexOrThrow + (LauncherSettings.Favorites.INTENT); + final int titleIndex = c.getColumnIndexOrThrow + (LauncherSettings.Favorites.TITLE); + final int iconTypeIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.ICON_TYPE); + final int iconIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ICON); + final int iconPackageIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.ICON_PACKAGE); + final int iconResourceIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.ICON_RESOURCE); + final int containerIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.CONTAINER); + final int itemTypeIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.ITEM_TYPE); + final int appWidgetIdIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.APPWIDGET_ID); + final int screenIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.SCREEN); + final int cellXIndex = c.getColumnIndexOrThrow + (LauncherSettings.Favorites.CELLX); + final int cellYIndex = c.getColumnIndexOrThrow + (LauncherSettings.Favorites.CELLY); + final int spanXIndex = c.getColumnIndexOrThrow + (LauncherSettings.Favorites.SPANX); + final int spanYIndex = c.getColumnIndexOrThrow( + LauncherSettings.Favorites.SPANY); + //final int uriIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.URI); + //final int displayModeIndex = c.getColumnIndexOrThrow( + // LauncherSettings.Favorites.DISPLAY_MODE); + + ShortcutInfo info; + String intentDescription; + LauncherAppWidgetInfo appWidgetInfo; + int container; + long id; + Intent intent; + + while (!mStopped && c.moveToNext()) { + try { + int itemType = c.getInt(itemTypeIndex); + + switch (itemType) { + case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION: + case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT: + intentDescription = c.getString(intentIndex); + try { + intent = Intent.parseUri(intentDescription, 0); + } catch (URISyntaxException e) { + continue; + } + + if (itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION) { + info = getShortcutInfo(manager, intent, context, c, iconIndex, + titleIndex, mLabelCache); + } else { + info = getShortcutInfo(c, context, iconTypeIndex, + iconPackageIndex, iconResourceIndex, iconIndex, + titleIndex); + + // App shortcuts that used to be automatically added to Launcher + // didn't always have the correct intent flags set, so do that here + if (intent.getAction() != null && + intent.getCategories() != null && + intent.getAction().equals(Intent.ACTION_MAIN) && + intent.getCategories().contains(Intent.CATEGORY_LAUNCHER)) { + intent.addFlags( + Intent.FLAG_ACTIVITY_NEW_TASK | + Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); + } + } + + if (info != null) { + info.intent = intent; + info.id = c.getLong(idIndex); + container = c.getInt(containerIndex); + info.container = container; + info.screen = c.getInt(screenIndex); + info.cellX = c.getInt(cellXIndex); + info.cellY = c.getInt(cellYIndex); + + // check & update map of what's occupied + if (!checkItemPlacement(occupied, info)) { + break; + } + + switch (container) { + case LauncherSettings.Favorites.CONTAINER_DESKTOP: + case LauncherSettings.Favorites.CONTAINER_HOTSEAT: + sWorkspaceItems.add(info); + break; + default: + // Item is in a user folder + FolderInfo folderInfo = + findOrMakeFolder(sFolders, container); + folderInfo.add(info); + break; + } + sItemsIdMap.put(info.id, info); + + // now that we've loaded everthing re-save it with the + // icon in case it disappears somehow. + queueIconToBeChecked(sDbIconCache, info, c, iconIndex); + } else { + // Failed to load the shortcut, probably because the + // activity manager couldn't resolve it (maybe the app + // was uninstalled), or the db row was somehow screwed up. + // Delete it. + id = c.getLong(idIndex); + Log.e(TAG, "Error loading shortcut " + id + ", removing it"); + contentResolver.delete(LauncherSettings.Favorites.getContentUri( + id, false), null, null); + } + break; + + case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: + id = c.getLong(idIndex); + FolderInfo folderInfo = findOrMakeFolder(sFolders, id); + + folderInfo.title = c.getString(titleIndex); + folderInfo.id = id; + container = c.getInt(containerIndex); + folderInfo.container = container; + folderInfo.screen = c.getInt(screenIndex); + folderInfo.cellX = c.getInt(cellXIndex); + folderInfo.cellY = c.getInt(cellYIndex); + + // check & update map of what's occupied + if (!checkItemPlacement(occupied, folderInfo)) { + break; + } + switch (container) { + case LauncherSettings.Favorites.CONTAINER_DESKTOP: + case LauncherSettings.Favorites.CONTAINER_HOTSEAT: + sWorkspaceItems.add(folderInfo); + break; + } + + sItemsIdMap.put(folderInfo.id, folderInfo); + sFolders.put(folderInfo.id, folderInfo); + break; + + case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET: + // Read all Launcher-specific widget details + int appWidgetId = c.getInt(appWidgetIdIndex); + id = c.getLong(idIndex); + + final AppWidgetProviderInfo provider = + widgets.getAppWidgetInfo(appWidgetId); + + if (!isSafeMode && (provider == null || provider.provider == null || + provider.provider.getPackageName() == null)) { + String log = "Deleting widget that isn't installed anymore: id=" + + id + " appWidgetId=" + appWidgetId; + Log.e(TAG, log); + Launcher.sDumpLogs.add(log); + itemsToRemove.add(id); + } else { + appWidgetInfo = new LauncherAppWidgetInfo(appWidgetId, + provider.provider); + appWidgetInfo.id = id; + appWidgetInfo.screen = c.getInt(screenIndex); + appWidgetInfo.cellX = c.getInt(cellXIndex); + appWidgetInfo.cellY = c.getInt(cellYIndex); + appWidgetInfo.spanX = c.getInt(spanXIndex); + appWidgetInfo.spanY = c.getInt(spanYIndex); + int[] minSpan = Launcher.getMinSpanForWidget(context, provider); + appWidgetInfo.minSpanX = minSpan[0]; + appWidgetInfo.minSpanY = minSpan[1]; + + container = c.getInt(containerIndex); + if (container != LauncherSettings.Favorites.CONTAINER_DESKTOP && + container != LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + Log.e(TAG, "Widget found where container " + + "!= CONTAINER_DESKTOP nor CONTAINER_HOTSEAT - ignoring!"); + continue; + } + appWidgetInfo.container = c.getInt(containerIndex); + + // check & update map of what's occupied + if (!checkItemPlacement(occupied, appWidgetInfo)) { + break; + } + sItemsIdMap.put(appWidgetInfo.id, appWidgetInfo); + sAppWidgets.add(appWidgetInfo); + } + break; + } + } catch (Exception e) { + Log.w(TAG, "Desktop items loading interrupted:", e); + } + } + } finally { + c.close(); + } + + if (itemsToRemove.size() > 0) { + ContentProviderClient client = contentResolver.acquireContentProviderClient( + LauncherSettings.Favorites.CONTENT_URI); + // Remove dead items + for (long id : itemsToRemove) { + if (DEBUG_LOADERS) { + Log.d(TAG, "Removed id = " + id); + } + // Don't notify content observers + try { + client.delete(LauncherSettings.Favorites.getContentUri(id, false), + null, null); + } catch (RemoteException e) { + Log.w(TAG, "Could not remove id = " + id); + } + } + } + + if (DEBUG_LOADERS) { + Log.d(TAG, "loaded workspace in " + (SystemClock.uptimeMillis()-t) + "ms"); + Log.d(TAG, "workspace layout: "); + for (int y = 0; y < mCellCountY; y++) { + String line = ""; + for (int s = 0; s < Launcher.SCREEN_COUNT; s++) { + if (s > 0) { + line += " | "; + } + for (int x = 0; x < mCellCountX; x++) { + line += ((occupied[s][x][y] != null) ? "#" : "."); + } + } + Log.d(TAG, "[ " + line + " ]"); + } + } + } + + /** + * Read everything out of our database. + */ + private void bindWorkspace() { + final long t = SystemClock.uptimeMillis(); + + // Don't use these two variables in any of the callback runnables. + // Otherwise we hold a reference to them. + final Callbacks oldCallbacks = mCallbacks.get(); + if (oldCallbacks == null) { + // This launcher has exited and nobody bothered to tell us. Just bail. + Log.w(TAG, "LoaderTask running with no launcher"); + return; + } + + // Get the list of workspace items to load and unbind the existing ShortcutInfos + // before we call startBinding() below. + final int currentScreen = oldCallbacks.getCurrentWorkspaceScreen(); + final ArrayList<ItemInfo> tmpWorkspaceItems = unbindWorkspaceItemsOnMainThread(); + // Order the items for loading as follows: current workspace, hotseat, everything else + Collections.sort(tmpWorkspaceItems, new Comparator<ItemInfo>() { + @Override + public int compare(ItemInfo lhs, ItemInfo rhs) { + int cellCountX = LauncherModel.getCellCountX(); + int cellCountY = LauncherModel.getCellCountY(); + int screenOffset = cellCountX * cellCountY; + int containerOffset = screenOffset * (Launcher.SCREEN_COUNT + 1); // +1 hotseat + long lr = (lhs.container * containerOffset + lhs.screen * screenOffset + + lhs.cellY * cellCountX + lhs.cellX); + long rr = (rhs.container * containerOffset + rhs.screen * screenOffset + + rhs.cellY * cellCountX + rhs.cellX); + return (int) (lr - rr); + } + }); + // Precondition: the items are ordered by page, screen + final ArrayList<ItemInfo> workspaceItems = new ArrayList<ItemInfo>(); + for (ItemInfo ii : tmpWorkspaceItems) { + // Prepend the current items, hotseat items, append everything else + if (ii.container == LauncherSettings.Favorites.CONTAINER_DESKTOP && + ii.screen == currentScreen) { + workspaceItems.add(0, ii); + } else if (ii.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { + workspaceItems.add(0, ii); + } else { + workspaceItems.add(ii); + } + } + + // Tell the workspace that we're about to start firing items at it + mHandler.post(new Runnable() { + public void run() { + Callbacks callbacks = tryGetCallbacks(oldCallbacks); + if (callbacks != null) { + callbacks.startBinding(); + } + } + }); + + // Add the items to the workspace. + int N = workspaceItems.size(); + for (int i=0; i<N; i+=ITEMS_CHUNK) { + final int start = i; + final int chunkSize = (i+ITEMS_CHUNK <= N) ? ITEMS_CHUNK : (N-i); + mHandler.post(new Runnable() { + public void run() { + Callbacks callbacks = tryGetCallbacks(oldCallbacks); + if (callbacks != null) { + callbacks.bindItems(workspaceItems, start, start+chunkSize); + } + } + }); + } + // Ensure that we don't use the same folders data structure on the main thread + final HashMap<Long, FolderInfo> folders = new HashMap<Long, FolderInfo>(sFolders); + mHandler.post(new Runnable() { + public void run() { + Callbacks callbacks = tryGetCallbacks(oldCallbacks); + if (callbacks != null) { + callbacks.bindFolders(folders); + } + } + }); + // Wait until the queue goes empty. + mHandler.post(new Runnable() { + public void run() { + if (DEBUG_LOADERS) { + Log.d(TAG, "Going to start binding widgets soon."); + } + } + }); + // Bind the widgets, one at a time. + // WARNING: this is calling into the workspace from the background thread, + // but since getCurrentScreen() just returns the int, we should be okay. This + // is just a hint for the order, and if it's wrong, we'll be okay. + // TODO: instead, we should have that push the current screen into here. + N = sAppWidgets.size(); + // once for the current screen + for (int i=0; i<N; i++) { + final LauncherAppWidgetInfo widget = sAppWidgets.get(i); + if (widget.screen == currentScreen) { + mHandler.post(new Runnable() { + public void run() { + Callbacks callbacks = tryGetCallbacks(oldCallbacks); + if (callbacks != null) { + callbacks.bindAppWidget(widget); + } + } + }); + } + } + // once for the other screens + for (int i=0; i<N; i++) { + final LauncherAppWidgetInfo widget = sAppWidgets.get(i); + if (widget.screen != currentScreen) { + mHandler.post(new Runnable() { + public void run() { + Callbacks callbacks = tryGetCallbacks(oldCallbacks); + if (callbacks != null) { + callbacks.bindAppWidget(widget); + } + } + }); + } + } + // Tell the workspace that we're done. + mHandler.post(new Runnable() { + public void run() { + Callbacks callbacks = tryGetCallbacks(oldCallbacks); + if (callbacks != null) { + callbacks.finishBindingItems(); + } + } + }); + // Cleanup + mHandler.post(new Runnable() { + public void run() { + // If we're profiling, ensure this is the last thing in the queue. + if (DEBUG_LOADERS) { + Log.d(TAG, "bound workspace in " + + (SystemClock.uptimeMillis()-t) + "ms"); + } + + mIsLoadingAndBindingWorkspace = false; + } + }); + } + + private void loadAndBindAllApps() { + if (DEBUG_LOADERS) { + Log.d(TAG, "loadAndBindAllApps mAllAppsLoaded=" + mAllAppsLoaded); + } + if (!mAllAppsLoaded) { + loadAllAppsByBatch(); + synchronized (LoaderTask.this) { + if (mStopped) { + return; + } + mAllAppsLoaded = true; + } + } else { + onlyBindAllApps(); + } + } + + private void onlyBindAllApps() { + final Callbacks oldCallbacks = mCallbacks.get(); + if (oldCallbacks == null) { + // This launcher has exited and nobody bothered to tell us. Just bail. + Log.w(TAG, "LoaderTask running with no launcher (onlyBindAllApps)"); + return; + } + + // shallow copy + @SuppressWarnings("unchecked") + final ArrayList<ApplicationInfo> list + = (ArrayList<ApplicationInfo>) mAllAppsList.data.clone(); + mHandler.post(new Runnable() { + public void run() { + final long t = SystemClock.uptimeMillis(); + final Callbacks callbacks = tryGetCallbacks(oldCallbacks); + if (callbacks != null) { + callbacks.bindAllApplications(list); + } + if (DEBUG_LOADERS) { + Log.d(TAG, "bound all " + list.size() + " apps from cache in " + + (SystemClock.uptimeMillis()-t) + "ms"); + } + } + }); + + } + + private void loadAllAppsByBatch() { + final long t = DEBUG_LOADERS ? SystemClock.uptimeMillis() : 0; + + // Don't use these two variables in any of the callback runnables. + // Otherwise we hold a reference to them. + final Callbacks oldCallbacks = mCallbacks.get(); + if (oldCallbacks == null) { + // This launcher has exited and nobody bothered to tell us. Just bail. + Log.w(TAG, "LoaderTask running with no launcher (loadAllAppsByBatch)"); + return; + } + + final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null); + mainIntent.addCategory(Intent.CATEGORY_LAUNCHER); + + final PackageManager packageManager = mContext.getPackageManager(); + List<ResolveInfo> apps = null; + + int N = Integer.MAX_VALUE; + + int startIndex; + int i=0; + int batchSize = -1; + while (i < N && !mStopped) { + if (i == 0) { + mAllAppsList.clear(); + final long qiaTime = DEBUG_LOADERS ? SystemClock.uptimeMillis() : 0; + apps = packageManager.queryIntentActivities(mainIntent, 0); + if (DEBUG_LOADERS) { + Log.d(TAG, "queryIntentActivities took " + + (SystemClock.uptimeMillis()-qiaTime) + "ms"); + } + if (apps == null) { + return; + } + N = apps.size(); + if (DEBUG_LOADERS) { + Log.d(TAG, "queryIntentActivities got " + N + " apps"); + } + if (N == 0) { + // There are no apps?!? + return; + } + if (mBatchSize == 0) { + batchSize = N; + } else { + batchSize = mBatchSize; + } + + final long sortTime = DEBUG_LOADERS ? SystemClock.uptimeMillis() : 0; + Collections.sort(apps, + new LauncherModel.ShortcutNameComparator(packageManager, mLabelCache)); + if (DEBUG_LOADERS) { + Log.d(TAG, "sort took " + + (SystemClock.uptimeMillis()-sortTime) + "ms"); + } + } + + final long t2 = DEBUG_LOADERS ? SystemClock.uptimeMillis() : 0; + + startIndex = i; + for (int j=0; i<N && j<batchSize; j++) { + // This builds the icon bitmaps. + mAllAppsList.add(new ApplicationInfo(packageManager, apps.get(i), + mIconCache, mLabelCache)); + i++; + } + + final boolean first = i <= batchSize; + final Callbacks callbacks = tryGetCallbacks(oldCallbacks); + final ArrayList<ApplicationInfo> added = mAllAppsList.added; + mAllAppsList.added = new ArrayList<ApplicationInfo>(); + + mHandler.post(new Runnable() { + public void run() { + final long t = SystemClock.uptimeMillis(); + if (callbacks != null) { + if (first) { + callbacks.bindAllApplications(added); + } else { + callbacks.bindAppsAdded(added); + } + if (DEBUG_LOADERS) { + Log.d(TAG, "bound " + added.size() + " apps in " + + (SystemClock.uptimeMillis() - t) + "ms"); + } + } else { + Log.i(TAG, "not binding apps: no Launcher activity"); + } + } + }); + + if (DEBUG_LOADERS) { + Log.d(TAG, "batch of " + (i-startIndex) + " icons processed in " + + (SystemClock.uptimeMillis()-t2) + "ms"); + } + + if (mAllAppsLoadDelay > 0 && i < N) { + try { + if (DEBUG_LOADERS) { + Log.d(TAG, "sleeping for " + mAllAppsLoadDelay + "ms"); + } + Thread.sleep(mAllAppsLoadDelay); + } catch (InterruptedException exc) { } + } + } + + if (DEBUG_LOADERS) { + Log.d(TAG, "cached all " + N + " apps in " + + (SystemClock.uptimeMillis()-t) + "ms" + + (mAllAppsLoadDelay > 0 ? " (including delay)" : "")); + } + } + + public void dumpState() { + Log.d(TAG, "mLoaderTask.mContext=" + mContext); + Log.d(TAG, "mLoaderTask.mWaitThread=" + mWaitThread); + Log.d(TAG, "mLoaderTask.mIsLaunching=" + mIsLaunching); + Log.d(TAG, "mLoaderTask.mStopped=" + mStopped); + Log.d(TAG, "mLoaderTask.mLoadAndBindStepFinished=" + mLoadAndBindStepFinished); + Log.d(TAG, "mItems size=" + sWorkspaceItems.size()); + } + } + + void enqueuePackageUpdated(PackageUpdatedTask task) { + sWorker.post(task); + } + + private class PackageUpdatedTask implements Runnable { + int mOp; + String[] mPackages; + + public static final int OP_NONE = 0; + public static final int OP_ADD = 1; + public static final int OP_UPDATE = 2; + public static final int OP_REMOVE = 3; // uninstlled + public static final int OP_UNAVAILABLE = 4; // external media unmounted + + + public PackageUpdatedTask(int op, String[] packages) { + mOp = op; + mPackages = packages; + } + + public void run() { + final Context context = mApp; + + final String[] packages = mPackages; + final int N = packages.length; + switch (mOp) { + case OP_ADD: + for (int i=0; i<N; i++) { + if (DEBUG_LOADERS) Log.d(TAG, "mAllAppsList.addPackage " + packages[i]); + mAllAppsList.addPackage(context, packages[i]); + } + break; + case OP_UPDATE: + for (int i=0; i<N; i++) { + if (DEBUG_LOADERS) Log.d(TAG, "mAllAppsList.updatePackage " + packages[i]); + mAllAppsList.updatePackage(context, packages[i]); + } + break; + case OP_REMOVE: + case OP_UNAVAILABLE: + for (int i=0; i<N; i++) { + if (DEBUG_LOADERS) Log.d(TAG, "mAllAppsList.removePackage " + packages[i]); + mAllAppsList.removePackage(packages[i]); + } + break; + } + + ArrayList<ApplicationInfo> added = null; + ArrayList<ApplicationInfo> removed = null; + ArrayList<ApplicationInfo> modified = null; + + if (mAllAppsList.added.size() > 0) { + added = mAllAppsList.added; + mAllAppsList.added = new ArrayList<ApplicationInfo>(); + } + if (mAllAppsList.removed.size() > 0) { + removed = mAllAppsList.removed; + mAllAppsList.removed = new ArrayList<ApplicationInfo>(); + for (ApplicationInfo info: removed) { + mIconCache.remove(info.intent.getComponent()); + } + } + if (mAllAppsList.modified.size() > 0) { + modified = mAllAppsList.modified; + mAllAppsList.modified = new ArrayList<ApplicationInfo>(); + } + + final Callbacks callbacks = mCallbacks != null ? mCallbacks.get() : null; + if (callbacks == null) { + Log.w(TAG, "Nobody to tell about the new app. Launcher is probably loading."); + return; + } + + if (added != null) { + final ArrayList<ApplicationInfo> addedFinal = added; + mHandler.post(new Runnable() { + public void run() { + Callbacks cb = mCallbacks != null ? mCallbacks.get() : null; + if (callbacks == cb && cb != null) { + callbacks.bindAppsAdded(addedFinal); + } + } + }); + } + if (modified != null) { + final ArrayList<ApplicationInfo> modifiedFinal = modified; + mHandler.post(new Runnable() { + public void run() { + Callbacks cb = mCallbacks != null ? mCallbacks.get() : null; + if (callbacks == cb && cb != null) { + callbacks.bindAppsUpdated(modifiedFinal); + } + } + }); + } + if (removed != null) { + final boolean permanent = mOp != OP_UNAVAILABLE; + final ArrayList<ApplicationInfo> removedFinal = removed; + mHandler.post(new Runnable() { + public void run() { + Callbacks cb = mCallbacks != null ? mCallbacks.get() : null; + if (callbacks == cb && cb != null) { + callbacks.bindAppsRemoved(removedFinal, permanent); + } + } + }); + } + + mHandler.post(new Runnable() { + @Override + public void run() { + Callbacks cb = mCallbacks != null ? mCallbacks.get() : null; + if (callbacks == cb && cb != null) { + callbacks.bindPackagesUpdated(); + } + } + }); + } + } + + /** + * Returns all the Workspace ShortcutInfos associated with a particular package. + * @param intent + * @return + */ + ArrayList<ShortcutInfo> getShortcutInfosForPackage(String packageName) { + ArrayList<ShortcutInfo> infos = new ArrayList<ShortcutInfo>(); + for (ItemInfo i : sWorkspaceItems) { + if (i instanceof ShortcutInfo) { + ShortcutInfo info = (ShortcutInfo) i; + if (packageName.equals(info.getPackageName())) { + infos.add(info); + } + } + } + return infos; + } + + /** + * This is called from the code that adds shortcuts from the intent receiver. This + * doesn't have a Cursor, but + */ + public ShortcutInfo getShortcutInfo(PackageManager manager, Intent intent, Context context) { + return getShortcutInfo(manager, intent, context, null, -1, -1, null); + } + + /** + * Make an ShortcutInfo object for a shortcut that is an application. + * + * If c is not null, then it will be used to fill in missing data like the title and icon. + */ + public ShortcutInfo getShortcutInfo(PackageManager manager, Intent intent, Context context, + Cursor c, int iconIndex, int titleIndex, HashMap<Object, CharSequence> labelCache) { + Bitmap icon = null; + final ShortcutInfo info = new ShortcutInfo(); + + ComponentName componentName = intent.getComponent(); + if (componentName == null) { + return null; + } + + try { + PackageInfo pi = manager.getPackageInfo(componentName.getPackageName(), 0); + if (!pi.applicationInfo.enabled) { + // If we return null here, the corresponding item will be removed from the launcher + // db and will not appear in the workspace. + return null; + } + } catch (NameNotFoundException e) { + Log.d(TAG, "getPackInfo failed for package " + componentName.getPackageName()); + } + + // TODO: See if the PackageManager knows about this case. If it doesn't + // then return null & delete this. + + // the resource -- This may implicitly give us back the fallback icon, + // but don't worry about that. All we're doing with usingFallbackIcon is + // to avoid saving lots of copies of that in the database, and most apps + // have icons anyway. + + // Attempt to use queryIntentActivities to get the ResolveInfo (with IntentFilter info) and + // if that fails, or is ambiguious, fallback to the standard way of getting the resolve info + // via resolveActivity(). + ResolveInfo resolveInfo = null; + ComponentName oldComponent = intent.getComponent(); + Intent newIntent = new Intent(intent.getAction(), null); + newIntent.addCategory(Intent.CATEGORY_LAUNCHER); + newIntent.setPackage(oldComponent.getPackageName()); + List<ResolveInfo> infos = manager.queryIntentActivities(newIntent, 0); + for (ResolveInfo i : infos) { + ComponentName cn = new ComponentName(i.activityInfo.packageName, + i.activityInfo.name); + if (cn.equals(oldComponent)) { + resolveInfo = i; + } + } + if (resolveInfo == null) { + resolveInfo = manager.resolveActivity(intent, 0); + } + if (resolveInfo != null) { + icon = mIconCache.getIcon(componentName, resolveInfo, labelCache); + } + // the db + if (icon == null) { + if (c != null) { + icon = getIconFromCursor(c, iconIndex, context); + } + } + // the fallback icon + if (icon == null) { + icon = getFallbackIcon(); + info.usingFallbackIcon = true; + } + info.setIcon(icon); + + // from the resource + if (resolveInfo != null) { + ComponentName key = LauncherModel.getComponentNameFromResolveInfo(resolveInfo); + if (labelCache != null && labelCache.containsKey(key)) { + info.title = labelCache.get(key); + } else { + info.title = resolveInfo.activityInfo.loadLabel(manager); + if (labelCache != null) { + labelCache.put(key, info.title); + } + } + } + // from the db + if (info.title == null) { + if (c != null) { + info.title = c.getString(titleIndex); + } + } + // fall back to the class name of the activity + if (info.title == null) { + info.title = componentName.getClassName(); + } + info.itemType = LauncherSettings.Favorites.ITEM_TYPE_APPLICATION; + return info; + } + + /** + * Make an ShortcutInfo object for a shortcut that isn't an application. + */ + private ShortcutInfo getShortcutInfo(Cursor c, Context context, + int iconTypeIndex, int iconPackageIndex, int iconResourceIndex, int iconIndex, + int titleIndex) { + + Bitmap icon = null; + final ShortcutInfo info = new ShortcutInfo(); + info.itemType = LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT; + + // TODO: If there's an explicit component and we can't install that, delete it. + + info.title = c.getString(titleIndex); + + int iconType = c.getInt(iconTypeIndex); + switch (iconType) { + case LauncherSettings.Favorites.ICON_TYPE_RESOURCE: + String packageName = c.getString(iconPackageIndex); + String resourceName = c.getString(iconResourceIndex); + PackageManager packageManager = context.getPackageManager(); + info.customIcon = false; + // the resource + try { + Resources resources = packageManager.getResourcesForApplication(packageName); + if (resources != null) { + final int id = resources.getIdentifier(resourceName, null, null); + icon = Utilities.createIconBitmap( + mIconCache.getFullResIcon(resources, id), context); + } + } catch (Exception e) { + // drop this. we have other places to look for icons + } + // the db + if (icon == null) { + icon = getIconFromCursor(c, iconIndex, context); + } + // the fallback icon + if (icon == null) { + icon = getFallbackIcon(); + info.usingFallbackIcon = true; + } + break; + case LauncherSettings.Favorites.ICON_TYPE_BITMAP: + icon = getIconFromCursor(c, iconIndex, context); + if (icon == null) { + icon = getFallbackIcon(); + info.customIcon = false; + info.usingFallbackIcon = true; + } else { + info.customIcon = true; + } + break; + default: + icon = getFallbackIcon(); + info.usingFallbackIcon = true; + info.customIcon = false; + break; + } + info.setIcon(icon); + return info; + } + + Bitmap getIconFromCursor(Cursor c, int iconIndex, Context context) { + @SuppressWarnings("all") // suppress dead code warning + final boolean debug = false; + if (debug) { + Log.d(TAG, "getIconFromCursor app=" + + c.getString(c.getColumnIndexOrThrow(LauncherSettings.Favorites.TITLE))); + } + byte[] data = c.getBlob(iconIndex); + try { + return Utilities.createIconBitmap( + BitmapFactory.decodeByteArray(data, 0, data.length), context); + } catch (Exception e) { + return null; + } + } + + ShortcutInfo addShortcut(Context context, Intent data, long container, int screen, + int cellX, int cellY, boolean notify) { + final ShortcutInfo info = infoFromShortcutIntent(context, data, null); + if (info == null) { + return null; + } + addItemToDatabase(context, info, container, screen, cellX, cellY, notify); + + return info; + } + + /** + * Attempts to find an AppWidgetProviderInfo that matches the given component. + */ + AppWidgetProviderInfo findAppWidgetProviderInfoWithComponent(Context context, + ComponentName component) { + List<AppWidgetProviderInfo> widgets = + AppWidgetManager.getInstance(context).getInstalledProviders(); + for (AppWidgetProviderInfo info : widgets) { + if (info.provider.equals(component)) { + return info; + } + } + return null; + } + + /** + * Returns a list of all the widgets that can handle configuration with a particular mimeType. + */ + List<WidgetMimeTypeHandlerData> resolveWidgetsForMimeType(Context context, String mimeType) { + final PackageManager packageManager = context.getPackageManager(); + final List<WidgetMimeTypeHandlerData> supportedConfigurationActivities = + new ArrayList<WidgetMimeTypeHandlerData>(); + + final Intent supportsIntent = + new Intent(InstallWidgetReceiver.ACTION_SUPPORTS_CLIPDATA_MIMETYPE); + supportsIntent.setType(mimeType); + + // Create a set of widget configuration components that we can test against + final List<AppWidgetProviderInfo> widgets = + AppWidgetManager.getInstance(context).getInstalledProviders(); + final HashMap<ComponentName, AppWidgetProviderInfo> configurationComponentToWidget = + new HashMap<ComponentName, AppWidgetProviderInfo>(); + for (AppWidgetProviderInfo info : widgets) { + configurationComponentToWidget.put(info.configure, info); + } + + // Run through each of the intents that can handle this type of clip data, and cross + // reference them with the components that are actual configuration components + final List<ResolveInfo> activities = packageManager.queryIntentActivities(supportsIntent, + PackageManager.MATCH_DEFAULT_ONLY); + for (ResolveInfo info : activities) { + final ActivityInfo activityInfo = info.activityInfo; + final ComponentName infoComponent = new ComponentName(activityInfo.packageName, + activityInfo.name); + if (configurationComponentToWidget.containsKey(infoComponent)) { + supportedConfigurationActivities.add( + new InstallWidgetReceiver.WidgetMimeTypeHandlerData(info, + configurationComponentToWidget.get(infoComponent))); + } + } + return supportedConfigurationActivities; + } + + ShortcutInfo infoFromShortcutIntent(Context context, Intent data, Bitmap fallbackIcon) { + Intent intent = data.getParcelableExtra(Intent.EXTRA_SHORTCUT_INTENT); + String name = data.getStringExtra(Intent.EXTRA_SHORTCUT_NAME); + Parcelable bitmap = data.getParcelableExtra(Intent.EXTRA_SHORTCUT_ICON); + + if (intent == null) { + // If the intent is null, we can't construct a valid ShortcutInfo, so we return null + Log.e(TAG, "Can't construct ShorcutInfo with null intent"); + return null; + } + + Bitmap icon = null; + boolean customIcon = false; + ShortcutIconResource iconResource = null; + + if (bitmap != null && bitmap instanceof Bitmap) { + icon = Utilities.createIconBitmap(new FastBitmapDrawable((Bitmap)bitmap), context); + customIcon = true; + } else { + Parcelable extra = data.getParcelableExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE); + if (extra != null && extra instanceof ShortcutIconResource) { + try { + iconResource = (ShortcutIconResource) extra; + final PackageManager packageManager = context.getPackageManager(); + Resources resources = packageManager.getResourcesForApplication( + iconResource.packageName); + final int id = resources.getIdentifier(iconResource.resourceName, null, null); + icon = Utilities.createIconBitmap( + mIconCache.getFullResIcon(resources, id), context); + } catch (Exception e) { + Log.w(TAG, "Could not load shortcut icon: " + extra); + } + } + } + + final ShortcutInfo info = new ShortcutInfo(); + + if (icon == null) { + if (fallbackIcon != null) { + icon = fallbackIcon; + } else { + icon = getFallbackIcon(); + info.usingFallbackIcon = true; + } + } + info.setIcon(icon); + + info.title = name; + info.intent = intent; + info.customIcon = customIcon; + info.iconResource = iconResource; + + return info; + } + + boolean queueIconToBeChecked(HashMap<Object, byte[]> cache, ShortcutInfo info, Cursor c, + int iconIndex) { + // If apps can't be on SD, don't even bother. + if (!mAppsCanBeOnExternalStorage) { + return false; + } + // If this icon doesn't have a custom icon, check to see + // what's stored in the DB, and if it doesn't match what + // we're going to show, store what we are going to show back + // into the DB. We do this so when we're loading, if the + // package manager can't find an icon (for example because + // the app is on SD) then we can use that instead. + if (!info.customIcon && !info.usingFallbackIcon) { + cache.put(info, c.getBlob(iconIndex)); + return true; + } + return false; + } + void updateSavedIcon(Context context, ShortcutInfo info, byte[] data) { + boolean needSave = false; + try { + if (data != null) { + Bitmap saved = BitmapFactory.decodeByteArray(data, 0, data.length); + Bitmap loaded = info.getIcon(mIconCache); + needSave = !saved.sameAs(loaded); + } else { + needSave = true; + } + } catch (Exception e) { + needSave = true; + } + if (needSave) { + Log.d(TAG, "going to save icon bitmap for info=" + info); + // This is slower than is ideal, but this only happens once + // or when the app is updated with a new icon. + updateItemInDatabase(context, info); + } + } + + /** + * Return an existing FolderInfo object if we have encountered this ID previously, + * or make a new one. + */ + private static FolderInfo findOrMakeFolder(HashMap<Long, FolderInfo> folders, long id) { + // See if a placeholder was created for us already + FolderInfo folderInfo = folders.get(id); + if (folderInfo == null) { + // No placeholder -- create a new instance + folderInfo = new FolderInfo(); + folders.put(id, folderInfo); + } + return folderInfo; + } + + private static final Collator sCollator = Collator.getInstance(); + public static final Comparator<ApplicationInfo> APP_NAME_COMPARATOR + = new Comparator<ApplicationInfo>() { + public final int compare(ApplicationInfo a, ApplicationInfo b) { + int result = sCollator.compare(a.title.toString(), b.title.toString()); + if (result == 0) { + result = a.componentName.compareTo(b.componentName); + } + return result; + } + }; + public static final Comparator<ApplicationInfo> APP_INSTALL_TIME_COMPARATOR + = new Comparator<ApplicationInfo>() { + public final int compare(ApplicationInfo a, ApplicationInfo b) { + if (a.firstInstallTime < b.firstInstallTime) return 1; + if (a.firstInstallTime > b.firstInstallTime) return -1; + return 0; + } + }; + public static final Comparator<AppWidgetProviderInfo> WIDGET_NAME_COMPARATOR + = new Comparator<AppWidgetProviderInfo>() { + public final int compare(AppWidgetProviderInfo a, AppWidgetProviderInfo b) { + return sCollator.compare(a.label.toString(), b.label.toString()); + } + }; + static ComponentName getComponentNameFromResolveInfo(ResolveInfo info) { + if (info.activityInfo != null) { + return new ComponentName(info.activityInfo.packageName, info.activityInfo.name); + } else { + return new ComponentName(info.serviceInfo.packageName, info.serviceInfo.name); + } + } + public static class ShortcutNameComparator implements Comparator<ResolveInfo> { + private PackageManager mPackageManager; + private HashMap<Object, CharSequence> mLabelCache; + ShortcutNameComparator(PackageManager pm) { + mPackageManager = pm; + mLabelCache = new HashMap<Object, CharSequence>(); + } + ShortcutNameComparator(PackageManager pm, HashMap<Object, CharSequence> labelCache) { + mPackageManager = pm; + mLabelCache = labelCache; + } + public final int compare(ResolveInfo a, ResolveInfo b) { + CharSequence labelA, labelB; + ComponentName keyA = LauncherModel.getComponentNameFromResolveInfo(a); + ComponentName keyB = LauncherModel.getComponentNameFromResolveInfo(b); + if (mLabelCache.containsKey(keyA)) { + labelA = mLabelCache.get(keyA); + } else { + labelA = a.loadLabel(mPackageManager).toString(); + + mLabelCache.put(keyA, labelA); + } + if (mLabelCache.containsKey(keyB)) { + labelB = mLabelCache.get(keyB); + } else { + labelB = b.loadLabel(mPackageManager).toString(); + + mLabelCache.put(keyB, labelB); + } + return sCollator.compare(labelA, labelB); + } + }; + public static class WidgetAndShortcutNameComparator implements Comparator<Object> { + private PackageManager mPackageManager; + private HashMap<Object, String> mLabelCache; + WidgetAndShortcutNameComparator(PackageManager pm) { + mPackageManager = pm; + mLabelCache = new HashMap<Object, String>(); + } + public final int compare(Object a, Object b) { + String labelA, labelB; + if (mLabelCache.containsKey(a)) { + labelA = mLabelCache.get(a); + } else { + labelA = (a instanceof AppWidgetProviderInfo) ? + ((AppWidgetProviderInfo) a).label : + ((ResolveInfo) a).loadLabel(mPackageManager).toString(); + mLabelCache.put(a, labelA); + } + if (mLabelCache.containsKey(b)) { + labelB = mLabelCache.get(b); + } else { + labelB = (b instanceof AppWidgetProviderInfo) ? + ((AppWidgetProviderInfo) b).label : + ((ResolveInfo) b).loadLabel(mPackageManager).toString(); + mLabelCache.put(b, labelB); + } + return sCollator.compare(labelA, labelB); + } + }; + + public void dumpState() { + Log.d(TAG, "mCallbacks=" + mCallbacks); + ApplicationInfo.dumpApplicationInfoList(TAG, "mAllAppsList.data", mAllAppsList.data); + ApplicationInfo.dumpApplicationInfoList(TAG, "mAllAppsList.added", mAllAppsList.added); + ApplicationInfo.dumpApplicationInfoList(TAG, "mAllAppsList.removed", mAllAppsList.removed); + ApplicationInfo.dumpApplicationInfoList(TAG, "mAllAppsList.modified", mAllAppsList.modified); + if (mLoaderTask != null) { + mLoaderTask.dumpState(); + } else { + Log.d(TAG, "mLoaderTask=null"); + } + } +} |