fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/automatic_code_signing.rb

@@ -0,0 +1,220 @@
+require 'xcodeproj'
+module Fastlane
+  module Actions
+    class AutomaticCodeSigningAction < Action
+      def self.run(params)
+        UI.deprecated("The `automatic_code_signing` action has been deprecated,")
+        UI.deprecated("Please use `update_code_signing_settings` action instead.")
+        FastlaneCore::PrintTable.print_values(config: params, title: "Summary for Automatic Codesigning")
+        path = params[:path]
+        path = File.join(File.expand_path(path), "project.pbxproj")
+
+        project = Xcodeproj::Project.open(params[:path])
+        UI.user_error!("Could not find path to project config '#{path}'. Pass the path to your project (not workspace)!") unless File.exist?(path)
+        UI.message("Updating the Automatic Codesigning flag to #{params[:use_automatic_signing] ? 'enabled' : 'disabled'} for the given project '#{path}'")
+
+        unless project.root_object.attributes["TargetAttributes"]
+          UI.user_error!("Seems to be a very old project file format - please open your project file in a more recent version of Xcode")
+          return false
+        end
+
+        target_dictionary = project.targets.map { |f| { name: f.name, uuid: f.uuid, build_configuration_list: f.build_configuration_list } }
+        target_attributes = project.root_object.attributes["TargetAttributes"]
+        changed_targets = []
+
+        # make sure TargetAttributes exist for all targets
+        target_dictionary.each do |props|
+          unless target_attributes.key?(props[:uuid])
+            target_attributes[props[:uuid]] = {}
+          end
+        end
+
+        target_attributes.each do |target, sett|
+          found_target = target_dictionary.detect { |h| h[:uuid] == target }
+          if params[:targets]
+            # get target name
+            unless params[:targets].include?(found_target[:name])
+              UI.important("Skipping #{found_target[:name]} not selected (#{params[:targets].join(',')})")
+              next
+            end
+          end
+
+          style_value = params[:use_automatic_signing] ? 'Automatic' : 'Manual'
+          build_configuration_list = found_target[:build_configuration_list]
+          build_configuration_list.set_setting("CODE_SIGN_STYLE", style_value)
+          sett["ProvisioningStyle"] = style_value
+
+          if params[:team_id]
+            sett["DevelopmentTeam"] = params[:team_id]
+            build_configuration_list.set_setting("DEVELOPMENT_TEAM", params[:team_id])
+            UI.important("Set Team id to: #{params[:team_id]} for target: #{found_target[:name]}")
+          end
+          if params[:code_sign_identity]
+            build_configuration_list.set_setting("CODE_SIGN_IDENTITY", params[:code_sign_identity])
+
+            # We also need to update the value if it was overridden for a specific SDK
+            build_configuration_list.build_configurations.each do |build_configuration|
+              codesign_build_settings_keys = build_configuration.build_settings.keys.select { |key| key.to_s.match(/CODE_SIGN_IDENTITY.*/) }
+              codesign_build_settings_keys.each do |setting|
+                build_configuration_list.set_setting(setting, params[:code_sign_identity])
+              end
+            end
+            UI.important("Set Code Sign identity to: #{params[:code_sign_identity]} for target: #{found_target[:name]}")
+          end
+          if params[:profile_name]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE_SPECIFIER", params[:profile_name])
+            UI.important("Set Provisioning Profile name to: #{params[:profile_name]} for target: #{found_target[:name]}")
+          end
+          # Since Xcode 8, this is no longer needed, you simply use PROVISIONING_PROFILE_SPECIFIER
+          if params[:profile_uuid]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE", params[:profile_uuid])
+            UI.important("Set Provisioning Profile UUID to: #{params[:profile_uuid]} for target: #{found_target[:name]}")
+          end
+          if params[:bundle_identifier]
+            build_configuration_list.set_setting("PRODUCT_BUNDLE_IDENTIFIER", params[:bundle_identifier])
+            UI.important("Set Bundle identifier to: #{params[:bundle_identifier]} for target: #{found_target[:name]}")
+          end
+
+          changed_targets << found_target[:name]
+        end
+        project.save
+
+        if changed_targets.empty?
+          UI.important("None of the specified targets has been modified")
+          UI.important("available targets:")
+          target_dictionary.each do |target|
+            UI.important("\t* #{target[:name]}")
+          end
+        else
+          UI.success("Successfully updated project settings to use Code Sign Style = '#{params[:use_automatic_signing] ? 'Automatic' : 'Manual'}'")
+          UI.success("Modified Targets:")
+          changed_targets.each do |target|
+            UI.success("\t * #{target}")
+          end
+        end
+
+        params[:use_automatic_signing]
+      end
+
+      def self.alias_used(action_alias, params)
+        params[:use_automatic_signing] = true if action_alias == "enable_automatic_code_signing"
+      end
+
+      def self.aliases
+        ["enable_automatic_code_signing", "disable_automatic_code_signing"]
+      end
+
+      def self.description
+        "Configures Xcode's Codesigning options"
+      end
+
+      def self.details
+        "Configures Xcode's Codesigning options of all targets in the project"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_PROJECT_SIGNING_PROJECT_PATH",
+                                       description: "Path to your Xcode project",
+                                       code_gen_sensitive: true,
+                                       default_value: Dir['*.xcodeproj'].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Path is invalid") unless File.exist?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :use_automatic_signing,
+                                       env_name: "FL_PROJECT_USE_AUTOMATIC_SIGNING",
+                                       description: "Defines if project should use automatic signing",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "FASTLANE_TEAM_ID",
+                                       optional: true,
+                                       description: "Team ID, is used when upgrading project"),
+          FastlaneCore::ConfigItem.new(key: :targets,
+                                       env_name: "FL_PROJECT_SIGNING_TARGETS",
+                                       optional: true,
+                                       type: Array,
+                                       description: "Specify targets you want to toggle the signing mech. (default to all targets)"),
+          FastlaneCore::ConfigItem.new(key: :code_sign_identity,
+                                       env_name: "FL_CODE_SIGN_IDENTITY",
+                                       description: "Code signing identity type (iPhone Developer, iPhone Distribution)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :profile_name,
+                                       env_name: "FL_PROVISIONING_PROFILE_SPECIFIER",
+                                       description: "Provisioning profile name to use for code signing",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :profile_uuid,
+                                       env_name: "FL_PROVISIONING_PROFILE",
+                                       description: "Provisioning profile UUID to use for code signing",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_identifier,
+                                       env_name: "FL_APP_IDENTIFIER",
+                                       description: "Application Product Bundle Identifier",
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.example_code
+        [
+          '# enable automatic code signing
+          enable_automatic_code_signing',
+          'enable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          '# disable automatic code signing
+          disable_automatic_code_signing',
+          'disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          '# also set team id
+          disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            team_id: "XXXX"
+          )',
+          '# Only specific targets
+          disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: false,
+            targets: ["demo"]
+          )
+          ',
+          ' # via generic action
+          automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: false
+          )',
+          'automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: true
+          )'
+
+        ]
+      end
+
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        "Please use `update_code_signing_settings` action instead."
+      end
+
+      def self.return_value
+        "The current status (boolean) of codesigning after modification"
+      end
+
+      def self.authors
+        ["mathiasAichinger", "hjanuschka", "p4checo", "portellaa", "aeons"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/backup_file.rb

@@ -0,0 +1,41 @@
+module Fastlane
+  module Actions
+    class BackupFileAction < Action
+      def self.run(params)
+        path = params[:path]
+        FileUtils.cp(path, "#{path}.back", preserve: true)
+        UI.message("Successfully created a backup 💾")
+      end
+
+      def self.description
+        'This action backs up your file to "[path].back"'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.author
+        "gin0606"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       description: "Path to the file you want to backup",
+                                       optional: false)
+        ]
+      end
+
+      def self.example_code
+        [
+          'backup_file(path: "/path/to/file")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/backup_xcarchive.rb

@@ -0,0 +1,135 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      BACKUP_XCARCHIVE_FILE = :BACKUP_XCARCHIVE_FILE
+    end
+
+    class BackupXcarchiveAction < Action
+      require 'fileutils'
+
+      def self.run(params)
+        # Get params
+        xcarchive = params[:xcarchive]
+        base_destination = params[:destination]
+        zipped = params[:zip]
+        zip_filename = params[:zip_filename]
+        versioned = params[:versioned]
+
+        # Prepare destionation folder
+        full_destination = base_destination
+
+        if versioned
+          date = Time.now.strftime("%Y-%m-%d")
+          version = `agvtool what-marketing-version -terse1`
+          subfolder = "#{date} #{version.strip}"
+          full_destination = File.expand_path(subfolder, base_destination)
+        end
+
+        FileUtils.mkdir(full_destination) unless File.exist?(full_destination)
+
+        # Save archive to destination
+        if zipped
+          Dir.mktmpdir("backup_xcarchive") do |dir|
+            UI.message("Compressing #{xcarchive}")
+            xcarchive_folder = File.expand_path(File.dirname(xcarchive))
+            xcarchive_file = File.basename(xcarchive)
+            zip_file = if zip_filename
+                         File.join(dir, "#{zip_filename}.xcarchive.zip")
+                       else
+                         File.join(dir, "#{xcarchive_file}.zip")
+                       end
+
+            # Create zip
+            Actions.sh(%(cd "#{xcarchive_folder}" && zip -r -X -y "#{zip_file}" "#{xcarchive_file}" > /dev/null))
+
+            # Moved to its final destination
+            FileUtils.mv(zip_file, full_destination)
+
+            Actions.lane_context[SharedValues::BACKUP_XCARCHIVE_FILE] = "#{full_destination}/#{File.basename(zip_file)}"
+          end
+        else
+          # Copy xcarchive file
+          FileUtils.cp_r(xcarchive, full_destination)
+
+          Actions.lane_context[SharedValues::BACKUP_XCARCHIVE_FILE] = "#{full_destination}/#{File.basename(xcarchive)}"
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Save your [zipped] xcarchive elsewhere from default path"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :xcarchive,
+                                       description: 'Path to your xcarchive file. Optional if you use the `xcodebuild` action',
+                                       default_value: Actions.lane_context[SharedValues::XCODEBUILD_ARCHIVE],
+                                       default_value_dynamic: true,
+                                       optional: false,
+                                       env_name: 'BACKUP_XCARCHIVE_ARCHIVE',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find xcarchive file at path '#{value}'") if !Helper.test? && !File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       description: 'Where your archive will be placed',
+                                       optional: false,
+                                       env_name: 'BACKUP_XCARCHIVE_DESTINATION',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find the destination folder at '#{value}'") if !Helper.test? && !File.directory?(value) && !File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :zip,
+                                       description: 'Enable compression of the archive',
+                                       type: Boolean,
+                                       default_value: true,
+                                       optional: true,
+                                       env_name: 'BACKUP_XCARCHIVE_ZIP'),
+          FastlaneCore::ConfigItem.new(key: :zip_filename,
+                                       description: 'Filename of the compressed archive. Will be appended by `.xcarchive.zip`. Default value is the output xcarchive filename',
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       env_name: 'BACKUP_XCARCHIVE_ZIP_FILENAME'),
+          FastlaneCore::ConfigItem.new(key: :versioned,
+                                       description: 'Create a versioned (date and app version) subfolder where to put the archive',
+                                       type: Boolean,
+                                       default_value: true,
+                                       optional: true,
+                                       env_name: 'BACKUP_XCARCHIVE_VERSIONED')
+        ]
+      end
+
+      def self.output
+        [
+          ['BACKUP_XCARCHIVE_FILE', 'Path to your saved xcarchive (compressed) file']
+        ]
+      end
+
+      def self.author
+        ['dral3x']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'backup_xcarchive(
+            xcarchive: "/path/to/file.xcarchive", # Optional if you use the `xcodebuild` action
+            destination: "/somewhere/else/", # Where the backup should be created
+            zip_filename: "file.xcarchive", # The name of the backup file
+            zip: false, # Enable compression of the archive. Defaults to `true`.
+            versioned: true # Create a versioned (date and app version) subfolder where to put the archive
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/badge.rb

