multi-platform-build-and-publish.yaml

# GitHub Actions Workflow for Multi-Platform Application Deployment
#
# OVERVIEW:
# This workflow supports building and publishing applications across multiple platforms:
# - Android (APK/AAB)
# - iOS (IPA)
# - Desktop (EXE, MSI, DMG, DEB)
# - Web (GitHub Pages)
#
# PREREQUISITES:
# 1. Ensure your project is configured with:
#    - Gradle build system
#    - Fastlane for deployment automation
#    - Separate modules/package names for each platform
#
# REQUIRED SECRETS:
# Configure the following secrets in GitHub repository settings:
#
# Android-related secrets:
# - original_keystore_file: Base64 encoded Android release keystore
# - original_keystore_file_password: Keystore password
# - original_keystore_alias: Keystore alias
# - original_keystore_alias_password: Keystore alias password
# - upload_keystore_file: Base64 encoded Android upload keystore
# - upload_keystore_file_password: Upload keystore password
# - upload_keystore_alias: Upload keystore alias
# - upload_keystore_alias_password: Upload keystore alias password
#
# Google and Firebase credentials:
# - google_services: Google Services configuration JSON
# - playstore_creds: Play Store service account credentials
# - firebase_creds: Firebase distribution credentials
# - token: GitHub token for repository access
#
# Apple-related secrets:
# - notarization_apple_id: Apple ID for macOS app notarization
# - notarization_password: Notarization password
# - notarization_team_id: Apple developer team ID
#
# Windows signing secrets:
# - windows_signing_key: Windows app signing key
# - windows_signing_password: Windows app signing password
# - windows_signing_certificate: Windows app signing certificate
#
# macOS signing secrets:
# - macos_signing_key: macOS app signing key
# - macos_signing_password: macOS app signing password
# - macos_signing_certificate: macOS app signing certificate
#
# Linux signing secrets:
# - linux_signing_key: Linux app signing key
# - linux_signing_password: Linux app signing password
# - linux_signing_certificate: Linux app signing certificate

# WORKFLOW INPUTS:
# - release_type: 'internal' (default) or 'beta'
# - target_branch: Branch to use for release (default: 'dev')
# - android_package_name: Name of Android module
# - ios_package_name: Name of iOS module
# - desktop_package_name: Name of desktop module
# - web_package_name: Name of web module
# - build_ios: Enable/disable iOS build
# - publish_ios: Enable/disable iOS App Store publishing
# - tester_groups: Firebase tester group for distribution

# USAGE:
# 1. Ensure all required secrets are configured
# 2. Customize package names in workflow inputs
# 3. Toggle platform-specific publishing flags
# 4. Trigger workflow manually or via GitHub Actions UI

# NOTES:
# - Some TODO sections exist for future implementation
# - Requires Fastlane and specific project structure
# - Assumes Kotlin Multiplatform or similar cross-platform setup

name: Multi-Platform App Build and Publish

on:
  workflow_call:
    inputs:
      release_type:
        type: string
        default: 'internal'
        description: Release Type

      target_branch:
        type: string
        default: 'dev'
        description: 'Target branch for release'

      android_package_name:
        description: 'Name of the Android project module'
        type: string
        required: true

      ios_package_name:
        description: 'Name of the iOS project module'
        type: string
        required: true

      desktop_package_name:
        description: 'Name of the Desktop project module'
        type: string
        required: true

      web_package_name:
        description: 'Name of the Web project module'
        type: string
        required: true

      build_ios:
        type: boolean
        default: false
        description: Build iOS App

      # Toggle for iOS App Store publishing
      publish_ios:
        type: boolean
        default: false
        description: Publish iOS App On App Store

      tester_groups:
        type: string
        description: 'Firebase Tester Group'
        required: true

    secrets:
      # Android-related secrets
      original_keystore_file:
        description: 'Base64 encoded Android release keystore'
        required: false
      original_keystore_file_password:
        description: 'Keystore password'
        required: false
      original_keystore_alias:
        description: 'Keystore alias'
        required: false
      original_keystore_alias_password:
        description: 'Keystore alias password'
        required: false

      upload_keystore_file:
        description: 'Base64 encoded Android upload keystore'
        required: false
      upload_keystore_file_password:
        description: 'Upload keystore password'
        required: false
      upload_keystore_alias:
        description: 'Upload keystore alias'
        required: false
      upload_keystore_alias_password:
        description: 'Upload keystore alias password'
        required: false

      # Google and Firebase credentials
      google_services:
        description: 'Google Services configuration JSON'
        required: false
      playstore_creds:
        description: 'Play Store service account credentials'
        required: false
      firebase_creds:
        description: 'Firebase distribution credentials'
        required: false
      token:
        description: 'Github Token'
        required: false

      # Apple-related secrets
      notarization_apple_id:
        description: 'Apple ID for macOS app notarization'
        required: false
      notarization_password:
        description: 'Notarization password'
        required: false
      notarization_team_id:
        description: 'Apple developer team ID'
        required: false

      # Desktop signing secrets
      windows_signing_key:
        description: 'Windows app signing key'
        required: false
      windows_signing_password:
        description: 'Windows app signing password'
        required: false
      windows_signing_certificate:
        description: 'Windows app signing certificate'
        required: false

      macos_signing_key:
        description: 'macOS app signing key'
        required: false
      macos_signing_password:
        description: 'macOS app signing password'
        required: false
      macos_signing_certificate:
        description: 'macOS app signing certificate'
        required: false

      linux_signing_key:
        description: 'Linux app signing key'
        required: false
      linux_signing_password:
        description: 'Linux app signing password'
        required: false
      linux_signing_certificate:
        description: 'Linux app signing certificate'
        required: false

