返回提示词目录第 1376 页

安卓应用发布与上架准备审计

核查正式构建、签名、混淆与升级路径,识别上线阻断项,整理修复措施及需核实的商店要求。

完整提示词

# ANDROID RELEASE AND PLAY STORE READINESS AUDIT

I want you to perform a maximally deep, systematic, evidence-first, and production-oriented analysis of an Android application's readiness for actual release and distribution via Google Play.

Main objective:

> Determine whether the application can be safely, reproducibly, and reliably built, signed, published, installed, updated, and operated in production without release-only crashes, misconfigurations, leaked secrets, R8/ProGuard regressions, target SDK incompatibilities, permission model failures, manifest merge anomalies, App Bundle split bugs, versioning errors, signing identity mismatches, or Google Play policy rejections.

This is not:

- a simple `assembleRelease` verification
- a generic Play Store publishing checklist
- advice to simply increment `versionCode`
- blindly upgrading all dependencies to latest
- a superficial scan of `AndroidManifest.xml`
- a replacement for an in-depth security penetration audit
- a replacement for a comprehensive legal/privacy counsel review
- an assumption that a functioning debug build guarantees release readiness
- an assumption that a compiling build equates to a crash-free production runtime

The focus encompasses the entire release lifecycle:

```text
source
↓
dependencies
↓
Gradle configuration
↓
release build
↓
R8 / shrinking
↓
signing
↓
AAB / APK
↓
Play delivery
↓
installation / update
↓
production runtime
```

Priority hierarchy:

**release correctness > update safety > signing/security > production configuration > store compliance > runtime reliability > build optimization**

Uncovering 5 genuine release blockers is infinitely more valuable than listing 100 generic Play Store best practices.

---

# 1. IDENTIFY THE RELEASE STACK

Before formulating findings, establish:

- Android Gradle Plugin (AGP) version
- Gradle wrapper version
- Kotlin compiler version
- JDK runtime version
- `compileSdk`
- `targetSdk`
- `minSdk`
- Build tools revision if explicitly pinned
- `versionCode`
- `versionName`
- Build types
- Product flavors and flavor dimensions
- Signing configurations
- R8 minification, optimization, and obfuscation configuration
- Resource shrinking configuration
- Manifest definitions and merge manifests
- Dependency management model (version catalogs, lockfiles)
- AAB vs APK delivery outputs
- CI/CD build scripts
- Automated Play publishing pipelines (Fastlane, Gradle Play Publisher)

Do not rely on obsolete Android platform or Google Play assumptions.

If a Google Play policy requirement depends upon current real-world policy deadlines:

**VERIFY CURRENT PLAY POLICY BEFORE CONCLUSION**

If you cannot verify active policy requirements:

**PLAY POLICY STATUS: NOT VERIFIED**

---

# 2. MAP THE RELEASE PIPELINE

Construct the real operational release flow:

```text
Git commit / tag
↓
CI runner or local Gradle daemon
↓
release variant compilation
↓
R8 code shrinking and obfuscation
↓
resource shrinking and asset removal
↓
release cryptographic signing
↓
Android App Bundle (AAB) packaging
↓
Google Play Console upload
↓
Release track (Internal → Closed → Open → Production)
↓
User device install / upgrade
```

If staging or release candidate tracks exist, map each distinct track.

---

# 3. BUILD TYPE AUDIT

Inspect all defined build types:

```text
debug
release
```

along with custom variants (staging, benchmark, releaseCandidate).

For each variant, audit:

- `debuggable` flag
- `minifyEnabled`
- `shrinkResources`
- Signing credentials configuration
- `applicationIdSuffix`
- Base backend API URLs
- Logging interceptors and logger levels
- Feature flag defaults
- Analytics dispatcher endpoints
- Crash reporting enablement

---

# 4. DEBUG VS RELEASE CONFIGURATION DELTA

One of the most critical audit phases.

Construct an exhaustive comparison matrix:

| Setting | Debug Variant | Release Variant | Risk Assessment |
|---|---|---|---|

Covering:

- API endpoint URLs
- Network logging interceptors
- SSL/TLS certificate handling
- Feature flag defaults
- Mock data and stub services
- Test credentials and bypasses
- Network security configuration
- Analytics logging
- Remote configuration fallbacks

---

# 5. EXECUTING THE RELEASE BUILD

Where tooling permits, attempt a genuine production compilation:

```text
./gradlew assembleRelease
```

or:

```text
./gradlew bundleRelease
```

If release signing keys or environment secrets are missing:

**RELEASE BUILD: BLOCKED BY MISSING SIGNING/SECRETS**

Never bypass security protections or fallback to debug signing just to force compilation.

---

# 6. APP BUNDLE PACKAGING AUDIT

For Google Play distribution, explicitly inspect the AAB output.

Validating an APK build is never a substitute for verifying the Android App Bundle pipeline.

---

# 7. CLEAN BUILD VERIFICATION

Where safe, execute a clean build from scratch:

```text
./gradlew clean bundleRelease
```

Objective:

Expose hidden dependencies on stale local build outputs or IDE caches.

---

# 8. BUILD REPRODUCIBILITY

Verify that release builds do not depend upon:

- Manually created local files
- Local Android Studio IDE state
- Uncommitted git configuration files
- Developer-specific local machine environment paths
- Ephemeral machine-local properties

---

# 9. VERSION CODE INTEGRITY

Verify that `versionCode`:

- Monotonically increments between release candidates
- Avoids collision across distinct production artifacts
- Evaluates flavor offsets safely where multi-flavor distribution exists

---

# 10. VERSION NAME CONSISTENCY

`versionName` is user-facing metadata.

Verify consistency with git release tags and product documentation.

Do not classify semantic formatting choices as bugs unless violated by specific business requirements.

---

# 11. MULTI-FLAVOR VERSIONING ARCHITECTURE

When multiple product flavors exist:

Verify that flavor-specific `versionCode` computation preserves unique integer identifiers across all Play Store tracks.

---

# 12. APPLICATION ID VERIFICATION

Identify the definitive production:

```text
applicationId
```

Ensure the release artifact does not inadvertently inherit:

- `.debug`
- `.dev`
- Internal test package suffixes

---

# 13. NAMESPACE VS APPLICATION ID

Never conflate Gradle module `namespace` with the runtime `applicationId`.

Verify configurations where third-party SDKs, deep links, or deployment tools rely on package identity.

---

# 14. APPLICATION ID IMPACT ON EXTERNAL SERVICES

Altering the `applicationId` breaks:

- Google OAuth consent client IDs
- Firebase project registrations
- Android App Links domain verification
- Third-party API key restrictions (Google Maps, Facebook SDK)

Audit production service bindings against the production `applicationId`.

---

# 15. CRYPTOGRAPHIC SIGNING CONFIGURATION

Map the signing pipeline:

```text
release signing configuration
↓
keystore storage location
↓
key alias
↓
credential retrieval mechanism
```

Never print secret passwords or key values in audit reports.

---

# 16. DEBUG KEY SIGNING IN RELEASE ARTIFACTS

Critical P0 blocker if a production artifact is signed with the default insecure debug certificate (`debug.keystore`).

---

# 17. KEYSTORE REPOSITORY LEAKS

If a private release keystore is committed to a public or insufficiently protected git repository:

Document the critical credential compromise.

Never echo keystore binaries or passwords into outputs.

---

# 18. HARDCODED SIGNING PASSWORDS

Search:

- `build.gradle` and `build.gradle.kts`
- `gradle.properties`
- CI/CD workflow YAML files
- Deployment scripts

If hardcoded credentials are found, mask all characters in findings.

---

# 19. ENVIRONMENT-DRIVEN SIGNING CREDENTIALS

When signing keys are injected via CI environment variables:

Verify fail-closed behavior when environment variables are undefined or empty.

---

# 20. SILENT FALLBACK TO DEBUG SIGNING (CRITICAL DEFECT)

Hazardous antipattern:

```text
if (releaseKeyMissing) {
    signingConfig = signingConfigs.debug
}
```

Production builds must fail immediately and loudly rather than silently switching to an untrusted debug identity.

---

# 21. PLAY APP SIGNING VERIFICATION

When Google Play App Signing is utilized:

Distinguish between:

- Upload key (used by developer / CI to sign AAB)
- App signing key (managed securely by Google to re-sign delivered split APKs)

Do not assert configuration state without access to Play Console settings.

If unavailable:

**PLAY APP SIGNING: NOT VERIFIED**

---

# 22. SIGNING KEY UPGRADE AND ROTATION

If the application has a history of key migration, verify the `signingConfig` cryptographically links past and new certificates via the signing lineage.

If not applicable:

**NOT APPLICABLE**

---

# 23. CERTIFICATE FINGERPRINT-DEPENDENT SERVICES

Many services bind strictly to the SHA-1 or SHA-256 certificate fingerprint:

- Google Sign-In / OAuth
- Google Maps SDK
- Firebase Authentication
- Android App Links digital asset links (`assetlinks.json`)
- Restricted backend API gateways

Verify that the production signing certificate fingerprint is registered across all provider consoles.

