1 /*
2  * Copyright (C) 2016 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 package com.android.server.pm;
17 
18 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.anyOrNull;
19 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.anyStringOrNull;
20 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllDisabled;
21 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllDynamic;
22 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllDynamicOrPinned;
23 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllEnabled;
24 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllHaveIntents;
25 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllHaveTitle;
26 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllImmutable;
27 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllKeyFieldsOnly;
28 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllManifest;
29 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllNotHaveIntents;
30 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllNotHaveTitle;
31 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllNotKeyFieldsOnly;
32 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllNotManifest;
33 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllPinned;
34 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertAllUnique;
35 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertBitmapSize;
36 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertBundleEmpty;
37 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertCallbackNotReceived;
38 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertCallbackReceived;
39 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertCannotUpdateImmutable;
40 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertDynamicAndPinned;
41 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertDynamicOnly;
42 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertDynamicShortcutCountExceeded;
43 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertEmpty;
44 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertExpectException;
45 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertForLauncherCallback;
46 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertShortcutIds;
47 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.assertWith;
48 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.filterByActivity;
49 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.findShortcut;
50 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.hashSet;
51 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.list;
52 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.makeBundle;
53 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.pfdToBitmap;
54 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.resetAll;
55 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.set;
56 import static com.android.server.pm.shortcutmanagertest.ShortcutManagerTestUtils.waitOnMainThread;
57 
58 import static org.mockito.Matchers.any;
59 import static org.mockito.Matchers.anyInt;
60 import static org.mockito.Matchers.eq;
61 import static org.mockito.Mockito.doReturn;
62 import static org.mockito.Mockito.mock;
63 import static org.mockito.Mockito.reset;
64 import static org.mockito.Mockito.times;
65 import static org.mockito.Mockito.verify;
66 
67 import android.Manifest.permission;
68 import android.app.ActivityManager;
69 import android.content.ActivityNotFoundException;
70 import android.content.ComponentName;
71 import android.content.Intent;
72 import android.content.pm.ApplicationInfo;
73 import android.content.pm.LauncherApps;
74 import android.content.pm.LauncherApps.ShortcutQuery;
75 import android.content.pm.ShortcutInfo;
76 import android.graphics.Bitmap;
77 import android.graphics.Bitmap.CompressFormat;
78 import android.graphics.BitmapFactory;
79 import android.graphics.drawable.AdaptiveIconDrawable;
80 import android.graphics.drawable.Drawable;
81 import android.graphics.drawable.Icon;
82 import android.net.Uri;
83 import android.os.Bundle;
84 import android.os.Handler;
85 import android.os.Looper;
86 import android.os.Process;
87 import android.os.UserHandle;
88 import android.test.suitebuilder.annotation.SmallTest;
89 import android.util.Log;
90 import android.util.SparseArray;
91 
92 import com.android.frameworks.servicestests.R;
93 import com.android.server.pm.ShortcutService.ConfigConstants;
94 import com.android.server.pm.ShortcutService.FileOutputStreamWithPath;
95 import com.android.server.pm.ShortcutUser.PackageWithUser;
96 
97 import org.mockito.ArgumentCaptor;
98 
99 import java.io.File;
100 import java.io.IOException;
101 import java.util.List;
102 import java.util.Locale;
103 import java.util.function.BiConsumer;
104 import java.util.function.BiPredicate;
105 
106 /**
107  * Tests for ShortcutService and ShortcutManager.
108  *
109  m FrameworksServicesTests &&
110  adb install \
111  -r -g ${ANDROID_PRODUCT_OUT}/data/app/FrameworksServicesTests/FrameworksServicesTests.apk &&
112  adb shell am instrument -e class com.android.server.pm.ShortcutManagerTest1 \
113  -w com.android.frameworks.servicestests/android.support.test.runner.AndroidJUnitRunner
114  */
115 @SmallTest
116 public class ShortcutManagerTest1 extends BaseShortcutManagerTest {
117 
118     /**
119      * Test for the first launch path, no settings file available.
120      */
testFirstInitialize()121     public void testFirstInitialize() {
122         assertResetTimes(START_TIME, START_TIME + INTERVAL);
123     }
124 
125     /**
126      * Test for {@link ShortcutService#getLastResetTimeLocked()} and
127      * {@link ShortcutService#getNextResetTimeLocked()}.
128      */
testUpdateAndGetNextResetTimeLocked()129     public void testUpdateAndGetNextResetTimeLocked() {
130         assertResetTimes(START_TIME, START_TIME + INTERVAL);
131 
132         // Advance clock.
133         mInjectedCurrentTimeMillis += 100;
134 
135         // Shouldn't have changed.
136         assertResetTimes(START_TIME, START_TIME + INTERVAL);
137 
138         // Advance clock, almost the reset time.
139         mInjectedCurrentTimeMillis = START_TIME + INTERVAL - 1;
140 
141         // Shouldn't have changed.
142         assertResetTimes(START_TIME, START_TIME + INTERVAL);
143 
144         // Advance clock.
145         mInjectedCurrentTimeMillis += 1;
146 
147         assertResetTimes(START_TIME + INTERVAL, START_TIME + 2 * INTERVAL);
148 
149         // Advance further; 4 hours since start.
150         mInjectedCurrentTimeMillis = START_TIME + 4 * INTERVAL + 50;
151 
152         assertResetTimes(START_TIME + 4 * INTERVAL, START_TIME + 5 * INTERVAL);
153     }
154 
155     /**
156      * Test for the restoration from saved file.
157      */
testInitializeFromSavedFile()158     public void testInitializeFromSavedFile() {
159 
160         mInjectedCurrentTimeMillis = START_TIME + 4 * INTERVAL + 50;
161         assertResetTimes(START_TIME + 4 * INTERVAL, START_TIME + 5 * INTERVAL);
162 
163         mService.saveBaseStateLocked();
164 
165         dumpBaseStateFile();
166 
167         mService.saveDirtyInfo();
168 
169         // Restore.
170         initService();
171 
172         assertResetTimes(START_TIME + 4 * INTERVAL, START_TIME + 5 * INTERVAL);
173     }
174 
175     /**
176      * Test for the restoration from restored file.
177      */
testLoadFromBrokenFile()178     public void testLoadFromBrokenFile() {
179         // TODO Add various broken cases.
180     }
181 
testLoadConfig()182     public void testLoadConfig() {
183         mService.updateConfigurationLocked(
184                 ConfigConstants.KEY_RESET_INTERVAL_SEC + "=123,"
185                         + ConfigConstants.KEY_MAX_SHORTCUTS + "=4,"
186                         + ConfigConstants.KEY_MAX_UPDATES_PER_INTERVAL + "=5,"
187                         + ConfigConstants.KEY_MAX_ICON_DIMENSION_DP + "=100,"
188                         + ConfigConstants.KEY_MAX_ICON_DIMENSION_DP_LOWRAM + "=50,"
189                         + ConfigConstants.KEY_ICON_FORMAT + "=WEBP,"
190                         + ConfigConstants.KEY_ICON_QUALITY + "=75");
191         assertEquals(123000, mService.getResetIntervalForTest());
192         assertEquals(4, mService.getMaxShortcutsForTest());
193         assertEquals(5, mService.getMaxUpdatesPerIntervalForTest());
194         assertEquals(100, mService.getMaxIconDimensionForTest());
195         assertEquals(CompressFormat.WEBP, mService.getIconPersistFormatForTest());
196         assertEquals(75, mService.getIconPersistQualityForTest());
197 
198         mInjectedIsLowRamDevice = true;
199         mService.updateConfigurationLocked(
200                 ConfigConstants.KEY_MAX_ICON_DIMENSION_DP + "=100,"
201                         + ConfigConstants.KEY_MAX_ICON_DIMENSION_DP_LOWRAM + "=50,"
202                         + ConfigConstants.KEY_ICON_FORMAT + "=JPEG");
203         assertEquals(ShortcutService.DEFAULT_RESET_INTERVAL_SEC * 1000,
204                 mService.getResetIntervalForTest());
205 
206         assertEquals(ShortcutService.DEFAULT_MAX_SHORTCUTS_PER_APP,
207                 mService.getMaxShortcutsForTest());
208 
209         assertEquals(ShortcutService.DEFAULT_MAX_UPDATES_PER_INTERVAL,
210                 mService.getMaxUpdatesPerIntervalForTest());
211 
212         assertEquals(50, mService.getMaxIconDimensionForTest());
213 
214         assertEquals(CompressFormat.JPEG, mService.getIconPersistFormatForTest());
215 
216         assertEquals(ShortcutService.DEFAULT_ICON_PERSIST_QUALITY,
217                 mService.getIconPersistQualityForTest());
218     }
219 
220     // === Test for app side APIs ===
221 
222     /** Test for {@link android.content.pm.ShortcutManager#getMaxShortcutCountForActivity()} */
testGetMaxDynamicShortcutCount()223     public void testGetMaxDynamicShortcutCount() {
224         assertEquals(MAX_SHORTCUTS, mManager.getMaxShortcutCountForActivity());
225     }
226 
227     /** Test for {@link android.content.pm.ShortcutManager#getRemainingCallCount()} */
testGetRemainingCallCount()228     public void testGetRemainingCallCount() {
229         assertEquals(MAX_UPDATES_PER_INTERVAL, mManager.getRemainingCallCount());
230     }
231 
testGetIconMaxDimensions()232     public void testGetIconMaxDimensions() {
233         assertEquals(MAX_ICON_DIMENSION, mManager.getIconMaxWidth());
234         assertEquals(MAX_ICON_DIMENSION, mManager.getIconMaxHeight());
235     }
236 
237     /** Test for {@link android.content.pm.ShortcutManager#getRateLimitResetTime()} */
testGetRateLimitResetTime()238     public void testGetRateLimitResetTime() {
239         assertEquals(START_TIME + INTERVAL, mManager.getRateLimitResetTime());
240 
241         mInjectedCurrentTimeMillis = START_TIME + 4 * INTERVAL + 50;
242 
243         assertEquals(START_TIME + 5 * INTERVAL, mManager.getRateLimitResetTime());
244     }
245 
testSetDynamicShortcuts()246     public void testSetDynamicShortcuts() {
247         setCaller(CALLING_PACKAGE_1, USER_0);
248 
249         final Icon icon1 = Icon.createWithResource(getTestContext(), R.drawable.icon1);
250         final Icon icon2 = Icon.createWithBitmap(BitmapFactory.decodeResource(
251                 getTestContext().getResources(), R.drawable.icon2));
252         final Icon icon3 = Icon.createWithAdaptiveBitmap(BitmapFactory.decodeResource(
253             getTestContext().getResources(), R.drawable.icon2));
254 
255         final ShortcutInfo si1 = makeShortcut(
256                 "shortcut1",
257                 "Title 1",
258                 makeComponent(ShortcutActivity.class),
259                 icon1,
260                 makeIntent(Intent.ACTION_ASSIST, ShortcutActivity2.class,
261                         "key1", "val1", "nest", makeBundle("key", 123)),
262                 /* weight */ 10);
263 
264         final ShortcutInfo si2 = makeShortcut(
265                 "shortcut2",
266                 "Title 2",
267                 /* activity */ null,
268                 icon2,
269                 makeIntent(Intent.ACTION_ASSIST, ShortcutActivity3.class),
270                 /* weight */ 12);
271         final ShortcutInfo si3 = makeShortcut(
272                 "shortcut3",
273                 "Title 3",
274                 /* activity */ null,
275                 icon3,
276                 makeIntent(Intent.ACTION_ASSIST, ShortcutActivity3.class),
277                 /* weight */ 13);
278 
279         assertTrue(mManager.setDynamicShortcuts(list(si1, si2, si3)));
280         assertShortcutIds(assertAllNotKeyFieldsOnly(
281                 mManager.getDynamicShortcuts()),
282                 "shortcut1", "shortcut2", "shortcut3");
283         assertEquals(2, mManager.getRemainingCallCount());
284 
285         // TODO: Check fields
286 
287         assertTrue(mManager.setDynamicShortcuts(list(si1)));
288         assertShortcutIds(assertAllNotKeyFieldsOnly(
289                 mManager.getDynamicShortcuts()),
290                 "shortcut1");
291         assertEquals(1, mManager.getRemainingCallCount());
292 
293         assertTrue(mManager.setDynamicShortcuts(list()));
294         assertEquals(0, mManager.getDynamicShortcuts().size());
295         assertEquals(0, mManager.getRemainingCallCount());
296 
297         dumpsysOnLogcat();
298 
299         mInjectedCurrentTimeMillis++; // Need to advance the clock for reset to work.
300         mService.resetThrottlingInner(UserHandle.USER_SYSTEM);
301 
302         dumpsysOnLogcat();
303 
304         assertTrue(mManager.setDynamicShortcuts(list(si2, si3)));
305         assertEquals(2, mManager.getDynamicShortcuts().size());
306 
307         // TODO Check max number
308 
309         mRunningUsers.put(USER_10, true);
310 
311         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
312             assertTrue(mManager.setDynamicShortcuts(list(makeShortcut("s1"))));
313         });
314     }
315 
testAddDynamicShortcuts()316     public void testAddDynamicShortcuts() {
317         setCaller(CALLING_PACKAGE_1, USER_0);
318 
319         final ShortcutInfo si1 = makeShortcut("shortcut1");
320         final ShortcutInfo si2 = makeShortcut("shortcut2");
321         final ShortcutInfo si3 = makeShortcut("shortcut3");
322 
323         assertEquals(3, mManager.getRemainingCallCount());
324 
325         assertTrue(mManager.setDynamicShortcuts(list(si1)));
326         assertEquals(2, mManager.getRemainingCallCount());
327         assertShortcutIds(assertAllNotKeyFieldsOnly(
328                 mManager.getDynamicShortcuts()),
329                 "shortcut1");
330 
331         assertTrue(mManager.addDynamicShortcuts(list(si2, si3)));
332         assertEquals(1, mManager.getRemainingCallCount());
333         assertShortcutIds(assertAllNotKeyFieldsOnly(
334                 mManager.getDynamicShortcuts()),
335                 "shortcut1", "shortcut2", "shortcut3");
336 
337         // This should not crash.  It'll still consume the quota.
338         assertTrue(mManager.addDynamicShortcuts(list()));
339         assertEquals(0, mManager.getRemainingCallCount());
340         assertShortcutIds(assertAllNotKeyFieldsOnly(
341                 mManager.getDynamicShortcuts()),
342                 "shortcut1", "shortcut2", "shortcut3");
343 
344         mInjectedCurrentTimeMillis += INTERVAL; // reset
345 
346         // Add with the same ID
347         assertTrue(mManager.addDynamicShortcuts(list(makeShortcut("shortcut1"))));
348         assertEquals(2, mManager.getRemainingCallCount());
349         assertShortcutIds(assertAllNotKeyFieldsOnly(
350                 mManager.getDynamicShortcuts()),
351                 "shortcut1", "shortcut2", "shortcut3");
352 
353         // TODO Check max number
354 
355         // TODO Check fields.
356 
357         mRunningUsers.put(USER_10, true);
358 
359         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
360             assertTrue(mManager.addDynamicShortcuts(list(makeShortcut("s1"))));
361         });
362     }
363 
testPublishWithNoActivity()364     public void testPublishWithNoActivity() {
365         // If activity is not explicitly set, use the default one.
366 
367         mRunningUsers.put(USER_10, true);
368 
369         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
370             // s1 and s3 has no activities.
371             final ShortcutInfo si1 = new ShortcutInfo.Builder(mClientContext, "si1")
372                     .setShortLabel("label1")
373                     .setIntent(new Intent("action1"))
374                     .build();
375             final ShortcutInfo si2 = new ShortcutInfo.Builder(mClientContext, "si2")
376                     .setShortLabel("label2")
377                     .setActivity(new ComponentName(getCallingPackage(), "abc"))
378                     .setIntent(new Intent("action2"))
379                     .build();
380             final ShortcutInfo si3 = new ShortcutInfo.Builder(mClientContext, "si3")
381                     .setShortLabel("label3")
382                     .setIntent(new Intent("action3"))
383                     .build();
384 
385             // Set test 1
386             assertTrue(mManager.setDynamicShortcuts(list(si1)));
387 
388             assertWith(getCallerShortcuts())
389                     .haveIds("si1")
390                     .forShortcutWithId("si1", si -> {
391                         assertEquals(new ComponentName(getCallingPackage(),
392                                 MAIN_ACTIVITY_CLASS), si.getActivity());
393                     });
394 
395             // Set test 2
396             assertTrue(mManager.setDynamicShortcuts(list(si2, si1)));
397 
398             assertWith(getCallerShortcuts())
399                     .haveIds("si1", "si2")
400                     .forShortcutWithId("si1", si -> {
401                         assertEquals(new ComponentName(getCallingPackage(),
402                                 MAIN_ACTIVITY_CLASS), si.getActivity());
403                     })
404                     .forShortcutWithId("si2", si -> {
405                         assertEquals(new ComponentName(getCallingPackage(),
406                                 "abc"), si.getActivity());
407                     });
408 
409 
410             // Set test 3
411             assertTrue(mManager.setDynamicShortcuts(list(si3, si1)));
412 
413             assertWith(getCallerShortcuts())
414                     .haveIds("si1", "si3")
415                     .forShortcutWithId("si1", si -> {
416                         assertEquals(new ComponentName(getCallingPackage(),
417                                 MAIN_ACTIVITY_CLASS), si.getActivity());
418                     })
419                     .forShortcutWithId("si3", si -> {
420                         assertEquals(new ComponentName(getCallingPackage(),
421                                 MAIN_ACTIVITY_CLASS), si.getActivity());
422                     });
423 
424             mInjectedCurrentTimeMillis += INTERVAL; // reset throttling
425 
426             // Add test 1
427             mManager.removeAllDynamicShortcuts();
428             assertTrue(mManager.addDynamicShortcuts(list(si1)));
429 
430             assertWith(getCallerShortcuts())
431                     .haveIds("si1")
432                     .forShortcutWithId("si1", si -> {
433                         assertEquals(new ComponentName(getCallingPackage(),
434                                 MAIN_ACTIVITY_CLASS), si.getActivity());
435                     });
436 
437             // Add test 2
438             mManager.removeAllDynamicShortcuts();
439             assertTrue(mManager.addDynamicShortcuts(list(si2, si1)));
440 
441             assertWith(getCallerShortcuts())
442                     .haveIds("si1", "si2")
443                     .forShortcutWithId("si1", si -> {
444                         assertEquals(new ComponentName(getCallingPackage(),
445                                 MAIN_ACTIVITY_CLASS), si.getActivity());
446                     })
447                     .forShortcutWithId("si2", si -> {
448                         assertEquals(new ComponentName(getCallingPackage(),
449                                 "abc"), si.getActivity());
450                     });
451 
452 
453             // Add test 3
454             mManager.removeAllDynamicShortcuts();
455             assertTrue(mManager.addDynamicShortcuts(list(si3, si1)));
456 
457             assertWith(getCallerShortcuts())
458                     .haveIds("si1", "si3")
459                     .forShortcutWithId("si1", si -> {
460                         assertEquals(new ComponentName(getCallingPackage(),
461                                 MAIN_ACTIVITY_CLASS), si.getActivity());
462                     })
463                     .forShortcutWithId("si3", si -> {
464                         assertEquals(new ComponentName(getCallingPackage(),
465                                 MAIN_ACTIVITY_CLASS), si.getActivity());
466                     });
467         });
468     }
469 
testPublishWithNoActivity_noMainActivityInPackage()470     public void testPublishWithNoActivity_noMainActivityInPackage() {
471         mRunningUsers.put(USER_10, true);
472 
473         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
474             final ShortcutInfo si1 = new ShortcutInfo.Builder(mClientContext, "si1")
475                     .setShortLabel("label1")
476                     .setIntent(new Intent("action1"))
477                     .build();
478 
479             // Returning null means there's no main activity in this package.
480             mMainActivityFetcher = (packageName, userId) -> null;
481 
482             assertExpectException(
483                     RuntimeException.class, "Launcher activity not found for", () -> {
484                         assertTrue(mManager.setDynamicShortcuts(list(si1)));
485                     });
486         });
487     }
488 
testDeleteDynamicShortcuts()489     public void testDeleteDynamicShortcuts() {
490         final ShortcutInfo si1 = makeShortcut("shortcut1");
491         final ShortcutInfo si2 = makeShortcut("shortcut2");
492         final ShortcutInfo si3 = makeShortcut("shortcut3");
493         final ShortcutInfo si4 = makeShortcut("shortcut4");
494 
495         assertTrue(mManager.setDynamicShortcuts(list(si1, si2, si3, si4)));
496         assertShortcutIds(assertAllNotKeyFieldsOnly(
497                 mManager.getDynamicShortcuts()),
498                 "shortcut1", "shortcut2", "shortcut3", "shortcut4");
499 
500         assertEquals(2, mManager.getRemainingCallCount());
501 
502         mManager.removeDynamicShortcuts(list("shortcut1"));
503         assertShortcutIds(assertAllNotKeyFieldsOnly(
504                 mManager.getDynamicShortcuts()),
505                 "shortcut2", "shortcut3", "shortcut4");
506 
507         mManager.removeDynamicShortcuts(list("shortcut1"));
508         assertShortcutIds(assertAllNotKeyFieldsOnly(
509                 mManager.getDynamicShortcuts()),
510                 "shortcut2", "shortcut3", "shortcut4");
511 
512         mManager.removeDynamicShortcuts(list("shortcutXXX"));
513         assertShortcutIds(assertAllNotKeyFieldsOnly(
514                 mManager.getDynamicShortcuts()),
515                 "shortcut2", "shortcut3", "shortcut4");
516 
517         mManager.removeDynamicShortcuts(list("shortcut2", "shortcut4"));
518         assertShortcutIds(assertAllNotKeyFieldsOnly(
519                 mManager.getDynamicShortcuts()),
520                 "shortcut3");
521 
522         mManager.removeDynamicShortcuts(list("shortcut3"));
523         assertShortcutIds(assertAllNotKeyFieldsOnly(
524                 mManager.getDynamicShortcuts()));
525 
526         // Still 2 calls left.
527         assertEquals(2, mManager.getRemainingCallCount());
528     }
529 
testDeleteAllDynamicShortcuts()530     public void testDeleteAllDynamicShortcuts() {
531         final ShortcutInfo si1 = makeShortcut("shortcut1");
532         final ShortcutInfo si2 = makeShortcut("shortcut2");
533         final ShortcutInfo si3 = makeShortcut("shortcut3");
534 
535         assertTrue(mManager.setDynamicShortcuts(list(si1, si2, si3)));
536         assertShortcutIds(assertAllNotKeyFieldsOnly(
537                 mManager.getDynamicShortcuts()),
538                 "shortcut1", "shortcut2", "shortcut3");
539 
540         assertEquals(2, mManager.getRemainingCallCount());
541 
542         mManager.removeAllDynamicShortcuts();
543         assertEquals(0, mManager.getDynamicShortcuts().size());
544         assertEquals(2, mManager.getRemainingCallCount());
545 
546         // Note delete shouldn't affect throttling, so...
547         assertEquals(0, mManager.getDynamicShortcuts().size());
548         assertEquals(0, mManager.getDynamicShortcuts().size());
549         assertEquals(0, mManager.getDynamicShortcuts().size());
550 
551         // This should still work.
552         assertTrue(mManager.setDynamicShortcuts(list(si1, si2, si3)));
553         assertEquals(3, mManager.getDynamicShortcuts().size());
554 
555         // Still 1 call left
556         assertEquals(1, mManager.getRemainingCallCount());
557     }
558 
testIcons()559     public void testIcons() throws IOException {
560         final Icon res32x32 = Icon.createWithResource(getTestContext(), R.drawable.black_32x32);
561         final Icon res64x64 = Icon.createWithResource(getTestContext(), R.drawable.black_64x64);
562         final Icon res512x512 = Icon.createWithResource(getTestContext(), R.drawable.black_512x512);
563 
564         final Icon bmp32x32 = Icon.createWithBitmap(BitmapFactory.decodeResource(
565                 getTestContext().getResources(), R.drawable.black_32x32));
566         final Icon bmp64x64_maskable = Icon.createWithAdaptiveBitmap(BitmapFactory.decodeResource(
567                 getTestContext().getResources(), R.drawable.black_64x64));
568         final Icon bmp512x512 = Icon.createWithBitmap(BitmapFactory.decodeResource(
569                 getTestContext().getResources(), R.drawable.black_512x512));
570 
571         // Set from package 1
572         setCaller(CALLING_PACKAGE_1);
573         assertTrue(mManager.setDynamicShortcuts(list(
574                 makeShortcutWithIcon("res32x32", res32x32),
575                 makeShortcutWithIcon("res64x64", res64x64),
576                 makeShortcutWithIcon("bmp32x32", bmp32x32),
577                 makeShortcutWithIcon("bmp64x64", bmp64x64_maskable),
578                 makeShortcutWithIcon("bmp512x512", bmp512x512),
579                 makeShortcut("none")
580         )));
581 
582         // getDynamicShortcuts() shouldn't return icons, thus assertAllNotHaveIcon().
583         assertShortcutIds(assertAllNotHaveIcon(mManager.getDynamicShortcuts()),
584                 "res32x32",
585                 "res64x64",
586                 "bmp32x32",
587                 "bmp64x64",
588                 "bmp512x512",
589                 "none");
590 
591         // Call from another caller with the same ID, just to make sure storage is per-package.
592         setCaller(CALLING_PACKAGE_2);
593         assertTrue(mManager.setDynamicShortcuts(list(
594                 makeShortcutWithIcon("res32x32", res512x512),
595                 makeShortcutWithIcon("res64x64", res512x512),
596                 makeShortcutWithIcon("none", res512x512)
597         )));
598         assertShortcutIds(assertAllNotHaveIcon(mManager.getDynamicShortcuts()),
599                 "res32x32",
600                 "res64x64",
601                 "none");
602 
603         // Different profile.  Note the names and the contents don't match.
604         setCaller(CALLING_PACKAGE_1, USER_P0);
605         assertTrue(mManager.setDynamicShortcuts(list(
606                 makeShortcutWithIcon("res32x32", res512x512),
607                 makeShortcutWithIcon("bmp32x32", bmp512x512)
608         )));
609         assertShortcutIds(assertAllNotHaveIcon(mManager.getDynamicShortcuts()),
610                 "res32x32",
611                 "bmp32x32");
612 
613         // Re-initialize and load from the files.
614         mService.saveDirtyInfo();
615         initService();
616 
617         // Load from launcher.
618         Bitmap bmp;
619 
620         setCaller(LAUNCHER_1);
621         // Check hasIconResource()/hasIconFile().
622         assertShortcutIds(assertAllHaveIconResId(
623                 list(getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "res32x32", USER_0))),
624                 "res32x32");
625 
626         assertShortcutIds(assertAllHaveIconResId(
627                 list(getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "res64x64", USER_0))),
628                 "res64x64");
629 
630         assertShortcutIds(assertAllHaveIconFile(
631                 list(getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp32x32", USER_0))),
632                 "bmp32x32");
633 
634         assertShortcutIds(assertAllHaveIconFile(
635                 list(getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp64x64", USER_0))),
636                 "bmp64x64");
637 
638         assertShortcutIds(assertAllHaveIconFile(
639                 list(getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp512x512", USER_0))),
640                 "bmp512x512");
641 
642         assertShortcutIds(assertAllHaveIconResId(
643                 list(getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "res32x32", USER_P0))),
644                 "res32x32");
645         assertShortcutIds(assertAllHaveIconFile(
646                 list(getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp32x32", USER_P0))),
647                 "bmp32x32");
648 
649         // Check
650         assertEquals(
651                 R.drawable.black_32x32,
652                 mLauncherApps.getShortcutIconResId(
653                         getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "res32x32", USER_0)));
654 
655         assertEquals(
656                 R.drawable.black_64x64,
657                 mLauncherApps.getShortcutIconResId(
658                         getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "res64x64", USER_0)));
659 
660         assertEquals(
661                 0, // because it's not a resource
662                 mLauncherApps.getShortcutIconResId(
663                         getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp32x32", USER_0)));
664         assertEquals(
665                 0, // because it's not a resource
666                 mLauncherApps.getShortcutIconResId(
667                         getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp64x64", USER_0)));
668         assertEquals(
669                 0, // because it's not a resource
670                 mLauncherApps.getShortcutIconResId(
671                         getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp512x512", USER_0)));
672 
673         bmp = pfdToBitmap(mLauncherApps.getShortcutIconFd(
674                 getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp32x32", USER_0)));
675         assertBitmapSize(32, 32, bmp);
676 
677         bmp = pfdToBitmap(mLauncherApps.getShortcutIconFd(
678                 getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp64x64", USER_0)));
679         assertBitmapSize(64, 64, bmp);
680 
681         bmp = pfdToBitmap(mLauncherApps.getShortcutIconFd(
682                 getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp512x512", USER_0)));
683         assertBitmapSize(128, 128, bmp);
684 
685         assertEquals(
686                 R.drawable.black_512x512,
687                 mLauncherApps.getShortcutIconResId(
688                         getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "res32x32", USER_P0)));
689         // Should be 512x512, so shrunk.
690         bmp = pfdToBitmap(mLauncherApps.getShortcutIconFd(
691                 getShortcutInfoAsLauncher(CALLING_PACKAGE_1, "bmp32x32", USER_P0)));
692         assertBitmapSize(128, 128, bmp);
693 
694         // Also check the overload APIs too.
695         assertEquals(
696                 R.drawable.black_32x32,
697                 mLauncherApps.getShortcutIconResId(CALLING_PACKAGE_1, "res32x32", HANDLE_USER_0));
698         assertEquals(
699                 R.drawable.black_64x64,
700                 mLauncherApps.getShortcutIconResId(CALLING_PACKAGE_1, "res64x64", HANDLE_USER_0));
701         assertEquals(
702                 R.drawable.black_512x512,
703                 mLauncherApps.getShortcutIconResId(CALLING_PACKAGE_1, "res32x32", HANDLE_USER_P0));
704         bmp = pfdToBitmap(
705                 mLauncherApps.getShortcutIconFd(CALLING_PACKAGE_1, "bmp32x32", HANDLE_USER_P0));
706         assertBitmapSize(128, 128, bmp);
707 
708         Drawable dr = mLauncherApps.getShortcutIconDrawable(
709             makeShortcutWithIcon("bmp64x64", bmp64x64_maskable), 0);
710         assertTrue(dr instanceof AdaptiveIconDrawable);
711         float viewportPercentage = 1 / (1 + 2 * AdaptiveIconDrawable.getExtraInsetFraction());
712         assertEquals((int) (bmp64x64_maskable.getBitmap().getWidth() * viewportPercentage),
713             dr.getIntrinsicWidth());
714         assertEquals((int) (bmp64x64_maskable.getBitmap().getHeight() * viewportPercentage),
715             dr.getIntrinsicHeight());
716     }
717 
testCleanupDanglingBitmaps()718     public void testCleanupDanglingBitmaps() throws Exception {
719         assertBitmapDirectories(USER_0, EMPTY_STRINGS);
720         assertBitmapDirectories(USER_10, EMPTY_STRINGS);
721 
722         // Make some shortcuts with bitmap icons.
723         final Icon bmp32x32 = Icon.createWithBitmap(BitmapFactory.decodeResource(
724                 getTestContext().getResources(), R.drawable.black_32x32));
725 
726         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
727             mManager.setDynamicShortcuts(list(
728                     makeShortcutWithIcon("s1", bmp32x32),
729                     makeShortcutWithIcon("s2", bmp32x32),
730                     makeShortcutWithIcon("s3", bmp32x32)
731             ));
732         });
733 
734         // Increment the time (which actually we don't have to), which is used for filenames.
735         mInjectedCurrentTimeMillis++;
736 
737         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
738             mManager.setDynamicShortcuts(list(
739                     makeShortcutWithIcon("s4", bmp32x32),
740                     makeShortcutWithIcon("s5", bmp32x32),
741                     makeShortcutWithIcon("s6", bmp32x32)
742             ));
743         });
744 
745         // Increment the time, which is used for filenames.
746         mInjectedCurrentTimeMillis++;
747 
748         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
749             mManager.setDynamicShortcuts(list(
750             ));
751         });
752 
753         // For USER-10, let's try without updating the times.
754         mRunningUsers.put(USER_10, true);
755 
756         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
757             mManager.setDynamicShortcuts(list(
758                     makeShortcutWithIcon("10s1", bmp32x32),
759                     makeShortcutWithIcon("10s2", bmp32x32),
760                     makeShortcutWithIcon("10s3", bmp32x32)
761             ));
762         });
763         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
764             mManager.setDynamicShortcuts(list(
765                     makeShortcutWithIcon("10s4", bmp32x32),
766                     makeShortcutWithIcon("10s5", bmp32x32),
767                     makeShortcutWithIcon("10s6", bmp32x32)
768             ));
769         });
770         runWithCaller(CALLING_PACKAGE_3, USER_10, () -> {
771             mManager.setDynamicShortcuts(list(
772             ));
773         });
774 
775         dumpsysOnLogcat();
776 
777         // Check files and directories.
778         // Package 3 has no bitmaps, so we don't create a directory.
779         assertBitmapDirectories(USER_0, CALLING_PACKAGE_1, CALLING_PACKAGE_2);
780         assertBitmapDirectories(USER_10, CALLING_PACKAGE_1, CALLING_PACKAGE_2);
781 
782         assertBitmapFiles(USER_0, CALLING_PACKAGE_1,
783                 getBitmapFilename(USER_0, CALLING_PACKAGE_1, "s1"),
784                 getBitmapFilename(USER_0, CALLING_PACKAGE_1, "s2"),
785                 getBitmapFilename(USER_0, CALLING_PACKAGE_1, "s3")
786         );
787         assertBitmapFiles(USER_0, CALLING_PACKAGE_2,
788                 getBitmapFilename(USER_0, CALLING_PACKAGE_2, "s4"),
789                 getBitmapFilename(USER_0, CALLING_PACKAGE_2, "s5"),
790                 getBitmapFilename(USER_0, CALLING_PACKAGE_2, "s6")
791         );
792         assertBitmapFiles(USER_0, CALLING_PACKAGE_3,
793                 EMPTY_STRINGS
794         );
795         assertBitmapFiles(USER_10, CALLING_PACKAGE_1,
796                 getBitmapFilename(USER_10, CALLING_PACKAGE_1, "10s1"),
797                 getBitmapFilename(USER_10, CALLING_PACKAGE_1, "10s2"),
798                 getBitmapFilename(USER_10, CALLING_PACKAGE_1, "10s3")
799         );
800         assertBitmapFiles(USER_10, CALLING_PACKAGE_2,
801                 getBitmapFilename(USER_10, CALLING_PACKAGE_2, "10s4"),
802                 getBitmapFilename(USER_10, CALLING_PACKAGE_2, "10s5"),
803                 getBitmapFilename(USER_10, CALLING_PACKAGE_2, "10s6")
804         );
805         assertBitmapFiles(USER_10, CALLING_PACKAGE_3,
806                 EMPTY_STRINGS
807         );
808 
809         // Then create random directories and files.
810         makeFile(mService.getUserBitmapFilePath(USER_0), "a.b.c").mkdir();
811         makeFile(mService.getUserBitmapFilePath(USER_0), "d.e.f").mkdir();
812         makeFile(mService.getUserBitmapFilePath(USER_0), "d.e.f", "123").createNewFile();
813         makeFile(mService.getUserBitmapFilePath(USER_0), "d.e.f", "456").createNewFile();
814 
815         makeFile(mService.getUserBitmapFilePath(USER_0), CALLING_PACKAGE_3).mkdir();
816 
817         makeFile(mService.getUserBitmapFilePath(USER_0), CALLING_PACKAGE_1, "1").createNewFile();
818         makeFile(mService.getUserBitmapFilePath(USER_0), CALLING_PACKAGE_1, "2").createNewFile();
819         makeFile(mService.getUserBitmapFilePath(USER_0), CALLING_PACKAGE_1, "3").createNewFile();
820         makeFile(mService.getUserBitmapFilePath(USER_0), CALLING_PACKAGE_1, "4").createNewFile();
821 
822         makeFile(mService.getUserBitmapFilePath(USER_10), "10a.b.c").mkdir();
823         makeFile(mService.getUserBitmapFilePath(USER_10), "10d.e.f").mkdir();
824         makeFile(mService.getUserBitmapFilePath(USER_10), "10d.e.f", "123").createNewFile();
825         makeFile(mService.getUserBitmapFilePath(USER_10), "10d.e.f", "456").createNewFile();
826 
827         makeFile(mService.getUserBitmapFilePath(USER_10), CALLING_PACKAGE_2, "1").createNewFile();
828         makeFile(mService.getUserBitmapFilePath(USER_10), CALLING_PACKAGE_2, "2").createNewFile();
829         makeFile(mService.getUserBitmapFilePath(USER_10), CALLING_PACKAGE_2, "3").createNewFile();
830         makeFile(mService.getUserBitmapFilePath(USER_10), CALLING_PACKAGE_2, "4").createNewFile();
831 
832         assertBitmapDirectories(USER_0, CALLING_PACKAGE_1, CALLING_PACKAGE_2, CALLING_PACKAGE_3,
833                 "a.b.c", "d.e.f");
834 
835         // Save and load.  When a user is loaded, we do the cleanup.
836         mService.saveDirtyInfo();
837         initService();
838 
839         mService.handleUnlockUser(USER_0);
840         mService.handleUnlockUser(USER_10);
841         mService.handleUnlockUser(20); // Make sure the logic will still work for nonexistent user.
842 
843         // The below check is the same as above, except this time USER_0 use the CALLING_PACKAGE_3
844         // directory.
845 
846         assertBitmapDirectories(USER_0, CALLING_PACKAGE_1, CALLING_PACKAGE_2, CALLING_PACKAGE_3);
847         assertBitmapDirectories(USER_10, CALLING_PACKAGE_1, CALLING_PACKAGE_2);
848 
849         assertBitmapFiles(USER_0, CALLING_PACKAGE_1,
850                 getBitmapFilename(USER_0, CALLING_PACKAGE_1, "s1"),
851                 getBitmapFilename(USER_0, CALLING_PACKAGE_1, "s2"),
852                 getBitmapFilename(USER_0, CALLING_PACKAGE_1, "s3")
853         );
854         assertBitmapFiles(USER_0, CALLING_PACKAGE_2,
855                 getBitmapFilename(USER_0, CALLING_PACKAGE_2, "s4"),
856                 getBitmapFilename(USER_0, CALLING_PACKAGE_2, "s5"),
857                 getBitmapFilename(USER_0, CALLING_PACKAGE_2, "s6")
858         );
859         assertBitmapFiles(USER_0, CALLING_PACKAGE_3,
860                 EMPTY_STRINGS
861         );
862         assertBitmapFiles(USER_10, CALLING_PACKAGE_1,
863                 getBitmapFilename(USER_10, CALLING_PACKAGE_1, "10s1"),
864                 getBitmapFilename(USER_10, CALLING_PACKAGE_1, "10s2"),
865                 getBitmapFilename(USER_10, CALLING_PACKAGE_1, "10s3")
866         );
867         assertBitmapFiles(USER_10, CALLING_PACKAGE_2,
868                 getBitmapFilename(USER_10, CALLING_PACKAGE_2, "10s4"),
869                 getBitmapFilename(USER_10, CALLING_PACKAGE_2, "10s5"),
870                 getBitmapFilename(USER_10, CALLING_PACKAGE_2, "10s6")
871         );
872         assertBitmapFiles(USER_10, CALLING_PACKAGE_3,
873                 EMPTY_STRINGS
874         );
875     }
876 
checkShrinkBitmap(int expectedWidth, int expectedHeight, int resId, int maxSize)877     protected void checkShrinkBitmap(int expectedWidth, int expectedHeight, int resId, int maxSize) {
878         assertBitmapSize(expectedWidth, expectedHeight,
879                 ShortcutService.shrinkBitmap(BitmapFactory.decodeResource(
880                         getTestContext().getResources(), resId),
881                         maxSize));
882     }
883 
testShrinkBitmap()884     public void testShrinkBitmap() {
885         checkShrinkBitmap(32, 32, R.drawable.black_512x512, 32);
886         checkShrinkBitmap(511, 511, R.drawable.black_512x512, 511);
887         checkShrinkBitmap(512, 512, R.drawable.black_512x512, 512);
888 
889         checkShrinkBitmap(1024, 4096, R.drawable.black_1024x4096, 4096);
890         checkShrinkBitmap(1024, 4096, R.drawable.black_1024x4096, 4100);
891         checkShrinkBitmap(512, 2048, R.drawable.black_1024x4096, 2048);
892 
893         checkShrinkBitmap(4096, 1024, R.drawable.black_4096x1024, 4096);
894         checkShrinkBitmap(4096, 1024, R.drawable.black_4096x1024, 4100);
895         checkShrinkBitmap(2048, 512, R.drawable.black_4096x1024, 2048);
896     }
897 
openIconFileForWriteAndGetPath(int userId, String packageName)898     protected File openIconFileForWriteAndGetPath(int userId, String packageName)
899             throws IOException {
900         // Shortcut IDs aren't used in the path, so just pass the same ID.
901         final FileOutputStreamWithPath out =
902                 mService.openIconFileForWrite(userId, makePackageShortcut(packageName, "id"));
903         out.close();
904         return out.getFile();
905     }
906 
testOpenIconFileForWrite()907     public void testOpenIconFileForWrite() throws IOException {
908         mInjectedCurrentTimeMillis = 1000;
909 
910         final File p10_1_1 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_1);
911         final File p10_1_2 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_1);
912 
913         final File p10_2_1 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_2);
914         final File p10_2_2 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_2);
915 
916         final File p11_1_1 = openIconFileForWriteAndGetPath(11, CALLING_PACKAGE_1);
917         final File p11_1_2 = openIconFileForWriteAndGetPath(11, CALLING_PACKAGE_1);
918 
919         mInjectedCurrentTimeMillis++;
920 
921         final File p10_1_3 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_1);
922         final File p10_1_4 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_1);
923         final File p10_1_5 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_1);
924 
925         final File p10_2_3 = openIconFileForWriteAndGetPath(10, CALLING_PACKAGE_2);
926         final File p11_1_3 = openIconFileForWriteAndGetPath(11, CALLING_PACKAGE_1);
927 
928         // Make sure their paths are all unique
929         assertAllUnique(list(
930                 p10_1_1,
931                 p10_1_2,
932                 p10_1_3,
933                 p10_1_4,
934                 p10_1_5,
935 
936                 p10_2_1,
937                 p10_2_2,
938                 p10_2_3,
939 
940                 p11_1_1,
941                 p11_1_2,
942                 p11_1_3
943         ));
944 
945         // Check each set has the same parent.
946         assertEquals(p10_1_1.getParent(), p10_1_2.getParent());
947         assertEquals(p10_1_1.getParent(), p10_1_3.getParent());
948         assertEquals(p10_1_1.getParent(), p10_1_4.getParent());
949         assertEquals(p10_1_1.getParent(), p10_1_5.getParent());
950 
951         assertEquals(p10_2_1.getParent(), p10_2_2.getParent());
952         assertEquals(p10_2_1.getParent(), p10_2_3.getParent());
953 
954         assertEquals(p11_1_1.getParent(), p11_1_2.getParent());
955         assertEquals(p11_1_1.getParent(), p11_1_3.getParent());
956 
957         // Check the parents are still unique.
958         assertAllUnique(list(
959                 p10_1_1.getParent(),
960                 p10_2_1.getParent(),
961                 p11_1_1.getParent()
962         ));
963 
964         // All files created at the same time for the same package/user, expcet for the first ones,
965         // will have "_" in the path.
966         assertFalse(p10_1_1.getName().contains("_"));
967         assertTrue(p10_1_2.getName().contains("_"));
968         assertFalse(p10_1_3.getName().contains("_"));
969         assertTrue(p10_1_4.getName().contains("_"));
970         assertTrue(p10_1_5.getName().contains("_"));
971 
972         assertFalse(p10_2_1.getName().contains("_"));
973         assertTrue(p10_2_2.getName().contains("_"));
974         assertFalse(p10_2_3.getName().contains("_"));
975 
976         assertFalse(p11_1_1.getName().contains("_"));
977         assertTrue(p11_1_2.getName().contains("_"));
978         assertFalse(p11_1_3.getName().contains("_"));
979     }
980 
testUpdateShortcuts()981     public void testUpdateShortcuts() {
982         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
983             assertTrue(mManager.setDynamicShortcuts(list(
984                     makeShortcut("s1"),
985                     makeShortcut("s2"),
986                     makeShortcut("s3"),
987                     makeShortcut("s4"),
988                     makeShortcut("s5")
989             )));
990         });
991         runWithCaller(CALLING_PACKAGE_2, UserHandle.USER_SYSTEM, () -> {
992             assertTrue(mManager.setDynamicShortcuts(list(
993                     makeShortcut("s1"),
994                     makeShortcut("s2"),
995                     makeShortcut("s3"),
996                     makeShortcut("s4"),
997                     makeShortcut("s5")
998             )));
999         });
1000         runWithCaller(LAUNCHER_1, UserHandle.USER_SYSTEM, () -> {
1001             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s2", "s3"),
1002                     getCallingUser());
1003             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list("s4", "s5"),
1004                     getCallingUser());
1005         });
1006         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
1007             mManager.removeDynamicShortcuts(list("s1"));
1008             mManager.removeDynamicShortcuts(list("s2"));
1009         });
1010         runWithCaller(CALLING_PACKAGE_2, UserHandle.USER_SYSTEM, () -> {
1011             mManager.removeDynamicShortcuts(list("s1"));
1012             mManager.removeDynamicShortcuts(list("s3"));
1013             mManager.removeDynamicShortcuts(list("s5"));
1014         });
1015         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
1016             assertShortcutIds(assertAllDynamic(
1017                     mManager.getDynamicShortcuts()),
1018                     "s3", "s4", "s5");
1019             assertShortcutIds(assertAllPinned(
1020                     mManager.getPinnedShortcuts()),
1021                     "s2", "s3");
1022         });
1023         runWithCaller(CALLING_PACKAGE_2, UserHandle.USER_SYSTEM, () -> {
1024             assertShortcutIds(assertAllDynamic(
1025                     mManager.getDynamicShortcuts()),
1026                     "s2", "s4");
1027             assertShortcutIds(assertAllPinned(
1028                     mManager.getPinnedShortcuts()),
1029                     "s4", "s5");
1030         });
1031 
1032         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
1033             ShortcutInfo s2 = makeShortcutBuilder()
1034                     .setId("s2")
1035                     .setIcon(Icon.createWithResource(getTestContext(), R.drawable.black_32x32))
1036                     .build();
1037 
1038             ShortcutInfo s4 = makeShortcutBuilder()
1039                     .setId("s4")
1040                     .setTitle("new title")
1041                     .build();
1042 
1043             mManager.updateShortcuts(list(s2, s4));
1044         });
1045         runWithCaller(CALLING_PACKAGE_2, UserHandle.USER_SYSTEM, () -> {
1046             ShortcutInfo s2 = makeShortcutBuilder()
1047                     .setId("s2")
1048                     .setIntent(makeIntent(Intent.ACTION_ANSWER, ShortcutActivity.class,
1049                             "key1", "val1"))
1050                     .build();
1051 
1052             ShortcutInfo s4 = makeShortcutBuilder()
1053                     .setId("s4")
1054                     .setIntent(new Intent(Intent.ACTION_ALL_APPS))
1055                     .build();
1056 
1057             mManager.updateShortcuts(list(s2, s4));
1058         });
1059 
1060         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
1061             assertShortcutIds(assertAllDynamic(
1062                     mManager.getDynamicShortcuts()),
1063                     "s3", "s4", "s5");
1064             assertShortcutIds(assertAllPinned(
1065                     mManager.getPinnedShortcuts()),
1066                     "s2", "s3");
1067 
1068             ShortcutInfo s = getCallerShortcut("s2");
1069             assertTrue(s.hasIconResource());
1070             assertEquals(R.drawable.black_32x32, s.getIconResourceId());
1071             assertEquals("string/r" + R.drawable.black_32x32, s.getIconResName());
1072             assertEquals("Title-s2", s.getTitle());
1073 
1074             s = getCallerShortcut("s4");
1075             assertFalse(s.hasIconResource());
1076             assertEquals(0, s.getIconResourceId());
1077             assertEquals("new title", s.getTitle());
1078         });
1079         runWithCaller(CALLING_PACKAGE_2, UserHandle.USER_SYSTEM, () -> {
1080             assertShortcutIds(assertAllDynamic(
1081                     mManager.getDynamicShortcuts()),
1082                     "s2", "s4");
1083             assertShortcutIds(assertAllPinned(
1084                     mManager.getPinnedShortcuts()),
1085                     "s4", "s5");
1086 
1087             ShortcutInfo s = getCallerShortcut("s2");
1088             assertFalse(s.hasIconResource());
1089             assertEquals(0, s.getIconResourceId());
1090             assertEquals("Title-s2", s.getTitle());
1091             assertEquals(Intent.ACTION_ANSWER, s.getIntent().getAction());
1092             assertEquals(1, s.getIntent().getExtras().size());
1093 
1094             s = getCallerShortcut("s4");
1095             assertFalse(s.hasIconResource());
1096             assertEquals(0, s.getIconResourceId());
1097             assertEquals("Title-s4", s.getTitle());
1098             assertEquals(Intent.ACTION_ALL_APPS, s.getIntent().getAction());
1099             assertBundleEmpty(s.getIntent().getExtras());
1100         });
1101         // TODO Check with other fields too.
1102 
1103         // TODO Check bitmap removal too.
1104 
1105         mRunningUsers.put(USER_11, true);
1106 
1107         runWithCaller(CALLING_PACKAGE_2, USER_11, () -> {
1108             mManager.updateShortcuts(list());
1109         });
1110     }
1111 
testUpdateShortcuts_icons()1112     public void testUpdateShortcuts_icons() {
1113         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
1114             assertTrue(mManager.setDynamicShortcuts(list(
1115                     makeShortcut("s1")
1116             )));
1117 
1118             // Set resource icon
1119             assertTrue(mManager.updateShortcuts(list(
1120                     new ShortcutInfo.Builder(mClientContext, "s1")
1121                     .setIcon(Icon.createWithResource(getTestContext(), R.drawable.black_32x32))
1122                     .build()
1123             )));
1124 
1125             assertWith(getCallerShortcuts())
1126                     .forShortcutWithId("s1", si -> {
1127                         assertTrue(si.hasIconResource());
1128                         assertEquals(R.drawable.black_32x32, si.getIconResourceId());
1129                     });
1130 
1131             // Set bitmap icon
1132             assertTrue(mManager.updateShortcuts(list(
1133                     new ShortcutInfo.Builder(mClientContext, "s1")
1134                     .setIcon(Icon.createWithBitmap(BitmapFactory.decodeResource(
1135                             getTestContext().getResources(), R.drawable.black_64x64)))
1136                     .build()
1137             )));
1138 
1139             assertWith(getCallerShortcuts())
1140                     .forShortcutWithId("s1", si -> {
1141                         assertTrue(si.hasIconFile());
1142                     });
1143 
1144             mInjectedCurrentTimeMillis += INTERVAL; // reset throttling
1145 
1146             // Do it again, with the reverse order (bitmap -> icon)
1147             assertTrue(mManager.setDynamicShortcuts(list(
1148                     makeShortcut("s1")
1149             )));
1150 
1151             // Set bitmap icon
1152             assertTrue(mManager.updateShortcuts(list(
1153                     new ShortcutInfo.Builder(mClientContext, "s1")
1154                             .setIcon(Icon.createWithBitmap(BitmapFactory.decodeResource(
1155                                     getTestContext().getResources(), R.drawable.black_64x64)))
1156                             .build()
1157             )));
1158 
1159             assertWith(getCallerShortcuts())
1160                     .forShortcutWithId("s1", si -> {
1161                         assertTrue(si.hasIconFile());
1162                     });
1163 
1164             // Set resource icon
1165             assertTrue(mManager.updateShortcuts(list(
1166                     new ShortcutInfo.Builder(mClientContext, "s1")
1167                             .setIcon(Icon.createWithResource(getTestContext(), R.drawable.black_32x32))
1168                             .build()
1169             )));
1170 
1171             assertWith(getCallerShortcuts())
1172                     .forShortcutWithId("s1", si -> {
1173                         assertTrue(si.hasIconResource());
1174                         assertEquals(R.drawable.black_32x32, si.getIconResourceId());
1175                     });
1176         });
1177     }
1178 
1179     // === Test for launcher side APIs ===
1180 
testGetShortcuts()1181     public void testGetShortcuts() {
1182 
1183         // Set up shortcuts.
1184 
1185         setCaller(CALLING_PACKAGE_1);
1186         final ShortcutInfo s1_1 = makeShortcut("s1");
1187         final ShortcutInfo s1_2 = makeShortcut("s2");
1188 
1189         assertTrue(mManager.setDynamicShortcuts(list(s1_1, s1_2)));
1190 
1191         // Because setDynamicShortcuts will update the timestamps when ranks are changing,
1192         // we explicitly set timestamps here.
1193         getCallerShortcut("s1").setTimestamp(5000);
1194         getCallerShortcut("s2").setTimestamp(1000);
1195 
1196         setCaller(CALLING_PACKAGE_2);
1197         final ShortcutInfo s2_2 = makeShortcut("s2");
1198         final ShortcutInfo s2_3 = makeShortcutWithActivity("s3",
1199                 makeComponent(ShortcutActivity2.class));
1200         final ShortcutInfo s2_4 = makeShortcutWithActivity("s4",
1201                 makeComponent(ShortcutActivity.class));
1202         assertTrue(mManager.setDynamicShortcuts(list(s2_2, s2_3, s2_4)));
1203 
1204         getCallerShortcut("s2").setTimestamp(1500);
1205         getCallerShortcut("s3").setTimestamp(3000);
1206         getCallerShortcut("s4").setTimestamp(500);
1207 
1208         setCaller(CALLING_PACKAGE_3);
1209         final ShortcutInfo s3_2 = makeShortcut("s3");
1210         assertTrue(mManager.setDynamicShortcuts(list(s3_2)));
1211 
1212         getCallerShortcut("s3").setTimestamp(START_TIME + 5000);
1213 
1214         setCaller(LAUNCHER_1);
1215 
1216         // Get dynamic
1217         assertAllDynamic(assertAllHaveTitle(assertAllNotHaveIntents(assertAllStringsResolved(
1218                 assertShortcutIds(
1219                         assertAllNotKeyFieldsOnly(
1220                                 mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1221                         /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1222                         "s1", "s2")))));
1223 
1224         // Get pinned
1225         assertShortcutIds(
1226                 mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1227                         /* activity =*/ null,
1228                         ShortcutQuery.FLAG_GET_PINNED), getCallingUser())
1229                 /* none */);
1230 
1231         // Get both, with timestamp
1232         assertAllDynamic(assertAllHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1233                 assertAllNotKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1234                         /* time =*/ 1000, CALLING_PACKAGE_2,
1235                         /* activity =*/ null,
1236                         ShortcutQuery.FLAG_GET_PINNED | ShortcutQuery.FLAG_GET_DYNAMIC),
1237                         getCallingUser())),
1238                 "s2", "s3"))));
1239 
1240         // FLAG_GET_KEY_FIELDS_ONLY
1241         assertAllDynamic(assertAllNotHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1242                 assertAllKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1243                         /* time =*/ 1000, CALLING_PACKAGE_2,
1244                         /* activity =*/ null,
1245                         ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY),
1246                         getCallingUser())),
1247                 "s2", "s3"))));
1248 
1249         // Filter by activity
1250         assertAllDynamic(assertAllHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1251                 assertAllNotKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1252                         /* time =*/ 0, CALLING_PACKAGE_2,
1253                         new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
1254                         ShortcutQuery.FLAG_GET_PINNED | ShortcutQuery.FLAG_GET_DYNAMIC),
1255                         getCallingUser())),
1256                 "s4"))));
1257 
1258         // With ID.
1259         assertAllDynamic(assertAllNotHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1260                 assertAllKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1261                         /* time =*/ 1000, CALLING_PACKAGE_2, list("s3"),
1262                         /* activity =*/ null,
1263                         ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY),
1264                         getCallingUser())),
1265                 "s3"))));
1266         assertAllDynamic(assertAllNotHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1267                 assertAllKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1268                         /* time =*/ 1000, CALLING_PACKAGE_2, list("s3", "s2", "ss"),
1269                         /* activity =*/ null,
1270                         ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY),
1271                         getCallingUser())),
1272                 "s2", "s3"))));
1273         assertAllDynamic(assertAllNotHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1274                 assertAllKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1275                         /* time =*/ 1000, CALLING_PACKAGE_2, list("s3x", "s2x"),
1276                         /* activity =*/ null,
1277                         ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY),
1278                         getCallingUser()))
1279                 /* empty */))));
1280         assertAllDynamic(assertAllNotHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1281                 assertAllKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1282                         /* time =*/ 1000, CALLING_PACKAGE_2, list(),
1283                         /* activity =*/ null,
1284                         ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY),
1285                         getCallingUser()))
1286                 /* empty */))));
1287 
1288         // Pin some shortcuts.
1289         mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
1290                 list("s3", "s4"), getCallingUser());
1291 
1292         // Pinned ones only
1293         assertAllPinned(assertAllHaveTitle(assertAllNotHaveIntents(assertShortcutIds(
1294                 assertAllNotKeyFieldsOnly(mLauncherApps.getShortcuts(buildQuery(
1295                         /* time =*/ 1000, CALLING_PACKAGE_2,
1296                         /* activity =*/ null,
1297                         ShortcutQuery.FLAG_GET_PINNED),
1298                         getCallingUser())),
1299                 "s3"))));
1300 
1301         // All packages.
1302         assertShortcutIds(assertAllNotKeyFieldsOnly(
1303                 mLauncherApps.getShortcuts(buildQuery(
1304                         /* time =*/ 5000, /* package= */ null,
1305                         /* activity =*/ null,
1306                         ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_PINNED),
1307                         getCallingUser())),
1308                 "s1", "s3");
1309 
1310         assertExpectException(
1311                 IllegalArgumentException.class, "package name must also be set", () -> {
1312                     mLauncherApps.getShortcuts(buildQuery(
1313                     /* time =*/ 0, /* package= */ null, list("id"),
1314                     /* activity =*/ null, /* flags */ 0), getCallingUser());
1315                 });
1316 
1317         // TODO More tests: pinned but dynamic.
1318     }
1319 
testGetShortcuts_shortcutKinds()1320     public void testGetShortcuts_shortcutKinds() throws Exception {
1321         // Create 3 manifest and 3 dynamic shortcuts
1322         addManifestShortcutResource(
1323                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
1324                 R.xml.shortcut_3);
1325         updatePackageVersion(CALLING_PACKAGE_1, 1);
1326         mService.mPackageMonitor.onReceive(getTestContext(),
1327                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
1328 
1329         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1330             assertTrue(mManager.setDynamicShortcuts(list(
1331                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
1332         });
1333 
1334         // Pin 2 and 3
1335         runWithCaller(LAUNCHER_1, USER_0, () -> {
1336             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms2", "ms3", "s2", "s3"),
1337                     HANDLE_USER_0);
1338         });
1339 
1340         // Remove ms3 and s3
1341         addManifestShortcutResource(
1342                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
1343                 R.xml.shortcut_2);
1344         updatePackageVersion(CALLING_PACKAGE_1, 1);
1345         mService.mPackageMonitor.onReceive(getTestContext(),
1346                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
1347 
1348         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1349             assertTrue(mManager.setDynamicShortcuts(list(
1350                     makeShortcut("s1"), makeShortcut("s2"))));
1351         });
1352 
1353         // Check their status.
1354         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1355             assertWith(getCallerShortcuts())
1356                     .haveIds("ms1", "ms2", "ms3", "s1", "s2", "s3")
1357 
1358                     .selectByIds("ms1", "ms2")
1359                     .areAllManifest()
1360                     .areAllImmutable()
1361                     .areAllNotDynamic()
1362 
1363                     .revertToOriginalList()
1364                     .selectByIds("ms3")
1365                     .areAllNotManifest()
1366                     .areAllImmutable()
1367                     .areAllDisabled()
1368                     .areAllNotDynamic()
1369 
1370                     .revertToOriginalList()
1371                     .selectByIds("s1", "s2")
1372                     .areAllNotManifest()
1373                     .areAllMutable()
1374                     .areAllDynamic()
1375 
1376                     .revertToOriginalList()
1377                     .selectByIds("s3")
1378                     .areAllNotManifest()
1379                     .areAllMutable()
1380                     .areAllEnabled()
1381                     .areAllNotDynamic()
1382 
1383                     .revertToOriginalList()
1384                     .selectByIds("s1", "ms1")
1385                     .areAllNotPinned()
1386 
1387                     .revertToOriginalList()
1388                     .selectByIds("s2", "s3", "ms2", "ms3")
1389                     .areAllPinned()
1390             ;
1391         });
1392 
1393         // Finally, actual tests.
1394         runWithCaller(LAUNCHER_1, USER_0, () -> {
1395             assertWith(mLauncherApps.getShortcuts(
1396                     buildQueryWithFlags(ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0))
1397                     .haveIds("s1", "s2");
1398             assertWith(mLauncherApps.getShortcuts(
1399                     buildQueryWithFlags(ShortcutQuery.FLAG_GET_MANIFEST), HANDLE_USER_0))
1400                     .haveIds("ms1", "ms2");
1401             assertWith(mLauncherApps.getShortcuts(
1402                     buildQueryWithFlags(ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0))
1403                     .haveIds("s2", "s3", "ms2", "ms3");
1404 
1405             assertWith(mLauncherApps.getShortcuts(
1406                     buildQueryWithFlags(
1407                             ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_PINNED
1408                     ), HANDLE_USER_0))
1409                     .haveIds("s1", "s2", "s3", "ms2", "ms3");
1410 
1411             assertWith(mLauncherApps.getShortcuts(
1412                     buildQueryWithFlags(
1413                             ShortcutQuery.FLAG_GET_MANIFEST | ShortcutQuery.FLAG_GET_PINNED
1414                     ), HANDLE_USER_0))
1415                     .haveIds("ms1", "s2", "s3", "ms2", "ms3");
1416 
1417             assertWith(mLauncherApps.getShortcuts(
1418                     buildQueryWithFlags(
1419                             ShortcutQuery.FLAG_GET_DYNAMIC | ShortcutQuery.FLAG_GET_MANIFEST
1420                     ), HANDLE_USER_0))
1421                     .haveIds("ms1", "ms2", "s1", "s2");
1422 
1423             assertWith(mLauncherApps.getShortcuts(
1424                     buildQueryWithFlags(
1425                             ShortcutQuery.FLAG_GET_ALL_KINDS
1426                     ), HANDLE_USER_0))
1427                     .haveIds("ms1", "ms2", "ms3", "s1", "s2", "s3");
1428         });
1429     }
1430 
testGetShortcuts_resolveStrings()1431     public void testGetShortcuts_resolveStrings() throws Exception {
1432         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1433             ShortcutInfo si = new ShortcutInfo.Builder(mClientContext)
1434                     .setId("id")
1435                     .setActivity(new ComponentName(mClientContext, "dummy"))
1436                     .setTitleResId(10)
1437                     .setTextResId(11)
1438                     .setDisabledMessageResId(12)
1439                     .setIntent(makeIntent("action", ShortcutActivity.class))
1440                     .build();
1441             mManager.setDynamicShortcuts(list(si));
1442         });
1443         runWithCaller(CALLING_PACKAGE_1, USER_P0, () -> {
1444             ShortcutInfo si = new ShortcutInfo.Builder(mClientContext)
1445                     .setId("id")
1446                     .setActivity(new ComponentName(mClientContext, "dummy"))
1447                     .setTitleResId(10)
1448                     .setTextResId(11)
1449                     .setDisabledMessageResId(12)
1450                     .setIntent(makeIntent("action", ShortcutActivity.class))
1451                     .build();
1452             mManager.setDynamicShortcuts(list(si));
1453         });
1454 
1455         runWithCaller(LAUNCHER_1, USER_0, () -> {
1456             final ShortcutQuery q = new ShortcutQuery();
1457             q.setQueryFlags(ShortcutQuery.FLAG_GET_DYNAMIC);
1458 
1459             // USER 0
1460             List<ShortcutInfo> ret = assertShortcutIds(
1461                     assertAllStringsResolved(mLauncherApps.getShortcuts(q, HANDLE_USER_0)),
1462                     "id");
1463             assertEquals("string-com.android.test.1-user:0-res:10/en", ret.get(0).getTitle());
1464             assertEquals("string-com.android.test.1-user:0-res:11/en", ret.get(0).getText());
1465             assertEquals("string-com.android.test.1-user:0-res:12/en",
1466                     ret.get(0).getDisabledMessage());
1467 
1468             // USER P0
1469             ret = assertShortcutIds(
1470                     assertAllStringsResolved(mLauncherApps.getShortcuts(q, HANDLE_USER_P0)),
1471                     "id");
1472             assertEquals("string-com.android.test.1-user:20-res:10/en", ret.get(0).getTitle());
1473             assertEquals("string-com.android.test.1-user:20-res:11/en", ret.get(0).getText());
1474             assertEquals("string-com.android.test.1-user:20-res:12/en",
1475                     ret.get(0).getDisabledMessage());
1476         });
1477     }
1478 
1479     // TODO resource
testGetShortcutInfo()1480     public void testGetShortcutInfo() {
1481         // Create shortcuts.
1482         setCaller(CALLING_PACKAGE_1);
1483         final ShortcutInfo s1_1 = makeShortcut(
1484                 "s1",
1485                 "Title 1",
1486                 makeComponent(ShortcutActivity.class),
1487                 /* icon =*/ null,
1488                 makeIntent(Intent.ACTION_ASSIST, ShortcutActivity2.class,
1489                         "key1", "val1", "nest", makeBundle("key", 123)),
1490                 /* weight */ 10);
1491 
1492         final ShortcutInfo s1_2 = makeShortcut(
1493                 "s2",
1494                 "Title 2",
1495                 /* activity */ null,
1496                 /* icon =*/ null,
1497                 makeIntent(Intent.ACTION_ASSIST, ShortcutActivity3.class),
1498                 /* weight */ 12);
1499 
1500         assertTrue(mManager.setDynamicShortcuts(list(s1_1, s1_2)));
1501         dumpsysOnLogcat();
1502 
1503         setCaller(CALLING_PACKAGE_2);
1504         final ShortcutInfo s2_1 = makeShortcut(
1505                 "s1",
1506                 "ABC",
1507                 makeComponent(ShortcutActivity2.class),
1508                 /* icon =*/ null,
1509                 makeIntent(Intent.ACTION_ANSWER, ShortcutActivity2.class,
1510                         "key1", "val1", "nest", makeBundle("key", 123)),
1511                 /* weight */ 10);
1512         assertTrue(mManager.setDynamicShortcuts(list(s2_1)));
1513         dumpsysOnLogcat();
1514 
1515         // Pin some.
1516         setCaller(LAUNCHER_1);
1517 
1518         mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
1519                 list("s2"), getCallingUser());
1520 
1521         dumpsysOnLogcat();
1522 
1523         // Delete some.
1524         setCaller(CALLING_PACKAGE_1);
1525         assertShortcutIds(mManager.getPinnedShortcuts(), "s2");
1526         mManager.removeDynamicShortcuts(list("s2"));
1527         assertShortcutIds(mManager.getPinnedShortcuts(), "s2");
1528 
1529         dumpsysOnLogcat();
1530 
1531         setCaller(LAUNCHER_1);
1532         List<ShortcutInfo> list;
1533 
1534         // Note we don't guarantee the orders.
1535         list = assertShortcutIds(assertAllHaveTitle(assertAllNotHaveIntents(
1536                 assertAllNotKeyFieldsOnly(
1537                         mLauncherApps.getShortcutInfo(CALLING_PACKAGE_1,
1538                                 list("s2", "s1", "s3", null), getCallingUser())))),
1539                 "s1", "s2");
1540         assertEquals("Title 1", findById(list, "s1").getTitle());
1541         assertEquals("Title 2", findById(list, "s2").getTitle());
1542 
1543         assertShortcutIds(assertAllHaveTitle(assertAllNotHaveIntents(
1544                 mLauncherApps.getShortcutInfo(CALLING_PACKAGE_1,
1545                         list("s3"), getCallingUser())))
1546                 /* none */);
1547 
1548         list = assertShortcutIds(assertAllHaveTitle(assertAllNotHaveIntents(
1549                 mLauncherApps.getShortcutInfo(CALLING_PACKAGE_2,
1550                         list("s1", "s2", "s3"), getCallingUser()))),
1551                 "s1");
1552         assertEquals("ABC", findById(list, "s1").getTitle());
1553     }
1554 
testPinShortcutAndGetPinnedShortcuts()1555     public void testPinShortcutAndGetPinnedShortcuts() {
1556         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1557             final ShortcutInfo s1_1 = makeShortcutWithTimestamp("s1", 1000);
1558             final ShortcutInfo s1_2 = makeShortcutWithTimestamp("s2", 2000);
1559 
1560             assertTrue(mManager.setDynamicShortcuts(list(s1_1, s1_2)));
1561         });
1562 
1563         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
1564             final ShortcutInfo s2_2 = makeShortcutWithTimestamp("s2", 1500);
1565             final ShortcutInfo s2_3 = makeShortcutWithTimestamp("s3", 3000);
1566             final ShortcutInfo s2_4 = makeShortcutWithTimestamp("s4", 500);
1567             assertTrue(mManager.setDynamicShortcuts(list(s2_2, s2_3, s2_4)));
1568         });
1569 
1570         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
1571             final ShortcutInfo s3_2 = makeShortcutWithTimestamp("s2", 1000);
1572             assertTrue(mManager.setDynamicShortcuts(list(s3_2)));
1573         });
1574 
1575         // Pin some.
1576         runWithCaller(LAUNCHER_1, USER_0, () -> {
1577             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
1578                     list("s2", "s3"), getCallingUser());
1579 
1580             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
1581                     list("s3", "s4", "s5"), getCallingUser());
1582 
1583             mLauncherApps.pinShortcuts(CALLING_PACKAGE_3,
1584                     list("s3"), getCallingUser());  // Note ID doesn't exist
1585         });
1586 
1587         // Delete some.
1588         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1589             assertShortcutIds(mManager.getPinnedShortcuts(), "s2");
1590             mManager.removeDynamicShortcuts(list("s2"));
1591             assertShortcutIds(mManager.getPinnedShortcuts(), "s2");
1592 
1593             assertShortcutIds(mManager.getDynamicShortcuts(), "s1");
1594         });
1595 
1596         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
1597             assertShortcutIds(mManager.getPinnedShortcuts(), "s3", "s4");
1598             mManager.removeDynamicShortcuts(list("s3"));
1599             assertShortcutIds(mManager.getPinnedShortcuts(), "s3", "s4");
1600 
1601             assertShortcutIds(mManager.getDynamicShortcuts(), "s2", "s4");
1602         });
1603 
1604         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
1605             assertShortcutIds(mManager.getPinnedShortcuts() /* none */);
1606             mManager.removeDynamicShortcuts(list("s2"));
1607             assertShortcutIds(mManager.getPinnedShortcuts() /* none */);
1608 
1609             assertEmpty(mManager.getDynamicShortcuts());
1610         });
1611 
1612         // Get pinned shortcuts from launcher
1613         runWithCaller(LAUNCHER_1, USER_0, () -> {
1614             // CALLING_PACKAGE_1 deleted s2, but it's pinned, so it still exists.
1615             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(assertAllEnabled(
1616                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1617                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser())))),
1618                     "s2");
1619 
1620             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(assertAllEnabled(
1621                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1622                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser())))),
1623                     "s3", "s4");
1624 
1625             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(assertAllEnabled(
1626                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_3,
1627                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))))
1628                     /* none */);
1629         });
1630     }
1631 
1632     /**
1633      * This is similar to the above test, except it used "disable" instead of "remove".  It also
1634      * does "enable".
1635      */
testDisableAndEnableShortcuts()1636     public void testDisableAndEnableShortcuts() {
1637         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1638             final ShortcutInfo s1_1 = makeShortcutWithTimestamp("s1", 1000);
1639             final ShortcutInfo s1_2 = makeShortcutWithTimestamp("s2", 2000);
1640 
1641             assertTrue(mManager.setDynamicShortcuts(list(s1_1, s1_2)));
1642         });
1643 
1644         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
1645             final ShortcutInfo s2_2 = makeShortcutWithTimestamp("s2", 1500);
1646             final ShortcutInfo s2_3 = makeShortcutWithTimestamp("s3", 3000);
1647             final ShortcutInfo s2_4 = makeShortcutWithTimestamp("s4", 500);
1648             assertTrue(mManager.setDynamicShortcuts(list(s2_2, s2_3, s2_4)));
1649         });
1650 
1651         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
1652             final ShortcutInfo s3_2 = makeShortcutWithTimestamp("s2", 1000);
1653             assertTrue(mManager.setDynamicShortcuts(list(s3_2)));
1654         });
1655 
1656         // Pin some.
1657         runWithCaller(LAUNCHER_1, USER_0, () -> {
1658             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
1659                     list("s2", "s3"), getCallingUser());
1660 
1661             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
1662                     list("s3", "s4", "s5"), getCallingUser());
1663 
1664             mLauncherApps.pinShortcuts(CALLING_PACKAGE_3,
1665                     list("s3"), getCallingUser());  // Note ID doesn't exist
1666         });
1667 
1668         // Disable some.
1669         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1670             assertShortcutIds(mManager.getPinnedShortcuts(), "s2");
1671 
1672             mManager.disableShortcuts(list("s2"));
1673 
1674             assertShortcutIds(mManager.getPinnedShortcuts(), "s2");
1675             assertShortcutIds(mManager.getDynamicShortcuts(), "s1");
1676         });
1677 
1678         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
1679             assertShortcutIds(mManager.getPinnedShortcuts(), "s3", "s4");
1680 
1681             // disable should work even if a shortcut is not dynamic, so try calling "remove" first
1682             // here.
1683             mManager.removeDynamicShortcuts(list("s3"));
1684             mManager.disableShortcuts(list("s3"));
1685 
1686             assertShortcutIds(mManager.getPinnedShortcuts(), "s3", "s4");
1687             assertShortcutIds(mManager.getDynamicShortcuts(), "s2", "s4");
1688         });
1689 
1690         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
1691             assertShortcutIds(mManager.getPinnedShortcuts() /* none */);
1692 
1693             mManager.disableShortcuts(list("s2"));
1694 
1695             assertShortcutIds(mManager.getPinnedShortcuts() /* none */);
1696 
1697             assertEmpty(mManager.getDynamicShortcuts());
1698             assertEmpty(getCallerShortcuts());
1699         });
1700 
1701         // Get pinned shortcuts from launcher
1702         runWithCaller(LAUNCHER_1, USER_0, () -> {
1703             // CALLING_PACKAGE_1 deleted s2, but it's pinned, so it still exists, and disabled.
1704             assertWith(mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1705                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))
1706                     .haveIds("s2")
1707                     .areAllPinned()
1708                     .areAllNotWithKeyFieldsOnly()
1709                     .areAllDisabled();
1710             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_0,
1711                     ActivityNotFoundException.class);
1712 
1713             // Here, s4 is still enabled and launchable, but s3 is disabled.
1714             assertWith(mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1715                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))
1716                     .haveIds("s3", "s4")
1717                     .areAllPinned()
1718                     .areAllNotWithKeyFieldsOnly()
1719 
1720                     .selectByIds("s3")
1721                     .areAllDisabled()
1722 
1723                     .revertToOriginalList()
1724                     .selectByIds("s4")
1725                     .areAllEnabled();
1726 
1727             assertStartShortcutThrowsException(CALLING_PACKAGE_2, "s3", USER_0,
1728                     ActivityNotFoundException.class);
1729             assertShortcutLaunchable(CALLING_PACKAGE_2, "s4", USER_0);
1730 
1731             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(assertAllEnabled(
1732                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_3,
1733                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))))
1734                     /* none */);
1735         });
1736 
1737         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1738             mManager.enableShortcuts(list("s2"));
1739 
1740             assertShortcutIds(mManager.getPinnedShortcuts(), "s2");
1741             assertShortcutIds(mManager.getDynamicShortcuts(), "s1");
1742         });
1743         runWithCaller(LAUNCHER_1, USER_0, () -> {
1744             // CALLING_PACKAGE_1 deleted s2, but it's pinned, so it still exists.
1745             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(assertAllEnabled(
1746                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1747                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser())))),
1748                     "s2");
1749             assertShortcutLaunchable(CALLING_PACKAGE_1, "s2", USER_0);
1750         });
1751     }
1752 
testDisableShortcuts_thenRepublish()1753     public void testDisableShortcuts_thenRepublish() {
1754         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1755             assertTrue(mManager.setDynamicShortcuts(list(
1756                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
1757 
1758             runWithCaller(LAUNCHER_1, USER_0, () -> {
1759                 mLauncherApps.pinShortcuts(
1760                         CALLING_PACKAGE_1, list("s1", "s2", "s3"), HANDLE_USER_0);
1761             });
1762 
1763             mManager.disableShortcuts(list("s1", "s2", "s3"));
1764 
1765             assertWith(getCallerShortcuts())
1766                     .haveIds("s1", "s2", "s3")
1767                     .areAllNotDynamic()
1768                     .areAllPinned()
1769                     .areAllDisabled();
1770 
1771             // Make sure updateShortcuts() will not re-enable them.
1772             assertTrue(mManager.updateShortcuts(list(
1773                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
1774 
1775             assertWith(getCallerShortcuts())
1776                     .haveIds("s1", "s2", "s3")
1777                     .areAllNotDynamic()
1778                     .areAllPinned()
1779                     .areAllDisabled();
1780 
1781             // Re-publish s1 with setDynamicShortcuts.
1782             mInjectedCurrentTimeMillis += INTERVAL; // reset throttling
1783 
1784             assertTrue(mManager.setDynamicShortcuts(list(
1785                     makeShortcut("s1"))));
1786 
1787             assertWith(getCallerShortcuts())
1788                     .haveIds("s1", "s2", "s3")
1789 
1790                     .selectByIds("s1")
1791                     .areAllDynamic()
1792                     .areAllPinned()
1793                     .areAllEnabled()
1794 
1795                     .revertToOriginalList()
1796                     .selectByIds("s2", "s3")
1797                     .areAllNotDynamic()
1798                     .areAllPinned()
1799                     .areAllDisabled();
1800 
1801             // Re-publish s2 with addDynamicShortcuts.
1802             mInjectedCurrentTimeMillis += INTERVAL; // reset throttling
1803 
1804             assertTrue(mManager.addDynamicShortcuts(list(
1805                     makeShortcut("s2"))));
1806 
1807             assertWith(getCallerShortcuts())
1808                     .haveIds("s1", "s2", "s3")
1809 
1810                     .selectByIds("s1", "s2")
1811                     .areAllDynamic()
1812                     .areAllPinned()
1813                     .areAllEnabled()
1814 
1815                     .revertToOriginalList()
1816                     .selectByIds("s3")
1817                     .areAllNotDynamic()
1818                     .areAllPinned()
1819                     .areAllDisabled();
1820         });
1821     }
1822 
testPinShortcutAndGetPinnedShortcuts_multi()1823     public void testPinShortcutAndGetPinnedShortcuts_multi() {
1824         // Create some shortcuts.
1825         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1826             assertTrue(mManager.setDynamicShortcuts(list(
1827                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
1828         });
1829 
1830         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
1831             assertTrue(mManager.setDynamicShortcuts(list(
1832                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
1833         });
1834 
1835         dumpsysOnLogcat();
1836 
1837         // Pin some.
1838         runWithCaller(LAUNCHER_1, USER_0, () -> {
1839             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
1840                     list("s3", "s4"), getCallingUser());
1841 
1842             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
1843                     list("s1", "s2", "s4"), getCallingUser());
1844         });
1845 
1846         dumpsysOnLogcat();
1847 
1848         // Delete some.
1849         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1850             assertShortcutIds(mManager.getPinnedShortcuts(), "s3");
1851             mManager.removeDynamicShortcuts(list("s3"));
1852             assertShortcutIds(mManager.getPinnedShortcuts(), "s3");
1853         });
1854 
1855         dumpsysOnLogcat();
1856 
1857         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
1858             assertShortcutIds(mManager.getPinnedShortcuts(), "s1", "s2");
1859             mManager.removeDynamicShortcuts(list("s1"));
1860             mManager.removeDynamicShortcuts(list("s3"));
1861             assertShortcutIds(mManager.getPinnedShortcuts(), "s1", "s2");
1862         });
1863 
1864         dumpsysOnLogcat();
1865 
1866         // Get pinned shortcuts from launcher
1867         runWithCaller(LAUNCHER_1, USER_0, () -> {
1868             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1869                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1870                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
1871                     "s3");
1872 
1873             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1874                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1875                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
1876                     "s1", "s2");
1877 
1878             assertShortcutIds(assertAllDynamicOrPinned(
1879                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1880                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1881                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1882                     "s1", "s2", "s3");
1883 
1884             assertShortcutIds(assertAllDynamicOrPinned(
1885                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1886                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1887                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1888                     "s1", "s2");
1889         });
1890 
1891         dumpsysOnLogcat();
1892 
1893         runWithCaller(LAUNCHER_2, USER_0, () -> {
1894             // Launcher2 still has no pinned ones.
1895             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1896                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1897                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser())))
1898                     /* none */);
1899             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1900                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1901                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser())))
1902                     /* none */);
1903 
1904             assertShortcutIds(assertAllDynamic(
1905                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1906                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1907                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1908                     "s1", "s2");
1909             assertShortcutIds(assertAllDynamic(
1910                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1911                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1912                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1913                     "s2");
1914 
1915             // Now pin some.
1916             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
1917                     list("s1", "s2"), getCallingUser());
1918 
1919             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
1920                     list("s1", "s2"), getCallingUser());
1921 
1922             assertShortcutIds(assertAllDynamic(
1923                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1924                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1925                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1926                     "s1", "s2");
1927 
1928             // S1 was not visible to it, so shouldn't be pinned.
1929             assertShortcutIds(assertAllDynamic(
1930                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1931                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1932                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1933                     "s2");
1934         });
1935 
1936         // Re-initialize and load from the files.
1937         mService.saveDirtyInfo();
1938         initService();
1939 
1940         // Load from file.
1941         mService.handleUnlockUser(USER_0);
1942 
1943         // Make sure package info is restored too.
1944         runWithCaller(LAUNCHER_1, USER_0, () -> {
1945             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1946                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1947                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
1948                     "s3");
1949             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1950                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1951                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
1952                     "s1", "s2");
1953         });
1954         runWithCaller(LAUNCHER_2, USER_0, () -> {
1955             assertShortcutIds(assertAllDynamic(
1956                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1957                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1958                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1959                     "s1", "s2");
1960             assertShortcutIds(assertAllDynamic(
1961                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1962                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED
1963                                     | ShortcutQuery.FLAG_GET_DYNAMIC), getCallingUser())),
1964                     "s2");
1965         });
1966 
1967         // Delete all dynamic.
1968         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
1969             mManager.removeAllDynamicShortcuts();
1970 
1971             assertEquals(0, mManager.getDynamicShortcuts().size());
1972             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()), "s1", "s2", "s3");
1973         });
1974         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
1975             mManager.removeAllDynamicShortcuts();
1976 
1977             assertEquals(0, mManager.getDynamicShortcuts().size());
1978             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()), "s2", "s1");
1979         });
1980 
1981         runWithCaller(LAUNCHER_1, USER_0, () -> {
1982             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1983                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
1984                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
1985                     "s3");
1986 
1987             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1988                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
1989                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
1990                     "s1", "s2");
1991 
1992             // from all packages.
1993             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
1994                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, null,
1995                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
1996                     "s1", "s2", "s3");
1997 
1998             // Update pined.  Note s2 and s3 are actually available, but not visible to this
1999             // launcher, so still can't be pinned.
2000             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s1", "s2", "s3", "s4"),
2001                     getCallingUser());
2002 
2003             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
2004                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2005                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
2006                     "s3");
2007         });
2008         // Re-publish s1.
2009         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2010             assertTrue(mManager.addDynamicShortcuts(list(makeShortcut("s1"))));
2011 
2012             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()), "s1");
2013             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()), "s1", "s2", "s3");
2014         });
2015         runWithCaller(LAUNCHER_1, USER_0, () -> {
2016             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
2017                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2018                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
2019                     "s3");
2020 
2021             // Now "s1" is visible, so can be pinned.
2022             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s1", "s2", "s3", "s4"),
2023                     getCallingUser());
2024 
2025             assertShortcutIds(assertAllPinned(assertAllNotKeyFieldsOnly(
2026                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2027                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()))),
2028                     "s1", "s3");
2029         });
2030 
2031         // Now clear pinned shortcuts.  First, from launcher 1.
2032         runWithCaller(LAUNCHER_1, USER_0, () -> {
2033             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list(), getCallingUser());
2034             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list(), getCallingUser());
2035 
2036             assertEquals(0,
2037                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2038                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()).size());
2039             assertEquals(0,
2040                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2041                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()).size());
2042         });
2043         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2044             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()), "s1");
2045             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()), "s1", "s2");
2046         });
2047         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
2048             assertEquals(0, mManager.getDynamicShortcuts().size());
2049             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()), "s2");
2050         });
2051 
2052         // Clear all pins from launcher 2.
2053         runWithCaller(LAUNCHER_2, USER_0, () -> {
2054             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list(), getCallingUser());
2055             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list(), getCallingUser());
2056 
2057             assertEquals(0,
2058                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2059                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()).size());
2060             assertEquals(0,
2061                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2062                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), getCallingUser()).size());
2063         });
2064         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2065             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()), "s1");
2066             assertEquals(0, mManager.getPinnedShortcuts().size());
2067         });
2068         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
2069             assertEquals(0, mManager.getDynamicShortcuts().size());
2070             assertEquals(0, mManager.getPinnedShortcuts().size());
2071         });
2072     }
2073 
testPinShortcutAndGetPinnedShortcuts_crossProfile_plusLaunch()2074     public void testPinShortcutAndGetPinnedShortcuts_crossProfile_plusLaunch() {
2075         // Create some shortcuts.
2076         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2077             assertTrue(mManager.setDynamicShortcuts(list(
2078                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
2079         });
2080         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
2081             assertTrue(mManager.setDynamicShortcuts(list(
2082                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
2083         });
2084 
2085         mRunningUsers.put(USER_10, true);
2086 
2087         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
2088             assertTrue(mManager.setDynamicShortcuts(list(
2089                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"),
2090                     makeShortcut("s4"), makeShortcut("s5"), makeShortcut("s6"))));
2091         });
2092 
2093         // Pin some shortcuts and see the result.
2094 
2095         runWithCaller(LAUNCHER_1, USER_0, () -> {
2096             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
2097                     list("s1"), HANDLE_USER_0);
2098 
2099             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
2100                     list("s1", "s2", "s3"), HANDLE_USER_0);
2101         });
2102 
2103         runWithCaller(LAUNCHER_1, USER_P0, () -> {
2104             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
2105                     list("s2"), HANDLE_USER_0);
2106 
2107             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
2108                     list("s2", "s3"), HANDLE_USER_0);
2109         });
2110 
2111         runWithCaller(LAUNCHER_2, USER_P0, () -> {
2112             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
2113                     list("s3"), HANDLE_USER_0);
2114 
2115             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
2116                     list("s3"), HANDLE_USER_0);
2117         });
2118 
2119         runWithCaller(LAUNCHER_2, USER_10, () -> {
2120             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
2121                     list("s1", "s2", "s3"), HANDLE_USER_10);
2122         });
2123 
2124         // First, make sure managed profile can't see other profiles.
2125         runWithCaller(LAUNCHER_1, USER_P1, () -> {
2126 
2127             final ShortcutQuery q = new ShortcutQuery().setQueryFlags(
2128                     ShortcutQuery.FLAG_MATCH_DYNAMIC | ShortcutQuery.FLAG_MATCH_PINNED
2129                     | ShortcutQuery.FLAG_MATCH_MANIFEST);
2130 
2131             // No shortcuts are visible.
2132             assertWith(mLauncherApps.getShortcuts(q, HANDLE_USER_0)).isEmpty();
2133 
2134             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s1"), HANDLE_USER_0);
2135 
2136             // Should have no effects.
2137             assertWith(mLauncherApps.getShortcuts(q, HANDLE_USER_0)).isEmpty();
2138 
2139             assertShortcutNotLaunched(CALLING_PACKAGE_1, "s1", USER_0);
2140         });
2141 
2142         // Cross profile pinning.
2143         final int PIN_AND_DYNAMIC = ShortcutQuery.FLAG_GET_PINNED | ShortcutQuery.FLAG_GET_DYNAMIC;
2144 
2145         runWithCaller(LAUNCHER_1, USER_0, () -> {
2146             assertShortcutIds(assertAllPinned(
2147                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2148                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2149                     "s1");
2150             assertShortcutIds(assertAllDynamic(
2151                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2152                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2153                     "s1", "s2", "s3");
2154             assertShortcutIds(assertAllDynamicOrPinned(
2155                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2156                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2157                     "s1", "s2", "s3");
2158 
2159             assertShortcutIds(assertAllPinned(
2160                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2161                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2162                     "s1", "s2", "s3");
2163             assertShortcutIds(assertAllDynamic(
2164                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2165                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2166                     "s1", "s2", "s3");
2167             assertShortcutIds(assertAllDynamicOrPinned(
2168                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2169                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2170                     "s1", "s2", "s3");
2171 
2172             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2173             assertShortcutLaunchable(CALLING_PACKAGE_1, "s2", USER_0);
2174             assertShortcutLaunchable(CALLING_PACKAGE_1, "s3", USER_0);
2175 
2176             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2177             assertShortcutLaunchable(CALLING_PACKAGE_2, "s2", USER_0);
2178             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2179 
2180             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2181                     SecurityException.class);
2182             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2183                     SecurityException.class);
2184             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2185                     SecurityException.class);
2186             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2187                     SecurityException.class);
2188             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2189                     SecurityException.class);
2190             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2191                     SecurityException.class);
2192         });
2193         runWithCaller(LAUNCHER_1, USER_P0, () -> {
2194             assertShortcutIds(assertAllPinned(
2195                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2196                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2197                     "s2");
2198             assertShortcutIds(assertAllDynamic(
2199                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2200                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2201                     "s1", "s2", "s3");
2202             assertShortcutIds(assertAllDynamicOrPinned(
2203                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2204                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2205                     "s1", "s2", "s3");
2206 
2207             assertShortcutIds(assertAllPinned(
2208                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2209                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2210                     "s2", "s3");
2211             assertShortcutIds(assertAllDynamic(
2212                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2213                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2214                     "s1", "s2", "s3");
2215             assertShortcutIds(assertAllDynamicOrPinned(
2216                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2217                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2218                     "s1", "s2", "s3");
2219 
2220             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2221             assertShortcutLaunchable(CALLING_PACKAGE_1, "s2", USER_0);
2222             assertShortcutLaunchable(CALLING_PACKAGE_1, "s3", USER_0);
2223 
2224             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2225             assertShortcutLaunchable(CALLING_PACKAGE_2, "s2", USER_0);
2226             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2227 
2228             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2229                     SecurityException.class);
2230             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2231                     SecurityException.class);
2232             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2233                     SecurityException.class);
2234             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2235                     SecurityException.class);
2236             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2237                     SecurityException.class);
2238             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2239                     SecurityException.class);
2240         });
2241         runWithCaller(LAUNCHER_2, USER_P0, () -> {
2242             assertShortcutIds(assertAllPinned(
2243                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2244                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2245                     "s3");
2246             assertShortcutIds(assertAllDynamic(
2247                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2248                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2249                     "s1", "s2", "s3");
2250             assertShortcutIds(assertAllDynamicOrPinned(
2251                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2252                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2253                     "s1", "s2", "s3");
2254 
2255             assertShortcutIds(assertAllPinned(
2256                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2257                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2258                     "s3");
2259             assertShortcutIds(assertAllDynamic(
2260                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2261                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2262                     "s1", "s2", "s3");
2263             assertShortcutIds(assertAllDynamicOrPinned(
2264                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2265                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2266                     "s1", "s2", "s3");
2267 
2268             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2269             assertShortcutLaunchable(CALLING_PACKAGE_1, "s2", USER_0);
2270             assertShortcutLaunchable(CALLING_PACKAGE_1, "s3", USER_0);
2271 
2272             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2273             assertShortcutLaunchable(CALLING_PACKAGE_2, "s2", USER_0);
2274             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2275 
2276             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2277                     SecurityException.class);
2278             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2279                     SecurityException.class);
2280             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2281                     SecurityException.class);
2282             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2283                     SecurityException.class);
2284             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2285                     SecurityException.class);
2286             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2287                     SecurityException.class);
2288         });
2289         runWithCaller(LAUNCHER_2, USER_10, () -> {
2290             assertShortcutIds(assertAllPinned(
2291                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2292                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_10)),
2293                     "s1", "s2", "s3");
2294             assertShortcutIds(assertAllDynamic(
2295                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2296                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_10)),
2297                     "s1", "s2", "s3", "s4", "s5", "s6");
2298             assertShortcutIds(assertAllDynamicOrPinned(
2299                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2300                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_10)),
2301                     "s1", "s2", "s3", "s4", "s5", "s6");
2302         });
2303 
2304         // Remove some dynamic shortcuts.
2305 
2306         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2307             assertTrue(mManager.setDynamicShortcuts(list(
2308                     makeShortcut("s1"))));
2309         });
2310         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
2311             assertTrue(mManager.setDynamicShortcuts(list(
2312                     makeShortcut("s1"))));
2313         });
2314         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
2315             assertTrue(mManager.setDynamicShortcuts(list(
2316                     makeShortcut("s1"))));
2317         });
2318 
2319         runWithCaller(LAUNCHER_1, USER_0, () -> {
2320             assertShortcutIds(assertAllPinned(
2321                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2322                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2323                     "s1");
2324             assertShortcutIds(assertAllDynamic(
2325                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2326                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2327                     "s1");
2328             assertShortcutIds(assertAllDynamicOrPinned(
2329                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2330                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2331                     "s1");
2332 
2333             assertShortcutIds(assertAllPinned(
2334                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2335                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2336                     "s1", "s2", "s3");
2337             assertShortcutIds(assertAllDynamic(
2338                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2339                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2340                     "s1");
2341             assertShortcutIds(assertAllDynamicOrPinned(
2342                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2343                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2344                     "s1", "s2", "s3");
2345 
2346             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2347             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_0,
2348                     ActivityNotFoundException.class);
2349             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_0,
2350                     ActivityNotFoundException.class);
2351 
2352             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2353             assertShortcutLaunchable(CALLING_PACKAGE_2, "s2", USER_0);
2354             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2355 
2356             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2357                     SecurityException.class);
2358             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2359                     SecurityException.class);
2360             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2361                     SecurityException.class);
2362             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2363                     SecurityException.class);
2364             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2365                     SecurityException.class);
2366             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2367                     SecurityException.class);
2368         });
2369         runWithCaller(LAUNCHER_1, USER_P0, () -> {
2370             assertShortcutIds(assertAllPinned(
2371                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2372                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2373                     "s2");
2374             assertShortcutIds(assertAllDynamic(
2375                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2376                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2377                     "s1");
2378             assertShortcutIds(assertAllDynamicOrPinned(
2379                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2380                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2381                     "s1", "s2");
2382 
2383             assertShortcutIds(assertAllPinned(
2384                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2385                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2386                     "s2", "s3");
2387             assertShortcutIds(assertAllDynamic(
2388                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2389                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2390                     "s1");
2391             assertShortcutIds(assertAllDynamicOrPinned(
2392                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2393                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2394                     "s1", "s2", "s3");
2395 
2396             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2397             assertShortcutLaunchable(CALLING_PACKAGE_1, "s2", USER_0);
2398             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_0,
2399                     ActivityNotFoundException.class);
2400 
2401             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2402             assertShortcutLaunchable(CALLING_PACKAGE_2, "s2", USER_0);
2403             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2404 
2405             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2406                     SecurityException.class);
2407             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2408                     SecurityException.class);
2409             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2410                     SecurityException.class);
2411             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2412                     SecurityException.class);
2413             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2414                     SecurityException.class);
2415             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2416                     SecurityException.class);
2417         });
2418         runWithCaller(LAUNCHER_2, USER_P0, () -> {
2419             assertShortcutIds(assertAllPinned(
2420                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2421                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2422                     "s3");
2423             assertShortcutIds(assertAllDynamic(
2424                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2425                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2426                     "s1");
2427             assertShortcutIds(assertAllDynamicOrPinned(
2428                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2429                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2430                     "s1", "s3");
2431 
2432             assertShortcutIds(assertAllPinned(
2433                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2434                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2435                     "s3");
2436             assertShortcutIds(assertAllDynamic(
2437                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2438                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2439                     "s1");
2440             assertShortcutIds(assertAllDynamicOrPinned(
2441                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2442                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2443                     "s1", "s3");
2444 
2445             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2446             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_0,
2447                     ActivityNotFoundException.class);
2448             assertShortcutLaunchable(CALLING_PACKAGE_1, "s3", USER_0);
2449 
2450             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2451             assertStartShortcutThrowsException(CALLING_PACKAGE_2, "s2", USER_0,
2452                     ActivityNotFoundException.class);
2453             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2454 
2455             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2456                     SecurityException.class);
2457             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2458                     SecurityException.class);
2459             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2460                     SecurityException.class);
2461             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2462                     SecurityException.class);
2463             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2464                     SecurityException.class);
2465             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2466                     SecurityException.class);
2467         });
2468         runWithCaller(LAUNCHER_2, USER_10, () -> {
2469             assertShortcutIds(assertAllPinned(
2470                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2471                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_10)),
2472                     "s1", "s2", "s3");
2473             assertShortcutIds(assertAllDynamic(
2474                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2475                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_10)),
2476                     "s1");
2477             assertShortcutIds(assertAllDynamicOrPinned(
2478                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2479                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_10)),
2480                     "s1", "s2", "s3");
2481 
2482             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_0,
2483                     SecurityException.class);
2484             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_0,
2485                     SecurityException.class);
2486             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_0,
2487                     SecurityException.class);
2488 
2489             assertStartShortcutThrowsException(CALLING_PACKAGE_2, "s1", USER_0,
2490                     SecurityException.class);
2491             assertStartShortcutThrowsException(CALLING_PACKAGE_2, "s2", USER_0,
2492                     SecurityException.class);
2493             assertStartShortcutThrowsException(CALLING_PACKAGE_2, "s3", USER_0,
2494                     SecurityException.class);
2495 
2496             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_10);
2497             assertShortcutLaunchable(CALLING_PACKAGE_1, "s2", USER_10);
2498             assertShortcutLaunchable(CALLING_PACKAGE_1, "s3", USER_10);
2499             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2500                     ActivityNotFoundException.class);
2501             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2502                     ActivityNotFoundException.class);
2503             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2504                     ActivityNotFoundException.class);
2505         });
2506 
2507         // Save & load and make sure we still have the same information.
2508         mService.saveDirtyInfo();
2509         initService();
2510         mService.handleUnlockUser(USER_0);
2511 
2512         runWithCaller(LAUNCHER_1, USER_0, () -> {
2513             assertShortcutIds(assertAllPinned(
2514                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2515                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2516                     "s1");
2517             assertShortcutIds(assertAllDynamic(
2518                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2519                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2520                     "s1");
2521             assertShortcutIds(assertAllDynamicOrPinned(
2522                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2523                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2524                     "s1");
2525 
2526             assertShortcutIds(assertAllPinned(
2527                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2528                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2529                     "s1", "s2", "s3");
2530             assertShortcutIds(assertAllDynamic(
2531                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2532                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2533                     "s1");
2534             assertShortcutIds(assertAllDynamicOrPinned(
2535                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2536                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2537                     "s1", "s2", "s3");
2538 
2539             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2540             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_0,
2541                     ActivityNotFoundException.class);
2542             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_0,
2543                     ActivityNotFoundException.class);
2544 
2545             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2546             assertShortcutLaunchable(CALLING_PACKAGE_2, "s2", USER_0);
2547             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2548 
2549             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2550                     SecurityException.class);
2551             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2552                     SecurityException.class);
2553             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2554                     SecurityException.class);
2555             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2556                     SecurityException.class);
2557             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2558                     SecurityException.class);
2559             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2560                     SecurityException.class);
2561         });
2562         runWithCaller(LAUNCHER_1, USER_P0, () -> {
2563             assertShortcutIds(assertAllPinned(
2564                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2565                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2566                     "s2");
2567             assertShortcutIds(assertAllDynamic(
2568                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2569                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2570                     "s1");
2571             assertShortcutIds(assertAllDynamicOrPinned(
2572                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2573                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2574                     "s1", "s2");
2575 
2576             assertShortcutIds(assertAllPinned(
2577                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2578                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2579                     "s2", "s3");
2580             assertShortcutIds(assertAllDynamic(
2581                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2582                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2583                     "s1");
2584             assertShortcutIds(assertAllDynamicOrPinned(
2585                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2586                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2587                     "s1", "s2", "s3");
2588 
2589             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2590             assertShortcutLaunchable(CALLING_PACKAGE_1, "s2", USER_0);
2591             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_0,
2592                     ActivityNotFoundException.class);
2593 
2594             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2595             assertShortcutLaunchable(CALLING_PACKAGE_2, "s2", USER_0);
2596             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2597 
2598             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2599                     SecurityException.class);
2600             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2601                     SecurityException.class);
2602             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2603                     SecurityException.class);
2604             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2605                     SecurityException.class);
2606             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2607                     SecurityException.class);
2608             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2609                     SecurityException.class);
2610         });
2611         runWithCaller(LAUNCHER_2, USER_P0, () -> {
2612             assertShortcutIds(assertAllPinned(
2613                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2614                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2615                     "s3");
2616             assertShortcutIds(assertAllDynamic(
2617                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2618                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2619                     "s1");
2620             assertShortcutIds(assertAllDynamicOrPinned(
2621                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_1,
2622                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2623                     "s1", "s3");
2624 
2625             assertShortcutIds(assertAllPinned(
2626                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2627                     /* activity =*/ null, ShortcutQuery.FLAG_GET_PINNED), HANDLE_USER_0)),
2628                     "s3");
2629             assertShortcutIds(assertAllDynamic(
2630                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2631                     /* activity =*/ null, ShortcutQuery.FLAG_GET_DYNAMIC), HANDLE_USER_0)),
2632                     "s1");
2633             assertShortcutIds(assertAllDynamicOrPinned(
2634                     mLauncherApps.getShortcuts(buildQuery(/* time =*/ 0, CALLING_PACKAGE_2,
2635                     /* activity =*/ null, PIN_AND_DYNAMIC), HANDLE_USER_0)),
2636                     "s1", "s3");
2637 
2638             assertShortcutLaunchable(CALLING_PACKAGE_1, "s1", USER_0);
2639             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_0,
2640                     ActivityNotFoundException.class);
2641             assertShortcutLaunchable(CALLING_PACKAGE_1, "s3", USER_0);
2642 
2643             assertShortcutLaunchable(CALLING_PACKAGE_2, "s1", USER_0);
2644             assertStartShortcutThrowsException(CALLING_PACKAGE_2, "s2", USER_0,
2645                     ActivityNotFoundException.class);
2646             assertShortcutLaunchable(CALLING_PACKAGE_2, "s3", USER_0);
2647 
2648             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_10,
2649                     SecurityException.class);
2650             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s2", USER_10,
2651                     SecurityException.class);
2652             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s3", USER_10,
2653                     SecurityException.class);
2654             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s4", USER_10,
2655                     SecurityException.class);
2656             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s5", USER_10,
2657                     SecurityException.class);
2658             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s6", USER_10,
2659                     SecurityException.class);
2660         });
2661     }
2662 
testStartShortcut()2663     public void testStartShortcut() {
2664         // Create some shortcuts.
2665         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2666             final ShortcutInfo s1_1 = makeShortcut(
2667                     "s1",
2668                     "Title 1",
2669                     makeComponent(ShortcutActivity.class),
2670                     /* icon =*/ null,
2671                     new Intent[] {makeIntent(Intent.ACTION_ASSIST, ShortcutActivity2.class,
2672                             "key1", "val1", "nest", makeBundle("key", 123))
2673                             .setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK),
2674                     new Intent("act2").setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)},
2675                     /* rank */ 10);
2676 
2677             final ShortcutInfo s1_2 = makeShortcut(
2678                     "s2",
2679                     "Title 2",
2680             /* activity */ null,
2681             /* icon =*/ null,
2682                     makeIntent(Intent.ACTION_ASSIST, ShortcutActivity3.class),
2683             /* rank */ 12);
2684 
2685             final ShortcutInfo s1_3 = makeShortcut("s3");
2686 
2687             assertTrue(mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3)));
2688         });
2689 
2690         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
2691             final ShortcutInfo s2_1 = makeShortcut(
2692                     "s1",
2693                     "ABC",
2694                     makeComponent(ShortcutActivity.class),
2695                     /* icon =*/ null,
2696                     makeIntent(Intent.ACTION_ANSWER, ShortcutActivity.class,
2697                             "key1", "val1", "nest", makeBundle("key", 123)),
2698                     /* weight */ 10);
2699             assertTrue(mManager.setDynamicShortcuts(list(s2_1)));
2700         });
2701 
2702         // Pin some.
2703         runWithCaller(LAUNCHER_1, USER_0, () -> {
2704             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
2705                     list("s1", "s2"), getCallingUser());
2706 
2707             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
2708                     list("s1"), getCallingUser());
2709         });
2710 
2711         // Just to make it complicated, delete some.
2712         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2713             mManager.removeDynamicShortcuts(list("s2"));
2714         });
2715 
2716         runWithCaller(LAUNCHER_1, USER_0, () -> {
2717             final Intent[] intents = launchShortcutAndGetIntents(CALLING_PACKAGE_1, "s1", USER_0);
2718             assertEquals(ShortcutActivity2.class.getName(),
2719                     intents[0].getComponent().getClassName());
2720             assertEquals(Intent.ACTION_ASSIST,
2721                     intents[0].getAction());
2722             assertEquals(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK,
2723                     intents[0].getFlags());
2724 
2725             assertEquals("act2",
2726                     intents[1].getAction());
2727             assertEquals(Intent.FLAG_ACTIVITY_NO_ANIMATION,
2728                     intents[1].getFlags());
2729 
2730             assertEquals(
2731                     ShortcutActivity3.class.getName(),
2732                     launchShortcutAndGetIntent(CALLING_PACKAGE_1, "s2", USER_0)
2733                             .getComponent().getClassName());
2734             assertEquals(
2735                     ShortcutActivity.class.getName(),
2736                     launchShortcutAndGetIntent(CALLING_PACKAGE_2, "s1", USER_0)
2737                             .getComponent().getClassName());
2738 
2739             assertShortcutLaunchable(CALLING_PACKAGE_1, "s3", USER_0);
2740 
2741             assertShortcutNotLaunched("no-such-package", "s2", USER_0);
2742             assertShortcutNotLaunched(CALLING_PACKAGE_1, "xxxx", USER_0);
2743         });
2744 
2745         // LAUNCHER_1 is no longer the default launcher
2746         setDefaultLauncherChecker((pkg, userId) -> false);
2747 
2748         runWithCaller(LAUNCHER_1, USER_0, () -> {
2749             // Not the default launcher, but pinned shortcuts are still lauchable.
2750             final Intent[] intents = launchShortcutAndGetIntents(CALLING_PACKAGE_1, "s1", USER_0);
2751             assertEquals(ShortcutActivity2.class.getName(),
2752                     intents[0].getComponent().getClassName());
2753             assertEquals(Intent.ACTION_ASSIST,
2754                     intents[0].getAction());
2755             assertEquals(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK,
2756                     intents[0].getFlags());
2757 
2758             assertEquals("act2",
2759                     intents[1].getAction());
2760             assertEquals(Intent.FLAG_ACTIVITY_NO_ANIMATION,
2761                     intents[1].getFlags());
2762             assertEquals(
2763                     ShortcutActivity3.class.getName(),
2764                     launchShortcutAndGetIntent(CALLING_PACKAGE_1, "s2", USER_0)
2765                             .getComponent().getClassName());
2766             assertEquals(
2767                     ShortcutActivity.class.getName(),
2768                     launchShortcutAndGetIntent(CALLING_PACKAGE_2, "s1", USER_0)
2769                             .getComponent().getClassName());
2770 
2771             // Not pinned, so not lauchable.
2772         });
2773 
2774         // Test inner errors.
2775         runWithCaller(LAUNCHER_1, USER_0, () -> {
2776             // Not launchable.
2777             doReturn(ActivityManager.START_CLASS_NOT_FOUND)
2778                     .when(mMockActivityManagerInternal).startActivitiesAsPackage(
2779                             anyStringOrNull(), anyInt(),
2780                             anyOrNull(Intent[].class), anyOrNull(Bundle.class));
2781             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_0,
2782                     ActivityNotFoundException.class);
2783 
2784             // Still not launchable.
2785             doReturn(ActivityManager.START_CLASS_NOT_FOUND)
2786                     .when(mMockActivityManagerInternal)
2787                     .startActivitiesAsPackage(
2788                             anyStringOrNull(), anyInt(),
2789                             anyOrNull(Intent[].class), anyOrNull(Bundle.class));
2790             assertStartShortcutThrowsException(CALLING_PACKAGE_1, "s1", USER_0,
2791                     ActivityNotFoundException.class);
2792         });
2793 
2794 
2795         // TODO Check extra, etc
2796     }
2797 
testLauncherCallback()2798     public void testLauncherCallback() throws Throwable {
2799         // Disable throttling for this test.
2800         mService.updateConfigurationLocked(
2801                 ConfigConstants.KEY_MAX_UPDATES_PER_INTERVAL + "=99999999,"
2802                         + ConfigConstants.KEY_MAX_SHORTCUTS + "=99999999"
2803         );
2804 
2805         setCaller(LAUNCHER_1, USER_0);
2806 
2807         assertForLauncherCallback(mLauncherApps, () -> {
2808             runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2809                 assertTrue(mManager.setDynamicShortcuts(list(
2810                         makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
2811             });
2812         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
2813                 .haveIds("s1", "s2", "s3")
2814                 .areAllWithKeyFieldsOnly()
2815                 .areAllDynamic();
2816 
2817         // From different package.
2818         assertForLauncherCallback(mLauncherApps, () -> {
2819             runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
2820                 assertTrue(mManager.setDynamicShortcuts(list(
2821                         makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
2822             });
2823         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_2, HANDLE_USER_0)
2824                 .haveIds("s1", "s2", "s3")
2825                 .areAllWithKeyFieldsOnly()
2826                 .areAllDynamic();
2827 
2828         mRunningUsers.put(USER_10, true);
2829 
2830         // Different user, callback shouldn't be called.
2831         assertForLauncherCallback(mLauncherApps, () -> {
2832             runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
2833                 assertTrue(mManager.setDynamicShortcuts(list(
2834                         makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
2835             });
2836         }).assertNoCallbackCalled();
2837 
2838 
2839         // Test for addDynamicShortcuts.
2840         assertForLauncherCallback(mLauncherApps, () -> {
2841             runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2842                 assertTrue(mManager.addDynamicShortcuts(list(makeShortcut("s4"))));
2843             });
2844         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
2845                 .haveIds("s1", "s2", "s3", "s4")
2846                 .areAllWithKeyFieldsOnly()
2847                 .areAllDynamic();
2848 
2849         // Test for remove
2850         assertForLauncherCallback(mLauncherApps, () -> {
2851             runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2852                 mManager.removeDynamicShortcuts(list("s1"));
2853             });
2854         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
2855                 .haveIds("s2", "s3", "s4")
2856                 .areAllWithKeyFieldsOnly()
2857                 .areAllDynamic();
2858 
2859         // Test for update
2860         assertForLauncherCallback(mLauncherApps, () -> {
2861             runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2862                 assertTrue(mManager.updateShortcuts(list(
2863                         makeShortcut("s1"), makeShortcut("s2"))));
2864             });
2865         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
2866                 // All remaining shortcuts will be passed regardless of what's been updated.
2867                 .haveIds("s2", "s3", "s4")
2868                 .areAllWithKeyFieldsOnly()
2869                 .areAllDynamic();
2870 
2871         // Test for deleteAll
2872         assertForLauncherCallback(mLauncherApps, () -> {
2873             runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2874                 mManager.removeAllDynamicShortcuts();
2875             });
2876         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
2877                 .isEmpty();
2878 
2879         // Update package1 with manifest shortcuts
2880         assertForLauncherCallback(mLauncherApps, () -> {
2881             addManifestShortcutResource(
2882                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
2883                     R.xml.shortcut_2);
2884             updatePackageVersion(CALLING_PACKAGE_1, 1);
2885             mService.mPackageMonitor.onReceive(getTestContext(),
2886                     genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
2887         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
2888                 .areAllManifest()
2889                 .areAllWithKeyFieldsOnly()
2890                 .haveIds("ms1", "ms2");
2891 
2892         // Make sure pinned shortcuts are passed too.
2893         // 1. Add dynamic shortcuts.
2894         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
2895             assertTrue(mManager.setDynamicShortcuts(list(
2896                     makeShortcut("s1"), makeShortcut("s2"))));
2897         });
2898 
2899         // 2. Pin some.
2900         runWithCaller(LAUNCHER_1, UserHandle.USER_SYSTEM, () -> {
2901             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms2", "s2"), HANDLE_USER_0);
2902         });
2903         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
2904             assertWith(getCallerShortcuts())
2905                     .haveIds("ms1", "ms2", "s1", "s2")
2906                     .areAllEnabled()
2907 
2908                     .selectByIds("ms1", "ms2")
2909                     .areAllManifest()
2910 
2911                     .revertToOriginalList()
2912                     .selectByIds("s1", "s2")
2913                     .areAllDynamic()
2914                     ;
2915         });
2916 
2917         // 3 Update the app with no manifest shortcuts.  (Pinned one will survive.)
2918         addManifestShortcutResource(
2919                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
2920                 R.xml.shortcut_0);
2921         updatePackageVersion(CALLING_PACKAGE_1, 1);
2922         mService.mPackageMonitor.onReceive(getTestContext(),
2923                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
2924 
2925         assertForLauncherCallback(mLauncherApps, () -> {
2926             runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
2927                 mManager.removeDynamicShortcuts(list("s2"));
2928 
2929                 assertWith(getCallerShortcuts())
2930                         .haveIds("ms2", "s1", "s2")
2931 
2932                         .selectByIds("ms2")
2933                         .areAllNotManifest()
2934                         .areAllPinned()
2935                         .areAllImmutable()
2936                         .areAllDisabled()
2937 
2938                         .revertToOriginalList()
2939                         .selectByIds("s1")
2940                         .areAllDynamic()
2941                         .areAllNotPinned()
2942                         .areAllEnabled()
2943 
2944                         .revertToOriginalList()
2945                         .selectByIds("s2")
2946                         .areAllNotDynamic()
2947                         .areAllPinned()
2948                         .areAllEnabled()
2949                 ;
2950             });
2951         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
2952                 .haveIds("ms2", "s1", "s2")
2953                 .areAllWithKeyFieldsOnly();
2954 
2955         // Remove CALLING_PACKAGE_2
2956         assertForLauncherCallback(mLauncherApps, () -> {
2957             uninstallPackage(USER_0, CALLING_PACKAGE_2);
2958             mService.cleanUpPackageLocked(CALLING_PACKAGE_2, USER_0, USER_0,
2959                     /* appStillExists = */ false);
2960         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_2, HANDLE_USER_0)
2961                 .isEmpty();
2962     }
2963 
testLauncherCallback_crossProfile()2964     public void testLauncherCallback_crossProfile() throws Throwable {
2965         prepareCrossProfileDataSet();
2966 
2967         final Handler h = new Handler(Looper.getMainLooper());
2968 
2969         final LauncherApps.Callback c0_1 = mock(LauncherApps.Callback.class);
2970         final LauncherApps.Callback c0_2 = mock(LauncherApps.Callback.class);
2971         final LauncherApps.Callback c0_3 = mock(LauncherApps.Callback.class);
2972         final LauncherApps.Callback c0_4 = mock(LauncherApps.Callback.class);
2973 
2974         final LauncherApps.Callback cP0_1 = mock(LauncherApps.Callback.class);
2975         final LauncherApps.Callback cP1_1 = mock(LauncherApps.Callback.class);
2976         final LauncherApps.Callback c10_1 = mock(LauncherApps.Callback.class);
2977         final LauncherApps.Callback c10_2 = mock(LauncherApps.Callback.class);
2978         final LauncherApps.Callback c11_1 = mock(LauncherApps.Callback.class);
2979 
2980         final List<LauncherApps.Callback> all =
2981                 list(c0_1, c0_2, c0_3, c0_4, cP0_1, c10_1, c11_1);
2982 
2983         setDefaultLauncherChecker((pkg, userId) -> {
2984             switch (userId) {
2985                 case USER_0:
2986                     return LAUNCHER_2.equals(pkg);
2987                 case USER_P0:
2988                     return LAUNCHER_1.equals(pkg);
2989                 case USER_P1:
2990                     return LAUNCHER_1.equals(pkg);
2991                 case USER_10:
2992                     return LAUNCHER_1.equals(pkg);
2993                 case USER_11:
2994                     return LAUNCHER_1.equals(pkg);
2995                 default:
2996                     return false;
2997             }
2998         });
2999 
3000         runWithCaller(LAUNCHER_1, USER_0, () -> mLauncherApps.registerCallback(c0_1, h));
3001         runWithCaller(LAUNCHER_2, USER_0, () -> mLauncherApps.registerCallback(c0_2, h));
3002         runWithCaller(LAUNCHER_3, USER_0, () -> mLauncherApps.registerCallback(c0_3, h));
3003         runWithCaller(LAUNCHER_4, USER_0, () -> mLauncherApps.registerCallback(c0_4, h));
3004         runWithCaller(LAUNCHER_1, USER_P0, () -> mLauncherApps.registerCallback(cP0_1, h));
3005         runWithCaller(LAUNCHER_1, USER_P1, () -> mLauncherApps.registerCallback(cP1_1, h));
3006         runWithCaller(LAUNCHER_1, USER_10, () -> mLauncherApps.registerCallback(c10_1, h));
3007         runWithCaller(LAUNCHER_2, USER_10, () -> mLauncherApps.registerCallback(c10_2, h));
3008         runWithCaller(LAUNCHER_1, USER_11, () -> mLauncherApps.registerCallback(c11_1, h));
3009 
3010         // User 0.
3011 
3012         resetAll(all);
3013         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3014             mManager.removeDynamicShortcuts(list());
3015         });
3016         waitOnMainThread();
3017 
3018         assertCallbackNotReceived(c0_1);
3019         assertCallbackNotReceived(c0_3);
3020         assertCallbackNotReceived(c0_4);
3021         assertCallbackNotReceived(c10_1);
3022         assertCallbackNotReceived(c10_2);
3023         assertCallbackNotReceived(c11_1);
3024         assertCallbackReceived(c0_2, HANDLE_USER_0, CALLING_PACKAGE_1, "s1", "s2", "s3");
3025         assertCallbackReceived(cP0_1, HANDLE_USER_0, CALLING_PACKAGE_1, "s1", "s2", "s3", "s4");
3026         assertCallbackNotReceived(cP1_1);
3027 
3028         // User 0, different package.
3029 
3030         resetAll(all);
3031         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
3032             mManager.removeDynamicShortcuts(list());
3033         });
3034         waitOnMainThread();
3035 
3036         assertCallbackNotReceived(c0_1);
3037         assertCallbackNotReceived(c0_3);
3038         assertCallbackNotReceived(c0_4);
3039         assertCallbackNotReceived(c10_1);
3040         assertCallbackNotReceived(c10_2);
3041         assertCallbackNotReceived(c11_1);
3042         assertCallbackReceived(c0_2, HANDLE_USER_0, CALLING_PACKAGE_3, "s1", "s2", "s3", "s4");
3043         assertCallbackReceived(cP0_1, HANDLE_USER_0, CALLING_PACKAGE_3,
3044                 "s1", "s2", "s3", "s4", "s5", "s6");
3045         assertCallbackNotReceived(cP1_1);
3046 
3047         // Work profile.
3048         resetAll(all);
3049         runWithCaller(CALLING_PACKAGE_1, USER_P0, () -> {
3050             mManager.removeDynamicShortcuts(list());
3051         });
3052         waitOnMainThread();
3053 
3054         assertCallbackNotReceived(c0_1);
3055         assertCallbackNotReceived(c0_3);
3056         assertCallbackNotReceived(c0_4);
3057         assertCallbackNotReceived(c10_1);
3058         assertCallbackNotReceived(c10_2);
3059         assertCallbackNotReceived(c11_1);
3060         assertCallbackReceived(c0_2, HANDLE_USER_P0, CALLING_PACKAGE_1, "s1", "s2", "s3", "s5");
3061         assertCallbackReceived(cP0_1, HANDLE_USER_P0, CALLING_PACKAGE_1, "s1", "s2", "s3", "s4");
3062         assertCallbackNotReceived(cP1_1);
3063 
3064         // Normal secondary user.
3065         mRunningUsers.put(USER_10, true);
3066 
3067         resetAll(all);
3068         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
3069             mManager.removeDynamicShortcuts(list());
3070         });
3071         waitOnMainThread();
3072 
3073         assertCallbackNotReceived(c0_1);
3074         assertCallbackNotReceived(c0_2);
3075         assertCallbackNotReceived(c0_3);
3076         assertCallbackNotReceived(c0_4);
3077         assertCallbackNotReceived(cP0_1);
3078         assertCallbackNotReceived(c10_2);
3079         assertCallbackNotReceived(c11_1);
3080         assertCallbackReceived(c10_1, HANDLE_USER_10, CALLING_PACKAGE_1,
3081                 "x1", "x2", "x3", "x4", "x5");
3082         assertCallbackNotReceived(cP1_1);
3083     }
3084 
3085     // === Test for persisting ===
3086 
testSaveAndLoadUser_empty()3087     public void testSaveAndLoadUser_empty() {
3088         assertTrue(mManager.setDynamicShortcuts(list()));
3089 
3090         Log.i(TAG, "Saved state");
3091         dumpsysOnLogcat();
3092         dumpUserFile(0);
3093 
3094         // Restore.
3095         mService.saveDirtyInfo();
3096         initService();
3097 
3098         assertEquals(0, mManager.getDynamicShortcuts().size());
3099     }
3100 
3101     /**
3102      * Try save and load, also stop/start the user.
3103      */
testSaveAndLoadUser()3104     public void testSaveAndLoadUser() {
3105         // First, create some shortcuts and save.
3106         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
3107             final Icon icon1 = Icon.createWithResource(getTestContext(), R.drawable.black_64x16);
3108             final Icon icon2 = Icon.createWithBitmap(BitmapFactory.decodeResource(
3109                     getTestContext().getResources(), R.drawable.icon2));
3110 
3111             final ShortcutInfo si1 = makeShortcut(
3112                     "s1",
3113                     "title1-1",
3114                     makeComponent(ShortcutActivity.class),
3115                     icon1,
3116                     makeIntent(Intent.ACTION_ASSIST, ShortcutActivity2.class,
3117                             "key1", "val1", "nest", makeBundle("key", 123)),
3118                         /* weight */ 10);
3119 
3120             final ShortcutInfo si2 = makeShortcut(
3121                     "s2",
3122                     "title1-2",
3123                         /* activity */ null,
3124                     icon2,
3125                     makeIntent(Intent.ACTION_ASSIST, ShortcutActivity3.class),
3126                         /* weight */ 12);
3127 
3128             assertTrue(mManager.setDynamicShortcuts(list(si1, si2)));
3129 
3130             assertEquals(START_TIME + INTERVAL, mManager.getRateLimitResetTime());
3131             assertEquals(2, mManager.getRemainingCallCount());
3132         });
3133         runWithCaller(CALLING_PACKAGE_2, UserHandle.USER_SYSTEM, () -> {
3134             final Icon icon1 = Icon.createWithResource(getTestContext(), R.drawable.black_16x64);
3135             final Icon icon2 = Icon.createWithBitmap(BitmapFactory.decodeResource(
3136                     getTestContext().getResources(), R.drawable.icon2));
3137 
3138             final ShortcutInfo si1 = makeShortcut(
3139                     "s1",
3140                     "title2-1",
3141                     makeComponent(ShortcutActivity.class),
3142                     icon1,
3143                     makeIntent(Intent.ACTION_ASSIST, ShortcutActivity2.class,
3144                             "key1", "val1", "nest", makeBundle("key", 123)),
3145                         /* weight */ 10);
3146 
3147             final ShortcutInfo si2 = makeShortcut(
3148                     "s2",
3149                     "title2-2",
3150                         /* activity */ null,
3151                     icon2,
3152                     makeIntent(Intent.ACTION_ASSIST, ShortcutActivity3.class),
3153                         /* weight */ 12);
3154 
3155             assertTrue(mManager.setDynamicShortcuts(list(si1, si2)));
3156 
3157             assertEquals(START_TIME + INTERVAL, mManager.getRateLimitResetTime());
3158             assertEquals(2, mManager.getRemainingCallCount());
3159         });
3160 
3161         mRunningUsers.put(USER_10, true);
3162 
3163         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
3164             final Icon icon1 = Icon.createWithResource(getTestContext(), R.drawable.black_64x64);
3165             final Icon icon2 = Icon.createWithBitmap(BitmapFactory.decodeResource(
3166                     getTestContext().getResources(), R.drawable.icon2));
3167 
3168             final ShortcutInfo si1 = makeShortcut(
3169                     "s1",
3170                     "title10-1-1",
3171                     makeComponent(ShortcutActivity.class),
3172                     icon1,
3173                     makeIntent(Intent.ACTION_ASSIST, ShortcutActivity2.class,
3174                             "key1", "val1", "nest", makeBundle("key", 123)),
3175                         /* weight */ 10);
3176 
3177             final ShortcutInfo si2 = makeShortcut(
3178                     "s2",
3179                     "title10-1-2",
3180                         /* activity */ null,
3181                     icon2,
3182                     makeIntent(Intent.ACTION_ASSIST, ShortcutActivity3.class),
3183                         /* weight */ 12);
3184 
3185             assertTrue(mManager.setDynamicShortcuts(list(si1, si2)));
3186 
3187             assertEquals(START_TIME + INTERVAL, mManager.getRateLimitResetTime());
3188             assertEquals(2, mManager.getRemainingCallCount());
3189         });
3190 
3191         mService.getShortcutsForTest().get(UserHandle.USER_SYSTEM).setLauncher(
3192                 new ComponentName("pkg1", "class"));
3193 
3194         // Restore.
3195         mService.saveDirtyInfo();
3196         initService();
3197 
3198         // Before the load, the map should be empty.
3199         assertEquals(0, mService.getShortcutsForTest().size());
3200 
3201         // this will pre-load the per-user info.
3202         mService.handleUnlockUser(UserHandle.USER_SYSTEM);
3203 
3204         // Now it's loaded.
3205         assertEquals(1, mService.getShortcutsForTest().size());
3206 
3207         runWithCaller(CALLING_PACKAGE_1, UserHandle.USER_SYSTEM, () -> {
3208             assertShortcutIds(assertAllDynamic(assertAllHaveIntents(assertAllHaveIcon(
3209                     mManager.getDynamicShortcuts()))), "s1", "s2");
3210             assertEquals(2, mManager.getRemainingCallCount());
3211 
3212             assertEquals("title1-1", getCallerShortcut("s1").getTitle());
3213             assertEquals("title1-2", getCallerShortcut("s2").getTitle());
3214         });
3215         runWithCaller(CALLING_PACKAGE_2, UserHandle.USER_SYSTEM, () -> {
3216             assertShortcutIds(assertAllDynamic(assertAllHaveIntents(assertAllHaveIcon(
3217                     mManager.getDynamicShortcuts()))), "s1", "s2");
3218             assertEquals(2, mManager.getRemainingCallCount());
3219 
3220             assertEquals("title2-1", getCallerShortcut("s1").getTitle());
3221             assertEquals("title2-2", getCallerShortcut("s2").getTitle());
3222         });
3223 
3224         assertEquals("pkg1", mService.getShortcutsForTest().get(UserHandle.USER_SYSTEM)
3225                 .getLastKnownLauncher().getPackageName());
3226 
3227         // Start another user
3228         mService.handleUnlockUser(USER_10);
3229 
3230         // Now the size is 2.
3231         assertEquals(2, mService.getShortcutsForTest().size());
3232 
3233         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
3234             assertShortcutIds(assertAllDynamic(assertAllHaveIntents(assertAllHaveIcon(
3235                     mManager.getDynamicShortcuts()))), "s1", "s2");
3236             assertEquals(2, mManager.getRemainingCallCount());
3237 
3238             assertEquals("title10-1-1", getCallerShortcut("s1").getTitle());
3239             assertEquals("title10-1-2", getCallerShortcut("s2").getTitle());
3240         });
3241         assertNull(mService.getShortcutsForTest().get(USER_10).getLastKnownLauncher());
3242 
3243         // Try stopping the user
3244         mService.handleStopUser(USER_10);
3245 
3246         // Now it's unloaded.
3247         assertEquals(1, mService.getShortcutsForTest().size());
3248 
3249         // TODO Check all other fields
3250     }
3251 
testCleanupPackage()3252     public void testCleanupPackage() {
3253         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3254             assertTrue(mManager.setDynamicShortcuts(list(
3255                     makeShortcut("s0_1"))));
3256         });
3257         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
3258             assertTrue(mManager.setDynamicShortcuts(list(
3259                     makeShortcut("s0_2"))));
3260         });
3261         runWithCaller(LAUNCHER_1, USER_0, () -> {
3262             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s0_1"),
3263                     HANDLE_USER_0);
3264             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list("s0_2"),
3265                     HANDLE_USER_0);
3266         });
3267         runWithCaller(LAUNCHER_2, USER_0, () -> {
3268             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s0_1"),
3269                     HANDLE_USER_0);
3270             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list("s0_2"),
3271                     HANDLE_USER_0);
3272         });
3273 
3274         mRunningUsers.put(USER_10, true);
3275 
3276         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
3277             assertTrue(mManager.setDynamicShortcuts(list(
3278                     makeShortcut("s10_1"))));
3279         });
3280         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
3281             assertTrue(mManager.setDynamicShortcuts(list(
3282                     makeShortcut("s10_2"))));
3283         });
3284         runWithCaller(LAUNCHER_1, USER_10, () -> {
3285             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s10_1"),
3286                     HANDLE_USER_10);
3287             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list("s10_2"),
3288                     HANDLE_USER_10);
3289         });
3290         runWithCaller(LAUNCHER_2, USER_10, () -> {
3291             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s10_1"),
3292                     HANDLE_USER_10);
3293             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list("s10_2"),
3294                     HANDLE_USER_10);
3295         });
3296 
3297         // Remove all dynamic shortcuts; now all shortcuts are just pinned.
3298         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3299             mManager.removeAllDynamicShortcuts();
3300         });
3301         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
3302             mManager.removeAllDynamicShortcuts();
3303         });
3304         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
3305             mManager.removeAllDynamicShortcuts();
3306         });
3307         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
3308             mManager.removeAllDynamicShortcuts();
3309         });
3310 
3311 
3312         final SparseArray<ShortcutUser> users =  mService.getShortcutsForTest();
3313         assertEquals(2, users.size());
3314         assertEquals(USER_0, users.keyAt(0));
3315         assertEquals(USER_10, users.keyAt(1));
3316 
3317         final ShortcutUser user0 =  users.get(USER_0);
3318         final ShortcutUser user10 =  users.get(USER_10);
3319 
3320 
3321         // Check the registered packages.
3322         dumpsysOnLogcat();
3323         assertEquals(set(CALLING_PACKAGE_1, CALLING_PACKAGE_2),
3324                 hashSet(user0.getAllPackagesForTest().keySet()));
3325         assertEquals(set(CALLING_PACKAGE_1, CALLING_PACKAGE_2),
3326                 hashSet(user10.getAllPackagesForTest().keySet()));
3327         assertEquals(
3328                 set(PackageWithUser.of(USER_0, LAUNCHER_1),
3329                         PackageWithUser.of(USER_0, LAUNCHER_2)),
3330                 hashSet(user0.getAllLaunchersForTest().keySet()));
3331         assertEquals(
3332                 set(PackageWithUser.of(USER_10, LAUNCHER_1),
3333                         PackageWithUser.of(USER_10, LAUNCHER_2)),
3334                 hashSet(user10.getAllLaunchersForTest().keySet()));
3335         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_0),
3336                 "s0_1", "s0_2");
3337         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_0),
3338                 "s0_1", "s0_2");
3339         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_10),
3340                 "s10_1", "s10_2");
3341         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_10),
3342                 "s10_1", "s10_2");
3343         assertShortcutExists(CALLING_PACKAGE_1, "s0_1", USER_0);
3344         assertShortcutExists(CALLING_PACKAGE_2, "s0_2", USER_0);
3345         assertShortcutExists(CALLING_PACKAGE_1, "s10_1", USER_10);
3346         assertShortcutExists(CALLING_PACKAGE_2, "s10_2", USER_10);
3347 
3348         mService.saveDirtyInfo();
3349 
3350         // Nonexistent package.
3351         uninstallPackage(USER_0, "abc");
3352         mService.cleanUpPackageLocked("abc", USER_0, USER_0, /* appStillExists = */ false);
3353 
3354         // No changes.
3355         assertEquals(set(CALLING_PACKAGE_1, CALLING_PACKAGE_2),
3356                 hashSet(user0.getAllPackagesForTest().keySet()));
3357         assertEquals(set(CALLING_PACKAGE_1, CALLING_PACKAGE_2),
3358                 hashSet(user10.getAllPackagesForTest().keySet()));
3359         assertEquals(
3360                 set(PackageWithUser.of(USER_0, LAUNCHER_1),
3361                         PackageWithUser.of(USER_0, LAUNCHER_2)),
3362                 hashSet(user0.getAllLaunchersForTest().keySet()));
3363         assertEquals(
3364                 set(PackageWithUser.of(USER_10, LAUNCHER_1),
3365                         PackageWithUser.of(USER_10, LAUNCHER_2)),
3366                 hashSet(user10.getAllLaunchersForTest().keySet()));
3367         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_0),
3368                 "s0_1", "s0_2");
3369         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_0),
3370                 "s0_1", "s0_2");
3371         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_10),
3372                 "s10_1", "s10_2");
3373         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_10),
3374                 "s10_1", "s10_2");
3375         assertShortcutExists(CALLING_PACKAGE_1, "s0_1", USER_0);
3376         assertShortcutExists(CALLING_PACKAGE_2, "s0_2", USER_0);
3377         assertShortcutExists(CALLING_PACKAGE_1, "s10_1", USER_10);
3378         assertShortcutExists(CALLING_PACKAGE_2, "s10_2", USER_10);
3379 
3380         mService.saveDirtyInfo();
3381 
3382         // Remove a package.
3383         uninstallPackage(USER_0, CALLING_PACKAGE_1);
3384         mService.cleanUpPackageLocked(CALLING_PACKAGE_1, USER_0, USER_0,
3385                 /* appStillExists = */ false);
3386 
3387         assertEquals(set(CALLING_PACKAGE_2),
3388                 hashSet(user0.getAllPackagesForTest().keySet()));
3389         assertEquals(set(CALLING_PACKAGE_1, CALLING_PACKAGE_2),
3390                 hashSet(user10.getAllPackagesForTest().keySet()));
3391         assertEquals(
3392                 set(PackageWithUser.of(USER_0, LAUNCHER_1),
3393                         PackageWithUser.of(USER_0, LAUNCHER_2)),
3394                 hashSet(user0.getAllLaunchersForTest().keySet()));
3395         assertEquals(
3396                 set(PackageWithUser.of(USER_10, LAUNCHER_1),
3397                         PackageWithUser.of(USER_10, LAUNCHER_2)),
3398                 hashSet(user10.getAllLaunchersForTest().keySet()));
3399         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_0),
3400                 "s0_2");
3401         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_0),
3402                 "s0_2");
3403         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_10),
3404                 "s10_1", "s10_2");
3405         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_10),
3406                 "s10_1", "s10_2");
3407         assertShortcutNotExists(CALLING_PACKAGE_1, "s0_1", USER_0);
3408         assertShortcutExists(CALLING_PACKAGE_2, "s0_2", USER_0);
3409         assertShortcutExists(CALLING_PACKAGE_1, "s10_1", USER_10);
3410         assertShortcutExists(CALLING_PACKAGE_2, "s10_2", USER_10);
3411 
3412         mService.saveDirtyInfo();
3413 
3414         // Remove a launcher.
3415         uninstallPackage(USER_10, LAUNCHER_1);
3416         mService.cleanUpPackageLocked(LAUNCHER_1, USER_10, USER_10, /* appStillExists = */ false);
3417 
3418         assertEquals(set(CALLING_PACKAGE_2),
3419                 hashSet(user0.getAllPackagesForTest().keySet()));
3420         assertEquals(set(CALLING_PACKAGE_1, CALLING_PACKAGE_2),
3421                 hashSet(user10.getAllPackagesForTest().keySet()));
3422         assertEquals(
3423                 set(PackageWithUser.of(USER_0, LAUNCHER_1),
3424                         PackageWithUser.of(USER_0, LAUNCHER_2)),
3425                 hashSet(user0.getAllLaunchersForTest().keySet()));
3426         assertEquals(
3427                 set(PackageWithUser.of(USER_10, LAUNCHER_2)),
3428                 hashSet(user10.getAllLaunchersForTest().keySet()));
3429         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_0),
3430                 "s0_2");
3431         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_0),
3432                 "s0_2");
3433         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_10),
3434                 "s10_1", "s10_2");
3435         assertShortcutNotExists(CALLING_PACKAGE_1, "s0_1", USER_0);
3436         assertShortcutExists(CALLING_PACKAGE_2, "s0_2", USER_0);
3437         assertShortcutExists(CALLING_PACKAGE_1, "s10_1", USER_10);
3438         assertShortcutExists(CALLING_PACKAGE_2, "s10_2", USER_10);
3439 
3440         mService.saveDirtyInfo();
3441 
3442         // Remove a package.
3443         uninstallPackage(USER_10, CALLING_PACKAGE_2);
3444         mService.cleanUpPackageLocked(CALLING_PACKAGE_2, USER_10, USER_10,
3445                 /* appStillExists = */ false);
3446 
3447         assertEquals(set(CALLING_PACKAGE_2),
3448                 hashSet(user0.getAllPackagesForTest().keySet()));
3449         assertEquals(set(CALLING_PACKAGE_1),
3450                 hashSet(user10.getAllPackagesForTest().keySet()));
3451         assertEquals(
3452                 set(PackageWithUser.of(USER_0, LAUNCHER_1),
3453                         PackageWithUser.of(USER_0, LAUNCHER_2)),
3454                 hashSet(user0.getAllLaunchersForTest().keySet()));
3455         assertEquals(
3456                 set(PackageWithUser.of(USER_10, LAUNCHER_2)),
3457                 hashSet(user10.getAllLaunchersForTest().keySet()));
3458         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_0),
3459                 "s0_2");
3460         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_0),
3461                 "s0_2");
3462         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_10),
3463                 "s10_1");
3464         assertShortcutNotExists(CALLING_PACKAGE_1, "s0_1", USER_0);
3465         assertShortcutExists(CALLING_PACKAGE_2, "s0_2", USER_0);
3466         assertShortcutExists(CALLING_PACKAGE_1, "s10_1", USER_10);
3467         assertShortcutNotExists(CALLING_PACKAGE_2, "s10_2", USER_10);
3468 
3469         mService.saveDirtyInfo();
3470 
3471         // Remove the other launcher from user 10 too.
3472         uninstallPackage(USER_10, LAUNCHER_2);
3473         mService.cleanUpPackageLocked(LAUNCHER_2, USER_10, USER_10,
3474                 /* appStillExists = */ false);
3475 
3476         assertEquals(set(CALLING_PACKAGE_2),
3477                 hashSet(user0.getAllPackagesForTest().keySet()));
3478         assertEquals(set(CALLING_PACKAGE_1),
3479                 hashSet(user10.getAllPackagesForTest().keySet()));
3480         assertEquals(
3481                 set(PackageWithUser.of(USER_0, LAUNCHER_1),
3482                         PackageWithUser.of(USER_0, LAUNCHER_2)),
3483                 hashSet(user0.getAllLaunchersForTest().keySet()));
3484         assertEquals(
3485                 set(),
3486                 hashSet(user10.getAllLaunchersForTest().keySet()));
3487         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_0),
3488                 "s0_2");
3489         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_0),
3490                 "s0_2");
3491 
3492         // Note the pinned shortcuts on user-10 no longer referred, so they should both be removed.
3493         assertShortcutNotExists(CALLING_PACKAGE_1, "s0_1", USER_0);
3494         assertShortcutExists(CALLING_PACKAGE_2, "s0_2", USER_0);
3495         assertShortcutNotExists(CALLING_PACKAGE_1, "s10_1", USER_10);
3496         assertShortcutNotExists(CALLING_PACKAGE_2, "s10_2", USER_10);
3497 
3498         mService.saveDirtyInfo();
3499 
3500         // More remove.
3501         uninstallPackage(USER_10, CALLING_PACKAGE_1);
3502         mService.cleanUpPackageLocked(CALLING_PACKAGE_1, USER_10, USER_10,
3503                 /* appStillExists = */ false);
3504 
3505         assertEquals(set(CALLING_PACKAGE_2),
3506                 hashSet(user0.getAllPackagesForTest().keySet()));
3507         assertEquals(set(),
3508                 hashSet(user10.getAllPackagesForTest().keySet()));
3509         assertEquals(
3510                 set(PackageWithUser.of(USER_0, LAUNCHER_1),
3511                         PackageWithUser.of(USER_0, LAUNCHER_2)),
3512                 hashSet(user0.getAllLaunchersForTest().keySet()));
3513         assertEquals(set(),
3514                 hashSet(user10.getAllLaunchersForTest().keySet()));
3515         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_1, USER_0),
3516                 "s0_2");
3517         assertShortcutIds(getLauncherPinnedShortcuts(LAUNCHER_2, USER_0),
3518                 "s0_2");
3519 
3520         // Note the pinned shortcuts on user-10 no longer referred, so they should both be removed.
3521         assertShortcutNotExists(CALLING_PACKAGE_1, "s0_1", USER_0);
3522         assertShortcutExists(CALLING_PACKAGE_2, "s0_2", USER_0);
3523         assertShortcutNotExists(CALLING_PACKAGE_1, "s10_1", USER_10);
3524         assertShortcutNotExists(CALLING_PACKAGE_2, "s10_2", USER_10);
3525 
3526         mService.saveDirtyInfo();
3527     }
3528 
testCleanupPackage_republishManifests()3529     public void testCleanupPackage_republishManifests() {
3530         addManifestShortcutResource(
3531                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
3532                 R.xml.shortcut_2);
3533         updatePackageVersion(CALLING_PACKAGE_1, 1);
3534                 mService.mPackageMonitor.onReceive(getTestContext(),
3535                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
3536 
3537         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3538             assertTrue(mManager.setDynamicShortcuts(list(
3539                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
3540         });
3541         runWithCaller(LAUNCHER_1, USER_0, () -> {
3542             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
3543                     list("s2", "s3", "ms1", "ms2"), HANDLE_USER_0);
3544         });
3545 
3546         // Remove ms2 from manifest.
3547         addManifestShortcutResource(
3548                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
3549                 R.xml.shortcut_1);
3550         updatePackageVersion(CALLING_PACKAGE_1, 1);
3551                 mService.mPackageMonitor.onReceive(getTestContext(),
3552                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
3553 
3554         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3555             assertTrue(mManager.setDynamicShortcuts(list(
3556                     makeShortcut("s1"), makeShortcut("s2"))));
3557 
3558             // Make sure the shortcuts are in the intended state.
3559             assertWith(getCallerShortcuts())
3560                     .haveIds("ms1", "ms2", "s1", "s2", "s3")
3561 
3562                     .selectByIds("ms1")
3563                     .areAllManifest()
3564                     .areAllPinned()
3565 
3566                     .revertToOriginalList()
3567                     .selectByIds("ms2")
3568                     .areAllNotManifest()
3569                     .areAllPinned()
3570 
3571                     .revertToOriginalList()
3572                     .selectByIds("s1")
3573                     .areAllDynamic()
3574                     .areAllNotPinned()
3575 
3576                     .revertToOriginalList()
3577                     .selectByIds("s2")
3578                     .areAllDynamic()
3579                     .areAllPinned()
3580 
3581                     .revertToOriginalList()
3582                     .selectByIds("s3")
3583                     .areAllNotDynamic()
3584                     .areAllPinned();
3585         });
3586 
3587         // Clean up + re-publish manifests.
3588         mService.cleanUpPackageLocked(CALLING_PACKAGE_1, USER_0, USER_0,
3589                 /* appStillExists = */ true);
3590         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3591             assertWith(getCallerShortcuts())
3592                     .haveIds("ms1")
3593                     .areAllManifest();
3594         });
3595     }
3596 
testHandleGonePackage_crossProfile()3597     public void testHandleGonePackage_crossProfile() {
3598         // Create some shortcuts.
3599         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3600             assertTrue(mManager.setDynamicShortcuts(list(
3601                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
3602         });
3603         runWithCaller(CALLING_PACKAGE_1, USER_P0, () -> {
3604             assertTrue(mManager.setDynamicShortcuts(list(
3605                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
3606         });
3607         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
3608             assertTrue(mManager.setDynamicShortcuts(list(
3609                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
3610         });
3611 
3612         mRunningUsers.put(USER_10, true);
3613 
3614         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
3615             assertTrue(mManager.setDynamicShortcuts(list(
3616                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
3617         });
3618 
3619         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3620         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3621         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3622 
3623         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3624         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3625         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3626 
3627         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3628         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3629         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3630 
3631         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3632         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3633         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3634 
3635         // Pin some.
3636 
3637         runWithCaller(LAUNCHER_1, USER_0, () -> {
3638             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
3639                     list("s1"), HANDLE_USER_0);
3640 
3641             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
3642                     list("s2"), UserHandle.of(USER_P0));
3643 
3644             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
3645                     list("s3"), HANDLE_USER_0);
3646         });
3647 
3648         runWithCaller(LAUNCHER_1, USER_P0, () -> {
3649             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
3650                     list("s2"), HANDLE_USER_0);
3651 
3652             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
3653                     list("s3"), UserHandle.of(USER_P0));
3654 
3655             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2,
3656                     list("s1"), HANDLE_USER_0);
3657         });
3658 
3659         runWithCaller(LAUNCHER_1, USER_10, () -> {
3660             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
3661                     list("s3"), HANDLE_USER_10);
3662         });
3663 
3664         // Check the state.
3665 
3666         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3667         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3668         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3669 
3670         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3671         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3672         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3673 
3674         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3675         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3676         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3677 
3678         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3679         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3680         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3681 
3682         // Make sure all the information is persisted.
3683         mService.saveDirtyInfo();
3684         initService();
3685         mService.handleUnlockUser(USER_0);
3686         mService.handleUnlockUser(USER_P0);
3687         mService.handleUnlockUser(USER_10);
3688 
3689         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3690         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3691         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3692 
3693         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3694         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3695         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3696 
3697         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3698         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3699         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3700 
3701         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3702         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3703         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3704 
3705         // Start uninstalling.
3706         uninstallPackage(USER_10, LAUNCHER_1);
3707         mService.checkPackageChanges(USER_10);
3708 
3709         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3710         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3711         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3712 
3713         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3714         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3715         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3716 
3717         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3718         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3719         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3720 
3721         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3722         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3723         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3724 
3725         // Uninstall.
3726         uninstallPackage(USER_10, CALLING_PACKAGE_1);
3727         mService.checkPackageChanges(USER_10);
3728 
3729         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3730         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3731         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3732 
3733         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3734         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3735         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3736 
3737         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3738         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3739         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3740 
3741         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3742         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3743         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3744 
3745         uninstallPackage(USER_P0, LAUNCHER_1);
3746         mService.checkPackageChanges(USER_0);
3747 
3748         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3749         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3750         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3751 
3752         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3753         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3754         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3755 
3756         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3757         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3758         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3759 
3760         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3761         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3762         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3763 
3764         mService.checkPackageChanges(USER_P0);
3765 
3766         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3767         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3768         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3769 
3770         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3771         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3772         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3773 
3774         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3775         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3776         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3777 
3778         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3779         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3780         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3781 
3782         uninstallPackage(USER_P0, CALLING_PACKAGE_1);
3783 
3784         mService.saveDirtyInfo();
3785         initService();
3786         mService.handleUnlockUser(USER_0);
3787         mService.handleUnlockUser(USER_P0);
3788         mService.handleUnlockUser(USER_10);
3789 
3790         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3791         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3792         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3793 
3794         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3795         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3796         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3797 
3798         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3799         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3800         assertDynamicAndPinned(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3801 
3802         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3803         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3804         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3805 
3806         // Uninstall
3807         uninstallPackage(USER_0, LAUNCHER_1);
3808 
3809         mService.saveDirtyInfo();
3810         initService();
3811         mService.handleUnlockUser(USER_0);
3812         mService.handleUnlockUser(USER_P0);
3813         mService.handleUnlockUser(USER_10);
3814 
3815         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3816         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3817         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3818 
3819         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3820         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3821         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3822 
3823         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3824         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3825         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3826 
3827         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3828         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3829         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3830 
3831         uninstallPackage(USER_0, CALLING_PACKAGE_2);
3832 
3833         mService.saveDirtyInfo();
3834         initService();
3835         mService.handleUnlockUser(USER_0);
3836         mService.handleUnlockUser(USER_P0);
3837         mService.handleUnlockUser(USER_10);
3838 
3839         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_0));
3840         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_0));
3841         assertDynamicOnly(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_0));
3842 
3843         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_P0));
3844         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_P0));
3845         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_P0));
3846 
3847         assertNull(getPackageShortcut(CALLING_PACKAGE_2, "s1", USER_0));
3848         assertNull(getPackageShortcut(CALLING_PACKAGE_2, "s2", USER_0));
3849         assertNull(getPackageShortcut(CALLING_PACKAGE_2, "s3", USER_0));
3850 
3851         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s1", USER_10));
3852         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s2", USER_10));
3853         assertNull(getPackageShortcut(CALLING_PACKAGE_1, "s3", USER_10));
3854     }
3855 
checkCanRestoreTo(boolean expected, ShortcutPackageInfo spi, int version, String... signatures)3856     protected void checkCanRestoreTo(boolean expected, ShortcutPackageInfo spi,
3857             int version, String... signatures) {
3858         assertEquals(expected, spi.canRestoreTo(mService, genPackage(
3859                 "dummy", /* uid */ 0, version, signatures)));
3860     }
3861 
testCanRestoreTo()3862     public void testCanRestoreTo() {
3863         addPackage(CALLING_PACKAGE_1, CALLING_UID_1, 10, "sig1");
3864         addPackage(CALLING_PACKAGE_2, CALLING_UID_1, 10, "sig1", "sig2");
3865 
3866         final ShortcutPackageInfo spi1 = ShortcutPackageInfo.generateForInstalledPackageForTest(
3867                 mService, CALLING_PACKAGE_1, USER_0);
3868         final ShortcutPackageInfo spi2 = ShortcutPackageInfo.generateForInstalledPackageForTest(
3869                 mService, CALLING_PACKAGE_2, USER_0);
3870 
3871         checkCanRestoreTo(true, spi1, 10, "sig1");
3872         checkCanRestoreTo(true, spi1, 10, "x", "sig1");
3873         checkCanRestoreTo(true, spi1, 10, "sig1", "y");
3874         checkCanRestoreTo(true, spi1, 10, "x", "sig1", "y");
3875         checkCanRestoreTo(true, spi1, 11, "sig1");
3876 
3877         checkCanRestoreTo(false, spi1, 10 /* empty */);
3878         checkCanRestoreTo(false, spi1, 10, "x");
3879         checkCanRestoreTo(false, spi1, 10, "x", "y");
3880         checkCanRestoreTo(false, spi1, 10, "x");
3881         checkCanRestoreTo(false, spi1, 9, "sig1");
3882 
3883         checkCanRestoreTo(true, spi2, 10, "sig1", "sig2");
3884         checkCanRestoreTo(true, spi2, 10, "sig2", "sig1");
3885         checkCanRestoreTo(true, spi2, 10, "x", "sig1", "sig2");
3886         checkCanRestoreTo(true, spi2, 10, "x", "sig2", "sig1");
3887         checkCanRestoreTo(true, spi2, 10, "sig1", "sig2", "y");
3888         checkCanRestoreTo(true, spi2, 10, "sig2", "sig1", "y");
3889         checkCanRestoreTo(true, spi2, 10, "x", "sig1", "sig2", "y");
3890         checkCanRestoreTo(true, spi2, 10, "x", "sig2", "sig1", "y");
3891         checkCanRestoreTo(true, spi2, 11, "x", "sig2", "sig1", "y");
3892 
3893         checkCanRestoreTo(false, spi2, 10, "sig1", "sig2x");
3894         checkCanRestoreTo(false, spi2, 10, "sig2", "sig1x");
3895         checkCanRestoreTo(false, spi2, 10, "x", "sig1x", "sig2");
3896         checkCanRestoreTo(false, spi2, 10, "x", "sig2x", "sig1");
3897         checkCanRestoreTo(false, spi2, 10, "sig1", "sig2x", "y");
3898         checkCanRestoreTo(false, spi2, 10, "sig2", "sig1x", "y");
3899         checkCanRestoreTo(false, spi2, 10, "x", "sig1x", "sig2", "y");
3900         checkCanRestoreTo(false, spi2, 10, "x", "sig2x", "sig1", "y");
3901         checkCanRestoreTo(false, spi2, 11, "x", "sig2x", "sig1", "y");
3902     }
3903 
testHandlePackageDelete()3904     public void testHandlePackageDelete() {
3905         checkHandlePackageDeleteInner((userId, packageName) -> {
3906             uninstallPackage(userId, packageName);
3907             mService.mPackageMonitor.onReceive(getTestContext(),
3908                     genPackageDeleteIntent(packageName, userId));
3909         });
3910     }
3911 
testHandlePackageDisable()3912     public void testHandlePackageDisable() {
3913         checkHandlePackageDeleteInner((userId, packageName) -> {
3914             disablePackage(userId, packageName);
3915             mService.mPackageMonitor.onReceive(getTestContext(),
3916                     genPackageChangedIntent(packageName, userId));
3917         });
3918     }
3919 
checkHandlePackageDeleteInner(BiConsumer<Integer, String> remover)3920     private void checkHandlePackageDeleteInner(BiConsumer<Integer, String> remover) {
3921         final Icon bmp32x32 = Icon.createWithBitmap(BitmapFactory.decodeResource(
3922                 getTestContext().getResources(), R.drawable.black_32x32));
3923         setCaller(CALLING_PACKAGE_1, USER_0);
3924         assertTrue(mManager.addDynamicShortcuts(list(
3925                 makeShortcutWithIcon("s1", bmp32x32), makeShortcutWithIcon("s2", bmp32x32)
3926         )));
3927         // Also add a manifest shortcut, which should be removed too.
3928         addManifestShortcutResource(
3929                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
3930                 R.xml.shortcut_1);
3931         updatePackageVersion(CALLING_PACKAGE_1, 1);
3932                 mService.mPackageMonitor.onReceive(getTestContext(),
3933                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
3934         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
3935             assertWith(getCallerShortcuts())
3936                     .haveIds("s1", "s2", "ms1")
3937 
3938                     .selectManifest()
3939                     .haveIds("ms1");
3940         });
3941 
3942         setCaller(CALLING_PACKAGE_2, USER_0);
3943         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
3944 
3945         setCaller(CALLING_PACKAGE_3, USER_0);
3946         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
3947 
3948         mRunningUsers.put(USER_10, true);
3949 
3950         setCaller(CALLING_PACKAGE_1, USER_10);
3951         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
3952 
3953         setCaller(CALLING_PACKAGE_2, USER_10);
3954         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
3955 
3956         setCaller(CALLING_PACKAGE_3, USER_10);
3957         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
3958 
3959         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
3960         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
3961         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));
3962         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
3963         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
3964         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
3965 
3966         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
3967         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
3968         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
3969         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
3970         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
3971         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
3972 
3973         remover.accept(USER_0, CALLING_PACKAGE_1);
3974 
3975         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
3976         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
3977         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));
3978         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
3979         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
3980         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
3981 
3982         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
3983         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
3984         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
3985         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
3986         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
3987         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
3988 
3989         mRunningUsers.put(USER_10, true);
3990 
3991         remover.accept(USER_10, CALLING_PACKAGE_2);
3992 
3993         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
3994         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
3995         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));
3996         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
3997         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
3998         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
3999 
4000         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
4001         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
4002         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
4003         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
4004         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
4005         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
4006 
4007         mInjectedPackages.remove(CALLING_PACKAGE_1);
4008         mInjectedPackages.remove(CALLING_PACKAGE_3);
4009 
4010         mService.checkPackageChanges(USER_0);
4011 
4012         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
4013         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
4014         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));  // ---------------
4015         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
4016         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
4017         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
4018 
4019         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
4020         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
4021         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
4022         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
4023         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
4024         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
4025 
4026         mService.checkPackageChanges(USER_10);
4027 
4028         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
4029         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
4030         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));
4031         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
4032         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
4033         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
4034 
4035         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
4036         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
4037         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
4038         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
4039         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
4040         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
4041     }
4042 
4043     /** Almost ame as testHandlePackageDelete, except it doesn't uninstall packages. */
testHandlePackageClearData()4044     public void testHandlePackageClearData() {
4045         final Icon bmp32x32 = Icon.createWithBitmap(BitmapFactory.decodeResource(
4046                 getTestContext().getResources(), R.drawable.black_32x32));
4047         setCaller(CALLING_PACKAGE_1, USER_0);
4048         assertTrue(mManager.addDynamicShortcuts(list(
4049                 makeShortcutWithIcon("s1", bmp32x32), makeShortcutWithIcon("s2", bmp32x32)
4050         )));
4051 
4052         setCaller(CALLING_PACKAGE_2, USER_0);
4053         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
4054 
4055         setCaller(CALLING_PACKAGE_3, USER_0);
4056         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
4057 
4058         mRunningUsers.put(USER_10, true);
4059 
4060         setCaller(CALLING_PACKAGE_1, USER_10);
4061         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
4062 
4063         setCaller(CALLING_PACKAGE_2, USER_10);
4064         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
4065 
4066         setCaller(CALLING_PACKAGE_3, USER_10);
4067         assertTrue(mManager.addDynamicShortcuts(list(makeShortcutWithIcon("s1", bmp32x32))));
4068 
4069         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
4070         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
4071         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));
4072         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
4073         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
4074         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
4075 
4076         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
4077         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
4078         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
4079         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
4080         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
4081         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
4082 
4083                 mService.mPackageMonitor.onReceive(getTestContext(),
4084                 genPackageDataClear(CALLING_PACKAGE_1, USER_0));
4085 
4086         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
4087         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
4088         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));
4089         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
4090         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
4091         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
4092 
4093         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
4094         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
4095         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
4096         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
4097         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
4098         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
4099 
4100         mRunningUsers.put(USER_10, true);
4101 
4102                 mService.mPackageMonitor.onReceive(getTestContext(),
4103                 genPackageDataClear(CALLING_PACKAGE_2, USER_10));
4104 
4105         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_0));
4106         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_0));
4107         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_0));
4108         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, "s1", USER_10));
4109         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, "s1", USER_10));
4110         assertNotNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_3, "s1", USER_10));
4111 
4112         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_0));
4113         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_0));
4114         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_0));
4115         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_1, USER_10));
4116         assertFalse(bitmapDirectoryExists(CALLING_PACKAGE_2, USER_10));
4117         assertTrue(bitmapDirectoryExists(CALLING_PACKAGE_3, USER_10));
4118     }
4119 
testHandlePackageClearData_manifestRepublished()4120     public void testHandlePackageClearData_manifestRepublished() {
4121 
4122         mRunningUsers.put(USER_10, true);
4123 
4124         // Add two manifests and two dynamics.
4125         addManifestShortcutResource(
4126                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
4127                 R.xml.shortcut_2);
4128         updatePackageVersion(CALLING_PACKAGE_1, 1);
4129                 mService.mPackageMonitor.onReceive(getTestContext(),
4130                 genPackageAddIntent(CALLING_PACKAGE_1, USER_10));
4131 
4132         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4133             assertTrue(mManager.addDynamicShortcuts(list(
4134                     makeShortcut("s1"), makeShortcut("s2"))));
4135         });
4136         runWithCaller(LAUNCHER_1, USER_10, () -> {
4137             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms2", "s2"), HANDLE_USER_10);
4138         });
4139 
4140         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4141             assertWith(getCallerShortcuts())
4142                     .haveIds("ms1", "ms2", "s1", "s2")
4143                     .areAllEnabled()
4144 
4145                     .selectPinned()
4146                     .haveIds("ms2", "s2");
4147         });
4148 
4149         // Clear data
4150         mService.mPackageMonitor.onReceive(getTestContext(),
4151                 genPackageDataClear(CALLING_PACKAGE_1, USER_10));
4152 
4153         // Only manifest shortcuts will remain, and are no longer pinned.
4154         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4155             assertWith(getCallerShortcuts())
4156                     .haveIds("ms1", "ms2")
4157                     .areAllEnabled()
4158                     .areAllNotPinned();
4159         });
4160     }
4161 
testHandlePackageUpdate()4162     public void testHandlePackageUpdate() throws Throwable {
4163         // Set up shortcuts and launchers.
4164 
4165         final Icon res32x32 = Icon.createWithResource(getTestContext(), R.drawable.black_32x32);
4166         final Icon bmp32x32 = Icon.createWithBitmap(BitmapFactory.decodeResource(
4167                 getTestContext().getResources(), R.drawable.black_32x32));
4168 
4169         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4170             assertTrue(mManager.setDynamicShortcuts(list(
4171                     makeShortcut("s1"),
4172                     makeShortcutWithIcon("s2", res32x32),
4173                     makeShortcutWithIcon("s3", res32x32),
4174                     makeShortcutWithIcon("s4", bmp32x32))));
4175         });
4176         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4177             assertTrue(mManager.setDynamicShortcuts(list(
4178                     makeShortcut("s1"),
4179                     makeShortcutWithIcon("s2", bmp32x32))));
4180         });
4181         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
4182             assertTrue(mManager.setDynamicShortcuts(list(
4183                     makeShortcutWithIcon("s1", res32x32))));
4184         });
4185 
4186         mRunningUsers.put(USER_10, true);
4187 
4188         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4189             assertTrue(mManager.setDynamicShortcuts(list(
4190                     makeShortcutWithIcon("s1", res32x32),
4191                     makeShortcutWithIcon("s2", res32x32))));
4192         });
4193         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
4194             assertTrue(mManager.setDynamicShortcuts(list(
4195                     makeShortcutWithIcon("s1", bmp32x32),
4196                     makeShortcutWithIcon("s2", bmp32x32))));
4197         });
4198 
4199         LauncherApps.Callback c0 = mock(LauncherApps.Callback.class);
4200         LauncherApps.Callback c10 = mock(LauncherApps.Callback.class);
4201 
4202         runWithCaller(LAUNCHER_1, USER_0, () -> {
4203             mLauncherApps.registerCallback(c0, new Handler(Looper.getMainLooper()));
4204         });
4205         runWithCaller(LAUNCHER_1, USER_10, () -> {
4206             mLauncherApps.registerCallback(c10, new Handler(Looper.getMainLooper()));
4207         });
4208 
4209         mInjectedCurrentTimeMillis = START_TIME + 100;
4210 
4211         ArgumentCaptor<List> shortcuts;
4212 
4213         // Update the version info for package 1.
4214         reset(c0);
4215         reset(c10);
4216         updatePackageVersion(CALLING_PACKAGE_1, 1);
4217 
4218         // Then send the broadcast, to only user-0.
4219         mService.mPackageMonitor.onReceive(getTestContext(),
4220                 genPackageUpdateIntent(CALLING_PACKAGE_1, USER_0));
4221 
4222         waitOnMainThread();
4223 
4224         // User-0 should get the notification.
4225         shortcuts = ArgumentCaptor.forClass(List.class);
4226         verify(c0).onShortcutsChanged(
4227                 eq(CALLING_PACKAGE_1),
4228                 shortcuts.capture(),
4229                 eq(HANDLE_USER_0));
4230 
4231         // User-10 shouldn't yet get the notification.
4232         verify(c10, times(0)).onShortcutsChanged(
4233                 eq(CALLING_PACKAGE_1),
4234                 any(List.class),
4235                 any(UserHandle.class));
4236         assertShortcutIds(shortcuts.getValue(), "s1", "s2", "s3", "s4");
4237         assertEquals(START_TIME,
4238                 findShortcut(shortcuts.getValue(), "s1").getLastChangedTimestamp());
4239         assertEquals(START_TIME + 100,
4240                 findShortcut(shortcuts.getValue(), "s2").getLastChangedTimestamp());
4241         assertEquals(START_TIME + 100,
4242                 findShortcut(shortcuts.getValue(), "s3").getLastChangedTimestamp());
4243         assertEquals(START_TIME,
4244                 findShortcut(shortcuts.getValue(), "s4").getLastChangedTimestamp());
4245 
4246         // Next, send an unlock event on user-10.  Now we scan packages on this user and send a
4247         // notification to the launcher.
4248         mInjectedCurrentTimeMillis = START_TIME + 200;
4249 
4250         mRunningUsers.put(USER_10, true);
4251         mUnlockedUsers.put(USER_10, true);
4252 
4253         reset(c0);
4254         reset(c10);
4255         setPackageLastUpdateTime(CALLING_PACKAGE_1, mInjectedCurrentTimeMillis);
4256         mService.handleUnlockUser(USER_10);
4257         mService.checkPackageChanges(USER_10);
4258 
4259         waitOnMainThread();
4260 
4261         shortcuts = ArgumentCaptor.forClass(List.class);
4262         verify(c0, times(0)).onShortcutsChanged(
4263                 eq(CALLING_PACKAGE_1),
4264                 any(List.class),
4265                 any(UserHandle.class));
4266 
4267         verify(c10).onShortcutsChanged(
4268                 eq(CALLING_PACKAGE_1),
4269                 shortcuts.capture(),
4270                 eq(HANDLE_USER_10));
4271 
4272         assertShortcutIds(shortcuts.getValue(), "s1", "s2");
4273         assertEquals(START_TIME + 200,
4274                 findShortcut(shortcuts.getValue(), "s1").getLastChangedTimestamp());
4275         assertEquals(START_TIME + 200,
4276                 findShortcut(shortcuts.getValue(), "s2").getLastChangedTimestamp());
4277 
4278 
4279         // Do the same thing for package 2, which doesn't have resource icons.
4280         mInjectedCurrentTimeMillis = START_TIME + 300;
4281 
4282         reset(c0);
4283         reset(c10);
4284         updatePackageVersion(CALLING_PACKAGE_2, 10);
4285 
4286         // Then send the broadcast, to only user-0.
4287         mService.mPackageMonitor.onReceive(getTestContext(),
4288                 genPackageUpdateIntent(CALLING_PACKAGE_2, USER_0));
4289 
4290         waitOnMainThread();
4291 
4292         verify(c0, times(0)).onShortcutsChanged(
4293                 eq(CALLING_PACKAGE_1),
4294                 any(List.class),
4295                 any(UserHandle.class));
4296 
4297         verify(c10, times(0)).onShortcutsChanged(
4298                 eq(CALLING_PACKAGE_1),
4299                 any(List.class),
4300                 any(UserHandle.class));
4301 
4302         // Do the same thing for package 3
4303         mInjectedCurrentTimeMillis = START_TIME + 400;
4304 
4305         reset(c0);
4306         reset(c10);
4307         updatePackageVersion(CALLING_PACKAGE_3, 100);
4308 
4309         // Then send the broadcast, to only user-0.
4310         mService.mPackageMonitor.onReceive(getTestContext(),
4311                 genPackageUpdateIntent(CALLING_PACKAGE_3, USER_0));
4312         mService.checkPackageChanges(USER_10);
4313 
4314         waitOnMainThread();
4315 
4316         shortcuts = ArgumentCaptor.forClass(List.class);
4317         verify(c0).onShortcutsChanged(
4318                 eq(CALLING_PACKAGE_3),
4319                 shortcuts.capture(),
4320                 eq(HANDLE_USER_0));
4321 
4322         // User 10 doesn't have package 3, so no callback.
4323         verify(c10, times(0)).onShortcutsChanged(
4324                 eq(CALLING_PACKAGE_3),
4325                 any(List.class),
4326                 any(UserHandle.class));
4327 
4328         assertShortcutIds(shortcuts.getValue(), "s1");
4329         assertEquals(START_TIME + 400,
4330                 findShortcut(shortcuts.getValue(), "s1").getLastChangedTimestamp());
4331     }
4332 
4333     /**
4334      * Test the case where an updated app has resource IDs changed.
4335      */
testHandlePackageUpdate_resIdChanged()4336     public void testHandlePackageUpdate_resIdChanged() throws Exception {
4337         final Icon icon1 = Icon.createWithResource(getTestContext(), /* res ID */ 1000);
4338         final Icon icon2 = Icon.createWithResource(getTestContext(), /* res ID */ 1001);
4339 
4340         // Set up shortcuts.
4341         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4342             // Note resource strings are not officially supported (they're hidden), but
4343             // should work.
4344 
4345             final ShortcutInfo s1 = new ShortcutInfo.Builder(mClientContext)
4346                     .setId("s1")
4347                     .setActivity(makeComponent(ShortcutActivity.class))
4348                     .setIntent(new Intent(Intent.ACTION_VIEW))
4349                     .setIcon(icon1)
4350                     .setTitleResId(10000)
4351                     .setTextResId(10001)
4352                     .setDisabledMessageResId(10002)
4353                     .build();
4354 
4355             final ShortcutInfo s2 = new ShortcutInfo.Builder(mClientContext)
4356                     .setId("s2")
4357                     .setActivity(makeComponent(ShortcutActivity.class))
4358                     .setIntent(new Intent(Intent.ACTION_VIEW))
4359                     .setIcon(icon2)
4360                     .setTitleResId(20000)
4361                     .build();
4362 
4363             assertTrue(mManager.setDynamicShortcuts(list(s1, s2)));
4364         });
4365 
4366         // Verify.
4367         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4368             final ShortcutInfo s1 = getCallerShortcut("s1");
4369             final ShortcutInfo s2 = getCallerShortcut("s2");
4370 
4371             assertEquals(1000, s1.getIconResourceId());
4372             assertEquals(10000, s1.getTitleResId());
4373             assertEquals(10001, s1.getTextResId());
4374             assertEquals(10002, s1.getDisabledMessageResourceId());
4375 
4376             assertEquals(1001, s2.getIconResourceId());
4377             assertEquals(20000, s2.getTitleResId());
4378             assertEquals(0, s2.getTextResId());
4379             assertEquals(0, s2.getDisabledMessageResourceId());
4380         });
4381 
4382         mService.saveDirtyInfo();
4383         initService();
4384 
4385         // Set up the mock resources again, with an "adjustment".
4386         // When the package is updated, the service will fetch the updated res-IDs with res-names,
4387         // and the new IDs will have this offset.
4388         setUpAppResources(10);
4389 
4390         // Update the package.
4391         updatePackageVersion(CALLING_PACKAGE_1, 1);
4392                 mService.mPackageMonitor.onReceive(getTestContext(),
4393                 genPackageUpdateIntent(CALLING_PACKAGE_1, USER_0));
4394 
4395         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4396             final ShortcutInfo s1 = getCallerShortcut("s1");
4397             final ShortcutInfo s2 = getCallerShortcut("s2");
4398 
4399             assertEquals(1010, s1.getIconResourceId());
4400             assertEquals(10010, s1.getTitleResId());
4401             assertEquals(10011, s1.getTextResId());
4402             assertEquals(10012, s1.getDisabledMessageResourceId());
4403 
4404             assertEquals(1011, s2.getIconResourceId());
4405             assertEquals(20010, s2.getTitleResId());
4406             assertEquals(0, s2.getTextResId());
4407             assertEquals(0, s2.getDisabledMessageResourceId());
4408         });
4409     }
4410 
testHandlePackageUpdate_systemAppUpdate()4411     public void testHandlePackageUpdate_systemAppUpdate() {
4412 
4413         // Package1 is a system app.  Package 2 is not a system app, so it's not scanned
4414         // in this test at all.
4415         mSystemPackages.add(CALLING_PACKAGE_1);
4416 
4417         // Initial state: no shortcuts.
4418         mService.checkPackageChanges(USER_0);
4419 
4420         assertEquals(mInjectedCurrentTimeMillis,
4421                 mService.getUserShortcutsLocked(USER_0).getLastAppScanTime());
4422         assertEquals(mInjectedBuildFingerprint,
4423                 mService.getUserShortcutsLocked(USER_0).getLastAppScanOsFingerprint());
4424 
4425         // They have no shortcuts.
4426         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4427             assertWith(getCallerShortcuts())
4428                     .isEmpty();
4429         });
4430 
4431         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4432             assertWith(getCallerShortcuts())
4433                     .isEmpty();
4434         });
4435 
4436         // Next.
4437         // Update the packages -- now they have 1 manifest shortcut.
4438         // But checkPackageChanges() don't notice it, since their version code / timestamp haven't
4439         // changed.
4440         addManifestShortcutResource(
4441                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
4442                 R.xml.shortcut_1);
4443         addManifestShortcutResource(
4444                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
4445                 R.xml.shortcut_1);
4446         mInjectedCurrentTimeMillis += 1000;
4447         mService.checkPackageChanges(USER_0);
4448 
4449         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4450             assertWith(getCallerShortcuts())
4451                     .isEmpty();
4452         });
4453         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4454             assertWith(getCallerShortcuts())
4455                     .isEmpty();
4456         });
4457 
4458         // Next.
4459         // Update the build finger print.  All apps will be scanned now.
4460         mInjectedBuildFingerprint = "update1";
4461         mInjectedCurrentTimeMillis += 1000;
4462         mService.checkPackageChanges(USER_0);
4463 
4464         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4465             assertWith(getCallerShortcuts())
4466                     .haveIds("ms1");
4467         });
4468         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4469             assertWith(getCallerShortcuts())
4470                     .haveIds("ms1");
4471         });
4472 
4473         // Next.
4474         // Update manifest shortcuts.
4475         addManifestShortcutResource(
4476                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
4477                 R.xml.shortcut_2);
4478         addManifestShortcutResource(
4479                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
4480                 R.xml.shortcut_2);
4481         mInjectedCurrentTimeMillis += 1000;
4482         mService.checkPackageChanges(USER_0);
4483 
4484         // Fingerprint hasn't changed, so there packages weren't scanned.
4485         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4486             assertWith(getCallerShortcuts())
4487                     .haveIds("ms1");
4488         });
4489         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4490             assertWith(getCallerShortcuts())
4491                     .haveIds("ms1");
4492         });
4493 
4494         // Update the fingerprint.  CALLING_PACKAGE_1's version code hasn't changed, but we scan
4495         // all apps anyway.
4496         mInjectedBuildFingerprint = "update2";
4497         mInjectedCurrentTimeMillis += 1000;
4498         mService.checkPackageChanges(USER_0);
4499 
4500         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4501             assertWith(getCallerShortcuts())
4502                     .haveIds("ms1", "ms2");
4503         });
4504         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4505             assertWith(getCallerShortcuts())
4506                     .haveIds("ms1", "ms2");
4507         });
4508 
4509         // Make sure getLastAppScanTime / getLastAppScanOsFingerprint are persisted.
4510         initService();
4511         assertEquals(mInjectedCurrentTimeMillis,
4512                 mService.getUserShortcutsLocked(USER_0).getLastAppScanTime());
4513         assertEquals(mInjectedBuildFingerprint,
4514                 mService.getUserShortcutsLocked(USER_0).getLastAppScanOsFingerprint());
4515     }
4516 
testHandlePackageChanged()4517     public void testHandlePackageChanged() {
4518         final ComponentName ACTIVITY1 = new ComponentName(CALLING_PACKAGE_1, "act1");
4519         final ComponentName ACTIVITY2 = new ComponentName(CALLING_PACKAGE_1, "act2");
4520 
4521         addManifestShortcutResource(ACTIVITY1, R.xml.shortcut_1);
4522         addManifestShortcutResource(ACTIVITY2, R.xml.shortcut_1_alt);
4523 
4524         mRunningUsers.put(USER_10, true);
4525 
4526         updatePackageVersion(CALLING_PACKAGE_1, 1);
4527                 mService.mPackageMonitor.onReceive(getTestContext(),
4528                 genPackageAddIntent(CALLING_PACKAGE_1, USER_10));
4529 
4530         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4531             assertTrue(mManager.addDynamicShortcuts(list(
4532                     makeShortcutWithActivity("s1", ACTIVITY1),
4533                     makeShortcutWithActivity("s2", ACTIVITY2)
4534             )));
4535         });
4536         runWithCaller(LAUNCHER_1, USER_10, () -> {
4537             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms1-alt", "s2"), HANDLE_USER_10);
4538         });
4539 
4540         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4541             assertWith(getCallerShortcuts())
4542                     .haveIds("ms1", "ms1-alt", "s1", "s2")
4543                     .areAllEnabled()
4544 
4545                     .selectPinned()
4546                     .haveIds("ms1-alt", "s2")
4547 
4548                     .revertToOriginalList()
4549                     .selectByIds("ms1", "s1")
4550                     .areAllWithActivity(ACTIVITY1)
4551 
4552                     .revertToOriginalList()
4553                     .selectByIds("ms1-alt", "s2")
4554                     .areAllWithActivity(ACTIVITY2)
4555                     ;
4556         });
4557 
4558         // First, no changes.
4559                 mService.mPackageMonitor.onReceive(getTestContext(),
4560                 genPackageChangedIntent(CALLING_PACKAGE_1, USER_10));
4561 
4562         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4563             assertWith(getCallerShortcuts())
4564                     .haveIds("ms1", "ms1-alt", "s1", "s2")
4565                     .areAllEnabled()
4566 
4567                     .selectPinned()
4568                     .haveIds("ms1-alt", "s2")
4569 
4570                     .revertToOriginalList()
4571                     .selectByIds("ms1", "s1")
4572                     .areAllWithActivity(ACTIVITY1)
4573 
4574                     .revertToOriginalList()
4575                     .selectByIds("ms1-alt", "s2")
4576                     .areAllWithActivity(ACTIVITY2)
4577             ;
4578         });
4579 
4580         // Disable activity 1
4581         mEnabledActivityChecker = (activity, userId) -> !ACTIVITY1.equals(activity);
4582                 mService.mPackageMonitor.onReceive(getTestContext(),
4583                 genPackageChangedIntent(CALLING_PACKAGE_1, USER_10));
4584 
4585         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4586             assertWith(getCallerShortcuts())
4587                     .haveIds("ms1-alt", "s2")
4588                     .areAllEnabled()
4589 
4590                     .selectPinned()
4591                     .haveIds("ms1-alt", "s2")
4592 
4593                     .revertToOriginalList()
4594                     .selectByIds("ms1-alt", "s2")
4595                     .areAllWithActivity(ACTIVITY2)
4596             ;
4597         });
4598 
4599         // Re-enable activity 1.
4600         // Manifest shortcuts will be re-published, but dynamic ones are not.
4601         mEnabledActivityChecker = (activity, userId) -> true;
4602                 mService.mPackageMonitor.onReceive(getTestContext(),
4603                 genPackageChangedIntent(CALLING_PACKAGE_1, USER_10));
4604 
4605         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4606             assertWith(getCallerShortcuts())
4607                     .haveIds("ms1", "ms1-alt", "s2")
4608                     .areAllEnabled()
4609 
4610                     .selectPinned()
4611                     .haveIds("ms1-alt", "s2")
4612 
4613                     .revertToOriginalList()
4614                     .selectByIds("ms1")
4615                     .areAllWithActivity(ACTIVITY1)
4616 
4617                     .revertToOriginalList()
4618                     .selectByIds("ms1-alt", "s2")
4619                     .areAllWithActivity(ACTIVITY2)
4620                     ;
4621         });
4622 
4623         // Disable activity 2
4624         // Because "ms1-alt" and "s2" are both pinned, they will remain, but disabled.
4625         mEnabledActivityChecker = (activity, userId) -> !ACTIVITY2.equals(activity);
4626                 mService.mPackageMonitor.onReceive(getTestContext(),
4627                 genPackageChangedIntent(CALLING_PACKAGE_1, USER_10));
4628 
4629         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
4630             assertWith(getCallerShortcuts())
4631                     .haveIds("ms1", "ms1-alt", "s2")
4632 
4633                     .selectDynamic().isEmpty().revertToOriginalList() // no dynamics.
4634 
4635                     .selectPinned()
4636                     .haveIds("ms1-alt", "s2")
4637                     .areAllDisabled()
4638 
4639                     .revertToOriginalList()
4640                     .selectByIds("ms1")
4641                     .areAllWithActivity(ACTIVITY1)
4642                     .areAllEnabled()
4643             ;
4644         });
4645     }
4646 
testHandlePackageUpdate_activityNoLongerMain()4647     public void testHandlePackageUpdate_activityNoLongerMain() throws Throwable {
4648         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4649             assertTrue(mManager.setDynamicShortcuts(list(
4650                     makeShortcutWithActivity("s1a",
4651                             new ComponentName(getCallingPackage(), "act1")),
4652                     makeShortcutWithActivity("s1b",
4653                             new ComponentName(getCallingPackage(), "act1")),
4654                     makeShortcutWithActivity("s2a",
4655                             new ComponentName(getCallingPackage(), "act2")),
4656                     makeShortcutWithActivity("s2b",
4657                             new ComponentName(getCallingPackage(), "act2")),
4658                     makeShortcutWithActivity("s3a",
4659                             new ComponentName(getCallingPackage(), "act3")),
4660                     makeShortcutWithActivity("s3b",
4661                             new ComponentName(getCallingPackage(), "act3"))
4662             )));
4663             assertWith(getCallerShortcuts())
4664                     .haveIds("s1a", "s1b", "s2a", "s2b", "s3a", "s3b")
4665                     .areAllDynamic();
4666         });
4667         runWithCaller(LAUNCHER_1, USER_0, () -> {
4668             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
4669                     list("s1b", "s2b", "s3b"),
4670                     HANDLE_USER_0);
4671         });
4672         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4673             assertWith(getCallerShortcuts())
4674                     .haveIds("s1a", "s1b", "s2a", "s2b", "s3a", "s3b")
4675                     .areAllDynamic()
4676 
4677                     .selectByIds("s1b", "s2b", "s3b")
4678                     .areAllPinned();
4679         });
4680 
4681         // Update the app and act2 and act3 are no longer main.
4682         mMainActivityChecker = (activity, userId) -> {
4683             return activity.getClassName().equals("act1");
4684         };
4685 
4686         setCaller(LAUNCHER_1, USER_0);
4687         assertForLauncherCallback(mLauncherApps, () -> {
4688             updatePackageVersion(CALLING_PACKAGE_1, 1);
4689                     mService.mPackageMonitor.onReceive(getTestContext(),
4690                     genPackageUpdateIntent(CALLING_PACKAGE_1, USER_0));
4691         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
4692                 // Make sure the launcher gets callbacks.
4693                 .haveIds("s1a", "s1b", "s2b", "s3b")
4694                 .areAllWithKeyFieldsOnly();
4695 
4696         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4697             // s2a and s3a are gone, but s2b and s3b will remain because they're pinned, and
4698             // disabled.
4699             assertWith(getCallerShortcuts())
4700                     .haveIds("s1a", "s1b", "s2b", "s3b")
4701 
4702                     .selectByIds("s1a", "s1b")
4703                     .areAllDynamic()
4704                     .areAllEnabled()
4705 
4706                     .revertToOriginalList()
4707                     .selectByIds("s2b", "s3b")
4708                     .areAllNotDynamic()
4709                     .areAllDisabled()
4710                     .areAllPinned()
4711                     ;
4712         });
4713     }
4714 
prepareForBackupTest()4715     protected void prepareForBackupTest() {
4716 
4717         prepareCrossProfileDataSet();
4718 
4719         backupAndRestore();
4720     }
4721 
4722     /**
4723      * Make sure the backup data doesn't have the following information:
4724      * - Launchers on other users.
4725      * - Non-backup app information.
4726      *
4727      * But restores all other infomation.
4728      *
4729      * It also omits the following pieces of information, but that's tested in
4730      * {@link ShortcutManagerTest2#testShortcutInfoSaveAndLoad_forBackup}.
4731      * - Unpinned dynamic shortcuts
4732      * - Bitmaps
4733      */
testBackupAndRestore()4734     public void testBackupAndRestore() {
4735         prepareForBackupTest();
4736 
4737         checkBackupAndRestore_success();
4738     }
4739 
testBackupAndRestore_backupRestoreTwice()4740     public void testBackupAndRestore_backupRestoreTwice() {
4741         prepareForBackupTest();
4742 
4743         // Note doing a backup & restore again here shouldn't affect the result.
4744         dumpsysOnLogcat("Before second backup");
4745 
4746         backupAndRestore();
4747 
4748         dumpsysOnLogcat("After second backup");
4749 
4750         checkBackupAndRestore_success();
4751     }
4752 
testBackupAndRestore_backupRestoreMultiple()4753     public void testBackupAndRestore_backupRestoreMultiple() {
4754         prepareForBackupTest();
4755 
4756         // Note doing a backup & restore again here shouldn't affect the result.
4757         backupAndRestore();
4758 
4759         // This also shouldn't affect the result.
4760         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4761             assertTrue(mManager.setDynamicShortcuts(list(
4762                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"),
4763                     makeShortcut("s4"), makeShortcut("s5"), makeShortcut("s6"))));
4764         });
4765 
4766         backupAndRestore();
4767 
4768         checkBackupAndRestore_success();
4769     }
4770 
testBackupAndRestore_restoreToNewVersion()4771     public void testBackupAndRestore_restoreToNewVersion() {
4772         prepareForBackupTest();
4773 
4774         // Note doing a backup & restore again here shouldn't affect the result.
4775         backupAndRestore();
4776 
4777         addPackage(CALLING_PACKAGE_1, CALLING_UID_1, 2);
4778         addPackage(LAUNCHER_1, LAUNCHER_UID_1, 5);
4779 
4780         checkBackupAndRestore_success();
4781     }
4782 
testBackupAndRestore_restoreToSuperSetSignatures()4783     public void testBackupAndRestore_restoreToSuperSetSignatures() {
4784         prepareForBackupTest();
4785 
4786         // Note doing a backup & restore again here shouldn't affect the result.
4787         backupAndRestore();
4788 
4789         // Change package signatures.
4790         addPackage(CALLING_PACKAGE_1, CALLING_UID_1, 1, "sigx", CALLING_PACKAGE_1);
4791         addPackage(LAUNCHER_1, LAUNCHER_UID_1, 4, LAUNCHER_1, "sigy");
4792 
4793         checkBackupAndRestore_success();
4794     }
4795 
checkBackupAndRestore_success()4796     protected void checkBackupAndRestore_success() {
4797         // Make sure non-system user is not restored.
4798         final ShortcutUser userP0 = mService.getUserShortcutsLocked(USER_P0);
4799         assertEquals(0, userP0.getAllPackagesForTest().size());
4800         assertEquals(0, userP0.getAllLaunchersForTest().size());
4801 
4802         // Make sure only "allowBackup" apps are restored, and are shadow.
4803         final ShortcutUser user0 = mService.getUserShortcutsLocked(USER_0);
4804         assertExistsAndShadow(user0.getAllPackagesForTest().get(CALLING_PACKAGE_1));
4805         assertExistsAndShadow(user0.getAllPackagesForTest().get(CALLING_PACKAGE_2));
4806         assertExistsAndShadow(user0.getAllLaunchersForTest().get(
4807                 PackageWithUser.of(USER_0, LAUNCHER_1)));
4808         assertExistsAndShadow(user0.getAllLaunchersForTest().get(
4809                 PackageWithUser.of(USER_0, LAUNCHER_2)));
4810 
4811         assertNull(user0.getAllPackagesForTest().get(CALLING_PACKAGE_3));
4812         assertNull(user0.getAllLaunchersForTest().get(PackageWithUser.of(USER_0, LAUNCHER_3)));
4813         assertNull(user0.getAllLaunchersForTest().get(PackageWithUser.of(USER_P0, LAUNCHER_1)));
4814 
4815         installPackage(USER_0, CALLING_PACKAGE_1);
4816         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4817             assertWith(getCallerVisibleShortcuts())
4818                     .selectDynamic()
4819                     .isEmpty()
4820 
4821                     .revertToOriginalList()
4822                     .selectPinned()
4823                     .haveIds("s1", "s2");
4824         });
4825 
4826         installPackage(USER_0, LAUNCHER_1);
4827         runWithCaller(LAUNCHER_1, USER_0, () -> {
4828             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
4829                     .areAllPinned()
4830                     .haveIds("s1");
4831 
4832             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
4833                     .isEmpty();
4834 
4835             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
4836                     .isEmpty();
4837 
4838             assertWith(mLauncherApps.getShortcuts(QUERY_ALL, HANDLE_USER_P0))
4839                     .isEmpty();
4840         });
4841 
4842         installPackage(USER_0, CALLING_PACKAGE_2);
4843         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4844             assertWith(getCallerVisibleShortcuts())
4845                     .selectDynamic()
4846                     .isEmpty()
4847 
4848                     .revertToOriginalList()
4849                     .selectPinned()
4850                     .haveIds("s1", "s2", "s3");
4851         });
4852 
4853         runWithCaller(LAUNCHER_1, USER_0, () -> {
4854             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
4855                     .areAllPinned()
4856                     .haveIds("s1");
4857 
4858             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
4859                     .areAllPinned()
4860                     .haveIds("s1", "s2");
4861 
4862             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
4863                     .isEmpty();
4864 
4865             assertWith(mLauncherApps.getShortcuts(QUERY_ALL, HANDLE_USER_P0))
4866                     .isEmpty();
4867         });
4868 
4869         // 3 shouldn't be backed up, so no pinned shortcuts.
4870         installPackage(USER_0, CALLING_PACKAGE_3);
4871         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
4872             assertWith(getCallerVisibleShortcuts())
4873                     .isEmpty();
4874         });
4875 
4876         // Launcher on a different profile shouldn't be restored.
4877         runWithCaller(LAUNCHER_1, USER_P0, () -> {
4878             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
4879                     .isEmpty();
4880             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
4881                     .isEmpty();
4882             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
4883                     .isEmpty();
4884         });
4885 
4886         // Package on a different profile, no restore.
4887         installPackage(USER_P0, CALLING_PACKAGE_1);
4888         runWithCaller(CALLING_PACKAGE_1, USER_P0, () -> {
4889             assertWith(getCallerVisibleShortcuts())
4890                     .isEmpty();
4891         });
4892 
4893         // Restore launcher 2 on user 0.
4894         installPackage(USER_0, LAUNCHER_2);
4895         runWithCaller(LAUNCHER_2, USER_0, () -> {
4896             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
4897                     .areAllPinned()
4898                     .haveIds("s2");
4899 
4900             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
4901                     .areAllPinned()
4902                     .haveIds("s2", "s3");
4903 
4904             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
4905                     .isEmpty();
4906 
4907             assertWith(mLauncherApps.getShortcuts(QUERY_ALL, HANDLE_USER_P0))
4908                     .isEmpty();
4909         });
4910 
4911 
4912         // Restoration of launcher2 shouldn't affect other packages; so do the same checks and
4913         // make sure they still have the same result.
4914         installPackage(USER_0, CALLING_PACKAGE_1);
4915         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4916             assertWith(getCallerVisibleShortcuts())
4917                     .areAllPinned()
4918                     .haveIds("s1", "s2");
4919         });
4920 
4921         installPackage(USER_0, LAUNCHER_1);
4922         runWithCaller(LAUNCHER_1, USER_0, () -> {
4923             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
4924                     .areAllPinned()
4925                     .haveIds("s1");
4926 
4927             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
4928                     .areAllPinned()
4929                     .haveIds("s1", "s2");
4930 
4931             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
4932                     .isEmpty();
4933 
4934             assertWith(mLauncherApps.getShortcuts(QUERY_ALL, HANDLE_USER_P0))
4935                     .isEmpty();
4936         });
4937 
4938         installPackage(USER_0, CALLING_PACKAGE_2);
4939         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4940             assertWith(getCallerVisibleShortcuts())
4941                     .areAllPinned()
4942                     .haveIds("s1", "s2", "s3");
4943         });
4944     }
4945 
testBackupAndRestore_publisherLowerVersion()4946     public void testBackupAndRestore_publisherLowerVersion() {
4947         prepareForBackupTest();
4948 
4949         // Note doing a backup & restore again here shouldn't affect the result.
4950         backupAndRestore();
4951 
4952         addPackage(CALLING_PACKAGE_1, CALLING_UID_1, 0); // Lower version
4953 
4954         checkBackupAndRestore_publisherNotRestored();
4955     }
4956 
testBackupAndRestore_publisherWrongSignature()4957     public void testBackupAndRestore_publisherWrongSignature() {
4958         prepareForBackupTest();
4959 
4960         // Note doing a backup & restore again here shouldn't affect the result.
4961         backupAndRestore();
4962 
4963         addPackage(CALLING_PACKAGE_1, CALLING_UID_1, 10, "sigx"); // different signature
4964 
4965         checkBackupAndRestore_publisherNotRestored();
4966     }
4967 
testBackupAndRestore_publisherNoLongerBackupTarget()4968     public void testBackupAndRestore_publisherNoLongerBackupTarget() {
4969         prepareForBackupTest();
4970 
4971         // Note doing a backup & restore again here shouldn't affect the result.
4972         backupAndRestore();
4973 
4974         updatePackageInfo(CALLING_PACKAGE_1,
4975                 pi -> pi.applicationInfo.flags &= ~ApplicationInfo.FLAG_ALLOW_BACKUP);
4976 
4977         checkBackupAndRestore_publisherNotRestored();
4978     }
4979 
checkBackupAndRestore_publisherNotRestored()4980     protected void checkBackupAndRestore_publisherNotRestored() {
4981         installPackage(USER_0, CALLING_PACKAGE_1);
4982         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
4983             assertEquals(0, mManager.getDynamicShortcuts().size());
4984             assertEquals(0, mManager.getPinnedShortcuts().size());
4985         });
4986         assertFalse(mService.getPackageShortcutForTest(CALLING_PACKAGE_1, USER_0)
4987                 .getPackageInfo().isShadow());
4988 
4989 
4990         installPackage(USER_0, CALLING_PACKAGE_2);
4991         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
4992             assertEquals(0, mManager.getDynamicShortcuts().size());
4993             assertShortcutIds(assertAllPinned(
4994                     mManager.getPinnedShortcuts()),
4995                     "s1", "s2", "s3");
4996         });
4997         assertFalse(mService.getPackageShortcutForTest(CALLING_PACKAGE_2, USER_0)
4998                 .getPackageInfo().isShadow());
4999 
5000         installPackage(USER_0, LAUNCHER_1);
5001         runWithCaller(LAUNCHER_1, USER_0, () -> {
5002             assertShortcutIds(assertAllPinned(
5003                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5004                     /* empty */);
5005             assertShortcutIds(assertAllPinned(
5006                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5007                     "s1", "s2");
5008             assertShortcutIds(assertAllPinned(
5009                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5010                     /* empty */);
5011         });
5012         installPackage(USER_0, LAUNCHER_2);
5013         runWithCaller(LAUNCHER_2, USER_0, () -> {
5014             assertShortcutIds(assertAllPinned(
5015                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5016                     /* empty */);
5017             assertShortcutIds(assertAllPinned(
5018                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5019                     "s2", "s3");
5020             assertShortcutIds(assertAllPinned(
5021                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5022                     /* empty */);
5023         });
5024 
5025         installPackage(USER_0, CALLING_PACKAGE_3);
5026         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5027             assertEquals(0, mManager.getDynamicShortcuts().size());
5028             assertEquals(0, mManager.getPinnedShortcuts().size());
5029         });
5030 
5031         runWithCaller(LAUNCHER_1, USER_0, () -> {
5032             assertShortcutIds(assertAllPinned(
5033                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5034                     /* empty */);
5035             assertShortcutIds(assertAllPinned(
5036                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5037                     "s1", "s2");
5038             assertShortcutIds(assertAllPinned(
5039                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5040                     /* empty */);
5041         });
5042         runWithCaller(LAUNCHER_2, USER_0, () -> {
5043             assertShortcutIds(assertAllPinned(
5044                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5045                     /* empty */);
5046             assertShortcutIds(assertAllPinned(
5047                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5048                     "s2", "s3");
5049             assertShortcutIds(assertAllPinned(
5050                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5051                     /* empty */);
5052         });
5053     }
5054 
testBackupAndRestore_launcherLowerVersion()5055     public void testBackupAndRestore_launcherLowerVersion() {
5056         prepareForBackupTest();
5057 
5058         // Note doing a backup & restore again here shouldn't affect the result.
5059         backupAndRestore();
5060 
5061         addPackage(LAUNCHER_1, LAUNCHER_UID_1, 0); // Lower version
5062 
5063         checkBackupAndRestore_launcherNotRestored();
5064     }
5065 
testBackupAndRestore_launcherWrongSignature()5066     public void testBackupAndRestore_launcherWrongSignature() {
5067         prepareForBackupTest();
5068 
5069         // Note doing a backup & restore again here shouldn't affect the result.
5070         backupAndRestore();
5071 
5072         addPackage(LAUNCHER_1, LAUNCHER_UID_1, 10, "sigx"); // different signature
5073 
5074         checkBackupAndRestore_launcherNotRestored();
5075     }
5076 
testBackupAndRestore_launcherNoLongerBackupTarget()5077     public void testBackupAndRestore_launcherNoLongerBackupTarget() {
5078         prepareForBackupTest();
5079 
5080         // Note doing a backup & restore again here shouldn't affect the result.
5081         backupAndRestore();
5082 
5083         updatePackageInfo(LAUNCHER_1,
5084                 pi -> pi.applicationInfo.flags &= ~ApplicationInfo.FLAG_ALLOW_BACKUP);
5085 
5086         checkBackupAndRestore_launcherNotRestored();
5087     }
5088 
checkBackupAndRestore_launcherNotRestored()5089     protected void checkBackupAndRestore_launcherNotRestored() {
5090         installPackage(USER_0, CALLING_PACKAGE_1);
5091         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5092             assertEquals(0, mManager.getDynamicShortcuts().size());
5093 
5094             // s1 was pinned by launcher 1, which is not restored, yet, so we still see "s1" here.
5095             assertShortcutIds(assertAllPinned(
5096                     mManager.getPinnedShortcuts()),
5097                     "s1", "s2");
5098         });
5099 
5100         installPackage(USER_0, CALLING_PACKAGE_2);
5101         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5102             assertEquals(0, mManager.getDynamicShortcuts().size());
5103             assertShortcutIds(assertAllPinned(
5104                     mManager.getPinnedShortcuts()),
5105                     "s1", "s2", "s3");
5106         });
5107 
5108         // Now we try to restore launcher 1.  Then we realize it's not restorable, so L1 has no pinned
5109         // shortcuts.
5110         installPackage(USER_0, LAUNCHER_1);
5111         runWithCaller(LAUNCHER_1, USER_0, () -> {
5112             assertShortcutIds(assertAllPinned(
5113                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5114                     /* empty */);
5115             assertShortcutIds(assertAllPinned(
5116                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
5117                     /* empty */);
5118             assertShortcutIds(assertAllPinned(
5119                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5120                     /* empty */);
5121         });
5122         assertFalse(mService.getLauncherShortcutForTest(LAUNCHER_1, USER_0)
5123                 .getPackageInfo().isShadow());
5124 
5125         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5126             assertEquals(0, mManager.getDynamicShortcuts().size());
5127 
5128             // Now CALLING_PACKAGE_1 realizes "s1" is no longer pinned.
5129             assertShortcutIds(assertAllPinned(
5130                     mManager.getPinnedShortcuts()),
5131                     "s2");
5132         });
5133 
5134         installPackage(USER_0, LAUNCHER_2);
5135         runWithCaller(LAUNCHER_2, USER_0, () -> {
5136             assertShortcutIds(assertAllPinned(
5137                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0)),
5138                     "s2");
5139             assertShortcutIds(assertAllPinned(
5140                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5141                     "s2", "s3");
5142             assertShortcutIds(assertAllPinned(
5143                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5144                     /* empty */);
5145         });
5146         assertFalse(mService.getLauncherShortcutForTest(LAUNCHER_2, USER_0)
5147                 .getPackageInfo().isShadow());
5148 
5149         installPackage(USER_0, CALLING_PACKAGE_3);
5150         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5151             assertEquals(0, mManager.getDynamicShortcuts().size());
5152             assertEquals(0, mManager.getPinnedShortcuts().size());
5153         });
5154 
5155         runWithCaller(LAUNCHER_1, USER_0, () -> {
5156             assertShortcutIds(assertAllPinned(
5157                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5158                     /* empty */);
5159             assertShortcutIds(assertAllPinned(
5160                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
5161                     /* empty */);
5162             assertShortcutIds(assertAllPinned(
5163                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5164                     /* empty */);
5165         });
5166         runWithCaller(LAUNCHER_2, USER_0, () -> {
5167             assertShortcutIds(assertAllPinned(
5168                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0)),
5169                     "s2");
5170             assertShortcutIds(assertAllPinned(
5171                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5172                     "s2", "s3");
5173             assertShortcutIds(assertAllPinned(
5174                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5175                     /* empty */);
5176         });
5177     }
5178 
testBackupAndRestore_launcherAndPackageNoLongerBackupTarget()5179     public void testBackupAndRestore_launcherAndPackageNoLongerBackupTarget() {
5180         prepareForBackupTest();
5181 
5182         // Note doing a backup & restore again here shouldn't affect the result.
5183         backupAndRestore();
5184 
5185         updatePackageInfo(CALLING_PACKAGE_1,
5186                 pi -> pi.applicationInfo.flags &= ~ApplicationInfo.FLAG_ALLOW_BACKUP);
5187 
5188         updatePackageInfo(LAUNCHER_1,
5189                 pi -> pi.applicationInfo.flags &= ~ApplicationInfo.FLAG_ALLOW_BACKUP);
5190 
5191         checkBackupAndRestore_publisherAndLauncherNotRestored();
5192     }
5193 
checkBackupAndRestore_publisherAndLauncherNotRestored()5194     protected void checkBackupAndRestore_publisherAndLauncherNotRestored() {
5195         installPackage(USER_0, CALLING_PACKAGE_1);
5196         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5197             assertEquals(0, mManager.getDynamicShortcuts().size());
5198             assertEquals(0, mManager.getPinnedShortcuts().size());
5199         });
5200 
5201         installPackage(USER_0, CALLING_PACKAGE_2);
5202         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5203             assertEquals(0, mManager.getDynamicShortcuts().size());
5204             assertShortcutIds(assertAllPinned(
5205                     mManager.getPinnedShortcuts()),
5206                     "s1", "s2", "s3");
5207         });
5208 
5209         installPackage(USER_0, LAUNCHER_1);
5210         runWithCaller(LAUNCHER_1, USER_0, () -> {
5211             assertShortcutIds(assertAllPinned(
5212                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5213                     /* empty */);
5214             assertShortcutIds(assertAllPinned(
5215                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
5216                     /* empty */);
5217             assertShortcutIds(assertAllPinned(
5218                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5219                     /* empty */);
5220         });
5221         installPackage(USER_0, LAUNCHER_2);
5222         runWithCaller(LAUNCHER_2, USER_0, () -> {
5223             assertShortcutIds(assertAllPinned(
5224                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5225                     /* empty */);
5226             assertShortcutIds(assertAllPinned(
5227                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5228                     "s2", "s3");
5229             assertShortcutIds(assertAllPinned(
5230                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5231                     /* empty */);
5232         });
5233 
5234         // Because launcher 1 wasn't restored, "s1" is no longer pinned.
5235         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5236             assertEquals(0, mManager.getDynamicShortcuts().size());
5237             assertShortcutIds(assertAllPinned(
5238                     mManager.getPinnedShortcuts()),
5239                     "s2", "s3");
5240         });
5241 
5242         installPackage(USER_0, CALLING_PACKAGE_3);
5243         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5244             assertEquals(0, mManager.getDynamicShortcuts().size());
5245             assertEquals(0, mManager.getPinnedShortcuts().size());
5246         });
5247 
5248         runWithCaller(LAUNCHER_1, USER_0, () -> {
5249             assertShortcutIds(assertAllPinned(
5250                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5251                     /* empty */);
5252             assertShortcutIds(assertAllPinned(
5253                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
5254                     /* empty */);
5255             assertShortcutIds(assertAllPinned(
5256                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5257                     /* empty */);
5258         });
5259         runWithCaller(LAUNCHER_2, USER_0, () -> {
5260             assertShortcutIds(assertAllPinned(
5261                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5262                     /* empty */);
5263             assertShortcutIds(assertAllPinned(
5264                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0)),
5265                     "s2", "s3");
5266             assertShortcutIds(assertAllPinned(
5267                     mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5268                     /* empty */);
5269         });
5270     }
5271 
testBackupAndRestore_disabled()5272     public void testBackupAndRestore_disabled() {
5273         prepareCrossProfileDataSet();
5274 
5275         // Before doing backup & restore, disable s1.
5276         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5277             mManager.disableShortcuts(list("s1"));
5278         });
5279 
5280         backupAndRestore();
5281 
5282         // Below is copied from checkBackupAndRestore_success.
5283 
5284         // Make sure non-system user is not restored.
5285         final ShortcutUser userP0 = mService.getUserShortcutsLocked(USER_P0);
5286         assertEquals(0, userP0.getAllPackagesForTest().size());
5287         assertEquals(0, userP0.getAllLaunchersForTest().size());
5288 
5289         // Make sure only "allowBackup" apps are restored, and are shadow.
5290         final ShortcutUser user0 = mService.getUserShortcutsLocked(USER_0);
5291         assertExistsAndShadow(user0.getAllPackagesForTest().get(CALLING_PACKAGE_1));
5292         assertExistsAndShadow(user0.getAllPackagesForTest().get(CALLING_PACKAGE_2));
5293         assertExistsAndShadow(user0.getAllLaunchersForTest().get(
5294                 PackageWithUser.of(USER_0, LAUNCHER_1)));
5295         assertExistsAndShadow(user0.getAllLaunchersForTest().get(
5296                 PackageWithUser.of(USER_0, LAUNCHER_2)));
5297 
5298         assertNull(user0.getAllPackagesForTest().get(CALLING_PACKAGE_3));
5299         assertNull(user0.getAllLaunchersForTest().get(PackageWithUser.of(USER_0, LAUNCHER_3)));
5300         assertNull(user0.getAllLaunchersForTest().get(PackageWithUser.of(USER_P0, LAUNCHER_1)));
5301 
5302         installPackage(USER_0, CALLING_PACKAGE_1);
5303         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5304             assertWith(getCallerVisibleShortcuts())
5305                     .areAllEnabled() // disabled shortcuts shouldn't be restored.
5306 
5307                     .selectDynamic()
5308                     .isEmpty()
5309 
5310                     .revertToOriginalList()
5311                     .selectPinned()
5312                     // s1 is not restored.
5313                     .haveIds("s2");
5314         });
5315 
5316         installPackage(USER_0, LAUNCHER_1);
5317         runWithCaller(LAUNCHER_1, USER_0, () -> {
5318             // Note, s1 was pinned by launcher 1, but was disabled, so isn't restored.
5319             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0))
5320                     .isEmpty();
5321 
5322             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_2), HANDLE_USER_0))
5323                     .isEmpty();
5324 
5325             assertWith(mLauncherApps.getShortcuts(buildAllQuery(CALLING_PACKAGE_3), HANDLE_USER_0))
5326                     .isEmpty();
5327 
5328             assertWith(mLauncherApps.getShortcuts(QUERY_ALL, HANDLE_USER_P0))
5329                     .isEmpty();
5330         });
5331     }
5332 
5333 
testBackupAndRestore_manifestRePublished()5334     public void testBackupAndRestore_manifestRePublished() {
5335         // Publish two manifest shortcuts.
5336         addManifestShortcutResource(
5337                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
5338                 R.xml.shortcut_2);
5339         updatePackageVersion(CALLING_PACKAGE_1, 1);
5340         mService.mPackageMonitor.onReceive(mServiceContext,
5341                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
5342 
5343         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5344             assertTrue(mManager.setDynamicShortcuts(list(
5345                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
5346         });
5347 
5348         // Pin from launcher 1.
5349         runWithCaller(LAUNCHER_1, USER_0, () -> {
5350             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
5351                     list("ms1", "ms2", "s1", "s2"), HANDLE_USER_0);
5352         });
5353 
5354         // Update and now ms2 is gone -> disabled.
5355         addManifestShortcutResource(
5356                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
5357                 R.xml.shortcut_1);
5358         updatePackageVersion(CALLING_PACKAGE_1, 1);
5359         mService.mPackageMonitor.onReceive(mServiceContext,
5360                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
5361 
5362         // Make sure the manifest shortcuts have been published.
5363         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5364             assertWith(getCallerShortcuts())
5365                     .selectManifest()
5366                     .haveIds("ms1")
5367 
5368                     .revertToOriginalList()
5369                     .selectDynamic()
5370                     .haveIds("s1", "s2", "s3")
5371 
5372                     .revertToOriginalList()
5373                     .selectPinned()
5374                     .haveIds("ms1", "ms2", "s1", "s2")
5375 
5376                     .revertToOriginalList()
5377                     .selectByIds("ms1")
5378                     .areAllManifest()
5379                     .areAllEnabled()
5380 
5381                     .revertToOriginalList()
5382                     .selectByIds("ms2")
5383                     .areAllNotManifest()
5384                     .areAllDisabled();
5385         });
5386 
5387         backupAndRestore();
5388 
5389         // When re-installing the app, the manifest shortcut should be re-published.
5390         mService.mPackageMonitor.onReceive(mServiceContext,
5391                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
5392         mService.mPackageMonitor.onReceive(mServiceContext,
5393                 genPackageAddIntent(LAUNCHER_1, USER_0));
5394 
5395         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5396             assertWith(getCallerVisibleShortcuts())
5397                     .selectPinned()
5398                     // ms2 was disabled, so not restored.
5399                     .haveIds("ms1", "s1", "s2")
5400                     .areAllEnabled()
5401 
5402                     .revertToOriginalList()
5403                     .selectByIds("ms1")
5404                     .areAllManifest()
5405 
5406                     .revertToOriginalList()
5407                     .selectByIds("s1", "s2")
5408                     .areAllNotDynamic()
5409                     ;
5410         });
5411     }
5412 
5413     /**
5414      * It's the case with preintalled apps -- when applyRestore() is called, the system
5415      * apps are already installed, so manifest shortcuts need to be re-published.
5416      *
5417      * Also, when a restore target app is already installed, and
5418      * - if it has allowBackup=true, we'll restore normally, so all existing shortcuts will be
5419      * replaced. (but manifest shortcuts will be re-published anyway.)  We log a warning on
5420      * logcat.
5421      * - if it has allowBackup=false, we don't touch any of the existing shortcuts.
5422      */
testBackupAndRestore_appAlreadyInstalledWhenRestored()5423     public void testBackupAndRestore_appAlreadyInstalledWhenRestored() {
5424         // Pre-backup.  Same as testBackupAndRestore_manifestRePublished().
5425 
5426         // Publish two manifest shortcuts.
5427         addManifestShortcutResource(
5428                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
5429                 R.xml.shortcut_2);
5430         updatePackageVersion(CALLING_PACKAGE_1, 1);
5431         mService.mPackageMonitor.onReceive(mServiceContext,
5432                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
5433 
5434         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5435             assertTrue(mManager.setDynamicShortcuts(list(
5436                     makeShortcut("s1"), makeShortcut("s2"), makeShortcut("s3"))));
5437         });
5438 
5439         // Pin from launcher 1.
5440         runWithCaller(LAUNCHER_1, USER_0, () -> {
5441             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
5442                     list("ms1", "ms2", "s1", "s2"), HANDLE_USER_0);
5443         });
5444 
5445         // Update and now ms2 is gone -> disabled.
5446         addManifestShortcutResource(
5447                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
5448                 R.xml.shortcut_1);
5449         updatePackageVersion(CALLING_PACKAGE_1, 1);
5450         mService.mPackageMonitor.onReceive(mServiceContext,
5451                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
5452 
5453         // Set up shortcuts for package 3, which won't be backed up / restored.
5454         addManifestShortcutResource(
5455                 new ComponentName(CALLING_PACKAGE_3, ShortcutActivity.class.getName()),
5456                 R.xml.shortcut_1);
5457         updatePackageVersion(CALLING_PACKAGE_3, 1);
5458         mService.mPackageMonitor.onReceive(mServiceContext,
5459                 genPackageAddIntent(CALLING_PACKAGE_3, USER_0));
5460 
5461         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5462             assertTrue(getManager().setDynamicShortcuts(list(
5463                     makeShortcut("s1"))));
5464         });
5465 
5466         // Make sure the manifest shortcuts have been published.
5467         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5468             assertWith(getCallerShortcuts())
5469                     .selectManifest()
5470                     .haveIds("ms1")
5471 
5472                     .revertToOriginalList()
5473                     .selectDynamic()
5474                     .haveIds("s1", "s2", "s3")
5475 
5476                     .revertToOriginalList()
5477                     .selectPinned()
5478                     .haveIds("ms1", "ms2", "s1", "s2")
5479 
5480                     .revertToOriginalList()
5481                     .selectByIds("ms1")
5482                     .areAllManifest()
5483                     .areAllEnabled()
5484 
5485                     .revertToOriginalList()
5486                     .selectByIds("ms2")
5487                     .areAllNotManifest()
5488                     .areAllDisabled();
5489         });
5490 
5491         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5492             assertWith(getCallerShortcuts())
5493                     .haveIds("s1", "ms1");
5494         });
5495 
5496         // Backup and *without restarting the service, just call applyRestore()*.
5497         {
5498             int prevUid = mInjectedCallingUid;
5499             mInjectedCallingUid = Process.SYSTEM_UID; // Only system can call it.
5500 
5501             dumpsysOnLogcat("Before backup");
5502 
5503             final byte[] payload = mService.getBackupPayload(USER_0);
5504             if (ENABLE_DUMP) {
5505                 final String xml = new String(payload);
5506                 Log.v(TAG, "Backup payload:");
5507                 for (String line : xml.split("\n")) {
5508                     Log.v(TAG, line);
5509                 }
5510             }
5511             mService.applyRestore(payload, USER_0);
5512 
5513             dumpsysOnLogcat("After restore");
5514 
5515             mInjectedCallingUid = prevUid;
5516         }
5517 
5518         // The check is also the same as testBackupAndRestore_manifestRePublished().
5519         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5520             assertWith(getCallerVisibleShortcuts())
5521                     .selectPinned()
5522                     // ms2 was disabled, so not restored.
5523                     .haveIds("ms1", "s1", "s2")
5524                     .areAllEnabled()
5525 
5526                     .revertToOriginalList()
5527                     .selectByIds("ms1")
5528                     .areAllManifest()
5529 
5530                     .revertToOriginalList()
5531                     .selectByIds("s1", "s2")
5532                     .areAllNotDynamic()
5533             ;
5534         });
5535 
5536         // Package 3 still has the same shortcuts.
5537         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5538             assertWith(getCallerShortcuts())
5539                     .haveIds("s1", "ms1");
5540         });
5541     }
5542 
testSaveAndLoad_crossProfile()5543     public void testSaveAndLoad_crossProfile() {
5544         prepareCrossProfileDataSet();
5545 
5546         dumpsysOnLogcat("Before save & load");
5547 
5548         mService.saveDirtyInfo();
5549         initService();
5550 
5551         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5552             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()),
5553                     "s1", "s2", "s3");
5554             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()),
5555                     "s1", "s2", "s3", "s4");
5556         });
5557         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5558             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()),
5559                     "s1", "s2", "s3");
5560             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()),
5561                     "s1", "s2", "s3", "s4", "s5");
5562         });
5563         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5564             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()),
5565                     "s1", "s2", "s3");
5566             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()),
5567                     "s1", "s2", "s3", "s4", "s5", "s6");
5568         });
5569         runWithCaller(CALLING_PACKAGE_4, USER_0, () -> {
5570             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts())
5571                     /* empty */);
5572             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts())
5573                     /* empty */);
5574         });
5575         runWithCaller(CALLING_PACKAGE_1, USER_P0, () -> {
5576             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()),
5577                     "s1", "s2", "s3");
5578             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()),
5579                     "s1", "s2", "s3", "s4", "s5", "s6");
5580         });
5581         runWithCaller(CALLING_PACKAGE_2, USER_P0, () -> {
5582             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts())
5583                     /* empty */);
5584             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts())
5585                     /* empty */);
5586         });
5587         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
5588             assertShortcutIds(assertAllDynamic(mManager.getDynamicShortcuts()),
5589                     "x1", "x2", "x3");
5590             assertShortcutIds(assertAllPinned(mManager.getPinnedShortcuts()),
5591                     "x4", "x5");
5592         });
5593         runWithCaller(LAUNCHER_1, USER_0, () -> {
5594             assertShortcutIds(
5595                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_0),
5596                     "s1");
5597             assertShortcutIds(
5598                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_0),
5599                     "s1", "s2");
5600             assertShortcutIds(
5601                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_3), HANDLE_USER_0),
5602                     "s1", "s2", "s3");
5603             assertShortcutIds(
5604                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_4), HANDLE_USER_0)
5605                     /* empty */);
5606             assertShortcutIds(
5607                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_P0),
5608                     "s1", "s4");
5609             assertShortcutIds(
5610                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_P0)
5611                     /* empty */);
5612             assertExpectException(
5613                     SecurityException.class, "", () -> {
5614                         mLauncherApps.getShortcuts(
5615                                 buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_10);
5616                     });
5617         });
5618         runWithCaller(LAUNCHER_2, USER_0, () -> {
5619             assertShortcutIds(
5620                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_0),
5621                     "s2");
5622             assertShortcutIds(
5623                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_0),
5624                     "s2", "s3");
5625             assertShortcutIds(
5626                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_3), HANDLE_USER_0),
5627                     "s2", "s3", "s4");
5628             assertShortcutIds(
5629                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_4), HANDLE_USER_0)
5630                     /* empty */);
5631             assertShortcutIds(
5632                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_P0),
5633                     "s2", "s5");
5634             assertShortcutIds(
5635                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_P0)
5636                     /* empty */);
5637         });
5638         runWithCaller(LAUNCHER_3, USER_0, () -> {
5639             assertShortcutIds(
5640                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_0),
5641                     "s3");
5642             assertShortcutIds(
5643                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_0),
5644                     "s3", "s4");
5645             assertShortcutIds(
5646                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_3), HANDLE_USER_0),
5647                     "s3", "s4", "s5");
5648             assertShortcutIds(
5649                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_4), HANDLE_USER_0)
5650                     /* empty */);
5651             assertShortcutIds(
5652                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_P0),
5653                     "s3", "s6");
5654             assertShortcutIds(
5655                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_P0)
5656                     /* empty */);
5657         });
5658         runWithCaller(LAUNCHER_4, USER_0, () -> {
5659             assertShortcutIds(
5660                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_0)
5661                     /* empty */);
5662             assertShortcutIds(
5663                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_0)
5664                     /* empty */);
5665             assertShortcutIds(
5666                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_3), HANDLE_USER_0)
5667                     /* empty */);
5668             assertShortcutIds(
5669                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_4), HANDLE_USER_0)
5670                     /* empty */);
5671             assertShortcutIds(
5672                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_P0)
5673                     /* empty */);
5674             assertShortcutIds(
5675                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_P0)
5676                     /* empty */);
5677         });
5678         runWithCaller(LAUNCHER_1, USER_P0, () -> {
5679             assertShortcutIds(
5680                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_0),
5681                     "s3", "s4");
5682             assertShortcutIds(
5683                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_0),
5684                     "s3", "s4", "s5");
5685             assertShortcutIds(
5686                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_3), HANDLE_USER_0),
5687                     "s3", "s4", "s5", "s6");
5688             assertShortcutIds(
5689                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_P0),
5690                     "s1", "s4");
5691             assertExpectException(
5692                     SecurityException.class, "unrelated profile", () -> {
5693                         mLauncherApps.getShortcuts(
5694                                 buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_10);
5695                     });
5696         });
5697         runWithCaller(LAUNCHER_1, USER_10, () -> {
5698             assertShortcutIds(
5699                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_1), HANDLE_USER_10),
5700                     "x4", "x5");
5701             assertShortcutIds(
5702                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_2), HANDLE_USER_10)
5703                     /* empty */);
5704             assertShortcutIds(
5705                     mLauncherApps.getShortcuts(buildPinnedQuery(CALLING_PACKAGE_3), HANDLE_USER_10)
5706                     /* empty */);
5707             assertExpectException(
5708                     SecurityException.class, "unrelated profile", () -> {
5709                         mLauncherApps.getShortcuts(
5710                                 buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_0);
5711                     });
5712             assertExpectException(
5713                     SecurityException.class, "unrelated profile", () -> {
5714                         mLauncherApps.getShortcuts(
5715                                 buildAllQuery(CALLING_PACKAGE_1), HANDLE_USER_P0);
5716                     });
5717         });
5718         // Check the user-IDs.
5719         assertEquals(USER_0,
5720                 mService.getUserShortcutsLocked(USER_0).getPackageShortcuts(CALLING_PACKAGE_1)
5721                         .getOwnerUserId());
5722         assertEquals(USER_0,
5723                 mService.getUserShortcutsLocked(USER_0).getPackageShortcuts(CALLING_PACKAGE_1)
5724                         .getPackageUserId());
5725         assertEquals(USER_P0,
5726                 mService.getUserShortcutsLocked(USER_P0).getPackageShortcuts(CALLING_PACKAGE_1)
5727                         .getOwnerUserId());
5728         assertEquals(USER_P0,
5729                 mService.getUserShortcutsLocked(USER_P0).getPackageShortcuts(CALLING_PACKAGE_1)
5730                         .getPackageUserId());
5731 
5732         assertEquals(USER_0,
5733                 mService.getUserShortcutsLocked(USER_0).getLauncherShortcuts(LAUNCHER_1, USER_0)
5734                         .getOwnerUserId());
5735         assertEquals(USER_0,
5736                 mService.getUserShortcutsLocked(USER_0).getLauncherShortcuts(LAUNCHER_1, USER_0)
5737                         .getPackageUserId());
5738         assertEquals(USER_P0,
5739                 mService.getUserShortcutsLocked(USER_P0).getLauncherShortcuts(LAUNCHER_1, USER_0)
5740                         .getOwnerUserId());
5741         assertEquals(USER_0,
5742                 mService.getUserShortcutsLocked(USER_P0).getLauncherShortcuts(LAUNCHER_1, USER_0)
5743                         .getPackageUserId());
5744     }
5745 
testOnApplicationActive_permission()5746     public void testOnApplicationActive_permission() {
5747         assertExpectException(SecurityException.class, "Missing permission", () ->
5748                 mManager.onApplicationActive(CALLING_PACKAGE_1, USER_0));
5749 
5750         // Has permission, now it should pass.
5751         mCallerPermissions.add(permission.RESET_SHORTCUT_MANAGER_THROTTLING);
5752         mManager.onApplicationActive(CALLING_PACKAGE_1, USER_0);
5753     }
5754 
testDumpsys_crossProfile()5755     public void testDumpsys_crossProfile() {
5756         prepareCrossProfileDataSet();
5757         dumpsysOnLogcat("test1", /* force= */ true);
5758     }
5759 
testDumpsys_withIcons()5760     public void testDumpsys_withIcons() throws IOException {
5761         testIcons();
5762         // Dump after having some icons.
5763         dumpsysOnLogcat("test1", /* force= */ true);
5764     }
5765 
testManifestShortcut_publishOnUnlockUser()5766     public void testManifestShortcut_publishOnUnlockUser() {
5767         addManifestShortcutResource(
5768                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
5769                 R.xml.shortcut_1);
5770         addManifestShortcutResource(
5771                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
5772                 R.xml.shortcut_2);
5773         addManifestShortcutResource(
5774                 new ComponentName(CALLING_PACKAGE_3, ShortcutActivity.class.getName()),
5775                 R.xml.shortcut_5);
5776 
5777         // Unlock user-0.
5778         mInjectedCurrentTimeMillis += 100;
5779         mService.handleUnlockUser(USER_0);
5780 
5781         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5782             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5783                     mManager.getManifestShortcuts()))),
5784                     "ms1");
5785             assertEmpty(mManager.getPinnedShortcuts());
5786         });
5787 
5788         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5789             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5790                     mManager.getManifestShortcuts()))),
5791                     "ms1", "ms2");
5792             assertEmpty(mManager.getPinnedShortcuts());
5793         });
5794 
5795         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5796             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5797                     mManager.getManifestShortcuts()))),
5798                     "ms1", "ms2", "ms3", "ms4", "ms5");
5799             assertEmpty(mManager.getPinnedShortcuts());
5800         });
5801 
5802         // Try on another user, with some packages uninstalled.
5803         mRunningUsers.put(USER_10, true);
5804 
5805         uninstallPackage(USER_10, CALLING_PACKAGE_1);
5806         uninstallPackage(USER_10, CALLING_PACKAGE_3);
5807 
5808         mInjectedCurrentTimeMillis += 100;
5809         mService.handleUnlockUser(USER_10);
5810 
5811         runWithCaller(CALLING_PACKAGE_1, USER_10, () -> {
5812             assertEmpty(mManager.getManifestShortcuts());
5813             assertEmpty(mManager.getPinnedShortcuts());
5814         });
5815 
5816         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
5817             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5818                     mManager.getManifestShortcuts()))),
5819                     "ms1", "ms2");
5820             assertEmpty(mManager.getPinnedShortcuts());
5821         });
5822 
5823         runWithCaller(CALLING_PACKAGE_3, USER_10, () -> {
5824             assertEmpty(mManager.getManifestShortcuts());
5825             assertEmpty(mManager.getPinnedShortcuts());
5826         });
5827 
5828         // Now change the resources for package 1, and unlock again.
5829         // But we still see *old* shortcuts, because the package version and install time
5830         // hasn't changed.
5831         shutdownServices();
5832 
5833         mInjectedCurrentTimeMillis += 100;
5834 
5835         addManifestShortcutResource(
5836                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
5837                 R.xml.shortcut_5);
5838         addManifestShortcutResource(
5839                 new ComponentName(CALLING_PACKAGE_3, ShortcutActivity.class.getName()),
5840                 R.xml.shortcut_1);
5841 
5842         initService();
5843         mService.handleUnlockUser(USER_0);
5844 
5845         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5846             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled( // FAIL
5847                     mManager.getManifestShortcuts()))),
5848                     "ms1");
5849             assertEmpty(mManager.getPinnedShortcuts());
5850         });
5851 
5852         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5853             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5854                     mManager.getManifestShortcuts()))),
5855                     "ms1", "ms2");
5856             assertEmpty(mManager.getPinnedShortcuts());
5857         });
5858 
5859         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5860             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5861                     mManager.getManifestShortcuts()))),
5862                     "ms1", "ms2", "ms3", "ms4", "ms5");
5863             assertEmpty(mManager.getPinnedShortcuts());
5864         });
5865 
5866         // Do it again, but this time we change the app version, so we do detect the changes.
5867         shutdownServices();
5868 
5869         mInjectedCurrentTimeMillis += 100;
5870 
5871         updatePackageVersion(CALLING_PACKAGE_1, 1);
5872         updatePackageLastUpdateTime(CALLING_PACKAGE_3, 1);
5873 
5874         initService();
5875         mService.handleUnlockUser(USER_0);
5876 
5877         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5878             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5879                     mManager.getManifestShortcuts()))),
5880                     "ms1", "ms2", "ms3", "ms4", "ms5");
5881             assertEmpty(mManager.getPinnedShortcuts());
5882         });
5883 
5884         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5885             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5886                     mManager.getManifestShortcuts()))),
5887                     "ms1", "ms2");
5888             assertEmpty(mManager.getPinnedShortcuts());
5889         });
5890 
5891         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5892             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5893                     mManager.getManifestShortcuts()))),
5894                     "ms1");
5895             assertEmpty(mManager.getPinnedShortcuts());
5896         });
5897 
5898         // Next, try removing all shortcuts, with some of them pinned.
5899         runWithCaller(LAUNCHER_1, USER_0, () -> {
5900             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms3"), HANDLE_USER_0);
5901             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list("ms2"), HANDLE_USER_0);
5902             mLauncherApps.pinShortcuts(CALLING_PACKAGE_3, list("ms1"), HANDLE_USER_0);
5903         });
5904         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5905             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5906                     mManager.getManifestShortcuts()))),
5907                     "ms1", "ms2", "ms3", "ms4", "ms5");
5908             assertShortcutIds(assertAllImmutable(assertAllPinned(assertAllManifest(
5909                     assertAllEnabled(mManager.getPinnedShortcuts())))),
5910                     "ms3");
5911         });
5912 
5913         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5914             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5915                     mManager.getManifestShortcuts()))),
5916                     "ms1", "ms2");
5917             assertShortcutIds(assertAllImmutable(assertAllPinned(assertAllManifest(
5918                     assertAllEnabled(mManager.getPinnedShortcuts())))),
5919                     "ms2");
5920         });
5921 
5922         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5923             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5924                     mManager.getManifestShortcuts()))),
5925                     "ms1");
5926             assertShortcutIds(assertAllImmutable(assertAllPinned(assertAllManifest(
5927                     assertAllEnabled(mManager.getPinnedShortcuts())))),
5928                     "ms1");
5929         });
5930 
5931         shutdownServices();
5932 
5933         mInjectedCurrentTimeMillis += 100;
5934 
5935         addManifestShortcutResource(
5936                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
5937                 R.xml.shortcut_0);
5938         addManifestShortcutResource(
5939                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
5940                 R.xml.shortcut_1);
5941         addManifestShortcutResource(
5942                 new ComponentName(CALLING_PACKAGE_3, ShortcutActivity.class.getName()),
5943                 R.xml.shortcut_0);
5944 
5945         updatePackageVersion(CALLING_PACKAGE_1, 1);
5946         updatePackageVersion(CALLING_PACKAGE_2, 1);
5947         updatePackageVersion(CALLING_PACKAGE_3, 1);
5948 
5949         initService();
5950         mService.handleUnlockUser(USER_0);
5951 
5952         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5953             assertEmpty(mManager.getManifestShortcuts());
5954             assertShortcutIds(assertAllImmutable(assertAllPinned(assertAllNotManifest(
5955                     assertAllDisabled(mManager.getPinnedShortcuts())))),
5956                     "ms3");
5957         });
5958 
5959         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
5960             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
5961                     mManager.getManifestShortcuts()))),
5962                     "ms1");
5963             assertShortcutIds(assertAllImmutable(assertAllPinned(assertAllNotManifest(
5964                     assertAllDisabled(mManager.getPinnedShortcuts())))),
5965                     "ms2");
5966         });
5967 
5968         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
5969             assertEmpty(mManager.getManifestShortcuts());
5970             assertShortcutIds(assertAllImmutable(assertAllPinned(assertAllNotManifest(
5971                     assertAllDisabled(mManager.getPinnedShortcuts())))),
5972                     "ms1");
5973         });
5974 
5975         // Make sure we don't have ShortcutPackage for packages that don't have shortcuts.
5976         assertNull(mService.getPackageShortcutForTest(CALLING_PACKAGE_4, USER_0));
5977         assertNull(mService.getPackageShortcutForTest(LAUNCHER_1, USER_0));
5978     }
5979 
testManifestShortcut_publishOnBroadcast()5980     public void testManifestShortcut_publishOnBroadcast() {
5981         // First, no packages are installed.
5982         uninstallPackage(USER_0, CALLING_PACKAGE_1);
5983         uninstallPackage(USER_0, CALLING_PACKAGE_2);
5984         uninstallPackage(USER_0, CALLING_PACKAGE_3);
5985         uninstallPackage(USER_0, CALLING_PACKAGE_4);
5986         uninstallPackage(USER_10, CALLING_PACKAGE_1);
5987         uninstallPackage(USER_10, CALLING_PACKAGE_2);
5988         uninstallPackage(USER_10, CALLING_PACKAGE_3);
5989         uninstallPackage(USER_10, CALLING_PACKAGE_4);
5990 
5991         mService.handleUnlockUser(USER_0);
5992 
5993         mRunningUsers.put(USER_10, true);
5994         mService.handleUnlockUser(USER_10);
5995 
5996         // Originally no manifest shortcuts.
5997         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
5998             assertEmpty(mManager.getManifestShortcuts());
5999             assertEmpty(mManager.getPinnedShortcuts());
6000         });
6001 
6002         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
6003             assertEmpty(mManager.getManifestShortcuts());
6004             assertEmpty(mManager.getPinnedShortcuts());
6005         });
6006 
6007         runWithCaller(CALLING_PACKAGE_3, USER_0, () -> {
6008             assertEmpty(mManager.getManifestShortcuts());
6009             assertEmpty(mManager.getPinnedShortcuts());
6010         });
6011 
6012         // Package 1 updated, with manifest shortcuts.
6013         addManifestShortcutResource(
6014                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6015                 R.xml.shortcut_1);
6016         updatePackageVersion(CALLING_PACKAGE_1, 1);
6017                 mService.mPackageMonitor.onReceive(getTestContext(),
6018                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6019 
6020         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6021             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6022                     mManager.getManifestShortcuts()))),
6023                     "ms1");
6024             assertEmpty(mManager.getPinnedShortcuts());
6025         });
6026 
6027         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
6028             assertEmpty(mManager.getManifestShortcuts());
6029             assertEmpty(mManager.getPinnedShortcuts());
6030         });
6031 
6032         // Package 2 updated, with manifest shortcuts.
6033 
6034         addManifestShortcutResource(
6035                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
6036                 R.xml.shortcut_5);
6037         updatePackageVersion(CALLING_PACKAGE_2, 1);
6038                 mService.mPackageMonitor.onReceive(getTestContext(),
6039                 genPackageAddIntent(CALLING_PACKAGE_2, USER_0));
6040 
6041         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6042             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6043                     mManager.getManifestShortcuts()))),
6044                     "ms1");
6045             assertEmpty(mManager.getPinnedShortcuts());
6046         });
6047 
6048         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
6049             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6050                     mManager.getManifestShortcuts()))),
6051                     "ms1", "ms2", "ms3", "ms4", "ms5");
6052             assertWith(getCallerShortcuts()).selectManifest()
6053                     .selectByActivity(
6054                             new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()))
6055                     .haveRanksInOrder("ms1", "ms2", "ms3", "ms4", "ms5");
6056             assertEmpty(mManager.getPinnedShortcuts());
6057         });
6058 
6059         // Package 2 updated, with less manifest shortcuts.
6060         // This time we use updatePackageLastUpdateTime() instead of updatePackageVersion().
6061 
6062         dumpsysOnLogcat("Before pinning");
6063 
6064         // Also pin some.
6065         runWithCaller(LAUNCHER_1, USER_0, () -> {
6066             mLauncherApps.pinShortcuts(CALLING_PACKAGE_2, list("ms2", "ms3"), HANDLE_USER_0);
6067         });
6068 
6069         dumpsysOnLogcat("After pinning");
6070 
6071         addManifestShortcutResource(
6072                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
6073                 R.xml.shortcut_2);
6074         updatePackageLastUpdateTime(CALLING_PACKAGE_2, 1);
6075                 mService.mPackageMonitor.onReceive(getTestContext(),
6076                 genPackageAddIntent(CALLING_PACKAGE_2, USER_0));
6077 
6078         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6079             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6080                     mManager.getManifestShortcuts()))),
6081                     "ms1");
6082             assertEmpty(mManager.getPinnedShortcuts());
6083         });
6084 
6085         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
6086             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6087                     mManager.getManifestShortcuts()))),
6088                     "ms1", "ms2");
6089             assertWith(getCallerShortcuts()).selectManifest()
6090                     .selectByActivity(
6091                             new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()))
6092                     .haveRanksInOrder("ms1", "ms2");
6093             assertShortcutIds(assertAllImmutable(assertAllPinned(
6094                     mManager.getPinnedShortcuts())),
6095                     "ms2", "ms3");
6096             // ms3 is no longer in manifest, so should be disabled.
6097             // but ms1 and ms2 should be enabled.
6098             assertAllEnabled(list(getCallerShortcut("ms1")));
6099             assertAllEnabled(list(getCallerShortcut("ms2")));
6100             assertAllDisabled(list(getCallerShortcut("ms3")));
6101         });
6102 
6103         // Package 2 on user 10 has no shortcuts yet.
6104         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
6105             assertEmpty(mManager.getManifestShortcuts());
6106             assertEmpty(mManager.getPinnedShortcuts());
6107         });
6108         // Send add broadcast, but the user is not running, so should be ignored.
6109         mService.handleStopUser(USER_10);
6110         mRunningUsers.put(USER_10, false);
6111         mUnlockedUsers.put(USER_10, false);
6112 
6113         mService.mPackageMonitor.onReceive(getTestContext(),
6114                 genPackageAddIntent(CALLING_PACKAGE_2, USER_10));
6115         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
6116             // Don't use the mManager APIs to get shortcuts, because they'll trigger the package
6117             // update check.
6118             // So look the internal data directly using getCallerShortcuts().
6119             assertEmpty(getCallerShortcuts());
6120         });
6121 
6122         // Try again, but the user is locked, so still ignored.
6123         mRunningUsers.put(USER_10, true);
6124                 mService.mPackageMonitor.onReceive(getTestContext(),
6125                 genPackageAddIntent(CALLING_PACKAGE_2, USER_10));
6126         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
6127             // Don't use the mManager APIs to get shortcuts, because they'll trigger the package
6128             // update check.
6129             // So look the internal data directly using getCallerShortcuts().
6130             assertEmpty(getCallerShortcuts());
6131         });
6132 
6133         // Unlock the user, now it should work.
6134         mUnlockedUsers.put(USER_10, true);
6135 
6136         // Send PACKAGE_ADD broadcast to have Package 2 on user-10 publish manifest shortcuts.
6137                 mService.mPackageMonitor.onReceive(getTestContext(),
6138                 genPackageAddIntent(CALLING_PACKAGE_2, USER_10));
6139 
6140         runWithCaller(CALLING_PACKAGE_2, USER_10, () -> {
6141             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6142                     mManager.getManifestShortcuts()))),
6143                     "ms1", "ms2");
6144             assertWith(getCallerShortcuts()).selectManifest()
6145                     .selectByActivity(
6146                             new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()))
6147                     .haveRanksInOrder("ms1", "ms2");
6148             assertEmpty(mManager.getPinnedShortcuts());
6149         });
6150 
6151         // But it shouldn't affect user-0.
6152         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
6153             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6154                     mManager.getManifestShortcuts()))),
6155                     "ms1", "ms2");
6156             assertWith(getCallerShortcuts()).selectManifest()
6157                     .selectByActivity(
6158                             new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()))
6159                     .haveRanksInOrder("ms1", "ms2");
6160             assertShortcutIds(assertAllImmutable(assertAllPinned(
6161                     mManager.getPinnedShortcuts())),
6162                     "ms2", "ms3");
6163             assertAllEnabled(list(getCallerShortcut("ms1")));
6164             assertAllEnabled(list(getCallerShortcut("ms2")));
6165             assertAllDisabled(list(getCallerShortcut("ms3")));
6166         });
6167 
6168         // Multiple activities.
6169         // Add shortcuts on activity 2 for package 2.
6170         addManifestShortcutResource(
6171                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
6172                 R.xml.shortcut_5_alt);
6173         addManifestShortcutResource(
6174                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity2.class.getName()),
6175                 R.xml.shortcut_5_reverse);
6176 
6177         updatePackageLastUpdateTime(CALLING_PACKAGE_2, 1);
6178                 mService.mPackageMonitor.onReceive(getTestContext(),
6179                 genPackageAddIntent(CALLING_PACKAGE_2, USER_0));
6180 
6181         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
6182             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6183                     mManager.getManifestShortcuts()))),
6184                     "ms1", "ms2", "ms3", "ms4", "ms5",
6185                     "ms1_alt", "ms2_alt", "ms3_alt", "ms4_alt", "ms5_alt");
6186 
6187             // Make sure they have the correct ranks, regardless of their ID's alphabetical order.
6188             assertWith(getCallerShortcuts()).selectManifest()
6189                     .selectByActivity(
6190                             new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()))
6191                     .haveRanksInOrder("ms1_alt", "ms2_alt", "ms3_alt", "ms4_alt", "ms5_alt");
6192             assertWith(getCallerShortcuts()).selectManifest()
6193                     .selectByActivity(
6194                             new ComponentName(CALLING_PACKAGE_2, ShortcutActivity2.class.getName()))
6195                     .haveRanksInOrder("ms5", "ms4", "ms3", "ms2", "ms1");
6196         });
6197 
6198         // Package 2 now has no manifest shortcuts.
6199         addManifestShortcutResource(
6200                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity.class.getName()),
6201                 R.xml.shortcut_0);
6202         addManifestShortcutResource(
6203                 new ComponentName(CALLING_PACKAGE_2, ShortcutActivity2.class.getName()),
6204                 R.xml.shortcut_0);
6205         updatePackageLastUpdateTime(CALLING_PACKAGE_2, 1);
6206                 mService.mPackageMonitor.onReceive(getTestContext(),
6207                 genPackageAddIntent(CALLING_PACKAGE_2, USER_0));
6208 
6209         // No manifest shortcuts, and pinned ones are disabled.
6210         runWithCaller(CALLING_PACKAGE_2, USER_0, () -> {
6211             assertEmpty(mManager.getManifestShortcuts());
6212             assertShortcutIds(assertAllImmutable(assertAllPinned(assertAllDisabled(
6213                     mManager.getPinnedShortcuts()))),
6214                     "ms2", "ms3");
6215         });
6216     }
6217 
testManifestShortcuts_missingMandatoryFields()6218     public void testManifestShortcuts_missingMandatoryFields() {
6219         // Start with no apps installed.
6220         uninstallPackage(USER_0, CALLING_PACKAGE_1);
6221         uninstallPackage(USER_0, CALLING_PACKAGE_2);
6222         uninstallPackage(USER_0, CALLING_PACKAGE_3);
6223         uninstallPackage(USER_0, CALLING_PACKAGE_4);
6224 
6225         mService.handleUnlockUser(USER_0);
6226 
6227         // Make sure no manifest shortcuts.
6228         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6229             assertEmpty(mManager.getManifestShortcuts());
6230         });
6231 
6232         // Package 1 updated, which has one valid manifest shortcut and one invalid.
6233         addManifestShortcutResource(
6234                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6235                 R.xml.shortcut_error_1);
6236         updatePackageVersion(CALLING_PACKAGE_1, 1);
6237                 mService.mPackageMonitor.onReceive(getTestContext(),
6238                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6239 
6240         // Only the valid one is published.
6241         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6242             assertWith(getCallerShortcuts())
6243                     .areAllManifest()
6244                     .areAllImmutable()
6245                     .areAllEnabled()
6246                     .haveIds("x1");
6247         });
6248 
6249         // Package 1 updated, which has one valid manifest shortcut and one invalid.
6250         addManifestShortcutResource(
6251                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6252                 R.xml.shortcut_error_2);
6253         updatePackageVersion(CALLING_PACKAGE_1, 1);
6254                 mService.mPackageMonitor.onReceive(getTestContext(),
6255                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6256 
6257         // Only the valid one is published.
6258         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6259             assertWith(getCallerShortcuts())
6260                     .areAllManifest()
6261                     .areAllImmutable()
6262                     .areAllEnabled()
6263                     .haveIds("x2");
6264         });
6265 
6266         // Package 1 updated, which has one valid manifest shortcut and one invalid.
6267         addManifestShortcutResource(
6268                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6269                 R.xml.shortcut_error_3);
6270         updatePackageVersion(CALLING_PACKAGE_1, 1);
6271                 mService.mPackageMonitor.onReceive(getTestContext(),
6272                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6273 
6274         // Only the valid one is published.
6275         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6276             assertWith(getCallerShortcuts())
6277                     .areAllManifest()
6278                     .areAllImmutable()
6279                     .areAllEnabled()
6280                     .haveIds("x3")
6281                     .forShortcutWithId("x3", si -> {
6282                         assertEquals(set("cat2"), si.getCategories());
6283                      });
6284         });
6285     }
6286 
testManifestShortcuts_intentDefinitions()6287     public void testManifestShortcuts_intentDefinitions() {
6288         addManifestShortcutResource(
6289                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6290                 R.xml.shortcut_error_4);
6291         updatePackageVersion(CALLING_PACKAGE_1, 1);
6292                 mService.mPackageMonitor.onReceive(getTestContext(),
6293                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6294 
6295         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6296             // Make sure invalid ones are not published.
6297             // Note that at this point disabled ones don't show up because they weren't pinned.
6298             assertWith(getCallerShortcuts())
6299                     .haveIds("ms1", "ms2")
6300                     .areAllManifest()
6301                     .areAllNotDynamic()
6302                     .areAllNotPinned()
6303                     .areAllImmutable()
6304                     .areAllEnabled()
6305                     .forShortcutWithId("ms1", si -> {
6306                         assertTrue(si.isEnabled());
6307                         assertEquals(1, si.getIntents().length);
6308 
6309                         assertEquals("action1", si.getIntent().getAction());
6310                         assertEquals("value1", si.getIntent().getStringExtra("key1"));
6311                         assertEquals(Intent.FLAG_ACTIVITY_NEW_TASK |
6312                                 Intent.FLAG_ACTIVITY_CLEAR_TASK |
6313                                 Intent.FLAG_ACTIVITY_TASK_ON_HOME, si.getIntent().getFlags());
6314 
6315                         assertEquals("action1", si.getIntents()[0].getAction());
6316                         assertEquals("value1", si.getIntents()[0].getStringExtra("key1"));
6317                         assertEquals(Intent.FLAG_ACTIVITY_NEW_TASK |
6318                                 Intent.FLAG_ACTIVITY_CLEAR_TASK |
6319                                 Intent.FLAG_ACTIVITY_TASK_ON_HOME, si.getIntents()[0].getFlags());
6320                     })
6321                     .forShortcutWithId("ms2", si -> {
6322                         assertTrue(si.isEnabled());
6323                         assertEquals(2, si.getIntents().length);
6324 
6325                         // getIntent will return the last one.
6326                         assertEquals("action2_2", si.getIntent().getAction());
6327                         assertEquals("value2", si.getIntent().getStringExtra("key2"));
6328                         assertEquals(0, si.getIntent().getFlags());
6329 
6330                         final Intent i1 = si.getIntents()[0];
6331                         final Intent i2 = si.getIntents()[1];
6332 
6333                         assertEquals("action2_1", i1.getAction());
6334                         assertEquals("value1", i1.getStringExtra("key1"));
6335                         assertEquals(Intent.FLAG_ACTIVITY_NEW_TASK |
6336                                         Intent.FLAG_ACTIVITY_CLEAR_TASK |
6337                                         Intent.FLAG_ACTIVITY_TASK_ON_HOME, i1.getFlags());
6338 
6339                         assertEquals("action2_2", i2.getAction());
6340                         assertEquals("value2", i2.getStringExtra("key2"));
6341                         assertEquals(0, i2.getFlags());
6342                     });
6343         });
6344 
6345         // Publish 5 enabled to pin some, so we can later test disabled manfiest shortcuts..
6346         addManifestShortcutResource(
6347                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6348                 R.xml.shortcut_5);
6349         updatePackageVersion(CALLING_PACKAGE_1, 1);
6350                 mService.mPackageMonitor.onReceive(getTestContext(),
6351                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6352 
6353         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6354             // Make sure 5 manifest shortcuts are published.
6355             assertWith(getCallerShortcuts())
6356                     .haveIds("ms1", "ms2", "ms3", "ms4", "ms5")
6357                     .areAllManifest()
6358                     .areAllNotDynamic()
6359                     .areAllNotPinned()
6360                     .areAllImmutable()
6361                     .areAllEnabled();
6362         });
6363 
6364         runWithCaller(LAUNCHER_1, USER_0, () -> {
6365             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
6366                     list("ms3", "ms4", "ms5"), HANDLE_USER_0);
6367         });
6368 
6369         // Make sure they're pinned.
6370         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6371             assertWith(getCallerShortcuts())
6372                     .haveIds("ms1", "ms2", "ms3", "ms4", "ms5")
6373                     .selectByIds("ms1", "ms2")
6374                     .areAllNotPinned()
6375                     .areAllEnabled()
6376 
6377                     .revertToOriginalList()
6378                     .selectByIds("ms3", "ms4", "ms5")
6379                     .areAllPinned()
6380                     .areAllEnabled();
6381         });
6382 
6383         // Update the app.
6384         addManifestShortcutResource(
6385                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6386                 R.xml.shortcut_error_4);
6387         updatePackageVersion(CALLING_PACKAGE_1, 1);
6388                 mService.mPackageMonitor.onReceive(getTestContext(),
6389                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6390 
6391         // Make sure 3, 4 and 5 still exist but disabled.
6392         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6393             assertWith(getCallerShortcuts())
6394                     .haveIds("ms1", "ms2", "ms3", "ms4", "ms5")
6395                     .areAllNotDynamic()
6396                     .areAllImmutable()
6397 
6398                     .selectByIds("ms1", "ms2")
6399                     .areAllManifest()
6400                     .areAllNotPinned()
6401                     .areAllEnabled()
6402 
6403                     .revertToOriginalList()
6404                     .selectByIds("ms3", "ms4", "ms5")
6405                     .areAllNotManifest()
6406                     .areAllPinned()
6407                     .areAllDisabled()
6408 
6409                     .revertToOriginalList()
6410                     .forShortcutWithId("ms1", si -> {
6411                         assertEquals(si.getId(), "action1", si.getIntent().getAction());
6412                     })
6413                     .forShortcutWithId("ms2", si -> {
6414                         // getIntent returns the last one.
6415                         assertEquals(si.getId(), "action2_2", si.getIntent().getAction());
6416                     })
6417                     .forShortcutWithId("ms3", si -> {
6418                         assertEquals(si.getId(), Intent.ACTION_VIEW, si.getIntent().getAction());
6419                     })
6420                     .forShortcutWithId("ms4", si -> {
6421                         assertEquals(si.getId(), Intent.ACTION_VIEW, si.getIntent().getAction());
6422                     })
6423                     .forShortcutWithId("ms5", si -> {
6424                         assertEquals(si.getId(), "action", si.getIntent().getAction());
6425                     });
6426         });
6427     }
6428 
testManifestShortcuts_checkAllFields()6429     public void testManifestShortcuts_checkAllFields() {
6430         mService.handleUnlockUser(USER_0);
6431 
6432         // Package 1 updated, which has one valid manifest shortcut and one invalid.
6433         addManifestShortcutResource(
6434                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6435                 R.xml.shortcut_5);
6436         updatePackageVersion(CALLING_PACKAGE_1, 1);
6437                 mService.mPackageMonitor.onReceive(getTestContext(),
6438                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6439 
6440         // Only the valid one is published.
6441         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6442             assertWith(getCallerShortcuts())
6443                     .haveIds("ms1", "ms2", "ms3", "ms4", "ms5")
6444                     .areAllManifest()
6445                     .areAllImmutable()
6446                     .areAllEnabled()
6447                     .areAllNotPinned()
6448                     .areAllNotDynamic()
6449 
6450                     .forShortcutWithId("ms1", si -> {
6451                         assertEquals(R.drawable.icon1, si.getIconResourceId());
6452                         assertEquals(new ComponentName(CALLING_PACKAGE_1,
6453                                 ShortcutActivity.class.getName()),
6454                                 si.getActivity());
6455 
6456                         assertEquals(R.string.shortcut_title1, si.getTitleResId());
6457                         assertEquals("r" + R.string.shortcut_title1, si.getTitleResName());
6458                         assertEquals(R.string.shortcut_text1, si.getTextResId());
6459                         assertEquals("r" + R.string.shortcut_text1, si.getTextResName());
6460                         assertEquals(R.string.shortcut_disabled_message1,
6461                                 si.getDisabledMessageResourceId());
6462                         assertEquals("r" + R.string.shortcut_disabled_message1,
6463                                 si.getDisabledMessageResName());
6464 
6465                         assertEquals(set("android.shortcut.conversation", "android.shortcut.media"),
6466                                 si.getCategories());
6467                         assertEquals("action1", si.getIntent().getAction());
6468                         assertEquals(Uri.parse("http://a.b.c/1"), si.getIntent().getData());
6469                     })
6470 
6471                     .forShortcutWithId("ms2", si -> {
6472                         assertEquals("ms2", si.getId());
6473                         assertEquals(R.drawable.icon2, si.getIconResourceId());
6474 
6475                         assertEquals(R.string.shortcut_title2, si.getTitleResId());
6476                         assertEquals("r" + R.string.shortcut_title2, si.getTitleResName());
6477                         assertEquals(R.string.shortcut_text2, si.getTextResId());
6478                         assertEquals("r" + R.string.shortcut_text2, si.getTextResName());
6479                         assertEquals(R.string.shortcut_disabled_message2,
6480                                 si.getDisabledMessageResourceId());
6481                         assertEquals("r" + R.string.shortcut_disabled_message2,
6482                                 si.getDisabledMessageResName());
6483 
6484                         assertEquals(set("android.shortcut.conversation"), si.getCategories());
6485                         assertEquals("action2", si.getIntent().getAction());
6486                         assertEquals(null, si.getIntent().getData());
6487                     })
6488 
6489                     .forShortcutWithId("ms3", si -> {
6490                         assertEquals(0, si.getIconResourceId());
6491                         assertEquals(R.string.shortcut_title1, si.getTitleResId());
6492                         assertEquals("r" + R.string.shortcut_title1, si.getTitleResName());
6493 
6494                         assertEquals(0, si.getTextResId());
6495                         assertEquals(null, si.getTextResName());
6496                         assertEquals(0, si.getDisabledMessageResourceId());
6497                         assertEquals(null, si.getDisabledMessageResName());
6498 
6499                         assertEmpty(si.getCategories());
6500                         assertEquals("android.intent.action.VIEW", si.getIntent().getAction());
6501                         assertEquals(null, si.getIntent().getData());
6502                     })
6503 
6504                     .forShortcutWithId("ms4", si -> {
6505                         assertEquals(0, si.getIconResourceId());
6506                         assertEquals(R.string.shortcut_title2, si.getTitleResId());
6507                         assertEquals("r" + R.string.shortcut_title2, si.getTitleResName());
6508 
6509                         assertEquals(0, si.getTextResId());
6510                         assertEquals(null, si.getTextResName());
6511                         assertEquals(0, si.getDisabledMessageResourceId());
6512                         assertEquals(null, si.getDisabledMessageResName());
6513 
6514                         assertEquals(set("cat"), si.getCategories());
6515                         assertEquals("android.intent.action.VIEW2", si.getIntent().getAction());
6516                         assertEquals(null, si.getIntent().getData());
6517                     })
6518 
6519                     .forShortcutWithId("ms5", si -> {
6520                         si = getCallerShortcut("ms5");
6521                         assertEquals("action", si.getIntent().getAction());
6522                         assertEquals("http://www/", si.getIntent().getData().toString());
6523                         assertEquals("foo/bar", si.getIntent().getType());
6524                         assertEquals(
6525                                 new ComponentName("abc", ".xyz"), si.getIntent().getComponent());
6526 
6527                         assertEquals(set("cat1", "cat2"), si.getIntent().getCategories());
6528                         assertEquals("value1", si.getIntent().getStringExtra("key1"));
6529                         assertEquals("value2", si.getIntent().getStringExtra("key2"));
6530                     });
6531         });
6532     }
6533 
testManifestShortcuts_localeChange()6534     public void testManifestShortcuts_localeChange() throws InterruptedException {
6535         mService.handleUnlockUser(USER_0);
6536 
6537         // Package 1 updated, which has one valid manifest shortcut and one invalid.
6538         addManifestShortcutResource(
6539                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6540                 R.xml.shortcut_2);
6541         updatePackageVersion(CALLING_PACKAGE_1, 1);
6542                 mService.mPackageMonitor.onReceive(getTestContext(),
6543                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6544 
6545         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6546             mManager.setDynamicShortcuts(list(makeShortcutWithTitle("s1", "title")));
6547 
6548             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6549                     mManager.getManifestShortcuts()))),
6550                     "ms1", "ms2");
6551 
6552             // check first shortcut.
6553             ShortcutInfo si = getCallerShortcut("ms1");
6554 
6555             assertEquals("ms1", si.getId());
6556             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_title1 + "/en",
6557                     si.getTitle());
6558             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_text1 + "/en",
6559                     si.getText());
6560             assertEquals("string-com.android.test.1-user:0-res:"
6561                             + R.string.shortcut_disabled_message1 + "/en",
6562                     si.getDisabledMessage());
6563             assertEquals(START_TIME, si.getLastChangedTimestamp());
6564 
6565             // check another
6566             si = getCallerShortcut("ms2");
6567 
6568             assertEquals("ms2", si.getId());
6569             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_title2 + "/en",
6570                     si.getTitle());
6571             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_text2 + "/en",
6572                     si.getText());
6573             assertEquals("string-com.android.test.1-user:0-res:"
6574                             + R.string.shortcut_disabled_message2 + "/en",
6575                     si.getDisabledMessage());
6576             assertEquals(START_TIME, si.getLastChangedTimestamp());
6577 
6578             // Check the dynamic one.
6579             si = getCallerShortcut("s1");
6580 
6581             assertEquals("s1", si.getId());
6582             assertEquals("title", si.getTitle());
6583             assertEquals(null, si.getText());
6584             assertEquals(null, si.getDisabledMessage());
6585             assertEquals(START_TIME, si.getLastChangedTimestamp());
6586         });
6587 
6588         mInjectedCurrentTimeMillis++;
6589 
6590         // Change the locale and send the broadcast, make sure the launcher gets a callback too.
6591         mInjectedLocale = Locale.JAPANESE;
6592 
6593         setCaller(LAUNCHER_1, USER_0);
6594 
6595         assertForLauncherCallback(mLauncherApps, () -> {
6596             mService.mReceiver.onReceive(mServiceContext, new Intent(Intent.ACTION_LOCALE_CHANGED));
6597         }).assertCallbackCalledForPackageAndUser(CALLING_PACKAGE_1, HANDLE_USER_0)
6598                 .haveIds("ms1", "ms2", "s1");
6599 
6600         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6601             // check first shortcut.
6602             ShortcutInfo si = getCallerShortcut("ms1");
6603 
6604             assertEquals("ms1", si.getId());
6605             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_title1 + "/ja",
6606                     si.getTitle());
6607             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_text1 + "/ja",
6608                     si.getText());
6609             assertEquals("string-com.android.test.1-user:0-res:"
6610                             + R.string.shortcut_disabled_message1 + "/ja",
6611                     si.getDisabledMessage());
6612             assertEquals(START_TIME + 1, si.getLastChangedTimestamp());
6613 
6614             // check another
6615             si = getCallerShortcut("ms2");
6616 
6617             assertEquals("ms2", si.getId());
6618             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_title2 + "/ja",
6619                     si.getTitle());
6620             assertEquals("string-com.android.test.1-user:0-res:" + R.string.shortcut_text2 + "/ja",
6621                     si.getText());
6622             assertEquals("string-com.android.test.1-user:0-res:"
6623                             + R.string.shortcut_disabled_message2 + "/ja",
6624                     si.getDisabledMessage());
6625             assertEquals(START_TIME + 1, si.getLastChangedTimestamp());
6626 
6627             // Check the dynamic one.  (locale change shouldn't affect.)
6628             si = getCallerShortcut("s1");
6629 
6630             assertEquals("s1", si.getId());
6631             assertEquals("title", si.getTitle());
6632             assertEquals(null, si.getText());
6633             assertEquals(null, si.getDisabledMessage());
6634             assertEquals(START_TIME, si.getLastChangedTimestamp()); // Not changed.
6635         });
6636     }
6637 
testManifestShortcuts_updateAndDisabled_notPinned()6638     public void testManifestShortcuts_updateAndDisabled_notPinned() {
6639         mService.handleUnlockUser(USER_0);
6640 
6641         // First, just publish a manifest shortcut.
6642         addManifestShortcutResource(
6643                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6644                 R.xml.shortcut_1);
6645         updatePackageVersion(CALLING_PACKAGE_1, 1);
6646                 mService.mPackageMonitor.onReceive(getTestContext(),
6647                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6648 
6649         // Only the valid one is published.
6650         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6651             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6652                     mManager.getManifestShortcuts()))),
6653                     "ms1");
6654             assertEmpty(mManager.getPinnedShortcuts());
6655 
6656             // Make sure there's no other dangling shortcuts.
6657             assertShortcutIds(getCallerShortcuts(), "ms1");
6658         });
6659 
6660         // Now version up, the manifest shortcut is disabled now.
6661         addManifestShortcutResource(
6662                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6663                 R.xml.shortcut_1_disable);
6664         updatePackageVersion(CALLING_PACKAGE_1, 1);
6665                 mService.mPackageMonitor.onReceive(getTestContext(),
6666                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6667 
6668         // Because shortcut 1 wasn't pinned, it'll just go away.
6669         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6670             assertEmpty(mManager.getManifestShortcuts());
6671             assertEmpty(mManager.getPinnedShortcuts());
6672 
6673             // Make sure there's no other dangling shortcuts.
6674             assertEmpty(getCallerShortcuts());
6675         });
6676     }
6677 
testManifestShortcuts_updateAndDisabled_pinned()6678     public void testManifestShortcuts_updateAndDisabled_pinned() {
6679         mService.handleUnlockUser(USER_0);
6680 
6681         // First, just publish a manifest shortcut.
6682         addManifestShortcutResource(
6683                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6684                 R.xml.shortcut_1);
6685         updatePackageVersion(CALLING_PACKAGE_1, 1);
6686                 mService.mPackageMonitor.onReceive(getTestContext(),
6687                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6688 
6689         // Only the valid one is published.
6690         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6691             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6692                     mManager.getManifestShortcuts()))),
6693                     "ms1");
6694             assertEmpty(mManager.getPinnedShortcuts());
6695 
6696             // Make sure there's no other dangling shortcuts.
6697             assertShortcutIds(getCallerShortcuts(), "ms1");
6698         });
6699 
6700         runWithCaller(LAUNCHER_1, USER_0, () -> {
6701             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms1"), HANDLE_USER_0);
6702         });
6703 
6704         // Now upgrade, the manifest shortcut is disabled now.
6705         addManifestShortcutResource(
6706                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6707                 R.xml.shortcut_1_disable);
6708         updatePackageVersion(CALLING_PACKAGE_1, 1);
6709                 mService.mPackageMonitor.onReceive(getTestContext(),
6710                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6711 
6712         // Because shortcut 1 was pinned, it'll still exist as pinned, but disabled.
6713         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6714             assertEmpty(mManager.getManifestShortcuts());
6715             assertShortcutIds(assertAllNotManifest(assertAllImmutable(assertAllDisabled(
6716                     mManager.getPinnedShortcuts()))),
6717                     "ms1");
6718 
6719             // Make sure the fields are updated.
6720             ShortcutInfo si = getCallerShortcut("ms1");
6721 
6722             assertEquals("ms1", si.getId());
6723             assertEquals(R.drawable.icon2, si.getIconResourceId());
6724             assertEquals(R.string.shortcut_title2, si.getTitleResId());
6725             assertEquals(R.string.shortcut_text2, si.getTextResId());
6726             assertEquals(R.string.shortcut_disabled_message2, si.getDisabledMessageResourceId());
6727             assertEquals(Intent.ACTION_VIEW, si.getIntent().getAction());
6728 
6729             // Make sure there's no other dangling shortcuts.
6730             assertShortcutIds(getCallerShortcuts(), "ms1");
6731         });
6732     }
6733 
testManifestShortcuts_duplicateInSingleActivity()6734     public void testManifestShortcuts_duplicateInSingleActivity() {
6735         mService.handleUnlockUser(USER_0);
6736 
6737         // The XML has two shortcuts with the same ID.
6738         addManifestShortcutResource(
6739                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6740                 R.xml.shortcut_2_duplicate);
6741         updatePackageVersion(CALLING_PACKAGE_1, 1);
6742                 mService.mPackageMonitor.onReceive(getTestContext(),
6743                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6744 
6745         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6746             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6747                     mManager.getManifestShortcuts()))),
6748                     "ms1");
6749 
6750             // Make sure the first one has survived.  (the second one has a different title.)
6751             ShortcutInfo si = getCallerShortcut("ms1");
6752             assertEquals(R.string.shortcut_title1, si.getTitleResId());
6753 
6754             // Make sure there's no other dangling shortcuts.
6755             assertShortcutIds(getCallerShortcuts(), "ms1");
6756         });
6757     }
6758 
testManifestShortcuts_duplicateInTwoActivities()6759     public void testManifestShortcuts_duplicateInTwoActivities() {
6760         mService.handleUnlockUser(USER_0);
6761 
6762         // ShortcutActivity has shortcut ms1
6763         addManifestShortcutResource(
6764                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6765                 R.xml.shortcut_1);
6766 
6767         // ShortcutActivity2 has two shortcuts, ms1 and ms2.
6768         addManifestShortcutResource(
6769                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity2.class.getName()),
6770                 R.xml.shortcut_5);
6771         updatePackageVersion(CALLING_PACKAGE_1, 1);
6772                 mService.mPackageMonitor.onReceive(getTestContext(),
6773                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6774 
6775         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6776             assertShortcutIds(assertAllManifest(assertAllImmutable(assertAllEnabled(
6777                     mManager.getManifestShortcuts()))),
6778                     "ms1", "ms2", "ms3", "ms4", "ms5");
6779 
6780             // ms1 should belong to ShortcutActivity.
6781             ShortcutInfo si = getCallerShortcut("ms1");
6782             assertEquals(R.string.shortcut_title1, si.getTitleResId());
6783             assertEquals(new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6784                     si.getActivity());
6785             assertEquals(0, si.getRank());
6786 
6787             // ms2 should belong to ShortcutActivity*2*.
6788             si = getCallerShortcut("ms2");
6789             assertEquals(R.string.shortcut_title2, si.getTitleResId());
6790             assertEquals(new ComponentName(CALLING_PACKAGE_1, ShortcutActivity2.class.getName()),
6791                     si.getActivity());
6792 
6793             // Also check the ranks
6794             assertWith(getCallerShortcuts()).selectManifest()
6795                     .selectByActivity(
6796                             new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()))
6797                     .haveRanksInOrder("ms1");
6798             assertWith(getCallerShortcuts()).selectManifest()
6799                     .selectByActivity(
6800                             new ComponentName(CALLING_PACKAGE_1, ShortcutActivity2.class.getName()))
6801                     .haveRanksInOrder("ms2", "ms3", "ms4", "ms5");
6802 
6803             // Make sure there's no other dangling shortcuts.
6804             assertShortcutIds(getCallerShortcuts(), "ms1", "ms2", "ms3", "ms4", "ms5");
6805         });
6806     }
6807 
6808     /**
6809      * Manifest shortcuts cannot override shortcuts that were published via the APIs.
6810      */
testManifestShortcuts_cannotOverrideNonManifest()6811     public void testManifestShortcuts_cannotOverrideNonManifest() {
6812         mService.handleUnlockUser(USER_0);
6813 
6814         // Create a non-pinned dynamic shortcut and a non-dynamic pinned shortcut.
6815 
6816         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6817             mManager.setDynamicShortcuts(list(
6818                     makeShortcut("ms1", "title1",
6819                             new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6820                     /* icon */ null, new Intent("action1"), /* rank */ 0),
6821                     makeShortcut("ms2", "title2",
6822                             new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6823                     /* icon */ null, new Intent("action1"), /* rank */ 0)));
6824         });
6825 
6826         runWithCaller(LAUNCHER_1, USER_0, () -> {
6827             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms2"), HANDLE_USER_0);
6828         });
6829 
6830         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6831             mManager.removeDynamicShortcuts(list("ms2"));
6832 
6833             assertShortcutIds(mManager.getDynamicShortcuts(), "ms1");
6834             assertShortcutIds(mManager.getPinnedShortcuts(), "ms2");
6835             assertEmpty(mManager.getManifestShortcuts());
6836         });
6837 
6838         // Then update the app with 5 manifest shortcuts.
6839         // Make sure "ms1" and "ms2" won't be replaced.
6840         addManifestShortcutResource(
6841                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6842                 R.xml.shortcut_5);
6843         updatePackageVersion(CALLING_PACKAGE_1, 1);
6844                 mService.mPackageMonitor.onReceive(getTestContext(),
6845                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6846 
6847         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6848             assertShortcutIds(assertAllNotManifest(mManager.getDynamicShortcuts()), "ms1");
6849             assertShortcutIds(assertAllNotManifest(mManager.getPinnedShortcuts()), "ms2");
6850             assertShortcutIds(assertAllManifest(mManager.getManifestShortcuts()),
6851                     "ms3", "ms4", "ms5");
6852 
6853             // ms1 and ms2 shouold keep the original title.
6854             ShortcutInfo si = getCallerShortcut("ms1");
6855             assertEquals("title1", si.getTitle());
6856 
6857             si = getCallerShortcut("ms2");
6858             assertEquals("title2", si.getTitle());
6859         });
6860     }
6861 
checkManifestShortcuts_immutable_verify()6862     protected void checkManifestShortcuts_immutable_verify() {
6863         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6864             assertShortcutIds(assertAllNotManifest(assertAllEnabled(
6865                     mManager.getDynamicShortcuts())),
6866                     "s1");
6867             assertShortcutIds(assertAllManifest(assertAllEnabled(
6868                     mManager.getManifestShortcuts())),
6869                     "ms1");
6870             assertShortcutIds(assertAllNotManifest(assertAllDisabled(
6871                     mManager.getPinnedShortcuts())),
6872                     "ms2");
6873 
6874             assertEquals("t1", getCallerShortcut("s1").getTitle());
6875 
6876             // Make sure there are no other shortcuts.
6877             assertShortcutIds(getCallerShortcuts(), "s1", "ms1", "ms2");
6878         });
6879     }
6880 
6881     /**
6882      * Make sure the APIs won't work on manifest shortcuts.
6883      */
testManifestShortcuts_immutable()6884     public void testManifestShortcuts_immutable() {
6885         mService.handleUnlockUser(USER_0);
6886 
6887         // Create a non-pinned manifest shortcut, a pinned shortcut that was originally
6888         // a manifest shortcut, as well as a dynamic shortcut.
6889 
6890         addManifestShortcutResource(
6891                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6892                 R.xml.shortcut_2);
6893         updatePackageVersion(CALLING_PACKAGE_1, 1);
6894                 mService.mPackageMonitor.onReceive(getTestContext(),
6895                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6896 
6897         runWithCaller(LAUNCHER_1, USER_0, () -> {
6898             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("ms2"), HANDLE_USER_0);
6899         });
6900 
6901         addManifestShortcutResource(
6902                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6903                 R.xml.shortcut_1);
6904         updatePackageVersion(CALLING_PACKAGE_1, 1);
6905                 mService.mPackageMonitor.onReceive(getTestContext(),
6906                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6907 
6908         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6909             mManager.addDynamicShortcuts(list(makeShortcutWithTitle("s1", "t1")));
6910         });
6911 
6912         checkManifestShortcuts_immutable_verify();
6913 
6914         // Note that even though the first argument is not immutable and only the second one
6915         // is immutable, the first argument should not be executed either.
6916 
6917         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6918             assertCannotUpdateImmutable(() -> {
6919                 mManager.setDynamicShortcuts(list(makeShortcut("xx"), makeShortcut("ms1")));
6920             });
6921             assertCannotUpdateImmutable(() -> {
6922                 mManager.setDynamicShortcuts(list(makeShortcut("xx"), makeShortcut("ms2")));
6923             });
6924         });
6925         checkManifestShortcuts_immutable_verify();
6926 
6927         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6928             assertCannotUpdateImmutable(() -> {
6929                 mManager.addDynamicShortcuts(list(makeShortcut("xx"), makeShortcut("ms1")));
6930             });
6931             assertCannotUpdateImmutable(() -> {
6932                 mManager.addDynamicShortcuts(list(makeShortcut("xx"), makeShortcut("ms2")));
6933             });
6934         });
6935         checkManifestShortcuts_immutable_verify();
6936 
6937 
6938         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6939             assertCannotUpdateImmutable(() -> {
6940                 mManager.updateShortcuts(list(makeShortcut("s1"), makeShortcut("ms1")));
6941             });
6942             assertCannotUpdateImmutable(() -> {
6943                 mManager.updateShortcuts(list(makeShortcut("s1"), makeShortcut("ms2")));
6944             });
6945         });
6946         checkManifestShortcuts_immutable_verify();
6947 
6948         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6949             assertCannotUpdateImmutable(() -> {
6950                 mManager.removeDynamicShortcuts(list("s1", "ms1"));
6951             });
6952             assertCannotUpdateImmutable(() -> {
6953                 mManager.removeDynamicShortcuts(list("s2", "ms2"));
6954             });
6955         });
6956         checkManifestShortcuts_immutable_verify();
6957 
6958         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6959             assertCannotUpdateImmutable(() -> {
6960                 mManager.disableShortcuts(list("s1", "ms1"));
6961             });
6962         });
6963         checkManifestShortcuts_immutable_verify();
6964 
6965         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6966             assertCannotUpdateImmutable(() -> {
6967                 mManager.enableShortcuts(list("s1", "ms2"));
6968             });
6969         });
6970         checkManifestShortcuts_immutable_verify();
6971     }
6972 
6973 
6974     /**
6975      * Make sure the APIs won't work on manifest shortcuts.
6976      */
testManifestShortcuts_tooMany()6977     public void testManifestShortcuts_tooMany() {
6978         // Change the max number of shortcuts.
6979         mService.updateConfigurationLocked(ConfigConstants.KEY_MAX_SHORTCUTS + "=3");
6980 
6981         mService.handleUnlockUser(USER_0);
6982 
6983         addManifestShortcutResource(
6984                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
6985                 R.xml.shortcut_5);
6986         updatePackageVersion(CALLING_PACKAGE_1, 1);
6987                 mService.mPackageMonitor.onReceive(getTestContext(),
6988                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
6989 
6990         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
6991             // Only the first 3 should be published.
6992             assertShortcutIds(mManager.getManifestShortcuts(), "ms1", "ms2", "ms3");
6993         });
6994     }
6995 
testMaxShortcutCount_set()6996     public void testMaxShortcutCount_set() {
6997         // Change the max number of shortcuts.
6998         mService.updateConfigurationLocked(ConfigConstants.KEY_MAX_SHORTCUTS + "=3");
6999 
7000         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
7001             final ComponentName a1 = new ComponentName(mClientContext, ShortcutActivity.class);
7002             final ComponentName a2 = new ComponentName(mClientContext, ShortcutActivity2.class);
7003             final ShortcutInfo s1_1 = makeShortcutWithActivity("s11", a1);
7004             final ShortcutInfo s1_2 = makeShortcutWithActivity("s12", a1);
7005             final ShortcutInfo s1_3 = makeShortcutWithActivity("s13", a1);
7006             final ShortcutInfo s1_4 = makeShortcutWithActivity("s14", a1);
7007             final ShortcutInfo s1_5 = makeShortcutWithActivity("s15", a1);
7008             final ShortcutInfo s1_6 = makeShortcutWithActivity("s16", a1);
7009             final ShortcutInfo s2_1 = makeShortcutWithActivity("s21", a2);
7010             final ShortcutInfo s2_2 = makeShortcutWithActivity("s22", a2);
7011             final ShortcutInfo s2_3 = makeShortcutWithActivity("s23", a2);
7012             final ShortcutInfo s2_4 = makeShortcutWithActivity("s24", a2);
7013 
7014             // 3 shortcuts for 2 activities -> okay
7015             mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3, s2_1, s2_2, s2_3));
7016             assertShortcutIds(mManager.getDynamicShortcuts(),
7017                     "s11", "s12", "s13", "s21", "s22", "s23");
7018 
7019             mManager.removeAllDynamicShortcuts();
7020 
7021             // 4 shortcut for activity 1 -> too many.
7022             assertDynamicShortcutCountExceeded(() -> {
7023                 mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3, s1_4, s2_1, s2_2, s2_3));
7024             });
7025             assertEmpty(mManager.getDynamicShortcuts());
7026 
7027             // 4 shortcut for activity 2 -> too many.
7028             assertDynamicShortcutCountExceeded(() -> {
7029                 mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3, s2_1, s2_2, s2_3, s2_4));
7030             });
7031             assertEmpty(mManager.getDynamicShortcuts());
7032 
7033             // First, set 3.  Then set 4, which should be ignored.
7034             mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3));
7035             assertShortcutIds(mManager.getDynamicShortcuts(),
7036                     "s11", "s12", "s13");
7037             assertDynamicShortcutCountExceeded(() -> {
7038                 mManager.setDynamicShortcuts(list(s2_1, s2_2, s2_3, s2_4));
7039             });
7040             assertShortcutIds(mManager.getDynamicShortcuts(),
7041                     "s11", "s12", "s13");
7042 
7043             // Set will remove the old dynamic set, unlike add, so the following should pass.
7044             mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3));
7045             assertShortcutIds(mManager.getDynamicShortcuts(),
7046                     "s11", "s12", "s13");
7047             mManager.setDynamicShortcuts(list(s1_4, s1_5, s1_6));
7048             assertShortcutIds(mManager.getDynamicShortcuts(),
7049                     "s14", "s15", "s16");
7050 
7051             // Now, test with 2 manifest shortcuts.
7052             mManager.removeAllDynamicShortcuts();
7053             addManifestShortcutResource(
7054                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
7055                     R.xml.shortcut_2);
7056             updatePackageVersion(CALLING_PACKAGE_1, 1);
7057                     mService.mPackageMonitor.onReceive(getTestContext(),
7058                     genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
7059             assertEquals(2, mManager.getManifestShortcuts().size());
7060 
7061             // Setting 1 to activity 1 will work.
7062             mManager.setDynamicShortcuts(list(s1_1, s2_1, s2_2, s2_3));
7063             assertShortcutIds(mManager.getDynamicShortcuts(),
7064                     "s11", "s21", "s22", "s23");
7065             assertEquals(2, mManager.getManifestShortcuts().size());
7066 
7067             // But setting 2 will not.
7068             mManager.removeAllDynamicShortcuts();
7069             assertDynamicShortcutCountExceeded(() -> {
7070                 mManager.setDynamicShortcuts(list(s1_1, s1_2, s2_1, s2_2, s2_3));
7071             });
7072             assertEmpty(mManager.getDynamicShortcuts());
7073             assertEquals(2, mManager.getManifestShortcuts().size());
7074         });
7075     }
7076 
testMaxShortcutCount_add()7077     public void testMaxShortcutCount_add() {
7078         // Change the max number of shortcuts.
7079         mService.updateConfigurationLocked(ConfigConstants.KEY_MAX_SHORTCUTS + "=3");
7080 
7081         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
7082             final ComponentName a1 = new ComponentName(mClientContext, ShortcutActivity.class);
7083             final ComponentName a2 = new ComponentName(mClientContext, ShortcutActivity2.class);
7084             final ShortcutInfo s1_1 = makeShortcutWithActivity("s11", a1);
7085             final ShortcutInfo s1_2 = makeShortcutWithActivity("s12", a1);
7086             final ShortcutInfo s1_3 = makeShortcutWithActivity("s13", a1);
7087             final ShortcutInfo s1_4 = makeShortcutWithActivity("s14", a1);
7088             final ShortcutInfo s2_1 = makeShortcutWithActivity("s21", a2);
7089             final ShortcutInfo s2_2 = makeShortcutWithActivity("s22", a2);
7090             final ShortcutInfo s2_3 = makeShortcutWithActivity("s23", a2);
7091             final ShortcutInfo s2_4 = makeShortcutWithActivity("s24", a2);
7092 
7093             // 3 shortcuts for 2 activities -> okay
7094             mManager.addDynamicShortcuts(list(s1_1, s1_2, s1_3, s2_1, s2_2, s2_3));
7095             assertShortcutIds(mManager.getDynamicShortcuts(),
7096                     "s11", "s12", "s13", "s21", "s22", "s23");
7097 
7098             mManager.removeAllDynamicShortcuts();
7099 
7100             // 4 shortcut for activity 1 -> too many.
7101             assertDynamicShortcutCountExceeded(() -> {
7102                 mManager.addDynamicShortcuts(list(s1_1, s1_2, s1_3, s1_4, s2_1, s2_2, s2_3));
7103             });
7104             assertEmpty(mManager.getDynamicShortcuts());
7105 
7106             // 4 shortcut for activity 2 -> too many.
7107             assertDynamicShortcutCountExceeded(() -> {
7108                 mManager.addDynamicShortcuts(list(s1_1, s1_2, s1_3, s2_1, s2_2, s2_3, s2_4));
7109             });
7110             assertEmpty(mManager.getDynamicShortcuts());
7111 
7112             // First, set 3.  Then add 1 more, which should be ignored.
7113             mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3));
7114             assertShortcutIds(mManager.getDynamicShortcuts(),
7115                     "s11", "s12", "s13");
7116             assertDynamicShortcutCountExceeded(() -> {
7117                 mManager.addDynamicShortcuts(list(s1_4, s2_1));
7118             });
7119             assertShortcutIds(mManager.getDynamicShortcuts(),
7120                     "s11", "s12", "s13");
7121 
7122             // Update existing one, which should work.
7123             mManager.addDynamicShortcuts(list(makeShortcutWithActivityAndTitle(
7124                     "s11", a1, "xxx"), s2_1));
7125             assertShortcutIds(mManager.getDynamicShortcuts(),
7126                     "s11", "s12", "s13", "s21");
7127             assertEquals("xxx", getCallerShortcut("s11").getTitle());
7128 
7129             // Make sure pinned shortcuts won't affect.
7130             // - Pin s11 - s13, and remove all dynamic.
7131             runWithCaller(LAUNCHER_1, USER_0, () -> {
7132                 mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s11", "s12", "s13"),
7133                         HANDLE_USER_0);
7134             });
7135             mManager.removeAllDynamicShortcuts();
7136 
7137             assertEmpty(mManager.getDynamicShortcuts());
7138             assertShortcutIds(mManager.getPinnedShortcuts(),
7139                     "s11", "s12", "s13");
7140 
7141             // Then add dynamic.
7142             mManager.addDynamicShortcuts(list(s1_4, s2_1, s2_2, s2_3));
7143 
7144             assertShortcutIds(mManager.getDynamicShortcuts(),
7145                     "s14", "s21", "s22", "s23");
7146             assertShortcutIds(mManager.getPinnedShortcuts(),
7147                     "s11", "s12", "s13");
7148 
7149             // Adding "s11" and "s12" back, should work
7150             mManager.addDynamicShortcuts(list(s1_1, s1_2));
7151 
7152             assertShortcutIds(mManager.getDynamicShortcuts(),
7153                     "s14", "s11", "s12", "s21", "s22", "s23");
7154             assertShortcutIds(mManager.getPinnedShortcuts(),
7155                     "s11", "s12", "s13");
7156 
7157             // Adding back s13 doesn't work.
7158             assertDynamicShortcutCountExceeded(() -> {
7159                 mManager.addDynamicShortcuts(list(s1_3));
7160             });
7161 
7162             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a1),
7163                     "s11", "s12", "s14");
7164             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a2),
7165                     "s21", "s22", "s23");
7166 
7167             // Now swap the activities.
7168             mManager.updateShortcuts(list(
7169                     makeShortcutWithActivity("s11", a2),
7170                     makeShortcutWithActivity("s21", a1)));
7171 
7172             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a1),
7173                     "s21", "s12", "s14");
7174             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a2),
7175                     "s11", "s22", "s23");
7176 
7177             // Now, test with 2 manifest shortcuts.
7178             mManager.removeAllDynamicShortcuts();
7179             addManifestShortcutResource(
7180                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
7181                     R.xml.shortcut_2);
7182             updatePackageVersion(CALLING_PACKAGE_1, 1);
7183                     mService.mPackageMonitor.onReceive(getTestContext(),
7184                     genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
7185 
7186             assertEquals(2, mManager.getManifestShortcuts().size());
7187 
7188             // Adding one shortcut to activity 1 works fine.
7189             mManager.addDynamicShortcuts(list(s1_1, s2_1, s2_2, s2_3));
7190             assertShortcutIds(mManager.getDynamicShortcuts(),
7191                     "s11", "s21", "s22", "s23");
7192             assertEquals(2, mManager.getManifestShortcuts().size());
7193 
7194             // But adding one more doesn't.
7195             assertDynamicShortcutCountExceeded(() -> {
7196                 mManager.addDynamicShortcuts(list(s1_4, s2_1));
7197             });
7198             assertShortcutIds(mManager.getDynamicShortcuts(),
7199                     "s11", "s21", "s22", "s23");
7200             assertEquals(2, mManager.getManifestShortcuts().size());
7201         });
7202     }
7203 
testMaxShortcutCount_update()7204     public void testMaxShortcutCount_update() {
7205         // Change the max number of shortcuts.
7206         mService.updateConfigurationLocked(ConfigConstants.KEY_MAX_SHORTCUTS + "=3");
7207 
7208         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
7209             final ComponentName a1 = new ComponentName(mClientContext, ShortcutActivity.class);
7210             final ComponentName a2 = new ComponentName(mClientContext, ShortcutActivity2.class);
7211             final ShortcutInfo s1_1 = makeShortcutWithActivity("s11", a1);
7212             final ShortcutInfo s1_2 = makeShortcutWithActivity("s12", a1);
7213             final ShortcutInfo s1_3 = makeShortcutWithActivity("s13", a1);
7214             final ShortcutInfo s1_4 = makeShortcutWithActivity("s14", a1);
7215             final ShortcutInfo s1_5 = makeShortcutWithActivity("s15", a1);
7216             final ShortcutInfo s2_1 = makeShortcutWithActivity("s21", a2);
7217             final ShortcutInfo s2_2 = makeShortcutWithActivity("s22", a2);
7218             final ShortcutInfo s2_3 = makeShortcutWithActivity("s23", a2);
7219             final ShortcutInfo s2_4 = makeShortcutWithActivity("s24", a2);
7220 
7221             // 3 shortcuts for 2 activities -> okay
7222             mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3, s2_1, s2_2, s2_3));
7223             assertShortcutIds(mManager.getDynamicShortcuts(),
7224                     "s11", "s12", "s13", "s21", "s22", "s23");
7225 
7226             // Trying to move s11 from a1 to a2 should fail.
7227             assertDynamicShortcutCountExceeded(() -> {
7228                 mManager.updateShortcuts(list(makeShortcutWithActivity("s11", a2)));
7229             });
7230             assertShortcutIds(mManager.getDynamicShortcuts(),
7231                     "s11", "s12", "s13", "s21", "s22", "s23");
7232 
7233             // Trying to move s21 from a2 to a1 should also fail.
7234             assertDynamicShortcutCountExceeded(() -> {
7235                 mManager.updateShortcuts(list(makeShortcutWithActivity("s21", a1)));
7236             });
7237             assertShortcutIds(mManager.getDynamicShortcuts(),
7238                     "s11", "s12", "s13", "s21", "s22", "s23");
7239 
7240             // But, if we do these two at the same time, it should work.
7241             mManager.updateShortcuts(list(
7242                     makeShortcutWithActivity("s11", a2),
7243                     makeShortcutWithActivity("s21", a1)));
7244             assertShortcutIds(mManager.getDynamicShortcuts(),
7245                     "s11", "s12", "s13", "s21", "s22", "s23");
7246             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a1),
7247                     "s21", "s12", "s13");
7248             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a2),
7249                     "s11", "s22", "s23");
7250 
7251             // Then reset.
7252             mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3, s2_1, s2_2, s2_3));
7253             assertShortcutIds(mManager.getDynamicShortcuts(),
7254                     "s11", "s12", "s13", "s21", "s22", "s23");
7255 
7256             // Pin some to have more shortcuts for a1.
7257             runWithCaller(LAUNCHER_1, USER_0, () -> {
7258                 mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s11", "s12", "s13"),
7259                         HANDLE_USER_0);
7260             });
7261             mManager.setDynamicShortcuts(list(s1_4, s1_5, s2_1, s2_2, s2_3));
7262             assertShortcutIds(mManager.getDynamicShortcuts(),
7263                     "s14", "s15", "s21", "s22", "s23");
7264             assertShortcutIds(mManager.getPinnedShortcuts(),
7265                     "s11", "s12", "s13");
7266 
7267             // a1 already has 2 dynamic shortcuts (and 3 pinned shortcuts that used to belong on it)
7268             // But that doesn't matter for update -- the following should still work.
7269             mManager.updateShortcuts(list(
7270                     makeShortcutWithActivityAndTitle("s11", a1, "xxx1"),
7271                     makeShortcutWithActivityAndTitle("s12", a1, "xxx2"),
7272                     makeShortcutWithActivityAndTitle("s13", a1, "xxx3"),
7273                     makeShortcutWithActivityAndTitle("s14", a1, "xxx4"),
7274                     makeShortcutWithActivityAndTitle("s15", a1, "xxx5")));
7275             // All the shortcuts should still exist they all belong on same activities,
7276             // with the updated titles.
7277             assertShortcutIds(mManager.getDynamicShortcuts(),
7278                     "s14", "s15", "s21", "s22", "s23");
7279             assertShortcutIds(mManager.getPinnedShortcuts(),
7280                     "s11", "s12", "s13");
7281 
7282             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a1),
7283                     "s14", "s15");
7284             assertShortcutIds(filterByActivity(mManager.getDynamicShortcuts(), a2),
7285                     "s21", "s22", "s23");
7286 
7287             assertEquals("xxx1", getCallerShortcut("s11").getTitle());
7288             assertEquals("xxx2", getCallerShortcut("s12").getTitle());
7289             assertEquals("xxx3", getCallerShortcut("s13").getTitle());
7290             assertEquals("xxx4", getCallerShortcut("s14").getTitle());
7291             assertEquals("xxx5", getCallerShortcut("s15").getTitle());
7292         });
7293     }
7294 
testShortcutsPushedOutByManifest()7295     public void testShortcutsPushedOutByManifest() {
7296         // Change the max number of shortcuts.
7297         mService.updateConfigurationLocked(ConfigConstants.KEY_MAX_SHORTCUTS + "=3");
7298 
7299         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
7300             final ComponentName a1 = new ComponentName(mClientContext, ShortcutActivity.class);
7301             final ComponentName a2 = new ComponentName(mClientContext, ShortcutActivity2.class);
7302             final ShortcutInfo s1_1 = makeShortcutWithActivityAndRank("s11", a1, 4);
7303             final ShortcutInfo s1_2 = makeShortcutWithActivityAndRank("s12", a1, 3);
7304             final ShortcutInfo s1_3 = makeShortcutWithActivityAndRank("s13", a1, 2);
7305             final ShortcutInfo s1_4 = makeShortcutWithActivityAndRank("s14", a1, 1);
7306             final ShortcutInfo s1_5 = makeShortcutWithActivityAndRank("s15", a1, 0);
7307             final ShortcutInfo s2_1 = makeShortcutWithActivityAndRank("s21", a2, 0);
7308             final ShortcutInfo s2_2 = makeShortcutWithActivityAndRank("s22", a2, 1);
7309             final ShortcutInfo s2_3 = makeShortcutWithActivityAndRank("s23", a2, 2);
7310             final ShortcutInfo s2_4 = makeShortcutWithActivityAndRank("s24", a2, 3);
7311             final ShortcutInfo s2_5 = makeShortcutWithActivityAndRank("s25", a2, 4);
7312 
7313             // Initial state.
7314             mManager.setDynamicShortcuts(list(s1_1, s1_2, s1_3, s2_1, s2_2, s2_3));
7315             runWithCaller(LAUNCHER_1, USER_0, () -> {
7316                 mLauncherApps.pinShortcuts(CALLING_PACKAGE_1, list("s11", "s12", "s21", "s22"),
7317                         HANDLE_USER_0);
7318             });
7319             mManager.setDynamicShortcuts(list(s1_2, s1_3, s1_4, s2_2, s2_3, s2_4));
7320             assertShortcutIds(assertAllEnabled(mManager.getDynamicShortcuts()),
7321                     "s12", "s13", "s14",
7322                     "s22", "s23", "s24");
7323             assertShortcutIds(assertAllEnabled(mManager.getPinnedShortcuts()),
7324                     "s11", "s12",
7325                     "s21", "s22");
7326 
7327             // Add 1 manifest shortcut to a1.
7328             addManifestShortcutResource(
7329                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
7330                     R.xml.shortcut_1);
7331             updatePackageVersion(CALLING_PACKAGE_1, 1);
7332                     mService.mPackageMonitor.onReceive(getTestContext(),
7333                     genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
7334             assertEquals(1, mManager.getManifestShortcuts().size());
7335 
7336             // s12 removed.
7337             assertShortcutIds(assertAllEnabled(mManager.getDynamicShortcuts()),
7338                     "s13", "s14",
7339                     "s22", "s23", "s24");
7340             assertShortcutIds(assertAllEnabled(mManager.getPinnedShortcuts()),
7341                     "s11", "s12",
7342                     "s21", "s22");
7343 
7344             // Add more manifest shortcuts.
7345             addManifestShortcutResource(
7346                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
7347                     R.xml.shortcut_2);
7348             addManifestShortcutResource(
7349                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity2.class.getName()),
7350                     R.xml.shortcut_1_alt);
7351             updatePackageVersion(CALLING_PACKAGE_1, 1);
7352                     mService.mPackageMonitor.onReceive(getTestContext(),
7353                     genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
7354             assertEquals(3, mManager.getManifestShortcuts().size());
7355 
7356             // Note the ones with the highest rank values (== least important) will be removed.
7357             assertShortcutIds(assertAllEnabled(mManager.getDynamicShortcuts()),
7358                     "s14",
7359                     "s22", "s23");
7360             assertShortcutIds(assertAllEnabled(mManager.getPinnedShortcuts()),
7361                     "s11", "s12",
7362                     "s21", "s22");
7363 
7364             // Add more manifest shortcuts.
7365             addManifestShortcutResource(
7366                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
7367                     R.xml.shortcut_2);
7368             addManifestShortcutResource(
7369                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity2.class.getName()),
7370                     R.xml.shortcut_5_alt); // manifest has 5, but max is 3, so a2 will have 3.
7371             updatePackageVersion(CALLING_PACKAGE_1, 1);
7372                     mService.mPackageMonitor.onReceive(getTestContext(),
7373                     genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
7374             assertEquals(5, mManager.getManifestShortcuts().size());
7375 
7376             assertShortcutIds(assertAllEnabled(mManager.getDynamicShortcuts()),
7377                     "s14" // a1 has 1 dynamic
7378             ); // a2 has no dynamic
7379             assertShortcutIds(assertAllEnabled(mManager.getPinnedShortcuts()),
7380                     "s11", "s12",
7381                     "s21", "s22");
7382 
7383             // Update, no manifest shortucts.  This doesn't affect anything.
7384             addManifestShortcutResource(
7385                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
7386                     R.xml.shortcut_0);
7387             addManifestShortcutResource(
7388                     new ComponentName(CALLING_PACKAGE_1, ShortcutActivity2.class.getName()),
7389                     R.xml.shortcut_0);
7390             updatePackageVersion(CALLING_PACKAGE_1, 1);
7391                     mService.mPackageMonitor.onReceive(getTestContext(),
7392                     genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
7393             assertEquals(0, mManager.getManifestShortcuts().size());
7394 
7395             assertShortcutIds(assertAllEnabled(mManager.getDynamicShortcuts()),
7396                     "s14");
7397             assertShortcutIds(assertAllEnabled(mManager.getPinnedShortcuts()),
7398                     "s11", "s12",
7399                     "s21", "s22");
7400         });
7401     }
7402 
testReturnedByServer()7403     public void testReturnedByServer() {
7404         // Package 1 updated, with manifest shortcuts.
7405         addManifestShortcutResource(
7406                 new ComponentName(CALLING_PACKAGE_1, ShortcutActivity.class.getName()),
7407                 R.xml.shortcut_1);
7408         updatePackageVersion(CALLING_PACKAGE_1, 1);
7409         mService.mPackageMonitor.onReceive(getTestContext(),
7410                 genPackageAddIntent(CALLING_PACKAGE_1, USER_0));
7411 
7412         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
7413             assertWith(mManager.getManifestShortcuts())
7414                     .haveIds("ms1")
7415                     .forAllShortcuts(si -> assertTrue(si.isReturnedByServer()));
7416 
7417             assertTrue(mManager.setDynamicShortcuts(list(makeShortcut("s1"))));
7418 
7419             assertWith(mManager.getDynamicShortcuts())
7420                     .haveIds("s1")
7421                     .forAllShortcuts(si -> assertTrue(si.isReturnedByServer()));
7422         });
7423 
7424         // Pin them.
7425         runWithCaller(LAUNCHER_1, USER_0, () -> {
7426             mLauncherApps.pinShortcuts(CALLING_PACKAGE_1,
7427                     list("ms1", "s1"), getCallingUser());
7428             assertWith(getShortcutAsLauncher(USER_0))
7429                     .haveIds("ms1", "s1")
7430                     .forAllShortcuts(si -> assertTrue(si.isReturnedByServer()));
7431         });
7432 
7433         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
7434             assertWith(mManager.getPinnedShortcuts())
7435                     .haveIds("ms1", "s1")
7436                     .forAllShortcuts(si -> assertTrue(si.isReturnedByServer()));
7437         });
7438 
7439         runWithCaller(CALLING_PACKAGE_1, USER_0, () -> {
7440             // This shows a warning log, but should still work.
7441             assertTrue(mManager.setDynamicShortcuts(mManager.getDynamicShortcuts()));
7442 
7443             assertWith(mManager.getDynamicShortcuts())
7444                     .haveIds("s1")
7445                     .forAllShortcuts(si -> assertTrue(si.isReturnedByServer()));
7446         });
7447     }
7448 }
7449