PackageManager

Flag for setApplicationEnabledSetting(String, int, int) and setComponentEnabledSetting(ComponentName, int, int) : This component or application is in its default enabled state (as specified in its manifest).

Flag for setApplicationEnabledSetting(String, int, int) and setComponentEnabledSetting(ComponentName, int, int) : This component or application has been explicitly disabled, regardless of what it has specified in its manifest.

Flag for 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 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 setComponentEnabledSetting(ComponentName, int, int) .

Flag for 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 setComponentEnabledSetting(ComponentName, int, int) .

Flag for setApplicationEnabledSetting(String, int, int) and setComponentEnabledSetting(ComponentName, int, int) : This component or application has been explictily enabled, regardless of what it has specified in its manifest.

Flag parameter for 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.

Extra field name for the ID of a package pending verification. Passed to a package verifier and is used to call back to verifyPendingInstall(int, int)

Extra field name for the result of a verification, either VERIFICATION_ALLOW , or VERIFICATION_REJECT . Passed to package verifiers after a package is verified.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports app widgets.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device's audio pipeline is low-latency, more suitable for audio applications sensitive to delays or lag in sound input or output.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device can perform backup and restore operations on installed applications.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device is capable of communicating with other devices via Bluetooth.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device is capable of communicating with other devices via Bluetooth Low Energy radio.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has a camera facing away from the screen.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has at least one camera pointing in some direction, or can support an external camera being connected to it.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device's camera supports auto-focus.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : 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.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device's camera supports flash.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has a front facing camera.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device is capable of communicating with consumer IR devices.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports device policy enforcement via device admins.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : 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.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : 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 FEATURE_FAKETOUCH for input devices with this capability. Note that unlike a distinct multitouch screen as defined by 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.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : 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 FEATURE_FAKETOUCH for input devices with this capability. Note that unlike a multitouch screen as defined by FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND , not all two finger gestures can be detected due to the limitations described for FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT .

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports a home screen that is replaceable by third party applications.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports adding new input methods implemented with the InputMethodService API.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports live wallpapers.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports one or more methods of reporting current location.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has a Global Positioning System receiver and can report precise location.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device can report location with coarse accuracy using a network-based geolocation system.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device can record audio via a microphone.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device can communicate using Near-Field Communications (NFC).

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports host- based NFC card emulation.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports printing.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports landscape orientation screens. For backwards compatibility, you can assume that if neither this nor FEATURE_SCREEN_PORTRAIT is set then the device supports both portrait and landscape.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports portrait orientation screens. For backwards compatibility, you can assume that if neither this nor FEATURE_SCREEN_LANDSCAPE is set then the device supports both portrait and landscape.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes an accelerometer.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a barometer (air pressure sensor.)

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a magnetometer (compass).

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a gyroscope.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a heart rate monitor.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a light sensor.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a proximity sensor.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a hardware step counter.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device includes a hardware step detector.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The SIP API is enabled on the device.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports SIP-based VOIP.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has a telephony radio with data communication support.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has a CDMA telephony stack.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has a GSM telephony stack.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : 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.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device's display has a touch screen.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device's touch screen supports multitouch sufficient for basic two-finger gesture detection.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device's touch screen is capable of tracking two or more fingers fully independently.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device's touch screen is capable of tracking a full hand of fingers fully independently -- that is, 5 or more simultaneous independent pointers.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports connecting to USB accessories.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports connecting to USB devices as the USB host.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : 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.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device has a full implementation of the android.webkit.* APIs. Devices lacking this feature will not have a functioning WebView implementation.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports WiFi (802.11) networking.

Feature for getSystemAvailableFeatures() and hasSystemFeature(String) : The device supports Wi-Fi Direct networking.

PackageInfo flag: return information about activities in the package in activities .

PackageInfo flag: return information about hardware preferences in PackageInfo.configPreferences and requested features in PackageInfo.reqFeatures .

PackageInfo flag: include disabled components in the returned info.

PackageInfo flag: include disabled components which are in that state only because of 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.

PackageInfo flag: return the group ids that are associated with an application. This applies for any API returning a PackageInfo class, either directly or nested inside of another.