---

# 24. "DEBUG WORKS, RELEASE AUTH CRASHES" SYNDROME

Classic release disaster:

```text
debug keystore SHA-1 registered with Google Cloud / Firebase
↓
release keystore SHA-1 missing from Google Cloud Console
↓
login works flawlessly in QA debug builds
↓
production release crashes or fails authentication immediately upon launch
```

Actively audit SHA fingerprint registrations.

---

# 25. R8 CODE SHRINKING AND MINIFICATION

When R8 is enabled for release:

Map:

- Code shrinking (unused class and method stripping)
- Name obfuscation (identifiers renamed to a, b, c)
- Code optimization (inlining, dead code removal)
- Resource shrinking

---

# 26. RELEASE-ONLY RUNTIME CRASH SURFACE

Search for code patterns vulnerable to R8 minification:

- Reflection and dynamic class loading
- Reliance on `class.simpleName` for business logic
- Runtime annotations
- Generics type argument reflection
- JSON serialization and deserialization
- Java Native Interface (JNI) C++ bindings

---

# 27. REFLECTION SAFETY UNDER R8

If code invokes:

```text
Class.forName("com.example.FeatureImpl")
```

Verify explicit `-keep` rules prevent R8 from stripping or renaming the target class.

---

# 28. RUNTIME CLASS NAME DEPENDENCY

If business logic, analytics tracking, or local database table names rely on:

```kotlin
javaClass.name
javaClass.simpleName
```

Name obfuscation will alter identifiers at runtime, corrupting persistence and analytics.

---

# 29. JSON SERIALIZATION CONTRACTS

For Gson, Moshi, Kotlinx Serialization, or Jackson:

Audit keep rules and annotation processors (`@Keep`, `@Serializable`, `@JsonClass(generateAdapter = true)`).

Never insert indiscriminate broad keep rules without understanding library contracts.

---

# 30. REFLECTIVE SERIALIZERS WITHOUT KEEP RULES

Reflection-based parsing fails in release if R8 strips no-arg constructors, field names, or generic type signatures.

---

# 31. RUNTIME ANNOTATION RETENTION

If framework dependency injection or serialization inspects annotations at runtime, ensure R8 preserves `-keepattributes *Annotation*,Signature,InnerClasses`.

---

# 32. JNI AND C++ BINDING SAFETY

C/C++ native code looking up Java classes and methods via JNI function signatures (`env->FindClass`, `env->GetMethodID`) will crash with `NoSuchMethodError` if R8 renames the Java symbols.

Verify JNI keep rules.

---

# 33. WEBVIEW JAVASCRIPT INTERFACE SAFETY

Methods exposed to WebView via `@JavascriptInterface` must be protected from stripping and renaming.

---

# 34. CUSTOM VIEW INFLATION FROM XML

If custom view classes are referenced in XML layout attributes, verify shrinker rules preserve their two-argument `(Context, AttributeSet)` constructors.

---

# 35. JETPACK NAVIGATION SAFE ARGS REFLECTION

Verify that generated Navigation Safe Args classes and Parcelable/Serializable arguments survive R8 obfuscation.

---

# 36. R8 BUILD WARNING AUDIT

Inspect R8 compiler output for unresolved reference warnings.

Classify warnings:

```text
ACTIONABLE
KNOWN SAFE
DEPENDENCY ISSUE
NOT VERIFIED
```

Never use `-dontwarn **` as a blanket suppressive fix.

---

# 37. INDISCRIMINATE BROAD KEEP RULES

Antipatterns like:

```text
-keep class ** { *; }
```

completely negate the benefits of R8 shrinking.

Classify as an optimization defect unless masking deeper correctness bugs.

---

# 38. RESOURCE SHRINKING RISKS

When `shrinkResources = true` is enabled:

Inspect dynamic resource lookups:

- `Resources.getIdentifier()`
- String-based drawable name lookups
- Raw assets referenced reflectively

---

# 39. DYNAMIC RESOURCE NAME PURGING

Resources accessed solely by string concatenation (e.g., `"icon_" + id`) will be identified as dead resources by AAPT2 and replaced with blank 1x1 stubs in release builds.

Verify `keep.xml` configurations.

---

# 40. NATIVE LIBRARY (.SO) PACKAGING

If native libraries are included:

Audit ABI architecture packaging across `.so` files.

---

# 41. ABI TARGET MATRIX

Map supported hardware architectures:

- `arm64-v8a`
- `armeabi-v7a`
- `x86_64`
- `x86`

strictly according to target device requirements.

---

# 42. MISSING ABI ARCHITECTURES

If a dependency bundles only 32-bit native libraries while the app targets 64-bit platforms, 64-bit devices will crash with `UnsatisfiedLinkError` at runtime.

---

# 43. NATIVE DEBUG SYMBOLS UPLOAD

If utilizing C/C++ native code, verify that native debug symbols (`lib.so.dbg`) are extracted and queued for upload to Google Play Console or Crashlytics for de-obfuscation.

---

# 44. APP BUNDLE SPLIT DELIVERY ASSUMPTIONS

Google Play splits AABs into base and configuration APKs (density, language, ABI).

Verify that code does not assume all language strings or density assets reside in the base APK filesystem.

---

# 45. DYNAMIC FEATURE MODULES

If implementing on-demand Play Feature Delivery:

Audit:

- Module download states
- Offline fallback when module is missing
- Deep navigation into uninstalled modules
- Module version compatibility

If not implemented:

**NOT APPLICABLE**

---

# 46. ON-DEMAND MODULE STATE DEFENSE

UI components must never assume dynamic feature module classes exist before the download and installation listener confirms success.

---

# 47. PLAY ASSET DELIVERY

If delivering large media or game assets via Play Asset Delivery:

Verify install-time, fast-follow, and on-demand asset pack loading.

If not implemented:

**NOT APPLICABLE**

---

# 48. MANIFEST MERGE AUDIT

Always inspect the generated final merged release manifest:

`build/intermediates/merged_manifests/release/AndroidManifest.xml`

Never evaluate release compliance solely from `app/src/main/AndroidManifest.xml`.

Third-party dependencies frequently inject:

- Unintended permissions
- Content providers
- Background services
- Broadcast receivers
- Transparent activities

---

# 49. MERGED RELEASE MANIFEST ATTRIBUTES

Audit final production values:

- `android:debuggable`
- `android:allowBackup`
- `android:usesCleartextTraffic`
- `android:exported`
- Permissions list
- Application label and icon
- Application theme
- `android:networkSecurityConfig`
- Foreground service declarations

---

# 50. `android:debuggable` ENFORCEMENT

The final production release manifest must strictly enforce:

```xml
android:debuggable="false"
```

Shipping `debuggable="true"` in production is a severe P0/P1 security vulnerability allowing arbitrary memory attachment and data extraction.

---

# 51. DATA BACKUP RULES

Inspect:

- `android:allowBackup`
- `android:dataExtractionRules` (Android 12+)
- `android:fullBackupContent` (legacy)

Verify that sensitive databases, cryptographic keys, and user tokens are excluded from cloud backup extraction.

---

# 52. CLEARTEXT HTTP TRAFFIC

If production manifests allow cleartext HTTP (`android:usesCleartextTraffic="true"`):

Document as a security finding unless specific local hardware devices explicitly demand unencrypted communication.

---

# 53. NETWORK SECURITY CONFIGURATION

Audit the production `network_security_config.xml`:

Ensure debug-only custom CA trust anchors (`<certificates src="user" />`) used for Charles/Mitmproxy proxying are strictly excluded from release builds.

---

# 54. USER CERTIFICATE TRUST ANCHORS

Trusting user-installed certificates in a release build permits man-in-the-middle network interception on standard production devices.

---

# 55. CERTIFICATE PINNING RESILIENCE

If SSL/TLS certificate pinning is configured:

Verify expiration dates, backup pin configurations, and remote emergency update paths.

Do not prescribe certificate pinning indiscriminately.

---

# 56. EXPORTED COMPONENT SECURITY

On the final merged manifest, inspect every:

- `<activity>`
- `<service>`
- `<receiver>`
- `<provider>`

Verify that every exported component enforces appropriate permissions or intent filters.

---

# 57. INTENT FILTER IMPLICIT EXPORT RISKS

On Android 12+, any component with an `<intent-filter>` must explicitly declare `android:exported="true"` or `"false"`.

Verify that exported components are not vulnerable to arbitrary intent injection.

---

# 58. DEEP LINK CONFIGURATION

Verify that deep link schemes and hosts point strictly to production domains.

---

# 59. DEVELOPMENT DEEP LINK LEAKS

Ensure test deep links (`dev://`, `staging.example.com`) are not exported in the production manifest.

---

# 60. ANDROID APP LINKS DOMAIN VERIFICATION

When using verified App Links (`android:autoVerify="true"`):

Verify:

- HTTPS scheme enforcement
- Fully qualified domain names
- Presence and formatting of `/.well-known/assetlinks.json` on the remote server

If the production server cannot be queried:

**APP LINKS PRODUCTION VERIFICATION: NOT VERIFIED**

