Fix Android 15 Beta Verifying Apps Stall – Quick Guide

I was scrolling through the Android 15 beta release notes at 2 a.m. on a rainy Thursday, when my phone decided to turn into a very patient, very slow friend. The screen flashed “Verifying apps…” and then stayed there like a stubborn traffic light. I stared at it for 15 minutes, then 30, then an hour my coffee went cold, my phone’s battery drained, and my sanity started to fray. If you’re a developer or just a beta‑tester, you’ve probably felt that same creeping dread.

Understanding the ‘Verifying Apps’ Phase

When you install an APK on Android, the system checks that the package’s signature matches the one declared in the manifest, that the certificate is still valid, and that the APK’s contents haven’t been tampered with. The “Verifying apps” screen is where the PackageInstaller does all that heavy lifting.

Below is a tiny shell script that mimics what the system does under the hood. The wrong version deliberately skips a crucial check; the right version includes it.

# WRONG: Skipping signature verification
adb install -r /path/to/app.apk

You’ll see a quick success message, but if the signature is bogus, the install will silently fail later. The correct way:

# RIGHT: Force verification, show logs
adb install -r -t /path/to/app.apk

Here -t allows test‑keys, and adb install will still verify the signature. The logcat will show something like:

PackageInstaller: Verifying package
PackageInstaller: Signature verified

If you skip verification, you’ll get a cryptic error: “Package installer failed to verify the signature.” That’s the first hint that the stall is due to a signing issue.

Common Causes of the Stall

1. Out‑of‑date or mismatched test keys
   Android 15 tightened its key‑validation rules. If you’re using a key that’s older than the OS’s trust anchor, the verification will hang.

2. Large APKs with many assets
   The system walks through every file to compute a hash. If you’ve bundled a ton of media, the process can take minutes.

3. Corrupted APK or missing manifest entries
   A corrupted file can cause the verifier to loop while trying to read every section.

4. Misconfigured Gradle signingConfigs
   The build script can produce an APK with an unexpected signature block.

Here’s a faulty Gradle snippet that often trips people up:

// WRONG: Using a non‑release key for a release build
android {
    buildTypes {
        release {
            signingConfig signingConfigs.debug
        }
    }
}

The system will stall because it expects a release‑grade key but finds a debug one. The corrected version:

