ann-flutter-flavor 0.1.2

data/lib/fastlane/plugin/ann_flutter_flavor/actions/ann_upload_to_play_store_action.rb

@@ -0,0 +1,248 @@
+require 'fastlane/action'
+require 'fastlane/plugin/ann_flutter_flavor/helper/lanes_annai'
+require 'fastlane/plugin/ann_flutter_flavor/helper/utils_spec_loader'
+
+module Fastlane
+  module Actions
+    # This class name dictates the action name 'ann_upload_to_play_store'
+    class AnnaiUploadToPlayStoreAction < Action
+
+      def self.run(params)
+        platform = :android # Hardcoded platform
+        action_name = "ann_upload_to_play_store"
+        requested_flavor = params[:flavor]
+        requested_clean_build = params[:clean]
+        spec_file = params[:spec_file]
+
+        # 1. Initialize AnnaiLanes
+        annai_lanes = FastlaneFlutterFlavor::AnnaiLanes.new(
+          lane: self,
+          platform: platform, # Pass platform symbol directly
+          spec_file: spec_file # Pass optional spec_file
+        )
+
+        status_manager = annai_lanes.instance_variable_get(:@statusManager)
+        spec_loader = annai_lanes.instance_variable_get(:@specLoader)
+        UI.user_error!("Internal Error: AnnaiLanes failed to initialize specLoader") unless spec_loader
+
+        any_upload_failed = false
+
+        # 2. Perform clean build if requested
+        if requested_clean_build
+            UI.header("🧹 Cleaning builds as requested...")
+            begin
+              annai_lanes.clean_build
+            rescue => e
+              UI.error("Failed to perform clean build: #{e.message}. Attempting to proceed with upload")
+              # Note: Using 'annai_clean_build' as the action name for the failure log
+              status_manager.logError("All", "annai_clean_build", platform, "Clean build failed: #{e.message}")
+            end
+        end
+
+        # 3. Get the list of all flavors defined for the platform
+        flavors_hash = spec_loader.get_platform_flavors(platform)
+
+        if flavors_hash.empty?
+          UI.important("No flavors found for Android in the Annai spec. Nothing to upload")
+          annai_lanes.finalize
+          return
+        end
+
+        all_flavor_names = flavors_hash.keys
+
+        # 4. Determine which flavors to upload
+        if requested_flavor && !requested_flavor.to_s.empty?
+            requested_flavors = requested_flavor.to_s.split(',').map(&:strip).reject(&:empty?)
+
+            # Validate all requested flavors
+            invalid_flavors = requested_flavors.reject { |f| all_flavor_names.include?(f) }
+
+            if invalid_flavors.any?
+                UI.user_error!("The following requested flavor(s) are not found in the Annai spec for Android: #{invalid_flavors.join(', ')}. Available flavors: #{all_flavor_names.join(', ')}")
+            end
+
+            flavors_to_upload = requested_flavors
+        else
+            flavors_to_upload = all_flavor_names
+        end
+
+        UI.header("Starting Google Play upload. Flavors to process: #{flavors_to_upload.join(', ')}")
+
+
+        # 5. Loop through each flavor and upload
+        flavors_to_upload.each do |flavor_key|
+
+          flavor = flavor_key.to_s
+
+          # Get values, prioritizing spec over parameters
+          final_main_file = spec_loader.get_main_file(platform, flavor) || params[:main_file]
+          final_api_key_path = spec_loader.get_api_key_path(platform, flavor) || params[:api_key_path]
+          final_priority = spec_loader.get_priority(platform, flavor) || params[:priority]
+          final_package_name = spec_loader.get_package_id(platform, flavor) || params[:package_name]
+
+          UI.message("🚀 Preparing **#{flavor}** flavor...")
+
+          # Use 'upload_to_store' as the consistent action name for flavor-specific failures
+          flavor_action_name = "upload_to_store"
+
+          begin
+            # Android Upload Logic (upload_to_play_store)
+            success = annai_lanes.upload_to_play_store(
+              package_name: final_package_name,
+              api_key_path: final_api_key_path,
+              in_app_update_priority: final_priority,
+              flavor: flavor,
+              main_file: final_main_file,
+              track: params[:track],
+              track_promote_to: params[:track_promote_to],
+              skip_sound_null_safety: params[:skip_sound_null_safety],
+              skip_compile: params[:skip_compile],
+              skip_upload_prod: params[:skip_upload_prod],
+              skip_upload_binary: params[:skip_upload_binary],
+              skip_upload_changelogs: params[:skip_upload_changelogs],
+              skip_upload_metadata: params[:skip_upload_metadata],
+              skip_upload_images: params[:skip_upload_images],
+              skip_upload_screenshots: params[:skip_upload_screenshots],
+              platform: platform.to_s,
+              metadata_path: params[:metadata_path],
+            )
+
+            if success
+              UI.success("✅ Successfully uploaded flavor: #{flavor}")
+            else
+              # If upload_to_play_store returns false (meaning it caught an error and logged it), flag the overall failure.
+              if !status_manager.instance_variable_get(:@status).key?([flavor, flavor_action_name, platform.to_s])
+                raise "Upload failed for flavor '#{flavor}'"
+              else
+                raise "Upload failed for flavor '#{flavor}' (error logged previously)"
+              end
+            end
+
+          rescue => e
+            # Failure handling: Log the error and continue
+            if !status_manager.instance_variable_get(:@status).key?([flavor, flavor_action_name, platform.to_s])
+              status_manager.logError(flavor, flavor_action_name, platform, e.message)
+            end
+
+            UI.error("❌ Failed to upload flavor: #{flavor}. Continuing to next flavor...")
+            any_upload_failed = true
+            # Continue to the next flavor
+          end
+        end
+
+        # 6. Final Reporting and Status Check
+        annai_lanes.finalize
+
+        if any_upload_failed
+            UI.user_error!("Upload failed for one or more flavors. See the Annai Fastlane summary above")
+        else
+            UI.success("🎉 Successfully uploaded all #{flavors_to_upload.count} requested flavor(s) to the Google Play Store!")
+        end
+      end
+
+      # ----------------------------------------------------
+      # Define Parameters
+      # ----------------------------------------------------
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :flavor,
+                                       description: "The specific flavor(s) to upload (comma-separated). If nil, all flavors are uploaded",
+                                       optional: true,
+                                       default_value: nil),
+
+          FastlaneCore::ConfigItem.new(key: :spec_file,
+                                       description: "Path to the annai spec configuration file (relative to flutter root). Defaults to standard discovery",
+                                       optional: true,
+                                       default_value: nil),
+
+          FastlaneCore::ConfigItem.new(key: :clean,
+                                       description: "If true, runs annai_clean_build before uploading (and compiling if not skipped)",
+                                       type: Boolean,
+                                       default_value: false),
+
+          # --- Common & Android Specific Parameters ---
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       description: "Path to the Google Service Account JSON file",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :main_file,
+                                       description: "Path to the main dart file (used if compilation is required)",
+                                       default_value: "lib/main.dart"),
+          FastlaneCore::ConfigItem.new(key: :skip_compile,
+                                       description: "If true, skips the compilation step and assumes artifacts already exist",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_sound_null_safety,
+                                       description: "Skips sound null safety checks during compilation (if skip_compile is false)",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_upload_prod,
+                                       description: "If true, skips uploading to the production track",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_upload_binary,
+                                       description: "If true, skips uploading the binary (.aab)",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_upload_metadata,
+                                       description: "If true, skips uploading store metadata (description, title, etc)",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_upload_screenshots,
+                                       description: "If true, skips uploading screenshots and app previews",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :metadata_path,
+                                       description: "The path to the localized store metadata (e.g., fastlane/metadata/android)",
+                                       optional: true,
+                                       default_value: nil),
+
+          FastlaneCore::ConfigItem.new(key: :package_name,
+                                       description: "The package name (Android)",
+                                       optional: true,
+                                       default_value: nil),
+          FastlaneCore::ConfigItem.new(key: :track,
+                                       description: "The track to upload to (e.g., internal, alpha, beta, production)",
+                                       optional: true,
+                                       default_value: "beta"),
+          FastlaneCore::ConfigItem.new(key: :track_promote_to,
+                                       description: "The track to promote to after upload",
+                                       optional: true,
+                                       default_value: "production"),
+          FastlaneCore::ConfigItem.new(key: :priority,
+                                       description: "In-app update priority (0-5)",
+                                       optional: true,
+                                       type: Integer,
+                                       default_value: 1),
+          FastlaneCore::ConfigItem.new(key: :skip_upload_changelogs,
+                                       description: "If true, skips uploading changelogs",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_upload_images,
+                                       description: "If true, skips uploading promotional images",
+                                       type: Boolean,
+                                       default_value: false),
+        ].compact
+      end
+
+      def self.description
+        "Handles compilation (optional) and uploading of one or all flavors to the Google Play Store"
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      def self.example_code
+        'ann_upload_to_play_store(
+          flavor: "production",
+          spec_file: "config/annai_config.yaml", # Optional custom spec path
+          package_name: "com.example.app",
+          api_key_path: "./api_keys/google.json",
+          track: "production",
+          skip_compile: false
+        )'
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/ann_flutter_flavor/helper/lanes_android.rb