---

# 61. CUSTOM URL SCHEMES AND HIJACKING

Custom URL schemes (e.g., `myapp://oauth`) can be intercepted by malicious apps installed on the same device.

Verify migration toward verified App Links where sensitive authentication tokens are passed.

---

# 62. FINAL PERMISSION INVENTORY

Construct an inventory of all permissions present in the merged release manifest:

Classify each:

```text
REQUIRED
OPTIONAL
TRANSITIVE
LEGACY
UNUSED
NOT VERIFIED
```

---

# 63. TRANSITIVE PERMISSION INJECTION

Dependencies often inject permissions automatically (e.g., an image library injecting `READ_EXTERNAL_STORAGE`).

Identify and remove unnecessary transitive permissions via manifest merge rules:

```xml
<uses-permission android:name="..." tools:node="remove" />
```

---

# 64. UNUSED DANGEROUS PERMISSIONS

Requesting dangerous permissions that the application no longer requires harms:

- User trust and conversion rates
- Google Play Store review approval
- App privacy rating

---

# 65. RUNTIME PERMISSION FLOWS

Verify that every dangerous permission is requested via modern runtime permission contracts (`ActivityResultContracts.RequestPermission()`) with proper rationale handling.

---

# 66. NOTIFICATION PERMISSION (POST_NOTIFICATIONS)

On Android 13+ (API 33+), verify that the application requests `POST_NOTIFICATIONS` at runtime and does not assume notifications are enabled by default.

---

# 67. MEDIA AND STORAGE PERMISSIONS

Audit image, video, and audio access against modern granular media permissions (`READ_MEDIA_IMAGES`, `READ_MEDIA_VIDEO`, `READ_MEDIA_AUDIO`) vs legacy storage permissions.

---

# 68. PHOTO PICKER MODERNIZATION

Where applicable, verify whether the app uses the zero-permission Android Photo Picker rather than demanding broad media permissions.

---

# 69. BACKGROUND LOCATION POLICY COMPLIANCE

Requesting `ACCESS_BACKGROUND_LOCATION` triggers strict Google Play declaration and review requirements.

Verify explicit business justification.

Current Play policy requirements must be verified before concluding store compliance.

---

# 70. EXACT ALARM PERMISSIONS (SCHEDULE_EXACT_ALARM)

On Android 13+, `SCHEDULE_EXACT_ALARM` is restricted to alarm clock and calendar categories.

Verify whether the app should migrate to `USE_EXACT_ALARM` or non-exact WorkManager tasks.

---

# 71. FOREGROUND SERVICE TYPES

On Android 14+ (API 34+), every foreground service must declare an explicit `android:foregroundServiceType` in the manifest and hold the matching permission (`FOREGROUND_SERVICE_MEDIA_PLAYBACK`, `FOREGROUND_SERVICE_LOCATION`, etc.).

---

# 72. FOREGROUND SERVICE PERMISSION AUDIT

Verify that the application holds the specific type permission matching its declared service.

Confirm active Play Store policy guidelines before issuing final compliance findings.

---

# 73. BACKGROUND EXECUTION CONSTRAINTS

Release builds must adhere to strict platform background limitations.

Testing with the app continuously open in the foreground fails to validate background durability.

---

# 74. PACKAGE VISIBILITY RESTRICTIONS (`<queries>`)

On Android 11+ (API 30+), apps must declare explicit packages or intent signatures in the `<queries>` manifest element to interact with external apps.

---

# 75. `QUERY_ALL_PACKAGES` SCRUTINY

Declaring `android.permission.QUERY_ALL_PACKAGES` is heavily restricted on Google Play and triggers policy rejection unless the app represents a launcher, file manager, or antivirus.

---

# 76. SCOPED STORAGE ADHERENCE

Verify complete compatibility with Scoped Storage without relying on legacy storage bypasses.

---

# 77. `requestLegacyExternalStorage` RETIREMENT

Verify that the app does not rely on `android:requestLegacyExternalStorage="true"`, which is ignored on modern target SDK levels.

---

# 78. FILEPROVIDER CONFIGURATION

Inspect all `<provider>` FileProvider definitions:

- Unique `android:authorities`
- `android:exported="false"`
- `android:grantUriPermissions="true"`
- Strict XML path definitions (`res/xml/file_paths.xml`)

---

# 79. HARDCODED FILEPROVIDER AUTHORITIES

Hardcoding package names in FileProvider authorities breaks multi-flavor and parallel debug/release installations.

Use manifest placeholders:

```xml
android:authorities="${applicationId}.fileprovider"
```

---

# 80. SIDE-BY-SIDE INSTALLATION COMPATIBILITY

If debug and release variants must co-exist on the same physical testing device, verify that content provider authorities and custom permissions do not collide.

If not a project requirement:

**NOT APPLICABLE**

---

# 81. CUSTOM PERMISSION UNIQUENESS

Custom permissions must use signature-level protection and unique domain names to prevent permission spoofing vulnerabilities.

---

# 82. MINIMUM SDK (minSdk) COMPATIBILITY

Verify that all modern API calls, resources, and XML attributes are properly protected by runtime SDK version guards for the defined `minSdk`.

---

# 83. RUNTIME API VERSION GUARDS

Search for:

```kotlin
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
```

Ensure new platform APIs are not called unconditionally on older Android versions.

---

# 84. `@RequiresApi` ANNOTATION LIMITATIONS

The `@RequiresApi` annotation silences lint warnings but provides zero runtime protection if the enclosing method is called on older devices.

---

# 85. CORE LIBRARY DESUGARING

Verify whether the project enables core library desugaring in Gradle to safely use modern Java 8+ APIs (java.time, java.util.function) on older Android versions:

```groovy
coreLibraryDesugaringEnabled true
```

---

# 86. TARGET SDK BEHAVIORAL CHANGES

Raising `targetSdk` activates mandatory platform behavioral changes.

Audit the features directly impacted by the target SDK upgrade rather than generating generic lists.

---

# 87. GOOGLE PLAY TARGET SDK REQUIREMENT

Google Play mandates specific minimum target SDK levels for annual app updates.

Verify active Google Play target API requirements at the time of the audit.

If not verified:

**CURRENT PLAY TARGET REQUIREMENT: NOT VERIFIED**

---

# 88. COMPILE SDK VS TARGET SDK

`compileSdk` must be greater than or equal to `targetSdk`.

Never confuse compiler capabilities with runtime target behavior.

---

# 89. DEPENDENCY GRAPH AND SUPPLY CHAIN AUDIT

Inspect the complete dependency tree (`./gradlew app:dependencies`):

- Version conflicts and resolution strategies
- Duplicate libraries packaging different versions of the same code
- Stale or unmaintained critical libraries
- Known Common Vulnerabilities and Exposures (CVEs) where documented

---

# 90. DYNAMIC AND UNBOUNDED DEPENDENCY VERSIONS

Antipatterns like:

```groovy
implementation 'com.example:library:1.+'
implementation 'com.example:library:latest.release'
```

destroy build reproducibility and introduce unexpected breaking changes during release builds.

---

# 91. UNSTABLE SNAPSHOT DEPENDENCIES

Release builds must never depend upon `-SNAPSHOT` dependencies unless explicitly governed by a deliberate release decision.

---

# 92. DIRECT BINARY DEPENDENCIES (LOCAL AAR / JAR)

When bundling local binary `.aar` or `.jar` files in `libs/`:

- Trace provenance and source origin
- Verify native architecture packaging
- Ensure licensing compliance

---

# 93. DEPENDENCY REPOSITORY INTEGRITY

Inspect Gradle repository declarations:

- Prioritize Google Maven and Maven Central
- Audit third-party hosts (JitPack, custom artifactories)
- Ban unencrypted HTTP repositories (`http://`) to prevent man-in-the-middle dependency poisoning

---

# 94. PRIVATE REPOSITORY CREDENTIAL SECURITY

Repository credentials must be loaded via environment variables or secret Gradle properties, never hardcoded in `build.gradle`.

---

# 95. DEPENDENCY LOCKING AND VERIFICATION

Evaluate Gradle dependency verification (`verification-metadata.xml`) or lockfiles.

If absent:

Classify as P4 / supply chain enhancement unless reproducibility is actively broken.

---

# 96. OPEN SOURCE LICENSING COMPLIANCE

If the application bundles third-party open-source components requiring attribution (GPL, Apache 2.0, MIT):

Verify notice and attribution compliance.

Do not formulate definitive legal conclusions.

---

# 97. IN-APP OPEN SOURCE LICENSE SCREEN

An in-app attribution screen is standard practice for software containing Apache/MIT code.

Audit presence against product and licensing requirements.

---

# 98. SECRETS AND SENSITIVE ASSETS INVENTORY

Search for release-sensitive assets embedded in code or resources:

- Third-party API keys
- Keystore signing credentials
- OAuth client secrets
- Cloud service account private keys
- Backend administrative passwords

---

# 99. THE "CLIENT SECRET" FALLACY

Any "secret" embedded inside an Android APK or AAB is completely accessible to end users via decompilation.

