Joe Onorato
0c4513e559
I'm not sure how .added is empty, but the only way I see for this to happen is if it is, so use .data instead, which ought to be the same.
1245 lines
53 KiB
Java
1245 lines
53 KiB
Java
/*
|
|
* 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.android.launcher2;
|
|
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.ComponentName;
|
|
import android.content.ContentResolver;
|
|
import android.content.ContentValues;
|
|
import android.content.Intent;
|
|
import android.content.Context;
|
|
import android.content.pm.ActivityInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.content.res.Resources;
|
|
import android.database.Cursor;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.BitmapFactory;
|
|
import android.net.Uri;
|
|
import android.util.Log;
|
|
import android.os.Process;
|
|
import android.os.SystemClock;
|
|
|
|
import java.lang.ref.WeakReference;
|
|
import java.net.URISyntaxException;
|
|
import java.text.Collator;
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.Collections;
|
|
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 final LauncherApplication mApp;
|
|
private final Object mLock = new Object();
|
|
private DeferredHandler mHandler = new DeferredHandler();
|
|
private Loader mLoader = new Loader();
|
|
|
|
private boolean mBeforeFirstLoad = true;
|
|
private WeakReference<Callbacks> mCallbacks;
|
|
|
|
private AllAppsList mAllAppsList = new AllAppsList();
|
|
|
|
public interface Callbacks {
|
|
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 bindPackageAdded(ArrayList<ApplicationInfo> apps);
|
|
public void bindPackageUpdated(String packageName, ArrayList<ApplicationInfo> apps);
|
|
public void bindPackageRemoved(String packageName, ArrayList<ApplicationInfo> apps);
|
|
}
|
|
|
|
LauncherModel(LauncherApplication app) {
|
|
mApp = app;
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Move an item in the DB to a new <container, screen, cellX, cellY>
|
|
*/
|
|
static void moveItemInDatabase(Context context, ItemInfo item, long container, int screen,
|
|
int cellX, int cellY) {
|
|
item.container = container;
|
|
item.screen = screen;
|
|
item.cellX = cellX;
|
|
item.cellY = cellY;
|
|
|
|
final ContentValues values = new ContentValues();
|
|
final ContentResolver cr = context.getContentResolver();
|
|
|
|
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);
|
|
|
|
cr.update(LauncherSettings.Favorites.getContentUri(item.id, false), values, null, null);
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
/**
|
|
* 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_USER_FOLDER),
|
|
String.valueOf(LauncherSettings.Favorites.ITEM_TYPE_LIVE_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_USER_FOLDER:
|
|
folderInfo = findOrMakeUserFolder(folderList, id);
|
|
break;
|
|
case LauncherSettings.Favorites.ITEM_TYPE_LIVE_FOLDER:
|
|
folderInfo = findOrMakeLiveFolder(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, ItemInfo item, long container,
|
|
int screen, int cellX, int cellY, boolean notify) {
|
|
item.container = container;
|
|
item.screen = screen;
|
|
item.cellX = cellX;
|
|
item.cellY = cellY;
|
|
|
|
final ContentValues values = new ContentValues();
|
|
final ContentResolver cr = context.getContentResolver();
|
|
|
|
item.onAddToDatabase(values);
|
|
|
|
Uri result = cr.insert(notify ? LauncherSettings.Favorites.CONTENT_URI :
|
|
LauncherSettings.Favorites.CONTENT_URI_NO_NOTIFICATION, values);
|
|
|
|
if (result != null) {
|
|
item.id = Integer.parseInt(result.getPathSegments().get(1));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update an item to the database in a specified container.
|
|
*/
|
|
static void updateItemInDatabase(Context context, ItemInfo item) {
|
|
final ContentValues values = new ContentValues();
|
|
final ContentResolver cr = context.getContentResolver();
|
|
|
|
item.onAddToDatabase(values);
|
|
|
|
cr.update(LauncherSettings.Favorites.getContentUri(item.id, false), values, null, null);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified item from the database
|
|
* @param context
|
|
* @param item
|
|
*/
|
|
static void deleteItemFromDatabase(Context context, ItemInfo item) {
|
|
final ContentResolver cr = context.getContentResolver();
|
|
|
|
cr.delete(LauncherSettings.Favorites.getContentUri(item.id, false), null, null);
|
|
}
|
|
|
|
/**
|
|
* Remove the contents of the specified folder from the database
|
|
*/
|
|
static void deleteUserFolderContentsFromDatabase(Context context, UserFolderInfo info) {
|
|
final ContentResolver cr = context.getContentResolver();
|
|
|
|
cr.delete(LauncherSettings.Favorites.getContentUri(info.id, false), null, null);
|
|
cr.delete(LauncherSettings.Favorites.CONTENT_URI,
|
|
LauncherSettings.Favorites.CONTAINER + "=" + info.id, null);
|
|
}
|
|
|
|
/**
|
|
* Set this as the current Launcher activity object for the loader.
|
|
*/
|
|
public void initialize(Callbacks callbacks) {
|
|
synchronized (mLock) {
|
|
mCallbacks = new WeakReference<Callbacks>(callbacks);
|
|
}
|
|
}
|
|
|
|
public void startLoader(Context context, boolean isLaunching) {
|
|
mLoader.startLoader(context, isLaunching);
|
|
}
|
|
|
|
public void stopLoader() {
|
|
mLoader.stopLoader();
|
|
}
|
|
|
|
/**
|
|
* We pick up most of the changes to all apps.
|
|
*/
|
|
public void setAllAppsDirty() {
|
|
mLoader.setAllAppsDirty();
|
|
}
|
|
|
|
public void setWorkspaceDirty() {
|
|
mLoader.setWorkspaceDirty();
|
|
}
|
|
|
|
/**
|
|
* Call from the handler for ACTION_PACKAGE_ADDED, ACTION_PACKAGE_REMOVED and
|
|
* ACTION_PACKAGE_CHANGED.
|
|
*/
|
|
public void onReceive(Context context, Intent intent) {
|
|
// Use the app as the context.
|
|
context = mApp;
|
|
|
|
final String packageName = intent.getData().getSchemeSpecificPart();
|
|
|
|
ArrayList<ApplicationInfo> added = null;
|
|
ArrayList<ApplicationInfo> removed = null;
|
|
ArrayList<ApplicationInfo> modified = null;
|
|
boolean update = false;
|
|
boolean remove = false;
|
|
|
|
synchronized (mLock) {
|
|
if (mBeforeFirstLoad) {
|
|
// If we haven't even loaded yet, don't bother, since we'll just pick
|
|
// up the changes.
|
|
return;
|
|
}
|
|
|
|
final String action = intent.getAction();
|
|
final boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
|
|
|
|
if (packageName == null || packageName.length() == 0) {
|
|
// they sent us a bad intent
|
|
return;
|
|
}
|
|
|
|
if (Intent.ACTION_PACKAGE_CHANGED.equals(action)) {
|
|
mAllAppsList.updatePackage(context, packageName);
|
|
update = true;
|
|
} else if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) {
|
|
if (!replacing) {
|
|
mAllAppsList.removePackage(packageName);
|
|
remove = true;
|
|
}
|
|
// else, we are replacing the package, so a PACKAGE_ADDED will be sent
|
|
// later, we will update the package at this time
|
|
} else {
|
|
if (!replacing) {
|
|
mAllAppsList.addPackage(context, packageName);
|
|
} else {
|
|
mAllAppsList.updatePackage(context, packageName);
|
|
update = true;
|
|
}
|
|
}
|
|
|
|
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) {
|
|
AppInfoCache.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.bindPackageAdded(addedFinal);
|
|
}
|
|
});
|
|
}
|
|
if (update || modified != null) {
|
|
final ArrayList<ApplicationInfo> modifiedFinal = modified;
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
callbacks.bindPackageUpdated(packageName, modifiedFinal);
|
|
}
|
|
});
|
|
}
|
|
if (remove || removed != null) {
|
|
final ArrayList<ApplicationInfo> removedFinal = removed;
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
callbacks.bindPackageRemoved(packageName, removedFinal);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Loader {
|
|
private static final int ITEMS_CHUNK = 6;
|
|
|
|
private LoaderThread mLoaderThread;
|
|
|
|
private int mLastWorkspaceSeq = 0;
|
|
private int mWorkspaceSeq = 1;
|
|
|
|
private int mLastAllAppsSeq = 0;
|
|
private int mAllAppsSeq = 1;
|
|
|
|
final ArrayList<ItemInfo> mItems = new ArrayList<ItemInfo>();
|
|
final ArrayList<LauncherAppWidgetInfo> mAppWidgets = new ArrayList<LauncherAppWidgetInfo>();
|
|
final HashMap<Long, FolderInfo> mFolders = new HashMap<Long, FolderInfo>();
|
|
|
|
/**
|
|
* Call this from the ui thread so the handler is initialized on the correct thread.
|
|
*/
|
|
public Loader() {
|
|
}
|
|
|
|
public void startLoader(Context context, 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.get() != null) {
|
|
LoaderThread oldThread = mLoaderThread;
|
|
if (oldThread != null) {
|
|
if (oldThread.isLaunching()) {
|
|
// don't downgrade isLaunching if we're already running
|
|
isLaunching = true;
|
|
}
|
|
oldThread.stopLocked();
|
|
}
|
|
mLoaderThread = new LoaderThread(context, oldThread, isLaunching);
|
|
mLoaderThread.start();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopLoader() {
|
|
synchronized (mLock) {
|
|
if (mLoaderThread != null) {
|
|
mLoaderThread.stopLocked();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setWorkspaceDirty() {
|
|
synchronized (mLock) {
|
|
mWorkspaceSeq++;
|
|
}
|
|
}
|
|
|
|
public void setAllAppsDirty() {
|
|
synchronized (mLock) {
|
|
mAllAppsSeq++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Runnable for the thread that loads the contents of the launcher:
|
|
* - workspace icons
|
|
* - widgets
|
|
* - all apps icons
|
|
*/
|
|
private class LoaderThread extends Thread {
|
|
private Context mContext;
|
|
private Thread mWaitThread;
|
|
private boolean mIsLaunching;
|
|
private boolean mStopped;
|
|
private boolean mWorkspaceDoneBinding;
|
|
|
|
LoaderThread(Context context, Thread waitThread, boolean isLaunching) {
|
|
mContext = context;
|
|
mWaitThread = waitThread;
|
|
mIsLaunching = isLaunching;
|
|
}
|
|
|
|
boolean isLaunching() {
|
|
return mIsLaunching;
|
|
}
|
|
|
|
/**
|
|
* If another LoaderThread was supplied, we need to wait for that to finish before
|
|
* we start our processing. This keeps the ordering of the setting and clearing
|
|
* of the dirty flags correct by making sure we don't start processing stuff until
|
|
* they've had a chance to re-set them. We do this waiting the worker thread, not
|
|
* the ui thread to avoid ANRs.
|
|
*/
|
|
private void waitForOtherThread() {
|
|
if (mWaitThread != null) {
|
|
boolean done = false;
|
|
while (!done) {
|
|
try {
|
|
mWaitThread.join();
|
|
done = true;
|
|
} catch (InterruptedException ex) {
|
|
// Ignore
|
|
}
|
|
}
|
|
mWaitThread = null;
|
|
}
|
|
}
|
|
|
|
public void run() {
|
|
waitForOtherThread();
|
|
|
|
// 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) {
|
|
android.os.Process.setThreadPriority(mIsLaunching
|
|
? Process.THREAD_PRIORITY_DEFAULT : Process.THREAD_PRIORITY_BACKGROUND);
|
|
}
|
|
|
|
// Load the workspace only if it's dirty.
|
|
int workspaceSeq;
|
|
boolean workspaceDirty;
|
|
synchronized (mLock) {
|
|
workspaceSeq = mWorkspaceSeq;
|
|
workspaceDirty = mWorkspaceSeq != mLastWorkspaceSeq;
|
|
}
|
|
if (workspaceDirty) {
|
|
loadWorkspace();
|
|
}
|
|
synchronized (mLock) {
|
|
// If we're not stopped, and nobody has incremented mWorkspaceSeq.
|
|
if (mStopped) {
|
|
return;
|
|
}
|
|
if (workspaceSeq == mWorkspaceSeq) {
|
|
mLastWorkspaceSeq = mWorkspaceSeq;
|
|
}
|
|
}
|
|
|
|
// Bind the workspace
|
|
bindWorkspace();
|
|
|
|
// 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 (LoaderThread.this) {
|
|
mHandler.postIdle(new Runnable() {
|
|
public void run() {
|
|
synchronized (LoaderThread.this) {
|
|
mWorkspaceDoneBinding = true;
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "done with workspace");
|
|
}
|
|
LoaderThread.this.notify();
|
|
}
|
|
}
|
|
});
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "waiting to be done with workspace");
|
|
}
|
|
while (!mStopped && !mWorkspaceDoneBinding) {
|
|
try {
|
|
this.wait();
|
|
} catch (InterruptedException ex) {
|
|
// Ignore
|
|
}
|
|
}
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "done waiting to be done with workspace");
|
|
}
|
|
}
|
|
|
|
// Load all apps if they're dirty
|
|
int allAppsSeq;
|
|
boolean allAppsDirty;
|
|
synchronized (mLock) {
|
|
allAppsSeq = mAllAppsSeq;
|
|
allAppsDirty = mAllAppsSeq != mLastAllAppsSeq;
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "mAllAppsSeq=" + mAllAppsSeq
|
|
+ " mLastAllAppsSeq=" + mLastAllAppsSeq + " allAppsDirty");
|
|
}
|
|
}
|
|
if (allAppsDirty) {
|
|
loadAllApps();
|
|
}
|
|
synchronized (mLock) {
|
|
// If we're not stopped, and nobody has incremented mAllAppsSeq.
|
|
if (mStopped) {
|
|
return;
|
|
}
|
|
if (allAppsSeq == mAllAppsSeq) {
|
|
mLastAllAppsSeq = mAllAppsSeq;
|
|
}
|
|
}
|
|
|
|
// Bind all apps
|
|
if (allAppsDirty) {
|
|
bindAllApps();
|
|
}
|
|
|
|
// Clear out this reference, otherwise we end up holding it until all of the
|
|
// callback runnables are done.
|
|
mContext = null;
|
|
|
|
synchronized (mLock) {
|
|
// Setting the reference is atomic, but we can't do it inside the other critical
|
|
// sections.
|
|
mLoaderThread = null;
|
|
}
|
|
}
|
|
|
|
public void stopLocked() {
|
|
synchronized (LoaderThread.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.
|
|
*/
|
|
Callbacks tryGetCallbacks() {
|
|
synchronized (mLock) {
|
|
if (mStopped) {
|
|
return null;
|
|
}
|
|
|
|
final Callbacks callbacks = mCallbacks.get();
|
|
if (callbacks == null) {
|
|
Log.w(TAG, "no mCallbacks");
|
|
return null;
|
|
}
|
|
|
|
return callbacks;
|
|
}
|
|
}
|
|
|
|
private void loadWorkspace() {
|
|
long t = SystemClock.uptimeMillis();
|
|
|
|
final Context context = mContext;
|
|
final ContentResolver contentResolver = context.getContentResolver();
|
|
final PackageManager manager = context.getPackageManager();
|
|
|
|
/* TODO
|
|
if (mLocaleChanged) {
|
|
updateShortcutLabels(contentResolver, manager);
|
|
}
|
|
*/
|
|
|
|
mItems.clear();
|
|
mAppWidgets.clear();
|
|
mFolders.clear();
|
|
|
|
final Cursor c = contentResolver.query(
|
|
LauncherSettings.Favorites.CONTENT_URI, null, null, null, null);
|
|
|
|
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);
|
|
|
|
ApplicationInfo info;
|
|
String intentDescription;
|
|
Widget widgetInfo;
|
|
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 = getApplicationInfo(manager, intent, context);
|
|
} else {
|
|
info = getApplicationInfoShortcut(c, context, iconTypeIndex,
|
|
iconPackageIndex, iconResourceIndex, iconIndex);
|
|
}
|
|
|
|
if (info == null) {
|
|
info = new ApplicationInfo();
|
|
info.icon = manager.getDefaultActivityIcon();
|
|
}
|
|
|
|
if (info != null) {
|
|
if (itemType
|
|
!= LauncherSettings.Favorites.ITEM_TYPE_APPLICATION) {
|
|
info.title = c.getString(titleIndex);
|
|
}
|
|
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);
|
|
|
|
switch (container) {
|
|
case LauncherSettings.Favorites.CONTAINER_DESKTOP:
|
|
mItems.add(info);
|
|
break;
|
|
default:
|
|
// Item is in a user folder
|
|
UserFolderInfo folderInfo =
|
|
findOrMakeUserFolder(mFolders, container);
|
|
folderInfo.add(info);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LauncherSettings.Favorites.ITEM_TYPE_USER_FOLDER:
|
|
id = c.getLong(idIndex);
|
|
UserFolderInfo folderInfo = findOrMakeUserFolder(mFolders, 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);
|
|
|
|
switch (container) {
|
|
case LauncherSettings.Favorites.CONTAINER_DESKTOP:
|
|
mItems.add(folderInfo);
|
|
break;
|
|
}
|
|
|
|
mFolders.put(folderInfo.id, folderInfo);
|
|
break;
|
|
|
|
case LauncherSettings.Favorites.ITEM_TYPE_LIVE_FOLDER:
|
|
|
|
id = c.getLong(idIndex);
|
|
LiveFolderInfo liveFolderInfo = findOrMakeLiveFolder(mFolders, id);
|
|
|
|
intentDescription = c.getString(intentIndex);
|
|
intent = null;
|
|
if (intentDescription != null) {
|
|
try {
|
|
intent = Intent.parseUri(intentDescription, 0);
|
|
} catch (URISyntaxException e) {
|
|
// Ignore, a live folder might not have a base intent
|
|
}
|
|
}
|
|
|
|
liveFolderInfo.title = c.getString(titleIndex);
|
|
liveFolderInfo.id = id;
|
|
container = c.getInt(containerIndex);
|
|
liveFolderInfo.container = container;
|
|
liveFolderInfo.screen = c.getInt(screenIndex);
|
|
liveFolderInfo.cellX = c.getInt(cellXIndex);
|
|
liveFolderInfo.cellY = c.getInt(cellYIndex);
|
|
liveFolderInfo.uri = Uri.parse(c.getString(uriIndex));
|
|
liveFolderInfo.baseIntent = intent;
|
|
liveFolderInfo.displayMode = c.getInt(displayModeIndex);
|
|
|
|
loadLiveFolderIcon(context, c, iconTypeIndex, iconPackageIndex,
|
|
iconResourceIndex, liveFolderInfo);
|
|
|
|
switch (container) {
|
|
case LauncherSettings.Favorites.CONTAINER_DESKTOP:
|
|
mItems.add(liveFolderInfo);
|
|
break;
|
|
}
|
|
mFolders.put(liveFolderInfo.id, liveFolderInfo);
|
|
break;
|
|
|
|
case LauncherSettings.Favorites.ITEM_TYPE_WIDGET_SEARCH:
|
|
widgetInfo = Widget.makeSearch();
|
|
|
|
container = c.getInt(containerIndex);
|
|
if (container != LauncherSettings.Favorites.CONTAINER_DESKTOP) {
|
|
Log.e(TAG, "Widget found where container "
|
|
+ "!= CONTAINER_DESKTOP ignoring!");
|
|
continue;
|
|
}
|
|
|
|
widgetInfo.id = c.getLong(idIndex);
|
|
widgetInfo.screen = c.getInt(screenIndex);
|
|
widgetInfo.container = container;
|
|
widgetInfo.cellX = c.getInt(cellXIndex);
|
|
widgetInfo.cellY = c.getInt(cellYIndex);
|
|
|
|
mItems.add(widgetInfo);
|
|
break;
|
|
|
|
case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
|
|
// Read all Launcher-specific widget details
|
|
int appWidgetId = c.getInt(appWidgetIdIndex);
|
|
appWidgetInfo = new LauncherAppWidgetInfo(appWidgetId);
|
|
appWidgetInfo.id = c.getLong(idIndex);
|
|
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);
|
|
|
|
container = c.getInt(containerIndex);
|
|
if (container != LauncherSettings.Favorites.CONTAINER_DESKTOP) {
|
|
Log.e(TAG, "Widget found where container "
|
|
+ "!= CONTAINER_DESKTOP -- ignoring!");
|
|
continue;
|
|
}
|
|
appWidgetInfo.container = c.getInt(containerIndex);
|
|
|
|
mAppWidgets.add(appWidgetInfo);
|
|
break;
|
|
}
|
|
} catch (Exception e) {
|
|
Log.w(TAG, "Desktop items loading interrupted:", e);
|
|
}
|
|
}
|
|
} finally {
|
|
c.close();
|
|
}
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "loaded workspace in " + (SystemClock.uptimeMillis()-t) + "ms");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
Callbacks callbacks = mCallbacks.get();
|
|
if (callbacks == null) {
|
|
// This launcher has exited and nobody bothered to tell us. Just bail.
|
|
Log.w(TAG, "LoaderThread running with no launcher");
|
|
return;
|
|
}
|
|
|
|
int N;
|
|
// Tell the workspace that we're about to start firing items at it
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
Callbacks callbacks = tryGetCallbacks();
|
|
if (callbacks != null) {
|
|
callbacks.startBinding();
|
|
}
|
|
}
|
|
});
|
|
// Add the items to the workspace.
|
|
N = mItems.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();
|
|
if (callbacks != null) {
|
|
callbacks.bindItems(mItems, start, start+chunkSize);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
Callbacks callbacks = tryGetCallbacks();
|
|
if (callbacks != null) {
|
|
callbacks.bindFolders(mFolders);
|
|
}
|
|
}
|
|
});
|
|
// Wait until the queue goes empty.
|
|
mHandler.postIdle(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.
|
|
final int currentScreen = callbacks.getCurrentWorkspaceScreen();
|
|
N = mAppWidgets.size();
|
|
// once for the current screen
|
|
for (int i=0; i<N; i++) {
|
|
final LauncherAppWidgetInfo widget = mAppWidgets.get(i);
|
|
if (widget.screen == currentScreen) {
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
Callbacks callbacks = tryGetCallbacks();
|
|
if (callbacks != null) {
|
|
callbacks.bindAppWidget(widget);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
// once for the other screens
|
|
for (int i=0; i<N; i++) {
|
|
final LauncherAppWidgetInfo widget = mAppWidgets.get(i);
|
|
if (widget.screen != currentScreen) {
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
Callbacks callbacks = tryGetCallbacks();
|
|
if (callbacks != null) {
|
|
callbacks.bindAppWidget(widget);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
// Tell the workspace that we're done.
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
Callbacks callbacks = tryGetCallbacks();
|
|
if (callbacks != null) {
|
|
callbacks.finishBindingItems();
|
|
}
|
|
}
|
|
});
|
|
// If we're profiling, this is the last thing in the queue.
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "bound workspace in "
|
|
+ (SystemClock.uptimeMillis()-t) + "ms");
|
|
}
|
|
if (Launcher.PROFILE_ROTATE) {
|
|
android.os.Debug.stopMethodTracing();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private void loadAllApps() {
|
|
final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
|
|
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
|
|
|
|
final Callbacks callbacks = tryGetCallbacks();
|
|
if (callbacks == null) {
|
|
return;
|
|
}
|
|
|
|
final Context context = mContext;
|
|
final PackageManager packageManager = context.getPackageManager();
|
|
|
|
final List<ResolveInfo> apps = packageManager.queryIntentActivities(mainIntent, 0);
|
|
|
|
synchronized (mLock) {
|
|
mBeforeFirstLoad = false;
|
|
|
|
mAllAppsList.clear();
|
|
if (apps != null) {
|
|
long t = SystemClock.uptimeMillis();
|
|
|
|
int N = apps.size();
|
|
Utilities.BubbleText bubble = new Utilities.BubbleText(context);
|
|
for (int i=0; i<N && !mStopped; i++) {
|
|
// This builds the icon bitmaps.
|
|
mAllAppsList.add(AppInfoCache.cache(apps.get(i), context, bubble));
|
|
}
|
|
Collections.sort(mAllAppsList.data, sComparator);
|
|
Collections.sort(mAllAppsList.added, sComparator);
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "cached app icons in "
|
|
+ (SystemClock.uptimeMillis()-t) + "ms");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void bindAllApps() {
|
|
synchronized (mLock) {
|
|
final ArrayList<ApplicationInfo> results
|
|
= (ArrayList<ApplicationInfo>)mAllAppsList.data.clone();
|
|
// We're adding this now, so clear out this so we don't re-send them.
|
|
mAllAppsList.added = new ArrayList<ApplicationInfo>();
|
|
mHandler.post(new Runnable() {
|
|
public void run() {
|
|
final long t = SystemClock.uptimeMillis();
|
|
final int count = results.size();
|
|
|
|
Callbacks callbacks = tryGetCallbacks();
|
|
if (callbacks != null) {
|
|
callbacks.bindAllApplications(results);
|
|
}
|
|
|
|
if (DEBUG_LOADERS) {
|
|
Log.d(TAG, "bound app " + count + " icons in "
|
|
+ (SystemClock.uptimeMillis()-t) + "ms");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
public void dumpState() {
|
|
Log.d(TAG, "mLoader.mLoaderThread.mContext=" + mContext);
|
|
Log.d(TAG, "mLoader.mLoaderThread.mWaitThread=" + mWaitThread);
|
|
Log.d(TAG, "mLoader.mLoaderThread.mIsLaunching=" + mIsLaunching);
|
|
Log.d(TAG, "mLoader.mLoaderThread.mStopped=" + mStopped);
|
|
Log.d(TAG, "mLoader.mLoaderThread.mWorkspaceDoneBinding=" + mWorkspaceDoneBinding);
|
|
}
|
|
}
|
|
|
|
public void dumpState() {
|
|
Log.d(TAG, "mLoader.mLastWorkspaceSeq=" + mLoader.mLastWorkspaceSeq);
|
|
Log.d(TAG, "mLoader.mWorkspaceSeq=" + mLoader.mWorkspaceSeq);
|
|
Log.d(TAG, "mLoader.mLastAllAppsSeq=" + mLoader.mLastAllAppsSeq);
|
|
Log.d(TAG, "mLoader.mAllAppsSeq=" + mLoader.mAllAppsSeq);
|
|
Log.d(TAG, "mLoader.mItems size=" + mLoader.mItems.size());
|
|
if (mLoaderThread != null) {
|
|
mLoaderThread.dumpState();
|
|
} else {
|
|
Log.d(TAG, "mLoader.mLoaderThread=null");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Make an ApplicationInfo object for an application.
|
|
*/
|
|
private static ApplicationInfo getApplicationInfo(PackageManager manager, Intent intent,
|
|
Context context) {
|
|
final ResolveInfo resolveInfo = manager.resolveActivity(intent, 0);
|
|
|
|
if (resolveInfo == null) {
|
|
return null;
|
|
}
|
|
|
|
final ApplicationInfo info = new ApplicationInfo();
|
|
final ActivityInfo activityInfo = resolveInfo.activityInfo;
|
|
info.icon = Utilities.createIconThumbnail(activityInfo.loadIcon(manager), context);
|
|
if (info.title == null || info.title.length() == 0) {
|
|
info.title = activityInfo.loadLabel(manager);
|
|
}
|
|
if (info.title == null) {
|
|
info.title = "";
|
|
}
|
|
info.itemType = LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* Make an ApplicationInfo object for a sortcut
|
|
*/
|
|
private static ApplicationInfo getApplicationInfoShortcut(Cursor c, Context context,
|
|
int iconTypeIndex, int iconPackageIndex, int iconResourceIndex, int iconIndex) {
|
|
|
|
final ApplicationInfo info = new ApplicationInfo();
|
|
info.itemType = LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT;
|
|
|
|
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();
|
|
try {
|
|
Resources resources = packageManager.getResourcesForApplication(packageName);
|
|
final int id = resources.getIdentifier(resourceName, null, null);
|
|
info.icon = Utilities.createIconThumbnail(resources.getDrawable(id), context);
|
|
} catch (Exception e) {
|
|
info.icon = packageManager.getDefaultActivityIcon();
|
|
}
|
|
info.iconResource = new Intent.ShortcutIconResource();
|
|
info.iconResource.packageName = packageName;
|
|
info.iconResource.resourceName = resourceName;
|
|
info.customIcon = false;
|
|
break;
|
|
case LauncherSettings.Favorites.ICON_TYPE_BITMAP:
|
|
byte[] data = c.getBlob(iconIndex);
|
|
try {
|
|
Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
|
|
info.icon = new FastBitmapDrawable(
|
|
Utilities.createBitmapThumbnail(bitmap, context));
|
|
} catch (Exception e) {
|
|
packageManager = context.getPackageManager();
|
|
info.icon = packageManager.getDefaultActivityIcon();
|
|
}
|
|
info.filtered = true;
|
|
info.customIcon = true;
|
|
break;
|
|
default:
|
|
info.icon = context.getPackageManager().getDefaultActivityIcon();
|
|
info.customIcon = false;
|
|
break;
|
|
}
|
|
return info;
|
|
}
|
|
|
|
private static void loadLiveFolderIcon(Context context, Cursor c, int iconTypeIndex,
|
|
int iconPackageIndex, int iconResourceIndex, LiveFolderInfo liveFolderInfo) {
|
|
|
|
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();
|
|
try {
|
|
Resources resources = packageManager.getResourcesForApplication(packageName);
|
|
final int id = resources.getIdentifier(resourceName, null, null);
|
|
liveFolderInfo.icon = resources.getDrawable(id);
|
|
} catch (Exception e) {
|
|
liveFolderInfo.icon =
|
|
context.getResources().getDrawable(R.drawable.ic_launcher_folder);
|
|
}
|
|
liveFolderInfo.iconResource = new Intent.ShortcutIconResource();
|
|
liveFolderInfo.iconResource.packageName = packageName;
|
|
liveFolderInfo.iconResource.resourceName = resourceName;
|
|
break;
|
|
default:
|
|
liveFolderInfo.icon =
|
|
context.getResources().getDrawable(R.drawable.ic_launcher_folder);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return an existing UserFolderInfo object if we have encountered this ID previously,
|
|
* or make a new one.
|
|
*/
|
|
private static UserFolderInfo findOrMakeUserFolder(HashMap<Long, FolderInfo> folders, long id) {
|
|
// See if a placeholder was created for us already
|
|
FolderInfo folderInfo = folders.get(id);
|
|
if (folderInfo == null || !(folderInfo instanceof UserFolderInfo)) {
|
|
// No placeholder -- create a new instance
|
|
folderInfo = new UserFolderInfo();
|
|
folders.put(id, folderInfo);
|
|
}
|
|
return (UserFolderInfo) folderInfo;
|
|
}
|
|
|
|
/**
|
|
* Return an existing UserFolderInfo object if we have encountered this ID previously, or make a
|
|
* new one.
|
|
*/
|
|
private static LiveFolderInfo findOrMakeLiveFolder(HashMap<Long, FolderInfo> folders, long id) {
|
|
// See if a placeholder was created for us already
|
|
FolderInfo folderInfo = folders.get(id);
|
|
if (folderInfo == null || !(folderInfo instanceof LiveFolderInfo)) {
|
|
// No placeholder -- create a new instance
|
|
folderInfo = new LiveFolderInfo();
|
|
folders.put(id, folderInfo);
|
|
}
|
|
return (LiveFolderInfo) folderInfo;
|
|
}
|
|
|
|
private static void updateShortcutLabels(ContentResolver resolver, PackageManager manager) {
|
|
final Cursor c = resolver.query(LauncherSettings.Favorites.CONTENT_URI,
|
|
new String[] { LauncherSettings.Favorites._ID, LauncherSettings.Favorites.TITLE,
|
|
LauncherSettings.Favorites.INTENT, LauncherSettings.Favorites.ITEM_TYPE },
|
|
null, null, null);
|
|
|
|
final int idIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites._ID);
|
|
final int intentIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.INTENT);
|
|
final int itemTypeIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ITEM_TYPE);
|
|
final int titleIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.TITLE);
|
|
|
|
// boolean changed = false;
|
|
|
|
try {
|
|
while (c.moveToNext()) {
|
|
try {
|
|
if (c.getInt(itemTypeIndex) !=
|
|
LauncherSettings.Favorites.ITEM_TYPE_APPLICATION) {
|
|
continue;
|
|
}
|
|
|
|
final String intentUri = c.getString(intentIndex);
|
|
if (intentUri != null) {
|
|
final Intent shortcut = Intent.parseUri(intentUri, 0);
|
|
if (Intent.ACTION_MAIN.equals(shortcut.getAction())) {
|
|
final ComponentName name = shortcut.getComponent();
|
|
if (name != null) {
|
|
final ActivityInfo activityInfo = manager.getActivityInfo(name, 0);
|
|
final String title = c.getString(titleIndex);
|
|
String label = getLabel(manager, activityInfo);
|
|
|
|
if (title == null || !title.equals(label)) {
|
|
final ContentValues values = new ContentValues();
|
|
values.put(LauncherSettings.Favorites.TITLE, label);
|
|
|
|
resolver.update(
|
|
LauncherSettings.Favorites.CONTENT_URI_NO_NOTIFICATION,
|
|
values, "_id=?",
|
|
new String[] { String.valueOf(c.getLong(idIndex)) });
|
|
|
|
// changed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (URISyntaxException e) {
|
|
// Ignore
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
// Ignore
|
|
}
|
|
}
|
|
} finally {
|
|
c.close();
|
|
}
|
|
|
|
// if (changed) resolver.notifyChange(Settings.Favorites.CONTENT_URI, null);
|
|
}
|
|
|
|
private static String getLabel(PackageManager manager, ActivityInfo activityInfo) {
|
|
String label = activityInfo.loadLabel(manager).toString();
|
|
if (label == null) {
|
|
label = manager.getApplicationLabel(activityInfo.applicationInfo).toString();
|
|
if (label == null) {
|
|
label = activityInfo.name;
|
|
}
|
|
}
|
|
return label;
|
|
}
|
|
|
|
private static final Collator sCollator = Collator.getInstance();
|
|
private static final Comparator<ApplicationInfo> sComparator
|
|
= new Comparator<ApplicationInfo>() {
|
|
public final int compare(ApplicationInfo a, ApplicationInfo b) {
|
|
return sCollator.compare(a.title.toString(), b.title.toString());
|
|
}
|
|
};
|
|
|
|
public void dumpState() {
|
|
Log.d(TAG, "mBeforeFirstLoad=" + mBeforeFirstLoad);
|
|
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);
|
|
mLoader.dumpState();
|
|
}
|
|
}
|