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 17package com.android.server.pm; 18 19import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 20import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED; 21import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER; 22import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED; 23 24import static org.hamcrest.CoreMatchers.equalTo; 25import static org.hamcrest.CoreMatchers.is; 26import static org.hamcrest.CoreMatchers.not; 27import static org.hamcrest.CoreMatchers.notNullValue; 28import static org.hamcrest.CoreMatchers.nullValue; 29import static org.junit.Assert.assertNotSame; 30import static org.junit.Assert.assertSame; 31import static org.junit.Assert.assertThat; 32import static org.junit.Assert.assertTrue; 33import static org.junit.Assert.fail; 34 35import android.annotation.NonNull; 36import android.content.Context; 37import android.content.pm.ApplicationInfo; 38import android.content.pm.PackageParser; 39import android.content.pm.PackageUserState; 40import android.content.pm.UserInfo; 41import android.os.BaseBundle; 42import android.os.PersistableBundle; 43import android.os.UserHandle; 44import android.os.UserManagerInternal; 45import android.support.test.InstrumentationRegistry; 46import android.support.test.filters.SmallTest; 47import android.support.test.runner.AndroidJUnit4; 48import android.util.ArrayMap; 49import android.util.ArraySet; 50import android.util.Log; 51import android.util.LongSparseArray; 52 53import com.android.internal.os.AtomicFile; 54import com.android.server.LocalServices; 55import com.android.server.pm.permission.PermissionManagerInternal; 56import com.android.server.pm.permission.PermissionManagerService; 57 58import org.junit.After; 59import org.junit.Before; 60import org.junit.Test; 61import org.junit.runner.RunWith; 62 63import java.io.File; 64import java.io.FileOutputStream; 65import java.io.IOException; 66import java.security.PublicKey; 67import java.util.ArrayList; 68import java.util.Arrays; 69import java.util.List; 70 71@RunWith(AndroidJUnit4.class) 72@SmallTest 73public class PackageManagerSettingsTests { 74 private static final String PACKAGE_NAME_2 = "com.android.app2"; 75 private static final String PACKAGE_NAME_3 = "com.android.app3"; 76 private static final String PACKAGE_NAME_1 = "com.android.app1"; 77 public static final String TAG = "PackageManagerSettingsTests"; 78 protected final String PREFIX = "android.content.pm"; 79 80 /** make sure our initialized KeySetManagerService metadata matches packages.xml */ 81 @Test 82 public void testReadKeySetSettings() 83 throws ReflectiveOperationException, IllegalAccessException { 84 /* write out files and read */ 85 writeOldFiles(); 86 final Context context = InstrumentationRegistry.getContext(); 87 final Object lock = new Object(); 88 PermissionManagerInternal pmInt = PermissionManagerService.create(context, null, lock); 89 Settings settings = 90 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 91 assertThat(settings.readLPw(createFakeUsers()), is(true)); 92 verifyKeySetMetaData(settings); 93 } 94 95 /** read in data, write it out, and read it back in. Verify same. */ 96 @Test 97 public void testWriteKeySetSettings() 98 throws ReflectiveOperationException, IllegalAccessException { 99 // write out files and read 100 writeOldFiles(); 101 final Context context = InstrumentationRegistry.getContext(); 102 final Object lock = new Object(); 103 PermissionManagerInternal pmInt = PermissionManagerService.create(context, null, lock); 104 Settings settings = 105 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 106 assertThat(settings.readLPw(createFakeUsers()), is(true)); 107 108 // write out, read back in and verify the same 109 settings.writeLPr(); 110 assertThat(settings.readLPw(createFakeUsers()), is(true)); 111 verifyKeySetMetaData(settings); 112 } 113 114 @Test 115 public void testSettingsReadOld() { 116 // Write the package files and make sure they're parsed properly the first time 117 writeOldFiles(); 118 final Context context = InstrumentationRegistry.getContext(); 119 final Object lock = new Object(); 120 PermissionManagerInternal pmInt = PermissionManagerService.create(context, null, lock); 121 Settings settings = 122 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 123 assertThat(settings.readLPw(createFakeUsers()), is(true)); 124 assertThat(settings.getPackageLPr(PACKAGE_NAME_3), is(notNullValue())); 125 assertThat(settings.getPackageLPr(PACKAGE_NAME_1), is(notNullValue())); 126 127 PackageSetting ps = settings.getPackageLPr(PACKAGE_NAME_1); 128 assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DEFAULT)); 129 assertThat(ps.getNotLaunched(0), is(true)); 130 131 ps = settings.getPackageLPr(PACKAGE_NAME_2); 132 assertThat(ps.getStopped(0), is(false)); 133 assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DISABLED_USER)); 134 assertThat(ps.getEnabled(1), is(COMPONENT_ENABLED_STATE_DEFAULT)); 135 } 136 137 @Test 138 public void testNewPackageRestrictionsFile() throws ReflectiveOperationException { 139 // Write the package files and make sure they're parsed properly the first time 140 writeOldFiles(); 141 final Context context = InstrumentationRegistry.getContext(); 142 final Object lock = new Object(); 143 PermissionManagerInternal pmInt = PermissionManagerService.create(context, null, lock); 144 Settings settings = 145 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 146 assertThat(settings.readLPw(createFakeUsers()), is(true)); 147 settings.writeLPr(); 148 149 // Create Settings again to make it read from the new files 150 settings = 151 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 152 assertThat(settings.readLPw(createFakeUsers()), is(true)); 153 154 PackageSetting ps = settings.getPackageLPr(PACKAGE_NAME_2); 155 assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DISABLED_USER)); 156 assertThat(ps.getEnabled(1), is(COMPONENT_ENABLED_STATE_DEFAULT)); 157 } 158 159 private PersistableBundle getPersistableBundle(String packageName, long longVal, 160 double doubleVal, boolean boolVal, String textVal) { 161 final PersistableBundle bundle = new PersistableBundle(); 162 bundle.putString(packageName + ".TEXT_VALUE", textVal); 163 bundle.putLong(packageName + ".LONG_VALUE", longVal); 164 bundle.putBoolean(packageName + ".BOOL_VALUE", boolVal); 165 bundle.putDouble(packageName + ".DOUBLE_VALUE", doubleVal); 166 return bundle; 167 } 168 169 @Test 170 public void testReadPackageRestrictions_oldSuspendInfo() { 171 writePackageRestrictions_oldSuspendInfoXml(0); 172 final Object lock = new Object(); 173 final Context context = InstrumentationRegistry.getTargetContext(); 174 final Settings settingsUnderTest = new Settings(context.getFilesDir(), null, lock); 175 settingsUnderTest.mPackages.put(PACKAGE_NAME_1, createPackageSetting(PACKAGE_NAME_1)); 176 settingsUnderTest.mPackages.put(PACKAGE_NAME_2, createPackageSetting(PACKAGE_NAME_2)); 177 settingsUnderTest.readPackageRestrictionsLPr(0); 178 179 final PackageSetting ps1 = settingsUnderTest.mPackages.get(PACKAGE_NAME_1); 180 final PackageUserState packageUserState1 = ps1.readUserState(0); 181 assertThat(packageUserState1.suspended, is(true)); 182 assertThat("android".equals(packageUserState1.suspendingPackage), is(true)); 183 184 final PackageSetting ps2 = settingsUnderTest.mPackages.get(PACKAGE_NAME_2); 185 final PackageUserState packageUserState2 = ps2.readUserState(0); 186 assertThat(packageUserState2.suspended, is(false)); 187 assertThat(packageUserState2.suspendingPackage, is(nullValue())); 188 } 189 190 @Test 191 public void testReadWritePackageRestrictions_newSuspendInfo() { 192 final Context context = InstrumentationRegistry.getTargetContext(); 193 final Settings settingsUnderTest = new Settings(context.getFilesDir(), null, new Object()); 194 final PackageSetting ps1 = createPackageSetting(PACKAGE_NAME_1); 195 final PackageSetting ps2 = createPackageSetting(PACKAGE_NAME_2); 196 final PackageSetting ps3 = createPackageSetting(PACKAGE_NAME_3); 197 198 final PersistableBundle appExtras1 = getPersistableBundle( 199 PACKAGE_NAME_1, 1L, 0.01, true, "appString1"); 200 final PersistableBundle launcherExtras1 = getPersistableBundle( 201 PACKAGE_NAME_1, 10L, 0.1, false, "launcherString1"); 202 ps1.setSuspended(true, "suspendingPackage1", "dialogMsg1", appExtras1, launcherExtras1, 0); 203 settingsUnderTest.mPackages.put(PACKAGE_NAME_1, ps1); 204 205 ps2.setSuspended(true, "suspendingPackage2", "dialogMsg2", null, null, 0); 206 settingsUnderTest.mPackages.put(PACKAGE_NAME_2, ps2); 207 208 ps3.setSuspended(false, "irrelevant", "irrevelant2", null, null, 0); 209 settingsUnderTest.mPackages.put(PACKAGE_NAME_3, ps3); 210 211 settingsUnderTest.writePackageRestrictionsLPr(0); 212 213 settingsUnderTest.mPackages.clear(); 214 settingsUnderTest.mPackages.put(PACKAGE_NAME_1, createPackageSetting(PACKAGE_NAME_1)); 215 settingsUnderTest.mPackages.put(PACKAGE_NAME_2, createPackageSetting(PACKAGE_NAME_2)); 216 settingsUnderTest.mPackages.put(PACKAGE_NAME_3, createPackageSetting(PACKAGE_NAME_3)); 217 // now read and verify 218 settingsUnderTest.readPackageRestrictionsLPr(0); 219 final PackageUserState readPus1 = settingsUnderTest.mPackages.get(PACKAGE_NAME_1). 220 readUserState(0); 221 assertThat(readPus1.suspended, is(true)); 222 assertThat(readPus1.suspendingPackage, equalTo("suspendingPackage1")); 223 assertThat(readPus1.dialogMessage, equalTo("dialogMsg1")); 224 assertThat(BaseBundle.kindofEquals(readPus1.suspendedAppExtras, appExtras1), is(true)); 225 assertThat(BaseBundle.kindofEquals(readPus1.suspendedLauncherExtras, launcherExtras1), 226 is(true)); 227 228 final PackageUserState readPus2 = settingsUnderTest.mPackages.get(PACKAGE_NAME_2). 229 readUserState(0); 230 assertThat(readPus2.suspended, is(true)); 231 assertThat(readPus2.suspendingPackage, equalTo("suspendingPackage2")); 232 assertThat(readPus2.dialogMessage, equalTo("dialogMsg2")); 233 assertThat(readPus2.suspendedAppExtras, is(nullValue())); 234 assertThat(readPus2.suspendedLauncherExtras, is(nullValue())); 235 236 final PackageUserState readPus3 = settingsUnderTest.mPackages.get(PACKAGE_NAME_3). 237 readUserState(0); 238 assertThat(readPus3.suspended, is(false)); 239 assertThat(readPus3.suspendingPackage, is(nullValue())); 240 assertThat(readPus3.dialogMessage, is(nullValue())); 241 assertThat(readPus3.suspendedAppExtras, is(nullValue())); 242 assertThat(readPus3.suspendedLauncherExtras, is(nullValue())); 243 } 244 245 @Test 246 public void testPackageRestrictionsSuspendedDefault() { 247 final PackageSetting defaultSetting = createPackageSetting(PACKAGE_NAME_1); 248 assertThat(defaultSetting.getSuspended(0), is(false)); 249 } 250 251 @Test 252 public void testEnableDisable() { 253 // Write the package files and make sure they're parsed properly the first time 254 writeOldFiles(); 255 final Context context = InstrumentationRegistry.getContext(); 256 final Object lock = new Object(); 257 PermissionManagerInternal pmInt = PermissionManagerService.create(context, null, lock); 258 Settings settings = 259 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 260 assertThat(settings.readLPw(createFakeUsers()), is(true)); 261 262 // Enable/Disable a package 263 PackageSetting ps = settings.getPackageLPr(PACKAGE_NAME_1); 264 ps.setEnabled(COMPONENT_ENABLED_STATE_DISABLED, 0, null); 265 ps.setEnabled(COMPONENT_ENABLED_STATE_ENABLED, 1, null); 266 assertThat(ps.getEnabled(0), is(COMPONENT_ENABLED_STATE_DISABLED)); 267 assertThat(ps.getEnabled(1), is(COMPONENT_ENABLED_STATE_ENABLED)); 268 269 // Enable/Disable a component 270 ArraySet<String> components = new ArraySet<String>(); 271 String component1 = PACKAGE_NAME_1 + "/.Component1"; 272 components.add(component1); 273 ps.setDisabledComponents(components, 0); 274 ArraySet<String> componentsDisabled = ps.getDisabledComponents(0); 275 assertThat(componentsDisabled.size(), is(1)); 276 assertThat(componentsDisabled.toArray()[0], is(component1)); 277 boolean hasEnabled = 278 ps.getEnabledComponents(0) != null && ps.getEnabledComponents(1).size() > 0; 279 assertThat(hasEnabled, is(false)); 280 281 // User 1 should not have any disabled components 282 boolean hasDisabled = 283 ps.getDisabledComponents(1) != null && ps.getDisabledComponents(1).size() > 0; 284 assertThat(hasDisabled, is(false)); 285 ps.setEnabledComponents(components, 1); 286 assertThat(ps.getEnabledComponents(1).size(), is(1)); 287 hasEnabled = ps.getEnabledComponents(0) != null && ps.getEnabledComponents(0).size() > 0; 288 assertThat(hasEnabled, is(false)); 289 } 290 291 private static final String PACKAGE_NAME = "com.android.bar"; 292 private static final String REAL_PACKAGE_NAME = "com.android.foo"; 293 private static final String PARENT_PACKAGE_NAME = "com.android.bar.parent"; 294 private static final String CHILD_PACKAGE_NAME_01 = "com.android.bar.child01"; 295 private static final String CHILD_PACKAGE_NAME_02 = "com.android.bar.child02"; 296 private static final String CHILD_PACKAGE_NAME_03 = "com.android.bar.child03"; 297 private static final File INITIAL_CODE_PATH = 298 new File(InstrumentationRegistry.getContext().getFilesDir(), "com.android.bar-1"); 299 private static final File UPDATED_CODE_PATH = 300 new File(InstrumentationRegistry.getContext().getFilesDir(), "com.android.bar-2"); 301 private static final long INITIAL_VERSION_CODE = 10023L; 302 private static final long UPDATED_VERSION_CODE = 10025L; 303 304 @Test 305 public void testPackageStateCopy01() { 306 final List<String> childPackageNames = new ArrayList<>(); 307 childPackageNames.add(CHILD_PACKAGE_NAME_01); 308 childPackageNames.add(CHILD_PACKAGE_NAME_02); 309 childPackageNames.add(CHILD_PACKAGE_NAME_03); 310 final PackageSetting origPkgSetting01 = new PackageSetting( 311 PACKAGE_NAME, 312 REAL_PACKAGE_NAME, 313 INITIAL_CODE_PATH /*codePath*/, 314 INITIAL_CODE_PATH /*resourcePath*/, 315 null /*legacyNativeLibraryPathString*/, 316 "x86_64" /*primaryCpuAbiString*/, 317 "x86" /*secondaryCpuAbiString*/, 318 null /*cpuAbiOverrideString*/, 319 INITIAL_VERSION_CODE, 320 ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_HAS_CODE, 321 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED|ApplicationInfo.PRIVATE_FLAG_HIDDEN, 322 PARENT_PACKAGE_NAME, 323 childPackageNames, 324 0, 325 null /*usesStaticLibraries*/, 326 null /*usesStaticLibrariesVersions*/); 327 final PackageSetting testPkgSetting01 = new PackageSetting(origPkgSetting01); 328 verifySettingCopy(origPkgSetting01, testPkgSetting01); 329 } 330 331 @Test 332 public void testPackageStateCopy02() { 333 final List<String> childPackageNames = new ArrayList<>(); 334 childPackageNames.add(CHILD_PACKAGE_NAME_01); 335 childPackageNames.add(CHILD_PACKAGE_NAME_02); 336 childPackageNames.add(CHILD_PACKAGE_NAME_03); 337 final PackageSetting origPkgSetting01 = new PackageSetting( 338 PACKAGE_NAME /*pkgName*/, 339 REAL_PACKAGE_NAME /*realPkgName*/, 340 INITIAL_CODE_PATH /*codePath*/, 341 INITIAL_CODE_PATH /*resourcePath*/, 342 null /*legacyNativeLibraryPathString*/, 343 "x86_64" /*primaryCpuAbiString*/, 344 "x86" /*secondaryCpuAbiString*/, 345 null /*cpuAbiOverrideString*/, 346 INITIAL_VERSION_CODE, 347 ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_HAS_CODE, 348 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED|ApplicationInfo.PRIVATE_FLAG_HIDDEN, 349 PARENT_PACKAGE_NAME, 350 childPackageNames, 351 0, 352 null /*usesStaticLibraries*/, 353 null /*usesStaticLibrariesVersions*/); 354 final PackageSetting testPkgSetting01 = new PackageSetting( 355 PACKAGE_NAME /*pkgName*/, 356 REAL_PACKAGE_NAME /*realPkgName*/, 357 UPDATED_CODE_PATH /*codePath*/, 358 UPDATED_CODE_PATH /*resourcePath*/, 359 null /*legacyNativeLibraryPathString*/, 360 null /*primaryCpuAbiString*/, 361 null /*secondaryCpuAbiString*/, 362 null /*cpuAbiOverrideString*/, 363 UPDATED_VERSION_CODE, 364 0 /*pkgFlags*/, 365 0 /*pkgPrivateFlags*/, 366 null /*parentPkgName*/, 367 null /*childPkgNames*/, 368 0, 369 null /*usesStaticLibraries*/, 370 null /*usesStaticLibrariesVersions*/); 371 testPkgSetting01.copyFrom(origPkgSetting01); 372 verifySettingCopy(origPkgSetting01, testPkgSetting01); 373 } 374 375 /** Update package */ 376 @Test 377 public void testUpdatePackageSetting01() throws PackageManagerException { 378 final PackageSetting testPkgSetting01 = 379 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/); 380 testPkgSetting01.setInstalled(false /*installed*/, 0 /*userId*/); 381 assertThat(testPkgSetting01.pkgFlags, is(0)); 382 assertThat(testPkgSetting01.pkgPrivateFlags, is(0)); 383 final PackageSetting oldPkgSetting01 = new PackageSetting(testPkgSetting01); 384 Settings.updatePackageSetting( 385 testPkgSetting01, 386 null /*disabledPkg*/, 387 null /*sharedUser*/, 388 UPDATED_CODE_PATH /*codePath*/, 389 UPDATED_CODE_PATH /*resourcePath*/, 390 null /*legacyNativeLibraryPath*/, 391 "arm64-v8a" /*primaryCpuAbi*/, 392 "armeabi" /*secondaryCpuAbi*/, 393 0 /*pkgFlags*/, 394 0 /*pkgPrivateFlags*/, 395 null /*childPkgNames*/, 396 UserManagerService.getInstance(), 397 null /*usesStaticLibraries*/, 398 null /*usesStaticLibrariesVersions*/); 399 assertThat(testPkgSetting01.primaryCpuAbiString, is("arm64-v8a")); 400 assertThat(testPkgSetting01.secondaryCpuAbiString, is("armeabi")); 401 assertThat(testPkgSetting01.pkgFlags, is(0)); 402 assertThat(testPkgSetting01.pkgPrivateFlags, is(0)); 403 final PackageUserState userState = testPkgSetting01.readUserState(0); 404 final PackageUserState oldUserState = oldPkgSetting01.readUserState(0); 405 verifyUserState(userState, oldUserState, false /*userStateChanged*/, false /*notLaunched*/, 406 false /*stopped*/, false /*installed*/); 407 } 408 409 /** Update package; package now on /system, install for user '0' */ 410 @Test 411 public void testUpdatePackageSetting02() throws PackageManagerException { 412 final PackageSetting testPkgSetting01 = 413 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/); 414 testPkgSetting01.setInstalled(false /*installed*/, 0 /*userId*/); 415 assertThat(testPkgSetting01.pkgFlags, is(0)); 416 assertThat(testPkgSetting01.pkgPrivateFlags, is(0)); 417 final PackageSetting oldPkgSetting01 = new PackageSetting(testPkgSetting01); 418 Settings.updatePackageSetting( 419 testPkgSetting01, 420 null /*disabledPkg*/, 421 null /*sharedUser*/, 422 UPDATED_CODE_PATH /*codePath*/, 423 UPDATED_CODE_PATH /*resourcePath*/, 424 null /*legacyNativeLibraryPath*/, 425 "arm64-v8a" /*primaryCpuAbi*/, 426 "armeabi" /*secondaryCpuAbi*/, 427 ApplicationInfo.FLAG_SYSTEM /*pkgFlags*/, 428 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED /*pkgPrivateFlags*/, 429 null /*childPkgNames*/, 430 UserManagerService.getInstance(), 431 null /*usesStaticLibraries*/, 432 null /*usesStaticLibrariesVersions*/); 433 assertThat(testPkgSetting01.primaryCpuAbiString, is("arm64-v8a")); 434 assertThat(testPkgSetting01.secondaryCpuAbiString, is("armeabi")); 435 assertThat(testPkgSetting01.pkgFlags, is(ApplicationInfo.FLAG_SYSTEM)); 436 assertThat(testPkgSetting01.pkgPrivateFlags, is(ApplicationInfo.PRIVATE_FLAG_PRIVILEGED)); 437 final PackageUserState userState = testPkgSetting01.readUserState(0); 438 final PackageUserState oldUserState = oldPkgSetting01.readUserState(0); 439 // WARNING: When creating a shallow copy of the PackageSetting we do NOT create 440 // new contained objects. For example, this means that changes to the user state 441 // in testPkgSetting01 will also change the user state in its copy. 442 verifyUserState(userState, oldUserState, false /*userStateChanged*/, false /*notLaunched*/, 443 false /*stopped*/, true /*installed*/); 444 } 445 446 /** Update package; changing shared user throws exception */ 447 @Test 448 public void testUpdatePackageSetting03() { 449 final Context context = InstrumentationRegistry.getContext(); 450 final Object lock = new Object(); 451 PermissionManagerInternal pmInt = PermissionManagerService.create(context, null, lock); 452 final Settings testSettings01 = 453 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 454 final SharedUserSetting testUserSetting01 = createSharedUserSetting( 455 testSettings01, "TestUser", 10064, 0 /*pkgFlags*/, 0 /*pkgPrivateFlags*/); 456 final PackageSetting testPkgSetting01 = 457 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/); 458 try { 459 Settings.updatePackageSetting( 460 testPkgSetting01, 461 null /*disabledPkg*/, 462 testUserSetting01 /*sharedUser*/, 463 UPDATED_CODE_PATH /*codePath*/, 464 null /*resourcePath*/, 465 null /*legacyNativeLibraryPath*/, 466 "arm64-v8a" /*primaryCpuAbi*/, 467 "armeabi" /*secondaryCpuAbi*/, 468 0 /*pkgFlags*/, 469 0 /*pkgPrivateFlags*/, 470 null /*childPkgNames*/, 471 UserManagerService.getInstance(), 472 null /*usesStaticLibraries*/, 473 null /*usesStaticLibrariesVersions*/); 474 fail("Expected a PackageManagerException"); 475 } catch (PackageManagerException expected) { 476 } 477 } 478 479 /** Create a new PackageSetting based on an original package setting */ 480 @Test 481 public void testCreateNewSetting01() { 482 final PackageSetting originalPkgSetting01 = 483 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/); 484 final PackageSignatures originalSignatures = originalPkgSetting01.signatures; 485 final PackageSetting testPkgSetting01 = Settings.createNewSetting( 486 REAL_PACKAGE_NAME, 487 originalPkgSetting01 /*originalPkg*/, 488 null /*disabledPkg*/, 489 null /*realPkgName*/, 490 null /*sharedUser*/, 491 UPDATED_CODE_PATH /*codePath*/, 492 UPDATED_CODE_PATH /*resourcePath*/, 493 null /*legacyNativeLibraryPath*/, 494 "arm64-v8a" /*primaryCpuAbi*/, 495 "armeabi" /*secondaryCpuAbi*/, 496 UPDATED_VERSION_CODE /*versionCode*/, 497 ApplicationInfo.FLAG_SYSTEM /*pkgFlags*/, 498 ApplicationInfo.PRIVATE_FLAG_PRIVILEGED /*pkgPrivateFlags*/, 499 null /*installUser*/, 500 false /*allowInstall*/, 501 false /*instantApp*/, 502 false /*virtualPreload*/, 503 null /*parentPkgName*/, 504 null /*childPkgNames*/, 505 UserManagerService.getInstance(), 506 null /*usesStaticLibraries*/, 507 null /*usesStaticLibrariesVersions*/); 508 assertThat(testPkgSetting01.codePath, is(UPDATED_CODE_PATH)); 509 assertThat(testPkgSetting01.name, is(PACKAGE_NAME)); 510 assertThat(testPkgSetting01.pkgFlags, is(ApplicationInfo.FLAG_SYSTEM)); 511 assertThat(testPkgSetting01.pkgPrivateFlags, is(ApplicationInfo.PRIVATE_FLAG_PRIVILEGED)); 512 assertThat(testPkgSetting01.primaryCpuAbiString, is("arm64-v8a")); 513 assertThat(testPkgSetting01.resourcePath, is(UPDATED_CODE_PATH)); 514 assertThat(testPkgSetting01.secondaryCpuAbiString, is("armeabi")); 515 // signatures object must be different 516 assertNotSame(testPkgSetting01.signatures, originalSignatures); 517 assertThat(testPkgSetting01.versionCode, is(UPDATED_VERSION_CODE)); 518 final PackageUserState userState = testPkgSetting01.readUserState(0); 519 verifyUserState(userState, null /*oldUserState*/, false /*userStateChanged*/, 520 false /*notLaunched*/, false /*stopped*/, true /*installed*/); 521 } 522 523 /** Create a new non-system PackageSetting */ 524 @Test 525 public void testCreateNewSetting02() { 526 final PackageSetting testPkgSetting01 = Settings.createNewSetting( 527 PACKAGE_NAME, 528 null /*originalPkg*/, 529 null /*disabledPkg*/, 530 null /*realPkgName*/, 531 null /*sharedUser*/, 532 INITIAL_CODE_PATH /*codePath*/, 533 INITIAL_CODE_PATH /*resourcePath*/, 534 null /*legacyNativeLibraryPath*/, 535 "x86_64" /*primaryCpuAbiString*/, 536 "x86" /*secondaryCpuAbiString*/, 537 INITIAL_VERSION_CODE /*versionCode*/, 538 0 /*pkgFlags*/, 539 0 /*pkgPrivateFlags*/, 540 UserHandle.SYSTEM /*installUser*/, 541 true /*allowInstall*/, 542 false /*instantApp*/, 543 false /*virtualPreload*/, 544 null /*parentPkgName*/, 545 null /*childPkgNames*/, 546 UserManagerService.getInstance(), 547 null /*usesStaticLibraries*/, 548 null /*usesStaticLibrariesVersions*/); 549 assertThat(testPkgSetting01.appId, is(0)); 550 assertThat(testPkgSetting01.codePath, is(INITIAL_CODE_PATH)); 551 assertThat(testPkgSetting01.name, is(PACKAGE_NAME)); 552 assertThat(testPkgSetting01.pkgFlags, is(0)); 553 assertThat(testPkgSetting01.pkgPrivateFlags, is(0)); 554 assertThat(testPkgSetting01.primaryCpuAbiString, is("x86_64")); 555 assertThat(testPkgSetting01.resourcePath, is(INITIAL_CODE_PATH)); 556 assertThat(testPkgSetting01.secondaryCpuAbiString, is("x86")); 557 assertThat(testPkgSetting01.versionCode, is(INITIAL_VERSION_CODE)); 558 // by default, the package is considered stopped 559 final PackageUserState userState = testPkgSetting01.readUserState(0); 560 verifyUserState(userState, null /*oldUserState*/, false /*userStateChanged*/, 561 true /*notLaunched*/, true /*stopped*/, true /*installed*/); 562 } 563 564 /** Create PackageSetting for a shared user */ 565 @Test 566 public void testCreateNewSetting03() { 567 final Context context = InstrumentationRegistry.getContext(); 568 final Object lock = new Object(); 569 PermissionManagerInternal pmInt = PermissionManagerService.create(context, null, lock); 570 final Settings testSettings01 = 571 new Settings(context.getFilesDir(), pmInt.getPermissionSettings(), lock); 572 final SharedUserSetting testUserSetting01 = createSharedUserSetting( 573 testSettings01, "TestUser", 10064, 0 /*pkgFlags*/, 0 /*pkgPrivateFlags*/); 574 final PackageSetting testPkgSetting01 = Settings.createNewSetting( 575 PACKAGE_NAME, 576 null /*originalPkg*/, 577 null /*disabledPkg*/, 578 null /*realPkgName*/, 579 testUserSetting01 /*sharedUser*/, 580 INITIAL_CODE_PATH /*codePath*/, 581 INITIAL_CODE_PATH /*resourcePath*/, 582 null /*legacyNativeLibraryPath*/, 583 "x86_64" /*primaryCpuAbiString*/, 584 "x86" /*secondaryCpuAbiString*/, 585 INITIAL_VERSION_CODE /*versionCode*/, 586 0 /*pkgFlags*/, 587 0 /*pkgPrivateFlags*/, 588 null /*installUser*/, 589 false /*allowInstall*/, 590 false /*instantApp*/, 591 false /*virtualPreload*/, 592 null /*parentPkgName*/, 593 null /*childPkgNames*/, 594 UserManagerService.getInstance(), 595 null /*usesStaticLibraries*/, 596 null /*usesStaticLibrariesVersions*/); 597 assertThat(testPkgSetting01.appId, is(10064)); 598 assertThat(testPkgSetting01.codePath, is(INITIAL_CODE_PATH)); 599 assertThat(testPkgSetting01.name, is(PACKAGE_NAME)); 600 assertThat(testPkgSetting01.pkgFlags, is(0)); 601 assertThat(testPkgSetting01.pkgPrivateFlags, is(0)); 602 assertThat(testPkgSetting01.primaryCpuAbiString, is("x86_64")); 603 assertThat(testPkgSetting01.resourcePath, is(INITIAL_CODE_PATH)); 604 assertThat(testPkgSetting01.secondaryCpuAbiString, is("x86")); 605 assertThat(testPkgSetting01.versionCode, is(INITIAL_VERSION_CODE)); 606 final PackageUserState userState = testPkgSetting01.readUserState(0); 607 verifyUserState(userState, null /*oldUserState*/, false /*userStateChanged*/, 608 false /*notLaunched*/, false /*stopped*/, true /*installed*/); 609 } 610 611 /** Create a new PackageSetting based on a disabled package setting */ 612 @Test 613 public void testCreateNewSetting04() { 614 final PackageSetting disabledPkgSetting01 = 615 createPackageSetting(0 /*sharedUserId*/, 0 /*pkgFlags*/); 616 disabledPkgSetting01.appId = 10064; 617 final PackageSignatures disabledSignatures = disabledPkgSetting01.signatures; 618 final PackageSetting testPkgSetting01 = Settings.createNewSetting( 619 PACKAGE_NAME, 620 null /*originalPkg*/, 621 disabledPkgSetting01 /*disabledPkg*/, 622 null /*realPkgName*/, 623 null /*sharedUser*/, 624 UPDATED_CODE_PATH /*codePath*/, 625 UPDATED_CODE_PATH /*resourcePath*/, 626 null /*legacyNativeLibraryPath*/, 627 "arm64-v8a" /*primaryCpuAbi*/, 628 "armeabi" /*secondaryCpuAbi*/, 629 UPDATED_VERSION_CODE /*versionCode*/, 630 0 /*pkgFlags*/, 631 0 /*pkgPrivateFlags*/, 632 null /*installUser*/, 633 false /*allowInstall*/, 634 false /*instantApp*/, 635 false /*virtualPreload*/, 636 null /*parentPkgName*/, 637 null /*childPkgNames*/, 638 UserManagerService.getInstance(), 639 null /*usesStaticLibraries*/, 640 null /*usesStaticLibrariesVersions*/); 641 assertThat(testPkgSetting01.appId, is(10064)); 642 assertThat(testPkgSetting01.codePath, is(UPDATED_CODE_PATH)); 643 assertThat(testPkgSetting01.name, is(PACKAGE_NAME)); 644 assertThat(testPkgSetting01.pkgFlags, is(0)); 645 assertThat(testPkgSetting01.pkgPrivateFlags, is(0)); 646 assertThat(testPkgSetting01.primaryCpuAbiString, is("arm64-v8a")); 647 assertThat(testPkgSetting01.resourcePath, is(UPDATED_CODE_PATH)); 648 assertThat(testPkgSetting01.secondaryCpuAbiString, is("armeabi")); 649 assertNotSame(testPkgSetting01.signatures, disabledSignatures); 650 assertThat(testPkgSetting01.versionCode, is(UPDATED_VERSION_CODE)); 651 final PackageUserState userState = testPkgSetting01.readUserState(0); 652 verifyUserState(userState, null /*oldUserState*/, false /*userStateChanged*/, 653 false /*notLaunched*/, false /*stopped*/, true /*installed*/); 654 } 655 656 private <T> void assertArrayEquals(T[] a, T[] b) { 657 assertTrue("Expected: " + Arrays.toString(a) + ", actual: " + Arrays.toString(b), 658 Arrays.equals(a, b)); 659 } 660 661 private void assertArrayEquals(int[] a, int[] b) { 662 assertTrue("Expected: " + Arrays.toString(a) + ", actual: " + Arrays.toString(b), 663 Arrays.equals(a, b)); 664 } 665 666 private void assertArrayEquals(long[] a, long[] b) { 667 assertTrue("Expected: " + Arrays.toString(a) + ", actual: " + Arrays.toString(b), 668 Arrays.equals(a, b)); 669 } 670 671 private void verifyUserState(PackageUserState userState, PackageUserState oldUserState, 672 boolean userStateChanged) { 673 verifyUserState(userState, oldUserState, userStateChanged, false /*notLaunched*/, 674 false /*stopped*/, true /*installed*/); 675 } 676 677 private void verifyUserState(PackageUserState userState, PackageUserState oldUserState, 678 boolean userStateChanged, boolean notLaunched, boolean stopped, boolean installed) { 679 assertThat(userState.enabled, is(0)); 680 assertThat(userState.hidden, is(false)); 681 assertThat(userState.installed, is(installed)); 682 assertThat(userState.notLaunched, is(notLaunched)); 683 assertThat(userState.stopped, is(stopped)); 684 assertThat(userState.suspended, is(false)); 685 if (oldUserState != null) { 686 assertThat(userState.equals(oldUserState), is(not(userStateChanged))); 687 } 688 } 689 690 private void verifySettingCopy(PackageSetting origPkgSetting, PackageSetting testPkgSetting) { 691 assertThat(origPkgSetting, is(not(testPkgSetting))); 692 assertThat(origPkgSetting.appId, is(testPkgSetting.appId)); 693 // different but equal objects 694 assertNotSame(origPkgSetting.childPackageNames, testPkgSetting.childPackageNames); 695 assertThat(origPkgSetting.childPackageNames, is(testPkgSetting.childPackageNames)); 696 assertSame(origPkgSetting.codePath, testPkgSetting.codePath); 697 assertThat(origPkgSetting.codePath, is(testPkgSetting.codePath)); 698 assertSame(origPkgSetting.codePathString, testPkgSetting.codePathString); 699 assertThat(origPkgSetting.codePathString, is(testPkgSetting.codePathString)); 700 assertSame(origPkgSetting.cpuAbiOverrideString, testPkgSetting.cpuAbiOverrideString); 701 assertThat(origPkgSetting.cpuAbiOverrideString, is(testPkgSetting.cpuAbiOverrideString)); 702 assertThat(origPkgSetting.firstInstallTime, is(testPkgSetting.firstInstallTime)); 703 assertSame(origPkgSetting.installerPackageName, testPkgSetting.installerPackageName); 704 assertThat(origPkgSetting.installerPackageName, is(testPkgSetting.installerPackageName)); 705 assertThat(origPkgSetting.installPermissionsFixed, 706 is(testPkgSetting.installPermissionsFixed)); 707 assertThat(origPkgSetting.isOrphaned, is(testPkgSetting.isOrphaned)); 708 assertSame(origPkgSetting.keySetData, testPkgSetting.keySetData); 709 assertThat(origPkgSetting.keySetData, is(testPkgSetting.keySetData)); 710 assertThat(origPkgSetting.lastUpdateTime, is(testPkgSetting.lastUpdateTime)); 711 assertSame(origPkgSetting.legacyNativeLibraryPathString, 712 testPkgSetting.legacyNativeLibraryPathString); 713 assertThat(origPkgSetting.legacyNativeLibraryPathString, 714 is(testPkgSetting.legacyNativeLibraryPathString)); 715 assertNotSame(origPkgSetting.mPermissionsState, testPkgSetting.mPermissionsState); 716 assertThat(origPkgSetting.mPermissionsState, is(testPkgSetting.mPermissionsState)); 717 assertThat(origPkgSetting.name, is(testPkgSetting.name)); 718 // oldCodePaths is _not_ copied 719 // assertNotSame(origPkgSetting.oldCodePaths, testPkgSetting.oldCodePaths); 720 // assertThat(origPkgSetting.oldCodePaths, is(not(testPkgSetting.oldCodePaths))); 721 assertSame(origPkgSetting.parentPackageName, testPkgSetting.parentPackageName); 722 assertThat(origPkgSetting.parentPackageName, is(testPkgSetting.parentPackageName)); 723 assertSame(origPkgSetting.pkg, testPkgSetting.pkg); 724 // No equals() method for this object 725 // assertThat(origPkgSetting.pkg, is(testPkgSetting.pkg)); 726 assertThat(origPkgSetting.pkgFlags, is(testPkgSetting.pkgFlags)); 727 assertThat(origPkgSetting.pkgPrivateFlags, is(testPkgSetting.pkgPrivateFlags)); 728 assertSame(origPkgSetting.primaryCpuAbiString, testPkgSetting.primaryCpuAbiString); 729 assertThat(origPkgSetting.primaryCpuAbiString, is(testPkgSetting.primaryCpuAbiString)); 730 assertThat(origPkgSetting.realName, is(testPkgSetting.realName)); 731 assertSame(origPkgSetting.resourcePath, testPkgSetting.resourcePath); 732 assertThat(origPkgSetting.resourcePath, is(testPkgSetting.resourcePath)); 733 assertSame(origPkgSetting.resourcePathString, testPkgSetting.resourcePathString); 734 assertThat(origPkgSetting.resourcePathString, is(testPkgSetting.resourcePathString)); 735 assertSame(origPkgSetting.secondaryCpuAbiString, testPkgSetting.secondaryCpuAbiString); 736 assertThat(origPkgSetting.secondaryCpuAbiString, is(testPkgSetting.secondaryCpuAbiString)); 737 assertSame(origPkgSetting.sharedUser, testPkgSetting.sharedUser); 738 assertThat(origPkgSetting.sharedUser, is(testPkgSetting.sharedUser)); 739 assertSame(origPkgSetting.signatures, testPkgSetting.signatures); 740 assertThat(origPkgSetting.signatures, is(testPkgSetting.signatures)); 741 assertThat(origPkgSetting.timeStamp, is(testPkgSetting.timeStamp)); 742 assertThat(origPkgSetting.uidError, is(testPkgSetting.uidError)); 743 assertNotSame(origPkgSetting.getUserState(), is(testPkgSetting.getUserState())); 744 // No equals() method for SparseArray object 745 // assertThat(origPkgSetting.getUserState(), is(testPkgSetting.getUserState())); 746 assertSame(origPkgSetting.verificationInfo, testPkgSetting.verificationInfo); 747 assertThat(origPkgSetting.verificationInfo, is(testPkgSetting.verificationInfo)); 748 assertThat(origPkgSetting.versionCode, is(testPkgSetting.versionCode)); 749 assertSame(origPkgSetting.volumeUuid, testPkgSetting.volumeUuid); 750 assertThat(origPkgSetting.volumeUuid, is(testPkgSetting.volumeUuid)); 751 } 752 753 private SharedUserSetting createSharedUserSetting(Settings settings, String userName, 754 int sharedUserId, int pkgFlags, int pkgPrivateFlags) { 755 return settings.addSharedUserLPw( 756 userName, 757 sharedUserId, 758 pkgFlags, 759 pkgPrivateFlags); 760 } 761 private PackageSetting createPackageSetting(int sharedUserId, int pkgFlags) { 762 return new PackageSetting( 763 PACKAGE_NAME, 764 REAL_PACKAGE_NAME, 765 INITIAL_CODE_PATH /*codePath*/, 766 INITIAL_CODE_PATH /*resourcePath*/, 767 null /*legacyNativeLibraryPathString*/, 768 "x86_64" /*primaryCpuAbiString*/, 769 "x86" /*secondaryCpuAbiString*/, 770 null /*cpuAbiOverrideString*/, 771 INITIAL_VERSION_CODE, 772 pkgFlags, 773 0 /*privateFlags*/, 774 null /*parentPackageName*/, 775 null /*childPackageNames*/, 776 sharedUserId, 777 null /*usesStaticLibraries*/, 778 null /*usesStaticLibrariesVersions*/); 779 } 780 781 private PackageSetting createPackageSetting(String packageName) { 782 return new PackageSetting( 783 packageName, 784 packageName, 785 INITIAL_CODE_PATH /*codePath*/, 786 INITIAL_CODE_PATH /*resourcePath*/, 787 null /*legacyNativeLibraryPathString*/, 788 "x86_64" /*primaryCpuAbiString*/, 789 "x86" /*secondaryCpuAbiString*/, 790 null /*cpuAbiOverrideString*/, 791 INITIAL_VERSION_CODE, 792 0, 793 0 /*privateFlags*/, 794 null /*parentPackageName*/, 795 null /*childPackageNames*/, 796 0, 797 null /*usesStaticLibraries*/, 798 null /*usesStaticLibrariesVersions*/); 799 } 800 801 private @NonNull List<UserInfo> createFakeUsers() { 802 ArrayList<UserInfo> users = new ArrayList<>(); 803 users.add(new UserInfo(UserHandle.USER_SYSTEM, "test user", UserInfo.FLAG_INITIALIZED)); 804 return users; 805 } 806 807 private void writeFile(File file, byte[] data) { 808 file.mkdirs(); 809 try { 810 AtomicFile aFile = new AtomicFile(file); 811 FileOutputStream fos = aFile.startWrite(); 812 fos.write(data); 813 aFile.finishWrite(fos); 814 } catch (IOException ioe) { 815 Log.e(TAG, "Cannot write file " + file.getPath()); 816 } 817 } 818 819 private void writePackagesXml() { 820 writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/packages.xml"), 821 ("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>" 822 + "<packages>" 823 + "<last-platform-version internal=\"15\" external=\"0\" fingerprint=\"foo\" />" 824 + "<permission-trees>" 825 + "<item name=\"com.google.android.permtree\" package=\"com.google.android.permpackage\" />" 826 + "</permission-trees>" 827 + "<permissions>" 828 + "<item name=\"android.permission.WRITE_CALL_LOG\" package=\"android\" protection=\"1\" />" 829 + "<item name=\"android.permission.ASEC_ACCESS\" package=\"android\" protection=\"2\" />" 830 + "<item name=\"android.permission.ACCESS_WIMAX_STATE\" package=\"android\" />" 831 + "<item name=\"android.permission.REBOOT\" package=\"android\" protection=\"18\" />" 832 + "</permissions>" 833 + "<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\">" 834 + "<sigs count=\"1\">" 835 + "<cert index=\"0\" key=\"" + KeySetStrings.ctsKeySetCertA + "\" />" 836 + "</sigs>" 837 + "<proper-signing-keyset identifier=\"1\" />" 838 + "</package>" 839 + "<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\">" 840 + "<sigs count=\"1\">" 841 + "<cert index=\"0\" />" 842 + "</sigs>" 843 + "<proper-signing-keyset identifier=\"1\" />" 844 + "<defined-keyset alias=\"AB\" identifier=\"4\" />" 845 + "</package>" 846 + "<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\">" 847 + "<sigs count=\"1\">" 848 + "<cert index=\"1\" key=\"" + KeySetStrings.ctsKeySetCertB + "\" />" 849 + "</sigs>" 850 + "<proper-signing-keyset identifier=\"2\" />" 851 + "<upgrade-keyset identifier=\"3\" />" 852 + "<defined-keyset alias=\"C\" identifier=\"3\" />" 853 + "</package>" 854 + "<shared-user name=\"com.android.shared1\" userId=\"11000\">" 855 + "<sigs count=\"1\">" 856 + "<cert index=\"1\" />" 857 + "</sigs>" 858 + "<perms>" 859 + "<item name=\"android.permission.REBOOT\" />" 860 + "</perms>" 861 + "</shared-user>" 862 + "<keyset-settings version=\"1\">" 863 + "<keys>" 864 + "<public-key identifier=\"1\" value=\"" + KeySetStrings.ctsKeySetPublicKeyA + "\" />" 865 + "<public-key identifier=\"2\" value=\"" + KeySetStrings.ctsKeySetPublicKeyB + "\" />" 866 + "<public-key identifier=\"3\" value=\"" + KeySetStrings.ctsKeySetPublicKeyC + "\" />" 867 + "</keys>" 868 + "<keysets>" 869 + "<keyset identifier=\"1\">" 870 + "<key-id identifier=\"1\" />" 871 + "</keyset>" 872 + "<keyset identifier=\"2\">" 873 + "<key-id identifier=\"2\" />" 874 + "</keyset>" 875 + "<keyset identifier=\"3\">" 876 + "<key-id identifier=\"3\" />" 877 + "</keyset>" 878 + "<keyset identifier=\"4\">" 879 + "<key-id identifier=\"1\" />" 880 + "<key-id identifier=\"2\" />" 881 + "</keyset>" 882 + "</keysets>" 883 + "<lastIssuedKeyId value=\"3\" />" 884 + "<lastIssuedKeySetId value=\"4\" />" 885 + "</keyset-settings>" 886 + "</packages>").getBytes()); 887 } 888 889 private void writePackageRestrictions_oldSuspendInfoXml(final int userId) { 890 writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/users/" 891 + userId + "/package-restrictions.xml"), 892 ( "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" 893 + "<package-restrictions>\n" 894 + " <pkg name=\"" + PACKAGE_NAME_1 + "\" suspended=\"true\" />" 895 + " <pkg name=\"" + PACKAGE_NAME_2 + "\" suspended=\"false\" />" 896 + " <preferred-activities />\n" 897 + " <persistent-preferred-activities />\n" 898 + " <crossProfile-intent-filters />\n" 899 + " <default-apps />\n" 900 + "</package-restrictions>\n") 901 .getBytes()); 902 } 903 904 private void writeStoppedPackagesXml() { 905 writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/packages-stopped.xml"), 906 ( "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>" 907 + "<stopped-packages>" 908 + "<pkg name=\"com.android.app1\" nl=\"1\" />" 909 + "<pkg name=\"com.android.app3\" nl=\"1\" />" 910 + "</stopped-packages>") 911 .getBytes()); 912 } 913 914 private void writePackagesList() { 915 writeFile(new File(InstrumentationRegistry.getContext().getFilesDir(), "system/packages.list"), 916 ( "com.android.app1 11000 0 /data/data/com.android.app1 seinfo1" 917 + "com.android.app2 11001 0 /data/data/com.android.app2 seinfo2" 918 + "com.android.app3 11030 0 /data/data/com.android.app3 seinfo3") 919 .getBytes()); 920 } 921 922 private void deleteSystemFolder() { 923 File systemFolder = new File(InstrumentationRegistry.getContext().getFilesDir(), "system"); 924 deleteFolder(systemFolder); 925 } 926 927 private static void deleteFolder(File folder) { 928 File[] files = folder.listFiles(); 929 if (files != null) { 930 for (File file : files) { 931 deleteFolder(file); 932 } 933 } 934 folder.delete(); 935 } 936 937 private void writeOldFiles() { 938 deleteSystemFolder(); 939 writePackagesXml(); 940 writeStoppedPackagesXml(); 941 writePackagesList(); 942 } 943 944 @Before 945 public void createUserManagerServiceRef() throws ReflectiveOperationException { 946 InstrumentationRegistry.getInstrumentation().runOnMainSync((Runnable) () -> { 947 try { 948 // unregister the user manager from the local service 949 LocalServices.removeServiceForTest(UserManagerInternal.class); 950 new UserManagerService(InstrumentationRegistry.getContext()); 951 } catch (Exception e) { 952 e.printStackTrace(); 953 fail("Could not create user manager service; " + e); 954 } 955 }); 956 } 957 958 @After 959 public void tearDown() throws Exception { 960 deleteFolder(InstrumentationRegistry.getTargetContext().getFilesDir()); 961 } 962 963 private void verifyKeySetMetaData(Settings settings) 964 throws ReflectiveOperationException, IllegalAccessException { 965 ArrayMap<String, PackageSetting> packages = settings.mPackages; 966 KeySetManagerService ksms = settings.mKeySetManagerService; 967 968 /* verify keyset and public key ref counts */ 969 assertThat(KeySetUtils.getKeySetRefCount(ksms, 1), is(2)); 970 assertThat(KeySetUtils.getKeySetRefCount(ksms, 2), is(1)); 971 assertThat(KeySetUtils.getKeySetRefCount(ksms, 3), is(1)); 972 assertThat(KeySetUtils.getKeySetRefCount(ksms, 4), is(1)); 973 assertThat(KeySetUtils.getPubKeyRefCount(ksms, 1), is(2)); 974 assertThat(KeySetUtils.getPubKeyRefCount(ksms, 2), is(2)); 975 assertThat(KeySetUtils.getPubKeyRefCount(ksms, 3), is(1)); 976 977 /* verify public keys properly read */ 978 PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); 979 PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); 980 PublicKey keyC = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyC); 981 assertThat(KeySetUtils.getPubKey(ksms, 1), is(keyA)); 982 assertThat(KeySetUtils.getPubKey(ksms, 2), is(keyB)); 983 assertThat(KeySetUtils.getPubKey(ksms, 3), is(keyC)); 984 985 /* verify mapping is correct (ks -> pub keys) */ 986 LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(ksms); 987 ArraySet<Long> mapping = ksMapping.get(1); 988 assertThat(mapping.size(), is(1)); 989 assertThat(mapping.contains(new Long(1)), is(true)); 990 mapping = ksMapping.get(2); 991 assertThat(mapping.size(), is(1)); 992 assertThat(mapping.contains(new Long(2)), is(true)); 993 mapping = ksMapping.get(3); 994 assertThat(mapping.size(), is(1)); 995 assertThat(mapping.contains(new Long(3)), is(true)); 996 mapping = ksMapping.get(4); 997 assertThat(mapping.size(), is(2)); 998 assertThat(mapping.contains(new Long(1)), is(true)); 999 assertThat(mapping.contains(new Long(2)), is(true)); 1000 1001 /* verify lastIssuedIds are consistent */ 1002 assertThat(KeySetUtils.getLastIssuedKeyId(ksms), is(3L)); 1003 assertThat(KeySetUtils.getLastIssuedKeySetId(ksms), is(4L)); 1004 1005 /* verify packages have been given the appropriate information */ 1006 PackageSetting ps = packages.get("com.android.app1"); 1007 assertThat(ps.keySetData.getProperSigningKeySet(), is(1L)); 1008 ps = packages.get("com.android.app2"); 1009 assertThat(ps.keySetData.getProperSigningKeySet(), is(1L)); 1010 assertThat(ps.keySetData.getAliases().get("AB"), is(4L)); 1011 ps = packages.get("com.android.app3"); 1012 assertThat(ps.keySetData.getProperSigningKeySet(), is(2L)); 1013 assertThat(ps.keySetData.getAliases().get("C"), is(3L)); 1014 assertThat(ps.keySetData.getUpgradeKeySets().length, is(1)); 1015 assertThat(ps.keySetData.getUpgradeKeySets()[0], is(3L)); 1016 } 1017} 1018