PackageInfo flag: return information about instrumentation in the package in instrumentation .

PackageInfo flag: return information about the intent filters supported by the activity.

ComponentInfo flag: return the metaData data Bundle s that are associated with a component. This applies for any API returning a ComponentInfo subclass.

PackageInfo flag: return information about permissions in the package in permissions .

PackageInfo flag: return information about content providers in the package in providers .

PackageInfo flag: return information about intent receivers in the package in receivers .

ResolveInfo flag: return the IntentFilter that was matched for a particular ResolveInfo in filter .

PackageInfo flag: return information about services in the package in services .

ApplicationInfo flag: return the 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.

PackageInfo flag: return information about the signatures included in the package.

Flag 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 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.

ProviderInfo flag: return the 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.

Resolution and querying flag: if set, only filters that support the CATEGORY_DEFAULT will be considered for matching. This is a synonym for including the CATEGORY_DEFAULT in your supplied Intent.

Can be used as the millisecondsToDelay argument for extendVerificationTimeout(int, int, long) . This is the maximum time PackageManager waits for the verification agent to return (in milliseconds).

Permission check result: this is returned by checkPermission(String, String) if the permission has not been granted to the given package.

Permission check result: this is returned by checkPermission(String, String) if the permission has been granted to the given package.

Signature check result: this is returned by checkSignatures(int, int) if the first package is not signed but the second is.

Signature check result: this is returned by checkSignatures(int, int) if all signatures on the two packages match.

Signature check result: this is returned by checkSignatures(int, int) if neither of the two packages is signed.

Signature check result: this is returned by checkSignatures(int, int) if not all signatures on both packages match.

Signature check result: this is returned by checkSignatures(int, int) if the second package is not signed but the first is.

Signature check result: this is returned by checkSignatures(int, int) if either of the packages are not valid.

Used as the verificationCode argument for verifyPendingInstall(int, int) to indicate that the calling package verifier allows the installation to proceed.

Used as the verificationCode argument for verifyPendingInstall(int, int) to indicate the calling package verifier does not vote to allow the installation to proceed.

Add a new dynamic permission to the system. For this to work, your package must have defined a permission tree through the <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.

Like 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.

Map from a packages canonical name to the current name in use on the device.

Check whether a particular package has been granted a particular permission.

Like 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.

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.

Remove all preferred activity mappings, previously added with addPreferredActivity(IntentFilter, int, ComponentName[], ComponentName) , from the system whose activities are implemented in the given package name. An application can only clear its own package(s).

Map from the current package names in use on the device to whatever the current canonical name of that package is.

Allows a package listening to the 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 verificationCodeAtTimeout which is one of VERIFICATION_ALLOW or VERIFICATION_REJECT . This method may only be called once per package id. Additional calls will have no effect.

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.

Retrieve the banner associated with an activity. Given the full name of an activity, retrieves the information about it and calls ComponentInfo.loadIcon() to return its banner. If the activity cannot be found, NameNotFoundException is thrown.

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.

Retrieve the icon associated with an activity. Given the full name of an activity, retrieves the information about it and calls ComponentInfo.loadIcon() to return its icon. If the activity cannot be found, NameNotFoundException is thrown.

Retrieve all of the information we know about a particular activity class.

Throws PackageManager.NameNotFoundException if an activity with the given class name cannot be found on the system.

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.

Retrieve the logo associated with an activity. Given the full name of an activity, retrieves the information about it and calls ComponentInfo.loadLogo() to return its logo. If the activity cannot be found, NameNotFoundException is thrown.

Retrieve all of the known permission groups in the system.

Retrieve the banner associated with an application.

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.

Return the the enabled setting for an application. This returns the last value set by setApplicationEnabledSetting(String, int, int) ; in most cases this value will be COMPONENT_ENABLED_STATE_DEFAULT since the value originally specified in the manifest has not been modified.

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.

Retrieve the icon associated with an application. If it has not defined an icon, the default app icon is returned. Does not return null.

Retrieve all of the information we know about a particular package/application.

Throws PackageManager.NameNotFoundException if an application with the given package name cannot be found on the system.

Return the label to use for this application.

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.

Retrieve the logo associated with an application. If it has not specified a logo, this method returns null.

