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 17 package android.content.pm; 18 19 import android.annotation.SdkConstant; 20 import android.annotation.SdkConstant.SdkConstantType; 21 import android.content.ComponentName; 22 import android.content.Context; 23 import android.content.Intent; 24 import android.content.IntentFilter; 25 import android.content.IntentSender; 26 import android.content.res.Resources; 27 import android.content.res.XmlResourceParser; 28 import android.graphics.drawable.Drawable; 29 import android.net.Uri; 30 import android.os.Environment; 31 import android.os.UserHandle; 32 import android.util.AndroidException; 33 import android.util.DisplayMetrics; 34 35 import java.io.File; 36 import java.util.List; 37 38 /** 39 * Class for retrieving various kinds of information related to the application 40 * packages that are currently installed on the device. 41 * 42 * You can find this class through {@link Context#getPackageManager}. 43 */ 44 public abstract class PackageManager { 45 46 /** 47 * This exception is thrown when a given package, application, or component 48 * name can not be found. 49 */ 50 public static class NameNotFoundException extends AndroidException { NameNotFoundException()51 public NameNotFoundException() { 52 } 53 NameNotFoundException(String name)54 public NameNotFoundException(String name) { 55 super(name); 56 } 57 } 58 59 /** 60 * {@link PackageInfo} flag: return information about 61 * activities in the package in {@link PackageInfo#activities}. 62 */ 63 public static final int GET_ACTIVITIES = 0x00000001; 64 65 /** 66 * {@link PackageInfo} flag: return information about 67 * intent receivers in the package in 68 * {@link PackageInfo#receivers}. 69 */ 70 public static final int GET_RECEIVERS = 0x00000002; 71 72 /** 73 * {@link PackageInfo} flag: return information about 74 * services in the package in {@link PackageInfo#services}. 75 */ 76 public static final int GET_SERVICES = 0x00000004; 77 78 /** 79 * {@link PackageInfo} flag: return information about 80 * content providers in the package in 81 * {@link PackageInfo#providers}. 82 */ 83 public static final int GET_PROVIDERS = 0x00000008; 84 85 /** 86 * {@link PackageInfo} flag: return information about 87 * instrumentation in the package in 88 * {@link PackageInfo#instrumentation}. 89 */ 90 public static final int GET_INSTRUMENTATION = 0x00000010; 91 92 /** 93 * {@link PackageInfo} flag: return information about the 94 * intent filters supported by the activity. 95 */ 96 public static final int GET_INTENT_FILTERS = 0x00000020; 97 98 /** 99 * {@link PackageInfo} flag: return information about the 100 * signatures included in the package. 101 */ 102 public static final int GET_SIGNATURES = 0x00000040; 103 104 /** 105 * {@link ResolveInfo} flag: return the IntentFilter that 106 * was matched for a particular ResolveInfo in 107 * {@link ResolveInfo#filter}. 108 */ 109 public static final int GET_RESOLVED_FILTER = 0x00000040; 110 111 /** 112 * {@link ComponentInfo} flag: return the {@link ComponentInfo#metaData} 113 * data {@link android.os.Bundle}s that are associated with a component. 114 * This applies for any API returning a ComponentInfo subclass. 115 */ 116 public static final int GET_META_DATA = 0x00000080; 117 118 /** 119 * {@link PackageInfo} flag: return the 120 * {@link PackageInfo#gids group ids} that are associated with an 121 * application. 122 * This applies for any API returning a PackageInfo class, either 123 * directly or nested inside of another. 124 */ 125 public static final int GET_GIDS = 0x00000100; 126 127 /** 128 * {@link PackageInfo} flag: include disabled components in the returned info. 129 */ 130 public static final int GET_DISABLED_COMPONENTS = 0x00000200; 131 132 /** 133 * {@link ApplicationInfo} flag: return the 134 * {@link ApplicationInfo#sharedLibraryFiles paths to the shared libraries} 135 * that are associated with an application. 136 * This applies for any API returning an ApplicationInfo class, either 137 * directly or nested inside of another. 138 */ 139 public static final int GET_SHARED_LIBRARY_FILES = 0x00000400; 140 141 /** 142 * {@link ProviderInfo} flag: return the 143 * {@link ProviderInfo#uriPermissionPatterns URI permission patterns} 144 * that are associated with a content provider. 145 * This applies for any API returning a ProviderInfo class, either 146 * directly or nested inside of another. 147 */ 148 public static final int GET_URI_PERMISSION_PATTERNS = 0x00000800; 149 /** 150 * {@link PackageInfo} flag: return information about 151 * permissions in the package in 152 * {@link PackageInfo#permissions}. 153 */ 154 public static final int GET_PERMISSIONS = 0x00001000; 155 156 /** 157 * Flag parameter to retrieve some information about all applications (even 158 * uninstalled ones) which have data directories. This state could have 159 * resulted if applications have been deleted with flag 160 * {@code DONT_DELETE_DATA} with a possibility of being replaced or 161 * reinstalled in future. 162 * <p> 163 * Note: this flag may cause less information about currently installed 164 * applications to be returned. 165 */ 166 public static final int GET_UNINSTALLED_PACKAGES = 0x00002000; 167 168 /** 169 * {@link PackageInfo} flag: return information about 170 * hardware preferences in 171 * {@link PackageInfo#configPreferences PackageInfo.configPreferences} and 172 * requested features in {@link PackageInfo#reqFeatures 173 * PackageInfo.reqFeatures}. 174 */ 175 public static final int GET_CONFIGURATIONS = 0x00004000; 176 177 /** 178 * Resolution and querying flag: if set, only filters that support the 179 * {@link android.content.Intent#CATEGORY_DEFAULT} will be considered for 180 * matching. This is a synonym for including the CATEGORY_DEFAULT in your 181 * supplied Intent. 182 */ 183 public static final int MATCH_DEFAULT_ONLY = 0x00010000; 184 185 /** 186 * Permission check result: this is returned by {@link #checkPermission} 187 * if the permission has been granted to the given package. 188 */ 189 public static final int PERMISSION_GRANTED = 0; 190 191 /** 192 * Permission check result: this is returned by {@link #checkPermission} 193 * if the permission has not been granted to the given package. 194 */ 195 public static final int PERMISSION_DENIED = -1; 196 197 /** 198 * Signature check result: this is returned by {@link #checkSignatures} 199 * if all signatures on the two packages match. 200 */ 201 public static final int SIGNATURE_MATCH = 0; 202 203 /** 204 * Signature check result: this is returned by {@link #checkSignatures} 205 * if neither of the two packages is signed. 206 */ 207 public static final int SIGNATURE_NEITHER_SIGNED = 1; 208 209 /** 210 * Signature check result: this is returned by {@link #checkSignatures} 211 * if the first package is not signed but the second is. 212 */ 213 public static final int SIGNATURE_FIRST_NOT_SIGNED = -1; 214 215 /** 216 * Signature check result: this is returned by {@link #checkSignatures} 217 * if the second package is not signed but the first is. 218 */ 219 public static final int SIGNATURE_SECOND_NOT_SIGNED = -2; 220 221 /** 222 * Signature check result: this is returned by {@link #checkSignatures} 223 * if not all signatures on both packages match. 224 */ 225 public static final int SIGNATURE_NO_MATCH = -3; 226 227 /** 228 * Signature check result: this is returned by {@link #checkSignatures} 229 * if either of the packages are not valid. 230 */ 231 public static final int SIGNATURE_UNKNOWN_PACKAGE = -4; 232 233 /** 234 * Flag for {@link #setApplicationEnabledSetting(String, int, int)} 235 * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This 236 * component or application is in its default enabled state (as specified 237 * in its manifest). 238 */ 239 public static final int COMPONENT_ENABLED_STATE_DEFAULT = 0; 240 241 /** 242 * Flag for {@link #setApplicationEnabledSetting(String, int, int)} 243 * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This 244 * component or application has been explictily enabled, regardless of 245 * what it has specified in its manifest. 246 */ 247 public static final int COMPONENT_ENABLED_STATE_ENABLED = 1; 248 249 /** 250 * Flag for {@link #setApplicationEnabledSetting(String, int, int)} 251 * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This 252 * component or application has been explicitly disabled, regardless of 253 * what it has specified in its manifest. 254 */ 255 public static final int COMPONENT_ENABLED_STATE_DISABLED = 2; 256 257 /** 258 * Flag for {@link #setApplicationEnabledSetting(String, int, int)} only: The 259 * user has explicitly disabled the application, regardless of what it has 260 * specified in its manifest. Because this is due to the user's request, 261 * they may re-enable it if desired through the appropriate system UI. This 262 * option currently <strong>can not</strong> be used with 263 * {@link #setComponentEnabledSetting(ComponentName, int, int)}. 264 */ 265 public static final int COMPONENT_ENABLED_STATE_DISABLED_USER = 3; 266 267 /** 268 * Flag parameter for {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} to 269 * indicate that this package should be installed as forward locked, i.e. only the app itself 270 * should have access to its code and non-resource assets. 271 * @hide 272 */ 273 public static final int INSTALL_FORWARD_LOCK = 0x00000001; 274 275 /** 276 * Flag parameter for {@link #installPackage} to indicate that you want to replace an already 277 * installed package, if one exists. 278 * @hide 279 */ 280 public static final int INSTALL_REPLACE_EXISTING = 0x00000002; 281 282 /** 283 * Flag parameter for {@link #installPackage} to indicate that you want to 284 * allow test packages (those that have set android:testOnly in their 285 * manifest) to be installed. 286 * @hide 287 */ 288 public static final int INSTALL_ALLOW_TEST = 0x00000004; 289 290 /** 291 * Flag parameter for {@link #installPackage} to indicate that this 292 * package has to be installed on the sdcard. 293 * @hide 294 */ 295 public static final int INSTALL_EXTERNAL = 0x00000008; 296 297 /** 298 * Flag parameter for {@link #installPackage} to indicate that this package 299 * has to be installed on the sdcard. 300 * @hide 301 */ 302 public static final int INSTALL_INTERNAL = 0x00000010; 303 304 /** 305 * Flag parameter for {@link #installPackage} to indicate that this install 306 * was initiated via ADB. 307 * 308 * @hide 309 */ 310 public static final int INSTALL_FROM_ADB = 0x00000020; 311 312 /** 313 * Flag parameter for {@link #installPackage} to indicate that this install 314 * should immediately be visible to all users. 315 * 316 * @hide 317 */ 318 public static final int INSTALL_ALL_USERS = 0x00000040; 319 320 /** 321 * Flag parameter for {@link #installPackage} to indicate that it is okay 322 * to install an update to an app where the newly installed app has a lower 323 * version code than the currently installed app. 324 * 325 * @hide 326 */ 327 public static final int INSTALL_ALLOW_DOWNGRADE = 0x00000080; 328 329 /** 330 * Flag parameter for 331 * {@link #setComponentEnabledSetting(android.content.ComponentName, int, int)} to indicate 332 * that you don't want to kill the app containing the component. Be careful when you set this 333 * since changing component states can make the containing application's behavior unpredictable. 334 */ 335 public static final int DONT_KILL_APP = 0x00000001; 336 337 /** 338 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 339 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} on success. 340 * @hide 341 */ 342 public static final int INSTALL_SUCCEEDED = 1; 343 344 /** 345 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 346 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package is 347 * already installed. 348 * @hide 349 */ 350 public static final int INSTALL_FAILED_ALREADY_EXISTS = -1; 351 352 /** 353 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 354 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package archive 355 * file is invalid. 356 * @hide 357 */ 358 public static final int INSTALL_FAILED_INVALID_APK = -2; 359 360 /** 361 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 362 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the URI passed in 363 * is invalid. 364 * @hide 365 */ 366 public static final int INSTALL_FAILED_INVALID_URI = -3; 367 368 /** 369 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 370 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package manager 371 * service found that the device didn't have enough storage space to install the app. 372 * @hide 373 */ 374 public static final int INSTALL_FAILED_INSUFFICIENT_STORAGE = -4; 375 376 /** 377 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 378 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if a 379 * package is already installed with the same name. 380 * @hide 381 */ 382 public static final int INSTALL_FAILED_DUPLICATE_PACKAGE = -5; 383 384 /** 385 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 386 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 387 * the requested shared user does not exist. 388 * @hide 389 */ 390 public static final int INSTALL_FAILED_NO_SHARED_USER = -6; 391 392 /** 393 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 394 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 395 * a previously installed package of the same name has a different signature 396 * than the new package (and the old package's data was not removed). 397 * @hide 398 */ 399 public static final int INSTALL_FAILED_UPDATE_INCOMPATIBLE = -7; 400 401 /** 402 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 403 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 404 * the new package is requested a shared user which is already installed on the 405 * device and does not have matching signature. 406 * @hide 407 */ 408 public static final int INSTALL_FAILED_SHARED_USER_INCOMPATIBLE = -8; 409 410 /** 411 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 412 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 413 * the new package uses a shared library that is not available. 414 * @hide 415 */ 416 public static final int INSTALL_FAILED_MISSING_SHARED_LIBRARY = -9; 417 418 /** 419 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 420 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 421 * the new package uses a shared library that is not available. 422 * @hide 423 */ 424 public static final int INSTALL_FAILED_REPLACE_COULDNT_DELETE = -10; 425 426 /** 427 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 428 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 429 * the new package failed while optimizing and validating its dex files, 430 * either because there was not enough storage or the validation failed. 431 * @hide 432 */ 433 public static final int INSTALL_FAILED_DEXOPT = -11; 434 435 /** 436 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 437 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 438 * the new package failed because the current SDK version is older than 439 * that required by the package. 440 * @hide 441 */ 442 public static final int INSTALL_FAILED_OLDER_SDK = -12; 443 444 /** 445 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 446 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 447 * the new package failed because it contains a content provider with the 448 * same authority as a provider already installed in the system. 449 * @hide 450 */ 451 public static final int INSTALL_FAILED_CONFLICTING_PROVIDER = -13; 452 453 /** 454 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 455 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 456 * the new package failed because the current SDK version is newer than 457 * that required by the package. 458 * @hide 459 */ 460 public static final int INSTALL_FAILED_NEWER_SDK = -14; 461 462 /** 463 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 464 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 465 * the new package failed because it has specified that it is a test-only 466 * package and the caller has not supplied the {@link #INSTALL_ALLOW_TEST} 467 * flag. 468 * @hide 469 */ 470 public static final int INSTALL_FAILED_TEST_ONLY = -15; 471 472 /** 473 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 474 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 475 * the package being installed contains native code, but none that is 476 * compatible with the the device's CPU_ABI. 477 * @hide 478 */ 479 public static final int INSTALL_FAILED_CPU_ABI_INCOMPATIBLE = -16; 480 481 /** 482 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 483 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 484 * the new package uses a feature that is not available. 485 * @hide 486 */ 487 public static final int INSTALL_FAILED_MISSING_FEATURE = -17; 488 489 // ------ Errors related to sdcard 490 /** 491 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 492 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 493 * a secure container mount point couldn't be accessed on external media. 494 * @hide 495 */ 496 public static final int INSTALL_FAILED_CONTAINER_ERROR = -18; 497 498 /** 499 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 500 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 501 * the new package couldn't be installed in the specified install 502 * location. 503 * @hide 504 */ 505 public static final int INSTALL_FAILED_INVALID_INSTALL_LOCATION = -19; 506 507 /** 508 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 509 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 510 * the new package couldn't be installed in the specified install 511 * location because the media is not available. 512 * @hide 513 */ 514 public static final int INSTALL_FAILED_MEDIA_UNAVAILABLE = -20; 515 516 /** 517 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 518 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 519 * the new package couldn't be installed because the verification timed out. 520 * @hide 521 */ 522 public static final int INSTALL_FAILED_VERIFICATION_TIMEOUT = -21; 523 524 /** 525 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 526 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 527 * the new package couldn't be installed because the verification did not succeed. 528 * @hide 529 */ 530 public static final int INSTALL_FAILED_VERIFICATION_FAILURE = -22; 531 532 /** 533 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 534 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 535 * the package changed from what the calling program expected. 536 * @hide 537 */ 538 public static final int INSTALL_FAILED_PACKAGE_CHANGED = -23; 539 540 /** 541 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 542 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 543 * the new package is assigned a different UID than it previously held. 544 * @hide 545 */ 546 public static final int INSTALL_FAILED_UID_CHANGED = -24; 547 548 /** 549 * Installation return code: this is passed to the {@link IPackageInstallObserver} by 550 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if 551 * the new package has an older version code than the currently installed package. 552 * @hide 553 */ 554 public static final int INSTALL_FAILED_VERSION_DOWNGRADE = -25; 555 556 /** 557 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 558 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 559 * if the parser was given a path that is not a file, or does not end with the expected 560 * '.apk' extension. 561 * @hide 562 */ 563 public static final int INSTALL_PARSE_FAILED_NOT_APK = -100; 564 565 /** 566 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 567 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 568 * if the parser was unable to retrieve the AndroidManifest.xml file. 569 * @hide 570 */ 571 public static final int INSTALL_PARSE_FAILED_BAD_MANIFEST = -101; 572 573 /** 574 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 575 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 576 * if the parser encountered an unexpected exception. 577 * @hide 578 */ 579 public static final int INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION = -102; 580 581 /** 582 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 583 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 584 * if the parser did not find any certificates in the .apk. 585 * @hide 586 */ 587 public static final int INSTALL_PARSE_FAILED_NO_CERTIFICATES = -103; 588 589 /** 590 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 591 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 592 * if the parser found inconsistent certificates on the files in the .apk. 593 * @hide 594 */ 595 public static final int INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES = -104; 596 597 /** 598 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 599 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 600 * if the parser encountered a CertificateEncodingException in one of the 601 * files in the .apk. 602 * @hide 603 */ 604 public static final int INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING = -105; 605 606 /** 607 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 608 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 609 * if the parser encountered a bad or missing package name in the manifest. 610 * @hide 611 */ 612 public static final int INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME = -106; 613 614 /** 615 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 616 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 617 * if the parser encountered a bad shared user id name in the manifest. 618 * @hide 619 */ 620 public static final int INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID = -107; 621 622 /** 623 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 624 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 625 * if the parser encountered some structural problem in the manifest. 626 * @hide 627 */ 628 public static final int INSTALL_PARSE_FAILED_MANIFEST_MALFORMED = -108; 629 630 /** 631 * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by 632 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 633 * if the parser did not find any actionable tags (instrumentation or application) 634 * in the manifest. 635 * @hide 636 */ 637 public static final int INSTALL_PARSE_FAILED_MANIFEST_EMPTY = -109; 638 639 /** 640 * Installation failed return code: this is passed to the {@link IPackageInstallObserver} by 641 * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} 642 * if the system failed to install the package because of system issues. 643 * @hide 644 */ 645 public static final int INSTALL_FAILED_INTERNAL_ERROR = -110; 646 647 /** 648 * Flag parameter for {@link #deletePackage} to indicate that you don't want to delete the 649 * package's data directory. 650 * 651 * @hide 652 */ 653 public static final int DELETE_KEEP_DATA = 0x00000001; 654 655 /** 656 * Flag parameter for {@link #deletePackage} to indicate that you want the 657 * package deleted for all users. 658 * 659 * @hide 660 */ 661 public static final int DELETE_ALL_USERS = 0x00000002; 662 663 /** 664 * Return code for when package deletion succeeds. This is passed to the 665 * {@link IPackageDeleteObserver} by {@link #deletePackage()} if the system 666 * succeeded in deleting the package. 667 * 668 * @hide 669 */ 670 public static final int DELETE_SUCCEEDED = 1; 671 672 /** 673 * Deletion failed return code: this is passed to the 674 * {@link IPackageDeleteObserver} by {@link #deletePackage()} if the system 675 * failed to delete the package for an unspecified reason. 676 * 677 * @hide 678 */ 679 public static final int DELETE_FAILED_INTERNAL_ERROR = -1; 680 681 /** 682 * Deletion failed return code: this is passed to the 683 * {@link IPackageDeleteObserver} by {@link #deletePackage()} if the system 684 * failed to delete the package because it is the active DevicePolicy 685 * manager. 686 * 687 * @hide 688 */ 689 public static final int DELETE_FAILED_DEVICE_POLICY_MANAGER = -2; 690 691 /** 692 * Return code that is passed to the {@link IPackageMoveObserver} by 693 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} when the 694 * package has been successfully moved by the system. 695 * 696 * @hide 697 */ 698 public static final int MOVE_SUCCEEDED = 1; 699 /** 700 * Error code that is passed to the {@link IPackageMoveObserver} by 701 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} 702 * when the package hasn't been successfully moved by the system 703 * because of insufficient memory on specified media. 704 * @hide 705 */ 706 public static final int MOVE_FAILED_INSUFFICIENT_STORAGE = -1; 707 708 /** 709 * Error code that is passed to the {@link IPackageMoveObserver} by 710 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} 711 * if the specified package doesn't exist. 712 * @hide 713 */ 714 public static final int MOVE_FAILED_DOESNT_EXIST = -2; 715 716 /** 717 * Error code that is passed to the {@link IPackageMoveObserver} by 718 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} 719 * if the specified package cannot be moved since its a system package. 720 * @hide 721 */ 722 public static final int MOVE_FAILED_SYSTEM_PACKAGE = -3; 723 724 /** 725 * Error code that is passed to the {@link IPackageMoveObserver} by 726 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} 727 * if the specified package cannot be moved since its forward locked. 728 * @hide 729 */ 730 public static final int MOVE_FAILED_FORWARD_LOCKED = -4; 731 732 /** 733 * Error code that is passed to the {@link IPackageMoveObserver} by 734 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} 735 * if the specified package cannot be moved to the specified location. 736 * @hide 737 */ 738 public static final int MOVE_FAILED_INVALID_LOCATION = -5; 739 740 /** 741 * Error code that is passed to the {@link IPackageMoveObserver} by 742 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} 743 * if the specified package cannot be moved to the specified location. 744 * @hide 745 */ 746 public static final int MOVE_FAILED_INTERNAL_ERROR = -6; 747 748 /** 749 * Error code that is passed to the {@link IPackageMoveObserver} by 750 * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} if the 751 * specified package already has an operation pending in the 752 * {@link PackageHandler} queue. 753 * 754 * @hide 755 */ 756 public static final int MOVE_FAILED_OPERATION_PENDING = -7; 757 758 /** 759 * Flag parameter for {@link #movePackage} to indicate that 760 * the package should be moved to internal storage if its 761 * been installed on external media. 762 * @hide 763 */ 764 public static final int MOVE_INTERNAL = 0x00000001; 765 766 /** 767 * Flag parameter for {@link #movePackage} to indicate that 768 * the package should be moved to external media. 769 * @hide 770 */ 771 public static final int MOVE_EXTERNAL_MEDIA = 0x00000002; 772 773 /** 774 * Usable by the required verifier as the {@code verificationCode} argument 775 * for {@link PackageManager#verifyPendingInstall} to indicate that it will 776 * allow the installation to proceed without any of the optional verifiers 777 * needing to vote. 778 * 779 * @hide 780 */ 781 public static final int VERIFICATION_ALLOW_WITHOUT_SUFFICIENT = 2; 782 783 /** 784 * Used as the {@code verificationCode} argument for 785 * {@link PackageManager#verifyPendingInstall} to indicate that the calling 786 * package verifier allows the installation to proceed. 787 */ 788 public static final int VERIFICATION_ALLOW = 1; 789 790 /** 791 * Used as the {@code verificationCode} argument for 792 * {@link PackageManager#verifyPendingInstall} to indicate the calling 793 * package verifier does not vote to allow the installation to proceed. 794 */ 795 public static final int VERIFICATION_REJECT = -1; 796 797 /** 798 * Can be used as the {@code millisecondsToDelay} argument for 799 * {@link PackageManager#extendVerificationTimeout}. This is the 800 * maximum time {@code PackageManager} waits for the verification 801 * agent to return (in milliseconds). 802 */ 803 public static final long MAXIMUM_VERIFICATION_TIMEOUT = 60*60*1000; 804 805 /** 806 * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: The device's 807 * audio pipeline is low-latency, more suitable for audio applications sensitive to delays or 808 * lag in sound input or output. 809 */ 810 @SdkConstant(SdkConstantType.FEATURE) 811 public static final String FEATURE_AUDIO_LOW_LATENCY = "android.hardware.audio.low_latency"; 812 813 /** 814 * Feature for {@link #getSystemAvailableFeatures} and 815 * {@link #hasSystemFeature}: The device is capable of communicating with 816 * other devices via Bluetooth. 817 */ 818 @SdkConstant(SdkConstantType.FEATURE) 819 public static final String FEATURE_BLUETOOTH = "android.hardware.bluetooth"; 820 821 /** 822 * Feature for {@link #getSystemAvailableFeatures} and 823 * {@link #hasSystemFeature}: The device has a camera facing away 824 * from the screen. 825 */ 826 @SdkConstant(SdkConstantType.FEATURE) 827 public static final String FEATURE_CAMERA = "android.hardware.camera"; 828 829 /** 830 * Feature for {@link #getSystemAvailableFeatures} and 831 * {@link #hasSystemFeature}: The device's camera supports auto-focus. 832 */ 833 @SdkConstant(SdkConstantType.FEATURE) 834 public static final String FEATURE_CAMERA_AUTOFOCUS = "android.hardware.camera.autofocus"; 835 836 /** 837 * Feature for {@link #getSystemAvailableFeatures} and 838 * {@link #hasSystemFeature}: The device has at least one camera pointing in 839 * some direction. 840 */ 841 @SdkConstant(SdkConstantType.FEATURE) 842 public static final String FEATURE_CAMERA_ANY = "android.hardware.camera.any"; 843 844 /** 845 * Feature for {@link #getSystemAvailableFeatures} and 846 * {@link #hasSystemFeature}: The device's camera supports flash. 847 */ 848 @SdkConstant(SdkConstantType.FEATURE) 849 public static final String FEATURE_CAMERA_FLASH = "android.hardware.camera.flash"; 850 851 /** 852 * Feature for {@link #getSystemAvailableFeatures} and 853 * {@link #hasSystemFeature}: The device has a front facing camera. 854 */ 855 @SdkConstant(SdkConstantType.FEATURE) 856 public static final String FEATURE_CAMERA_FRONT = "android.hardware.camera.front"; 857 858 /** 859 * Feature for {@link #getSystemAvailableFeatures} and 860 * {@link #hasSystemFeature}: The device supports one or more methods of 861 * reporting current location. 862 */ 863 @SdkConstant(SdkConstantType.FEATURE) 864 public static final String FEATURE_LOCATION = "android.hardware.location"; 865 866 /** 867 * Feature for {@link #getSystemAvailableFeatures} and 868 * {@link #hasSystemFeature}: The device has a Global Positioning System 869 * receiver and can report precise location. 870 */ 871 @SdkConstant(SdkConstantType.FEATURE) 872 public static final String FEATURE_LOCATION_GPS = "android.hardware.location.gps"; 873 874 /** 875 * Feature for {@link #getSystemAvailableFeatures} and 876 * {@link #hasSystemFeature}: The device can report location with coarse 877 * accuracy using a network-based geolocation system. 878 */ 879 @SdkConstant(SdkConstantType.FEATURE) 880 public static final String FEATURE_LOCATION_NETWORK = "android.hardware.location.network"; 881 882 /** 883 * Feature for {@link #getSystemAvailableFeatures} and 884 * {@link #hasSystemFeature}: The device can record audio via a 885 * microphone. 886 */ 887 @SdkConstant(SdkConstantType.FEATURE) 888 public static final String FEATURE_MICROPHONE = "android.hardware.microphone"; 889 890 /** 891 * Feature for {@link #getSystemAvailableFeatures} and 892 * {@link #hasSystemFeature}: The device can communicate using Near-Field 893 * Communications (NFC). 894 */ 895 @SdkConstant(SdkConstantType.FEATURE) 896 public static final String FEATURE_NFC = "android.hardware.nfc"; 897 898 /** 899 * Feature for {@link #getSystemAvailableFeatures} and 900 * {@link #hasSystemFeature}: The device includes an accelerometer. 901 */ 902 @SdkConstant(SdkConstantType.FEATURE) 903 public static final String FEATURE_SENSOR_ACCELEROMETER = "android.hardware.sensor.accelerometer"; 904 905 /** 906 * Feature for {@link #getSystemAvailableFeatures} and 907 * {@link #hasSystemFeature}: The device includes a barometer (air 908 * pressure sensor.) 909 */ 910 @SdkConstant(SdkConstantType.FEATURE) 911 public static final String FEATURE_SENSOR_BAROMETER = "android.hardware.sensor.barometer"; 912 913 /** 914 * Feature for {@link #getSystemAvailableFeatures} and 915 * {@link #hasSystemFeature}: The device includes a magnetometer (compass). 916 */ 917 @SdkConstant(SdkConstantType.FEATURE) 918 public static final String FEATURE_SENSOR_COMPASS = "android.hardware.sensor.compass"; 919 920 /** 921 * Feature for {@link #getSystemAvailableFeatures} and 922 * {@link #hasSystemFeature}: The device includes a gyroscope. 923 */ 924 @SdkConstant(SdkConstantType.FEATURE) 925 public static final String FEATURE_SENSOR_GYROSCOPE = "android.hardware.sensor.gyroscope"; 926 927 /** 928 * Feature for {@link #getSystemAvailableFeatures} and 929 * {@link #hasSystemFeature}: The device includes a light sensor. 930 */ 931 @SdkConstant(SdkConstantType.FEATURE) 932 public static final String FEATURE_SENSOR_LIGHT = "android.hardware.sensor.light"; 933 934 /** 935 * Feature for {@link #getSystemAvailableFeatures} and 936 * {@link #hasSystemFeature}: The device includes a proximity sensor. 937 */ 938 @SdkConstant(SdkConstantType.FEATURE) 939 public static final String FEATURE_SENSOR_PROXIMITY = "android.hardware.sensor.proximity"; 940 941 /** 942 * Feature for {@link #getSystemAvailableFeatures} and 943 * {@link #hasSystemFeature}: The device has a telephony radio with data 944 * communication support. 945 */ 946 @SdkConstant(SdkConstantType.FEATURE) 947 public static final String FEATURE_TELEPHONY = "android.hardware.telephony"; 948 949 /** 950 * Feature for {@link #getSystemAvailableFeatures} and 951 * {@link #hasSystemFeature}: The device has a CDMA telephony stack. 952 */ 953 @SdkConstant(SdkConstantType.FEATURE) 954 public static final String FEATURE_TELEPHONY_CDMA = "android.hardware.telephony.cdma"; 955 956 /** 957 * Feature for {@link #getSystemAvailableFeatures} and 958 * {@link #hasSystemFeature}: The device has a GSM telephony stack. 959 */ 960 @SdkConstant(SdkConstantType.FEATURE) 961 public static final String FEATURE_TELEPHONY_GSM = "android.hardware.telephony.gsm"; 962 963 /** 964 * Feature for {@link #getSystemAvailableFeatures} and 965 * {@link #hasSystemFeature}: The device supports connecting to USB devices 966 * as the USB host. 967 */ 968 @SdkConstant(SdkConstantType.FEATURE) 969 public static final String FEATURE_USB_HOST = "android.hardware.usb.host"; 970 971 /** 972 * Feature for {@link #getSystemAvailableFeatures} and 973 * {@link #hasSystemFeature}: The device supports connecting to USB accessories. 974 */ 975 @SdkConstant(SdkConstantType.FEATURE) 976 public static final String FEATURE_USB_ACCESSORY = "android.hardware.usb.accessory"; 977 978 /** 979 * Feature for {@link #getSystemAvailableFeatures} and 980 * {@link #hasSystemFeature}: The SIP API is enabled on the device. 981 */ 982 @SdkConstant(SdkConstantType.FEATURE) 983 public static final String FEATURE_SIP = "android.software.sip"; 984 985 /** 986 * Feature for {@link #getSystemAvailableFeatures} and 987 * {@link #hasSystemFeature}: The device supports SIP-based VOIP. 988 */ 989 @SdkConstant(SdkConstantType.FEATURE) 990 public static final String FEATURE_SIP_VOIP = "android.software.sip.voip"; 991 992 /** 993 * Feature for {@link #getSystemAvailableFeatures} and 994 * {@link #hasSystemFeature}: The device's display has a touch screen. 995 */ 996 @SdkConstant(SdkConstantType.FEATURE) 997 public static final String FEATURE_TOUCHSCREEN = "android.hardware.touchscreen"; 998 999 1000 /** 1001 * Feature for {@link #getSystemAvailableFeatures} and 1002 * {@link #hasSystemFeature}: The device's touch screen supports 1003 * multitouch sufficient for basic two-finger gesture detection. 1004 */ 1005 @SdkConstant(SdkConstantType.FEATURE) 1006 public static final String FEATURE_TOUCHSCREEN_MULTITOUCH = "android.hardware.touchscreen.multitouch"; 1007 1008 /** 1009 * Feature for {@link #getSystemAvailableFeatures} and 1010 * {@link #hasSystemFeature}: The device's touch screen is capable of 1011 * tracking two or more fingers fully independently. 1012 */ 1013 @SdkConstant(SdkConstantType.FEATURE) 1014 public static final String FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT = "android.hardware.touchscreen.multitouch.distinct"; 1015 1016 /** 1017 * Feature for {@link #getSystemAvailableFeatures} and 1018 * {@link #hasSystemFeature}: The device's touch screen is capable of 1019 * tracking a full hand of fingers fully independently -- that is, 5 or 1020 * more simultaneous independent pointers. 1021 */ 1022 @SdkConstant(SdkConstantType.FEATURE) 1023 public static final String FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND = "android.hardware.touchscreen.multitouch.jazzhand"; 1024 1025 /** 1026 * Feature for {@link #getSystemAvailableFeatures} and 1027 * {@link #hasSystemFeature}: The device does not have a touch screen, but 1028 * does support touch emulation for basic events. For instance, the 1029 * device might use a mouse or remote control to drive a cursor, and 1030 * emulate basic touch pointer events like down, up, drag, etc. All 1031 * devices that support android.hardware.touchscreen or a sub-feature are 1032 * presumed to also support faketouch. 1033 */ 1034 @SdkConstant(SdkConstantType.FEATURE) 1035 public static final String FEATURE_FAKETOUCH = "android.hardware.faketouch"; 1036 1037 /** 1038 * Feature for {@link #getSystemAvailableFeatures} and 1039 * {@link #hasSystemFeature}: The device does not have a touch screen, but 1040 * does support touch emulation for basic events that supports distinct 1041 * tracking of two or more fingers. This is an extension of 1042 * {@link #FEATURE_FAKETOUCH} for input devices with this capability. Note 1043 * that unlike a distinct multitouch screen as defined by 1044 * {@link #FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT}, these kinds of input 1045 * devices will not actually provide full two-finger gestures since the 1046 * input is being transformed to cursor movement on the screen. That is, 1047 * single finger gestures will move a cursor; two-finger swipes will 1048 * result in single-finger touch events; other two-finger gestures will 1049 * result in the corresponding two-finger touch event. 1050 */ 1051 @SdkConstant(SdkConstantType.FEATURE) 1052 public static final String FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT = "android.hardware.faketouch.multitouch.distinct"; 1053 1054 /** 1055 * Feature for {@link #getSystemAvailableFeatures} and 1056 * {@link #hasSystemFeature}: The device does not have a touch screen, but 1057 * does support touch emulation for basic events that supports tracking 1058 * a hand of fingers (5 or more fingers) fully independently. 1059 * This is an extension of 1060 * {@link #FEATURE_FAKETOUCH} for input devices with this capability. Note 1061 * that unlike a multitouch screen as defined by 1062 * {@link #FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND}, not all two finger 1063 * gestures can be detected due to the limitations described for 1064 * {@link #FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT}. 1065 */ 1066 @SdkConstant(SdkConstantType.FEATURE) 1067 public static final String FEATURE_FAKETOUCH_MULTITOUCH_JAZZHAND = "android.hardware.faketouch.multitouch.jazzhand"; 1068 1069 /** 1070 * Feature for {@link #getSystemAvailableFeatures} and 1071 * {@link #hasSystemFeature}: The device supports portrait orientation 1072 * screens. For backwards compatibility, you can assume that if neither 1073 * this nor {@link #FEATURE_SCREEN_LANDSCAPE} is set then the device supports 1074 * both portrait and landscape. 1075 */ 1076 @SdkConstant(SdkConstantType.FEATURE) 1077 public static final String FEATURE_SCREEN_PORTRAIT = "android.hardware.screen.portrait"; 1078 1079 /** 1080 * Feature for {@link #getSystemAvailableFeatures} and 1081 * {@link #hasSystemFeature}: The device supports landscape orientation 1082 * screens. For backwards compatibility, you can assume that if neither 1083 * this nor {@link #FEATURE_SCREEN_PORTRAIT} is set then the device supports 1084 * both portrait and landscape. 1085 */ 1086 @SdkConstant(SdkConstantType.FEATURE) 1087 public static final String FEATURE_SCREEN_LANDSCAPE = "android.hardware.screen.landscape"; 1088 1089 /** 1090 * Feature for {@link #getSystemAvailableFeatures} and 1091 * {@link #hasSystemFeature}: The device supports live wallpapers. 1092 */ 1093 @SdkConstant(SdkConstantType.FEATURE) 1094 public static final String FEATURE_LIVE_WALLPAPER = "android.software.live_wallpaper"; 1095 1096 /** 1097 * Feature for {@link #getSystemAvailableFeatures} and 1098 * {@link #hasSystemFeature}: The device supports WiFi (802.11) networking. 1099 */ 1100 @SdkConstant(SdkConstantType.FEATURE) 1101 public static final String FEATURE_WIFI = "android.hardware.wifi"; 1102 1103 /** 1104 * Feature for {@link #getSystemAvailableFeatures} and 1105 * {@link #hasSystemFeature}: The device supports Wi-Fi Direct networking. 1106 */ 1107 @SdkConstant(SdkConstantType.FEATURE) 1108 public static final String FEATURE_WIFI_DIRECT = "android.hardware.wifi.direct"; 1109 1110 /** 1111 * Feature for {@link #getSystemAvailableFeatures} and 1112 * {@link #hasSystemFeature}: This is a device dedicated to showing UI 1113 * on a television. Television here is defined to be a typical living 1114 * room television experience: displayed on a big screen, where the user 1115 * is sitting far away from it, and the dominant form of input will be 1116 * something like a DPAD, not through touch or mouse. 1117 */ 1118 @SdkConstant(SdkConstantType.FEATURE) 1119 public static final String FEATURE_TELEVISION = "android.hardware.type.television"; 1120 1121 /** 1122 * Action to external storage service to clean out removed apps. 1123 * @hide 1124 */ 1125 public static final String ACTION_CLEAN_EXTERNAL_STORAGE 1126 = "android.content.pm.CLEAN_EXTERNAL_STORAGE"; 1127 1128 /** 1129 * Extra field name for the URI to a verification file. Passed to a package 1130 * verifier. 1131 * 1132 * @hide 1133 */ 1134 public static final String EXTRA_VERIFICATION_URI = "android.content.pm.extra.VERIFICATION_URI"; 1135 1136 /** 1137 * Extra field name for the ID of a package pending verification. Passed to 1138 * a package verifier and is used to call back to 1139 * {@link PackageManager#verifyPendingInstall(int, int)} 1140 */ 1141 public static final String EXTRA_VERIFICATION_ID = "android.content.pm.extra.VERIFICATION_ID"; 1142 1143 /** 1144 * Extra field name for the package identifier which is trying to install 1145 * the package. 1146 * 1147 * @hide 1148 */ 1149 public static final String EXTRA_VERIFICATION_INSTALLER_PACKAGE 1150 = "android.content.pm.extra.VERIFICATION_INSTALLER_PACKAGE"; 1151 1152 /** 1153 * Extra field name for the requested install flags for a package pending 1154 * verification. Passed to a package verifier. 1155 * 1156 * @hide 1157 */ 1158 public static final String EXTRA_VERIFICATION_INSTALL_FLAGS 1159 = "android.content.pm.extra.VERIFICATION_INSTALL_FLAGS"; 1160 1161 /** 1162 * Extra field name for the uid of who is requesting to install 1163 * the package. 1164 * 1165 * @hide 1166 */ 1167 public static final String EXTRA_VERIFICATION_INSTALLER_UID 1168 = "android.content.pm.extra.VERIFICATION_INSTALLER_UID"; 1169 1170 /** 1171 * Extra field name for the package name of a package pending verification. 1172 * 1173 * @hide 1174 */ 1175 public static final String EXTRA_VERIFICATION_PACKAGE_NAME 1176 = "android.content.pm.extra.VERIFICATION_PACKAGE_NAME"; 1177 /** 1178 * Extra field name for the result of a verification, either 1179 * {@link #VERIFICATION_ALLOW}, or {@link #VERIFICATION_REJECT}. 1180 * Passed to package verifiers after a package is verified. 1181 */ 1182 public static final String EXTRA_VERIFICATION_RESULT 1183 = "android.content.pm.extra.VERIFICATION_RESULT"; 1184 1185 /** 1186 * Extra field name for the version code of a package pending verification. 1187 * 1188 * @hide 1189 */ 1190 public static final String EXTRA_VERIFICATION_VERSION_CODE 1191 = "android.content.pm.extra.VERIFICATION_VERSION_CODE"; 1192 1193 /** 1194 * Retrieve overall information about an application package that is 1195 * installed on the system. 1196 * <p> 1197 * Throws {@link NameNotFoundException} if a package with the given name can 1198 * not be found on the system. 1199 * 1200 * @param packageName The full name (i.e. com.google.apps.contacts) of the 1201 * desired package. 1202 * @param flags Additional option flags. Use any combination of 1203 * {@link #GET_ACTIVITIES}, {@link #GET_GIDS}, 1204 * {@link #GET_CONFIGURATIONS}, {@link #GET_INSTRUMENTATION}, 1205 * {@link #GET_PERMISSIONS}, {@link #GET_PROVIDERS}, 1206 * {@link #GET_RECEIVERS}, {@link #GET_SERVICES}, 1207 * {@link #GET_SIGNATURES}, {@link #GET_UNINSTALLED_PACKAGES} to 1208 * modify the data returned. 1209 * @return Returns a PackageInfo object containing information about the 1210 * package. If flag GET_UNINSTALLED_PACKAGES is set and if the 1211 * package is not found in the list of installed applications, the 1212 * package information is retrieved from the list of uninstalled 1213 * applications(which includes installed applications as well as 1214 * applications with data directory ie applications which had been 1215 * deleted with DONT_DELTE_DATA flag set). 1216 * @see #GET_ACTIVITIES 1217 * @see #GET_GIDS 1218 * @see #GET_CONFIGURATIONS 1219 * @see #GET_INSTRUMENTATION 1220 * @see #GET_PERMISSIONS 1221 * @see #GET_PROVIDERS 1222 * @see #GET_RECEIVERS 1223 * @see #GET_SERVICES 1224 * @see #GET_SIGNATURES 1225 * @see #GET_UNINSTALLED_PACKAGES 1226 */ getPackageInfo(String packageName, int flags)1227 public abstract PackageInfo getPackageInfo(String packageName, int flags) 1228 throws NameNotFoundException; 1229 1230 /** 1231 * Map from the current package names in use on the device to whatever 1232 * the current canonical name of that package is. 1233 * @param names Array of current names to be mapped. 1234 * @return Returns an array of the same size as the original, containing 1235 * the canonical name for each package. 1236 */ currentToCanonicalPackageNames(String[] names)1237 public abstract String[] currentToCanonicalPackageNames(String[] names); 1238 1239 /** 1240 * Map from a packages canonical name to the current name in use on the device. 1241 * @param names Array of new names to be mapped. 1242 * @return Returns an array of the same size as the original, containing 1243 * the current name for each package. 1244 */ canonicalToCurrentPackageNames(String[] names)1245 public abstract String[] canonicalToCurrentPackageNames(String[] names); 1246 1247 /** 1248 * Return a "good" intent to launch a front-door activity in a package, 1249 * for use for example to implement an "open" button when browsing through 1250 * packages. The current implementation will look first for a main 1251 * activity in the category {@link Intent#CATEGORY_INFO}, next for a 1252 * main activity in the category {@link Intent#CATEGORY_LAUNCHER}, or return 1253 * null if neither are found. 1254 * 1255 * <p>Throws {@link NameNotFoundException} if a package with the given 1256 * name can not be found on the system. 1257 * 1258 * @param packageName The name of the package to inspect. 1259 * 1260 * @return Returns either a fully-qualified Intent that can be used to 1261 * launch the main activity in the package, or null if the package does 1262 * not contain such an activity. 1263 */ getLaunchIntentForPackage(String packageName)1264 public abstract Intent getLaunchIntentForPackage(String packageName); 1265 1266 /** 1267 * Return an array of all of the secondary group-ids that have been 1268 * assigned to a package. 1269 * 1270 * <p>Throws {@link NameNotFoundException} if a package with the given 1271 * name can not be found on the system. 1272 * 1273 * @param packageName The full name (i.e. com.google.apps.contacts) of the 1274 * desired package. 1275 * 1276 * @return Returns an int array of the assigned gids, or null if there 1277 * are none. 1278 */ getPackageGids(String packageName)1279 public abstract int[] getPackageGids(String packageName) 1280 throws NameNotFoundException; 1281 1282 /** 1283 * Retrieve all of the information we know about a particular permission. 1284 * 1285 * <p>Throws {@link NameNotFoundException} if a permission with the given 1286 * name can not be found on the system. 1287 * 1288 * @param name The fully qualified name (i.e. com.google.permission.LOGIN) 1289 * of the permission you are interested in. 1290 * @param flags Additional option flags. Use {@link #GET_META_DATA} to 1291 * retrieve any meta-data associated with the permission. 1292 * 1293 * @return Returns a {@link PermissionInfo} containing information about the 1294 * permission. 1295 */ getPermissionInfo(String name, int flags)1296 public abstract PermissionInfo getPermissionInfo(String name, int flags) 1297 throws NameNotFoundException; 1298 1299 /** 1300 * Query for all of the permissions associated with a particular group. 1301 * 1302 * <p>Throws {@link NameNotFoundException} if the given group does not 1303 * exist. 1304 * 1305 * @param group The fully qualified name (i.e. com.google.permission.LOGIN) 1306 * of the permission group you are interested in. Use null to 1307 * find all of the permissions not associated with a group. 1308 * @param flags Additional option flags. Use {@link #GET_META_DATA} to 1309 * retrieve any meta-data associated with the permissions. 1310 * 1311 * @return Returns a list of {@link PermissionInfo} containing information 1312 * about all of the permissions in the given group. 1313 */ queryPermissionsByGroup(String group, int flags)1314 public abstract List<PermissionInfo> queryPermissionsByGroup(String group, 1315 int flags) throws NameNotFoundException; 1316 1317 /** 1318 * Retrieve all of the information we know about a particular group of 1319 * permissions. 1320 * 1321 * <p>Throws {@link NameNotFoundException} if a permission group with the given 1322 * name can not be found on the system. 1323 * 1324 * @param name The fully qualified name (i.e. com.google.permission_group.APPS) 1325 * of the permission you are interested in. 1326 * @param flags Additional option flags. Use {@link #GET_META_DATA} to 1327 * retrieve any meta-data associated with the permission group. 1328 * 1329 * @return Returns a {@link PermissionGroupInfo} containing information 1330 * about the permission. 1331 */ getPermissionGroupInfo(String name, int flags)1332 public abstract PermissionGroupInfo getPermissionGroupInfo(String name, 1333 int flags) throws NameNotFoundException; 1334 1335 /** 1336 * Retrieve all of the known permission groups in the system. 1337 * 1338 * @param flags Additional option flags. Use {@link #GET_META_DATA} to 1339 * retrieve any meta-data associated with the permission group. 1340 * 1341 * @return Returns a list of {@link PermissionGroupInfo} containing 1342 * information about all of the known permission groups. 1343 */ getAllPermissionGroups(int flags)1344 public abstract List<PermissionGroupInfo> getAllPermissionGroups(int flags); 1345 1346 /** 1347 * Retrieve all of the information we know about a particular 1348 * package/application. 1349 * 1350 * <p>Throws {@link NameNotFoundException} if an application with the given 1351 * package name can not be found on the system. 1352 * 1353 * @param packageName The full name (i.e. com.google.apps.contacts) of an 1354 * application. 1355 * @param flags Additional option flags. Use any combination of 1356 * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES}, 1357 * {@link #GET_UNINSTALLED_PACKAGES} to modify the data returned. 1358 * 1359 * @return {@link ApplicationInfo} Returns ApplicationInfo object containing 1360 * information about the package. 1361 * If flag GET_UNINSTALLED_PACKAGES is set and if the package is not 1362 * found in the list of installed applications, 1363 * the application information is retrieved from the 1364 * list of uninstalled applications(which includes 1365 * installed applications as well as applications 1366 * with data directory ie applications which had been 1367 * deleted with DONT_DELTE_DATA flag set). 1368 * 1369 * @see #GET_META_DATA 1370 * @see #GET_SHARED_LIBRARY_FILES 1371 * @see #GET_UNINSTALLED_PACKAGES 1372 */ getApplicationInfo(String packageName, int flags)1373 public abstract ApplicationInfo getApplicationInfo(String packageName, 1374 int flags) throws NameNotFoundException; 1375 1376 /** 1377 * Retrieve all of the information we know about a particular activity 1378 * class. 1379 * 1380 * <p>Throws {@link NameNotFoundException} if an activity with the given 1381 * class name can not be found on the system. 1382 * 1383 * @param component The full component name (i.e. 1384 * com.google.apps.contacts/com.google.apps.contacts.ContactsList) of an Activity 1385 * class. 1386 * @param flags Additional option flags. Use any combination of 1387 * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES}, 1388 * to modify the data (in ApplicationInfo) returned. 1389 * 1390 * @return {@link ActivityInfo} containing information about the activity. 1391 * 1392 * @see #GET_INTENT_FILTERS 1393 * @see #GET_META_DATA 1394 * @see #GET_SHARED_LIBRARY_FILES 1395 */ getActivityInfo(ComponentName component, int flags)1396 public abstract ActivityInfo getActivityInfo(ComponentName component, 1397 int flags) throws NameNotFoundException; 1398 1399 /** 1400 * Retrieve all of the information we know about a particular receiver 1401 * class. 1402 * 1403 * <p>Throws {@link NameNotFoundException} if a receiver with the given 1404 * class name can not be found on the system. 1405 * 1406 * @param component The full component name (i.e. 1407 * com.google.apps.calendar/com.google.apps.calendar.CalendarAlarm) of a Receiver 1408 * class. 1409 * @param flags Additional option flags. Use any combination of 1410 * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES}, 1411 * to modify the data returned. 1412 * 1413 * @return {@link ActivityInfo} containing information about the receiver. 1414 * 1415 * @see #GET_INTENT_FILTERS 1416 * @see #GET_META_DATA 1417 * @see #GET_SHARED_LIBRARY_FILES 1418 */ getReceiverInfo(ComponentName component, int flags)1419 public abstract ActivityInfo getReceiverInfo(ComponentName component, 1420 int flags) throws NameNotFoundException; 1421 1422 /** 1423 * Retrieve all of the information we know about a particular service 1424 * class. 1425 * 1426 * <p>Throws {@link NameNotFoundException} if a service with the given 1427 * class name can not be found on the system. 1428 * 1429 * @param component The full component name (i.e. 1430 * com.google.apps.media/com.google.apps.media.BackgroundPlayback) of a Service 1431 * class. 1432 * @param flags Additional option flags. Use any combination of 1433 * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES}, 1434 * to modify the data returned. 1435 * 1436 * @return ServiceInfo containing information about the service. 1437 * 1438 * @see #GET_META_DATA 1439 * @see #GET_SHARED_LIBRARY_FILES 1440 */ getServiceInfo(ComponentName component, int flags)1441 public abstract ServiceInfo getServiceInfo(ComponentName component, 1442 int flags) throws NameNotFoundException; 1443 1444 /** 1445 * Retrieve all of the information we know about a particular content 1446 * provider class. 1447 * 1448 * <p>Throws {@link NameNotFoundException} if a provider with the given 1449 * class name can not be found on the system. 1450 * 1451 * @param component The full component name (i.e. 1452 * com.google.providers.media/com.google.providers.media.MediaProvider) of a 1453 * ContentProvider class. 1454 * @param flags Additional option flags. Use any combination of 1455 * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES}, 1456 * to modify the data returned. 1457 * 1458 * @return ProviderInfo containing information about the service. 1459 * 1460 * @see #GET_META_DATA 1461 * @see #GET_SHARED_LIBRARY_FILES 1462 */ getProviderInfo(ComponentName component, int flags)1463 public abstract ProviderInfo getProviderInfo(ComponentName component, 1464 int flags) throws NameNotFoundException; 1465 1466 /** 1467 * Return a List of all packages that are installed 1468 * on the device. 1469 * 1470 * @param flags Additional option flags. Use any combination of 1471 * {@link #GET_ACTIVITIES}, 1472 * {@link #GET_GIDS}, 1473 * {@link #GET_CONFIGURATIONS}, 1474 * {@link #GET_INSTRUMENTATION}, 1475 * {@link #GET_PERMISSIONS}, 1476 * {@link #GET_PROVIDERS}, 1477 * {@link #GET_RECEIVERS}, 1478 * {@link #GET_SERVICES}, 1479 * {@link #GET_SIGNATURES}, 1480 * {@link #GET_UNINSTALLED_PACKAGES} to modify the data returned. 1481 * 1482 * @return A List of PackageInfo objects, one for each package that is 1483 * installed on the device. In the unlikely case of there being no 1484 * installed packages, an empty list is returned. 1485 * If flag GET_UNINSTALLED_PACKAGES is set, a list of all 1486 * applications including those deleted with DONT_DELETE_DATA 1487 * (partially installed apps with data directory) will be returned. 1488 * 1489 * @see #GET_ACTIVITIES 1490 * @see #GET_GIDS 1491 * @see #GET_CONFIGURATIONS 1492 * @see #GET_INSTRUMENTATION 1493 * @see #GET_PERMISSIONS 1494 * @see #GET_PROVIDERS 1495 * @see #GET_RECEIVERS 1496 * @see #GET_SERVICES 1497 * @see #GET_SIGNATURES 1498 * @see #GET_UNINSTALLED_PACKAGES 1499 * 1500 */ getInstalledPackages(int flags)1501 public abstract List<PackageInfo> getInstalledPackages(int flags); 1502 1503 /** 1504 * Return a List of all packages that are installed on the device, for a specific user. 1505 * Requesting a list of installed packages for another user 1506 * will require the permission INTERACT_ACROSS_USERS_FULL. 1507 * @param flags Additional option flags. Use any combination of 1508 * {@link #GET_ACTIVITIES}, 1509 * {@link #GET_GIDS}, 1510 * {@link #GET_CONFIGURATIONS}, 1511 * {@link #GET_INSTRUMENTATION}, 1512 * {@link #GET_PERMISSIONS}, 1513 * {@link #GET_PROVIDERS}, 1514 * {@link #GET_RECEIVERS}, 1515 * {@link #GET_SERVICES}, 1516 * {@link #GET_SIGNATURES}, 1517 * {@link #GET_UNINSTALLED_PACKAGES} to modify the data returned. 1518 * @param userId The user for whom the installed packages are to be listed 1519 * 1520 * @return A List of PackageInfo objects, one for each package that is 1521 * installed on the device. In the unlikely case of there being no 1522 * installed packages, an empty list is returned. 1523 * If flag GET_UNINSTALLED_PACKAGES is set, a list of all 1524 * applications including those deleted with DONT_DELETE_DATA 1525 * (partially installed apps with data directory) will be returned. 1526 * 1527 * @see #GET_ACTIVITIES 1528 * @see #GET_GIDS 1529 * @see #GET_CONFIGURATIONS 1530 * @see #GET_INSTRUMENTATION 1531 * @see #GET_PERMISSIONS 1532 * @see #GET_PROVIDERS 1533 * @see #GET_RECEIVERS 1534 * @see #GET_SERVICES 1535 * @see #GET_SIGNATURES 1536 * @see #GET_UNINSTALLED_PACKAGES 1537 * 1538 * @hide 1539 */ getInstalledPackages(int flags, int userId)1540 public abstract List<PackageInfo> getInstalledPackages(int flags, int userId); 1541 1542 /** 1543 * Check whether a particular package has been granted a particular 1544 * permission. 1545 * 1546 * @param permName The name of the permission you are checking for, 1547 * @param pkgName The name of the package you are checking against. 1548 * 1549 * @return If the package has the permission, PERMISSION_GRANTED is 1550 * returned. If it does not have the permission, PERMISSION_DENIED 1551 * is returned. 1552 * 1553 * @see #PERMISSION_GRANTED 1554 * @see #PERMISSION_DENIED 1555 */ checkPermission(String permName, String pkgName)1556 public abstract int checkPermission(String permName, String pkgName); 1557 1558 /** 1559 * Add a new dynamic permission to the system. For this to work, your 1560 * package must have defined a permission tree through the 1561 * {@link android.R.styleable#AndroidManifestPermissionTree 1562 * <permission-tree>} tag in its manifest. A package can only add 1563 * permissions to trees that were defined by either its own package or 1564 * another with the same user id; a permission is in a tree if it 1565 * matches the name of the permission tree + ".": for example, 1566 * "com.foo.bar" is a member of the permission tree "com.foo". 1567 * 1568 * <p>It is good to make your permission tree name descriptive, because you 1569 * are taking possession of that entire set of permission names. Thus, it 1570 * must be under a domain you control, with a suffix that will not match 1571 * any normal permissions that may be declared in any applications that 1572 * are part of that domain. 1573 * 1574 * <p>New permissions must be added before 1575 * any .apks are installed that use those permissions. Permissions you 1576 * add through this method are remembered across reboots of the device. 1577 * If the given permission already exists, the info you supply here 1578 * will be used to update it. 1579 * 1580 * @param info Description of the permission to be added. 1581 * 1582 * @return Returns true if a new permission was created, false if an 1583 * existing one was updated. 1584 * 1585 * @throws SecurityException if you are not allowed to add the 1586 * given permission name. 1587 * 1588 * @see #removePermission(String) 1589 */ addPermission(PermissionInfo info)1590 public abstract boolean addPermission(PermissionInfo info); 1591 1592 /** 1593 * Like {@link #addPermission(PermissionInfo)} but asynchronously 1594 * persists the package manager state after returning from the call, 1595 * allowing it to return quicker and batch a series of adds at the 1596 * expense of no guarantee the added permission will be retained if 1597 * the device is rebooted before it is written. 1598 */ addPermissionAsync(PermissionInfo info)1599 public abstract boolean addPermissionAsync(PermissionInfo info); 1600 1601 /** 1602 * Removes a permission that was previously added with 1603 * {@link #addPermission(PermissionInfo)}. The same ownership rules apply 1604 * -- you are only allowed to remove permissions that you are allowed 1605 * to add. 1606 * 1607 * @param name The name of the permission to remove. 1608 * 1609 * @throws SecurityException if you are not allowed to remove the 1610 * given permission name. 1611 * 1612 * @see #addPermission(PermissionInfo) 1613 */ removePermission(String name)1614 public abstract void removePermission(String name); 1615 1616 /** 1617 * Grant a permission to an application which the application does not 1618 * already have. The permission must have been requested by the application, 1619 * but as an optional permission. If the application is not allowed to 1620 * hold the permission, a SecurityException is thrown. 1621 * @hide 1622 * 1623 * @param packageName The name of the package that the permission will be 1624 * granted to. 1625 * @param permissionName The name of the permission. 1626 */ grantPermission(String packageName, String permissionName)1627 public abstract void grantPermission(String packageName, String permissionName); 1628 1629 /** 1630 * Revoke a permission that was previously granted by {@link #grantPermission}. 1631 * @hide 1632 * 1633 * @param packageName The name of the package that the permission will be 1634 * granted to. 1635 * @param permissionName The name of the permission. 1636 */ revokePermission(String packageName, String permissionName)1637 public abstract void revokePermission(String packageName, String permissionName); 1638 1639 /** 1640 * Compare the signatures of two packages to determine if the same 1641 * signature appears in both of them. If they do contain the same 1642 * signature, then they are allowed special privileges when working 1643 * with each other: they can share the same user-id, run instrumentation 1644 * against each other, etc. 1645 * 1646 * @param pkg1 First package name whose signature will be compared. 1647 * @param pkg2 Second package name whose signature will be compared. 1648 * 1649 * @return Returns an integer indicating whether all signatures on the 1650 * two packages match. The value is >= 0 ({@link #SIGNATURE_MATCH}) if 1651 * all signatures match or < 0 if there is not a match ({@link 1652 * #SIGNATURE_NO_MATCH} or {@link #SIGNATURE_UNKNOWN_PACKAGE}). 1653 * 1654 * @see #checkSignatures(int, int) 1655 * @see #SIGNATURE_MATCH 1656 * @see #SIGNATURE_NO_MATCH 1657 * @see #SIGNATURE_UNKNOWN_PACKAGE 1658 */ checkSignatures(String pkg1, String pkg2)1659 public abstract int checkSignatures(String pkg1, String pkg2); 1660 1661 /** 1662 * Like {@link #checkSignatures(String, String)}, but takes UIDs of 1663 * the two packages to be checked. This can be useful, for example, 1664 * when doing the check in an IPC, where the UID is the only identity 1665 * available. It is functionally identical to determining the package 1666 * associated with the UIDs and checking their signatures. 1667 * 1668 * @param uid1 First UID whose signature will be compared. 1669 * @param uid2 Second UID whose signature will be compared. 1670 * 1671 * @return Returns an integer indicating whether all signatures on the 1672 * two packages match. The value is >= 0 ({@link #SIGNATURE_MATCH}) if 1673 * all signatures match or < 0 if there is not a match ({@link 1674 * #SIGNATURE_NO_MATCH} or {@link #SIGNATURE_UNKNOWN_PACKAGE}). 1675 * 1676 * @see #checkSignatures(String, String) 1677 * @see #SIGNATURE_MATCH 1678 * @see #SIGNATURE_NO_MATCH 1679 * @see #SIGNATURE_UNKNOWN_PACKAGE 1680 */ checkSignatures(int uid1, int uid2)1681 public abstract int checkSignatures(int uid1, int uid2); 1682 1683 /** 1684 * Retrieve the names of all packages that are associated with a particular 1685 * user id. In most cases, this will be a single package name, the package 1686 * that has been assigned that user id. Where there are multiple packages 1687 * sharing the same user id through the "sharedUserId" mechanism, all 1688 * packages with that id will be returned. 1689 * 1690 * @param uid The user id for which you would like to retrieve the 1691 * associated packages. 1692 * 1693 * @return Returns an array of one or more packages assigned to the user 1694 * id, or null if there are no known packages with the given id. 1695 */ getPackagesForUid(int uid)1696 public abstract String[] getPackagesForUid(int uid); 1697 1698 /** 1699 * Retrieve the official name associated with a user id. This name is 1700 * guaranteed to never change, though it is possibly for the underlying 1701 * user id to be changed. That is, if you are storing information about 1702 * user ids in persistent storage, you should use the string returned 1703 * by this function instead of the raw user-id. 1704 * 1705 * @param uid The user id for which you would like to retrieve a name. 1706 * @return Returns a unique name for the given user id, or null if the 1707 * user id is not currently assigned. 1708 */ getNameForUid(int uid)1709 public abstract String getNameForUid(int uid); 1710 1711 /** 1712 * Return the user id associated with a shared user name. Multiple 1713 * applications can specify a shared user name in their manifest and thus 1714 * end up using a common uid. This might be used for new applications 1715 * that use an existing shared user name and need to know the uid of the 1716 * shared user. 1717 * 1718 * @param sharedUserName The shared user name whose uid is to be retrieved. 1719 * @return Returns the uid associated with the shared user, or NameNotFoundException 1720 * if the shared user name is not being used by any installed packages 1721 * @hide 1722 */ getUidForSharedUser(String sharedUserName)1723 public abstract int getUidForSharedUser(String sharedUserName) 1724 throws NameNotFoundException; 1725 1726 /** 1727 * Return a List of all application packages that are installed on the 1728 * device. If flag GET_UNINSTALLED_PACKAGES has been set, a list of all 1729 * applications including those deleted with DONT_DELETE_DATA(partially 1730 * installed apps with data directory) will be returned. 1731 * 1732 * @param flags Additional option flags. Use any combination of 1733 * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES}, 1734 * {@link #GET_UNINSTALLED_PACKAGES} to modify the data returned. 1735 * 1736 * @return A List of ApplicationInfo objects, one for each application that 1737 * is installed on the device. In the unlikely case of there being 1738 * no installed applications, an empty list is returned. 1739 * If flag GET_UNINSTALLED_PACKAGES is set, a list of all 1740 * applications including those deleted with DONT_DELETE_DATA 1741 * (partially installed apps with data directory) will be returned. 1742 * 1743 * @see #GET_META_DATA 1744 * @see #GET_SHARED_LIBRARY_FILES 1745 * @see #GET_UNINSTALLED_PACKAGES 1746 */ getInstalledApplications(int flags)1747 public abstract List<ApplicationInfo> getInstalledApplications(int flags); 1748 1749 /** 1750 * Get a list of shared libraries that are available on the 1751 * system. 1752 * 1753 * @return An array of shared library names that are 1754 * available on the system, or null if none are installed. 1755 * 1756 */ getSystemSharedLibraryNames()1757 public abstract String[] getSystemSharedLibraryNames(); 1758 1759 /** 1760 * Get a list of features that are available on the 1761 * system. 1762 * 1763 * @return An array of FeatureInfo classes describing the features 1764 * that are available on the system, or null if there are none(!!). 1765 */ getSystemAvailableFeatures()1766 public abstract FeatureInfo[] getSystemAvailableFeatures(); 1767 1768 /** 1769 * Check whether the given feature name is one of the available 1770 * features as returned by {@link #getSystemAvailableFeatures()}. 1771 * 1772 * @return Returns true if the devices supports the feature, else 1773 * false. 1774 */ hasSystemFeature(String name)1775 public abstract boolean hasSystemFeature(String name); 1776 1777 /** 1778 * Determine the best action to perform for a given Intent. This is how 1779 * {@link Intent#resolveActivity} finds an activity if a class has not 1780 * been explicitly specified. 1781 * 1782 * <p><em>Note:</em> if using an implicit Intent (without an explicit ComponentName 1783 * specified), be sure to consider whether to set the {@link #MATCH_DEFAULT_ONLY} 1784 * only flag. You need to do so to resolve the activity in the same way 1785 * that {@link android.content.Context#startActivity(Intent)} and 1786 * {@link android.content.Intent#resolveActivity(PackageManager) 1787 * Intent.resolveActivity(PackageManager)} do.</p> 1788 * 1789 * @param intent An intent containing all of the desired specification 1790 * (action, data, type, category, and/or component). 1791 * @param flags Additional option flags. The most important is 1792 * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only 1793 * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}. 1794 * 1795 * @return Returns a ResolveInfo containing the final activity intent that 1796 * was determined to be the best action. Returns null if no 1797 * matching activity was found. If multiple matching activities are 1798 * found and there is no default set, returns a ResolveInfo 1799 * containing something else, such as the activity resolver. 1800 * 1801 * @see #MATCH_DEFAULT_ONLY 1802 * @see #GET_INTENT_FILTERS 1803 * @see #GET_RESOLVED_FILTER 1804 */ resolveActivity(Intent intent, int flags)1805 public abstract ResolveInfo resolveActivity(Intent intent, int flags); 1806 1807 /** 1808 * Determine the best action to perform for a given Intent for a given user. This 1809 * is how {@link Intent#resolveActivity} finds an activity if a class has not 1810 * been explicitly specified. 1811 * 1812 * <p><em>Note:</em> if using an implicit Intent (without an explicit ComponentName 1813 * specified), be sure to consider whether to set the {@link #MATCH_DEFAULT_ONLY} 1814 * only flag. You need to do so to resolve the activity in the same way 1815 * that {@link android.content.Context#startActivity(Intent)} and 1816 * {@link android.content.Intent#resolveActivity(PackageManager) 1817 * Intent.resolveActivity(PackageManager)} do.</p> 1818 * 1819 * @param intent An intent containing all of the desired specification 1820 * (action, data, type, category, and/or component). 1821 * @param flags Additional option flags. The most important is 1822 * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only 1823 * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}. 1824 * @param userId The user id. 1825 * 1826 * @return Returns a ResolveInfo containing the final activity intent that 1827 * was determined to be the best action. Returns null if no 1828 * matching activity was found. If multiple matching activities are 1829 * found and there is no default set, returns a ResolveInfo 1830 * containing something else, such as the activity resolver. 1831 * 1832 * @see #MATCH_DEFAULT_ONLY 1833 * @see #GET_INTENT_FILTERS 1834 * @see #GET_RESOLVED_FILTER 1835 * 1836 * @hide 1837 */ resolveActivityAsUser(Intent intent, int flags, int userId)1838 public abstract ResolveInfo resolveActivityAsUser(Intent intent, int flags, int userId); 1839 1840 /** 1841 * Retrieve all activities that can be performed for the given intent. 1842 * 1843 * @param intent The desired intent as per resolveActivity(). 1844 * @param flags Additional option flags. The most important is 1845 * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only 1846 * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}. 1847 * 1848 * @return A List<ResolveInfo> containing one entry for each matching 1849 * Activity. These are ordered from best to worst match -- that 1850 * is, the first item in the list is what is returned by 1851 * {@link #resolveActivity}. If there are no matching activities, an empty 1852 * list is returned. 1853 * 1854 * @see #MATCH_DEFAULT_ONLY 1855 * @see #GET_INTENT_FILTERS 1856 * @see #GET_RESOLVED_FILTER 1857 */ queryIntentActivities(Intent intent, int flags)1858 public abstract List<ResolveInfo> queryIntentActivities(Intent intent, 1859 int flags); 1860 1861 /** 1862 * Retrieve all activities that can be performed for the given intent, for a specific user. 1863 * 1864 * @param intent The desired intent as per resolveActivity(). 1865 * @param flags Additional option flags. The most important is 1866 * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only 1867 * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}. 1868 * 1869 * @return A List<ResolveInfo> containing one entry for each matching 1870 * Activity. These are ordered from best to worst match -- that 1871 * is, the first item in the list is what is returned by 1872 * {@link #resolveActivity}. If there are no matching activities, an empty 1873 * list is returned. 1874 * 1875 * @see #MATCH_DEFAULT_ONLY 1876 * @see #GET_INTENT_FILTERS 1877 * @see #GET_RESOLVED_FILTER 1878 * @hide 1879 */ queryIntentActivitiesAsUser(Intent intent, int flags, int userId)1880 public abstract List<ResolveInfo> queryIntentActivitiesAsUser(Intent intent, 1881 int flags, int userId); 1882 1883 1884 /** 1885 * Retrieve a set of activities that should be presented to the user as 1886 * similar options. This is like {@link #queryIntentActivities}, except it 1887 * also allows you to supply a list of more explicit Intents that you would 1888 * like to resolve to particular options, and takes care of returning the 1889 * final ResolveInfo list in a reasonable order, with no duplicates, based 1890 * on those inputs. 1891 * 1892 * @param caller The class name of the activity that is making the 1893 * request. This activity will never appear in the output 1894 * list. Can be null. 1895 * @param specifics An array of Intents that should be resolved to the 1896 * first specific results. Can be null. 1897 * @param intent The desired intent as per resolveActivity(). 1898 * @param flags Additional option flags. The most important is 1899 * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only 1900 * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}. 1901 * 1902 * @return A List<ResolveInfo> containing one entry for each matching 1903 * Activity. These are ordered first by all of the intents resolved 1904 * in <var>specifics</var> and then any additional activities that 1905 * can handle <var>intent</var> but did not get included by one of 1906 * the <var>specifics</var> intents. If there are no matching 1907 * activities, an empty list is returned. 1908 * 1909 * @see #MATCH_DEFAULT_ONLY 1910 * @see #GET_INTENT_FILTERS 1911 * @see #GET_RESOLVED_FILTER 1912 */ queryIntentActivityOptions( ComponentName caller, Intent[] specifics, Intent intent, int flags)1913 public abstract List<ResolveInfo> queryIntentActivityOptions( 1914 ComponentName caller, Intent[] specifics, Intent intent, int flags); 1915 1916 /** 1917 * Retrieve all receivers that can handle a broadcast of the given intent. 1918 * 1919 * @param intent The desired intent as per resolveActivity(). 1920 * @param flags Additional option flags. 1921 * 1922 * @return A List<ResolveInfo> containing one entry for each matching 1923 * Receiver. These are ordered from first to last in priority. If 1924 * there are no matching receivers, an empty list is returned. 1925 * 1926 * @see #MATCH_DEFAULT_ONLY 1927 * @see #GET_INTENT_FILTERS 1928 * @see #GET_RESOLVED_FILTER 1929 */ queryBroadcastReceivers(Intent intent, int flags)1930 public abstract List<ResolveInfo> queryBroadcastReceivers(Intent intent, 1931 int flags); 1932 1933 /** 1934 * Retrieve all receivers that can handle a broadcast of the given intent, for a specific 1935 * user. 1936 * 1937 * @param intent The desired intent as per resolveActivity(). 1938 * @param flags Additional option flags. 1939 * @param userId The userId of the user being queried. 1940 * 1941 * @return A List<ResolveInfo> containing one entry for each matching 1942 * Receiver. These are ordered from first to last in priority. If 1943 * there are no matching receivers, an empty list is returned. 1944 * 1945 * @see #MATCH_DEFAULT_ONLY 1946 * @see #GET_INTENT_FILTERS 1947 * @see #GET_RESOLVED_FILTER 1948 * @hide 1949 */ queryBroadcastReceivers(Intent intent, int flags, int userId)1950 public abstract List<ResolveInfo> queryBroadcastReceivers(Intent intent, 1951 int flags, int userId); 1952 1953 /** 1954 * Determine the best service to handle for a given Intent. 1955 * 1956 * @param intent An intent containing all of the desired specification 1957 * (action, data, type, category, and/or component). 1958 * @param flags Additional option flags. 1959 * 1960 * @return Returns a ResolveInfo containing the final service intent that 1961 * was determined to be the best action. Returns null if no 1962 * matching service was found. 1963 * 1964 * @see #GET_INTENT_FILTERS 1965 * @see #GET_RESOLVED_FILTER 1966 */ resolveService(Intent intent, int flags)1967 public abstract ResolveInfo resolveService(Intent intent, int flags); 1968 1969 /** 1970 * Retrieve all services that can match the given intent. 1971 * 1972 * @param intent The desired intent as per resolveService(). 1973 * @param flags Additional option flags. 1974 * 1975 * @return A List<ResolveInfo> containing one entry for each matching 1976 * ServiceInfo. These are ordered from best to worst match -- that 1977 * is, the first item in the list is what is returned by 1978 * resolveService(). If there are no matching services, an empty 1979 * list is returned. 1980 * 1981 * @see #GET_INTENT_FILTERS 1982 * @see #GET_RESOLVED_FILTER 1983 */ queryIntentServices(Intent intent, int flags)1984 public abstract List<ResolveInfo> queryIntentServices(Intent intent, 1985 int flags); 1986 1987 /** 1988 * Retrieve all services that can match the given intent for a given user. 1989 * 1990 * @param intent The desired intent as per resolveService(). 1991 * @param flags Additional option flags. 1992 * @param userId The user id. 1993 * 1994 * @return A List<ResolveInfo> containing one entry for each matching 1995 * ServiceInfo. These are ordered from best to worst match -- that 1996 * is, the first item in the list is what is returned by 1997 * resolveService(). If there are no matching services, an empty 1998 * list is returned. 1999 * 2000 * @see #GET_INTENT_FILTERS 2001 * @see #GET_RESOLVED_FILTER 2002 * 2003 * @hide 2004 */ queryIntentServicesAsUser(Intent intent, int flags, int userId)2005 public abstract List<ResolveInfo> queryIntentServicesAsUser(Intent intent, 2006 int flags, int userId); 2007 2008 /** 2009 * Find a single content provider by its base path name. 2010 * 2011 * @param name The name of the provider to find. 2012 * @param flags Additional option flags. Currently should always be 0. 2013 * 2014 * @return ContentProviderInfo Information about the provider, if found, 2015 * else null. 2016 */ resolveContentProvider(String name, int flags)2017 public abstract ProviderInfo resolveContentProvider(String name, 2018 int flags); 2019 2020 /** 2021 * Retrieve content provider information. 2022 * 2023 * <p><em>Note: unlike most other methods, an empty result set is indicated 2024 * by a null return instead of an empty list.</em> 2025 * 2026 * @param processName If non-null, limits the returned providers to only 2027 * those that are hosted by the given process. If null, 2028 * all content providers are returned. 2029 * @param uid If <var>processName</var> is non-null, this is the required 2030 * uid owning the requested content providers. 2031 * @param flags Additional option flags. Currently should always be 0. 2032 * 2033 * @return A List<ContentProviderInfo> containing one entry for each 2034 * content provider either patching <var>processName</var> or, if 2035 * <var>processName</var> is null, all known content providers. 2036 * <em>If there are no matching providers, null is returned.</em> 2037 */ queryContentProviders( String processName, int uid, int flags)2038 public abstract List<ProviderInfo> queryContentProviders( 2039 String processName, int uid, int flags); 2040 2041 /** 2042 * Retrieve all of the information we know about a particular 2043 * instrumentation class. 2044 * 2045 * <p>Throws {@link NameNotFoundException} if instrumentation with the 2046 * given class name can not be found on the system. 2047 * 2048 * @param className The full name (i.e. 2049 * com.google.apps.contacts.InstrumentList) of an 2050 * Instrumentation class. 2051 * @param flags Additional option flags. Currently should always be 0. 2052 * 2053 * @return InstrumentationInfo containing information about the 2054 * instrumentation. 2055 */ getInstrumentationInfo( ComponentName className, int flags)2056 public abstract InstrumentationInfo getInstrumentationInfo( 2057 ComponentName className, int flags) throws NameNotFoundException; 2058 2059 /** 2060 * Retrieve information about available instrumentation code. May be used 2061 * to retrieve either all instrumentation code, or only the code targeting 2062 * a particular package. 2063 * 2064 * @param targetPackage If null, all instrumentation is returned; only the 2065 * instrumentation targeting this package name is 2066 * returned. 2067 * @param flags Additional option flags. Currently should always be 0. 2068 * 2069 * @return A List<InstrumentationInfo> containing one entry for each 2070 * matching available Instrumentation. Returns an empty list if 2071 * there is no instrumentation available for the given package. 2072 */ queryInstrumentation( String targetPackage, int flags)2073 public abstract List<InstrumentationInfo> queryInstrumentation( 2074 String targetPackage, int flags); 2075 2076 /** 2077 * Retrieve an image from a package. This is a low-level API used by 2078 * the various package manager info structures (such as 2079 * {@link ComponentInfo} to implement retrieval of their associated 2080 * icon. 2081 * 2082 * @param packageName The name of the package that this icon is coming from. 2083 * Can not be null. 2084 * @param resid The resource identifier of the desired image. Can not be 0. 2085 * @param appInfo Overall information about <var>packageName</var>. This 2086 * may be null, in which case the application information will be retrieved 2087 * for you if needed; if you already have this information around, it can 2088 * be much more efficient to supply it here. 2089 * 2090 * @return Returns a Drawable holding the requested image. Returns null if 2091 * an image could not be found for any reason. 2092 */ getDrawable(String packageName, int resid, ApplicationInfo appInfo)2093 public abstract Drawable getDrawable(String packageName, int resid, 2094 ApplicationInfo appInfo); 2095 2096 /** 2097 * Retrieve the icon associated with an activity. Given the full name of 2098 * an activity, retrieves the information about it and calls 2099 * {@link ComponentInfo#loadIcon ComponentInfo.loadIcon()} to return its icon. 2100 * If the activity can not be found, NameNotFoundException is thrown. 2101 * 2102 * @param activityName Name of the activity whose icon is to be retrieved. 2103 * 2104 * @return Returns the image of the icon, or the default activity icon if 2105 * it could not be found. Does not return null. 2106 * @throws NameNotFoundException Thrown if the resources for the given 2107 * activity could not be loaded. 2108 * 2109 * @see #getActivityIcon(Intent) 2110 */ getActivityIcon(ComponentName activityName)2111 public abstract Drawable getActivityIcon(ComponentName activityName) 2112 throws NameNotFoundException; 2113 2114 /** 2115 * Retrieve the icon associated with an Intent. If intent.getClassName() is 2116 * set, this simply returns the result of 2117 * getActivityIcon(intent.getClassName()). Otherwise it resolves the intent's 2118 * component and returns the icon associated with the resolved component. 2119 * If intent.getClassName() can not be found or the Intent can not be resolved 2120 * to a component, NameNotFoundException is thrown. 2121 * 2122 * @param intent The intent for which you would like to retrieve an icon. 2123 * 2124 * @return Returns the image of the icon, or the default activity icon if 2125 * it could not be found. Does not return null. 2126 * @throws NameNotFoundException Thrown if the resources for application 2127 * matching the given intent could not be loaded. 2128 * 2129 * @see #getActivityIcon(ComponentName) 2130 */ getActivityIcon(Intent intent)2131 public abstract Drawable getActivityIcon(Intent intent) 2132 throws NameNotFoundException; 2133 2134 /** 2135 * Return the generic icon for an activity that is used when no specific 2136 * icon is defined. 2137 * 2138 * @return Drawable Image of the icon. 2139 */ getDefaultActivityIcon()2140 public abstract Drawable getDefaultActivityIcon(); 2141 2142 /** 2143 * Retrieve the icon associated with an application. If it has not defined 2144 * an icon, the default app icon is returned. Does not return null. 2145 * 2146 * @param info Information about application being queried. 2147 * 2148 * @return Returns the image of the icon, or the default application icon 2149 * if it could not be found. 2150 * 2151 * @see #getApplicationIcon(String) 2152 */ getApplicationIcon(ApplicationInfo info)2153 public abstract Drawable getApplicationIcon(ApplicationInfo info); 2154 2155 /** 2156 * Retrieve the icon associated with an application. Given the name of the 2157 * application's package, retrieves the information about it and calls 2158 * getApplicationIcon() to return its icon. If the application can not be 2159 * found, NameNotFoundException is thrown. 2160 * 2161 * @param packageName Name of the package whose application icon is to be 2162 * retrieved. 2163 * 2164 * @return Returns the image of the icon, or the default application icon 2165 * if it could not be found. Does not return null. 2166 * @throws NameNotFoundException Thrown if the resources for the given 2167 * application could not be loaded. 2168 * 2169 * @see #getApplicationIcon(ApplicationInfo) 2170 */ getApplicationIcon(String packageName)2171 public abstract Drawable getApplicationIcon(String packageName) 2172 throws NameNotFoundException; 2173 2174 /** 2175 * Retrieve the logo associated with an activity. Given the full name of 2176 * an activity, retrieves the information about it and calls 2177 * {@link ComponentInfo#loadLogo ComponentInfo.loadLogo()} to return its logo. 2178 * If the activity can not be found, NameNotFoundException is thrown. 2179 * 2180 * @param activityName Name of the activity whose logo is to be retrieved. 2181 * 2182 * @return Returns the image of the logo or null if the activity has no 2183 * logo specified. 2184 * 2185 * @throws NameNotFoundException Thrown if the resources for the given 2186 * activity could not be loaded. 2187 * 2188 * @see #getActivityLogo(Intent) 2189 */ getActivityLogo(ComponentName activityName)2190 public abstract Drawable getActivityLogo(ComponentName activityName) 2191 throws NameNotFoundException; 2192 2193 /** 2194 * Retrieve the logo associated with an Intent. If intent.getClassName() is 2195 * set, this simply returns the result of 2196 * getActivityLogo(intent.getClassName()). Otherwise it resolves the intent's 2197 * component and returns the logo associated with the resolved component. 2198 * If intent.getClassName() can not be found or the Intent can not be resolved 2199 * to a component, NameNotFoundException is thrown. 2200 * 2201 * @param intent The intent for which you would like to retrieve a logo. 2202 * 2203 * @return Returns the image of the logo, or null if the activity has no 2204 * logo specified. 2205 * 2206 * @throws NameNotFoundException Thrown if the resources for application 2207 * matching the given intent could not be loaded. 2208 * 2209 * @see #getActivityLogo(ComponentName) 2210 */ getActivityLogo(Intent intent)2211 public abstract Drawable getActivityLogo(Intent intent) 2212 throws NameNotFoundException; 2213 2214 /** 2215 * Retrieve the logo associated with an application. If it has not specified 2216 * a logo, this method returns null. 2217 * 2218 * @param info Information about application being queried. 2219 * 2220 * @return Returns the image of the logo, or null if no logo is specified 2221 * by the application. 2222 * 2223 * @see #getApplicationLogo(String) 2224 */ getApplicationLogo(ApplicationInfo info)2225 public abstract Drawable getApplicationLogo(ApplicationInfo info); 2226 2227 /** 2228 * Retrieve the logo associated with an application. Given the name of the 2229 * application's package, retrieves the information about it and calls 2230 * getApplicationLogo() to return its logo. If the application can not be 2231 * found, NameNotFoundException is thrown. 2232 * 2233 * @param packageName Name of the package whose application logo is to be 2234 * retrieved. 2235 * 2236 * @return Returns the image of the logo, or null if no application logo 2237 * has been specified. 2238 * 2239 * @throws NameNotFoundException Thrown if the resources for the given 2240 * application could not be loaded. 2241 * 2242 * @see #getApplicationLogo(ApplicationInfo) 2243 */ getApplicationLogo(String packageName)2244 public abstract Drawable getApplicationLogo(String packageName) 2245 throws NameNotFoundException; 2246 2247 /** 2248 * Retrieve text from a package. This is a low-level API used by 2249 * the various package manager info structures (such as 2250 * {@link ComponentInfo} to implement retrieval of their associated 2251 * labels and other text. 2252 * 2253 * @param packageName The name of the package that this text is coming from. 2254 * Can not be null. 2255 * @param resid The resource identifier of the desired text. Can not be 0. 2256 * @param appInfo Overall information about <var>packageName</var>. This 2257 * may be null, in which case the application information will be retrieved 2258 * for you if needed; if you already have this information around, it can 2259 * be much more efficient to supply it here. 2260 * 2261 * @return Returns a CharSequence holding the requested text. Returns null 2262 * if the text could not be found for any reason. 2263 */ getText(String packageName, int resid, ApplicationInfo appInfo)2264 public abstract CharSequence getText(String packageName, int resid, 2265 ApplicationInfo appInfo); 2266 2267 /** 2268 * Retrieve an XML file from a package. This is a low-level API used to 2269 * retrieve XML meta data. 2270 * 2271 * @param packageName The name of the package that this xml is coming from. 2272 * Can not be null. 2273 * @param resid The resource identifier of the desired xml. Can not be 0. 2274 * @param appInfo Overall information about <var>packageName</var>. This 2275 * may be null, in which case the application information will be retrieved 2276 * for you if needed; if you already have this information around, it can 2277 * be much more efficient to supply it here. 2278 * 2279 * @return Returns an XmlPullParser allowing you to parse out the XML 2280 * data. Returns null if the xml resource could not be found for any 2281 * reason. 2282 */ getXml(String packageName, int resid, ApplicationInfo appInfo)2283 public abstract XmlResourceParser getXml(String packageName, int resid, 2284 ApplicationInfo appInfo); 2285 2286 /** 2287 * Return the label to use for this application. 2288 * 2289 * @return Returns the label associated with this application, or null if 2290 * it could not be found for any reason. 2291 * @param info The application to get the label of 2292 */ getApplicationLabel(ApplicationInfo info)2293 public abstract CharSequence getApplicationLabel(ApplicationInfo info); 2294 2295 /** 2296 * Retrieve the resources associated with an activity. Given the full 2297 * name of an activity, retrieves the information about it and calls 2298 * getResources() to return its application's resources. If the activity 2299 * can not be found, NameNotFoundException is thrown. 2300 * 2301 * @param activityName Name of the activity whose resources are to be 2302 * retrieved. 2303 * 2304 * @return Returns the application's Resources. 2305 * @throws NameNotFoundException Thrown if the resources for the given 2306 * application could not be loaded. 2307 * 2308 * @see #getResourcesForApplication(ApplicationInfo) 2309 */ getResourcesForActivity(ComponentName activityName)2310 public abstract Resources getResourcesForActivity(ComponentName activityName) 2311 throws NameNotFoundException; 2312 2313 /** 2314 * Retrieve the resources for an application. Throws NameNotFoundException 2315 * if the package is no longer installed. 2316 * 2317 * @param app Information about the desired application. 2318 * 2319 * @return Returns the application's Resources. 2320 * @throws NameNotFoundException Thrown if the resources for the given 2321 * application could not be loaded (most likely because it was uninstalled). 2322 */ getResourcesForApplication(ApplicationInfo app)2323 public abstract Resources getResourcesForApplication(ApplicationInfo app) 2324 throws NameNotFoundException; 2325 2326 /** 2327 * Retrieve the resources associated with an application. Given the full 2328 * package name of an application, retrieves the information about it and 2329 * calls getResources() to return its application's resources. If the 2330 * appPackageName can not be found, NameNotFoundException is thrown. 2331 * 2332 * @param appPackageName Package name of the application whose resources 2333 * are to be retrieved. 2334 * 2335 * @return Returns the application's Resources. 2336 * @throws NameNotFoundException Thrown if the resources for the given 2337 * application could not be loaded. 2338 * 2339 * @see #getResourcesForApplication(ApplicationInfo) 2340 */ getResourcesForApplication(String appPackageName)2341 public abstract Resources getResourcesForApplication(String appPackageName) 2342 throws NameNotFoundException; 2343 2344 /** @hide */ getResourcesForApplicationAsUser(String appPackageName, int userId)2345 public abstract Resources getResourcesForApplicationAsUser(String appPackageName, int userId) 2346 throws NameNotFoundException; 2347 2348 /** 2349 * Retrieve overall information about an application package defined 2350 * in a package archive file 2351 * 2352 * @param archiveFilePath The path to the archive file 2353 * @param flags Additional option flags. Use any combination of 2354 * {@link #GET_ACTIVITIES}, 2355 * {@link #GET_GIDS}, 2356 * {@link #GET_CONFIGURATIONS}, 2357 * {@link #GET_INSTRUMENTATION}, 2358 * {@link #GET_PERMISSIONS}, 2359 * {@link #GET_PROVIDERS}, 2360 * {@link #GET_RECEIVERS}, 2361 * {@link #GET_SERVICES}, 2362 * {@link #GET_SIGNATURES}, to modify the data returned. 2363 * 2364 * @return Returns the information about the package. Returns 2365 * null if the package could not be successfully parsed. 2366 * 2367 * @see #GET_ACTIVITIES 2368 * @see #GET_GIDS 2369 * @see #GET_CONFIGURATIONS 2370 * @see #GET_INSTRUMENTATION 2371 * @see #GET_PERMISSIONS 2372 * @see #GET_PROVIDERS 2373 * @see #GET_RECEIVERS 2374 * @see #GET_SERVICES 2375 * @see #GET_SIGNATURES 2376 * 2377 */ getPackageArchiveInfo(String archiveFilePath, int flags)2378 public PackageInfo getPackageArchiveInfo(String archiveFilePath, int flags) { 2379 PackageParser packageParser = new PackageParser(archiveFilePath); 2380 DisplayMetrics metrics = new DisplayMetrics(); 2381 metrics.setToDefaults(); 2382 final File sourceFile = new File(archiveFilePath); 2383 PackageParser.Package pkg = packageParser.parsePackage( 2384 sourceFile, archiveFilePath, metrics, 0); 2385 if (pkg == null) { 2386 return null; 2387 } 2388 if ((flags & GET_SIGNATURES) != 0) { 2389 packageParser.collectCertificates(pkg, 0); 2390 } 2391 PackageUserState state = new PackageUserState(); 2392 return PackageParser.generatePackageInfo(pkg, null, flags, 0, 0, null, state); 2393 } 2394 2395 /** 2396 * @hide 2397 * 2398 * Install a package. Since this may take a little while, the result will 2399 * be posted back to the given observer. An installation will fail if the calling context 2400 * lacks the {@link android.Manifest.permission#INSTALL_PACKAGES} permission, if the 2401 * package named in the package file's manifest is already installed, or if there's no space 2402 * available on the device. 2403 * 2404 * @param packageURI The location of the package file to install. This can be a 'file:' or a 2405 * 'content:' URI. 2406 * @param observer An observer callback to get notified when the package installation is 2407 * complete. {@link IPackageInstallObserver#packageInstalled(String, int)} will be 2408 * called when that happens. observer may be null to indicate that no callback is desired. 2409 * @param flags - possible values: {@link #INSTALL_FORWARD_LOCK}, 2410 * {@link #INSTALL_REPLACE_EXISTING}, {@link #INSTALL_ALLOW_TEST}. 2411 * @param installerPackageName Optional package name of the application that is performing the 2412 * installation. This identifies which market the package came from. 2413 */ installPackage( Uri packageURI, IPackageInstallObserver observer, int flags, String installerPackageName)2414 public abstract void installPackage( 2415 Uri packageURI, IPackageInstallObserver observer, int flags, 2416 String installerPackageName); 2417 2418 /** 2419 * Similar to 2420 * {@link #installPackage(Uri, IPackageInstallObserver, int, String)} but 2421 * with an extra verification file provided. 2422 * 2423 * @param packageURI The location of the package file to install. This can 2424 * be a 'file:' or a 'content:' URI. 2425 * @param observer An observer callback to get notified when the package 2426 * installation is complete. 2427 * {@link IPackageInstallObserver#packageInstalled(String, int)} 2428 * will be called when that happens. observer may be null to 2429 * indicate that no callback is desired. 2430 * @param flags - possible values: {@link #INSTALL_FORWARD_LOCK}, 2431 * {@link #INSTALL_REPLACE_EXISTING}, {@link #INSTALL_ALLOW_TEST} 2432 * . 2433 * @param installerPackageName Optional package name of the application that 2434 * is performing the installation. This identifies which market 2435 * the package came from. 2436 * @param verificationURI The location of the supplementary verification 2437 * file. This can be a 'file:' or a 'content:' URI. May be 2438 * {@code null}. 2439 * @param manifestDigest an object that holds the digest of the package 2440 * which can be used to verify ownership. May be {@code null}. 2441 * @param encryptionParams if the package to be installed is encrypted, 2442 * these parameters describing the encryption and authentication 2443 * used. May be {@code null}. 2444 * @hide 2445 */ installPackageWithVerification(Uri packageURI, IPackageInstallObserver observer, int flags, String installerPackageName, Uri verificationURI, ManifestDigest manifestDigest, ContainerEncryptionParams encryptionParams)2446 public abstract void installPackageWithVerification(Uri packageURI, 2447 IPackageInstallObserver observer, int flags, String installerPackageName, 2448 Uri verificationURI, ManifestDigest manifestDigest, 2449 ContainerEncryptionParams encryptionParams); 2450 2451 /** 2452 * Similar to 2453 * {@link #installPackage(Uri, IPackageInstallObserver, int, String)} but 2454 * with an extra verification information provided. 2455 * 2456 * @param packageURI The location of the package file to install. This can 2457 * be a 'file:' or a 'content:' URI. 2458 * @param observer An observer callback to get notified when the package 2459 * installation is complete. 2460 * {@link IPackageInstallObserver#packageInstalled(String, int)} 2461 * will be called when that happens. observer may be null to 2462 * indicate that no callback is desired. 2463 * @param flags - possible values: {@link #INSTALL_FORWARD_LOCK}, 2464 * {@link #INSTALL_REPLACE_EXISTING}, {@link #INSTALL_ALLOW_TEST} 2465 * . 2466 * @param installerPackageName Optional package name of the application that 2467 * is performing the installation. This identifies which market 2468 * the package came from. 2469 * @param verificationParams an object that holds signal information to 2470 * assist verification. May be {@code null}. 2471 * @param encryptionParams if the package to be installed is encrypted, 2472 * these parameters describing the encryption and authentication 2473 * used. May be {@code null}. 2474 * 2475 * @hide 2476 */ installPackageWithVerificationAndEncryption(Uri packageURI, IPackageInstallObserver observer, int flags, String installerPackageName, VerificationParams verificationParams, ContainerEncryptionParams encryptionParams)2477 public abstract void installPackageWithVerificationAndEncryption(Uri packageURI, 2478 IPackageInstallObserver observer, int flags, String installerPackageName, 2479 VerificationParams verificationParams, 2480 ContainerEncryptionParams encryptionParams); 2481 2482 /** 2483 * If there is already an application with the given package name installed 2484 * on the system for other users, also install it for the calling user. 2485 * @hide 2486 */ installExistingPackage(String packageName)2487 public abstract int installExistingPackage(String packageName) 2488 throws NameNotFoundException; 2489 2490 /** 2491 * Allows a package listening to the 2492 * {@link Intent#ACTION_PACKAGE_NEEDS_VERIFICATION package verification 2493 * broadcast} to respond to the package manager. The response must include 2494 * the {@code verificationCode} which is one of 2495 * {@link PackageManager#VERIFICATION_ALLOW} or 2496 * {@link PackageManager#VERIFICATION_REJECT}. 2497 * 2498 * @param id pending package identifier as passed via the 2499 * {@link PackageManager#EXTRA_VERIFICATION_ID} Intent extra 2500 * @param verificationCode either {@link PackageManager#VERIFICATION_ALLOW} 2501 * or {@link PackageManager#VERIFICATION_REJECT}. 2502 * @throws SecurityException if the caller does not have the 2503 * PACKAGE_VERIFICATION_AGENT permission. 2504 */ verifyPendingInstall(int id, int verificationCode)2505 public abstract void verifyPendingInstall(int id, int verificationCode); 2506 2507 /** 2508 * Allows a package listening to the 2509 * {@link Intent#ACTION_PACKAGE_NEEDS_VERIFICATION package verification 2510 * broadcast} to extend the default timeout for a response and declare what 2511 * action to perform after the timeout occurs. The response must include 2512 * the {@code verificationCodeAtTimeout} which is one of 2513 * {@link PackageManager#VERIFICATION_ALLOW} or 2514 * {@link PackageManager#VERIFICATION_REJECT}. 2515 * 2516 * This method may only be called once per package id. Additional calls 2517 * will have no effect. 2518 * 2519 * @param id pending package identifier as passed via the 2520 * {@link PackageManager#EXTRA_VERIFICATION_ID} Intent extra 2521 * @param verificationCodeAtTimeout either 2522 * {@link PackageManager#VERIFICATION_ALLOW} or 2523 * {@link PackageManager#VERIFICATION_REJECT}. If 2524 * {@code verificationCodeAtTimeout} is neither 2525 * {@link PackageManager#VERIFICATION_ALLOW} or 2526 * {@link PackageManager#VERIFICATION_REJECT}, then 2527 * {@code verificationCodeAtTimeout} will default to 2528 * {@link PackageManager#VERIFICATION_REJECT}. 2529 * @param millisecondsToDelay the amount of time requested for the timeout. 2530 * Must be positive and less than 2531 * {@link PackageManager#MAXIMUM_VERIFICATION_TIMEOUT}. If 2532 * {@code millisecondsToDelay} is out of bounds, 2533 * {@code millisecondsToDelay} will be set to the closest in 2534 * bounds value; namely, 0 or 2535 * {@link PackageManager#MAXIMUM_VERIFICATION_TIMEOUT}. 2536 * @throws SecurityException if the caller does not have the 2537 * PACKAGE_VERIFICATION_AGENT permission. 2538 */ extendVerificationTimeout(int id, int verificationCodeAtTimeout, long millisecondsToDelay)2539 public abstract void extendVerificationTimeout(int id, 2540 int verificationCodeAtTimeout, long millisecondsToDelay); 2541 2542 /** 2543 * Change the installer associated with a given package. There are limitations 2544 * on how the installer package can be changed; in particular: 2545 * <ul> 2546 * <li> A SecurityException will be thrown if <var>installerPackageName</var> 2547 * is not signed with the same certificate as the calling application. 2548 * <li> A SecurityException will be thrown if <var>targetPackage</var> already 2549 * has an installer package, and that installer package is not signed with 2550 * the same certificate as the calling application. 2551 * </ul> 2552 * 2553 * @param targetPackage The installed package whose installer will be changed. 2554 * @param installerPackageName The package name of the new installer. May be 2555 * null to clear the association. 2556 */ setInstallerPackageName(String targetPackage, String installerPackageName)2557 public abstract void setInstallerPackageName(String targetPackage, 2558 String installerPackageName); 2559 2560 /** 2561 * Attempts to delete a package. Since this may take a little while, the result will 2562 * be posted back to the given observer. A deletion will fail if the calling context 2563 * lacks the {@link android.Manifest.permission#DELETE_PACKAGES} permission, if the 2564 * named package cannot be found, or if the named package is a "system package". 2565 * (TODO: include pointer to documentation on "system packages") 2566 * 2567 * @param packageName The name of the package to delete 2568 * @param observer An observer callback to get notified when the package deletion is 2569 * complete. {@link android.content.pm.IPackageDeleteObserver#packageDeleted(boolean)} will be 2570 * called when that happens. observer may be null to indicate that no callback is desired. 2571 * @param flags - possible values: {@link #DELETE_KEEP_DATA}, 2572 * {@link #DELETE_ALL_USERS}. 2573 * 2574 * @hide 2575 */ deletePackage( String packageName, IPackageDeleteObserver observer, int flags)2576 public abstract void deletePackage( 2577 String packageName, IPackageDeleteObserver observer, int flags); 2578 2579 /** 2580 * Retrieve the package name of the application that installed a package. This identifies 2581 * which market the package came from. 2582 * 2583 * @param packageName The name of the package to query 2584 */ getInstallerPackageName(String packageName)2585 public abstract String getInstallerPackageName(String packageName); 2586 2587 /** 2588 * Attempts to clear the user data directory of an application. 2589 * Since this may take a little while, the result will 2590 * be posted back to the given observer. A deletion will fail if the 2591 * named package cannot be found, or if the named package is a "system package". 2592 * 2593 * @param packageName The name of the package 2594 * @param observer An observer callback to get notified when the operation is finished 2595 * {@link android.content.pm.IPackageDataObserver#onRemoveCompleted(String, boolean)} 2596 * will be called when that happens. observer may be null to indicate that 2597 * no callback is desired. 2598 * 2599 * @hide 2600 */ clearApplicationUserData(String packageName, IPackageDataObserver observer)2601 public abstract void clearApplicationUserData(String packageName, 2602 IPackageDataObserver observer); 2603 /** 2604 * Attempts to delete the cache files associated with an application. 2605 * Since this may take a little while, the result will 2606 * be posted back to the given observer. A deletion will fail if the calling context 2607 * lacks the {@link android.Manifest.permission#DELETE_CACHE_FILES} permission, if the 2608 * named package cannot be found, or if the named package is a "system package". 2609 * 2610 * @param packageName The name of the package to delete 2611 * @param observer An observer callback to get notified when the cache file deletion 2612 * is complete. 2613 * {@link android.content.pm.IPackageDataObserver#onRemoveCompleted(String, boolean)} 2614 * will be called when that happens. observer may be null to indicate that 2615 * no callback is desired. 2616 * 2617 * @hide 2618 */ deleteApplicationCacheFiles(String packageName, IPackageDataObserver observer)2619 public abstract void deleteApplicationCacheFiles(String packageName, 2620 IPackageDataObserver observer); 2621 2622 /** 2623 * Free storage by deleting LRU sorted list of cache files across 2624 * all applications. If the currently available free storage 2625 * on the device is greater than or equal to the requested 2626 * free storage, no cache files are cleared. If the currently 2627 * available storage on the device is less than the requested 2628 * free storage, some or all of the cache files across 2629 * all applications are deleted (based on last accessed time) 2630 * to increase the free storage space on the device to 2631 * the requested value. There is no guarantee that clearing all 2632 * the cache files from all applications will clear up 2633 * enough storage to achieve the desired value. 2634 * @param freeStorageSize The number of bytes of storage to be 2635 * freed by the system. Say if freeStorageSize is XX, 2636 * and the current free storage is YY, 2637 * if XX is less than YY, just return. if not free XX-YY number 2638 * of bytes if possible. 2639 * @param observer call back used to notify when 2640 * the operation is completed 2641 * 2642 * @hide 2643 */ freeStorageAndNotify(long freeStorageSize, IPackageDataObserver observer)2644 public abstract void freeStorageAndNotify(long freeStorageSize, IPackageDataObserver observer); 2645 2646 /** 2647 * Free storage by deleting LRU sorted list of cache files across 2648 * all applications. If the currently available free storage 2649 * on the device is greater than or equal to the requested 2650 * free storage, no cache files are cleared. If the currently 2651 * available storage on the device is less than the requested 2652 * free storage, some or all of the cache files across 2653 * all applications are deleted (based on last accessed time) 2654 * to increase the free storage space on the device to 2655 * the requested value. There is no guarantee that clearing all 2656 * the cache files from all applications will clear up 2657 * enough storage to achieve the desired value. 2658 * @param freeStorageSize The number of bytes of storage to be 2659 * freed by the system. Say if freeStorageSize is XX, 2660 * and the current free storage is YY, 2661 * if XX is less than YY, just return. if not free XX-YY number 2662 * of bytes if possible. 2663 * @param pi IntentSender call back used to 2664 * notify when the operation is completed.May be null 2665 * to indicate that no call back is desired. 2666 * 2667 * @hide 2668 */ freeStorage(long freeStorageSize, IntentSender pi)2669 public abstract void freeStorage(long freeStorageSize, IntentSender pi); 2670 2671 /** 2672 * Retrieve the size information for a package. 2673 * Since this may take a little while, the result will 2674 * be posted back to the given observer. The calling context 2675 * should have the {@link android.Manifest.permission#GET_PACKAGE_SIZE} permission. 2676 * 2677 * @param packageName The name of the package whose size information is to be retrieved 2678 * @param userHandle The user whose size information should be retrieved. 2679 * @param observer An observer callback to get notified when the operation 2680 * is complete. 2681 * {@link android.content.pm.IPackageStatsObserver#onGetStatsCompleted(PackageStats, boolean)} 2682 * The observer's callback is invoked with a PackageStats object(containing the 2683 * code, data and cache sizes of the package) and a boolean value representing 2684 * the status of the operation. observer may be null to indicate that 2685 * no callback is desired. 2686 * 2687 * @hide 2688 */ getPackageSizeInfo(String packageName, int userHandle, IPackageStatsObserver observer)2689 public abstract void getPackageSizeInfo(String packageName, int userHandle, 2690 IPackageStatsObserver observer); 2691 2692 /** 2693 * Like {@link #getPackageSizeInfo(String, int, IPackageStatsObserver)}, but 2694 * returns the size for the calling user. 2695 * 2696 * @hide 2697 */ getPackageSizeInfo(String packageName, IPackageStatsObserver observer)2698 public void getPackageSizeInfo(String packageName, IPackageStatsObserver observer) { 2699 getPackageSizeInfo(packageName, UserHandle.myUserId(), observer); 2700 } 2701 2702 /** 2703 * @deprecated This function no longer does anything; it was an old 2704 * approach to managing preferred activities, which has been superceeded 2705 * (and conflicts with) the modern activity-based preferences. 2706 */ 2707 @Deprecated addPackageToPreferred(String packageName)2708 public abstract void addPackageToPreferred(String packageName); 2709 2710 /** 2711 * @deprecated This function no longer does anything; it was an old 2712 * approach to managing preferred activities, which has been superceeded 2713 * (and conflicts with) the modern activity-based preferences. 2714 */ 2715 @Deprecated removePackageFromPreferred(String packageName)2716 public abstract void removePackageFromPreferred(String packageName); 2717 2718 /** 2719 * Retrieve the list of all currently configured preferred packages. The 2720 * first package on the list is the most preferred, the last is the 2721 * least preferred. 2722 * 2723 * @param flags Additional option flags. Use any combination of 2724 * {@link #GET_ACTIVITIES}, 2725 * {@link #GET_GIDS}, 2726 * {@link #GET_CONFIGURATIONS}, 2727 * {@link #GET_INSTRUMENTATION}, 2728 * {@link #GET_PERMISSIONS}, 2729 * {@link #GET_PROVIDERS}, 2730 * {@link #GET_RECEIVERS}, 2731 * {@link #GET_SERVICES}, 2732 * {@link #GET_SIGNATURES}, to modify the data returned. 2733 * 2734 * @return Returns a list of PackageInfo objects describing each 2735 * preferred application, in order of preference. 2736 * 2737 * @see #GET_ACTIVITIES 2738 * @see #GET_GIDS 2739 * @see #GET_CONFIGURATIONS 2740 * @see #GET_INSTRUMENTATION 2741 * @see #GET_PERMISSIONS 2742 * @see #GET_PROVIDERS 2743 * @see #GET_RECEIVERS 2744 * @see #GET_SERVICES 2745 * @see #GET_SIGNATURES 2746 */ getPreferredPackages(int flags)2747 public abstract List<PackageInfo> getPreferredPackages(int flags); 2748 2749 /** 2750 * @deprecated This is a protected API that should not have been available 2751 * to third party applications. It is the platform's responsibility for 2752 * assigning preferred activities and this can not be directly modified. 2753 * 2754 * Add a new preferred activity mapping to the system. This will be used 2755 * to automatically select the given activity component when 2756 * {@link Context#startActivity(Intent) Context.startActivity()} finds 2757 * multiple matching activities and also matches the given filter. 2758 * 2759 * @param filter The set of intents under which this activity will be 2760 * made preferred. 2761 * @param match The IntentFilter match category that this preference 2762 * applies to. 2763 * @param set The set of activities that the user was picking from when 2764 * this preference was made. 2765 * @param activity The component name of the activity that is to be 2766 * preferred. 2767 */ 2768 @Deprecated addPreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity)2769 public abstract void addPreferredActivity(IntentFilter filter, int match, 2770 ComponentName[] set, ComponentName activity); 2771 2772 /** 2773 * Same as {@link #addPreferredActivity(IntentFilter, int, 2774 ComponentName[], ComponentName)}, but with a specific userId to apply the preference 2775 to. 2776 * @hide 2777 */ addPreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity, int userId)2778 public void addPreferredActivity(IntentFilter filter, int match, 2779 ComponentName[] set, ComponentName activity, int userId) { 2780 throw new RuntimeException("Not implemented. Must override in a subclass."); 2781 } 2782 2783 /** 2784 * @deprecated This is a protected API that should not have been available 2785 * to third party applications. It is the platform's responsibility for 2786 * assigning preferred activities and this can not be directly modified. 2787 * 2788 * Replaces an existing preferred activity mapping to the system, and if that were not present 2789 * adds a new preferred activity. This will be used 2790 * to automatically select the given activity component when 2791 * {@link Context#startActivity(Intent) Context.startActivity()} finds 2792 * multiple matching activities and also matches the given filter. 2793 * 2794 * @param filter The set of intents under which this activity will be 2795 * made preferred. 2796 * @param match The IntentFilter match category that this preference 2797 * applies to. 2798 * @param set The set of activities that the user was picking from when 2799 * this preference was made. 2800 * @param activity The component name of the activity that is to be 2801 * preferred. 2802 * @hide 2803 */ 2804 @Deprecated replacePreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity)2805 public abstract void replacePreferredActivity(IntentFilter filter, int match, 2806 ComponentName[] set, ComponentName activity); 2807 2808 /** 2809 * Remove all preferred activity mappings, previously added with 2810 * {@link #addPreferredActivity}, from the 2811 * system whose activities are implemented in the given package name. 2812 * An application can only clear its own package(s). 2813 * 2814 * @param packageName The name of the package whose preferred activity 2815 * mappings are to be removed. 2816 */ clearPackagePreferredActivities(String packageName)2817 public abstract void clearPackagePreferredActivities(String packageName); 2818 2819 /** 2820 * Retrieve all preferred activities, previously added with 2821 * {@link #addPreferredActivity}, that are 2822 * currently registered with the system. 2823 * 2824 * @param outFilters A list in which to place the filters of all of the 2825 * preferred activities, or null for none. 2826 * @param outActivities A list in which to place the component names of 2827 * all of the preferred activities, or null for none. 2828 * @param packageName An option package in which you would like to limit 2829 * the list. If null, all activities will be returned; if non-null, only 2830 * those activities in the given package are returned. 2831 * 2832 * @return Returns the total number of registered preferred activities 2833 * (the number of distinct IntentFilter records, not the number of unique 2834 * activity components) that were found. 2835 */ getPreferredActivities(List<IntentFilter> outFilters, List<ComponentName> outActivities, String packageName)2836 public abstract int getPreferredActivities(List<IntentFilter> outFilters, 2837 List<ComponentName> outActivities, String packageName); 2838 2839 /** 2840 * Set the enabled setting for a package component (activity, receiver, service, provider). 2841 * This setting will override any enabled state which may have been set by the component in its 2842 * manifest. 2843 * 2844 * @param componentName The component to enable 2845 * @param newState The new enabled state for the component. The legal values for this state 2846 * are: 2847 * {@link #COMPONENT_ENABLED_STATE_ENABLED}, 2848 * {@link #COMPONENT_ENABLED_STATE_DISABLED} 2849 * and 2850 * {@link #COMPONENT_ENABLED_STATE_DEFAULT} 2851 * The last one removes the setting, thereby restoring the component's state to 2852 * whatever was set in it's manifest (or enabled, by default). 2853 * @param flags Optional behavior flags: {@link #DONT_KILL_APP} or 0. 2854 */ setComponentEnabledSetting(ComponentName componentName, int newState, int flags)2855 public abstract void setComponentEnabledSetting(ComponentName componentName, 2856 int newState, int flags); 2857 2858 2859 /** 2860 * Return the the enabled setting for a package component (activity, 2861 * receiver, service, provider). This returns the last value set by 2862 * {@link #setComponentEnabledSetting(ComponentName, int, int)}; in most 2863 * cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since 2864 * the value originally specified in the manifest has not been modified. 2865 * 2866 * @param componentName The component to retrieve. 2867 * @return Returns the current enabled state for the component. May 2868 * be one of {@link #COMPONENT_ENABLED_STATE_ENABLED}, 2869 * {@link #COMPONENT_ENABLED_STATE_DISABLED}, or 2870 * {@link #COMPONENT_ENABLED_STATE_DEFAULT}. The last one means the 2871 * component's enabled state is based on the original information in 2872 * the manifest as found in {@link ComponentInfo}. 2873 */ getComponentEnabledSetting(ComponentName componentName)2874 public abstract int getComponentEnabledSetting(ComponentName componentName); 2875 2876 /** 2877 * Set the enabled setting for an application 2878 * This setting will override any enabled state which may have been set by the application in 2879 * its manifest. It also overrides the enabled state set in the manifest for any of the 2880 * application's components. It does not override any enabled state set by 2881 * {@link #setComponentEnabledSetting} for any of the application's components. 2882 * 2883 * @param packageName The package name of the application to enable 2884 * @param newState The new enabled state for the component. The legal values for this state 2885 * are: 2886 * {@link #COMPONENT_ENABLED_STATE_ENABLED}, 2887 * {@link #COMPONENT_ENABLED_STATE_DISABLED} 2888 * and 2889 * {@link #COMPONENT_ENABLED_STATE_DEFAULT} 2890 * The last one removes the setting, thereby restoring the applications's state to 2891 * whatever was set in its manifest (or enabled, by default). 2892 * @param flags Optional behavior flags: {@link #DONT_KILL_APP} or 0. 2893 */ setApplicationEnabledSetting(String packageName, int newState, int flags)2894 public abstract void setApplicationEnabledSetting(String packageName, 2895 int newState, int flags); 2896 2897 /** 2898 * Return the the enabled setting for an application. This returns 2899 * the last value set by 2900 * {@link #setApplicationEnabledSetting(String, int, int)}; in most 2901 * cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since 2902 * the value originally specified in the manifest has not been modified. 2903 * 2904 * @param packageName The component to retrieve. 2905 * @return Returns the current enabled state for the component. May 2906 * be one of {@link #COMPONENT_ENABLED_STATE_ENABLED}, 2907 * {@link #COMPONENT_ENABLED_STATE_DISABLED}, or 2908 * {@link #COMPONENT_ENABLED_STATE_DEFAULT}. The last one means the 2909 * application's enabled state is based on the original information in 2910 * the manifest as found in {@link ComponentInfo}. 2911 * @throws IllegalArgumentException if the named package does not exist. 2912 */ getApplicationEnabledSetting(String packageName)2913 public abstract int getApplicationEnabledSetting(String packageName); 2914 2915 /** 2916 * Return whether the device has been booted into safe mode. 2917 */ isSafeMode()2918 public abstract boolean isSafeMode(); 2919 2920 /** 2921 * Attempts to move package resources from internal to external media or vice versa. 2922 * Since this may take a little while, the result will 2923 * be posted back to the given observer. This call may fail if the calling context 2924 * lacks the {@link android.Manifest.permission#MOVE_PACKAGE} permission, if the 2925 * named package cannot be found, or if the named package is a "system package". 2926 * 2927 * @param packageName The name of the package to delete 2928 * @param observer An observer callback to get notified when the package move is 2929 * complete. {@link android.content.pm.IPackageMoveObserver#packageMoved(boolean)} will be 2930 * called when that happens. observer may be null to indicate that no callback is desired. 2931 * @param flags To indicate install location {@link #MOVE_INTERNAL} or 2932 * {@link #MOVE_EXTERNAL_MEDIA} 2933 * 2934 * @hide 2935 */ movePackage( String packageName, IPackageMoveObserver observer, int flags)2936 public abstract void movePackage( 2937 String packageName, IPackageMoveObserver observer, int flags); 2938 2939 /** 2940 * Returns the device identity that verifiers can use to associate their scheme to a particular 2941 * device. This should not be used by anything other than a package verifier. 2942 * 2943 * @return identity that uniquely identifies current device 2944 * @hide 2945 */ getVerifierDeviceIdentity()2946 public abstract VerifierDeviceIdentity getVerifierDeviceIdentity(); 2947 2948 /** 2949 * Returns the data directory for a particular user and package, given the uid of the package. 2950 * @param uid uid of the package, including the userId and appId 2951 * @param packageName name of the package 2952 * @return the user-specific data directory for the package 2953 * @hide 2954 */ getDataDirForUser(int userId, String packageName)2955 public static String getDataDirForUser(int userId, String packageName) { 2956 // TODO: This should be shared with Installer's knowledge of user directory 2957 return Environment.getDataDirectory().toString() + "/user/" + userId 2958 + "/" + packageName; 2959 } 2960 } 2961