ApplicationInfo.java revision f9fc6d6cc05595241bc7ced6d4cab97b45f9b901
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 * Private/hidden flags. See {@code PRIVATE_FLAG_...} constants. 483 * {@hide} 484 */ 485 public int privateFlags; 486 487 /** 488 * The required smallest screen width the application can run on. If 0, 489 * nothing has been specified. Comes from 490 * {@link android.R.styleable#AndroidManifestSupportsScreens_requiresSmallestWidthDp 491 * android:requiresSmallestWidthDp} attribute of the <supports-screens> tag. 492 */ 493 public int requiresSmallestWidthDp = 0; 494 495 /** 496 * The maximum smallest screen width the application is designed for. If 0, 497 * nothing has been specified. Comes from 498 * {@link android.R.styleable#AndroidManifestSupportsScreens_compatibleWidthLimitDp 499 * android:compatibleWidthLimitDp} attribute of the <supports-screens> tag. 500 */ 501 public int compatibleWidthLimitDp = 0; 502 503 /** 504 * The maximum smallest screen width the application will work on. If 0, 505 * nothing has been specified. Comes from 506 * {@link android.R.styleable#AndroidManifestSupportsScreens_largestWidthLimitDp 507 * android:largestWidthLimitDp} attribute of the <supports-screens> tag. 508 */ 509 public int largestWidthLimitDp = 0; 510 511 /** {@hide} */ 512 public String volumeUuid; 513 /** {@hide} */ 514 public String scanSourceDir; 515 /** {@hide} */ 516 public String scanPublicSourceDir; 517 518 /** 519 * Full path to the base APK for this application. 520 */ 521 public String sourceDir; 522 523 /** 524 * Full path to the publicly available parts of {@link #sourceDir}, 525 * including resources and manifest. This may be different from 526 * {@link #sourceDir} if an application is forward locked. 527 */ 528 public String publicSourceDir; 529 530 /** 531 * Full paths to zero or more split APKs that, when combined with the base 532 * APK defined in {@link #sourceDir}, form a complete application. 533 */ 534 public String[] splitSourceDirs; 535 536 /** 537 * Full path to the publicly available parts of {@link #splitSourceDirs}, 538 * including resources and manifest. This may be different from 539 * {@link #splitSourceDirs} if an application is forward locked. 540 */ 541 public String[] splitPublicSourceDirs; 542 543 /** 544 * Full paths to the locations of extra resource packages this application 545 * uses. This field is only used if there are extra resource packages, 546 * otherwise it is null. 547 * 548 * {@hide} 549 */ 550 public String[] resourceDirs; 551 552 /** 553 * String retrieved from the seinfo tag found in selinux policy. This value 554 * can be overridden with a value set through the mac_permissions.xml policy 555 * construct. This value is useful in setting an SELinux security context on 556 * the process as well as its data directory. The String default is being used 557 * here to represent a catchall label when no policy matches. 558 * 559 * {@hide} 560 */ 561 public String seinfo = "default"; 562 563 /** 564 * Paths to all shared libraries this application is linked against. This 565 * field is only set if the {@link PackageManager#GET_SHARED_LIBRARY_FILES 566 * PackageManager.GET_SHARED_LIBRARY_FILES} flag was used when retrieving 567 * the structure. 568 */ 569 public String[] sharedLibraryFiles; 570 571 /** 572 * Full path to a directory assigned to the package for its persistent data. 573 */ 574 public String dataDir; 575 576 /** {@hide} */ 577 public String deviceEncryptedDataDir; 578 /** {@hide} */ 579 public String credentialEncryptedDataDir; 580 581 /** 582 * Full path to the directory where native JNI libraries are stored. 583 */ 584 public String nativeLibraryDir; 585 586 /** 587 * Full path where unpacked native libraries for {@link #secondaryCpuAbi} 588 * are stored, if present. 589 * 590 * The main reason this exists is for bundled multi-arch apps, where 591 * it's not trivial to calculate the location of libs for the secondary abi 592 * given the location of the primary. 593 * 594 * TODO: Change the layout of bundled installs so that we can use 595 * nativeLibraryRootDir & nativeLibraryRootRequiresIsa there as well. 596 * (e.g {@code [ "/system/app-lib/Foo/arm", "/system/app-lib/Foo/arm64" ]} 597 * instead of {@code [ "/system/lib/Foo", "/system/lib64/Foo" ]}. 598 * 599 * @hide 600 */ 601 public String secondaryNativeLibraryDir; 602 603 /** 604 * The root path where unpacked native libraries are stored. 605 * <p> 606 * When {@link #nativeLibraryRootRequiresIsa} is set, the libraries are 607 * placed in ISA-specific subdirectories under this path, otherwise the 608 * libraries are placed directly at this path. 609 * 610 * @hide 611 */ 612 public String nativeLibraryRootDir; 613 614 /** 615 * Flag indicating that ISA must be appended to 616 * {@link #nativeLibraryRootDir} to be useful. 617 * 618 * @hide 619 */ 620 public boolean nativeLibraryRootRequiresIsa; 621 622 /** 623 * The primary ABI that this application requires, This is inferred from the ABIs 624 * of the native JNI libraries the application bundles. Will be {@code null} 625 * if this application does not require any particular ABI. 626 * 627 * If non-null, the application will always be launched with this ABI. 628 * 629 * {@hide} 630 */ 631 public String primaryCpuAbi; 632 633 /** 634 * The secondary ABI for this application. Might be non-null for multi-arch 635 * installs. The application itself never uses this ABI, but other applications that 636 * use its code might. 637 * 638 * {@hide} 639 */ 640 public String secondaryCpuAbi; 641 642 /** 643 * The kernel user-ID that has been assigned to this application; 644 * currently this is not a unique ID (multiple applications can have 645 * the same uid). 646 */ 647 public int uid; 648 649 /** 650 * The minimum SDK version this application targets. It may run on earlier 651 * versions, but it knows how to work with any new behavior added at this 652 * version. Will be {@link android.os.Build.VERSION_CODES#CUR_DEVELOPMENT} 653 * if this is a development build and the app is targeting that. You should 654 * compare that this number is >= the SDK version number at which your 655 * behavior was introduced. 656 */ 657 public int targetSdkVersion; 658 659 /** 660 * The app's declared version code. 661 * @hide 662 */ 663 public int versionCode; 664 665 /** 666 * When false, indicates that all components within this application are 667 * considered disabled, regardless of their individually set enabled status. 668 */ 669 public boolean enabled = true; 670 671 /** 672 * For convenient access to the current enabled setting of this app. 673 * @hide 674 */ 675 public int enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 676 677 /** 678 * For convenient access to package's install location. 679 * @hide 680 */ 681 public int installLocation = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 682 683 public void dump(Printer pw, String prefix) { 684 super.dumpFront(pw, prefix); 685 if (className != null) { 686 pw.println(prefix + "className=" + className); 687 } 688 if (permission != null) { 689 pw.println(prefix + "permission=" + permission); 690 } 691 pw.println(prefix + "processName=" + processName); 692 pw.println(prefix + "taskAffinity=" + taskAffinity); 693 pw.println(prefix + "uid=" + uid + " flags=0x" + Integer.toHexString(flags) 694 + " privateFlags=0x" + Integer.toHexString(privateFlags) 695 + " theme=0x" + Integer.toHexString(theme)); 696 pw.println(prefix + "requiresSmallestWidthDp=" + requiresSmallestWidthDp 697 + " compatibleWidthLimitDp=" + compatibleWidthLimitDp 698 + " largestWidthLimitDp=" + largestWidthLimitDp); 699 pw.println(prefix + "sourceDir=" + sourceDir); 700 if (!Objects.equals(sourceDir, publicSourceDir)) { 701 pw.println(prefix + "publicSourceDir=" + publicSourceDir); 702 } 703 if (!ArrayUtils.isEmpty(splitSourceDirs)) { 704 pw.println(prefix + "splitSourceDirs=" + Arrays.toString(splitSourceDirs)); 705 } 706 if (!ArrayUtils.isEmpty(splitPublicSourceDirs) 707 && !Arrays.equals(splitSourceDirs, splitPublicSourceDirs)) { 708 pw.println(prefix + "splitPublicSourceDirs=" + Arrays.toString(splitPublicSourceDirs)); 709 } 710 if (resourceDirs != null) { 711 pw.println(prefix + "resourceDirs=" + resourceDirs); 712 } 713 if (seinfo != null) { 714 pw.println(prefix + "seinfo=" + seinfo); 715 } 716 pw.println(prefix + "dataDir=" + dataDir); 717 pw.println(prefix + "deviceEncryptedDataDir=" + deviceEncryptedDataDir); 718 pw.println(prefix + "credentialEncryptedDataDir=" + credentialEncryptedDataDir); 719 if (sharedLibraryFiles != null) { 720 pw.println(prefix + "sharedLibraryFiles=" + Arrays.toString(sharedLibraryFiles)); 721 } 722 pw.println(prefix + "enabled=" + enabled + " targetSdkVersion=" + targetSdkVersion 723 + " versionCode=" + versionCode); 724 if (manageSpaceActivityName != null) { 725 pw.println(prefix + "manageSpaceActivityName="+manageSpaceActivityName); 726 } 727 if (descriptionRes != 0) { 728 pw.println(prefix + "description=0x"+Integer.toHexString(descriptionRes)); 729 } 730 if (uiOptions != 0) { 731 pw.println(prefix + "uiOptions=0x" + Integer.toHexString(uiOptions)); 732 } 733 pw.println(prefix + "supportsRtl=" + (hasRtlSupport() ? "true" : "false")); 734 if (fullBackupContent > 0) { 735 pw.println(prefix + "fullBackupContent=@xml/" + fullBackupContent); 736 } else { 737 pw.println(prefix + "fullBackupContent=" + (fullBackupContent < 0 ? "false" : "true")); 738 } 739 super.dumpBack(pw, prefix); 740 } 741 742 /** 743 * @return true if "supportsRtl" has been set to true in the AndroidManifest 744 * @hide 745 */ 746 public boolean hasRtlSupport() { 747 return (flags & FLAG_SUPPORTS_RTL) == FLAG_SUPPORTS_RTL; 748 } 749 750 public static class DisplayNameComparator 751 implements Comparator<ApplicationInfo> { 752 public DisplayNameComparator(PackageManager pm) { 753 mPM = pm; 754 } 755 756 public final int compare(ApplicationInfo aa, ApplicationInfo ab) { 757 CharSequence sa = mPM.getApplicationLabel(aa); 758 if (sa == null) { 759 sa = aa.packageName; 760 } 761 CharSequence sb = mPM.getApplicationLabel(ab); 762 if (sb == null) { 763 sb = ab.packageName; 764 } 765 766 return sCollator.compare(sa.toString(), sb.toString()); 767 } 768 769 private final Collator sCollator = Collator.getInstance(); 770 private PackageManager mPM; 771 } 772 773 public ApplicationInfo() { 774 } 775 776 public ApplicationInfo(ApplicationInfo orig) { 777 super(orig); 778 taskAffinity = orig.taskAffinity; 779 permission = orig.permission; 780 processName = orig.processName; 781 className = orig.className; 782 theme = orig.theme; 783 flags = orig.flags; 784 privateFlags = orig.privateFlags; 785 requiresSmallestWidthDp = orig.requiresSmallestWidthDp; 786 compatibleWidthLimitDp = orig.compatibleWidthLimitDp; 787 largestWidthLimitDp = orig.largestWidthLimitDp; 788 volumeUuid = orig.volumeUuid; 789 scanSourceDir = orig.scanSourceDir; 790 scanPublicSourceDir = orig.scanPublicSourceDir; 791 sourceDir = orig.sourceDir; 792 publicSourceDir = orig.publicSourceDir; 793 splitSourceDirs = orig.splitSourceDirs; 794 splitPublicSourceDirs = orig.splitPublicSourceDirs; 795 nativeLibraryDir = orig.nativeLibraryDir; 796 secondaryNativeLibraryDir = orig.secondaryNativeLibraryDir; 797 nativeLibraryRootDir = orig.nativeLibraryRootDir; 798 nativeLibraryRootRequiresIsa = orig.nativeLibraryRootRequiresIsa; 799 primaryCpuAbi = orig.primaryCpuAbi; 800 secondaryCpuAbi = orig.secondaryCpuAbi; 801 resourceDirs = orig.resourceDirs; 802 seinfo = orig.seinfo; 803 sharedLibraryFiles = orig.sharedLibraryFiles; 804 dataDir = orig.dataDir; 805 deviceEncryptedDataDir = orig.deviceEncryptedDataDir; 806 credentialEncryptedDataDir = orig.credentialEncryptedDataDir; 807 uid = orig.uid; 808 targetSdkVersion = orig.targetSdkVersion; 809 versionCode = orig.versionCode; 810 enabled = orig.enabled; 811 enabledSetting = orig.enabledSetting; 812 installLocation = orig.installLocation; 813 manageSpaceActivityName = orig.manageSpaceActivityName; 814 descriptionRes = orig.descriptionRes; 815 uiOptions = orig.uiOptions; 816 backupAgentName = orig.backupAgentName; 817 fullBackupContent = orig.fullBackupContent; 818 } 819 820 public String toString() { 821 return "ApplicationInfo{" 822 + Integer.toHexString(System.identityHashCode(this)) 823 + " " + packageName + "}"; 824 } 825 826 public int describeContents() { 827 return 0; 828 } 829 830 public void writeToParcel(Parcel dest, int parcelableFlags) { 831 super.writeToParcel(dest, parcelableFlags); 832 dest.writeString(taskAffinity); 833 dest.writeString(permission); 834 dest.writeString(processName); 835 dest.writeString(className); 836 dest.writeInt(theme); 837 dest.writeInt(flags); 838 dest.writeInt(privateFlags); 839 dest.writeInt(requiresSmallestWidthDp); 840 dest.writeInt(compatibleWidthLimitDp); 841 dest.writeInt(largestWidthLimitDp); 842 dest.writeString(volumeUuid); 843 dest.writeString(scanSourceDir); 844 dest.writeString(scanPublicSourceDir); 845 dest.writeString(sourceDir); 846 dest.writeString(publicSourceDir); 847 dest.writeStringArray(splitSourceDirs); 848 dest.writeStringArray(splitPublicSourceDirs); 849 dest.writeString(nativeLibraryDir); 850 dest.writeString(secondaryNativeLibraryDir); 851 dest.writeString(nativeLibraryRootDir); 852 dest.writeInt(nativeLibraryRootRequiresIsa ? 1 : 0); 853 dest.writeString(primaryCpuAbi); 854 dest.writeString(secondaryCpuAbi); 855 dest.writeStringArray(resourceDirs); 856 dest.writeString(seinfo); 857 dest.writeStringArray(sharedLibraryFiles); 858 dest.writeString(dataDir); 859 dest.writeString(deviceEncryptedDataDir); 860 dest.writeString(credentialEncryptedDataDir); 861 dest.writeInt(uid); 862 dest.writeInt(targetSdkVersion); 863 dest.writeInt(versionCode); 864 dest.writeInt(enabled ? 1 : 0); 865 dest.writeInt(enabledSetting); 866 dest.writeInt(installLocation); 867 dest.writeString(manageSpaceActivityName); 868 dest.writeString(backupAgentName); 869 dest.writeInt(descriptionRes); 870 dest.writeInt(uiOptions); 871 dest.writeInt(fullBackupContent); 872 } 873 874 public static final Parcelable.Creator<ApplicationInfo> CREATOR 875 = new Parcelable.Creator<ApplicationInfo>() { 876 public ApplicationInfo createFromParcel(Parcel source) { 877 return new ApplicationInfo(source); 878 } 879 public ApplicationInfo[] newArray(int size) { 880 return new ApplicationInfo[size]; 881 } 882 }; 883 884 private ApplicationInfo(Parcel source) { 885 super(source); 886 taskAffinity = source.readString(); 887 permission = source.readString(); 888 processName = source.readString(); 889 className = source.readString(); 890 theme = source.readInt(); 891 flags = source.readInt(); 892 privateFlags = source.readInt(); 893 requiresSmallestWidthDp = source.readInt(); 894 compatibleWidthLimitDp = source.readInt(); 895 largestWidthLimitDp = source.readInt(); 896 volumeUuid = source.readString(); 897 scanSourceDir = source.readString(); 898 scanPublicSourceDir = source.readString(); 899 sourceDir = source.readString(); 900 publicSourceDir = source.readString(); 901 splitSourceDirs = source.readStringArray(); 902 splitPublicSourceDirs = source.readStringArray(); 903 nativeLibraryDir = source.readString(); 904 secondaryNativeLibraryDir = source.readString(); 905 nativeLibraryRootDir = source.readString(); 906 nativeLibraryRootRequiresIsa = source.readInt() != 0; 907 primaryCpuAbi = source.readString(); 908 secondaryCpuAbi = source.readString(); 909 resourceDirs = source.readStringArray(); 910 seinfo = source.readString(); 911 sharedLibraryFiles = source.readStringArray(); 912 dataDir = source.readString(); 913 deviceEncryptedDataDir = source.readString(); 914 credentialEncryptedDataDir = source.readString(); 915 uid = source.readInt(); 916 targetSdkVersion = source.readInt(); 917 versionCode = source.readInt(); 918 enabled = source.readInt() != 0; 919 enabledSetting = source.readInt(); 920 installLocation = source.readInt(); 921 manageSpaceActivityName = source.readString(); 922 backupAgentName = source.readString(); 923 descriptionRes = source.readInt(); 924 uiOptions = source.readInt(); 925 fullBackupContent = source.readInt(); 926 } 927 928 /** 929 * Retrieve the textual description of the application. This 930 * will call back on the given PackageManager to load the description from 931 * the application. 932 * 933 * @param pm A PackageManager from which the label can be loaded; usually 934 * the PackageManager from which you originally retrieved this item. 935 * 936 * @return Returns a CharSequence containing the application's description. 937 * If there is no description, null is returned. 938 */ 939 public CharSequence loadDescription(PackageManager pm) { 940 if (descriptionRes != 0) { 941 CharSequence label = pm.getText(packageName, descriptionRes, this); 942 if (label != null) { 943 return label; 944 } 945 } 946 return null; 947 } 948 949 /** 950 * Disable compatibility mode 951 * 952 * @hide 953 */ 954 public void disableCompatibilityMode() { 955 flags |= (FLAG_SUPPORTS_LARGE_SCREENS | FLAG_SUPPORTS_NORMAL_SCREENS | 956 FLAG_SUPPORTS_SMALL_SCREENS | FLAG_RESIZEABLE_FOR_SCREENS | 957 FLAG_SUPPORTS_SCREEN_DENSITIES | FLAG_SUPPORTS_XLARGE_SCREENS); 958 } 959 960 /** {@hide} */ 961 public void initForUser(int userId) { 962 uid = UserHandle.getUid(userId, UserHandle.getAppId(uid)); 963 964 if ("android".equals(packageName)) { 965 dataDir = Environment.getDataSystemDirectory().getAbsolutePath(); 966 return; 967 } 968 969 deviceEncryptedDataDir = Environment 970 .getDataUserDeviceEncryptedPackageDirectory(volumeUuid, userId, packageName) 971 .getAbsolutePath(); 972 credentialEncryptedDataDir = Environment 973 .getDataUserCredentialEncryptedPackageDirectory(volumeUuid, userId, packageName) 974 .getAbsolutePath(); 975 976 if ((privateFlags & PRIVATE_FLAG_FORCE_DEVICE_ENCRYPTED) != 0 977 && SystemProperties.getBoolean(StorageManager.PROP_HAS_FBE, false)) { 978 dataDir = deviceEncryptedDataDir; 979 } else { 980 dataDir = credentialEncryptedDataDir; 981 } 982 } 983 984 /** 985 * @hide 986 */ 987 @Override 988 public Drawable loadDefaultIcon(PackageManager pm) { 989 if ((flags & FLAG_EXTERNAL_STORAGE) != 0 990 && isPackageUnavailable(pm)) { 991 return Resources.getSystem().getDrawable( 992 com.android.internal.R.drawable.sym_app_on_sd_unavailable_icon); 993 } 994 return pm.getDefaultActivityIcon(); 995 } 996 997 private boolean isPackageUnavailable(PackageManager pm) { 998 try { 999 return pm.getPackageInfo(packageName, 0) == null; 1000 } catch (NameNotFoundException ex) { 1001 return true; 1002 } 1003 } 1004 1005 /** 1006 * @hide 1007 */ 1008 public boolean isForwardLocked() { 1009 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0; 1010 } 1011 1012 /** 1013 * @hide 1014 */ 1015 public boolean isSystemApp() { 1016 return (flags & ApplicationInfo.FLAG_SYSTEM) != 0; 1017 } 1018 1019 /** 1020 * @hide 1021 */ 1022 public boolean isPrivilegedApp() { 1023 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0; 1024 } 1025 1026 /** 1027 * @hide 1028 */ 1029 public boolean isUpdatedSystemApp() { 1030 return (flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0; 1031 } 1032 1033 /** @hide */ 1034 public boolean isInternal() { 1035 return (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 0; 1036 } 1037 1038 /** @hide */ 1039 public boolean isExternalAsec() { 1040 return TextUtils.isEmpty(volumeUuid) 1041 && (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0; 1042 } 1043 1044 /** @hide */ 1045 public boolean isEncryptionAware() { 1046 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_ENCRYPTION_AWARE) != 0; 1047 } 1048 1049 /** 1050 * @hide 1051 */ 1052 @Override protected ApplicationInfo getApplicationInfo() { 1053 return this; 1054 } 1055 1056 /** {@hide} */ public void setCodePath(String codePath) { scanSourceDir = codePath; } 1057 /** {@hide} */ public void setBaseCodePath(String baseCodePath) { sourceDir = baseCodePath; } 1058 /** {@hide} */ public void setSplitCodePaths(String[] splitCodePaths) { splitSourceDirs = splitCodePaths; } 1059 /** {@hide} */ public void setResourcePath(String resourcePath) { scanPublicSourceDir = resourcePath; } 1060 /** {@hide} */ public void setBaseResourcePath(String baseResourcePath) { publicSourceDir = baseResourcePath; } 1061 /** {@hide} */ public void setSplitResourcePaths(String[] splitResourcePaths) { splitPublicSourceDirs = splitResourcePaths; } 1062 1063 /** {@hide} */ public String getCodePath() { return scanSourceDir; } 1064 /** {@hide} */ public String getBaseCodePath() { return sourceDir; } 1065 /** {@hide} */ public String[] getSplitCodePaths() { return splitSourceDirs; } 1066 /** {@hide} */ public String getResourcePath() { return scanPublicSourceDir; } 1067 /** {@hide} */ public String getBaseResourcePath() { return publicSourceDir; } 1068 /** {@hide} */ public String[] getSplitResourcePaths() { return splitSourceDirs; } 1069} 1070