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 17 package android.content.pm; 18 19 import static android.os.Build.VERSION_CODES.DONUT; 20 21 import android.annotation.IntDef; 22 import android.annotation.SystemApi; 23 import android.annotation.TestApi; 24 import android.content.Context; 25 import android.content.pm.PackageManager.NameNotFoundException; 26 import android.content.res.Resources; 27 import android.graphics.drawable.Drawable; 28 import android.os.Environment; 29 import android.os.Parcel; 30 import android.os.Parcelable; 31 import android.os.UserHandle; 32 import android.os.storage.StorageManager; 33 import android.text.TextUtils; 34 import android.util.Printer; 35 import android.util.SparseArray; 36 37 import com.android.internal.util.ArrayUtils; 38 39 import java.lang.annotation.Retention; 40 import java.lang.annotation.RetentionPolicy; 41 import java.text.Collator; 42 import java.util.Arrays; 43 import java.util.Comparator; 44 import java.util.Objects; 45 import java.util.UUID; 46 47 /** 48 * Information you can retrieve about a particular application. This 49 * corresponds to information collected from the AndroidManifest.xml's 50 * <application> tag. 51 */ 52 public class ApplicationInfo extends PackageItemInfo implements Parcelable { 53 54 /** 55 * Default task affinity of all activities in this application. See 56 * {@link ActivityInfo#taskAffinity} for more information. This comes 57 * from the "taskAffinity" attribute. 58 */ 59 public String taskAffinity; 60 61 /** 62 * Optional name of a permission required to be able to access this 63 * application's components. From the "permission" attribute. 64 */ 65 public String permission; 66 67 /** 68 * The name of the process this application should run in. From the 69 * "process" attribute or, if not set, the same as 70 * <var>packageName</var>. 71 */ 72 public String processName; 73 74 /** 75 * Class implementing the Application object. From the "class" 76 * attribute. 77 */ 78 public String className; 79 80 /** 81 * A style resource identifier (in the package's resources) of the 82 * description of an application. From the "description" attribute 83 * or, if not set, 0. 84 */ 85 public int descriptionRes; 86 87 /** 88 * A style resource identifier (in the package's resources) of the 89 * default visual theme of the application. From the "theme" attribute 90 * or, if not set, 0. 91 */ 92 public int theme; 93 94 /** 95 * Class implementing the Application's manage space 96 * functionality. From the "manageSpaceActivity" 97 * attribute. This is an optional attribute and will be null if 98 * applications don't specify it in their manifest 99 */ 100 public String manageSpaceActivityName; 101 102 /** 103 * Class implementing the Application's backup functionality. From 104 * the "backupAgent" attribute. This is an optional attribute and 105 * will be null if the application does not specify it in its manifest. 106 * 107 * <p>If android:allowBackup is set to false, this attribute is ignored. 108 */ 109 public String backupAgentName; 110 111 /** 112 * An optional attribute that indicates the app supports automatic backup of app data. 113 * <p>0 is the default and means the app's entire data folder + managed external storage will 114 * be backed up; 115 * Any negative value indicates the app does not support full-data backup, though it may still 116 * want to participate via the traditional key/value backup API; 117 * A positive number specifies an xml resource in which the application has defined its backup 118 * include/exclude criteria. 119 * <p>If android:allowBackup is set to false, this attribute is ignored. 120 * 121 * @see android.content.Context#getNoBackupFilesDir() 122 * @see #FLAG_ALLOW_BACKUP 123 * 124 * @hide 125 */ 126 public int fullBackupContent = 0; 127 128 /** 129 * The default extra UI options for activities in this application. 130 * Set from the {@link android.R.attr#uiOptions} attribute in the 131 * activity's manifest. 132 */ 133 public int uiOptions = 0; 134 135 /** 136 * Value for {@link #flags}: if set, this application is installed in the 137 * device's system image. 138 */ 139 public static final int FLAG_SYSTEM = 1<<0; 140 141 /** 142 * Value for {@link #flags}: set to true if this application would like to 143 * allow debugging of its 144 * code, even when installed on a non-development system. Comes 145 * from {@link android.R.styleable#AndroidManifestApplication_debuggable 146 * android:debuggable} of the <application> tag. 147 */ 148 public static final int FLAG_DEBUGGABLE = 1<<1; 149 150 /** 151 * Value for {@link #flags}: set to true if this application has code 152 * associated with it. Comes 153 * from {@link android.R.styleable#AndroidManifestApplication_hasCode 154 * android:hasCode} of the <application> tag. 155 */ 156 public static final int FLAG_HAS_CODE = 1<<2; 157 158 /** 159 * Value for {@link #flags}: set to true if this application is persistent. 160 * Comes from {@link android.R.styleable#AndroidManifestApplication_persistent 161 * android:persistent} of the <application> tag. 162 */ 163 public static final int FLAG_PERSISTENT = 1<<3; 164 165 /** 166 * Value for {@link #flags}: set to true if this application holds the 167 * {@link android.Manifest.permission#FACTORY_TEST} permission and the 168 * device is running in factory test mode. 169 */ 170 public static final int FLAG_FACTORY_TEST = 1<<4; 171 172 /** 173 * Value for {@link #flags}: default value for the corresponding ActivityInfo flag. 174 * Comes from {@link android.R.styleable#AndroidManifestApplication_allowTaskReparenting 175 * android:allowTaskReparenting} of the <application> tag. 176 */ 177 public static final int FLAG_ALLOW_TASK_REPARENTING = 1<<5; 178 179 /** 180 * Value for {@link #flags}: default value for the corresponding ActivityInfo flag. 181 * Comes from {@link android.R.styleable#AndroidManifestApplication_allowClearUserData 182 * android:allowClearUserData} of the <application> tag. 183 */ 184 public static final int FLAG_ALLOW_CLEAR_USER_DATA = 1<<6; 185 186 /** 187 * Value for {@link #flags}: this is set if this application has been 188 * installed as an update to a built-in system application. 189 */ 190 public static final int FLAG_UPDATED_SYSTEM_APP = 1<<7; 191 192 /** 193 * Value for {@link #flags}: this is set if the application has specified 194 * {@link android.R.styleable#AndroidManifestApplication_testOnly 195 * android:testOnly} to be true. 196 */ 197 public static final int FLAG_TEST_ONLY = 1<<8; 198 199 /** 200 * Value for {@link #flags}: true when the application's window can be 201 * reduced in size for smaller screens. Corresponds to 202 * {@link android.R.styleable#AndroidManifestSupportsScreens_smallScreens 203 * android:smallScreens}. 204 */ 205 public static final int FLAG_SUPPORTS_SMALL_SCREENS = 1<<9; 206 207 /** 208 * Value for {@link #flags}: true when the application's window can be 209 * displayed on normal screens. Corresponds to 210 * {@link android.R.styleable#AndroidManifestSupportsScreens_normalScreens 211 * android:normalScreens}. 212 */ 213 public static final int FLAG_SUPPORTS_NORMAL_SCREENS = 1<<10; 214 215 /** 216 * Value for {@link #flags}: true when the application's window can be 217 * increased in size for larger screens. Corresponds to 218 * {@link android.R.styleable#AndroidManifestSupportsScreens_largeScreens 219 * android:largeScreens}. 220 */ 221 public static final int FLAG_SUPPORTS_LARGE_SCREENS = 1<<11; 222 223 /** 224 * Value for {@link #flags}: true when the application knows how to adjust 225 * its UI for different screen sizes. Corresponds to 226 * {@link android.R.styleable#AndroidManifestSupportsScreens_resizeable 227 * android:resizeable}. 228 */ 229 public static final int FLAG_RESIZEABLE_FOR_SCREENS = 1<<12; 230 231 /** 232 * Value for {@link #flags}: true when the application knows how to 233 * accomodate different screen densities. Corresponds to 234 * {@link android.R.styleable#AndroidManifestSupportsScreens_anyDensity 235 * android:anyDensity}. 236 */ 237 public static final int FLAG_SUPPORTS_SCREEN_DENSITIES = 1<<13; 238 239 /** 240 * Value for {@link #flags}: set to true if this application would like to 241 * request the VM to operate under the safe mode. Comes from 242 * {@link android.R.styleable#AndroidManifestApplication_vmSafeMode 243 * android:vmSafeMode} of the <application> tag. 244 */ 245 public static final int FLAG_VM_SAFE_MODE = 1<<14; 246 247 /** 248 * Value for {@link #flags}: set to <code>false</code> if the application does not wish 249 * to permit any OS-driven backups of its data; <code>true</code> otherwise. 250 * 251 * <p>Comes from the 252 * {@link android.R.styleable#AndroidManifestApplication_allowBackup android:allowBackup} 253 * attribute of the <application> tag. 254 */ 255 public static final int FLAG_ALLOW_BACKUP = 1<<15; 256 257 /** 258 * Value for {@link #flags}: set to <code>false</code> if the application must be kept 259 * in memory following a full-system restore operation; <code>true</code> otherwise. 260 * Ordinarily, during a full system restore operation each application is shut down 261 * following execution of its agent's onRestore() method. Setting this attribute to 262 * <code>false</code> prevents this. Most applications will not need to set this attribute. 263 * 264 * <p>If 265 * {@link android.R.styleable#AndroidManifestApplication_allowBackup android:allowBackup} 266 * is set to <code>false</code> or no 267 * {@link android.R.styleable#AndroidManifestApplication_backupAgent android:backupAgent} 268 * is specified, this flag will be ignored. 269 * 270 * <p>Comes from the 271 * {@link android.R.styleable#AndroidManifestApplication_killAfterRestore android:killAfterRestore} 272 * attribute of the <application> tag. 273 */ 274 public static final int FLAG_KILL_AFTER_RESTORE = 1<<16; 275 276 /** 277 * Value for {@link #flags}: Set to <code>true</code> if the application's backup 278 * agent claims to be able to handle restore data even "from the future," 279 * i.e. from versions of the application with a versionCode greater than 280 * the one currently installed on the device. <i>Use with caution!</i> By default 281 * this attribute is <code>false</code> and the Backup Manager will ensure that data 282 * from "future" versions of the application are never supplied during a restore operation. 283 * 284 * <p>If 285 * {@link android.R.styleable#AndroidManifestApplication_allowBackup android:allowBackup} 286 * is set to <code>false</code> or no 287 * {@link android.R.styleable#AndroidManifestApplication_backupAgent android:backupAgent} 288 * is specified, this flag will be ignored. 289 * 290 * <p>Comes from the 291 * {@link android.R.styleable#AndroidManifestApplication_restoreAnyVersion android:restoreAnyVersion} 292 * attribute of the <application> tag. 293 */ 294 public static final int FLAG_RESTORE_ANY_VERSION = 1<<17; 295 296 /** 297 * Value for {@link #flags}: Set to true if the application is 298 * currently installed on external/removable/unprotected storage. Such 299 * applications may not be available if their storage is not currently 300 * mounted. When the storage it is on is not available, it will look like 301 * the application has been uninstalled (its .apk is no longer available) 302 * but its persistent data is not removed. 303 */ 304 public static final int FLAG_EXTERNAL_STORAGE = 1<<18; 305 306 /** 307 * Value for {@link #flags}: true when the application's window can be 308 * increased in size for extra large screens. Corresponds to 309 * {@link android.R.styleable#AndroidManifestSupportsScreens_xlargeScreens 310 * android:xlargeScreens}. 311 */ 312 public static final int FLAG_SUPPORTS_XLARGE_SCREENS = 1<<19; 313 314 /** 315 * Value for {@link #flags}: true when the application has requested a 316 * large heap for its processes. Corresponds to 317 * {@link android.R.styleable#AndroidManifestApplication_largeHeap 318 * android:largeHeap}. 319 */ 320 public static final int FLAG_LARGE_HEAP = 1<<20; 321 322 /** 323 * Value for {@link #flags}: true if this application's package is in 324 * the stopped state. 325 */ 326 public static final int FLAG_STOPPED = 1<<21; 327 328 /** 329 * Value for {@link #flags}: true when the application is willing to support 330 * RTL (right to left). All activities will inherit this value. 331 * 332 * Set from the {@link android.R.attr#supportsRtl} attribute in the 333 * activity's manifest. 334 * 335 * Default value is false (no support for RTL). 336 */ 337 public static final int FLAG_SUPPORTS_RTL = 1<<22; 338 339 /** 340 * Value for {@link #flags}: true if the application is currently 341 * installed for the calling user. 342 */ 343 public static final int FLAG_INSTALLED = 1<<23; 344 345 /** 346 * Value for {@link #flags}: true if the application only has its 347 * data installed; the application package itself does not currently 348 * exist on the device. 349 */ 350 public static final int FLAG_IS_DATA_ONLY = 1<<24; 351 352 /** 353 * Value for {@link #flags}: true if the application was declared to be a 354 * game, or false if it is a non-game application. 355 * 356 * @deprecated use {@link #CATEGORY_GAME} instead. 357 */ 358 @Deprecated 359 public static final int FLAG_IS_GAME = 1<<25; 360 361 /** 362 * Value for {@link #flags}: {@code true} if the application asks that only 363 * full-data streaming backups of its data be performed even though it defines 364 * a {@link android.app.backup.BackupAgent BackupAgent}, which normally 365 * indicates that the app will manage its backed-up data via incremental 366 * key/value updates. 367 */ 368 public static final int FLAG_FULL_BACKUP_ONLY = 1<<26; 369 370 /** 371 * Value for {@link #flags}: {@code true} if the application may use cleartext network traffic 372 * (e.g., HTTP rather than HTTPS; WebSockets rather than WebSockets Secure; XMPP, IMAP, STMP 373 * without STARTTLS or TLS). If {@code false}, the app declares that it does not intend to use 374 * cleartext network traffic, in which case platform components (e.g., HTTP stacks, 375 * {@code DownloadManager}, {@code MediaPlayer}) will refuse app's requests to use cleartext 376 * traffic. Third-party libraries are encouraged to honor this flag as well. 377 * 378 * <p>NOTE: {@code WebView} does not honor this flag. 379 * 380 * <p>This flag is ignored on Android N and above if an Android Network Security Config is 381 * present. 382 * 383 * <p>This flag comes from 384 * {@link android.R.styleable#AndroidManifestApplication_usesCleartextTraffic 385 * android:usesCleartextTraffic} of the <application> tag. 386 */ 387 public static final int FLAG_USES_CLEARTEXT_TRAFFIC = 1<<27; 388 389 /** 390 * When set installer extracts native libs from .apk files. 391 */ 392 public static final int FLAG_EXTRACT_NATIVE_LIBS = 1<<28; 393 394 /** 395 * Value for {@link #flags}: {@code true} when the application's rendering 396 * should be hardware accelerated. 397 */ 398 public static final int FLAG_HARDWARE_ACCELERATED = 1<<29; 399 400 /** 401 * Value for {@link #flags}: true if this application's package is in 402 * the suspended state. 403 */ 404 public static final int FLAG_SUSPENDED = 1<<30; 405 406 /** 407 * Value for {@link #flags}: true if code from this application will need to be 408 * loaded into other applications' processes. On devices that support multiple 409 * instruction sets, this implies the code might be loaded into a process that's 410 * using any of the devices supported instruction sets. 411 * 412 * <p> The system might treat such applications specially, for eg., by 413 * extracting the application's native libraries for all supported instruction 414 * sets or by compiling the application's dex code for all supported instruction 415 * sets. 416 */ 417 public static final int FLAG_MULTIARCH = 1 << 31; 418 419 /** 420 * Flags associated with the application. Any combination of 421 * {@link #FLAG_SYSTEM}, {@link #FLAG_DEBUGGABLE}, {@link #FLAG_HAS_CODE}, 422 * {@link #FLAG_PERSISTENT}, {@link #FLAG_FACTORY_TEST}, and 423 * {@link #FLAG_ALLOW_TASK_REPARENTING} 424 * {@link #FLAG_ALLOW_CLEAR_USER_DATA}, {@link #FLAG_UPDATED_SYSTEM_APP}, 425 * {@link #FLAG_TEST_ONLY}, {@link #FLAG_SUPPORTS_SMALL_SCREENS}, 426 * {@link #FLAG_SUPPORTS_NORMAL_SCREENS}, 427 * {@link #FLAG_SUPPORTS_LARGE_SCREENS}, {@link #FLAG_SUPPORTS_XLARGE_SCREENS}, 428 * {@link #FLAG_RESIZEABLE_FOR_SCREENS}, 429 * {@link #FLAG_SUPPORTS_SCREEN_DENSITIES}, {@link #FLAG_VM_SAFE_MODE}, 430 * {@link #FLAG_ALLOW_BACKUP}, {@link #FLAG_KILL_AFTER_RESTORE}, 431 * {@link #FLAG_RESTORE_ANY_VERSION}, {@link #FLAG_EXTERNAL_STORAGE}, 432 * {@link #FLAG_LARGE_HEAP}, {@link #FLAG_STOPPED}, 433 * {@link #FLAG_SUPPORTS_RTL}, {@link #FLAG_INSTALLED}, 434 * {@link #FLAG_IS_DATA_ONLY}, {@link #FLAG_IS_GAME}, 435 * {@link #FLAG_FULL_BACKUP_ONLY}, {@link #FLAG_USES_CLEARTEXT_TRAFFIC}, 436 * {@link #FLAG_MULTIARCH}. 437 */ 438 public int flags = 0; 439 440 /** 441 * Value for {@link #privateFlags}: true if the application is hidden via restrictions and for 442 * most purposes is considered as not installed. 443 * {@hide} 444 */ 445 public static final int PRIVATE_FLAG_HIDDEN = 1<<0; 446 447 /** 448 * Value for {@link #privateFlags}: set to <code>true</code> if the application 449 * has reported that it is heavy-weight, and thus can not participate in 450 * the normal application lifecycle. 451 * 452 * <p>Comes from the 453 * android.R.styleable#AndroidManifestApplication_cantSaveState 454 * attribute of the <application> tag. 455 * 456 * {@hide} 457 */ 458 public static final int PRIVATE_FLAG_CANT_SAVE_STATE = 1<<1; 459 460 /** 461 * Value for {@link #privateFlags}: Set to true if the application has been 462 * installed using the forward lock option. 463 * 464 * NOTE: DO NOT CHANGE THIS VALUE! It is saved in packages.xml. 465 * 466 * {@hide} 467 */ 468 public static final int PRIVATE_FLAG_FORWARD_LOCK = 1<<2; 469 470 /** 471 * Value for {@link #privateFlags}: set to {@code true} if the application 472 * is permitted to hold privileged permissions. 473 * 474 * {@hide} 475 */ 476 public static final int PRIVATE_FLAG_PRIVILEGED = 1<<3; 477 478 /** 479 * Value for {@link #privateFlags}: {@code true} if the application has any IntentFiler 480 * with some data URI using HTTP or HTTPS with an associated VIEW action. 481 * 482 * {@hide} 483 */ 484 public static final int PRIVATE_FLAG_HAS_DOMAIN_URLS = 1<<4; 485 486 /** 487 * When set, the default data storage directory for this app is pointed at 488 * the device-protected location. 489 * 490 * @hide 491 */ 492 public static final int PRIVATE_FLAG_DEFAULT_TO_DEVICE_PROTECTED_STORAGE = 1 << 5; 493 494 /** 495 * When set, assume that all components under the given app are direct boot 496 * aware, unless otherwise specified. 497 * 498 * @hide 499 */ 500 public static final int PRIVATE_FLAG_DIRECT_BOOT_AWARE = 1 << 6; 501 502 /** 503 * Value for {@link #privateFlags}: {@code true} if the application is installed 504 * as instant app. 505 * 506 * @hide 507 */ 508 public static final int PRIVATE_FLAG_INSTANT = 1 << 7; 509 510 /** 511 * When set, at least one component inside this application is direct boot 512 * aware. 513 * 514 * @hide 515 */ 516 public static final int PRIVATE_FLAG_PARTIALLY_DIRECT_BOOT_AWARE = 1 << 8; 517 518 519 /** 520 * When set, signals that the application is required for the system user and should not be 521 * uninstalled. 522 * 523 * @hide 524 */ 525 public static final int PRIVATE_FLAG_REQUIRED_FOR_SYSTEM_USER = 1 << 9; 526 527 /** 528 * When set, the application explicitly requested that its activities be resizeable by default. 529 * @see android.R.styleable#AndroidManifestActivity_resizeableActivity 530 * 531 * @hide 532 */ 533 public static final int PRIVATE_FLAG_ACTIVITIES_RESIZE_MODE_RESIZEABLE = 1 << 10; 534 535 /** 536 * When set, the application explicitly requested that its activities *not* be resizeable by 537 * default. 538 * @see android.R.styleable#AndroidManifestActivity_resizeableActivity 539 * 540 * @hide 541 */ 542 public static final int PRIVATE_FLAG_ACTIVITIES_RESIZE_MODE_UNRESIZEABLE = 1 << 11; 543 544 /** 545 * The application isn't requesting explicitly requesting for its activities to be resizeable or 546 * non-resizeable by default. So, we are making it activities resizeable by default based on the 547 * target SDK version of the app. 548 * @see android.R.styleable#AndroidManifestActivity_resizeableActivity 549 * 550 * NOTE: This only affects apps with target SDK >= N where the resizeableActivity attribute was 551 * introduced. It shouldn't be confused with {@link ActivityInfo#RESIZE_MODE_FORCE_RESIZEABLE} 552 * where certain pre-N apps are forced to the resizeable. 553 * 554 * @hide 555 */ 556 public static final int PRIVATE_FLAG_ACTIVITIES_RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION = 557 1 << 12; 558 559 /** 560 * Value for {@link #privateFlags}: {@code true} means the OS should go ahead and 561 * run full-data backup operations for the app even when it is in a 562 * foreground-equivalent run state. Defaults to {@code false} if unspecified. 563 * @hide 564 */ 565 public static final int PRIVATE_FLAG_BACKUP_IN_FOREGROUND = 1 << 13; 566 567 /** 568 * Value for {@link #privateFlags}: {@code true} means this application 569 * contains a static shared library. Defaults to {@code false} if unspecified. 570 * @hide 571 */ 572 public static final int PRIVATE_FLAG_STATIC_SHARED_LIBRARY = 1 << 14; 573 574 /** 575 * Value for {@linl #privateFlags}: When set, the application will only have its splits loaded 576 * if they are required to load a component. Splits can be loaded on demand using the 577 * {@link Context#createContextForSplit(String)} API. 578 * @hide 579 */ 580 public static final int PRIVATE_FLAG_ISOLATED_SPLIT_LOADING = 1 << 15; 581 582 /** 583 * Private/hidden flags. See {@code PRIVATE_FLAG_...} constants. 584 * {@hide} 585 */ 586 public int privateFlags; 587 588 /** 589 * @hide 590 */ 591 public static final String METADATA_PRELOADED_FONTS = "preloaded_fonts"; 592 593 /** 594 * The required smallest screen width the application can run on. If 0, 595 * nothing has been specified. Comes from 596 * {@link android.R.styleable#AndroidManifestSupportsScreens_requiresSmallestWidthDp 597 * android:requiresSmallestWidthDp} attribute of the <supports-screens> tag. 598 */ 599 public int requiresSmallestWidthDp = 0; 600 601 /** 602 * The maximum smallest screen width the application is designed for. If 0, 603 * nothing has been specified. Comes from 604 * {@link android.R.styleable#AndroidManifestSupportsScreens_compatibleWidthLimitDp 605 * android:compatibleWidthLimitDp} attribute of the <supports-screens> tag. 606 */ 607 public int compatibleWidthLimitDp = 0; 608 609 /** 610 * The maximum smallest screen width the application will work on. If 0, 611 * nothing has been specified. Comes from 612 * {@link android.R.styleable#AndroidManifestSupportsScreens_largestWidthLimitDp 613 * android:largestWidthLimitDp} attribute of the <supports-screens> tag. 614 */ 615 public int largestWidthLimitDp = 0; 616 617 /** 618 * Value indicating the maximum aspect ratio the application supports. 619 * <p> 620 * 0 means unset. 621 * @See {@link android.R.attr#maxAspectRatio}. 622 * @hide 623 */ 624 public float maxAspectRatio; 625 626 /** @removed */ 627 @Deprecated 628 public String volumeUuid; 629 630 /** 631 * UUID of the storage volume on which this application is being hosted. For 632 * apps hosted on the default internal storage at 633 * {@link Environment#getDataDirectory()}, the UUID value is 634 * {@link StorageManager#UUID_DEFAULT}. 635 */ 636 public UUID storageUuid; 637 638 /** {@hide} */ 639 public String scanSourceDir; 640 /** {@hide} */ 641 public String scanPublicSourceDir; 642 643 /** 644 * Full path to the base APK for this application. 645 */ 646 public String sourceDir; 647 648 /** 649 * Full path to the publicly available parts of {@link #sourceDir}, 650 * including resources and manifest. This may be different from 651 * {@link #sourceDir} if an application is forward locked. 652 */ 653 public String publicSourceDir; 654 655 /** 656 * The names of all installed split APKs, ordered lexicographically. 657 */ 658 public String[] splitNames; 659 660 /** 661 * Full paths to zero or more split APKs, indexed by the same order as {@link #splitNames}. 662 */ 663 public String[] splitSourceDirs; 664 665 /** 666 * Full path to the publicly available parts of {@link #splitSourceDirs}, 667 * including resources and manifest. This may be different from 668 * {@link #splitSourceDirs} if an application is forward locked. 669 * 670 * @see #splitSourceDirs 671 */ 672 public String[] splitPublicSourceDirs; 673 674 /** 675 * Maps the dependencies between split APKs. All splits implicitly depend on the base APK. 676 * 677 * Available since platform version O. 678 * 679 * Only populated if the application opts in to isolated split loading via the 680 * {@link android.R.attr.isolatedSplits} attribute in the <manifest> tag of the app's 681 * AndroidManifest.xml. 682 * 683 * The keys and values are all indices into the {@link #splitNames}, {@link #splitSourceDirs}, 684 * and {@link #splitPublicSourceDirs} arrays. 685 * Each key represents a split and its value is an array of splits. The first element of this 686 * array is the parent split, and the rest are configuration splits. These configuration splits 687 * have no dependencies themselves. 688 * Cycles do not exist because they are illegal and screened for during installation. 689 * 690 * May be null if no splits are installed, or if no dependencies exist between them. 691 * @hide 692 */ 693 public SparseArray<int[]> splitDependencies; 694 695 /** 696 * Full paths to the locations of extra resource packages (runtime overlays) 697 * this application uses. This field is only used if there are extra resource 698 * packages, otherwise it is null. 699 * 700 * {@hide} 701 */ 702 public String[] resourceDirs; 703 704 /** 705 * String retrieved from the seinfo tag found in selinux policy. This value 706 * can be overridden with a value set through the mac_permissions.xml policy 707 * construct. This value is useful in setting an SELinux security context on 708 * the process as well as its data directory. The String default is being used 709 * here to represent a catchall label when no policy matches. 710 * 711 * {@hide} 712 */ 713 public String seInfo = "default"; 714 715 /** 716 * The seinfo tag generated per-user. This value may change based upon the 717 * user's configuration. For example, when an instant app is installed for 718 * a user. It is an error if this field is ever {@code null} when trying to 719 * start a new process. 720 * <p>NOTE: We need to separate this out because we modify per-user values 721 * multiple times. This needs to be refactored since we're performing more 722 * work than necessary and these values should only be set once. When that 723 * happens, we can merge the per-user value with the seInfo state above. 724 * 725 * {@hide} 726 */ 727 public String seInfoUser; 728 729 /** 730 * Paths to all shared libraries this application is linked against. This 731 * field is only set if the {@link PackageManager#GET_SHARED_LIBRARY_FILES 732 * PackageManager.GET_SHARED_LIBRARY_FILES} flag was used when retrieving 733 * the structure. 734 */ 735 public String[] sharedLibraryFiles; 736 737 /** 738 * Full path to the default directory assigned to the package for its 739 * persistent data. 740 */ 741 public String dataDir; 742 743 /** 744 * Full path to the device-protected directory assigned to the package for 745 * its persistent data. 746 * 747 * @see Context#createDeviceProtectedStorageContext() 748 */ 749 public String deviceProtectedDataDir; 750 751 /** 752 * Full path to the credential-protected directory assigned to the package 753 * for its persistent data. 754 * 755 * @hide 756 */ 757 @SystemApi 758 public String credentialProtectedDataDir; 759 760 /** 761 * Full path to the directory where native JNI libraries are stored. 762 */ 763 public String nativeLibraryDir; 764 765 /** 766 * Full path where unpacked native libraries for {@link #secondaryCpuAbi} 767 * are stored, if present. 768 * 769 * The main reason this exists is for bundled multi-arch apps, where 770 * it's not trivial to calculate the location of libs for the secondary abi 771 * given the location of the primary. 772 * 773 * TODO: Change the layout of bundled installs so that we can use 774 * nativeLibraryRootDir & nativeLibraryRootRequiresIsa there as well. 775 * (e.g {@code [ "/system/app-lib/Foo/arm", "/system/app-lib/Foo/arm64" ]} 776 * instead of {@code [ "/system/lib/Foo", "/system/lib64/Foo" ]}. 777 * 778 * @hide 779 */ 780 public String secondaryNativeLibraryDir; 781 782 /** 783 * The root path where unpacked native libraries are stored. 784 * <p> 785 * When {@link #nativeLibraryRootRequiresIsa} is set, the libraries are 786 * placed in ISA-specific subdirectories under this path, otherwise the 787 * libraries are placed directly at this path. 788 * 789 * @hide 790 */ 791 public String nativeLibraryRootDir; 792 793 /** 794 * Flag indicating that ISA must be appended to 795 * {@link #nativeLibraryRootDir} to be useful. 796 * 797 * @hide 798 */ 799 public boolean nativeLibraryRootRequiresIsa; 800 801 /** 802 * The primary ABI that this application requires, This is inferred from the ABIs 803 * of the native JNI libraries the application bundles. Will be {@code null} 804 * if this application does not require any particular ABI. 805 * 806 * If non-null, the application will always be launched with this ABI. 807 * 808 * {@hide} 809 */ 810 public String primaryCpuAbi; 811 812 /** 813 * The secondary ABI for this application. Might be non-null for multi-arch 814 * installs. The application itself never uses this ABI, but other applications that 815 * use its code might. 816 * 817 * {@hide} 818 */ 819 public String secondaryCpuAbi; 820 821 /** 822 * The kernel user-ID that has been assigned to this application; 823 * currently this is not a unique ID (multiple applications can have 824 * the same uid). 825 */ 826 public int uid; 827 828 /** 829 * The minimum SDK version this application can run on. It will not run 830 * on earlier versions. 831 */ 832 public int minSdkVersion; 833 834 /** 835 * The minimum SDK version this application targets. It may run on earlier 836 * versions, but it knows how to work with any new behavior added at this 837 * version. Will be {@link android.os.Build.VERSION_CODES#CUR_DEVELOPMENT} 838 * if this is a development build and the app is targeting that. You should 839 * compare that this number is >= the SDK version number at which your 840 * behavior was introduced. 841 */ 842 public int targetSdkVersion; 843 844 /** 845 * The app's declared version code. 846 * @hide 847 */ 848 public int versionCode; 849 850 /** 851 * When false, indicates that all components within this application are 852 * considered disabled, regardless of their individually set enabled status. 853 */ 854 public boolean enabled = true; 855 856 /** 857 * For convenient access to the current enabled setting of this app. 858 * @hide 859 */ 860 public int enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 861 862 /** 863 * For convenient access to package's install location. 864 * @hide 865 */ 866 public int installLocation = PackageInfo.INSTALL_LOCATION_UNSPECIFIED; 867 868 /** 869 * Resource file providing the application's Network Security Config. 870 * @hide 871 */ 872 public int networkSecurityConfigRes; 873 874 /** 875 * Version of the sandbox the application wants to run in. 876 * @hide 877 */ 878 public int targetSandboxVersion; 879 880 /** 881 * The category of this app. Categories are used to cluster multiple apps 882 * together into meaningful groups, such as when summarizing battery, 883 * network, or disk usage. Apps should only define this value when they fit 884 * well into one of the specific categories. 885 * <p> 886 * Set from the {@link android.R.attr#appCategory} attribute in the 887 * manifest. If the manifest doesn't define a category, this value may have 888 * been provided by the installer via 889 * {@link PackageManager#setApplicationCategoryHint(String, int)}. 890 */ 891 public @Category int category = CATEGORY_UNDEFINED; 892 893 /** {@hide} */ 894 @IntDef(prefix = { "CATEGORY_" }, value = { 895 CATEGORY_UNDEFINED, 896 CATEGORY_GAME, 897 CATEGORY_AUDIO, 898 CATEGORY_VIDEO, 899 CATEGORY_IMAGE, 900 CATEGORY_SOCIAL, 901 CATEGORY_NEWS, 902 CATEGORY_MAPS, 903 CATEGORY_PRODUCTIVITY 904 }) 905 @Retention(RetentionPolicy.SOURCE) 906 public @interface Category { 907 } 908 909 /** 910 * Value when category is undefined. 911 * 912 * @see #category 913 */ 914 public static final int CATEGORY_UNDEFINED = -1; 915 916 /** 917 * Category for apps which are primarily games. 918 * 919 * @see #category 920 */ 921 public static final int CATEGORY_GAME = 0; 922 923 /** 924 * Category for apps which primarily work with audio or music, such as music 925 * players. 926 * 927 * @see #category 928 */ 929 public static final int CATEGORY_AUDIO = 1; 930 931 /** 932 * Category for apps which primarily work with video or movies, such as 933 * streaming video apps. 934 * 935 * @see #category 936 */ 937 public static final int CATEGORY_VIDEO = 2; 938 939 /** 940 * Category for apps which primarily work with images or photos, such as 941 * camera or gallery apps. 942 * 943 * @see #category 944 */ 945 public static final int CATEGORY_IMAGE = 3; 946 947 /** 948 * Category for apps which are primarily social apps, such as messaging, 949 * communication, email, or social network apps. 950 * 951 * @see #category 952 */ 953 public static final int CATEGORY_SOCIAL = 4; 954 955 /** 956 * Category for apps which are primarily news apps, such as newspapers, 957 * magazines, or sports apps. 958 * 959 * @see #category 960 */ 961 public static final int CATEGORY_NEWS = 5; 962 963 /** 964 * Category for apps which are primarily maps apps, such as navigation apps. 965 * 966 * @see #category 967 */ 968 public static final int CATEGORY_MAPS = 6; 969 970 /** 971 * Category for apps which are primarily productivity apps, such as cloud 972 * storage or workplace apps. 973 * 974 * @see #category 975 */ 976 public static final int CATEGORY_PRODUCTIVITY = 7; 977 978 /** 979 * Return a concise, localized title for the given 980 * {@link ApplicationInfo#category} value, or {@code null} for unknown 981 * values such as {@link #CATEGORY_UNDEFINED}. 982 * 983 * @see #category 984 */ 985 public static CharSequence getCategoryTitle(Context context, @Category int category) { 986 switch (category) { 987 case ApplicationInfo.CATEGORY_GAME: 988 return context.getText(com.android.internal.R.string.app_category_game); 989 case ApplicationInfo.CATEGORY_AUDIO: 990 return context.getText(com.android.internal.R.string.app_category_audio); 991 case ApplicationInfo.CATEGORY_VIDEO: 992 return context.getText(com.android.internal.R.string.app_category_video); 993 case ApplicationInfo.CATEGORY_IMAGE: 994 return context.getText(com.android.internal.R.string.app_category_image); 995 case ApplicationInfo.CATEGORY_SOCIAL: 996 return context.getText(com.android.internal.R.string.app_category_social); 997 case ApplicationInfo.CATEGORY_NEWS: 998 return context.getText(com.android.internal.R.string.app_category_news); 999 case ApplicationInfo.CATEGORY_MAPS: 1000 return context.getText(com.android.internal.R.string.app_category_maps); 1001 case ApplicationInfo.CATEGORY_PRODUCTIVITY: 1002 return context.getText(com.android.internal.R.string.app_category_productivity); 1003 default: 1004 return null; 1005 } 1006 } 1007 1008 public void dump(Printer pw, String prefix) { 1009 dump(pw, prefix, DUMP_FLAG_ALL); 1010 } 1011 1012 /** @hide */ 1013 public void dump(Printer pw, String prefix, int flags) { 1014 super.dumpFront(pw, prefix); 1015 if ((flags&DUMP_FLAG_DETAILS) != 0 && className != null) { 1016 pw.println(prefix + "className=" + className); 1017 } 1018 if (permission != null) { 1019 pw.println(prefix + "permission=" + permission); 1020 } 1021 pw.println(prefix + "processName=" + processName); 1022 if ((flags&DUMP_FLAG_DETAILS) != 0) { 1023 pw.println(prefix + "taskAffinity=" + taskAffinity); 1024 } 1025 pw.println(prefix + "uid=" + uid + " flags=0x" + Integer.toHexString(flags) 1026 + " privateFlags=0x" + Integer.toHexString(privateFlags) 1027 + " theme=0x" + Integer.toHexString(theme)); 1028 if ((flags&DUMP_FLAG_DETAILS) != 0) { 1029 pw.println(prefix + "requiresSmallestWidthDp=" + requiresSmallestWidthDp 1030 + " compatibleWidthLimitDp=" + compatibleWidthLimitDp 1031 + " largestWidthLimitDp=" + largestWidthLimitDp); 1032 } 1033 pw.println(prefix + "sourceDir=" + sourceDir); 1034 if (!Objects.equals(sourceDir, publicSourceDir)) { 1035 pw.println(prefix + "publicSourceDir=" + publicSourceDir); 1036 } 1037 if (!ArrayUtils.isEmpty(splitSourceDirs)) { 1038 pw.println(prefix + "splitSourceDirs=" + Arrays.toString(splitSourceDirs)); 1039 } 1040 if (!ArrayUtils.isEmpty(splitPublicSourceDirs) 1041 && !Arrays.equals(splitSourceDirs, splitPublicSourceDirs)) { 1042 pw.println(prefix + "splitPublicSourceDirs=" + Arrays.toString(splitPublicSourceDirs)); 1043 } 1044 if (resourceDirs != null) { 1045 pw.println(prefix + "resourceDirs=" + Arrays.toString(resourceDirs)); 1046 } 1047 if ((flags&DUMP_FLAG_DETAILS) != 0 && seInfo != null) { 1048 pw.println(prefix + "seinfo=" + seInfo); 1049 pw.println(prefix + "seinfoUser=" + seInfoUser); 1050 } 1051 pw.println(prefix + "dataDir=" + dataDir); 1052 if ((flags&DUMP_FLAG_DETAILS) != 0) { 1053 pw.println(prefix + "deviceProtectedDataDir=" + deviceProtectedDataDir); 1054 pw.println(prefix + "credentialProtectedDataDir=" + credentialProtectedDataDir); 1055 if (sharedLibraryFiles != null) { 1056 pw.println(prefix + "sharedLibraryFiles=" + Arrays.toString(sharedLibraryFiles)); 1057 } 1058 } 1059 pw.println(prefix + "enabled=" + enabled 1060 + " minSdkVersion=" + minSdkVersion 1061 + " targetSdkVersion=" + targetSdkVersion 1062 + " versionCode=" + versionCode 1063 + " targetSandboxVersion=" + targetSandboxVersion); 1064 if ((flags&DUMP_FLAG_DETAILS) != 0) { 1065 if (manageSpaceActivityName != null) { 1066 pw.println(prefix + "manageSpaceActivityName=" + manageSpaceActivityName); 1067 } 1068 if (descriptionRes != 0) { 1069 pw.println(prefix + "description=0x" + Integer.toHexString(descriptionRes)); 1070 } 1071 if (uiOptions != 0) { 1072 pw.println(prefix + "uiOptions=0x" + Integer.toHexString(uiOptions)); 1073 } 1074 pw.println(prefix + "supportsRtl=" + (hasRtlSupport() ? "true" : "false")); 1075 if (fullBackupContent > 0) { 1076 pw.println(prefix + "fullBackupContent=@xml/" + fullBackupContent); 1077 } else { 1078 pw.println(prefix + "fullBackupContent=" 1079 + (fullBackupContent < 0 ? "false" : "true")); 1080 } 1081 if (networkSecurityConfigRes != 0) { 1082 pw.println(prefix + "networkSecurityConfigRes=0x" 1083 + Integer.toHexString(networkSecurityConfigRes)); 1084 } 1085 if (category != CATEGORY_UNDEFINED) { 1086 pw.println(prefix + "category=" + category); 1087 } 1088 } 1089 super.dumpBack(pw, prefix); 1090 } 1091 1092 /** 1093 * @return true if "supportsRtl" has been set to true in the AndroidManifest 1094 * @hide 1095 */ 1096 public boolean hasRtlSupport() { 1097 return (flags & FLAG_SUPPORTS_RTL) == FLAG_SUPPORTS_RTL; 1098 } 1099 1100 /** {@hide} */ 1101 public boolean hasCode() { 1102 return (flags & FLAG_HAS_CODE) != 0; 1103 } 1104 1105 public static class DisplayNameComparator 1106 implements Comparator<ApplicationInfo> { 1107 public DisplayNameComparator(PackageManager pm) { 1108 mPM = pm; 1109 } 1110 1111 public final int compare(ApplicationInfo aa, ApplicationInfo ab) { 1112 CharSequence sa = mPM.getApplicationLabel(aa); 1113 if (sa == null) { 1114 sa = aa.packageName; 1115 } 1116 CharSequence sb = mPM.getApplicationLabel(ab); 1117 if (sb == null) { 1118 sb = ab.packageName; 1119 } 1120 1121 return sCollator.compare(sa.toString(), sb.toString()); 1122 } 1123 1124 private final Collator sCollator = Collator.getInstance(); 1125 private PackageManager mPM; 1126 } 1127 1128 public ApplicationInfo() { 1129 } 1130 1131 public ApplicationInfo(ApplicationInfo orig) { 1132 super(orig); 1133 taskAffinity = orig.taskAffinity; 1134 permission = orig.permission; 1135 processName = orig.processName; 1136 className = orig.className; 1137 theme = orig.theme; 1138 flags = orig.flags; 1139 privateFlags = orig.privateFlags; 1140 requiresSmallestWidthDp = orig.requiresSmallestWidthDp; 1141 compatibleWidthLimitDp = orig.compatibleWidthLimitDp; 1142 largestWidthLimitDp = orig.largestWidthLimitDp; 1143 volumeUuid = orig.volumeUuid; 1144 storageUuid = orig.storageUuid; 1145 scanSourceDir = orig.scanSourceDir; 1146 scanPublicSourceDir = orig.scanPublicSourceDir; 1147 sourceDir = orig.sourceDir; 1148 publicSourceDir = orig.publicSourceDir; 1149 splitNames = orig.splitNames; 1150 splitSourceDirs = orig.splitSourceDirs; 1151 splitPublicSourceDirs = orig.splitPublicSourceDirs; 1152 splitDependencies = orig.splitDependencies; 1153 nativeLibraryDir = orig.nativeLibraryDir; 1154 secondaryNativeLibraryDir = orig.secondaryNativeLibraryDir; 1155 nativeLibraryRootDir = orig.nativeLibraryRootDir; 1156 nativeLibraryRootRequiresIsa = orig.nativeLibraryRootRequiresIsa; 1157 primaryCpuAbi = orig.primaryCpuAbi; 1158 secondaryCpuAbi = orig.secondaryCpuAbi; 1159 resourceDirs = orig.resourceDirs; 1160 seInfo = orig.seInfo; 1161 seInfoUser = orig.seInfoUser; 1162 sharedLibraryFiles = orig.sharedLibraryFiles; 1163 dataDir = orig.dataDir; 1164 deviceProtectedDataDir = orig.deviceProtectedDataDir; 1165 credentialProtectedDataDir = orig.credentialProtectedDataDir; 1166 uid = orig.uid; 1167 minSdkVersion = orig.minSdkVersion; 1168 targetSdkVersion = orig.targetSdkVersion; 1169 versionCode = orig.versionCode; 1170 enabled = orig.enabled; 1171 enabledSetting = orig.enabledSetting; 1172 installLocation = orig.installLocation; 1173 manageSpaceActivityName = orig.manageSpaceActivityName; 1174 descriptionRes = orig.descriptionRes; 1175 uiOptions = orig.uiOptions; 1176 backupAgentName = orig.backupAgentName; 1177 fullBackupContent = orig.fullBackupContent; 1178 networkSecurityConfigRes = orig.networkSecurityConfigRes; 1179 category = orig.category; 1180 targetSandboxVersion = orig.targetSandboxVersion; 1181 } 1182 1183 public String toString() { 1184 return "ApplicationInfo{" 1185 + Integer.toHexString(System.identityHashCode(this)) 1186 + " " + packageName + "}"; 1187 } 1188 1189 public int describeContents() { 1190 return 0; 1191 } 1192 1193 @SuppressWarnings("unchecked") 1194 public void writeToParcel(Parcel dest, int parcelableFlags) { 1195 super.writeToParcel(dest, parcelableFlags); 1196 dest.writeString(taskAffinity); 1197 dest.writeString(permission); 1198 dest.writeString(processName); 1199 dest.writeString(className); 1200 dest.writeInt(theme); 1201 dest.writeInt(flags); 1202 dest.writeInt(privateFlags); 1203 dest.writeInt(requiresSmallestWidthDp); 1204 dest.writeInt(compatibleWidthLimitDp); 1205 dest.writeInt(largestWidthLimitDp); 1206 if (storageUuid != null) { 1207 dest.writeInt(1); 1208 dest.writeLong(storageUuid.getMostSignificantBits()); 1209 dest.writeLong(storageUuid.getLeastSignificantBits()); 1210 } else { 1211 dest.writeInt(0); 1212 } 1213 dest.writeString(scanSourceDir); 1214 dest.writeString(scanPublicSourceDir); 1215 dest.writeString(sourceDir); 1216 dest.writeString(publicSourceDir); 1217 dest.writeStringArray(splitNames); 1218 dest.writeStringArray(splitSourceDirs); 1219 dest.writeStringArray(splitPublicSourceDirs); 1220 dest.writeSparseArray((SparseArray) splitDependencies); 1221 dest.writeString(nativeLibraryDir); 1222 dest.writeString(secondaryNativeLibraryDir); 1223 dest.writeString(nativeLibraryRootDir); 1224 dest.writeInt(nativeLibraryRootRequiresIsa ? 1 : 0); 1225 dest.writeString(primaryCpuAbi); 1226 dest.writeString(secondaryCpuAbi); 1227 dest.writeStringArray(resourceDirs); 1228 dest.writeString(seInfo); 1229 dest.writeString(seInfoUser); 1230 dest.writeStringArray(sharedLibraryFiles); 1231 dest.writeString(dataDir); 1232 dest.writeString(deviceProtectedDataDir); 1233 dest.writeString(credentialProtectedDataDir); 1234 dest.writeInt(uid); 1235 dest.writeInt(minSdkVersion); 1236 dest.writeInt(targetSdkVersion); 1237 dest.writeInt(versionCode); 1238 dest.writeInt(enabled ? 1 : 0); 1239 dest.writeInt(enabledSetting); 1240 dest.writeInt(installLocation); 1241 dest.writeString(manageSpaceActivityName); 1242 dest.writeString(backupAgentName); 1243 dest.writeInt(descriptionRes); 1244 dest.writeInt(uiOptions); 1245 dest.writeInt(fullBackupContent); 1246 dest.writeInt(networkSecurityConfigRes); 1247 dest.writeInt(category); 1248 dest.writeInt(targetSandboxVersion); 1249 } 1250 1251 public static final Parcelable.Creator<ApplicationInfo> CREATOR 1252 = new Parcelable.Creator<ApplicationInfo>() { 1253 public ApplicationInfo createFromParcel(Parcel source) { 1254 return new ApplicationInfo(source); 1255 } 1256 public ApplicationInfo[] newArray(int size) { 1257 return new ApplicationInfo[size]; 1258 } 1259 }; 1260 1261 @SuppressWarnings("unchecked") 1262 private ApplicationInfo(Parcel source) { 1263 super(source); 1264 taskAffinity = source.readString(); 1265 permission = source.readString(); 1266 processName = source.readString(); 1267 className = source.readString(); 1268 theme = source.readInt(); 1269 flags = source.readInt(); 1270 privateFlags = source.readInt(); 1271 requiresSmallestWidthDp = source.readInt(); 1272 compatibleWidthLimitDp = source.readInt(); 1273 largestWidthLimitDp = source.readInt(); 1274 if (source.readInt() != 0) { 1275 storageUuid = new UUID(source.readLong(), source.readLong()); 1276 volumeUuid = StorageManager.convert(storageUuid); 1277 } 1278 scanSourceDir = source.readString(); 1279 scanPublicSourceDir = source.readString(); 1280 sourceDir = source.readString(); 1281 publicSourceDir = source.readString(); 1282 splitNames = source.readStringArray(); 1283 splitSourceDirs = source.readStringArray(); 1284 splitPublicSourceDirs = source.readStringArray(); 1285 splitDependencies = source.readSparseArray(null); 1286 nativeLibraryDir = source.readString(); 1287 secondaryNativeLibraryDir = source.readString(); 1288 nativeLibraryRootDir = source.readString(); 1289 nativeLibraryRootRequiresIsa = source.readInt() != 0; 1290 primaryCpuAbi = source.readString(); 1291 secondaryCpuAbi = source.readString(); 1292 resourceDirs = source.readStringArray(); 1293 seInfo = source.readString(); 1294 seInfoUser = source.readString(); 1295 sharedLibraryFiles = source.readStringArray(); 1296 dataDir = source.readString(); 1297 deviceProtectedDataDir = source.readString(); 1298 credentialProtectedDataDir = source.readString(); 1299 uid = source.readInt(); 1300 minSdkVersion = source.readInt(); 1301 targetSdkVersion = source.readInt(); 1302 versionCode = source.readInt(); 1303 enabled = source.readInt() != 0; 1304 enabledSetting = source.readInt(); 1305 installLocation = source.readInt(); 1306 manageSpaceActivityName = source.readString(); 1307 backupAgentName = source.readString(); 1308 descriptionRes = source.readInt(); 1309 uiOptions = source.readInt(); 1310 fullBackupContent = source.readInt(); 1311 networkSecurityConfigRes = source.readInt(); 1312 category = source.readInt(); 1313 targetSandboxVersion = source.readInt(); 1314 } 1315 1316 /** 1317 * Retrieve the textual description of the application. This 1318 * will call back on the given PackageManager to load the description from 1319 * the application. 1320 * 1321 * @param pm A PackageManager from which the label can be loaded; usually 1322 * the PackageManager from which you originally retrieved this item. 1323 * 1324 * @return Returns a CharSequence containing the application's description. 1325 * If there is no description, null is returned. 1326 */ 1327 public CharSequence loadDescription(PackageManager pm) { 1328 if (descriptionRes != 0) { 1329 CharSequence label = pm.getText(packageName, descriptionRes, this); 1330 if (label != null) { 1331 return label; 1332 } 1333 } 1334 return null; 1335 } 1336 1337 /** 1338 * Disable compatibility mode 1339 * 1340 * @hide 1341 */ 1342 public void disableCompatibilityMode() { 1343 flags |= (FLAG_SUPPORTS_LARGE_SCREENS | FLAG_SUPPORTS_NORMAL_SCREENS | 1344 FLAG_SUPPORTS_SMALL_SCREENS | FLAG_RESIZEABLE_FOR_SCREENS | 1345 FLAG_SUPPORTS_SCREEN_DENSITIES | FLAG_SUPPORTS_XLARGE_SCREENS); 1346 } 1347 1348 /** 1349 * Is using compatibility mode for non densty aware legacy applications. 1350 * 1351 * @hide 1352 */ 1353 public boolean usesCompatibilityMode() { 1354 return targetSdkVersion < DONUT || 1355 (flags & (FLAG_SUPPORTS_LARGE_SCREENS | FLAG_SUPPORTS_NORMAL_SCREENS | 1356 FLAG_SUPPORTS_SMALL_SCREENS | FLAG_RESIZEABLE_FOR_SCREENS | 1357 FLAG_SUPPORTS_SCREEN_DENSITIES | FLAG_SUPPORTS_XLARGE_SCREENS)) == 0; 1358 } 1359 1360 /** {@hide} */ 1361 public void initForUser(int userId) { 1362 uid = UserHandle.getUid(userId, UserHandle.getAppId(uid)); 1363 1364 if ("android".equals(packageName)) { 1365 dataDir = Environment.getDataSystemDirectory().getAbsolutePath(); 1366 return; 1367 } 1368 1369 deviceProtectedDataDir = Environment 1370 .getDataUserDePackageDirectory(volumeUuid, userId, packageName) 1371 .getAbsolutePath(); 1372 credentialProtectedDataDir = Environment 1373 .getDataUserCePackageDirectory(volumeUuid, userId, packageName) 1374 .getAbsolutePath(); 1375 1376 if ((privateFlags & PRIVATE_FLAG_DEFAULT_TO_DEVICE_PROTECTED_STORAGE) != 0 1377 && PackageManager.APPLY_DEFAULT_TO_DEVICE_PROTECTED_STORAGE) { 1378 dataDir = deviceProtectedDataDir; 1379 } else { 1380 dataDir = credentialProtectedDataDir; 1381 } 1382 } 1383 1384 /** 1385 * @hide 1386 */ 1387 @Override 1388 public Drawable loadDefaultIcon(PackageManager pm) { 1389 if ((flags & FLAG_EXTERNAL_STORAGE) != 0 1390 && isPackageUnavailable(pm)) { 1391 return Resources.getSystem().getDrawable( 1392 com.android.internal.R.drawable.sym_app_on_sd_unavailable_icon); 1393 } 1394 return pm.getDefaultActivityIcon(); 1395 } 1396 1397 private boolean isPackageUnavailable(PackageManager pm) { 1398 try { 1399 return pm.getPackageInfo(packageName, 0) == null; 1400 } catch (NameNotFoundException ex) { 1401 return true; 1402 } 1403 } 1404 1405 /** 1406 * @hide 1407 */ 1408 public boolean isForwardLocked() { 1409 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0; 1410 } 1411 1412 /** 1413 * @hide 1414 */ 1415 @TestApi 1416 public boolean isSystemApp() { 1417 return (flags & ApplicationInfo.FLAG_SYSTEM) != 0; 1418 } 1419 1420 /** 1421 * @hide 1422 */ 1423 @TestApi 1424 public boolean isPrivilegedApp() { 1425 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0; 1426 } 1427 1428 /** 1429 * @hide 1430 */ 1431 public boolean isUpdatedSystemApp() { 1432 return (flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0; 1433 } 1434 1435 /** @hide */ 1436 public boolean isInternal() { 1437 return (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 0; 1438 } 1439 1440 /** @hide */ 1441 public boolean isExternalAsec() { 1442 return TextUtils.isEmpty(volumeUuid) 1443 && (flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0; 1444 } 1445 1446 /** @hide */ 1447 public boolean isDefaultToDeviceProtectedStorage() { 1448 return (privateFlags 1449 & ApplicationInfo.PRIVATE_FLAG_DEFAULT_TO_DEVICE_PROTECTED_STORAGE) != 0; 1450 } 1451 1452 /** @hide */ 1453 public boolean isDirectBootAware() { 1454 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_DIRECT_BOOT_AWARE) != 0; 1455 } 1456 1457 /** @hide */ 1458 public boolean isPartiallyDirectBootAware() { 1459 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_PARTIALLY_DIRECT_BOOT_AWARE) != 0; 1460 } 1461 1462 /** 1463 * @hide 1464 */ 1465 public boolean isInstantApp() { 1466 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_INSTANT) != 0; 1467 } 1468 1469 /** 1470 * @hide 1471 */ 1472 public boolean isRequiredForSystemUser() { 1473 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_REQUIRED_FOR_SYSTEM_USER) != 0; 1474 } 1475 1476 /** 1477 * Returns true if the app has declared in its manifest that it wants its split APKs to be 1478 * loaded into isolated Contexts, with their own ClassLoaders and Resources objects. 1479 * @hide 1480 */ 1481 public boolean requestsIsolatedSplitLoading() { 1482 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_ISOLATED_SPLIT_LOADING) != 0; 1483 } 1484 1485 /** 1486 * @hide 1487 */ 1488 public boolean isStaticSharedLibrary() { 1489 return (privateFlags & ApplicationInfo.PRIVATE_FLAG_STATIC_SHARED_LIBRARY) != 0; 1490 } 1491 1492 /** 1493 * @hide 1494 */ 1495 @Override protected ApplicationInfo getApplicationInfo() { 1496 return this; 1497 } 1498 1499 /** {@hide} */ public void setCodePath(String codePath) { scanSourceDir = codePath; } 1500 /** {@hide} */ public void setBaseCodePath(String baseCodePath) { sourceDir = baseCodePath; } 1501 /** {@hide} */ public void setSplitCodePaths(String[] splitCodePaths) { splitSourceDirs = splitCodePaths; } 1502 /** {@hide} */ public void setResourcePath(String resourcePath) { scanPublicSourceDir = resourcePath; } 1503 /** {@hide} */ public void setBaseResourcePath(String baseResourcePath) { publicSourceDir = baseResourcePath; } 1504 /** {@hide} */ public void setSplitResourcePaths(String[] splitResourcePaths) { splitPublicSourceDirs = splitResourcePaths; } 1505 1506 /** {@hide} */ public String getCodePath() { return scanSourceDir; } 1507 /** {@hide} */ public String getBaseCodePath() { return sourceDir; } 1508 /** {@hide} */ public String[] getSplitCodePaths() { return splitSourceDirs; } 1509 /** {@hide} */ public String getResourcePath() { return scanPublicSourceDir; } 1510 /** {@hide} */ public String getBaseResourcePath() { return publicSourceDir; } 1511 /** {@hide} */ public String[] getSplitResourcePaths() { return splitPublicSourceDirs; } 1512 } 1513
