android_deploy.yml

name: Push Android build to Play Store Beta

on:
  workflow_dispatch:
    inputs:
      version_bump:
        description: 'Version bump type'
        required: true
        type: choice
        options:
          - patch
          - minor
          - major
        default: 'patch'

jobs:
  android_deployment:
    runs-on: ubuntu-latest
    env:
      ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
      ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
      ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
      ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
      PLAY_STORE_SERVICE_ACCOUNT_JSON: ${{ secrets.PLAY_STORE_SERVICE_ACCOUNT_JSON }}
      ANDROID_GOOGLE_SERVICES_JSON: ${{ secrets.ANDROID_GOOGLE_SERVICES_JSON }}

    steps:
      - name: Checkout Repo
        uses: actions/checkout@v4

      - name: Set up Flutter SDK
        uses: flutter-actions/setup-flutter@v3
        with:
          channel: stable
          version: 3.24.0

      - name: Install dependencies & Lint check
        run: |
          flutter clean
          flutter pub get
          flutter analyze --fatal-infos

      - name: Install the CodeMagic CLI
        run: |
          pip install --upgrade pip
          pip install --upgrade codemagic-cli-tools
          google-play --version
          sudo apt-get update && sudo apt-get install -y jq

      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Setup Android keystore
        run: |
          mkdir -p $GITHUB_WORKSPACE/keystore
          echo $ANDROID_KEYSTORE_BASE64 | base64 -d > $GITHUB_WORKSPACE/keystore/upload-keystore.jks
          # Verify keystore file was created
          if [ ! -f "$GITHUB_WORKSPACE/keystore/upload-keystore.jks" ]; then
            echo "Error: Keystore file was not created"
            exit 1
          fi
          # List keystore contents to verify the alias
          keytool -list -v -keystore $GITHUB_WORKSPACE/keystore/upload-keystore.jks -storepass $ANDROID_KEYSTORE_PASSWORD || echo "Failed to read keystore"
          
      - name: Setup key.properties
        run: |
          echo "storePassword=$ANDROID_KEYSTORE_PASSWORD" > android/key.properties
          echo "keyPassword=$ANDROID_KEY_PASSWORD" >> android/key.properties
          echo "keyAlias=$ANDROID_KEY_ALIAS" >> android/key.properties
          echo "storeFile=$GITHUB_WORKSPACE/keystore/upload-keystore.jks" >> android/key.properties

      - name: Set up Google Services JSON
        run: |
          echo $ANDROID_GOOGLE_SERVICES_JSON | base64 -d > android/app/google-services.json

      - name: Update Version
        run: |
          set -x  # Enable debug mode to see each command
          file='VERSION'
          echo "Checking for VERSION file..."
          if [ -f "$file" ]; then
            echo "VERSION file exists"
            echo "Current file contents:"
            cat "$file"
            
            echo "Reading version components..."
            # Read the version and split it into parts
            version=$(cat "$file" | tr -d '[:space:]')  # Remove any whitespace
            IFS='.' read -r -a version_parts <<< "$version"
            
            # Set default values for missing components
            major="${version_parts[0]:-0}"
            minor="${version_parts[1]:-0}"
            patch="${version_parts[2]:-0}"
            
            # Validate that we got numbers
            if ! [[ "$major" =~ ^[0-9]+$ ]] || ! [[ "$minor" =~ ^[0-9]+$ ]] || ! [[ "$patch" =~ ^[0-9]+$ ]]; then
              echo "Error: Version components must be numbers. Got major=$major minor=$minor patch=$patch"
              exit 1
            fi
            
            echo "Current version: major=$major minor=$minor patch=$patch"
            
            echo "Getting version bump type from input..."
            echo "Raw input value: ${{ github.event.inputs.version_bump }}"
            bump_type="${{ github.event.inputs.version_bump }}"
            echo "Assigned bump_type: $bump_type"
            
            if [ -z "$bump_type" ]; then
              echo "No bump type provided, defaulting to patch"
              bump_type="patch"
            fi
            
            echo "Using bump type: $bump_type"
            
            case "$bump_type" in
              "major")
                echo "Performing major version bump"
                major=$((major + 1))
                minor=0
                patch=0
                ;;
              "minor")
                echo "Performing minor version bump"
                minor=$((minor + 1))
                patch=0
                ;;
              "patch")
                echo "Performing patch version bump"
                patch=$((patch + 1))
                ;;
              *)
                echo "Invalid version bump type: '$bump_type'"
                exit 1
                ;;
            esac
            
            new_version="$major.$minor.$patch"
            echo "Writing new version: $new_version"
            echo "$new_version" > "$file"
            echo "Updated version to $new_version"
            
            echo "New file contents:"
            cat "$file"
          else
            echo "VERSION file does not exist, creating with initial version"
            echo "1.0.0" > "$file"
            echo "Created initial version 1.0.0"
            
            echo "New file contents:"
            cat "$file"
          fi

      - name: Build Android App Bundle
        run: |
          set -x  # Enable debug mode
          file='VERSION'
          version=$(cat "$file" | tr -d '[:space:]')  # Remove any whitespace
          IFS='.' read -r -a version_parts <<< "$version"
          
          major="${version_parts[0]}"
          minor="${version_parts[1]}"
          
          buildNumber=$(( major * 1000000 + minor * 10000 + ${{github.run_number}} ))
          buildName="$major.$minor.${{github.run_number}}"
          
          echo "Building version $buildName ($buildNumber)"
          
          # Update the Android project to use v2 embedding
          echo "Updating Android project configuration..."
          cd android
          if [ -f "./app/build.gradle" ]; then
            echo "Checking build.gradle configuration..."
            cat ./app/build.gradle
          fi
          cd ..
          
          flutter build appbundle --release --build-number=$buildNumber --build-name=$buildName

      - name: Upload and Release to Play Store
        run: |
          APP_FILE="build/app/outputs/bundle/release/app-release.aab"
          
          if [ ! -f "$APP_FILE" ]; then
            echo "Error: AAB file not found at expected path: $APP_FILE"
            exit 1
          fi
          
          echo "Found AAB file at: $APP_FILE"
          
          # Upload the bundle and capture the output
          echo "Uploading bundle to Play Store..."
          UPLOAD_OUTPUT=$(google-play bundles publish \
            --bundle "$APP_FILE" \
            --credentials "$PLAY_STORE_SERVICE_ACCOUNT_JSON" \
            --track internal \
            --release-name "$(cat VERSION)" \
            --release-notes '[{"language": "en-US", "text": "Automated release from GitHub Actions"}]' \
            --json \
            --log-stream stderr)
            
          echo "Upload response:"
          echo "$UPLOAD_OUTPUT"
          
          echo "Release process completed. Please check Play Console in a few minutes."