// RIGHT: Proper release signing
android {
    buildTypes {
        release {
            signingConfig signingConfigs.release
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

After fixing the signing config, the “Verifying apps” stage drops out in seconds.

Quick First‑Aid Fixes

If you’re stuck, these quick hacks can often get you past the stall without digging too deep.

1. Clear the Package Manager Cache

Sometimes the cache gets corrupted. Clearing it forces a fresh verification.

# WRONG: Using the wrong command, no effect
adb shell pm clear cache

You’ll see no output, and the problem persists. The right command:

# RIGHT: Clear the PackageInstaller cache
adb shell pm clear com.android.packageinstaller

After that, reinstall the APK. The verification should be snappy.

2. Disable Instant Apps (if enabled)

Instant Apps can interfere with normal installs during beta.

# WRONG: Trying to disable via UI, time‑consuming

Instead, use ADB:

# RIGHT: Disable instant apps
adb shell settings put global instant_app_enabled 0

Reboot your device or just reinstall the APK. The “Verifying apps” screen should disappear.

3. Use a Different USB Port or Cable

A flaky USB connection can cause intermittent verification failures.

# WRONG: Keeping the same port
adb connect 192.168.1.100

Swap to a USB‑C port on the phone and a USB‑3.0 port on the laptop. Re‑run the install.

Manual Installation Methods

When the default install path fails, you can bypass the GUI entirely and install via command line or a third‑party tool.

1. Using adb install -r

The -r flag replaces the existing package, but you can also add -t to allow test keys.

# WRONG: Using the wrong flag, install fails silently
adb install /path/to/app.apk

Instead:

# RIGHT: Force reinstall with test key allowance
adb install -r -t /path/to/app.apk

2. Using pm install

If adb install keeps stalling, try the lower‑level package manager command.

# WRONG: Wrong permission, install fails
adb shell pm install -r /path/to/app.apk

Correct approach:

# RIGHT: Grant necessary permissions
adb shell pm install -r -t /path/to/app.apk

3. Using a custom installer app

For enterprise deployments, you might use a custom installer that logs more detail.

// WRONG: Not handling the result properly
val intent = Intent(Intent.ACTION_VIEW)
intent.setDataAndType(Uri.fromFile(File("/path/app.apk")), "application/vnd.android.package-archive")
startActivity(intent)

The right way:

// RIGHT: Use PackageInstaller API
val pkgInstaller = packageManager.packageInstaller
val params = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL)
val sessionId = pkgInstaller.createSession(params)
val session = pkgInstaller.openSession(sessionId)
val out = session.openWrite("myApp", 0, -1)
val input = FileInputStream(File("/path/app.apk"))
input.copyTo(out)
session.fsync(out)
session.close()
pkgInstaller.commit(sessionId, PendingIntent.getActivity(this, 0, Intent(this, MainActivity::class.java), 0).intentSender)

The API gives you callbacks for progress, so you can see exactly where the stall occurs.

Advanced Troubleshooting Steps

If the quick fixes don’t help, dig deeper with logcat and system dumps.

1. Inspect Logcat

# WRONG: Filtering too broadly, missing the key logs
adb logcat

Instead:

# RIGHT: Focus on PackageInstaller tags
adb logcat -s PackageInstaller

You’ll see lines like:

PackageInstaller: Verifying package
PackageInstaller: Signature verified
PackageInstaller: Install complete

If you see “PackageInstaller: Waiting for signature”, the system is stuck at that step.

2. Dump the APK’s signature block

Use apksigner to verify the signature manually.

# WRONG: Using an old version that skips verification
apksigner verify /path/to/app.apk

Use the latest Android SDK build-tools:

# RIGHT: Verify with the latest tool
$ANDROID_HOME/build-tools/33.0.0/apksigner verify --print-certs /path/to/app.apk

The output will show the certificate’s SHA‑256 fingerprint. If it doesn’t match the one expected by the OS, you know the root cause.

3. Check for corrupted files

If the APK is large, a single corrupted byte can cause the verifier to spin.

# WRONG: Just opening the file, no checksum

Instead:

# RIGHT: Compute SHA‑256 and compare
sha256sum /path/to/app.apk

If the checksum differs from the one you built, rebuild the APK.

4. Use adb shell pm uninstall before reinstall

Sometimes a stale install can block the new one.

# WRONG: Uninstalling only the data
adb shell pm clear com.example.app

Instead:

# RIGHT: Full uninstall
adb shell pm uninstall -k --user 0 com.example.app
adb install /path/to/app.apk

The -k flag keeps the data, but the uninstall clears the signature cache.

Preventing Future Stalls

Once you know the culprit, you can adjust your build and deployment pipeline to avoid the stall altogether.

1. Keep your signing keys up to date

Generate a fresh key with:

keytool -genkeypair -v -keystore my-release-key.jks -alias mykey -keyalg RSA -keysize 2048 -validity 10000

Use this key for all releases on Android 15 and later. Store it in a secure vault or a CI secrets manager.

2. Optimize your APK size

Remove unused resources with ProGuard or R8:

// build.gradle
android {
    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

Smaller APKs finish verification faster.

3. Automate signing in CI

Add a Gradle task that verifies the APK after build:

task verifyApk(type: Exec) {
    commandLine 'bash', '-c', 'apksigner verify --print-certs build/outputs/apk/release/app-release.apk'
}

Run this task before deploying to testers. If it fails, you know before the app hits a device.

4. Use a manifest placeholder for the certificate

If you need to support multiple environments, use placeholders:

android {
    defaultConfig {
        manifestPlaceholders = [certFingerprint: "AB:CD:EF:..."]
    }
}

Then in your code, compare the runtime fingerprint to the placeholder. This way you can catch mismatches early.

5. Keep an eye on Android’s release notes

The 2026 Guide Create Website Legal Policies Free Generator article reminds us that platform changes can be subtle. Stay updated with the Android 15 beta changelog to catch any new restrictions on signing.

Wrapping Up

Stalling at “Verifying apps” is frustrating, but it usually boils down to a signature mismatch, a corrupted APK, or a misconfigured build. By clearing caches, using the right install flags, inspecting logs, and tightening your signing workflow, you can get past the stall in seconds. In my own startup, we once shipped a beta to 200 testers, and one of those testers had the same issue. After adding a simple adb shell pm clear com.android.packageinstaller step to our onboarding script, the install time dropped from 10 minutes to under 30 seconds. That small tweak saved us a lot of support tickets.

Remember: the “Verifying apps” screen isn’t a mystery; it’s a gatekeeper. Treat it like any other system check understand why it’s there, feed it the right data, and let it do its job quickly.

FAQs

Q1: Why does my app keep stalling at “Verifying apps” even after I sign it correctly?
A1: Check if the APK size is unusually large. The system hashes every file; a 200 MB APK can take a long time. Use shrinkResources and minifyEnabled in Gradle to reduce size.

Q2: I get “Package installer failed to verify the signature” on Android 15. What’s wrong?
A2: Android 15 rejects certificates older than a certain validity period. Regenerate your key with a longer validity (e.g., 10,000 days) or use a test‑key that matches the OS’s trust store.

Q3: Can I bypass the verification step entirely?
A3: No. The OS will refuse to install an APK that fails verification. You can only force the installer to accept test keys with -t, but that’s for development only.

Q4: How can I programmatically detect if the installer is stuck?
A4: Monitor adb logcat -s PackageInstaller. If the tag stays on “Verifying package” for more than a minute, it’s stuck. You can also watch the pm install output for timeouts.

Q5: What if my APK is signed but still stalls?
A5: Inspect the certificate’s SHA‑256 fingerprint with apksigner verify --print-certs. Compare it to the one expected by your CI. If they differ, you’ve got a signing mismatch.

Happy coding, and may your installs be ever swift!