Home | History | Annotate | Download | only in pm
      1 /*
      2  * Copyright (C) 2006 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 android.Manifest;
     20 import android.annotation.CheckResult;
     21 import android.annotation.DrawableRes;
     22 import android.annotation.IntDef;
     23 import android.annotation.IntRange;
     24 import android.annotation.NonNull;
     25 import android.annotation.Nullable;
     26 import android.annotation.RequiresPermission;
     27 import android.annotation.SdkConstant;
     28 import android.annotation.SdkConstant.SdkConstantType;
     29 import android.annotation.StringRes;
     30 import android.annotation.SystemApi;
     31 import android.annotation.TestApi;
     32 import android.annotation.UserIdInt;
     33 import android.annotation.XmlRes;
     34 import android.app.PackageDeleteObserver;
     35 import android.app.PackageInstallObserver;
     36 import android.app.admin.DevicePolicyManager;
     37 import android.app.usage.StorageStatsManager;
     38 import android.content.ComponentName;
     39 import android.content.Context;
     40 import android.content.Intent;
     41 import android.content.IntentFilter;
     42 import android.content.IntentSender;
     43 import android.content.pm.PackageParser.PackageParserException;
     44 import android.content.res.Resources;
     45 import android.content.res.XmlResourceParser;
     46 import android.graphics.Rect;
     47 import android.graphics.drawable.Drawable;
     48 import android.net.Uri;
     49 import android.os.Build;
     50 import android.os.Bundle;
     51 import android.os.Handler;
     52 import android.os.RemoteException;
     53 import android.os.UserHandle;
     54 import android.os.UserManager;
     55 import android.os.storage.StorageManager;
     56 import android.os.storage.VolumeInfo;
     57 import android.provider.Settings;
     58 import android.util.AndroidException;
     59 import android.util.Log;
     60 
     61 import com.android.internal.util.ArrayUtils;
     62 
     63 import dalvik.system.VMRuntime;
     64 
     65 import java.io.File;
     66 import java.lang.annotation.Retention;
     67 import java.lang.annotation.RetentionPolicy;
     68 import java.util.List;
     69 
     70 /**
     71  * Class for retrieving various kinds of information related to the application
     72  * packages that are currently installed on the device.
     73  *
     74  * You can find this class through {@link Context#getPackageManager}.
     75  */
     76 public abstract class PackageManager {
     77     private static final String TAG = "PackageManager";
     78 
     79     /** {@hide} */
     80     public static final boolean APPLY_DEFAULT_TO_DEVICE_PROTECTED_STORAGE = true;
     81 
     82     /**
     83      * This exception is thrown when a given package, application, or component
     84      * name cannot be found.
     85      */
     86     public static class NameNotFoundException extends AndroidException {
     87         public NameNotFoundException() {
     88         }
     89 
     90         public NameNotFoundException(String name) {
     91             super(name);
     92         }
     93     }
     94 
     95     /**
     96      * Listener for changes in permissions granted to a UID.
     97      *
     98      * @hide
     99      */
    100     @SystemApi
    101     public interface OnPermissionsChangedListener {
    102 
    103         /**
    104          * Called when the permissions for a UID change.
    105          * @param uid The UID with a change.
    106          */
    107         public void onPermissionsChanged(int uid);
    108     }
    109 
    110     /**
    111      * As a guiding principle:
    112      * <p>
    113      * {@code GET_} flags are used to request additional data that may have been
    114      * elided to save wire space.
    115      * <p>
    116      * {@code MATCH_} flags are used to include components or packages that
    117      * would have otherwise been omitted from a result set by current system
    118      * state.
    119      */
    120 
    121     /** @hide */
    122     @IntDef(flag = true, prefix = { "GET_", "MATCH_" }, value = {
    123             GET_ACTIVITIES,
    124             GET_CONFIGURATIONS,
    125             GET_GIDS,
    126             GET_INSTRUMENTATION,
    127             GET_INTENT_FILTERS,
    128             GET_META_DATA,
    129             GET_PERMISSIONS,
    130             GET_PROVIDERS,
    131             GET_RECEIVERS,
    132             GET_SERVICES,
    133             GET_SHARED_LIBRARY_FILES,
    134             GET_SIGNATURES,
    135             GET_URI_PERMISSION_PATTERNS,
    136             MATCH_UNINSTALLED_PACKAGES,
    137             MATCH_DISABLED_COMPONENTS,
    138             MATCH_DISABLED_UNTIL_USED_COMPONENTS,
    139             MATCH_SYSTEM_ONLY,
    140             MATCH_FACTORY_ONLY,
    141             MATCH_DEBUG_TRIAGED_MISSING,
    142             MATCH_INSTANT,
    143             GET_DISABLED_COMPONENTS,
    144             GET_DISABLED_UNTIL_USED_COMPONENTS,
    145             GET_UNINSTALLED_PACKAGES,
    146     })
    147     @Retention(RetentionPolicy.SOURCE)
    148     public @interface PackageInfoFlags {}
    149 
    150     /** @hide */
    151     @IntDef(flag = true, prefix = { "GET_", "MATCH_" }, value = {
    152             GET_META_DATA,
    153             GET_SHARED_LIBRARY_FILES,
    154             MATCH_UNINSTALLED_PACKAGES,
    155             MATCH_SYSTEM_ONLY,
    156             MATCH_DEBUG_TRIAGED_MISSING,
    157             MATCH_DISABLED_COMPONENTS,
    158             MATCH_DISABLED_UNTIL_USED_COMPONENTS,
    159             MATCH_INSTANT,
    160             MATCH_STATIC_SHARED_LIBRARIES,
    161             GET_DISABLED_UNTIL_USED_COMPONENTS,
    162             GET_UNINSTALLED_PACKAGES,
    163     })
    164     @Retention(RetentionPolicy.SOURCE)
    165     public @interface ApplicationInfoFlags {}
    166 
    167     /** @hide */
    168     @IntDef(flag = true, prefix = { "GET_", "MATCH_" }, value = {
    169             GET_META_DATA,
    170             GET_SHARED_LIBRARY_FILES,
    171             MATCH_ALL,
    172             MATCH_DEBUG_TRIAGED_MISSING,
    173             MATCH_DEFAULT_ONLY,
    174             MATCH_DISABLED_COMPONENTS,
    175             MATCH_DISABLED_UNTIL_USED_COMPONENTS,
    176             MATCH_DIRECT_BOOT_AWARE,
    177             MATCH_DIRECT_BOOT_UNAWARE,
    178             MATCH_SYSTEM_ONLY,
    179             MATCH_UNINSTALLED_PACKAGES,
    180             MATCH_INSTANT,
    181             MATCH_STATIC_SHARED_LIBRARIES,
    182             GET_DISABLED_COMPONENTS,
    183             GET_DISABLED_UNTIL_USED_COMPONENTS,
    184             GET_UNINSTALLED_PACKAGES,
    185     })
    186     @Retention(RetentionPolicy.SOURCE)
    187     public @interface ComponentInfoFlags {}
    188 
    189     /** @hide */
    190     @IntDef(flag = true, prefix = { "GET_", "MATCH_" }, value = {
    191             GET_META_DATA,
    192             GET_RESOLVED_FILTER,
    193             GET_SHARED_LIBRARY_FILES,
    194             MATCH_ALL,
    195             MATCH_DEBUG_TRIAGED_MISSING,
    196             MATCH_DISABLED_COMPONENTS,
    197             MATCH_DISABLED_UNTIL_USED_COMPONENTS,
    198             MATCH_DEFAULT_ONLY,
    199             MATCH_DIRECT_BOOT_AWARE,
    200             MATCH_DIRECT_BOOT_UNAWARE,
    201             MATCH_SYSTEM_ONLY,
    202             MATCH_UNINSTALLED_PACKAGES,
    203             MATCH_INSTANT,
    204             GET_DISABLED_COMPONENTS,
    205             GET_DISABLED_UNTIL_USED_COMPONENTS,
    206             GET_UNINSTALLED_PACKAGES,
    207     })
    208     @Retention(RetentionPolicy.SOURCE)
    209     public @interface ResolveInfoFlags {}
    210 
    211     /** @hide */
    212     @IntDef(flag = true, prefix = { "GET_", "MATCH_" }, value = {
    213             GET_META_DATA,
    214     })
    215     @Retention(RetentionPolicy.SOURCE)
    216     public @interface PermissionInfoFlags {}
    217 
    218     /** @hide */
    219     @IntDef(flag = true, prefix = { "GET_", "MATCH_" }, value = {
    220             GET_META_DATA,
    221     })
    222     @Retention(RetentionPolicy.SOURCE)
    223     public @interface PermissionGroupInfoFlags {}
    224 
    225     /** @hide */
    226     @IntDef(flag = true, prefix = { "GET_", "MATCH_" }, value = {
    227             GET_META_DATA,
    228     })
    229     @Retention(RetentionPolicy.SOURCE)
    230     public @interface InstrumentationInfoFlags {}
    231 
    232     /**
    233      * {@link PackageInfo} flag: return information about
    234      * activities in the package in {@link PackageInfo#activities}.
    235      */
    236     public static final int GET_ACTIVITIES              = 0x00000001;
    237 
    238     /**
    239      * {@link PackageInfo} flag: return information about
    240      * intent receivers in the package in
    241      * {@link PackageInfo#receivers}.
    242      */
    243     public static final int GET_RECEIVERS               = 0x00000002;
    244 
    245     /**
    246      * {@link PackageInfo} flag: return information about
    247      * services in the package in {@link PackageInfo#services}.
    248      */
    249     public static final int GET_SERVICES                = 0x00000004;
    250 
    251     /**
    252      * {@link PackageInfo} flag: return information about
    253      * content providers in the package in
    254      * {@link PackageInfo#providers}.
    255      */
    256     public static final int GET_PROVIDERS               = 0x00000008;
    257 
    258     /**
    259      * {@link PackageInfo} flag: return information about
    260      * instrumentation in the package in
    261      * {@link PackageInfo#instrumentation}.
    262      */
    263     public static final int GET_INSTRUMENTATION         = 0x00000010;
    264 
    265     /**
    266      * {@link PackageInfo} flag: return information about the
    267      * intent filters supported by the activity.
    268      */
    269     public static final int GET_INTENT_FILTERS          = 0x00000020;
    270 
    271     /**
    272      * {@link PackageInfo} flag: return information about the
    273      * signatures included in the package.
    274      */
    275     public static final int GET_SIGNATURES          = 0x00000040;
    276 
    277     /**
    278      * {@link ResolveInfo} flag: return the IntentFilter that
    279      * was matched for a particular ResolveInfo in
    280      * {@link ResolveInfo#filter}.
    281      */
    282     public static final int GET_RESOLVED_FILTER         = 0x00000040;
    283 
    284     /**
    285      * {@link ComponentInfo} flag: return the {@link ComponentInfo#metaData}
    286      * data {@link android.os.Bundle}s that are associated with a component.
    287      * This applies for any API returning a ComponentInfo subclass.
    288      */
    289     public static final int GET_META_DATA               = 0x00000080;
    290 
    291     /**
    292      * {@link PackageInfo} flag: return the
    293      * {@link PackageInfo#gids group ids} that are associated with an
    294      * application.
    295      * This applies for any API returning a PackageInfo class, either
    296      * directly or nested inside of another.
    297      */
    298     public static final int GET_GIDS                    = 0x00000100;
    299 
    300     /**
    301      * @deprecated replaced with {@link #MATCH_DISABLED_COMPONENTS}
    302      */
    303     @Deprecated
    304     public static final int GET_DISABLED_COMPONENTS = 0x00000200;
    305 
    306     /**
    307      * {@link PackageInfo} flag: include disabled components in the returned info.
    308      */
    309     public static final int MATCH_DISABLED_COMPONENTS = 0x00000200;
    310 
    311     /**
    312      * {@link ApplicationInfo} flag: return the
    313      * {@link ApplicationInfo#sharedLibraryFiles paths to the shared libraries}
    314      * that are associated with an application.
    315      * This applies for any API returning an ApplicationInfo class, either
    316      * directly or nested inside of another.
    317      */
    318     public static final int GET_SHARED_LIBRARY_FILES    = 0x00000400;
    319 
    320     /**
    321      * {@link ProviderInfo} flag: return the
    322      * {@link ProviderInfo#uriPermissionPatterns URI permission patterns}
    323      * that are associated with a content provider.
    324      * This applies for any API returning a ProviderInfo class, either
    325      * directly or nested inside of another.
    326      */
    327     public static final int GET_URI_PERMISSION_PATTERNS  = 0x00000800;
    328     /**
    329      * {@link PackageInfo} flag: return information about
    330      * permissions in the package in
    331      * {@link PackageInfo#permissions}.
    332      */
    333     public static final int GET_PERMISSIONS               = 0x00001000;
    334 
    335     /**
    336      * @deprecated replaced with {@link #MATCH_UNINSTALLED_PACKAGES}
    337      */
    338     @Deprecated
    339     public static final int GET_UNINSTALLED_PACKAGES = 0x00002000;
    340 
    341     /**
    342      * Flag parameter to retrieve some information about all applications (even
    343      * uninstalled ones) which have data directories. This state could have
    344      * resulted if applications have been deleted with flag
    345      * {@code DONT_DELETE_DATA} with a possibility of being replaced or
    346      * reinstalled in future.
    347      * <p>
    348      * Note: this flag may cause less information about currently installed
    349      * applications to be returned.
    350      */
    351     public static final int MATCH_UNINSTALLED_PACKAGES = 0x00002000;
    352 
    353     /**
    354      * {@link PackageInfo} flag: return information about
    355      * hardware preferences in
    356      * {@link PackageInfo#configPreferences PackageInfo.configPreferences},
    357      * and requested features in {@link PackageInfo#reqFeatures} and
    358      * {@link PackageInfo#featureGroups}.
    359      */
    360     public static final int GET_CONFIGURATIONS = 0x00004000;
    361 
    362     /**
    363      * @deprecated replaced with {@link #MATCH_DISABLED_UNTIL_USED_COMPONENTS}.
    364      */
    365     @Deprecated
    366     public static final int GET_DISABLED_UNTIL_USED_COMPONENTS = 0x00008000;
    367 
    368     /**
    369      * {@link PackageInfo} flag: include disabled components which are in
    370      * that state only because of {@link #COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED}
    371      * in the returned info.  Note that if you set this flag, applications
    372      * that are in this disabled state will be reported as enabled.
    373      */
    374     public static final int MATCH_DISABLED_UNTIL_USED_COMPONENTS = 0x00008000;
    375 
    376     /**
    377      * Resolution and querying flag: if set, only filters that support the
    378      * {@link android.content.Intent#CATEGORY_DEFAULT} will be considered for
    379      * matching.  This is a synonym for including the CATEGORY_DEFAULT in your
    380      * supplied Intent.
    381      */
    382     public static final int MATCH_DEFAULT_ONLY  = 0x00010000;
    383 
    384     /**
    385      * Querying flag: if set and if the platform is doing any filtering of the
    386      * results, then the filtering will not happen. This is a synonym for saying
    387      * that all results should be returned.
    388      * <p>
    389      * <em>This flag should be used with extreme care.</em>
    390      */
    391     public static final int MATCH_ALL = 0x00020000;
    392 
    393     /**
    394      * Querying flag: match components which are direct boot <em>unaware</em> in
    395      * the returned info, regardless of the current user state.
    396      * <p>
    397      * When neither {@link #MATCH_DIRECT_BOOT_AWARE} nor
    398      * {@link #MATCH_DIRECT_BOOT_UNAWARE} are specified, the default behavior is
    399      * to match only runnable components based on the user state. For example,
    400      * when a user is started but credentials have not been presented yet, the
    401      * user is running "locked" and only {@link #MATCH_DIRECT_BOOT_AWARE}
    402      * components are returned. Once the user credentials have been presented,
    403      * the user is running "unlocked" and both {@link #MATCH_DIRECT_BOOT_AWARE}
    404      * and {@link #MATCH_DIRECT_BOOT_UNAWARE} components are returned.
    405      *
    406      * @see UserManager#isUserUnlocked()
    407      */
    408     public static final int MATCH_DIRECT_BOOT_UNAWARE = 0x00040000;
    409 
    410     /**
    411      * Querying flag: match components which are direct boot <em>aware</em> in
    412      * the returned info, regardless of the current user state.
    413      * <p>
    414      * When neither {@link #MATCH_DIRECT_BOOT_AWARE} nor
    415      * {@link #MATCH_DIRECT_BOOT_UNAWARE} are specified, the default behavior is
    416      * to match only runnable components based on the user state. For example,
    417      * when a user is started but credentials have not been presented yet, the
    418      * user is running "locked" and only {@link #MATCH_DIRECT_BOOT_AWARE}
    419      * components are returned. Once the user credentials have been presented,
    420      * the user is running "unlocked" and both {@link #MATCH_DIRECT_BOOT_AWARE}
    421      * and {@link #MATCH_DIRECT_BOOT_UNAWARE} components are returned.
    422      *
    423      * @see UserManager#isUserUnlocked()
    424      */
    425     public static final int MATCH_DIRECT_BOOT_AWARE = 0x00080000;
    426 
    427     /**
    428      * Querying flag: include only components from applications that are marked
    429      * with {@link ApplicationInfo#FLAG_SYSTEM}.
    430      */
    431     public static final int MATCH_SYSTEM_ONLY = 0x00100000;
    432 
    433     /**
    434      * Internal {@link PackageInfo} flag: include only components on the system image.
    435      * This will not return information on any unbundled update to system components.
    436      * @hide
    437      */
    438     @SystemApi
    439     public static final int MATCH_FACTORY_ONLY = 0x00200000;
    440 
    441     /**
    442      * Allows querying of packages installed for any user, not just the specific one. This flag
    443      * is only meant for use by apps that have INTERACT_ACROSS_USERS permission.
    444      * @hide
    445      */
    446     @SystemApi
    447     public static final int MATCH_ANY_USER = 0x00400000;
    448 
    449     /**
    450      * Combination of MATCH_ANY_USER and MATCH_UNINSTALLED_PACKAGES to mean any known
    451      * package.
    452      * @hide
    453      */
    454     public static final int MATCH_KNOWN_PACKAGES = MATCH_UNINSTALLED_PACKAGES | MATCH_ANY_USER;
    455 
    456     /**
    457      * Internal {@link PackageInfo} flag: include components that are part of an
    458      * instant app. By default, instant app components are not matched.
    459      * @hide
    460      */
    461     @SystemApi
    462     public static final int MATCH_INSTANT = 0x00800000;
    463 
    464     /**
    465      * Internal {@link PackageInfo} flag: include only components that are exposed to
    466      * instant apps. Matched components may have been either explicitly or implicitly
    467      * exposed.
    468      * @hide
    469      */
    470     public static final int MATCH_VISIBLE_TO_INSTANT_APP_ONLY = 0x01000000;
    471 
    472     /**
    473      * Internal {@link PackageInfo} flag: include only components that have been
    474      * explicitly exposed to instant apps.
    475      * @hide
    476      */
    477     public static final int MATCH_EXPLICITLY_VISIBLE_ONLY = 0x02000000;
    478 
    479     /**
    480      * Internal {@link PackageInfo} flag: include static shared libraries.
    481      * Apps that depend on static shared libs can always access the version
    482      * of the lib they depend on. System/shell/root can access all shared
    483      * libs regardless of dependency but need to explicitly ask for them
    484      * via this flag.
    485      * @hide
    486      */
    487     public static final int MATCH_STATIC_SHARED_LIBRARIES = 0x04000000;
    488 
    489     /**
    490      * Internal flag used to indicate that a system component has done their
    491      * homework and verified that they correctly handle packages and components
    492      * that come and go over time. In particular:
    493      * <ul>
    494      * <li>Apps installed on external storage, which will appear to be
    495      * uninstalled while the the device is ejected.
    496      * <li>Apps with encryption unaware components, which will appear to not
    497      * exist while the device is locked.
    498      * </ul>
    499      *
    500      * @see #MATCH_UNINSTALLED_PACKAGES
    501      * @see #MATCH_DIRECT_BOOT_AWARE
    502      * @see #MATCH_DIRECT_BOOT_UNAWARE
    503      * @hide
    504      */
    505     public static final int MATCH_DEBUG_TRIAGED_MISSING = 0x10000000;
    506 
    507     /**
    508      * Flag for {@link #addCrossProfileIntentFilter}: if this flag is set: when
    509      * resolving an intent that matches the {@code CrossProfileIntentFilter},
    510      * the current profile will be skipped. Only activities in the target user
    511      * can respond to the intent.
    512      *
    513      * @hide
    514      */
    515     public static final int SKIP_CURRENT_PROFILE = 0x00000002;
    516 
    517     /**
    518      * Flag for {@link #addCrossProfileIntentFilter}: if this flag is set:
    519      * activities in the other profiles can respond to the intent only if no activity with
    520      * non-negative priority in current profile can respond to the intent.
    521      * @hide
    522      */
    523     public static final int ONLY_IF_NO_MATCH_FOUND = 0x00000004;
    524 
    525     /** @hide */
    526     @IntDef(prefix = { "PERMISSION_" }, value = {
    527             PERMISSION_GRANTED,
    528             PERMISSION_DENIED
    529     })
    530     @Retention(RetentionPolicy.SOURCE)
    531     public @interface PermissionResult {}
    532 
    533     /**
    534      * Permission check result: this is returned by {@link #checkPermission}
    535      * if the permission has been granted to the given package.
    536      */
    537     public static final int PERMISSION_GRANTED = 0;
    538 
    539     /**
    540      * Permission check result: this is returned by {@link #checkPermission}
    541      * if the permission has not been granted to the given package.
    542      */
    543     public static final int PERMISSION_DENIED = -1;
    544 
    545     /** @hide */
    546     @IntDef(prefix = { "SIGNATURE_" }, value = {
    547             SIGNATURE_MATCH,
    548             SIGNATURE_NEITHER_SIGNED,
    549             SIGNATURE_FIRST_NOT_SIGNED,
    550             SIGNATURE_SECOND_NOT_SIGNED,
    551             SIGNATURE_NO_MATCH,
    552             SIGNATURE_UNKNOWN_PACKAGE,
    553     })
    554     @Retention(RetentionPolicy.SOURCE)
    555     public @interface SignatureResult {}
    556 
    557     /**
    558      * Signature check result: this is returned by {@link #checkSignatures}
    559      * if all signatures on the two packages match.
    560      */
    561     public static final int SIGNATURE_MATCH = 0;
    562 
    563     /**
    564      * Signature check result: this is returned by {@link #checkSignatures}
    565      * if neither of the two packages is signed.
    566      */
    567     public static final int SIGNATURE_NEITHER_SIGNED = 1;
    568 
    569     /**
    570      * Signature check result: this is returned by {@link #checkSignatures}
    571      * if the first package is not signed but the second is.
    572      */
    573     public static final int SIGNATURE_FIRST_NOT_SIGNED = -1;
    574 
    575     /**
    576      * Signature check result: this is returned by {@link #checkSignatures}
    577      * if the second package is not signed but the first is.
    578      */
    579     public static final int SIGNATURE_SECOND_NOT_SIGNED = -2;
    580 
    581     /**
    582      * Signature check result: this is returned by {@link #checkSignatures}
    583      * if not all signatures on both packages match.
    584      */
    585     public static final int SIGNATURE_NO_MATCH = -3;
    586 
    587     /**
    588      * Signature check result: this is returned by {@link #checkSignatures}
    589      * if either of the packages are not valid.
    590      */
    591     public static final int SIGNATURE_UNKNOWN_PACKAGE = -4;
    592 
    593     /** @hide */
    594     @IntDef(prefix = { "COMPONENT_ENABLED_STATE_" }, value = {
    595             COMPONENT_ENABLED_STATE_DEFAULT,
    596             COMPONENT_ENABLED_STATE_ENABLED,
    597             COMPONENT_ENABLED_STATE_DISABLED,
    598             COMPONENT_ENABLED_STATE_DISABLED_USER,
    599             COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED,
    600     })
    601     @Retention(RetentionPolicy.SOURCE)
    602     public @interface EnabledState {}
    603 
    604     /**
    605      * Flag for {@link #setApplicationEnabledSetting(String, int, int)} and
    606      * {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
    607      * component or application is in its default enabled state (as specified in
    608      * its manifest).
    609      * <p>
    610      * Explicitly setting the component state to this value restores it's
    611      * enabled state to whatever is set in the manifest.
    612      */
    613     public static final int COMPONENT_ENABLED_STATE_DEFAULT = 0;
    614 
    615     /**
    616      * Flag for {@link #setApplicationEnabledSetting(String, int, int)}
    617      * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
    618      * component or application has been explictily enabled, regardless of
    619      * what it has specified in its manifest.
    620      */
    621     public static final int COMPONENT_ENABLED_STATE_ENABLED = 1;
    622 
    623     /**
    624      * Flag for {@link #setApplicationEnabledSetting(String, int, int)}
    625      * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
    626      * component or application has been explicitly disabled, regardless of
    627      * what it has specified in its manifest.
    628      */
    629     public static final int COMPONENT_ENABLED_STATE_DISABLED = 2;
    630 
    631     /**
    632      * Flag for {@link #setApplicationEnabledSetting(String, int, int)} only: The
    633      * user has explicitly disabled the application, regardless of what it has
    634      * specified in its manifest.  Because this is due to the user's request,
    635      * they may re-enable it if desired through the appropriate system UI.  This
    636      * option currently <strong>cannot</strong> be used with
    637      * {@link #setComponentEnabledSetting(ComponentName, int, int)}.
    638      */
    639     public static final int COMPONENT_ENABLED_STATE_DISABLED_USER = 3;
    640 
    641     /**
    642      * Flag for {@link #setApplicationEnabledSetting(String, int, int)} only: This
    643      * application should be considered, until the point where the user actually
    644      * wants to use it.  This means that it will not normally show up to the user
    645      * (such as in the launcher), but various parts of the user interface can
    646      * use {@link #GET_DISABLED_UNTIL_USED_COMPONENTS} to still see it and allow
    647      * the user to select it (as for example an IME, device admin, etc).  Such code,
    648      * once the user has selected the app, should at that point also make it enabled.
    649      * This option currently <strong>can not</strong> be used with
    650      * {@link #setComponentEnabledSetting(ComponentName, int, int)}.
    651      */
    652     public static final int COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED = 4;
    653 
    654     /** @hide */
    655     @IntDef(flag = true, prefix = { "INSTALL_" }, value = {
    656             INSTALL_FORWARD_LOCK,
    657             INSTALL_REPLACE_EXISTING,
    658             INSTALL_ALLOW_TEST,
    659             INSTALL_EXTERNAL,
    660             INSTALL_INTERNAL,
    661             INSTALL_FROM_ADB,
    662             INSTALL_ALL_USERS,
    663             INSTALL_ALLOW_DOWNGRADE,
    664             INSTALL_GRANT_RUNTIME_PERMISSIONS,
    665             INSTALL_FORCE_VOLUME_UUID,
    666             INSTALL_FORCE_PERMISSION_PROMPT,
    667             INSTALL_INSTANT_APP,
    668             INSTALL_DONT_KILL_APP,
    669             INSTALL_FORCE_SDK,
    670             INSTALL_FULL_APP,
    671             INSTALL_ALLOCATE_AGGRESSIVE,
    672     })
    673     @Retention(RetentionPolicy.SOURCE)
    674     public @interface InstallFlags {}
    675 
    676     /**
    677      * Flag parameter for {@link #installPackage} to indicate that this package
    678      * should be installed as forward locked, i.e. only the app itself should
    679      * have access to its code and non-resource assets.
    680      *
    681      * @deprecated new installs into ASEC containers are no longer supported.
    682      * @hide
    683      */
    684     @Deprecated
    685     public static final int INSTALL_FORWARD_LOCK = 0x00000001;
    686 
    687     /**
    688      * Flag parameter for {@link #installPackage} to indicate that you want to
    689      * replace an already installed package, if one exists.
    690      *
    691      * @hide
    692      */
    693     public static final int INSTALL_REPLACE_EXISTING = 0x00000002;
    694 
    695     /**
    696      * Flag parameter for {@link #installPackage} to indicate that you want to
    697      * allow test packages (those that have set android:testOnly in their
    698      * manifest) to be installed.
    699      * @hide
    700      */
    701     public static final int INSTALL_ALLOW_TEST = 0x00000004;
    702 
    703     /**
    704      * Flag parameter for {@link #installPackage} to indicate that this package
    705      * must be installed to an ASEC on a {@link VolumeInfo#TYPE_PUBLIC}.
    706      *
    707      * @deprecated new installs into ASEC containers are no longer supported;
    708      *             use adoptable storage instead.
    709      * @hide
    710      */
    711     @Deprecated
    712     public static final int INSTALL_EXTERNAL = 0x00000008;
    713 
    714     /**
    715      * Flag parameter for {@link #installPackage} to indicate that this package
    716      * must be installed to internal storage.
    717      *
    718      * @hide
    719      */
    720     public static final int INSTALL_INTERNAL = 0x00000010;
    721 
    722     /**
    723      * Flag parameter for {@link #installPackage} to indicate that this install
    724      * was initiated via ADB.
    725      *
    726      * @hide
    727      */
    728     public static final int INSTALL_FROM_ADB = 0x00000020;
    729 
    730     /**
    731      * Flag parameter for {@link #installPackage} to indicate that this install
    732      * should immediately be visible to all users.
    733      *
    734      * @hide
    735      */
    736     public static final int INSTALL_ALL_USERS = 0x00000040;
    737 
    738     /**
    739      * Flag parameter for {@link #installPackage} to indicate that it is okay
    740      * to install an update to an app where the newly installed app has a lower
    741      * version code than the currently installed app. This is permitted only if
    742      * the currently installed app is marked debuggable.
    743      *
    744      * @hide
    745      */
    746     public static final int INSTALL_ALLOW_DOWNGRADE = 0x00000080;
    747 
    748     /**
    749      * Flag parameter for {@link #installPackage} to indicate that all runtime
    750      * permissions should be granted to the package. If {@link #INSTALL_ALL_USERS}
    751      * is set the runtime permissions will be granted to all users, otherwise
    752      * only to the owner.
    753      *
    754      * @hide
    755      */
    756     public static final int INSTALL_GRANT_RUNTIME_PERMISSIONS = 0x00000100;
    757 
    758     /** {@hide} */
    759     public static final int INSTALL_FORCE_VOLUME_UUID = 0x00000200;
    760 
    761     /**
    762      * Flag parameter for {@link #installPackage} to indicate that we always want to force
    763      * the prompt for permission approval. This overrides any special behaviour for internal
    764      * components.
    765      *
    766      * @hide
    767      */
    768     public static final int INSTALL_FORCE_PERMISSION_PROMPT = 0x00000400;
    769 
    770     /**
    771      * Flag parameter for {@link #installPackage} to indicate that this package is
    772      * to be installed as a lightweight "ephemeral" app.
    773      *
    774      * @hide
    775      */
    776     public static final int INSTALL_INSTANT_APP = 0x00000800;
    777 
    778     /**
    779      * Flag parameter for {@link #installPackage} to indicate that this package contains
    780      * a feature split to an existing application and the existing application should not
    781      * be killed during the installation process.
    782      *
    783      * @hide
    784      */
    785     public static final int INSTALL_DONT_KILL_APP = 0x00001000;
    786 
    787     /**
    788      * Flag parameter for {@link #installPackage} to indicate that this package is an
    789      * upgrade to a package that refers to the SDK via release letter.
    790      *
    791      * @hide
    792      */
    793     public static final int INSTALL_FORCE_SDK = 0x00002000;
    794 
    795     /**
    796      * Flag parameter for {@link #installPackage} to indicate that this package is
    797      * to be installed as a heavy weight app. This is fundamentally the opposite of
    798      * {@link #INSTALL_INSTANT_APP}.
    799      *
    800      * @hide
    801      */
    802     public static final int INSTALL_FULL_APP = 0x00004000;
    803 
    804     /**
    805      * Flag parameter for {@link #installPackage} to indicate that this package
    806      * is critical to system health or security, meaning the system should use
    807      * {@link StorageManager#FLAG_ALLOCATE_AGGRESSIVE} internally.
    808      *
    809      * @hide
    810      */
    811     public static final int INSTALL_ALLOCATE_AGGRESSIVE = 0x00008000;
    812 
    813     /** @hide */
    814     @IntDef(flag = true, prefix = { "DONT_KILL_APP" }, value = {
    815             DONT_KILL_APP
    816     })
    817     @Retention(RetentionPolicy.SOURCE)
    818     public @interface EnabledFlags {}
    819 
    820     /**
    821      * Flag parameter for
    822      * {@link #setComponentEnabledSetting(android.content.ComponentName, int, int)} to indicate
    823      * that you don't want to kill the app containing the component.  Be careful when you set this
    824      * since changing component states can make the containing application's behavior unpredictable.
    825      */
    826     public static final int DONT_KILL_APP = 0x00000001;
    827 
    828     /** @hide */
    829     @IntDef(prefix = { "INSTALL_REASON_" }, value = {
    830             INSTALL_REASON_UNKNOWN,
    831             INSTALL_REASON_POLICY,
    832             INSTALL_REASON_DEVICE_RESTORE,
    833             INSTALL_REASON_DEVICE_SETUP,
    834             INSTALL_REASON_USER
    835     })
    836     @Retention(RetentionPolicy.SOURCE)
    837     public @interface InstallReason {}
    838 
    839     /**
    840      * Code indicating that the reason for installing this package is unknown.
    841      */
    842     public static final int INSTALL_REASON_UNKNOWN = 0;
    843 
    844     /**
    845      * Code indicating that this package was installed due to enterprise policy.
    846      */
    847     public static final int INSTALL_REASON_POLICY = 1;
    848 
    849     /**
    850      * Code indicating that this package was installed as part of restoring from another device.
    851      */
    852     public static final int INSTALL_REASON_DEVICE_RESTORE = 2;
    853 
    854     /**
    855      * Code indicating that this package was installed as part of device setup.
    856      */
    857     public static final int INSTALL_REASON_DEVICE_SETUP = 3;
    858 
    859     /**
    860      * Code indicating that the package installation was initiated by the user.
    861      */
    862     public static final int INSTALL_REASON_USER = 4;
    863 
    864     /**
    865      * Installation return code: this is passed to the
    866      * {@link IPackageInstallObserver} on success.
    867      *
    868      * @hide
    869      */
    870     @SystemApi
    871     public static final int INSTALL_SUCCEEDED = 1;
    872 
    873     /**
    874      * Installation return code: this is passed to the
    875      * {@link IPackageInstallObserver} if the package is already installed.
    876      *
    877      * @hide
    878      */
    879     @SystemApi
    880     public static final int INSTALL_FAILED_ALREADY_EXISTS = -1;
    881 
    882     /**
    883      * Installation return code: this is passed to the
    884      * {@link IPackageInstallObserver} if the package archive file is invalid.
    885      *
    886      * @hide
    887      */
    888     @SystemApi
    889     public static final int INSTALL_FAILED_INVALID_APK = -2;
    890 
    891     /**
    892      * Installation return code: this is passed to the
    893      * {@link IPackageInstallObserver} if the URI passed in is invalid.
    894      *
    895      * @hide
    896      */
    897     @SystemApi
    898     public static final int INSTALL_FAILED_INVALID_URI = -3;
    899 
    900     /**
    901      * Installation return code: this is passed to the
    902      * {@link IPackageInstallObserver} if the package manager service found that
    903      * the device didn't have enough storage space to install the app.
    904      *
    905      * @hide
    906      */
    907     @SystemApi
    908     public static final int INSTALL_FAILED_INSUFFICIENT_STORAGE = -4;
    909 
    910     /**
    911      * Installation return code: this is passed to the
    912      * {@link IPackageInstallObserver} if a package is already installed with
    913      * the same name.
    914      *
    915      * @hide
    916      */
    917     @SystemApi
    918     public static final int INSTALL_FAILED_DUPLICATE_PACKAGE = -5;
    919 
    920     /**
    921      * Installation return code: this is passed to the
    922      * {@link IPackageInstallObserver} if the requested shared user does not
    923      * exist.
    924      *
    925      * @hide
    926      */
    927     @SystemApi
    928     public static final int INSTALL_FAILED_NO_SHARED_USER = -6;
    929 
    930     /**
    931      * Installation return code: this is passed to the
    932      * {@link IPackageInstallObserver} if a previously installed package of the
    933      * same name has a different signature than the new package (and the old
    934      * package's data was not removed).
    935      *
    936      * @hide
    937      */
    938     @SystemApi
    939     public static final int INSTALL_FAILED_UPDATE_INCOMPATIBLE = -7;
    940 
    941     /**
    942      * Installation return code: this is passed to the
    943      * {@link IPackageInstallObserver} if the new package is requested a shared
    944      * user which is already installed on the device and does not have matching
    945      * signature.
    946      *
    947      * @hide
    948      */
    949     @SystemApi
    950     public static final int INSTALL_FAILED_SHARED_USER_INCOMPATIBLE = -8;
    951 
    952     /**
    953      * Installation return code: this is passed to the
    954      * {@link IPackageInstallObserver} if the new package uses a shared library
    955      * that is not available.
    956      *
    957      * @hide
    958      */
    959     @SystemApi
    960     public static final int INSTALL_FAILED_MISSING_SHARED_LIBRARY = -9;
    961 
    962     /**
    963      * Installation return code: this is passed to the
    964      * {@link IPackageInstallObserver} if the new package uses a shared library
    965      * that is not available.
    966      *
    967      * @hide
    968      */
    969     @SystemApi
    970     public static final int INSTALL_FAILED_REPLACE_COULDNT_DELETE = -10;
    971 
    972     /**
    973      * Installation return code: this is passed to the
    974      * {@link IPackageInstallObserver} if the new package failed while
    975      * optimizing and validating its dex files, either because there was not
    976      * enough storage or the validation failed.
    977      *
    978      * @hide
    979      */
    980     @SystemApi
    981     public static final int INSTALL_FAILED_DEXOPT = -11;
    982 
    983     /**
    984      * Installation return code: this is passed to the
    985      * {@link IPackageInstallObserver} if the new package failed because the
    986      * current SDK version is older than that required by the package.
    987      *
    988      * @hide
    989      */
    990     @SystemApi
    991     public static final int INSTALL_FAILED_OLDER_SDK = -12;
    992 
    993     /**
    994      * Installation return code: this is passed to the
    995      * {@link IPackageInstallObserver} if the new package failed because it
    996      * contains a content provider with the same authority as a provider already
    997      * installed in the system.
    998      *
    999      * @hide
   1000      */
   1001     @SystemApi
   1002     public static final int INSTALL_FAILED_CONFLICTING_PROVIDER = -13;
   1003 
   1004     /**
   1005      * Installation return code: this is passed to the
   1006      * {@link IPackageInstallObserver} if the new package failed because the
   1007      * current SDK version is newer than that required by the package.
   1008      *
   1009      * @hide
   1010      */
   1011     @SystemApi
   1012     public static final int INSTALL_FAILED_NEWER_SDK = -14;
   1013 
   1014     /**
   1015      * Installation return code: this is passed to the
   1016      * {@link IPackageInstallObserver} if the new package failed because it has
   1017      * specified that it is a test-only package and the caller has not supplied
   1018      * the {@link #INSTALL_ALLOW_TEST} flag.
   1019      *
   1020      * @hide
   1021      */
   1022     @SystemApi
   1023     public static final int INSTALL_FAILED_TEST_ONLY = -15;
   1024 
   1025     /**
   1026      * Installation return code: this is passed to the
   1027      * {@link IPackageInstallObserver} if the package being installed contains
   1028      * native code, but none that is compatible with the device's CPU_ABI.
   1029      *
   1030      * @hide
   1031      */
   1032     @SystemApi
   1033     public static final int INSTALL_FAILED_CPU_ABI_INCOMPATIBLE = -16;
   1034 
   1035     /**
   1036      * Installation return code: this is passed to the
   1037      * {@link IPackageInstallObserver} if the new package uses a feature that is
   1038      * not available.
   1039      *
   1040      * @hide
   1041      */
   1042     @SystemApi
   1043     public static final int INSTALL_FAILED_MISSING_FEATURE = -17;
   1044 
   1045     // ------ Errors related to sdcard
   1046     /**
   1047      * Installation return code: this is passed to the
   1048      * {@link IPackageInstallObserver} if a secure container mount point
   1049      * couldn't be accessed on external media.
   1050      *
   1051      * @hide
   1052      */
   1053     @SystemApi
   1054     public static final int INSTALL_FAILED_CONTAINER_ERROR = -18;
   1055 
   1056     /**
   1057      * Installation return code: this is passed to the
   1058      * {@link IPackageInstallObserver} if the new package couldn't be installed
   1059      * in the specified install location.
   1060      *
   1061      * @hide
   1062      */
   1063     @SystemApi
   1064     public static final int INSTALL_FAILED_INVALID_INSTALL_LOCATION = -19;
   1065 
   1066     /**
   1067      * Installation return code: this is passed to the
   1068      * {@link IPackageInstallObserver} if the new package couldn't be installed
   1069      * in the specified install location because the media is not available.
   1070      *
   1071      * @hide
   1072      */
   1073     @SystemApi
   1074     public static final int INSTALL_FAILED_MEDIA_UNAVAILABLE = -20;
   1075 
   1076     /**
   1077      * Installation return code: this is passed to the
   1078      * {@link IPackageInstallObserver} if the new package couldn't be installed
   1079      * because the verification timed out.
   1080      *
   1081      * @hide
   1082      */
   1083     @SystemApi
   1084     public static final int INSTALL_FAILED_VERIFICATION_TIMEOUT = -21;
   1085 
   1086     /**
   1087      * Installation return code: this is passed to the
   1088      * {@link IPackageInstallObserver} if the new package couldn't be installed
   1089      * because the verification did not succeed.
   1090      *
   1091      * @hide
   1092      */
   1093     @SystemApi
   1094     public static final int INSTALL_FAILED_VERIFICATION_FAILURE = -22;
   1095 
   1096     /**
   1097      * Installation return code: this is passed to the
   1098      * {@link IPackageInstallObserver} if the package changed from what the
   1099      * calling program expected.
   1100      *
   1101      * @hide
   1102      */
   1103     @SystemApi
   1104     public static final int INSTALL_FAILED_PACKAGE_CHANGED = -23;
   1105 
   1106     /**
   1107      * Installation return code: this is passed to the
   1108      * {@link IPackageInstallObserver} if the new package is assigned a
   1109      * different UID than it previously held.
   1110      *
   1111      * @hide
   1112      */
   1113     public static final int INSTALL_FAILED_UID_CHANGED = -24;
   1114 
   1115     /**
   1116      * Installation return code: this is passed to the
   1117      * {@link IPackageInstallObserver} if the new package has an older version
   1118      * code than the currently installed package.
   1119      *
   1120      * @hide
   1121      */
   1122     public static final int INSTALL_FAILED_VERSION_DOWNGRADE = -25;
   1123 
   1124     /**
   1125      * Installation return code: this is passed to the
   1126      * {@link IPackageInstallObserver} if the old package has target SDK high
   1127      * enough to support runtime permission and the new package has target SDK
   1128      * low enough to not support runtime permissions.
   1129      *
   1130      * @hide
   1131      */
   1132     @SystemApi
   1133     public static final int INSTALL_FAILED_PERMISSION_MODEL_DOWNGRADE = -26;
   1134 
   1135     /**
   1136      * Installation return code: this is passed to the
   1137      * {@link IPackageInstallObserver} if the new package attempts to downgrade the
   1138      * target sandbox version of the app.
   1139      *
   1140      * @hide
   1141      */
   1142     @SystemApi
   1143     public static final int INSTALL_FAILED_SANDBOX_VERSION_DOWNGRADE = -27;
   1144 
   1145     /**
   1146      * Installation parse return code: this is passed to the
   1147      * {@link IPackageInstallObserver} if the parser was given a path that is
   1148      * not a file, or does not end with the expected '.apk' extension.
   1149      *
   1150      * @hide
   1151      */
   1152     @SystemApi
   1153     public static final int INSTALL_PARSE_FAILED_NOT_APK = -100;
   1154 
   1155     /**
   1156      * Installation parse return code: this is passed to the
   1157      * {@link IPackageInstallObserver} if the parser was unable to retrieve the
   1158      * AndroidManifest.xml file.
   1159      *
   1160      * @hide
   1161      */
   1162     @SystemApi
   1163     public static final int INSTALL_PARSE_FAILED_BAD_MANIFEST = -101;
   1164 
   1165     /**
   1166      * Installation parse return code: this is passed to the
   1167      * {@link IPackageInstallObserver} if the parser encountered an unexpected
   1168      * exception.
   1169      *
   1170      * @hide
   1171      */
   1172     @SystemApi
   1173     public static final int INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION = -102;
   1174 
   1175     /**
   1176      * Installation parse return code: this is passed to the
   1177      * {@link IPackageInstallObserver} if the parser did not find any
   1178      * certificates in the .apk.
   1179      *
   1180      * @hide
   1181      */
   1182     @SystemApi
   1183     public static final int INSTALL_PARSE_FAILED_NO_CERTIFICATES = -103;
   1184 
   1185     /**
   1186      * Installation parse return code: this is passed to the
   1187      * {@link IPackageInstallObserver} if the parser found inconsistent
   1188      * certificates on the files in the .apk.
   1189      *
   1190      * @hide
   1191      */
   1192     @SystemApi
   1193     public static final int INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES = -104;
   1194 
   1195     /**
   1196      * Installation parse return code: this is passed to the
   1197      * {@link IPackageInstallObserver} if the parser encountered a
   1198      * CertificateEncodingException in one of the files in the .apk.
   1199      *
   1200      * @hide
   1201      */
   1202     @SystemApi
   1203     public static final int INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING = -105;
   1204 
   1205     /**
   1206      * Installation parse return code: this is passed to the
   1207      * {@link IPackageInstallObserver} if the parser encountered a bad or
   1208      * missing package name in the manifest.
   1209      *
   1210      * @hide
   1211      */
   1212     @SystemApi
   1213     public static final int INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME = -106;
   1214 
   1215     /**
   1216      * Installation parse return code: this is passed to the
   1217      * {@link IPackageInstallObserver} if the parser encountered a bad shared
   1218      * user id name in the manifest.
   1219      *
   1220      * @hide
   1221      */
   1222     @SystemApi
   1223     public static final int INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID = -107;
   1224 
   1225     /**
   1226      * Installation parse return code: this is passed to the
   1227      * {@link IPackageInstallObserver} if the parser encountered some structural
   1228      * problem in the manifest.
   1229      *
   1230      * @hide
   1231      */
   1232     @SystemApi
   1233     public static final int INSTALL_PARSE_FAILED_MANIFEST_MALFORMED = -108;
   1234 
   1235     /**
   1236      * Installation parse return code: this is passed to the
   1237      * {@link IPackageInstallObserver} if the parser did not find any actionable
   1238      * tags (instrumentation or application) in the manifest.
   1239      *
   1240      * @hide
   1241      */
   1242     @SystemApi
   1243     public static final int INSTALL_PARSE_FAILED_MANIFEST_EMPTY = -109;
   1244 
   1245     /**
   1246      * Installation failed return code: this is passed to the
   1247      * {@link IPackageInstallObserver} if the system failed to install the
   1248      * package because of system issues.
   1249      *
   1250      * @hide
   1251      */
   1252     @SystemApi
   1253     public static final int INSTALL_FAILED_INTERNAL_ERROR = -110;
   1254 
   1255     /**
   1256      * Installation failed return code: this is passed to the
   1257      * {@link IPackageInstallObserver} if the system failed to install the
   1258      * package because the user is restricted from installing apps.
   1259      *
   1260      * @hide
   1261      */
   1262     public static final int INSTALL_FAILED_USER_RESTRICTED = -111;
   1263 
   1264     /**
   1265      * Installation failed return code: this is passed to the
   1266      * {@link IPackageInstallObserver} if the system failed to install the
   1267      * package because it is attempting to define a permission that is already
   1268      * defined by some existing package.
   1269      * <p>
   1270      * The package name of the app which has already defined the permission is
   1271      * passed to a {@link PackageInstallObserver}, if any, as the
   1272      * {@link #EXTRA_FAILURE_EXISTING_PACKAGE} string extra; and the name of the
   1273      * permission being redefined is passed in the
   1274      * {@link #EXTRA_FAILURE_EXISTING_PERMISSION} string extra.
   1275      *
   1276      * @hide
   1277      */
   1278     public static final int INSTALL_FAILED_DUPLICATE_PERMISSION = -112;
   1279 
   1280     /**
   1281      * Installation failed return code: this is passed to the
   1282      * {@link IPackageInstallObserver} if the system failed to install the
   1283      * package because its packaged native code did not match any of the ABIs
   1284      * supported by the system.
   1285      *
   1286      * @hide
   1287      */
   1288     public static final int INSTALL_FAILED_NO_MATCHING_ABIS = -113;
   1289 
   1290     /**
   1291      * Internal return code for NativeLibraryHelper methods to indicate that the package
   1292      * being processed did not contain any native code. This is placed here only so that
   1293      * it can belong to the same value space as the other install failure codes.
   1294      *
   1295      * @hide
   1296      */
   1297     public static final int NO_NATIVE_LIBRARIES = -114;
   1298 
   1299     /** {@hide} */
   1300     public static final int INSTALL_FAILED_ABORTED = -115;
   1301 
   1302     /**
   1303      * Installation failed return code: instant app installs are incompatible with some
   1304      * other installation flags supplied for the operation; or other circumstances such
   1305      * as trying to upgrade a system app via an instant app install.
   1306      * @hide
   1307      */
   1308     public static final int INSTALL_FAILED_INSTANT_APP_INVALID = -116;
   1309 
   1310     /** @hide */
   1311     @IntDef(flag = true, prefix = { "DELETE_" }, value = {
   1312             DELETE_KEEP_DATA,
   1313             DELETE_ALL_USERS,
   1314             DELETE_SYSTEM_APP,
   1315             DELETE_DONT_KILL_APP,
   1316     })
   1317     @Retention(RetentionPolicy.SOURCE)
   1318     public @interface DeleteFlags {}
   1319 
   1320     /**
   1321      * Flag parameter for {@link #deletePackage} to indicate that you don't want to delete the
   1322      * package's data directory.
   1323      *
   1324      * @hide
   1325      */
   1326     public static final int DELETE_KEEP_DATA = 0x00000001;
   1327 
   1328     /**
   1329      * Flag parameter for {@link #deletePackage} to indicate that you want the
   1330      * package deleted for all users.
   1331      *
   1332      * @hide
   1333      */
   1334     public static final int DELETE_ALL_USERS = 0x00000002;
   1335 
   1336     /**
   1337      * Flag parameter for {@link #deletePackage} to indicate that, if you are calling
   1338      * uninstall on a system that has been updated, then don't do the normal process
   1339      * of uninstalling the update and rolling back to the older system version (which
   1340      * needs to happen for all users); instead, just mark the app as uninstalled for
   1341      * the current user.
   1342      *
   1343      * @hide
   1344      */
   1345     public static final int DELETE_SYSTEM_APP = 0x00000004;
   1346 
   1347     /**
   1348      * Flag parameter for {@link #deletePackage} to indicate that, if you are calling
   1349      * uninstall on a package that is replaced to provide new feature splits, the
   1350      * existing application should not be killed during the removal process.
   1351      *
   1352      * @hide
   1353      */
   1354     public static final int DELETE_DONT_KILL_APP = 0x00000008;
   1355 
   1356     /**
   1357      * Return code for when package deletion succeeds. This is passed to the
   1358      * {@link IPackageDeleteObserver} if the system succeeded in deleting the
   1359      * package.
   1360      *
   1361      * @hide
   1362      */
   1363     public static final int DELETE_SUCCEEDED = 1;
   1364 
   1365     /**
   1366      * Deletion failed return code: this is passed to the
   1367      * {@link IPackageDeleteObserver} if the system failed to delete the package
   1368      * for an unspecified reason.
   1369      *
   1370      * @hide
   1371      */
   1372     public static final int DELETE_FAILED_INTERNAL_ERROR = -1;
   1373 
   1374     /**
   1375      * Deletion failed return code: this is passed to the
   1376      * {@link IPackageDeleteObserver} if the system failed to delete the package
   1377      * because it is the active DevicePolicy manager.
   1378      *
   1379      * @hide
   1380      */
   1381     public static final int DELETE_FAILED_DEVICE_POLICY_MANAGER = -2;
   1382 
   1383     /**
   1384      * Deletion failed return code: this is passed to the
   1385      * {@link IPackageDeleteObserver} if the system failed to delete the package
   1386      * since the user is restricted.
   1387      *
   1388      * @hide
   1389      */
   1390     public static final int DELETE_FAILED_USER_RESTRICTED = -3;
   1391 
   1392     /**
   1393      * Deletion failed return code: this is passed to the
   1394      * {@link IPackageDeleteObserver} if the system failed to delete the package
   1395      * because a profile or device owner has marked the package as
   1396      * uninstallable.
   1397      *
   1398      * @hide
   1399      */
   1400     public static final int DELETE_FAILED_OWNER_BLOCKED = -4;
   1401 
   1402     /** {@hide} */
   1403     public static final int DELETE_FAILED_ABORTED = -5;
   1404 
   1405     /**
   1406      * Deletion failed return code: this is passed to the
   1407      * {@link IPackageDeleteObserver} if the system failed to delete the package
   1408      * because the packge is a shared library used by other installed packages.
   1409      * {@hide} */
   1410     public static final int DELETE_FAILED_USED_SHARED_LIBRARY = -6;
   1411 
   1412     /**
   1413      * Return code that is passed to the {@link IPackageMoveObserver} when the
   1414      * package has been successfully moved by the system.
   1415      *
   1416      * @hide
   1417      */
   1418     public static final int MOVE_SUCCEEDED = -100;
   1419 
   1420     /**
   1421      * Error code that is passed to the {@link IPackageMoveObserver} when the
   1422      * package hasn't been successfully moved by the system because of
   1423      * insufficient memory on specified media.
   1424      *
   1425      * @hide
   1426      */
   1427     public static final int MOVE_FAILED_INSUFFICIENT_STORAGE = -1;
   1428 
   1429     /**
   1430      * Error code that is passed to the {@link IPackageMoveObserver} if the
   1431      * specified package doesn't exist.
   1432      *
   1433      * @hide
   1434      */
   1435     public static final int MOVE_FAILED_DOESNT_EXIST = -2;
   1436 
   1437     /**
   1438      * Error code that is passed to the {@link IPackageMoveObserver} if the
   1439      * specified package cannot be moved since its a system package.
   1440      *
   1441      * @hide
   1442      */
   1443     public static final int MOVE_FAILED_SYSTEM_PACKAGE = -3;
   1444 
   1445     /**
   1446      * Error code that is passed to the {@link IPackageMoveObserver} if the
   1447      * specified package cannot be moved since its forward locked.
   1448      *
   1449      * @hide
   1450      */
   1451     public static final int MOVE_FAILED_FORWARD_LOCKED = -4;
   1452 
   1453     /**
   1454      * Error code that is passed to the {@link IPackageMoveObserver} if the
   1455      * specified package cannot be moved to the specified location.
   1456      *
   1457      * @hide
   1458      */
   1459     public static final int MOVE_FAILED_INVALID_LOCATION = -5;
   1460 
   1461     /**
   1462      * Error code that is passed to the {@link IPackageMoveObserver} if the
   1463      * specified package cannot be moved to the specified location.
   1464      *
   1465      * @hide
   1466      */
   1467     public static final int MOVE_FAILED_INTERNAL_ERROR = -6;
   1468 
   1469     /**
   1470      * Error code that is passed to the {@link IPackageMoveObserver} if the
   1471      * specified package already has an operation pending in the queue.
   1472      *
   1473      * @hide
   1474      */
   1475     public static final int MOVE_FAILED_OPERATION_PENDING = -7;
   1476 
   1477     /**
   1478      * Error code that is passed to the {@link IPackageMoveObserver} if the
   1479      * specified package cannot be moved since it contains a device admin.
   1480      *
   1481      * @hide
   1482      */
   1483     public static final int MOVE_FAILED_DEVICE_ADMIN = -8;
   1484 
   1485     /**
   1486      * Error code that is passed to the {@link IPackageMoveObserver} if system does not allow
   1487      * non-system apps to be moved to internal storage.
   1488      *
   1489      * @hide
   1490      */
   1491     public static final int MOVE_FAILED_3RD_PARTY_NOT_ALLOWED_ON_INTERNAL = -9;
   1492 
   1493     /**
   1494      * Flag parameter for {@link #movePackage} to indicate that
   1495      * the package should be moved to internal storage if its
   1496      * been installed on external media.
   1497      * @hide
   1498      */
   1499     @Deprecated
   1500     public static final int MOVE_INTERNAL = 0x00000001;
   1501 
   1502     /**
   1503      * Flag parameter for {@link #movePackage} to indicate that
   1504      * the package should be moved to external media.
   1505      * @hide
   1506      */
   1507     @Deprecated
   1508     public static final int MOVE_EXTERNAL_MEDIA = 0x00000002;
   1509 
   1510     /** {@hide} */
   1511     public static final String EXTRA_MOVE_ID = "android.content.pm.extra.MOVE_ID";
   1512 
   1513     /**
   1514      * Usable by the required verifier as the {@code verificationCode} argument
   1515      * for {@link PackageManager#verifyPendingInstall} to indicate that it will
   1516      * allow the installation to proceed without any of the optional verifiers
   1517      * needing to vote.
   1518      *
   1519      * @hide
   1520      */
   1521     public static final int VERIFICATION_ALLOW_WITHOUT_SUFFICIENT = 2;
   1522 
   1523     /**
   1524      * Used as the {@code verificationCode} argument for
   1525      * {@link PackageManager#verifyPendingInstall} to indicate that the calling
   1526      * package verifier allows the installation to proceed.
   1527      */
   1528     public static final int VERIFICATION_ALLOW = 1;
   1529 
   1530     /**
   1531      * Used as the {@code verificationCode} argument for
   1532      * {@link PackageManager#verifyPendingInstall} to indicate the calling
   1533      * package verifier does not vote to allow the installation to proceed.
   1534      */
   1535     public static final int VERIFICATION_REJECT = -1;
   1536 
   1537     /**
   1538      * Used as the {@code verificationCode} argument for
   1539      * {@link PackageManager#verifyIntentFilter} to indicate that the calling
   1540      * IntentFilter Verifier confirms that the IntentFilter is verified.
   1541      *
   1542      * @hide
   1543      */
   1544     @SystemApi
   1545     public static final int INTENT_FILTER_VERIFICATION_SUCCESS = 1;
   1546 
   1547     /**
   1548      * Used as the {@code verificationCode} argument for
   1549      * {@link PackageManager#verifyIntentFilter} to indicate that the calling
   1550      * IntentFilter Verifier confirms that the IntentFilter is NOT verified.
   1551      *
   1552      * @hide
   1553      */
   1554     @SystemApi
   1555     public static final int INTENT_FILTER_VERIFICATION_FAILURE = -1;
   1556 
   1557     /**
   1558      * Internal status code to indicate that an IntentFilter verification result is not specified.
   1559      *
   1560      * @hide
   1561      */
   1562     @SystemApi
   1563     public static final int INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED = 0;
   1564 
   1565     /**
   1566      * Used as the {@code status} argument for
   1567      * {@link #updateIntentVerificationStatusAsUser} to indicate that the User
   1568      * will always be prompted the Intent Disambiguation Dialog if there are two
   1569      * or more Intent resolved for the IntentFilter's domain(s).
   1570      *
   1571      * @hide
   1572      */
   1573     @SystemApi
   1574     public static final int INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK = 1;
   1575 
   1576     /**
   1577      * Used as the {@code status} argument for
   1578      * {@link #updateIntentVerificationStatusAsUser} to indicate that the User
   1579      * will never be prompted the Intent Disambiguation Dialog if there are two
   1580      * or more resolution of the Intent. The default App for the domain(s)
   1581      * specified in the IntentFilter will also ALWAYS be used.
   1582      *
   1583      * @hide
   1584      */
   1585     @SystemApi
   1586     public static final int INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS = 2;
   1587 
   1588     /**
   1589      * Used as the {@code status} argument for
   1590      * {@link #updateIntentVerificationStatusAsUser} to indicate that the User
   1591      * may be prompted the Intent Disambiguation Dialog if there are two or more
   1592      * Intent resolved. The default App for the domain(s) specified in the
   1593      * IntentFilter will also NEVER be presented to the User.
   1594      *
   1595      * @hide
   1596      */
   1597     @SystemApi
   1598     public static final int INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER = 3;
   1599 
   1600     /**
   1601      * Used as the {@code status} argument for
   1602      * {@link #updateIntentVerificationStatusAsUser} to indicate that this app
   1603      * should always be considered as an ambiguous candidate for handling the
   1604      * matching Intent even if there are other candidate apps in the "always"
   1605      * state. Put another way: if there are any 'always ask' apps in a set of
   1606      * more than one candidate app, then a disambiguation is *always* presented
   1607      * even if there is another candidate app with the 'always' state.
   1608      *
   1609      * @hide
   1610      */
   1611     @SystemApi
   1612     public static final int INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS_ASK = 4;
   1613 
   1614     /**
   1615      * Can be used as the {@code millisecondsToDelay} argument for
   1616      * {@link PackageManager#extendVerificationTimeout}. This is the
   1617      * maximum time {@code PackageManager} waits for the verification
   1618      * agent to return (in milliseconds).
   1619      */
   1620     public static final long MAXIMUM_VERIFICATION_TIMEOUT = 60*60*1000;
   1621 
   1622     /**
   1623      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: The device's
   1624      * audio pipeline is low-latency, more suitable for audio applications sensitive to delays or
   1625      * lag in sound input or output.
   1626      */
   1627     @SdkConstant(SdkConstantType.FEATURE)
   1628     public static final String FEATURE_AUDIO_LOW_LATENCY = "android.hardware.audio.low_latency";
   1629 
   1630     /**
   1631      * Feature for {@link #getSystemAvailableFeatures} and
   1632      * {@link #hasSystemFeature}: The device includes at least one form of audio
   1633      * output, such as speakers, audio jack or streaming over bluetooth
   1634      */
   1635     @SdkConstant(SdkConstantType.FEATURE)
   1636     public static final String FEATURE_AUDIO_OUTPUT = "android.hardware.audio.output";
   1637 
   1638     /**
   1639      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   1640      * The device has professional audio level of functionality and performance.
   1641      */
   1642     @SdkConstant(SdkConstantType.FEATURE)
   1643     public static final String FEATURE_AUDIO_PRO = "android.hardware.audio.pro";
   1644 
   1645     /**
   1646      * Feature for {@link #getSystemAvailableFeatures} and
   1647      * {@link #hasSystemFeature}: The device is capable of communicating with
   1648      * other devices via Bluetooth.
   1649      */
   1650     @SdkConstant(SdkConstantType.FEATURE)
   1651     public static final String FEATURE_BLUETOOTH = "android.hardware.bluetooth";
   1652 
   1653     /**
   1654      * Feature for {@link #getSystemAvailableFeatures} and
   1655      * {@link #hasSystemFeature}: The device is capable of communicating with
   1656      * other devices via Bluetooth Low Energy radio.
   1657      */
   1658     @SdkConstant(SdkConstantType.FEATURE)
   1659     public static final String FEATURE_BLUETOOTH_LE = "android.hardware.bluetooth_le";
   1660 
   1661     /**
   1662      * Feature for {@link #getSystemAvailableFeatures} and
   1663      * {@link #hasSystemFeature}: The device has a camera facing away
   1664      * from the screen.
   1665      */
   1666     @SdkConstant(SdkConstantType.FEATURE)
   1667     public static final String FEATURE_CAMERA = "android.hardware.camera";
   1668 
   1669     /**
   1670      * Feature for {@link #getSystemAvailableFeatures} and
   1671      * {@link #hasSystemFeature}: The device's camera supports auto-focus.
   1672      */
   1673     @SdkConstant(SdkConstantType.FEATURE)
   1674     public static final String FEATURE_CAMERA_AUTOFOCUS = "android.hardware.camera.autofocus";
   1675 
   1676     /**
   1677      * Feature for {@link #getSystemAvailableFeatures} and
   1678      * {@link #hasSystemFeature}: The device has at least one camera pointing in
   1679      * some direction, or can support an external camera being connected to it.
   1680      */
   1681     @SdkConstant(SdkConstantType.FEATURE)
   1682     public static final String FEATURE_CAMERA_ANY = "android.hardware.camera.any";
   1683 
   1684     /**
   1685      * Feature for {@link #getSystemAvailableFeatures} and
   1686      * {@link #hasSystemFeature}: The device can support having an external camera connected to it.
   1687      * The external camera may not always be connected or available to applications to use.
   1688      */
   1689     @SdkConstant(SdkConstantType.FEATURE)
   1690     public static final String FEATURE_CAMERA_EXTERNAL = "android.hardware.camera.external";
   1691 
   1692     /**
   1693      * Feature for {@link #getSystemAvailableFeatures} and
   1694      * {@link #hasSystemFeature}: The device's camera supports flash.
   1695      */
   1696     @SdkConstant(SdkConstantType.FEATURE)
   1697     public static final String FEATURE_CAMERA_FLASH = "android.hardware.camera.flash";
   1698 
   1699     /**
   1700      * Feature for {@link #getSystemAvailableFeatures} and
   1701      * {@link #hasSystemFeature}: The device has a front facing camera.
   1702      */
   1703     @SdkConstant(SdkConstantType.FEATURE)
   1704     public static final String FEATURE_CAMERA_FRONT = "android.hardware.camera.front";
   1705 
   1706     /**
   1707      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
   1708      * of the cameras on the device supports the
   1709      * {@link android.hardware.camera2.CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL full hardware}
   1710      * capability level.
   1711      */
   1712     @SdkConstant(SdkConstantType.FEATURE)
   1713     public static final String FEATURE_CAMERA_LEVEL_FULL = "android.hardware.camera.level.full";
   1714 
   1715     /**
   1716      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
   1717      * of the cameras on the device supports the
   1718      * {@link android.hardware.camera2.CameraMetadata#REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR manual sensor}
   1719      * capability level.
   1720      */
   1721     @SdkConstant(SdkConstantType.FEATURE)
   1722     public static final String FEATURE_CAMERA_CAPABILITY_MANUAL_SENSOR =
   1723             "android.hardware.camera.capability.manual_sensor";
   1724 
   1725     /**
   1726      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
   1727      * of the cameras on the device supports the
   1728      * {@link android.hardware.camera2.CameraMetadata#REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING manual post-processing}
   1729      * capability level.
   1730      */
   1731     @SdkConstant(SdkConstantType.FEATURE)
   1732     public static final String FEATURE_CAMERA_CAPABILITY_MANUAL_POST_PROCESSING =
   1733             "android.hardware.camera.capability.manual_post_processing";
   1734 
   1735     /**
   1736      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
   1737      * of the cameras on the device supports the
   1738      * {@link android.hardware.camera2.CameraMetadata#REQUEST_AVAILABLE_CAPABILITIES_RAW RAW}
   1739      * capability level.
   1740      */
   1741     @SdkConstant(SdkConstantType.FEATURE)
   1742     public static final String FEATURE_CAMERA_CAPABILITY_RAW =
   1743             "android.hardware.camera.capability.raw";
   1744 
   1745     /**
   1746      * Feature for {@link #getSystemAvailableFeatures} and
   1747      * {@link #hasSystemFeature}: The device is capable of communicating with
   1748      * consumer IR devices.
   1749      */
   1750     @SdkConstant(SdkConstantType.FEATURE)
   1751     public static final String FEATURE_CONSUMER_IR = "android.hardware.consumerir";
   1752 
   1753     /** {@hide} */
   1754     @SdkConstant(SdkConstantType.FEATURE)
   1755     public static final String FEATURE_CTS = "android.software.cts";
   1756 
   1757     /**
   1758      * Feature for {@link #getSystemAvailableFeatures} and
   1759      * {@link #hasSystemFeature}: The device supports one or more methods of
   1760      * reporting current location.
   1761      */
   1762     @SdkConstant(SdkConstantType.FEATURE)
   1763     public static final String FEATURE_LOCATION = "android.hardware.location";
   1764 
   1765     /**
   1766      * Feature for {@link #getSystemAvailableFeatures} and
   1767      * {@link #hasSystemFeature}: The device has a Global Positioning System
   1768      * receiver and can report precise location.
   1769      */
   1770     @SdkConstant(SdkConstantType.FEATURE)
   1771     public static final String FEATURE_LOCATION_GPS = "android.hardware.location.gps";
   1772 
   1773     /**
   1774      * Feature for {@link #getSystemAvailableFeatures} and
   1775      * {@link #hasSystemFeature}: The device can report location with coarse
   1776      * accuracy using a network-based geolocation system.
   1777      */
   1778     @SdkConstant(SdkConstantType.FEATURE)
   1779     public static final String FEATURE_LOCATION_NETWORK = "android.hardware.location.network";
   1780 
   1781     /**
   1782      * Feature for {@link #getSystemAvailableFeatures} and
   1783      * {@link #hasSystemFeature}: The device can record audio via a
   1784      * microphone.
   1785      */
   1786     @SdkConstant(SdkConstantType.FEATURE)
   1787     public static final String FEATURE_MICROPHONE = "android.hardware.microphone";
   1788 
   1789     /**
   1790      * Feature for {@link #getSystemAvailableFeatures} and
   1791      * {@link #hasSystemFeature}: The device can communicate using Near-Field
   1792      * Communications (NFC).
   1793      */
   1794     @SdkConstant(SdkConstantType.FEATURE)
   1795     public static final String FEATURE_NFC = "android.hardware.nfc";
   1796 
   1797     /**
   1798      * Feature for {@link #getSystemAvailableFeatures} and
   1799      * {@link #hasSystemFeature}: The device supports host-
   1800      * based NFC card emulation.
   1801      *
   1802      * TODO remove when depending apps have moved to new constant.
   1803      * @hide
   1804      * @deprecated
   1805      */
   1806     @Deprecated
   1807     @SdkConstant(SdkConstantType.FEATURE)
   1808     public static final String FEATURE_NFC_HCE = "android.hardware.nfc.hce";
   1809 
   1810     /**
   1811      * Feature for {@link #getSystemAvailableFeatures} and
   1812      * {@link #hasSystemFeature}: The device supports host-
   1813      * based NFC card emulation.
   1814      */
   1815     @SdkConstant(SdkConstantType.FEATURE)
   1816     public static final String FEATURE_NFC_HOST_CARD_EMULATION = "android.hardware.nfc.hce";
   1817 
   1818     /**
   1819      * Feature for {@link #getSystemAvailableFeatures} and
   1820      * {@link #hasSystemFeature}: The device supports host-
   1821      * based NFC-F card emulation.
   1822      */
   1823     @SdkConstant(SdkConstantType.FEATURE)
   1824     public static final String FEATURE_NFC_HOST_CARD_EMULATION_NFCF = "android.hardware.nfc.hcef";
   1825 
   1826     /**
   1827      * Feature for {@link #getSystemAvailableFeatures} and
   1828      * {@link #hasSystemFeature}: The device supports any
   1829      * one of the {@link #FEATURE_NFC}, {@link #FEATURE_NFC_HOST_CARD_EMULATION},
   1830      * or {@link #FEATURE_NFC_HOST_CARD_EMULATION_NFCF} features.
   1831      *
   1832      * @hide
   1833      */
   1834     @SdkConstant(SdkConstantType.FEATURE)
   1835     public static final String FEATURE_NFC_ANY = "android.hardware.nfc.any";
   1836 
   1837     /**
   1838      * Feature for {@link #getSystemAvailableFeatures} and
   1839      * {@link #hasSystemFeature}: The device supports the OpenGL ES
   1840      * <a href="http://www.khronos.org/registry/gles/extensions/ANDROID/ANDROID_extension_pack_es31a.txt">
   1841      * Android Extension Pack</a>.
   1842      */
   1843     @SdkConstant(SdkConstantType.FEATURE)
   1844     public static final String FEATURE_OPENGLES_EXTENSION_PACK = "android.hardware.opengles.aep";
   1845 
   1846     /**
   1847      * Feature for {@link #getSystemAvailableFeatures} and
   1848      * {@link #hasSystemFeature(String, int)}: If this feature is supported, the Vulkan native API
   1849      * will enumerate at least one {@code VkPhysicalDevice}, and the feature version will indicate
   1850      * what level of optional hardware features limits it supports.
   1851      * <p>
   1852      * Level 0 includes the base Vulkan requirements as well as:
   1853      * <ul><li>{@code VkPhysicalDeviceFeatures::textureCompressionETC2}</li></ul>
   1854      * <p>
   1855      * Level 1 additionally includes:
   1856      * <ul>
   1857      * <li>{@code VkPhysicalDeviceFeatures::fullDrawIndexUint32}</li>
   1858      * <li>{@code VkPhysicalDeviceFeatures::imageCubeArray}</li>
   1859      * <li>{@code VkPhysicalDeviceFeatures::independentBlend}</li>
   1860      * <li>{@code VkPhysicalDeviceFeatures::geometryShader}</li>
   1861      * <li>{@code VkPhysicalDeviceFeatures::tessellationShader}</li>
   1862      * <li>{@code VkPhysicalDeviceFeatures::sampleRateShading}</li>
   1863      * <li>{@code VkPhysicalDeviceFeatures::textureCompressionASTC_LDR}</li>
   1864      * <li>{@code VkPhysicalDeviceFeatures::fragmentStoresAndAtomics}</li>
   1865      * <li>{@code VkPhysicalDeviceFeatures::shaderImageGatherExtended}</li>
   1866      * <li>{@code VkPhysicalDeviceFeatures::shaderUniformBufferArrayDynamicIndexing}</li>
   1867      * <li>{@code VkPhysicalDeviceFeatures::shaderSampledImageArrayDynamicIndexing}</li>
   1868      * </ul>
   1869      */
   1870     @SdkConstant(SdkConstantType.FEATURE)
   1871     public static final String FEATURE_VULKAN_HARDWARE_LEVEL = "android.hardware.vulkan.level";
   1872 
   1873     /**
   1874      * Feature for {@link #getSystemAvailableFeatures} and
   1875      * {@link #hasSystemFeature(String, int)}: If this feature is supported, the Vulkan native API
   1876      * will enumerate at least one {@code VkPhysicalDevice}, and the feature version will indicate
   1877      * what level of optional compute features are supported beyond the Vulkan 1.0 requirements.
   1878      * <p>
   1879      * Compute level 0 indicates support for the {@code VariablePointers} SPIR-V capability defined
   1880      * by the SPV_KHR_variable_pointers extension.
   1881      */
   1882     @SdkConstant(SdkConstantType.FEATURE)
   1883     public static final String FEATURE_VULKAN_HARDWARE_COMPUTE = "android.hardware.vulkan.compute";
   1884 
   1885     /**
   1886      * Feature for {@link #getSystemAvailableFeatures} and
   1887      * {@link #hasSystemFeature(String, int)}: The version of this feature indicates the highest
   1888      * {@code VkPhysicalDeviceProperties::apiVersion} supported by the physical devices that support
   1889      * the hardware level indicated by {@link #FEATURE_VULKAN_HARDWARE_LEVEL}. The feature version
   1890      * uses the same encoding as Vulkan version numbers:
   1891      * <ul>
   1892      * <li>Major version number in bits 31-22</li>
   1893      * <li>Minor version number in bits 21-12</li>
   1894      * <li>Patch version number in bits 11-0</li>
   1895      * </ul>
   1896      */
   1897     @SdkConstant(SdkConstantType.FEATURE)
   1898     public static final String FEATURE_VULKAN_HARDWARE_VERSION = "android.hardware.vulkan.version";
   1899 
   1900     /**
   1901      * Feature for {@link #getSystemAvailableFeatures} and
   1902      * {@link #hasSystemFeature}: The device includes an accelerometer.
   1903      */
   1904     @SdkConstant(SdkConstantType.FEATURE)
   1905     public static final String FEATURE_SENSOR_ACCELEROMETER = "android.hardware.sensor.accelerometer";
   1906 
   1907     /**
   1908      * Feature for {@link #getSystemAvailableFeatures} and
   1909      * {@link #hasSystemFeature}: The device includes a barometer (air
   1910      * pressure sensor.)
   1911      */
   1912     @SdkConstant(SdkConstantType.FEATURE)
   1913     public static final String FEATURE_SENSOR_BAROMETER = "android.hardware.sensor.barometer";
   1914 
   1915     /**
   1916      * Feature for {@link #getSystemAvailableFeatures} and
   1917      * {@link #hasSystemFeature}: The device includes a magnetometer (compass).
   1918      */
   1919     @SdkConstant(SdkConstantType.FEATURE)
   1920     public static final String FEATURE_SENSOR_COMPASS = "android.hardware.sensor.compass";
   1921 
   1922     /**
   1923      * Feature for {@link #getSystemAvailableFeatures} and
   1924      * {@link #hasSystemFeature}: The device includes a gyroscope.
   1925      */
   1926     @SdkConstant(SdkConstantType.FEATURE)
   1927     public static final String FEATURE_SENSOR_GYROSCOPE = "android.hardware.sensor.gyroscope";
   1928 
   1929     /**
   1930      * Feature for {@link #getSystemAvailableFeatures} and
   1931      * {@link #hasSystemFeature}: The device includes a light sensor.
   1932      */
   1933     @SdkConstant(SdkConstantType.FEATURE)
   1934     public static final String FEATURE_SENSOR_LIGHT = "android.hardware.sensor.light";
   1935 
   1936     /**
   1937      * Feature for {@link #getSystemAvailableFeatures} and
   1938      * {@link #hasSystemFeature}: The device includes a proximity sensor.
   1939      */
   1940     @SdkConstant(SdkConstantType.FEATURE)
   1941     public static final String FEATURE_SENSOR_PROXIMITY = "android.hardware.sensor.proximity";
   1942 
   1943     /**
   1944      * Feature for {@link #getSystemAvailableFeatures} and
   1945      * {@link #hasSystemFeature}: The device includes a hardware step counter.
   1946      */
   1947     @SdkConstant(SdkConstantType.FEATURE)
   1948     public static final String FEATURE_SENSOR_STEP_COUNTER = "android.hardware.sensor.stepcounter";
   1949 
   1950     /**
   1951      * Feature for {@link #getSystemAvailableFeatures} and
   1952      * {@link #hasSystemFeature}: The device includes a hardware step detector.
   1953      */
   1954     @SdkConstant(SdkConstantType.FEATURE)
   1955     public static final String FEATURE_SENSOR_STEP_DETECTOR = "android.hardware.sensor.stepdetector";
   1956 
   1957     /**
   1958      * Feature for {@link #getSystemAvailableFeatures} and
   1959      * {@link #hasSystemFeature}: The device includes a heart rate monitor.
   1960      */
   1961     @SdkConstant(SdkConstantType.FEATURE)
   1962     public static final String FEATURE_SENSOR_HEART_RATE = "android.hardware.sensor.heartrate";
   1963 
   1964     /**
   1965      * Feature for {@link #getSystemAvailableFeatures} and
   1966      * {@link #hasSystemFeature}: The heart rate sensor on this device is an Electrocardiogram.
   1967      */
   1968     @SdkConstant(SdkConstantType.FEATURE)
   1969     public static final String FEATURE_SENSOR_HEART_RATE_ECG =
   1970             "android.hardware.sensor.heartrate.ecg";
   1971 
   1972     /**
   1973      * Feature for {@link #getSystemAvailableFeatures} and
   1974      * {@link #hasSystemFeature}: The device includes a relative humidity sensor.
   1975      */
   1976     @SdkConstant(SdkConstantType.FEATURE)
   1977     public static final String FEATURE_SENSOR_RELATIVE_HUMIDITY =
   1978             "android.hardware.sensor.relative_humidity";
   1979 
   1980     /**
   1981      * Feature for {@link #getSystemAvailableFeatures} and
   1982      * {@link #hasSystemFeature}: The device includes an ambient temperature sensor.
   1983      */
   1984     @SdkConstant(SdkConstantType.FEATURE)
   1985     public static final String FEATURE_SENSOR_AMBIENT_TEMPERATURE =
   1986             "android.hardware.sensor.ambient_temperature";
   1987 
   1988     /**
   1989      * Feature for {@link #getSystemAvailableFeatures} and
   1990      * {@link #hasSystemFeature}: The device supports high fidelity sensor processing
   1991      * capabilities.
   1992      */
   1993     @SdkConstant(SdkConstantType.FEATURE)
   1994     public static final String FEATURE_HIFI_SENSORS =
   1995             "android.hardware.sensor.hifi_sensors";
   1996 
   1997     /**
   1998      * Feature for {@link #getSystemAvailableFeatures} and
   1999      * {@link #hasSystemFeature}: The device has a telephony radio with data
   2000      * communication support.
   2001      */
   2002     @SdkConstant(SdkConstantType.FEATURE)
   2003     public static final String FEATURE_TELEPHONY = "android.hardware.telephony";
   2004 
   2005     /**
   2006      * Feature for {@link #getSystemAvailableFeatures} and
   2007      * {@link #hasSystemFeature}: The device has a CDMA telephony stack.
   2008      */
   2009     @SdkConstant(SdkConstantType.FEATURE)
   2010     public static final String FEATURE_TELEPHONY_CDMA = "android.hardware.telephony.cdma";
   2011 
   2012     /**
   2013      * Feature for {@link #getSystemAvailableFeatures} and
   2014      * {@link #hasSystemFeature}: The device has a GSM telephony stack.
   2015      */
   2016     @SdkConstant(SdkConstantType.FEATURE)
   2017     public static final String FEATURE_TELEPHONY_GSM = "android.hardware.telephony.gsm";
   2018 
   2019     /**
   2020      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2021      * The device supports telephony carrier restriction mechanism.
   2022      *
   2023      * <p>Devices declaring this feature must have an implementation of the
   2024      * {@link android.telephony.TelephonyManager#getAllowedCarriers} and
   2025      * {@link android.telephony.TelephonyManager#setAllowedCarriers}.
   2026      * @hide
   2027      */
   2028     @SystemApi
   2029     @SdkConstant(SdkConstantType.FEATURE)
   2030     public static final String FEATURE_TELEPHONY_CARRIERLOCK =
   2031             "android.hardware.telephony.carrierlock";
   2032 
   2033     /**
   2034      * Feature for {@link #getSystemAvailableFeatures} and
   2035      * {@link #hasSystemFeature}: The device supports connecting to USB devices
   2036      * as the USB host.
   2037      */
   2038     @SdkConstant(SdkConstantType.FEATURE)
   2039     public static final String FEATURE_USB_HOST = "android.hardware.usb.host";
   2040 
   2041     /**
   2042      * Feature for {@link #getSystemAvailableFeatures} and
   2043      * {@link #hasSystemFeature}: The device supports connecting to USB accessories.
   2044      */
   2045     @SdkConstant(SdkConstantType.FEATURE)
   2046     public static final String FEATURE_USB_ACCESSORY = "android.hardware.usb.accessory";
   2047 
   2048     /**
   2049      * Feature for {@link #getSystemAvailableFeatures} and
   2050      * {@link #hasSystemFeature}: The SIP API is enabled on the device.
   2051      */
   2052     @SdkConstant(SdkConstantType.FEATURE)
   2053     public static final String FEATURE_SIP = "android.software.sip";
   2054 
   2055     /**
   2056      * Feature for {@link #getSystemAvailableFeatures} and
   2057      * {@link #hasSystemFeature}: The device supports SIP-based VOIP.
   2058      */
   2059     @SdkConstant(SdkConstantType.FEATURE)
   2060     public static final String FEATURE_SIP_VOIP = "android.software.sip.voip";
   2061 
   2062     /**
   2063      * Feature for {@link #getSystemAvailableFeatures} and
   2064      * {@link #hasSystemFeature}: The Connection Service API is enabled on the device.
   2065      */
   2066     @SdkConstant(SdkConstantType.FEATURE)
   2067     public static final String FEATURE_CONNECTION_SERVICE = "android.software.connectionservice";
   2068 
   2069     /**
   2070      * Feature for {@link #getSystemAvailableFeatures} and
   2071      * {@link #hasSystemFeature}: The device's display has a touch screen.
   2072      */
   2073     @SdkConstant(SdkConstantType.FEATURE)
   2074     public static final String FEATURE_TOUCHSCREEN = "android.hardware.touchscreen";
   2075 
   2076     /**
   2077      * Feature for {@link #getSystemAvailableFeatures} and
   2078      * {@link #hasSystemFeature}: The device's touch screen supports
   2079      * multitouch sufficient for basic two-finger gesture detection.
   2080      */
   2081     @SdkConstant(SdkConstantType.FEATURE)
   2082     public static final String FEATURE_TOUCHSCREEN_MULTITOUCH = "android.hardware.touchscreen.multitouch";
   2083 
   2084     /**
   2085      * Feature for {@link #getSystemAvailableFeatures} and
   2086      * {@link #hasSystemFeature}: The device's touch screen is capable of
   2087      * tracking two or more fingers fully independently.
   2088      */
   2089     @SdkConstant(SdkConstantType.FEATURE)
   2090     public static final String FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT = "android.hardware.touchscreen.multitouch.distinct";
   2091 
   2092     /**
   2093      * Feature for {@link #getSystemAvailableFeatures} and
   2094      * {@link #hasSystemFeature}: The device's touch screen is capable of
   2095      * tracking a full hand of fingers fully independently -- that is, 5 or
   2096      * more simultaneous independent pointers.
   2097      */
   2098     @SdkConstant(SdkConstantType.FEATURE)
   2099     public static final String FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND = "android.hardware.touchscreen.multitouch.jazzhand";
   2100 
   2101     /**
   2102      * Feature for {@link #getSystemAvailableFeatures} and
   2103      * {@link #hasSystemFeature}: The device does not have a touch screen, but
   2104      * does support touch emulation for basic events. For instance, the
   2105      * device might use a mouse or remote control to drive a cursor, and
   2106      * emulate basic touch pointer events like down, up, drag, etc. All
   2107      * devices that support android.hardware.touchscreen or a sub-feature are
   2108      * presumed to also support faketouch.
   2109      */
   2110     @SdkConstant(SdkConstantType.FEATURE)
   2111     public static final String FEATURE_FAKETOUCH = "android.hardware.faketouch";
   2112 
   2113     /**
   2114      * Feature for {@link #getSystemAvailableFeatures} and
   2115      * {@link #hasSystemFeature}: The device does not have a touch screen, but
   2116      * does support touch emulation for basic events that supports distinct
   2117      * tracking of two or more fingers.  This is an extension of
   2118      * {@link #FEATURE_FAKETOUCH} for input devices with this capability.  Note
   2119      * that unlike a distinct multitouch screen as defined by
   2120      * {@link #FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT}, these kinds of input
   2121      * devices will not actually provide full two-finger gestures since the
   2122      * input is being transformed to cursor movement on the screen.  That is,
   2123      * single finger gestures will move a cursor; two-finger swipes will
   2124      * result in single-finger touch events; other two-finger gestures will
   2125      * result in the corresponding two-finger touch event.
   2126      */
   2127     @SdkConstant(SdkConstantType.FEATURE)
   2128     public static final String FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT = "android.hardware.faketouch.multitouch.distinct";
   2129 
   2130     /**
   2131      * Feature for {@link #getSystemAvailableFeatures} and
   2132      * {@link #hasSystemFeature}: The device does not have a touch screen, but
   2133      * does support touch emulation for basic events that supports tracking
   2134      * a hand of fingers (5 or more fingers) fully independently.
   2135      * This is an extension of
   2136      * {@link #FEATURE_FAKETOUCH} for input devices with this capability.  Note
   2137      * that unlike a multitouch screen as defined by
   2138      * {@link #FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND}, not all two finger
   2139      * gestures can be detected due to the limitations described for
   2140      * {@link #FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT}.
   2141      */
   2142     @SdkConstant(SdkConstantType.FEATURE)
   2143     public static final String FEATURE_FAKETOUCH_MULTITOUCH_JAZZHAND = "android.hardware.faketouch.multitouch.jazzhand";
   2144 
   2145     /**
   2146      * Feature for {@link #getSystemAvailableFeatures} and
   2147      * {@link #hasSystemFeature}: The device has biometric hardware to detect a fingerprint.
   2148       */
   2149     @SdkConstant(SdkConstantType.FEATURE)
   2150     public static final String FEATURE_FINGERPRINT = "android.hardware.fingerprint";
   2151 
   2152     /**
   2153      * Feature for {@link #getSystemAvailableFeatures} and
   2154      * {@link #hasSystemFeature}: The device supports portrait orientation
   2155      * screens.  For backwards compatibility, you can assume that if neither
   2156      * this nor {@link #FEATURE_SCREEN_LANDSCAPE} is set then the device supports
   2157      * both portrait and landscape.
   2158      */
   2159     @SdkConstant(SdkConstantType.FEATURE)
   2160     public static final String FEATURE_SCREEN_PORTRAIT = "android.hardware.screen.portrait";
   2161 
   2162     /**
   2163      * Feature for {@link #getSystemAvailableFeatures} and
   2164      * {@link #hasSystemFeature}: The device supports landscape orientation
   2165      * screens.  For backwards compatibility, you can assume that if neither
   2166      * this nor {@link #FEATURE_SCREEN_PORTRAIT} is set then the device supports
   2167      * both portrait and landscape.
   2168      */
   2169     @SdkConstant(SdkConstantType.FEATURE)
   2170     public static final String FEATURE_SCREEN_LANDSCAPE = "android.hardware.screen.landscape";
   2171 
   2172     /**
   2173      * Feature for {@link #getSystemAvailableFeatures} and
   2174      * {@link #hasSystemFeature}: The device supports live wallpapers.
   2175      */
   2176     @SdkConstant(SdkConstantType.FEATURE)
   2177     public static final String FEATURE_LIVE_WALLPAPER = "android.software.live_wallpaper";
   2178     /**
   2179      * Feature for {@link #getSystemAvailableFeatures} and
   2180      * {@link #hasSystemFeature}: The device supports app widgets.
   2181      */
   2182     @SdkConstant(SdkConstantType.FEATURE)
   2183     public static final String FEATURE_APP_WIDGETS = "android.software.app_widgets";
   2184 
   2185     /**
   2186      * @hide
   2187      * Feature for {@link #getSystemAvailableFeatures} and
   2188      * {@link #hasSystemFeature}: The device supports
   2189      * {@link android.service.voice.VoiceInteractionService} and
   2190      * {@link android.app.VoiceInteractor}.
   2191      */
   2192     @SdkConstant(SdkConstantType.FEATURE)
   2193     public static final String FEATURE_VOICE_RECOGNIZERS = "android.software.voice_recognizers";
   2194 
   2195 
   2196     /**
   2197      * Feature for {@link #getSystemAvailableFeatures} and
   2198      * {@link #hasSystemFeature}: The device supports a home screen that is replaceable
   2199      * by third party applications.
   2200      */
   2201     @SdkConstant(SdkConstantType.FEATURE)
   2202     public static final String FEATURE_HOME_SCREEN = "android.software.home_screen";
   2203 
   2204     /**
   2205      * Feature for {@link #getSystemAvailableFeatures} and
   2206      * {@link #hasSystemFeature}: The device supports adding new input methods implemented
   2207      * with the {@link android.inputmethodservice.InputMethodService} API.
   2208      */
   2209     @SdkConstant(SdkConstantType.FEATURE)
   2210     public static final String FEATURE_INPUT_METHODS = "android.software.input_methods";
   2211 
   2212     /**
   2213      * Feature for {@link #getSystemAvailableFeatures} and
   2214      * {@link #hasSystemFeature}: The device supports device policy enforcement via device admins.
   2215      */
   2216     @SdkConstant(SdkConstantType.FEATURE)
   2217     public static final String FEATURE_DEVICE_ADMIN = "android.software.device_admin";
   2218 
   2219     /**
   2220      * Feature for {@link #getSystemAvailableFeatures} and
   2221      * {@link #hasSystemFeature}: The device supports leanback UI. This is
   2222      * typically used in a living room television experience, but is a software
   2223      * feature unlike {@link #FEATURE_TELEVISION}. Devices running with this
   2224      * feature will use resources associated with the "television" UI mode.
   2225      */
   2226     @SdkConstant(SdkConstantType.FEATURE)
   2227     public static final String FEATURE_LEANBACK = "android.software.leanback";
   2228 
   2229     /**
   2230      * Feature for {@link #getSystemAvailableFeatures} and
   2231      * {@link #hasSystemFeature}: The device supports only leanback UI. Only
   2232      * applications designed for this experience should be run, though this is
   2233      * not enforced by the system.
   2234      */
   2235     @SdkConstant(SdkConstantType.FEATURE)
   2236     public static final String FEATURE_LEANBACK_ONLY = "android.software.leanback_only";
   2237 
   2238     /**
   2239      * Feature for {@link #getSystemAvailableFeatures} and
   2240      * {@link #hasSystemFeature}: The device supports live TV and can display
   2241      * contents from TV inputs implemented with the
   2242      * {@link android.media.tv.TvInputService} API.
   2243      */
   2244     @SdkConstant(SdkConstantType.FEATURE)
   2245     public static final String FEATURE_LIVE_TV = "android.software.live_tv";
   2246 
   2247     /**
   2248      * Feature for {@link #getSystemAvailableFeatures} and
   2249      * {@link #hasSystemFeature}: The device supports WiFi (802.11) networking.
   2250      */
   2251     @SdkConstant(SdkConstantType.FEATURE)
   2252     public static final String FEATURE_WIFI = "android.hardware.wifi";
   2253 
   2254     /**
   2255      * Feature for {@link #getSystemAvailableFeatures} and
   2256      * {@link #hasSystemFeature}: The device supports Wi-Fi Direct networking.
   2257      */
   2258     @SdkConstant(SdkConstantType.FEATURE)
   2259     public static final String FEATURE_WIFI_DIRECT = "android.hardware.wifi.direct";
   2260 
   2261     /**
   2262      * Feature for {@link #getSystemAvailableFeatures} and
   2263      * {@link #hasSystemFeature}: The device supports Wi-Fi Aware.
   2264      */
   2265     @SdkConstant(SdkConstantType.FEATURE)
   2266     public static final String FEATURE_WIFI_AWARE = "android.hardware.wifi.aware";
   2267 
   2268     /**
   2269      * Feature for {@link #getSystemAvailableFeatures} and
   2270      * {@link #hasSystemFeature}: This is a device dedicated to showing UI
   2271      * on a vehicle headunit. A headunit here is defined to be inside a
   2272      * vehicle that may or may not be moving. A headunit uses either a
   2273      * primary display in the center console and/or additional displays in
   2274      * the instrument cluster or elsewhere in the vehicle. Headunit display(s)
   2275      * have limited size and resolution. The user will likely be focused on
   2276      * driving so limiting driver distraction is a primary concern. User input
   2277      * can be a variety of hard buttons, touch, rotary controllers and even mouse-
   2278      * like interfaces.
   2279      */
   2280     @SdkConstant(SdkConstantType.FEATURE)
   2281     public static final String FEATURE_AUTOMOTIVE = "android.hardware.type.automotive";
   2282 
   2283     /**
   2284      * Feature for {@link #getSystemAvailableFeatures} and
   2285      * {@link #hasSystemFeature}: This is a device dedicated to showing UI
   2286      * on a television.  Television here is defined to be a typical living
   2287      * room television experience: displayed on a big screen, where the user
   2288      * is sitting far away from it, and the dominant form of input will be
   2289      * something like a DPAD, not through touch or mouse.
   2290      * @deprecated use {@link #FEATURE_LEANBACK} instead.
   2291      */
   2292     @Deprecated
   2293     @SdkConstant(SdkConstantType.FEATURE)
   2294     public static final String FEATURE_TELEVISION = "android.hardware.type.television";
   2295 
   2296     /**
   2297      * Feature for {@link #getSystemAvailableFeatures} and
   2298      * {@link #hasSystemFeature}: This is a device dedicated to showing UI
   2299      * on a watch. A watch here is defined to be a device worn on the body, perhaps on
   2300      * the wrist. The user is very close when interacting with the device.
   2301      */
   2302     @SdkConstant(SdkConstantType.FEATURE)
   2303     public static final String FEATURE_WATCH = "android.hardware.type.watch";
   2304 
   2305     /**
   2306      * Feature for {@link #getSystemAvailableFeatures} and
   2307      * {@link #hasSystemFeature}: This is a device for IoT and may not have an UI. An embedded
   2308      * device is defined as a full stack Android device with or without a display and no
   2309      * user-installable apps.
   2310      */
   2311     @SdkConstant(SdkConstantType.FEATURE)
   2312     public static final String FEATURE_EMBEDDED = "android.hardware.type.embedded";
   2313 
   2314     /**
   2315      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2316      * The device supports printing.
   2317      */
   2318     @SdkConstant(SdkConstantType.FEATURE)
   2319     public static final String FEATURE_PRINTING = "android.software.print";
   2320 
   2321     /**
   2322      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2323      * The device supports {@link android.companion.CompanionDeviceManager#associate associating}
   2324      * with devices via {@link android.companion.CompanionDeviceManager}.
   2325      */
   2326     @SdkConstant(SdkConstantType.FEATURE)
   2327     public static final String FEATURE_COMPANION_DEVICE_SETUP
   2328             = "android.software.companion_device_setup";
   2329 
   2330     /**
   2331      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2332      * The device can perform backup and restore operations on installed applications.
   2333      */
   2334     @SdkConstant(SdkConstantType.FEATURE)
   2335     public static final String FEATURE_BACKUP = "android.software.backup";
   2336 
   2337     /**
   2338      * Feature for {@link #getSystemAvailableFeatures} and
   2339      * {@link #hasSystemFeature}: The device supports freeform window management.
   2340      * Windows have title bars and can be moved and resized.
   2341      */
   2342     // If this feature is present, you also need to set
   2343     // com.android.internal.R.config_freeformWindowManagement to true in your configuration overlay.
   2344     @SdkConstant(SdkConstantType.FEATURE)
   2345     public static final String FEATURE_FREEFORM_WINDOW_MANAGEMENT
   2346             = "android.software.freeform_window_management";
   2347 
   2348     /**
   2349      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2350      * The device supports picture-in-picture multi-window mode.
   2351      */
   2352     @SdkConstant(SdkConstantType.FEATURE)
   2353     public static final String FEATURE_PICTURE_IN_PICTURE = "android.software.picture_in_picture";
   2354 
   2355     /**
   2356      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2357      * The device supports running activities on secondary displays.
   2358      */
   2359     @SdkConstant(SdkConstantType.FEATURE)
   2360     public static final String FEATURE_ACTIVITIES_ON_SECONDARY_DISPLAYS
   2361             = "android.software.activities_on_secondary_displays";
   2362 
   2363     /**
   2364      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2365      * The device supports creating secondary users and managed profiles via
   2366      * {@link DevicePolicyManager}.
   2367      */
   2368     @SdkConstant(SdkConstantType.FEATURE)
   2369     public static final String FEATURE_MANAGED_USERS = "android.software.managed_users";
   2370 
   2371     /**
   2372      * @hide
   2373      * TODO: Remove after dependencies updated b/17392243
   2374      */
   2375     public static final String FEATURE_MANAGED_PROFILES = "android.software.managed_users";
   2376 
   2377     /**
   2378      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2379      * The device supports verified boot.
   2380      */
   2381     @SdkConstant(SdkConstantType.FEATURE)
   2382     public static final String FEATURE_VERIFIED_BOOT = "android.software.verified_boot";
   2383 
   2384     /**
   2385      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2386      * The device supports secure removal of users. When a user is deleted the data associated
   2387      * with that user is securely deleted and no longer available.
   2388      */
   2389     @SdkConstant(SdkConstantType.FEATURE)
   2390     public static final String FEATURE_SECURELY_REMOVES_USERS
   2391             = "android.software.securely_removes_users";
   2392 
   2393     /** {@hide} */
   2394     @SdkConstant(SdkConstantType.FEATURE)
   2395     public static final String FEATURE_FILE_BASED_ENCRYPTION
   2396             = "android.software.file_based_encryption";
   2397 
   2398     /**
   2399      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2400      * The device has a full implementation of the android.webkit.* APIs. Devices
   2401      * lacking this feature will not have a functioning WebView implementation.
   2402      */
   2403     @SdkConstant(SdkConstantType.FEATURE)
   2404     public static final String FEATURE_WEBVIEW = "android.software.webview";
   2405 
   2406     /**
   2407      * Feature for {@link #getSystemAvailableFeatures} and
   2408      * {@link #hasSystemFeature}: This device supports ethernet.
   2409      */
   2410     @SdkConstant(SdkConstantType.FEATURE)
   2411     public static final String FEATURE_ETHERNET = "android.hardware.ethernet";
   2412 
   2413     /**
   2414      * Feature for {@link #getSystemAvailableFeatures} and
   2415      * {@link #hasSystemFeature}: This device supports HDMI-CEC.
   2416      * @hide
   2417      */
   2418     @SdkConstant(SdkConstantType.FEATURE)
   2419     public static final String FEATURE_HDMI_CEC = "android.hardware.hdmi.cec";
   2420 
   2421     /**
   2422      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2423      * The device has all of the inputs necessary to be considered a compatible game controller, or
   2424      * includes a compatible game controller in the box.
   2425      */
   2426     @SdkConstant(SdkConstantType.FEATURE)
   2427     public static final String FEATURE_GAMEPAD = "android.hardware.gamepad";
   2428 
   2429     /**
   2430      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2431      * The device has a full implementation of the android.media.midi.* APIs.
   2432      */
   2433     @SdkConstant(SdkConstantType.FEATURE)
   2434     public static final String FEATURE_MIDI = "android.software.midi";
   2435 
   2436     /**
   2437      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2438      * The device implements an optimized mode for virtual reality (VR) applications that handles
   2439      * stereoscopic rendering of notifications, and disables most monocular system UI components
   2440      * while a VR application has user focus.
   2441      * Devices declaring this feature must include an application implementing a
   2442      * {@link android.service.vr.VrListenerService} that can be targeted by VR applications via
   2443      * {@link android.app.Activity#setVrModeEnabled}.
   2444      */
   2445     @SdkConstant(SdkConstantType.FEATURE)
   2446     public static final String FEATURE_VR_MODE = "android.software.vr.mode";
   2447 
   2448     /**
   2449      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2450      * The device implements {@link #FEATURE_VR_MODE} but additionally meets extra CDD requirements
   2451      * to provide a high-quality VR experience.  In general, devices declaring this feature will
   2452      * additionally:
   2453      * <ul>
   2454      *   <li>Deliver consistent performance at a high framerate over an extended period of time
   2455      *   for typical VR application CPU/GPU workloads with a minimal number of frame drops for VR
   2456      *   applications that have called
   2457      *   {@link android.view.Window#setSustainedPerformanceMode}.</li>
   2458      *   <li>Implement {@link #FEATURE_HIFI_SENSORS} and have a low sensor latency.</li>
   2459      *   <li>Include optimizations to lower display persistence while running VR applications.</li>
   2460      *   <li>Implement an optimized render path to minimize latency to draw to the device's main
   2461      *   display.</li>
   2462      *   <li>Include the following EGL extensions: EGL_ANDROID_create_native_client_buffer,
   2463      *   EGL_ANDROID_front_buffer_auto_refresh, EGL_EXT_protected_content,
   2464      *   EGL_KHR_mutable_render_buffer, EGL_KHR_reusable_sync, and EGL_KHR_wait_sync.</li>
   2465      *   <li>Provide at least one CPU core that is reserved for use solely by the top, foreground
   2466      *   VR application process for critical render threads while such an application is
   2467      *   running.</li>
   2468      * </ul>
   2469      */
   2470     @SdkConstant(SdkConstantType.FEATURE)
   2471     public static final String FEATURE_VR_MODE_HIGH_PERFORMANCE
   2472             = "android.hardware.vr.high_performance";
   2473 
   2474     /**
   2475      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2476      * The device supports autofill of user credentials, addresses, credit cards, etc
   2477      * via integration with {@link android.service.autofill.AutofillService autofill
   2478      * providers}.
   2479      */
   2480     @SdkConstant(SdkConstantType.FEATURE)
   2481     public static final String FEATURE_AUTOFILL = "android.software.autofill";
   2482 
   2483     /**
   2484      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
   2485      * The device implements headtracking suitable for a VR device.
   2486      */
   2487     @SdkConstant(SdkConstantType.FEATURE)
   2488     public static final String FEATURE_VR_HEADTRACKING = "android.hardware.vr.headtracking";
   2489 
   2490     /**
   2491      * Action to external storage service to clean out removed apps.
   2492      * @hide
   2493      */
   2494     public static final String ACTION_CLEAN_EXTERNAL_STORAGE
   2495             = "android.content.pm.CLEAN_EXTERNAL_STORAGE";
   2496 
   2497     /**
   2498      * Extra field name for the URI to a verification file. Passed to a package
   2499      * verifier.
   2500      *
   2501      * @hide
   2502      */
   2503     public static final String EXTRA_VERIFICATION_URI = "android.content.pm.extra.VERIFICATION_URI";
   2504 
   2505     /**
   2506      * Extra field name for the ID of a package pending verification. Passed to
   2507      * a package verifier and is used to call back to
   2508      * {@link PackageManager#verifyPendingInstall(int, int)}
   2509      */
   2510     public static final String EXTRA_VERIFICATION_ID = "android.content.pm.extra.VERIFICATION_ID";
   2511 
   2512     /**
   2513      * Extra field name for the package identifier which is trying to install
   2514      * the package.
   2515      *
   2516      * @hide
   2517      */
   2518     public static final String EXTRA_VERIFICATION_INSTALLER_PACKAGE
   2519             = "android.content.pm.extra.VERIFICATION_INSTALLER_PACKAGE";
   2520 
   2521     /**
   2522      * Extra field name for the requested install flags for a package pending
   2523      * verification. Passed to a package verifier.
   2524      *
   2525      * @hide
   2526      */
   2527     public static final String EXTRA_VERIFICATION_INSTALL_FLAGS
   2528             = "android.content.pm.extra.VERIFICATION_INSTALL_FLAGS";
   2529 
   2530     /**
   2531      * Extra field name for the uid of who is requesting to install
   2532      * the package.
   2533      *
   2534      * @hide
   2535      */
   2536     public static final String EXTRA_VERIFICATION_INSTALLER_UID
   2537             = "android.content.pm.extra.VERIFICATION_INSTALLER_UID";
   2538 
   2539     /**
   2540      * Extra field name for the package name of a package pending verification.
   2541      *
   2542      * @hide
   2543      */
   2544     public static final String EXTRA_VERIFICATION_PACKAGE_NAME
   2545             = "android.content.pm.extra.VERIFICATION_PACKAGE_NAME";
   2546     /**
   2547      * Extra field name for the result of a verification, either
   2548      * {@link #VERIFICATION_ALLOW}, or {@link #VERIFICATION_REJECT}.
   2549      * Passed to package verifiers after a package is verified.
   2550      */
   2551     public static final String EXTRA_VERIFICATION_RESULT
   2552             = "android.content.pm.extra.VERIFICATION_RESULT";
   2553 
   2554     /**
   2555      * Extra field name for the version code of a package pending verification.
   2556      *
   2557      * @hide
   2558      */
   2559     public static final String EXTRA_VERIFICATION_VERSION_CODE
   2560             = "android.content.pm.extra.VERIFICATION_VERSION_CODE";
   2561 
   2562     /**
   2563      * Extra field name for the ID of a intent filter pending verification.
   2564      * Passed to an intent filter verifier and is used to call back to
   2565      * {@link #verifyIntentFilter}
   2566      *
   2567      * @hide
   2568      */
   2569     public static final String EXTRA_INTENT_FILTER_VERIFICATION_ID
   2570             = "android.content.pm.extra.INTENT_FILTER_VERIFICATION_ID";
   2571 
   2572     /**
   2573      * Extra field name for the scheme used for an intent filter pending verification. Passed to
   2574      * an intent filter verifier and is used to construct the URI to verify against.
   2575      *
   2576      * Usually this is "https"
   2577      *
   2578      * @hide
   2579      */
   2580     public static final String EXTRA_INTENT_FILTER_VERIFICATION_URI_SCHEME
   2581             = "android.content.pm.extra.INTENT_FILTER_VERIFICATION_URI_SCHEME";
   2582 
   2583     /**
   2584      * Extra field name for the host names to be used for an intent filter pending verification.
   2585      * Passed to an intent filter verifier and is used to construct the URI to verify the
   2586      * intent filter.
   2587      *
   2588      * This is a space delimited list of hosts.
   2589      *
   2590      * @hide
   2591      */
   2592     public static final String EXTRA_INTENT_FILTER_VERIFICATION_HOSTS
   2593             = "android.content.pm.extra.INTENT_FILTER_VERIFICATION_HOSTS";
   2594 
   2595     /**
   2596      * Extra field name for the package name to be used for an intent filter pending verification.
   2597      * Passed to an intent filter verifier and is used to check the verification responses coming
   2598      * from the hosts. Each host response will need to include the package name of APK containing
   2599      * the intent filter.
   2600      *
   2601      * @hide
   2602      */
   2603     public static final String EXTRA_INTENT_FILTER_VERIFICATION_PACKAGE_NAME
   2604             = "android.content.pm.extra.INTENT_FILTER_VERIFICATION_PACKAGE_NAME";
   2605 
   2606     /**
   2607      * The action used to request that the user approve a permission request
   2608      * from the application.
   2609      *
   2610      * @hide
   2611      */
   2612     @SystemApi
   2613     public static final String ACTION_REQUEST_PERMISSIONS =
   2614             "android.content.pm.action.REQUEST_PERMISSIONS";
   2615 
   2616     /**
   2617      * The names of the requested permissions.
   2618      * <p>
   2619      * <strong>Type:</strong> String[]
   2620      * </p>
   2621      *
   2622      * @hide
   2623      */
   2624     @SystemApi
   2625     public static final String EXTRA_REQUEST_PERMISSIONS_NAMES =
   2626             "android.content.pm.extra.REQUEST_PERMISSIONS_NAMES";
   2627 
   2628     /**
   2629      * The results from the permissions request.
   2630      * <p>
   2631      * <strong>Type:</strong> int[] of #PermissionResult
   2632      * </p>
   2633      *
   2634      * @hide
   2635      */
   2636     @SystemApi
   2637     public static final String EXTRA_REQUEST_PERMISSIONS_RESULTS
   2638             = "android.content.pm.extra.REQUEST_PERMISSIONS_RESULTS";
   2639 
   2640     /**
   2641      * String extra for {@link PackageInstallObserver} in the 'extras' Bundle in case of
   2642      * {@link #INSTALL_FAILED_DUPLICATE_PERMISSION}.  This extra names the package which provides
   2643      * the existing definition for the permission.
   2644      * @hide
   2645      */
   2646     public static final String EXTRA_FAILURE_EXISTING_PACKAGE
   2647             = "android.content.pm.extra.FAILURE_EXISTING_PACKAGE";
   2648 
   2649     /**
   2650      * String extra for {@link PackageInstallObserver} in the 'extras' Bundle in case of
   2651      * {@link #INSTALL_FAILED_DUPLICATE_PERMISSION}.  This extra names the permission that is
   2652      * being redundantly defined by the package being installed.
   2653      * @hide
   2654      */
   2655     public static final String EXTRA_FAILURE_EXISTING_PERMISSION
   2656             = "android.content.pm.extra.FAILURE_EXISTING_PERMISSION";
   2657 
   2658    /**
   2659     * Permission flag: The permission is set in its current state
   2660     * by the user and apps can still request it at runtime.
   2661     *
   2662     * @hide
   2663     */
   2664     @SystemApi
   2665     public static final int FLAG_PERMISSION_USER_SET = 1 << 0;
   2666 
   2667     /**
   2668      * Permission flag: The permission is set in its current state
   2669      * by the user and it is fixed, i.e. apps can no longer request
   2670      * this permission.
   2671      *
   2672      * @hide
   2673      */
   2674     @SystemApi
   2675     public static final int FLAG_PERMISSION_USER_FIXED =  1 << 1;
   2676 
   2677     /**
   2678      * Permission flag: The permission is set in its current state
   2679      * by device policy and neither apps nor the user can change
   2680      * its state.
   2681      *
   2682      * @hide
   2683      */
   2684     @SystemApi
   2685     public static final int FLAG_PERMISSION_POLICY_FIXED =  1 << 2;
   2686 
   2687     /**
   2688      * Permission flag: The permission is set in a granted state but
   2689      * access to resources it guards is restricted by other means to
   2690      * enable revoking a permission on legacy apps that do not support
   2691      * runtime permissions. If this permission is upgraded to runtime
   2692      * because the app was updated to support runtime permissions, the
   2693      * the permission will be revoked in the upgrade process.
   2694      *
   2695      * @hide
   2696      */
   2697     @SystemApi
   2698     public static final int FLAG_PERMISSION_REVOKE_ON_UPGRADE =  1 << 3;
   2699 
   2700     /**
   2701      * Permission flag: The permission is set in its current state
   2702      * because the app is a component that is a part of the system.
   2703      *
   2704      * @hide
   2705      */
   2706     @SystemApi
   2707     public static final int FLAG_PERMISSION_SYSTEM_FIXED =  1 << 4;
   2708 
   2709     /**
   2710      * Permission flag: The permission is granted by default because it
   2711      * enables app functionality that is expected to work out-of-the-box
   2712      * for providing a smooth user experience. For example, the phone app
   2713      * is expected to have the phone permission.
   2714      *
   2715      * @hide
   2716      */
   2717     @SystemApi
   2718     public static final int FLAG_PERMISSION_GRANTED_BY_DEFAULT =  1 << 5;
   2719 
   2720     /**
   2721      * Permission flag: The permission has to be reviewed before any of
   2722      * the app components can run.
   2723      *
   2724      * @hide
   2725      */
   2726     @SystemApi
   2727     public static final int FLAG_PERMISSION_REVIEW_REQUIRED =  1 << 6;
   2728 
   2729     /**
   2730      * Mask for all permission flags.
   2731      *
   2732      * @hide
   2733      */
   2734     @SystemApi
   2735     public static final int MASK_PERMISSION_FLAGS = 0xFF;
   2736 
   2737     /**
   2738      * This is a library that contains components apps can invoke. For
   2739      * example, a services for apps to bind to, or standard chooser UI,
   2740      * etc. This library is versioned and backwards compatible. Clients
   2741      * should check its version via {@link android.ext.services.Version
   2742      * #getVersionCode()} and avoid calling APIs added in later versions.
   2743      *
   2744      * @hide
   2745      */
   2746     public static final String SYSTEM_SHARED_LIBRARY_SERVICES = "android.ext.services";
   2747 
   2748     /**
   2749      * This is a library that contains components apps can dynamically
   2750      * load. For example, new widgets, helper classes, etc. This library
   2751      * is versioned and backwards compatible. Clients should check its
   2752      * version via {@link android.ext.shared.Version#getVersionCode()}
   2753      * and avoid calling APIs added in later versions.
   2754      *
   2755      * @hide
   2756      */
   2757     public static final String SYSTEM_SHARED_LIBRARY_SHARED = "android.ext.shared";
   2758 
   2759     /**
   2760      * Used when starting a process for an Activity.
   2761      *
   2762      * @hide
   2763      */
   2764     public static final int NOTIFY_PACKAGE_USE_ACTIVITY = 0;
   2765 
   2766     /**
   2767      * Used when starting a process for a Service.
   2768      *
   2769      * @hide
   2770      */
   2771     public static final int NOTIFY_PACKAGE_USE_SERVICE = 1;
   2772 
   2773     /**
   2774      * Used when moving a Service to the foreground.
   2775      *
   2776      * @hide
   2777      */
   2778     public static final int NOTIFY_PACKAGE_USE_FOREGROUND_SERVICE = 2;
   2779 
   2780     /**
   2781      * Used when starting a process for a BroadcastReceiver.
   2782      *
   2783      * @hide
   2784      */
   2785     public static final int NOTIFY_PACKAGE_USE_BROADCAST_RECEIVER = 3;
   2786 
   2787     /**
   2788      * Used when starting a process for a ContentProvider.
   2789      *
   2790      * @hide
   2791      */
   2792     public static final int NOTIFY_PACKAGE_USE_CONTENT_PROVIDER = 4;
   2793 
   2794     /**
   2795      * Used when starting a process for a BroadcastReceiver.
   2796      *
   2797      * @hide
   2798      */
   2799     public static final int NOTIFY_PACKAGE_USE_BACKUP = 5;
   2800 
   2801     /**
   2802      * Used with Context.getClassLoader() across Android packages.
   2803      *
   2804      * @hide
   2805      */
   2806     public static final int NOTIFY_PACKAGE_USE_CROSS_PACKAGE = 6;
   2807 
   2808     /**
   2809      * Used when starting a package within a process for Instrumentation.
   2810      *
   2811      * @hide
   2812      */
   2813     public static final int NOTIFY_PACKAGE_USE_INSTRUMENTATION = 7;
   2814 
   2815     /**
   2816      * Total number of usage reasons.
   2817      *
   2818      * @hide
   2819      */
   2820     public static final int NOTIFY_PACKAGE_USE_REASONS_COUNT = 8;
   2821 
   2822     /**
   2823      * Constant for specifying the highest installed package version code.
   2824      */
   2825     public static final int VERSION_CODE_HIGHEST = -1;
   2826 
   2827     /**
   2828      * Retrieve overall information about an application package that is
   2829      * installed on the system.
   2830      *
   2831      * @param packageName The full name (i.e. com.google.apps.contacts) of the
   2832      *            desired package.
   2833      * @param flags Additional option flags to modify the data returned.
   2834      * @return A PackageInfo object containing information about the package. If
   2835      *         flag {@code MATCH_UNINSTALLED_PACKAGES} is set and if the package
   2836      *         is not found in the list of installed applications, the package
   2837      *         information is retrieved from the list of uninstalled
   2838      *         applications (which includes installed applications as well as
   2839      *         applications with data directory i.e. applications which had been
   2840      *         deleted with {@code DONT_DELETE_DATA} flag set).
   2841      * @throws NameNotFoundException if a package with the given name cannot be
   2842      *             found on the system.
   2843      */
   2844     public abstract PackageInfo getPackageInfo(String packageName, @PackageInfoFlags int flags)
   2845             throws NameNotFoundException;
   2846 
   2847     /**
   2848      * Retrieve overall information about an application package that is
   2849      * installed on the system. This method can be used for retrieving
   2850      * information about packages for which multiple versions can be installed
   2851      * at the time. Currently only packages hosting static shared libraries can
   2852      * have multiple installed versions. The method can also be used to get info
   2853      * for a package that has a single version installed by passing
   2854      * {@link #VERSION_CODE_HIGHEST} in the {@link VersionedPackage}
   2855      * constructor.
   2856      *
   2857      * @param versionedPackage The versioned package for which to query.
   2858      * @param flags Additional option flags to modify the data returned.
   2859      * @return A PackageInfo object containing information about the package. If
   2860      *         flag {@code MATCH_UNINSTALLED_PACKAGES} is set and if the package
   2861      *         is not found in the list of installed applications, the package
   2862      *         information is retrieved from the list of uninstalled
   2863      *         applications (which includes installed applications as well as
   2864      *         applications with data directory i.e. applications which had been
   2865      *         deleted with {@code DONT_DELETE_DATA} flag set).
   2866      * @throws NameNotFoundException if a package with the given name cannot be
   2867      *             found on the system.
   2868      */
   2869     public abstract PackageInfo getPackageInfo(VersionedPackage versionedPackage,
   2870             @PackageInfoFlags int flags) throws NameNotFoundException;
   2871 
   2872     /**
   2873      * Retrieve overall information about an application package that is
   2874      * installed on the system.
   2875      *
   2876      * @param packageName The full name (i.e. com.google.apps.contacts) of the
   2877      *            desired package.
   2878      * @param flags Additional option flags to modify the data returned.
   2879      * @param userId The user id.
   2880      * @return A PackageInfo object containing information about the package. If
   2881      *         flag {@code MATCH_UNINSTALLED_PACKAGES} is set and if the package
   2882      *         is not found in the list of installed applications, the package
   2883      *         information is retrieved from the list of uninstalled
   2884      *         applications (which includes installed applications as well as
   2885      *         applications with data directory i.e. applications which had been
   2886      *         deleted with {@code DONT_DELETE_DATA} flag set).
   2887      * @throws NameNotFoundException if a package with the given name cannot be
   2888      *             found on the system.
   2889      * @hide
   2890      */
   2891     @RequiresPermission(Manifest.permission.INTERACT_ACROSS_USERS)
   2892     public abstract PackageInfo getPackageInfoAsUser(String packageName,
   2893             @PackageInfoFlags int flags, @UserIdInt int userId) throws NameNotFoundException;
   2894 
   2895     /**
   2896      * Map from the current package names in use on the device to whatever
   2897      * the current canonical name of that package is.
   2898      * @param names Array of current names to be mapped.
   2899      * @return Returns an array of the same size as the original, containing
   2900      * the canonical name for each package.
   2901      */
   2902     public abstract String[] currentToCanonicalPackageNames(String[] names);
   2903 
   2904     /**
   2905      * Map from a packages canonical name to the current name in use on the device.
   2906      * @param names Array of new names to be mapped.
   2907      * @return Returns an array of the same size as the original, containing
   2908      * the current name for each package.
   2909      */
   2910     public abstract String[] canonicalToCurrentPackageNames(String[] names);
   2911 
   2912     /**
   2913      * Returns a "good" intent to launch a front-door activity in a package.
   2914      * This is used, for example, to implement an "open" button when browsing
   2915      * through packages.  The current implementation looks first for a main
   2916      * activity in the category {@link Intent#CATEGORY_INFO}, and next for a
   2917      * main activity in the category {@link Intent#CATEGORY_LAUNCHER}. Returns
   2918      * <code>null</code> if neither are found.
   2919      *
   2920      * @param packageName The name of the package to inspect.
   2921      *
   2922      * @return A fully-qualified {@link Intent} that can be used to launch the
   2923      * main activity in the package. Returns <code>null</code> if the package
   2924      * does not contain such an activity, or if <em>packageName</em> is not
   2925      * recognized.
   2926      */
   2927     public abstract @Nullable Intent getLaunchIntentForPackage(@NonNull String packageName);
   2928 
   2929     /**
   2930      * Return a "good" intent to launch a front-door Leanback activity in a
   2931      * package, for use for example to implement an "open" button when browsing
   2932      * through packages. The current implementation will look for a main
   2933      * activity in the category {@link Intent#CATEGORY_LEANBACK_LAUNCHER}, or
   2934      * return null if no main leanback activities are found.
   2935      *
   2936      * @param packageName The name of the package to inspect.
   2937      * @return Returns either a fully-qualified Intent that can be used to launch
   2938      *         the main Leanback activity in the package, or null if the package
   2939      *         does not contain such an activity.
   2940      */
   2941     public abstract @Nullable Intent getLeanbackLaunchIntentForPackage(@NonNull String packageName);
   2942 
   2943     /**
   2944      * Return an array of all of the POSIX secondary group IDs that have been
   2945      * assigned to the given package.
   2946      * <p>
   2947      * Note that the same package may have different GIDs under different
   2948      * {@link UserHandle} on the same device.
   2949      *
   2950      * @param packageName The full name (i.e. com.google.apps.contacts) of the
   2951      *            desired package.
   2952      * @return Returns an int array of the assigned GIDs, or null if there are
   2953      *         none.
   2954      * @throws NameNotFoundException if a package with the given name cannot be
   2955      *             found on the system.
   2956      */
   2957     public abstract int[] getPackageGids(@NonNull String packageName)
   2958             throws NameNotFoundException;
   2959 
   2960     /**
   2961      * Return an array of all of the POSIX secondary group IDs that have been
   2962      * assigned to the given package.
   2963      * <p>
   2964      * Note that the same package may have different GIDs under different
   2965      * {@link UserHandle} on the same device.
   2966      *
   2967      * @param packageName The full name (i.e. com.google.apps.contacts) of the
   2968      *            desired package.
   2969      * @return Returns an int array of the assigned gids, or null if there are
   2970      *         none.
   2971      * @throws NameNotFoundException if a package with the given name cannot be
   2972      *             found on the system.
   2973      */
   2974     public abstract int[] getPackageGids(String packageName, @PackageInfoFlags int flags)
   2975             throws NameNotFoundException;
   2976 
   2977     /**
   2978      * Return the UID associated with the given package name.
   2979      * <p>
   2980      * Note that the same package will have different UIDs under different
   2981      * {@link UserHandle} on the same device.
   2982      *
   2983      * @param packageName The full name (i.e. com.google.apps.contacts) of the
   2984      *            desired package.
   2985      * @return Returns an integer UID who owns the given package name.
   2986      * @throws NameNotFoundException if a package with the given name can not be
   2987      *             found on the system.
   2988      */
   2989     public abstract int getPackageUid(String packageName, @PackageInfoFlags int flags)
   2990             throws NameNotFoundException;
   2991 
   2992     /**
   2993      * Return the UID associated with the given package name.
   2994      * <p>
   2995      * Note that the same package will have different UIDs under different
   2996      * {@link UserHandle} on the same device.
   2997      *
   2998      * @param packageName The full name (i.e. com.google.apps.contacts) of the
   2999      *            desired package.
   3000      * @param userId The user handle identifier to look up the package under.
   3001      * @return Returns an integer UID who owns the given package name.
   3002      * @throws NameNotFoundException if a package with the given name can not be
   3003      *             found on the system.
   3004      * @hide
   3005      */
   3006     public abstract int getPackageUidAsUser(String packageName, @UserIdInt int userId)
   3007             throws NameNotFoundException;
   3008 
   3009     /**
   3010      * Return the UID associated with the given package name.
   3011      * <p>
   3012      * Note that the same package will have different UIDs under different
   3013      * {@link UserHandle} on the same device.
   3014      *
   3015      * @param packageName The full name (i.e. com.google.apps.contacts) of the
   3016      *            desired package.
   3017      * @param userId The user handle identifier to look up the package under.
   3018      * @return Returns an integer UID who owns the given package name.
   3019      * @throws NameNotFoundException if a package with the given name can not be
   3020      *             found on the system.
   3021      * @hide
   3022      */
   3023     public abstract int getPackageUidAsUser(String packageName, @PackageInfoFlags int flags,
   3024             @UserIdInt int userId) throws NameNotFoundException;
   3025 
   3026     /**
   3027      * Retrieve all of the information we know about a particular permission.
   3028      *
   3029      * @param name The fully qualified name (i.e. com.google.permission.LOGIN)
   3030      *            of the permission you are interested in.
   3031      * @param flags Additional option flags to modify the data returned.
   3032      * @return Returns a {@link PermissionInfo} containing information about the
   3033      *         permission.
   3034      * @throws NameNotFoundException if a package with the given name cannot be
   3035      *             found on the system.
   3036      */
   3037     public abstract PermissionInfo getPermissionInfo(String name, @PermissionInfoFlags int flags)
   3038             throws NameNotFoundException;
   3039 
   3040     /**
   3041      * Query for all of the permissions associated with a particular group.
   3042      *
   3043      * @param group The fully qualified name (i.e. com.google.permission.LOGIN)
   3044      *            of the permission group you are interested in. Use null to
   3045      *            find all of the permissions not associated with a group.
   3046      * @param flags Additional option flags to modify the data returned.
   3047      * @return Returns a list of {@link PermissionInfo} containing information
   3048      *         about all of the permissions in the given group.
   3049      * @throws NameNotFoundException if a package with the given name cannot be
   3050      *             found on the system.
   3051      */
   3052     public abstract List<PermissionInfo> queryPermissionsByGroup(String group,
   3053             @PermissionInfoFlags int flags) throws NameNotFoundException;
   3054 
   3055     /**
   3056      * Returns true if Permission Review Mode is enabled, false otherwise.
   3057      *
   3058      * @hide
   3059      */
   3060     @TestApi
   3061     public abstract boolean isPermissionReviewModeEnabled();
   3062 
   3063     /**
   3064      * Retrieve all of the information we know about a particular group of
   3065      * permissions.
   3066      *
   3067      * @param name The fully qualified name (i.e.
   3068      *            com.google.permission_group.APPS) of the permission you are
   3069      *            interested in.
   3070      * @param flags Additional option flags to modify the data returned.
   3071      * @return Returns a {@link PermissionGroupInfo} containing information
   3072      *         about the permission.
   3073      * @throws NameNotFoundException if a package with the given name cannot be
   3074      *             found on the system.
   3075      */
   3076     public abstract PermissionGroupInfo getPermissionGroupInfo(String name,
   3077             @PermissionGroupInfoFlags int flags) throws NameNotFoundException;
   3078 
   3079     /**
   3080      * Retrieve all of the known permission groups in the system.
   3081      *
   3082      * @param flags Additional option flags to modify the data returned.
   3083      * @return Returns a list of {@link PermissionGroupInfo} containing
   3084      *         information about all of the known permission groups.
   3085      */
   3086     public abstract List<PermissionGroupInfo> getAllPermissionGroups(
   3087             @PermissionGroupInfoFlags int flags);
   3088 
   3089     /**
   3090      * Retrieve all of the information we know about a particular
   3091      * package/application.
   3092      *
   3093      * @param packageName The full name (i.e. com.google.apps.contacts) of an
   3094      *            application.
   3095      * @param flags Additional option flags to modify the data returned.
   3096      * @return An {@link ApplicationInfo} containing information about the
   3097      *         package. If flag {@code MATCH_UNINSTALLED_PACKAGES} is set and if
   3098      *         the package is not found in the list of installed applications,
   3099      *         the application information is retrieved from the list of
   3100      *         uninstalled applications (which includes installed applications
   3101      *         as well as applications with data directory i.e. applications
   3102      *         which had been deleted with {@code DONT_DELETE_DATA} flag set).
   3103      * @throws NameNotFoundException if a package with the given name cannot be
   3104      *             found on the system.
   3105      */
   3106     public abstract ApplicationInfo getApplicationInfo(String packageName,
   3107             @ApplicationInfoFlags int flags) throws NameNotFoundException;
   3108 
   3109     /** {@hide} */
   3110     public abstract ApplicationInfo getApplicationInfoAsUser(String packageName,
   3111             @ApplicationInfoFlags int flags, @UserIdInt int userId) throws NameNotFoundException;
   3112 
   3113     /**
   3114      * Retrieve all of the information we know about a particular activity
   3115      * class.
   3116      *
   3117      * @param component The full component name (i.e.
   3118      *            com.google.apps.contacts/com.google.apps.contacts.
   3119      *            ContactsList) of an Activity class.
   3120      * @param flags Additional option flags to modify the data returned.
   3121      * @return An {@link ActivityInfo} containing information about the
   3122      *         activity.
   3123      * @throws NameNotFoundException if a package with the given name cannot be
   3124      *             found on the system.
   3125      */
   3126     public abstract ActivityInfo getActivityInfo(ComponentName component,
   3127             @ComponentInfoFlags int flags) throws NameNotFoundException;
   3128 
   3129     /**
   3130      * Retrieve all of the information we know about a particular receiver
   3131      * class.
   3132      *
   3133      * @param component The full component name (i.e.
   3134      *            com.google.apps.calendar/com.google.apps.calendar.
   3135      *            CalendarAlarm) of a Receiver class.
   3136      * @param flags Additional option flags to modify the data returned.
   3137      * @return An {@link ActivityInfo} containing information about the
   3138      *         receiver.
   3139      * @throws NameNotFoundException if a package with the given name cannot be
   3140      *             found on the system.
   3141      */
   3142     public abstract ActivityInfo getReceiverInfo(ComponentName component,
   3143             @ComponentInfoFlags int flags) throws NameNotFoundException;
   3144 
   3145     /**
   3146      * Retrieve all of the information we know about a particular service class.
   3147      *
   3148      * @param component The full component name (i.e.
   3149      *            com.google.apps.media/com.google.apps.media.
   3150      *            BackgroundPlayback) of a Service class.
   3151      * @param flags Additional option flags to modify the data returned.
   3152      * @return A {@link ServiceInfo} object containing information about the
   3153      *         service.
   3154      * @throws NameNotFoundException if a package with the given name cannot be
   3155      *             found on the system.
   3156      */
   3157     public abstract ServiceInfo getServiceInfo(ComponentName component,
   3158             @ComponentInfoFlags int flags) throws NameNotFoundException;
   3159 
   3160     /**
   3161      * Retrieve all of the information we know about a particular content
   3162      * provider class.
   3163      *
   3164      * @param component The full component name (i.e.
   3165      *            com.google.providers.media/com.google.providers.media.
   3166      *            MediaProvider) of a ContentProvider class.
   3167      * @param flags Additional option flags to modify the data returned.
   3168      * @return A {@link ProviderInfo} object containing information about the
   3169      *         provider.
   3170      * @throws NameNotFoundException if a package with the given name cannot be
   3171      *             found on the system.
   3172      */
   3173     public abstract ProviderInfo getProviderInfo(ComponentName component,
   3174             @ComponentInfoFlags int flags) throws NameNotFoundException;
   3175 
   3176     /**
   3177      * Return a List of all packages that are installed on the device.
   3178      *
   3179      * @param flags Additional option flags to modify the data returned.
   3180      * @return A List of PackageInfo objects, one for each installed package,
   3181      *         containing information about the package. In the unlikely case
   3182      *         there are no installed packages, an empty list is returned. If
   3183      *         flag {@code MATCH_UNINSTALLED_PACKAGES} is set, the package
   3184      *         information is retrieved from the list of uninstalled
   3185      *         applications (which includes installed applications as well as
   3186      *         applications with data directory i.e. applications which had been
   3187      *         deleted with {@code DONT_DELETE_DATA} flag set).
   3188      */
   3189     public abstract List<PackageInfo> getInstalledPackages(@PackageInfoFlags int flags);
   3190 
   3191     /**
   3192      * Return a List of all installed packages that are currently holding any of
   3193      * the given permissions.
   3194      *
   3195      * @param flags Additional option flags to modify the data returned.
   3196      * @return A List of PackageInfo objects, one for each installed package
   3197      *         that holds any of the permissions that were provided, containing
   3198      *         information about the package. If no installed packages hold any
   3199      *         of the permissions, an empty list is returned. If flag
   3200      *         {@code MATCH_UNINSTALLED_PACKAGES} is set, the package
   3201      *         information is retrieved from the list of uninstalled
   3202      *         applications (which includes installed applications as well as
   3203      *         applications with data directory i.e. applications which had been
   3204      *         deleted with {@code DONT_DELETE_DATA} flag set).
   3205      */
   3206     public abstract List<PackageInfo> getPackagesHoldingPermissions(
   3207             String[] permissions, @PackageInfoFlags int flags);
   3208 
   3209     /**
   3210      * Return a List of all packages that are installed on the device, for a
   3211      * specific user.
   3212      *
   3213      * @param flags Additional option flags to modify the data returned.
   3214      * @param userId The user for whom the installed packages are to be listed
   3215      * @return A List of PackageInfo objects, one for each installed package,
   3216      *         containing information about the package. In the unlikely case
   3217      *         there are no installed packages, an empty list is returned. If
   3218      *         flag {@code MATCH_UNINSTALLED_PACKAGES} is set, the package
   3219      *         information is retrieved from the list of uninstalled
   3220      *         applications (which includes installed applications as well as
   3221      *         applications with data directory i.e. applications which had been
   3222      *         deleted with {@code DONT_DELETE_DATA} flag set).
   3223      * @hide
   3224      */
   3225     @SystemApi
   3226     @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
   3227     public abstract List<PackageInfo> getInstalledPackagesAsUser(@PackageInfoFlags int flags,
   3228             @UserIdInt int userId);
   3229 
   3230     /**
   3231      * Check whether a particular package has been granted a particular
   3232      * permission.
   3233      *
   3234      * @param permName The name of the permission you are checking for.
   3235      * @param pkgName The name of the package you are checking against.
   3236      *
   3237      * @return If the package has the permission, PERMISSION_GRANTED is
   3238      * returned.  If it does not have the permission, PERMISSION_DENIED
   3239      * is returned.
   3240      *
   3241      * @see #PERMISSION_GRANTED
   3242      * @see #PERMISSION_DENIED
   3243      */
   3244     @CheckResult
   3245     public abstract @PermissionResult int checkPermission(String permName, String pkgName);
   3246 
   3247     /**
   3248      * Checks whether a particular permissions has been revoked for a
   3249      * package by policy. Typically the device owner or the profile owner
   3250      * may apply such a policy. The user cannot grant policy revoked
   3251      * permissions, hence the only way for an app to get such a permission
   3252      * is by a policy change.
   3253      *
   3254      * @param permName The name of the permission you are checking for.
   3255      * @param pkgName The name of the package you are checking against.
   3256      *
   3257      * @return Whether the permission is restricted by policy.
   3258      */
   3259     @CheckResult
   3260     public abstract boolean isPermissionRevokedByPolicy(@NonNull String permName,
   3261             @NonNull String pkgName);
   3262 
   3263     /**
   3264      * Gets the package name of the component controlling runtime permissions.
   3265      *
   3266      * @return The package name.
   3267      *
   3268      * @hide
   3269      */
   3270     public abstract String getPermissionControllerPackageName();
   3271 
   3272     /**
   3273      * Add a new dynamic permission to the system.  For this to work, your
   3274      * package must have defined a permission tree through the
   3275      * {@link android.R.styleable#AndroidManifestPermissionTree
   3276      * &lt;permission-tree&gt;} tag in its manifest.  A package can only add
   3277      * permissions to trees that were defined by either its own package or
   3278      * another with the same user id; a permission is in a tree if it
   3279      * matches the name of the permission tree + ".": for example,
   3280      * "com.foo.bar" is a member of the permission tree "com.foo".
   3281      *
   3282      * <p>It is good to make your permission tree name descriptive, because you
   3283      * are taking possession of that entire set of permission names.  Thus, it
   3284      * must be under a domain you control, with a suffix that will not match
   3285      * any normal permissions that may be declared in any applications that
   3286      * are part of that domain.
   3287      *
   3288      * <p>New permissions must be added before
   3289      * any .apks are installed that use those permissions.  Permissions you
   3290      * add through this method are remembered across reboots of the device.
   3291      * If the given permission already exists, the info you supply here
   3292      * will be used to update it.
   3293      *
   3294      * @param info Description of the permission to be added.
   3295      *
   3296      * @return Returns true if a new permission was created, false if an
   3297      * existing one was updated.
   3298      *
   3299      * @throws SecurityException if you are not allowed to add the
   3300      * given permission name.
   3301      *
   3302      * @see #removePermission(String)
   3303      */
   3304     public abstract boolean addPermission(PermissionInfo info);
   3305 
   3306     /**
   3307      * Like {@link #addPermission(PermissionInfo)} but asynchronously
   3308      * persists the package manager state after returning from the call,
   3309      * allowing it to return quicker and batch a series of adds at the
   3310      * expense of no guarantee the added permission will be retained if
   3311      * the device is rebooted before it is written.
   3312      */
   3313     public abstract boolean addPermissionAsync(PermissionInfo info);
   3314 
   3315     /**
   3316      * Removes a permission that was previously added with
   3317      * {@link #addPermission(PermissionInfo)}.  The same ownership rules apply
   3318      * -- you are only allowed to remove permissions that you are allowed
   3319      * to add.
   3320      *
   3321      * @param name The name of the permission to remove.
   3322      *
   3323      * @throws SecurityException if you are not allowed to remove the
   3324      * given permission name.
   3325      *
   3326      * @see #addPermission(PermissionInfo)
   3327      */
   3328     public abstract void removePermission(String name);
   3329 
   3330     /**
   3331      * Permission flags set when granting or revoking a permission.
   3332      *
   3333      * @hide
   3334      */
   3335     @SystemApi
   3336     @IntDef(prefix = { "FLAG_PERMISSION_" }, value = {
   3337             FLAG_PERMISSION_USER_SET,
   3338             FLAG_PERMISSION_USER_FIXED,
   3339             FLAG_PERMISSION_POLICY_FIXED,
   3340             FLAG_PERMISSION_REVOKE_ON_UPGRADE,
   3341             FLAG_PERMISSION_SYSTEM_FIXED,
   3342             FLAG_PERMISSION_GRANTED_BY_DEFAULT
   3343     })
   3344     @Retention(RetentionPolicy.SOURCE)
   3345     public @interface PermissionFlags {}
   3346 
   3347     /**
   3348      * Grant a runtime permission to an application which the application does not
   3349      * already have. The permission must have been requested by the application.
   3350      * If the application is not allowed to hold the permission, a {@link
   3351      * java.lang.SecurityException} is thrown. If the package or permission is
   3352      * invalid, a {@link java.lang.IllegalArgumentException} is thrown.
   3353      * <p>
   3354      * <strong>Note: </strong>Using this API requires holding
   3355      * android.permission.GRANT_RUNTIME_PERMISSIONS and if the user id is
   3356      * not the current user android.permission.INTERACT_ACROSS_USERS_FULL.
   3357      * </p>
   3358      *
   3359      * @param packageName The package to which to grant the permission.
   3360      * @param permissionName The permission name to grant.
   3361      * @param user The user for which to grant the permission.
   3362      *
   3363      * @see #revokeRuntimePermission(String, String, android.os.UserHandle)
   3364      *
   3365      * @hide
   3366      */
   3367     @SystemApi
   3368     @RequiresPermission(android.Manifest.permission.GRANT_RUNTIME_PERMISSIONS)
   3369     public abstract void grantRuntimePermission(@NonNull String packageName,
   3370             @NonNull String permissionName, @NonNull UserHandle user);
   3371 
   3372     /**
   3373      * Revoke a runtime permission that was previously granted by {@link
   3374      * #grantRuntimePermission(String, String, android.os.UserHandle)}. The
   3375      * permission must have been requested by and granted to the application.
   3376      * If the application is not allowed to hold the permission, a {@link
   3377      * java.lang.SecurityException} is thrown. If the package or permission is
   3378      * invalid, a {@link java.lang.IllegalArgumentException} is thrown.
   3379      * <p>
   3380      * <strong>Note: </strong>Using this API requires holding
   3381      * android.permission.REVOKE_RUNTIME_PERMISSIONS and if the user id is
   3382      * not the current user android.permission.INTERACT_ACROSS_USERS_FULL.
   3383      * </p>
   3384      *
   3385      * @param packageName The package from which to revoke the permission.
   3386      * @param permissionName The permission name to revoke.
   3387      * @param user The user for which to revoke the permission.
   3388      *
   3389      * @see #grantRuntimePermission(String, String, android.os.UserHandle)
   3390      *
   3391      * @hide
   3392      */
   3393     @SystemApi
   3394     @RequiresPermission(android.Manifest.permission.REVOKE_RUNTIME_PERMISSIONS)
   3395     public abstract void revokeRuntimePermission(@NonNull String packageName,
   3396             @NonNull String permissionName, @NonNull UserHandle user);
   3397 
   3398     /**
   3399      * Gets the state flags associated with a permission.
   3400      *
   3401      * @param permissionName The permission for which to get the flags.
   3402      * @param packageName The package name for which to get the flags.
   3403      * @param user The user for which to get permission flags.
   3404      * @return The permission flags.
   3405      *
   3406      * @hide
   3407      */
   3408     @SystemApi
   3409     @RequiresPermission(anyOf = {
   3410             android.Manifest.permission.GRANT_RUNTIME_PERMISSIONS,
   3411             android.Manifest.permission.REVOKE_RUNTIME_PERMISSIONS
   3412     })
   3413     public abstract @PermissionFlags int getPermissionFlags(String permissionName,
   3414             String packageName, @NonNull UserHandle user);
   3415 
   3416     /**
   3417      * Updates the flags associated with a permission by replacing the flags in
   3418      * the specified mask with the provided flag values.
   3419      *
   3420      * @param permissionName The permission for which to update the flags.
   3421      * @param packageName The package name for which to update the flags.
   3422      * @param flagMask The flags which to replace.
   3423      * @param flagValues The flags with which to replace.
   3424      * @param user The user for which to update the permission flags.
   3425      *
   3426      * @hide
   3427      */
   3428     @SystemApi
   3429     @RequiresPermission(anyOf = {
   3430             android.Manifest.permission.GRANT_RUNTIME_PERMISSIONS,
   3431             android.Manifest.permission.REVOKE_RUNTIME_PERMISSIONS
   3432     })
   3433     public abstract void updatePermissionFlags(String permissionName,
   3434             String packageName, @PermissionFlags int flagMask, @PermissionFlags int flagValues,
   3435             @NonNull UserHandle user);
   3436 
   3437     /**
   3438      * Gets whether you should show UI with rationale for requesting a permission.
   3439      * You should do this only if you do not have the permission and the context in
   3440      * which the permission is requested does not clearly communicate to the user
   3441      * what would be the benefit from grating this permission.
   3442      *
   3443      * @param permission A permission your app wants to request.
   3444      * @return Whether you can show permission rationale UI.
   3445      *
   3446      * @hide
   3447      */
   3448     public abstract boolean shouldShowRequestPermissionRationale(String permission);
   3449 
   3450     /**
   3451      * Returns an {@link android.content.Intent} suitable for passing to
   3452      * {@link android.app.Activity#startActivityForResult(android.content.Intent, int)}
   3453      * which prompts the user to grant permissions to this application.
   3454      *
   3455      * @throws NullPointerException if {@code permissions} is {@code null} or empty.
   3456      *
   3457      * @hide
   3458      */
   3459     public Intent buildRequestPermissionsIntent(@NonNull String[] permissions) {
   3460         if (ArrayUtils.isEmpty(permissions)) {
   3461            throw new IllegalArgumentException("permission cannot be null or empty");
   3462         }
   3463         Intent intent = new Intent(ACTION_REQUEST_PERMISSIONS);
   3464         intent.putExtra(EXTRA_REQUEST_PERMISSIONS_NAMES, permissions);
   3465         intent.setPackage(getPermissionControllerPackageName());
   3466         return intent;
   3467     }
   3468 
   3469     /**
   3470      * Compare the signatures of two packages to determine if the same
   3471      * signature appears in both of them.  If they do contain the same
   3472      * signature, then they are allowed special privileges when working
   3473      * with each other: they can share the same user-id, run instrumentation
   3474      * against each other, etc.
   3475      *
   3476      * @param pkg1 First package name whose signature will be compared.
   3477      * @param pkg2 Second package name whose signature will be compared.
   3478      *
   3479      * @return Returns an integer indicating whether all signatures on the
   3480      * two packages match. The value is >= 0 ({@link #SIGNATURE_MATCH}) if
   3481      * all signatures match or < 0 if there is not a match ({@link
   3482      * #SIGNATURE_NO_MATCH} or {@link #SIGNATURE_UNKNOWN_PACKAGE}).
   3483      *
   3484      * @see #checkSignatures(int, int)
   3485      */
   3486     @CheckResult
   3487     public abstract @SignatureResult int checkSignatures(String pkg1, String pkg2);
   3488 
   3489     /**
   3490      * Like {@link #checkSignatures(String, String)}, but takes UIDs of
   3491      * the two packages to be checked.  This can be useful, for example,
   3492      * when doing the check in an IPC, where the UID is the only identity
   3493      * available.  It is functionally identical to determining the package
   3494      * associated with the UIDs and checking their signatures.
   3495      *
   3496      * @param uid1 First UID whose signature will be compared.
   3497      * @param uid2 Second UID whose signature will be compared.
   3498      *
   3499      * @return Returns an integer indicating whether all signatures on the
   3500      * two packages match. The value is >= 0 ({@link #SIGNATURE_MATCH}) if
   3501      * all signatures match or < 0 if there is not a match ({@link
   3502      * #SIGNATURE_NO_MATCH} or {@link #SIGNATURE_UNKNOWN_PACKAGE}).
   3503      *
   3504      * @see #checkSignatures(String, String)
   3505      */
   3506     @CheckResult
   3507     public abstract @SignatureResult int checkSignatures(int uid1, int uid2);
   3508 
   3509     /**
   3510      * Retrieve the names of all packages that are associated with a particular
   3511      * user id.  In most cases, this will be a single package name, the package
   3512      * that has been assigned that user id.  Where there are multiple packages
   3513      * sharing the same user id through the "sharedUserId" mechanism, all
   3514      * packages with that id will be returned.
   3515      *
   3516      * @param uid The user id for which you would like to retrieve the
   3517      * associated packages.
   3518      *
   3519      * @return Returns an array of one or more packages assigned to the user
   3520      * id, or null if there are no known packages with the given id.
   3521      */
   3522     public abstract @Nullable String[] getPackagesForUid(int uid);
   3523 
   3524     /**
   3525      * Retrieve the official name associated with a uid. This name is
   3526      * guaranteed to never change, though it is possible for the underlying
   3527      * uid to be changed.  That is, if you are storing information about
   3528      * uids in persistent storage, you should use the string returned
   3529      * by this function instead of the raw uid.
   3530      *
   3531      * @param uid The uid for which you would like to retrieve a name.
   3532      * @return Returns a unique name for the given uid, or null if the
   3533      * uid is not currently assigned.
   3534      */
   3535     public abstract @Nullable String getNameForUid(int uid);
   3536 
   3537     /**
   3538      * Return the user id associated with a shared user name. Multiple
   3539      * applications can specify a shared user name in their manifest and thus
   3540      * end up using a common uid. This might be used for new applications
   3541      * that use an existing shared user name and need to know the uid of the
   3542      * shared user.
   3543      *
   3544      * @param sharedUserName The shared user name whose uid is to be retrieved.
   3545      * @return Returns the UID associated with the shared user.
   3546      * @throws NameNotFoundException if a package with the given name cannot be
   3547      *             found on the system.
   3548      * @hide
   3549      */
   3550     public abstract int getUidForSharedUser(String sharedUserName)
   3551             throws NameNotFoundException;
   3552 
   3553     /**
   3554      * Return a List of all application packages that are installed on the
   3555      * device. If flag GET_UNINSTALLED_PACKAGES has been set, a list of all
   3556      * applications including those deleted with {@code DONT_DELETE_DATA}
   3557      * (partially installed apps with data directory) will be returned.
   3558      *
   3559      * @param flags Additional option flags to modify the data returned.
   3560      * @return A List of ApplicationInfo objects, one for each installed
   3561      *         application. In the unlikely case there are no installed
   3562      *         packages, an empty list is returned. If flag
   3563      *         {@code MATCH_UNINSTALLED_PACKAGES} is set, the application
   3564      *         information is retrieved from the list of uninstalled
   3565      *         applications (which includes installed applications as well as
   3566      *         applications with data directory i.e. applications which had been
   3567      *         deleted with {@code DONT_DELETE_DATA} flag set).
   3568      */
   3569     public abstract List<ApplicationInfo> getInstalledApplications(@ApplicationInfoFlags int flags);
   3570 
   3571     /**
   3572      * Return a List of all application packages that are installed on the
   3573      * device, for a specific user. If flag GET_UNINSTALLED_PACKAGES has been
   3574      * set, a list of all applications including those deleted with
   3575      * {@code DONT_DELETE_DATA} (partially installed apps with data directory)
   3576      * will be returned.
   3577      *
   3578      * @param flags Additional option flags to modify the data returned.
   3579      * @param userId The user for whom the installed applications are to be
   3580      *            listed
   3581      * @return A List of ApplicationInfo objects, one for each installed
   3582      *         application. In the unlikely case there are no installed
   3583      *         packages, an empty list is returned. If flag
   3584      *         {@code MATCH_UNINSTALLED_PACKAGES} is set, the application
   3585      *         information is retrieved from the list of uninstalled
   3586      *         applications (which includes installed applications as well as
   3587      *         applications with data directory i.e. applications which had been
   3588      *         deleted with {@code DONT_DELETE_DATA} flag set).
   3589      * @hide
   3590      */
   3591     public abstract List<ApplicationInfo> getInstalledApplicationsAsUser(
   3592             @ApplicationInfoFlags int flags, @UserIdInt int userId);
   3593 
   3594     /**
   3595      * Gets the instant applications the user recently used.
   3596      *
   3597      * @return The instant app list.
   3598      *
   3599      * @hide
   3600      */
   3601     @SystemApi
   3602     @RequiresPermission(Manifest.permission.ACCESS_INSTANT_APPS)
   3603     public abstract @NonNull List<InstantAppInfo> getInstantApps();
   3604 
   3605     /**
   3606      * Gets the icon for an instant application.
   3607      *
   3608      * @param packageName The app package name.
   3609      *
   3610      * @hide
   3611      */
   3612     @SystemApi
   3613     @RequiresPermission(Manifest.permission.ACCESS_INSTANT_APPS)
   3614     public abstract @Nullable Drawable getInstantAppIcon(String packageName);
   3615 
   3616     /**
   3617      * Gets whether this application is an instant app.
   3618      *
   3619      * @return Whether caller is an instant app.
   3620      *
   3621      * @see #isInstantApp(String)
   3622      * @see #updateInstantAppCookie(byte[])
   3623      * @see #getInstantAppCookie()
   3624      * @see #getInstantAppCookieMaxBytes()
   3625      */
   3626     public abstract boolean isInstantApp();
   3627 
   3628     /**
   3629      * Gets whether the given package is an instant app.
   3630      *
   3631      * @param packageName The package to check
   3632      * @return Whether the given package is an instant app.
   3633      *
   3634      * @see #isInstantApp()
   3635      * @see #updateInstantAppCookie(byte[])
   3636      * @see #getInstantAppCookie()
   3637      * @see #getInstantAppCookieMaxBytes()
   3638      * @see #clearInstantAppCookie()
   3639      */
   3640     public abstract boolean isInstantApp(String packageName);
   3641 
   3642     /**
   3643      * Gets the maximum size in bytes of the cookie data an instant app
   3644      * can store on the device.
   3645      *
   3646      * @return The max cookie size in bytes.
   3647      *
   3648      * @see #isInstantApp()
   3649      * @see #isInstantApp(String)
   3650      * @see #updateInstantAppCookie(byte[])
   3651      * @see #getInstantAppCookie()
   3652      * @see #clearInstantAppCookie()
   3653      */
   3654     public abstract int getInstantAppCookieMaxBytes();
   3655 
   3656     /**
   3657      * @deprecated
   3658      * @hide
   3659      */
   3660     public abstract int getInstantAppCookieMaxSize();
   3661 
   3662     /**
   3663      * Gets the instant application cookie for this app. Non
   3664      * instant apps and apps that were instant but were upgraded
   3665      * to normal apps can still access this API. For instant apps
   3666      * this cookie is cached for some time after uninstall while for
   3667      * normal apps the cookie is deleted after the app is uninstalled.
   3668      * The cookie is always present while the app is installed.
   3669      *
   3670      * @return The cookie.
   3671      *
   3672      * @see #isInstantApp()
   3673      * @see #isInstantApp(String)
   3674      * @see #updateInstantAppCookie(byte[])
   3675      * @see #getInstantAppCookieMaxBytes()
   3676      * @see #clearInstantAppCookie()
   3677      */
   3678     public abstract @NonNull byte[] getInstantAppCookie();
   3679 
   3680     /**
   3681      * Clears the instant application cookie for the calling app.
   3682      *
   3683      * @see #isInstantApp()
   3684      * @see #isInstantApp(String)
   3685      * @see #getInstantAppCookieMaxBytes()
   3686      * @see #getInstantAppCookie()
   3687      * @see #clearInstantAppCookie()
   3688      */
   3689     public abstract void clearInstantAppCookie();
   3690 
   3691     /**
   3692      * Updates the instant application cookie for the calling app. Non
   3693      * instant apps and apps that were instant but were upgraded
   3694      * to normal apps can still access this API. For instant apps
   3695      * this cookie is cached for some time after uninstall while for
   3696      * normal apps the cookie is deleted after the app is uninstalled.
   3697      * The cookie is always present while the app is installed. The
   3698      * cookie size is limited by {@link #getInstantAppCookieMaxBytes()}.
   3699      * Passing <code>null</code> or an empty array clears the cookie.
   3700      * </p>
   3701      *
   3702      * @param cookie The cookie data.
   3703      *
   3704      * @see #isInstantApp()
   3705      * @see #isInstantApp(String)
   3706      * @see #getInstantAppCookieMaxBytes()
   3707      * @see #getInstantAppCookie()
   3708      * @see #clearInstantAppCookie()
   3709      *
   3710      * @throws IllegalArgumentException if the array exceeds max cookie size.
   3711      */
   3712     public abstract void updateInstantAppCookie(@Nullable byte[] cookie);
   3713 
   3714     /**
   3715      * @removed
   3716      * @hide
   3717      */
   3718     public abstract boolean setInstantAppCookie(@Nullable byte[] cookie);
   3719 
   3720     /**
   3721      * Get a list of shared libraries that are available on the
   3722      * system.
   3723      *
   3724      * @return An array of shared library names that are
   3725      * available on the system, or null if none are installed.
   3726      *
   3727      */
   3728     public abstract String[] getSystemSharedLibraryNames();
   3729 
   3730     /**
   3731      * Get a list of shared libraries on the device.
   3732      *
   3733      * @param flags To filter the libraries to return.
   3734      * @return The shared library list.
   3735      *
   3736      * @see #MATCH_UNINSTALLED_PACKAGES
   3737      */
   3738     public abstract @NonNull List<SharedLibraryInfo> getSharedLibraries(
   3739             @InstallFlags int flags);
   3740 
   3741     /**
   3742      * Get a list of shared libraries on the device.
   3743      *
   3744      * @param flags To filter the libraries to return.
   3745      * @param userId The user to query for.
   3746      * @return The shared library list.
   3747      *
   3748      * @see #MATCH_FACTORY_ONLY
   3749      * @see #MATCH_KNOWN_PACKAGES
   3750      * @see #MATCH_ANY_USER
   3751      * @see #MATCH_UNINSTALLED_PACKAGES
   3752      *
   3753      * @hide
   3754      */
   3755     public abstract @NonNull List<SharedLibraryInfo> getSharedLibrariesAsUser(
   3756             @InstallFlags int flags, @UserIdInt int userId);
   3757 
   3758     /**
   3759      * Get the name of the package hosting the services shared library.
   3760      *
   3761      * @return The library host package.
   3762      *
   3763      * @hide
   3764      */
   3765     public abstract @NonNull String getServicesSystemSharedLibraryPackageName();
   3766 
   3767     /**
   3768      * Get the name of the package hosting the shared components shared library.
   3769      *
   3770      * @return The library host package.
   3771      *
   3772      * @hide
   3773      */
   3774     public abstract @NonNull String getSharedSystemSharedLibraryPackageName();
   3775 
   3776     /**
   3777      * Returns the names of the packages that have been changed
   3778      * [eg. added, removed or updated] since the given sequence
   3779      * number.
   3780      * <p>If no packages have been changed, returns <code>null</code>.
   3781      * <p>The sequence number starts at <code>0</code> and is
   3782      * reset every boot.
   3783      * @param sequenceNumber The first sequence number for which to retrieve package changes.
   3784      * @see Settings.Global#BOOT_COUNT
   3785      */
   3786     public abstract @Nullable ChangedPackages getChangedPackages(
   3787             @IntRange(from=0) int sequenceNumber);
   3788 
   3789     /**
   3790      * Get a list of features that are available on the
   3791      * system.
   3792      *
   3793      * @return An array of FeatureInfo classes describing the features
   3794      * that are available on the system, or null if there are none(!!).
   3795      */
   3796     public abstract FeatureInfo[] getSystemAvailableFeatures();
   3797 
   3798     /**
   3799      * Check whether the given feature name is one of the available features as
   3800      * returned by {@link #getSystemAvailableFeatures()}. This tests for the
   3801      * presence of <em>any</em> version of the given feature name; use
   3802      * {@link #hasSystemFeature(String, int)} to check for a minimum version.
   3803      *
   3804      * @return Returns true if the devices supports the feature, else false.
   3805      */
   3806     public abstract boolean hasSystemFeature(String name);
   3807 
   3808     /**
   3809      * Check whether the given feature name and version is one of the available
   3810      * features as returned by {@link #getSystemAvailableFeatures()}. Since
   3811      * features are defined to always be backwards compatible, this returns true
   3812      * if the available feature version is greater than or equal to the
   3813      * requested version.
   3814      *
   3815      * @return Returns true if the devices supports the feature, else false.
   3816      */
   3817     public abstract boolean hasSystemFeature(String name, int version);
   3818 
   3819     /**
   3820      * Determine the best action to perform for a given Intent. This is how
   3821      * {@link Intent#resolveActivity} finds an activity if a class has not been
   3822      * explicitly specified.
   3823      * <p>
   3824      * <em>Note:</em> if using an implicit Intent (without an explicit
   3825      * ComponentName specified), be sure to consider whether to set the
   3826      * {@link #MATCH_DEFAULT_ONLY} only flag. You need to do so to resolve the
   3827      * activity in the same way that
   3828      * {@link android.content.Context#startActivity(Intent)} and
   3829      * {@link android.content.Intent#resolveActivity(PackageManager)
   3830      * Intent.resolveActivity(PackageManager)} do.
   3831      * </p>
   3832      *
   3833      * @param intent An intent containing all of the desired specification
   3834      *            (action, data, type, category, and/or component).
   3835      * @param flags Additional option flags to modify the data returned. The
   3836      *            most important is {@link #MATCH_DEFAULT_ONLY}, to limit the
   3837      *            resolution to only those activities that support the
   3838      *            {@link android.content.Intent#CATEGORY_DEFAULT}.
   3839      * @return Returns a ResolveInfo object containing the final activity intent
   3840      *         that was determined to be the best action. Returns null if no
   3841      *         matching activity was found. If multiple matching activities are
   3842      *         found and there is no default set, returns a ResolveInfo object
   3843      *         containing something else, such as the activity resolver.
   3844      */
   3845     public abstract ResolveInfo resolveActivity(Intent intent, @ResolveInfoFlags int flags);
   3846 
   3847     /**
   3848      * Determine the best action to perform for a given Intent for a given user.
   3849      * This is how {@link Intent#resolveActivity} finds an activity if a class
   3850      * has not been explicitly specified.
   3851      * <p>
   3852      * <em>Note:</em> if using an implicit Intent (without an explicit
   3853      * ComponentName specified), be sure to consider whether to set the
   3854      * {@link #MATCH_DEFAULT_ONLY} only flag. You need to do so to resolve the
   3855      * activity in the same way that
   3856      * {@link android.content.Context#startActivity(Intent)} and
   3857      * {@link android.content.Intent#resolveActivity(PackageManager)
   3858      * Intent.resolveActivity(PackageManager)} do.
   3859      * </p>
   3860      *
   3861      * @param intent An intent containing all of the desired specification
   3862      *            (action, data, type, category, and/or component).
   3863      * @param flags Additional option flags to modify the data returned. The
   3864      *            most important is {@link #MATCH_DEFAULT_ONLY}, to limit the
   3865      *            resolution to only those activities that support the
   3866      *            {@link android.content.Intent#CATEGORY_DEFAULT}.
   3867      * @param userId The user id.
   3868      * @return Returns a ResolveInfo object containing the final activity intent
   3869      *         that was determined to be the best action. Returns null if no
   3870      *         matching activity was found. If multiple matching activities are
   3871      *         found and there is no default set, returns a ResolveInfo object
   3872      *         containing something else, such as the activity resolver.
   3873      * @hide
   3874      */
   3875     public abstract ResolveInfo resolveActivityAsUser(Intent intent, @ResolveInfoFlags int flags,
   3876             @UserIdInt int userId);
   3877 
   3878     /**
   3879      * Retrieve all activities that can be performed for the given intent.
   3880      *
   3881      * @param intent The desired intent as per resolveActivity().
   3882      * @param flags Additional option flags to modify the data returned. The
   3883      *            most important is {@link #MATCH_DEFAULT_ONLY}, to limit the
   3884      *            resolution to only those activities that support the
   3885      *            {@link android.content.Intent#CATEGORY_DEFAULT}. Or, set
   3886      *            {@link #MATCH_ALL} to prevent any filtering of the results.
   3887      * @return Returns a List of ResolveInfo objects containing one entry for
   3888      *         each matching activity, ordered from best to worst. In other
   3889      *         words, the first item is what would be returned by
   3890      *         {@link #resolveActivity}. If there are no matching activities, an
   3891      *         empty list is returned.
   3892      */
   3893     public abstract List<ResolveInfo> queryIntentActivities(Intent intent,
   3894             @ResolveInfoFlags int flags);
   3895 
   3896     /**
   3897      * Retrieve all activities that can be performed for the given intent, for a
   3898      * specific user.
   3899      *
   3900      * @param intent The desired intent as per resolveActivity().
   3901      * @param flags Additional option flags to modify the data returned. The
   3902      *            most important is {@link #MATCH_DEFAULT_ONLY}, to limit the
   3903      *            resolution to only those activities that support the
   3904      *            {@link android.content.Intent#CATEGORY_DEFAULT}. Or, set
   3905      *            {@link #MATCH_ALL} to prevent any filtering of the results.
   3906      * @return Returns a List of ResolveInfo objects containing one entry for
   3907      *         each matching activity, ordered from best to worst. In other
   3908      *         words, the first item is what would be returned by
   3909      *         {@link #resolveActivity}. If there are no matching activities, an
   3910      *         empty list is returned.
   3911      * @hide
   3912      */
   3913     public abstract List<ResolveInfo> queryIntentActivitiesAsUser(Intent intent,
   3914             @ResolveInfoFlags int flags, @UserIdInt int userId);
   3915 
   3916     /**
   3917      * Retrieve a set of activities that should be presented to the user as
   3918      * similar options. This is like {@link #queryIntentActivities}, except it
   3919      * also allows you to supply a list of more explicit Intents that you would
   3920      * like to resolve to particular options, and takes care of returning the
   3921      * final ResolveInfo list in a reasonable order, with no duplicates, based
   3922      * on those inputs.
   3923      *
   3924      * @param caller The class name of the activity that is making the request.
   3925      *            This activity will never appear in the output list. Can be
   3926      *            null.
   3927      * @param specifics An array of Intents that should be resolved to the first
   3928      *            specific results. Can be null.
   3929      * @param intent The desired intent as per resolveActivity().
   3930      * @param flags Additional option flags to modify the data returned. The
   3931      *            most important is {@link #MATCH_DEFAULT_ONLY}, to limit the
   3932      *            resolution to only those activities that support the
   3933      *            {@link android.content.Intent#CATEGORY_DEFAULT}.
   3934      * @return Returns a List of ResolveInfo objects containing one entry for
   3935      *         each matching activity. The list is ordered first by all of the
   3936      *         intents resolved in <var>specifics</var> and then any additional
   3937      *         activities that can handle <var>intent</var> but did not get
   3938      *         included by one of the <var>specifics</var> intents. If there are
   3939      *         no matching activities, an empty list is returned.
   3940      */
   3941     public abstract List<ResolveInfo> queryIntentActivityOptions(@Nullable ComponentName caller,
   3942             @Nullable Intent[] specifics, Intent intent, @ResolveInfoFlags int flags);
   3943 
   3944     /**
   3945      * Retrieve all receivers that can handle a broadcast of the given intent.
   3946      *
   3947      * @param intent The desired intent as per resolveActivity().
   3948      * @param flags Additional option flags to modify the data returned.
   3949      * @return Returns a List of ResolveInfo objects containing one entry for
   3950      *         each matching receiver, ordered from best to worst. If there are
   3951      *         no matching receivers, an empty list or null is returned.
   3952      */
   3953     public abstract List<ResolveInfo> queryBroadcastReceivers(Intent intent,
   3954             @ResolveInfoFlags int flags);
   3955 
   3956     /**
   3957      * Retrieve all receivers that can handle a broadcast of the given intent,
   3958      * for a specific user.
   3959      *
   3960      * @param intent The desired intent as per resolveActivity().
   3961      * @param flags Additional option flags to modify the data returned.
   3962      * @param userHandle UserHandle of the user being queried.
   3963      * @return Returns a List of ResolveInfo objects containing one entry for
   3964      *         each matching receiver, ordered from best to worst. If there are
   3965      *         no matching receivers, an empty list or null is returned.
   3966      * @hide
   3967      */
   3968     @SystemApi
   3969     public List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent,
   3970             @ResolveInfoFlags int flags, UserHandle userHandle) {
   3971         return queryBroadcastReceiversAsUser(intent, flags, userHandle.getIdentifier());
   3972     }
   3973 
   3974     /**
   3975      * @hide
   3976      */
   3977     public abstract List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent,
   3978             @ResolveInfoFlags int flags, @UserIdInt int userId);
   3979 
   3980 
   3981     /** {@hide} */
   3982     @Deprecated
   3983     public List<ResolveInfo> queryBroadcastReceivers(Intent intent,
   3984             @ResolveInfoFlags int flags, @UserIdInt int userId) {
   3985         final String msg = "Shame on you for calling the hidden API "
   3986                 + "queryBroadcastReceivers(). Shame!";
   3987         if (VMRuntime.getRuntime().getTargetSdkVersion() >= Build.VERSION_CODES.O) {
   3988             throw new UnsupportedOperationException(msg);
   3989         } else {
   3990             Log.d(TAG, msg);
   3991             return queryBroadcastReceiversAsUser(intent, flags, userId);
   3992         }
   3993     }
   3994 
   3995     /**
   3996      * Determine the best service to handle for a given Intent.
   3997      *
   3998      * @param intent An intent containing all of the desired specification
   3999      *            (action, data, type, category, and/or component).
   4000      * @param flags Additional option flags to modify the data returned.
   4001      * @return Returns a ResolveInfo object containing the final service intent
   4002      *         that was determined to be the best action. Returns null if no
   4003      *         matching service was found.
   4004      */
   4005     public abstract ResolveInfo resolveService(Intent intent, @ResolveInfoFlags int flags);
   4006 
   4007     /**
   4008      * Retrieve all services that can match the given intent.
   4009      *
   4010      * @param intent The desired intent as per resolveService().
   4011      * @param flags Additional option flags to modify the data returned.
   4012      * @return Returns a List of ResolveInfo objects containing one entry for
   4013      *         each matching service, ordered from best to worst. In other
   4014      *         words, the first item is what would be returned by
   4015      *         {@link #resolveService}. If there are no matching services, an
   4016      *         empty list or null is returned.
   4017      */
   4018     public abstract List<ResolveInfo> queryIntentServices(Intent intent,
   4019             @ResolveInfoFlags int flags);
   4020 
   4021     /**
   4022      * Retrieve all services that can match the given intent for a given user.
   4023      *
   4024      * @param intent The desired intent as per resolveService().
   4025      * @param flags Additional option flags to modify the data returned.
   4026      * @param userId The user id.
   4027      * @return Returns a List of ResolveInfo objects containing one entry for
   4028      *         each matching service, ordered from best to worst. In other
   4029      *         words, the first item is what would be returned by
   4030      *         {@link #resolveService}. If there are no matching services, an
   4031      *         empty list or null is returned.
   4032      * @hide
   4033      */
   4034     public abstract List<ResolveInfo> queryIntentServicesAsUser(Intent intent,
   4035             @ResolveInfoFlags int flags, @UserIdInt int userId);
   4036 
   4037     /**
   4038      * Retrieve all providers that can match the given intent.
   4039      *
   4040      * @param intent An intent containing all of the desired specification
   4041      *            (action, data, type, category, and/or component).
   4042      * @param flags Additional option flags to modify the data returned.
   4043      * @param userId The user id.
   4044      * @return Returns a List of ResolveInfo objects containing one entry for
   4045      *         each matching provider, ordered from best to worst. If there are
   4046      *         no matching services, an empty list or null is returned.
   4047      * @hide
   4048      */
   4049     public abstract List<ResolveInfo> queryIntentContentProvidersAsUser(
   4050             Intent intent, @ResolveInfoFlags int flags, @UserIdInt int userId);
   4051 
   4052     /**
   4053      * Retrieve all providers that can match the given intent.
   4054      *
   4055      * @param intent An intent containing all of the desired specification
   4056      *            (action, data, type, category, and/or component).
   4057      * @param flags Additional option flags to modify the data returned.
   4058      * @return Returns a List of ResolveInfo objects containing one entry for
   4059      *         each matching provider, ordered from best to worst. If there are
   4060      *         no matching services, an empty list or null is returned.
   4061      */
   4062     public abstract List<ResolveInfo> queryIntentContentProviders(Intent intent,
   4063             @ResolveInfoFlags int flags);
   4064 
   4065     /**
   4066      * Find a single content provider by its base path name.
   4067      *
   4068      * @param name The name of the provider to find.
   4069      * @param flags Additional option flags to modify the data returned.
   4070      * @return A {@link ProviderInfo} object containing information about the
   4071      *         provider. If a provider was not found, returns null.
   4072      */
   4073     public abstract ProviderInfo resolveContentProvider(String name,
   4074             @ComponentInfoFlags int flags);
   4075 
   4076     /**
   4077      * Find a single content provider by its base path name.
   4078      *
   4079      * @param name The name of the provider to find.
   4080      * @param flags Additional option flags to modify the data returned.
   4081      * @param userId The user id.
   4082      * @return A {@link ProviderInfo} object containing information about the
   4083      *         provider. If a provider was not found, returns null.
   4084      * @hide
   4085      */
   4086     public abstract ProviderInfo resolveContentProviderAsUser(String name,
   4087             @ComponentInfoFlags int flags, @UserIdInt int userId);
   4088 
   4089     /**
   4090      * Retrieve content provider information.
   4091      * <p>
   4092      * <em>Note: unlike most other methods, an empty result set is indicated
   4093      * by a null return instead of an empty list.</em>
   4094      *
   4095      * @param processName If non-null, limits the returned providers to only
   4096      *            those that are hosted by the given process. If null, all
   4097      *            content providers are returned.
   4098      * @param uid If <var>processName</var> is non-null, this is the required
   4099      *            uid owning the requested content providers.
   4100      * @param flags Additional option flags to modify the data returned.
   4101      * @return A list of {@link ProviderInfo} objects containing one entry for
   4102      *         each provider either matching <var>processName</var> or, if
   4103      *         <var>processName</var> is null, all known content providers.
   4104      *         <em>If there are no matching providers, null is returned.</em>
   4105      */
   4106     public abstract List<ProviderInfo> queryContentProviders(
   4107             String processName, int uid, @ComponentInfoFlags int flags);
   4108 
   4109     /**
   4110      * Same as {@link #queryContentProviders}, except when {@code metaDataKey} is not null,
   4111      * it only returns providers which have metadata with the {@code metaDataKey} key.
   4112      *
   4113      * <p>DO NOT USE the {@code metaDataKey} parameter, unless you're the contacts provider.
   4114      * You really shouldn't need it.  Other apps should use {@link #queryIntentContentProviders}
   4115      * instead.
   4116      *
   4117      * <p>The {@code metaDataKey} parameter was added to allow the contacts provider to quickly
   4118      * scan the GAL providers on the device.  Unfortunately the discovery protocol used metadata
   4119      * to mark GAL providers, rather than intent filters, so we can't use
   4120      * {@link #queryIntentContentProviders} for that.
   4121      *
   4122      * @hide
   4123      */
   4124     public List<ProviderInfo> queryContentProviders(
   4125             String processName, int uid, @ComponentInfoFlags int flags, String metaDataKey) {
   4126         // Provide the default implementation for mocks.
   4127         return queryContentProviders(processName, uid, flags);
   4128     }
   4129 
   4130     /**
   4131      * Retrieve all of the information we know about a particular
   4132      * instrumentation class.
   4133      *
   4134      * @param className The full name (i.e.
   4135      *            com.google.apps.contacts.InstrumentList) of an Instrumentation
   4136      *            class.
   4137      * @param flags Additional option flags to modify the data returned.
   4138      * @return An {@link InstrumentationInfo} object containing information
   4139      *         about the instrumentation.
   4140      * @throws NameNotFoundException if a package with the given name cannot be
   4141      *             found on the system.
   4142      */
   4143     public abstract InstrumentationInfo getInstrumentationInfo(ComponentName className,
   4144             @InstrumentationInfoFlags int flags) throws NameNotFoundException;
   4145 
   4146     /**
   4147      * Retrieve information about available instrumentation code. May be used to
   4148      * retrieve either all instrumentation code, or only the code targeting a
   4149      * particular package.
   4150      *
   4151      * @param targetPackage If null, all instrumentation is returned; only the
   4152      *            instrumentation targeting this package name is returned.
   4153      * @param flags Additional option flags to modify the data returned.
   4154      * @return A list of {@link InstrumentationInfo} objects containing one
   4155      *         entry for each matching instrumentation. If there are no
   4156      *         instrumentation available, returns an empty list.
   4157      */
   4158     public abstract List<InstrumentationInfo> queryInstrumentation(String targetPackage,
   4159             @InstrumentationInfoFlags int flags);
   4160 
   4161     /**
   4162      * Retrieve an image from a package.  This is a low-level API used by
   4163      * the various package manager info structures (such as
   4164      * {@link ComponentInfo} to implement retrieval of their associated
   4165      * icon.
   4166      *
   4167      * @param packageName The name of the package that this icon is coming from.
   4168      * Cannot be null.
   4169      * @param resid The resource identifier of the desired image.  Cannot be 0.
   4170      * @param appInfo Overall information about <var>packageName</var>.  This
   4171      * may be null, in which case the application information will be retrieved
   4172      * for you if needed; if you already have this information around, it can
   4173      * be much more efficient to supply it here.
   4174      *
   4175      * @return Returns a Drawable holding the requested image.  Returns null if
   4176      * an image could not be found for any reason.
   4177      */
   4178     public abstract Drawable getDrawable(String packageName, @DrawableRes int resid,
   4179             ApplicationInfo appInfo);
   4180 
   4181     /**
   4182      * Retrieve the icon associated with an activity.  Given the full name of
   4183      * an activity, retrieves the information about it and calls
   4184      * {@link ComponentInfo#loadIcon ComponentInfo.loadIcon()} to return its icon.
   4185      * If the activity cannot be found, NameNotFoundException is thrown.
   4186      *
   4187      * @param activityName Name of the activity whose icon is to be retrieved.
   4188      *
   4189      * @return Returns the image of the icon, or the default activity icon if
   4190      * it could not be found.  Does not return null.
   4191      * @throws NameNotFoundException Thrown if the resources for the given
   4192      * activity could not be loaded.
   4193      *
   4194      * @see #getActivityIcon(Intent)
   4195      */
   4196     public abstract Drawable getActivityIcon(ComponentName activityName)
   4197             throws NameNotFoundException;
   4198 
   4199     /**
   4200      * Retrieve the icon associated with an Intent.  If intent.getClassName() is
   4201      * set, this simply returns the result of
   4202      * getActivityIcon(intent.getClassName()).  Otherwise it resolves the intent's
   4203      * component and returns the icon associated with the resolved component.
   4204      * If intent.getClassName() cannot be found or the Intent cannot be resolved
   4205      * to a component, NameNotFoundException is thrown.
   4206      *
   4207      * @param intent The intent for which you would like to retrieve an icon.
   4208      *
   4209      * @return Returns the image of the icon, or the default activity icon if
   4210      * it could not be found.  Does not return null.
   4211      * @throws NameNotFoundException Thrown if the resources for application
   4212      * matching the given intent could not be loaded.
   4213      *
   4214      * @see #getActivityIcon(ComponentName)
   4215      */
   4216     public abstract Drawable getActivityIcon(Intent intent)
   4217             throws NameNotFoundException;
   4218 
   4219     /**
   4220      * Retrieve the banner associated with an activity. Given the full name of
   4221      * an activity, retrieves the information about it and calls
   4222      * {@link ComponentInfo#loadIcon ComponentInfo.loadIcon()} to return its
   4223      * banner. If the activity cannot be found, NameNotFoundException is thrown.
   4224      *
   4225      * @param activityName Name of the activity whose banner is to be retrieved.
   4226      * @return Returns the image of the banner, or null if the activity has no
   4227      *         banner specified.
   4228      * @throws NameNotFoundException Thrown if the resources for the given
   4229      *             activity could not be loaded.
   4230      * @see #getActivityBanner(Intent)
   4231      */
   4232     public abstract Drawable getActivityBanner(ComponentName activityName)
   4233             throws NameNotFoundException;
   4234 
   4235     /**
   4236      * Retrieve the banner associated with an Intent. If intent.getClassName()
   4237      * is set, this simply returns the result of
   4238      * getActivityBanner(intent.getClassName()). Otherwise it resolves the
   4239      * intent's component and returns the banner associated with the resolved
   4240      * component. If intent.getClassName() cannot be found or the Intent cannot
   4241      * be resolved to a component, NameNotFoundException is thrown.
   4242      *
   4243      * @param intent The intent for which you would like to retrieve a banner.
   4244      * @return Returns the image of the banner, or null if the activity has no
   4245      *         banner specified.
   4246      * @throws NameNotFoundException Thrown if the resources for application
   4247      *             matching the given intent could not be loaded.
   4248      * @see #getActivityBanner(ComponentName)
   4249      */
   4250     public abstract Drawable getActivityBanner(Intent intent)
   4251             throws NameNotFoundException;
   4252 
   4253     /**
   4254      * Return the generic icon for an activity that is used when no specific
   4255      * icon is defined.
   4256      *
   4257      * @return Drawable Image of the icon.
   4258      */
   4259     public abstract Drawable getDefaultActivityIcon();
   4260 
   4261     /**
   4262      * Retrieve the icon associated with an application.  If it has not defined
   4263      * an icon, the default app icon is returned.  Does not return null.
   4264      *
   4265      * @param info Information about application being queried.
   4266      *
   4267      * @return Returns the image of the icon, or the default application icon
   4268      * if it could not be found.
   4269      *
   4270      * @see #getApplicationIcon(String)
   4271      */
   4272     public abstract Drawable getApplicationIcon(ApplicationInfo info);
   4273 
   4274     /**
   4275      * Retrieve the icon associated with an application.  Given the name of the
   4276      * application's package, retrieves the information about it and calls
   4277      * getApplicationIcon() to return its icon. If the application cannot be
   4278      * found, NameNotFoundException is thrown.
   4279      *
   4280      * @param packageName Name of the package whose application icon is to be
   4281      *                    retrieved.
   4282      *
   4283      * @return Returns the image of the icon, or the default application icon
   4284      * if it could not be found.  Does not return null.
   4285      * @throws NameNotFoundException Thrown if the resources for the given
   4286      * application could not be loaded.
   4287      *
   4288      * @see #getApplicationIcon(ApplicationInfo)
   4289      */
   4290     public abstract Drawable getApplicationIcon(String packageName)
   4291             throws NameNotFoundException;
   4292 
   4293     /**
   4294      * Retrieve the banner associated with an application.
   4295      *
   4296      * @param info Information about application being queried.
   4297      * @return Returns the image of the banner or null if the application has no
   4298      *         banner specified.
   4299      * @see #getApplicationBanner(String)
   4300      */
   4301     public abstract Drawable getApplicationBanner(ApplicationInfo info);
   4302 
   4303     /**
   4304      * Retrieve the banner associated with an application. Given the name of the
   4305      * application's package, retrieves the information about it and calls
   4306      * getApplicationIcon() to return its banner. If the application cannot be
   4307      * found, NameNotFoundException is thrown.
   4308      *
   4309      * @param packageName Name of the package whose application banner is to be
   4310      *            retrieved.
   4311      * @return Returns the image of the banner or null if the application has no
   4312      *         banner specified.
   4313      * @throws NameNotFoundException Thrown if the resources for the given
   4314      *             application could not be loaded.
   4315      * @see #getApplicationBanner(ApplicationInfo)
   4316      */
   4317     public abstract Drawable getApplicationBanner(String packageName)
   4318             throws NameNotFoundException;
   4319 
   4320     /**
   4321      * Retrieve the logo associated with an activity. Given the full name of an
   4322      * activity, retrieves the information about it and calls
   4323      * {@link ComponentInfo#loadLogo ComponentInfo.loadLogo()} to return its
   4324      * logo. If the activity cannot be found, NameNotFoundException is thrown.
   4325      *
   4326      * @param activityName Name of the activity whose logo is to be retrieved.
   4327      * @return Returns the image of the logo or null if the activity has no logo
   4328      *         specified.
   4329      * @throws NameNotFoundException Thrown if the resources for the given
   4330      *             activity could not be loaded.
   4331      * @see #getActivityLogo(Intent)
   4332      */
   4333     public abstract Drawable getActivityLogo(ComponentName activityName)
   4334             throws NameNotFoundException;
   4335 
   4336     /**
   4337      * Retrieve the logo associated with an Intent.  If intent.getClassName() is
   4338      * set, this simply returns the result of
   4339      * getActivityLogo(intent.getClassName()).  Otherwise it resolves the intent's
   4340      * component and returns the logo associated with the resolved component.
   4341      * If intent.getClassName() cannot be found or the Intent cannot be resolved
   4342      * to a component, NameNotFoundException is thrown.
   4343      *
   4344      * @param intent The intent for which you would like to retrieve a logo.
   4345      *
   4346      * @return Returns the image of the logo, or null if the activity has no
   4347      * logo specified.
   4348      *
   4349      * @throws NameNotFoundException Thrown if the resources for application
   4350      * matching the given intent could not be loaded.
   4351      *
   4352      * @see #getActivityLogo(ComponentName)
   4353      */
   4354     public abstract Drawable getActivityLogo(Intent intent)
   4355             throws NameNotFoundException;
   4356 
   4357     /**
   4358      * Retrieve the logo associated with an application.  If it has not specified
   4359      * a logo, this method returns null.
   4360      *
   4361      * @param info Information about application being queried.
   4362      *
   4363      * @return Returns the image of the logo, or null if no logo is specified
   4364      * by the application.
   4365      *
   4366      * @see #getApplicationLogo(String)
   4367      */
   4368     public abstract Drawable getApplicationLogo(ApplicationInfo info);
   4369 
   4370     /**
   4371      * Retrieve the logo associated with an application.  Given the name of the
   4372      * application's package, retrieves the information about it and calls
   4373      * getApplicationLogo() to return its logo. If the application cannot be
   4374      * found, NameNotFoundException is thrown.
   4375      *
   4376      * @param packageName Name of the package whose application logo is to be
   4377      *                    retrieved.
   4378      *
   4379      * @return Returns the image of the logo, or null if no application logo
   4380      * has been specified.
   4381      *
   4382      * @throws NameNotFoundException Thrown if the resources for the given
   4383      * application could not be loaded.
   4384      *
   4385      * @see #getApplicationLogo(ApplicationInfo)
   4386      */
   4387     public abstract Drawable getApplicationLogo(String packageName)
   4388             throws NameNotFoundException;
   4389 
   4390     /**
   4391      * If the target user is a managed profile, then this returns a badged copy of the given icon
   4392      * to be able to distinguish it from the original icon. For badging an arbitrary drawable use
   4393      * {@link #getUserBadgedDrawableForDensity(
   4394      * android.graphics.drawable.Drawable, UserHandle, android.graphics.Rect, int)}.
   4395      * <p>
   4396      * If the original drawable is a BitmapDrawable and the backing bitmap is
   4397      * mutable as per {@link android.graphics.Bitmap#isMutable()}, the badging
   4398      * is performed in place and the original drawable is returned.
   4399      * </p>
   4400      *
   4401      * @param icon The icon to badge.
   4402      * @param user The target user.
   4403      * @return A drawable that combines the original icon and a badge as
   4404      *         determined by the system.
   4405      */
   4406     public abstract Drawable getUserBadgedIcon(Drawable icon, UserHandle user);
   4407 
   4408     /**
   4409      * If the target user is a managed profile of the calling user or the caller
   4410      * is itself a managed profile, then this returns a badged copy of the given
   4411      * drawable allowing the user to distinguish it from the original drawable.
   4412      * The caller can specify the location in the bounds of the drawable to be
   4413      * badged where the badge should be applied as well as the density of the
   4414      * badge to be used.
   4415      * <p>
   4416      * If the original drawable is a BitmapDrawable and the backing bitmap is
   4417      * mutable as per {@link android.graphics.Bitmap#isMutable()}, the badging
   4418      * is performed in place and the original drawable is returned.
   4419      * </p>
   4420      *
   4421      * @param drawable The drawable to badge.
   4422      * @param user The target user.
   4423      * @param badgeLocation Where in the bounds of the badged drawable to place
   4424      *         the badge. If it's {@code null}, the badge is applied on top of the entire
   4425      *         drawable being badged.
   4426      * @param badgeDensity The optional desired density for the badge as per
   4427      *         {@link android.util.DisplayMetrics#densityDpi}. If it's not positive,
   4428      *         the density of the display is used.
   4429      * @return A drawable that combines the original drawable and a badge as
   4430      *         determined by the system.
   4431      */
   4432     public abstract Drawable getUserBadgedDrawableForDensity(Drawable drawable,
   4433             UserHandle user, Rect badgeLocation, int badgeDensity);
   4434 
   4435     /**
   4436      * If the target user is a managed profile of the calling user or the caller
   4437      * is itself a managed profile, then this returns a drawable to use as a small
   4438      * icon to include in a view to distinguish it from the original icon.
   4439      *
   4440      * @param user The target user.
   4441      * @param density The optional desired density for the badge as per
   4442      *         {@link android.util.DisplayMetrics#densityDpi}. If not provided
   4443      *         the density of the current display is used.
   4444      * @return the drawable or null if no drawable is required.
   4445      * @hide
   4446      */
   4447     public abstract Drawable getUserBadgeForDensity(UserHandle user, int density);
   4448 
   4449     /**
   4450      * If the target user is a managed profile of the calling user or the caller
   4451      * is itself a managed profile, then this returns a drawable to use as a small
   4452      * icon to include in a view to distinguish it from the original icon. This version
   4453      * doesn't have background protection and should be used over a light background instead of
   4454      * a badge.
   4455      *
   4456      * @param user The target user.
   4457      * @param density The optional desired density for the badge as per
   4458      *         {@link android.util.DisplayMetrics#densityDpi}. If not provided
   4459      *         the density of the current display is used.
   4460      * @return the drawable or null if no drawable is required.
   4461      * @hide
   4462      */
   4463     public abstract Drawable getUserBadgeForDensityNoBackground(UserHandle user, int density);
   4464 
   4465     /**
   4466      * If the target user is a managed profile of the calling user or the caller
   4467      * is itself a managed profile, then this returns a copy of the label with
   4468      * badging for accessibility services like talkback. E.g. passing in "Email"
   4469      * and it might return "Work Email" for Email in the work profile.
   4470      *
   4471      * @param label The label to change.
   4472      * @param user The target user.
   4473      * @return A label that combines the original label and a badge as
   4474      *         determined by the system.
   4475      */
   4476     public abstract CharSequence getUserBadgedLabel(CharSequence label, UserHandle user);
   4477 
   4478     /**
   4479      * Retrieve text from a package.  This is a low-level API used by
   4480      * the various package manager info structures (such as
   4481      * {@link ComponentInfo} to implement retrieval of their associated
   4482      * labels and other text.
   4483      *
   4484      * @param packageName The name of the package that this text is coming from.
   4485      * Cannot be null.
   4486      * @param resid The resource identifier of the desired text.  Cannot be 0.
   4487      * @param appInfo Overall information about <var>packageName</var>.  This
   4488      * may be null, in which case the application information will be retrieved
   4489      * for you if needed; if you already have this information around, it can
   4490      * be much more efficient to supply it here.
   4491      *
   4492      * @return Returns a CharSequence holding the requested text.  Returns null
   4493      * if the text could not be found for any reason.
   4494      */
   4495     public abstract CharSequence getText(String packageName, @StringRes int resid,
   4496             ApplicationInfo appInfo);
   4497 
   4498     /**
   4499      * Retrieve an XML file from a package.  This is a low-level API used to
   4500      * retrieve XML meta data.
   4501      *
   4502      * @param packageName The name of the package that this xml is coming from.
   4503      * Cannot be null.
   4504      * @param resid The resource identifier of the desired xml.  Cannot be 0.
   4505      * @param appInfo Overall information about <var>packageName</var>.  This
   4506      * may be null, in which case the application information will be retrieved
   4507      * for you if needed; if you already have this information around, it can
   4508      * be much more efficient to supply it here.
   4509      *
   4510      * @return Returns an XmlPullParser allowing you to parse out the XML
   4511      * data.  Returns null if the xml resource could not be found for any
   4512      * reason.
   4513      */
   4514     public abstract XmlResourceParser getXml(String packageName, @XmlRes int resid,
   4515             ApplicationInfo appInfo);
   4516 
   4517     /**
   4518      * Return the label to use for this application.
   4519      *
   4520      * @return Returns the label associated with this application, or null if
   4521      * it could not be found for any reason.
   4522      * @param info The application to get the label of.
   4523      */
   4524     public abstract CharSequence getApplicationLabel(ApplicationInfo info);
   4525 
   4526     /**
   4527      * Retrieve the resources associated with an activity.  Given the full
   4528      * name of an activity, retrieves the information about it and calls
   4529      * getResources() to return its application's resources.  If the activity
   4530      * cannot be found, NameNotFoundException is thrown.
   4531      *
   4532      * @param activityName Name of the activity whose resources are to be
   4533      *                     retrieved.
   4534      *
   4535      * @return Returns the application's Resources.
   4536      * @throws NameNotFoundException Thrown if the resources for the given
   4537      * application could not be loaded.
   4538      *
   4539      * @see #getResourcesForApplication(ApplicationInfo)
   4540      */
   4541     public abstract Resources getResourcesForActivity(ComponentName activityName)
   4542             throws NameNotFoundException;
   4543 
   4544     /**
   4545      * Retrieve the resources for an application.  Throws NameNotFoundException
   4546      * if the package is no longer installed.
   4547      *
   4548      * @param app Information about the desired application.
   4549      *
   4550      * @return Returns the application's Resources.
   4551      * @throws NameNotFoundException Thrown if the resources for the given
   4552      * application could not be loaded (most likely because it was uninstalled).
   4553      */
   4554     public abstract Resources getResourcesForApplication(ApplicationInfo app)
   4555             throws NameNotFoundException;
   4556 
   4557     /**
   4558      * Retrieve the resources associated with an application.  Given the full
   4559      * package name of an application, retrieves the information about it and
   4560      * calls getResources() to return its application's resources.  If the
   4561      * appPackageName cannot be found, NameNotFoundException is thrown.
   4562      *
   4563      * @param appPackageName Package name of the application whose resources
   4564      *                       are to be retrieved.
   4565      *
   4566      * @return Returns the application's Resources.
   4567      * @throws NameNotFoundException Thrown if the resources for the given
   4568      * application could not be loaded.
   4569      *
   4570      * @see #getResourcesForApplication(ApplicationInfo)
   4571      */
   4572     public abstract Resources getResourcesForApplication(String appPackageName)
   4573             throws NameNotFoundException;
   4574 
   4575     /** @hide */
   4576     public abstract Resources getResourcesForApplicationAsUser(String appPackageName,
   4577             @UserIdInt int userId) throws NameNotFoundException;
   4578 
   4579     /**
   4580      * Retrieve overall information about an application package defined in a
   4581      * package archive file
   4582      *
   4583      * @param archiveFilePath The path to the archive file
   4584      * @param flags Additional option flags to modify the data returned.
   4585      * @return A PackageInfo object containing information about the package
   4586      *         archive. If the package could not be parsed, returns null.
   4587      */
   4588     public PackageInfo getPackageArchiveInfo(String archiveFilePath, @PackageInfoFlags int flags) {
   4589         final PackageParser parser = new PackageParser();
   4590         parser.setCallback(new PackageParser.CallbackImpl(this));
   4591         final File apkFile = new File(archiveFilePath);
   4592         try {
   4593             if ((flags & (MATCH_DIRECT_BOOT_UNAWARE | MATCH_DIRECT_BOOT_AWARE)) != 0) {
   4594                 // Caller expressed an explicit opinion about what encryption
   4595                 // aware/unaware components they want to see, so fall through and
   4596                 // give them what they want
   4597             } else {
   4598                 // Caller expressed no opinion, so match everything
   4599                 flags |= MATCH_DIRECT_BOOT_AWARE | MATCH_DIRECT_BOOT_UNAWARE;
   4600             }
   4601 
   4602             PackageParser.Package pkg = parser.parseMonolithicPackage(apkFile, 0);
   4603             if ((flags & GET_SIGNATURES) != 0) {
   4604                 PackageParser.collectCertificates(pkg, 0);
   4605             }
   4606             PackageUserState state = new PackageUserState();
   4607             return PackageParser.generatePackageInfo(pkg, null, flags, 0, 0, null, state);
   4608         } catch (PackageParserException e) {
   4609             return null;
   4610         }
   4611     }
   4612 
   4613     /**
   4614      * @deprecated replaced by {@link PackageInstaller}
   4615      * @hide
   4616      */
   4617     @Deprecated
   4618     public abstract void installPackage(
   4619             Uri packageURI,
   4620             IPackageInstallObserver observer,
   4621             @InstallFlags int flags,
   4622             String installerPackageName);
   4623     /**
   4624      * @deprecated replaced by {@link PackageInstaller}
   4625      * @hide
   4626      */
   4627     @Deprecated
   4628     public abstract void installPackage(
   4629             Uri packageURI,
   4630             PackageInstallObserver observer,
   4631             @InstallFlags int flags,
   4632             String installerPackageName);
   4633 
   4634     /**
   4635      * If there is already an application with the given package name installed
   4636      * on the system for other users, also install it for the calling user.
   4637      * @hide
   4638      */
   4639     public abstract int installExistingPackage(String packageName) throws NameNotFoundException;
   4640 
   4641     /**
   4642      * If there is already an application with the given package name installed
   4643      * on the system for other users, also install it for the calling user.
   4644      * @hide
   4645      */
   4646     public abstract int installExistingPackage(String packageName, @InstallReason int installReason)
   4647             throws NameNotFoundException;
   4648 
   4649     /**
   4650      * If there is already an application with the given package name installed
   4651      * on the system for other users, also install it for the specified user.
   4652      * @hide
   4653      */
   4654      @RequiresPermission(anyOf = {
   4655             Manifest.permission.INSTALL_PACKAGES,
   4656             Manifest.permission.INTERACT_ACROSS_USERS_FULL})
   4657     public abstract int installExistingPackageAsUser(String packageName, @UserIdInt int userId)
   4658             throws NameNotFoundException;
   4659 
   4660     /**
   4661      * Allows a package listening to the
   4662      * {@link Intent#ACTION_PACKAGE_NEEDS_VERIFICATION package verification
   4663      * broadcast} to respond to the package manager. The response must include
   4664      * the {@code verificationCode} which is one of
   4665      * {@link PackageManager#VERIFICATION_ALLOW} or
   4666      * {@link PackageManager#VERIFICATION_REJECT}.
   4667      *
   4668      * @param id pending package identifier as passed via the
   4669      *            {@link PackageManager#EXTRA_VERIFICATION_ID} Intent extra.
   4670      * @param verificationCode either {@link PackageManager#VERIFICATION_ALLOW}
   4671      *            or {@link PackageManager#VERIFICATION_REJECT}.
   4672      * @throws SecurityException if the caller does not have the
   4673      *            PACKAGE_VERIFICATION_AGENT permission.
   4674      */
   4675     public abstract void verifyPendingInstall(int id, int verificationCode);
   4676 
   4677     /**
   4678      * Allows a package listening to the
   4679      * {@link Intent#ACTION_PACKAGE_NEEDS_VERIFICATION package verification
   4680      * broadcast} to extend the default timeout for a response and declare what
   4681      * action to perform after the timeout occurs. The response must include
   4682      * the {@code verificationCodeAtTimeout} which is one of
   4683      * {@link PackageManager#VERIFICATION_ALLOW} or
   4684      * {@link PackageManager#VERIFICATION_REJECT}.
   4685      *
   4686      * This method may only be called once per package id. Additional calls
   4687      * will have no effect.
   4688      *
   4689      * @param id pending package identifier as passed via the
   4690      *            {@link PackageManager#EXTRA_VERIFICATION_ID} Intent extra.
   4691      * @param verificationCodeAtTimeout either
   4692      *            {@link PackageManager#VERIFICATION_ALLOW} or
   4693      *            {@link PackageManager#VERIFICATION_REJECT}. If
   4694      *            {@code verificationCodeAtTimeout} is neither
   4695      *            {@link PackageManager#VERIFICATION_ALLOW} or
   4696      *            {@link PackageManager#VERIFICATION_REJECT}, then
   4697      *            {@code verificationCodeAtTimeout} will default to
   4698      *            {@link PackageManager#VERIFICATION_REJECT}.
   4699      * @param millisecondsToDelay the amount of time requested for the timeout.
   4700      *            Must be positive and less than
   4701      *            {@link PackageManager#MAXIMUM_VERIFICATION_TIMEOUT}. If
   4702      *            {@code millisecondsToDelay} is out of bounds,
   4703      *            {@code millisecondsToDelay} will be set to the closest in
   4704      *            bounds value; namely, 0 or
   4705      *            {@link PackageManager#MAXIMUM_VERIFICATION_TIMEOUT}.
   4706      * @throws SecurityException if the caller does not have the
   4707      *            PACKAGE_VERIFICATION_AGENT permission.
   4708      */
   4709     public abstract void extendVerificationTimeout(int id,
   4710             int verificationCodeAtTimeout, long millisecondsToDelay);
   4711 
   4712     /**
   4713      * Allows a package listening to the
   4714      * {@link Intent#ACTION_INTENT_FILTER_NEEDS_VERIFICATION} intent filter verification
   4715      * broadcast to respond to the package manager. The response must include
   4716      * the {@code verificationCode} which is one of
   4717      * {@link PackageManager#INTENT_FILTER_VERIFICATION_SUCCESS} or
   4718      * {@link PackageManager#INTENT_FILTER_VERIFICATION_FAILURE}.
   4719      *
   4720      * @param verificationId pending package identifier as passed via the
   4721      *            {@link PackageManager#EXTRA_VERIFICATION_ID} Intent extra.
   4722      * @param verificationCode either {@link PackageManager#INTENT_FILTER_VERIFICATION_SUCCESS}
   4723      *            or {@link PackageManager#INTENT_FILTER_VERIFICATION_FAILURE}.
   4724      * @param failedDomains a list of failed domains if the verificationCode is
   4725      *            {@link PackageManager#INTENT_FILTER_VERIFICATION_FAILURE}, otherwise null;
   4726      * @throws SecurityException if the caller does not have the
   4727      *            INTENT_FILTER_VERIFICATION_AGENT permission.
   4728      *
   4729      * @hide
   4730      */
   4731     @SystemApi
   4732     @RequiresPermission(android.Manifest.permission.INTENT_FILTER_VERIFICATION_AGENT)
   4733     public abstract void verifyIntentFilter(int verificationId, int verificationCode,
   4734             List<String> failedDomains);
   4735 
   4736     /**
   4737      * Get the status of a Domain Verification Result for an IntentFilter. This is
   4738      * related to the {@link android.content.IntentFilter#setAutoVerify(boolean)} and
   4739      * {@link android.content.IntentFilter#getAutoVerify()}
   4740      *
   4741      * This is used by the ResolverActivity to change the status depending on what the User select
   4742      * in the Disambiguation Dialog and also used by the Settings App for changing the default App
   4743      * for a domain.
   4744      *
   4745      * @param packageName The package name of the Activity associated with the IntentFilter.
   4746      * @param userId The user id.
   4747      *
   4748      * @return The status to set to. This can be
   4749      *              {@link #INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK} or
   4750      *              {@link #INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS} or
   4751      *              {@link #INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER} or
   4752      *              {@link #INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED}
   4753      *
   4754      * @hide
   4755      */
   4756     @SystemApi
   4757     public abstract int getIntentVerificationStatusAsUser(String packageName, @UserIdInt int userId);
   4758 
   4759     /**
   4760      * Allow to change the status of a Intent Verification status for all IntentFilter of an App.
   4761      * This is related to the {@link android.content.IntentFilter#setAutoVerify(boolean)} and
   4762      * {@link android.content.IntentFilter#getAutoVerify()}
   4763      *
   4764      * This is used by the ResolverActivity to change the status depending on what the User select
   4765      * in the Disambiguation Dialog and also used by the Settings App for changing the default App
   4766      * for a domain.
   4767      *
   4768      * @param packageName The package name of the Activity associated with the IntentFilter.
   4769      * @param status The status to set to. This can be
   4770      *              {@link #INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK} or
   4771      *              {@link #INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS} or
   4772      *              {@link #INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER}
   4773      * @param userId The user id.
   4774      *
   4775      * @return true if the status has been set. False otherwise.
   4776      *
   4777      * @hide
   4778      */
   4779     @SystemApi
   4780     @RequiresPermission(android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
   4781     public abstract boolean updateIntentVerificationStatusAsUser(String packageName, int status,
   4782             @UserIdInt int userId);
   4783 
   4784     /**
   4785      * Get the list of IntentFilterVerificationInfo for a specific package and User.
   4786      *
   4787      * @param packageName the package name. When this parameter is set to a non null value,
   4788      *                    the results will be filtered by the package name provided.
   4789      *                    Otherwise, there will be no filtering and it will return a list
   4790      *                    corresponding for all packages
   4791      *
   4792      * @return a list of IntentFilterVerificationInfo for a specific package.
   4793      *
   4794      * @hide
   4795      */
   4796     @SystemApi
   4797     public abstract List<IntentFilterVerificationInfo> getIntentFilterVerifications(
   4798             String packageName);
   4799 
   4800     /**
   4801      * Get the list of IntentFilter for a specific package.
   4802      *
   4803      * @param packageName the package name. This parameter is set to a non null value,
   4804      *                    the list will contain all the IntentFilter for that package.
   4805      *                    Otherwise, the list will be empty.
   4806      *
   4807      * @return a list of IntentFilter for a specific package.
   4808      *
   4809      * @hide
   4810      */
   4811     @SystemApi
   4812     public abstract List<IntentFilter> getAllIntentFilters(String packageName);
   4813 
   4814     /**
   4815      * Get the default Browser package name for a specific user.
   4816      *
   4817      * @param userId The user id.
   4818      *
   4819      * @return the package name of the default Browser for the specified user. If the user id passed
   4820      *         is -1 (all users) it will return a null value.
   4821      *
   4822      * @hide
   4823      */
   4824     @TestApi
   4825     @SystemApi
   4826     public abstract String getDefaultBrowserPackageNameAsUser(@UserIdInt int userId);
   4827 
   4828     /**
   4829      * Set the default Browser package name for a specific user.
   4830      *
   4831      * @param packageName The package name of the default Browser.
   4832      * @param userId The user id.
   4833      *
   4834      * @return true if the default Browser for the specified user has been set,
   4835      *         otherwise return false. If the user id passed is -1 (all users) this call will not
   4836      *         do anything and just return false.
   4837      *
   4838      * @hide
   4839      */
   4840     @SystemApi
   4841     @RequiresPermission(android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
   4842     public abstract boolean setDefaultBrowserPackageNameAsUser(String packageName,
   4843             @UserIdInt int userId);
   4844 
   4845     /**
   4846      * Change the installer associated with a given package.  There are limitations
   4847      * on how the installer package can be changed; in particular:
   4848      * <ul>
   4849      * <li> A SecurityException will be thrown if <var>installerPackageName</var>
   4850      * is not signed with the same certificate as the calling application.
   4851      * <li> A SecurityException will be thrown if <var>targetPackage</var> already
   4852      * has an installer package, and that installer package is not signed with
   4853      * the same certificate as the calling application.
   4854      * </ul>
   4855      *
   4856      * @param targetPackage The installed package whose installer will be changed.
   4857      * @param installerPackageName The package name of the new installer.  May be
   4858      * null to clear the association.
   4859      */
   4860     public abstract void setInstallerPackageName(String targetPackage,
   4861             String installerPackageName);
   4862 
   4863     /** @hide */
   4864     @SystemApi
   4865     @RequiresPermission(Manifest.permission.INSTALL_PACKAGES)
   4866     public abstract void setUpdateAvailable(String packageName, boolean updateAvaialble);
   4867 
   4868     /**
   4869      * Attempts to delete a package. Since this may take a little while, the
   4870      * result will be posted back to the given observer. A deletion will fail if
   4871      * the calling context lacks the
   4872      * {@link android.Manifest.permission#DELETE_PACKAGES} permission, if the
   4873      * named package cannot be found, or if the named package is a system
   4874      * package.
   4875      *
   4876      * @param packageName The name of the package to delete
   4877      * @param observer An observer callback to get notified when the package
   4878      *            deletion is complete.
   4879      *            {@link android.content.pm.IPackageDeleteObserver#packageDeleted}
   4880      *            will be called when that happens. observer may be null to
   4881      *            indicate that no callback is desired.
   4882      * @hide
   4883      */
   4884     @RequiresPermission(Manifest.permission.DELETE_PACKAGES)
   4885     public abstract void deletePackage(String packageName, IPackageDeleteObserver observer,
   4886             @DeleteFlags int flags);
   4887 
   4888     /**
   4889      * Attempts to delete a package. Since this may take a little while, the
   4890      * result will be posted back to the given observer. A deletion will fail if
   4891      * the named package cannot be found, or if the named package is a system
   4892      * package.
   4893      *
   4894      * @param packageName The name of the package to delete
   4895      * @param observer An observer callback to get notified when the package
   4896      *            deletion is complete.
   4897      *            {@link android.content.pm.IPackageDeleteObserver#packageDeleted}
   4898      *            will be called when that happens. observer may be null to
   4899      *            indicate that no callback is desired.
   4900      * @param userId The user Id
   4901      * @hide
   4902      */
   4903     @RequiresPermission(anyOf = {
   4904             Manifest.permission.DELETE_PACKAGES,
   4905             Manifest.permission.INTERACT_ACROSS_USERS_FULL})
   4906     public abstract void deletePackageAsUser(@NonNull String packageName,
   4907             IPackageDeleteObserver observer, @DeleteFlags int flags, @UserIdInt int userId);
   4908 
   4909     /**
   4910      * Retrieve the package name of the application that installed a package. This identifies
   4911      * which market the package came from.
   4912      *
   4913      * @param packageName The name of the package to query
   4914      */
   4915     public abstract String getInstallerPackageName(String packageName);
   4916 
   4917     /**
   4918      * Attempts to clear the user data directory of an application.
   4919      * Since this may take a little while, the result will
   4920      * be posted back to the given observer.  A deletion will fail if the
   4921      * named package cannot be found, or if the named package is a "system package".
   4922      *
   4923      * @param packageName The name of the package
   4924      * @param observer An observer callback to get notified when the operation is finished
   4925      * {@link android.content.pm.IPackageDataObserver#onRemoveCompleted(String, boolean)}
   4926      * will be called when that happens.  observer may be null to indicate that
   4927      * no callback is desired.
   4928      *
   4929      * @hide
   4930      */
   4931     public abstract void clearApplicationUserData(String packageName,
   4932             IPackageDataObserver observer);
   4933     /**
   4934      * Attempts to delete the cache files associated with an application.
   4935      * Since this may take a little while, the result will
   4936      * be posted back to the given observer.  A deletion will fail if the calling context
   4937      * lacks the {@link android.Manifest.permission#DELETE_CACHE_FILES} permission, if the
   4938      * named package cannot be found, or if the named package is a "system package".
   4939      *
   4940      * @param packageName The name of the package to delete
   4941      * @param observer An observer callback to get notified when the cache file deletion
   4942      * is complete.
   4943      * {@link android.content.pm.IPackageDataObserver#onRemoveCompleted(String, boolean)}
   4944      * will be called when that happens.  observer may be null to indicate that
   4945      * no callback is desired.
   4946      *
   4947      * @hide
   4948      */
   4949     public abstract void deleteApplicationCacheFiles(String packageName,
   4950             IPackageDataObserver observer);
   4951 
   4952     /**
   4953      * Attempts to delete the cache files associated with an application for a given user. Since
   4954      * this may take a little while, the result will be posted back to the given observer. A
   4955      * deletion will fail if the calling context lacks the
   4956      * {@link android.Manifest.permission#DELETE_CACHE_FILES} permission, if the named package
   4957      * cannot be found, or if the named package is a "system package". If {@code userId} does not
   4958      * belong to the calling user, the caller must have
   4959      * {@link android.Manifest.permission#INTERACT_ACROSS_USERS} permission.
   4960      *
   4961      * @param packageName The name of the package to delete
   4962      * @param userId the user for which the cache files needs to be deleted
   4963      * @param observer An observer callback to get notified when the cache file deletion is
   4964      *            complete.
   4965      *            {@link android.content.pm.IPackageDataObserver#onRemoveCompleted(String, boolean)}
   4966      *            will be called when that happens. observer may be null to indicate that no
   4967      *            callback is desired.
   4968      * @hide
   4969      */
   4970     public abstract void deleteApplicationCacheFilesAsUser(String packageName, int userId,
   4971             IPackageDataObserver observer);
   4972 
   4973     /**
   4974      * Free storage by deleting LRU sorted list of cache files across
   4975      * all applications. If the currently available free storage
   4976      * on the device is greater than or equal to the requested
   4977      * free storage, no cache files are cleared. If the currently
   4978      * available storage on the device is less than the requested
   4979      * free storage, some or all of the cache files across
   4980      * all applications are deleted (based on last accessed time)
   4981      * to increase the free storage space on the device to
   4982      * the requested value. There is no guarantee that clearing all
   4983      * the cache files from all applications will clear up
   4984      * enough storage to achieve the desired value.
   4985      * @param freeStorageSize The number of bytes of storage to be
   4986      * freed by the system. Say if freeStorageSize is XX,
   4987      * and the current free storage is YY,
   4988      * if XX is less than YY, just return. if not free XX-YY number
   4989      * of bytes if possible.
   4990      * @param observer call back used to notify when
   4991      * the operation is completed
   4992      *
   4993      * @hide
   4994      */
   4995     public void freeStorageAndNotify(long freeStorageSize, IPackageDataObserver observer) {
   4996         freeStorageAndNotify(null, freeStorageSize, observer);
   4997     }
   4998 
   4999     /** {@hide} */
   5000     public abstract void freeStorageAndNotify(String volumeUuid, long freeStorageSize,
   5001             IPackageDataObserver observer);
   5002 
   5003     /**
   5004      * Free storage by deleting LRU sorted list of cache files across
   5005      * all applications. If the currently available free storage
   5006      * on the device is greater than or equal to the requested
   5007      * free storage, no cache files are cleared. If the currently
   5008      * available storage on the device is less than the requested
   5009      * free storage, some or all of the cache files across
   5010      * all applications are deleted (based on last accessed time)
   5011      * to increase the free storage space on the device to
   5012      * the requested value. There is no guarantee that clearing all
   5013      * the cache files from all applications will clear up
   5014      * enough storage to achieve the desired value.
   5015      * @param freeStorageSize The number of bytes of storage to be
   5016      * freed by the system. Say if freeStorageSize is XX,
   5017      * and the current free storage is YY,
   5018      * if XX is less than YY, just return. if not free XX-YY number
   5019      * of bytes if possible.
   5020      * @param pi IntentSender call back used to
   5021      * notify when the operation is completed.May be null
   5022      * to indicate that no call back is desired.
   5023      *
   5024      * @hide
   5025      */
   5026     public void freeStorage(long freeStorageSize, IntentSender pi) {
   5027         freeStorage(null, freeStorageSize, pi);
   5028     }
   5029 
   5030     /** {@hide} */
   5031     public abstract void freeStorage(String volumeUuid, long freeStorageSize, IntentSender pi);
   5032 
   5033     /**
   5034      * Retrieve the size information for a package.
   5035      * Since this may take a little while, the result will
   5036      * be posted back to the given observer.  The calling context
   5037      * should have the {@link android.Manifest.permission#GET_PACKAGE_SIZE} permission.
   5038      *
   5039      * @param packageName The name of the package whose size information is to be retrieved
   5040      * @param userId The user whose size information should be retrieved.
   5041      * @param observer An observer callback to get notified when the operation
   5042      * is complete.
   5043      * {@link android.content.pm.IPackageStatsObserver#onGetStatsCompleted(PackageStats, boolean)}
   5044      * The observer's callback is invoked with a PackageStats object(containing the
   5045      * code, data and cache sizes of the package) and a boolean value representing
   5046      * the status of the operation. observer may be null to indicate that
   5047      * no callback is desired.
   5048      *
   5049      * @deprecated use {@link StorageStatsManager} instead.
   5050      * @hide
   5051      */
   5052     @Deprecated
   5053     public abstract void getPackageSizeInfoAsUser(String packageName, @UserIdInt int userId,
   5054             IPackageStatsObserver observer);
   5055 
   5056     /**
   5057      * Like {@link #getPackageSizeInfoAsUser(String, int, IPackageStatsObserver)}, but
   5058      * returns the size for the calling user.
   5059      *
   5060      * @deprecated use {@link StorageStatsManager} instead.
   5061      * @hide
   5062      */
   5063     @Deprecated
   5064     public void getPackageSizeInfo(String packageName, IPackageStatsObserver observer) {
   5065         getPackageSizeInfoAsUser(packageName, UserHandle.myUserId(), observer);
   5066     }
   5067 
   5068     /**
   5069      * @deprecated This function no longer does anything; it was an old
   5070      * approach to managing preferred activities, which has been superseded
   5071      * by (and conflicts with) the modern activity-based preferences.
   5072      */
   5073     @Deprecated
   5074     public abstract void addPackageToPreferred(String packageName);
   5075 
   5076     /**
   5077      * @deprecated This function no longer does anything; it was an old
   5078      * approach to managing preferred activities, which has been superseded
   5079      * by (and conflicts with) the modern activity-based preferences.
   5080      */
   5081     @Deprecated
   5082     public abstract void removePackageFromPreferred(String packageName);
   5083 
   5084     /**
   5085      * Retrieve the list of all currently configured preferred packages. The
   5086      * first package on the list is the most preferred, the last is the least
   5087      * preferred.
   5088      *
   5089      * @param flags Additional option flags to modify the data returned.
   5090      * @return A List of PackageInfo objects, one for each preferred
   5091      *         application, in order of preference.
   5092      */
   5093     public abstract List<PackageInfo> getPreferredPackages(@PackageInfoFlags int flags);
   5094 
   5095     /**
   5096      * @deprecated This is a protected API that should not have been available
   5097      * to third party applications.  It is the platform's responsibility for
   5098      * assigning preferred activities and this cannot be directly modified.
   5099      *
   5100      * Add a new preferred activity mapping to the system.  This will be used
   5101      * to automatically select the given activity component when
   5102      * {@link Context#startActivity(Intent) Context.startActivity()} finds
   5103      * multiple matching activities and also matches the given filter.
   5104      *
   5105      * @param filter The set of intents under which this activity will be
   5106      * made preferred.
   5107      * @param match The IntentFilter match category that this preference
   5108      * applies to.
   5109      * @param set The set of activities that the user was picking from when
   5110      * this preference was made.
   5111      * @param activity The component name of the activity that is to be
   5112      * preferred.
   5113      */
   5114     @Deprecated
   5115     public abstract void addPreferredActivity(IntentFilter filter, int match,
   5116             ComponentName[] set, ComponentName activity);
   5117 
   5118     /**
   5119      * Same as {@link #addPreferredActivity(IntentFilter, int,
   5120             ComponentName[], ComponentName)}, but with a specific userId to apply the preference
   5121             to.
   5122      * @hide
   5123      */
   5124     public void addPreferredActivityAsUser(IntentFilter filter, int match,
   5125             ComponentName[] set, ComponentName activity, @UserIdInt int userId) {
   5126         throw new RuntimeException("Not implemented. Must override in a subclass.");
   5127     }
   5128 
   5129     /**
   5130      * @deprecated This is a protected API that should not have been available
   5131      * to third party applications.  It is the platform's responsibility for
   5132      * assigning preferred activities and this cannot be directly modified.
   5133      *
   5134      * Replaces an existing preferred activity mapping to the system, and if that were not present
   5135      * adds a new preferred activity.  This will be used
   5136      * to automatically select the given activity component when
   5137      * {@link Context#startActivity(Intent) Context.startActivity()} finds
   5138      * multiple matching activities and also matches the given filter.
   5139      *
   5140      * @param filter The set of intents under which this activity will be
   5141      * made preferred.
   5142      * @param match The IntentFilter match category that this preference
   5143      * applies to.
   5144      * @param set The set of activities that the user was picking from when
   5145      * this preference was made.
   5146      * @param activity The component name of the activity that is to be
   5147      * preferred.
   5148      * @hide
   5149      */
   5150     @Deprecated
   5151     public abstract void replacePreferredActivity(IntentFilter filter, int match,
   5152             ComponentName[] set, ComponentName activity);
   5153 
   5154     /**
   5155      * @hide
   5156      */
   5157     @Deprecated
   5158     public void replacePreferredActivityAsUser(IntentFilter filter, int match,
   5159            ComponentName[] set, ComponentName activity, @UserIdInt int userId) {
   5160         throw new RuntimeException("Not implemented. Must override in a subclass.");
   5161     }
   5162 
   5163     /**
   5164      * Remove all preferred activity mappings, previously added with
   5165      * {@link #addPreferredActivity}, from the
   5166      * system whose activities are implemented in the given package name.
   5167      * An application can only clear its own package(s).
   5168      *
   5169      * @param packageName The name of the package whose preferred activity
   5170      * mappings are to be removed.
   5171      */
   5172     public abstract void clearPackagePreferredActivities(String packageName);
   5173 
   5174     /**
   5175      * Retrieve all preferred activities, previously added with
   5176      * {@link #addPreferredActivity}, that are
   5177      * currently registered with the system.
   5178      *
   5179      * @param outFilters A required list in which to place the filters of all of the
   5180      * preferred activities.
   5181      * @param outActivities A required list in which to place the component names of
   5182      * all of the preferred activities.
   5183      * @param packageName An optional package in which you would like to limit
   5184      * the list.  If null, all activities will be returned; if non-null, only
   5185      * those activities in the given package are returned.
   5186      *
   5187      * @return Returns the total number of registered preferred activities
   5188      * (the number of distinct IntentFilter records, not the number of unique
   5189      * activity components) that were found.
   5190      */
   5191     public abstract int getPreferredActivities(@NonNull List<IntentFilter> outFilters,
   5192             @NonNull List<ComponentName> outActivities, String packageName);
   5193 
   5194     /**
   5195      * Ask for the set of available 'home' activities and the current explicit
   5196      * default, if any.
   5197      * @hide
   5198      */
   5199     public abstract ComponentName getHomeActivities(List<ResolveInfo> outActivities);
   5200 
   5201     /**
   5202      * Set the enabled setting for a package component (activity, receiver, service, provider).
   5203      * This setting will override any enabled state which may have been set by the component in its
   5204      * manifest.
   5205      *
   5206      * @param componentName The component to enable
   5207      * @param newState The new enabled state for the component.
   5208      * @param flags Optional behavior flags.
   5209      */
   5210     public abstract void setComponentEnabledSetting(ComponentName componentName,
   5211             @EnabledState int newState, @EnabledFlags int flags);
   5212 
   5213     /**
   5214      * Return the enabled setting for a package component (activity,
   5215      * receiver, service, provider).  This returns the last value set by
   5216      * {@link #setComponentEnabledSetting(ComponentName, int, int)}; in most
   5217      * cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since
   5218      * the value originally specified in the manifest has not been modified.
   5219      *
   5220      * @param componentName The component to retrieve.
   5221      * @return Returns the current enabled state for the component.
   5222      */
   5223     public abstract @EnabledState int getComponentEnabledSetting(
   5224             ComponentName componentName);
   5225 
   5226     /**
   5227      * Set the enabled setting for an application
   5228      * This setting will override any enabled state which may have been set by the application in
   5229      * its manifest.  It also overrides the enabled state set in the manifest for any of the
   5230      * application's components.  It does not override any enabled state set by
   5231      * {@link #setComponentEnabledSetting} for any of the application's components.
   5232      *
   5233      * @param packageName The package name of the application to enable
   5234      * @param newState The new enabled state for the application.
   5235      * @param flags Optional behavior flags.
   5236      */
   5237     public abstract void setApplicationEnabledSetting(String packageName,
   5238             @EnabledState int newState, @EnabledFlags int flags);
   5239 
   5240     /**
   5241      * Return the enabled setting for an application. This returns
   5242      * the last value set by
   5243      * {@link #setApplicationEnabledSetting(String, int, int)}; in most
   5244      * cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since
   5245      * the value originally specified in the manifest has not been modified.
   5246      *
   5247      * @param packageName The package name of the application to retrieve.
   5248      * @return Returns the current enabled state for the application.
   5249      * @throws IllegalArgumentException if the named package does not exist.
   5250      */
   5251     public abstract @EnabledState int getApplicationEnabledSetting(String packageName);
   5252 
   5253     /**
   5254      * Flush the package restrictions for a given user to disk. This forces the package restrictions
   5255      * like component and package enabled settings to be written to disk and avoids the delay that
   5256      * is otherwise present when changing those settings.
   5257      *
   5258      * @param userId Ther userId of the user whose restrictions are to be flushed.
   5259      * @hide
   5260      */
   5261     public abstract void flushPackageRestrictionsAsUser(int userId);
   5262 
   5263     /**
   5264      * Puts the package in a hidden state, which is almost like an uninstalled state,
   5265      * making the package unavailable, but it doesn't remove the data or the actual
   5266      * package file. Application can be unhidden by either resetting the hidden state
   5267      * or by installing it, such as with {@link #installExistingPackage(String)}
   5268      * @hide
   5269      */
   5270     public abstract boolean setApplicationHiddenSettingAsUser(String packageName, boolean hidden,
   5271             UserHandle userHandle);
   5272 
   5273     /**
   5274      * Returns the hidden state of a package.
   5275      * @see #setApplicationHiddenSettingAsUser(String, boolean, UserHandle)
   5276      * @hide
   5277      */
   5278     public abstract boolean getApplicationHiddenSettingAsUser(String packageName,
   5279             UserHandle userHandle);
   5280 
   5281     /**
   5282      * Return whether the device has been booted into safe mode.
   5283      */
   5284     public abstract boolean isSafeMode();
   5285 
   5286     /**
   5287      * Adds a listener for permission changes for installed packages.
   5288      *
   5289      * @param listener The listener to add.
   5290      *
   5291      * @hide
   5292      */
   5293     @SystemApi
   5294     @RequiresPermission(Manifest.permission.OBSERVE_GRANT_REVOKE_PERMISSIONS)
   5295     public abstract void addOnPermissionsChangeListener(OnPermissionsChangedListener listener);
   5296 
   5297     /**
   5298      * Remvoes a listener for permission changes for installed packages.
   5299      *
   5300      * @param listener The listener to remove.
   5301      *
   5302      * @hide
   5303      */
   5304     @SystemApi
   5305     @RequiresPermission(Manifest.permission.OBSERVE_GRANT_REVOKE_PERMISSIONS)
   5306     public abstract void removeOnPermissionsChangeListener(OnPermissionsChangedListener listener);
   5307 
   5308     /**
   5309      * Return the {@link KeySet} associated with the String alias for this
   5310      * application.
   5311      *
   5312      * @param alias The alias for a given {@link KeySet} as defined in the
   5313      *        application's AndroidManifest.xml.
   5314      * @hide
   5315      */
   5316     public abstract KeySet getKeySetByAlias(String packageName, String alias);
   5317 
   5318     /** Return the signing {@link KeySet} for this application.
   5319      * @hide
   5320      */
   5321     public abstract KeySet getSigningKeySet(String packageName);
   5322 
   5323     /**
   5324      * Return whether the package denoted by packageName has been signed by all
   5325      * of the keys specified by the {@link KeySet} ks.  This will return true if
   5326      * the package has been signed by additional keys (a superset) as well.
   5327      * Compare to {@link #isSignedByExactly(String packageName, KeySet ks)}.
   5328      * @hide
   5329      */
   5330     public abstract boolean isSignedBy(String packageName, KeySet ks);
   5331 
   5332     /**
   5333      * Return whether the package denoted by packageName has been signed by all
   5334      * of, and only, the keys specified by the {@link KeySet} ks. Compare to
   5335      * {@link #isSignedBy(String packageName, KeySet ks)}.
   5336      * @hide
   5337      */
   5338     public abstract boolean isSignedByExactly(String packageName, KeySet ks);
   5339 
   5340     /**
   5341      * Puts the package in a suspended state, where attempts at starting activities are denied.
   5342      *
   5343      * <p>It doesn't remove the data or the actual package file. The application notifications
   5344      * will be hidden, the application will not show up in recents, will not be able to show
   5345      * toasts or dialogs or ring the device.
   5346      *
   5347      * <p>The package must already be installed. If the package is uninstalled while suspended
   5348      * the package will no longer be suspended.
   5349      *
   5350      * @param packageNames The names of the packages to set the suspended status.
   5351      * @param suspended If set to {@code true} than the packages will be suspended, if set to
   5352      * {@code false} the packages will be unsuspended.
   5353      * @param userId The user id.
   5354      *
   5355      * @return an array of package names for which the suspended status is not set as requested in
   5356      * this method.
   5357      *
   5358      * @hide
   5359      */
   5360     public abstract String[] setPackagesSuspendedAsUser(
   5361             String[] packageNames, boolean suspended, @UserIdInt int userId);
   5362 
   5363     /**
   5364      * @see #setPackageSuspendedAsUser(String, boolean, int)
   5365      * @param packageName The name of the package to get the suspended status of.
   5366      * @param userId The user id.
   5367      * @return {@code true} if the package is suspended or {@code false} if the package is not
   5368      * suspended or could not be found.
   5369      * @hide
   5370      */
   5371     public abstract boolean isPackageSuspendedForUser(String packageName, int userId);
   5372 
   5373     /**
   5374      * Provide a hint of what the {@link ApplicationInfo#category} value should
   5375      * be for the given package.
   5376      * <p>
   5377      * This hint can only be set by the app which installed this package, as
   5378      * determined by {@link #getInstallerPackageName(String)}.
   5379      *
   5380      * @param packageName the package to change the category hint for.
   5381      * @param categoryHint the category hint to set.
   5382      */
   5383     public abstract void setApplicationCategoryHint(@NonNull String packageName,
   5384             @ApplicationInfo.Category int categoryHint);
   5385 
   5386     /** {@hide} */
   5387     public static boolean isMoveStatusFinished(int status) {
   5388         return (status < 0 || status > 100);
   5389     }
   5390 
   5391     /** {@hide} */
   5392     public static abstract class MoveCallback {
   5393         public void onCreated(int moveId, Bundle extras) {}
   5394         public abstract void onStatusChanged(int moveId, int status, long estMillis);
   5395     }
   5396 
   5397     /** {@hide} */
   5398     public abstract int getMoveStatus(int moveId);
   5399 
   5400     /** {@hide} */
   5401     public abstract void registerMoveCallback(MoveCallback callback, Handler handler);
   5402     /** {@hide} */
   5403     public abstract void unregisterMoveCallback(MoveCallback callback);
   5404 
   5405     /** {@hide} */
   5406     public abstract int movePackage(String packageName, VolumeInfo vol);
   5407     /** {@hide} */
   5408     public abstract @Nullable VolumeInfo getPackageCurrentVolume(ApplicationInfo app);
   5409     /** {@hide} */
   5410     public abstract @NonNull List<VolumeInfo> getPackageCandidateVolumes(ApplicationInfo app);
   5411 
   5412     /** {@hide} */
   5413     public abstract int movePrimaryStorage(VolumeInfo vol);
   5414     /** {@hide} */
   5415     public abstract @Nullable VolumeInfo getPrimaryStorageCurrentVolume();
   5416     /** {@hide} */
   5417     public abstract @NonNull List<VolumeInfo> getPrimaryStorageCandidateVolumes();
   5418 
   5419     /**
   5420      * Returns the device identity that verifiers can use to associate their scheme to a particular
   5421      * device. This should not be used by anything other than a package verifier.
   5422      *
   5423      * @return identity that uniquely identifies current device
   5424      * @hide
   5425      */
   5426     public abstract VerifierDeviceIdentity getVerifierDeviceIdentity();
   5427 
   5428     /**
   5429      * Returns true if the device is upgrading, such as first boot after OTA.
   5430      *
   5431      * @hide
   5432      */
   5433     public abstract boolean isUpgrade();
   5434 
   5435     /**
   5436      * Return interface that offers the ability to install, upgrade, and remove
   5437      * applications on the device.
   5438      */
   5439     public abstract @NonNull PackageInstaller getPackageInstaller();
   5440 
   5441     /**
   5442      * Adds a {@code CrossProfileIntentFilter}. After calling this method all
   5443      * intents sent from the user with id sourceUserId can also be be resolved
   5444      * by activities in the user with id targetUserId if they match the
   5445      * specified intent filter.
   5446      *
   5447      * @param filter The {@link IntentFilter} the intent has to match
   5448      * @param sourceUserId The source user id.
   5449      * @param targetUserId The target user id.
   5450      * @param flags The possible values are {@link #SKIP_CURRENT_PROFILE} and
   5451      *            {@link #ONLY_IF_NO_MATCH_FOUND}.
   5452      * @hide
   5453      */
   5454     public abstract void addCrossProfileIntentFilter(IntentFilter filter, int sourceUserId,
   5455             int targetUserId, int flags);
   5456 
   5457     /**
   5458      * Clearing {@code CrossProfileIntentFilter}s which have the specified user
   5459      * as their source, and have been set by the app calling this method.
   5460      *
   5461      * @param sourceUserId The source user id.
   5462      * @hide
   5463      */
   5464     public abstract void clearCrossProfileIntentFilters(int sourceUserId);
   5465 
   5466     /**
   5467      * @hide
   5468      */
   5469     public abstract Drawable loadItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo);
   5470 
   5471     /**
   5472      * @hide
   5473      */
   5474     public abstract Drawable loadUnbadgedItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo);
   5475 
   5476     /** {@hide} */
   5477     public abstract boolean isPackageAvailable(String packageName);
   5478 
   5479     /** {@hide} */
   5480     public static String installStatusToString(int status, String msg) {
   5481         final String str = installStatusToString(status);
   5482         if (msg != null) {
   5483             return str + ": " + msg;
   5484         } else {
   5485             return str;
   5486         }
   5487     }
   5488 
   5489     /** {@hide} */
   5490     public static String installStatusToString(int status) {
   5491         switch (status) {
   5492             case INSTALL_SUCCEEDED: return "INSTALL_SUCCEEDED";
   5493             case INSTALL_FAILED_ALREADY_EXISTS: return "INSTALL_FAILED_ALREADY_EXISTS";
   5494             case INSTALL_FAILED_INVALID_APK: return "INSTALL_FAILED_INVALID_APK";
   5495             case INSTALL_FAILED_INVALID_URI: return "INSTALL_FAILED_INVALID_URI";
   5496             case INSTALL_FAILED_INSUFFICIENT_STORAGE: return "INSTALL_FAILED_INSUFFICIENT_STORAGE";
   5497             case INSTALL_FAILED_DUPLICATE_PACKAGE: return "INSTALL_FAILED_DUPLICATE_PACKAGE";
   5498             case INSTALL_FAILED_NO_SHARED_USER: return "INSTALL_FAILED_NO_SHARED_USER";
   5499             case INSTALL_FAILED_UPDATE_INCOMPATIBLE: return "INSTALL_FAILED_UPDATE_INCOMPATIBLE";
   5500             case INSTALL_FAILED_SHARED_USER_INCOMPATIBLE: return "INSTALL_FAILED_SHARED_USER_INCOMPATIBLE";
   5501             case INSTALL_FAILED_MISSING_SHARED_LIBRARY: return "INSTALL_FAILED_MISSING_SHARED_LIBRARY";
   5502             case INSTALL_FAILED_REPLACE_COULDNT_DELETE: return "INSTALL_FAILED_REPLACE_COULDNT_DELETE";
   5503             case INSTALL_FAILED_DEXOPT: return "INSTALL_FAILED_DEXOPT";
   5504             case INSTALL_FAILED_OLDER_SDK: return "INSTALL_FAILED_OLDER_SDK";
   5505             case INSTALL_FAILED_CONFLICTING_PROVIDER: return "INSTALL_FAILED_CONFLICTING_PROVIDER";
   5506             case INSTALL_FAILED_NEWER_SDK: return "INSTALL_FAILED_NEWER_SDK";
   5507             case INSTALL_FAILED_TEST_ONLY: return "INSTALL_FAILED_TEST_ONLY";
   5508             case INSTALL_FAILED_CPU_ABI_INCOMPATIBLE: return "INSTALL_FAILED_CPU_ABI_INCOMPATIBLE";
   5509             case INSTALL_FAILED_MISSING_FEATURE: return "INSTALL_FAILED_MISSING_FEATURE";
   5510             case INSTALL_FAILED_CONTAINER_ERROR: return "INSTALL_FAILED_CONTAINER_ERROR";
   5511             case INSTALL_FAILED_INVALID_INSTALL_LOCATION: return "INSTALL_FAILED_INVALID_INSTALL_LOCATION";
   5512             case INSTALL_FAILED_MEDIA_UNAVAILABLE: return "INSTALL_FAILED_MEDIA_UNAVAILABLE";
   5513             case INSTALL_FAILED_VERIFICATION_TIMEOUT: return "INSTALL_FAILED_VERIFICATION_TIMEOUT";
   5514             case INSTALL_FAILED_VERIFICATION_FAILURE: return "INSTALL_FAILED_VERIFICATION_FAILURE";
   5515             case INSTALL_FAILED_PACKAGE_CHANGED: return "INSTALL_FAILED_PACKAGE_CHANGED";
   5516             case INSTALL_FAILED_UID_CHANGED: return "INSTALL_FAILED_UID_CHANGED";
   5517             case INSTALL_FAILED_VERSION_DOWNGRADE: return "INSTALL_FAILED_VERSION_DOWNGRADE";
   5518             case INSTALL_PARSE_FAILED_NOT_APK: return "INSTALL_PARSE_FAILED_NOT_APK";
   5519             case INSTALL_PARSE_FAILED_BAD_MANIFEST: return "INSTALL_PARSE_FAILED_BAD_MANIFEST";
   5520             case INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION: return "INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION";
   5521             case INSTALL_PARSE_FAILED_NO_CERTIFICATES: return "INSTALL_PARSE_FAILED_NO_CERTIFICATES";
   5522             case INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES: return "INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES";
   5523             case INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING: return "INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING";
   5524             case INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME: return "INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME";
   5525             case INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID: return "INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID";
   5526             case INSTALL_PARSE_FAILED_MANIFEST_MALFORMED: return "INSTALL_PARSE_FAILED_MANIFEST_MALFORMED";
   5527             case INSTALL_PARSE_FAILED_MANIFEST_EMPTY: return "INSTALL_PARSE_FAILED_MANIFEST_EMPTY";
   5528             case INSTALL_FAILED_INTERNAL_ERROR: return "INSTALL_FAILED_INTERNAL_ERROR";
   5529             case INSTALL_FAILED_USER_RESTRICTED: return "INSTALL_FAILED_USER_RESTRICTED";
   5530             case INSTALL_FAILED_DUPLICATE_PERMISSION: return "INSTALL_FAILED_DUPLICATE_PERMISSION";
   5531             case INSTALL_FAILED_NO_MATCHING_ABIS: return "INSTALL_FAILED_NO_MATCHING_ABIS";
   5532             case INSTALL_FAILED_ABORTED: return "INSTALL_FAILED_ABORTED";
   5533             default: return Integer.toString(status);
   5534         }
   5535     }
   5536 
   5537     /** {@hide} */
   5538     public static int installStatusToPublicStatus(int status) {
   5539         switch (status) {
   5540             case INSTALL_SUCCEEDED: return PackageInstaller.STATUS_SUCCESS;
   5541             case INSTALL_FAILED_ALREADY_EXISTS: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5542             case INSTALL_FAILED_INVALID_APK: return PackageInstaller.STATUS_FAILURE_INVALID;
   5543             case INSTALL_FAILED_INVALID_URI: return PackageInstaller.STATUS_FAILURE_INVALID;
   5544             case INSTALL_FAILED_INSUFFICIENT_STORAGE: return PackageInstaller.STATUS_FAILURE_STORAGE;
   5545             case INSTALL_FAILED_DUPLICATE_PACKAGE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5546             case INSTALL_FAILED_NO_SHARED_USER: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5547             case INSTALL_FAILED_UPDATE_INCOMPATIBLE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5548             case INSTALL_FAILED_SHARED_USER_INCOMPATIBLE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5549             case INSTALL_FAILED_MISSING_SHARED_LIBRARY: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
   5550             case INSTALL_FAILED_REPLACE_COULDNT_DELETE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5551             case INSTALL_FAILED_DEXOPT: return PackageInstaller.STATUS_FAILURE_INVALID;
   5552             case INSTALL_FAILED_OLDER_SDK: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
   5553             case INSTALL_FAILED_CONFLICTING_PROVIDER: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5554             case INSTALL_FAILED_NEWER_SDK: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
   5555             case INSTALL_FAILED_TEST_ONLY: return PackageInstaller.STATUS_FAILURE_INVALID;
   5556             case INSTALL_FAILED_CPU_ABI_INCOMPATIBLE: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
   5557             case INSTALL_FAILED_MISSING_FEATURE: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
   5558             case INSTALL_FAILED_CONTAINER_ERROR: return PackageInstaller.STATUS_FAILURE_STORAGE;
   5559             case INSTALL_FAILED_INVALID_INSTALL_LOCATION: return PackageInstaller.STATUS_FAILURE_STORAGE;
   5560             case INSTALL_FAILED_MEDIA_UNAVAILABLE: return PackageInstaller.STATUS_FAILURE_STORAGE;
   5561             case INSTALL_FAILED_VERIFICATION_TIMEOUT: return PackageInstaller.STATUS_FAILURE_ABORTED;
   5562             case INSTALL_FAILED_VERIFICATION_FAILURE: return PackageInstaller.STATUS_FAILURE_ABORTED;
   5563             case INSTALL_FAILED_PACKAGE_CHANGED: return PackageInstaller.STATUS_FAILURE_INVALID;
   5564             case INSTALL_FAILED_UID_CHANGED: return PackageInstaller.STATUS_FAILURE_INVALID;
   5565             case INSTALL_FAILED_VERSION_DOWNGRADE: return PackageInstaller.STATUS_FAILURE_INVALID;
   5566             case INSTALL_FAILED_PERMISSION_MODEL_DOWNGRADE: return PackageInstaller.STATUS_FAILURE_INVALID;
   5567             case INSTALL_PARSE_FAILED_NOT_APK: return PackageInstaller.STATUS_FAILURE_INVALID;
   5568             case INSTALL_PARSE_FAILED_BAD_MANIFEST: return PackageInstaller.STATUS_FAILURE_INVALID;
   5569             case INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION: return PackageInstaller.STATUS_FAILURE_INVALID;
   5570             case INSTALL_PARSE_FAILED_NO_CERTIFICATES: return PackageInstaller.STATUS_FAILURE_INVALID;
   5571             case INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES: return PackageInstaller.STATUS_FAILURE_INVALID;
   5572             case INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING: return PackageInstaller.STATUS_FAILURE_INVALID;
   5573             case INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME: return PackageInstaller.STATUS_FAILURE_INVALID;
   5574             case INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID: return PackageInstaller.STATUS_FAILURE_INVALID;
   5575             case INSTALL_PARSE_FAILED_MANIFEST_MALFORMED: return PackageInstaller.STATUS_FAILURE_INVALID;
   5576             case INSTALL_PARSE_FAILED_MANIFEST_EMPTY: return PackageInstaller.STATUS_FAILURE_INVALID;
   5577             case INSTALL_FAILED_INTERNAL_ERROR: return PackageInstaller.STATUS_FAILURE;
   5578             case INSTALL_FAILED_USER_RESTRICTED: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
   5579             case INSTALL_FAILED_DUPLICATE_PERMISSION: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5580             case INSTALL_FAILED_NO_MATCHING_ABIS: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
   5581             case INSTALL_FAILED_ABORTED: return PackageInstaller.STATUS_FAILURE_ABORTED;
   5582             default: return PackageInstaller.STATUS_FAILURE;
   5583         }
   5584     }
   5585 
   5586     /** {@hide} */
   5587     public static String deleteStatusToString(int status, String msg) {
   5588         final String str = deleteStatusToString(status);
   5589         if (msg != null) {
   5590             return str + ": " + msg;
   5591         } else {
   5592             return str;
   5593         }
   5594     }
   5595 
   5596     /** {@hide} */
   5597     public static String deleteStatusToString(int status) {
   5598         switch (status) {
   5599             case DELETE_SUCCEEDED: return "DELETE_SUCCEEDED";
   5600             case DELETE_FAILED_INTERNAL_ERROR: return "DELETE_FAILED_INTERNAL_ERROR";
   5601             case DELETE_FAILED_DEVICE_POLICY_MANAGER: return "DELETE_FAILED_DEVICE_POLICY_MANAGER";
   5602             case DELETE_FAILED_USER_RESTRICTED: return "DELETE_FAILED_USER_RESTRICTED";
   5603             case DELETE_FAILED_OWNER_BLOCKED: return "DELETE_FAILED_OWNER_BLOCKED";
   5604             case DELETE_FAILED_ABORTED: return "DELETE_FAILED_ABORTED";
   5605             case DELETE_FAILED_USED_SHARED_LIBRARY: return "DELETE_FAILED_USED_SHARED_LIBRARY";
   5606             default: return Integer.toString(status);
   5607         }
   5608     }
   5609 
   5610     /** {@hide} */
   5611     public static int deleteStatusToPublicStatus(int status) {
   5612         switch (status) {
   5613             case DELETE_SUCCEEDED: return PackageInstaller.STATUS_SUCCESS;
   5614             case DELETE_FAILED_INTERNAL_ERROR: return PackageInstaller.STATUS_FAILURE;
   5615             case DELETE_FAILED_DEVICE_POLICY_MANAGER: return PackageInstaller.STATUS_FAILURE_BLOCKED;
   5616             case DELETE_FAILED_USER_RESTRICTED: return PackageInstaller.STATUS_FAILURE_BLOCKED;
   5617             case DELETE_FAILED_OWNER_BLOCKED: return PackageInstaller.STATUS_FAILURE_BLOCKED;
   5618             case DELETE_FAILED_ABORTED: return PackageInstaller.STATUS_FAILURE_ABORTED;
   5619             case DELETE_FAILED_USED_SHARED_LIBRARY: return PackageInstaller.STATUS_FAILURE_CONFLICT;
   5620             default: return PackageInstaller.STATUS_FAILURE;
   5621         }
   5622     }
   5623 
   5624     /** {@hide} */
   5625     public static String permissionFlagToString(int flag) {
   5626         switch (flag) {
   5627             case FLAG_PERMISSION_GRANTED_BY_DEFAULT: return "GRANTED_BY_DEFAULT";
   5628             case FLAG_PERMISSION_POLICY_FIXED: return "POLICY_FIXED";
   5629             case FLAG_PERMISSION_SYSTEM_FIXED: return "SYSTEM_FIXED";
   5630             case FLAG_PERMISSION_USER_SET: return "USER_SET";
   5631             case FLAG_PERMISSION_REVOKE_ON_UPGRADE: return "REVOKE_ON_UPGRADE";
   5632             case FLAG_PERMISSION_USER_FIXED: return "USER_FIXED";
   5633             case FLAG_PERMISSION_REVIEW_REQUIRED: return "REVIEW_REQUIRED";
   5634             default: return Integer.toString(flag);
   5635         }
   5636     }
   5637 
   5638     /** {@hide} */
   5639     public static class LegacyPackageInstallObserver extends PackageInstallObserver {
   5640         private final IPackageInstallObserver mLegacy;
   5641 
   5642         public LegacyPackageInstallObserver(IPackageInstallObserver legacy) {
   5643             mLegacy = legacy;
   5644         }
   5645 
   5646         @Override
   5647         public void onPackageInstalled(String basePackageName, int returnCode, String msg,
   5648                 Bundle extras) {
   5649             if (mLegacy == null) return;
   5650             try {
   5651                 mLegacy.packageInstalled(basePackageName, returnCode);
   5652             } catch (RemoteException ignored) {
   5653             }
   5654         }
   5655     }
   5656 
   5657     /** {@hide} */
   5658     public static class LegacyPackageDeleteObserver extends PackageDeleteObserver {
   5659         private final IPackageDeleteObserver mLegacy;
   5660 
   5661         public LegacyPackageDeleteObserver(IPackageDeleteObserver legacy) {
   5662             mLegacy = legacy;
   5663         }
   5664 
   5665         @Override
   5666         public void onPackageDeleted(String basePackageName, int returnCode, String msg) {
   5667             if (mLegacy == null) return;
   5668             try {
   5669                 mLegacy.packageDeleted(basePackageName, returnCode);
   5670             } catch (RemoteException ignored) {
   5671             }
   5672         }
   5673     }
   5674 
   5675     /**
   5676      * Return the install reason that was recorded when a package was first
   5677      * installed for a specific user. Requesting the install reason for another
   5678      * user will require the permission INTERACT_ACROSS_USERS_FULL.
   5679      *
   5680      * @param packageName The package for which to retrieve the install reason
   5681      * @param user The user for whom to retrieve the install reason
   5682      * @return The install reason. If the package is not installed for the given
   5683      *         user, {@code INSTALL_REASON_UNKNOWN} is returned.
   5684      * @hide
   5685      */
   5686     @TestApi
   5687     public abstract @InstallReason int getInstallReason(String packageName,
   5688             @NonNull UserHandle user);
   5689 
   5690     /**
   5691      * Checks whether the calling package is allowed to request package installs through package
   5692      * installer. Apps are encouraged to call this API before launching the package installer via
   5693      * intent {@link android.content.Intent#ACTION_INSTALL_PACKAGE}. Starting from Android O, the
   5694      * user can explicitly choose what external sources they trust to install apps on the device.
   5695      * If this API returns false, the install request will be blocked by the package installer and
   5696      * a dialog will be shown to the user with an option to launch settings to change their
   5697      * preference. An application must target Android O or higher and declare permission
   5698      * {@link android.Manifest.permission#REQUEST_INSTALL_PACKAGES} in order to use this API.
   5699      *
   5700      * @return true if the calling package is trusted by the user to request install packages on
   5701      * the device, false otherwise.
   5702      * @see android.content.Intent#ACTION_INSTALL_PACKAGE
   5703      * @see android.provider.Settings#ACTION_MANAGE_UNKNOWN_APP_SOURCES
   5704      */
   5705     public abstract boolean canRequestPackageInstalls();
   5706 
   5707     /**
   5708      * Return the {@link ComponentName} of the activity providing Settings for the Instant App
   5709      * resolver.
   5710      *
   5711      * @see {@link android.content.Intent#ACTION_INSTANT_APP_RESOLVER_SETTINGS}
   5712      * @hide
   5713      */
   5714     @SystemApi
   5715     public abstract ComponentName getInstantAppResolverSettingsComponent();
   5716 
   5717     /**
   5718      * Return the {@link ComponentName} of the activity responsible for installing instant
   5719      * applications.
   5720      *
   5721      * @see {@link android.content.Intent#ACTION_INSTALL_INSTANT_APP_PACKAGE}
   5722      * @hide
   5723      */
   5724     @SystemApi
   5725     public abstract ComponentName getInstantAppInstallerComponent();
   5726 
   5727     /**
   5728      * Return the Android Id for a given Instant App.
   5729      *
   5730      * @see {@link android.provider.Settings.Secure#ANDROID_ID}
   5731      * @hide
   5732      */
   5733     public abstract String getInstantAppAndroidId(String packageName, @NonNull UserHandle user);
   5734 }
   5735