ApplicationInfo.java revision 8924e8759f9a8cffb5ad538ca40a7826793aac07
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.content.pm; 18 19import android.content.pm.PackageManager.NameNotFoundException; 20import android.content.res.Resources; 21import android.graphics.drawable.Drawable; 22import android.os.Environment; 23import android.os.Parcel; 24import android.os.Parcelable; 25import android.os.SystemProperties; 26import android.os.UserHandle; 27import android.os.storage.StorageManager; 28import android.text.TextUtils; 29import android.util.Printer; 30 31import com.android.internal.util.ArrayUtils; 32 33import java.text.Collator; 34import java.util.Arrays; 35import java.util.Comparator; 36import java.util.Objects; 37 38/** 39 * Information you can retrieve about a particular application. This 40 * corresponds to information collected from the AndroidManifest.xml's 41 * <application> tag. 42 */ 43public class ApplicationInfo extends PackageItemInfo implements Parcelable { 44 45 /** 46 * Default task affinity of all activities in this application. See 47 * {@link ActivityInfo#taskAffinity} for more information. This comes 48 * from the "taskAffinity" attribute. 49 */ 50 public String taskAffinity; 51 52 /** 53 * Optional name of a permission required to be able to access this 54 * application's components. From the "permission" attribute. 55 */ 56 public String permission; 57 58 /** 59 * The name of the process this application should run in. From the 60 * "process" attribute or, if not set, the same as 61 * <var>packageName</var>. 62 */ 63 public String processName; 64 65 /** 66 * Class implementing the Application object. From the "class" 67 * attribute. 68 */ 69 public String className; 70 71 /** 72 * A style resource identifier (in the package's resources) of the 73 * description of an application. From the "description" attribute 74 * or, if not set, 0. 75 */ 76 public int descriptionRes; 77 78 /** 79 * A style resource identifier (in the package's resources) of the 80 * default visual theme of the application. From the "theme" attribute 81 * or, if not set, 0. 82 */ 83 public int theme; 84 85 /** 86 * Class implementing the Application's manage space 87 * functionality. From the "manageSpaceActivity" 88 * attribute. This is an optional attribute and will be null if 89 * applications don't specify it in their manifest 90 */ 91 public String manageSpaceActivityName; 92 93 /** 94 * Class implementing the Application's backup functionality. From 95 * the "backupAgent" attribute. This is an optional attribute and 96 * will be null if the application does not specify it in its manifest. 97 * 98 * <p>If android:allowBackup is set to false, this attribute is ignored. 99 */ 100 public String backupAgentName; 101 102 /** 103 * An optional attribute that indicates the app supports automatic backup of app data. 104 * <p>0 is the default and means the app's entire data folder + managed external storage will 105 * be backed up; 106 * Any negative value indicates the app does not support full-data backup, though it may still 107 * want to participate via the traditional key/value backup API; 108 * A positive number specifies an xml resource in which the application has defined its backup 109 * include/exclude criteria. 110 * <p>If android:allowBackup is set to false, this attribute is ignored. 111 * 112 * @see {@link android.content.Context#getNoBackupFilesDir} 113 * @see {@link #FLAG_ALLOW_BACKUP} 114 * 115 * @hide 116 */ 117 public int fullBackupContent = 0; 118 119 /** 120 * The default extra UI options for activities in this application. 121 * Set from the {@link android.R.attr#uiOptions} attribute in the 122 * activity's manifest. 123 */ 124 public int uiOptions = 0; 125 126 /** 127 * Value for {@link #flags}: if set, this application is installed in the 128 * device's system image. 129 */ 130 public static final int FLAG_SYSTEM = 1<<0; 131 132 /** 133 * Value for {@link #flags}: set to true if this application would like to 134 * allow debugging of its 135 * code, even when installed on a non-development system. Comes 136 * from {@link android.R.styleable#AndroidManifestApplication_debuggable 137 * android:debuggable} of the <application> tag. 138 */ 139 public static final int FLAG_DEBUGGABLE = 1<<1; 140 141 /** 142 * Value for {@link #flags}: set to true if this application has code 143 * associated with it. Comes 144 * from {@link android.R.styleable#AndroidManifestApplication_hasCode 145 * android:hasCode} of the <application> tag. 146 */ 147 public static final int FLAG_HAS_CODE = 1<<2; 148 149 /** 150 * Value for {@link #flags}: set to true if this application is persistent. 151 * Comes from {@link android.R.styleable#AndroidManifestApplication_persistent 152 * android:persistent} of the <application> tag. 153 */ 154 public static final int FLAG_PERSISTENT = 1<<3; 155 156 /** 157 * Value for {@link #flags}: set to true if this application holds the 158 * {@link android.Manifest.permission#FACTORY_TEST} permission and the 159 * device is running in factory test mode. 160 */ 161 public static final int FLAG_FACTORY_TEST = 1<<4; 162 163 /** 164 * Value for {@link #flags}: default value for the corresponding ActivityInfo flag. 165 * Comes from {@link android.R.styleable#AndroidManifestApplication_allowTaskReparenting 166 * android:allowTaskReparenting} of the <application> tag. 167 */ 168 public static final int FLAG_ALLOW_TASK_REPARENTING = 1<<5; 169 170 /** 171 * Value for {@link #flags}: default value for the corresponding ActivityInfo flag. 172 * Comes from {@link android.R.styleable#AndroidManifestApplication_allowClearUserData 173 * android:allowClearUserData} of the <application> tag. 174 */ 175 public static final int FLAG_ALLOW_CLEAR_USER_DATA = 1<<6; 176 177 /** 178 * Value for {@link #flags}: this is set if this application has been 179 * install as an update to a built-in system application. 180 */ 181 public static final int FLAG_UPDATED_SYSTEM_APP = 1<<7; 182 183 /** 184 * Value for {@link #flags}: this is set of the application has specified 185 * {@link android.R.styleable#AndroidManifestApplication_testOnly 186 * android:testOnly} to be true. 187 */ 188 public static final int FLAG_TEST_ONLY = 1<<8; 189 190 /** 191 * Value for {@link #flags}: true when the application's window can be 192 * reduced in size for smaller screens. Corresponds to 193 * {@link android.R.styleable#AndroidManifestSupportsScreens_smallScreens 194 * android:smallScreens}. 195 */ 196 public static final int FLAG_SUPPORTS_SMALL_SCREENS = 1<<9; 197 198 /** 199 * Value for {@link #flags}: true when the application's window can be 200 * displayed on normal screens. Corresponds to 201 * {@link android.R.styleable#AndroidManifestSupportsScreens_normalScreens 202 * android:normalScreens}. 203 */ 204 public static final int FLAG_SUPPORTS_NORMAL_SCREENS = 1<<10; 205 206 /** 207 * Value for {@link #flags}: true when the application's window can be 208 * increased in size for larger screens. Corresponds to 209 * {@link android.R.styleable#AndroidManifestSupportsScreens_largeScreens 210 * android:largeScreens}. 211 */ 212 public static final int FLAG_SUPPORTS_LARGE_SCREENS = 1<<11; 213 214 /** 215 * Value for {@link #flags}: true when the application knows how to adjust 216 * its UI for different screen sizes. Corresponds to 217 * {@link android.R.styleable#AndroidManifestSupportsScreens_resizeable 218 * android:resizeable}. 219 */ 220 public static final int FLAG_RESIZEABLE_FOR_SCREENS = 1<<12; 221 222 /** 223 * Value for {@link #flags}: true when the application knows how to 224 * accomodate different screen densities. Corresponds to 225 * {@link android.R.styleable#AndroidManifestSupportsScreens_anyDensity 226 * android:anyDensity}. 227 */ 228 public static final int FLAG_SUPPORTS_SCREEN_DENSITIES = 1<<13; 229 230 /** 231 * Value for {@link #flags}: set to true if this application would like to 232 * request the VM to operate under the safe mode. Comes from 233 * {@link android.R.styleable#AndroidManifestApplication_vmSafeMode 234 * android:vmSafeMode} of the <application> tag. 235 */ 236 public static final int FLAG_VM_SAFE_MODE = 1<<14; 237 238 /** 239 * Value for {@link #flags}: set to <code>false</code> if the application does not wish 240 * to permit any OS-driven backups of its data; <code>true</code> otherwise. 241 * 242 * <p>Comes from the 243 * {@link android.R.styleable#AndroidManifestApplication_allowBackup android:allowBackup} 244 * attribute of the <application> tag. 245 */ 246 public static final int FLAG_ALLOW_BACKUP = 1<<15; 247 248 /** 249 * Value for {@link #flags}: set to <code>false</code> if the application must be kept 250 * in memory following a full-system restore operation; <code>true</code> otherwise. 251 * Ordinarily, during a full system restore operation each application is shut down 252 * following execution of its agent's onRestore() method. Setting this attribute to 253 * <code>false</code> prevents this. Most applications will not need to set this attribute. 254 * 255 * <p>If 256 * {@link android.R.styleable#AndroidManifestApplication_allowBackup android:allowBackup} 257 * is set to <code>false</code> or no 258 * {@link android.R.styleable#AndroidManifestApplication_backupAgent android:backupAgent} 259 * is specified, this flag will be ignored. 260 * 261 * <p>Comes from the 262 * {@link android.R.styleable#AndroidManifestApplication_killAfterRestore android:killAfterRestore} 263 * attribute of the <application> tag. 264 */ 265 public static final int FLAG_KILL_AFTER_RESTORE = 1<<16; 266 267 /** 268 * Value for {@link #flags}: Set to <code>true</code> if the application's backup 269 * agent claims to be able to handle restore data even "from the future," 270 * i.e. from versions of the application with a versionCode greater than 271 * the one currently installed on the device. <i>Use with caution!</i> By default 272 * this attribute is <code>false</code> and the Backup Manager will ensure that data 273 * from "future" versions of the application are never supplied during a restore operation. 274 * 275 * <p>If 276 * {@link android.R.styleable#AndroidManifestApplication_allowBackup android:allowBackup} 277 * is set to <code>false</code> or no 278 * {@link android.R.styleable#AndroidManifestApplication_backupAgent android:backupAgent} 279 * is specified, this flag will be ignored. 280 * 281 * <p>Comes from the 282 * {@link android.R.styleable#AndroidManifestApplication_restoreAnyVersion android:restoreAnyVersion} 283 * attribute of the <application> tag. 284 */ 285 public static final int FLAG_RESTORE_ANY_VERSION = 1<<17; 286 287 /** 288 * Value for {@link #flags}: Set to true if the application is 289 * currently installed on external/removable/unprotected storage. Such 290 * applications may not be available if their storage is not currently 291 * mounted. When the storage it is on is not available, it will look like 292 * the application has been uninstalled (its .apk is no longer available) 293 * but its persistent data is not removed. 294 */ 295 public static final int FLAG_EXTERNAL_STORAGE = 1<<18; 296 297 /** 298 * Value for {@link #flags}: true when the application's window can be 299 * increased in size for extra large screens. Corresponds to 300 * {@link android.R.styleable#AndroidManifestSupportsScreens_xlargeScreens 301 * android:xlargeScreens}. 302 */ 303 public static final int FLAG_SUPPORTS_XLARGE_SCREENS = 1<<19; 304 305 /** 306 * Value for {@link #flags}: true when the application has requested a 307 * large heap for its processes. Corresponds to 308 * {@link android.R.styleable#AndroidManifestApplication_largeHeap 309 * android:largeHeap}. 310 */ 311 public static final int FLAG_LARGE_HEAP = 1<<20; 312 313 /** 314 * Value for {@link #flags}: true if this application's package is in 315 * the stopped state. 316 */ 317 public static final int FLAG_STOPPED = 1<<21; 318 319 /** 320 * Value for {@link #flags}: true when the application is willing to support 321 * RTL (right to left). All activities will inherit this value. 322 * 323 * Set from the {@link android.R.attr#supportsRtl} attribute in the 324 * activity's manifest. 325 * 326 * Default value is false (no support for RTL). 327 */ 328 public static final int FLAG_SUPPORTS_RTL = 1<<22; 329 330 /** 331 * Value for {@link #flags}: true if the application is currently 332 * installed for the calling user. 333 */ 334 public static final int FLAG_INSTALLED = 1<<23; 335 336 /** 337 * Value for {@link #flags}: true if the application only has its 338 * data installed; the application package itself does not currently 339 * exist on the device. 340 */ 341 public static final int FLAG_IS_DATA_ONLY = 1<<24; 342 343 /** 344 * Value for {@link #flags}: true if the application was declared to be a game, or 345 * false if it is a non-game application. 346 */ 347 public static final int FLAG_IS_GAME = 1<<25; 348 349 /** 350 * Value for {@link #flags}: {@code true} if the application asks that only 351 * full-data streaming backups of its data be performed even though it defines 352 * a {@link android.app.backup.BackupAgent BackupAgent}, which normally 353 * indicates that the app will manage its backed-up data via incremental 354 * key/value updates. 355 */ 356 public static final int FLAG_FULL_BACKUP_ONLY = 1<<26; 357 358 /** 359 * Value for {@link #flags}: {@code true} if the application may use cleartext network traffic 360 * (e.g., HTTP rather than HTTPS; WebSockets rather than WebSockets Secure; XMPP, IMAP, STMP 361 * without STARTTLS or TLS). If {@code false}, the app declares that it does not intend to use 362 * cleartext network traffic, in which case platform components (e.g., HTTP stacks, 363 * {@code DownloadManager}, {@code MediaPlayer}) will refuse app's requests to use cleartext 364 * traffic. Third-party libraries are encouraged to honor this flag as well. 365 * 366 * <p>NOTE: {@code WebView} does not honor this flag. 367 * 368 * <p>This flag comes from 369 * {@link android.R.styleable#AndroidManifestApplication_usesCleartextTraffic 370 * android:usesCleartextTraffic} of the <application> tag. 371 */ 372 public static final int FLAG_USES_CLEARTEXT_TRAFFIC = 1<<27; 373 374 /** 375 * When set installer extracts native libs from .apk files. 376 */ 377 public static final int FLAG_EXTRACT_NATIVE_LIBS = 1<<28; 378 379 /** 380 * Value for {@link #flags}: {@code true} when the application's rendering 381 * should be hardware accelerated. 382 */ 383 public static final int FLAG_HARDWARE_ACCELERATED = 1<<29; 384 385 /** 386 * Value for {@link #flags}: true if code from this application will need to be 387 * loaded into other applications' processes. On devices that support multiple 388 * instruction sets, this implies the code might be loaded into a process that's 389 * using any of the devices supported instruction sets. 390 * 391 * <p> The system might treat such applications specially, for eg., by 392 * extracting the application's native libraries for all supported instruction 393 * sets or by compiling the application's dex code for all supported instruction 394 * sets. 395 */ 396 public static final int FLAG_MULTIARCH = 1 << 31; 397 398 /** 399 * Flags associated with the application. Any combination of 400 * {@link #FLAG_SYSTEM}, {@link #FLAG_DEBUGGABLE}, {@link #FLAG_HAS_CODE}, 401 * {@link #FLAG_PERSISTENT}, {@link #FLAG_FACTORY_TEST}, and 402 * {@link #FLAG_ALLOW_TASK_REPARENTING} 403 * {@link #FLAG_ALLOW_CLEAR_USER_DATA}, {@link #FLAG_UPDATED_SYSTEM_APP}, 404 * {@link #FLAG_TEST_ONLY}, {@link #FLAG_SUPPORTS_SMALL_SCREENS}, 405 * {@link #FLAG_SUPPORTS_NORMAL_SCREENS}, 406 * {@link #FLAG_SUPPORTS_LARGE_SCREENS}, {@link #FLAG_SUPPORTS_XLARGE_SCREENS}, 407 * {@link #FLAG_RESIZEABLE_FOR_SCREENS}, 408 * {@link #FLAG_SUPPORTS_SCREEN_DENSITIES}, {@link #FLAG_VM_SAFE_MODE}, 409 * {@link #FLAG_ALLOW_BACKUP}, {@link #FLAG_KILL_AFTER_RESTORE}, 410 * {@link #FLAG_RESTORE_ANY_VERSION}, {@link #FLAG_EXTERNAL_STORAGE}, 411 * {@link #FLAG_LARGE_HEAP}, {@link #FLAG_STOPPED}, 412 * {@link #FLAG_SUPPORTS_RTL}, {@link #FLAG_INSTALLED}, 413 * {@link #FLAG_IS_DATA_ONLY}, {@link #FLAG_IS_GAME}, 414 * {@link #FLAG_FULL_BACKUP_ONLY}, {@link #FLAG_USES_CLEARTEXT_TRAFFIC}, 415 * {@link #FLAG_MULTIARCH}. 416 */ 417 public int flags = 0; 418 419 /** 420 * Value for {@link #privateFlags}: true if the application is hidden via restrictions and for 421 * most purposes is considered as not installed. 422 * {@hide} 423 */ 424 public static final int PRIVATE_FLAG_HIDDEN = 1<<0; 425 426 /** 427 * Value for {@link #privateFlags}: set to <code>true</code> if the application 428 * has reported that it is heavy-weight, and thus can not participate in 429 * the normal application lifecycle. 430 * 431 * <p>Comes from the 432 * android.R.styleable#AndroidManifestApplication_cantSaveState 433 * attribute of the <application> tag. 434 * 435 * {@hide} 436 */ 437 public static final int PRIVATE_FLAG_CANT_SAVE_STATE = 1<<1; 438 439 /** 440 * Value for {@link #privateFlags}: Set to true if the application has been 441 * installed using the forward lock option. 442 * 443 * NOTE: DO NOT CHANGE THIS VALUE! It is saved in packages.xml. 444 * 445 * {@hide} 446 */ 447 public static final int PRIVATE_FLAG_FORWARD_LOCK = 1<<2; 448 449 /** 450 * Value for {@link #privateFlags}: set to {@code true} if the application 451 * is permitted to hold privileged permissions. 452 * 453 * {@hide} 454 */ 455 public static final int PRIVATE_FLAG_PRIVILEGED = 1<<3; 456 457 /** 458 * Value for {@link #flags}: {@code true} if the application has any IntentFiler with some 459 * data URI using HTTP or HTTPS with an associated VIEW action. 460 * 461 * {@hide} 462 */ 463 public static final int PRIVATE_FLAG_HAS_DOMAIN_URLS = 1<<4; 464 465 /** 466 * When set, default data storage directory for given app is pointed at 467 * device-encrypted location. 468 * 469 * @hide 470 */ 471 public static final int PRIVATE_FLAG_FORCE_DEVICE_ENCRYPTED = 1 << 5; 472 473 /** 474 * When set, assume that all components under the given app are encryption 475 * aware, unless otherwise specified. 476 * 477 * @hide 478 */ 479 public static final int PRIVATE_FLAG_ENCRYPTION_AWARE = 1 << 6; 480 481 /** 482 * Value for {@link #privateFlags}: set to {@code true} if the application 483 * is AutoPlay. 484 * 485 * {@hide} 486 */ 487 public static final int PRIVATE_FLAG_AUTOPLAY = 1 << 7; 488 489 /** 490 * When set, at least one component inside this application is encryption aware. 491 * 492 * @hide 493 */ 494 public static final int PRIVATE_FLAG_PARTIALLY_ENCRYPTION_AWARE = 1 << 8; 495 496 /** 497 * Private/hidden flags. See {@code PRIVATE_FLAG_...} constants. 498 * {@hide} 499 */ 500 public int privateFlags; 501 502 /** 503 * The required smallest screen width the application can run on. If 0, 504 * nothing has been specified. Comes from 505 * {@link android.R.styleable#AndroidManifestSupportsScreens_requiresSmallestWidthDp 506 * android:requiresSmallestWidthDp} attribute of the <supports-screens> tag. 507 */ 508 public int requiresSmallestWidthDp = 0; 509 510 /** 511 * The maximum smallest screen width the application is designed for. If 0, 512 * nothing has been specified. Comes from 513 * {@link android.R.styleable#AndroidManifestSupportsScreens_compatibleWidthLimitDp 514 * android:compatibleWidthLimitDp} attribute of the <supports-screens> tag. 515 */ 516 public int compatibleWidthLimitDp = 0; 517 518 /** 519 * The maximum smallest screen width the application will work on. If 0, 520 * nothing has been specified. Comes from 521 * {@link android.R.styleable#AndroidManifestSupportsScreens_largestWidthLimitDp 522 * android:largestWidthLimitDp} attribute of the <supports-screens> tag. 523 */ 524 public int largestWidthLimitDp = 0; 525 526 /** {@hide} */ 527 public String volumeUuid; 528 /** {@hide} */ 529 public String scanSourceDir; 530 /** {@hide} */ 531 public String scanPublicSourceDir; 532 533 /** 534 * Full path to the base APK for this application. 535 */ 536 public String sourceDir; 537 538 /** 539 * Full path to the publicly available parts of {@link #sourceDir}, 540 * including resources and manifest. This may be different from 541 * {@link #sourceDir} if an application is forward locked. 542 */ 543 public String publicSourceDir; 544 545 /** 546 * Full paths to zero or more split APKs that, when combined with the base 547 * APK defined in {@link #sourceDir}, form a complete application. 548 */ 549 public String[] splitSourceDirs; 550 551 /** 552 * Full path to the publicly available parts of {@link #splitSourceDirs}, 553 * including resources and manifest. This may be different from 554 * {@link #splitSourceDirs} if an application is forward locked. 555 */ 556 public String[] splitPublicSourceDirs; 557 558 /** 559 * Full paths to the locations of extra resource packages this application 560 * uses. This field is only used if there are extra resource packages, 561 * otherwise it is null. 562 * 563 * {@hide} 564 */ 565 public String[] resourceDirs; 566 567 /** 568 * String retrieved from the seinfo tag found in selinux policy. This value 569 * can be overridden with a value set through the mac_permissions.xml policy 570 * construct. This value is useful in setting an SELinux security context on 571 * the process as well as its data directory. The String default is being used 572 * here to represent a catchall label when no policy matches. 573 * 574 * {@hide} 575 */ 576 public String seinfo = "default"; 577 578 /** 579 * Paths to all shared libraries this application is linked against. This 580 * field is only set if the {@link PackageManager#GET_SHARED_LIBRARY_FILES 581 * PackageManager.GET_SHARED_LIBRARY_FILES} flag was used when retrieving 582 * the structure. 583 */ 584 public String[] sharedLibraryFiles; 585 586 /** 587 * Full path to a directory assigned to the package for its persistent data. 588 */ 589 public String dataDir; 590 591 /** {@hide} */ 592 public String deviceEncryptedDataDir; 593 /** {@hide} */ 594 public String credentialEncryptedDataDir; 595 596 /** 597 * Full path to the directory where native JNI libraries are stored. 598 */ 599 public String nativeLibraryDir; 600 601 /** 602 * Full path where unpacked native libraries for {@link #secondaryCpuAbi} 603 * are stored, if present. 604 * 605 * The main reason this exists is for bundled multi-arch apps, where 606 * it's not trivial to calculate the location of libs for the secondary abi 607 * given the location of the primary. 608 * 609 * TODO: Change the layout of bundled installs so that we can use 610 * nativeLibraryRootDir & nativeLibraryRootRequiresIsa there as well. 611 * (e.g {@code [ "/system/app-lib/Foo/arm", "/system/app-lib/Foo/arm64" ]} 612 * instead of {@code [ "/system/lib/Foo", "/system/lib64/Foo" ]}. 613 * 614 * @hide 615 */ 616 public String secondaryNativeLibraryDir; 617 618 /** 619 * The root path where unpacked native libraries are stored. 620 * <p> 621 * When {@link #nativeLibraryRootRequiresIsa} is set, the libraries are 622 * placed in ISA-specific subdirectories under this path, otherwise the 623 * libraries are placed directly at this path. 624 * 625 * @hide 626 */ 627 public String nativeLibraryRootDir; 628 629 /** 630 * Flag indicating that ISA must be appended to 631 * {@link #nativeLibraryRootDir} to be useful. 632 * 633 * @hide 634 */ 635 public boolean nativeLibraryRootRequiresIsa; 636 637 /** 638 * The primary ABI that this application requires, This is inferred from the ABIs 639 * of the native JNI libraries the application bundles. Will be {@code null} 640 * if this application does not require any particular ABI. 641 * 642 * If non-null, the application will always be launched with this ABI. 643 * 644 * {@hide} 645 */ 646 public String primaryCpuAbi; 647 648 /** 649 * The secondary ABI for this application. Might be non-null for multi-arch 650 * installs. The application itself never uses this ABI, but other applications that 651 * use its code might. 652 * 653 * {@hide} 654 */ 655 public String secondaryCpuAbi; 656 657 /** 658 * The kernel user-ID that has been assigned to this application; 659 * currently this is not a unique ID (multiple applications can have 660 * the same uid). 661 */ 662 public int uid; 663 664 /** 665 * The minimum SDK version this application targets. It may run on earlier 666 * versions, but it knows how to work with any new behavior added at this 667 * version. Will be {@link android.os.Build.VERSION_CODES#CUR_DEVELOPMENT} 668 * if this is a development build and the app is targeting that. You should 669 * compare that this number is >= the SDK version number at which your 670 * behavior was introduced. 671 */ 672 public int targetSdkVersion; 673 674 /** 675 * The app's declared version code. 676 * @hide 677 */ 678 public int versionCode; 679 680 /** 681 * When false, indicates that all components within this application are 682 * considered disabled, regardless of their individually set enabled status. 683 */ 684 public boolean enabled = true; 685 686 /** 687 * For convenient access to the current enabled setting of this app. 688 * @hide 689 */ 690 public int enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 691 692 /** 693 * For convenient access to package's install location. 694 * @hide 695 */ 696 public int installLocation = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 697 698 public void dump(Printer pw, String prefix) { 699 super.dumpFront(pw, prefix); 700 if (className != null) { 701 pw.println(prefix + "className=" + className); 702 } 703 if (permission != null) { 704 pw.println(prefix + "permission=" + permission); 705 } 706 pw.println(prefix + "processName=" + processName); 707 pw.println(prefix + "taskAffinity=" + taskAffinity); 708 pw.println(prefix + "uid=" + uid + " flags=0x" + Integer.toHexString(flags) 709 + " privateFlags=0x" + Integer.toHexString(privateFlags) 710 + " theme=0x" + Integer.toHexString(theme)); 711 pw.println(prefix + "requiresSmallestWidthDp=" + requiresSmallestWidthDp 712 + " compatibleWidthLimitDp=" + compatibleWidthLimitDp 713 + " largestWidthLimitDp=" + largestWidthLimitDp); 714 pw.println(prefix + "sourceDir=" + sourceDir); 715 if (!Objects.equals(sourceDir, publicSourceDir)) { 716 pw.println(prefix + "publicSourceDir=" + publicSourceDir); 717 } 718 if (!ArrayUtils.isEmpty(splitSourceDirs)) { 719 pw.println(prefix + "splitSourceDirs=" + Arrays.toString(splitSourceDirs)); 720 } 721 if (!ArrayUtils.isEmpty(splitPublicSourceDirs) 722 && !Arrays.equals(splitSourceDirs, splitPublicSourceDirs)) { 723 pw.println(prefix + "splitPublicSourceDirs=" + Arrays.toString(splitPublicSourceDirs)); 724 } 725 if (resourceDirs != null) { 726 pw.println(prefix + "resourceDirs=" + resourceDirs); 727 } 728 if (seinfo != null) { 729 pw.println(prefix + "seinfo=" + seinfo); 730 } 731 pw.println(prefix + "dataDir=" + dataDir); 732 pw.println(prefix + "deviceEncryptedDataDir=" + deviceEncryptedDataDir); 733 pw.println(prefix + "credentialEncryptedDataDir=" + credentialEncryptedDataDir); 734 if (sharedLibraryFiles != null) { 735 pw.println(prefix + "sharedLibraryFiles=" + Arrays.toString(sharedLibraryFiles)); 736 } 737 pw.println(prefix + "enabled=" + enabled + " targetSdkVersion=" + targetSdkVersion 738 + " versionCode=" + versionCode); 739 if (manageSpaceActivityName != null) { 740 pw.println(prefix + "manageSpaceActivityName="+manageSpaceActivityName); 741 } 742 if (descriptionRes != 0) { 743 pw.println(prefix + "description=0x"+Integer.toHexString(descriptionRes)); 744 } 745 if (uiOptions != 0) { 746 pw.println(prefix + "uiOptions=0x" + Integer.toHexString(uiOptions)); 747 } 748 pw.println(prefix + "supportsRtl=" + (hasRtlSupport() ? "true" : "false")); 749 if (fullBackupContent > 0) { 750 pw.println(prefix + "fullBackupContent=@xml/" + fullBackupContent); 751 } else { 752 pw.println(prefix + "fullBackupContent=" + (fullBackupContent < 0 ? "false" : "true")); 753 } 754 super.dumpBack(pw, prefix); 755 } 756 757 /** 758 * @return true if "supportsRtl" has been set to true in the AndroidManifest 759 * @hide 760 */ 761 public boolean hasRtlSupport() { 762 return (flags & FLAG_SUPPORTS_RTL) == FLAG_SUPPORTS_RTL; 763 } 764 765 public static class DisplayNameComparator 766 implements Comparator<ApplicationInfo> { 767 public DisplayNameComparator(PackageManager pm) { 768 mPM = pm; 769 } 770 771 public final int compare(ApplicationInfo aa, ApplicationInfo ab) { 772 CharSequence sa = mPM.getApplicationLabel(aa); 773 if (sa == null) { 774 sa = aa.packageName; 775 } 776 CharSequence sb = mPM.getApplicationLabel(ab); 777 if (sb == null) { 778 sb = ab.packageName; 779 } 780 781 return sCollator.compare(sa.toString(), sb.toString()); 782 } 783 784 private final Collator sCollator = Collator.getInstance(); 785 private PackageManager mPM; 786 } 787 788 public ApplicationInfo() { 789 } 790 791 public ApplicationInfo(ApplicationInfo orig) { 792 super(orig); 793 taskAffinity = orig.taskAffinity; 794 permission = orig.permission; 795 processName = orig.processName; 796 className = orig.className; 797 theme = orig.theme; 798 flags = orig.flags; 799 privateFlags = orig.privateFlags; 800 requiresSmallestWidthDp = orig.requiresSmallestWidthDp; 801 compatibleWidthLimitDp = orig.compatibleWidthLimitDp; 802 largestWidthLimitDp = orig.largestWidthLimitDp; 803 volumeUuid = orig.volumeUuid; 804 scanSourceDir = orig.scanSourceDir; 805 scanPublicSourceDir = orig.scanPublicSourceDir; 806 sourceDir = orig.sourceDir; 807 publicSourceDir = orig.publicSourceDir; 808 splitSourceDirs = orig.splitSourceDirs; 809 splitPublicSourceDirs = orig.splitPublicSourceDirs; 810 nativeLibraryDir = orig.nativeLibraryDir; 811 secondaryNativeLibraryDir = orig.secondaryNativeLibraryDir; 812 nativeLibraryRootDir = orig.nativeLibraryRootDir; 813 nativeLibraryRootRequiresIsa = orig.nativeLibraryRootRequiresIsa; 814 primaryCpuAbi = orig.primaryCpuAbi; 815 secondaryCpuAbi = orig.secondaryCpuAbi; 816 resourceDirs = orig.resourceDirs; 817 seinfo = orig.seinfo; 818 sharedLibraryFiles = orig.sharedLibraryFiles; 819 dataDir = orig.dataDir; 820 deviceEncryptedDataDir = orig.deviceEncryptedDataDir; 821 credentialEncryptedDataDir = orig.credentialEncryptedDataDir; 822 uid = orig.uid; 823 targetSdkVersion = orig.targetSdkVersion; 824 versionCode = orig.versionCode; 825 enabled = orig.enabled; 826 enabledSetting = orig.enabledSetting; 827 installLocation = orig.installLocation; 828 manageSpaceActivityName = orig.manageSpaceActivityName; 829 descriptionRes = orig.descriptionRes; 830 uiOptions = orig.uiOptions; 831 backupAgentName = orig.backupAgentName; 832 fullBackupContent = orig.fullBackupContent; 833 } 834 835 public String toString() { 836 return "ApplicationInfo{" 837 + Integer.toHexString(System.identityHashCode(this)) 838 + " " + packageName + "}"; 839 } 840 841 public int describeContents() { 842 return 0; 843 } 844 845 public void writeToParcel(Parcel dest, int parcelableFlags) { 846 super.writeToParcel(dest, parcelableFlags); 847 dest.writeString(taskAffinity); 848 dest.writeString(permission); 849 dest.writeString(processName); 850 dest.writeString(className); 851 dest.writeInt(theme); 852 dest.writeInt(flags); 853 dest.writeInt(privateFlags); 854 dest.writeInt(requiresSmallestWidthDp); 855 dest.writeInt(compatibleWidthLimitDp); 856 dest.writeInt(largestWidthLimitDp); 857 dest.writeString(volumeUuid); 858 dest.writeString(scanSourceDir); 859 dest.writeString(scanPublicSourceDir); 860 dest.writeString(sourceDir); 861 dest.writeString(publicSourceDir); 862 dest.writeStringArray(splitSourceDirs); 863 dest.writeStringArray(splitPublicSourceDirs); 864 dest.writeString(nativeLibraryDir); 865 dest.writeString(secondaryNativeLibraryDir); 866 dest.writeString(nativeLibraryRootDir); 867 dest.writeInt(nativeLibraryRootRequiresIsa ? 1 : 0); 868 dest.writeString(primaryCpuAbi); 869 dest.writeString(secondaryCpuAbi); 870 dest.writeStringArray(resourceDirs); 871 dest.writeString(seinfo); 872 dest.writeStringArray(sharedLibraryFiles); 873 dest.writeString(dataDir); 874 dest.writeString(deviceEncryptedDataDir); 875 dest.writeString(credentialEncryptedDataDir); 876 dest.writeInt(uid); 877 dest.writeInt(targetSdkVersion); 878 dest.writeInt(versionCode); 879 dest.writeInt(enabled ? 1 : 0); 880 dest.writeInt(enabledSetting); 881 dest.writeInt(installLocation); 882 dest.writeString(manageSpaceActivityName); 883 dest.writeString(backupAgentName); 884 dest.writeInt(descriptionRes); 885 dest.writeInt(uiOptions); 886 dest.writeInt(fullBackupContent); 887 } 888 889 public static final Parcelable.Creator<ApplicationInfo> CREATOR 890 = new Parcelable.Creator<ApplicationInfo>() { 891 public ApplicationInfo createFromParcel(Parcel source) { 892 return new ApplicationInfo(source); 893 } 894 public ApplicationInfo[] newArray(int size) { 895 return new ApplicationInfo[size]; 896 } 897 }; 898 899 private ApplicationInfo(Parcel source) { 900 super(source); 901 taskAffinity = source.readString(); 902 permission = source.readString(); 903 processName = source.readString(); 904 className = source.readString(); 905 theme = source.readInt(); 906 flags = source.readInt(); 907 privateFlags = source.readInt(); 908 requiresSmallestWidthDp = source.readInt(); 909 compatibleWidthLimitDp = source.readInt(); 910 largestWidthLimitDp = source.readInt(); 911 volumeUuid = source.readString(); 912 scanSourceDir = source.readString(); 913 scanPublicSourceDir = source.readString(); 914 sourceDir = source.readString(); 915 publicSourceDir = source.readString(); 916 splitSourceDirs = source.readStringArray(); 917 splitPublicSourceDirs = source.readStringArray(); 918 nativeLibraryDir = source.readString(); 919 secondaryNativeLibraryDir = source.readString(); 920 nativeLibraryRootDir = source.readString(); 921 nativeLibraryRootRequiresIsa = source.readInt() != 0; 922 primaryCpuAbi = source.readString(); 923 secondaryCpuAbi = source.readString(); 924 resourceDirs = source.readStringArray(); 925 seinfo = source.readString(); 926 sharedLibraryFiles = source.readStringArray(); 927 dataDir = source.readString(); 928 deviceEncryptedDataDir = source.readString(); 929 credentialEncryptedDataDir = source.readString(); 930 uid = source.readInt(); 931 targetSdkVersion = source.readInt(); 932 versionCode = source.readInt(); 933 enabled = source.readInt() != 0; 934 enabledSetting = source.readInt(); 935 installLocation = source.readInt(); 936 manageSpaceActivityName = source.readString(); 937 backupAgentName = source.readString(); 938 descriptionRes = source.readInt(); 939 uiOptions = source.readInt(); 940 fullBackupContent = source.readInt(); 941 } 942 943 /** 944 * Retrieve the textual description of the application. This 945 * will call back on the given PackageManager to load the description from 946 * the application. 947 * 948 * @param pm A PackageManager from which the label can be loaded; usually 949 * the PackageManager from which you originally retrieved this item. 950 * 951 * @return Returns a CharSequence containing the application's description. 952 * If there is no description, null is returned. 953 */ 954 public CharSequence loadDescription(PackageManager pm) { 955 if (descriptionRes != 0) { 956 CharSequence label = pm.getText(packageName, descriptionRes, this); 957 if (label != null) { 958 return label; 959 } 960 } 961 return null; 962 } 963 964 /** 965 * Disable compatibility mode 966 * 967 * @hide 968 */ 969 public void disableCompatibilityMode() { 970 flags |= (FLAG_SUPPORTS_LARGE_SCREENS | FLAG_SUPPORTS_NORMAL_SCREENS | 971 FLAG_SUPPORTS_SMALL_SCREENS | FLAG_RESIZEABLE_FOR_SCREENS | 972 FLAG_SUPPORTS_SCREEN_DENSITIES | FLAG_SUPPORTS_XLARGE_SCREENS); 973 } 974 975 /** {@hide} */ 976 public void initForUser(int userId) { 977 uid = UserHandle.getUid(userId, UserHandle.getAppId(uid)); 978 979 if ("android".equals(packageName)) { 980 dataDir = Environment.getDataSystemDirectory().getAbsolutePath(); 981 return; 982 } 983 984 deviceEncryptedDataDir = Environment 985 .getDataUserDeviceEncryptedPackageDirectory(volumeUuid, userId, packageName) 986 .getAbsolutePath(); 987 credentialEncryptedDataDir = Environment 988 .getDataUserCredentialEncryptedPackageDirectory(volumeUuid, userId, packageName) 989 .getAbsolutePath(); 990 991 if ((privateFlags & PRIVATE_FLAG_FORCE_DEVICE_ENCRYPTED) != 0 992 && StorageManager.isFileBasedEncryptionEnabled()) { 993 dataDir = deviceEncryptedDataDir; 994 } else { 995 dataDir = credentialEncryptedDataDir; 996 } 997 } 998 999 /** 1000 * @hide 1001 */ 1002 @Override 1003 public Drawable loadDefaultIcon(PackageManager pm) { 1004 if ((flags & FLAG_EXTERNAL_STORAGE) != 0 1005 && isPackageUnavailable(pm)) { 1006 return Resources.getSystem().getDrawable( 1007 com.android.internal.R.drawable.sym_app_on_sd_unavailable_icon); 1008 } 1009 return pm.getDefaultActivityIcon(); 1010 } 1011 1012 private boolean isPackageUnavailable(PackageManager pm) { 1013 try { 1014 return pm.getPackageInfo(packageName, 0) == null; 1015 } catch (NameNotFoundException ex) { 1016 return true; 1017 } 1018 } 1019 1020 /** 1021 * @hide 1022 */ 1023 public boolean isForwardLocked() { 1024 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0; 1025 } 1026 1027 /** 1028 * @hide 1029 */ 1030 public boolean isSystemApp() { 1031 return (flags & ApplicationInfo.FLAG_SYSTEM) != 0; 1032 } 1033 1034 /** 1035 * @hide 1036 */ 1037 public boolean isPrivilegedApp() { 1038 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0; 1039 } 1040 1041 /** 1042 * @hide 1043 */ 1044 public boolean isUpdatedSystemApp() { 1045 return (flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0; 1046 } 1047 1048 /** @hide */ 1049 public boolean isInternal() { 1050 return (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 0; 1051 } 1052 1053 /** @hide */ 1054 public boolean isExternalAsec() { 1055 return TextUtils.isEmpty(volumeUuid) 1056 && (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0; 1057 } 1058 1059 /** @hide */ 1060 public boolean isEncryptionAware() { 1061 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_ENCRYPTION_AWARE) != 0; 1062 } 1063 1064 /** @hide */ 1065 public boolean isPartiallyEncryptionAware() { 1066 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_PARTIALLY_ENCRYPTION_AWARE) != 0; 1067 } 1068 1069 /** 1070 * @hide 1071 */ 1072 public boolean isAutoPlayApp() { 1073 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_AUTOPLAY) != 0; 1074 } 1075 1076 /** 1077 * @hide 1078 */ 1079 @Override protected ApplicationInfo getApplicationInfo() { 1080 return this; 1081 } 1082 1083 /** {@hide} */ public void setCodePath(String codePath) { scanSourceDir = codePath; } 1084 /** {@hide} */ public void setBaseCodePath(String baseCodePath) { sourceDir = baseCodePath; } 1085 /** {@hide} */ public void setSplitCodePaths(String[] splitCodePaths) { splitSourceDirs = splitCodePaths; } 1086 /** {@hide} */ public void setResourcePath(String resourcePath) { scanPublicSourceDir = resourcePath; } 1087 /** {@hide} */ public void setBaseResourcePath(String baseResourcePath) { publicSourceDir = baseResourcePath; } 1088 /** {@hide} */ public void setSplitResourcePaths(String[] splitResourcePaths) { splitPublicSourceDirs = splitResourcePaths; } 1089 1090 /** {@hide} */ public String getCodePath() { return scanSourceDir; } 1091 /** {@hide} */ public String getBaseCodePath() { return sourceDir; } 1092 /** {@hide} */ public String[] getSplitCodePaths() { return splitSourceDirs; } 1093 /** {@hide} */ public String getResourcePath() { return scanPublicSourceDir; } 1094 /** {@hide} */ public String getBaseResourcePath() { return publicSourceDir; } 1095 /** {@hide} */ public String[] getSplitResourcePaths() { return splitSourceDirs; } 1096} 1097