If backend security trusts a client-embedded secret for authentication:

Document this critical architectural security flaw.

---

# 100. RESTRICTING CLIENT-FACING API KEYS

Client-visible API keys (e.g., Google Maps, Firebase API Key) must be restricted within provider consoles by:

- Android package name (`applicationId`)
- Production SHA-1 certificate fingerprint
- Allowed API service scopes
- Usage and billing quotas

---

# 101. SERVICE ACCOUNT PRIVATE KEYS IN PRODUCTION (P0)

Embedding a Google Cloud service account JSON key or AWS secret access key inside an Android app is an immediate Critical P0 vulnerability.

---

# 102. `google-services.json` METADATA BOUNDARIES

`google-services.json` contains public client identifiers, not private server secrets.

Verify that backend security rules (Firebase Security Rules) do not assume `google-services.json` is confidential.

---

# 103. ENVIRONMENT CONFIGURATION AUDIT

Verify that the release variant points strictly to production resources:

- Production backend API URLs
- Production OAuth client IDs
- Production analytics accounts
- Production remote configuration instances
- Production Crashlytics / Sentry projects

---

# 104. DEVELOPMENT BACKEND IN PRODUCTION (CRITICAL P1)

Catastrophic release misconfiguration:

```text
release build
↓
DEV_API_BASE_URL (points to localhost or staging server)
```

Real users will flood the staging database with live data or fail to connect.

---

# 105. STAGING CREDENTIAL LEAKS

Ensure production builds do not utilize staging API keys or sandbox payment gateway credentials.

---

# 106. FEATURE FLAG RELEASE DEFAULTS

Audit feature flag defaults for release:

Unfinished or experimental features must not be active in release builds simply because debug defaults enabled them.

---

# 107. REMOTE CONFIGURATION AS SOLE SECURITY BOUNDARY

Remote config flags should control UX feature rollout, never act as the sole barrier guarding sensitive backend operations.

---

# 108. EMERGENCY KILL SWITCH BEHAVIOR

If the application incorporates an emergency remote kill switch:

Verify behavior when the remote config service is unreachable or network is offline.

---

# 109. LOGGING HYGIENE IN RELEASE

Audit logging outputs:

- Log severity levels
- Personally Identifiable Information (PII)
- Session and auth tokens
- Full request and response bodies
- Raw database queries

---

# 110. `Log.d` AND `Log.v` STRIPPING

Verify whether release builds strip debug logging statements via R8 rules:

```text
-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(java.lang.String, int);
    public static int v(...);
    public static int d(...);
}
```

---

# 111. NETWORK LOGGING INTERCEPTOR IN PRODUCTION

OkHttp `HttpLoggingInterceptor.Level.BODY` must be disabled in release builds to avoid printing sensitive authorization headers and payloads to logcat.

---

# 112. CRASH REPORTING INTEGRATION

Verify that crash reporting (Firebase Crashlytics, Sentry, Bugsnag) is active and pointed to the production workspace.

If absent:

Document as an observability improvement.

---

# 113. DE-OBFUSCATION MAPPING FILE UPLOAD

When R8 obfuscation is enabled, stack traces are unreadable without the corresponding `mapping.txt` file.

Verify automated mapping file upload via Gradle plugins (`firebaseCrashlytics`, `sentry-android-gradle-plugin`).

---

# 114. MAPPING FILE ARCHIVAL AND RETENTION

Ensure CI builds archive `mapping.txt` for every tagged production release to enable manual de-obfuscation in the future.

---

# 115. NATIVE SYMBOL ARCHIVAL

If using NDK code, ensure unstripped native symbols are retained for crash de-obfuscation.

---

# 116. JETPACK COMPOSE COMPILER TRACE DE-OBFUSCATION

Verify that Compose compiler metrics and mapping files are handled according to toolchain recommendations.

---

# 117. ANALYTICS PIPELINE VERIFICATION

Verify:

- Production analytics workspace routing
- Debug event filtering (excluding developer traffic)
- User identity sanitization
- User consent handling where required

---

# 118. CONTAMINATING PRODUCTION ANALYTICS WITH TEST EVENTS

Ensure internal QA testing and automated UI test runs do not pollute production analytics properties.

---

# 119. THIRD-PARTY SDK PRIVACY AUDIT

Catalog all third-party SDKs that collect device or user telemetry (advertising, analytics, social login, crash tracking).

---

# 120. GOOGLE PLAY DATA SAFETY DECLARATION

Do not guess Data Safety declarations.

Map the exact data collected and shared by app code and embedded third-party SDKs.

If Play Console declaration responses are unavailable:

**DATA SAFETY DECLARATION CONSISTENCY: NOT VERIFIED**

---

# 121. PRIVACY POLICY VALIDITY

If the application requires a Privacy Policy:

Verify that the Privacy Policy URL is live, accessible via HTTPS, and accurately reflects app data practices.

---

# 122. BROKEN OR NON-COMPLIANT PRIVACY POLICY URL

A dead link (HTTP 404) or staging privacy policy URL in the Play Console listing is an immediate trigger for app rejection or removal.

---

# 123. ACCOUNT DELETION COMPLIANCE

Google Play mandates that any app allowing user account creation must provide an in-app and web-based account deletion mechanism.

Verify active Google Play policy requirements and inspect implementation.

---

# 124. IN-APP ACCOUNT DELETION FLOW

If account deletion exists:

- Confirmation dialog
- Re-authentication challenge
- Local database and token purging
- Cancellation of background jobs
- Verification of backend server account purge

---

# 125. EXTERNAL WEB ACCOUNT DELETION URL

Verify that the web deletion link submitted to Google Play Console allows users to request deletion of their account and associated data without requiring the app.

---

# 126. ADVERTISING SDK AUDIT

If ads are implemented:

Audit ad SDK integrations (AdMob, AppLovin).

If not implemented:

**NOT APPLICABLE**

---

# 127. ADVERTISING ID DECLARATION

If collecting the Android Advertising ID (AAID) on Android 12+, verify the declaration of `com.google.android.gms.permission.AD_ID` and the Play Console advertising declaration.

---

# 128. DESIGNED FOR FAMILIES / CHILDREN PRIVACY

If the app targets children:

Strict Google Play Families policies apply (COPPA, restricted SDKs, non-personalized ads).

Do not apply children policies to general-audience apps.

---

# 129. REGULATED APP CATEGORIES (HEALTH, FINANCE, VPN)

If the app operates within regulated domains:

Verify domain-specific Play policies and mandatory declarations.

Do not transfer specialized requirements to general apps.

---

# 130. USER-GENERATED CONTENT (UGC) POLICIES

If users can post content:

Verify reporting mechanisms, user blocking, content filtering, and terms of service.

---

# 131. DIGITAL GOODS AND IN-APP PURCHASES

If selling digital features or subscriptions:

Verify Google Play Billing implementation and compliance with Play payment policies.

Confirm current policy guidelines before issuing compliance verdicts.

---

# 132. GOOGLE PLAY BILLING LIBRARY VERSION

Verify that the app utilizes a supported version of the Google Play Billing Library according to Google's annual deprecation schedule.

---

# 133. BILLING RELEASE SKU CONFIGURATION

Ensure test SKU IDs are replaced with live production Google Play In-App Product and Subscription IDs.

---

# 134. PURCHASE ACKNOWLEDGEMENT CONTRACT

Purchases must be acknowledged within Google's required timeframe (typically 3 days), otherwise Google Play automatically refunds and revokes the purchase.

Verify the call to `BillingClient.acknowledgePurchase()`.

---

# 135. PENDING PURCHASES HANDLING

Verify that the app supports pending transactions (e.g., cash payments at retail) and does not grant entitlements before payment confirmation.

---

# 136. RESTORE PURCHASES FUNCTIONALITY

Ensure users can restore existing entitlements across reinstalls or device switches without relying solely on local flags.

---

# 137. SERVER-SIDE PURCHASE VALIDATION

For high-value digital goods, verify that purchases are validated securely against the Google Play Developer API on the backend.

---

# 138. PLAY INTEGRITY API USAGE

If implementing Play Integrity:

Verify that token verification is evaluated on the backend as a risk signal rather than an absolute binary client-side block.

---

# 139. ROOT DETECTION REALISM

Never treat root detection as a mandatory release blocker unless justified by explicit security threat models (e.g., banking apps).

---

# 140. APP UPGRADE AND UPDATE AUDIT

The single most critical production test:

```text
user has version N installed with active data
↓
Play Store downloads and installs version N+1
↓
application opens cleanly without data loss
```

Audit:

- Room / SQLite database migrations
- SharedPreferences and DataStore schema evolution
- Stored authentication tokens
- Pending WorkManager background jobs
- Existing notification channels
- Local cache compatibility

---

# 141. UPGRADE VS FRESH INSTALL SEPARATION

Never test only fresh installs.

Explicitly differentiate:

```text
FRESH INSTALL
```

from:

```text
UPGRADE FROM PREVIOUS RELEASE
```

---

# 142. SKIPPED VERSION MIGRATION TESTING

Users rarely update sequentially.

