1 /*
2  * Copyright (C) 2012 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 
17 package com.android.server.pm;
18 
19 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
20 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
21 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
22 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
23 import static android.content.pm.SuspendDialogInfo.BUTTON_ACTION_MORE_DETAILS;
24 import static android.content.pm.SuspendDialogInfo.BUTTON_ACTION_UNSUSPEND;
25 import static android.content.pm.parsing.FrameworkParsingPackageUtils.parsePublicKey;
26 import static android.content.res.Resources.ID_NULL;
27 
28 import static com.android.server.pm.PackageManagerService.WRITE_USER_PACKAGE_RESTRICTIONS;
29 
30 import static org.hamcrest.CoreMatchers.equalTo;
31 import static org.hamcrest.CoreMatchers.is;
32 import static org.hamcrest.CoreMatchers.not;
33 import static org.hamcrest.CoreMatchers.notNullValue;
34 import static org.hamcrest.CoreMatchers.nullValue;
35 import static org.hamcrest.MatcherAssert.assertThat;
36 import static org.junit.Assert.assertEquals;
37 import static org.junit.Assert.assertFalse;
38 import static org.junit.Assert.assertNotSame;
39 import static org.junit.Assert.assertNull;
40 import static org.junit.Assert.assertSame;
41 import static org.junit.Assert.assertTrue;
42 import static org.junit.Assert.fail;
43 import static org.mockito.Mockito.when;
44 
45 import android.annotation.NonNull;
46 import android.app.PropertyInvalidatedCache;
47 import android.content.ComponentName;
48 import android.content.pm.ApplicationInfo;
49 import android.content.pm.Flags;
50 import android.content.pm.PackageManager;
51 import android.content.pm.SharedLibraryInfo;
52 import android.content.pm.SuspendDialogInfo;
53 import android.content.pm.UserInfo;
54 import android.content.pm.UserPackage;
55 import android.os.BaseBundle;
56 import android.os.Message;
57 import android.os.PersistableBundle;
58 import android.os.Process;
59 import android.os.UserHandle;
60 import android.platform.test.annotations.Presubmit;
61 import android.platform.test.annotations.RequiresFlagsEnabled;
62 import android.platform.test.flag.junit.CheckFlagsRule;
63 import android.platform.test.flag.junit.DeviceFlagsValueProvider;
64 import android.platform.test.flag.junit.SetFlagsRule;
65 import android.util.ArrayMap;
66 import android.util.ArraySet;
67 import android.util.AtomicFile;
68 import android.util.LongSparseArray;
69 
70 import androidx.test.InstrumentationRegistry;
71 import androidx.test.filters.SmallTest;
72 import androidx.test.runner.AndroidJUnit4;
73 
74 import com.android.internal.pm.parsing.pkg.PackageImpl;
75 import com.android.internal.pm.parsing.pkg.ParsedPackage;
76 import com.android.permission.persistence.RuntimePermissionsPersistence;
77 import com.android.server.LocalServices;
78 import com.android.server.pm.parsing.PackageInfoUtils;
79 import com.android.server.pm.permission.LegacyPermissionDataProvider;
80 import com.android.server.pm.pkg.AndroidPackage;
81 import com.android.server.pm.pkg.ArchiveState;
82 import com.android.server.pm.pkg.PackageUserState;
83 import com.android.server.pm.pkg.PackageUserStateInternal;
84 import com.android.server.pm.pkg.SuspendParams;
85 import com.android.server.pm.verify.domain.DomainVerificationManagerInternal;
86 import com.android.server.testutils.TestHandler;
87 import com.android.server.utils.Watchable;
88 import com.android.server.utils.WatchableTester;
89 import com.android.server.utils.WatchedArrayMap;
90 import com.android.server.utils.WatchedArraySet;
91 import com.android.server.utils.Watcher;
92 
93 import com.google.common.truth.Truth;
94 
95 import org.junit.After;
96 import org.junit.Before;
97 import org.junit.Rule;
98 import org.junit.Test;
99 import org.junit.runner.RunWith;
100 import org.mockito.Mock;
101 import org.mockito.MockitoAnnotations;
102 
103 import java.io.File;
104 import java.io.FileOutputStream;
105 import java.io.IOException;
106 import java.nio.file.Files;
107 import java.nio.file.Path;
108 import java.security.PublicKey;
109 import java.util.ArrayList;
110 import java.util.Arrays;
111 import java.util.Collections;
112 import java.util.List;
113 import java.util.PriorityQueue;
114 import java.util.Set;
115 import java.util.UUID;
116 import java.util.concurrent.CountDownLatch;
117 
118 @Presubmit
119 @RunWith(AndroidJUnit4.class)
120 @SmallTest
121 public class PackageManagerSettingsTests {
122 
123     @Rule
124     public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
125     private static final String PACKAGE_NAME_1 = "com.android.app1";
126     private static final String PACKAGE_NAME_2 = "com.android.app2";
127     private static final String PACKAGE_NAME_3 = "com.android.app3";
128     private static final int TEST_RESOURCE_ID = 2131231283;
129 
130     @Rule
131     public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
132     @Mock
133     RuntimePermissionsPersistence mRuntimePermissionsPersistence;
134     @Mock
135     LegacyPermissionDataProvider mPermissionDataProvider;
136     @Mock
137     DomainVerificationManagerInternal mDomainVerificationManager;
138     @Mock
139     Computer computer;
140 
141     final ArrayMap<String, Long> mOrigFirstInstallTimes = new ArrayMap<>();
142 
143     final TestHandler mHandler = new TestHandler((@NonNull Message msg) -> {
144         return true;
145     });
146 
147     @Before
initializeMocks()148     public void initializeMocks() {
149         MockitoAnnotations.initMocks(this);
150         when(mDomainVerificationManager.generateNewId())
151                 .thenAnswer(invocation -> UUID.randomUUID());
152     }
153 
154     @Before
setup()155     public void setup() {
156         // Disable binder caches in this process.
157         PropertyInvalidatedCache.disableForTestMode();
158 
159     }
160 
161     @Before
createUserManagerServiceRef()162     public void createUserManagerServiceRef() throws ReflectiveOperationException {
163         InstrumentationRegistry.getInstrumentation().runOnMainSync((Runnable) () -> {
164             try {
165                 // unregister the user manager from the local service
166                 LocalServices.removeServiceForTest(UserManagerInternal.class);
167                 new UserManagerService(InstrumentationRegistry.getContext());
168             } catch (Exception e) {
169                 e.printStackTrace();
170                 fail("Could not create user manager service; " + e);
171             }
172         });
173     }
174 
175     @After
tearDown()176     public void tearDown() throws Exception {
177         deleteFolder(InstrumentationRegistry.getContext().getFilesDir());
178     }
179 
180     @Test
testApplicationInfoForUseSdkOptionalEnabled()181     public void testApplicationInfoForUseSdkOptionalEnabled() throws Exception {
182         mSetFlagsRule.enableFlags(Flags.FLAG_SDK_LIB_INDEPENDENCE);
183 
184         // Create basic information for SDK lib
185         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
186         ps1.setPkg(((ParsedPackage) PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed())
187                 .setUid(ps1.getAppId())
188                 .setSystem(true)
189                 .hideAsFinal());
190         ps1.setUsesSdkLibraries(new String[] { "com.example.sdk.one" });
191         ps1.setUsesSdkLibrariesVersionsMajor(new long[] { 12 });
192         ps1.setUsesSdkLibrariesOptional(new boolean[] {true});
193         ps1.addUsesLibraryInfo(new SharedLibraryInfo("path1",
194                 "packageName1",
195                 Collections.emptyList(),
196                 "com.example.sdk.one",
197                 12 /*version*/,
198                 SharedLibraryInfo.TYPE_SDK_PACKAGE,
199                 null /*declaringPackage*/,
200                 null /*dependentPackages*/,
201                 null /*dependencies*/,
202                 false /*isNative*/));
203         ps1.addUsesLibraryInfo(new SharedLibraryInfo("path11",
204                 "packageName11",
205                 Collections.emptyList(),
206                 "com.example.sdk.oneone",
207                 1212 /*version*/,
208                 SharedLibraryInfo.TYPE_STATIC,
209                 null /*declaringPackage*/,
210                 null /*dependentPackages*/,
211                 null /*dependencies*/,
212                 false /*isNative*/));
213         ApplicationInfo appInfo1 = PackageInfoUtils.generateApplicationInfo(ps1.getAndroidPackage(),
214                 0 /*flags*/, ps1.getUserStateOrDefault(0), 0 /*userId*/,
215                 ps1);
216         assertThat(appInfo1, notNullValue());
217         assertThat(appInfo1.sharedLibraryInfos, notNullValue());
218         assertThat(appInfo1.optionalSharedLibraryInfos, notNullValue());
219         assertEquals(appInfo1.sharedLibraryInfos.get(0).getName(), "com.example.sdk.one");
220         assertEquals(appInfo1.optionalSharedLibraryInfos.get(0).getName(), "com.example.sdk.one");
221 
222         final PackageSetting ps2 = createPackageSetting(PACKAGE_NAME_2);
223         ps2.setPkg(((ParsedPackage) PackageImpl.forTesting(PACKAGE_NAME_2).hideAsParsed())
224                 .setUid(ps2.getAppId())
225                 .setSystem(true)
226                 .hideAsFinal());
227         ps2.setUsesSdkLibraries(new String[] { "com.example.sdk.two" });
228         ps2.setUsesSdkLibrariesVersionsMajor(new long[] { 34 });
229         ps2.setUsesSdkLibrariesOptional(new boolean[] {false});
230         ps2.addUsesLibraryInfo(new SharedLibraryInfo("path2",
231                 "packageName2",
232                 Collections.emptyList(),
233                 "com.example.sdk.two",
234                 34 /*version*/,
235                 SharedLibraryInfo.TYPE_SDK_PACKAGE,
236                 null /*declaringPackage*/,
237                 null /*dependentPackages*/,
238                 null /*dependencies*/,
239                 false /*isNative*/));
240         ApplicationInfo appInfo2 = PackageInfoUtils.generateApplicationInfo(ps2.getAndroidPackage(),
241                 0 /*flags*/, ps2.getUserStateOrDefault(0), 0 /*userId*/,
242                 ps2);
243         assertThat(appInfo2, notNullValue());
244         assertThat(appInfo2.sharedLibraryInfos, notNullValue());
245         assertThat(appInfo2.optionalSharedLibraryInfos, nullValue());
246         assertEquals(appInfo2.sharedLibraryInfos.get(0).getName(), "com.example.sdk.two");
247     }
248 
249     @Test
testApplicationInfoForUseSdkOptionalDisabled()250     public void testApplicationInfoForUseSdkOptionalDisabled() throws Exception {
251         mSetFlagsRule.disableFlags(Flags.FLAG_SDK_LIB_INDEPENDENCE);
252 
253         // Create basic information for SDK lib
254         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
255         ps1.setPkg(((ParsedPackage) PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed())
256                 .setUid(ps1.getAppId())
257                 .setSystem(true)
258                 .hideAsFinal());
259         ps1.setUsesSdkLibraries(new String[] { "com.example.sdk.one" });
260         ps1.setUsesSdkLibrariesVersionsMajor(new long[] { 12 });
261         ps1.setUsesSdkLibrariesOptional(new boolean[] {true});
262         ps1.addUsesLibraryInfo(new SharedLibraryInfo("path1",
263                 "packageName1",
264                 Collections.emptyList(),
265                 "com.example.sdk.one",
266                 12 /*version*/,
267                 SharedLibraryInfo.TYPE_SDK_PACKAGE,
268                 null /*declaringPackage*/,
269                 null /*dependentPackages*/,
270                 null /*dependencies*/,
271                 false /*isNative*/));
272         ApplicationInfo appInfo1 = PackageInfoUtils.generateApplicationInfo(ps1.getAndroidPackage(),
273                 0 /*flags*/, ps1.getUserStateOrDefault(0), 0 /*userId*/,
274                 ps1);
275         assertThat(appInfo1, notNullValue());
276         assertThat(appInfo1.sharedLibraryInfos, notNullValue());
277         assertThat(appInfo1.optionalSharedLibraryInfos, nullValue());
278         assertEquals(appInfo1.sharedLibraryInfos.get(0).getName(), "com.example.sdk.one");
279     }
280 
281     /** make sure our initialized KeySetManagerService metadata matches packages.xml */
282     @Test
testReadKeySetSettings()283     public void testReadKeySetSettings() throws Exception {
284         /* write out files and read */
285         writeOldFiles();
286         Settings settings = makeSettings();
287         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
288         verifyKeySetMetaData(settings);
289     }
290 
291     // Same as above but use the reserve copy.
292     @Test
testReadReserveCopyKeySetSettings()293     public void testReadReserveCopyKeySetSettings() throws Exception {
294         /* write out files and read */
295         writeReserveCopyOldFiles();
296         Settings settings = makeSettings();
297         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
298         verifyKeySetMetaData(settings);
299     }
300 
301     // Same as above but packages.xml is malformed.
302     @Test
testReadMalformedPackagesXmlKeySetSettings()303     public void testReadMalformedPackagesXmlKeySetSettings() throws Exception {
304         // write out files
305         writeReserveCopyOldFiles();
306         // write corrupted packages.xml
307         writeCorruptedPackagesXml();
308 
309         Settings settings = makeSettings();
310         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
311         verifyKeySetMetaData(settings);
312     }
313 
314     /** read in data, write it out, and read it back in.  Verify same. */
315     @Test
testWriteKeySetSettings()316     public void testWriteKeySetSettings()
317             throws ReflectiveOperationException, IllegalAccessException {
318         // write out files and read
319         writeOldFiles();
320         Settings settings = makeSettings();
321         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
322 
323         // write out, read back in and verify the same
324         settings.writeLPr(computer, /*sync=*/true);
325         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
326         verifyKeySetMetaData(settings);
327     }
328 
329     // Same as above, but corrupt the primary.xml in process.
330     @Test
testWriteCorruptReadKeySetSettings()331     public void testWriteCorruptReadKeySetSettings() throws Exception {
332         // write out files and read
333         writeOldFiles();
334         Settings settings = makeSettings();
335         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
336 
337         // write out
338         settings.writeLPr(computer, /*sync=*/true);
339 
340         File filesDir = InstrumentationRegistry.getContext().getFilesDir();
341         File packageXml = new File(filesDir, "system/packages.xml");
342         File packagesReserveCopyXml = new File(filesDir, "system/packages.xml.reservecopy");
343         // Primary.
344         assertTrue(packageXml.exists());
345         // Reserve copy.
346         assertTrue(packagesReserveCopyXml.exists());
347         // Temporary backup.
348         assertFalse(new File(filesDir, "packages-backup.xml").exists());
349 
350         // compare two copies, make sure they are the same
351         assertTrue(Arrays.equals(Files.readAllBytes(Path.of(packageXml.getAbsolutePath())),
352                 Files.readAllBytes(Path.of(packagesReserveCopyXml.getAbsolutePath()))));
353 
354         // write corrupted packages.xml
355         writeCorruptedPackagesXml();
356 
357         // read back in and verify the same
358         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
359         verifyKeySetMetaData(settings);
360     }
361 
362     @Test
testSettingsReadOld()363     public void testSettingsReadOld() {
364         // Write delegateshellthe package files and make sure they're parsed properly the first time
365         writeOldFiles();
366         Settings settings = makeSettings();
367         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
368         assertThat(settings.getPackageLPr(PACKAGE_NAME_3), is(notNullValue()));
369         assertThat(settings.getPackageLPr(PACKAGE_NAME_1), is(notNullValue()));
370 
371         PackageSetting ps = settings.getPackageLPr(PACKAGE_NAME_1);
372         assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DEFAULT));
373         assertThat(ps.getNotLaunched(0), is(true));
374 
375         ps = settings.getPackageLPr(PACKAGE_NAME_2);
376         assertThat(ps.getStopped(0), is(false));
377         assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DISABLED_USER));
378         assertThat(ps.getEnabled(1), is(COMPONENT_ENABLED_STATE_DEFAULT));
379     }
380 
381     @Test
testNewPackageRestrictionsFile()382     public void testNewPackageRestrictionsFile() throws ReflectiveOperationException {
383         // Write the package files and make sure they're parsed properly the first time
384         writeOldFiles();
385         Settings settings = makeSettings();
386         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
387         settings.writeLPr(computer, /*sync=*/true);
388 
389         // Create Settings again to make it read from the new files
390         settings = makeSettings();
391         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
392 
393         PackageSetting ps = settings.getPackageLPr(PACKAGE_NAME_2);
394         assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DISABLED_USER));
395         assertThat(ps.getEnabled(1), is(COMPONENT_ENABLED_STATE_DEFAULT));
396 
397         // Verify that the snapshot passes the same test
398         Settings snapshot = settings.snapshot();
399         ps = snapshot.getPackageLPr(PACKAGE_NAME_2);
400         assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DISABLED_USER));
401         assertThat(ps.getEnabled(1), is(COMPONENT_ENABLED_STATE_DEFAULT));
402     }
403 
createPersistableBundle(String packageName, long longVal, double doubleVal, boolean boolVal, String textVal)404     private static PersistableBundle createPersistableBundle(String packageName, long longVal,
405             double doubleVal, boolean boolVal, String textVal) {
406         final PersistableBundle bundle = new PersistableBundle();
407         bundle.putString(packageName + ".TEXT_VALUE", textVal);
408         bundle.putLong(packageName + ".LONG_VALUE", longVal);
409         bundle.putBoolean(packageName + ".BOOL_VALUE", boolVal);
410         bundle.putDouble(packageName + ".DOUBLE_VALUE", doubleVal);
411         return bundle;
412     }
413 
414     @Test
testReadPackageRestrictions_noSuspendingPackage()415     public void testReadPackageRestrictions_noSuspendingPackage() {
416         writePackageRestrictions_noSuspendingPackageXml(0);
417         Settings settingsUnderTest = makeSettings();
418         final WatchableTester watcher =
419                 new WatchableTester(settingsUnderTest, "noSuspendingPackage");
420         watcher.register();
421         settingsUnderTest.mPackages.put(PACKAGE_NAME_1, createPackageSetting(PACKAGE_NAME_1));
422         settingsUnderTest.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
423         watcher.verifyChangeReported("put package 1");
424         // Collect a snapshot at the midway point (package 2 has not been added)
425         final Settings snapshot = settingsUnderTest.snapshot();
426         watcher.verifyNoChangeReported("snapshot");
427         settingsUnderTest.mPackages.put(PACKAGE_NAME_2, createPackageSetting(PACKAGE_NAME_2));
428         watcher.verifyChangeReported("put package 2");
429         settingsUnderTest.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
430 
431         PackageSetting ps1 = settingsUnderTest.mPackages.get(PACKAGE_NAME_1);
432         PackageUserStateInternal packageUserState1 = ps1.readUserState(0);
433         assertThat(packageUserState1.isSuspended(), is(true));
434         assertThat(packageUserState1.getSuspendParams().size(), is(1));
435         assertThat(packageUserState1.getSuspendParams().keyAt(0), is(UserPackage.of(0, "android")));
436         assertThat(packageUserState1.getSuspendParams().valueAt(0).getAppExtras(), is(nullValue()));
437         assertThat(packageUserState1.getSuspendParams().valueAt(0).getDialogInfo(),
438                 is(nullValue()));
439         assertThat(packageUserState1.getSuspendParams().valueAt(0).getLauncherExtras(),
440                 is(nullValue()));
441 
442         // Verify that the snapshot returns the same answers
443         ps1 = snapshot.mPackages.get(PACKAGE_NAME_1);
444         packageUserState1 = ps1.readUserState(0);
445         assertThat(packageUserState1.isSuspended(), is(true));
446         assertThat(packageUserState1.getSuspendParams().size(), is(1));
447         assertThat(packageUserState1.getSuspendParams().keyAt(0), is(UserPackage.of(0, "android")));
448         assertThat(packageUserState1.getSuspendParams().valueAt(0).getAppExtras(), is(nullValue()));
449         assertThat(packageUserState1.getSuspendParams().valueAt(0).getDialogInfo(),
450                 is(nullValue()));
451         assertThat(packageUserState1.getSuspendParams().valueAt(0).getLauncherExtras(),
452                 is(nullValue()));
453 
454         PackageSetting ps2 = settingsUnderTest.mPackages.get(PACKAGE_NAME_2);
455         PackageUserStateInternal packageUserState2 = ps2.readUserState(0);
456         assertThat(packageUserState2.isSuspended(), is(false));
457         assertThat(packageUserState2.getSuspendParams(), is(nullValue()));
458 
459         // Verify that the snapshot returns different answers
460         ps2 = snapshot.mPackages.get(PACKAGE_NAME_2);
461         assertTrue(ps2 == null);
462     }
463 
464     @Test
testReadPackageRestrictions_noSuspendParamsMap()465     public void testReadPackageRestrictions_noSuspendParamsMap() {
466         writePackageRestrictions_noSuspendParamsMapXml(0);
467         final Settings settingsUnderTest = makeSettings();
468         final WatchableTester watcher =
469                 new WatchableTester(settingsUnderTest, "noSuspendParamsMap");
470         watcher.register();
471         settingsUnderTest.mPackages.put(PACKAGE_NAME_1, createPackageSetting(PACKAGE_NAME_1));
472         watcher.verifyChangeReported("put package 1");
473         settingsUnderTest.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
474         watcher.verifyChangeReported("readPackageRestrictions");
475 
476         final PackageSetting ps1 = settingsUnderTest.mPackages.get(PACKAGE_NAME_1);
477         watcher.verifyNoChangeReported("get package 1");
478         final PackageUserStateInternal packageUserState1 = ps1.readUserState(0);
479         watcher.verifyNoChangeReported("readUserState");
480         assertThat(packageUserState1.isSuspended(), is(true));
481         assertThat(packageUserState1.getSuspendParams().size(), is(1));
482         assertThat(packageUserState1.getSuspendParams().keyAt(0),
483                 is(UserPackage.of(0, PACKAGE_NAME_3)));
484         final SuspendParams params = packageUserState1.getSuspendParams().valueAt(0);
485         watcher.verifyNoChangeReported("fetch user state");
486         assertThat(params, is(notNullValue()));
487         assertThat(params.getAppExtras().size(), is(1));
488         assertThat(params.getAppExtras().getString("app_extra_string"), is("value"));
489         assertThat(params.getLauncherExtras().size(), is(1));
490         assertThat(params.getLauncherExtras().getLong("launcher_extra_long"), is(4L));
491         assertThat(params.getDialogInfo(), is(notNullValue()));
492         assertThat(params.getDialogInfo().getDialogMessage(), is("Dialog Message"));
493         assertThat(params.getDialogInfo().getTitleResId(), is(ID_NULL));
494         assertThat(params.getDialogInfo().getIconResId(), is(TEST_RESOURCE_ID));
495         assertThat(params.getDialogInfo().getNeutralButtonTextResId(), is(ID_NULL));
496         assertThat(params.getDialogInfo().getNeutralButtonAction(), is(BUTTON_ACTION_MORE_DETAILS));
497         assertThat(params.getDialogInfo().getDialogMessageResId(), is(ID_NULL));
498     }
499 
500     @Test
testReadWritePackageRestrictions_suspendInfo()501     public void testReadWritePackageRestrictions_suspendInfo() {
502         final Settings settingsUnderTest = makeSettings();
503         final WatchableTester watcher = new WatchableTester(settingsUnderTest, "suspendInfo");
504         watcher.register();
505         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
506         final PackageSetting ps2 = createPackageSetting(PACKAGE_NAME_2);
507         final PackageSetting ps3 = createPackageSetting(PACKAGE_NAME_3);
508 
509         final PersistableBundle appExtras1 = createPersistableBundle(
510                 PACKAGE_NAME_1, 1L, 0.01, true, "appString1");
511         final PersistableBundle appExtras2 = createPersistableBundle(
512                 PACKAGE_NAME_2, 2L, 0.02, true, "appString2");
513 
514         final PersistableBundle launcherExtras1 = createPersistableBundle(
515                 PACKAGE_NAME_1, 10L, 0.1, false, "launcherString1");
516         final PersistableBundle launcherExtras2 = createPersistableBundle(
517                 PACKAGE_NAME_2, 20L, 0.2, false, "launcherString2");
518 
519         final SuspendDialogInfo dialogInfo1 = new SuspendDialogInfo.Builder()
520                 .setIcon(0x11220001)
521                 .setTitle("String Title")
522                 .setMessage("1st message")
523                 .setNeutralButtonText(0x11220003)
524                 .setNeutralButtonAction(BUTTON_ACTION_MORE_DETAILS)
525                 .build();
526         final SuspendDialogInfo dialogInfo2 = new SuspendDialogInfo.Builder()
527                 .setIcon(0x22220001)
528                 .setTitle(0x22220002)
529                 .setMessage("2nd message")
530                 .setNeutralButtonText("String button text")
531                 .setNeutralButtonAction(BUTTON_ACTION_UNSUSPEND)
532                 .build();
533 
534         UserPackage suspender1 = UserPackage.of(0, "suspendingPackage1");
535         UserPackage suspender2 = UserPackage.of(0, "suspendingPackage2");
536         UserPackage suspender3 = UserPackage.of(0, "suspendingPackage3");
537         UserPackage irrelevantSuspender = UserPackage.of(0, "irrelevant");
538 
539         ps1.modifyUserState(0).putSuspendParams(suspender1,
540                 new SuspendParams(dialogInfo1, appExtras1, launcherExtras1));
541         ps1.modifyUserState(0).putSuspendParams(suspender2,
542                 new SuspendParams(dialogInfo2, appExtras2, launcherExtras2));
543         settingsUnderTest.mPackages.put(PACKAGE_NAME_1, ps1);
544         watcher.verifyChangeReported("put package 1");
545 
546         ps2.modifyUserState(0).putSuspendParams(suspender3,
547                 new SuspendParams(null, appExtras1, null));
548         settingsUnderTest.mPackages.put(PACKAGE_NAME_2, ps2);
549         watcher.verifyChangeReported("put package 2");
550 
551         ps3.modifyUserState(0).removeSuspension(irrelevantSuspender);
552         settingsUnderTest.mPackages.put(PACKAGE_NAME_3, ps3);
553         watcher.verifyChangeReported("put package 3");
554 
555         settingsUnderTest.writePackageRestrictionsLPr(0, /*sync=*/true);
556         watcher.verifyChangeReported("writePackageRestrictions");
557 
558         settingsUnderTest.mPackages.clear();
559         watcher.verifyChangeReported("clear packages");
560         settingsUnderTest.mPackages.put(PACKAGE_NAME_1, createPackageSetting(PACKAGE_NAME_1));
561         watcher.verifyChangeReported("put package 1");
562         settingsUnderTest.mPackages.put(PACKAGE_NAME_2, createPackageSetting(PACKAGE_NAME_2));
563         watcher.verifyChangeReported("put package 2");
564         settingsUnderTest.mPackages.put(PACKAGE_NAME_3, createPackageSetting(PACKAGE_NAME_3));
565         watcher.verifyChangeReported("put package 3");
566         // now read and verify
567         settingsUnderTest.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
568         watcher.verifyChangeReported("readPackageRestrictions");
569         final PackageUserStateInternal readPus1 = settingsUnderTest.mPackages.get(PACKAGE_NAME_1)
570                 .readUserState(0);
571         watcher.verifyNoChangeReported("package get 1");
572         assertThat(readPus1.isSuspended(), is(true));
573         assertThat(readPus1.getSuspendParams().size(), is(2));
574         watcher.verifyNoChangeReported("read package param");
575 
576         assertThat(readPus1.getSuspendParams().keyAt(0), is(suspender1));
577         final SuspendParams params11 = readPus1.getSuspendParams().valueAt(0);
578         watcher.verifyNoChangeReported("read package param");
579         assertThat(params11, is(notNullValue()));
580         assertThat(params11.getDialogInfo(), is(dialogInfo1));
581         assertThat(BaseBundle.kindofEquals(params11.getAppExtras(), appExtras1), is(true));
582         assertThat(BaseBundle.kindofEquals(params11.getLauncherExtras(), launcherExtras1),
583                 is(true));
584         watcher.verifyNoChangeReported("read package param");
585 
586         assertThat(readPus1.getSuspendParams().keyAt(1), is(suspender2));
587         final SuspendParams params12 = readPus1.getSuspendParams().valueAt(1);
588         assertThat(params12, is(notNullValue()));
589         assertThat(params12.getDialogInfo(), is(dialogInfo2));
590         assertThat(BaseBundle.kindofEquals(params12.getAppExtras(), appExtras2), is(true));
591         assertThat(BaseBundle.kindofEquals(params12.getLauncherExtras(), launcherExtras2),
592                 is(true));
593         watcher.verifyNoChangeReported("read package param");
594 
595         final PackageUserStateInternal readPus2 = settingsUnderTest.mPackages.get(PACKAGE_NAME_2)
596                 .readUserState(0);
597         assertThat(readPus2.isSuspended(), is(true));
598         assertThat(readPus2.getSuspendParams().size(), is(1));
599         assertThat(readPus2.getSuspendParams().keyAt(0), is(suspender3));
600         final SuspendParams params21 = readPus2.getSuspendParams().valueAt(0);
601         assertThat(params21, is(notNullValue()));
602         assertThat(params21.getDialogInfo(), is(nullValue()));
603         assertThat(BaseBundle.kindofEquals(params21.getAppExtras(), appExtras1), is(true));
604         assertThat(params21.getLauncherExtras(), is(nullValue()));
605         watcher.verifyNoChangeReported("read package param");
606 
607         final PackageUserStateInternal readPus3 = settingsUnderTest.mPackages.get(PACKAGE_NAME_3)
608                 .readUserState(0);
609         assertThat(readPus3.isSuspended(), is(false));
610         assertThat(readPus3.getSuspendParams(), is(nullValue()));
611         watcher.verifyNoChangeReported("package get 3");
612     }
613 
614     @Test
testPackageRestrictionsSuspendedDefault()615     public void testPackageRestrictionsSuspendedDefault() {
616         final PackageSetting defaultSetting = createPackageSetting(PACKAGE_NAME_1);
617         assertThat(defaultSetting.getUserStateOrDefault(0).isSuspended(), is(false));
618     }
619 
populateDefaultSettings(Settings settings)620     private void populateDefaultSettings(Settings settings) {
621         settings.mPackages.clear();
622         settings.mPackages.put(PACKAGE_NAME_1, createPackageSetting(PACKAGE_NAME_1));
623         settings.mPackages.put(PACKAGE_NAME_2, createPackageSetting(PACKAGE_NAME_2));
624         settings.mPackages.put(PACKAGE_NAME_3, createPackageSetting(PACKAGE_NAME_3));
625     }
626 
verifyDefaultDistractionFlags(Settings settings)627     private void verifyDefaultDistractionFlags(Settings settings) {
628         final PackageUserState readPus1 = settings.mPackages.get(PACKAGE_NAME_1)
629                 .readUserState(0);
630         assertThat(readPus1.getDistractionFlags(), is(0));
631 
632         final PackageUserState readPus2 = settings.mPackages.get(PACKAGE_NAME_2)
633                 .readUserState(0);
634         assertThat(readPus2.getDistractionFlags(), is(0));
635 
636         final PackageUserState readPus3 = settings.mPackages.get(PACKAGE_NAME_3)
637                 .readUserState(0);
638         assertThat(readPus3.getDistractionFlags(), is(0));
639     }
640 
populateDistractionFlags(Settings settings)641     private void populateDistractionFlags(Settings settings) {
642         settings.mPackages.clear();
643         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
644         final PackageSetting ps2 = createPackageSetting(PACKAGE_NAME_2);
645         final PackageSetting ps3 = createPackageSetting(PACKAGE_NAME_3);
646 
647         final int distractionFlags1 = PackageManager.RESTRICTION_HIDE_FROM_SUGGESTIONS;
648         ps1.setDistractionFlags(distractionFlags1, 0);
649         settings.mPackages.put(PACKAGE_NAME_1, ps1);
650 
651         final int distractionFlags2 = PackageManager.RESTRICTION_HIDE_NOTIFICATIONS
652                 | PackageManager.RESTRICTION_HIDE_FROM_SUGGESTIONS;
653         ps2.setDistractionFlags(distractionFlags2, 0);
654         settings.mPackages.put(PACKAGE_NAME_2, ps2);
655 
656         final int distractionFlags3 = PackageManager.RESTRICTION_NONE;
657         ps3.setDistractionFlags(distractionFlags3, 0);
658         settings.mPackages.put(PACKAGE_NAME_3, ps3);
659     }
660 
verifyDistractionFlags(Settings settings)661     private void verifyDistractionFlags(Settings settings) {
662         final int distractionFlags1 = PackageManager.RESTRICTION_HIDE_FROM_SUGGESTIONS;
663         final int distractionFlags2 = PackageManager.RESTRICTION_HIDE_NOTIFICATIONS
664                 | PackageManager.RESTRICTION_HIDE_FROM_SUGGESTIONS;
665         final int distractionFlags3 = PackageManager.RESTRICTION_NONE;
666 
667         final PackageUserState readPus1 = settings.mPackages.get(PACKAGE_NAME_1)
668                 .readUserState(0);
669         assertThat(readPus1.getDistractionFlags(), is(distractionFlags1));
670 
671         final PackageUserState readPus2 = settings.mPackages.get(PACKAGE_NAME_2)
672                 .readUserState(0);
673         assertThat(readPus2.getDistractionFlags(), is(distractionFlags2));
674 
675         final PackageUserState readPus3 = settings.mPackages.get(PACKAGE_NAME_3)
676                 .readUserState(0);
677         assertThat(readPus3.getDistractionFlags(), is(distractionFlags3));
678     }
679 
680     @Test
testReadWritePackageRestrictions_distractionFlags()681     public void testReadWritePackageRestrictions_distractionFlags() {
682         final Settings settingsUnderTest = makeSettings();
683 
684         populateDistractionFlags(settingsUnderTest);
685         settingsUnderTest.writePackageRestrictionsLPr(0, /*sync=*/true);
686 
687         // now read and verify
688         populateDefaultSettings(settingsUnderTest);
689         settingsUnderTest.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
690         verifyDistractionFlags(settingsUnderTest);
691     }
692 
693     @Test
testWriteCorruptReadPackageRestrictions()694     public void testWriteCorruptReadPackageRestrictions() {
695         final Settings settingsUnderTest = makeSettings();
696 
697         populateDistractionFlags(settingsUnderTest);
698         settingsUnderTest.writePackageRestrictionsLPr(0, /*sync=*/true);
699 
700         // Corrupt primary file.
701         writeCorruptedPackageRestrictions(0);
702 
703         // now read and verify
704         populateDefaultSettings(settingsUnderTest);
705         settingsUnderTest.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
706         verifyDistractionFlags(settingsUnderTest);
707     }
708 
709     @Test
testReadWritePackageRestrictionsAsync()710     public void testReadWritePackageRestrictionsAsync() {
711         final Settings settingsWrite = makeSettings();
712         final Settings settingsRead = makeSettings();
713         mHandler.clear();
714 
715         // Initial empty state.
716         settingsWrite.removeUserLPw(0);
717 
718         // Schedule 3 async writes.
719         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/false);
720         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/false);
721         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/false);
722 
723         PriorityQueue<TestHandler.MsgInfo> messages = mHandler.getPendingMessages();
724         assertEquals(3, messages.size());
725         final Runnable asyncWrite1 = (Runnable) messages.poll().message.obj;
726         final Runnable asyncWrite2 = (Runnable) messages.poll().message.obj;
727         final Runnable asyncWrite3 = (Runnable) messages.poll().message.obj;
728         mHandler.clear();
729 
730         // First read should read old data.
731         populateDefaultSettings(settingsRead);
732         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
733         verifyDefaultDistractionFlags(settingsRead);
734 
735         // 1st write: with flags.
736         populateDistractionFlags(settingsWrite);
737         asyncWrite1.run();
738 
739         // New data.
740         populateDefaultSettings(settingsRead);
741         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
742         verifyDistractionFlags(settingsRead);
743 
744         // 2nd write: without.
745         populateDefaultSettings(settingsWrite);
746         asyncWrite2.run();
747 
748         // Default data.
749         populateDefaultSettings(settingsRead);
750         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
751         verifyDefaultDistractionFlags(settingsRead);
752 
753         // 3rd write: with flags.
754         populateDistractionFlags(settingsWrite);
755         asyncWrite3.run();
756 
757         // New data.
758         populateDefaultSettings(settingsRead);
759         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
760         verifyDistractionFlags(settingsRead);
761     }
762 
763     @Test
testReadWritePackageRestrictionsAsyncUserRemoval()764     public void testReadWritePackageRestrictionsAsyncUserRemoval() {
765         final Settings settingsWrite = makeSettings();
766         final Settings settingsRead = makeSettings();
767         mHandler.clear();
768 
769         // Initial empty state.
770         settingsWrite.removeUserLPw(0);
771 
772         // 2 async writes.
773         populateDistractionFlags(settingsWrite);
774         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/false);
775         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/false);
776 
777         PriorityQueue<TestHandler.MsgInfo> messages = mHandler.getPendingMessages();
778         assertEquals(2, messages.size());
779         final Runnable asyncWrite1 = (Runnable) messages.poll().message.obj;
780         final Runnable asyncWrite2 = (Runnable) messages.poll().message.obj;
781         mHandler.clear();
782 
783         // First read should not read anything.
784         populateDefaultSettings(settingsRead);
785         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
786         verifyDefaultDistractionFlags(settingsRead);
787 
788         // 1st write.
789         asyncWrite1.run();
790 
791         // Second read should read new data.
792         populateDefaultSettings(settingsRead);
793         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
794         verifyDistractionFlags(settingsRead);
795 
796         // Now remove the user.
797         settingsWrite.removeUserLPw(0);
798 
799         // 2nd write.
800         asyncWrite2.run();
801 
802         // Re-read and verify that nothing was read.
803         populateDefaultSettings(settingsRead);
804         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
805         verifyDefaultDistractionFlags(settingsRead);
806     }
807 
808     @Test
testReadWritePackageRestrictionsSyncAfterAsync()809     public void testReadWritePackageRestrictionsSyncAfterAsync() {
810         final Settings settingsWrite = makeSettings();
811         final Settings settingsRead = makeSettings();
812         mHandler.clear();
813 
814         // Initial state, distraction flags populated.
815         populateDistractionFlags(settingsWrite);
816         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/true);
817 
818         // 2 async writes of empty distraction flags.
819         populateDefaultSettings(settingsWrite);
820         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/false);
821         settingsWrite.writePackageRestrictionsLPr(0, /*sync=*/false);
822 
823         PriorityQueue<TestHandler.MsgInfo> messages = mHandler.getPendingMessages();
824         assertEquals(2, messages.size());
825         final Runnable asyncWrite1 = (Runnable) messages.poll().message.obj;
826         final Runnable asyncWrite2 = (Runnable) messages.poll().message.obj;
827 
828         // First read should use read initial data (with flags).
829         populateDefaultSettings(settingsRead);
830         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
831         verifyDistractionFlags(settingsRead);
832 
833         // 1st write.
834         asyncWrite1.run();
835 
836         // Second read should read updated data.
837         populateDefaultSettings(settingsRead);
838         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
839         verifyDefaultDistractionFlags(settingsRead);
840 
841         // Sync write with flags - overrides all async writes.
842         populateDistractionFlags(settingsWrite);
843         settingsWrite.writeAllUsersPackageRestrictionsLPr(/*sync=*/true);
844 
845         // Expect removeMessages call.
846         assertFalse(mHandler.hasMessages(WRITE_USER_PACKAGE_RESTRICTIONS));
847 
848         populateDefaultSettings(settingsRead);
849         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
850         verifyDistractionFlags(settingsRead);
851 
852         // 2nd write.
853         asyncWrite2.run();
854 
855         // Re-read and verify.
856         populateDefaultSettings(settingsRead);
857         settingsRead.readPackageRestrictionsLPr(0, mOrigFirstInstallTimes);
858         verifyDistractionFlags(settingsRead);
859     }
860 
861     @Test
testWriteReadUsesStaticLibraries()862     public void testWriteReadUsesStaticLibraries() {
863         final Settings settingsUnderTest = makeSettings();
864         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
865         ps1.setAppId(Process.FIRST_APPLICATION_UID);
866         ps1.setPkg(((ParsedPackage) PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed())
867                 .setUid(ps1.getAppId())
868                 .setSystem(true)
869                 .hideAsFinal());
870         final PackageSetting ps2 = createPackageSetting(PACKAGE_NAME_2);
871         ps2.setAppId(Process.FIRST_APPLICATION_UID + 1);
872         ps2.setPkg(((ParsedPackage) PackageImpl.forTesting(PACKAGE_NAME_2).hideAsParsed())
873                 .setUid(ps2.getAppId())
874                 .hideAsFinal());
875 
876         ps1.setUsesStaticLibraries(new String[] { "com.example.shared.one" });
877         ps1.setUsesStaticLibrariesVersions(new long[] { 12 });
878         ps1.setFlags(ps1.getFlags() | ApplicationInfo.FLAG_SYSTEM);
879         settingsUnderTest.mPackages.put(PACKAGE_NAME_1, ps1);
880         assertThat(settingsUnderTest.disableSystemPackageLPw(PACKAGE_NAME_1, false), is(true));
881 
882         ps2.setUsesStaticLibraries(new String[] { "com.example.shared.two" });
883         ps2.setUsesStaticLibrariesVersions(new long[] { 34 });
884         settingsUnderTest.mPackages.put(PACKAGE_NAME_2, ps2);
885 
886         settingsUnderTest.writeLPr(computer, /*sync=*/true);
887 
888         settingsUnderTest.mPackages.clear();
889         settingsUnderTest.mDisabledSysPackages.clear();
890 
891         assertThat(settingsUnderTest.readLPw(computer, createFakeUsers()), is(true));
892 
893         PackageSetting readPs1 = settingsUnderTest.getPackageLPr(PACKAGE_NAME_1);
894         PackageSetting readPs2 = settingsUnderTest.getPackageLPr(PACKAGE_NAME_2);
895 
896         Truth.assertThat(readPs1).isNotNull();
897         Truth.assertThat(readPs1.getUsesStaticLibraries()).isNotNull();
898         Truth.assertThat(readPs1.getUsesStaticLibrariesVersions()).isNotNull();
899         Truth.assertThat(readPs2).isNotNull();
900         Truth.assertThat(readPs2.getUsesStaticLibraries()).isNotNull();
901         Truth.assertThat(readPs2.getUsesStaticLibrariesVersions()).isNotNull();
902 
903         List<Long> ps1VersionsAsList = new ArrayList<>();
904         for (long version : ps1.getUsesStaticLibrariesVersions()) {
905             ps1VersionsAsList.add(version);
906         }
907 
908         List<Long> ps2VersionsAsList = new ArrayList<>();
909         for (long version : ps2.getUsesStaticLibrariesVersions()) {
910             ps2VersionsAsList.add(version);
911         }
912 
913         Truth.assertThat(readPs1.getUsesStaticLibraries()).asList()
914                 .containsExactlyElementsIn(ps1.getUsesStaticLibraries()).inOrder();
915 
916         Truth.assertThat(readPs1.getUsesStaticLibrariesVersions()).asList()
917                 .containsExactlyElementsIn(ps1VersionsAsList).inOrder();
918 
919         Truth.assertThat(readPs2.getUsesStaticLibraries()).asList()
920                 .containsExactlyElementsIn(ps2.getUsesStaticLibraries()).inOrder();
921 
922         Truth.assertThat(readPs2.getUsesStaticLibrariesVersions()).asList()
923                 .containsExactlyElementsIn(ps2VersionsAsList).inOrder();
924     }
925 
926     @Test
testSameVersions_writeReadUsesStaticLibraries()927     public void testSameVersions_writeReadUsesStaticLibraries() {
928         Settings settings = makeSettings();
929         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
930         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
931 
932         final String libOne = "one";
933         final String libTwo = "two";
934         final long versionOne = 311;
935         packageSetting.setUsesStaticLibraries(new String[] { libOne, libTwo });
936         packageSetting.setUsesStaticLibrariesVersions(new long[] { versionOne, versionOne });
937         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
938 
939         settings.writeLPr(computer, /* sync= */ true);
940         settings.mPackages.clear();
941 
942         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
943         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
944         assertThat(resultSetting.getUsesStaticLibraries()[0], is(libOne));
945         assertThat(resultSetting.getUsesStaticLibraries()[1], is(libTwo));
946         assertThat(resultSetting.getUsesStaticLibrariesVersions()[0], is(versionOne));
947         assertThat(resultSetting.getUsesStaticLibrariesVersions()[1], is(versionOne));
948     }
949 
950     @Test
testSameLibNames_writeReadUsesStaticLibraries()951     public void testSameLibNames_writeReadUsesStaticLibraries() {
952         Settings settings = makeSettings();
953         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
954         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
955 
956         final String libOne = "one";
957         final long versionOne = 311;
958         final long versionTwo = 330;
959         packageSetting.setUsesStaticLibraries(new String[] { libOne, libOne});
960         packageSetting.setUsesStaticLibrariesVersions(new long[] { versionOne, versionTwo });
961         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
962 
963         settings.writeLPr(computer, /* sync= */ true);
964         settings.mPackages.clear();
965 
966         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
967         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
968         assertThat(resultSetting.getUsesStaticLibraries().length, is(1));
969         assertThat(resultSetting.getUsesStaticLibrariesVersions().length, is(1));
970         assertThat(resultSetting.getUsesStaticLibraries()[0], is(libOne));
971         assertThat(resultSetting.getUsesStaticLibrariesVersions()[0], is(versionTwo));
972     }
973 
974     @Test
testWriteReadUsesSdkLibraries()975     public void testWriteReadUsesSdkLibraries() {
976         final Settings settingsUnderTest = makeSettings();
977         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
978         ps1.setAppId(Process.FIRST_APPLICATION_UID);
979         ps1.setPkg(((ParsedPackage) PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed())
980                 .setUid(ps1.getAppId())
981                 .setSystem(true)
982                 .hideAsFinal());
983         final PackageSetting ps2 = createPackageSetting(PACKAGE_NAME_2);
984         ps2.setAppId(Process.FIRST_APPLICATION_UID + 1);
985         ps2.setPkg(((ParsedPackage) PackageImpl.forTesting(PACKAGE_NAME_2).hideAsParsed())
986                 .setUid(ps2.getAppId())
987                 .hideAsFinal());
988 
989         ps1.setUsesSdkLibraries(new String[] { "com.example.sdk.one" });
990         ps1.setUsesSdkLibrariesVersionsMajor(new long[] { 12 });
991         ps1.setUsesSdkLibrariesOptional(new boolean[] {true});
992         ps1.setFlags(ps1.getFlags() | ApplicationInfo.FLAG_SYSTEM);
993         settingsUnderTest.mPackages.put(PACKAGE_NAME_1, ps1);
994         assertThat(settingsUnderTest.disableSystemPackageLPw(PACKAGE_NAME_1, false), is(true));
995 
996         ps2.setUsesSdkLibraries(new String[] { "com.example.sdk.two" });
997         ps2.setUsesSdkLibrariesVersionsMajor(new long[] { 34 });
998         ps2.setUsesSdkLibrariesOptional(new boolean[] {false});
999         settingsUnderTest.mPackages.put(PACKAGE_NAME_2, ps2);
1000 
1001         settingsUnderTest.writeLPr(computer, /*sync=*/true);
1002 
1003         settingsUnderTest.mPackages.clear();
1004         settingsUnderTest.mDisabledSysPackages.clear();
1005 
1006         assertThat(settingsUnderTest.readLPw(computer, createFakeUsers()), is(true));
1007 
1008         PackageSetting readPs1 = settingsUnderTest.getPackageLPr(PACKAGE_NAME_1);
1009         PackageSetting readPs2 = settingsUnderTest.getPackageLPr(PACKAGE_NAME_2);
1010 
1011         Truth.assertThat(readPs1).isNotNull();
1012         Truth.assertThat(readPs1.getUsesSdkLibraries()).isNotNull();
1013         Truth.assertThat(readPs1.getUsesSdkLibrariesVersionsMajor()).isNotNull();
1014         Truth.assertThat(readPs1.getUsesSdkLibrariesOptional()).isNotNull();
1015         Truth.assertThat(readPs2).isNotNull();
1016         Truth.assertThat(readPs2.getUsesSdkLibraries()).isNotNull();
1017         Truth.assertThat(readPs2.getUsesSdkLibrariesVersionsMajor()).isNotNull();
1018         Truth.assertThat(readPs2.getUsesSdkLibrariesOptional()).isNotNull();
1019 
1020         List<Long> ps1VersionsAsList = new ArrayList<>();
1021         for (long version : ps1.getUsesSdkLibrariesVersionsMajor()) {
1022             ps1VersionsAsList.add(version);
1023         }
1024 
1025         List<Boolean> ps1RequireAsList = new ArrayList<>();
1026         for (boolean optional : ps1.getUsesSdkLibrariesOptional()) {
1027             ps1RequireAsList.add(optional);
1028         }
1029 
1030         List<Long> ps2VersionsAsList = new ArrayList<>();
1031         for (long version : ps2.getUsesSdkLibrariesVersionsMajor()) {
1032             ps2VersionsAsList.add(version);
1033         }
1034         List<Boolean> ps2RequireAsList = new ArrayList<>();
1035         for (boolean optional : ps2.getUsesSdkLibrariesOptional()) {
1036             ps2RequireAsList.add(optional);
1037         }
1038 
1039         Truth.assertThat(readPs1.getUsesSdkLibraries()).asList()
1040                 .containsExactlyElementsIn(ps1.getUsesSdkLibraries()).inOrder();
1041 
1042         Truth.assertThat(readPs1.getUsesSdkLibrariesVersionsMajor()).asList()
1043                 .containsExactlyElementsIn(ps1VersionsAsList).inOrder();
1044 
1045         Truth.assertThat(readPs1.getUsesSdkLibrariesOptional()).asList()
1046                 .containsExactlyElementsIn(ps1RequireAsList).inOrder();
1047 
1048         Truth.assertThat(readPs2.getUsesSdkLibraries()).asList()
1049                 .containsExactlyElementsIn(ps2.getUsesSdkLibraries()).inOrder();
1050 
1051         Truth.assertThat(readPs2.getUsesSdkLibrariesVersionsMajor()).asList()
1052                 .containsExactlyElementsIn(ps2VersionsAsList).inOrder();
1053 
1054         Truth.assertThat(readPs2.getUsesSdkLibrariesOptional()).asList()
1055                 .containsExactlyElementsIn(ps2RequireAsList).inOrder();
1056     }
1057 
1058     @Test
testSameVersions_writeReadUsesSdkLibraries()1059     public void testSameVersions_writeReadUsesSdkLibraries() {
1060         Settings settings = makeSettings();
1061         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1062         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1063 
1064         final String libOne = "one";
1065         final String libTwo = "two";
1066         final long versionOne = 311;
1067         final boolean optional = false;
1068         packageSetting.setUsesSdkLibraries(new String[] { libOne, libTwo });
1069         packageSetting.setUsesSdkLibrariesVersionsMajor(new long[] { versionOne, versionOne });
1070         packageSetting.setUsesSdkLibrariesOptional(new boolean[] { optional, optional });
1071         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1072 
1073         settings.writeLPr(computer, /* sync= */ true);
1074         settings.mPackages.clear();
1075 
1076         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1077         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
1078 
1079         assertThat(resultSetting.getUsesSdkLibraries()[0], is(libOne));
1080         assertThat(resultSetting.getUsesSdkLibraries()[1], is(libTwo));
1081         assertThat(resultSetting.getUsesSdkLibrariesVersionsMajor()[0], is(versionOne));
1082         assertThat(resultSetting.getUsesSdkLibrariesVersionsMajor()[1], is(versionOne));
1083         assertThat(resultSetting.getUsesSdkLibrariesOptional()[0], is(optional));
1084         assertThat(resultSetting.getUsesSdkLibrariesOptional()[1], is(optional));
1085     }
1086 
1087     @Test
testSameLibNames_writeReadUsesSdkLibraries()1088     public void testSameLibNames_writeReadUsesSdkLibraries() {
1089         Settings settings = makeSettings();
1090         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1091         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1092 
1093         final String libOne = "one";
1094         final long versionOne = 311;
1095         final long versionTwo = 330;
1096         final boolean optionalOne = false;
1097         final boolean optionalTwo = true;
1098         packageSetting.setUsesSdkLibraries(new String[] { libOne, libOne });
1099         packageSetting.setUsesSdkLibrariesVersionsMajor(new long[] { versionOne, versionTwo });
1100         packageSetting.setUsesSdkLibrariesOptional(new boolean[] { optionalOne, optionalTwo });
1101         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1102 
1103         settings.writeLPr(computer, /* sync= */ true);
1104         settings.mPackages.clear();
1105 
1106         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1107         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
1108 
1109         assertThat(resultSetting.getUsesSdkLibraries().length, is(1));
1110         assertThat(resultSetting.getUsesSdkLibrariesVersionsMajor().length, is(1));
1111         assertThat(resultSetting.getUsesSdkLibrariesOptional().length, is(1));
1112         assertThat(resultSetting.getUsesSdkLibraries()[0], is(libOne));
1113         assertThat(resultSetting.getUsesSdkLibrariesVersionsMajor()[0], is(versionTwo));
1114         assertThat(resultSetting.getUsesSdkLibrariesOptional()[0], is(optionalTwo));
1115     }
1116 
1117     @Test
testWriteReadPendingRestore()1118     public void testWriteReadPendingRestore() {
1119         Settings settings = makeSettings();
1120         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1121         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1122         packageSetting.setPkg(PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed()
1123                 .setUid(packageSetting.getAppId())
1124                 .hideAsFinal());
1125 
1126         packageSetting.setPendingRestore(true);
1127         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1128 
1129         settings.writeLPr(computer, /*sync=*/true);
1130         settings.mPackages.clear();
1131 
1132         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1133         assertThat(settings.getPackageLPr(PACKAGE_NAME_1).isPendingRestore(), is(true));
1134     }
1135 
1136     @Test
testWriteReadDebuggable()1137     public void testWriteReadDebuggable() {
1138         Settings settings = makeSettings();
1139         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1140         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1141         packageSetting.setPkg(PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed()
1142                 .setUid(packageSetting.getAppId())
1143                 .hideAsFinal());
1144 
1145         packageSetting.setDebuggable(true);
1146         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1147 
1148         settings.writeLPr(computer, /* sync= */ true);
1149         settings.mPackages.clear();
1150 
1151         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1152         assertThat(settings.getPackageLPr(PACKAGE_NAME_1).isDebuggable(), is(true));
1153     }
1154 
1155     @Test
testWriteReadBaseRevisionCode()1156     public void testWriteReadBaseRevisionCode() {
1157         Settings settings = makeSettings();
1158         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1159         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1160         packageSetting.setPkg(PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed()
1161                 .setUid(packageSetting.getAppId())
1162                 .hideAsFinal());
1163 
1164         final int revisionCode = 311;
1165         packageSetting.setBaseRevisionCode(revisionCode);
1166         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1167 
1168         settings.writeLPr(computer, /* sync= */ true);
1169         settings.mPackages.clear();
1170 
1171         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1172         assertThat(settings.getPackageLPr(PACKAGE_NAME_1).getBaseRevisionCode(), is(revisionCode));
1173     }
1174 
1175     @Test
testHasPkg_writeReadSplitVersions()1176     public void testHasPkg_writeReadSplitVersions() {
1177         Settings settings = makeSettings();
1178         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1179         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1180         packageSetting.setPkg(PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed()
1181                 .setUid(packageSetting.getAppId())
1182                 .hideAsFinal());
1183 
1184         final String splitOne = "one";
1185         final String splitTwo = "two";
1186         final int revisionOne = 311;
1187         final int revisionTwo = 330;
1188         packageSetting.setSplitNames(new String[] { splitOne, splitTwo});
1189         packageSetting.setSplitRevisionCodes(new int[] { revisionOne, revisionTwo});
1190         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1191 
1192         settings.writeLPr(computer, /* sync= */ true);
1193         settings.mPackages.clear();
1194 
1195         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1196         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
1197         assertThat(resultSetting.getSplitNames().length, is(0));
1198         assertThat(resultSetting.getSplitRevisionCodes().length, is(0));
1199     }
1200 
1201     @Test
testNoPkgDifferentRevisions_writeReadSplitVersions()1202     public void testNoPkgDifferentRevisions_writeReadSplitVersions() {
1203         Settings settings = makeSettings();
1204         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1205         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1206 
1207         final String splitOne = "one";
1208         final String splitTwo = "two";
1209         final int revisionOne = 311;
1210         final int revisionTwo = 330;
1211         packageSetting.setSplitNames(new String[] { splitOne, splitTwo});
1212         packageSetting.setSplitRevisionCodes(new int[] { revisionOne, revisionTwo});
1213         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1214 
1215         settings.writeLPr(computer, /* sync= */ true);
1216         settings.mPackages.clear();
1217 
1218         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1219         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
1220         assertThat(resultSetting.getSplitNames()[0], is(splitOne));
1221         assertThat(resultSetting.getSplitNames()[1], is(splitTwo));
1222         assertThat(resultSetting.getSplitRevisionCodes()[0], is(revisionOne));
1223         assertThat(resultSetting.getSplitRevisionCodes()[1], is(revisionTwo));
1224     }
1225 
1226     @Test
testNoPkgSameRevisions_writeReadSplitVersions()1227     public void testNoPkgSameRevisions_writeReadSplitVersions() {
1228         Settings settings = makeSettings();
1229         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1230         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1231 
1232         final String splitOne = "one";
1233         final String splitTwo = "two";
1234         final int revisionOne = 311;
1235         packageSetting.setSplitNames(new String[] { splitOne, splitTwo});
1236         packageSetting.setSplitRevisionCodes(new int[] { revisionOne, revisionOne});
1237         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1238 
1239         settings.writeLPr(computer, /* sync= */ true);
1240         settings.mPackages.clear();
1241 
1242         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1243         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
1244         assertThat(resultSetting.getSplitNames()[0], is(splitOne));
1245         assertThat(resultSetting.getSplitNames()[1], is(splitTwo));
1246         assertThat(resultSetting.getSplitRevisionCodes()[0], is(revisionOne));
1247         assertThat(resultSetting.getSplitRevisionCodes()[1], is(revisionOne));
1248     }
1249 
1250     @Test
testNoPkgSameSplitNames_writeReadSplitVersions()1251     public void testNoPkgSameSplitNames_writeReadSplitVersions() {
1252         Settings settings = makeSettings();
1253         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1254         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1255 
1256         final String splitOne = "one";
1257         final int revisionOne = 311;
1258         final int revisionTwo = 330;
1259         packageSetting.setSplitNames(new String[] { splitOne, splitOne});
1260         packageSetting.setSplitRevisionCodes(new int[] { revisionOne, revisionTwo});
1261         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1262 
1263         settings.writeLPr(computer, /* sync= */ true);
1264         settings.mPackages.clear();
1265 
1266         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1267         PackageSetting resultSetting = settings.getPackageLPr(PACKAGE_NAME_1);
1268         assertThat(resultSetting.getSplitNames().length, is(1));
1269         assertThat(resultSetting.getSplitRevisionCodes().length, is(1));
1270         assertThat(resultSetting.getSplitNames()[0], is(splitOne));
1271         assertThat(resultSetting.getSplitRevisionCodes()[0], is(revisionTwo));
1272     }
1273 
1274     @Test
testWriteReadArchiveState()1275     public void testWriteReadArchiveState() {
1276         Settings settings = makeSettings();
1277         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1278         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1279         packageSetting.setPkg(PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed()
1280                 .setUid(packageSetting.getAppId())
1281                 .hideAsFinal());
1282 
1283         ArchiveState archiveState =
1284                 new ArchiveState(
1285                         List.of(
1286                                 new ArchiveState.ArchiveActivityInfo(
1287                                         "title1",
1288                                         new ComponentName("pkg1", "class1"),
1289                                         Path.of("/path1"),
1290                                         Path.of("/monochromePath1")),
1291                                 new ArchiveState.ArchiveActivityInfo(
1292                                         "title2",
1293                                         new ComponentName("pkg2", "class2"),
1294                                         Path.of("/path2"),
1295                                         Path.of("/monochromePath2"))),
1296                         "installerTitle");
1297         packageSetting.modifyUserState(UserHandle.SYSTEM.getIdentifier()).setArchiveState(
1298                 archiveState);
1299         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1300 
1301         settings.writeLPr(computer, /*sync=*/true);
1302         settings.mPackages.clear();
1303 
1304         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1305 
1306         Truth.assertThat(settings.getPackageLPr(PACKAGE_NAME_1).getStateForUser(
1307                 UserHandle.SYSTEM).getArchiveState()).isEqualTo(archiveState);
1308     }
1309 
1310     @RequiresFlagsEnabled(Flags.FLAG_ASL_IN_APK_APP_METADATA_SOURCE)
1311     @Test
testWriteReadAppMetadataSource()1312     public void testWriteReadAppMetadataSource() {
1313         Settings settings = makeSettings();
1314         PackageSetting packageSetting = createPackageSetting(PACKAGE_NAME_1);
1315         packageSetting.setAppId(Process.FIRST_APPLICATION_UID);
1316         packageSetting.setPkg(PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed()
1317                 .setUid(packageSetting.getAppId())
1318                 .hideAsFinal());
1319 
1320         packageSetting.setAppMetadataSource(PackageManager.APP_METADATA_SOURCE_INSTALLER);
1321         settings.mPackages.put(PACKAGE_NAME_1, packageSetting);
1322 
1323         settings.writeLPr(computer, /*sync=*/true);
1324         settings.mPackages.clear();
1325 
1326         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1327         assertThat(settings.getPackageLPr(PACKAGE_NAME_1).getAppMetadataSource(),
1328                 is(PackageManager.APP_METADATA_SOURCE_INSTALLER));
1329     }
1330 
1331     @Test
testPackageRestrictionsDistractionFlagsDefault()1332     public void testPackageRestrictionsDistractionFlagsDefault() {
1333         final PackageSetting defaultSetting = createPackageSetting(PACKAGE_NAME_1);
1334         assertThat(defaultSetting.getDistractionFlags(0), is(PackageManager.RESTRICTION_NONE));
1335     }
1336 
1337     @Test
testEnableDisable()1338     public void testEnableDisable() {
1339         // Write the package files and make sure they're parsed properly the first time
1340         writeOldFiles();
1341         Settings settings = makeSettings();
1342         final WatchableTester watcher = new WatchableTester(settings, "testEnableDisable");
1343         watcher.register();
1344         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
1345         watcher.verifyChangeReported("readLPw");
1346 
1347         // Enable/Disable a package
1348         PackageSetting ps = settings.getPackageLPr(PACKAGE_NAME_1);
1349         watcher.verifyNoChangeReported("getPackageLPr");
1350         assertThat(ps.getEnabled(0), is(not(COMPONENT_ENABLED_STATE_DISABLED)));
1351         assertThat(ps.getEnabled(1), is(not(COMPONENT_ENABLED_STATE_ENABLED)));
1352         ps.setEnabled(COMPONENT_ENABLED_STATE_DISABLED, 0, null);
1353         watcher.verifyChangeReported("setEnabled DISABLED");
1354         ps.setEnabled(COMPONENT_ENABLED_STATE_ENABLED, 1, null);
1355         watcher.verifyChangeReported("setEnabled ENABLED");
1356         assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DISABLED));
1357         assertThat(ps.getEnabled(1), is(COMPONENT_ENABLED_STATE_ENABLED));
1358         watcher.verifyNoChangeReported("getEnabled");
1359 
1360         // Enable/Disable a component
1361         WatchedArraySet<String> components = new WatchedArraySet<String>();
1362         String component1 = PACKAGE_NAME_1 + "/.Component1";
1363         components.add(component1);
1364         ps.setDisabledComponents(components, 0);
1365         WatchedArraySet<String> componentsDisabled = ps.getDisabledComponents(0);
1366         assertThat(componentsDisabled.size(), is(1));
1367         assertThat(componentsDisabled.untrackedStorage().toArray()[0], is(component1));
1368         boolean hasEnabled =
1369                 ps.getEnabledComponents(0) != null && ps.getEnabledComponents(1).size() > 0;
1370         assertThat(hasEnabled, is(false));
1371 
1372         // User 1 should not have any disabled components
1373         boolean hasDisabled =
1374                 ps.getDisabledComponents(1) != null && ps.getDisabledComponents(1).size() > 0;
1375         assertThat(hasDisabled, is(false));
1376         ps.setEnabledComponents(components, 1);
1377         assertThat(ps.getEnabledComponents(1).size(), is(1));
1378         hasEnabled = ps.getEnabledComponents(0) != null && ps.getEnabledComponents(0).size() > 0;
1379         assertThat(hasEnabled, is(false));
1380     }
1381 
1382     private static final String PACKAGE_NAME = "com.android.bar";
1383     private static final String REAL_PACKAGE_NAME = "com.android.foo";
1384     private static final File INITIAL_CODE_PATH =
1385             new File(InstrumentationRegistry.getContext().getFilesDir(), "com.android.bar-1");
1386     private static final File UPDATED_CODE_PATH =
1387             new File(InstrumentationRegistry.getContext().getFilesDir(), "com.android.bar-2");
1388     private static final File UPDATED_CODE_PATH2 =
1389             new File(InstrumentationRegistry.getContext().getFilesDir(), "com.android.bar-3");
1390     private static final long INITIAL_VERSION_CODE = 10023L;
1391     private static final long UPDATED_VERSION_CODE = 10025L;
1392 
1393     @Test
testPackageStateCopy01()1394     public void testPackageStateCopy01() {
1395         final PackageSetting origPkgSetting01 = new PackageSetting(
1396                 PACKAGE_NAME,
1397                 REAL_PACKAGE_NAME,
1398                 INITIAL_CODE_PATH /*codePath*/,
1399                 ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_HAS_CODE,
1400                 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED|ApplicationInfo.PRIVATE_FLAG_HIDDEN,
1401                 UUID.randomUUID())
1402                 .setPrimaryCpuAbi("x86_64")
1403                 .setSecondaryCpuAbi("x86")
1404                 .setLongVersionCode(INITIAL_VERSION_CODE);
1405         origPkgSetting01.setPkg(mockAndroidPackage(origPkgSetting01));
1406         final PackageSetting testPkgSetting01 = new PackageSetting(origPkgSetting01);
1407         verifySettingCopy(origPkgSetting01, testPkgSetting01);
1408     }
1409 
1410     @Test
testPackageStateCopy02()1411     public void testPackageStateCopy02() {
1412         final PackageSetting origPkgSetting01 = new PackageSetting(
1413                 PACKAGE_NAME,
1414                 REAL_PACKAGE_NAME,
1415                 INITIAL_CODE_PATH /*codePath*/,
1416                 ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_HAS_CODE,
1417                 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED|ApplicationInfo.PRIVATE_FLAG_HIDDEN,
1418                 UUID.randomUUID())
1419                 .setPrimaryCpuAbi("x86_64")
1420                 .setSecondaryCpuAbi("x86")
1421                 .setLongVersionCode(INITIAL_VERSION_CODE);
1422         origPkgSetting01.setUserState(0, 100, 100, 1, true, false, false, false, 0, null, false,
1423                 false, "lastDisabledCaller", new ArraySet<>(new String[]{"enabledComponent1"}),
1424                 new ArraySet<>(new String[]{"disabledComponent1"}), 0, 0, "harmfulAppWarning",
1425                 "splashScreenTheme", 1000L, PackageManager.USER_MIN_ASPECT_RATIO_UNSET, null);
1426         final PersistableBundle appExtras1 = createPersistableBundle(
1427                 PACKAGE_NAME_1, 1L, 0.01, true, "appString1");
1428         final PersistableBundle launcherExtras1 = createPersistableBundle(
1429                 PACKAGE_NAME_1, 10L, 0.1, false, "launcherString1");
1430         final SuspendDialogInfo dialogInfo1 = new SuspendDialogInfo.Builder()
1431                 .setIcon(0x11220001)
1432                 .setTitle("String Title")
1433                 .setMessage("1st message")
1434                 .setNeutralButtonText(0x11220003)
1435                 .setNeutralButtonAction(BUTTON_ACTION_MORE_DETAILS)
1436                 .build();
1437         origPkgSetting01.modifyUserState(0).putSuspendParams(
1438                 UserPackage.of(0, "suspendingPackage1"),
1439                 new SuspendParams(dialogInfo1, appExtras1, launcherExtras1));
1440         origPkgSetting01.setPkg(mockAndroidPackage(origPkgSetting01));
1441         final PackageSetting testPkgSetting01 = new PackageSetting(
1442                 PACKAGE_NAME /*pkgName*/,
1443                 REAL_PACKAGE_NAME /*realPkgName*/,
1444                 UPDATED_CODE_PATH /*codePath*/,
1445                 0 /*pkgFlags*/,
1446                 0 /*pkgPrivateFlags*/,
1447                 UUID.randomUUID())
1448                 .setLongVersionCode(UPDATED_VERSION_CODE);
1449         testPkgSetting01.copyPackageSetting(origPkgSetting01, true);
1450         verifySettingCopy(origPkgSetting01, testPkgSetting01);
1451         verifyUserStatesCopy(origPkgSetting01.readUserState(0),
1452                 origPkgSetting01.getStateForUser(UserHandle.of(0)));
1453         verifyUserStatesCopy(origPkgSetting01.readUserState(0),
1454                 testPkgSetting01.readUserState(0));
1455     }
1456 
1457     /** Update package */
1458     @Test
testUpdatePackageSetting01()1459     public void testUpdatePackageSetting01() throws PackageManagerException {
1460         final PackageSetting testPkgSetting01 =
1461                 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/);
1462         testPkgSetting01.setInstalled(false /*installed*/, 0 /*userId*/);
1463         assertThat(testPkgSetting01.getFlags(), is(0));
1464         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1465         final PackageSetting oldPkgSetting01 = new PackageSetting(testPkgSetting01);
1466         Settings.updatePackageSetting(
1467                 testPkgSetting01,
1468                 null /*disabledPkg*/,
1469                 null /*existingSharedUserSetting*/,
1470                 null /*sharedUser*/,
1471                 UPDATED_CODE_PATH /*codePath*/,
1472                 null /*legacyNativeLibraryPath*/,
1473                 "arm64-v8a" /*primaryCpuAbi*/,
1474                 "armeabi" /*secondaryCpuAbi*/,
1475                 0 /*pkgFlags*/,
1476                 0 /*pkgPrivateFlags*/,
1477                 UserManagerService.getInstance(),
1478                 null /*usesSdkLibraries*/,
1479                 null /*usesSdkLibrariesVersions*/,
1480                 null /*usesSdkLibrariesOptional*/,
1481                 null /*usesStaticLibraries*/,
1482                 null /*usesStaticLibrariesVersions*/,
1483                 null /*mimeGroups*/,
1484                 UUID.randomUUID(),
1485                 34 /*targetSdkVersion*/,
1486                 null /*restrictUpdateHash*/,
1487                 false /*isDontKill*/);
1488         assertThat(testPkgSetting01.getPrimaryCpuAbi(), is("arm64-v8a"));
1489         assertThat(testPkgSetting01.getPrimaryCpuAbiLegacy(), is("arm64-v8a"));
1490         assertThat(testPkgSetting01.getSecondaryCpuAbi(), is("armeabi"));
1491         assertThat(testPkgSetting01.getSecondaryCpuAbiLegacy(), is("armeabi"));
1492         assertThat(testPkgSetting01.getFlags(), is(0));
1493         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1494         assertThat(testPkgSetting01.getPath(), is(UPDATED_CODE_PATH));
1495         assertNull(testPkgSetting01.getOldPaths());
1496         final PackageUserState userState = testPkgSetting01.readUserState(0);
1497         verifyUserState(userState, false /*notLaunched*/,
1498                 false /*stopped*/, false /*installed*/);
1499     }
1500 
1501     /** Update package; package now on /system, install for user '0' */
1502     @Test
testUpdatePackageSetting02()1503     public void testUpdatePackageSetting02() throws PackageManagerException {
1504         final PackageSetting testPkgSetting01 =
1505                 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/);
1506         testPkgSetting01.setInstalled(false /*installed*/, 0 /*userId*/);
1507         assertThat(testPkgSetting01.getFlags(), is(0));
1508         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1509         final PackageSetting oldPkgSetting01 = new PackageSetting(testPkgSetting01);
1510         Settings.updatePackageSetting(
1511                 testPkgSetting01,
1512                 null /*disabledPkg*/,
1513                 null /*existingSharedUserSetting*/,
1514                 null /*sharedUser*/,
1515                 UPDATED_CODE_PATH /*codePath*/,
1516                 null /*legacyNativeLibraryPath*/,
1517                 "arm64-v8a" /*primaryCpuAbi*/,
1518                 "armeabi" /*secondaryCpuAbi*/,
1519                 ApplicationInfo.FLAG_SYSTEM /*pkgFlags*/,
1520                 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED /*pkgPrivateFlags*/,
1521                 UserManagerService.getInstance(),
1522                 null /*usesSdkLibraries*/,
1523                 null /*usesSdkLibrariesVersions*/,
1524                 null /*usesSdkLibrariesOptional*/,
1525                 null /*usesStaticLibraries*/,
1526                 null /*usesStaticLibrariesVersions*/,
1527                 null /*mimeGroups*/,
1528                 UUID.randomUUID(),
1529                 34 /*targetSdkVersion*/,
1530                 null /*restrictUpdateHash*/,
1531                 false /*isDontKill*/);
1532         assertThat(testPkgSetting01.getPrimaryCpuAbi(), is("arm64-v8a"));
1533         assertThat(testPkgSetting01.getPrimaryCpuAbiLegacy(), is("arm64-v8a"));
1534         assertThat(testPkgSetting01.getSecondaryCpuAbi(), is("armeabi"));
1535         assertThat(testPkgSetting01.getSecondaryCpuAbiLegacy(), is("armeabi"));
1536         assertThat(testPkgSetting01.getFlags(), is(ApplicationInfo.FLAG_SYSTEM));
1537         assertThat(testPkgSetting01.isSystem(), is(true));
1538         assertThat(testPkgSetting01.getPrivateFlags(), is(ApplicationInfo.PRIVATE_FLAG_PRIVILEGED));
1539         assertThat(testPkgSetting01.isPrivileged(), is(true));
1540         final PackageUserState userState = testPkgSetting01.readUserState(0);
1541         verifyUserState(userState,  false /*notLaunched*/,
1542                 false /*stopped*/, true /*installed*/);
1543     }
1544 
1545     @Test
1546     @RequiresFlagsEnabled(Flags.FLAG_IMPROVE_INSTALL_DONT_KILL)
testUpdatePackageSettings02WithOldPaths()1547     public void testUpdatePackageSettings02WithOldPaths() throws PackageManagerException {
1548         final PackageSetting testPkgSetting01 =
1549                 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/);
1550         testPkgSetting01.setInstalled(false /*installed*/, 0 /*userId*/);
1551         assertThat(testPkgSetting01.getFlags(), is(0));
1552         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1553         final PackageSetting oldPkgSetting01 = new PackageSetting(testPkgSetting01);
1554         Settings.updatePackageSetting(
1555                 testPkgSetting01,
1556                 null /*disabledPkg*/,
1557                 null /*existingSharedUserSetting*/,
1558                 null /*sharedUser*/,
1559                 UPDATED_CODE_PATH /*codePath*/,
1560                 null /*legacyNativeLibraryPath*/,
1561                 "arm64-v8a" /*primaryCpuAbi*/,
1562                 "armeabi" /*secondaryCpuAbi*/,
1563                 ApplicationInfo.FLAG_SYSTEM /*pkgFlags*/,
1564                 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED /*pkgPrivateFlags*/,
1565                 UserManagerService.getInstance(),
1566                 null /*usesSdkLibraries*/,
1567                 null /*usesSdkLibrariesVersions*/,
1568                 null /*usesSdkLibrariesOptional*/,
1569                 null /*usesStaticLibraries*/,
1570                 null /*usesStaticLibrariesVersions*/,
1571                 null /*mimeGroups*/,
1572                 UUID.randomUUID(),
1573                 34 /*targetSdkVersion*/,
1574                 null /*restrictUpdateHash*/,
1575                 true /*isDontKill*/);
1576         assertThat(testPkgSetting01.getPath(), is(UPDATED_CODE_PATH));
1577         assertThat(testPkgSetting01.getOldPaths().size(), is(1));
1578         assertTrue(testPkgSetting01.getOldPaths().contains(INITIAL_CODE_PATH));
1579         Settings.updatePackageSetting(
1580                 testPkgSetting01,
1581                 null /*disabledPkg*/,
1582                 null /*existingSharedUserSetting*/,
1583                 null /*sharedUser*/,
1584                 UPDATED_CODE_PATH2 /*codePath*/,
1585                 null /*legacyNativeLibraryPath*/,
1586                 "arm64-v8a" /*primaryCpuAbi*/,
1587                 "armeabi" /*secondaryCpuAbi*/,
1588                 ApplicationInfo.FLAG_SYSTEM /*pkgFlags*/,
1589                 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED /*pkgPrivateFlags*/,
1590                 UserManagerService.getInstance(),
1591                 null /*usesSdkLibraries*/,
1592                 null /*usesSdkLibrariesVersions*/,
1593                 null /*usesSdkLibrariesOptional*/,
1594                 null /*usesStaticLibraries*/,
1595                 null /*usesStaticLibrariesVersions*/,
1596                 null /*mimeGroups*/,
1597                 UUID.randomUUID(),
1598                 34 /*targetSdkVersion*/,
1599                 null /*restrictUpdateHash*/,
1600                 true /*isDontKill*/);
1601         assertThat(testPkgSetting01.getPath(), is(UPDATED_CODE_PATH2));
1602         assertThat(testPkgSetting01.getOldPaths().size(), is(2));
1603         int index = 0;
1604         for (File path : testPkgSetting01.getOldPaths()) {
1605             switch (index) {
1606                 case 0 -> assertThat(path, is(INITIAL_CODE_PATH));
1607                 case 1 -> assertThat(path, is(UPDATED_CODE_PATH));
1608             }
1609             index++;
1610         }
1611     }
1612 
1613     /** Update package; changing shared user throws exception */
1614     @Test
testUpdatePackageSetting03()1615     public void testUpdatePackageSetting03() {
1616         Settings settings = makeSettings();
1617         final SharedUserSetting testUserSetting01 = createSharedUserSetting(
1618                 settings, "TestUser", 10064, 0 /*pkgFlags*/, 0 /*pkgPrivateFlags*/);
1619         final PackageSetting testPkgSetting01 =
1620                 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/);
1621         try {
1622             Settings.updatePackageSetting(
1623                     testPkgSetting01,
1624                     null /*disabledPkg*/,
1625                     null /*existingSharedUserSetting*/,
1626                     testUserSetting01 /*sharedUser*/,
1627                     UPDATED_CODE_PATH /*codePath*/,
1628                     null /*legacyNativeLibraryPath*/,
1629                     "arm64-v8a" /*primaryCpuAbi*/,
1630                     "armeabi" /*secondaryCpuAbi*/,
1631                     0 /*pkgFlags*/,
1632                     0 /*pkgPrivateFlags*/,
1633                     UserManagerService.getInstance(),
1634                     null /*usesSdkLibraries*/,
1635                     null /*usesSdkLibrariesVersions*/,
1636                     null /*usesSdkLibrariesOptional*/,
1637                     null /*usesStaticLibraries*/,
1638                     null /*usesStaticLibrariesVersions*/,
1639                     null /*mimeGroups*/,
1640                     UUID.randomUUID(),
1641                     34 /*targetSdkVersion*/,
1642                     null /*restrictUpdateHash*/,
1643                     false /*isDontKill*/);
1644             fail("Expected a PackageManagerException");
1645         } catch (PackageManagerException expected) {
1646         }
1647     }
1648 
1649     /** Create a new PackageSetting based on an original package setting */
1650     @Test
testCreateNewSetting01()1651     public void testCreateNewSetting01() {
1652         final PackageSetting originalPkgSetting01 =
1653                 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/);
1654         final PackageSignatures originalSignatures = originalPkgSetting01.getSignatures();
1655         final PackageSetting testPkgSetting01 = Settings.createNewSetting(
1656                 REAL_PACKAGE_NAME,
1657                 originalPkgSetting01 /*originalPkg*/,
1658                 null /*disabledPkg*/,
1659                 null /*realPkgName*/,
1660                 null /*sharedUser*/,
1661                 UPDATED_CODE_PATH /*codePath*/,
1662                 null /*legacyNativeLibraryPath*/,
1663                 "arm64-v8a" /*primaryCpuAbi*/,
1664                 "armeabi" /*secondaryCpuAbi*/,
1665                 UPDATED_VERSION_CODE /*versionCode*/,
1666                 ApplicationInfo.FLAG_SYSTEM /*pkgFlags*/,
1667                 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED /*pkgPrivateFlags*/,
1668                 null /*installUser*/,
1669                 false /*allowInstall*/,
1670                 false /*instantApp*/,
1671                 false /*virtualPreload*/,
1672                 false /* stopped */,
1673                 UserManagerService.getInstance(),
1674                 null /*usesSdkLibraries*/,
1675                 null /*usesSdkLibrariesVersions*/,
1676                 null /*usesSdkLibrariesOptional*/,
1677                 null /*usesStaticLibraries*/,
1678                 null /*usesStaticLibrariesVersions*/,
1679                 null /*mimeGroups*/,
1680                 UUID.randomUUID(),
1681                 34 /*targetSdkVersion*/,
1682                 null /*restrictUpdateHash*/);
1683         assertThat(testPkgSetting01.getPath(), is(UPDATED_CODE_PATH));
1684         assertThat(testPkgSetting01.getPackageName(), is(PACKAGE_NAME));
1685         assertThat(testPkgSetting01.getFlags(), is(ApplicationInfo.FLAG_SYSTEM));
1686         assertThat(testPkgSetting01.isSystem(), is(true));
1687         assertThat(testPkgSetting01.getPrivateFlags(), is(ApplicationInfo.PRIVATE_FLAG_PRIVILEGED));
1688         assertThat(testPkgSetting01.isPrivileged(), is(true));
1689         assertThat(testPkgSetting01.getPrimaryCpuAbi(), is("arm64-v8a"));
1690         assertThat(testPkgSetting01.getPrimaryCpuAbiLegacy(), is("arm64-v8a"));
1691         assertThat(testPkgSetting01.getSecondaryCpuAbi(), is("armeabi"));
1692         assertThat(testPkgSetting01.getSecondaryCpuAbiLegacy(), is("armeabi"));
1693         // signatures object must be different
1694         assertNotSame(testPkgSetting01.getSignatures(), originalSignatures);
1695         assertThat(testPkgSetting01.getVersionCode(), is(UPDATED_VERSION_CODE));
1696         final PackageUserState userState = testPkgSetting01.readUserState(0);
1697         verifyUserState(userState, false /*notLaunched*/, false /*stopped*/, true /*installed*/);
1698     }
1699 
1700     /** Create a new non-system PackageSetting */
1701     @Test
testCreateNewSetting02()1702     public void testCreateNewSetting02() {
1703         final PackageSetting testPkgSetting01 = Settings.createNewSetting(
1704                 PACKAGE_NAME,
1705                 null /*originalPkg*/,
1706                 null /*disabledPkg*/,
1707                 null /*realPkgName*/,
1708                 null /*sharedUser*/,
1709                 INITIAL_CODE_PATH /*codePath*/,
1710                 null /*legacyNativeLibraryPath*/,
1711                 "x86_64" /*primaryCpuAbiString*/,
1712                 "x86" /*secondaryCpuAbiString*/,
1713                 INITIAL_VERSION_CODE /*versionCode*/,
1714                 0 /*pkgFlags*/,
1715                 0 /*pkgPrivateFlags*/,
1716                 UserHandle.SYSTEM /*installUser*/,
1717                 true /*allowInstall*/,
1718                 false /*instantApp*/,
1719                 false /*virtualPreload*/,
1720                 false /* stopped */,
1721                 UserManagerService.getInstance(),
1722                 null /*usesSdkLibraries*/,
1723                 null /*usesSdkLibrariesVersions*/,
1724                 null /*usesSdkLibrariesOptional*/,
1725                 null /*usesStaticLibraries*/,
1726                 null /*usesStaticLibrariesVersions*/,
1727                 null /*mimeGroups*/,
1728                 UUID.randomUUID(),
1729                 34 /*targetSdkVersion*/,
1730                 null /*restrictUpdateHash*/);
1731         assertThat(testPkgSetting01.getAppId(), is(0));
1732         assertThat(testPkgSetting01.getPath(), is(INITIAL_CODE_PATH));
1733         assertThat(testPkgSetting01.getPackageName(), is(PACKAGE_NAME));
1734         assertThat(testPkgSetting01.getFlags(), is(0));
1735         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1736         assertThat(testPkgSetting01.getPrimaryCpuAbi(), is("x86_64"));
1737         assertThat(testPkgSetting01.getPrimaryCpuAbiLegacy(), is("x86_64"));
1738         assertThat(testPkgSetting01.getSecondaryCpuAbiLegacy(), is("x86"));
1739         assertThat(testPkgSetting01.getVersionCode(), is(INITIAL_VERSION_CODE));
1740         // by default, the package is considered stopped
1741         final PackageUserState userState = testPkgSetting01.readUserState(0);
1742         verifyUserState(userState, true /*notLaunched*/, true /*stopped*/, true /*installed*/);
1743     }
1744 
1745     /** Create PackageSetting for a shared user */
1746     @Test
testCreateNewSetting03()1747     public void testCreateNewSetting03() {
1748         Settings settings = makeSettings();
1749         final SharedUserSetting testUserSetting01 = createSharedUserSetting(
1750                 settings, "TestUser", 10064, 0 /*pkgFlags*/, 0 /*pkgPrivateFlags*/);
1751         final PackageSetting testPkgSetting01 = Settings.createNewSetting(
1752                 PACKAGE_NAME,
1753                 null /*originalPkg*/,
1754                 null /*disabledPkg*/,
1755                 null /*realPkgName*/,
1756                 testUserSetting01 /*sharedUser*/,
1757                 INITIAL_CODE_PATH /*codePath*/,
1758                 null /*legacyNativeLibraryPath*/,
1759                 "x86_64" /*primaryCpuAbiString*/,
1760                 "x86" /*secondaryCpuAbiString*/,
1761                 INITIAL_VERSION_CODE /*versionCode*/,
1762                 0 /*pkgFlags*/,
1763                 0 /*pkgPrivateFlags*/,
1764                 null /*installUser*/,
1765                 false /*allowInstall*/,
1766                 false /*instantApp*/,
1767                 false /*virtualPreload*/,
1768                 false /* stopped */,
1769                 UserManagerService.getInstance(),
1770                 null /*usesSdkLibraries*/,
1771                 null /*usesSdkLibrariesVersions*/,
1772                 null /*usesStaticLibraries*/,
1773                 null /*usesStaticLibrariesVersions*/,
1774                 null /*usesSdkLibrariesOptional*/,
1775                 null /*mimeGroups*/,
1776                 UUID.randomUUID(),
1777                 34 /*targetSdkVersion*/,
1778                 null /*restrictUpdateHash*/);
1779         assertThat(testPkgSetting01.getAppId(), is(10064));
1780         assertThat(testPkgSetting01.getPath(), is(INITIAL_CODE_PATH));
1781         assertThat(testPkgSetting01.getPackageName(), is(PACKAGE_NAME));
1782         assertThat(testPkgSetting01.getFlags(), is(0));
1783         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1784         assertThat(testPkgSetting01.getPrimaryCpuAbi(), is("x86_64"));
1785         assertThat(testPkgSetting01.getPrimaryCpuAbiLegacy(), is("x86_64"));
1786         assertThat(testPkgSetting01.getSecondaryCpuAbi(), is("x86"));
1787         assertThat(testPkgSetting01.getSecondaryCpuAbiLegacy(), is("x86"));
1788         assertThat(testPkgSetting01.getVersionCode(), is(INITIAL_VERSION_CODE));
1789         final PackageUserState userState = testPkgSetting01.readUserState(0);
1790         verifyUserState(userState, false /*notLaunched*/, false /*stopped*/, true /*installed*/);
1791     }
1792 
1793     /** Create a new PackageSetting based on a disabled package setting */
1794     @Test
testCreateNewSetting04()1795     public void testCreateNewSetting04() {
1796         final PackageSetting disabledPkgSetting01 =
1797                 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/);
1798         disabledPkgSetting01.setAppId(10064);
1799         final PackageSignatures disabledSignatures = disabledPkgSetting01.getSignatures();
1800         final PackageSetting testPkgSetting01 = Settings.createNewSetting(
1801                 PACKAGE_NAME,
1802                 null /*originalPkg*/,
1803                 disabledPkgSetting01 /*disabledPkg*/,
1804                 null /*realPkgName*/,
1805                 null /*sharedUser*/,
1806                 UPDATED_CODE_PATH /*codePath*/,
1807                 null /*legacyNativeLibraryPath*/,
1808                 "arm64-v8a" /*primaryCpuAbi*/,
1809                 "armeabi" /*secondaryCpuAbi*/,
1810                 UPDATED_VERSION_CODE /*versionCode*/,
1811                 0 /*pkgFlags*/,
1812                 0 /*pkgPrivateFlags*/,
1813                 null /*installUser*/,
1814                 false /*allowInstall*/,
1815                 false /*instantApp*/,
1816                 false /*virtualPreload*/,
1817                 false /* stopped */,
1818                 UserManagerService.getInstance(),
1819                 null /*usesSdkLibraries*/,
1820                 null /*usesSdkLibrariesVersions*/,
1821                 null /*usesStaticLibraries*/,
1822                 null /*usesStaticLibrariesVersions*/,
1823                 null /*usesSdkLibrariesOptional*/,
1824                 null /*mimeGroups*/,
1825                 UUID.randomUUID(),
1826                 34 /*targetSdkVersion*/,
1827                 null /*restrictUpdateHash*/);
1828         assertThat(testPkgSetting01.getAppId(), is(10064));
1829         assertThat(testPkgSetting01.getPath(), is(UPDATED_CODE_PATH));
1830         assertThat(testPkgSetting01.getPackageName(), is(PACKAGE_NAME));
1831         assertThat(testPkgSetting01.getFlags(), is(0));
1832         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1833         assertThat(testPkgSetting01.getPrimaryCpuAbi(), is("arm64-v8a"));
1834         assertThat(testPkgSetting01.getPrimaryCpuAbiLegacy(), is("arm64-v8a"));
1835         assertThat(testPkgSetting01.getSecondaryCpuAbi(), is("armeabi"));
1836         assertThat(testPkgSetting01.getSecondaryCpuAbiLegacy(), is("armeabi"));
1837         assertNotSame(testPkgSetting01.getSignatures(), disabledSignatures);
1838         assertThat(testPkgSetting01.getVersionCode(), is(UPDATED_VERSION_CODE));
1839         final PackageUserState userState = testPkgSetting01.readUserState(0);
1840         verifyUserState(userState, false /*notLaunched*/, false /*stopped*/, true /*installed*/);
1841     }
1842 
1843     /** Create a new stopped system PackageSetting */
1844     @Test
testCreateNewSetting05()1845     public void testCreateNewSetting05() {
1846         final PackageSetting testPkgSetting01 = Settings.createNewSetting(
1847                 PACKAGE_NAME,
1848                 null /*originalPkg*/,
1849                 null /*disabledPkg*/,
1850                 null /*realPkgName*/,
1851                 null /*sharedUser*/,
1852                 UPDATED_CODE_PATH /*codePath*/,
1853                 null /*legacyNativeLibraryPath*/,
1854                 "arm64-v8a" /*primaryCpuAbi*/,
1855                 "armeabi" /*secondaryCpuAbi*/,
1856                 UPDATED_VERSION_CODE /*versionCode*/,
1857                 ApplicationInfo.FLAG_SYSTEM /*pkgFlags*/,
1858                 0 /*pkgPrivateFlags*/,
1859                 UserHandle.SYSTEM /*installUser*/,
1860                 false /*allowInstall*/,
1861                 false /*instantApp*/,
1862                 false /*virtualPreload*/,
1863                 true /* stopped */,
1864                 UserManagerService.getInstance(),
1865                 null /*usesSdkLibraries*/,
1866                 null /*usesSdkLibrariesVersions*/,
1867                 null /*usesStaticLibraries*/,
1868                 null /*usesStaticLibrariesVersions*/,
1869                 null /*usesSdkLibrariesOptional*/,
1870                 null /*mimeGroups*/,
1871                 UUID.randomUUID(),
1872                 34 /*targetSdkVersion*/,
1873                 null /*restrictUpdateHash*/);
1874         assertThat(testPkgSetting01.getAppId(), is(0));
1875         assertThat(testPkgSetting01.getPath(), is(UPDATED_CODE_PATH));
1876         assertThat(testPkgSetting01.getPackageName(), is(PACKAGE_NAME));
1877         assertThat(testPkgSetting01.getFlags(), is(ApplicationInfo.FLAG_SYSTEM));
1878         assertThat(testPkgSetting01.getPrivateFlags(), is(0));
1879         assertThat(testPkgSetting01.getPrimaryCpuAbi(), is("arm64-v8a"));
1880         assertThat(testPkgSetting01.getPrimaryCpuAbiLegacy(), is("arm64-v8a"));
1881         assertThat(testPkgSetting01.getSecondaryCpuAbi(), is("armeabi"));
1882         assertThat(testPkgSetting01.getSecondaryCpuAbiLegacy(), is("armeabi"));
1883         assertThat(testPkgSetting01.getVersionCode(), is(UPDATED_VERSION_CODE));
1884         final PackageUserState userState = testPkgSetting01.readUserState(0);
1885         verifyUserState(userState, false /*notLaunched*/, true /*stopped*/, true /*installed*/);
1886     }
1887 
1888     @Test
testSetPkgStateLibraryFiles_addNewFiles()1889     public void testSetPkgStateLibraryFiles_addNewFiles() {
1890         final PackageSetting packageSetting = createPackageSetting("com.foo");
1891         final CountDownLatch countDownLatch = new CountDownLatch(1);
1892         packageSetting.registerObserver(new Watcher() {
1893             @Override
1894             public void onChange(Watchable what) {
1895                 countDownLatch.countDown();
1896             }
1897         });
1898 
1899         final List<String> newUsesLibraryFiles = new ArrayList<>();
1900         newUsesLibraryFiles.add("code/path/A.apk");
1901         newUsesLibraryFiles.add("code/path/B.apk");
1902         packageSetting.setPkgStateLibraryFiles(newUsesLibraryFiles);
1903 
1904         assertThat(countDownLatch.getCount(), is(0L));
1905     }
1906 
1907     @Test
testSetPkgStateLibraryFiles_removeOneExistingFile()1908     public void testSetPkgStateLibraryFiles_removeOneExistingFile() {
1909         final PackageSetting packageSetting = createPackageSetting("com.foo");
1910         final List<String> oldUsesLibraryFiles = new ArrayList<>();
1911         oldUsesLibraryFiles.add("code/path/A.apk");
1912         oldUsesLibraryFiles.add("code/path/B.apk");
1913         oldUsesLibraryFiles.add("code/path/C.apk");
1914         packageSetting.setPkgStateLibraryFiles(oldUsesLibraryFiles);
1915         final CountDownLatch countDownLatch = new CountDownLatch(1);
1916         packageSetting.registerObserver(new Watcher() {
1917             @Override
1918             public void onChange(Watchable what) {
1919                 countDownLatch.countDown();
1920             }
1921         });
1922 
1923         final List<String> newUsesLibraryFiles = new ArrayList<>();
1924         oldUsesLibraryFiles.add("code/path/A.apk");
1925         oldUsesLibraryFiles.add("code/path/B.apk");
1926         packageSetting.setPkgStateLibraryFiles(newUsesLibraryFiles);
1927 
1928         assertThat(countDownLatch.getCount(), is(0L));
1929     }
1930 
1931     @Test
testSetPkgStateLibraryFiles_changeOneOfFile()1932     public void testSetPkgStateLibraryFiles_changeOneOfFile() {
1933         final PackageSetting packageSetting = createPackageSetting("com.foo");
1934         final List<String> oldUsesLibraryFiles = new ArrayList<>();
1935         oldUsesLibraryFiles.add("code/path/A.apk");
1936         oldUsesLibraryFiles.add("code/path/B.apk");
1937         packageSetting.setPkgStateLibraryFiles(oldUsesLibraryFiles);
1938         final CountDownLatch countDownLatch = new CountDownLatch(1);
1939         packageSetting.registerObserver(new Watcher() {
1940             @Override
1941             public void onChange(Watchable what) {
1942                 countDownLatch.countDown();
1943             }
1944         });
1945 
1946         final List<String> newUsesLibraryFiles = new ArrayList<>();
1947         newUsesLibraryFiles.add("code/path/A.apk");
1948         newUsesLibraryFiles.add("code/path/B-1.apk");
1949         packageSetting.setPkgStateLibraryFiles(newUsesLibraryFiles);
1950 
1951         assertThat(countDownLatch.getCount(), is(0L));
1952     }
1953 
1954     @Test
testSetPkgStateLibraryFiles_nothingChanged()1955     public void testSetPkgStateLibraryFiles_nothingChanged() {
1956         final PackageSetting packageSetting = createPackageSetting("com.foo");
1957         final List<String> oldUsesLibraryFiles = new ArrayList<>();
1958         oldUsesLibraryFiles.add("code/path/A.apk");
1959         oldUsesLibraryFiles.add("code/path/B.apk");
1960         packageSetting.setPkgStateLibraryFiles(oldUsesLibraryFiles);
1961         final CountDownLatch countDownLatch = new CountDownLatch(1);
1962         packageSetting.registerObserver(new Watcher() {
1963             @Override
1964             public void onChange(Watchable what) {
1965                 countDownLatch.countDown();
1966             }
1967         });
1968 
1969         final List<String> newUsesLibraryFiles = new ArrayList<>();
1970         newUsesLibraryFiles.add("code/path/A.apk");
1971         newUsesLibraryFiles.add("code/path/B.apk");
1972         packageSetting.setPkgStateLibraryFiles(newUsesLibraryFiles);
1973 
1974         assertThat(countDownLatch.getCount(), is(1L));
1975     }
1976 
1977     @Test
testSetPkgStateLibraryFiles_addNewSdks()1978     public void testSetPkgStateLibraryFiles_addNewSdks() {
1979         final PackageSetting packageSetting = createPackageSetting("com.foo");
1980         final CountDownLatch countDownLatch = new CountDownLatch(1);
1981         packageSetting.registerObserver(new Watcher() {
1982             @Override
1983             public void onChange(Watchable what) {
1984                 countDownLatch.countDown();
1985             }
1986         });
1987 
1988         final List<String> files = new ArrayList<>();
1989         files.add("com.sdk1_123");
1990         files.add("com.sdk9_876");
1991         packageSetting.setUsesSdkLibraries(files.toArray(new String[files.size()]));
1992 
1993         assertThat(countDownLatch.getCount(), is(0L));
1994     }
1995 
1996     @Test
testRegisterAndRemoveAppId()1997     public void testRegisterAndRemoveAppId() throws PackageManagerException {
1998         // Test that the first new app UID should start from FIRST_APPLICATION_UID
1999         final Settings settings = makeSettings();
2000         final PackageSetting ps = createPackageSetting("com.foo");
2001         assertTrue(settings.registerAppIdLPw(ps, false));
2002         assertEquals(10000, ps.getAppId());
2003         // Set up existing app IDs: 10000, 10001, 10003
2004         final PackageSetting ps1 = createPackageSetting("com.foo1");
2005         ps1.setAppId(10001);
2006         final PackageSetting ps2 = createPackageSetting("com.foo2");
2007         ps2.setAppId(10003);
2008         final PackageSetting ps3 = createPackageSetting("com.foo3");
2009         assertEquals(0, ps3.getAppId());
2010         assertTrue(settings.registerAppIdLPw(ps1, false));
2011         assertTrue(settings.registerAppIdLPw(ps2, false));
2012         assertTrue(settings.registerAppIdLPw(ps3, false));
2013         assertEquals(10001, ps1.getAppId());
2014         assertEquals(10003, ps2.getAppId());
2015         // Expecting the new one to start with the next available uid
2016         assertEquals(10002, ps3.getAppId());
2017         // Remove and insert a new one and the new one should not reuse the same uid
2018         settings.removeAppIdLPw(10002);
2019         final PackageSetting ps4 = createPackageSetting("com.foo4");
2020         assertTrue(settings.registerAppIdLPw(ps4, false));
2021         assertEquals(10004, ps4.getAppId());
2022         // Keep adding more
2023         final PackageSetting ps5 = createPackageSetting("com.foo5");
2024         assertTrue(settings.registerAppIdLPw(ps5, false));
2025         assertEquals(10005, ps5.getAppId());
2026         // Remove the last one and the new one should use incremented uid
2027         settings.removeAppIdLPw(10005);
2028         final PackageSetting ps6 = createPackageSetting("com.foo6");
2029         assertTrue(settings.registerAppIdLPw(ps6, false));
2030         assertEquals(10006, ps6.getAppId());
2031     }
2032 
2033     /**
2034      * Test replacing a PackageSetting with a SharedUserSetting in mAppIds
2035      */
2036     @Test
testAddPackageSetting()2037     public void testAddPackageSetting() throws PackageManagerException {
2038         final Settings settings = makeSettings();
2039         final SharedUserSetting sus1 = new SharedUserSetting(
2040                 "TestUser", 0 /*pkgFlags*/, 0 /*pkgPrivateFlags*/);
2041         sus1.mAppId = 10001;
2042         final PackageSetting ps1 = createPackageSetting("com.foo");
2043         ps1.setAppId(10001);
2044         assertTrue(settings.registerAppIdLPw(ps1, false));
2045         settings.addPackageSettingLPw(ps1, sus1);
2046         assertSame(sus1, settings.getSharedUserSettingLPr(ps1));
2047     }
2048 
2049     @Test
testAddRemoveOldPaths()2050     public void testAddRemoveOldPaths() {
2051         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
2052         ps1.addOldPath(INITIAL_CODE_PATH);
2053         ps1.addOldPath(UPDATED_CODE_PATH);
2054         ps1.addOldPath(UPDATED_CODE_PATH2);
2055         assertThat(ps1.getOldPaths().size(), is(3));
2056         int index = 0;
2057         for (File path : ps1.getOldPaths()) {
2058             switch (index) {
2059                 case 0 -> assertThat(path, is(INITIAL_CODE_PATH));
2060                 case 1 -> assertThat(path, is(UPDATED_CODE_PATH));
2061                 case 2 -> assertThat(path, is(UPDATED_CODE_PATH2));
2062             }
2063             index++;
2064         }
2065 
2066         ps1.removeOldPath(UPDATED_CODE_PATH);
2067         assertThat(ps1.getOldPaths().size(), is(2));
2068         index = 0;
2069         for (File path : ps1.getOldPaths()) {
2070             switch (index) {
2071                 case 0 -> assertThat(path, is(INITIAL_CODE_PATH));
2072                 case 1 -> assertThat(path, is(UPDATED_CODE_PATH2));
2073             }
2074             index++;
2075         }
2076         ps1.removeOldPath(UPDATED_CODE_PATH2);
2077         // assert not throws when deleting non-existing element
2078         ps1.removeOldPath(UPDATED_CODE_PATH2);
2079         assertThat(ps1.getOldPaths().size(), is(1));
2080         assertTrue(ps1.getOldPaths().contains(INITIAL_CODE_PATH));
2081         ps1.removeOldPath(INITIAL_CODE_PATH);
2082         // assert not throws when deleting from an empty list
2083         ps1.removeOldPath(INITIAL_CODE_PATH);
2084         assertThat(ps1.getOldPaths().size(), is(0));
2085     }
2086 
2087     @Test
testOldPathsNotPreservedAfterReboot()2088     public void testOldPathsNotPreservedAfterReboot() {
2089         Settings settings = makeSettings();
2090         final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1);
2091         ps1.setAppId(Process.FIRST_APPLICATION_UID);
2092         ps1.setPkg(PackageImpl.forTesting(PACKAGE_NAME_1).hideAsParsed()
2093                 .setUid(ps1.getAppId())
2094                 .hideAsFinal());
2095         ps1.addOldPath(INITIAL_CODE_PATH);
2096         ps1.addOldPath(UPDATED_CODE_PATH);
2097         settings.mPackages.put(PACKAGE_NAME_1, ps1);
2098 
2099         settings.writeLPr(computer, /*sync=*/true);
2100         settings.mPackages.clear();
2101 
2102         assertThat(settings.readLPw(computer, createFakeUsers()), is(true));
2103         assertNull(settings.getPackageLPr(PACKAGE_NAME_1).getOldPaths());
2104     }
2105 
verifyUserState(PackageUserState userState, boolean notLaunched, boolean stopped, boolean installed)2106     private void verifyUserState(PackageUserState userState,
2107             boolean notLaunched, boolean stopped, boolean installed) {
2108         assertThat(userState.getEnabledState(), is(0));
2109         assertThat(userState.isHidden(), is(false));
2110         assertThat(userState.isInstalled(), is(installed));
2111         assertThat(userState.isNotLaunched(), is(notLaunched));
2112         assertThat(userState.isStopped(), is(stopped));
2113         assertThat(userState.isSuspended(), is(false));
2114         assertThat(userState.getDistractionFlags(), is(0));
2115     }
2116 
verifyKeySetData(PackageKeySetData originalData, PackageKeySetData testData)2117     private void verifyKeySetData(PackageKeySetData originalData, PackageKeySetData testData) {
2118         assertThat(originalData.getProperSigningKeySet(),
2119                 equalTo(testData.getProperSigningKeySet()));
2120         assertThat(originalData.getUpgradeKeySets(), is(testData.getUpgradeKeySets()));
2121         assertThat(originalData.getAliases(), is(testData.getAliases()));
2122     }
2123 
verifySettingCopy(PackageSetting origPkgSetting, PackageSetting testPkgSetting)2124     private void verifySettingCopy(PackageSetting origPkgSetting, PackageSetting testPkgSetting) {
2125         assertThat(origPkgSetting, is(not(testPkgSetting)));
2126         assertThat(origPkgSetting.getAppId(), is(testPkgSetting.getAppId()));
2127         assertSame(origPkgSetting.getPath(), testPkgSetting.getPath());
2128         assertThat(origPkgSetting.getPath(), is(testPkgSetting.getPath()));
2129         assertSame(origPkgSetting.getPathString(), testPkgSetting.getPathString());
2130         assertThat(origPkgSetting.getPathString(), is(testPkgSetting.getPathString()));
2131         assertSame(origPkgSetting.getCpuAbiOverride(), testPkgSetting.getCpuAbiOverride());
2132         assertThat(origPkgSetting.getCpuAbiOverride(), is(testPkgSetting.getCpuAbiOverride()));
2133         assertThat(origPkgSetting.getDomainSetId(), is(testPkgSetting.getDomainSetId()));
2134         assertSame(origPkgSetting.getInstallSource(), testPkgSetting.getInstallSource());
2135         assertThat(origPkgSetting.isInstallPermissionsFixed(),
2136                 is(testPkgSetting.isInstallPermissionsFixed()));
2137         verifyKeySetData(origPkgSetting.getKeySetData(), testPkgSetting.getKeySetData());
2138         assertThat(origPkgSetting.getLastUpdateTime(), is(testPkgSetting.getLastUpdateTime()));
2139         assertSame(origPkgSetting.getLegacyNativeLibraryPath(),
2140                 testPkgSetting.getLegacyNativeLibraryPath());
2141         assertThat(origPkgSetting.getLegacyNativeLibraryPath(),
2142                 is(testPkgSetting.getLegacyNativeLibraryPath()));
2143         if (origPkgSetting.getMimeGroups() != null
2144                 && origPkgSetting.getMimeGroups() != Collections.<String, Set<String>>emptyMap()) {
2145             assertNotSame(origPkgSetting.getMimeGroups(), testPkgSetting.getMimeGroups());
2146         }
2147         assertThat(origPkgSetting.getMimeGroups(), is(testPkgSetting.getMimeGroups()));
2148         assertNotSame(origPkgSetting.mLegacyPermissionsState,
2149                 testPkgSetting.mLegacyPermissionsState);
2150         assertThat(origPkgSetting.mLegacyPermissionsState,
2151                 is(testPkgSetting.mLegacyPermissionsState));
2152         assertThat(origPkgSetting.getPackageName(), is(testPkgSetting.getPackageName()));
2153         // mOldCodePaths is _not_ copied
2154         // assertNotSame(origPkgSetting.mOldCodePaths, testPkgSetting.mOldCodePaths);
2155         // assertThat(origPkgSetting.mOldCodePaths, is(not(testPkgSetting.mOldCodePaths)));
2156         assertSame(origPkgSetting.getPkg(), testPkgSetting.getPkg());
2157         assertSame(origPkgSetting.getAndroidPackage(), origPkgSetting.getPkg());
2158         assertThat(origPkgSetting.getAndroidPackage().getPackageName(),
2159                 is(origPkgSetting.getPackageName()));
2160         // No equals() method for this object
2161         // assertThat(origPkgSetting.pkg, is(testPkgSetting.pkg));
2162         assertThat(origPkgSetting.getFlags(), is(testPkgSetting.getFlags()));
2163         assertThat(origPkgSetting.getPrivateFlags(), is(testPkgSetting.getPrivateFlags()));
2164         assertSame(origPkgSetting.getPrimaryCpuAbi(), testPkgSetting.getPrimaryCpuAbi());
2165         assertThat(origPkgSetting.getPrimaryCpuAbi(), is(testPkgSetting.getPrimaryCpuAbi()));
2166         assertSame(origPkgSetting.getPrimaryCpuAbiLegacy(), testPkgSetting.getPrimaryCpuAbiLegacy());
2167         assertThat(origPkgSetting.getPrimaryCpuAbiLegacy(), is(testPkgSetting.getPrimaryCpuAbiLegacy()));
2168         assertThat(origPkgSetting.getRealName(), is(testPkgSetting.getRealName()));
2169         assertSame(origPkgSetting.getSecondaryCpuAbi(), testPkgSetting.getSecondaryCpuAbi());
2170         assertThat(origPkgSetting.getSecondaryCpuAbi(), is(testPkgSetting.getSecondaryCpuAbi()));
2171         assertSame(origPkgSetting.getSecondaryCpuAbiLegacy(), testPkgSetting.getSecondaryCpuAbiLegacy());
2172         assertThat(origPkgSetting.getSecondaryCpuAbiLegacy(), is(testPkgSetting.getSecondaryCpuAbiLegacy()));
2173         assertSame(origPkgSetting.getSignatures(), testPkgSetting.getSignatures());
2174         assertThat(origPkgSetting.getSignatures(), is(testPkgSetting.getSignatures()));
2175         assertThat(origPkgSetting.getLastModifiedTime(), is(testPkgSetting.getLastModifiedTime()));
2176         assertNotSame(origPkgSetting.getUserStates(), is(testPkgSetting.getUserStates()));
2177         // No equals() method for SparseArray object
2178         // assertThat(origPkgSetting.getUserState(), is(testPkgSetting.getUserState()));
2179         assertThat(origPkgSetting.getVersionCode(), is(testPkgSetting.getVersionCode()));
2180         assertSame(origPkgSetting.getVolumeUuid(), testPkgSetting.getVolumeUuid());
2181         assertThat(origPkgSetting.getVolumeUuid(), is(testPkgSetting.getVolumeUuid()));
2182     }
2183 
verifyUserStatesCopy(PackageUserStateInternal origPus, PackageUserStateInternal testPus)2184     private void verifyUserStatesCopy(PackageUserStateInternal origPus,
2185             PackageUserStateInternal testPus) {
2186         assertThat(userStateEquals(origPus, testPus), is(true));
2187         // Verify suspendParams are copied over
2188         assertThat(origPus.getSuspendParams(), is(notNullValue()));
2189         assertThat(testPus.getSuspendParams(), is(notNullValue()));
2190         SuspendParams origSuspendParams = origPus.getSuspendParams().valueAt(0);
2191         SuspendParams testSuspendParams = testPus.getSuspendParams().valueAt(0);
2192         assertThat(origSuspendParams.getDialogInfo().equals(testSuspendParams.getDialogInfo()),
2193                 is(true));
2194         assertThat(BaseBundle.kindofEquals(
2195                 origSuspendParams.getAppExtras(), testSuspendParams.getAppExtras()), is(true));
2196         assertThat(BaseBundle.kindofEquals(origSuspendParams.getLauncherExtras(),
2197                 testSuspendParams.getLauncherExtras()), is(true));
2198     }
2199 
verifyUserStatesCopy(PackageUserState origPus, PackageUserState testPus)2200     private void verifyUserStatesCopy(PackageUserState origPus,
2201             PackageUserState testPus) {
2202         assertThat(userStateEquals(origPus, testPus), is(true));
2203         // Verify that disabledComponents and enabledComponents are copied
2204         assertThat(origPus.getDisabledComponents(), is(notNullValue()));
2205         assertThat(origPus.getDisabledComponents().equals(testPus.getDisabledComponents()),
2206                 is(true));
2207         assertThat(origPus.getEnabledComponents(), is(notNullValue()));
2208         assertThat(origPus.getEnabledComponents().equals(testPus.getEnabledComponents()),
2209                 is(true));
2210     }
2211 
userStateEquals(PackageUserState userState, PackageUserState oldUserState)2212     private boolean userStateEquals(PackageUserState userState, PackageUserState oldUserState) {
2213         return userState.isHidden() == oldUserState.isHidden()
2214                 && userState.isStopped() == oldUserState.isStopped()
2215                 && userState.isInstalled() == oldUserState.isInstalled()
2216                 && userState.isSuspended() == oldUserState.isSuspended()
2217                 && userState.isNotLaunched() == oldUserState.isNotLaunched()
2218                 && userState.isInstantApp() == oldUserState.isInstantApp()
2219                 && userState.isVirtualPreload() == oldUserState.isVirtualPreload()
2220                 && (userState.getAllOverlayPaths() != null
2221                 ? userState.getAllOverlayPaths().equals(oldUserState.getAllOverlayPaths())
2222                 : oldUserState.getOverlayPaths() == null)
2223                 && userState.getCeDataInode() == oldUserState.getCeDataInode()
2224                 && userState.getDistractionFlags() == oldUserState.getDistractionFlags()
2225                 && userState.getFirstInstallTimeMillis() == oldUserState.getFirstInstallTimeMillis()
2226                 && userState.getEnabledState() == oldUserState.getEnabledState()
2227                  && userState.getHarmfulAppWarning().equals(oldUserState.getHarmfulAppWarning())
2228                 && userState.getInstallReason() == oldUserState.getInstallReason()
2229                 && userState.getLastDisableAppCaller().equals(
2230                         oldUserState.getLastDisableAppCaller())
2231                 && (userState.getSharedLibraryOverlayPaths() != null
2232                 ? userState.getSharedLibraryOverlayPaths().equals(
2233                         oldUserState.getSharedLibraryOverlayPaths())
2234                 : oldUserState.getSharedLibraryOverlayPaths() == null)
2235                 && userState.getSplashScreenTheme().equals(
2236                         oldUserState.getSplashScreenTheme())
2237                 && userState.getUninstallReason() == oldUserState.getUninstallReason()
2238                 && userState.getMinAspectRatio() == oldUserState.getMinAspectRatio();
2239     }
2240 
createSharedUserSetting(Settings settings, String userName, int sharedUserId, int pkgFlags, int pkgPrivateFlags)2241     private SharedUserSetting createSharedUserSetting(Settings settings, String userName,
2242             int sharedUserId, int pkgFlags, int pkgPrivateFlags) {
2243         return settings.addSharedUserLPw(
2244                 userName,
2245                 sharedUserId,
2246                 pkgFlags,
2247                 pkgPrivateFlags);
2248     }
createPackageSetting(int sharedUserId, int pkgFlags)2249     private PackageSetting createPackageSetting(int sharedUserId, int pkgFlags) {
2250         return new PackageSetting(
2251                 PACKAGE_NAME,
2252                 REAL_PACKAGE_NAME,
2253                 INITIAL_CODE_PATH /*codePath*/,
2254                 pkgFlags,
2255                 0 /*privateFlags*/,
2256                 UUID.randomUUID())
2257                 .setPrimaryCpuAbi("x86_64")
2258                 .setSecondaryCpuAbi("x86")
2259                 .setLongVersionCode(INITIAL_VERSION_CODE)
2260                 .setSharedUserAppId(sharedUserId);
2261     }
2262 
createPackageSetting(String packageName)2263     private PackageSetting createPackageSetting(String packageName) {
2264         return new PackageSetting(
2265                 packageName,
2266                 packageName,
2267                 INITIAL_CODE_PATH /*codePath*/,
2268                 0,
2269                 0 /*privateFlags*/,
2270                 UUID.randomUUID())
2271                 .setPrimaryCpuAbi("x86_64")
2272                 .setSecondaryCpuAbi("x86")
2273                 .setLongVersionCode(INITIAL_VERSION_CODE);
2274     }
2275 
createFakeUsers()2276     static @NonNull List<UserInfo> createFakeUsers() {
2277         ArrayList<UserInfo> users = new ArrayList<>();
2278         users.add(new UserInfo(UserHandle.USER_SYSTEM, "test user", UserInfo.FLAG_INITIALIZED));
2279         return users;
2280     }
2281 
writeFile(File file, byte[] data)2282     private static void writeFile(File file, byte[] data) {
2283         file.mkdirs();
2284         try {
2285             AtomicFile aFile = new AtomicFile(file);
2286             FileOutputStream fos = aFile.startWrite();
2287             fos.write(data);
2288             aFile.finishWrite(fos);
2289         } catch (IOException ioe) {
2290             throw new RuntimeException("Cannot write file " + file.getPath(), ioe);
2291         }
2292     }
2293 
writeCorruptedPackagesXml()2294     private void writeCorruptedPackagesXml() {
2295         writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/packages.xml"),
2296                 ("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>"
2297                         + "<packages>"
2298                         + "<last-platform-version internal=\"15\" external=\"0\" />"
2299                         + "<permission-trees>"
2300                         + "<item name=\"com.google.android.permtree\""
2301                 ).getBytes());
2302     }
2303 
writePackagesXml(String fileName)2304     static void writePackagesXml(String fileName) {
2305         writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), fileName),
2306                 ("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>"
2307                 + "<packages>"
2308                 + "<last-platform-version internal=\"15\" external=\"0\" fingerprint=\"foo\" />"
2309                 + "<permission-trees>"
2310                 + "<item name=\"com.google.android.permtree\" package=\"com.google.android.permpackage\" />"
2311                 + "</permission-trees>"
2312                 + "<permissions>"
2313                 + "<item name=\"android.permission.WRITE_CALL_LOG\" package=\"android\" protection=\"1\" />"
2314                 + "<item name=\"android.permission.ASEC_ACCESS\" package=\"android\" protection=\"2\" />"
2315                 + "<item name=\"android.permission.REBOOT\" package=\"android\" protection=\"18\" />"
2316                 + "</permissions>"
2317                 + "<package name=\"com.android.app1\" codePath=\"/system/app/app1.apk\" nativeLibraryPath=\"/data/data/com.android.app1/lib\" flags=\"1\" ft=\"1360e2caa70\" it=\"135f2f80d08\" ut=\"1360e2caa70\" version=\"1109\" sharedUserId=\"11000\">"
2318                 + "<sigs count=\"1\">"
2319                 + "<cert index=\"0\" key=\"" + KeySetStrings.ctsKeySetCertA + "\" />"
2320                 + "</sigs>"
2321                 + "<proper-signing-keyset identifier=\"1\" />"
2322                 + "</package>"
2323                 + "<package name=\"com.android.app2\" codePath=\"/system/app/app2.apk\" nativeLibraryPath=\"/data/data/com.android.app2/lib\" flags=\"1\" ft=\"1360e578718\" it=\"135f2f80d08\" ut=\"1360e578718\" version=\"15\" enabled=\"3\" userId=\"11001\">"
2324                 + "<sigs count=\"1\">"
2325                 + "<cert index=\"0\" />"
2326                 + "</sigs>"
2327                 + "<proper-signing-keyset identifier=\"1\" />"
2328                 + "<defined-keyset alias=\"AB\" identifier=\"4\" />"
2329                 + "</package>"
2330                 + "<package name=\"com.android.app3\" codePath=\"/system/app/app3.apk\" nativeLibraryPath=\"/data/data/com.android.app3/lib\" flags=\"1\" ft=\"1360e577b60\" it=\"135f2f80d08\" ut=\"1360e577b60\" version=\"15\" userId=\"11030\">"
2331                 + "<sigs count=\"1\">"
2332                 + "<cert index=\"1\" key=\"" + KeySetStrings.ctsKeySetCertB + "\" />"
2333                 + "</sigs>"
2334                 + "<proper-signing-keyset identifier=\"2\" />"
2335                 + "<upgrade-keyset identifier=\"3\" />"
2336                 + "<defined-keyset alias=\"C\" identifier=\"3\" />"
2337                 + "</package>"
2338                 + "<shared-user name=\"com.android.shared1\" userId=\"11000\">"
2339                 + "<sigs count=\"1\">"
2340                 + "<cert index=\"1\" />"
2341                 + "</sigs>"
2342                 + "<perms>"
2343                 + "<item name=\"android.permission.REBOOT\" />"
2344                 + "</perms>"
2345                 + "</shared-user>"
2346                 + "<keyset-settings version=\"1\">"
2347                 + "<keys>"
2348                 + "<public-key identifier=\"1\" value=\"" + KeySetStrings.ctsKeySetPublicKeyA + "\" />"
2349                 + "<public-key identifier=\"2\" value=\"" + KeySetStrings.ctsKeySetPublicKeyB + "\" />"
2350                 + "<public-key identifier=\"3\" value=\"" + KeySetStrings.ctsKeySetPublicKeyC + "\" />"
2351                 + "</keys>"
2352                 + "<keysets>"
2353                 + "<keyset identifier=\"1\">"
2354                 + "<key-id identifier=\"1\" />"
2355                 + "</keyset>"
2356                 + "<keyset identifier=\"2\">"
2357                 + "<key-id identifier=\"2\" />"
2358                 + "</keyset>"
2359                 + "<keyset identifier=\"3\">"
2360                 + "<key-id identifier=\"3\" />"
2361                 + "</keyset>"
2362                 + "<keyset identifier=\"4\">"
2363                 + "<key-id identifier=\"1\" />"
2364                 + "<key-id identifier=\"2\" />"
2365                 + "</keyset>"
2366                 + "</keysets>"
2367                 + "<lastIssuedKeyId value=\"3\" />"
2368                 + "<lastIssuedKeySetId value=\"4\" />"
2369                 + "</keyset-settings>"
2370                 + "</packages>").getBytes());
2371     }
2372 
writePackageRestrictions_noSuspendingPackageXml(final int userId)2373     private void writePackageRestrictions_noSuspendingPackageXml(final int userId) {
2374         writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/users/"
2375                         + userId + "/package-restrictions.xml"),
2376                 ("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n"
2377                         + "<package-restrictions>\n"
2378                         + "    <pkg name=\"" + PACKAGE_NAME_1 + "\" suspended=\"true\" />"
2379                         + "    <pkg name=\"" + PACKAGE_NAME_2 + "\" suspended=\"false\" />"
2380                         + "    <preferred-activities />\n"
2381                         + "    <persistent-preferred-activities />\n"
2382                         + "    <crossProfile-intent-filters />\n"
2383                         + "    <default-apps />\n"
2384                         + "</package-restrictions>\n")
2385                         .getBytes());
2386     }
2387 
writePackageRestrictions_noSuspendParamsMapXml(final int userId)2388     private void writePackageRestrictions_noSuspendParamsMapXml(final int userId) {
2389         writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/users/"
2390                         + userId + "/package-restrictions.xml"),
2391                 ("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n"
2392                         + "<package-restrictions>\n"
2393                         + "    <pkg name=\"" + PACKAGE_NAME_1 + "\" "
2394                         + "     suspended=\"true\" suspending-package=\"" + PACKAGE_NAME_3 + "\">\n"
2395                         + "        <suspended-dialog-info dialogMessage=\"Dialog Message\""
2396                         + "         iconResId=\"" + TEST_RESOURCE_ID + "\"/>\n"
2397                         + "        <suspended-app-extras>\n"
2398                         + "            <string name=\"app_extra_string\">value</string>\n"
2399                         + "        </suspended-app-extras>\n"
2400                         + "        <suspended-launcher-extras>\n"
2401                         + "            <long name=\"launcher_extra_long\" value=\"4\" />\n"
2402                         + "        </suspended-launcher-extras>\n"
2403                         + "    </pkg>\n"
2404                         + "    <preferred-activities />\n"
2405                         + "    <persistent-preferred-activities />\n"
2406                         + "    <crossProfile-intent-filters />\n"
2407                         + "    <default-apps />\n"
2408                         + "</package-restrictions>\n")
2409                         .getBytes());
2410     }
2411 
writeCorruptedPackageRestrictions(final int userId)2412     private void writeCorruptedPackageRestrictions(final int userId) {
2413         writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/users/"
2414                         + userId + "/package-restrictions.xml"),
2415                 ("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n"
2416                         + "<package-restrictions>\n"
2417                         + "    <pkg name=\"" + PACKAGE_NAME_1 + "\" ").getBytes());
2418     }
2419 
writeStoppedPackagesXml()2420     private static void writeStoppedPackagesXml() {
2421         writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/packages-stopped.xml"),
2422                 ( "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>"
2423                 + "<stopped-packages>"
2424                 + "<pkg name=\"com.android.app1\" nl=\"1\" />"
2425                 + "<pkg name=\"com.android.app3\" nl=\"1\" />"
2426                 + "</stopped-packages>")
2427                 .getBytes());
2428     }
2429 
writePackagesList()2430     private static void writePackagesList() {
2431         writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/packages.list"),
2432                 ( "com.android.app1 11000 0 /data/data/com.android.app1 seinfo1"
2433                 + "com.android.app2 11001 0 /data/data/com.android.app2 seinfo2"
2434                 + "com.android.app3 11030 0 /data/data/com.android.app3 seinfo3")
2435                 .getBytes());
2436     }
2437 
deleteSystemFolder()2438     private static void deleteSystemFolder() {
2439         File systemFolder = new File(InstrumentationRegistry.getContext().getFilesDir(), "system");
2440         deleteFolder(systemFolder);
2441     }
2442 
deleteFolder(File folder)2443     private static void deleteFolder(File folder) {
2444         File[] files = folder.listFiles();
2445         if (files != null) {
2446             for (File file : files) {
2447                 deleteFolder(file);
2448             }
2449         }
2450         folder.delete();
2451     }
2452 
writeOldFiles()2453     static void writeOldFiles() {
2454         deleteSystemFolder();
2455         writePackagesXml("system/packages.xml");
2456         writeStoppedPackagesXml();
2457         writePackagesList();
2458     }
2459 
writeReserveCopyOldFiles()2460     private void writeReserveCopyOldFiles() {
2461         deleteSystemFolder();
2462         writePackagesXml("system/packages.xml.reservecopy");
2463         writeStoppedPackagesXml();
2464         writePackagesList();
2465     }
2466 
makeSettings()2467     private Settings makeSettings() {
2468         return new Settings(InstrumentationRegistry.getContext().getFilesDir(),
2469                 mRuntimePermissionsPersistence, mPermissionDataProvider,
2470                 mDomainVerificationManager, mHandler,
2471                 new PackageManagerTracedLock());
2472     }
2473 
verifyKeySetMetaData(Settings settings)2474     static void verifyKeySetMetaData(Settings settings)
2475             throws ReflectiveOperationException, IllegalAccessException {
2476         WatchedArrayMap<String, PackageSetting> packages = settings.mPackages;
2477         KeySetManagerService ksms = settings.getKeySetManagerService();
2478 
2479         /* verify keyset and public key ref counts */
2480         assertThat(KeySetUtils.getKeySetRefCount(ksms, 1), is(2));
2481         assertThat(KeySetUtils.getKeySetRefCount(ksms, 2), is(1));
2482         assertThat(KeySetUtils.getKeySetRefCount(ksms, 3), is(1));
2483         assertThat(KeySetUtils.getKeySetRefCount(ksms, 4), is(1));
2484         assertThat(KeySetUtils.getPubKeyRefCount(ksms, 1), is(2));
2485         assertThat(KeySetUtils.getPubKeyRefCount(ksms, 2), is(2));
2486         assertThat(KeySetUtils.getPubKeyRefCount(ksms, 3), is(1));
2487 
2488         /* verify public keys properly read */
2489         PublicKey keyA = parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
2490         PublicKey keyB = parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
2491         PublicKey keyC = parsePublicKey(KeySetStrings.ctsKeySetPublicKeyC);
2492         assertThat(KeySetUtils.getPubKey(ksms, 1), is(keyA));
2493         assertThat(KeySetUtils.getPubKey(ksms, 2), is(keyB));
2494         assertThat(KeySetUtils.getPubKey(ksms, 3), is(keyC));
2495 
2496         /* verify mapping is correct (ks -> pub keys) */
2497         LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(ksms);
2498         ArraySet<Long> mapping = ksMapping.get(1);
2499         assertThat(mapping.size(), is(1));
2500         assertThat(mapping.contains(new Long(1)), is(true));
2501         mapping = ksMapping.get(2);
2502         assertThat(mapping.size(), is(1));
2503         assertThat(mapping.contains(new Long(2)), is(true));
2504         mapping = ksMapping.get(3);
2505         assertThat(mapping.size(), is(1));
2506         assertThat(mapping.contains(new Long(3)), is(true));
2507         mapping = ksMapping.get(4);
2508         assertThat(mapping.size(), is(2));
2509         assertThat(mapping.contains(new Long(1)), is(true));
2510         assertThat(mapping.contains(new Long(2)), is(true));
2511 
2512         /* verify lastIssuedIds are consistent */
2513         assertThat(KeySetUtils.getLastIssuedKeyId(ksms), is(3L));
2514         assertThat(KeySetUtils.getLastIssuedKeySetId(ksms), is(4L));
2515 
2516         /* verify packages have been given the appropriate information */
2517         PackageSetting ps = packages.get("com.android.app1");
2518         assertThat(ps.getKeySetData().getProperSigningKeySet(), is(1L));
2519         ps = packages.get("com.android.app2");
2520         assertThat(ps.getKeySetData().getProperSigningKeySet(), is(1L));
2521         assertThat(ps.getKeySetData().getAliases().get("AB"), is(4L));
2522         ps = packages.get("com.android.app3");
2523         assertThat(ps.getKeySetData().getProperSigningKeySet(), is(2L));
2524         assertThat(ps.getKeySetData().getAliases().get("C"), is(3L));
2525         assertThat(ps.getKeySetData().getUpgradeKeySets().length, is(1));
2526         assertThat(ps.getKeySetData().getUpgradeKeySets()[0], is(3L));
2527     }
2528 
2529     @NonNull
mockAndroidPackage(PackageSetting pkgSetting)2530     private AndroidPackage mockAndroidPackage(PackageSetting pkgSetting) {
2531         return PackageImpl.forTesting(pkgSetting.getPackageName()).hideAsParsed().hideAsFinal();
2532     }
2533 
2534 }
2535