Detecting Application Installation Status on Android: From Basic Implementation to Package Visibility Challenges in API 30+

In Android development, detecting whether a specific application is installed is a common requirement, such as verifying installation results after guiding users to install via Google Play. The original question illustrates a typical scenario: the developer attempts to cyclically check the application package name in onResume(), but encounters an ActivityNotFoundException. This error is not directly caused by the detection logic, but rather by an incorrect URI used to launch Google Play or the absence of the Google Play app on the device. However, a more fundamental issue lies in the detection method itself—using a blocking loop in onResume() prevents the UI thread from responding, leading to Application Not Responding (ANR).

Basic Detection Method

The core method for detecting application installation is using PackageManager.getPackageInfo(). When the provided package name exists, this method returns a PackageInfo object; if the package is not installed, it throws a PackageManager.NameNotFoundException. Here is an optimized implementation:

private boolean isPackageInstalled(String packageName, PackageManager packageManager) {
    try {
        packageManager.getPackageInfo(packageName, 0);
        return true;
    } catch (PackageManager.NameNotFoundException e) {
        return false;
    }
}

This method accepts a PackageManager parameter instead of Context, enhancing code reusability and testability while adhering to the Law of Demeter. In usage, obtain a PackageManager instance via context.getPackageManager():

public void checkInstallation(Context context) {
    PackageManager pm = context.getPackageManager();
    boolean isInstalled = isPackageInstalled("com.example.app", pm);
    if (isInstalled) {
        // Execute post-installation logic
    }
}

Package Visibility Restrictions in Android 11 and Later

Starting with Android 11 (API 30), the system introduced stricter package visibility policies. By default, applications cannot query most other apps installed on the device unless they explicitly declare the package names they need to access. This means that even if the above detection method is code-correct, it may return false on Android 11+ devices even when the target app is installed.

The solution is to add a <queries> declaration in AndroidManifest.xml:

<manifest>
    <queries>
        <package android:name="com.example.targetapp" />
        <package android:name="com.another.app" />
    </queries>
    ...
</manifest>

This allows the system to permit queries for the declared package names. For apps not declared in <queries>, getPackageInfo() will throw NameNotFoundException even if they are actually installed. This mechanism balances functional needs with user privacy protection.

Complete Implementation and Best Practices

A robust implementation combining basic detection and package visibility handling should include the following elements:

1. Asynchronous Detection: Avoid blocking operations on the UI thread (e.g., in onResume()). Use AsyncTask, Kotlin coroutines, or Thread for background checks.
2. Version Adaptation: For API 30+ devices, ensure correct <queries> declarations; for older versions, the method works directly.
3. Error Handling: Catch potential security exceptions or insufficient permission scenarios, providing fallback strategies.
4. Intent Launch Optimization: When launching Google Play, use the standard URI format market://details?id=com.package.name and check if the device supports the Intent.

Example of improved onResume() logic:

@Override
protected void onResume() {
    super.onResume();
    new AsyncTask<Void, Void, Boolean>() {
        @Override
        protected Boolean doInBackground(Void... voids) {
            return isPackageInstalled("com.target.app", getPackageManager());
        }
        @Override
        protected void onPostExecute(Boolean installed) {
            if (installed) {
                Toast.makeText(MainActivity.this, "App installed", Toast.LENGTH_SHORT).show();
            }
        }
    }.execute();
}

Conclusion and Extensions

Although detecting application installation status may seem straightforward, it involves considerations such as lifecycle management, thread safety, and system compatibility. The package visibility changes in Android 11 remind developers to prioritize privacy norms and proactively declare data access needs. In the future, as the Android system evolves, such detection may require more granular permission models or API adjustments. Developers are advised to regularly consult the official documentation to maintain forward-looking and compliant code.