Simulate a user upgrading directly from version N-5 to the latest version.

---

# 143. APPLICATION DOWNGRADES

Android package manager prevents installing an older `versionCode` over a newer one without prior uninstallation.

Document this constraint for QA workflows.

---

# 144. DATABASE MIGRATION INTEGRITY (RELEASE BLOCKER)

A crashing database migration on startup will destroy user data and trigger massive 1-star reviews.

Verify that `fallbackToDestructiveMigration()` is not active on production tables containing user data.

---

# 145. PREFERENCES AND DATASTORE MIGRATIONS

Ensure key renames or default value changes do not reset user settings or corrupt stored sessions upon update.

---

# 146. AUTHENTICATION SESSION SURVIVAL

An application update must not force all existing users to log in again unless security tokens were deliberately invalidated.

---

# 147. WORKMANAGER COMPATIBILITY ACROSS UPGRADES

Existing users may have scheduled WorkManager jobs stored in local SQLite databases.

Verify that worker class names and input data formats remain backward compatible.

---

# 148. WORKER CLASS RENAMING HAZARDS

Renaming or deleting a `ListenableWorker` class while existing jobs remain scheduled will cause WorkManager to fail or throw exceptions when reviving work.

---

# 149. NOTIFICATION CHANNELS IMMUTABILITY

Notification channel attributes (importance, sound, vibration) are immutable once created on a user's device.

Updating code defaults will not alter settings for existing users.

---

# 150. DEEP LINK BACKWARD COMPATIBILITY

Ensure legacy deep link URLs previously sent in emails or push notifications continue resolving after an update.

---

# 151. APP SHORTCUTS COMPATIBILITY

Verify that static and dynamic app shortcuts do not point to deleted or renamed activity classes.

---

# 152. APP WIDGET COMPATIBILITY

Verify that home screen widgets update their layout and receiver bindings smoothly across version upgrades.

---

# 153. POST-UPDATE FIRST RUN IDEMPOTENCY

One-time data migration or onboarding routines must execute idempotently and record completion flags reliably.

---

# 154. "WHAT'S NEW" CHANGELOG PROMPT

Classify changelog dialogs as P4 UX enhancements.

---

# 155. FRESH INSTALL TESTING

Execute:

```text
clean device with no prior app data
↓
install release artifact
↓
launch application
```

---

# 156. FRESH INSTALL DEFAULT STATE

Verify:

- Initial database seeding
- Preference defaults
- Initial permission requests
- Login / onboarding navigation flows

---

# 157. TESTING REAL RELEASE ARTIFACTS

Where possible, install the exact compiled release AAB/APK on a physical device or emulator.

Successful compilation is never proof of runtime health.

---

# 158. SIGNED ARTIFACT INSTALLATION

If release signing keys are inaccessible during audit:

**SIGNED RELEASE INSTALL: NOT VERIFIED**

---

# 159. UPGRADE INSTALLATION SIMULATION

Ideal verification path:

```text
install previous signed production build
↓
populate user data and login session
↓
install new signed release candidate over existing app
↓
verify smooth startup and data continuity
```

---

# 160. UNINSTALL AND REINSTALLATION DYNAMICS

Verify behavior when a user uninstalls and reinstalls:

Understand what data restores via Google Auto Backup versus what initializes clean.

---

# 161. AUTO BACKUP SURPRISES

Users reinstalling an app may inherit old preferences or invalid tokens restored silently from Google Drive.

The onboarding flow must handle pre-existing restored tokens defensively.

---

# 162. PLAY STORE LISTING ASSETS

If store listing copy and assets reside in the repository (e.g., Fastlane metadata):

Verify consistency with actual app features.

If absent:

**STORE LISTING: NOT VERIFIED**

---

# 163. APPLICATION NAME (LABEL)

Verify that `android:label` matches the official brand name and does not exceed character limits.

---

# 164. LAUNCHER ICONS AND ADAPTIVE ICONS

Verify:

- Adaptive icon XML definitions (`ic_launcher.xml`, `ic_launcher_round.xml`)
- Foreground and background layers
- Themed icon monochrome layer (Android 13+)

---

# 165. ANDROID TV STORE ASSETS

For Android TV apps, verify the TV banner asset and leanback launcher icon.

---

# 166. SCREENSHOTS AND GRAPHIC ASSETS

If screenshots are not stored in the repository:

Mark as NOT VERIFIED.

---

# 167. CONTENT RATING DECLARATION

If Play Console questionnaires are unavailable:

**CONTENT RATING: NOT VERIFIED**

---

# 168. APP ACCESS AND DEMO CREDENTIALS

If the app requires login, verify that valid demo credentials and instructions are prepared for Google Play review teams.

---

# 169. REVIEWER ENVIRONMENT RESTRICTIONS

If the application requires IP whitelisting, VPNs, specific geolocation, or proprietary hardware:

Document clear reviewer bypass mechanisms.

---

# 170. GEOGRAPHIC DISTRIBUTION RESTRICTIONS

Verify that store listing distribution settings exclude countries where backend services or licensing rights are unsupported.

---

# 171. DEVICE CATALOG FILTERING

Inspect how manifest hardware declarations filter supported devices:

- Camera
- Telephony
- Bluetooth
- Sensor hardware

---

# 172. ACCIDENTAL DEVICE EXCLUSION VIA USES-FEATURE

Declaring:

```xml
<uses-feature android:name="android.hardware.camera" android:required="true" />
```

filters out all devices lacking a rear camera (e.g., tablets, Chromebooks).

Mark `android:required="false"` if the feature is optional.

---

# 173. ACCIDENTAL DEVICE INCLUSION WITHOUT HARDWARE GUARDS

Conversely, allowing installation on devices lacking necessary hardware without runtime checks will cause crashes when the feature is accessed.

---

# 174. SCREEN COMPATIBILITY AND TABLET SUPPORT

Verify that the app layout renders reasonably on tablets, foldables, and large screens without manifest restrictions artificially blocking distribution.

---

# 175. SCREEN ORIENTATION LOCKING

Locking orientation to `portrait` or `landscape` restricts foldables and tablets.

Do not classify as a bug if justified by product requirements.

---

# 176. CHROMEBOOK AND DESKTOP ANDROID SCOPE

If Chromebook distribution is enabled, audit keyboard, trackpad, and window resizing behavior.

If not targeted:

**NOT IN TARGET SCOPE**

---

# 177. APP DOWNLOAD AND INSTALLATION SIZE

AAB packaging and App Delivery optimize download size.

If not measured:

**DOWNLOAD SIZE: NOT MEASURED**

---

# 178. EXCESSIVE ASSET SIZES

Search for uncompressed media assets, oversized raw videos, bundled SQLite files, or duplicate graphics inflating artifact size.

---

# 179. UNUSED RESOURCES AND DRAWABLES

Resource shrinking removes unused XML resources, but avoid deleting assets referenced dynamically by name.

---

# 180. DENSITY ASSET DISTRIBUTION

Verify that vectorized drawables (vector XMLs) are prioritized over bloating the APK with multi-density PNGs.

---

# 181. NATIVE LIBRARY SIZE IMPACT

While multi-ABI universal APKs are large, Google Play serves single-ABI split APKs to devices.

Do not judge download footprint purely from universal APK sizes.

---

# 182. BASELINE PROFILES FOR STARTUP PERFORMANCE

If Baseline Profiles are configured:

Verify that profile rules are compiled into the AAB release artifact.

If absent:

Document as an optimization opportunity (P4), not a release blocker.

---

# 183. BENCHMARK AND TEST MODULE ISOLATION

Verify that Macrobenchmark and instrumentation test modules are strictly excluded from the production release bundle.

---

# 184. LEAKING DEBUG TOOLS INTO PRODUCTION

Search release configurations and manifests for:

- LeakCanary
- Stetho
- Flipper
- Chucker
- In-app debug menus
- Test endpoint switchers

---

# 185. LEAKCANARY IN PRODUCTION

LeakCanary must strictly use `debugImplementation`.

Shipping LeakCanary in release causes severe performance degradation and confusing user notifications.

---

# 186. MOCK AND STUB DATA LEAKS

Ensure release variants cannot initialize mock repositories or demo user profiles due to misconfigured dependency injection.

---

# 187. EXPOSED DEBUG AND DEVELOPER MENUS

Secret gestures (e.g., tapping a version number 7 times) that expose developer menus must be disabled or strictly protected in production builds.

---

# 188. HARDCODED TEST CREDENTIALS IN CODE (P0)

Hardcoded test usernames, passwords, or bypass tokens accessible in release builds represent critical security findings.

---

# 189. STRICTMODE PENALTIES IN RELEASE

`StrictMode` detection is valuable in debug, but penalty configurations that crash the app (`penaltyDeath()`) must be disabled in release.

---

# 190. PRODUCTION CODE RELYING ON ASSERTIONS

Java/Kotlin `assert` statements are disabled by default in Android runtime and must never be used to enforce production business logic or security checks.

---

# 191. VULNERABLE `BuildConfig.DEBUG` BRANCHES

Inspect all `if (BuildConfig.DEBUG)` code blocks.

