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