@@ -0,0 +1,120 @@
+require 'yaml'
+require 'fileutils'
+require 'fastlane/action'
+
+module FastlaneFlutterFlavor
+
+  # ------------------------------------
+  # AndroidLanes (Helper Class)
+  # ------------------------------------
+  class AndroidLanes
+
+    # NOTE: We keep @lane for general context, but must use other_action for calling built-in Fastlane actions.
+    def initialize(lane: ,root_folder:)
+      @lane = lane
+      @root_folder = root_folder
+    end
+
+    def upload_to_store(aab:, package_name:, api_key_path:, metadata_path:,
+                        in_app_update_priority: 1, track: "beta", track_promote_to: "production",
+                        skip_upload_prod: false, skip_upload_binary: false,
+                        skip_upload_changelogs: false, skip_upload_metadata: false,
+                        skip_upload_images: false, skip_upload_screenshots: false, platform: "android"
+    )
+
+      # 1. Upload Binary (AAB file)
+      unless skip_upload_binary
+        # Use 'other_action' to call the built-in Fastlane action
+        @lane.other_action.upload_to_play_store(
+          track: track,
+          aab: aab,
+          package_name: package_name,
+          in_app_update_priority: in_app_update_priority,
+          json_key: api_key_path,
+          metadata_path: metadata_path,
+
+          # Explicitly set AAB upload to FALSE if we are skipping it, otherwise TRUE
+          skip_upload_aab: false,
+
+          # Skip all other non-binary uploads for this initial call
+          skip_upload_apk: true,
+          skip_upload_changelogs: true,
+          skip_upload_metadata: true,
+          skip_upload_images: true,
+          skip_upload_screenshots: true,
+          )
+      end
+
+      # 2. Upload Metadata/Promote to Production (if required)
+      unless skip_upload_prod
+
+        # Use 'other_action' to call the built-in Fastlane action
+        versions = @lane.other_action.google_play_track_version_codes(
+          track: track,
+          package_name: package_name,
+          json_key: api_key_path,
+          )
+
+        # Ensure versions is an array and take the first (latest)
+        version_code = versions.is_a?(Array) && versions.any? ? versions[0] : nil
+
+        if version_code.nil?
+          Fastlane::UI.error "Could not retrieve version code for package #{package_name} on track #{track}. Skipping metadata/promotion step."
+          return
+        end
+
+        Fastlane::UI.message  "App Version Code: " + version_code.to_s
+        Fastlane::UI.message  "App Identifier: " + package_name
+        Fastlane::UI.message  "Track: " + track
+        Fastlane::UI.message  "Track Promote to: " + track_promote_to
+
+        # This call handles metadata, changelogs, images, screenshots, and promotion
+        # Use 'other_action' to call the built-in Fastlane action
+        @lane.other_action.upload_to_play_store(
+          track: track,
+          track_promote_to: track_promote_to,
+          package_name: package_name,
+          version_code: version_code, # Ensure we apply changes to the correct version
+          in_app_update_priority: in_app_update_priority,
+          json_key: api_key_path,
+          metadata_path: metadata_path,
+
+          # Skip the binary upload here, as it was handled in step 1 or skipped by the user
+          skip_upload_aab: true,
+          skip_upload_apk: true,
+
+          # Use user-defined skip flags for other components
+          skip_upload_changelogs: skip_upload_changelogs,
+          skip_upload_metadata: skip_upload_metadata,
+          skip_upload_images: skip_upload_images,
+          skip_upload_screenshots: skip_upload_screenshots,
+          )
+      end
+    end
+
+    def download_from_store(package_name:, api_key_path:, metadata_path:, platform: "android")
+      FileUtils.rm_rf(metadata_path)
+
+      Fastlane::Actions::sh(
+        "fastlane", "supply", "init",
+        "--metadata_path", metadata_path,
+        "--package_name", package_name,
+        "--json_key", api_key_path,
+        )
+    end
+
+    # Resolves the metadata path: either a custom one relative to the root,
+    # or the standard Fastlane structure.
+    def get_metadata_path(platform: "android", metadata_path: nil, flavor:)
+      # If a custom path is provided (and not nil or empty string), use it.
+      unless metadata_path.to_s.empty?
+        # Path structure: @root_folder / custom_path / flavor
+        return File.join(@root_folder, metadata_path, flavor)
+      end
+
+      # Default Path: Use the standard Fastlane structure.
+      # Path structure: @root_folder / fastlane / platform / metadata / flavor
+      File.join(@root_folder, "fastlane", platform, 'metadata', flavor)
+    end
+  end
+end