Android Signed-Release Pipeline

    1

    Gradle's signing config is conditional on environment variables; with one unset it silently produces an unsigned artifact and still prints `BUILD SUCCESSFUL`.

    $39

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Android Signed-Release Pipeline

    Example session with this skill installed

    Build the 1.4.0 release candidate of our Android app (com.example.acme, versionCode 12) with the production upload key and verify it before I upload the bundle to the internal testing track.

    • Read your context and instructions
    • Compiled the android signed-release pipeline

    Summary

    Candidate built from a clean tree at a3f9c21, signed with the recorded upload key, and verified from the artifacts. State:

    verified (not submitted, not device-accepted).

    GateResult
    Working treeclean (git status --porcelain empty)
    Toolskeytool 21.0.3, apksigner 35.0.0, aapt2 8.5.0
    Unsigned APK presentno
    apksigner verifyOK, v2 scheme, 1 signer
    Signer SHA-2567C:3E:...:9A = recorded fingerprint
    jarsigner -verify app-release.aabjar verified
    Package / versionCode / versionNamecom.example.acme / 12 / 1.4.0
    debuggablefalse
    Permissions in shipped binaryINTERNET, POST_NOTIFICATIONS (allow-listed); none extra
    Forbidden stringsnone (staging\.example\.com, 10\.0\.2\.2)
    candidates/AcmeApp-1.4.0-12/
      app-release.apk          sha256 4b8e...d10f
      app-release.aab          sha256 c0a2...77e3
      SHA256SUMS.txt  APK-SIGNATURE.txt  AAB-SIGNATURE.txt  SIGNING-CERTIFICATE.txt
      BUILD-INPUTS.json  RELEASE-EVIDENCE.json  VERIFY.txt
    

    RELEASE-EVIDENCE.json records physicalDeviceAcceptance: "pending"; no secrets are in the folder.

    Next steps

    • Device acceptance on Android 10 and Android 15; record per device in DEVICE-ACCEPTANCE.md, then flip the evidence flag.
    • Upload app-release.aab to the internal testing track and write SUBMISSION-RECEIPT.json with the track, version code, upload time and console reference (state submitted).
    • Do not describe this build as "released" until the console shows published or rolling out, with the percentage.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Gradle's signing config is conditional on environment variables; with one unset it silently produces an unsigned artifact and still prints BUILD SUCCESSFUL. This skill makes the key, the build and the verification three separate steps that read facts from files, and keeps a receipt whose states are never collapsed into "released".

    Scripts

    • New-UploadKey.ps1: 4096-bit RSA upload key with random passwords passed to keytool only through environment variables, keystore and signing .env written outside the repo with owner-only ACLs, refusal to overwrite, public certificate exported as PEM with its SHA-256 fingerprint printed from the certificate itself.
    • Build-SignedCandidate.ps1: dirty-tree guard, gradlew clean test lint bundleRelease assembleRelease, refusal if an unsigned APK appears, apksigner verify, jarsigner -verify, certificate record, a check that the APK signer digest equals the keystore certificate, SHA-256 sums, BUILD-INPUTS.json and a non-secret RELEASE-EVIDENCE.json.
    • Verify-Release.ps1 and verify-release.sh: read the artifacts: exactly one signer equal to the recorded fingerprint, v2 scheme, AAB JAR signature, package id, versionCode and versionName, not debuggable, only allow-listed permissions in the shipped binary (manifest merging adds library permissions), no forbidden strings (staging hosts, removed endpoints). Exit 0/1/2.

    References

    • The key lifecycle: owner decisions before generating, what to commit, what never to commit, rotation and recovery with and without Play App Signing, certificate fingerprint versus keystore-file hash.
    • Receipt schemas: build inputs, release evidence, submission receipt.
    • The state vocabulary: built, verified, device-accepted, submitted, in review, approved, published or rolling out; each with the evidence that proves it.

    Requirements

    Windows with Android Studio (keytool, jarsigner, apksigner, aapt2) and openssl for key generation and building; Linux, macOS or CI with the same tools for the bash verifier. No network.

    Windows-first for builds. No automated Play Console uploads. Requires local Android SDK and JDK tools. Deciding Play App Signing status is a manual prerequisite.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 19 days ago

    Requires

    PowerShell 7
    Android Studio or JDK 17+
    Android SDK build-tools
    OpenSSL
    Git

    Permissions

    Terminal / Shell
    Write Files
    Read Files
    Environment Variables

    Shell runs keytool, gradlew, apksigner, jarsigner, aapt2, openssl and git. Read/write files: the Android project, the keystore and signing .env in a directory you choose outside the repo, and the candidate output folder. Environment variables: signing passwords are passed to keytool and Gradle only through the process environment during the run and are cleared afterwards. No network.

    Listed19 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a hardened, multi-stage pipeline that uses independent binary verification to catch silent failures—like missing signing configurations or unwanted manifest permissions—that standard Gradle builds often overlook.

    The purchase includes a suite of PowerShell and Bash scripts for secure key generation, build execution, and post-build auditing, along with documentation for integrating them into your local or CI environment.

    Key generation and build scripts are optimized for Windows (PowerShell), while the critical verification scripts are cross-platform and compatible with Windows, Linux, and macOS environments.

    While the skill automates the creation and verification of release-ready artifacts, it does not include the final API handshake to the Google Play Console, ensuring you maintain manual control over the actual deployment step.

    Yes, the Manifest Auditing component allows you to define a permission allow-list, automatically failing the build if a third-party library injects unexpected or high-risk permissions during the manifest merging process.

    New in APIs & Backend