blob: 5424d97bf9b2d016ee454f5a7a42f2558c784693 [file] [log] [blame]
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Daniel Sandler325dc232013-06-05 22:57:57 -040017package com.android.launcher3;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
Sunny Goyal29947f02017-12-18 13:49:44 -080019import static com.android.launcher3.LauncherAppState.ACTION_FORCE_ROLOAD;
20import static com.android.launcher3.config.FeatureFlags.IS_DOGFOOD_BUILD;
21
Sunny Goyalf599ccf2014-07-08 13:01:29 -070022import android.content.BroadcastReceiver;
Sunny Goyalf599ccf2014-07-08 13:01:29 -070023import android.content.ContentProviderOperation;
24import android.content.ContentResolver;
25import android.content.ContentValues;
26import android.content.Context;
27import android.content.Intent;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080028import android.net.Uri;
Joe Onorato36115782010-06-17 13:28:48 -040029import android.os.Handler;
30import android.os.HandlerThread;
Sunny Goyal756adbc2015-04-16 15:20:51 -070031import android.os.Looper;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080032import android.os.Process;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080033import android.os.UserHandle;
Winson Chunga90303b2013-11-15 13:05:06 -080034import android.text.TextUtils;
Winson Chungaafa03c2010-06-11 17:34:16 -070035import android.util.Log;
Sunny Goyala474a9b2017-05-04 16:47:11 -070036import android.util.Pair;
Michael Jurka34c2e6c2013-12-13 16:07:45 +010037
Kenny Guyed131872014-04-30 03:02:21 +010038import com.android.launcher3.compat.LauncherAppsCompat;
Sunny Goyale755d462014-07-22 13:48:29 -070039import com.android.launcher3.compat.PackageInstallerCompat.PackageInstallInfo;
Kenny Guyed131872014-04-30 03:02:21 +010040import com.android.launcher3.compat.UserManagerCompat;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070041import com.android.launcher3.icons.LauncherIcons;
Sunny Goyalf840f102018-09-21 14:41:05 -070042import com.android.launcher3.icons.IconCache;
Sunny Goyalf0ba8b72016-09-09 15:47:55 -070043import com.android.launcher3.model.AddWorkspaceItemsTask;
Sunny Goyale75d9f12018-01-31 11:59:00 -080044import com.android.launcher3.model.BaseModelUpdateTask;
Sunny Goyale9956a72016-09-01 17:24:47 -070045import com.android.launcher3.model.BgDataModel;
Sunny Goyalf0ba8b72016-09-09 15:47:55 -070046import com.android.launcher3.model.CacheDataUpdatedTask;
Sunny Goyalf8d6ed22017-06-01 14:26:38 -070047import com.android.launcher3.model.LoaderResults;
Sunny Goyalb434fde2017-06-06 10:46:59 -070048import com.android.launcher3.model.LoaderTask;
Sunny Goyal43bf11d2017-02-02 13:52:53 -080049import com.android.launcher3.model.ModelWriter;
Sunny Goyalf0ba8b72016-09-09 15:47:55 -070050import com.android.launcher3.model.PackageInstallStateChangedTask;
51import com.android.launcher3.model.PackageUpdatedTask;
52import com.android.launcher3.model.ShortcutsChangedTask;
53import com.android.launcher3.model.UserLockStateChangedTask;
Sunny Goyala9e2f5a2016-06-10 12:22:04 -070054import com.android.launcher3.provider.LauncherDbUtils;
Tony Wickhambfbf7f92016-05-19 11:19:39 -070055import com.android.launcher3.shortcuts.DeepShortcutManager;
56import com.android.launcher3.shortcuts.ShortcutInfoCompat;
Robin Lee26ace122015-03-16 19:41:43 +000057import com.android.launcher3.util.ComponentKey;
Sunny Goyal6e13dd32017-08-17 03:01:19 -070058import com.android.launcher3.util.ItemInfoMatcher;
Tony Wickhamd82a39d2016-07-01 15:44:13 -070059import com.android.launcher3.util.MultiHashMap;
Tony Wickham86222d22017-03-29 15:30:43 -070060import com.android.launcher3.util.PackageUserKey;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -070061import com.android.launcher3.util.Preconditions;
Sunny Goyal2bcbe132016-11-16 09:23:42 -080062import com.android.launcher3.util.Provider;
Adam Cohen091440a2015-03-18 14:16:05 -070063import com.android.launcher3.util.Thunk;
Sunny Goyal527c7d32015-08-28 15:19:36 -070064import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -070065import com.android.launcher3.widget.WidgetListRowEntry;
Romain Guyedcce092010-03-04 13:03:17 -080066
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -080067import java.io.FileDescriptor;
68import java.io.PrintWriter;
Michael Jurkac2f801e2011-07-12 14:19:46 -070069import java.lang.ref.WeakReference;
Michael Jurkac2f801e2011-07-12 14:19:46 -070070import java.util.ArrayList;
Winson Chungb8b2a5a2012-07-12 17:55:31 -070071import java.util.HashSet;
Winson Chung2abf94d2012-07-18 18:16:38 -070072import java.util.Iterator;
Michael Jurkac2f801e2011-07-12 14:19:46 -070073import java.util.List;
Sunny Goyaldd96a5e2017-02-17 11:22:34 -080074import java.util.concurrent.CancellationException;
Sunny Goyal527c7d32015-08-28 15:19:36 -070075import java.util.concurrent.Executor;
Michael Jurkac2f801e2011-07-12 14:19:46 -070076
Sunny Goyald2303072018-08-14 15:21:45 -070077import androidx.annotation.Nullable;
78
The Android Open Source Project31dd5032009-03-03 19:32:27 -080079/**
80 * Maintains in-memory state of the Launcher. It is expected that there should be only one
81 * LauncherModel object held in a static. Also provide APIs for updating the database state
The Android Open Source Projectbc219c32009-03-09 11:52:14 -070082 * for the Launcher.
The Android Open Source Project31dd5032009-03-03 19:32:27 -080083 */
Kenny Guyed131872014-04-30 03:02:21 +010084public class LauncherModel extends BroadcastReceiver
Kenny Guyc2bd8102014-06-30 12:30:31 +010085 implements LauncherAppsCompat.OnAppsChangedCallbackCompat {
Chris Wrenee523362014-09-09 10:09:02 -040086 private static final boolean DEBUG_RECEIVER = false;
Chris Wrenb358f812014-04-16 13:37:00 -040087
Joe Onorato9c1289c2009-08-17 11:03:03 -040088 static final String TAG = "Launcher.Model";
The Android Open Source Projectf96811c2009-03-18 17:39:48 -070089
Sunny Goyalb265ba72017-02-14 15:03:45 -080090 private final MainThreadExecutor mUiExecutor = new MainThreadExecutor();
Adam Cohen091440a2015-03-18 14:16:05 -070091 @Thunk final LauncherAppState mApp;
92 @Thunk final Object mLock = new Object();
Sunny Goyalb434fde2017-06-06 10:46:59 -070093 @Thunk
94 LoaderTask mLoaderTask;
Adam Cohen091440a2015-03-18 14:16:05 -070095 @Thunk boolean mIsLoaderTaskRunning;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080096
Adam Cohen091440a2015-03-18 14:16:05 -070097 @Thunk static final HandlerThread sWorkerThread = new HandlerThread("launcher-loader");
Brad Fitzpatrick700889f2010-10-11 09:40:44 -070098 static {
99 sWorkerThread.start();
100 }
Adam Cohen091440a2015-03-18 14:16:05 -0700101 @Thunk static final Handler sWorker = new Handler(sWorkerThread.getLooper());
Brad Fitzpatrick700889f2010-10-11 09:40:44 -0700102
Sunny Goyaldd96a5e2017-02-17 11:22:34 -0800103 // Indicates whether the current model data is valid or not.
104 // We start off with everything not loaded. After that, we assume that
Joe Onoratocc67f472010-06-08 10:54:30 -0700105 // our monitoring of the package manager provides all updates and we never
Sunny Goyaldd96a5e2017-02-17 11:22:34 -0800106 // need to do a requery. This is only ever touched from the loader thread.
107 private boolean mModelLoaded;
Hyunyoung Song6aa37292017-02-06 10:46:24 -0800108 public boolean isModelLoaded() {
109 synchronized (mLock) {
110 return mModelLoaded && mLoaderTask == null;
111 }
112 }
Joe Onoratocc67f472010-06-08 10:54:30 -0700113
Adam Cohen091440a2015-03-18 14:16:05 -0700114 @Thunk WeakReference<Callbacks> mCallbacks;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800115
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700116 // < only access in worker thread >
Sunny Goyal2e1efb42016-03-03 16:58:55 -0800117 private final AllAppsList mBgAllAppsList;
Sunny Goyal95f3d6b2016-08-10 16:09:29 -0700118
Sunny Goyale9956a72016-09-01 17:24:47 -0700119 /**
120 * All the static data should be accessed on the background thread, A lock should be acquired
121 * on this object when accessing any data from this model.
122 */
123 static final BgDataModel sBgDataModel = new BgDataModel();
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700124
Sunny Goyalc6e97692017-06-02 13:46:55 -0700125 // Runnable to check if the shortcuts permission has changed.
126 private final Runnable mShortcutPermissionCheckRunnable = new Runnable() {
127 @Override
128 public void run() {
129 if (mModelLoaded) {
130 boolean hasShortcutHostPermission =
131 DeepShortcutManager.getInstance(mApp.getContext()).hasHostPermission();
132 if (hasShortcutHostPermission != sBgDataModel.hasShortcutHostPermission) {
133 forceReload();
134 }
135 }
136 }
137 };
Kenny Guyed131872014-04-30 03:02:21 +0100138
Sunny Goyalaeb16432017-10-16 11:46:41 -0700139 public interface Callbacks {
Sunny Goyal605bcf32018-03-02 15:16:12 -0800140 public void rebindModel();
141
Joe Onorato9c1289c2009-08-17 11:03:03 -0400142 public int getCurrentWorkspaceScreen();
Sunny Goyal527c7d32015-08-28 15:19:36 -0700143 public void clearPendingBinds();
Joe Onorato9c1289c2009-08-17 11:03:03 -0400144 public void startBinding();
Sunny Goyalb23980c2017-08-17 07:45:25 -0700145 public void bindItems(List<ItemInfo> shortcuts, boolean forceAnimateIcons);
Adam Cohendcd297f2013-06-18 13:13:40 -0700146 public void bindScreens(ArrayList<Long> orderedScreenIds);
Sunny Goyalb5b9ad62016-04-02 11:23:39 -0700147 public void finishFirstPageBind(ViewOnDrawExecutor executor);
Tony Wickham6a71a5b2018-08-21 11:40:23 -0700148 public void finishBindingItems(int currentScreen);
Michael Jurkaeadbfc52013-09-04 00:45:37 +0200149 public void bindAllApplications(ArrayList<AppInfo> apps);
Sunny Goyalb23980c2017-08-17 07:45:25 -0700150 public void bindAppsAddedOrUpdated(ArrayList<AppInfo> apps);
Tony Wickham6a71a5b2018-08-21 11:40:23 -0700151 public void preAddApps();
Winson Chungd64d1762013-08-20 14:37:16 -0700152 public void bindAppsAdded(ArrayList<Long> newScreens,
153 ArrayList<ItemInfo> addNotAnimated,
Sunny Goyalb23980c2017-08-17 07:45:25 -0700154 ArrayList<ItemInfo> addAnimated);
Mario Bertschler08ffaae2017-03-20 11:30:27 -0700155 public void bindPromiseAppProgressUpdated(PromiseAppInfo app);
Sunny Goyal6e13dd32017-08-17 03:01:19 -0700156 public void bindShortcutsChanged(ArrayList<ShortcutInfo> updated, UserHandle user);
Sunny Goyal4390ace2014-10-13 11:33:11 -0700157 public void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets);
Sunny Goyal756adbc2015-04-16 15:20:51 -0700158 public void bindRestoreItemsChange(HashSet<ItemInfo> updates);
Sunny Goyal6e13dd32017-08-17 03:01:19 -0700159 public void bindWorkspaceComponentsRemoved(ItemInfoMatcher matcher);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -0700160 public void bindAppInfosRemoved(ArrayList<AppInfo> appInfos);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700161 public void bindAllWidgets(ArrayList<WidgetListRowEntry> widgets);
Adam Cohen1462de32012-07-24 22:34:36 -0700162 public void onPageBoundSynchronously(int page);
Sunny Goyal527c7d32015-08-28 15:19:36 -0700163 public void executeOnNextDraw(ViewOnDrawExecutor executor);
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700164 public void bindDeepShortcutMap(MultiHashMap<ComponentKey, String> deepShortcutMap);
Joe Onorato9c1289c2009-08-17 11:03:03 -0400165 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800166
Sunny Goyaldde4fd92016-11-21 16:02:39 +0530167 LauncherModel(LauncherAppState app, IconCache iconCache, AppFilter appFilter) {
Daniel Sandlere4f98912013-06-25 15:13:26 -0400168 mApp = app;
Bjorn Bringert1307f632013-10-03 22:31:03 +0100169 mBgAllAppsList = new AllAppsList(iconCache, appFilter);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800170 }
171
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700172 /** Runs the specified runnable immediately if called from the worker thread, otherwise it is
173 * posted on the worker thread handler. */
Tony Wickham80f57872016-06-29 18:12:15 -0700174 private static void runOnWorkerThread(Runnable r) {
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700175 if (sWorkerThread.getThreadId() == Process.myTid()) {
176 r.run();
177 } else {
178 // If we are not on the worker thread, then post to the worker handler
179 sWorker.post(r);
180 }
181 }
182
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700183 public void setPackageState(PackageInstallInfo installInfo) {
184 enqueueModelUpdateTask(new PackageInstallStateChangedTask(installInfo));
Chris Wrenaeff7ea2014-02-14 16:59:24 -0500185 }
186
Sunny Goyal756adbc2015-04-16 15:20:51 -0700187 /**
188 * Updates the icons and label of all pending icons for the provided package name.
189 */
190 public void updateSessionDisplayInfo(final String packageName) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700191 HashSet<String> packages = new HashSet<>();
192 packages.add(packageName);
193 enqueueModelUpdateTask(new CacheDataUpdatedTask(
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800194 CacheDataUpdatedTask.OP_SESSION_UPDATE, Process.myUserHandle(), packages));
Sunny Goyal71b5c0b2015-01-08 16:59:04 -0800195 }
196
197 /**
198 * Adds the provided items to the workspace.
Sunny Goyal71b5c0b2015-01-08 16:59:04 -0800199 */
Sunny Goyal91498ab2017-10-05 15:57:40 -0700200 public void addAndBindAddedWorkspaceItems(List<Pair<ItemInfo, Object>> itemList) {
Tony Wickham6a71a5b2018-08-21 11:40:23 -0700201 Callbacks callbacks = getCallback();
202 if (callbacks != null) {
203 callbacks.preAddApps();
204 }
Sunny Goyal91498ab2017-10-05 15:57:40 -0700205 enqueueModelUpdateTask(new AddWorkspaceItemsTask(itemList));
Winson Chung64359a52013-07-08 17:17:08 -0700206 }
207
Sunny Goyal605bcf32018-03-02 15:16:12 -0800208 public ModelWriter getWriter(boolean hasVerticalHotseat, boolean verifyChanges) {
209 return new ModelWriter(mApp.getContext(), this, sBgDataModel,
210 hasVerticalHotseat, verifyChanges);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800211 }
212
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700213 static void checkItemInfoLocked(
214 final long itemId, final ItemInfo item, StackTraceElement[] stackTrace) {
Vadim Tryshevc052e4e2018-10-05 15:17:42 -0700215 if (com.android.launcher3.Utilities.IS_RUNNING_IN_TEST_HARNESS
216 && com.android.launcher3.Utilities.IS_DEBUG_DEVICE) {
217 android.util.Log.d("b/117332845",
218 "Checking item: " + android.util.Log.getStackTraceString(new Throwable()));
219 }
Sunny Goyale9956a72016-09-01 17:24:47 -0700220 ItemInfo modelItem = sBgDataModel.itemsIdMap.get(itemId);
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700221 if (modelItem != null && item != modelItem) {
222 // check all the data is consistent
223 if (modelItem instanceof ShortcutInfo && item instanceof ShortcutInfo) {
224 ShortcutInfo modelShortcut = (ShortcutInfo) modelItem;
225 ShortcutInfo shortcut = (ShortcutInfo) item;
226 if (modelShortcut.title.toString().equals(shortcut.title.toString()) &&
227 modelShortcut.intent.filterEquals(shortcut.intent) &&
228 modelShortcut.id == shortcut.id &&
229 modelShortcut.itemType == shortcut.itemType &&
230 modelShortcut.container == shortcut.container &&
Adam Cohendcd297f2013-06-18 13:13:40 -0700231 modelShortcut.screenId == shortcut.screenId &&
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700232 modelShortcut.cellX == shortcut.cellX &&
233 modelShortcut.cellY == shortcut.cellY &&
234 modelShortcut.spanX == shortcut.spanX &&
Sunny Goyalaa8ef112015-06-12 20:04:41 -0700235 modelShortcut.spanY == shortcut.spanY) {
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700236 // For all intents and purposes, this is the same object
237 return;
238 }
239 }
240
241 // the modelItem needs to match up perfectly with item if our model is
242 // to be consistent with the database-- for now, just require
243 // modelItem == item or the equality check above
244 String msg = "item: " + ((item != null) ? item.toString() : "null") +
245 "modelItem: " +
246 ((modelItem != null) ? modelItem.toString() : "null") +
247 "Error: ItemInfo passed to checkItemInfo doesn't match original";
248 RuntimeException e = new RuntimeException(msg);
249 if (stackTrace != null) {
250 e.setStackTrace(stackTrace);
251 }
Adam Cohenb9ada652013-11-08 08:25:08 -0800252 throw e;
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700253 }
254 }
255
Michael Jurka816474f2012-06-25 14:49:02 -0700256 static void checkItemInfo(final ItemInfo item) {
257 final StackTraceElement[] stackTrace = new Throwable().getStackTrace();
258 final long itemId = item.id;
259 Runnable r = new Runnable() {
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700260 public void run() {
Sunny Goyale9956a72016-09-01 17:24:47 -0700261 synchronized (sBgDataModel) {
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700262 checkItemInfoLocked(itemId, item, stackTrace);
Michael Jurka816474f2012-06-25 14:49:02 -0700263 }
Michael Jurkab2ae8ac2012-09-21 12:06:06 -0700264 }
265 };
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700266 runOnWorkerThread(r);
Michael Jurka816474f2012-06-25 14:49:02 -0700267 }
268
Joe Onorato9c1289c2009-08-17 11:03:03 -0400269 /**
Adam Cohendcd297f2013-06-18 13:13:40 -0700270 * Update the order of the workspace screens in the database. The array list contains
271 * a list of screen ids in the order that they should appear.
272 */
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700273 public static void updateWorkspaceScreenOrder(Context context, final ArrayList<Long> screens) {
Winson Chung64359a52013-07-08 17:17:08 -0700274 final ArrayList<Long> screensCopy = new ArrayList<Long>(screens);
Adam Cohendcd297f2013-06-18 13:13:40 -0700275 final ContentResolver cr = context.getContentResolver();
276 final Uri uri = LauncherSettings.WorkspaceScreens.CONTENT_URI;
277
278 // Remove any negative screen ids -- these aren't persisted
Winson Chung64359a52013-07-08 17:17:08 -0700279 Iterator<Long> iter = screensCopy.iterator();
Adam Cohendcd297f2013-06-18 13:13:40 -0700280 while (iter.hasNext()) {
281 long id = iter.next();
282 if (id < 0) {
283 iter.remove();
284 }
285 }
286
287 Runnable r = new Runnable() {
288 @Override
289 public void run() {
Yura085c8532014-02-11 15:15:29 +0000290 ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
Adam Cohendcd297f2013-06-18 13:13:40 -0700291 // Clear the table
Yura085c8532014-02-11 15:15:29 +0000292 ops.add(ContentProviderOperation.newDelete(uri).build());
Winson Chung76828c82013-08-19 15:43:29 -0700293 int count = screensCopy.size();
Adam Cohendcd297f2013-06-18 13:13:40 -0700294 for (int i = 0; i < count; i++) {
295 ContentValues v = new ContentValues();
Winson Chung76828c82013-08-19 15:43:29 -0700296 long screenId = screensCopy.get(i);
Adam Cohendcd297f2013-06-18 13:13:40 -0700297 v.put(LauncherSettings.WorkspaceScreens._ID, screenId);
298 v.put(LauncherSettings.WorkspaceScreens.SCREEN_RANK, i);
Yura085c8532014-02-11 15:15:29 +0000299 ops.add(ContentProviderOperation.newInsert(uri).withValues(v).build());
Adam Cohendcd297f2013-06-18 13:13:40 -0700300 }
Yura085c8532014-02-11 15:15:29 +0000301
302 try {
303 cr.applyBatch(LauncherProvider.AUTHORITY, ops);
304 } catch (Exception ex) {
305 throw new RuntimeException(ex);
306 }
Winson Chung9e6a0a22013-08-27 11:58:12 -0700307
Sunny Goyale9956a72016-09-01 17:24:47 -0700308 synchronized (sBgDataModel) {
309 sBgDataModel.workspaceScreens.clear();
310 sBgDataModel.workspaceScreens.addAll(screensCopy);
Adam Cohen4caf2982013-08-20 18:54:31 -0700311 }
Adam Cohendcd297f2013-06-18 13:13:40 -0700312 }
313 };
314 runOnWorkerThread(r);
315 }
316
317 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -0400318 * Set this as the current Launcher activity object for the loader.
319 */
320 public void initialize(Callbacks callbacks) {
321 synchronized (mLock) {
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -0700322 Preconditions.assertUIThread();
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -0700323 mCallbacks = new WeakReference<>(callbacks);
Joe Onorato9c1289c2009-08-17 11:03:03 -0400324 }
325 }
326
Kenny Guyed131872014-04-30 03:02:21 +0100327 @Override
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800328 public void onPackageChanged(String packageName, UserHandle user) {
Kenny Guyed131872014-04-30 03:02:21 +0100329 int op = PackageUpdatedTask.OP_UPDATE;
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700330 enqueueModelUpdateTask(new PackageUpdatedTask(op, user, packageName));
Kenny Guyed131872014-04-30 03:02:21 +0100331 }
332
333 @Override
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800334 public void onPackageRemoved(String packageName, UserHandle user) {
Sunny Goyalc2936bc2016-09-01 15:50:36 -0700335 onPackagesRemoved(user, packageName);
336 }
337
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800338 public void onPackagesRemoved(UserHandle user, String... packages) {
Kenny Guyed131872014-04-30 03:02:21 +0100339 int op = PackageUpdatedTask.OP_REMOVE;
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700340 enqueueModelUpdateTask(new PackageUpdatedTask(op, user, packages));
Kenny Guyed131872014-04-30 03:02:21 +0100341 }
342
343 @Override
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800344 public void onPackageAdded(String packageName, UserHandle user) {
Kenny Guyed131872014-04-30 03:02:21 +0100345 int op = PackageUpdatedTask.OP_ADD;
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700346 enqueueModelUpdateTask(new PackageUpdatedTask(op, user, packageName));
Kenny Guyed131872014-04-30 03:02:21 +0100347 }
348
349 @Override
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800350 public void onPackagesAvailable(String[] packageNames, UserHandle user,
Kenny Guyed131872014-04-30 03:02:21 +0100351 boolean replacing) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700352 enqueueModelUpdateTask(
353 new PackageUpdatedTask(PackageUpdatedTask.OP_UPDATE, user, packageNames));
Kenny Guyed131872014-04-30 03:02:21 +0100354 }
355
356 @Override
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800357 public void onPackagesUnavailable(String[] packageNames, UserHandle user,
Kenny Guyed131872014-04-30 03:02:21 +0100358 boolean replacing) {
359 if (!replacing) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700360 enqueueModelUpdateTask(new PackageUpdatedTask(
361 PackageUpdatedTask.OP_UNAVAILABLE, user, packageNames));
Kenny Guyed131872014-04-30 03:02:21 +0100362 }
Kenny Guyed131872014-04-30 03:02:21 +0100363 }
364
Kenny Guy44cba692016-01-21 19:50:02 +0000365 @Override
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800366 public void onPackagesSuspended(String[] packageNames, UserHandle user) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700367 enqueueModelUpdateTask(new PackageUpdatedTask(
368 PackageUpdatedTask.OP_SUSPEND, user, packageNames));
Kenny Guy44cba692016-01-21 19:50:02 +0000369 }
370
371 @Override
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800372 public void onPackagesUnsuspended(String[] packageNames, UserHandle user) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700373 enqueueModelUpdateTask(new PackageUpdatedTask(
374 PackageUpdatedTask.OP_UNSUSPEND, user, packageNames));
Kenny Guy44cba692016-01-21 19:50:02 +0000375 }
376
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700377 @Override
378 public void onShortcutsChanged(String packageName, List<ShortcutInfoCompat> shortcuts,
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800379 UserHandle user) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700380 enqueueModelUpdateTask(new ShortcutsChangedTask(packageName, shortcuts, user, true));
Sunny Goyal50941fb2016-08-04 12:03:52 -0700381 }
382
383 public void updatePinnedShortcuts(String packageName, List<ShortcutInfoCompat> shortcuts,
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800384 UserHandle user) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700385 enqueueModelUpdateTask(new ShortcutsChangedTask(packageName, shortcuts, user, false));
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700386 }
387
Joe Onorato1d8e7bb2009-10-15 19:49:43 -0700388 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -0400389 * Call from the handler for ACTION_PACKAGE_ADDED, ACTION_PACKAGE_REMOVED and
390 * ACTION_PACKAGE_CHANGED.
391 */
Narayan Kamathcb1a4772011-06-28 13:46:59 +0100392 @Override
Joe Onoratof99f8c12009-10-31 17:27:36 -0400393 public void onReceive(Context context, Intent intent) {
Chris Wrenb358f812014-04-16 13:37:00 -0400394 if (DEBUG_RECEIVER) Log.d(TAG, "onReceive intent=" + intent);
Winson Chungaafa03c2010-06-11 17:34:16 -0700395
Joe Onorato36115782010-06-17 13:28:48 -0400396 final String action = intent.getAction();
Kenny Guyed131872014-04-30 03:02:21 +0100397 if (Intent.ACTION_LOCALE_CHANGED.equals(action)) {
Reena Lee93f824a2011-09-23 17:20:28 -0700398 // If we have changed locale we need to clear out the labels in all apps/workspace.
399 forceReload();
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700400 } else if (Intent.ACTION_MANAGED_PROFILE_ADDED.equals(action)
401 || Intent.ACTION_MANAGED_PROFILE_REMOVED.equals(action)) {
Sunny Goyal823fd502015-08-04 11:40:13 -0700402 UserManagerCompat.getInstance(context).enableAndResetCache();
Sunny Goyal957c13f2015-05-01 13:02:20 -0700403 forceReload();
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700404 } else if (Intent.ACTION_MANAGED_PROFILE_AVAILABLE.equals(action) ||
405 Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE.equals(action) ||
406 Intent.ACTION_MANAGED_PROFILE_UNLOCKED.equals(action)) {
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800407 UserHandle user = intent.getParcelableExtra(Intent.EXTRA_USER);
Sunny Goyalda891c12016-03-18 18:29:24 -0700408 if (user != null) {
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700409 if (Intent.ACTION_MANAGED_PROFILE_AVAILABLE.equals(action) ||
410 Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE.equals(action)) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700411 enqueueModelUpdateTask(new PackageUpdatedTask(
412 PackageUpdatedTask.OP_USER_AVAILABILITY_CHANGE, user));
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700413 }
414
415 // ACTION_MANAGED_PROFILE_UNAVAILABLE sends the profile back to locked mode, so
416 // we need to run the state change task again.
417 if (Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE.equals(action) ||
418 Intent.ACTION_MANAGED_PROFILE_UNLOCKED.equals(action)) {
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700419 enqueueModelUpdateTask(new UserLockStateChangedTask(user));
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700420 }
Sunny Goyalda891c12016-03-18 18:29:24 -0700421 }
Sunny Goyal29947f02017-12-18 13:49:44 -0800422 } else if (IS_DOGFOOD_BUILD && ACTION_FORCE_ROLOAD.equals(action)) {
423 forceReload();
Joe Onoratoe9ad59e2010-10-29 17:35:36 -0700424 }
425 }
426
Sunny Goyaldd96a5e2017-02-17 11:22:34 -0800427 /**
428 * Reloads the workspace items from the DB and re-binds the workspace. This should generally
429 * not be called as DB updates are automatically followed by UI update
430 */
431 public void forceReload() {
432 synchronized (mLock) {
433 // Stop any existing loaders first, so they don't set mModelLoaded to true later
Sunny Goyale86f11f2017-06-06 14:33:18 -0700434 stopLoader();
Sunny Goyaldd96a5e2017-02-17 11:22:34 -0800435 mModelLoaded = false;
436 }
Winson Chungf0c6ae02012-03-21 16:10:31 -0700437
Sunny Goyal29947f02017-12-18 13:49:44 -0800438 // Start the loader if launcher is already running, otherwise the loader will run,
439 // the next time launcher starts
Sunny Goyale0f58d72014-11-10 18:05:31 -0800440 Callbacks callbacks = getCallback();
441 if (callbacks != null) {
Sunny Goyal29947f02017-12-18 13:49:44 -0800442 startLoader(callbacks.getCurrentWorkspaceScreen());
Joe Onoratoe9ad59e2010-10-29 17:35:36 -0700443 }
Joe Onorato36115782010-06-17 13:28:48 -0400444 }
Joe Onoratof99f8c12009-10-31 17:27:36 -0400445
Adam Cohen1a85c582014-09-30 09:48:49 -0700446 public boolean isCurrentCallbacks(Callbacks callbacks) {
447 return (mCallbacks != null && mCallbacks.get() == callbacks);
448 }
449
Sunny Goyalb5b9ad62016-04-02 11:23:39 -0700450 /**
451 * Starts the loader. Tries to bind {@params synchronousBindPage} synchronously if possible.
452 * @return true if the page could be bound synchronously.
453 */
454 public boolean startLoader(int synchronousBindPage) {
Sunny Goyal756adbc2015-04-16 15:20:51 -0700455 // Enable queue before starting loader. It will get disabled in Launcher#finishBindingItems
Sunny Goyala474a9b2017-05-04 16:47:11 -0700456 InstallShortcutReceiver.enableInstallQueue(InstallShortcutReceiver.FLAG_LOADER_RUNNING);
Joe Onorato36115782010-06-17 13:28:48 -0400457 synchronized (mLock) {
Joe Onorato36115782010-06-17 13:28:48 -0400458 // Don't bother to start the thread if we know it's not going to do anything
459 if (mCallbacks != null && mCallbacks.get() != null) {
Sunny Goyal527c7d32015-08-28 15:19:36 -0700460 final Callbacks oldCallbacks = mCallbacks.get();
461 // Clear any pending bind-runnables from the synchronized load process.
Sunny Goyal0e7724c2018-02-22 13:22:21 -0800462 mUiExecutor.execute(oldCallbacks::clearPendingBinds);
Sunny Goyal527c7d32015-08-28 15:19:36 -0700463
Joe Onorato36115782010-06-17 13:28:48 -0400464 // If there is already one running, tell it to stop.
Sunny Goyale86f11f2017-06-06 14:33:18 -0700465 stopLoader();
Sunny Goyalf8d6ed22017-06-01 14:26:38 -0700466 LoaderResults loaderResults = new LoaderResults(mApp, sBgDataModel,
467 mBgAllAppsList, synchronousBindPage, mCallbacks);
Sunny Goyale86f11f2017-06-06 14:33:18 -0700468 if (mModelLoaded && !mIsLoaderTaskRunning) {
Sunny Goyalf8d6ed22017-06-01 14:26:38 -0700469 // Divide the set of loaded items into those that we are binding synchronously,
470 // and everything else that is to be bound normally (asynchronously).
471 loaderResults.bindWorkspace();
472 // For now, continue posting the binding of AllApps as there are other
473 // issues that arise from that.
474 loaderResults.bindAllApps();
475 loaderResults.bindDeepShortcuts();
Sunny Goyalc6e97692017-06-02 13:46:55 -0700476 loaderResults.bindWidgets();
Sunny Goyalb5b9ad62016-04-02 11:23:39 -0700477 return true;
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700478 } else {
Sunny Goyale86f11f2017-06-06 14:33:18 -0700479 startLoaderForResults(loaderResults);
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700480 }
Joe Onorato9c1289c2009-08-17 11:03:03 -0400481 }
Joe Onorato9c1289c2009-08-17 11:03:03 -0400482 }
Sunny Goyalb5b9ad62016-04-02 11:23:39 -0700483 return false;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400484 }
485
Sunny Goyale86f11f2017-06-06 14:33:18 -0700486 /**
487 * If there is already a loader task running, tell it to stop.
488 */
Joe Onorato36115782010-06-17 13:28:48 -0400489 public void stopLoader() {
490 synchronized (mLock) {
Sunny Goyale86f11f2017-06-06 14:33:18 -0700491 LoaderTask oldTask = mLoaderTask;
492 mLoaderTask = null;
493 if (oldTask != null) {
494 oldTask.stopLocked();
Joe Onorato9c1289c2009-08-17 11:03:03 -0400495 }
496 }
Joe Onorato36115782010-06-17 13:28:48 -0400497 }
Joe Onorato9c1289c2009-08-17 11:03:03 -0400498
Sunny Goyale86f11f2017-06-06 14:33:18 -0700499 public void startLoaderForResults(LoaderResults results) {
500 synchronized (mLock) {
501 stopLoader();
502 mLoaderTask = new LoaderTask(mApp, mBgAllAppsList, sBgDataModel, results);
503 runOnWorkerThread(mLoaderTask);
504 }
505 }
506
Winson Chungd6519662018-02-16 03:23:51 +0000507 public void startLoaderForResultsIfNotLoaded(LoaderResults results) {
508 synchronized (mLock) {
509 if (!isModelLoaded()) {
510 Log.d(TAG, "Workspace not loaded, loading now");
511 startLoaderForResults(results);
512 }
513 }
514 }
515
Sunny Goyalc1b7c2e2015-01-16 16:19:04 -0800516 /**
517 * Loads the workspace screen ids in an ordered list.
518 */
Sunny Goyale5bb7052015-07-27 14:36:07 -0700519 public static ArrayList<Long> loadWorkspaceScreensDb(Context context) {
Winson Chung76828c82013-08-19 15:43:29 -0700520 final ContentResolver contentResolver = context.getContentResolver();
521 final Uri screensUri = LauncherSettings.WorkspaceScreens.CONTENT_URI;
Winson Chung76828c82013-08-19 15:43:29 -0700522
Sunny Goyalc1b7c2e2015-01-16 16:19:04 -0800523 // Get screens ordered by rank.
Sunny Goyala9e2f5a2016-06-10 12:22:04 -0700524 return LauncherDbUtils.getScreenIdsFromCursor(contentResolver.query(
525 screensUri, null, null, null, LauncherSettings.WorkspaceScreens.SCREEN_RANK));
Winson Chung76828c82013-08-19 15:43:29 -0700526 }
527
Mario Bertschler817afa32017-03-15 11:56:47 -0700528 public void onInstallSessionCreated(final PackageInstallInfo sessionInfo) {
Sunny Goyale86f11f2017-06-06 14:33:18 -0700529 enqueueModelUpdateTask(new BaseModelUpdateTask() {
Mario Bertschler817afa32017-03-15 11:56:47 -0700530 @Override
531 public void execute(LauncherAppState app, BgDataModel dataModel, AllAppsList apps) {
532 apps.addPromiseApp(app.getContext(), sessionInfo);
533 if (!apps.added.isEmpty()) {
534 final ArrayList<AppInfo> arrayList = new ArrayList<>(apps.added);
535 apps.added.clear();
536 scheduleCallbackTask(new CallbackTask() {
537 @Override
538 public void execute(Callbacks callbacks) {
Sunny Goyalb23980c2017-08-17 07:45:25 -0700539 callbacks.bindAppsAddedOrUpdated(arrayList);
Mario Bertschler817afa32017-03-15 11:56:47 -0700540 }
541 });
542 }
543 }
544 });
545 }
546
Sunny Goyalc6e97692017-06-02 13:46:55 -0700547 public class LoaderTransaction implements AutoCloseable {
548
549 private final LoaderTask mTask;
550
551 private LoaderTransaction(LoaderTask task) throws CancellationException {
552 synchronized (mLock) {
553 if (mLoaderTask != task) {
554 throw new CancellationException("Loader already stopped");
555 }
556 mTask = task;
557 mIsLoaderTaskRunning = true;
558 mModelLoaded = false;
559 }
560 }
561
562 public void commit() {
563 synchronized (mLock) {
564 // Everything loaded bind the data.
565 mModelLoaded = true;
Vadim Trysheva7da86e2018-10-05 20:03:57 -0700566 if (com.android.launcher3.Utilities.IS_RUNNING_IN_TEST_HARNESS
567 && com.android.launcher3.Utilities.IS_DEBUG_DEVICE) {
568 android.util.Log.d("b/117332845",
569 android.util.Log.getStackTraceString(new Throwable()));
570 }
Sunny Goyalc6e97692017-06-02 13:46:55 -0700571 }
572 }
573
574 @Override
575 public void close() {
576 synchronized (mLock) {
577 // If we are still the last one to be scheduled, remove ourselves.
578 if (mLoaderTask == mTask) {
579 mLoaderTask = null;
580 }
581 mIsLoaderTaskRunning = false;
582 }
583 }
584 }
585
586 public LoaderTransaction beginLoader(LoaderTask task) throws CancellationException {
587 return new LoaderTransaction(task);
588 }
589
Joe Onorato36115782010-06-17 13:28:48 -0400590 /**
Sunny Goyal95f3d6b2016-08-10 16:09:29 -0700591 * Refreshes the cached shortcuts if the shortcut permission has changed.
592 * Current implementation simply reloads the workspace, but it can be optimized to
593 * use partial updates similar to {@link UserManagerCompat}
594 */
595 public void refreshShortcutsIfRequired() {
Sunny Goyalf5e37442016-11-02 10:31:24 -0700596 if (Utilities.ATLEAST_NOUGAT_MR1) {
Sunny Goyal95f3d6b2016-08-10 16:09:29 -0700597 sWorker.removeCallbacks(mShortcutPermissionCheckRunnable);
598 sWorker.post(mShortcutPermissionCheckRunnable);
599 }
600 }
601
602 /**
Sunny Goyal75b0f552015-05-20 21:57:06 -0700603 * Called when the icons for packages have been updated in the icon cache.
604 */
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800605 public void onPackageIconsUpdated(HashSet<String> updatedPackages, UserHandle user) {
Sunny Goyal75b0f552015-05-20 21:57:06 -0700606 // If any package icon has changed (app was updated while launcher was dead),
607 // update the corresponding shortcuts.
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700608 enqueueModelUpdateTask(new CacheDataUpdatedTask(
609 CacheDataUpdatedTask.OP_CACHE_UPDATE, user, updatedPackages));
Sunny Goyal75b0f552015-05-20 21:57:06 -0700610 }
611
Sunny Goyalac8154a2018-09-26 12:00:30 -0700612 /**
613 * Called when the labels for the widgets has updated in the icon cache.
614 */
615 public void onWidgetLabelsUpdated(HashSet<String> updatedPackages, UserHandle user) {
616 enqueueModelUpdateTask(new BaseModelUpdateTask() {
617 @Override
618 public void execute(LauncherAppState app, BgDataModel dataModel, AllAppsList apps) {
619 dataModel.widgetsModel.onPackageIconsUpdated(updatedPackages, user, app);
620 bindUpdatedWidgets(dataModel);
621 }
622 });
623 }
624
Sunny Goyale86f11f2017-06-06 14:33:18 -0700625 public void enqueueModelUpdateTask(ModelUpdateTask task) {
626 task.init(mApp, this, sBgDataModel, mBgAllAppsList, mUiExecutor);
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700627 runOnWorkerThread(task);
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700628 }
629
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700630 /**
631 * A task to be executed on the current callbacks on the UI thread.
632 * If there is no current callbacks, the task is ignored.
633 */
634 public interface CallbackTask {
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700635
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700636 void execute(Callbacks callbacks);
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700637 }
638
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700639 /**
640 * A runnable which changes/updates the data model of the launcher based on certain events.
641 */
Sunny Goyale86f11f2017-06-06 14:33:18 -0700642 public interface ModelUpdateTask extends Runnable {
Joe Onorato36115782010-06-17 13:28:48 -0400643
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700644 /**
Sunny Goyale86f11f2017-06-06 14:33:18 -0700645 * Called before the task is posted to initialize the internal state.
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700646 */
Sunny Goyale86f11f2017-06-06 14:33:18 -0700647 void init(LauncherAppState app, LauncherModel model,
648 BgDataModel dataModel, AllAppsList allAppsList, Executor uiExecutor);
Sunny Goyale0f58d72014-11-10 18:05:31 -0800649
Sunny Goyal2e1efb42016-03-03 16:58:55 -0800650 }
651
Sunny Goyal1b072632017-01-18 11:30:23 -0800652 public void updateAndBindShortcutInfo(final ShortcutInfo si, final ShortcutInfoCompat info) {
Sunny Goyal83fd25e2018-07-09 16:47:01 -0700653 updateAndBindShortcutInfo(() -> {
654 si.updateFromDeepShortcutInfo(info, mApp.getContext());
655 LauncherIcons li = LauncherIcons.obtain(mApp.getContext());
656 li.createShortcutIcon(info).applyTo(si);
657 li.recycle();
658 return si;
Sunny Goyal1b072632017-01-18 11:30:23 -0800659 });
660 }
661
Sunny Goyal10923b32016-07-20 15:42:44 -0700662 /**
Sunny Goyal1cc1c9a2017-01-06 16:32:57 -0800663 * Utility method to update a shortcut on the background thread.
Sunny Goyal10923b32016-07-20 15:42:44 -0700664 */
Sunny Goyal1cc1c9a2017-01-06 16:32:57 -0800665 public void updateAndBindShortcutInfo(final Provider<ShortcutInfo> shortcutProvider) {
Sunny Goyale86f11f2017-06-06 14:33:18 -0700666 enqueueModelUpdateTask(new BaseModelUpdateTask() {
Sunny Goyal10923b32016-07-20 15:42:44 -0700667 @Override
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700668 public void execute(LauncherAppState app, BgDataModel dataModel, AllAppsList apps) {
Sunny Goyal1cc1c9a2017-01-06 16:32:57 -0800669 ShortcutInfo info = shortcutProvider.get();
Sunny Goyalf266deb2018-06-21 09:59:08 -0700670 getModelWriter().updateItemInDatabase(info);
Sunny Goyalf0ba8b72016-09-09 15:47:55 -0700671 ArrayList<ShortcutInfo> update = new ArrayList<>();
Sunny Goyal10923b32016-07-20 15:42:44 -0700672 update.add(info);
Sunny Goyal1cc1c9a2017-01-06 16:32:57 -0800673 bindUpdatedShortcuts(update, info.user);
Sunny Goyal10923b32016-07-20 15:42:44 -0700674 }
675 });
676 }
677
Sunny Goyalc6e97692017-06-02 13:46:55 -0700678 public void refreshAndBindWidgetsAndShortcuts(@Nullable final PackageUserKey packageUser) {
Sunny Goyale86f11f2017-06-06 14:33:18 -0700679 enqueueModelUpdateTask(new BaseModelUpdateTask() {
Sunny Goyal2e1efb42016-03-03 16:58:55 -0800680 @Override
Sunny Goyalc6e97692017-06-02 13:46:55 -0700681 public void execute(LauncherAppState app, BgDataModel dataModel, AllAppsList apps) {
682 dataModel.widgetsModel.update(app, packageUser);
683 bindUpdatedWidgets(dataModel);
Sunny Goyal31860582015-09-18 08:38:57 -0700684 }
Sunny Goyal2e1efb42016-03-03 16:58:55 -0800685 });
Michael Jurkac402cd92013-05-20 15:49:32 +0200686 }
687
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -0800688 public void dumpState(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
689 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
690 writer.println(prefix + "All apps list: size=" + mBgAllAppsList.data.size());
691 for (AppInfo info : mBgAllAppsList.data) {
692 writer.println(prefix + " title=\"" + info.title + "\" iconBitmap=" + info.iconBitmap
693 + " componentName=" + info.componentName.getPackageName());
694 }
Joe Onorato36115782010-06-17 13:28:48 -0400695 }
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -0800696 sBgDataModel.dump(prefix, fd, writer, args);
Joe Onoratobe386092009-11-17 17:32:16 -0800697 }
Sunny Goyale0f58d72014-11-10 18:05:31 -0800698
699 public Callbacks getCallback() {
700 return mCallbacks != null ? mCallbacks.get() : null;
701 }
Sunny Goyal18bf8e22015-04-08 18:13:46 -0700702
703 /**
Sunny Goyal756adbc2015-04-16 15:20:51 -0700704 * @return the looper for the worker thread which can be used to start background tasks.
705 */
706 public static Looper getWorkerLooper() {
707 return sWorkerThread.getLooper();
708 }
Tony2917a8b2017-07-31 23:29:42 -0700709
710 public static void setWorkerPriority(final int priority) {
711 Process.setThreadPriority(sWorkerThread.getThreadId(), priority);
712 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800713}