For example:

```text
if (BuildConfig.DEBUG) {
    validation/security
}
```

Search for essential validation or security logic accidentally bypassed in release.

---

# 192. UNTESTED `if (!BuildConfig.DEBUG)` PATHS

Code paths that execute exclusively in release builds are frequently untested in everyday development.

```text
if (!BuildConfig.DEBUG) {
    ...
}
```

---

# 193. PRODUCTION-ONLY SDK INITIALIZATION

Analytics, crash reporters, and ad SDKs that only initialize in release builds must be tested via staging release variants.

---

# 194. PRODUCTION BACKEND API DISCREPANCIES

A successful staging build proves nothing regarding production backend health.

If production endpoints cannot be verified safely:

**PRODUCTION BACKEND INTEGRATION: NOT VERIFIED**

---

# 195. PRODUCTION SSL/TLS CERTIFICATE VALIDITY

Verify that production domains possess valid, unexpired SSL certificates issued by recognized public Certificate Authorities.

---

# 196. PRODUCTION API QUOTAS AND RATE LIMITS

Production environments enforce stricter rate limiting than staging environments.

Ensure critical release flows handle HTTP 429 gracefully.

---

# 197. CRASH-ON-LAUNCH SMOKE TESTING

Execute a clean install and launch on a real device with no attached debugger.

```text
clean install
↓
launch release
```

Catch immediate initialization crashes (`NullPointerException`, `ClassNotFoundException`).

---

# 198. OFFLINE FIRST LAUNCH RESILIENCE

Simulate a user launching the app for the very first time with no internet connectivity.

Verify that the app renders a clear offline state without crashing.

---

# 199. PERMISSION REJECTION SMOKE TESTING

Simulate a user denying all optional runtime permissions.

The app must remain operable and must not crash.

---

# 200. GOOGLE PLAY SERVICES (GMS) DEPENDENCY

If the app depends on Google Play Services (Maps, FusedLocation, Play Integrity):

Verify graceful handling and user prompts on devices where GMS is missing or outdated.

---

# 201. HARDCODED PLAY SERVICES VERSIONS

Avoid hardcoding fragile Play Services version checks that break as platform updates roll out.

---

# 202. FIREBASE INITIALIZATION FOR RELEASE

If Firebase configuration files (`google-services.json`) are variant-specific, ensure the release variant loads the production Firebase project credentials.

---

# 203. FLAVOR-SPECIFIC APPLICATION IDS IN FIREBASE

Every distinct `applicationId` across flavors must be registered as a separate Android app in the Firebase console.

---

# 204. CRASHLYTICS SYMBOL MAPPING UPLOAD

Verify that the Crashlytics Gradle plugin runs during release builds and successfully uploads R8 mapping files.

---

# 205. CI/CD AUTOMATION PIPELINE AUDIT

Map the CI release workflow:

```text
git tag / trigger
↓
checkout source
↓
JDK & Android SDK setup
↓
dependency restoration
↓
unit tests & lint checks
↓
bundleRelease
↓
sign artifact via secrets
↓
publish to Play Console track
```

---

# 206. TOOLCHAIN PINNING IN CI

Verify that the CI environment pins:

- Specific JDK distribution and version
- Gradle wrapper version
- Android SDK build tools version

---

# 207. GRADLE WRAPPER INTEGRITY

Ensure `gradlew` and `gradle-wrapper.jar` are committed to the repository and match official checksums.

---

# 208. WRAPPER CHECKSUM VERIFICATION

Verify whether GitHub Actions or CI workflows validate the Gradle wrapper checksum (`gradle/wrapper-validation-action`).

---

# 209. CI SECRETS MANAGEMENT

Ensure signing keystores, passwords, and Google Play API service account keys are stored in encrypted secret vaults (GitHub Secrets, Vault) and never outputted in build logs.

---

# 210. LEAKING SECRETS IN BUILD LOGS

Commands that pass passwords as command-line arguments can expose secrets in public CI build logs.

---

# 211. RELEASING FROM DEVELOPER LAPTOPS

Relying on a developer's local laptop to build and sign production releases introduces severe operational risks and lacks reproducibility.

---

# 212. AUTOMATED QUALITY GATES BEFORE RELEASE

Verify that the release CI pipeline enforces mandatory quality gates:

- All unit tests pass
- Android Lint reports no fatal issues
- Release compilation succeeds
- Room database migration tests pass

---

# 213. IGNORING TEST FAILURES IN CI

Search for:

```yaml
continue-on-error: true
```

or Gradle tasks running with `--continue` where failing test suites are ignored.

---

# 214. LINT ABORT ON ERROR BEHAVIOR

Inspect `lintOptions`:

```groovy
abortOnError false
```

Determine whether fatal errors are ignored during release builds.

Do not mandate zero lint warnings, but fatal errors must fail the build.

---

# 215. LINT BASELINE USAGE

Using a lint baseline is a valid strategy for legacy projects.

Verify that newly introduced errors are not hidden behind baseline masks.

---

# 216. RELEASE ARTIFACT PROVENANCE

Ensure that the exact AAB artifact tested in the QA pipeline is promoted to production, rather than compiling a new artifact from source with different timestamps.

---

# 217. "BUILD ONCE, PROMOTE" PRINCIPLE

Promoting a single verified binary across testing tracks guarantees that what was tested is exactly what ships to users.

---

# 218. GIT COMMIT TRACEABILITY

Every production release artifact should be traceable to an immutable Git commit hash and release tag.

---

# 219. CLIENT-SIDE ROLLBACK IMPOSSIBILITY

Mobile applications cannot be rolled back instantly like web servers.

Backward-compatible backend APIs and emergency server-side feature flags are essential defenses.

---

# 220. DISASTER RECOVERY PROTOCOL FOR BAD RELEASES

Establish:

> What is the exact operational response if a newly released version exhibits a critical crash in production?

Available recovery mechanisms:

- Halting the Google Play rollout
- Staged rollouts (e.g., 5% → 10% → 20% → 100%)
- Remote kill switches / feature flags
- Rapid hotfix release pipeline

---

# 221. STAGED ROLLOUT STRATEGY

Verify whether the release plan incorporates staged percentage rollouts.

If unverified:

**STAGED ROLLOUT STRATEGY: NOT VERIFIED**

---

# 222. POST-RELEASE MONITORING

Ensure real-time monitoring of:

- Crashlytics / Sentry crash-free session rates
- Google Play Console Android Vitals (crash rate, ANR rate)
- Authentication failure spikes
- Backend API error rates

---

# 223. GOOGLE PLAY PRE-LAUNCH REPORT

If pre-launch report data is accessible in the Play Console:

Audit findings across test devices.

If unavailable:

**PRE-LAUNCH REPORT: NOT VERIFIED**

---

# 224. GOOGLE PLAY CONSOLE POLICY WARNINGS

Do not fabricate Play Console account warnings without direct access.

---

# 225. DEVICE AND OS COMPATIBILITY TESTING

Release testing must validate against:

- Minimum supported Android version (`minSdk`)
- Median current market Android version
- Latest target Android version

---

# 226. COMPATIBILITY TEST MATRIX

Construct:

| Android Version / Device | Installation | Cold Launch | Core Feature Flow | Status |
|---|---|---|---|---|

---

# 227. LOW-END HARDWARE VALIDATION

Validate the release build on budget, low-memory devices to expose memory pressure crashes and UI lag.

---

# 228. 64-BIT NATIVE ARCHITECTURE COMPLIANCE

Google Play strictly mandates 64-bit support for all applications containing native code.

Verify that 64-bit `.so` libraries (`arm64-v8a`) are present.

If unverified:

**NATIVE PLAY REQUIREMENTS: NOT VERIFIED**

---

# 229. 16 KB PAGE SIZE COMPLIANCE

For applications bundling native C/C++ code, audit readiness for 16 KB page size support on modern Android platform architectures.

---

# 230. EDGE-TO-EDGE AND WINDOW INSETS COMPLIANCE

When targeting modern SDKs where edge-to-edge rendering is mandatory:

Verify that system bars (status bar, navigation bar) do not overlap critical UI interactive elements.

---

# 231. PREDICTIVE BACK NAVIGATION

If targeting Android 14+ and implementing custom back navigation:

Verify compatibility with Predictive Back animations.

---

# 232. NOTIFICATION TRAMPOLINE RESTRICTIONS

Verify that notification actions and taps launch Activities directly, rather than launching broadcast receivers or services that start activities.

---

# 233. EXACT ALARM RESTRICTIONS

Verify compliance with modern background scheduling limitations.

---

# 234. FOREGROUND SERVICE POLICY COMPLIANCE

Confirm that all declared foreground services comply with Google Play foreground service use-case policies.

---

# 235. PLAY POLICY CITATION REQUIREMENTS

For every policy-related finding, document:

```text
Policy area:
Applicable to this app:
Evidence:
Current requirement verified:
YES / NO
Date / source:
```

Never assert a policy rejection without verifying active Google Play guidelines.

---

# 236. SEPARATING PLATFORM BUGS FROM STORE POLICY

Distinguish:

