android-release.yml

name: Android Release

on:
  workflow_dispatch:
    inputs:
      release_tag:
        description: "Optional release tag"
        required: false
        type: string
      release_name:
        description: "Optional release title"
        required: false
        type: string
      prerelease:
        description: "Mark release as prerelease"
        required: true
        default: true
        type: boolean
      build_type:
        description: "Build type"
        required: true
        default: release
        type: choice
        options:
          - release
          - debug

permissions:
  contents: write

concurrency:
  group: android-release-${{ github.ref }}
  cancel-in-progress: false

jobs:
  build-and-release:
    runs-on: ubuntu-latest
    env:
      NODE_VERSION: "24"
      JAVA_VERSION: "21"
      PNPM_VERSION: "10.28.1"
      ANDROID_API_LEVEL: "36"
      ANDROID_BUILD_TOOLS: "36.0.0"
      ANDROID_NDK_VERSION: "27.0.12077973"
      ANDROID_CMAKE_VERSION: "3.22.1"
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup pnpm
        uses: pnpm/action-setup@v4
        with:
          version: ${{ env.PNPM_VERSION }}

      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: pnpm

      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: ${{ env.JAVA_VERSION }}
          cache: gradle

      - name: Setup Android SDK
        uses: android-actions/setup-android@v3

      - name: Install Android packages
        shell: bash
        run: |
          set +o pipefail
          yes | sdkmanager --licenses > /dev/null
          set -o pipefail
          sdkmanager --install \
            "platform-tools" \
            "platforms;android-${ANDROID_API_LEVEL}" \
            "build-tools;${ANDROID_BUILD_TOOLS}" \
            "ndk;${ANDROID_NDK_VERSION}" \
            "cmake;${ANDROID_CMAKE_VERSION}"

          echo "ANDROID_NDK_HOME=${ANDROID_SDK_ROOT}/ndk/${ANDROID_NDK_VERSION}" >> "$GITHUB_ENV"
          echo "ANDROID_NDK_ROOT=${ANDROID_SDK_ROOT}/ndk/${ANDROID_NDK_VERSION}" >> "$GITHUB_ENV"

      - name: Prepare Android local.properties
        shell: bash
        run: |
          cat > android/local.properties <<EOF
          sdk.dir=${ANDROID_SDK_ROOT}
          ndk.dir=${ANDROID_SDK_ROOT}/ndk/${ANDROID_NDK_VERSION}
          EOF

      - name: Prepare env file
        shell: bash
        run: |
          if [ ! -f .env ] && [ -f .env.example ]; then
            cp .env.example .env
          fi

      - name: Validate signing secrets
        if: ${{ inputs.build_type == 'release' }}
        shell: bash
        env:
          KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
          KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
          KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
          KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
        run: |
          test -n "$KEYSTORE_BASE64" || { echo "Missing secret: ANDROID_KEYSTORE_BASE64"; exit 1; }
          test -n "$KEYSTORE_PASSWORD" || { echo "Missing secret: ANDROID_KEYSTORE_PASSWORD"; exit 1; }
          test -n "$KEY_ALIAS" || { echo "Missing secret: ANDROID_KEY_ALIAS"; exit 1; }
          test -n "$KEY_PASSWORD" || { echo "Missing secret: ANDROID_KEY_PASSWORD"; exit 1; }

      - name: Prepare Android signing files
        if: ${{ inputs.build_type == 'release' }}
        shell: bash
        env:
          KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
          KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
          KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
          KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
        run: |
          mkdir -p android/app
          echo "$KEYSTORE_BASE64" | base64 --decode > android/app/release.keystore
          cat > android/key.properties <<EOF
          storeFile=release.keystore
          storePassword=${KEYSTORE_PASSWORD}
          keyAlias=${KEY_ALIAS}
          keyPassword=${KEY_PASSWORD}
          EOF

      - name: Install dependencies
        run: pnpm install --frozen-lockfile

      - name: Build web assets
        run: pnpm build:web

      - name: Sync Capacitor Android project
        run: npx cap sync android

      - name: Build embedded Android API bundle
        run: pnpm build:android:node

      - name: Prepare embedded Android assets
        run: pnpm prepare:android:embedded

      - name: Build APK
        shell: bash
        run: |
          chmod +x android/gradlew
          cd android
          if [ "${{ inputs.build_type }}" = "release" ]; then
            ./gradlew assembleRelease
          else
            ./gradlew assembleDebug
          fi

      - name: Prepare release metadata
        id: meta
        shell: bash
        run: |
          VERSION=$(node -p "require('./package.json').version")
          SHORT_SHA=$(git rev-parse --short HEAD)
          BUILD_TYPE="${{ inputs.build_type }}"

          if [ -n "${{ inputs.release_tag }}" ]; then
            TAG="${{ inputs.release_tag }}"
          else
            TAG="android-${BUILD_TYPE}-v${VERSION}-run.${GITHUB_RUN_NUMBER}"
          fi

          if [ -n "${{ inputs.release_name }}" ]; then
            NAME="${{ inputs.release_name }}"
          else
            NAME="SPlayer for Android ${VERSION} ${BUILD_TYPE} (${SHORT_SHA})"
          fi

          if [ "$BUILD_TYPE" = "release" ]; then
            APK_DIR="android/app/build/outputs/apk/release"
            APK_SUFFIX="release"
          else
            APK_DIR="android/app/build/outputs/apk/debug"
            APK_SUFFIX="debug"
          fi

          mkdir -p release
          ABIS=(armeabi-v7a arm64-v8a x86 x86_64)
          FOUND=0
          for abi in "${ABIS[@]}"; do
            SRC="${APK_DIR}/app-${abi}-${APK_SUFFIX}.apk"
            if [ ! -f "${SRC}" ]; then
              # release 构建在未配置签名时，APK 可能带 -unsigned 后缀
              SRC_ALT="${APK_DIR}/app-${abi}-${APK_SUFFIX}-unsigned.apk"
              if [ -f "${SRC_ALT}" ]; then
                SRC="${SRC_ALT}"
              else
                echo "::warning::Expected APK not found: ${SRC}"
                continue
              fi
            fi
            DST="release/SPlayer-for-Android-${TAG}-${abi}.apk"
            cp "${SRC}" "${DST}"
            sha256sum "${DST}" > "${DST}.sha256"
            FOUND=$((FOUND + 1))
          done

          if [ "${FOUND}" -eq 0 ]; then
            echo "::error::No per-ABI APK found under ${APK_DIR}"
            ls -la "${APK_DIR}" || true
            exit 1
          fi

          {
            echo "tag=${TAG}"
            echo "name=${NAME}"
            echo "build_type=${BUILD_TYPE}"
            echo "apk_count=${FOUND}"
          } >> "$GITHUB_OUTPUT"

      - name: Upload workflow artifact
        uses: actions/upload-artifact@v4
        with:
          name: SPlayer-for-Android-${{ steps.meta.outputs.tag }}
          path: |
            release/*.apk
            release/*.sha256

      - name: Create GitHub Release
        uses: softprops/action-gh-release@v2
        with:
          tag_name: ${{ steps.meta.outputs.tag }}
          name: ${{ steps.meta.outputs.name }}
          target_commitish: ${{ github.sha }}
          generate_release_notes: true
          prerelease: ${{ inputs.prerelease }}
          files: |
            release/*.apk
            release/*.sha256
          body: |
            Automatically built Android APK (split per ABI).

            Artifacts (${{ steps.meta.outputs.apk_count }}):
            - `armeabi-v7a` — 32-bit ARM (旧设备)
            - `arm64-v8a` — 64-bit ARM (绝大多数现代设备)
            - `x86` — 32-bit Intel (模拟器 / 少数设备)
            - `x86_64` — 64-bit Intel (Intel 平板 / 模拟器)

            Build pipeline:
            - GitHub Actions `workflow_dispatch`
            - `pnpm build:web`
            - `npx cap sync android`
            - `pnpm build:android:node`
            - `pnpm prepare:android:embedded`
            - `./gradlew assemble${{ inputs.build_type == 'release' && 'Release' || 'Debug' }}`（启用 `splits.abi`）

            Notes:
            - Build type: `${{ steps.meta.outputs.build_type }}`
            - 每个 APK 附带对应的 `sha256` 校验文件
            - 根据设备 CPU 架构选择对应包即可，推荐优先选 `arm64-v8a`