PackageManagerpublic abstract class PackageManager extends Object | Class for retrieving various kinds of information related to the application
packages that are currently installed on the device.
You can find this class through {@link Context#getPackageManager}. |
| Fields Summary |
|---|
| public static final int | GET_ACTIVITIES{@link PackageInfo} flag: return information about
activities in the package in {@link PackageInfo#activities}. | | public static final int | GET_RECEIVERS{@link PackageInfo} flag: return information about
intent receivers in the package in
{@link PackageInfo#receivers}. | | public static final int | GET_SERVICES{@link PackageInfo} flag: return information about
services in the package in {@link PackageInfo#services}. | | public static final int | GET_PROVIDERS{@link PackageInfo} flag: return information about
content providers in the package in
{@link PackageInfo#providers}. | | public static final int | GET_INSTRUMENTATION{@link PackageInfo} flag: return information about
instrumentation in the package in
{@link PackageInfo#instrumentation}. | | public static final int | GET_INTENT_FILTERS{@link PackageInfo} flag: return information about the
intent filters supported by the activity. | | public static final int | GET_SIGNATURES{@link PackageInfo} flag: return information about the
signatures included in the package. | | public static final int | GET_RESOLVED_FILTER{@link ResolveInfo} flag: return the IntentFilter that
was matched for a particular ResolveInfo in
{@link ResolveInfo#filter}. | | public static final int | GET_META_DATA{@link ComponentInfo} flag: return the {@link ComponentInfo#metaData}
data {@link android.os.Bundle}s that are associated with a component.
This applies for any API returning a ComponentInfo subclass. | | public static final int | GET_GIDS{@link PackageInfo} flag: return the
{@link PackageInfo#gids group ids} that are associated with an
application.
This applies for any API returning a PackageInfo class, either
directly or nested inside of another. | | public static final int | GET_DISABLED_COMPONENTS{@link PackageInfo} flag: include disabled components in the returned info. | | public static final int | GET_SHARED_LIBRARY_FILES{@link ApplicationInfo} flag: return the
{@link ApplicationInfo#sharedLibraryFiles paths to the shared libraries}
that are associated with an application.
This applies for any API returning an ApplicationInfo class, either
directly or nested inside of another. | | public static final int | GET_URI_PERMISSION_PATTERNS{@link ProviderInfo} flag: return the
{@link ProviderInfo#uriPermissionPatterns URI permission patterns}
that are associated with a content provider.
This applies for any API returning a ProviderInfo class, either
directly or nested inside of another. | | public static final int | GET_PERMISSIONS{@link PackageInfo} flag: return information about
permissions in the package in
{@link PackageInfo#permissions}. | | public static final int | GET_UNINSTALLED_PACKAGESFlag parameter to retrieve some information about all applications (even
uninstalled ones) which have data directories. This state could have
resulted if applications have been deleted with flag
{@code DONT_DELETE_DATA} with a possibility of being replaced or
reinstalled in future.
Note: this flag may cause less information about currently installed
applications to be returned. | | public static final int | GET_CONFIGURATIONS{@link PackageInfo} flag: return information about
hardware preferences in
{@link PackageInfo#configPreferences PackageInfo.configPreferences},
and requested features in {@link PackageInfo#reqFeatures} and
{@link PackageInfo#featureGroups}. | | public static final int | GET_DISABLED_UNTIL_USED_COMPONENTS{@link PackageInfo} flag: include disabled components which are in
that state only because of {@link #COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED}
in the returned info. Note that if you set this flag, applications
that are in this disabled state will be reported as enabled. | | public static final int | MATCH_DEFAULT_ONLYResolution and querying flag: if set, only filters that support the
{@link android.content.Intent#CATEGORY_DEFAULT} will be considered for
matching. This is a synonym for including the CATEGORY_DEFAULT in your
supplied Intent. | | public static final int | SKIP_CURRENT_PROFILEFlag for {@link addCrossProfileIntentFilter}: if this flag is set:
when resolving an intent that matches the {@link CrossProfileIntentFilter}, the current
profile will be skipped.
Only activities in the target user can respond to the intent. | | public static final int | PERMISSION_GRANTEDPermission check result: this is returned by {@link #checkPermission}
if the permission has been granted to the given package. | | public static final int | PERMISSION_DENIEDPermission check result: this is returned by {@link #checkPermission}
if the permission has not been granted to the given package. | | public static final int | SIGNATURE_MATCHSignature check result: this is returned by {@link #checkSignatures}
if all signatures on the two packages match. | | public static final int | SIGNATURE_NEITHER_SIGNEDSignature check result: this is returned by {@link #checkSignatures}
if neither of the two packages is signed. | | public static final int | SIGNATURE_FIRST_NOT_SIGNEDSignature check result: this is returned by {@link #checkSignatures}
if the first package is not signed but the second is. | | public static final int | SIGNATURE_SECOND_NOT_SIGNEDSignature check result: this is returned by {@link #checkSignatures}
if the second package is not signed but the first is. | | public static final int | SIGNATURE_NO_MATCHSignature check result: this is returned by {@link #checkSignatures}
if not all signatures on both packages match. | | public static final int | SIGNATURE_UNKNOWN_PACKAGESignature check result: this is returned by {@link #checkSignatures}
if either of the packages are not valid. | | public static final int | COMPONENT_ENABLED_STATE_DEFAULTFlag for {@link #setApplicationEnabledSetting(String, int, int)}
and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
component or application is in its default enabled state (as specified
in its manifest). | | public static final int | COMPONENT_ENABLED_STATE_ENABLEDFlag for {@link #setApplicationEnabledSetting(String, int, int)}
and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
component or application has been explictily enabled, regardless of
what it has specified in its manifest. | | public static final int | COMPONENT_ENABLED_STATE_DISABLEDFlag for {@link #setApplicationEnabledSetting(String, int, int)}
and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
component or application has been explicitly disabled, regardless of
what it has specified in its manifest. | | public static final int | COMPONENT_ENABLED_STATE_DISABLED_USERFlag for {@link #setApplicationEnabledSetting(String, int, int)} only: The
user has explicitly disabled the application, regardless of what it has
specified in its manifest. Because this is due to the user's request,
they may re-enable it if desired through the appropriate system UI. This
option currently cannot be used with
{@link #setComponentEnabledSetting(ComponentName, int, int)}. | | public static final int | COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USEDFlag for {@link #setApplicationEnabledSetting(String, int, int)} only: This
application should be considered, until the point where the user actually
wants to use it. This means that it will not normally show up to the user
(such as in the launcher), but various parts of the user interface can
use {@link #GET_DISABLED_UNTIL_USED_COMPONENTS} to still see it and allow
the user to select it (as for example an IME, device admin, etc). Such code,
once the user has selected the app, should at that point also make it enabled.
This option currently can not be used with
{@link #setComponentEnabledSetting(ComponentName, int, int)}. | | public static final int | INSTALL_FORWARD_LOCKFlag parameter for {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} to
indicate that this package should be installed as forward locked, i.e. only the app itself
should have access to its code and non-resource assets. | | public static final int | INSTALL_REPLACE_EXISTINGFlag parameter for {@link #installPackage} to indicate that you want to replace an already
installed package, if one exists. | | public static final int | INSTALL_ALLOW_TESTFlag parameter for {@link #installPackage} to indicate that you want to
allow test packages (those that have set android:testOnly in their
manifest) to be installed. | | public static final int | INSTALL_EXTERNALFlag parameter for {@link #installPackage} to indicate that this
package has to be installed on the sdcard. | | public static final int | INSTALL_INTERNALFlag parameter for {@link #installPackage} to indicate that this package
has to be installed on the sdcard. | | public static final int | INSTALL_FROM_ADBFlag parameter for {@link #installPackage} to indicate that this install
was initiated via ADB. | | public static final int | INSTALL_ALL_USERSFlag parameter for {@link #installPackage} to indicate that this install
should immediately be visible to all users. | | public static final int | INSTALL_ALLOW_DOWNGRADEFlag parameter for {@link #installPackage} to indicate that it is okay
to install an update to an app where the newly installed app has a lower
version code than the currently installed app. | | public static final int | DONT_KILL_APPFlag parameter for
{@link #setComponentEnabledSetting(android.content.ComponentName, int, int)} to indicate
that you don't want to kill the app containing the component. Be careful when you set this
since changing component states can make the containing application's behavior unpredictable. | | public static final int | INSTALL_SUCCEEDEDInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} on success. | | public static final int | INSTALL_FAILED_ALREADY_EXISTSInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package is
already installed. | | public static final int | INSTALL_FAILED_INVALID_APKInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package archive
file is invalid. | | public static final int | INSTALL_FAILED_INVALID_URIInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the URI passed in
is invalid. | | public static final int | INSTALL_FAILED_INSUFFICIENT_STORAGEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package manager
service found that the device didn't have enough storage space to install the app. | | public static final int | INSTALL_FAILED_DUPLICATE_PACKAGEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if a
package is already installed with the same name. | | public static final int | INSTALL_FAILED_NO_SHARED_USERInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the requested shared user does not exist. | | public static final int | INSTALL_FAILED_UPDATE_INCOMPATIBLEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
a previously installed package of the same name has a different signature
than the new package (and the old package's data was not removed). | | public static final int | INSTALL_FAILED_SHARED_USER_INCOMPATIBLEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package is requested a shared user which is already installed on the
device and does not have matching signature. | | public static final int | INSTALL_FAILED_MISSING_SHARED_LIBRARYInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package uses a shared library that is not available. | | public static final int | INSTALL_FAILED_REPLACE_COULDNT_DELETEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package uses a shared library that is not available. | | public static final int | INSTALL_FAILED_DEXOPTInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package failed while optimizing and validating its dex files,
either because there was not enough storage or the validation failed. | | public static final int | INSTALL_FAILED_OLDER_SDKInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package failed because the current SDK version is older than
that required by the package. | | public static final int | INSTALL_FAILED_CONFLICTING_PROVIDERInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package failed because it contains a content provider with the
same authority as a provider already installed in the system. | | public static final int | INSTALL_FAILED_NEWER_SDKInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package failed because the current SDK version is newer than
that required by the package. | | public static final int | INSTALL_FAILED_TEST_ONLYInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package failed because it has specified that it is a test-only
package and the caller has not supplied the {@link #INSTALL_ALLOW_TEST}
flag. | | public static final int | INSTALL_FAILED_CPU_ABI_INCOMPATIBLEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the package being installed contains native code, but none that is
compatible with the device's CPU_ABI. | | public static final int | INSTALL_FAILED_MISSING_FEATUREInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package uses a feature that is not available. | | public static final int | INSTALL_FAILED_CONTAINER_ERRORInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
a secure container mount point couldn't be accessed on external media. | | public static final int | INSTALL_FAILED_INVALID_INSTALL_LOCATIONInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package couldn't be installed in the specified install
location. | | public static final int | INSTALL_FAILED_MEDIA_UNAVAILABLEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package couldn't be installed in the specified install
location because the media is not available. | | public static final int | INSTALL_FAILED_VERIFICATION_TIMEOUTInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package couldn't be installed because the verification timed out. | | public static final int | INSTALL_FAILED_VERIFICATION_FAILUREInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package couldn't be installed because the verification did not succeed. | | public static final int | INSTALL_FAILED_PACKAGE_CHANGEDInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the package changed from what the calling program expected. | | public static final int | INSTALL_FAILED_UID_CHANGEDInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package is assigned a different UID than it previously held. | | public static final int | INSTALL_FAILED_VERSION_DOWNGRADEInstallation return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
the new package has an older version code than the currently installed package. | | public static final int | INSTALL_PARSE_FAILED_NOT_APKInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser was given a path that is not a file, or does not end with the expected
'.apk' extension. | | public static final int | INSTALL_PARSE_FAILED_BAD_MANIFESTInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser was unable to retrieve the AndroidManifest.xml file. | | public static final int | INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTIONInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser encountered an unexpected exception. | | public static final int | INSTALL_PARSE_FAILED_NO_CERTIFICATESInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser did not find any certificates in the .apk. | | public static final int | INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATESInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser found inconsistent certificates on the files in the .apk. | | public static final int | INSTALL_PARSE_FAILED_CERTIFICATE_ENCODINGInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser encountered a CertificateEncodingException in one of the
files in the .apk. | | public static final int | INSTALL_PARSE_FAILED_BAD_PACKAGE_NAMEInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser encountered a bad or missing package name in the manifest. | | public static final int | INSTALL_PARSE_FAILED_BAD_SHARED_USER_IDInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser encountered a bad shared user id name in the manifest. | | public static final int | INSTALL_PARSE_FAILED_MANIFEST_MALFORMEDInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser encountered some structural problem in the manifest. | | public static final int | INSTALL_PARSE_FAILED_MANIFEST_EMPTYInstallation parse return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the parser did not find any actionable tags (instrumentation or application)
in the manifest. | | public static final int | INSTALL_FAILED_INTERNAL_ERRORInstallation failed return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the system failed to install the package because of system issues. | | public static final int | INSTALL_FAILED_USER_RESTRICTEDInstallation failed return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the system failed to install the package because the user is restricted from installing
apps. | | public static final int | INSTALL_FAILED_DUPLICATE_PERMISSIONInstallation failed return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the system failed to install the package because it is attempting to define a
permission that is already defined by some existing package.
The package name of the app which has already defined the permission is passed to
a {@link PackageInstallObserver}, if any, as the {@link #EXTRA_EXISTING_PACKAGE}
string extra; and the name of the permission being redefined is passed in the
{@link #EXTRA_EXISTING_PERMISSION} string extra. | | public static final int | INSTALL_FAILED_NO_MATCHING_ABISInstallation failed return code: this is passed to the {@link IPackageInstallObserver} by
{@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
if the system failed to install the package because its packaged native code did not
match any of the ABIs supported by the system. | | public static final int | NO_NATIVE_LIBRARIESInternal return code for NativeLibraryHelper methods to indicate that the package
being processed did not contain any native code. This is placed here only so that
it can belong to the same value space as the other install failure codes. | | public static final int | INSTALL_FAILED_ABORTED{@hide} | | public static final int | DELETE_KEEP_DATAFlag parameter for {@link #deletePackage} to indicate that you don't want to delete the
package's data directory. | | public static final int | DELETE_ALL_USERSFlag parameter for {@link #deletePackage} to indicate that you want the
package deleted for all users. | | public static final int | DELETE_SYSTEM_APPFlag parameter for {@link #deletePackage} to indicate that, if you are calling
uninstall on a system that has been updated, then don't do the normal process
of uninstalling the update and rolling back to the older system version (which
needs to happen for all users); instead, just mark the app as uninstalled for
the current user. | | public static final int | DELETE_SUCCEEDEDReturn code for when package deletion succeeds. This is passed to the
{@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
succeeded in deleting the package. | | public static final int | DELETE_FAILED_INTERNAL_ERRORDeletion failed return code: this is passed to the
{@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
failed to delete the package for an unspecified reason. | | public static final int | DELETE_FAILED_DEVICE_POLICY_MANAGERDeletion failed return code: this is passed to the
{@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
failed to delete the package because it is the active DevicePolicy
manager. | | public static final int | DELETE_FAILED_USER_RESTRICTEDDeletion failed return code: this is passed to the
{@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
failed to delete the package since the user is restricted. | | public static final int | DELETE_FAILED_OWNER_BLOCKEDDeletion failed return code: this is passed to the
{@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
failed to delete the package because a profile
or device owner has marked the package as uninstallable. | | public static final int | DELETE_FAILED_ABORTED{@hide} | | public static final int | MOVE_SUCCEEDEDReturn code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)} when the
package has been successfully moved by the system. | | public static final int | MOVE_FAILED_INSUFFICIENT_STORAGEError code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)}
when the package hasn't been successfully moved by the system
because of insufficient memory on specified media. | | public static final int | MOVE_FAILED_DOESNT_EXISTError code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)}
if the specified package doesn't exist. | | public static final int | MOVE_FAILED_SYSTEM_PACKAGEError code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)}
if the specified package cannot be moved since its a system package. | | public static final int | MOVE_FAILED_FORWARD_LOCKEDError code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)}
if the specified package cannot be moved since its forward locked. | | public static final int | MOVE_FAILED_INVALID_LOCATIONError code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)}
if the specified package cannot be moved to the specified location. | | public static final int | MOVE_FAILED_INTERNAL_ERRORError code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)}
if the specified package cannot be moved to the specified location. | | public static final int | MOVE_FAILED_OPERATION_PENDINGError code that is passed to the {@link IPackageMoveObserver} by
{@link #movePackage(android.net.Uri, IPackageMoveObserver)} if the
specified package already has an operation pending in the
{@link PackageHandler} queue. | | public static final int | MOVE_INTERNALFlag parameter for {@link #movePackage} to indicate that
the package should be moved to internal storage if its
been installed on external media. | | public static final int | MOVE_EXTERNAL_MEDIAFlag parameter for {@link #movePackage} to indicate that
the package should be moved to external media. | | public static final int | VERIFICATION_ALLOW_WITHOUT_SUFFICIENTUsable by the required verifier as the {@code verificationCode} argument
for {@link PackageManager#verifyPendingInstall} to indicate that it will
allow the installation to proceed without any of the optional verifiers
needing to vote. | | public static final int | VERIFICATION_ALLOWUsed as the {@code verificationCode} argument for
{@link PackageManager#verifyPendingInstall} to indicate that the calling
package verifier allows the installation to proceed. | | public static final int | VERIFICATION_REJECTUsed as the {@code verificationCode} argument for
{@link PackageManager#verifyPendingInstall} to indicate the calling
package verifier does not vote to allow the installation to proceed. | | public static final long | MAXIMUM_VERIFICATION_TIMEOUTCan be used as the {@code millisecondsToDelay} argument for
{@link PackageManager#extendVerificationTimeout}. This is the
maximum time {@code PackageManager} waits for the verification
agent to return (in milliseconds). | | public static final String | FEATURE_AUDIO_LOW_LATENCYFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: The device's
audio pipeline is low-latency, more suitable for audio applications sensitive to delays or
lag in sound input or output. | | public static final String | FEATURE_AUDIO_OUTPUTFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes at least one form of audio
output, such as speakers, audio jack or streaming over bluetooth | | public static final String | FEATURE_BLUETOOTHFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device is capable of communicating with
other devices via Bluetooth. | | public static final String | FEATURE_BLUETOOTH_LEFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device is capable of communicating with
other devices via Bluetooth Low Energy radio. | | public static final String | FEATURE_CAMERAFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device has a camera facing away
from the screen. | | public static final String | FEATURE_CAMERA_AUTOFOCUSFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device's camera supports auto-focus. | | public static final String | FEATURE_CAMERA_ANYFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device has at least one camera pointing in
some direction, or can support an external camera being connected to it. | | public static final String | FEATURE_CAMERA_EXTERNALFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device can support having an external camera connected to it.
The external camera may not always be connected or available to applications to use. | | public static final String | FEATURE_CAMERA_FLASHFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device's camera supports flash. | | public static final String | FEATURE_CAMERA_FRONTFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device has a front facing camera. | | public static final String | FEATURE_CAMERA_LEVEL_FULLFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
of the cameras on the device supports the
{@link android.hardware.camera2.CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL full hardware}
capability level. | | public static final String | FEATURE_CAMERA_CAPABILITY_MANUAL_SENSORFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
of the cameras on the device supports the
{@link android.hardware.camera2.CameraMetadata#REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR manual sensor}
capability level. | | public static final String | FEATURE_CAMERA_CAPABILITY_MANUAL_POST_PROCESSINGFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
of the cameras on the device supports the
{@link android.hardware.camera2.CameraMetadata#REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING manual post-processing}
capability level. | | public static final String | FEATURE_CAMERA_CAPABILITY_RAWFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: At least one
of the cameras on the device supports the
{@link android.hardware.camera2.CameraMetadata#REQUEST_AVAILABLE_CAPABILITIES_RAW RAW}
capability level. | | public static final String | FEATURE_CONSUMER_IRFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device is capable of communicating with
consumer IR devices. | | public static final String | FEATURE_LOCATIONFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports one or more methods of
reporting current location. | | public static final String | FEATURE_LOCATION_GPSFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device has a Global Positioning System
receiver and can report precise location. | | public static final String | FEATURE_LOCATION_NETWORKFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device can report location with coarse
accuracy using a network-based geolocation system. | | public static final String | FEATURE_MICROPHONEFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device can record audio via a
microphone. | | public static final String | FEATURE_NFCFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device can communicate using Near-Field
Communications (NFC). | | public static final String | FEATURE_NFC_HCEFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports host-
based NFC card emulation.
TODO remove when depending apps have moved to new constant. | | public static final String | FEATURE_NFC_HOST_CARD_EMULATIONFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports host-
based NFC card emulation. | | public static final String | FEATURE_OPENGLES_EXTENSION_PACKFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports the OpenGL ES
Android Extension Pack. | | public static final String | FEATURE_SENSOR_ACCELEROMETERFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes an accelerometer. | | public static final String | FEATURE_SENSOR_BAROMETERFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a barometer (air
pressure sensor.) | | public static final String | FEATURE_SENSOR_COMPASSFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a magnetometer (compass). | | public static final String | FEATURE_SENSOR_GYROSCOPEFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a gyroscope. | | public static final String | FEATURE_SENSOR_LIGHTFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a light sensor. | | public static final String | FEATURE_SENSOR_PROXIMITYFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a proximity sensor. | | public static final String | FEATURE_SENSOR_STEP_COUNTERFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a hardware step counter. | | public static final String | FEATURE_SENSOR_STEP_DETECTORFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a hardware step detector. | | public static final String | FEATURE_SENSOR_HEART_RATEFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a heart rate monitor. | | public static final String | FEATURE_SENSOR_HEART_RATE_ECGFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The heart rate sensor on this device is an Electrocargiogram. | | public static final String | FEATURE_SENSOR_RELATIVE_HUMIDITYFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes a relative humidity sensor. | | public static final String | FEATURE_SENSOR_AMBIENT_TEMPERATUREFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device includes an ambient temperature sensor. | | public static final String | FEATURE_TELEPHONYFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device has a telephony radio with data
communication support. | | public static final String | FEATURE_TELEPHONY_CDMAFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device has a CDMA telephony stack. | | public static final String | FEATURE_TELEPHONY_GSMFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device has a GSM telephony stack. | | public static final String | FEATURE_USB_HOSTFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports connecting to USB devices
as the USB host. | | public static final String | FEATURE_USB_ACCESSORYFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports connecting to USB accessories. | | public static final String | FEATURE_SIPFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The SIP API is enabled on the device. | | public static final String | FEATURE_SIP_VOIPFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports SIP-based VOIP. | | public static final String | FEATURE_CONNECTION_SERVICEFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The Connection Service API is enabled on the device. | | public static final String | FEATURE_TOUCHSCREENFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device's display has a touch screen. | | public static final String | FEATURE_TOUCHSCREEN_MULTITOUCHFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device's touch screen supports
multitouch sufficient for basic two-finger gesture detection. | | public static final String | FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCTFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device's touch screen is capable of
tracking two or more fingers fully independently. | | public static final String | FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHANDFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device's touch screen is capable of
tracking a full hand of fingers fully independently -- that is, 5 or
more simultaneous independent pointers. | | public static final String | FEATURE_FAKETOUCHFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device does not have a touch screen, but
does support touch emulation for basic events. For instance, the
device might use a mouse or remote control to drive a cursor, and
emulate basic touch pointer events like down, up, drag, etc. All
devices that support android.hardware.touchscreen or a sub-feature are
presumed to also support faketouch. | | public static final String | FEATURE_FAKETOUCH_MULTITOUCH_DISTINCTFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device does not have a touch screen, but
does support touch emulation for basic events that supports distinct
tracking of two or more fingers. This is an extension of
{@link #FEATURE_FAKETOUCH} for input devices with this capability. Note
that unlike a distinct multitouch screen as defined by
{@link #FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT}, these kinds of input
devices will not actually provide full two-finger gestures since the
input is being transformed to cursor movement on the screen. That is,
single finger gestures will move a cursor; two-finger swipes will
result in single-finger touch events; other two-finger gestures will
result in the corresponding two-finger touch event. | | public static final String | FEATURE_FAKETOUCH_MULTITOUCH_JAZZHANDFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device does not have a touch screen, but
does support touch emulation for basic events that supports tracking
a hand of fingers (5 or more fingers) fully independently.
This is an extension of
{@link #FEATURE_FAKETOUCH} for input devices with this capability. Note
that unlike a multitouch screen as defined by
{@link #FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND}, not all two finger
gestures can be detected due to the limitations described for
{@link #FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT}. | | public static final String | FEATURE_SCREEN_PORTRAITFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports portrait orientation
screens. For backwards compatibility, you can assume that if neither
this nor {@link #FEATURE_SCREEN_LANDSCAPE} is set then the device supports
both portrait and landscape. | | public static final String | FEATURE_SCREEN_LANDSCAPEFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports landscape orientation
screens. For backwards compatibility, you can assume that if neither
this nor {@link #FEATURE_SCREEN_PORTRAIT} is set then the device supports
both portrait and landscape. | | public static final String | FEATURE_LIVE_WALLPAPERFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports live wallpapers. | | public static final String | FEATURE_APP_WIDGETSFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports app widgets. | | public static final String | FEATURE_VOICE_RECOGNIZERS | | public static final String | FEATURE_HOME_SCREENFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports a home screen that is replaceable
by third party applications. | | public static final String | FEATURE_INPUT_METHODSFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports adding new input methods implemented
with the {@link android.inputmethodservice.InputMethodService} API. | | public static final String | FEATURE_DEVICE_ADMINFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports device policy enforcement via device admins. | | public static final String | FEATURE_LEANBACKFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports leanback UI. This is
typically used in a living room television experience, but is a software
feature unlike {@link #FEATURE_TELEVISION}. Devices running with this
feature will use resources associated with the "television" UI mode. | | public static final String | FEATURE_LEANBACK_ONLYFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports only leanback UI. Only
applications designed for this experience should be run, though this is
not enforced by the system. | | public static final String | FEATURE_LIVE_TVFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports live TV and can display
contents from TV inputs implemented with the
{@link android.media.tv.TvInputService} API. | | public static final String | FEATURE_WIFIFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports WiFi (802.11) networking. | | public static final String | FEATURE_WIFI_DIRECTFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: The device supports Wi-Fi Direct networking. | | public static final String | FEATURE_TELEVISIONFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: This is a device dedicated to showing UI
on a television. Television here is defined to be a typical living
room television experience: displayed on a big screen, where the user
is sitting far away from it, and the dominant form of input will be
something like a DPAD, not through touch or mouse. | | public static final String | FEATURE_WATCHFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: This is a device dedicated to showing UI
on a watch. A watch here is defined to be a device worn on the body, perhaps on
the wrist. The user is very close when interacting with the device. | | public static final String | FEATURE_PRINTINGFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
The device supports printing. | | public static final String | FEATURE_BACKUPFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
The device can perform backup and restore operations on installed applications. | | public static final String | FEATURE_MANAGED_USERSFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
The device supports creating secondary users and managed profiles via
{@link DevicePolicyManager}. | | public static final String | FEATURE_MANAGED_PROFILES | | public static final String | FEATURE_VERIFIED_BOOTFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
The device supports verified boot. | | public static final String | FEATURE_SECURELY_REMOVES_USERSFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
The device supports secure removal of users. When a user is deleted the data associated
with that user is securely deleted and no longer available. | | public static final String | FEATURE_WEBVIEWFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
The device has a full implementation of the android.webkit.* APIs. Devices
lacking this feature will not have a functioning WebView implementation. | | public static final String | FEATURE_ETHERNETFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: This device supports ethernet. | | public static final String | FEATURE_HDMI_CECFeature for {@link #getSystemAvailableFeatures} and
{@link #hasSystemFeature}: This device supports HDMI-CEC. | | public static final String | FEATURE_GAMEPADFeature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
The device has all of the inputs necessary to be considered a compatible game controller, or
includes a compatible game controller in the box. | | public static final String | ACTION_CLEAN_EXTERNAL_STORAGEAction to external storage service to clean out removed apps. | | public static final String | EXTRA_VERIFICATION_URIExtra field name for the URI to a verification file. Passed to a package
verifier. | | public static final String | EXTRA_VERIFICATION_IDExtra field name for the ID of a package pending verification. Passed to
a package verifier and is used to call back to
{@link PackageManager#verifyPendingInstall(int, int)} | | public static final String | EXTRA_VERIFICATION_INSTALLER_PACKAGEExtra field name for the package identifier which is trying to install
the package. | | public static final String | EXTRA_VERIFICATION_INSTALL_FLAGSExtra field name for the requested install flags for a package pending
verification. Passed to a package verifier. | | public static final String | EXTRA_VERIFICATION_INSTALLER_UIDExtra field name for the uid of who is requesting to install
the package. | | public static final String | EXTRA_VERIFICATION_PACKAGE_NAMEExtra field name for the package name of a package pending verification. | | public static final String | EXTRA_VERIFICATION_RESULTExtra field name for the result of a verification, either
{@link #VERIFICATION_ALLOW}, or {@link #VERIFICATION_REJECT}.
Passed to package verifiers after a package is verified. | | public static final String | EXTRA_VERIFICATION_VERSION_CODEExtra field name for the version code of a package pending verification. | | public static final String | ACTION_REQUEST_PERMISSIONThe action used to request that the user approve a permission request
from the application. | | public static final String | EXTRA_REQUEST_PERMISSION_PERMISSION_LISTExtra field name for the list of permissions, which the user must approve. | | public static final String | EXTRA_FAILURE_EXISTING_PACKAGEString extra for {@link PackageInstallObserver} in the 'extras' Bundle in case of
{@link #INSTALL_FAILED_DUPLICATE_PERMISSION}. This extra names the package which provides
the existing definition for the permission. | | public static final String | EXTRA_FAILURE_EXISTING_PERMISSIONString extra for {@link PackageInstallObserver} in the 'extras' Bundle in case of
{@link #INSTALL_FAILED_DUPLICATE_PERMISSION}. This extra names the permission that is
being redundantly defined by the package being installed. |
| Methods Summary |
|---|
| public abstract void | addCrossProfileIntentFilter(android.content.IntentFilter filter, int sourceUserId, int targetUserId, int flags)Adds a {@link CrossProfileIntentFilter}. After calling this method all intents sent from the
user with id sourceUserId can also be be resolved by activities in the user with id
targetUserId if they match the specified intent filter.
| | public abstract void | addPackageToPreferred(java.lang.String packageName)
| | public abstract boolean | addPermission(PermissionInfo info)Add a new dynamic permission to the system. For this to work, your
package must have defined a permission tree through the
{@link android.R.styleable#AndroidManifestPermissionTree
<permission-tree>} tag in its manifest. A package can only add
permissions to trees that were defined by either its own package or
another with the same user id; a permission is in a tree if it
matches the name of the permission tree + ".": for example,
"com.foo.bar" is a member of the permission tree "com.foo".
It is good to make your permission tree name descriptive, because you
are taking possession of that entire set of permission names. Thus, it
must be under a domain you control, with a suffix that will not match
any normal permissions that may be declared in any applications that
are part of that domain.
New permissions must be added before
any .apks are installed that use those permissions. Permissions you
add through this method are remembered across reboots of the device.
If the given permission already exists, the info you supply here
will be used to update it.
| | public abstract boolean | addPermissionAsync(PermissionInfo info)Like {@link #addPermission(PermissionInfo)} but asynchronously
persists the package manager state after returning from the call,
allowing it to return quicker and batch a series of adds at the
expense of no guarantee the added permission will be retained if
the device is rebooted before it is written.
| | public abstract void | addPreferredActivity(android.content.IntentFilter filter, int match, android.content.ComponentName[] set, android.content.ComponentName activity)
| | public void | addPreferredActivity(android.content.IntentFilter filter, int match, android.content.ComponentName[] set, android.content.ComponentName activity, int userId)Same as {@link #addPreferredActivity(IntentFilter, int,
ComponentName[], ComponentName)}, but with a specific userId to apply the preference
to.
throw new RuntimeException("Not implemented. Must override in a subclass.");
| | public android.content.Intent | buildPermissionRequestIntent(java.lang.String permissions)Returns an {@link Intent} suitable for passing to {@code startActivityForResult}
which prompts the user to grant {@code permissions} to this application.
if (permissions == null) {
throw new NullPointerException("permissions cannot be null");
}
for (String permission : permissions) {
if (permission == null) {
throw new IllegalArgumentException("permissions cannot contain null");
}
}
Intent i = new Intent(ACTION_REQUEST_PERMISSION);
i.putExtra(EXTRA_REQUEST_PERMISSION_PERMISSION_LIST, permissions);
i.setPackage("com.android.packageinstaller");
return i;
| | public abstract java.lang.String[] | canonicalToCurrentPackageNames(java.lang.String[] names)Map from a packages canonical name to the current name in use on the device.
| | public abstract int | checkPermission(java.lang.String permName, java.lang.String pkgName)Check whether a particular package has been granted a particular
permission.
| | public abstract int | checkSignatures(java.lang.String pkg1, java.lang.String pkg2)Compare the signatures of two packages to determine if the same
signature appears in both of them. If they do contain the same
signature, then they are allowed special privileges when working
with each other: they can share the same user-id, run instrumentation
against each other, etc.
| | public abstract int | checkSignatures(int uid1, int uid2)Like {@link #checkSignatures(String, String)}, but takes UIDs of
the two packages to be checked. This can be useful, for example,
when doing the check in an IPC, where the UID is the only identity
available. It is functionally identical to determining the package
associated with the UIDs and checking their signatures.
| | public abstract void | clearApplicationUserData(java.lang.String packageName, IPackageDataObserver observer)Attempts to clear the user data directory of an application.
Since this may take a little while, the result will
be posted back to the given observer. A deletion will fail if the
named package cannot be found, or if the named package is a "system package".
| | public abstract void | clearCrossProfileIntentFilters(int sourceUserId)Clearing {@link CrossProfileIntentFilter}s which have the specified user as their
source, and have been set by the app calling this method.
| | public abstract void | clearPackagePreferredActivities(java.lang.String packageName)Remove all preferred activity mappings, previously added with
{@link #addPreferredActivity}, from the
system whose activities are implemented in the given package name.
An application can only clear its own package(s).
| | public abstract java.lang.String[] | currentToCanonicalPackageNames(java.lang.String[] names)Map from the current package names in use on the device to whatever
the current canonical name of that package is.
| | public abstract void | deleteApplicationCacheFiles(java.lang.String packageName, IPackageDataObserver observer)Attempts to delete the cache files associated with an application.
Since this may take a little while, the result will
be posted back to the given observer. A deletion will fail if the calling context
lacks the {@link android.Manifest.permission#DELETE_CACHE_FILES} permission, if the
named package cannot be found, or if the named package is a "system package".
| | public abstract void | deletePackage(java.lang.String packageName, IPackageDeleteObserver observer, int flags)Attempts to delete a package. Since this may take a little while, the result will
be posted back to the given observer. A deletion will fail if the calling context
lacks the {@link android.Manifest.permission#DELETE_PACKAGES} permission, if the
named package cannot be found, or if the named package is a "system package".
(TODO: include pointer to documentation on "system packages")
| | public static int | deleteStatusToPublicStatus(int status){@hide}
switch (status) {
case DELETE_SUCCEEDED: return PackageInstaller.STATUS_SUCCESS;
case DELETE_FAILED_INTERNAL_ERROR: return PackageInstaller.STATUS_FAILURE;
case DELETE_FAILED_DEVICE_POLICY_MANAGER: return PackageInstaller.STATUS_FAILURE_BLOCKED;
case DELETE_FAILED_USER_RESTRICTED: return PackageInstaller.STATUS_FAILURE_BLOCKED;
case DELETE_FAILED_OWNER_BLOCKED: return PackageInstaller.STATUS_FAILURE_BLOCKED;
case DELETE_FAILED_ABORTED: return PackageInstaller.STATUS_FAILURE_ABORTED;
default: return PackageInstaller.STATUS_FAILURE;
}
| | public static java.lang.String | deleteStatusToString(int status, java.lang.String msg){@hide}
final String str = deleteStatusToString(status);
if (msg != null) {
return str + ": " + msg;
} else {
return str;
}
| | public static java.lang.String | deleteStatusToString(int status){@hide}
switch (status) {
case DELETE_SUCCEEDED: return "DELETE_SUCCEEDED";
case DELETE_FAILED_INTERNAL_ERROR: return "DELETE_FAILED_INTERNAL_ERROR";
case DELETE_FAILED_DEVICE_POLICY_MANAGER: return "DELETE_FAILED_DEVICE_POLICY_MANAGER";
case DELETE_FAILED_USER_RESTRICTED: return "DELETE_FAILED_USER_RESTRICTED";
case DELETE_FAILED_OWNER_BLOCKED: return "DELETE_FAILED_OWNER_BLOCKED";
case DELETE_FAILED_ABORTED: return "DELETE_FAILED_ABORTED";
default: return Integer.toString(status);
}
| | public abstract void | extendVerificationTimeout(int id, int verificationCodeAtTimeout, long millisecondsToDelay)Allows a package listening to the
{@link Intent#ACTION_PACKAGE_NEEDS_VERIFICATION package verification
broadcast} to extend the default timeout for a response and declare what
action to perform after the timeout occurs. The response must include
the {@code verificationCodeAtTimeout} which is one of
{@link PackageManager#VERIFICATION_ALLOW} or
{@link PackageManager#VERIFICATION_REJECT}.
This method may only be called once per package id. Additional calls
will have no effect.
| | public abstract void | freeStorage(long freeStorageSize, android.content.IntentSender pi)Free storage by deleting LRU sorted list of cache files across
all applications. If the currently available free storage
on the device is greater than or equal to the requested
free storage, no cache files are cleared. If the currently
available storage on the device is less than the requested
free storage, some or all of the cache files across
all applications are deleted (based on last accessed time)
to increase the free storage space on the device to
the requested value. There is no guarantee that clearing all
the cache files from all applications will clear up
enough storage to achieve the desired value.
| | public abstract void | freeStorageAndNotify(long freeStorageSize, IPackageDataObserver observer)Free storage by deleting LRU sorted list of cache files across
all applications. If the currently available free storage
on the device is greater than or equal to the requested
free storage, no cache files are cleared. If the currently
available storage on the device is less than the requested
free storage, some or all of the cache files across
all applications are deleted (based on last accessed time)
to increase the free storage space on the device to
the requested value. There is no guarantee that clearing all
the cache files from all applications will clear up
enough storage to achieve the desired value.
| | public abstract android.graphics.drawable.Drawable | getActivityBanner(android.content.ComponentName activityName)Retrieve the banner associated with an activity. Given the full name of
an activity, retrieves the information about it and calls
{@link ComponentInfo#loadIcon ComponentInfo.loadIcon()} to return its
banner. If the activity cannot be found, NameNotFoundException is thrown.
| | public abstract android.graphics.drawable.Drawable | getActivityBanner(android.content.Intent intent)Retrieve the banner associated with an Intent. If intent.getClassName()
is set, this simply returns the result of
getActivityBanner(intent.getClassName()). Otherwise it resolves the
intent's component and returns the banner associated with the resolved
component. If intent.getClassName() cannot be found or the Intent cannot
be resolved to a component, NameNotFoundException is thrown.
| | public abstract android.graphics.drawable.Drawable | getActivityIcon(android.content.ComponentName activityName)Retrieve the icon associated with an activity. Given the full name of
an activity, retrieves the information about it and calls
{@link ComponentInfo#loadIcon ComponentInfo.loadIcon()} to return its icon.
If the activity cannot be found, NameNotFoundException is thrown.
| | public abstract android.graphics.drawable.Drawable | getActivityIcon(android.content.Intent intent)Retrieve the icon associated with an Intent. If intent.getClassName() is
set, this simply returns the result of
getActivityIcon(intent.getClassName()). Otherwise it resolves the intent's
component and returns the icon associated with the resolved component.
If intent.getClassName() cannot be found or the Intent cannot be resolved
to a component, NameNotFoundException is thrown.
| | public abstract ActivityInfo | getActivityInfo(android.content.ComponentName component, int flags)Retrieve all of the information we know about a particular activity
class.
Throws {@link NameNotFoundException} if an activity with the given
class name cannot be found on the system.
| | public abstract android.graphics.drawable.Drawable | getActivityLogo(android.content.ComponentName activityName)Retrieve the logo associated with an activity. Given the full name of an
activity, retrieves the information about it and calls
{@link ComponentInfo#loadLogo ComponentInfo.loadLogo()} to return its
logo. If the activity cannot be found, NameNotFoundException is thrown.
| | public abstract android.graphics.drawable.Drawable | getActivityLogo(android.content.Intent intent)Retrieve the logo associated with an Intent. If intent.getClassName() is
set, this simply returns the result of
getActivityLogo(intent.getClassName()). Otherwise it resolves the intent's
component and returns the logo associated with the resolved component.
If intent.getClassName() cannot be found or the Intent cannot be resolved
to a component, NameNotFoundException is thrown.
| | public abstract java.util.List | getAllPermissionGroups(int flags)Retrieve all of the known permission groups in the system.
| | public abstract android.graphics.drawable.Drawable | getApplicationBanner(ApplicationInfo info)Retrieve the banner associated with an application.
| | public abstract android.graphics.drawable.Drawable | getApplicationBanner(java.lang.String packageName)Retrieve the banner associated with an application. Given the name of the
application's package, retrieves the information about it and calls
getApplicationIcon() to return its banner. If the application cannot be
found, NameNotFoundException is thrown.
| | public abstract int | getApplicationEnabledSetting(java.lang.String packageName)Return the enabled setting for an application. This returns
the last value set by
{@link #setApplicationEnabledSetting(String, int, int)}; in most
cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since
the value originally specified in the manifest has not been modified.
| | public abstract boolean | getApplicationHiddenSettingAsUser(java.lang.String packageName, android.os.UserHandle userHandle)Returns the hidden state of a package.
| | public abstract android.graphics.drawable.Drawable | getApplicationIcon(ApplicationInfo info)Retrieve the icon associated with an application. If it has not defined
an icon, the default app icon is returned. Does not return null.
| | public abstract android.graphics.drawable.Drawable | getApplicationIcon(java.lang.String packageName)Retrieve the icon associated with an application. Given the name of the
application's package, retrieves the information about it and calls
getApplicationIcon() to return its icon. If the application cannot be
found, NameNotFoundException is thrown.
| | public abstract ApplicationInfo | getApplicationInfo(java.lang.String packageName, int flags)Retrieve all of the information we know about a particular
package/application.
Throws {@link NameNotFoundException} if an application with the given
package name cannot be found on the system.
| | public abstract java.lang.CharSequence | getApplicationLabel(ApplicationInfo info)Return the label to use for this application.
| | public abstract android.graphics.drawable.Drawable | getApplicationLogo(ApplicationInfo info)Retrieve the logo associated with an application. If it has not specified
a logo, this method returns null.
| | public abstract android.graphics.drawable.Drawable | getApplicationLogo(java.lang.String packageName)Retrieve the logo associated with an application. Given the name of the
application's package, retrieves the information about it and calls
getApplicationLogo() to return its logo. If the application cannot be
found, NameNotFoundException is thrown.
| | public abstract int | getComponentEnabledSetting(android.content.ComponentName componentName)Return the enabled setting for a package component (activity,
receiver, service, provider). This returns the last value set by
{@link #setComponentEnabledSetting(ComponentName, int, int)}; in most
cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since
the value originally specified in the manifest has not been modified.
| | public static java.lang.String | getDataDirForUser(int userId, java.lang.String packageName)Returns the data directory for a particular user and package, given the uid of the package.
// TODO: This should be shared with Installer's knowledge of user directory
return Environment.getDataDirectory().toString() + "/user/" + userId
+ "/" + packageName;
| | public abstract android.graphics.drawable.Drawable | getDefaultActivityIcon()Return the generic icon for an activity that is used when no specific
icon is defined.
| | public abstract android.graphics.drawable.Drawable | getDrawable(java.lang.String packageName, int resid, ApplicationInfo appInfo)Retrieve an image from a package. This is a low-level API used by
the various package manager info structures (such as
{@link ComponentInfo} to implement retrieval of their associated
icon.
| | public abstract android.content.ComponentName | getHomeActivities(java.util.List outActivities)Ask for the set of available 'home' activities and the current explicit
default, if any.
| | public abstract java.util.List | getInstalledApplications(int flags)Return a List of all application packages that are installed on the
device. If flag GET_UNINSTALLED_PACKAGES has been set, a list of all
applications including those deleted with {@code DONT_DELETE_DATA} (partially
installed apps with data directory) will be returned.
| | public abstract java.util.List | getInstalledPackages(int flags)Return a List of all packages that are installed
on the device.
| | public abstract java.util.List | getInstalledPackages(int flags, int userId)Return a List of all packages that are installed on the device, for a specific user.
Requesting a list of installed packages for another user
will require the permission INTERACT_ACROSS_USERS_FULL.
| | public abstract java.lang.String | getInstallerPackageName(java.lang.String packageName)Retrieve the package name of the application that installed a package. This identifies
which market the package came from.
| | public abstract InstrumentationInfo | getInstrumentationInfo(android.content.ComponentName className, int flags)Retrieve all of the information we know about a particular
instrumentation class.
Throws {@link NameNotFoundException} if instrumentation with the
given class name cannot be found on the system.
| | public abstract KeySet | getKeySetByAlias(java.lang.String packageName, java.lang.String alias)Return the {@link KeySet} associated with the String alias for this
application.
| | public abstract android.content.Intent | getLaunchIntentForPackage(java.lang.String packageName)Returns a "good" intent to launch a front-door activity in a package.
This is used, for example, to implement an "open" button when browsing
through packages. The current implementation looks first for a main
activity in the category {@link Intent#CATEGORY_INFO}, and next for a
main activity in the category {@link Intent#CATEGORY_LAUNCHER}. Returns
null if neither are found.
| | public abstract android.content.Intent | getLeanbackLaunchIntentForPackage(java.lang.String packageName)Return a "good" intent to launch a front-door Leanback activity in a
package, for use for example to implement an "open" button when browsing
through packages. The current implementation will look for a main
activity in the category {@link Intent#CATEGORY_LEANBACK_LAUNCHER}, or
return null if no main leanback activities are found.
Throws {@link NameNotFoundException} if a package with the given name
cannot be found on the system.
| | public abstract java.lang.String | getNameForUid(int uid)Retrieve the official name associated with a user id. This name is
guaranteed to never change, though it is possibly for the underlying
user id to be changed. That is, if you are storing information about
user ids in persistent storage, you should use the string returned
by this function instead of the raw user-id.
| | public PackageInfo | getPackageArchiveInfo(java.lang.String archiveFilePath, int flags)Retrieve overall information about an application package defined
in a package archive file
final PackageParser parser = new PackageParser();
final File apkFile = new File(archiveFilePath);
try {
PackageParser.Package pkg = parser.parseMonolithicPackage(apkFile, 0);
if ((flags & GET_SIGNATURES) != 0) {
parser.collectCertificates(pkg, 0);
parser.collectManifestDigest(pkg);
}
PackageUserState state = new PackageUserState();
return PackageParser.generatePackageInfo(pkg, null, flags, 0, 0, null, state);
} catch (PackageParserException e) {
return null;
}
| | public abstract int[] | getPackageGids(java.lang.String packageName)Return an array of all of the secondary group-ids that have been assigned
to a package.
Throws {@link NameNotFoundException} if a package with the given name
cannot be found on the system.
| | public abstract PackageInfo | getPackageInfo(java.lang.String packageName, int flags)Retrieve overall information about an application package that is
installed on the system.
Throws {@link NameNotFoundException} if a package with the given name can
not be found on the system.
| | public abstract PackageInstaller | getPackageInstaller()Return interface that offers the ability to install, upgrade, and remove
applications on the device.
| | public abstract void | getPackageSizeInfo(java.lang.String packageName, int userHandle, IPackageStatsObserver observer)Retrieve the size information for a package.
Since this may take a little while, the result will
be posted back to the given observer. The calling context
should have the {@link android.Manifest.permission#GET_PACKAGE_SIZE} permission.
| | public void | getPackageSizeInfo(java.lang.String packageName, IPackageStatsObserver observer)Like {@link #getPackageSizeInfo(String, int, IPackageStatsObserver)}, but
returns the size for the calling user.
getPackageSizeInfo(packageName, UserHandle.myUserId(), observer);
| | public abstract int | getPackageUid(java.lang.String packageName, int userHandle)
| | public abstract java.lang.String[] | getPackagesForUid(int uid)Retrieve the names of all packages that are associated with a particular
user id. In most cases, this will be a single package name, the package
that has been assigned that user id. Where there are multiple packages
sharing the same user id through the "sharedUserId" mechanism, all
packages with that id will be returned.
| | public abstract java.util.List | getPackagesHoldingPermissions(java.lang.String[] permissions, int flags)Return a List of all installed packages that are currently
holding any of the given permissions.
| | public abstract PermissionGroupInfo | getPermissionGroupInfo(java.lang.String name, int flags)Retrieve all of the information we know about a particular group of
permissions.
Throws {@link NameNotFoundException} if a permission group with the given
name cannot be found on the system.
| | public abstract PermissionInfo | getPermissionInfo(java.lang.String name, int flags)Retrieve all of the information we know about a particular permission.
Throws {@link NameNotFoundException} if a permission with the given
name cannot be found on the system.
| | public abstract int | getPreferredActivities(java.util.List outFilters, java.util.List outActivities, java.lang.String packageName)Retrieve all preferred activities, previously added with
{@link #addPreferredActivity}, that are
currently registered with the system.
| | public abstract java.util.List | getPreferredPackages(int flags)Retrieve the list of all currently configured preferred packages. The
first package on the list is the most preferred, the last is the
least preferred.
| | public abstract ProviderInfo | getProviderInfo(android.content.ComponentName component, int flags)Retrieve all of the information we know about a particular content
provider class.
Throws {@link NameNotFoundException} if a provider with the given
class name cannot be found on the system.
| | public abstract ActivityInfo | getReceiverInfo(android.content.ComponentName component, int flags)Retrieve all of the information we know about a particular receiver
class.
Throws {@link NameNotFoundException} if a receiver with the given
class name cannot be found on the system.
| | public abstract android.content.res.Resources | getResourcesForActivity(android.content.ComponentName activityName)Retrieve the resources associated with an activity. Given the full
name of an activity, retrieves the information about it and calls
getResources() to return its application's resources. If the activity
cannot be found, NameNotFoundException is thrown.
| | public abstract android.content.res.Resources | getResourcesForApplication(ApplicationInfo app)Retrieve the resources for an application. Throws NameNotFoundException
if the package is no longer installed.
| | public abstract android.content.res.Resources | getResourcesForApplication(java.lang.String appPackageName)Retrieve the resources associated with an application. Given the full
package name of an application, retrieves the information about it and
calls getResources() to return its application's resources. If the
appPackageName cannot be found, NameNotFoundException is thrown.
| | public abstract android.content.res.Resources | getResourcesForApplicationAsUser(java.lang.String appPackageName, int userId)
| | public abstract ServiceInfo | getServiceInfo(android.content.ComponentName component, int flags)Retrieve all of the information we know about a particular service
class.
Throws {@link NameNotFoundException} if a service with the given
class name cannot be found on the system.
| | public abstract KeySet | getSigningKeySet(java.lang.String packageName)Return the signing {@link KeySet} for this application.
| | public abstract FeatureInfo[] | getSystemAvailableFeatures()Get a list of features that are available on the
system.
| | public abstract java.lang.String[] | getSystemSharedLibraryNames()Get a list of shared libraries that are available on the
system.
| | public abstract java.lang.CharSequence | getText(java.lang.String packageName, int resid, ApplicationInfo appInfo)Retrieve text from a package. This is a low-level API used by
the various package manager info structures (such as
{@link ComponentInfo} to implement retrieval of their associated
labels and other text.
| | public abstract int | getUidForSharedUser(java.lang.String sharedUserName)Return the user id associated with a shared user name. Multiple
applications can specify a shared user name in their manifest and thus
end up using a common uid. This might be used for new applications
that use an existing shared user name and need to know the uid of the
shared user.
| | public abstract android.graphics.drawable.Drawable | getUserBadgeForDensity(android.os.UserHandle user, int density)If the target user is a managed profile of the calling user or the caller
is itself a managed profile, then this returns a drawable to use as a small
icon to include in a view to distinguish it from the original icon.
| | public abstract android.graphics.drawable.Drawable | getUserBadgedDrawableForDensity(android.graphics.drawable.Drawable drawable, android.os.UserHandle user, android.graphics.Rect badgeLocation, int badgeDensity)If the target user is a managed profile of the calling user or the caller
is itself a managed profile, then this returns a badged copy of the given
drawable allowing the user to distinguish it from the original drawable.
The caller can specify the location in the bounds of the drawable to be
badged where the badge should be applied as well as the density of the
badge to be used.
If the original drawable is a BitmapDrawable and the backing bitmap is
mutable as per {@link android.graphics.Bitmap#isMutable()}, the bading
is performed in place and the original drawable is returned.
| | public abstract android.graphics.drawable.Drawable | getUserBadgedIcon(android.graphics.drawable.Drawable icon, android.os.UserHandle user)If the target user is a managed profile of the calling user or the caller
is itself a managed profile, then this returns a badged copy of the given
icon to be able to distinguish it from the original icon. For badging an
arbitrary drawable use {@link #getUserBadgedDrawableForDensity(
android.graphics.drawable.Drawable, UserHandle, android.graphics.Rect, int)}.
If the original drawable is a BitmapDrawable and the backing bitmap is
mutable as per {@link android.graphics.Bitmap#isMutable()}, the badging
is performed in place and the original drawable is returned.
| | public abstract java.lang.CharSequence | getUserBadgedLabel(java.lang.CharSequence label, android.os.UserHandle user)If the target user is a managed profile of the calling user or the caller
is itself a managed profile, then this returns a copy of the label with
badging for accessibility services like talkback. E.g. passing in "Email"
and it might return "Work Email" for Email in the work profile.
| | public abstract VerifierDeviceIdentity | getVerifierDeviceIdentity()Returns the device identity that verifiers can use to associate their scheme to a particular
device. This should not be used by anything other than a package verifier.
| | public abstract android.content.res.XmlResourceParser | getXml(java.lang.String packageName, int resid, ApplicationInfo appInfo)Retrieve an XML file from a package. This is a low-level API used to
retrieve XML meta data.
| | public abstract void | grantPermission(java.lang.String packageName, java.lang.String permissionName)Grant a permission to an application which the application does not
already have. The permission must have been requested by the application,
but as an optional permission. If the application is not allowed to
hold the permission, a SecurityException is thrown.
| | public abstract boolean | hasSystemFeature(java.lang.String name)Check whether the given feature name is one of the available
features as returned by {@link #getSystemAvailableFeatures()}.
| | public abstract int | installExistingPackage(java.lang.String packageName)If there is already an application with the given package name installed
on the system for other users, also install it for the calling user.
| | public abstract void | installPackage(android.net.Uri packageURI, IPackageInstallObserver observer, int flags, java.lang.String installerPackageName)
| | public abstract void | installPackage(android.net.Uri packageURI, android.app.PackageInstallObserver observer, int flags, java.lang.String installerPackageName)
| | public abstract void | installPackageWithVerification(android.net.Uri packageURI, IPackageInstallObserver observer, int flags, java.lang.String installerPackageName, android.net.Uri verificationURI, ManifestDigest manifestDigest, ContainerEncryptionParams encryptionParams)Similar to
{@link #installPackage(Uri, IPackageInstallObserver, int, String)} but
with an extra verification file provided.
| | public abstract void | installPackageWithVerification(android.net.Uri packageURI, android.app.PackageInstallObserver observer, int flags, java.lang.String installerPackageName, android.net.Uri verificationURI, ManifestDigest manifestDigest, ContainerEncryptionParams encryptionParams)Similar to
{@link #installPackage(Uri, IPackageInstallObserver, int, String)} but
with an extra verification file provided.
| | public abstract void | installPackageWithVerificationAndEncryption(android.net.Uri packageURI, IPackageInstallObserver observer, int flags, java.lang.String installerPackageName, VerificationParams verificationParams, ContainerEncryptionParams encryptionParams)Similar to
{@link #installPackage(Uri, IPackageInstallObserver, int, String)} but
with an extra verification information provided.
| | public abstract void | installPackageWithVerificationAndEncryption(android.net.Uri packageURI, android.app.PackageInstallObserver observer, int flags, java.lang.String installerPackageName, VerificationParams verificationParams, ContainerEncryptionParams encryptionParams)Similar to
{@link #installPackage(Uri, IPackageInstallObserver, int, String)} but
with an extra verification information provided.
| | public static int | installStatusToPublicStatus(int status){@hide}
switch (status) {
case INSTALL_SUCCEEDED: return PackageInstaller.STATUS_SUCCESS;
case INSTALL_FAILED_ALREADY_EXISTS: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_INVALID_APK: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_FAILED_INVALID_URI: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_FAILED_INSUFFICIENT_STORAGE: return PackageInstaller.STATUS_FAILURE_STORAGE;
case INSTALL_FAILED_DUPLICATE_PACKAGE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_NO_SHARED_USER: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_UPDATE_INCOMPATIBLE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_SHARED_USER_INCOMPATIBLE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_MISSING_SHARED_LIBRARY: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
case INSTALL_FAILED_REPLACE_COULDNT_DELETE: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_DEXOPT: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_FAILED_OLDER_SDK: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
case INSTALL_FAILED_CONFLICTING_PROVIDER: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_NEWER_SDK: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
case INSTALL_FAILED_TEST_ONLY: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_FAILED_CPU_ABI_INCOMPATIBLE: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
case INSTALL_FAILED_MISSING_FEATURE: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
case INSTALL_FAILED_CONTAINER_ERROR: return PackageInstaller.STATUS_FAILURE_STORAGE;
case INSTALL_FAILED_INVALID_INSTALL_LOCATION: return PackageInstaller.STATUS_FAILURE_STORAGE;
case INSTALL_FAILED_MEDIA_UNAVAILABLE: return PackageInstaller.STATUS_FAILURE_STORAGE;
case INSTALL_FAILED_VERIFICATION_TIMEOUT: return PackageInstaller.STATUS_FAILURE_ABORTED;
case INSTALL_FAILED_VERIFICATION_FAILURE: return PackageInstaller.STATUS_FAILURE_ABORTED;
case INSTALL_FAILED_PACKAGE_CHANGED: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_FAILED_UID_CHANGED: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_FAILED_VERSION_DOWNGRADE: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_NOT_APK: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_BAD_MANIFEST: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_NO_CERTIFICATES: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_MANIFEST_MALFORMED: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_PARSE_FAILED_MANIFEST_EMPTY: return PackageInstaller.STATUS_FAILURE_INVALID;
case INSTALL_FAILED_INTERNAL_ERROR: return PackageInstaller.STATUS_FAILURE;
case INSTALL_FAILED_USER_RESTRICTED: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
case INSTALL_FAILED_DUPLICATE_PERMISSION: return PackageInstaller.STATUS_FAILURE_CONFLICT;
case INSTALL_FAILED_NO_MATCHING_ABIS: return PackageInstaller.STATUS_FAILURE_INCOMPATIBLE;
case INSTALL_FAILED_ABORTED: return PackageInstaller.STATUS_FAILURE_ABORTED;
default: return PackageInstaller.STATUS_FAILURE;
}
| | public static java.lang.String | installStatusToString(int status, java.lang.String msg){@hide}
final String str = installStatusToString(status);
if (msg != null) {
return str + ": " + msg;
} else {
return str;
}
| | public static java.lang.String | installStatusToString(int status){@hide}
switch (status) {
case INSTALL_SUCCEEDED: return "INSTALL_SUCCEEDED";
case INSTALL_FAILED_ALREADY_EXISTS: return "INSTALL_FAILED_ALREADY_EXISTS";
case INSTALL_FAILED_INVALID_APK: return "INSTALL_FAILED_INVALID_APK";
case INSTALL_FAILED_INVALID_URI: return "INSTALL_FAILED_INVALID_URI";
case INSTALL_FAILED_INSUFFICIENT_STORAGE: return "INSTALL_FAILED_INSUFFICIENT_STORAGE";
case INSTALL_FAILED_DUPLICATE_PACKAGE: return "INSTALL_FAILED_DUPLICATE_PACKAGE";
case INSTALL_FAILED_NO_SHARED_USER: return "INSTALL_FAILED_NO_SHARED_USER";
case INSTALL_FAILED_UPDATE_INCOMPATIBLE: return "INSTALL_FAILED_UPDATE_INCOMPATIBLE";
case INSTALL_FAILED_SHARED_USER_INCOMPATIBLE: return "INSTALL_FAILED_SHARED_USER_INCOMPATIBLE";
case INSTALL_FAILED_MISSING_SHARED_LIBRARY: return "INSTALL_FAILED_MISSING_SHARED_LIBRARY";
case INSTALL_FAILED_REPLACE_COULDNT_DELETE: return "INSTALL_FAILED_REPLACE_COULDNT_DELETE";
case INSTALL_FAILED_DEXOPT: return "INSTALL_FAILED_DEXOPT";
case INSTALL_FAILED_OLDER_SDK: return "INSTALL_FAILED_OLDER_SDK";
case INSTALL_FAILED_CONFLICTING_PROVIDER: return "INSTALL_FAILED_CONFLICTING_PROVIDER";
case INSTALL_FAILED_NEWER_SDK: return "INSTALL_FAILED_NEWER_SDK";
case INSTALL_FAILED_TEST_ONLY: return "INSTALL_FAILED_TEST_ONLY";
case INSTALL_FAILED_CPU_ABI_INCOMPATIBLE: return "INSTALL_FAILED_CPU_ABI_INCOMPATIBLE";
case INSTALL_FAILED_MISSING_FEATURE: return "INSTALL_FAILED_MISSING_FEATURE";
case INSTALL_FAILED_CONTAINER_ERROR: return "INSTALL_FAILED_CONTAINER_ERROR";
case INSTALL_FAILED_INVALID_INSTALL_LOCATION: return "INSTALL_FAILED_INVALID_INSTALL_LOCATION";
case INSTALL_FAILED_MEDIA_UNAVAILABLE: return "INSTALL_FAILED_MEDIA_UNAVAILABLE";
case INSTALL_FAILED_VERIFICATION_TIMEOUT: return "INSTALL_FAILED_VERIFICATION_TIMEOUT";
case INSTALL_FAILED_VERIFICATION_FAILURE: return "INSTALL_FAILED_VERIFICATION_FAILURE";
case INSTALL_FAILED_PACKAGE_CHANGED: return "INSTALL_FAILED_PACKAGE_CHANGED";
case INSTALL_FAILED_UID_CHANGED: return "INSTALL_FAILED_UID_CHANGED";
case INSTALL_FAILED_VERSION_DOWNGRADE: return "INSTALL_FAILED_VERSION_DOWNGRADE";
case INSTALL_PARSE_FAILED_NOT_APK: return "INSTALL_PARSE_FAILED_NOT_APK";
case INSTALL_PARSE_FAILED_BAD_MANIFEST: return "INSTALL_PARSE_FAILED_BAD_MANIFEST";
case INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION: return "INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION";
case INSTALL_PARSE_FAILED_NO_CERTIFICATES: return "INSTALL_PARSE_FAILED_NO_CERTIFICATES";
case INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES: return "INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES";
case INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING: return "INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING";
case INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME: return "INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME";
case INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID: return "INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID";
case INSTALL_PARSE_FAILED_MANIFEST_MALFORMED: return "INSTALL_PARSE_FAILED_MANIFEST_MALFORMED";
case INSTALL_PARSE_FAILED_MANIFEST_EMPTY: return "INSTALL_PARSE_FAILED_MANIFEST_EMPTY";
case INSTALL_FAILED_INTERNAL_ERROR: return "INSTALL_FAILED_INTERNAL_ERROR";
case INSTALL_FAILED_USER_RESTRICTED: return "INSTALL_FAILED_USER_RESTRICTED";
case INSTALL_FAILED_DUPLICATE_PERMISSION: return "INSTALL_FAILED_DUPLICATE_PERMISSION";
case INSTALL_FAILED_NO_MATCHING_ABIS: return "INSTALL_FAILED_NO_MATCHING_ABIS";
case INSTALL_FAILED_ABORTED: return "INSTALL_FAILED_ABORTED";
default: return Integer.toString(status);
}
| | public abstract boolean | isPackageAvailable(java.lang.String packageName){@hide}
| | public abstract boolean | isSafeMode()Return whether the device has been booted into safe mode.
| | public abstract boolean | isSignedBy(java.lang.String packageName, KeySet ks)Return whether the package denoted by packageName has been signed by all
of the keys specified by the {@link KeySet} ks. This will return true if
the package has been signed by additional keys (a superset) as well.
Compare to {@link #isSignedByExactly(String packageName, KeySet ks)}.
| | public abstract boolean | isSignedByExactly(java.lang.String packageName, KeySet ks)Return whether the package denoted by packageName has been signed by all
of, and only, the keys specified by the {@link KeySet} ks. Compare to
{@link #isSignedBy(String packageName, KeySet ks)}.
| | public abstract boolean | isUpgrade()Returns true if the device is upgrading, such as first boot after OTA.
| | public abstract android.graphics.drawable.Drawable | loadItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo)
| | public abstract android.graphics.drawable.Drawable | loadUnbadgedItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo)
| | public abstract void | movePackage(java.lang.String packageName, IPackageMoveObserver observer, int flags)Attempts to move package resources from internal to external media or vice versa.
Since this may take a little while, the result will
be posted back to the given observer. This call may fail if the calling context
lacks the {@link android.Manifest.permission#MOVE_PACKAGE} permission, if the
named package cannot be found, or if the named package is a "system package".
| | public abstract java.util.List | queryBroadcastReceivers(android.content.Intent intent, int flags)Retrieve all receivers that can handle a broadcast of the given intent.
| | public abstract java.util.List | queryBroadcastReceivers(android.content.Intent intent, int flags, int userId)Retrieve all receivers that can handle a broadcast of the given intent, for a specific
user.
| | public abstract java.util.List | queryContentProviders(java.lang.String processName, int uid, int flags)Retrieve content provider information.
Note: unlike most other methods, an empty result set is indicated
by a null return instead of an empty list.
| | public abstract java.util.List | queryInstrumentation(java.lang.String targetPackage, int flags)Retrieve information about available instrumentation code. May be used
to retrieve either all instrumentation code, or only the code targeting
a particular package.
| | public abstract java.util.List | queryIntentActivities(android.content.Intent intent, int flags)Retrieve all activities that can be performed for the given intent.
| | public abstract java.util.List | queryIntentActivitiesAsUser(android.content.Intent intent, int flags, int userId)Retrieve all activities that can be performed for the given intent, for a specific user.
| | public abstract java.util.List | queryIntentActivityOptions(android.content.ComponentName caller, android.content.Intent[] specifics, android.content.Intent intent, int flags)Retrieve a set of activities that should be presented to the user as
similar options. This is like {@link #queryIntentActivities}, except it
also allows you to supply a list of more explicit Intents that you would
like to resolve to particular options, and takes care of returning the
final ResolveInfo list in a reasonable order, with no duplicates, based
on those inputs.
| | public abstract java.util.List | queryIntentContentProviders(android.content.Intent intent, int flags)Retrieve all providers that can match the given intent.
| | public abstract java.util.List | queryIntentContentProvidersAsUser(android.content.Intent intent, int flags, int userId){@hide}
| | public abstract java.util.List | queryIntentServices(android.content.Intent intent, int flags)Retrieve all services that can match the given intent.
| | public abstract java.util.List | queryIntentServicesAsUser(android.content.Intent intent, int flags, int userId)Retrieve all services that can match the given intent for a given user.
| | public abstract java.util.List | queryPermissionsByGroup(java.lang.String group, int flags)Query for all of the permissions associated with a particular group.
Throws {@link NameNotFoundException} if the given group does not
exist.
| | public abstract void | removePackageFromPreferred(java.lang.String packageName)
| | public abstract void | removePermission(java.lang.String name)Removes a permission that was previously added with
{@link #addPermission(PermissionInfo)}. The same ownership rules apply
-- you are only allowed to remove permissions that you are allowed
to add.
| | public abstract void | replacePreferredActivity(android.content.IntentFilter filter, int match, android.content.ComponentName[] set, android.content.ComponentName activity)
| | public void | replacePreferredActivityAsUser(android.content.IntentFilter filter, int match, android.content.ComponentName[] set, android.content.ComponentName activity, int userId)
throw new RuntimeException("Not implemented. Must override in a subclass.");
| | public abstract ResolveInfo | resolveActivity(android.content.Intent intent, int flags)Determine the best action to perform for a given Intent. This is how
{@link Intent#resolveActivity} finds an activity if a class has not
been explicitly specified.
Note: if using an implicit Intent (without an explicit ComponentName
specified), be sure to consider whether to set the {@link #MATCH_DEFAULT_ONLY}
only flag. You need to do so to resolve the activity in the same way
that {@link android.content.Context#startActivity(Intent)} and
{@link android.content.Intent#resolveActivity(PackageManager)
Intent.resolveActivity(PackageManager)} do.
| | public abstract ResolveInfo | resolveActivityAsUser(android.content.Intent intent, int flags, int userId)Determine the best action to perform for a given Intent for a given user. This
is how {@link Intent#resolveActivity} finds an activity if a class has not
been explicitly specified.
Note: if using an implicit Intent (without an explicit ComponentName
specified), be sure to consider whether to set the {@link #MATCH_DEFAULT_ONLY}
only flag. You need to do so to resolve the activity in the same way
that {@link android.content.Context#startActivity(Intent)} and
{@link android.content.Intent#resolveActivity(PackageManager)
Intent.resolveActivity(PackageManager)} do.
| | public abstract ProviderInfo | resolveContentProvider(java.lang.String name, int flags)Find a single content provider by its base path name.
| | public abstract ProviderInfo | resolveContentProviderAsUser(java.lang.String name, int flags, int userId)Find a single content provider by its base path name.
| | public abstract ResolveInfo | resolveService(android.content.Intent intent, int flags)Determine the best service to handle for a given Intent.
| | public abstract void | revokePermission(java.lang.String packageName, java.lang.String permissionName)Revoke a permission that was previously granted by {@link #grantPermission}.
| | public abstract void | setApplicationEnabledSetting(java.lang.String packageName, int newState, int flags)Set the enabled setting for an application
This setting will override any enabled state which may have been set by the application in
its manifest. It also overrides the enabled state set in the manifest for any of the
application's components. It does not override any enabled state set by
{@link #setComponentEnabledSetting} for any of the application's components.
| | public abstract boolean | setApplicationHiddenSettingAsUser(java.lang.String packageName, boolean hidden, android.os.UserHandle userHandle)Puts the package in a hidden state, which is almost like an uninstalled state,
making the package unavailable, but it doesn't remove the data or the actual
package file. Application can be unhidden by either resetting the hidden state
or by installing it, such as with {@link #installExistingPackage(String)}
| | public abstract void | setComponentEnabledSetting(android.content.ComponentName componentName, int newState, int flags)Set the enabled setting for a package component (activity, receiver, service, provider).
This setting will override any enabled state which may have been set by the component in its
manifest.
| | public abstract void | setInstallerPackageName(java.lang.String targetPackage, java.lang.String installerPackageName)Change the installer associated with a given package. There are limitations
on how the installer package can be changed; in particular:
- A SecurityException will be thrown if installerPackageName
is not signed with the same certificate as the calling application.
- A SecurityException will be thrown if targetPackage already
has an installer package, and that installer package is not signed with
the same certificate as the calling application.
| | public abstract void | verifyPendingInstall(int id, int verificationCode)Allows a package listening to the
{@link Intent#ACTION_PACKAGE_NEEDS_VERIFICATION package verification
broadcast} to respond to the package manager. The response must include
the {@code verificationCode} which is one of
{@link PackageManager#VERIFICATION_ALLOW} or
{@link PackageManager#VERIFICATION_REJECT}.
|
|