```text
permission runtime crash
```

(Platform implementation correctness defect)

from:

```text
permission declaration violates store policy
```

(Google Play compliance violation)

Keep them strictly segregated.

---

# 237. SEPARATING BLOCKERS FROM RECOMMENDATIONS

Classify every finding into clear operational buckets:

```text
RELEASE BLOCKER
HIGH RISK
NON-BLOCKING ISSUE
IMPROVEMENT
NOT VERIFIED
```

---

# 238. RELEASE BLOCKER EXAMPLES

Concrete blockers:

- Release build fails compilation
- App crashes on startup in release variant
- Incorrect signing key used
- Database migration crashes upon upgrade
- Release variant points to staging/dev API
- Critical runtime permission flow broken
- Verified active Google Play policy violation preventing submission

---

# 239. NON-BLOCKING IMPROVEMENTS

Non-blocking suggestions:

- Missing Baseline Profiles
- Absence of documented staged rollout policy
- Additional analytics telemetry
- Minor build speed optimizations

Never present cosmetic recommendations as "The app cannot be published to Google Play."

---

# 240. SUBSTANTIVE FINDING REPORTING TEMPLATE

Every substantive finding must be documented using this exact structure:

```text
ID:
Severity:
Release classification:
Confidence:
Status:

Build variant:
Application ID:
Version:
API scope:
Device scope:

File:
Gradle config:
Manifest component:
Dependency:
Relevant code/config:

Problem:

Evidence:

Release Flow:

Reproduction:

Debug behavior:

Release behavior:

User impact:

Store/Policy impact:

Security/Data impact:

Root cause:

Recommended remediation:

Regression / release test:

Production verification:

Complexity:
XS / S / M / L / XL
```

---

# 241. SEVERITY RATING SYSTEM

Apply strict severity definitions:

## P0 - CRITICAL

- Compromise of production release signing keys or server credentials
- Hardcoded production administrative secrets
- Catastrophic security or privacy vulnerability shipping to all users

## P1 - HIGH

- Release build fails compilation or crashes on startup
- Release-only crash blocking core user flows
- Broken database migration destroying user data upon upgrade
- Production build pointing to staging/dev backends
- Verified Google Play policy violation causing immediate app rejection

## P2 - MEDIUM

- Substantial device compatibility or configuration defect
- Store readiness issue requiring remediation before public release

## P3 - LOW

- Bounded release edge cases
- Minor metadata or configuration inconsistency

## P4 - IMPROVEMENT

- CI/CD optimizations, observability enhancements, or build performance tuning

---

# 242. CONFIDENCE RATINGS

Use:

```text
HIGH
MEDIUM
LOW
```

HIGH:

Empirically verified via successful/failed release compilation or direct code evidence.

MEDIUM:

Strong configuration evidence, but unverified on physical hardware or Play Console.

LOW:

Dependent upon unavailable external backend configs or unverified policy updates.

---

# 243. VERIFICATION STATUS

Use:

```text
CONFIRMED
LIKELY
THEORETICAL
NOT VERIFIED
```

---

# 244. RELEASE VERIFICATION FLAGS

Include:

```text
RELEASE BUILD:
PASS
FAIL
NOT VERIFIED

SIGNED INSTALL:
PASS
FAIL
NOT VERIFIED

UPGRADE TEST:
PASS
FAIL
NOT VERIFIED

PLAY POLICY:
VERIFIED
PARTIAL
NOT VERIFIED
```

---

# 245. DO NOT MODIFY CODE DURING THE AUDIT

Throughout the audit:

- Do not increment `versionCode`
- Do not bump `targetSdk`
- Do not alter signing configurations
- Do not inject ProGuard keep rules
- Do not remove permissions
- Do not upgrade dependencies
- Do not edit Play Console configurations

Complete the investigation first.

---

# 246. OUTPUT REPORT STRUCTURE - ANDROID_RELEASE_PLAY_READINESS_AUDIT.md

Structure the audit report:

## 1. Executive Summary

- Release stack overview
- Release compilation status
- Signing integrity status
- Identified release blockers
- Play Store readiness verdict
- Production configuration posture

## 2. Release Environment

## 3. Build Variant Matrix

## 4. Debug vs Release Differences

## 5. Release Build Audit

## 6. AAB / APK Audit

## 7. Signing Audit

## 8. R8 / ProGuard Audit

## 9. Resource Shrinking Audit

## 10. Manifest Merge Audit

## 11. Permissions Audit

## 12. Target SDK / Platform Compatibility

## 13. Dependencies / Supply Chain Audit

## 14. Secrets / Production Configuration

## 15. Network / API Production Config

## 16. Firebase / External Service Config

## 17. Logging / Analytics / Crash Reporting

## 18. Update / Migration Audit

## 19. Fresh Install Audit

## 20. Upgrade Install Audit

## 21. Device / API Compatibility Matrix

## 22. Play Store Policy Areas

## 23. Data Safety / Privacy Configuration

## 24. Billing Audit

If implemented.

## 25. Store Listing Readiness

If assets available.

## 26. CI/CD Release Pipeline

## 27. Rollout / Monitoring / Recovery

## 28. Findings Summary

| ID | Severity | Classification | Area | Problem | Confidence | Status |
|---|---|---|---|---|---|---|

## 29. Release Blockers

## 30. P0 Findings

## 31. P1 Findings

## 32. P2 Findings

## 33. P3 Findings

## 34. P4 Improvements

## 35. Things Done Well

## 36. Unknown / Not Verified

## 37. Final Release Readiness Matrix

Use:

```text
✅ PASS
⚠️ PARTIAL
❌ FAIL
❓ NOT VERIFIED
➖ NOT APPLICABLE
```

Covering:

- Clean build
- Release build compilation
- AAB packaging
- R8 minification
- Resource shrinking
- Cryptographic signing
- Fresh installation
- Cold launch
- Version upgrade
- Database migration
- Production authentication
- Production API endpoints
- Permissions model
- Notifications
- Deep links / App Links
- Background execution
- External SDK integrations
- Crash reporting de-obfuscation
- Target SDK compliance
- Privacy and Data Safety
- Google Play Billing
- Store listing metadata
- CI/CD pipeline
- Rollout and monitoring

## 38. Go-Live Remediation Roadmap

### Phase 0 - Release Blockers

### Phase 1 - Before Production Submission

### Phase 2 - First Production Rollout

### Phase 3 - Post-Launch Hardening

---

# 247. BUILD VARIANT MATRIX

Construct:

| Variant | Compiles | Minified | Resource Shrunk | Signed | Tested on Device |
|---|---|---|---|---|---|

---

# 248. SIGNING SECURITY MATRIX

| Environment | Certificate Type | Storage Location | Verified | Risk |
|---|---|---|---|---|

Never display sensitive credentials.

---

# 249. CONFIGURATION ENVIRONMENT MATRIX

| Configuration | Debug Value | Release Value | Expected Production Target | Status |
|---|---|---|---|---|

Covering:

- Base API URL
- OAuth Client ID
- Firebase project
- Analytics property
- Crash reporting project
- Feature flag defaults

---

# 250. PERMISSIONS AUDIT MATRIX

| Permission | Source (App vs Library) | Protection Level | Runtime Rationale | Store Policy Relevance |
|---|---|---|---|---|

---

# 251. DATABASE AND STORAGE UPGRADE MATRIX

| From Version | To Version | Room Migration Path | Preferences Preserved | Background Work Intact | Verified |
|---|---|---|---|---|---|

---

# 252. STORE READINESS MATRIX

| Area | Mandatory | Available in Repo | Verified | Status |
|---|---|---|---|---|

Covering:

- App name
- App icon
- Screenshots
- Privacy Policy
- Data Safety declarations
- Content rating
- App access credentials
- Account deletion
- In-app billing

---

# 253. SECOND PASS - RELEASE-ONLY CODE PATH ATTACK

Review the codebase with a single guiding question:

> What code runs exclusively in release, or behaves fundamentally differently in release?

Inspect:

- R8 obfuscation and optimization
- Production API base URLs
- Release-only SDK initialization
- Production cryptographic signing
- Log suppression
- Resource shrinking
- Manifest placeholders

---

# 254. SECOND PASS - DEBUG FALSE CONFIDENCE ATTACK

For every critical feature, evaluate:

> What aspect of the development environment is masking a production failure?

Examples:

- Debug keystore SHA registered in Google Cloud Console
- Mock backend stubs
- Verbose logging hiding race conditions
- Unminified code masking reflection failures
- Permissive network security config
- Pre-authenticated developer test accounts

---

# 255. SECOND PASS - FRESH INSTALL SIMULATION

Simulate:

```text
brand new physical device
↓
install release AAB
↓
deny all optional runtime permissions
↓
launch application
```

Verify that the app reaches a usable state without crashing.

---

# 256. SECOND PASS - OLD USER UPGRADE SIMULATION

Simulate a user upgrading from a historical production release:

```text
device with legacy database v4
legacy SharedPreferences
pending scheduled WorkManager jobs
cached auth tokens
↓
install latest release candidate
```