Return the the enabled setting for a package component (activity, receiver, service, provider). This returns the last value set by setComponentEnabledSetting(ComponentName, int, int) ; in most cases this value will be COMPONENT_ENABLED_STATE_DEFAULT since the value originally specified in the manifest has not been modified.

Return the generic icon for an activity that is used when no specific icon is defined.

Retrieve an image from a package. This is a low-level API used by the various package manager info structures (such as ComponentInfo to implement retrieval of their associated icon.

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 DONT_DELETE_DATA (partially installed apps with data directory) will be returned.

Return a List of all packages that are installed on the device.

Retrieve the package name of the application that installed a package. This identifies which market the package came from.

Retrieve all of the information we know about a particular instrumentation class.

Throws PackageManager.NameNotFoundException if instrumentation with the given class name cannot be found on the system.

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 CATEGORY_INFO , and next for a main activity in the category CATEGORY_LAUNCHER . Returns null if neither are found.

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.

Retrieve overall information about an application package defined in a package archive file

Return an array of all of the secondary group-ids that have been assigned to a package.

Throws PackageManager.NameNotFoundException if a package with the given name cannot be found on the system.

Retrieve overall information about an application package that is installed on the system.

Throws PackageManager.NameNotFoundException if a package with the given name can not be found on the system.

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.

Return a List of all installed packages that are currently holding any of the given permissions.

Retrieve all of the information we know about a particular group of permissions.

Throws PackageManager.NameNotFoundException if a permission group with the given name cannot be found on the system.

Retrieve all of the information we know about a particular permission.

Throws PackageManager.NameNotFoundException if a permission with the given name cannot be found on the system.

Retrieve all preferred activities, previously added with addPreferredActivity(IntentFilter, int, ComponentName[], ComponentName) , that are currently registered with the system.

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.

Retrieve all of the information we know about a particular content provider class.

Throws PackageManager.NameNotFoundException if a provider with the given class name cannot be found on the system.

Retrieve all of the information we know about a particular receiver class.

Throws PackageManager.NameNotFoundException if a receiver with the given class name cannot be found on the system.

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.

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.

Retrieve the resources for an application. Throws NameNotFoundException if the package is no longer installed.

Retrieve all of the information we know about a particular service class.

Throws PackageManager.NameNotFoundException if a service with the given class name cannot be found on the system.

Get a list of features that are available on the system.

Get a list of shared libraries that are available on the system.

Retrieve text from a package. This is a low-level API used by the various package manager info structures (such as ComponentInfo to implement retrieval of their associated labels and other text.

Retrieve an XML file from a package. This is a low-level API used to retrieve XML meta data.

Check whether the given feature name is one of the available features as returned by getSystemAvailableFeatures() .

Return whether the device has been booted into safe mode.

Retrieve all receivers that can handle a broadcast of the given intent.

Retrieve content provider information.

Note: unlike most other methods, an empty result set is indicated by a null return instead of an empty list.

Retrieve information about available instrumentation code. May be used to retrieve either all instrumentation code, or only the code targeting a particular package.

Retrieve all activities that can be performed for the given intent.

Retrieve a set of activities that should be presented to the user as similar options. This is like queryIntentActivities(Intent, int) , 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.

Retrieve all providers that can match the given intent.

Retrieve all services that can match the given intent.

Query for all of the permissions associated with a particular group.

Throws PackageManager.NameNotFoundException if the given group does not exist.

Removes a permission that was previously added with addPermission(PermissionInfo) . The same ownership rules apply -- you are only allowed to remove permissions that you are allowed to add.

Determine the best action to perform for a given Intent. This is how resolveActivity(PackageManager) 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 MATCH_DEFAULT_ONLY only flag. You need to do so to resolve the activity in the same way that startActivity(Intent) and Intent.resolveActivity(PackageManager) do.

Find a single content provider by its base path name.

Determine the best service to handle for a given Intent.

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 setComponentEnabledSetting(ComponentName, int, int) for any of the application's components.

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.

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.

Allows a package listening to the package verification broadcast to respond to the package manager. The response must include the verificationCode which is one of VERIFICATION_ALLOW or VERIFICATION_REJECT .