Jeffrey Sharkey
c975a06ac3
Only happens when user changes orientation while editing, where getFolderById can return the wrong folder type for the given ID. Original author: jsharkey Merged from: //branches/cupcake/... Original author: android-build Merged from: //branches/donutburger/... Automated import of CL 143382
1345 lines
53 KiB
Java
1345 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.launcher;
|
|
|
|
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.graphics.drawable.Drawable;
|
|
import android.net.Uri;
|
|
import static android.util.Log.*;
|
|
import android.os.Process;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Comparator;
|
|
import java.lang.ref.WeakReference;
|
|
import java.text.Collator;
|
|
import java.net.URISyntaxException;
|
|
|
|
/**
|
|
* 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 {
|
|
static final boolean DEBUG_LOADERS = true;
|
|
static final String LOG_TAG = "HomeLoaders";
|
|
|
|
private static final int UI_NOTIFICATION_RATE = 4;
|
|
private static final int DEFAULT_APPLICATIONS_NUMBER = 42;
|
|
private static final long APPLICATION_NOT_RESPONDING_TIMEOUT = 5000;
|
|
private static final int INITIAL_ICON_CACHE_CAPACITY = 50;
|
|
|
|
private static final Collator sCollator = Collator.getInstance();
|
|
|
|
private boolean mApplicationsLoaded;
|
|
private boolean mDesktopItemsLoaded;
|
|
|
|
private ArrayList<ItemInfo> mDesktopItems;
|
|
private ArrayList<LauncherAppWidgetInfo> mDesktopAppWidgets;
|
|
private HashMap<Long, FolderInfo> mFolders;
|
|
|
|
private ArrayList<ApplicationInfo> mApplications;
|
|
private ApplicationsAdapter mApplicationsAdapter;
|
|
private ApplicationsLoader mApplicationsLoader;
|
|
private DesktopItemsLoader mDesktopItemsLoader;
|
|
private Thread mApplicationsLoaderThread;
|
|
private Thread mDesktopLoaderThread;
|
|
|
|
private final HashMap<ComponentName, ApplicationInfo> mAppInfoCache =
|
|
new HashMap<ComponentName, ApplicationInfo>(INITIAL_ICON_CACHE_CAPACITY);
|
|
|
|
synchronized void abortLoaders() {
|
|
if (mApplicationsLoader != null && mApplicationsLoader.isRunning()) {
|
|
mApplicationsLoader.stop();
|
|
mApplicationsLoaded = false;
|
|
}
|
|
|
|
if (mDesktopItemsLoader != null && mDesktopItemsLoader.isRunning()) {
|
|
mDesktopItemsLoader.stop();
|
|
mDesktopItemsLoaded = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Drop our cache of components to their lables & icons. We do
|
|
* this from Launcher when applications are added/removed. It's a
|
|
* bit overkill, but it's a rare operation anyway.
|
|
*/
|
|
synchronized void dropApplicationCache() {
|
|
mAppInfoCache.clear();
|
|
}
|
|
|
|
/**
|
|
* Loads the list of installed applications in mApplications.
|
|
*
|
|
* @return true if the applications loader must be started
|
|
* (see startApplicationsLoader()), false otherwise.
|
|
*/
|
|
synchronized boolean loadApplications(boolean isLaunching, Launcher launcher,
|
|
boolean localeChanged) {
|
|
|
|
if (DEBUG_LOADERS) d(LOG_TAG, "load applications");
|
|
|
|
if (isLaunching && mApplicationsLoaded && !localeChanged) {
|
|
mApplicationsAdapter = new ApplicationsAdapter(launcher, mApplications);
|
|
if (DEBUG_LOADERS) d(LOG_TAG, " --> applications loaded, return");
|
|
return false;
|
|
}
|
|
|
|
stopAndWaitForApplicationsLoader();
|
|
|
|
if (localeChanged) {
|
|
dropApplicationCache();
|
|
}
|
|
|
|
if (mApplicationsAdapter == null || isLaunching || localeChanged) {
|
|
mApplications = new ArrayList<ApplicationInfo>(DEFAULT_APPLICATIONS_NUMBER);
|
|
mApplicationsAdapter = new ApplicationsAdapter(launcher, mApplications);
|
|
}
|
|
|
|
mApplicationsLoaded = false;
|
|
|
|
if (!isLaunching) {
|
|
startApplicationsLoader(launcher);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private synchronized void stopAndWaitForApplicationsLoader() {
|
|
if (mApplicationsLoader != null && mApplicationsLoader.isRunning()) {
|
|
if (DEBUG_LOADERS) d(LOG_TAG, " --> wait for applications loader");
|
|
|
|
mApplicationsLoader.stop();
|
|
// Wait for the currently running thread to finish, this can take a little
|
|
// time but it should be well below the timeout limit
|
|
try {
|
|
mApplicationsLoaderThread.join(APPLICATION_NOT_RESPONDING_TIMEOUT);
|
|
} catch (InterruptedException e) {
|
|
// EMpty
|
|
}
|
|
}
|
|
}
|
|
|
|
private synchronized void startApplicationsLoader(Launcher launcher) {
|
|
if (DEBUG_LOADERS) d(LOG_TAG, " --> starting applications loader");
|
|
|
|
stopAndWaitForApplicationsLoader();
|
|
|
|
mApplicationsLoader = new ApplicationsLoader(launcher);
|
|
mApplicationsLoaderThread = new Thread(mApplicationsLoader, "Applications Loader");
|
|
mApplicationsLoaderThread.start();
|
|
}
|
|
|
|
synchronized void addPackage(Launcher launcher, String packageName) {
|
|
if (mApplicationsLoader != null && mApplicationsLoader.isRunning()) {
|
|
startApplicationsLoader(launcher);
|
|
return;
|
|
}
|
|
|
|
if (packageName != null && packageName.length() > 0) {
|
|
final PackageManager packageManager = launcher.getPackageManager();
|
|
final List<ResolveInfo> matches = findActivitiesForPackage(packageManager, packageName);
|
|
|
|
if (matches.size() > 0) {
|
|
final ApplicationsAdapter adapter = mApplicationsAdapter;
|
|
final HashMap<ComponentName, ApplicationInfo> cache = mAppInfoCache;
|
|
|
|
for (ResolveInfo info : matches) {
|
|
adapter.setNotifyOnChange(false);
|
|
adapter.add(makeAndCacheApplicationInfo(packageManager, cache, info));
|
|
}
|
|
|
|
adapter.sort(new ApplicationInfoComparator());
|
|
adapter.notifyDataSetChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
synchronized void removePackage(Launcher launcher, String packageName) {
|
|
if (mApplicationsLoader != null && mApplicationsLoader.isRunning()) {
|
|
dropApplicationCache(); // TODO: this could be optimized
|
|
startApplicationsLoader(launcher);
|
|
return;
|
|
}
|
|
|
|
if (packageName != null && packageName.length() > 0) {
|
|
final ApplicationsAdapter adapter = mApplicationsAdapter;
|
|
|
|
final List<ApplicationInfo> toRemove = new ArrayList<ApplicationInfo>();
|
|
final int count = adapter.getCount();
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
final ApplicationInfo applicationInfo = adapter.getItem(i);
|
|
final Intent intent = applicationInfo.intent;
|
|
final ComponentName component = intent.getComponent();
|
|
if (packageName.equals(component.getPackageName())) {
|
|
toRemove.add(applicationInfo);
|
|
}
|
|
}
|
|
|
|
final HashMap<ComponentName, ApplicationInfo> cache = mAppInfoCache;
|
|
for (ApplicationInfo info : toRemove) {
|
|
adapter.setNotifyOnChange(false);
|
|
adapter.remove(info);
|
|
cache.remove(info.intent.getComponent());
|
|
}
|
|
|
|
if (toRemove.size() > 0) {
|
|
adapter.sort(new ApplicationInfoComparator());
|
|
adapter.notifyDataSetChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
synchronized void updatePackage(Launcher launcher, String packageName) {
|
|
if (mApplicationsLoader != null && mApplicationsLoader.isRunning()) {
|
|
startApplicationsLoader(launcher);
|
|
return;
|
|
}
|
|
|
|
if (packageName != null && packageName.length() > 0) {
|
|
final PackageManager packageManager = launcher.getPackageManager();
|
|
final ApplicationsAdapter adapter = mApplicationsAdapter;
|
|
|
|
final List<ResolveInfo> matches = findActivitiesForPackage(packageManager, packageName);
|
|
final int count = matches.size();
|
|
|
|
boolean changed = false;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
final ResolveInfo info = matches.get(i);
|
|
final ApplicationInfo applicationInfo = findIntent(adapter,
|
|
info.activityInfo.applicationInfo.packageName, info.activityInfo.name);
|
|
if (applicationInfo != null) {
|
|
updateAndCacheApplicationInfo(packageManager, info, applicationInfo);
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
adapter.sort(new ApplicationInfoComparator());
|
|
adapter.notifyDataSetChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateAndCacheApplicationInfo(PackageManager packageManager, ResolveInfo info,
|
|
ApplicationInfo applicationInfo) {
|
|
|
|
updateApplicationInfoTitleAndIcon(packageManager, info, applicationInfo);
|
|
|
|
ComponentName componentName = new ComponentName(
|
|
info.activityInfo.applicationInfo.packageName, info.activityInfo.name);
|
|
mAppInfoCache.put(componentName, applicationInfo);
|
|
}
|
|
|
|
synchronized void syncPackage(Launcher launcher, String packageName) {
|
|
if (mApplicationsLoader != null && mApplicationsLoader.isRunning()) {
|
|
startApplicationsLoader(launcher);
|
|
return;
|
|
}
|
|
|
|
if (packageName != null && packageName.length() > 0) {
|
|
final PackageManager packageManager = launcher.getPackageManager();
|
|
final List<ResolveInfo> matches = findActivitiesForPackage(packageManager, packageName);
|
|
|
|
if (matches.size() > 0) {
|
|
final ApplicationsAdapter adapter = mApplicationsAdapter;
|
|
|
|
// Find disabled activities and remove them from the adapter
|
|
boolean removed = removeDisabledActivities(packageName, matches, adapter);
|
|
// Find enable activities and add them to the adapter
|
|
// Also updates existing activities with new labels/icons
|
|
boolean added = addEnabledAndUpdateActivities(matches, adapter, launcher);
|
|
|
|
if (added || removed) {
|
|
adapter.sort(new ApplicationInfoComparator());
|
|
adapter.notifyDataSetChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static List<ResolveInfo> findActivitiesForPackage(PackageManager packageManager,
|
|
String packageName) {
|
|
|
|
final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
|
|
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
|
|
|
|
final List<ResolveInfo> apps = packageManager.queryIntentActivities(mainIntent, 0);
|
|
final List<ResolveInfo> matches = new ArrayList<ResolveInfo>();
|
|
|
|
if (apps != null) {
|
|
// Find all activities that match the packageName
|
|
int count = apps.size();
|
|
for (int i = 0; i < count; i++) {
|
|
final ResolveInfo info = apps.get(i);
|
|
final ActivityInfo activityInfo = info.activityInfo;
|
|
if (packageName.equals(activityInfo.packageName)) {
|
|
matches.add(info);
|
|
}
|
|
}
|
|
}
|
|
|
|
return matches;
|
|
}
|
|
|
|
private boolean addEnabledAndUpdateActivities(List<ResolveInfo> matches,
|
|
ApplicationsAdapter adapter, Launcher launcher) {
|
|
|
|
final List<ApplicationInfo> toAdd = new ArrayList<ApplicationInfo>();
|
|
final int count = matches.size();
|
|
|
|
boolean changed = false;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
final ResolveInfo info = matches.get(i);
|
|
final ApplicationInfo applicationInfo = findIntent(adapter,
|
|
info.activityInfo.applicationInfo.packageName, info.activityInfo.name);
|
|
if (applicationInfo == null) {
|
|
toAdd.add(makeAndCacheApplicationInfo(launcher.getPackageManager(),
|
|
mAppInfoCache, info));
|
|
changed = true;
|
|
} else {
|
|
updateAndCacheApplicationInfo(launcher.getPackageManager(), info, applicationInfo);
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
for (ApplicationInfo info : toAdd) {
|
|
adapter.setNotifyOnChange(false);
|
|
adapter.add(info);
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
private boolean removeDisabledActivities(String packageName, List<ResolveInfo> matches,
|
|
ApplicationsAdapter adapter) {
|
|
|
|
final List<ApplicationInfo> toRemove = new ArrayList<ApplicationInfo>();
|
|
final int count = adapter.getCount();
|
|
|
|
boolean changed = false;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
final ApplicationInfo applicationInfo = adapter.getItem(i);
|
|
final Intent intent = applicationInfo.intent;
|
|
final ComponentName component = intent.getComponent();
|
|
if (packageName.equals(component.getPackageName())) {
|
|
if (!findIntent(matches, component)) {
|
|
toRemove.add(applicationInfo);
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
final HashMap<ComponentName, ApplicationInfo> cache = mAppInfoCache;
|
|
for (ApplicationInfo info : toRemove) {
|
|
adapter.setNotifyOnChange(false);
|
|
adapter.remove(info);
|
|
cache.remove(info.intent.getComponent());
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
private static ApplicationInfo findIntent(ApplicationsAdapter adapter, String packageName,
|
|
String name) {
|
|
|
|
final int count = adapter.getCount();
|
|
for (int i = 0; i < count; i++) {
|
|
final ApplicationInfo applicationInfo = adapter.getItem(i);
|
|
final Intent intent = applicationInfo.intent;
|
|
final ComponentName component = intent.getComponent();
|
|
if (packageName.equals(component.getPackageName()) &&
|
|
name.equals(component.getClassName())) {
|
|
return applicationInfo;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static boolean findIntent(List<ResolveInfo> apps, ComponentName component) {
|
|
final String className = component.getClassName();
|
|
for (ResolveInfo info : apps) {
|
|
final ActivityInfo activityInfo = info.activityInfo;
|
|
if (activityInfo.name.equals(className)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Drawable getApplicationInfoIcon(PackageManager manager, ApplicationInfo info) {
|
|
final ResolveInfo resolveInfo = manager.resolveActivity(info.intent, 0);
|
|
if (resolveInfo == null) {
|
|
return null;
|
|
}
|
|
|
|
ComponentName componentName = new ComponentName(
|
|
resolveInfo.activityInfo.applicationInfo.packageName,
|
|
resolveInfo.activityInfo.name);
|
|
ApplicationInfo application = mAppInfoCache.get(componentName);
|
|
|
|
if (application == null) {
|
|
return resolveInfo.activityInfo.loadIcon(manager);
|
|
}
|
|
|
|
return application.icon;
|
|
}
|
|
|
|
private static ApplicationInfo makeAndCacheApplicationInfo(PackageManager manager,
|
|
HashMap<ComponentName, ApplicationInfo> appInfoCache, ResolveInfo info) {
|
|
|
|
ComponentName componentName = new ComponentName(
|
|
info.activityInfo.applicationInfo.packageName,
|
|
info.activityInfo.name);
|
|
ApplicationInfo application = appInfoCache.get(componentName);
|
|
|
|
if (application == null) {
|
|
application = new ApplicationInfo();
|
|
application.container = ItemInfo.NO_ID;
|
|
|
|
updateApplicationInfoTitleAndIcon(manager, info, application);
|
|
|
|
application.setActivity(componentName,
|
|
Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
|
|
|
|
appInfoCache.put(componentName, application);
|
|
}
|
|
|
|
return application;
|
|
}
|
|
|
|
private static void updateApplicationInfoTitleAndIcon(PackageManager manager, ResolveInfo info,
|
|
ApplicationInfo application) {
|
|
|
|
application.title = info.loadLabel(manager);
|
|
if (application.title == null) {
|
|
application.title = info.activityInfo.name;
|
|
}
|
|
|
|
application.icon = info.activityInfo.loadIcon(manager);
|
|
application.filtered = false;
|
|
}
|
|
|
|
private class ApplicationsLoader implements Runnable {
|
|
private final WeakReference<Launcher> mLauncher;
|
|
|
|
private volatile boolean mStopped;
|
|
private volatile boolean mRunning;
|
|
|
|
ApplicationsLoader(Launcher launcher) {
|
|
mLauncher = new WeakReference<Launcher>(launcher);
|
|
}
|
|
|
|
void stop() {
|
|
mStopped = true;
|
|
}
|
|
|
|
boolean isRunning() {
|
|
return mRunning;
|
|
}
|
|
|
|
public void run() {
|
|
mRunning = true;
|
|
|
|
android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
|
|
|
|
final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
|
|
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
|
|
|
|
final Launcher launcher = mLauncher.get();
|
|
final PackageManager manager = launcher.getPackageManager();
|
|
final List<ResolveInfo> apps = manager.queryIntentActivities(mainIntent, 0);
|
|
|
|
if (apps != null && !mStopped) {
|
|
final int count = apps.size();
|
|
// Can be set to null on the UI thread by the unbind() method
|
|
// Do not access without checking for null first
|
|
final ApplicationsAdapter applicationList = mApplicationsAdapter;
|
|
|
|
ChangeNotifier action = new ChangeNotifier(applicationList, true);
|
|
final HashMap<ComponentName, ApplicationInfo> appInfoCache = mAppInfoCache;
|
|
|
|
for (int i = 0; i < count && !mStopped; i++) {
|
|
ResolveInfo info = apps.get(i);
|
|
ApplicationInfo application =
|
|
makeAndCacheApplicationInfo(manager, appInfoCache, info);
|
|
|
|
if (action.add(application) && !mStopped) {
|
|
launcher.runOnUiThread(action);
|
|
action = new ChangeNotifier(applicationList, false);
|
|
}
|
|
}
|
|
|
|
launcher.runOnUiThread(action);
|
|
}
|
|
|
|
if (!mStopped) {
|
|
mApplicationsLoaded = true;
|
|
}
|
|
mRunning = false;
|
|
}
|
|
}
|
|
|
|
private static class ChangeNotifier implements Runnable {
|
|
private final ApplicationsAdapter mApplicationList;
|
|
private final ArrayList<ApplicationInfo> mBuffer;
|
|
|
|
private boolean mFirst = true;
|
|
|
|
ChangeNotifier(ApplicationsAdapter applicationList, boolean first) {
|
|
mApplicationList = applicationList;
|
|
mFirst = first;
|
|
mBuffer = new ArrayList<ApplicationInfo>(UI_NOTIFICATION_RATE);
|
|
}
|
|
|
|
public void run() {
|
|
final ApplicationsAdapter applicationList = mApplicationList;
|
|
// Can be set to null on the UI thread by the unbind() method
|
|
if (applicationList == null) return;
|
|
|
|
if (mFirst) {
|
|
applicationList.setNotifyOnChange(false);
|
|
applicationList.clear();
|
|
mFirst = false;
|
|
}
|
|
|
|
final ArrayList<ApplicationInfo> buffer = mBuffer;
|
|
final int count = buffer.size();
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
applicationList.setNotifyOnChange(false);
|
|
applicationList.add(buffer.get(i));
|
|
}
|
|
|
|
buffer.clear();
|
|
|
|
applicationList.sort(new ApplicationInfoComparator());
|
|
applicationList.notifyDataSetChanged();
|
|
}
|
|
|
|
boolean add(ApplicationInfo application) {
|
|
final ArrayList<ApplicationInfo> buffer = mBuffer;
|
|
buffer.add(application);
|
|
return buffer.size() >= UI_NOTIFICATION_RATE;
|
|
}
|
|
}
|
|
|
|
private static class ApplicationInfoComparator implements Comparator<ApplicationInfo> {
|
|
public final int compare(ApplicationInfo a, ApplicationInfo b) {
|
|
return sCollator.compare(a.title.toString(), b.title.toString());
|
|
}
|
|
}
|
|
|
|
boolean isDesktopLoaded() {
|
|
return mDesktopItems != null && mDesktopAppWidgets != null && mDesktopItemsLoaded;
|
|
}
|
|
|
|
/**
|
|
* Loads all of the items on the desktop, in folders, or in the dock.
|
|
* These can be apps, shortcuts or widgets
|
|
*/
|
|
void loadUserItems(boolean isLaunching, Launcher launcher, boolean localeChanged,
|
|
boolean loadApplications) {
|
|
if (DEBUG_LOADERS) d(LOG_TAG, "loading user items");
|
|
|
|
if (isLaunching && isDesktopLoaded()) {
|
|
if (DEBUG_LOADERS) d(LOG_TAG, " --> items loaded, return");
|
|
if (loadApplications) startApplicationsLoader(launcher);
|
|
// We have already loaded our data from the DB
|
|
launcher.onDesktopItemsLoaded();
|
|
return;
|
|
}
|
|
|
|
if (mDesktopItemsLoader != null && mDesktopItemsLoader.isRunning()) {
|
|
mDesktopItemsLoader.stop();
|
|
// Wait for the currently running thread to finish, this can take a little
|
|
// time but it should be well below the timeout limit
|
|
try {
|
|
mDesktopLoaderThread.join(APPLICATION_NOT_RESPONDING_TIMEOUT);
|
|
} catch (InterruptedException e) {
|
|
// Empty
|
|
}
|
|
}
|
|
|
|
if (DEBUG_LOADERS) d(LOG_TAG, " --> starting workspace loader");
|
|
mDesktopItemsLoaded = false;
|
|
mDesktopItemsLoader = new DesktopItemsLoader(launcher, localeChanged, loadApplications);
|
|
mDesktopLoaderThread = new Thread(mDesktopItemsLoader, "Desktop Items Loader");
|
|
mDesktopLoaderThread.start();
|
|
}
|
|
|
|
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.getIntent(intentUri);
|
|
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 class DesktopItemsLoader implements Runnable {
|
|
private volatile boolean mStopped;
|
|
private volatile boolean mRunning;
|
|
|
|
private final WeakReference<Launcher> mLauncher;
|
|
private final boolean mLocaleChanged;
|
|
private final boolean mLoadApplications;
|
|
|
|
DesktopItemsLoader(Launcher launcher, boolean localeChanged, boolean loadApplications) {
|
|
mLoadApplications = loadApplications;
|
|
mLauncher = new WeakReference<Launcher>(launcher);
|
|
mLocaleChanged = localeChanged;
|
|
}
|
|
|
|
void stop() {
|
|
mStopped = true;
|
|
}
|
|
|
|
boolean isRunning() {
|
|
return mRunning;
|
|
}
|
|
|
|
public void run() {
|
|
mRunning = true;
|
|
|
|
final Launcher launcher = mLauncher.get();
|
|
final ContentResolver contentResolver = launcher.getContentResolver();
|
|
final PackageManager manager = launcher.getPackageManager();
|
|
|
|
if (mLocaleChanged) {
|
|
updateShortcutLabels(contentResolver, manager);
|
|
}
|
|
|
|
mDesktopItems = new ArrayList<ItemInfo>();
|
|
mDesktopAppWidgets = new ArrayList<LauncherAppWidgetInfo>();
|
|
mFolders = new HashMap<Long, FolderInfo>();
|
|
|
|
final ArrayList<ItemInfo> desktopItems = mDesktopItems;
|
|
final ArrayList<LauncherAppWidgetInfo> desktopAppWidgets = mDesktopAppWidgets;
|
|
|
|
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;
|
|
|
|
final HashMap<Long, FolderInfo> folders = mFolders;
|
|
|
|
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.getIntent(intentDescription);
|
|
} catch (java.net.URISyntaxException e) {
|
|
continue;
|
|
}
|
|
|
|
if (itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION) {
|
|
info = getApplicationInfo(manager, intent);
|
|
} else {
|
|
info = getApplicationInfoShortcut(c, launcher, iconTypeIndex,
|
|
iconPackageIndex, iconResourceIndex, iconIndex);
|
|
}
|
|
|
|
if (info == null) {
|
|
info = new ApplicationInfo();
|
|
info.icon = manager.getDefaultActivityIcon();
|
|
}
|
|
|
|
if (info != null) {
|
|
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:
|
|
desktopItems.add(info);
|
|
break;
|
|
default:
|
|
// Item is in a user folder
|
|
UserFolderInfo folderInfo =
|
|
findOrMakeUserFolder(folders, container);
|
|
folderInfo.add(info);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case LauncherSettings.Favorites.ITEM_TYPE_USER_FOLDER:
|
|
|
|
id = c.getLong(idIndex);
|
|
UserFolderInfo folderInfo = findOrMakeUserFolder(folders, 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:
|
|
desktopItems.add(folderInfo);
|
|
break;
|
|
}
|
|
break;
|
|
case LauncherSettings.Favorites.ITEM_TYPE_LIVE_FOLDER:
|
|
|
|
id = c.getLong(idIndex);
|
|
LiveFolderInfo liveFolderInfo = findOrMakeLiveFolder(folders, id);
|
|
|
|
intentDescription = c.getString(intentIndex);
|
|
intent = null;
|
|
if (intentDescription != null) {
|
|
try {
|
|
intent = Intent.getIntent(intentDescription);
|
|
} catch (java.net.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(launcher, c, iconTypeIndex, iconPackageIndex,
|
|
iconResourceIndex, liveFolderInfo);
|
|
|
|
switch (container) {
|
|
case LauncherSettings.Favorites.CONTAINER_DESKTOP:
|
|
desktopItems.add(liveFolderInfo);
|
|
break;
|
|
}
|
|
break;
|
|
case LauncherSettings.Favorites.ITEM_TYPE_WIDGET_SEARCH:
|
|
widgetInfo = Widget.makeSearch();
|
|
|
|
container = c.getInt(containerIndex);
|
|
if (container != LauncherSettings.Favorites.CONTAINER_DESKTOP) {
|
|
e(Launcher.LOG_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);
|
|
|
|
desktopItems.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) {
|
|
e(Launcher.LOG_TAG, "Widget found where container "
|
|
+ "!= CONTAINER_DESKTOP -- ignoring!");
|
|
continue;
|
|
}
|
|
appWidgetInfo.container = c.getInt(containerIndex);
|
|
|
|
desktopAppWidgets.add(appWidgetInfo);
|
|
break;
|
|
}
|
|
} catch (Exception e) {
|
|
w(Launcher.LOG_TAG, "Desktop items loading interrupted:", e);
|
|
}
|
|
}
|
|
} finally {
|
|
c.close();
|
|
}
|
|
|
|
if (!mStopped) {
|
|
launcher.runOnUiThread(new Runnable() {
|
|
public void run() {
|
|
launcher.onDesktopItemsLoaded();
|
|
}
|
|
});
|
|
if (mLoadApplications) startApplicationsLoader(launcher);
|
|
}
|
|
|
|
if (!mStopped) {
|
|
mDesktopItemsLoaded = true;
|
|
}
|
|
mRunning = false;
|
|
}
|
|
}
|
|
|
|
private static void loadLiveFolderIcon(Launcher launcher, 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 = launcher.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 =
|
|
launcher.getResources().getDrawable(R.drawable.ic_launcher_folder);
|
|
}
|
|
liveFolderInfo.iconResource = new Intent.ShortcutIconResource();
|
|
liveFolderInfo.iconResource.packageName = packageName;
|
|
liveFolderInfo.iconResource.resourceName = resourceName;
|
|
break;
|
|
default:
|
|
liveFolderInfo.icon =
|
|
launcher.getResources().getDrawable(R.drawable.ic_launcher_folder);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finds the user folder defined by the specified id.
|
|
*
|
|
* @param id The id of the folder to look for.
|
|
*
|
|
* @return A UserFolderInfo if the folder exists or null otherwise.
|
|
*/
|
|
FolderInfo findFolderById(long id) {
|
|
return mFolders.get(id);
|
|
}
|
|
|
|
void addFolder(FolderInfo info) {
|
|
mFolders.put(info.id, info);
|
|
}
|
|
|
|
/**
|
|
* Return an existing UserFolderInfo object if we have encountered this ID previously, or make a
|
|
* new one.
|
|
*/
|
|
private 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 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;
|
|
}
|
|
|
|
/**
|
|
* Remove the callback for the cached drawables or we leak the previous
|
|
* Home screen on orientation change.
|
|
*/
|
|
void unbind() {
|
|
// Interrupt the applications loader before setting the adapter to null
|
|
stopAndWaitForApplicationsLoader();
|
|
mApplicationsAdapter = null;
|
|
unbindAppDrawables(mApplications);
|
|
unbindDrawables(mDesktopItems);
|
|
unbindAppWidgetHostViews(mDesktopAppWidgets);
|
|
unbindCachedIconDrawables();
|
|
}
|
|
|
|
/**
|
|
* Remove the callback for the cached drawables or we leak the previous
|
|
* Home screen on orientation change.
|
|
*/
|
|
private void unbindDrawables(ArrayList<ItemInfo> desktopItems) {
|
|
if (desktopItems != null) {
|
|
final int count = desktopItems.size();
|
|
for (int i = 0; i < count; i++) {
|
|
ItemInfo item = desktopItems.get(i);
|
|
switch (item.itemType) {
|
|
case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
|
|
case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
|
|
((ApplicationInfo)item).icon.setCallback(null);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the callback for the cached drawables or we leak the previous
|
|
* Home screen on orientation change.
|
|
*/
|
|
private void unbindAppDrawables(ArrayList<ApplicationInfo> applications) {
|
|
if (applications != null) {
|
|
final int count = applications.size();
|
|
for (int i = 0; i < count; i++) {
|
|
applications.get(i).icon.setCallback(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove any {@link LauncherAppWidgetHostView} references in our widgets.
|
|
*/
|
|
private void unbindAppWidgetHostViews(ArrayList<LauncherAppWidgetInfo> appWidgets) {
|
|
if (appWidgets != null) {
|
|
final int count = appWidgets.size();
|
|
for (int i = 0; i < count; i++) {
|
|
LauncherAppWidgetInfo launcherInfo = appWidgets.get(i);
|
|
launcherInfo.hostView = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the callback for the cached drawables or we leak the previous
|
|
* Home screen on orientation change.
|
|
*/
|
|
private void unbindCachedIconDrawables() {
|
|
for (ApplicationInfo appInfo : mAppInfoCache.values()) {
|
|
appInfo.icon.setCallback(null);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return The current list of applications
|
|
*/
|
|
ApplicationsAdapter getApplicationsAdapter() {
|
|
return mApplicationsAdapter;
|
|
}
|
|
|
|
/**
|
|
* @return The current list of desktop items
|
|
*/
|
|
ArrayList<ItemInfo> getDesktopItems() {
|
|
return mDesktopItems;
|
|
}
|
|
|
|
/**
|
|
* @return The current list of desktop items
|
|
*/
|
|
ArrayList<LauncherAppWidgetInfo> getDesktopAppWidgets() {
|
|
return mDesktopAppWidgets;
|
|
}
|
|
|
|
/**
|
|
* Add an item to the desktop
|
|
* @param info
|
|
*/
|
|
void addDesktopItem(ItemInfo info) {
|
|
// TODO: write to DB; also check that folder has been added to folders list
|
|
mDesktopItems.add(info);
|
|
}
|
|
|
|
/**
|
|
* Remove an item from the desktop
|
|
* @param info
|
|
*/
|
|
void removeDesktopItem(ItemInfo info) {
|
|
// TODO: write to DB; figure out if we should remove folder from folders list
|
|
mDesktopItems.remove(info);
|
|
}
|
|
|
|
/**
|
|
* Add a widget to the desktop
|
|
*/
|
|
void addDesktopAppWidget(LauncherAppWidgetInfo info) {
|
|
mDesktopAppWidgets.add(info);
|
|
}
|
|
|
|
/**
|
|
* Remove a widget from the desktop
|
|
*/
|
|
void removeDesktopAppWidget(LauncherAppWidgetInfo info) {
|
|
mDesktopAppWidgets.remove(info);
|
|
}
|
|
|
|
/**
|
|
* Make an ApplicationInfo object for an application
|
|
*/
|
|
private static ApplicationInfo getApplicationInfo(PackageManager manager, Intent intent) {
|
|
final ResolveInfo resolveInfo = manager.resolveActivity(intent, 0);
|
|
|
|
if (resolveInfo == null) {
|
|
return null;
|
|
}
|
|
|
|
final ApplicationInfo info = new ApplicationInfo();
|
|
final ActivityInfo activityInfo = resolveInfo.activityInfo;
|
|
info.icon = activityInfo.loadIcon(manager);
|
|
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 ApplicationInfo getApplicationInfoShortcut(Cursor c, Launcher launcher,
|
|
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 = launcher.getPackageManager();
|
|
try {
|
|
Resources resources = packageManager.getResourcesForApplication(packageName);
|
|
final int id = resources.getIdentifier(resourceName, null, null);
|
|
info.icon = resources.getDrawable(id);
|
|
} 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);
|
|
Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
|
|
info.icon = new FastBitmapDrawable(
|
|
Utilities.createBitmapThumbnail(bitmap, launcher));
|
|
info.filtered = true;
|
|
info.customIcon = true;
|
|
break;
|
|
default:
|
|
info.icon = launcher.getPackageManager().getDefaultActivityIcon();
|
|
info.customIcon = false;
|
|
break;
|
|
}
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* Remove an item from the in-memory represention of a user folder. Does not change the DB.
|
|
*/
|
|
void removeUserFolderItem(UserFolderInfo folder, ItemInfo info) {
|
|
//noinspection SuspiciousMethodCalls
|
|
folder.contents.remove(info);
|
|
}
|
|
|
|
/**
|
|
* Removes a UserFolder from the in-memory list of folders. Does not change the DB.
|
|
* @param userFolderInfo
|
|
*/
|
|
void removeUserFolder(UserFolderInfo userFolderInfo) {
|
|
mFolders.remove(userFolderInfo.id);
|
|
}
|
|
|
|
/**
|
|
* 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() }, null);
|
|
boolean result = false;
|
|
try {
|
|
result = c.moveToFirst();
|
|
} finally {
|
|
c.close();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
FolderInfo getFolderById(Context context, 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(mFolders, id);
|
|
break;
|
|
case LauncherSettings.Favorites.ITEM_TYPE_LIVE_FOLDER:
|
|
folderInfo = findOrMakeLiveFolder(mFolders, 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);
|
|
}
|
|
}
|