PackageManagerTests.java revision c39bb4aaa7be1b9b0cc9fb0b1f03d54f7609ffeb
1/* 2 * Copyright (C) 2006 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 android.content.pm; 18 19import com.android.frameworks.coretests.R; 20import com.android.internal.content.PackageHelper; 21 22import android.content.BroadcastReceiver; 23import android.content.Context; 24import android.content.Intent; 25import android.content.IntentFilter; 26import android.content.pm.PackageManager; 27import android.content.pm.PackageManager.NameNotFoundException; 28import android.content.res.Resources; 29import android.content.res.Resources.NotFoundException; 30import android.net.Uri; 31import android.os.Environment; 32import android.os.FileUtils; 33import android.os.IBinder; 34import android.os.RemoteException; 35import android.os.ServiceManager; 36import android.os.StatFs; 37import android.os.storage.IMountService; 38import android.os.storage.StorageListener; 39import android.os.storage.StorageManager; 40import android.os.storage.StorageResultCode; 41import android.provider.Settings; 42import android.provider.Settings.SettingNotFoundException; 43import android.test.AndroidTestCase; 44import android.test.suitebuilder.annotation.LargeTest; 45import android.util.DisplayMetrics; 46import android.util.Log; 47 48import java.io.File; 49import java.io.IOException; 50import java.io.InputStream; 51 52public class PackageManagerTests extends AndroidTestCase { 53 private static final boolean localLOGV = true; 54 public static final String TAG="PackageManagerTests"; 55 public final long MAX_WAIT_TIME = 25*1000; 56 public final long WAIT_TIME_INCR = 5*1000; 57 private static final String SECURE_CONTAINERS_PREFIX = "/mnt/asec"; 58 private static final int APP_INSTALL_AUTO = PackageHelper.APP_INSTALL_AUTO; 59 private static final int APP_INSTALL_DEVICE = PackageHelper.APP_INSTALL_INTERNAL; 60 private static final int APP_INSTALL_SDCARD = PackageHelper.APP_INSTALL_EXTERNAL; 61 private boolean mOrigState; 62 63 void failStr(String errMsg) { 64 Log.w(TAG, "errMsg="+errMsg); 65 fail(errMsg); 66 } 67 void failStr(Exception e) { 68 failStr(e.getMessage()); 69 } 70 71 @Override 72 protected void setUp() throws Exception { 73 super.setUp(); 74 mOrigState = checkMediaState(Environment.MEDIA_MOUNTED); 75 if (!mountMedia()) { 76 Log.i(TAG, "sdcard not mounted? Some of these tests might fail"); 77 } 78 } 79 80 @Override 81 protected void tearDown() throws Exception { 82 // Restore media state. 83 boolean newState = checkMediaState(Environment.MEDIA_MOUNTED); 84 if (newState != mOrigState) { 85 if (mOrigState) { 86 mountMedia(); 87 } else { 88 unmountMedia(); 89 } 90 } 91 super.tearDown(); 92 } 93 94 private class PackageInstallObserver extends IPackageInstallObserver.Stub { 95 public int returnCode; 96 private boolean doneFlag = false; 97 98 public void packageInstalled(String packageName, int returnCode) { 99 synchronized(this) { 100 this.returnCode = returnCode; 101 doneFlag = true; 102 notifyAll(); 103 } 104 } 105 106 public boolean isDone() { 107 return doneFlag; 108 } 109 } 110 111 abstract class GenericReceiver extends BroadcastReceiver { 112 private boolean doneFlag = false; 113 boolean received = false; 114 Intent intent; 115 IntentFilter filter; 116 abstract boolean notifyNow(Intent intent); 117 @Override 118 public void onReceive(Context context, Intent intent) { 119 if (notifyNow(intent)) { 120 synchronized (this) { 121 received = true; 122 doneFlag = true; 123 this.intent = intent; 124 notifyAll(); 125 } 126 } 127 } 128 129 public boolean isDone() { 130 return doneFlag; 131 } 132 133 public void setFilter(IntentFilter filter) { 134 this.filter = filter; 135 } 136 } 137 138 class InstallReceiver extends GenericReceiver { 139 String pkgName; 140 141 InstallReceiver(String pkgName) { 142 this.pkgName = pkgName; 143 IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED); 144 filter.addDataScheme("package"); 145 super.setFilter(filter); 146 } 147 148 public boolean notifyNow(Intent intent) { 149 String action = intent.getAction(); 150 if (!Intent.ACTION_PACKAGE_ADDED.equals(action)) { 151 return false; 152 } 153 Uri data = intent.getData(); 154 String installedPkg = data.getEncodedSchemeSpecificPart(); 155 if (pkgName.equals(installedPkg)) { 156 return true; 157 } 158 return false; 159 } 160 } 161 162 private PackageManager getPm() { 163 return mContext.getPackageManager(); 164 } 165 166 private IPackageManager getIPm() { 167 IPackageManager ipm = IPackageManager.Stub.asInterface( 168 ServiceManager.getService("package")); 169 return ipm; 170 } 171 172 public boolean invokeInstallPackage(Uri packageURI, int flags, GenericReceiver receiver) { 173 PackageInstallObserver observer = new PackageInstallObserver(); 174 final boolean received = false; 175 mContext.registerReceiver(receiver, receiver.filter); 176 final boolean DEBUG = true; 177 try { 178 // Wait on observer 179 synchronized(observer) { 180 synchronized (receiver) { 181 getPm().installPackage(packageURI, observer, flags, null); 182 long waitTime = 0; 183 while((!observer.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 184 try { 185 observer.wait(WAIT_TIME_INCR); 186 waitTime += WAIT_TIME_INCR; 187 } catch (InterruptedException e) { 188 Log.i(TAG, "Interrupted during sleep", e); 189 } 190 } 191 if(!observer.isDone()) { 192 fail("Timed out waiting for packageInstalled callback"); 193 } 194 if (observer.returnCode != PackageManager.INSTALL_SUCCEEDED) { 195 Log.i(TAG, "Failed to install with error code = " + observer.returnCode); 196 return false; 197 } 198 // Verify we received the broadcast 199 waitTime = 0; 200 while((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 201 try { 202 receiver.wait(WAIT_TIME_INCR); 203 waitTime += WAIT_TIME_INCR; 204 } catch (InterruptedException e) { 205 Log.i(TAG, "Interrupted during sleep", e); 206 } 207 } 208 if(!receiver.isDone()) { 209 fail("Timed out waiting for PACKAGE_ADDED notification"); 210 } 211 return receiver.received; 212 } 213 } 214 } finally { 215 mContext.unregisterReceiver(receiver); 216 } 217 } 218 219 public void invokeInstallPackageFail(Uri packageURI, int flags, int expectedResult) { 220 PackageInstallObserver observer = new PackageInstallObserver(); 221 try { 222 // Wait on observer 223 synchronized(observer) { 224 getPm().installPackage(packageURI, observer, flags, null); 225 long waitTime = 0; 226 while((!observer.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 227 try { 228 observer.wait(WAIT_TIME_INCR); 229 waitTime += WAIT_TIME_INCR; 230 } catch (InterruptedException e) { 231 Log.i(TAG, "Interrupted during sleep", e); 232 } 233 } 234 if(!observer.isDone()) { 235 fail("Timed out waiting for packageInstalled callback"); 236 } 237 assertEquals(expectedResult, observer.returnCode); 238 } 239 } finally { 240 } 241 } 242 243 Uri getInstallablePackage(int fileResId, File outFile) { 244 Resources res = mContext.getResources(); 245 InputStream is = null; 246 try { 247 is = res.openRawResource(fileResId); 248 } catch (NotFoundException e) { 249 failStr("Failed to load resource with id: " + fileResId); 250 } 251 FileUtils.setPermissions(outFile.getPath(), 252 FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IRWXO, 253 -1, -1); 254 assertTrue(FileUtils.copyToFile(is, outFile)); 255 FileUtils.setPermissions(outFile.getPath(), 256 FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IRWXO, 257 -1, -1); 258 return Uri.fromFile(outFile); 259 } 260 261 private PackageParser.Package parsePackage(Uri packageURI) { 262 final String archiveFilePath = packageURI.getPath(); 263 PackageParser packageParser = new PackageParser(archiveFilePath); 264 File sourceFile = new File(archiveFilePath); 265 DisplayMetrics metrics = new DisplayMetrics(); 266 metrics.setToDefaults(); 267 PackageParser.Package pkg = packageParser.parsePackage(sourceFile, archiveFilePath, metrics, 0); 268 packageParser = null; 269 return pkg; 270 } 271 private boolean checkSd(long pkgLen) { 272 String status = Environment.getExternalStorageState(); 273 if (!status.equals(Environment.MEDIA_MOUNTED)) { 274 return false; 275 } 276 long sdSize = -1; 277 StatFs sdStats = new StatFs( 278 Environment.getExternalStorageDirectory().getPath()); 279 sdSize = (long)sdStats.getAvailableBlocks() * 280 (long)sdStats.getBlockSize(); 281 // TODO check for thresholds here 282 return pkgLen <= sdSize; 283 284 } 285 private boolean checkInt(long pkgLen) { 286 StatFs intStats = new StatFs(Environment.getDataDirectory().getPath()); 287 long intSize = (long)intStats.getBlockCount() * 288 (long)intStats.getBlockSize(); 289 long iSize = (long)intStats.getAvailableBlocks() * 290 (long)intStats.getBlockSize(); 291 // TODO check for thresholds here? 292 return pkgLen <= iSize; 293 } 294 private static final int INSTALL_LOC_INT = 1; 295 private static final int INSTALL_LOC_SD = 2; 296 private static final int INSTALL_LOC_ERR = -1; 297 private int getInstallLoc(int flags, int expInstallLocation, long pkgLen) { 298 // Flags explicitly over ride everything else. 299 if ((flags & PackageManager.INSTALL_FORWARD_LOCK) != 0 ) { 300 return INSTALL_LOC_INT; 301 } else if ((flags & PackageManager.INSTALL_EXTERNAL) != 0 ) { 302 return INSTALL_LOC_SD; 303 } else if ((flags & PackageManager.INSTALL_INTERNAL) != 0) { 304 return INSTALL_LOC_INT; 305 } 306 // Manifest option takes precedence next 307 if (expInstallLocation == PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL) { 308 if (checkSd(pkgLen)) { 309 return INSTALL_LOC_SD; 310 } 311 if (checkInt(pkgLen)) { 312 return INSTALL_LOC_INT; 313 } 314 return INSTALL_LOC_ERR; 315 } 316 if (expInstallLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY) { 317 if (checkInt(pkgLen)) { 318 return INSTALL_LOC_INT; 319 } 320 return INSTALL_LOC_ERR; 321 } 322 if (expInstallLocation == PackageInfo.INSTALL_LOCATION_AUTO) { 323 // Check for free memory internally 324 if (checkInt(pkgLen)) { 325 return INSTALL_LOC_INT; 326 } 327 // Check for free memory externally 328 if (checkSd(pkgLen)) { 329 return INSTALL_LOC_SD; 330 } 331 return INSTALL_LOC_ERR; 332 } 333 // Check for settings preference. 334 boolean checkSd = false; 335 int userPref = getDefaultInstallLoc(); 336 if (userPref == APP_INSTALL_DEVICE) { 337 if (checkInt(pkgLen)) { 338 return INSTALL_LOC_INT; 339 } 340 return INSTALL_LOC_ERR; 341 } else if (userPref == APP_INSTALL_SDCARD) { 342 if (checkSd(pkgLen)) { 343 return INSTALL_LOC_SD; 344 } 345 return INSTALL_LOC_ERR; 346 } 347 // Default system policy for apps with no manifest option specified. 348 // Check for free memory internally 349 if (checkInt(pkgLen)) { 350 return INSTALL_LOC_INT; 351 } 352 return INSTALL_LOC_ERR; 353 } 354 355 private void assertInstall(PackageParser.Package pkg, int flags, int expInstallLocation) { 356 try { 357 String pkgName = pkg.packageName; 358 ApplicationInfo info = getPm().getApplicationInfo(pkgName, 0); 359 assertNotNull(info); 360 assertEquals(pkgName, info.packageName); 361 File dataDir = Environment.getDataDirectory(); 362 String appInstallPath = new File(dataDir, "app").getPath(); 363 String drmInstallPath = new File(dataDir, "app-private").getPath(); 364 File srcDir = new File(info.sourceDir); 365 String srcPath = srcDir.getParent(); 366 File publicSrcDir = new File(info.publicSourceDir); 367 String publicSrcPath = publicSrcDir.getParent(); 368 long pkgLen = new File(info.sourceDir).length(); 369 370 if ((flags & PackageManager.INSTALL_FORWARD_LOCK) != 0) { 371 assertTrue((info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0); 372 assertEquals(srcPath, drmInstallPath); 373 assertEquals(publicSrcPath, appInstallPath); 374 assertTrue(info.nativeLibraryDir.startsWith(dataDir.getPath())); 375 } else { 376 assertFalse((info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0); 377 int rLoc = getInstallLoc(flags, expInstallLocation, pkgLen); 378 if (rLoc == INSTALL_LOC_INT) { 379 assertEquals(srcPath, appInstallPath); 380 assertEquals(publicSrcPath, appInstallPath); 381 assertFalse((info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0); 382 assertTrue(info.nativeLibraryDir.startsWith(dataDir.getPath())); 383 384 // Make sure the native library dir is not a symlink 385 final File nativeLibDir = new File(info.nativeLibraryDir); 386 assertTrue("Native library dir should exist at " + info.nativeLibraryDir, 387 nativeLibDir.exists()); 388 try { 389 assertEquals("Native library dir should not be a symlink", 390 info.nativeLibraryDir, 391 nativeLibDir.getCanonicalPath()); 392 } catch (IOException e) { 393 fail("Can't read " + nativeLibDir.getPath()); 394 } 395 } else if (rLoc == INSTALL_LOC_SD){ 396 assertTrue("Application flags (" + info.flags 397 + ") should contain FLAG_EXTERNAL_STORAGE", 398 (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0); 399 assertTrue("The APK path (" + srcPath + ") should start with " 400 + SECURE_CONTAINERS_PREFIX, srcPath 401 .startsWith(SECURE_CONTAINERS_PREFIX)); 402 assertTrue("The public APK path (" + publicSrcPath + ") should start with " 403 + SECURE_CONTAINERS_PREFIX, publicSrcPath 404 .startsWith(SECURE_CONTAINERS_PREFIX)); 405 assertTrue("The native library path (" + info.nativeLibraryDir 406 + ") should start with " + SECURE_CONTAINERS_PREFIX, 407 info.nativeLibraryDir.startsWith(SECURE_CONTAINERS_PREFIX)); 408 409 // Make sure the native library in /data/data/<app>/lib is a 410 // symlink to the ASEC 411 final File nativeLibSymLink = new File(info.dataDir, "lib"); 412 assertTrue("Native library symlink should exist at " + nativeLibSymLink.getPath(), 413 nativeLibSymLink.exists()); 414 try { 415 assertEquals(nativeLibSymLink.getPath() + " should be a symlink to " 416 + info.nativeLibraryDir, info.nativeLibraryDir, nativeLibSymLink 417 .getCanonicalPath()); 418 } catch (IOException e) { 419 fail("Can't read " + nativeLibSymLink.getPath()); 420 } 421 } else { 422 // TODO handle error. Install should have failed. 423 fail("Install should have failed"); 424 } 425 } 426 } catch (NameNotFoundException e) { 427 failStr("failed with exception : " + e); 428 } 429 } 430 431 private void assertNotInstalled(String pkgName) { 432 try { 433 ApplicationInfo info = getPm().getApplicationInfo(pkgName, 0); 434 fail(pkgName + " shouldnt be installed"); 435 } catch (NameNotFoundException e) { 436 } 437 } 438 439 class InstallParams { 440 Uri packageURI; 441 PackageParser.Package pkg; 442 InstallParams(String outFileName, int rawResId) { 443 this.pkg = getParsedPackage(outFileName, rawResId); 444 this.packageURI = Uri.fromFile(new File(pkg.mScanPath)); 445 } 446 InstallParams(PackageParser.Package pkg) { 447 this.packageURI = Uri.fromFile(new File(pkg.mScanPath)); 448 this.pkg = pkg; 449 } 450 long getApkSize() { 451 File file = new File(pkg.mScanPath); 452 return file.length(); 453 } 454 } 455 456 private InstallParams sampleInstallFromRawResource(int flags, boolean cleanUp) { 457 return installFromRawResource("install.apk", R.raw.install, flags, cleanUp, 458 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 459 } 460 461 static final String PERM_PACKAGE = "package"; 462 static final String PERM_DEFINED = "defined"; 463 static final String PERM_UNDEFINED = "undefined"; 464 static final String PERM_USED = "used"; 465 static final String PERM_NOTUSED = "notused"; 466 467 private void assertPermissions(String[] cmds) { 468 final PackageManager pm = getPm(); 469 String pkg = null; 470 PackageInfo pkgInfo = null; 471 String mode = PERM_DEFINED; 472 int i = 0; 473 while (i < cmds.length) { 474 String cmd = cmds[i++]; 475 if (cmd == PERM_PACKAGE) { 476 pkg = cmds[i++]; 477 try { 478 pkgInfo = pm.getPackageInfo(pkg, 479 PackageManager.GET_PERMISSIONS 480 | PackageManager.GET_UNINSTALLED_PACKAGES); 481 } catch (NameNotFoundException e) { 482 pkgInfo = null; 483 } 484 } else if (cmd == PERM_DEFINED || cmd == PERM_UNDEFINED 485 || cmd == PERM_USED || cmd == PERM_NOTUSED) { 486 mode = cmds[i++]; 487 } else { 488 if (mode == PERM_DEFINED) { 489 try { 490 PermissionInfo pi = pm.getPermissionInfo(cmd, 0); 491 assertNotNull(pi); 492 assertEquals(pi.packageName, pkg); 493 assertEquals(pi.name, cmd); 494 assertNotNull(pkgInfo); 495 boolean found = false; 496 for (int j=0; j<pkgInfo.permissions.length && !found; j++) { 497 if (pkgInfo.permissions[j].name.equals(cmd)) { 498 found = true; 499 } 500 } 501 if (!found) { 502 fail("Permission not found: " + cmd); 503 } 504 } catch (NameNotFoundException e) { 505 throw new RuntimeException(e); 506 } 507 } else if (mode == PERM_UNDEFINED) { 508 try { 509 pm.getPermissionInfo(cmd, 0); 510 throw new RuntimeException("Permission exists: " + cmd); 511 } catch (NameNotFoundException e) { 512 } 513 if (pkgInfo != null) { 514 boolean found = false; 515 for (int j=0; j<pkgInfo.permissions.length && !found; j++) { 516 if (pkgInfo.permissions[j].name.equals(cmd)) { 517 found = true; 518 } 519 } 520 if (found) { 521 fail("Permission still exists: " + cmd); 522 } 523 } 524 } else if (mode == PERM_USED || mode == PERM_NOTUSED) { 525 boolean found = false; 526 for (int j=0; j<pkgInfo.requestedPermissions.length && !found; j++) { 527 if (pkgInfo.requestedPermissions[j].equals(cmd)) { 528 found = true; 529 } 530 } 531 if (!found) { 532 fail("Permission not requested: " + cmd); 533 } 534 if (mode == PERM_USED) { 535 if (pm.checkPermission(cmd, pkg) 536 != PackageManager.PERMISSION_GRANTED) { 537 fail("Permission not granted: " + cmd); 538 } 539 } else { 540 if (pm.checkPermission(cmd, pkg) 541 != PackageManager.PERMISSION_DENIED) { 542 fail("Permission granted: " + cmd); 543 } 544 } 545 } 546 } 547 } 548 } 549 550 private PackageParser.Package getParsedPackage(String outFileName, int rawResId) { 551 PackageManager pm = mContext.getPackageManager(); 552 File filesDir = mContext.getFilesDir(); 553 File outFile = new File(filesDir, outFileName); 554 Uri packageURI = getInstallablePackage(rawResId, outFile); 555 PackageParser.Package pkg = parsePackage(packageURI); 556 return pkg; 557 } 558 559 /* 560 * Utility function that reads a apk bundled as a raw resource 561 * copies it into own data directory and invokes 562 * PackageManager api to install it. 563 */ 564 private void installFromRawResource(InstallParams ip, 565 int flags, boolean cleanUp, boolean fail, int result, 566 int expInstallLocation) { 567 PackageManager pm = mContext.getPackageManager(); 568 PackageParser.Package pkg = ip.pkg; 569 Uri packageURI = ip.packageURI; 570 if ((flags & PackageManager.INSTALL_REPLACE_EXISTING) == 0) { 571 // Make sure the package doesn't exist 572 try { 573 ApplicationInfo appInfo = pm.getApplicationInfo(pkg.packageName, 574 PackageManager.GET_UNINSTALLED_PACKAGES); 575 GenericReceiver receiver = new DeleteReceiver(pkg.packageName); 576 invokeDeletePackage(pkg.packageName, 0, receiver); 577 } catch (NameNotFoundException e1) { 578 } catch (Exception e) { 579 failStr(e); 580 } 581 } 582 try { 583 if (fail) { 584 invokeInstallPackageFail(packageURI, flags, result); 585 if ((flags & PackageManager.INSTALL_REPLACE_EXISTING) == 0) { 586 assertNotInstalled(pkg.packageName); 587 } 588 } else { 589 InstallReceiver receiver = new InstallReceiver(pkg.packageName); 590 assertTrue(invokeInstallPackage(packageURI, flags, receiver)); 591 // Verify installed information 592 assertInstall(pkg, flags, expInstallLocation); 593 } 594 } finally { 595 if (cleanUp) { 596 cleanUpInstall(ip); 597 } 598 } 599 } 600 601 /* 602 * Utility function that reads a apk bundled as a raw resource 603 * copies it into own data directory and invokes 604 * PackageManager api to install it. 605 */ 606 private InstallParams installFromRawResource(String outFileName, 607 int rawResId, int flags, boolean cleanUp, boolean fail, int result, 608 int expInstallLocation) { 609 InstallParams ip = new InstallParams(outFileName, rawResId); 610 installFromRawResource(ip, flags, cleanUp, fail, result, expInstallLocation); 611 return ip; 612 } 613 614 @LargeTest 615 public void testInstallNormalInternal() { 616 sampleInstallFromRawResource(0, true); 617 } 618 619 @LargeTest 620 public void testInstallFwdLockedInternal() { 621 sampleInstallFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, true); 622 } 623 624 @LargeTest 625 public void testInstallSdcard() { 626 // Do not run on devices with emulated external storage. 627 if (Environment.isExternalStorageEmulated()) { 628 return; 629 } 630 631 mountMedia(); 632 sampleInstallFromRawResource(PackageManager.INSTALL_EXTERNAL, true); 633 } 634 635 /* ------------------------- Test replacing packages --------------*/ 636 class ReplaceReceiver extends GenericReceiver { 637 String pkgName; 638 final static int INVALID = -1; 639 final static int REMOVED = 1; 640 final static int ADDED = 2; 641 final static int REPLACED = 3; 642 int removed = INVALID; 643 // for updated system apps only 644 boolean update = false; 645 646 ReplaceReceiver(String pkgName) { 647 this.pkgName = pkgName; 648 filter = new IntentFilter(Intent.ACTION_PACKAGE_REMOVED); 649 filter.addAction(Intent.ACTION_PACKAGE_ADDED); 650 if (update) { 651 filter.addAction(Intent.ACTION_PACKAGE_REPLACED); 652 } 653 filter.addDataScheme("package"); 654 super.setFilter(filter); 655 } 656 657 public boolean notifyNow(Intent intent) { 658 String action = intent.getAction(); 659 Uri data = intent.getData(); 660 String installedPkg = data.getEncodedSchemeSpecificPart(); 661 if (pkgName == null || !pkgName.equals(installedPkg)) { 662 return false; 663 } 664 if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) { 665 removed = REMOVED; 666 } else if (Intent.ACTION_PACKAGE_ADDED.equals(action)) { 667 if (removed != REMOVED) { 668 return false; 669 } 670 boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false); 671 if (!replacing) { 672 return false; 673 } 674 removed = ADDED; 675 if (!update) { 676 return true; 677 } 678 } else if (Intent.ACTION_PACKAGE_REPLACED.equals(action)) { 679 if (removed != ADDED) { 680 return false; 681 } 682 removed = REPLACED; 683 return true; 684 } 685 return false; 686 } 687 } 688 689 /* 690 * Utility function that reads a apk bundled as a raw resource 691 * copies it into own data directory and invokes 692 * PackageManager api to install first and then replace it 693 * again. 694 */ 695 private void sampleReplaceFromRawResource(int flags) { 696 InstallParams ip = sampleInstallFromRawResource(flags, false); 697 boolean replace = ((flags & PackageManager.INSTALL_REPLACE_EXISTING) != 0); 698 Log.i(TAG, "replace=" + replace); 699 GenericReceiver receiver; 700 if (replace) { 701 receiver = new ReplaceReceiver(ip.pkg.packageName); 702 Log.i(TAG, "Creating replaceReceiver"); 703 } else { 704 receiver = new InstallReceiver(ip.pkg.packageName); 705 } 706 try { 707 try { 708 assertEquals(invokeInstallPackage(ip.packageURI, flags, receiver), replace); 709 if (replace) { 710 assertInstall(ip.pkg, flags, ip.pkg.installLocation); 711 } 712 } catch (Exception e) { 713 failStr("Failed with exception : " + e); 714 } 715 } finally { 716 cleanUpInstall(ip); 717 } 718 } 719 720 @LargeTest 721 public void testReplaceFailNormalInternal() { 722 sampleReplaceFromRawResource(0); 723 } 724 725 @LargeTest 726 public void testReplaceFailFwdLockedInternal() { 727 sampleReplaceFromRawResource(PackageManager.INSTALL_FORWARD_LOCK); 728 } 729 730 @LargeTest 731 public void testReplaceFailSdcard() { 732 // Do not run on devices with emulated external storage. 733 if (Environment.isExternalStorageEmulated()) { 734 return; 735 } 736 737 sampleReplaceFromRawResource(PackageManager.INSTALL_EXTERNAL); 738 } 739 740 @LargeTest 741 public void testReplaceNormalInternal() { 742 sampleReplaceFromRawResource(PackageManager.INSTALL_REPLACE_EXISTING); 743 } 744 745 @LargeTest 746 public void testReplaceFwdLockedInternal() { 747 sampleReplaceFromRawResource(PackageManager.INSTALL_REPLACE_EXISTING | 748 PackageManager.INSTALL_FORWARD_LOCK); 749 } 750 751 @LargeTest 752 public void testReplaceSdcard() { 753 // Do not run on devices with emulated external storage. 754 if (Environment.isExternalStorageEmulated()) { 755 return; 756 } 757 758 sampleReplaceFromRawResource(PackageManager.INSTALL_REPLACE_EXISTING | 759 PackageManager.INSTALL_EXTERNAL); 760 } 761 762 /* -------------- Delete tests ---*/ 763 class DeleteObserver extends IPackageDeleteObserver.Stub { 764 765 public boolean succeeded; 766 private boolean doneFlag = false; 767 768 public boolean isDone() { 769 return doneFlag; 770 } 771 772 public void packageDeleted(String packageName, int returnCode) throws RemoteException { 773 synchronized(this) { 774 this.succeeded = returnCode == PackageManager.DELETE_SUCCEEDED; 775 doneFlag = true; 776 notifyAll(); 777 } 778 } 779 } 780 781 class DeleteReceiver extends GenericReceiver { 782 String pkgName; 783 784 DeleteReceiver(String pkgName) { 785 this.pkgName = pkgName; 786 IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_REMOVED); 787 filter.addDataScheme("package"); 788 super.setFilter(filter); 789 } 790 791 public boolean notifyNow(Intent intent) { 792 String action = intent.getAction(); 793 if (!Intent.ACTION_PACKAGE_REMOVED.equals(action)) { 794 return false; 795 } 796 Uri data = intent.getData(); 797 String installedPkg = data.getEncodedSchemeSpecificPart(); 798 if (pkgName.equals(installedPkg)) { 799 return true; 800 } 801 return false; 802 } 803 } 804 805 public boolean invokeDeletePackage(final String pkgName, int flags, 806 GenericReceiver receiver) throws Exception { 807 DeleteObserver observer = new DeleteObserver(); 808 final boolean received = false; 809 mContext.registerReceiver(receiver, receiver.filter); 810 try { 811 // Wait on observer 812 synchronized(observer) { 813 synchronized (receiver) { 814 getPm().deletePackage(pkgName, observer, flags); 815 long waitTime = 0; 816 while((!observer.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 817 observer.wait(WAIT_TIME_INCR); 818 waitTime += WAIT_TIME_INCR; 819 } 820 if(!observer.isDone()) { 821 throw new Exception("Timed out waiting for packageInstalled callback"); 822 } 823 // Verify we received the broadcast 824 waitTime = 0; 825 while((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 826 receiver.wait(WAIT_TIME_INCR); 827 waitTime += WAIT_TIME_INCR; 828 } 829 if(!receiver.isDone()) { 830 throw new Exception("Timed out waiting for PACKAGE_REMOVED notification"); 831 } 832 return receiver.received; 833 } 834 } 835 } finally { 836 mContext.unregisterReceiver(receiver); 837 } 838 } 839 840 public void deleteFromRawResource(int iFlags, int dFlags) { 841 InstallParams ip = sampleInstallFromRawResource(iFlags, false); 842 boolean retainData = ((dFlags & PackageManager.DONT_DELETE_DATA) != 0); 843 GenericReceiver receiver = new DeleteReceiver(ip.pkg.packageName); 844 DeleteObserver observer = new DeleteObserver(); 845 try { 846 assertTrue(invokeDeletePackage(ip.pkg.packageName, dFlags, receiver)); 847 ApplicationInfo info = null; 848 Log.i(TAG, "okay4"); 849 try { 850 info = getPm().getApplicationInfo(ip.pkg.packageName, 851 PackageManager.GET_UNINSTALLED_PACKAGES); 852 } catch (NameNotFoundException e) { 853 info = null; 854 } 855 if (retainData) { 856 assertNotNull(info); 857 assertEquals(info.packageName, ip.pkg.packageName); 858 File file = new File(info.dataDir); 859 assertTrue(file.exists()); 860 } else { 861 assertNull(info); 862 } 863 } catch (Exception e) { 864 failStr(e); 865 } finally { 866 cleanUpInstall(ip); 867 } 868 } 869 870 @LargeTest 871 public void testDeleteNormalInternal() { 872 deleteFromRawResource(0, 0); 873 } 874 875 @LargeTest 876 public void testDeleteFwdLockedInternal() { 877 deleteFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, 0); 878 } 879 880 @LargeTest 881 public void testDeleteSdcard() { 882 // Do not run on devices with emulated external storage. 883 if (Environment.isExternalStorageEmulated()) { 884 return; 885 } 886 887 deleteFromRawResource(PackageManager.INSTALL_EXTERNAL, 0); 888 } 889 890 @LargeTest 891 public void testDeleteNormalInternalRetainData() { 892 deleteFromRawResource(0, PackageManager.DONT_DELETE_DATA); 893 } 894 895 @LargeTest 896 public void testDeleteFwdLockedInternalRetainData() { 897 deleteFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, PackageManager.DONT_DELETE_DATA); 898 } 899 900 @LargeTest 901 public void testDeleteSdcardRetainData() { 902 // Do not run on devices with emulated external storage. 903 if (Environment.isExternalStorageEmulated()) { 904 return; 905 } 906 907 deleteFromRawResource(PackageManager.INSTALL_EXTERNAL, PackageManager.DONT_DELETE_DATA); 908 } 909 910 /* sdcard mount/unmount tests ******/ 911 912 class SdMountReceiver extends GenericReceiver { 913 String pkgNames[]; 914 boolean status = true; 915 916 SdMountReceiver(String[] pkgNames) { 917 this.pkgNames = pkgNames; 918 IntentFilter filter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE); 919 super.setFilter(filter); 920 } 921 922 public boolean notifyNow(Intent intent) { 923 Log.i(TAG, "okay 1"); 924 String action = intent.getAction(); 925 if (!Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) { 926 return false; 927 } 928 String rpkgList[] = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 929 for (String pkg : pkgNames) { 930 boolean found = false; 931 for (String rpkg : rpkgList) { 932 if (rpkg.equals(pkg)) { 933 found = true; 934 break; 935 } 936 } 937 if (!found) { 938 status = false; 939 return true; 940 } 941 } 942 return true; 943 } 944 } 945 946 class SdUnMountReceiver extends GenericReceiver { 947 String pkgNames[]; 948 boolean status = true; 949 950 SdUnMountReceiver(String[] pkgNames) { 951 this.pkgNames = pkgNames; 952 IntentFilter filter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); 953 super.setFilter(filter); 954 } 955 956 public boolean notifyNow(Intent intent) { 957 String action = intent.getAction(); 958 if (!Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) { 959 return false; 960 } 961 String rpkgList[] = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 962 for (String pkg : pkgNames) { 963 boolean found = false; 964 for (String rpkg : rpkgList) { 965 if (rpkg.equals(pkg)) { 966 found = true; 967 break; 968 } 969 } 970 if (!found) { 971 status = false; 972 return true; 973 } 974 } 975 return true; 976 } 977 } 978 979 IMountService getMs() { 980 IBinder service = ServiceManager.getService("mount"); 981 if (service != null) { 982 return IMountService.Stub.asInterface(service); 983 } else { 984 Log.e(TAG, "Can't get mount service"); 985 } 986 return null; 987 } 988 989 boolean checkMediaState(String desired) { 990 try { 991 String mPath = Environment.getExternalStorageDirectory().getPath(); 992 String actual = getMs().getVolumeState(mPath); 993 if (desired.equals(actual)) { 994 return true; 995 } else { 996 return false; 997 } 998 } catch (RemoteException e) { 999 Log.e(TAG, "Exception while checking media state", e); 1000 return false; 1001 } 1002 } 1003 1004 boolean mountMedia() { 1005 // We can't mount emulated storage. 1006 if (Environment.isExternalStorageEmulated()) { 1007 return true; 1008 } 1009 1010 if (checkMediaState(Environment.MEDIA_MOUNTED)) { 1011 return true; 1012 } 1013 1014 final String path = Environment.getExternalStorageDirectory().toString(); 1015 StorageListener observer = new StorageListener(Environment.MEDIA_MOUNTED); 1016 StorageManager sm = (StorageManager) mContext.getSystemService(Context.STORAGE_SERVICE); 1017 sm.registerListener(observer); 1018 try { 1019 // Wait on observer 1020 synchronized (observer) { 1021 int ret = getMs().mountVolume(path); 1022 if (ret != StorageResultCode.OperationSucceeded) { 1023 throw new Exception("Could not mount the media"); 1024 } 1025 long waitTime = 0; 1026 while ((!observer.isDone()) && (waitTime < MAX_WAIT_TIME)) { 1027 observer.wait(WAIT_TIME_INCR); 1028 waitTime += WAIT_TIME_INCR; 1029 } 1030 if (!observer.isDone()) { 1031 throw new Exception("Timed out waiting for unmount media notification"); 1032 } 1033 return true; 1034 } 1035 } catch (Exception e) { 1036 Log.e(TAG, "Exception : " + e); 1037 return false; 1038 } finally { 1039 sm.unregisterListener(observer); 1040 } 1041 } 1042 1043 private boolean unmountMedia() { 1044 // We can't unmount emulated storage. 1045 if (Environment.isExternalStorageEmulated()) { 1046 return true; 1047 } 1048 1049 if (checkMediaState(Environment.MEDIA_UNMOUNTED)) { 1050 return true; 1051 } 1052 1053 final String path = Environment.getExternalStorageDirectory().getPath(); 1054 StorageListener observer = new StorageListener(Environment.MEDIA_UNMOUNTED); 1055 StorageManager sm = (StorageManager) mContext.getSystemService(Context.STORAGE_SERVICE); 1056 sm.registerListener(observer); 1057 try { 1058 // Wait on observer 1059 synchronized(observer) { 1060 getMs().unmountVolume(path, true); 1061 long waitTime = 0; 1062 while((!observer.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 1063 observer.wait(WAIT_TIME_INCR); 1064 waitTime += WAIT_TIME_INCR; 1065 } 1066 if(!observer.isDone()) { 1067 throw new Exception("Timed out waiting for unmount media notification"); 1068 } 1069 return true; 1070 } 1071 } catch (Exception e) { 1072 Log.e(TAG, "Exception : " + e); 1073 return false; 1074 } finally { 1075 sm.unregisterListener(observer); 1076 } 1077 } 1078 1079 private boolean mountFromRawResource() { 1080 // Install pkg on sdcard 1081 InstallParams ip = sampleInstallFromRawResource(PackageManager.INSTALL_EXTERNAL, false); 1082 if (localLOGV) Log.i(TAG, "Installed pkg on sdcard"); 1083 boolean origState = checkMediaState(Environment.MEDIA_MOUNTED); 1084 boolean registeredReceiver = false; 1085 SdMountReceiver receiver = new SdMountReceiver(new String[]{ip.pkg.packageName}); 1086 try { 1087 if (localLOGV) Log.i(TAG, "Unmounting media"); 1088 // Unmount media 1089 assertTrue(unmountMedia()); 1090 if (localLOGV) Log.i(TAG, "Unmounted media"); 1091 // Register receiver here 1092 PackageManager pm = getPm(); 1093 mContext.registerReceiver(receiver, receiver.filter); 1094 registeredReceiver = true; 1095 1096 // Wait on receiver 1097 synchronized (receiver) { 1098 if (localLOGV) Log.i(TAG, "Mounting media"); 1099 // Mount media again 1100 assertTrue(mountMedia()); 1101 if (localLOGV) Log.i(TAG, "Mounted media"); 1102 if (localLOGV) Log.i(TAG, "Waiting for notification"); 1103 long waitTime = 0; 1104 // Verify we received the broadcast 1105 waitTime = 0; 1106 while((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 1107 receiver.wait(WAIT_TIME_INCR); 1108 waitTime += WAIT_TIME_INCR; 1109 } 1110 if(!receiver.isDone()) { 1111 failStr("Timed out waiting for EXTERNAL_APPLICATIONS notification"); 1112 } 1113 return receiver.received; 1114 } 1115 } catch (InterruptedException e) { 1116 failStr(e); 1117 return false; 1118 } finally { 1119 if (registeredReceiver) mContext.unregisterReceiver(receiver); 1120 // Restore original media state 1121 if (origState) { 1122 mountMedia(); 1123 } else { 1124 unmountMedia(); 1125 } 1126 if (localLOGV) Log.i(TAG, "Cleaning up install"); 1127 cleanUpInstall(ip); 1128 } 1129 } 1130 1131 /* 1132 * Install package on sdcard. Unmount and then mount the media. 1133 * (Use PackageManagerService private api for now) 1134 * Make sure the installed package is available. 1135 */ 1136 @LargeTest 1137 public void testMountSdNormalInternal() { 1138 // Do not run on devices with emulated external storage. 1139 if (Environment.isExternalStorageEmulated()) { 1140 return; 1141 } 1142 1143 assertTrue(mountFromRawResource()); 1144 } 1145 1146 void cleanUpInstall(InstallParams ip) { 1147 if (ip == null) { 1148 return; 1149 } 1150 Runtime.getRuntime().gc(); 1151 Log.i(TAG, "Deleting package : " + ip.pkg.packageName); 1152 getPm().deletePackage(ip.pkg.packageName, null, 0); 1153 File outFile = new File(ip.pkg.mScanPath); 1154 if (outFile != null && outFile.exists()) { 1155 outFile.delete(); 1156 } 1157 } 1158 void cleanUpInstall(String pkgName) { 1159 if (pkgName == null) { 1160 return; 1161 } 1162 Log.i(TAG, "Deleting package : " + pkgName); 1163 try { 1164 ApplicationInfo info = getPm().getApplicationInfo(pkgName, 1165 PackageManager.GET_UNINSTALLED_PACKAGES); 1166 if (info != null) { 1167 getPm().deletePackage(pkgName, null, 0); 1168 } 1169 } catch (NameNotFoundException e) {} 1170 } 1171 1172 @LargeTest 1173 public void testManifestInstallLocationInternal() { 1174 installFromRawResource("install.apk", R.raw.install_loc_internal, 1175 0, true, false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 1176 } 1177 1178 @LargeTest 1179 public void testManifestInstallLocationSdcard() { 1180 // Do not run on devices with emulated external storage. 1181 if (Environment.isExternalStorageEmulated()) { 1182 return; 1183 } 1184 1185 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 1186 0, true, false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1187 } 1188 1189 @LargeTest 1190 public void testManifestInstallLocationAuto() { 1191 installFromRawResource("install.apk", R.raw.install_loc_auto, 1192 0, true, false, -1, PackageInfo.INSTALL_LOCATION_AUTO); 1193 } 1194 1195 @LargeTest 1196 public void testManifestInstallLocationUnspecified() { 1197 installFromRawResource("install.apk", R.raw.install_loc_unspecified, 1198 0, true, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 1199 } 1200 1201 @LargeTest 1202 public void testManifestInstallLocationFwdLockedFlagSdcard() { 1203 // Do not run on devices with emulated external storage. 1204 if (Environment.isExternalStorageEmulated()) { 1205 return; 1206 } 1207 1208 installFromRawResource("install.apk", R.raw.install_loc_unspecified, 1209 PackageManager.INSTALL_FORWARD_LOCK | 1210 PackageManager.INSTALL_EXTERNAL, true, true, 1211 PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION, 1212 PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 1213 } 1214 1215 @LargeTest 1216 public void testManifestInstallLocationFwdLockedSdcard() { 1217 // Do not run on devices with emulated external storage. 1218 if (Environment.isExternalStorageEmulated()) { 1219 return; 1220 } 1221 1222 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 1223 PackageManager.INSTALL_FORWARD_LOCK, true, false, 1224 -1, 1225 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1226 } 1227 1228 /* 1229 * Install a package on internal flash via PackageManager install flag. Replace 1230 * the package via flag to install on sdcard. Make sure the new flag overrides 1231 * the old install location. 1232 */ 1233 @LargeTest 1234 public void testReplaceFlagInternalSdcard() { 1235 // Do not run on devices with emulated external storage. 1236 if (Environment.isExternalStorageEmulated()) { 1237 return; 1238 } 1239 1240 int iFlags = 0; 1241 int rFlags = PackageManager.INSTALL_EXTERNAL; 1242 InstallParams ip = sampleInstallFromRawResource(iFlags, false); 1243 GenericReceiver receiver = new ReplaceReceiver(ip.pkg.packageName); 1244 int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING; 1245 try { 1246 assertEquals(invokeInstallPackage(ip.packageURI, replaceFlags, receiver), true); 1247 assertInstall(ip.pkg, rFlags, ip.pkg.installLocation); 1248 } catch (Exception e) { 1249 failStr("Failed with exception : " + e); 1250 } finally { 1251 cleanUpInstall(ip); 1252 } 1253 } 1254 1255 /* 1256 * Install a package on sdcard via PackageManager install flag. Replace 1257 * the package with no flags or manifest option and make sure the old 1258 * install location is retained. 1259 */ 1260 @LargeTest 1261 public void testReplaceFlagSdcardInternal() { 1262 // Do not run on devices with emulated external storage. 1263 if (Environment.isExternalStorageEmulated()) { 1264 return; 1265 } 1266 1267 int iFlags = PackageManager.INSTALL_EXTERNAL; 1268 int rFlags = 0; 1269 InstallParams ip = sampleInstallFromRawResource(iFlags, false); 1270 GenericReceiver receiver = new ReplaceReceiver(ip.pkg.packageName); 1271 int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING; 1272 try { 1273 assertEquals(invokeInstallPackage(ip.packageURI, replaceFlags, receiver), true); 1274 assertInstall(ip.pkg, iFlags, ip.pkg.installLocation); 1275 } catch (Exception e) { 1276 failStr("Failed with exception : " + e); 1277 } finally { 1278 cleanUpInstall(ip); 1279 } 1280 } 1281 1282 @LargeTest 1283 public void testManifestInstallLocationReplaceInternalSdcard() { 1284 // Do not run on devices with emulated external storage. 1285 if (Environment.isExternalStorageEmulated()) { 1286 return; 1287 } 1288 1289 int iFlags = 0; 1290 int iApk = R.raw.install_loc_internal; 1291 int rFlags = 0; 1292 int rApk = R.raw.install_loc_sdcard; 1293 InstallParams ip = installFromRawResource("install.apk", iApk, 1294 iFlags, false, 1295 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 1296 GenericReceiver receiver = new ReplaceReceiver(ip.pkg.packageName); 1297 int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING; 1298 try { 1299 InstallParams rp = installFromRawResource("install.apk", rApk, 1300 replaceFlags, false, 1301 false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1302 assertInstall(rp.pkg, replaceFlags, rp.pkg.installLocation); 1303 } catch (Exception e) { 1304 failStr("Failed with exception : " + e); 1305 } finally { 1306 cleanUpInstall(ip); 1307 } 1308 } 1309 1310 @LargeTest 1311 public void testManifestInstallLocationReplaceSdcardInternal() { 1312 // Do not run on devices with emulated external storage. 1313 if (Environment.isExternalStorageEmulated()) { 1314 return; 1315 } 1316 1317 int iFlags = 0; 1318 int iApk = R.raw.install_loc_sdcard; 1319 int rFlags = 0; 1320 int rApk = R.raw.install_loc_unspecified; 1321 InstallParams ip = installFromRawResource("install.apk", iApk, 1322 iFlags, false, 1323 false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1324 int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING; 1325 try { 1326 InstallParams rp = installFromRawResource("install.apk", rApk, 1327 replaceFlags, false, 1328 false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1329 assertInstall(rp.pkg, replaceFlags, ip.pkg.installLocation); 1330 } catch (Exception e) { 1331 failStr("Failed with exception : " + e); 1332 } finally { 1333 cleanUpInstall(ip); 1334 } 1335 } 1336 1337 class MoveReceiver extends GenericReceiver { 1338 String pkgName; 1339 final static int INVALID = -1; 1340 final static int REMOVED = 1; 1341 final static int ADDED = 2; 1342 int removed = INVALID; 1343 1344 MoveReceiver(String pkgName) { 1345 this.pkgName = pkgName; 1346 filter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE); 1347 filter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); 1348 super.setFilter(filter); 1349 } 1350 1351 public boolean notifyNow(Intent intent) { 1352 String action = intent.getAction(); 1353 Log.i(TAG, "MoveReceiver::" + action); 1354 if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) { 1355 String[] list = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 1356 if (list != null) { 1357 for (String pkg : list) { 1358 if (pkg.equals(pkgName)) { 1359 removed = REMOVED; 1360 break; 1361 } 1362 } 1363 } 1364 removed = REMOVED; 1365 } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) { 1366 if (removed != REMOVED) { 1367 return false; 1368 } 1369 String[] list = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 1370 if (list != null) { 1371 for (String pkg : list) { 1372 if (pkg.equals(pkgName)) { 1373 removed = ADDED; 1374 return true; 1375 } 1376 } 1377 } 1378 } 1379 return false; 1380 } 1381 } 1382 1383 private class PackageMoveObserver extends IPackageMoveObserver.Stub { 1384 public int returnCode; 1385 private boolean doneFlag = false; 1386 public String packageName; 1387 public PackageMoveObserver(String pkgName) { 1388 packageName = pkgName; 1389 } 1390 public void packageMoved(String packageName, int returnCode) { 1391 Log.i("DEBUG_MOVE::", "pkg = " + packageName + ", " + "ret = " + returnCode); 1392 if (!packageName.equals(this.packageName)) { 1393 return; 1394 } 1395 synchronized(this) { 1396 this.returnCode = returnCode; 1397 doneFlag = true; 1398 notifyAll(); 1399 } 1400 } 1401 1402 public boolean isDone() { 1403 return doneFlag; 1404 } 1405 } 1406 1407 public boolean invokeMovePackage(String pkgName, int flags, 1408 GenericReceiver receiver) throws Exception { 1409 PackageMoveObserver observer = new PackageMoveObserver(pkgName); 1410 final boolean received = false; 1411 mContext.registerReceiver(receiver, receiver.filter); 1412 try { 1413 // Wait on observer 1414 synchronized(observer) { 1415 synchronized (receiver) { 1416 getPm().movePackage(pkgName, observer, flags); 1417 long waitTime = 0; 1418 while((!observer.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 1419 observer.wait(WAIT_TIME_INCR); 1420 waitTime += WAIT_TIME_INCR; 1421 } 1422 if(!observer.isDone()) { 1423 throw new Exception("Timed out waiting for pkgmove callback"); 1424 } 1425 if (observer.returnCode != PackageManager.MOVE_SUCCEEDED) { 1426 return false; 1427 } 1428 // Verify we received the broadcast 1429 waitTime = 0; 1430 while((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 1431 receiver.wait(WAIT_TIME_INCR); 1432 waitTime += WAIT_TIME_INCR; 1433 } 1434 if(!receiver.isDone()) { 1435 throw new Exception("Timed out waiting for MOVE notifications"); 1436 } 1437 return receiver.received; 1438 } 1439 } 1440 } finally { 1441 mContext.unregisterReceiver(receiver); 1442 } 1443 } 1444 private boolean invokeMovePackageFail(String pkgName, int flags, int errCode) throws Exception { 1445 PackageMoveObserver observer = new PackageMoveObserver(pkgName); 1446 try { 1447 // Wait on observer 1448 synchronized(observer) { 1449 getPm().movePackage(pkgName, observer, flags); 1450 long waitTime = 0; 1451 while((!observer.isDone()) && (waitTime < MAX_WAIT_TIME) ) { 1452 observer.wait(WAIT_TIME_INCR); 1453 waitTime += WAIT_TIME_INCR; 1454 } 1455 if(!observer.isDone()) { 1456 throw new Exception("Timed out waiting for pkgmove callback"); 1457 } 1458 assertEquals(errCode, observer.returnCode); 1459 } 1460 } finally { 1461 } 1462 return true; 1463 } 1464 1465 private int getDefaultInstallLoc() { 1466 int origDefaultLoc = PackageInfo.INSTALL_LOCATION_AUTO; 1467 try { 1468 origDefaultLoc = Settings.System.getInt(mContext.getContentResolver(), Settings.Secure.DEFAULT_INSTALL_LOCATION); 1469 } catch (SettingNotFoundException e1) { 1470 } 1471 return origDefaultLoc; 1472 } 1473 1474 private void setInstallLoc(int loc) { 1475 Settings.System.putInt(mContext.getContentResolver(), 1476 Settings.Secure.DEFAULT_INSTALL_LOCATION, loc); 1477 } 1478 /* 1479 * Tests for moving apps between internal and external storage 1480 */ 1481 /* 1482 * Utility function that reads a apk bundled as a raw resource 1483 * copies it into own data directory and invokes 1484 * PackageManager api to install first and then replace it 1485 * again. 1486 */ 1487 1488 private void moveFromRawResource(String outFileName, 1489 int rawResId, int installFlags, int moveFlags, boolean cleanUp, 1490 boolean fail, int result) { 1491 int origDefaultLoc = getDefaultInstallLoc(); 1492 InstallParams ip = null; 1493 try { 1494 setInstallLoc(PackageHelper.APP_INSTALL_AUTO); 1495 // Install first 1496 ip = installFromRawResource("install.apk", rawResId, installFlags, false, 1497 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 1498 ApplicationInfo oldAppInfo = getPm().getApplicationInfo(ip.pkg.packageName, 0); 1499 if (fail) { 1500 assertTrue(invokeMovePackageFail(ip.pkg.packageName, moveFlags, result)); 1501 ApplicationInfo info = getPm().getApplicationInfo(ip.pkg.packageName, 0); 1502 assertNotNull(info); 1503 assertEquals(oldAppInfo.flags, info.flags); 1504 } else { 1505 // Create receiver based on expRetCode 1506 MoveReceiver receiver = new MoveReceiver(ip.pkg.packageName); 1507 boolean retCode = invokeMovePackage(ip.pkg.packageName, moveFlags, 1508 receiver); 1509 assertTrue(retCode); 1510 ApplicationInfo info = getPm().getApplicationInfo(ip.pkg.packageName, 0); 1511 assertNotNull("ApplicationInfo for recently installed application should exist", 1512 info); 1513 if ((moveFlags & PackageManager.MOVE_INTERNAL) != 0) { 1514 assertTrue("ApplicationInfo.FLAG_EXTERNAL_STORAGE flag should NOT be set", 1515 (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 0); 1516 assertTrue("ApplicationInfo.nativeLibraryDir should start with " + info.dataDir, 1517 info.nativeLibraryDir.startsWith(info.dataDir)); 1518 } else if ((moveFlags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0){ 1519 assertTrue("ApplicationInfo.FLAG_EXTERNAL_STORAGE flag should be set", 1520 (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0); 1521 assertTrue("ApplicationInfo.nativeLibraryDir should start with " + SECURE_CONTAINERS_PREFIX, 1522 info.nativeLibraryDir.startsWith(SECURE_CONTAINERS_PREFIX)); 1523 final File nativeLibSymLink = new File(info.dataDir, "lib"); 1524 assertTrue("The data directory should have a 'lib' symlink that points to the ASEC container", 1525 nativeLibSymLink.getCanonicalPath().startsWith(SECURE_CONTAINERS_PREFIX)); 1526 } 1527 } 1528 } catch (NameNotFoundException e) { 1529 failStr("Pkg hasnt been installed correctly"); 1530 } catch (Exception e) { 1531 failStr("Failed with exception : " + e); 1532 } finally { 1533 if (ip != null) { 1534 cleanUpInstall(ip); 1535 } 1536 // Restore default install location 1537 setInstallLoc(origDefaultLoc); 1538 } 1539 } 1540 private void sampleMoveFromRawResource(int installFlags, int moveFlags, boolean fail, 1541 int result) { 1542 moveFromRawResource("install.apk", 1543 R.raw.install, installFlags, moveFlags, true, 1544 fail, result); 1545 } 1546 1547 @LargeTest 1548 public void testMoveAppInternalToExternal() { 1549 // Do not run on devices with emulated external storage. 1550 if (Environment.isExternalStorageEmulated()) { 1551 return; 1552 } 1553 1554 int installFlags = PackageManager.INSTALL_INTERNAL; 1555 int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA; 1556 boolean fail = false; 1557 int result = PackageManager.MOVE_SUCCEEDED; 1558 sampleMoveFromRawResource(installFlags, moveFlags, fail, result); 1559 } 1560 1561 @LargeTest 1562 public void testMoveAppInternalToInternal() { 1563 int installFlags = PackageManager.INSTALL_INTERNAL; 1564 int moveFlags = PackageManager.MOVE_INTERNAL; 1565 boolean fail = true; 1566 int result = PackageManager.MOVE_FAILED_INVALID_LOCATION; 1567 sampleMoveFromRawResource(installFlags, moveFlags, fail, result); 1568 } 1569 1570 @LargeTest 1571 public void testMoveAppExternalToExternal() { 1572 // Do not run on devices with emulated external storage. 1573 if (Environment.isExternalStorageEmulated()) { 1574 return; 1575 } 1576 1577 int installFlags = PackageManager.INSTALL_EXTERNAL; 1578 int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA; 1579 boolean fail = true; 1580 int result = PackageManager.MOVE_FAILED_INVALID_LOCATION; 1581 sampleMoveFromRawResource(installFlags, moveFlags, fail, result); 1582 } 1583 1584 @LargeTest 1585 public void testMoveAppExternalToInternal() { 1586 // Do not run on devices with emulated external storage. 1587 if (Environment.isExternalStorageEmulated()) { 1588 return; 1589 } 1590 1591 int installFlags = PackageManager.INSTALL_EXTERNAL; 1592 int moveFlags = PackageManager.MOVE_INTERNAL; 1593 boolean fail = false; 1594 int result = PackageManager.MOVE_SUCCEEDED; 1595 sampleMoveFromRawResource(installFlags, moveFlags, fail, result); 1596 } 1597 1598 @LargeTest 1599 public void testMoveAppForwardLocked() { 1600 // Do not run on devices with emulated external storage. 1601 if (Environment.isExternalStorageEmulated()) { 1602 return; 1603 } 1604 1605 int installFlags = PackageManager.INSTALL_FORWARD_LOCK; 1606 int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA; 1607 boolean fail = true; 1608 int result = PackageManager.MOVE_FAILED_FORWARD_LOCKED; 1609 sampleMoveFromRawResource(installFlags, moveFlags, fail, result); 1610 } 1611 1612 @LargeTest 1613 public void testMoveAppFailInternalToExternalDelete() { 1614 // Do not run on devices with emulated external storage. 1615 if (Environment.isExternalStorageEmulated()) { 1616 return; 1617 } 1618 1619 int installFlags = 0; 1620 int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA; 1621 boolean fail = true; 1622 final int result = PackageManager.MOVE_FAILED_DOESNT_EXIST; 1623 1624 int rawResId = R.raw.install; 1625 int origDefaultLoc = getDefaultInstallLoc(); 1626 InstallParams ip = null; 1627 try { 1628 PackageManager pm = getPm(); 1629 setInstallLoc(PackageHelper.APP_INSTALL_AUTO); 1630 // Install first 1631 ip = installFromRawResource("install.apk", R.raw.install, installFlags, false, 1632 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 1633 // Delete the package now retaining data. 1634 GenericReceiver receiver = new DeleteReceiver(ip.pkg.packageName); 1635 invokeDeletePackage(ip.pkg.packageName, PackageManager.DONT_DELETE_DATA, receiver); 1636 assertTrue(invokeMovePackageFail(ip.pkg.packageName, moveFlags, result)); 1637 } catch (Exception e) { 1638 failStr(e); 1639 } finally { 1640 if (ip != null) { 1641 cleanUpInstall(ip); 1642 } 1643 // Restore default install location 1644 setInstallLoc(origDefaultLoc); 1645 } 1646 } 1647 1648 /* 1649 * Test that an install error code is returned when media is unmounted 1650 * and package installed on sdcard via package manager flag. 1651 */ 1652 @LargeTest 1653 public void testInstallSdcardUnmount() { 1654 // Do not run on devices with emulated external storage. 1655 if (Environment.isExternalStorageEmulated()) { 1656 return; 1657 } 1658 1659 boolean origState = checkMediaState(Environment.MEDIA_MOUNTED); 1660 try { 1661 // Unmount sdcard 1662 assertTrue(unmountMedia()); 1663 // Try to install and make sure an error code is returned. 1664 installFromRawResource("install.apk", R.raw.install, 1665 PackageManager.INSTALL_EXTERNAL, false, 1666 true, PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE, 1667 PackageInfo.INSTALL_LOCATION_AUTO); 1668 } finally { 1669 // Restore original media state 1670 if (origState) { 1671 mountMedia(); 1672 } else { 1673 unmountMedia(); 1674 } 1675 } 1676 } 1677 1678 /* 1679 * Unmount sdcard. Try installing an app with manifest option to install 1680 * on sdcard. Make sure it gets installed on internal flash. 1681 */ 1682 @LargeTest 1683 public void testInstallManifestSdcardUnmount() { 1684 // Do not run on devices with emulated external storage. 1685 if (Environment.isExternalStorageEmulated()) { 1686 return; 1687 } 1688 1689 boolean origState = checkMediaState(Environment.MEDIA_MOUNTED); 1690 try { 1691 // Unmount sdcard 1692 assertTrue(unmountMedia()); 1693 InstallParams ip = new InstallParams("install.apk", R.raw.install_loc_sdcard); 1694 installFromRawResource(ip, 0, true, false, -1, 1695 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 1696 } finally { 1697 // Restore original media state 1698 if (origState) { 1699 mountMedia(); 1700 } else { 1701 unmountMedia(); 1702 } 1703 } 1704 } 1705 1706 /*---------- Recommended install location tests ----*/ 1707 /* Precedence: FlagManifestExistingUser 1708 * PrecedenceSuffixes: 1709 * Flag : FlagI, FlagE, FlagF 1710 * I - internal, E - external, F - forward locked, Flag suffix absent if not using any option. 1711 * Manifest: ManifestI, ManifestE, ManifestA, Manifest suffix absent if not using any option. 1712 * Existing: Existing suffix absent if not existing. 1713 * User: UserI, UserE, UserA, User suffix absent if not existing. 1714 * 1715 */ 1716 1717 /* 1718 * Install an app on internal flash 1719 */ 1720 @LargeTest 1721 public void testFlagI() { 1722 sampleInstallFromRawResource(PackageManager.INSTALL_INTERNAL, true); 1723 } 1724 1725 /* 1726 * Install an app on sdcard. 1727 */ 1728 @LargeTest 1729 public void testFlagE() { 1730 // Do not run on devices with emulated external storage. 1731 if (Environment.isExternalStorageEmulated()) { 1732 return; 1733 } 1734 1735 sampleInstallFromRawResource(PackageManager.INSTALL_EXTERNAL, true); 1736 } 1737 1738 /* 1739 * Install an app forward-locked. 1740 */ 1741 @LargeTest 1742 public void testFlagF() { 1743 sampleInstallFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, true); 1744 } 1745 1746 /* 1747 * Install an app with both internal and external flags set. should fail 1748 */ 1749 @LargeTest 1750 public void testFlagIE() { 1751 installFromRawResource("install.apk", R.raw.install, 1752 PackageManager.INSTALL_EXTERNAL | PackageManager.INSTALL_INTERNAL, 1753 false, 1754 true, PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION, 1755 PackageInfo.INSTALL_LOCATION_AUTO); 1756 } 1757 1758 /* 1759 * Install an app with both internal and forward-lock flags set. 1760 */ 1761 @LargeTest 1762 public void testFlagIF() { 1763 sampleInstallFromRawResource(PackageManager.INSTALL_FORWARD_LOCK 1764 | PackageManager.INSTALL_INTERNAL, true); 1765 } 1766 1767 /* 1768 * Install an app with both external and forward-lock flags set. should fail 1769 */ 1770 @LargeTest 1771 public void testFlagEF() { 1772 installFromRawResource("install.apk", R.raw.install, 1773 PackageManager.INSTALL_FORWARD_LOCK | PackageManager.INSTALL_EXTERNAL, 1774 false, 1775 true, PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION, 1776 PackageInfo.INSTALL_LOCATION_AUTO); 1777 } 1778 1779 /* 1780 * Install an app with both internal and external flags set with forward 1781 * lock. Should fail. 1782 */ 1783 @LargeTest 1784 public void testFlagIEF() { 1785 installFromRawResource("install.apk", R.raw.install, 1786 PackageManager.INSTALL_FORWARD_LOCK | PackageManager.INSTALL_INTERNAL | 1787 PackageManager.INSTALL_EXTERNAL, 1788 false, 1789 true, PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION, 1790 PackageInfo.INSTALL_LOCATION_AUTO); 1791 } 1792 1793 /* 1794 * Install an app with both internal and manifest option set. 1795 * should install on internal. 1796 */ 1797 @LargeTest 1798 public void testFlagIManifestI() { 1799 installFromRawResource("install.apk", R.raw.install_loc_internal, 1800 PackageManager.INSTALL_INTERNAL, 1801 true, 1802 false, -1, 1803 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 1804 } 1805 /* 1806 * Install an app with both internal and manifest preference for 1807 * preferExternal. Should install on internal. 1808 */ 1809 @LargeTest 1810 public void testFlagIManifestE() { 1811 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 1812 PackageManager.INSTALL_INTERNAL, 1813 true, 1814 false, -1, 1815 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 1816 } 1817 /* 1818 * Install an app with both internal and manifest preference for 1819 * auto. should install internal. 1820 */ 1821 @LargeTest 1822 public void testFlagIManifestA() { 1823 installFromRawResource("install.apk", R.raw.install_loc_auto, 1824 PackageManager.INSTALL_INTERNAL, 1825 true, 1826 false, -1, 1827 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 1828 } 1829 /* 1830 * Install an app with both external and manifest option set. 1831 * should install externally. 1832 */ 1833 @LargeTest 1834 public void testFlagEManifestI() { 1835 // Do not run on devices with emulated external storage. 1836 if (Environment.isExternalStorageEmulated()) { 1837 return; 1838 } 1839 1840 installFromRawResource("install.apk", R.raw.install_loc_internal, 1841 PackageManager.INSTALL_EXTERNAL, 1842 true, 1843 false, -1, 1844 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1845 } 1846 1847 /* 1848 * Install an app with both external and manifest preference for 1849 * preferExternal. Should install externally. 1850 */ 1851 @LargeTest 1852 public void testFlagEManifestE() { 1853 // Do not run on devices with emulated external storage. 1854 if (Environment.isExternalStorageEmulated()) { 1855 return; 1856 } 1857 1858 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 1859 PackageManager.INSTALL_EXTERNAL, 1860 true, 1861 false, -1, 1862 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1863 } 1864 1865 /* 1866 * Install an app with both external and manifest preference for 1867 * auto. should install on external media. 1868 */ 1869 @LargeTest 1870 public void testFlagEManifestA() { 1871 // Do not run on devices with emulated external storage. 1872 if (Environment.isExternalStorageEmulated()) { 1873 return; 1874 } 1875 1876 installFromRawResource("install.apk", R.raw.install_loc_auto, 1877 PackageManager.INSTALL_EXTERNAL, 1878 true, 1879 false, -1, 1880 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1881 } 1882 1883 /* 1884 * Install an app with fwd locked flag set and install location set to 1885 * internal. should install internally. 1886 */ 1887 @LargeTest 1888 public void testFlagFManifestI() { 1889 installFromRawResource("install.apk", R.raw.install_loc_internal, 1890 PackageManager.INSTALL_FORWARD_LOCK, 1891 true, 1892 false, -1, 1893 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1894 } 1895 1896 /* 1897 * Install an app with fwd locked flag set and install location set to 1898 * preferExternal. should install internally. 1899 */ 1900 @LargeTest 1901 public void testFlagFManifestE() { 1902 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 1903 PackageManager.INSTALL_FORWARD_LOCK, 1904 true, 1905 false, -1, 1906 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1907 } 1908 1909 /* 1910 * Install an app with fwd locked flag set and install location set to 1911 * auto. should install internally. 1912 */ 1913 @LargeTest 1914 public void testFlagFManifestA() { 1915 installFromRawResource("install.apk", R.raw.install_loc_auto, 1916 PackageManager.INSTALL_FORWARD_LOCK, 1917 true, 1918 false, -1, 1919 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 1920 } 1921 1922 /* The following test functions verify install location for existing apps. 1923 * ie existing app can be installed internally or externally. If install 1924 * flag is explicitly set it should override current location. If manifest location 1925 * is set, that should over ride current location too. if not the existing install 1926 * location should be honoured. 1927 * testFlagI/E/F/ExistingI/E - 1928 */ 1929 @LargeTest 1930 public void testFlagIExistingI() { 1931 int iFlags = PackageManager.INSTALL_INTERNAL; 1932 int rFlags = PackageManager.INSTALL_INTERNAL | PackageManager.INSTALL_REPLACE_EXISTING; 1933 // First install. 1934 installFromRawResource("install.apk", R.raw.install, 1935 iFlags, 1936 false, 1937 false, -1, 1938 -1); 1939 // Replace now 1940 installFromRawResource("install.apk", R.raw.install, 1941 rFlags, 1942 true, 1943 false, -1, 1944 -1); 1945 } 1946 1947 @LargeTest 1948 public void testFlagIExistingE() { 1949 // Do not run on devices with emulated external storage. 1950 if (Environment.isExternalStorageEmulated()) { 1951 return; 1952 } 1953 1954 int iFlags = PackageManager.INSTALL_EXTERNAL; 1955 int rFlags = PackageManager.INSTALL_INTERNAL | PackageManager.INSTALL_REPLACE_EXISTING; 1956 // First install. 1957 installFromRawResource("install.apk", R.raw.install, 1958 iFlags, 1959 false, 1960 false, -1, 1961 -1); 1962 // Replace now 1963 installFromRawResource("install.apk", R.raw.install, 1964 rFlags, 1965 true, 1966 false, -1, 1967 -1); 1968 } 1969 1970 @LargeTest 1971 public void testFlagEExistingI() { 1972 // Do not run on devices with emulated external storage. 1973 if (Environment.isExternalStorageEmulated()) { 1974 return; 1975 } 1976 1977 int iFlags = PackageManager.INSTALL_INTERNAL; 1978 int rFlags = PackageManager.INSTALL_EXTERNAL | PackageManager.INSTALL_REPLACE_EXISTING; 1979 // First install. 1980 installFromRawResource("install.apk", R.raw.install, 1981 iFlags, 1982 false, 1983 false, -1, 1984 -1); 1985 // Replace now 1986 installFromRawResource("install.apk", R.raw.install, 1987 rFlags, 1988 true, 1989 false, -1, 1990 -1); 1991 } 1992 1993 @LargeTest 1994 public void testFlagEExistingE() { 1995 // Do not run on devices with emulated external storage. 1996 if (Environment.isExternalStorageEmulated()) { 1997 return; 1998 } 1999 2000 int iFlags = PackageManager.INSTALL_EXTERNAL; 2001 int rFlags = PackageManager.INSTALL_EXTERNAL | PackageManager.INSTALL_REPLACE_EXISTING; 2002 // First install. 2003 installFromRawResource("install.apk", R.raw.install, 2004 iFlags, 2005 false, 2006 false, -1, 2007 -1); 2008 // Replace now 2009 installFromRawResource("install.apk", R.raw.install, 2010 rFlags, 2011 true, 2012 false, -1, 2013 -1); 2014 } 2015 2016 @LargeTest 2017 public void testFlagFExistingI() { 2018 int iFlags = PackageManager.INSTALL_INTERNAL; 2019 int rFlags = PackageManager.INSTALL_FORWARD_LOCK | PackageManager.INSTALL_REPLACE_EXISTING; 2020 // First install. 2021 installFromRawResource("install.apk", R.raw.install, 2022 iFlags, 2023 false, 2024 false, -1, 2025 -1); 2026 // Replace now 2027 installFromRawResource("install.apk", R.raw.install, 2028 rFlags, 2029 true, 2030 false, -1, 2031 -1); 2032 } 2033 2034 @LargeTest 2035 public void testFlagFExistingE() { 2036 // Do not run on devices with emulated external storage. 2037 if (Environment.isExternalStorageEmulated()) { 2038 return; 2039 } 2040 2041 int iFlags = PackageManager.INSTALL_EXTERNAL; 2042 int rFlags = PackageManager.INSTALL_FORWARD_LOCK | PackageManager.INSTALL_REPLACE_EXISTING; 2043 // First install. 2044 installFromRawResource("install.apk", R.raw.install, 2045 iFlags, 2046 false, 2047 false, -1, 2048 -1); 2049 // Replace now 2050 installFromRawResource("install.apk", R.raw.install, 2051 rFlags, 2052 true, 2053 false, -1, 2054 -1); 2055 } 2056 2057 /* 2058 * The following set of tests verify the installation of apps with 2059 * install location attribute set to internalOnly, preferExternal and auto. 2060 * The manifest option should dictate the install location. 2061 * public void testManifestI/E/A 2062 * TODO out of memory fall back behaviour. 2063 */ 2064 @LargeTest 2065 public void testManifestI() { 2066 installFromRawResource("install.apk", R.raw.install_loc_internal, 2067 0, 2068 true, 2069 false, -1, 2070 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2071 } 2072 2073 @LargeTest 2074 public void testManifestE() { 2075 // Do not run on devices with emulated external storage. 2076 if (Environment.isExternalStorageEmulated()) { 2077 return; 2078 } 2079 2080 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 2081 0, 2082 true, 2083 false, -1, 2084 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 2085 } 2086 2087 @LargeTest 2088 public void testManifestA() { 2089 installFromRawResource("install.apk", R.raw.install_loc_auto, 2090 0, 2091 true, 2092 false, -1, 2093 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2094 } 2095 2096 /* 2097 * The following set of tests verify the installation of apps 2098 * with install location attribute set to internalOnly, preferExternal and auto 2099 * for already existing apps. The manifest option should take precedence. 2100 * TODO add out of memory fall back behaviour. 2101 * testManifestI/E/AExistingI/E 2102 */ 2103 @LargeTest 2104 public void testManifestIExistingI() { 2105 int iFlags = PackageManager.INSTALL_INTERNAL; 2106 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2107 // First install. 2108 installFromRawResource("install.apk", R.raw.install, 2109 iFlags, 2110 false, 2111 false, -1, 2112 -1); 2113 // Replace now 2114 installFromRawResource("install.apk", R.raw.install_loc_internal, 2115 rFlags, 2116 true, 2117 false, -1, 2118 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2119 } 2120 2121 @LargeTest 2122 public void testManifestIExistingE() { 2123 // Do not run on devices with emulated external storage. 2124 if (Environment.isExternalStorageEmulated()) { 2125 return; 2126 } 2127 2128 int iFlags = PackageManager.INSTALL_EXTERNAL; 2129 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2130 // First install. 2131 installFromRawResource("install.apk", R.raw.install, 2132 iFlags, 2133 false, 2134 false, -1, 2135 -1); 2136 // Replace now 2137 installFromRawResource("install.apk", R.raw.install_loc_internal, 2138 rFlags, 2139 true, 2140 false, -1, 2141 PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2142 } 2143 2144 @LargeTest 2145 public void testManifestEExistingI() { 2146 // Do not run on devices with emulated external storage. 2147 if (Environment.isExternalStorageEmulated()) { 2148 return; 2149 } 2150 2151 int iFlags = PackageManager.INSTALL_INTERNAL; 2152 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2153 // First install. 2154 installFromRawResource("install.apk", R.raw.install, 2155 iFlags, 2156 false, 2157 false, -1, 2158 -1); 2159 // Replace now 2160 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 2161 rFlags, 2162 true, 2163 false, -1, 2164 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 2165 } 2166 2167 @LargeTest 2168 public void testManifestEExistingE() { 2169 // Do not run on devices with emulated external storage. 2170 if (Environment.isExternalStorageEmulated()) { 2171 return; 2172 } 2173 2174 int iFlags = PackageManager.INSTALL_EXTERNAL; 2175 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2176 // First install. 2177 installFromRawResource("install.apk", R.raw.install, 2178 iFlags, 2179 false, 2180 false, -1, 2181 -1); 2182 // Replace now 2183 installFromRawResource("install.apk", R.raw.install_loc_sdcard, 2184 rFlags, 2185 true, 2186 false, -1, 2187 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 2188 } 2189 2190 @LargeTest 2191 public void testManifestAExistingI() { 2192 int iFlags = PackageManager.INSTALL_INTERNAL; 2193 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2194 // First install. 2195 installFromRawResource("install.apk", R.raw.install, 2196 iFlags, 2197 false, 2198 false, -1, 2199 -1); 2200 // Replace now 2201 installFromRawResource("install.apk", R.raw.install_loc_auto, 2202 rFlags, 2203 true, 2204 false, -1, 2205 PackageInfo.INSTALL_LOCATION_AUTO); 2206 } 2207 2208 @LargeTest 2209 public void testManifestAExistingE() { 2210 // Do not run on devices with emulated external storage. 2211 if (Environment.isExternalStorageEmulated()) { 2212 return; 2213 } 2214 2215 int iFlags = PackageManager.INSTALL_EXTERNAL; 2216 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2217 // First install. 2218 installFromRawResource("install.apk", R.raw.install, 2219 iFlags, 2220 false, 2221 false, -1, 2222 -1); 2223 // Replace now 2224 installFromRawResource("install.apk", R.raw.install_loc_auto, 2225 rFlags, 2226 true, 2227 false, -1, 2228 PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 2229 } 2230 2231 /* 2232 * The following set of tests check install location for existing 2233 * application based on user setting. 2234 */ 2235 private int getExpectedInstallLocation(int userSetting) { 2236 int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 2237 boolean enable = getUserSettingSetInstallLocation(); 2238 if (enable) { 2239 if (userSetting == PackageHelper.APP_INSTALL_AUTO) { 2240 iloc = PackageInfo.INSTALL_LOCATION_AUTO; 2241 } else if (userSetting == PackageHelper.APP_INSTALL_EXTERNAL) { 2242 iloc = PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL; 2243 } else if (userSetting == PackageHelper.APP_INSTALL_INTERNAL) { 2244 iloc = PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY; 2245 } 2246 } 2247 return iloc; 2248 } 2249 private void setExistingXUserX(int userSetting, int iFlags, int iloc) { 2250 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2251 // First install. 2252 installFromRawResource("install.apk", R.raw.install, 2253 iFlags, 2254 false, 2255 false, -1, 2256 PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2257 int origSetting = getDefaultInstallLoc(); 2258 try { 2259 // Set user setting 2260 setInstallLoc(userSetting); 2261 // Replace now 2262 installFromRawResource("install.apk", R.raw.install, 2263 rFlags, 2264 true, 2265 false, -1, 2266 iloc); 2267 } finally { 2268 setInstallLoc(origSetting); 2269 } 2270 } 2271 @LargeTest 2272 public void testExistingIUserI() { 2273 int userSetting = PackageHelper.APP_INSTALL_INTERNAL; 2274 int iFlags = PackageManager.INSTALL_INTERNAL; 2275 setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2276 } 2277 2278 @LargeTest 2279 public void testExistingIUserE() { 2280 // Do not run on devices with emulated external storage. 2281 if (Environment.isExternalStorageEmulated()) { 2282 return; 2283 } 2284 2285 int userSetting = PackageHelper.APP_INSTALL_EXTERNAL; 2286 int iFlags = PackageManager.INSTALL_INTERNAL; 2287 setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2288 } 2289 2290 @LargeTest 2291 public void testExistingIUserA() { 2292 int userSetting = PackageHelper.APP_INSTALL_AUTO; 2293 int iFlags = PackageManager.INSTALL_INTERNAL; 2294 setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2295 } 2296 2297 @LargeTest 2298 public void testExistingEUserI() { 2299 // Do not run on devices with emulated external storage. 2300 if (Environment.isExternalStorageEmulated()) { 2301 return; 2302 } 2303 2304 int userSetting = PackageHelper.APP_INSTALL_INTERNAL; 2305 int iFlags = PackageManager.INSTALL_EXTERNAL; 2306 setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 2307 } 2308 2309 @LargeTest 2310 public void testExistingEUserE() { 2311 // Do not run on devices with emulated external storage. 2312 if (Environment.isExternalStorageEmulated()) { 2313 return; 2314 } 2315 2316 int userSetting = PackageHelper.APP_INSTALL_EXTERNAL; 2317 int iFlags = PackageManager.INSTALL_EXTERNAL; 2318 setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 2319 } 2320 2321 @LargeTest 2322 public void testExistingEUserA() { 2323 // Do not run on devices with emulated external storage. 2324 if (Environment.isExternalStorageEmulated()) { 2325 return; 2326 } 2327 2328 int userSetting = PackageHelper.APP_INSTALL_AUTO; 2329 int iFlags = PackageManager.INSTALL_EXTERNAL; 2330 setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL); 2331 } 2332 2333 /* 2334 * The following set of tests verify that the user setting defines 2335 * the install location. 2336 * 2337 */ 2338 private boolean getUserSettingSetInstallLocation() { 2339 try { 2340 return Settings.System.getInt(mContext.getContentResolver(), Settings.Secure.SET_INSTALL_LOCATION) != 0; 2341 2342 } catch (SettingNotFoundException e1) { 2343 } 2344 return false; 2345 } 2346 2347 private void setUserSettingSetInstallLocation(boolean value) { 2348 Settings.System.putInt(mContext.getContentResolver(), 2349 Settings.Secure.SET_INSTALL_LOCATION, value ? 1 : 0); 2350 } 2351 private void setUserX(boolean enable, int userSetting, int iloc) { 2352 boolean origUserSetting = getUserSettingSetInstallLocation(); 2353 int origSetting = getDefaultInstallLoc(); 2354 try { 2355 setUserSettingSetInstallLocation(enable); 2356 // Set user setting 2357 setInstallLoc(userSetting); 2358 // Replace now 2359 installFromRawResource("install.apk", R.raw.install, 2360 0, 2361 true, 2362 false, -1, 2363 iloc); 2364 } finally { 2365 // Restore original setting 2366 setUserSettingSetInstallLocation(origUserSetting); 2367 setInstallLoc(origSetting); 2368 } 2369 } 2370 @LargeTest 2371 public void testUserI() { 2372 int userSetting = PackageHelper.APP_INSTALL_INTERNAL; 2373 int iloc = getExpectedInstallLocation(userSetting); 2374 setUserX(true, userSetting, iloc); 2375 } 2376 2377 @LargeTest 2378 public void testUserE() { 2379 // Do not run on devices with emulated external storage. 2380 if (Environment.isExternalStorageEmulated()) { 2381 return; 2382 } 2383 2384 int userSetting = PackageHelper.APP_INSTALL_EXTERNAL; 2385 int iloc = getExpectedInstallLocation(userSetting); 2386 setUserX(true, userSetting, iloc); 2387 } 2388 2389 @LargeTest 2390 public void testUserA() { 2391 int userSetting = PackageHelper.APP_INSTALL_AUTO; 2392 int iloc = getExpectedInstallLocation(userSetting); 2393 setUserX(true, userSetting, iloc); 2394 } 2395 /* 2396 * The following set of tests turn on/off the basic 2397 * user setting for turning on install location. 2398 */ 2399 @LargeTest 2400 public void testUserPrefOffUserI() { 2401 int userSetting = PackageHelper.APP_INSTALL_INTERNAL; 2402 int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 2403 setUserX(false, userSetting, iloc); 2404 } 2405 2406 @LargeTest 2407 public void testUserPrefOffUserE() { 2408 // Do not run on devices with emulated external storage. 2409 if (Environment.isExternalStorageEmulated()) { 2410 return; 2411 } 2412 2413 int userSetting = PackageHelper.APP_INSTALL_EXTERNAL; 2414 int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 2415 setUserX(false, userSetting, iloc); 2416 } 2417 2418 @LargeTest 2419 public void testUserPrefOffA() { 2420 int userSetting = PackageHelper.APP_INSTALL_AUTO; 2421 int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 2422 setUserX(false, userSetting, iloc); 2423 } 2424 2425 static final String BASE_PERMISSIONS_DEFINED[] = new String[] { 2426 PERM_PACKAGE, "com.android.unit_tests.install_decl_perm", 2427 PERM_DEFINED, 2428 "com.android.frameworks.coretests.NORMAL", 2429 "com.android.frameworks.coretests.DANGEROUS", 2430 "com.android.frameworks.coretests.SIGNATURE", 2431 }; 2432 2433 static final String BASE_PERMISSIONS_UNDEFINED[] = new String[] { 2434 PERM_PACKAGE, "com.android.frameworks.coretests.install_decl_perm", 2435 PERM_UNDEFINED, 2436 "com.android.frameworks.coretests.NORMAL", 2437 "com.android.frameworks.coretests.DANGEROUS", 2438 "com.android.frameworks.coretests.SIGNATURE", 2439 }; 2440 2441 static final String BASE_PERMISSIONS_USED[] = new String[] { 2442 PERM_PACKAGE, "com.android.frameworks.coretests.install_use_perm_good", 2443 PERM_USED, 2444 "com.android.frameworks.coretests.NORMAL", 2445 "com.android.frameworks.coretests.DANGEROUS", 2446 "com.android.frameworks.coretests.SIGNATURE", 2447 }; 2448 2449 static final String BASE_PERMISSIONS_NOTUSED[] = new String[] { 2450 PERM_PACKAGE, "com.android.frameworks.coretests.install_use_perm_good", 2451 PERM_NOTUSED, 2452 "com.android.frameworks.coretests.NORMAL", 2453 "com.android.frameworks.coretests.DANGEROUS", 2454 "com.android.frameworks.coretests.SIGNATURE", 2455 }; 2456 2457 static final String BASE_PERMISSIONS_SIGUSED[] = new String[] { 2458 PERM_PACKAGE, "com.android.frameworks.coretests.install_use_perm_good", 2459 PERM_USED, 2460 "com.android.frameworks.coretests.SIGNATURE", 2461 PERM_NOTUSED, 2462 "com.android.frameworks.coretests.NORMAL", 2463 "com.android.frameworks.coretests.DANGEROUS", 2464 }; 2465 2466 /* 2467 * Ensure that permissions are properly declared. 2468 */ 2469 @LargeTest 2470 public void testInstallDeclaresPermissions() { 2471 InstallParams ip = null; 2472 InstallParams ip2 = null; 2473 try { 2474 // **: Upon installing a package, are its declared permissions published? 2475 2476 int iFlags = PackageManager.INSTALL_INTERNAL; 2477 int iApk = R.raw.install_decl_perm; 2478 ip = installFromRawResource("install.apk", iApk, 2479 iFlags, false, 2480 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2481 assertInstall(ip.pkg, iFlags, ip.pkg.installLocation); 2482 assertPermissions(BASE_PERMISSIONS_DEFINED); 2483 2484 // **: Upon installing package, are its permissions granted? 2485 2486 int i2Flags = PackageManager.INSTALL_INTERNAL; 2487 int i2Apk = R.raw.install_use_perm_good; 2488 ip2 = installFromRawResource("install2.apk", i2Apk, 2489 i2Flags, false, 2490 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2491 assertInstall(ip2.pkg, i2Flags, ip2.pkg.installLocation); 2492 assertPermissions(BASE_PERMISSIONS_USED); 2493 2494 // **: Upon removing but not deleting, are permissions retained? 2495 2496 GenericReceiver receiver = new DeleteReceiver(ip.pkg.packageName); 2497 2498 try { 2499 invokeDeletePackage(ip.pkg.packageName, PackageManager.DONT_DELETE_DATA, receiver); 2500 } catch (Exception e) { 2501 failStr(e); 2502 } 2503 assertPermissions(BASE_PERMISSIONS_DEFINED); 2504 assertPermissions(BASE_PERMISSIONS_USED); 2505 2506 // **: Upon re-installing, are permissions retained? 2507 2508 ip = installFromRawResource("install.apk", iApk, 2509 iFlags | PackageManager.INSTALL_REPLACE_EXISTING, false, 2510 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2511 assertInstall(ip.pkg, iFlags, ip.pkg.installLocation); 2512 assertPermissions(BASE_PERMISSIONS_DEFINED); 2513 assertPermissions(BASE_PERMISSIONS_USED); 2514 2515 // **: Upon deleting package, are all permissions removed? 2516 2517 try { 2518 invokeDeletePackage(ip.pkg.packageName, 0, receiver); 2519 ip = null; 2520 } catch (Exception e) { 2521 failStr(e); 2522 } 2523 assertPermissions(BASE_PERMISSIONS_UNDEFINED); 2524 assertPermissions(BASE_PERMISSIONS_NOTUSED); 2525 2526 // **: Delete package using permissions; nothing to check here. 2527 2528 GenericReceiver receiver2 = new DeleteReceiver(ip2.pkg.packageName); 2529 try { 2530 invokeDeletePackage(ip2.pkg.packageName, 0, receiver); 2531 ip2 = null; 2532 } catch (Exception e) { 2533 failStr(e); 2534 } 2535 2536 // **: Re-install package using permissions; no permissions can be granted. 2537 2538 ip2 = installFromRawResource("install2.apk", i2Apk, 2539 i2Flags, false, 2540 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2541 assertInstall(ip2.pkg, i2Flags, ip2.pkg.installLocation); 2542 assertPermissions(BASE_PERMISSIONS_NOTUSED); 2543 2544 // **: Upon installing declaring package, are sig permissions granted 2545 // to other apps (but not other perms)? 2546 2547 ip = installFromRawResource("install.apk", iApk, 2548 iFlags, false, 2549 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2550 assertInstall(ip.pkg, iFlags, ip.pkg.installLocation); 2551 assertPermissions(BASE_PERMISSIONS_DEFINED); 2552 assertPermissions(BASE_PERMISSIONS_SIGUSED); 2553 2554 // **: Re-install package using permissions; are all permissions granted? 2555 2556 ip2 = installFromRawResource("install2.apk", i2Apk, 2557 i2Flags | PackageManager.INSTALL_REPLACE_EXISTING, false, 2558 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2559 assertInstall(ip2.pkg, i2Flags, ip2.pkg.installLocation); 2560 assertPermissions(BASE_PERMISSIONS_NOTUSED); 2561 2562 // **: Upon deleting package, are all permissions removed? 2563 2564 try { 2565 invokeDeletePackage(ip.pkg.packageName, 0, receiver); 2566 ip = null; 2567 } catch (Exception e) { 2568 failStr(e); 2569 } 2570 assertPermissions(BASE_PERMISSIONS_UNDEFINED); 2571 assertPermissions(BASE_PERMISSIONS_NOTUSED); 2572 2573 // **: Delete package using permissions; nothing to check here. 2574 2575 try { 2576 invokeDeletePackage(ip2.pkg.packageName, 0, receiver); 2577 ip2 = null; 2578 } catch (Exception e) { 2579 failStr(e); 2580 } 2581 2582 } finally { 2583 if (ip2 != null) { 2584 cleanUpInstall(ip2); 2585 } 2586 if (ip != null) { 2587 cleanUpInstall(ip); 2588 } 2589 } 2590 } 2591 2592 /* 2593 * Ensure that permissions are properly declared. 2594 */ 2595 @LargeTest 2596 public void testInstallOnSdPermissionsUnmount() { 2597 InstallParams ip = null; 2598 boolean origMediaState = checkMediaState(Environment.MEDIA_MOUNTED); 2599 try { 2600 // **: Upon installing a package, are its declared permissions published? 2601 int iFlags = PackageManager.INSTALL_INTERNAL; 2602 int iApk = R.raw.install_decl_perm; 2603 ip = installFromRawResource("install.apk", iApk, 2604 iFlags, false, 2605 false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2606 assertInstall(ip.pkg, iFlags, ip.pkg.installLocation); 2607 assertPermissions(BASE_PERMISSIONS_DEFINED); 2608 // Unmount media here 2609 assertTrue(unmountMedia()); 2610 // Mount media again 2611 mountMedia(); 2612 //Check permissions now 2613 assertPermissions(BASE_PERMISSIONS_DEFINED); 2614 } finally { 2615 if (ip != null) { 2616 cleanUpInstall(ip); 2617 } 2618 } 2619 } 2620 2621 /* This test creates a stale container via MountService and then installs 2622 * a package and verifies that the stale container is cleaned up and install 2623 * is successful. 2624 * Please note that this test is very closely tied to the framework's 2625 * naming convention for secure containers. 2626 */ 2627 @LargeTest 2628 public void testInstallSdcardStaleContainer() { 2629 // Do not run on devices with emulated external storage. 2630 if (Environment.isExternalStorageEmulated()) { 2631 return; 2632 } 2633 2634 boolean origMediaState = checkMediaState(Environment.MEDIA_MOUNTED); 2635 try { 2636 // Mount media first 2637 mountMedia(); 2638 String outFileName = "install.apk"; 2639 int rawResId = R.raw.install; 2640 PackageManager pm = mContext.getPackageManager(); 2641 File filesDir = mContext.getFilesDir(); 2642 File outFile = new File(filesDir, outFileName); 2643 Uri packageURI = getInstallablePackage(rawResId, outFile); 2644 PackageParser.Package pkg = parsePackage(packageURI); 2645 assertNotNull(pkg); 2646 // Install an app on sdcard. 2647 installFromRawResource(outFileName, rawResId, 2648 PackageManager.INSTALL_EXTERNAL, false, 2649 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2650 // Unmount sdcard 2651 unmountMedia(); 2652 // Delete the app on sdcard to leave a stale container on sdcard. 2653 GenericReceiver receiver = new DeleteReceiver(pkg.packageName); 2654 assertTrue(invokeDeletePackage(pkg.packageName, 0, receiver)); 2655 mountMedia(); 2656 // Reinstall the app and make sure it gets installed. 2657 installFromRawResource(outFileName, rawResId, 2658 PackageManager.INSTALL_EXTERNAL, true, 2659 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2660 } catch (Exception e) { 2661 failStr(e.getMessage()); 2662 } finally { 2663 if (origMediaState) { 2664 mountMedia(); 2665 } else { 2666 unmountMedia(); 2667 } 2668 2669 } 2670 } 2671 2672 /* This test installs an application on sdcard and unmounts media. 2673 * The app is then re-installed on internal storage. The sdcard is mounted 2674 * and verified that the re-installation on internal storage takes precedence. 2675 */ 2676 @LargeTest 2677 public void testInstallSdcardStaleContainerReinstall() { 2678 // Do not run on devices with emulated external storage. 2679 if (Environment.isExternalStorageEmulated()) { 2680 return; 2681 } 2682 2683 boolean origMediaState = checkMediaState(Environment.MEDIA_MOUNTED); 2684 try { 2685 // Mount media first 2686 mountMedia(); 2687 String outFileName = "install.apk"; 2688 int rawResId = R.raw.install; 2689 PackageManager pm = mContext.getPackageManager(); 2690 File filesDir = mContext.getFilesDir(); 2691 File outFile = new File(filesDir, outFileName); 2692 Uri packageURI = getInstallablePackage(rawResId, outFile); 2693 PackageParser.Package pkg = parsePackage(packageURI); 2694 assertNotNull(pkg); 2695 // Install an app on sdcard. 2696 installFromRawResource(outFileName, rawResId, 2697 PackageManager.INSTALL_EXTERNAL, false, 2698 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2699 // Unmount sdcard 2700 unmountMedia(); 2701 // Reinstall the app and make sure it gets installed on internal storage. 2702 installFromRawResource(outFileName, rawResId, 2703 PackageManager.INSTALL_REPLACE_EXISTING, false, 2704 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2705 mountMedia(); 2706 // Verify that the app installed is on internal storage. 2707 assertInstall(pkg, 0, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY); 2708 } catch (Exception e) { 2709 failStr(e.getMessage()); 2710 } finally { 2711 if (origMediaState) { 2712 mountMedia(); 2713 } else { 2714 unmountMedia(); 2715 } 2716 } 2717 } 2718 2719 /* 2720 * The following series of tests are related to upgrading apps with 2721 * different certificates. 2722 */ 2723 private int APP1_UNSIGNED = R.raw.install_app1_unsigned; 2724 private int APP1_CERT1 = R.raw.install_app1_cert1; 2725 private int APP1_CERT2 = R.raw.install_app1_cert2; 2726 private int APP1_CERT1_CERT2 = R.raw.install_app1_cert1_cert2; 2727 private int APP1_CERT3_CERT4 = R.raw.install_app1_cert3_cert4; 2728 private int APP1_CERT3 = R.raw.install_app1_cert3; 2729 private int APP2_UNSIGNED = R.raw.install_app2_unsigned; 2730 private int APP2_CERT1 = R.raw.install_app2_cert1; 2731 private int APP2_CERT2 = R.raw.install_app2_cert2; 2732 private int APP2_CERT1_CERT2 = R.raw.install_app2_cert1_cert2; 2733 private int APP2_CERT3 = R.raw.install_app2_cert3; 2734 2735 private InstallParams replaceCerts(int apk1, int apk2, boolean cleanUp, boolean fail, int retCode) { 2736 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2737 String apk1Name = "install1.apk"; 2738 String apk2Name = "install2.apk"; 2739 PackageParser.Package pkg1 = getParsedPackage(apk1Name, apk1); 2740 try { 2741 InstallParams ip = installFromRawResource(apk1Name, apk1, 0, false, 2742 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2743 installFromRawResource(apk2Name, apk2, rFlags, false, 2744 fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2745 return ip; 2746 } catch (Exception e) { 2747 failStr(e.getMessage()); 2748 } finally { 2749 if (cleanUp) { 2750 cleanUpInstall(pkg1.packageName); 2751 } 2752 } 2753 return null; 2754 } 2755 /* 2756 * Test that an app signed with two certificates can be upgraded by the 2757 * same app signed with two certificates. 2758 */ 2759 @LargeTest 2760 public void testReplaceMatchAllCerts() { 2761 replaceCerts(APP1_CERT1_CERT2, APP1_CERT1_CERT2, true, false, -1); 2762 } 2763 2764 /* 2765 * Test that an app signed with two certificates cannot be upgraded 2766 * by an app signed with a different certificate. 2767 */ 2768 @LargeTest 2769 public void testReplaceMatchNoCerts1() { 2770 replaceCerts(APP1_CERT1_CERT2, APP1_CERT3, true, true, 2771 PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES); 2772 } 2773 /* 2774 * Test that an app signed with two certificates cannot be upgraded 2775 * by an app signed with a different certificate. 2776 */ 2777 @LargeTest 2778 public void testReplaceMatchNoCerts2() { 2779 replaceCerts(APP1_CERT1_CERT2, APP1_CERT3_CERT4, true, true, 2780 PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES); 2781 } 2782 /* 2783 * Test that an app signed with two certificates cannot be upgraded by 2784 * an app signed with a subset of initial certificates. 2785 */ 2786 @LargeTest 2787 public void testReplaceMatchSomeCerts1() { 2788 replaceCerts(APP1_CERT1_CERT2, APP1_CERT1, true, true, 2789 PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES); 2790 } 2791 /* 2792 * Test that an app signed with two certificates cannot be upgraded by 2793 * an app signed with the last certificate. 2794 */ 2795 @LargeTest 2796 public void testReplaceMatchSomeCerts2() { 2797 replaceCerts(APP1_CERT1_CERT2, APP1_CERT2, true, true, 2798 PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES); 2799 } 2800 /* 2801 * Test that an app signed with a certificate can be upgraded by app 2802 * signed with a superset of certificates. 2803 */ 2804 @LargeTest 2805 public void testReplaceMatchMoreCerts() { 2806 replaceCerts(APP1_CERT1, APP1_CERT1_CERT2, true, true, 2807 PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES); 2808 } 2809 /* 2810 * Test that an app signed with a certificate can be upgraded by app 2811 * signed with a superset of certificates. Then verify that the an app 2812 * signed with the original set of certs cannot upgrade the new one. 2813 */ 2814 @LargeTest 2815 public void testReplaceMatchMoreCertsReplaceSomeCerts() { 2816 InstallParams ip = replaceCerts(APP1_CERT1, APP1_CERT1_CERT2, false, true, 2817 PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES); 2818 try { 2819 int rFlags = PackageManager.INSTALL_REPLACE_EXISTING; 2820 installFromRawResource("install.apk", APP1_CERT1, rFlags, false, 2821 false, -1, 2822 PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2823 } catch (Exception e) { 2824 failStr(e.getMessage()); 2825 } finally { 2826 if (ip != null) { 2827 cleanUpInstall(ip); 2828 } 2829 } 2830 } 2831 /* 2832 * The following tests are related to testing the checkSignatures 2833 * api. 2834 */ 2835 private void checkSignatures(int apk1, int apk2, int expMatchResult) { 2836 checkSharedSignatures(apk1, apk2, true, false, -1, expMatchResult); 2837 } 2838 @LargeTest 2839 public void testCheckSignaturesAllMatch() { 2840 int apk1 = APP1_CERT1_CERT2; 2841 int apk2 = APP2_CERT1_CERT2; 2842 checkSignatures(apk1, apk2, PackageManager.SIGNATURE_MATCH); 2843 } 2844 @LargeTest 2845 public void testCheckSignaturesNoMatch() { 2846 int apk1 = APP1_CERT1; 2847 int apk2 = APP2_CERT2; 2848 checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH); 2849 } 2850 @LargeTest 2851 public void testCheckSignaturesSomeMatch1() { 2852 int apk1 = APP1_CERT1_CERT2; 2853 int apk2 = APP2_CERT1; 2854 checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH); 2855 } 2856 @LargeTest 2857 public void testCheckSignaturesSomeMatch2() { 2858 int apk1 = APP1_CERT1_CERT2; 2859 int apk2 = APP2_CERT2; 2860 checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH); 2861 } 2862 @LargeTest 2863 public void testCheckSignaturesMoreMatch() { 2864 int apk1 = APP1_CERT1; 2865 int apk2 = APP2_CERT1_CERT2; 2866 checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH); 2867 } 2868 @LargeTest 2869 public void testCheckSignaturesUnknown() { 2870 int apk1 = APP1_CERT1_CERT2; 2871 int apk2 = APP2_CERT1_CERT2; 2872 String apk1Name = "install1.apk"; 2873 String apk2Name = "install2.apk"; 2874 InstallParams ip1 = null; 2875 2876 try { 2877 ip1 = installFromRawResource(apk1Name, apk1, 0, false, 2878 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2879 PackageManager pm = mContext.getPackageManager(); 2880 // Delete app2 2881 File filesDir = mContext.getFilesDir(); 2882 File outFile = new File(filesDir, apk2Name); 2883 int rawResId = apk2; 2884 Uri packageURI = getInstallablePackage(rawResId, outFile); 2885 PackageParser.Package pkg = parsePackage(packageURI); 2886 getPm().deletePackage(pkg.packageName, null, 0); 2887 // Check signatures now 2888 int match = mContext.getPackageManager().checkSignatures( 2889 ip1.pkg.packageName, pkg.packageName); 2890 assertEquals(PackageManager.SIGNATURE_UNKNOWN_PACKAGE, match); 2891 } finally { 2892 if (ip1 != null) { 2893 cleanUpInstall(ip1); 2894 } 2895 } 2896 } 2897 @LargeTest 2898 public void testInstallNoCertificates() { 2899 int apk1 = APP1_UNSIGNED; 2900 String apk1Name = "install1.apk"; 2901 InstallParams ip1 = null; 2902 2903 try { 2904 installFromRawResource(apk1Name, apk1, 0, false, 2905 true, PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES, 2906 PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2907 } finally { 2908 } 2909 } 2910 /* The following tests are related to apps using shared uids signed 2911 * with different certs. 2912 */ 2913 private int SHARED1_UNSIGNED = R.raw.install_shared1_unsigned; 2914 private int SHARED1_CERT1 = R.raw.install_shared1_cert1; 2915 private int SHARED1_CERT2 = R.raw.install_shared1_cert2; 2916 private int SHARED1_CERT1_CERT2 = R.raw.install_shared1_cert1_cert2; 2917 private int SHARED2_UNSIGNED = R.raw.install_shared2_unsigned; 2918 private int SHARED2_CERT1 = R.raw.install_shared2_cert1; 2919 private int SHARED2_CERT2 = R.raw.install_shared2_cert2; 2920 private int SHARED2_CERT1_CERT2 = R.raw.install_shared2_cert1_cert2; 2921 private void checkSharedSignatures(int apk1, int apk2, boolean cleanUp, boolean fail, int retCode, int expMatchResult) { 2922 String apk1Name = "install1.apk"; 2923 String apk2Name = "install2.apk"; 2924 PackageParser.Package pkg1 = getParsedPackage(apk1Name, apk1); 2925 PackageParser.Package pkg2 = getParsedPackage(apk2Name, apk2); 2926 2927 try { 2928 // Clean up before testing first. 2929 cleanUpInstall(pkg1.packageName); 2930 cleanUpInstall(pkg2.packageName); 2931 installFromRawResource(apk1Name, apk1, 0, false, 2932 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2933 if (fail) { 2934 installFromRawResource(apk2Name, apk2, 0, false, 2935 true, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2936 } else { 2937 installFromRawResource(apk2Name, apk2, 0, false, 2938 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 2939 int match = mContext.getPackageManager().checkSignatures( 2940 pkg1.packageName, pkg2.packageName); 2941 assertEquals(expMatchResult, match); 2942 } 2943 } finally { 2944 if (cleanUp) { 2945 cleanUpInstall(pkg1.packageName); 2946 cleanUpInstall(pkg2.packageName); 2947 } 2948 } 2949 } 2950 @LargeTest 2951 public void testCheckSignaturesSharedAllMatch() { 2952 int apk1 = SHARED1_CERT1_CERT2; 2953 int apk2 = SHARED2_CERT1_CERT2; 2954 boolean fail = false; 2955 int retCode = -1; 2956 int expMatchResult = PackageManager.SIGNATURE_MATCH; 2957 checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult); 2958 } 2959 @LargeTest 2960 public void testCheckSignaturesSharedNoMatch() { 2961 int apk1 = SHARED1_CERT1; 2962 int apk2 = SHARED2_CERT2; 2963 boolean fail = true; 2964 int retCode = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE; 2965 int expMatchResult = -1; 2966 checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult); 2967 } 2968 /* 2969 * Test that an app signed with cert1 and cert2 cannot be replaced when signed with cert1 alone. 2970 */ 2971 @LargeTest 2972 public void testCheckSignaturesSharedSomeMatch1() { 2973 int apk1 = SHARED1_CERT1_CERT2; 2974 int apk2 = SHARED2_CERT1; 2975 boolean fail = true; 2976 int retCode = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE; 2977 int expMatchResult = -1; 2978 checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult); 2979 } 2980 /* 2981 * Test that an app signed with cert1 and cert2 cannot be replaced when signed with cert2 alone. 2982 */ 2983 @LargeTest 2984 public void testCheckSignaturesSharedSomeMatch2() { 2985 int apk1 = SHARED1_CERT1_CERT2; 2986 int apk2 = SHARED2_CERT2; 2987 boolean fail = true; 2988 int retCode = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE; 2989 int expMatchResult = -1; 2990 checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult); 2991 } 2992 @LargeTest 2993 public void testCheckSignaturesSharedUnknown() { 2994 int apk1 = SHARED1_CERT1_CERT2; 2995 int apk2 = SHARED2_CERT1_CERT2; 2996 String apk1Name = "install1.apk"; 2997 String apk2Name = "install2.apk"; 2998 InstallParams ip1 = null; 2999 3000 try { 3001 ip1 = installFromRawResource(apk1Name, apk1, 0, false, 3002 false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3003 PackageManager pm = mContext.getPackageManager(); 3004 // Delete app2 3005 PackageParser.Package pkg = getParsedPackage(apk2Name, apk2); 3006 getPm().deletePackage(pkg.packageName, null, 0); 3007 // Check signatures now 3008 int match = mContext.getPackageManager().checkSignatures( 3009 ip1.pkg.packageName, pkg.packageName); 3010 assertEquals(PackageManager.SIGNATURE_UNKNOWN_PACKAGE, match); 3011 } finally { 3012 if (ip1 != null) { 3013 cleanUpInstall(ip1); 3014 } 3015 } 3016 } 3017 3018 @LargeTest 3019 public void testReplaceFirstSharedMatchAllCerts() { 3020 int apk1 = SHARED1_CERT1; 3021 int apk2 = SHARED2_CERT1; 3022 int rapk1 = SHARED1_CERT1; 3023 checkSignatures(apk1, apk2, PackageManager.SIGNATURE_MATCH); 3024 replaceCerts(apk1, rapk1, true, false, -1); 3025 } 3026 @LargeTest 3027 public void testReplaceSecondSharedMatchAllCerts() { 3028 int apk1 = SHARED1_CERT1; 3029 int apk2 = SHARED2_CERT1; 3030 int rapk2 = SHARED2_CERT1; 3031 checkSignatures(apk1, apk2, PackageManager.SIGNATURE_MATCH); 3032 replaceCerts(apk2, rapk2, true, false, -1); 3033 } 3034 @LargeTest 3035 public void testReplaceFirstSharedMatchSomeCerts() { 3036 int apk1 = SHARED1_CERT1_CERT2; 3037 int apk2 = SHARED2_CERT1_CERT2; 3038 int rapk1 = SHARED1_CERT1; 3039 boolean fail = true; 3040 int retCode = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; 3041 checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH); 3042 installFromRawResource("install.apk", rapk1, PackageManager.INSTALL_REPLACE_EXISTING, true, 3043 fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3044 } 3045 @LargeTest 3046 public void testReplaceSecondSharedMatchSomeCerts() { 3047 int apk1 = SHARED1_CERT1_CERT2; 3048 int apk2 = SHARED2_CERT1_CERT2; 3049 int rapk2 = SHARED2_CERT1; 3050 boolean fail = true; 3051 int retCode = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; 3052 checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH); 3053 installFromRawResource("install.apk", rapk2, PackageManager.INSTALL_REPLACE_EXISTING, true, 3054 fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3055 } 3056 @LargeTest 3057 public void testReplaceFirstSharedMatchNoCerts() { 3058 int apk1 = SHARED1_CERT1; 3059 int apk2 = SHARED2_CERT1; 3060 int rapk1 = SHARED1_CERT2; 3061 boolean fail = true; 3062 int retCode = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; 3063 checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH); 3064 installFromRawResource("install.apk", rapk1, PackageManager.INSTALL_REPLACE_EXISTING, true, 3065 fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3066 } 3067 @LargeTest 3068 public void testReplaceSecondSharedMatchNoCerts() { 3069 int apk1 = SHARED1_CERT1; 3070 int apk2 = SHARED2_CERT1; 3071 int rapk2 = SHARED2_CERT2; 3072 boolean fail = true; 3073 int retCode = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; 3074 checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH); 3075 installFromRawResource("install.apk", rapk2, PackageManager.INSTALL_REPLACE_EXISTING, true, 3076 fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3077 } 3078 @LargeTest 3079 public void testReplaceFirstSharedMatchMoreCerts() { 3080 int apk1 = SHARED1_CERT1; 3081 int apk2 = SHARED2_CERT1; 3082 int rapk1 = SHARED1_CERT1_CERT2; 3083 boolean fail = true; 3084 int retCode = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; 3085 checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH); 3086 installFromRawResource("install.apk", rapk1, PackageManager.INSTALL_REPLACE_EXISTING, true, 3087 fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3088 } 3089 @LargeTest 3090 public void testReplaceSecondSharedMatchMoreCerts() { 3091 int apk1 = SHARED1_CERT1; 3092 int apk2 = SHARED2_CERT1; 3093 int rapk2 = SHARED2_CERT1_CERT2; 3094 boolean fail = true; 3095 int retCode = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; 3096 checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH); 3097 installFromRawResource("install.apk", rapk2, PackageManager.INSTALL_REPLACE_EXISTING, true, 3098 fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3099 } 3100 3101 /** 3102 * Unknown features should be allowed to install. This prevents older phones 3103 * from rejecting new packages that specify features that didn't exist when 3104 * an older phone existed. All older phones are assumed to have those 3105 * features. 3106 * <p> 3107 * Right now we allow all packages to be installed regardless of their 3108 * features. 3109 */ 3110 @LargeTest 3111 public void testUsesFeatureUnknownFeature() { 3112 int retCode = PackageManager.INSTALL_SUCCEEDED; 3113 installFromRawResource("install.apk", R.raw.install_uses_feature, 0, true, false, retCode, 3114 PackageInfo.INSTALL_LOCATION_UNSPECIFIED); 3115 } 3116 3117 /*---------- Recommended install location tests ----*/ 3118 /* 3119 * TODO's 3120 * check version numbers for upgrades 3121 * check permissions of installed packages 3122 * how to do tests on updated system apps? 3123 * verify updates to system apps cannot be installed on the sdcard. 3124 */ 3125} 3126