@@ -0,0 +1,151 @@
+module Fastlane
+  module Actions
+    class BadgeAction < Action
+      def self.run(params)
+        UI.important('The badge action has been deprecated,')
+        UI.important('please checkout the badge plugin here:')
+        UI.important('https://github.com/HazAT/fastlane-plugin-badge')
+        Actions.verify_gem!('badge')
+        require 'badge'
+        options = {
+          dark: params[:dark],
+          custom: params[:custom],
+          no_badge: params[:no_badge],
+          shield: params[:shield],
+          alpha: params[:alpha],
+          shield_io_timeout: params[:shield_io_timeout],
+          glob: params[:glob],
+          alpha_channel: params[:alpha_channel],
+          shield_gravity: params[:shield_gravity],
+          shield_no_resize: params[:shield_no_resize]
+        }
+        begin
+          Badge::Runner.new.run(params[:path], options)
+        rescue => e
+          # We want to catch this error and raise our own so that we are not counting this as a crash in our metrics
+          UI.verbose(e.backtrace.join("\n"))
+          UI.user_error!("Something went wrong while running badge: #{e}")
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Automatically add a badge to your app icon"
+      end
+
+      def self.details
+        [
+          "Please use the [badge plugin](https://github.com/HazAT/fastlane-plugin-badge) instead.",
+          "This action will add a light/dark badge onto your app icon.",
+          "You can also provide your custom badge/overlay or add a shield for more customization.",
+          "More info: [https://github.com/HazAT/badge](https://github.com/HazAT/badge)",
+          "**Note**: If you want to reset the badge back to default, you can use `sh 'git checkout -- <path>/Assets.xcassets/'`."
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'badge(dark: true)',
+          'badge(alpha: true)',
+          'badge(custom: "/Users/xxx/Desktop/badge.png")',
+          'badge(shield: "Version-0.0.3-blue", no_badge: true)'
+        ]
+      end
+
+      def self.category
+        :deprecated
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :dark,
+                                       env_name: "FL_BADGE_DARK",
+                                       description: "Adds a dark flavored badge on top of your icon",
+                                       optional: true,
+                                       type: Boolean,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("dark is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :custom,
+                                       env_name: "FL_BADGE_CUSTOM",
+                                       description: "Add your custom overlay/badge image",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("custom should be a valid file path") unless value && File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :no_badge,
+                                       env_name: "FL_BADGE_NO_BADGE",
+                                       description: "Hides the beta badge",
+                                       optional: true,
+                                       type: Boolean,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("no_badge is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :shield,
+                                       env_name: "FL_BADGE_SHIELD",
+                                       description: "Add a shield to your app icon from shields.io",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :alpha,
+                                       env_name: "FL_BADGE_ALPHA",
+                                       description: "Adds and alpha badge instead of the default beta one",
+                                       optional: true,
+                                       type: Boolean,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("alpha is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_BADGE_PATH",
+                                       description: "Sets the root path to look for AppIcons",
+                                       optional: true,
+                                       default_value: '.',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("path needs to be a valid directory") if Dir[value].empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :shield_io_timeout,
+                                       env_name: "FL_BADGE_SHIELD_IO_TIMEOUT",
+                                       description: "Set custom duration for the timeout of the shields.io request in seconds",
+                                       optional: true,
+                                       type: Integer, # allow integers, strings both
+                                       verify_block: proc do |value|
+                                         UI.user_error!("shield_io_timeout needs to be an integer > 0") if value.to_i < 1
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :glob,
+                                       env_name: "FL_BADGE_GLOB",
+                                       description: "Glob pattern for finding image files",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :alpha_channel,
+                                       env_name: "FL_BADGE_ALPHA_CHANNEL",
+                                       description: "Keeps/adds an alpha channel to the icon (useful for android icons)",
+                                       optional: true,
+                                       type: Boolean,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("alpha_channel is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :shield_gravity,
+                                       env_name: "FL_BADGE_SHIELD_GRAVITY",
+                                       description: "Position of shield on icon. Default: North - Choices include: NorthWest, North, NorthEast, West, Center, East, SouthWest, South, SouthEast",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :shield_no_resize,
+                                       env_name: "FL_BADGE_SHIELD_NO_RESIZE",
+                                       description: "Shield image will no longer be resized to aspect fill the full icon. Instead it will only be shrunk to not exceed the icon graphic",
+                                       optional: true,
+                                       type: Boolean,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("shield_no_resize is only a flag and should always be true") unless value == true
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ["DanielGri"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac, :android].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/build_and_upload_to_appetize.rb

@@ -0,0 +1,113 @@
+module Fastlane
+  module Actions
+    class BuildAndUploadToAppetizeAction < Action
+      def self.run(params)
+        tmp_path = "/tmp/fastlane_build"
+
+        xcodebuild_configs = params[:xcodebuild]
+        xcodebuild_configs[:sdk] = "iphonesimulator"
+        xcodebuild_configs[:derivedDataPath] = tmp_path
+        xcodebuild_configs[:xcargs] = "CONFIGURATION_BUILD_DIR=" + tmp_path
+        xcodebuild_configs[:scheme] ||= params[:scheme] if params[:scheme].to_s.length > 0
+
+        Actions::XcodebuildAction.run(xcodebuild_configs)
+
+        app_path = Dir[File.join(tmp_path, "**", "*.app")].last
+        UI.user_error!("Couldn't find app") unless app_path
+
+        zipped_bundle = Actions::ZipAction.run(path: app_path,
+                                        output_path: File.join(tmp_path, "Result.zip"))
+
+        other_action.appetize(path: zipped_bundle,
+                              api_token: params[:api_token],
+                              public_key: params[:public_key],
+                              note: params[:note],
+                              timeout: params[:timeout])
+
+        public_key = Actions.lane_context[SharedValues::APPETIZE_PUBLIC_KEY]
+        UI.success("Generated Public Key: #{Actions.lane_context[SharedValues::APPETIZE_PUBLIC_KEY]}")
+
+        FileUtils.rm_rf(tmp_path)
+
+        return public_key
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Generate and upload an ipa file to appetize.io"
+      end
+
+      def self.details
+        [
+          "This should be called from danger.",
+          "More information in the [device_grid guide](https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/actions/device_grid/README.md)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :xcodebuild,
+                                       description: "Parameters that are passed to the xcodebuild action",
+                                       type: Hash,
+                                       default_value: {},
+                                       short_option: '-x',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :scheme,
+                                       description: "The scheme to build. Can also be passed using the `xcodebuild` parameter",
+                                       type: String,
+                                       short_option: '-s',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "APPETIZE_API_TOKEN",
+                                       description: "Appetize.io API Token",
+                                       sensitive: true,
+                                       code_gen_sensitive: true),
+          FastlaneCore::ConfigItem.new(key: :public_key,
+                                       description: "If not provided, a new app will be created. If provided, the existing build will be overwritten",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         if value.start_with?("private_")
+                                           UI.user_error!("You provided a private key to appetize, please provide the public key")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :note,
+                                       description: "Notes you wish to add to the uploaded app",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       description: "The number of seconds to wait until automatically ending the session due to user inactivity. Must be 30, 60, 90, 120, 180, 300, 600, 1800, 3600 or 7200. Default is 120",
+                                       type: Integer,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The value provided doesn't match any of the supported options.") unless [30, 60, 90, 120, 180, 300, 600, 1800, 3600, 7200].include?(value)
+                                       end)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        ""
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        nil
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/build_android_app.rb

@@ -0,0 +1,14 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/gradle'
+    class BuildAndroidAppAction < GradleAction
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Alias for the `gradle` action"
+      end
+    end
+  end
+end