test.yml

name: Test

on:
  workflow_dispatch:
  pull_request:
    paths-ignore:
      - 'LICENSE'
      - 'README.md'
      - 'Makefile'
    branches:
      - main
  push:
    paths-ignore:
      - 'LICENSE'
      - 'README.md'
      - 'Makefile'
    branches:
      - main

# Declare default permissions as readonly.
permissions: read-all

jobs:
  apk:
    name: Create apk
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: "17.x"
          distribution: 'temurin'

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
          channel: 'stable'
          flutter-version: '3.22.3'

      - name: Configure .env
        run: |
          echo "$ENV_KEY" | base64 --decode > .env
        env:
          ENV_KEY: ${{ secrets.ENV_STG_BASE64 }}

      - name: Flutter doctor -v
        run: flutter doctor -v

      - name: Install Deps
        run: flutter pub get

      - name: Configure Keystore for Android
        run: |
          echo "$PLAY_STORE_UPLOAD_KEY" | base64 --decode > app/upload-keystore.jks
          echo "storeFile=upload-keystore.jks" >> key.properties
          echo "keyAlias=$KEYSTORE_KEY_ALIAS" >> key.properties
          echo "storePassword=$KEYSTORE_STORE_PASSWORD" >> key.properties
          echo "keyPassword=$KEYSTORE_KEY_PASSWORD" >> key.properties
        env:
          PLAY_STORE_UPLOAD_KEY: ${{ secrets.PLAY_STORE_UPLOAD_KEY }}
          KEYSTORE_KEY_ALIAS: ${{ secrets.KEYSTORE_KEY_ALIAS }}
          KEYSTORE_KEY_PASSWORD: ${{ secrets.KEYSTORE_KEY_PASSWORD }}
          KEYSTORE_STORE_PASSWORD: ${{ secrets.KEYSTORE_STORE_PASSWORD }}
        working-directory: android

      - name: Build Apk
        run: flutter build apk --no-tree-shake-icons --dart-define-from-file=.env --flavor staging

      # Package the build.
      - name: Copy build for Android
        run: ls -la
        working-directory: build/app/outputs/flutter-apk

      - name: Clean up
        if: ${{ always() }}
        run: |
          rm -f android/app/upload-keystore.jks
          rm -f android/key.properties
          rm -f .env

  ios:
    name: Create ios
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
          channel: 'stable'
          flutter-version: '3.22.3'

      - name: Configure .env
        run: |
          echo "$ENV_KEY" | base64 --decode > .env
        env:
          ENV_KEY: ${{ secrets.ENV_STG_BASE64 }}

      - name: Flutter doctor -v
        run: flutter doctor -v

      - name: Resolving flutter dependencies
        run: flutter pub get

      - name: Resolving ios dependencies
        run: cd ios && pod install --repo-update && cd ..

      - name: Install the Apple certificate and provisioning profile
        env:
          CERT_BASE64: ${{ secrets.CERT_BASE64 }}
          CERT_DEV_BASE64: ${{ secrets.CERT_DEV_BASE64 }}
          P12_BASE64: ${{ secrets.P12_BASE64 }}
          P12_DEV_BASE64: ${{ secrets.P12_DEV_BASE64 }}
          P12_PASSWORD: ${{ secrets.P12_PASSWORD }}
          PROVISION_PROFILE_BASE64: ${{ secrets.PROVISION_PROFILE_BASE64 }}
          PROVISION_PROFILE_DEV_BASE64: ${{ secrets.PROVISION_PROFILE_DEV_BASE64 }}
          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
        run: |
          # create variables
          CERTIFICATE_PATH=$RUNNER_TEMP/build_certificate.p12
          CERTIFICATE_DEV_PATH=$RUNNER_TEMP/build_certificate_dev.p12
          CERT_PATH=$RUNNER_TEMP/ios_distribution.cer
          CERT_DEV_PATH=$RUNNER_TEMP/ios_development.cer
          PP_PATH=$RUNNER_TEMP/watermark_assistant_appstore.mobileprovision
          PP_DEV_PATH=$RUNNER_TEMP/watermark_assistant_dev.mobileprovision
          KEYCHAIN_PATH=$RUNNER_TEMP/ff-signing.keychain-db

          # import certificate and provisioning profile from secrets
          echo -n "$P12_BASE64" | base64 --decode --output $CERTIFICATE_PATH
          echo -n "$P12_DEV_BASE64" | base64 --decode --output $CERTIFICATE_DEV_PATH
          echo -n "$CERT_BASE64" | base64 --decode --output $CERT_PATH
          echo -n "$CERT_DEV_BASE64" | base64 --decode --output $CERT_DEV_PATH
          echo -n "$PROVISION_PROFILE_BASE64" | base64 --decode --output $PP_PATH
          echo -n "$PROVISION_PROFILE_DEV_BASE64" | base64 --decode --output $PP_DEV_PATH

          # create temporary keychain
          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH

          # import certificate to keychain
          security import $CERTIFICATE_PATH -P "$P12_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
          security import $CERTIFICATE_DEV_PATH -P "$P12_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
          security import $CERT_PATH -P "$P12_PASSWORD" -A -t cert -k $KEYCHAIN_PATH
          security import $CERT_DEV_PATH -P "$P12_PASSWORD" -A -t cert -k $KEYCHAIN_PATH
          security list-keychain -d user -s $KEYCHAIN_PATH

          # apply provisioning profile
          mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
          mv $PP_PATH ~/Library/MobileDevice/Provisioning\ Profiles
          mv $PP_DEV_PATH ~/Library/MobileDevice/Provisioning\ Profiles

      - name: Build Ipa
        run: |
          echo "╠ Removing build products and intermediate files from the build root..."
          cd ios && xcodebuild clean && cd ..
          echo "╠ Releasing to app store..."
          flutter build ipa --dart-define-from-file=.env --export-options-plist=ios/ExportOptions-debug.plist

      # Package the build.
      - name: Copy build for iOS
        run: ls -la
        working-directory: build/ios/ipa

      - name: Clean up
        if: ${{ always() }}
        run: |
          if [ -f "$RUNNER_TEMP/ff-signing.keychain-db" ]; then
            echo "$RUNNER_TEMP/ff-signing.keychain-db"
            security delete-keychain $RUNNER_TEMP/ff-signing.keychain-db
          fi
          rm -f ~/Library/MobileDevice/Provisioning\ Profiles/watermark_assistant_*.mobileprovision
          rm -f .env

  macos:
    name: Create macos
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v4

      - name: setup node
        uses: actions/setup-node@v4
        with:
          node-version: 18

      - uses: pnpm/action-setup@v3
        with:
          version: 9

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
          channel: 'stable'
          flutter-version: '3.22.3'

      - name: Configure .env
        run: |
          echo "$ENV_KEY" | base64 --decode > .env
        env:
          ENV_KEY: ${{ secrets.ENV_STG_BASE64 }}

      - name: Flutter doctor -v
        run: flutter doctor -v

      - name: Resolving flutter dependencies
        run: flutter pub get

      - name: Resolving macos dependencies
        run: cd macos && pod install --repo-update && cd ..

      - name: Build macOS
        run: |
          echo "╠ Removing build products and intermediate files from the build root..."
          cd macos && xcodebuild clean && cd ..
          echo "╠ Releasing to app store..."
          flutter build macos --dart-define-from-file=.env

      - name: Install certificates
        env:
          DEVELOPER_ID_APPLICATION_P12_BASE64_MAC: ${{ secrets.DEVELOPER_ID_APPLICATION_P12_BASE64_MAC }}
          P12_PASSWORD: ${{ secrets.P12_PASSWORD }}
          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
        run: |
          # create variables
          DEVELOPER_ID_APPLICATION_CERTIFICATE_PATH=$RUNNER_TEMP/build_developerID_application_certificate.p12
          KEYCHAIN_PATH=$RUNNER_TEMP/ff-signing.keychain-db

          # import certificate and provisioning profile from secrets
          echo -n "$DEVELOPER_ID_APPLICATION_P12_BASE64_MAC" | base64 --decode --output $DEVELOPER_ID_APPLICATION_CERTIFICATE_PATH

          # create temporary keychain
          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
          # security default-keychain -s $KEYCHAIN_PATH
          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH

          # import certificate to keychain
          security import $DEVELOPER_ID_APPLICATION_CERTIFICATE_PATH -P "$P12_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
          security list-keychain -d user -s $KEYCHAIN_PATH
          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH

      - name: Code Signing
        run: /usr/bin/codesign --deep --force -s "$DEVELOPER_ID_APPLICATION_SIGNING_IDENTITY" --options runtime FaForever.app -v
        working-directory: build/macos/Build/Products/Release
        env:
          DEVELOPER_ID_APPLICATION_SIGNING_IDENTITY: ${{ secrets.DEVELOPER_ID_APPLICATION_SIGNING_IDENTITY }}

      - name: Notarize app
        run: |
          # We can't notarize an app bundle directly, but we need to compress it as an archive.
          # Therefore, we create a zip file containing our app bundle, so that we can send it to the
          # notarization service
          echo "Creating temp notarization archive"
          ditto -c -k --keepParent "FaForever.app" "FaForever.zip"

          # Here we send the notarization request to the Apple's Notarization service, waiting for the result.
          # This typically takes a few seconds inside a CI environment, but it might take more depending on the App
          # characteristics. Visit the Notarization docs for more information and strategies on how to optimize it if
          # you're curious
          echo "Notarize app"
          xcrun notarytool submit "FaForever.zip" --apple-id "$APPLE_ID" --team-id "$APPLE_TEAM_ID" --password "$APPLE_PASSWORD" --wait

          # Finally, we need to "attach the staple" to our executable, which will allow our app to be
          # validated by macOS even when an internet connection is not available.
          echo "Attach staple"
          xcrun stapler staple "FaForever.app"
        working-directory: build/macos/Build/Products/Release
        env:
          APPLE_ID: ${{ secrets.APPLE_ID }}
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}

      - name: Install appdmg
        run: |
          pnpm add -g appdmg

      - name: Build DMG
        run: |
          bash build-dmg.sh

      # Package the build.
      - name: Copy build for snap
        run: ls -la *.dmg

      - name: Clean up
        if: ${{ always() }}
        run: |
          if [ -f "$RUNNER_TEMP/ff-signing.keychain-db" ]; then
            echo "$RUNNER_TEMP/ff-signing.keychain-db"
            security delete-keychain $RUNNER_TEMP/ff-signing.keychain-db
          fi
          rm -f .env

  linux:
    name: Create linux
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install dependencies for Linux
        run: |
          sudo apt update
          sudo apt install -y clang cmake ninja-build pkg-config libgtk-3-dev liblzma-dev
          sudo apt install -y p7zip-full p7zip-rar

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
          channel: 'stable'
          flutter-version: '3.22.3'

      - name: Configure .env
        run: |
          echo "$ENV_KEY" | base64 --decode > .env
        env:
          ENV_KEY: ${{ secrets.ENV_STG_BASE64 }}

      - name: Flutter doctor -v
        run: flutter doctor -v

      - name: Install flutter dependencies
        run: flutter pub get

      - name: Build flutter
        run: flutter build linux --dart-define-from-file=.env --target-platform=linux-x64

      - name: Install yq
        run: |
          if ! command -v yq >/dev/null 2>&1; then
            echo "yq not exists"
            if ! command -v wget >/dev/null 2>&1; then
              echo "wget not exists"
              sudo apt install -y wget
            fi
            wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/bin/yq &&\
            chmod +x /usr/bin/yq
          fi
          yq --version

      - name: Build tar
        run: |
          baseDir=$(pwd)
          VERSION=$(yq '.version' pubspec.yaml)
          echo "$VERSION"
          archiveName="faforever_"$VERSION".tar.gz"
          cd build/linux/x64/release/bundle
          tar -czaf $archiveName ./*
          mv $archiveName "$baseDir/"

      # Package the build.
      - name: Copy build for tar
        run: ls -la *.tar.gz

      - name: Clean up
        if: ${{ always() }}
        run: |
          rm -f .env

  windows:
    name: Create windows
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
          channel: 'stable'
          flutter-version: '3.22.3'

      - name: Configure .env
        run: |
          echo "$pwd"
          $bytes = echo $env:ENV_KEY | %{[Convert]::FromBase64String($_)}
          [IO.File]::WriteAllBytes("$pwd\.env", $bytes)
        env:
          ENV_KEY: ${{ secrets.ENV_STG_BASE64_WINDOWS }}

      - name: Install flutter_distributor
        run: dart pub global activate flutter_distributor

      - name: Flutter doctor -v
        run: flutter doctor -v

      - name: Install flutter dependencies
        run: flutter pub get

      - name: Build zip
        run: |
          flutter_distributor package --flutter-build-args "dart-define-from-file=.env" --platform windows --targets zip --artifact-name '{{name}}_{{build_name}}+{{build_number}}.{{ext}}'

      # Package the build.
      - name: Copy build for zip
        run: ls -R
        working-directory: dist

      - name: Clean up
        if: ${{ always() }}
        run: |
          ls
          if (test-path -Path "$pwd\.env") {
            echo "Remove file($pwd\.env)"
            remove-item -Path "$pwd\.env" -Force -ErrorAction SilentlyContinue
          } else {
            echo "File($pwd\.env) doesn't exist."
          }