Trace the entire cold startup sequence.

---

# 257. SECOND PASS - R8 MINIFICATION ATTACK

For every:

- Reflection call
- JSON serializer/deserializer
- JNI C++ binding
- Dynamic class lookup
- Dynamic resource identifier lookup

Evaluate:

> Can code shrinking, field stripping, or name obfuscation break this runtime behavior?

---

# 258. SECOND PASS - SIGNING CERTIFICATE SERVICE BINDING

Inspect:

> Which external services bind client identity directly to the production signing certificate?

Audit:

- Google Sign-In / OAuth
- Google Maps SDK
- Firebase Authentication
- App Links `assetlinks.json`

---

# 259. SECOND PASS - MISSING ENVIRONMENT VARIABLES

Mentally strip every CI/build environment variable:

Evaluate:

> Does the release build fail cleanly, or silently fall back to insecure debug defaults?

---

# 260. SECOND PASS - STORE POLICY APPLICABILITY

For sensitive capabilities:

- Background location
- Broad package visibility (`QUERY_ALL_PACKAGES`)
- VPN services
- In-app digital goods billing
- Children's apps
- Health and financial categories
- User-generated content

Verify against current, active Google Play policies.

---

# 261. SECOND PASS - PRODUCTION NETWORK REALISM

Analyze or test against production-like environments:

```text
real production host
real TLS
release auth client
release certificate identity
```

Verify:
- Production domain hostnames
- Public SSL/TLS certificates
- Production OAuth client configurations
- Production API rate limits

A pass on staging never proves production network viability.

---

# 262. SECOND PASS - EXECUTION WITHOUT ATTACHED DEBUGGER

Run release builds without an attached debugger.

Timing, coroutine execution, and exception handling differ when unhooked from JDWP.

---

# 263. SECOND PASS - CRASH OBSERVABILITY VALIDATION

Inject a controlled, test-only exception within a staging release build:

Verify that the crash reporting tool captures, de-obfuscates, and renders the stack trace with readable line numbers.

Never trigger test crashes in live production user populations.

---

# 264. SECOND PASS - ROLLOUT FAILURE CONTINGENCY

Assume the newly published release candidate contains a fatal bug:

Evaluate:

- How fast can the rollout be halted in Google Play Console?
- Can the defect be neutralized via remote feature flags?
- How quickly can a hotfix binary be compiled, signed, and approved?
- Does the backend maintain backward compatibility with previous app versions?

---

# 265. SECOND PASS - BACKEND API VERSION SKEW

During phased rollout, active users simultaneously run:

```text
version N (old client)
version N+1 (new client)
```

The backend must support both payload schemas concurrently.

---

# 266. SECOND PASS - LONG-TERM UN-UPDATED CLIENTS

Evaluate:

> What happens if a user does not update their application for 6 months?

Audit:

- API endpoint deprecations
- Auth token refresh lifecycles
- Enum serialization drift
- Force-update enforcement mechanisms

---

# 267. SECOND PASS - IN-APP FORCE UPDATE DEADLOCKS

If an in-app force-update gate exists:

Verify behavior when:

- Backend is unreachable
- Google Play Store is offline
- Update has not yet propagated globally to all regions

The user must not be trapped in an unrecoverable, flickering loop.

---

# 268. SECOND PASS - UNINSTALL AND CLOUD RESTORATION

Simulate Google Auto Backup restoration across reinstalls:

Ensure stale auth tokens or obsolete device IDs do not corrupt initial onboarding.

---

# 269. SECOND PASS - PERMISSION DENIAL RECOVERY

For every optional runtime permission:

```text
deny
↓
deny again / don't ask again
```

Simulate denial and permanent denial ("Don't ask again").

Verify that core non-dependent features remain fully functional.

---

# 270. SECOND PASS - MINIMUM SDK PLATFORM VALIDATION

Where possible, execute the release build on a physical device or emulator running the declared `minSdk`.

Expose missing API level checks and class verification crashes.

---

# 271. SECOND PASS - LATEST ANDROID PLATFORM BEHAVIOR

Execute on the latest production Android OS version.

Expose behavioral shifts in window insets, predictive back, notifications, and background work.

---

# 272. SECOND PASS - MANIFEST HARDWARE FILTERING

Audit:

> Which device categories will Google Play filter out based on the merged manifest `<uses-feature>` tags?

Identify accidental exclusions of tablets, foldables, or camera-less devices.

---

# 273. FINAL QUALITY GATE

Before publishing the audit report, verify:

- Release compilation is audited separately from debug builds
- AAB bundle packaging is evaluated for Google Play distribution
- Signing configuration is verified from code/scripts, not assumed
- Secret passwords and tokens are strictly masked in the report
- Merged release manifest is analyzed, not just source manifest
- Transitive permissions injected by libraries are audited
- R8 findings include specific reflection, JNI, or serialization evidence
- Indiscriminate keep rules are not recommended as quick fixes
- Resource shrinking and dynamic string lookups are verified
- Fresh install and version upgrade paths are evaluated separately
- Multi-version skipped database migrations are audited
- Production backend configs are not assumed from staging success
- Release certificate service bindings (OAuth, Maps) are checked
- Debugging tools (LeakCanary, Stetho) do not leak into release
- Crash mapping de-obfuscation pipeline is verified
- Google Play policy assertions cite active, verified guidelines
- Platform runtime bugs are segregated from store policy issues
- Unavailable Play Console settings are clearly flagged NOT VERIFIED
- Billing and subscriptions are audited only if implemented
- Child, health, financial, and UGC policies are applied only when relevant
- minSdk and targetSdk behavioral changes are verified against target versions
- Version skew between old and new clients during rollout is evaluated
- Identified release blockers are strictly separated from P4 improvements

---

# FINAL RULE

Do not deliver a report stating:

> Increment versionCode, enable R8, compile an AAB, and publish the app to Google Play.

That is not a release readiness audit.

Seek concrete systemic failures such as:

```text
debug build
↓
Google OAuth uses debug signing certificate fingerprint
↓
login works perfectly in QA
↓
release variant compiled and signed with production key
↓
production SHA-1 fingerprint was never registered in Google Cloud Console
↓
authentication fails for 100% of production users immediately after release
```

or:

```text
release minification enabled
↓
JSON serializer inspects data models via runtime reflection
↓
R8 strips model constructors and field names
↓
debug automated tests pass
↓
release build crashes with JsonDataException parsing production API responses
```

or:

```text
current application database version = 8
↓
existing user updates from historical production version with database v4
↓
only migration 7 → 8 was implemented and tested
↓
database throws IllegalStateException upon startup
↓
app crashes continuously or wipes user data via destructive fallback
```

or:

```text
release CI environment variable missing
↓
Gradle script silently falls back to staging API endpoint
↓
production application ships successfully to Google Play
↓
thousands of real users transmit sensitive data to staging servers
```

or:

```text
third-party library injects dangerous permission via manifest merge
↓
developer inspects only app/src/main/AndroidManifest.xml
↓
permission ships inside final production release
↓
Google Play Store flags policy violation and rejects app submission
```

or:

```text
R8 mapping.txt file is not archived by CI
↓
production crashes occur in live release
↓
Crashlytics displays obfuscated stack traces with unreadable symbols
↓
engineering team cannot diagnose or locate the failure
```

or:

```text
new release renames a ListenableWorker class
↓
existing users have active scheduled WorkManager jobs referencing old class name
↓
after update, WorkManager fails to instantiate missing worker class
↓
critical background synchronization permanently halts
```

These are the release and distribution failures you must uncover.

Think through:

- Debug vs release configuration differences
- Source vs merged release manifests
- Unminified vs shrunk and obfuscated bytecode
- Local developer builds vs automated CI pipelines
- Unsigned vs cryptographically signed binaries
- Fresh clean installs vs multi-version upgrades
- Current client vs historical legacy clients
- Staging vs production environments
- APK vs App Bundle split delivery
- Technical code correctness vs Google Play Store compliance

For every substantive finding, you must answer:

> Does this defect manifest strictly in release builds?

> Does the compiled AAB contain the expected production configuration?

> Does the production signing identity match all registered external services?

> Can an existing user safely upgrade without data loss or crashes?

> Does the merged manifest reflect the intended permission and component model?

> Is the Play Store policy assertion backed by verified active requirements?

If not verified at runtime:

**NOT VERIFIED.**

If Google Play policy is unconfirmed:

**CURRENT PLAY POLICY NOT VERIFIED.**

If representing only process quality enhancement rather than a release blocker:

**P4 - IMPROVEMENT.**

Uncovering 5 genuine release blockers with exact root cause analysis is infinitely superior to writing 100 generic publishing recommendations.

The goal is a forensically precise release audit from which every substantive finding translates directly into:

- a Gradle build fix
- a signing and configuration correction
- an R8 regression test
- an upgrade and database migration test
- a pre-flight release smoke test
- an automated CI quality gate
- a verified Google Play submission checklist
- a production-safe phased rollout plan

分类与标签

编程开发、安卓发布、应用签名、代码混淆、升级迁移、应用商店上架

前往 AI 图片创作