permissions:
  contents: write

concurrency:
  group: "pages"
  cancel-in-progress: false

jobs:
  # Publish Android app on Firebase App Distribution
  publish_android_on_firebase:
    name: Deploy Android App On Firebase
    runs-on: macos-latest
    steps:
      # Check out caller repository
      - name: Checkout Caller Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Publish Android App on Firebase
        uses: openMF/kmp-android-firebase-publish-action@v2.0.0
        with:
          android_package_name: ${{ inputs.android_package_name }}
          keystore_file: ${{ secrets.original_keystore_file }}
          keystore_password: ${{ secrets.original_keystore_file_password }}
          keystore_alias: ${{ secrets.original_keystore_alias }}
          keystore_alias_password: ${{ secrets.original_keystore_alias_password }}
          google_services: ${{ secrets.google_services }}
          firebase_creds: ${{ secrets.firebase_creds }}
          tester_groups: ${{ inputs.tester_groups }}


  # Publish Android app on Play Store
  publish_android_on_playstore:
    name: Publish Android App On Play Store
    runs-on: macos-latest
    steps:
      # Check out caller repository
      - name: Checkout Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Promote Android App to Beta or Internal
        uses: openMF/kmp-publish-android-on-playstore-beta-action@v1.0.0
        with:
          release_type: ${{ inputs.release_type }}
          android_package_name: ${{ inputs.android_package_name }}
          google_services: ${{ secrets.google_services }}
          playstore_creds: ${{ secrets.playstore_creds }}
          keystore_file: ${{ secrets.upload_keystore_file }}
          keystore_password: ${{ secrets.upload_keystore_file_password }}
          keystore_alias: ${{ secrets.upload_keystore_alias }}
          keystore_alias_password: ${{ secrets.upload_keystore_alias_password }}

  # Firebase Distribution Job for iOS
  publish_ios_app_to_firebase:
    name: Publish iOS App On Firebase
    runs-on: macos-latest
    permissions:
      contents: write
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Deploy iOS App to Firebase
        if: inputs.build_ios
        uses: openMF/kmp-publish-ios-on-firebase-action@v1.0.0
        continue-on-error: true
        with:
          ios_package_name: ${{ inputs.ios_package_name }}
          firebase_creds: ${{ secrets.firebase_creds }}
          tester_groups: ${{ inputs.tester_groups }}

  # App Store Publishing Job
  publish_ios_app_to_app_center:
    name: Publish iOS App On App Center
    if: inputs.publish_ios
    runs-on: macos-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Git Status
        run: git status

      # TODO: Implement App Store publishing

  # Desktop Publishing Job
  publish_desktop:
    name: Publish Desktop App
    strategy:
      matrix:
        os: [ ubuntu-latest, windows-latest, macos-latest ]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: openMF/kmp-publish-desktop-app-action@v1.0.0
        with:
          desktop_package_name: ${{ inputs.desktop_package_name }}
          windows_signing_key: ${{ secrets.windows_signing_key }}
          windows_signing_password: ${{ secrets.windows_signing_password }}
          windows_signing_certificate: ${{ secrets.windows_signing_certificate }}
          macos_signing_key: ${{ secrets.macos_signing_key }}
          macos_signing_password: ${{ secrets.macos_signing_password }}
          macos_signing_certificate: ${{ secrets.macos_signing_certificate }}
          linux_signing_key: ${{ secrets.linux_signing_key }}
          linux_signing_password: ${{ secrets.linux_signing_password }}
          linux_signing_certificate: ${{ secrets.linux_signing_certificate }}

  # Web Publishing Job
  publish_web:
    name: Publish Web App
    runs-on: ubuntu-latest
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    permissions:
      id-token: write
      pages: write
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Publish KMP Web App To GitHub Pages
        uses: openMF/kmp-web-publish-action@v1.0.0
        id: deployment
        with:
          web_package_name: ${{ inputs.web_package_name }}

  # Creates GitHub release with all built artifacts
  github_release:
    name: Create Github Release
    needs: [ publish_android_on_firebase, publish_ios_app_to_firebase, publish_desktop, publish_web ]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      # Generate Release Number
      - name: Generate Release Number
        id: rel_number
        shell: bash
        run: |        
          set +e  # Disable exit on error to handle task non-existence
          ./gradlew versionFile
          VERSIONFILE_EXIT_CODE=$?
          set -e  # Re-enable exit on error
          
          # Check if version file exists after attempting to generate it
          if [ -f "version.txt" ]; then
          echo "Using version from versionFile"
          VERSION=$(cat version.txt)

          # Count commits to generate version code
          VERSION_CODE=$(($(git rev-list --count HEAD) * 10))

          echo "Version from file: ${VERSION}"
          echo "Version Code: ${VERSION_CODE}"

          echo "version=${VERSION}" >> $GITHUB_OUTPUT
          echo "version-code=${VERSION_CODE}" >> $GITHUB_OUTPUT
          exit 0
          fi
          
          # Fallback to Git-based version generation
          # Get the latest tag or use 1.0.0 as default
          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v1.0.0")
          
          # Remove 'v' prefix if present
          LATEST_TAG=${LATEST_TAG#v}
          
          # Count commits since the last tag
          COMMITS_SINCE_TAG=$(git rev-list ${LATEST_TAG}..HEAD --count)
          
          # Extract major, minor, patch from the latest tag
          IFS='.' read -r MAJOR MINOR PATCH <<< "${LATEST_TAG}"
          
          # Increment patch version and add commits as build number
          NEW_VERSION="${MAJOR}.${MINOR}.$((PATCH + 1))"
          
          # Calculate version code (can be adjusted based on your versioning needs)
          VERSION_CODE=$(($(git rev-list --count HEAD) * 10))
          
          echo "Version: ${NEW_VERSION}"
          echo "Version Code: ${VERSION_CODE}"
          
          echo "version=${NEW_VERSION}" >> $GITHUB_OUTPUT


      - name: Generate Release Notes
        uses: actions/github-script@v7
        id: release-notes
        with:
          github-token: ${{ secrets.token }}
          script: |
            try {
              // Get latest release tag
              const latestRelease = await github.rest.repos.getLatestRelease({
                owner: context.repo.owner,
                repo: context.repo.repo,
              });
              const previousTag = latestRelease.data.tag_name;

              // Generate release notes
              const params = {
                owner: context.repo.owner,
                repo: context.repo.repo,
                tag_name: '${{ steps.rel_number.outputs.version }}',
                target_commitish: '${{ inputs.target_branch }}'
              };

              const { data } = await github.rest.repos.generateReleaseNotes(params);
              const changelog = data.body.replaceAll('`', '\'').replaceAll('"', '\'');

              // Write changelog files
              const fs = require('fs');
              fs.writeFileSync('changelogGithub', changelog);

              // Generate beta changelog
              const { execSync } = require('child_process');
              execSync('git log --format="* %s" HEAD^..HEAD > changelogBeta');

              return changelog;
            } catch (error) {
              console.error('Error generating release notes:', error);
              return '';
            }

      # Get all build artifacts
      - name: Download All Artifacts
        uses: actions/download-artifact@v4
        with:
          path: ./all-artifacts

      # Debug: Show downloaded files
      - name: Display structure of downloaded files
        run: ls -R ./all-artifacts

      #Creates a ZIP archive of the web app build using PowerShell.
      - name: Archive Web Build
        shell: pwsh
        # Executes the Compress-Archive command to create the ZIP archive.
        run: |
          Compress-Archive -Path './all-artifacts/web-app/*' -DestinationPath './all-artifacts/${{ inputs.web_package_name }}.zip'

      # Create GitHub pre-release with all artifacts
      - name: Create Github Pre-Release
        uses: softprops/action-gh-release@v2.0.8
        with:
          tag_name: ${{ steps.rel_number.outputs.version }}
          body_path: ./changelogGithub
          draft: false
          prerelease: true
          files: |
            ./all-artifacts/android-app/${{ inputs.android_package_name }}/build/outputs/apk/demo/release/*.apk
            ./all-artifacts/android-app/${{ inputs.android_package_name }}/build/outputs/apk/prod/release/*.apk
            ./all-artifacts/desktop-app-macos-latest/${{ inputs.desktop_package_name }}/build/compose/binaries/main-release/dmg/*.dmg
            ./all-artifacts/desktop-app-ubuntu-latest/${{ inputs.desktop_package_name }}/build/compose/binaries/main-release/deb/*.deb
            ./all-artifacts/desktop-app-windows-latest/${{ inputs.desktop_package_name }}/build/compose/binaries/main-release/exe/*.exe
            ./all-artifacts/desktop-app-windows-latest/${{ inputs.desktop_package_name }}/build/compose/binaries/main-release/msi/*.msi            
            ./all-artifacts/${{ inputs.web_package_name }}.zip