ApplicationInfo.java revision 6afdf91b179afd4e4ae9aa0e520961e57638d637
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.annotation.TestApi; 20import android.content.pm.PackageManager.NameNotFoundException; 21import android.content.res.Resources; 22import android.graphics.drawable.Drawable; 23import android.os.Environment; 24import android.os.Parcel; 25import android.os.Parcelable; 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 * installed 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 this application's package is in 387 * the suspended state. 388 */ 389 public static final int FLAG_SUSPENDED = 1<<30; 390 391 /** 392 * Value for {@link #flags}: true if code from this application will need to be 393 * loaded into other applications' processes. On devices that support multiple 394 * instruction sets, this implies the code might be loaded into a process that's 395 * using any of the devices supported instruction sets. 396 * 397 * <p> The system might treat such applications specially, for eg., by 398 * extracting the application's native libraries for all supported instruction 399 * sets or by compiling the application's dex code for all supported instruction 400 * sets. 401 */ 402 public static final int FLAG_MULTIARCH = 1 << 31; 403 404 /** 405 * Flags associated with the application. Any combination of 406 * {@link #FLAG_SYSTEM}, {@link #FLAG_DEBUGGABLE}, {@link #FLAG_HAS_CODE}, 407 * {@link #FLAG_PERSISTENT}, {@link #FLAG_FACTORY_TEST}, and 408 * {@link #FLAG_ALLOW_TASK_REPARENTING} 409 * {@link #FLAG_ALLOW_CLEAR_USER_DATA}, {@link #FLAG_UPDATED_SYSTEM_APP}, 410 * {@link #FLAG_TEST_ONLY}, {@link #FLAG_SUPPORTS_SMALL_SCREENS}, 411 * {@link #FLAG_SUPPORTS_NORMAL_SCREENS}, 412 * {@link #FLAG_SUPPORTS_LARGE_SCREENS}, {@link #FLAG_SUPPORTS_XLARGE_SCREENS}, 413 * {@link #FLAG_RESIZEABLE_FOR_SCREENS}, 414 * {@link #FLAG_SUPPORTS_SCREEN_DENSITIES}, {@link #FLAG_VM_SAFE_MODE}, 415 * {@link #FLAG_ALLOW_BACKUP}, {@link #FLAG_KILL_AFTER_RESTORE}, 416 * {@link #FLAG_RESTORE_ANY_VERSION}, {@link #FLAG_EXTERNAL_STORAGE}, 417 * {@link #FLAG_LARGE_HEAP}, {@link #FLAG_STOPPED}, 418 * {@link #FLAG_SUPPORTS_RTL}, {@link #FLAG_INSTALLED}, 419 * {@link #FLAG_IS_DATA_ONLY}, {@link #FLAG_IS_GAME}, 420 * {@link #FLAG_FULL_BACKUP_ONLY}, {@link #FLAG_USES_CLEARTEXT_TRAFFIC}, 421 * {@link #FLAG_MULTIARCH}. 422 */ 423 public int flags = 0; 424 425 /** 426 * Value for {@link #privateFlags}: true if the application is hidden via restrictions and for 427 * most purposes is considered as not installed. 428 * {@hide} 429 */ 430 public static final int PRIVATE_FLAG_HIDDEN = 1<<0; 431 432 /** 433 * Value for {@link #privateFlags}: set to <code>true</code> if the application 434 * has reported that it is heavy-weight, and thus can not participate in 435 * the normal application lifecycle. 436 * 437 * <p>Comes from the 438 * android.R.styleable#AndroidManifestApplication_cantSaveState 439 * attribute of the <application> tag. 440 * 441 * {@hide} 442 */ 443 public static final int PRIVATE_FLAG_CANT_SAVE_STATE = 1<<1; 444 445 /** 446 * Value for {@link #privateFlags}: Set to true if the application has been 447 * installed using the forward lock option. 448 * 449 * NOTE: DO NOT CHANGE THIS VALUE! It is saved in packages.xml. 450 * 451 * {@hide} 452 */ 453 public static final int PRIVATE_FLAG_FORWARD_LOCK = 1<<2; 454 455 /** 456 * Value for {@link #privateFlags}: set to {@code true} if the application 457 * is permitted to hold privileged permissions. 458 * 459 * {@hide} 460 */ 461 public static final int PRIVATE_FLAG_PRIVILEGED = 1<<3; 462 463 /** 464 * Value for {@link #privateFlags}: {@code true} if the application has any IntentFiler 465 * with some data URI using HTTP or HTTPS with an associated VIEW action. 466 * 467 * {@hide} 468 */ 469 public static final int PRIVATE_FLAG_HAS_DOMAIN_URLS = 1<<4; 470 471 /** 472 * When set, default data storage directory for given app is pointed at 473 * device-encrypted location. 474 * 475 * @hide 476 */ 477 public static final int PRIVATE_FLAG_FORCE_DEVICE_ENCRYPTED = 1 << 5; 478 479 /** 480 * When set, assume that all components under the given app are encryption 481 * aware, unless otherwise specified. 482 * 483 * @hide 484 */ 485 public static final int PRIVATE_FLAG_ENCRYPTION_AWARE = 1 << 6; 486 487 /** 488 * Value for {@link #privateFlags}: set to {@code true} if the application 489 * is AutoPlay. 490 * 491 * {@hide} 492 */ 493 public static final int PRIVATE_FLAG_AUTOPLAY = 1 << 7; 494 495 /** 496 * When set, at least one component inside this application is encryption aware. 497 * 498 * @hide 499 */ 500 public static final int PRIVATE_FLAG_PARTIALLY_ENCRYPTION_AWARE = 1 << 8; 501 502 /** 503 * Value for {@link #flags}: {@code true} if the application is blocked via restrictions 504 * and for most purposes is considered as not installed. 505 * {@hide} 506 */ 507 public static final int PRIVATE_FLAG_EPHEMERAL = 1 << 9; 508 509 /** 510 * When set, signals that the application is required for the system user and should not be 511 * uninstalled. 512 * 513 * @hide 514 */ 515 public static final int PRIVATE_FLAG_REQUIRED_FOR_SYSTEM_USER = 1 << 10; 516 517 /** 518 * When set, the activities associated with this application are resizeable by default. 519 * @see android.R.styleable#AndroidManifestActivity_resizeableActivity 520 * 521 * @hide 522 */ 523 public static final int PRIVATE_FLAG_RESIZEABLE_ACTIVITIES = 1 << 11; 524 525 /** 526 * Private/hidden flags. See {@code PRIVATE_FLAG_...} constants. 527 * {@hide} 528 */ 529 public int privateFlags; 530 531 /** 532 * The required smallest screen width the application can run on. If 0, 533 * nothing has been specified. Comes from 534 * {@link android.R.styleable#AndroidManifestSupportsScreens_requiresSmallestWidthDp 535 * android:requiresSmallestWidthDp} attribute of the <supports-screens> tag. 536 */ 537 public int requiresSmallestWidthDp = 0; 538 539 /** 540 * The maximum smallest screen width the application is designed for. If 0, 541 * nothing has been specified. Comes from 542 * {@link android.R.styleable#AndroidManifestSupportsScreens_compatibleWidthLimitDp 543 * android:compatibleWidthLimitDp} attribute of the <supports-screens> tag. 544 */ 545 public int compatibleWidthLimitDp = 0; 546 547 /** 548 * The maximum smallest screen width the application will work on. If 0, 549 * nothing has been specified. Comes from 550 * {@link android.R.styleable#AndroidManifestSupportsScreens_largestWidthLimitDp 551 * android:largestWidthLimitDp} attribute of the <supports-screens> tag. 552 */ 553 public int largestWidthLimitDp = 0; 554 555 /** {@hide} */ 556 public String volumeUuid; 557 /** {@hide} */ 558 public String scanSourceDir; 559 /** {@hide} */ 560 public String scanPublicSourceDir; 561 562 /** 563 * Full path to the base APK for this application. 564 */ 565 public String sourceDir; 566 567 /** 568 * Full path to the publicly available parts of {@link #sourceDir}, 569 * including resources and manifest. This may be different from 570 * {@link #sourceDir} if an application is forward locked. 571 */ 572 public String publicSourceDir; 573 574 /** 575 * Full paths to zero or more split APKs that, when combined with the base 576 * APK defined in {@link #sourceDir}, form a complete application. 577 */ 578 public String[] splitSourceDirs; 579 580 /** 581 * Full path to the publicly available parts of {@link #splitSourceDirs}, 582 * including resources and manifest. This may be different from 583 * {@link #splitSourceDirs} if an application is forward locked. 584 */ 585 public String[] splitPublicSourceDirs; 586 587 /** 588 * Full paths to the locations of extra resource packages this application 589 * uses. This field is only used if there are extra resource packages, 590 * otherwise it is null. 591 * 592 * {@hide} 593 */ 594 public String[] resourceDirs; 595 596 /** 597 * String retrieved from the seinfo tag found in selinux policy. This value 598 * can be overridden with a value set through the mac_permissions.xml policy 599 * construct. This value is useful in setting an SELinux security context on 600 * the process as well as its data directory. The String default is being used 601 * here to represent a catchall label when no policy matches. 602 * 603 * {@hide} 604 */ 605 public String seinfo = "default"; 606 607 /** 608 * Paths to all shared libraries this application is linked against. This 609 * field is only set if the {@link PackageManager#GET_SHARED_LIBRARY_FILES 610 * PackageManager.GET_SHARED_LIBRARY_FILES} flag was used when retrieving 611 * the structure. 612 */ 613 public String[] sharedLibraryFiles; 614 615 /** 616 * Full path to the default directory assigned to the package for its 617 * persistent data. 618 */ 619 public String dataDir; 620 621 /** 622 * Full path to the device-encrypted directory assigned to the package for 623 * its persistent data. 624 */ 625 public String deviceEncryptedDataDir; 626 627 /** 628 * Full path to the credential-encrypted directory assigned to the package 629 * for its persistent data. 630 */ 631 public String credentialEncryptedDataDir; 632 633 /** 634 * Full path to the directory where native JNI libraries are stored. 635 */ 636 public String nativeLibraryDir; 637 638 /** 639 * Full path where unpacked native libraries for {@link #secondaryCpuAbi} 640 * are stored, if present. 641 * 642 * The main reason this exists is for bundled multi-arch apps, where 643 * it's not trivial to calculate the location of libs for the secondary abi 644 * given the location of the primary. 645 * 646 * TODO: Change the layout of bundled installs so that we can use 647 * nativeLibraryRootDir & nativeLibraryRootRequiresIsa there as well. 648 * (e.g {@code [ "/system/app-lib/Foo/arm", "/system/app-lib/Foo/arm64" ]} 649 * instead of {@code [ "/system/lib/Foo", "/system/lib64/Foo" ]}. 650 * 651 * @hide 652 */ 653 public String secondaryNativeLibraryDir; 654 655 /** 656 * The root path where unpacked native libraries are stored. 657 * <p> 658 * When {@link #nativeLibraryRootRequiresIsa} is set, the libraries are 659 * placed in ISA-specific subdirectories under this path, otherwise the 660 * libraries are placed directly at this path. 661 * 662 * @hide 663 */ 664 public String nativeLibraryRootDir; 665 666 /** 667 * Flag indicating that ISA must be appended to 668 * {@link #nativeLibraryRootDir} to be useful. 669 * 670 * @hide 671 */ 672 public boolean nativeLibraryRootRequiresIsa; 673 674 /** 675 * The primary ABI that this application requires, This is inferred from the ABIs 676 * of the native JNI libraries the application bundles. Will be {@code null} 677 * if this application does not require any particular ABI. 678 * 679 * If non-null, the application will always be launched with this ABI. 680 * 681 * {@hide} 682 */ 683 public String primaryCpuAbi; 684 685 /** 686 * The secondary ABI for this application. Might be non-null for multi-arch 687 * installs. The application itself never uses this ABI, but other applications that 688 * use its code might. 689 * 690 * {@hide} 691 */ 692 public String secondaryCpuAbi; 693 694 /** 695 * The kernel user-ID that has been assigned to this application; 696 * currently this is not a unique ID (multiple applications can have 697 * the same uid). 698 */ 699 public int uid; 700 701 /** 702 * The minimum SDK version this application targets. It may run on earlier 703 * versions, but it knows how to work with any new behavior added at this 704 * version. Will be {@link android.os.Build.VERSION_CODES#CUR_DEVELOPMENT} 705 * if this is a development build and the app is targeting that. You should 706 * compare that this number is >= the SDK version number at which your 707 * behavior was introduced. 708 */ 709 public int targetSdkVersion; 710 711 /** 712 * The app's declared version code. 713 * @hide 714 */ 715 public int versionCode; 716 717 /** 718 * When false, indicates that all components within this application are 719 * considered disabled, regardless of their individually set enabled status. 720 */ 721 public boolean enabled = true; 722 723 /** 724 * For convenient access to the current enabled setting of this app. 725 * @hide 726 */ 727 public int enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 728 729 /** 730 * For convenient access to package's install location. 731 * @hide 732 */ 733 public int installLocation = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 734 735 public void dump(Printer pw, String prefix) { 736 dump(pw, prefix, DUMP_FLAG_ALL); 737 } 738 739 /** @hide */ 740 public void dump(Printer pw, String prefix, int flags) { 741 super.dumpFront(pw, prefix); 742 if ((flags&DUMP_FLAG_DETAILS) != 0 && className != null) { 743 pw.println(prefix + "className=" + className); 744 } 745 if (permission != null) { 746 pw.println(prefix + "permission=" + permission); 747 } 748 pw.println(prefix + "processName=" + processName); 749 if ((flags&DUMP_FLAG_DETAILS) != 0) { 750 pw.println(prefix + "taskAffinity=" + taskAffinity); 751 } 752 pw.println(prefix + "uid=" + uid + " flags=0x" + Integer.toHexString(flags) 753 + " privateFlags=0x" + Integer.toHexString(privateFlags) 754 + " theme=0x" + Integer.toHexString(theme)); 755 if ((flags&DUMP_FLAG_DETAILS) != 0) { 756 pw.println(prefix + "requiresSmallestWidthDp=" + requiresSmallestWidthDp 757 + " compatibleWidthLimitDp=" + compatibleWidthLimitDp 758 + " largestWidthLimitDp=" + largestWidthLimitDp); 759 } 760 pw.println(prefix + "sourceDir=" + sourceDir); 761 if (!Objects.equals(sourceDir, publicSourceDir)) { 762 pw.println(prefix + "publicSourceDir=" + publicSourceDir); 763 } 764 if (!ArrayUtils.isEmpty(splitSourceDirs)) { 765 pw.println(prefix + "splitSourceDirs=" + Arrays.toString(splitSourceDirs)); 766 } 767 if (!ArrayUtils.isEmpty(splitPublicSourceDirs) 768 && !Arrays.equals(splitSourceDirs, splitPublicSourceDirs)) { 769 pw.println(prefix + "splitPublicSourceDirs=" + Arrays.toString(splitPublicSourceDirs)); 770 } 771 if (resourceDirs != null) { 772 pw.println(prefix + "resourceDirs=" + Arrays.toString(resourceDirs)); 773 } 774 if ((flags&DUMP_FLAG_DETAILS) != 0 && seinfo != null) { 775 pw.println(prefix + "seinfo=" + seinfo); 776 } 777 pw.println(prefix + "dataDir=" + dataDir); 778 if ((flags&DUMP_FLAG_DETAILS) != 0) { 779 pw.println(prefix + "deviceEncryptedDataDir=" + deviceEncryptedDataDir); 780 pw.println(prefix + "credentialEncryptedDataDir=" + credentialEncryptedDataDir); 781 if (sharedLibraryFiles != null) { 782 pw.println(prefix + "sharedLibraryFiles=" + Arrays.toString(sharedLibraryFiles)); 783 } 784 } 785 pw.println(prefix + "enabled=" + enabled + " targetSdkVersion=" + targetSdkVersion 786 + " versionCode=" + versionCode); 787 if ((flags&DUMP_FLAG_DETAILS) != 0) { 788 if (manageSpaceActivityName != null) { 789 pw.println(prefix + "manageSpaceActivityName=" + manageSpaceActivityName); 790 } 791 if (descriptionRes != 0) { 792 pw.println(prefix + "description=0x" + Integer.toHexString(descriptionRes)); 793 } 794 if (uiOptions != 0) { 795 pw.println(prefix + "uiOptions=0x" + Integer.toHexString(uiOptions)); 796 } 797 pw.println(prefix + "supportsRtl=" + (hasRtlSupport() ? "true" : "false")); 798 if (fullBackupContent > 0) { 799 pw.println(prefix + "fullBackupContent=@xml/" + fullBackupContent); 800 } else { 801 pw.println(prefix + "fullBackupContent=" 802 + (fullBackupContent < 0 ? "false" : "true")); 803 } 804 } 805 super.dumpBack(pw, prefix); 806 } 807 808 /** 809 * @return true if "supportsRtl" has been set to true in the AndroidManifest 810 * @hide 811 */ 812 public boolean hasRtlSupport() { 813 return (flags & FLAG_SUPPORTS_RTL) == FLAG_SUPPORTS_RTL; 814 } 815 816 /** {@hide} */ 817 public boolean hasCode() { 818 return (flags & FLAG_HAS_CODE) != 0; 819 } 820 821 public static class DisplayNameComparator 822 implements Comparator<ApplicationInfo> { 823 public DisplayNameComparator(PackageManager pm) { 824 mPM = pm; 825 } 826 827 public final int compare(ApplicationInfo aa, ApplicationInfo ab) { 828 CharSequence sa = mPM.getApplicationLabel(aa); 829 if (sa == null) { 830 sa = aa.packageName; 831 } 832 CharSequence sb = mPM.getApplicationLabel(ab); 833 if (sb == null) { 834 sb = ab.packageName; 835 } 836 837 return sCollator.compare(sa.toString(), sb.toString()); 838 } 839 840 private final Collator sCollator = Collator.getInstance(); 841 private PackageManager mPM; 842 } 843 844 public ApplicationInfo() { 845 } 846 847 public ApplicationInfo(ApplicationInfo orig) { 848 super(orig); 849 taskAffinity = orig.taskAffinity; 850 permission = orig.permission; 851 processName = orig.processName; 852 className = orig.className; 853 theme = orig.theme; 854 flags = orig.flags; 855 privateFlags = orig.privateFlags; 856 requiresSmallestWidthDp = orig.requiresSmallestWidthDp; 857 compatibleWidthLimitDp = orig.compatibleWidthLimitDp; 858 largestWidthLimitDp = orig.largestWidthLimitDp; 859 volumeUuid = orig.volumeUuid; 860 scanSourceDir = orig.scanSourceDir; 861 scanPublicSourceDir = orig.scanPublicSourceDir; 862 sourceDir = orig.sourceDir; 863 publicSourceDir = orig.publicSourceDir; 864 splitSourceDirs = orig.splitSourceDirs; 865 splitPublicSourceDirs = orig.splitPublicSourceDirs; 866 nativeLibraryDir = orig.nativeLibraryDir; 867 secondaryNativeLibraryDir = orig.secondaryNativeLibraryDir; 868 nativeLibraryRootDir = orig.nativeLibraryRootDir; 869 nativeLibraryRootRequiresIsa = orig.nativeLibraryRootRequiresIsa; 870 primaryCpuAbi = orig.primaryCpuAbi; 871 secondaryCpuAbi = orig.secondaryCpuAbi; 872 resourceDirs = orig.resourceDirs; 873 seinfo = orig.seinfo; 874 sharedLibraryFiles = orig.sharedLibraryFiles; 875 dataDir = orig.dataDir; 876 deviceEncryptedDataDir = orig.deviceEncryptedDataDir; 877 credentialEncryptedDataDir = orig.credentialEncryptedDataDir; 878 uid = orig.uid; 879 targetSdkVersion = orig.targetSdkVersion; 880 versionCode = orig.versionCode; 881 enabled = orig.enabled; 882 enabledSetting = orig.enabledSetting; 883 installLocation = orig.installLocation; 884 manageSpaceActivityName = orig.manageSpaceActivityName; 885 descriptionRes = orig.descriptionRes; 886 uiOptions = orig.uiOptions; 887 backupAgentName = orig.backupAgentName; 888 fullBackupContent = orig.fullBackupContent; 889 } 890 891 public String toString() { 892 return "ApplicationInfo{" 893 + Integer.toHexString(System.identityHashCode(this)) 894 + " " + packageName + "}"; 895 } 896 897 public int describeContents() { 898 return 0; 899 } 900 901 public void writeToParcel(Parcel dest, int parcelableFlags) { 902 super.writeToParcel(dest, parcelableFlags); 903 dest.writeString(taskAffinity); 904 dest.writeString(permission); 905 dest.writeString(processName); 906 dest.writeString(className); 907 dest.writeInt(theme); 908 dest.writeInt(flags); 909 dest.writeInt(privateFlags); 910 dest.writeInt(requiresSmallestWidthDp); 911 dest.writeInt(compatibleWidthLimitDp); 912 dest.writeInt(largestWidthLimitDp); 913 dest.writeString(volumeUuid); 914 dest.writeString(scanSourceDir); 915 dest.writeString(scanPublicSourceDir); 916 dest.writeString(sourceDir); 917 dest.writeString(publicSourceDir); 918 dest.writeStringArray(splitSourceDirs); 919 dest.writeStringArray(splitPublicSourceDirs); 920 dest.writeString(nativeLibraryDir); 921 dest.writeString(secondaryNativeLibraryDir); 922 dest.writeString(nativeLibraryRootDir); 923 dest.writeInt(nativeLibraryRootRequiresIsa ? 1 : 0); 924 dest.writeString(primaryCpuAbi); 925 dest.writeString(secondaryCpuAbi); 926 dest.writeStringArray(resourceDirs); 927 dest.writeString(seinfo); 928 dest.writeStringArray(sharedLibraryFiles); 929 dest.writeString(dataDir); 930 dest.writeString(deviceEncryptedDataDir); 931 dest.writeString(credentialEncryptedDataDir); 932 dest.writeInt(uid); 933 dest.writeInt(targetSdkVersion); 934 dest.writeInt(versionCode); 935 dest.writeInt(enabled ? 1 : 0); 936 dest.writeInt(enabledSetting); 937 dest.writeInt(installLocation); 938 dest.writeString(manageSpaceActivityName); 939 dest.writeString(backupAgentName); 940 dest.writeInt(descriptionRes); 941 dest.writeInt(uiOptions); 942 dest.writeInt(fullBackupContent); 943 } 944 945 public static final Parcelable.Creator<ApplicationInfo> CREATOR 946 = new Parcelable.Creator<ApplicationInfo>() { 947 public ApplicationInfo createFromParcel(Parcel source) { 948 return new ApplicationInfo(source); 949 } 950 public ApplicationInfo[] newArray(int size) { 951 return new ApplicationInfo[size]; 952 } 953 }; 954 955 private ApplicationInfo(Parcel source) { 956 super(source); 957 taskAffinity = source.readString(); 958 permission = source.readString(); 959 processName = source.readString(); 960 className = source.readString(); 961 theme = source.readInt(); 962 flags = source.readInt(); 963 privateFlags = source.readInt(); 964 requiresSmallestWidthDp = source.readInt(); 965 compatibleWidthLimitDp = source.readInt(); 966 largestWidthLimitDp = source.readInt(); 967 volumeUuid = source.readString(); 968 scanSourceDir = source.readString(); 969 scanPublicSourceDir = source.readString(); 970 sourceDir = source.readString(); 971 publicSourceDir = source.readString(); 972 splitSourceDirs = source.readStringArray(); 973 splitPublicSourceDirs = source.readStringArray(); 974 nativeLibraryDir = source.readString(); 975 secondaryNativeLibraryDir = source.readString(); 976 nativeLibraryRootDir = source.readString(); 977 nativeLibraryRootRequiresIsa = source.readInt() != 0; 978 primaryCpuAbi = source.readString(); 979 secondaryCpuAbi = source.readString(); 980 resourceDirs = source.readStringArray(); 981 seinfo = source.readString(); 982 sharedLibraryFiles = source.readStringArray(); 983 dataDir = source.readString(); 984 deviceEncryptedDataDir = source.readString(); 985 credentialEncryptedDataDir = source.readString(); 986 uid = source.readInt(); 987 targetSdkVersion = source.readInt(); 988 versionCode = source.readInt(); 989 enabled = source.readInt() != 0; 990 enabledSetting = source.readInt(); 991 installLocation = source.readInt(); 992 manageSpaceActivityName = source.readString(); 993 backupAgentName = source.readString(); 994 descriptionRes = source.readInt(); 995 uiOptions = source.readInt(); 996 fullBackupContent = source.readInt(); 997 } 998 999 /** 1000 * Retrieve the textual description of the application. This 1001 * will call back on the given PackageManager to load the description from 1002 * the application. 1003 * 1004 * @param pm A PackageManager from which the label can be loaded; usually 1005 * the PackageManager from which you originally retrieved this item. 1006 * 1007 * @return Returns a CharSequence containing the application's description. 1008 * If there is no description, null is returned. 1009 */ 1010 public CharSequence loadDescription(PackageManager pm) { 1011 if (descriptionRes != 0) { 1012 CharSequence label = pm.getText(packageName, descriptionRes, this); 1013 if (label != null) { 1014 return label; 1015 } 1016 } 1017 return null; 1018 } 1019 1020 /** 1021 * Disable compatibility mode 1022 * 1023 * @hide 1024 */ 1025 public void disableCompatibilityMode() { 1026 flags |= (FLAG_SUPPORTS_LARGE_SCREENS | FLAG_SUPPORTS_NORMAL_SCREENS | 1027 FLAG_SUPPORTS_SMALL_SCREENS | FLAG_RESIZEABLE_FOR_SCREENS | 1028 FLAG_SUPPORTS_SCREEN_DENSITIES | FLAG_SUPPORTS_XLARGE_SCREENS); 1029 } 1030 1031 /** {@hide} */ 1032 public void initForUser(int userId) { 1033 uid = UserHandle.getUid(userId, UserHandle.getAppId(uid)); 1034 1035 if ("android".equals(packageName)) { 1036 dataDir = Environment.getDataSystemDirectory().getAbsolutePath(); 1037 return; 1038 } 1039 1040 deviceEncryptedDataDir = Environment 1041 .getDataUserDeviceEncryptedPackageDirectory(volumeUuid, userId, packageName) 1042 .getAbsolutePath(); 1043 credentialEncryptedDataDir = Environment 1044 .getDataUserCredentialEncryptedPackageDirectory(volumeUuid, userId, packageName) 1045 .getAbsolutePath(); 1046 1047 if ((privateFlags & PRIVATE_FLAG_FORCE_DEVICE_ENCRYPTED) != 0 1048 && StorageManager.isFileBasedEncryptionEnabled()) { 1049 dataDir = deviceEncryptedDataDir; 1050 } else { 1051 dataDir = credentialEncryptedDataDir; 1052 } 1053 } 1054 1055 /** 1056 * @hide 1057 */ 1058 @Override 1059 public Drawable loadDefaultIcon(PackageManager pm) { 1060 if ((flags & FLAG_EXTERNAL_STORAGE) != 0 1061 && isPackageUnavailable(pm)) { 1062 return Resources.getSystem().getDrawable( 1063 com.android.internal.R.drawable.sym_app_on_sd_unavailable_icon); 1064 } 1065 return pm.getDefaultActivityIcon(); 1066 } 1067 1068 private boolean isPackageUnavailable(PackageManager pm) { 1069 try { 1070 return pm.getPackageInfo(packageName, 0) == null; 1071 } catch (NameNotFoundException ex) { 1072 return true; 1073 } 1074 } 1075 1076 /** 1077 * @hide 1078 */ 1079 public boolean isForwardLocked() { 1080 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0; 1081 } 1082 1083 /** 1084 * @hide 1085 */ 1086 @TestApi 1087 public boolean isSystemApp() { 1088 return (flags & ApplicationInfo.FLAG_SYSTEM) != 0; 1089 } 1090 1091 /** 1092 * @hide 1093 */ 1094 @TestApi 1095 public boolean isPrivilegedApp() { 1096 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0; 1097 } 1098 1099 /** 1100 * @hide 1101 */ 1102 public boolean isUpdatedSystemApp() { 1103 return (flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0; 1104 } 1105 1106 /** @hide */ 1107 public boolean isInternal() { 1108 return (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 0; 1109 } 1110 1111 /** @hide */ 1112 public boolean isExternalAsec() { 1113 return TextUtils.isEmpty(volumeUuid) 1114 && (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0; 1115 } 1116 1117 /** @hide */ 1118 public boolean isEncryptionAware() { 1119 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_ENCRYPTION_AWARE) != 0; 1120 } 1121 1122 /** @hide */ 1123 public boolean isPartiallyEncryptionAware() { 1124 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_PARTIALLY_ENCRYPTION_AWARE) != 0; 1125 } 1126 1127 /** 1128 * @hide 1129 */ 1130 public boolean isAutoPlayApp() { 1131 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_AUTOPLAY) != 0; 1132 } 1133 1134 /** 1135 * @hide 1136 */ 1137 public boolean isEphemeralApp() { 1138 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_EPHEMERAL) != 0; 1139 } 1140 1141 /** 1142 * @hide 1143 */ 1144 public boolean isRequiredForSystemUser() { 1145 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_REQUIRED_FOR_SYSTEM_USER) != 0; 1146 } 1147 1148 /** 1149 * @hide 1150 */ 1151 @Override protected ApplicationInfo getApplicationInfo() { 1152 return this; 1153 } 1154 1155 /** {@hide} */ public void setCodePath(String codePath) { scanSourceDir = codePath; } 1156 /** {@hide} */ public void setBaseCodePath(String baseCodePath) { sourceDir = baseCodePath; } 1157 /** {@hide} */ public void setSplitCodePaths(String[] splitCodePaths) { splitSourceDirs = splitCodePaths; } 1158 /** {@hide} */ public void setResourcePath(String resourcePath) { scanPublicSourceDir = resourcePath; } 1159 /** {@hide} */ public void setBaseResourcePath(String baseResourcePath) { publicSourceDir = baseResourcePath; } 1160 /** {@hide} */ public void setSplitResourcePaths(String[] splitResourcePaths) { splitPublicSourceDirs = splitResourcePaths; } 1161 1162 /** {@hide} */ public String getCodePath() { return scanSourceDir; } 1163 /** {@hide} */ public String getBaseCodePath() { return sourceDir; } 1164 /** {@hide} */ public String[] getSplitCodePaths() { return splitSourceDirs; } 1165 /** {@hide} */ public String getResourcePath() { return scanPublicSourceDir; } 1166 /** {@hide} */ public String getBaseResourcePath() { return publicSourceDir; } 1167 /** {@hide} */ public String[] getSplitResourcePaths() { return splitSourceDirs; } 1168} 1169