fastlane-plugin-wpmreleasetoolkit 5.5.0 → 5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 858fcaeb7ccaa13b2b3990d36aa1c9aa15f9f9cb90c7ee7bb6941442f2c97847
-  data.tar.gz: '067942032d28224600deae4333b427e3eda6af56d65fb83eefb5ef4e3c07b868'
+  metadata.gz: dd2b56e6aa5cf05e5e464b66e8b136e05048c7cdadee95b43bb152ab6d451e9f
+  data.tar.gz: da440f83d0f87a6d2dd6c74684a149d381f157d0f0ce40157c12cd237ebed373
 SHA512:
-  metadata.gz: eb6a9f16072c66b7458d4a0787b300cdddd0d87ae99cc886ecc5d64a733d11f046a27c6167b7150fd73c358d9f6c3c85e03b10d4b5c76202fa5273560b5b523e
-  data.tar.gz: ca606aef9d929fe6ae3c1f821575e07fc4b672929b61ad7174a1f7e43dea8c2698ed63c696c62506beca226581f726fccadc01930e15b5e8088aa7908e2f0a6c
+  metadata.gz: e684c1a705d0fab1f9d3ce82f7feed96be8a4aa09a954a19db1a564c4b958654668a6d2b9c23ee41bdcfd39ec68104f3e44e877a8df6d2bb5773efbe706c1730
+  data.tar.gz: 9fb910e098bbcc54a8753aebb1c2776e0c6e889d20e042f2848a38a5e3ebbeb95ae7b8def13d4efa0fa0e06c050e24e3d80633642a4281e3ba194e55c148427b

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_create_avd_action.rb

@@ -0,0 +1,90 @@
+module Fastlane
+  module Actions
+    class AndroidCreateAvdAction < Action
+      def self.run(params)
+        device_model = params[:device_model]
+        api_level = params[:api_level]
+        avd_name = params[:avd_name]
+        sdcard = params[:sdcard]
+
+        helper = Fastlane::Helper::Android::EmulatorHelper.new
+
+        # Ensure we have the system image needed for creating the AVD with this API level
+        system_image = params[:system_image] || helper.install_system_image(api: api_level)
+
+        # Create the AVD for device, API and system image we need
+        helper.create_avd(
+          api: api_level,
+          device: device_model,
+          system_image: system_image,
+          name: avd_name,
+          sdcard: sdcard
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Creates a new Android Virtual Device (AVD) for a specific device model and API level'
+      end
+
+      def self.details
+        <<~DESC
+          Creates a new Android Virtual Device (AVD) for a specific device model and API level.
+          By default, it also installs the necessary system image (using `sdkmanager`) if needed before creating the AVD
+        DESC
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :device_model,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_DEVICE_MODEL',
+                                       description: 'The device model code to use to create the AVD. Valid values can be found using `avdmanager list devices`',
+                                       type: String,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :api_level,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_API_LEVEL',
+                                       description: 'The API level to use to install the necessary system-image and create the AVD',
+                                       type: Integer,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :avd_name,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_AVD_NAME',
+                                       description: 'The name to give to the created AVD. If not provided, will be derived from device model and API level',
+                                       type: String,
+                                       optional: true,
+                                       default_value: nil),
+          FastlaneCore::ConfigItem.new(key: :sdcard,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_SDCARD',
+                                       description: 'The size of the SD card to use for the AVD',
+                                       type: String,
+                                       optional: true,
+                                       default_value: '512M'),
+          FastlaneCore::ConfigItem.new(key: :system_image,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_SYSTEM_IMAGE',
+                                       description: 'The system image to use (as used/listed by `sdkmanager`). Defaults to the appropriate system image given the API level requested and the current machine\'s architecture',
+                                       type: String,
+                                       optional: true,
+                                       default_value_dynamic: true,
+                                       default_value: nil),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        'Returns the name of the created AVD'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_launch_emulator_action.rb

@@ -0,0 +1,61 @@
+module Fastlane
+  module Actions
+    class AndroidLaunchEmulatorAction < Action
+      def self.run(params)
+        helper = Fastlane::Helper::Android::EmulatorHelper.new
+        helper.launch_avd(
+          name: params[:avd_name],
+          cold_boot: params[:cold_boot],
+          wipe_data: params[:wipe_data]
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Boots an Android emulator using the given AVD name'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :avd_name,
+                                       env_name: 'FL_ANDROID_LAUNCH_EMULATOR_AVD_NAME',
+                                       description: 'The name of the AVD to boot',
+                                       type: String,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :cold_boot,
+                                       env_name: 'FL_ANDROID_LAUNCH_EMULATOR_COLD_BOOT',
+                                       description: 'Indicate if we want a cold boot (true) of if we prefer booting from a snapshot (false)',
+                                       type: Fastlane::Boolean,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :wipe_data,
+                                       env_name: 'FL_ANDROID_LAUNCH_EMULATOR_WIPE_DATA',
+                                       description: 'Indicate if we want to wipe the device data before booting the AVD, so it is like it were a brand new device',
+                                       type: Fastlane::Boolean,
+                                       default_value: true),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        'The serial of the emulator that was created after booting the AVD (e.g. `emulator-5554`)'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_send_app_size_metrics.rb

@@ -71,31 +71,26 @@ module Fastlane
         end
 
         # The path where the `apkanalyzer` binary was found, after searching it:
-        #  - in priority in `$ANDROID_SDK_ROOT` (or `$ANDROID_HOME` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
+        #  - in priority in `$ANDROID_HOME` (or `$ANDROID_SDK_ROOT` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
         #  - and falling back by trying to find it in `$PATH`
         #
         # @return [String,Nil] The path to `apkanalyzer`, or `nil` if it wasn't found in any of the above tested paths.
         #
         def find_apkanalyzer_binary
-          sdk_root = ENV['ANDROID_SDK_ROOT'] || ENV['ANDROID_HOME']
-          if sdk_root
-            pattern = File.join(sdk_root, 'cmdline-tools', '{latest,tools}', 'bin', 'apkanalyzer')
-            apkanalyzer_bin = Dir.glob(pattern).find { |path| File.executable?(path) }
-          end
-          apkanalyzer_bin || Action.sh('command', '-v', 'apkanalyzer', print_command_output: false) { |_| nil }
+          @tools ||= Fastlane::Helper::Android::ToolsPathHelper.new
+          @tools.find_tool_path(binary: 'apkanalyzer', search_paths: @tools.cmdline_tools_search_paths)
         end
 
         # The path where the `apkanalyzer` binary was found, after searching it:
-        #  - in priority in `$ANDROID_SDK_ROOT` (or `$ANDROID_HOME` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
+        #  - in priority in `$ANDROID_HOME` (or `$ANDROID_SDK_ROOT` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
         #  - and falling back by trying to find it in `$PATH`
         #
         # @return [String] The path to `apkanalyzer`
         # @raise [FastlaneCore::Interface::FastlaneError] if it wasn't found in any of the above tested paths.
         #
         def find_apkanalyzer_binary!
-          apkanalyzer_bin = find_apkanalyzer_binary
-          UI.user_error!('Unable to find `apkanalyzer` executable in either `$PATH` or `$ANDROID_SDK_ROOT`. Make sure you installed the Android SDK Command-line Tools') if apkanalyzer_bin.nil?
-          apkanalyzer_bin
+          @tools ||= Fastlane::Helper::Android::ToolsPathHelper.new
+          @tools.find_tool_path!(binary: 'apkanalyzer', search_paths: @tools.cmdline_tools_search_paths)
         end
 
         # Add the `file-size` and `download-size` values of an APK to the helper, as reported by the corresponding `apkanalyzer apk …` commands

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_shutdown_emulator_action.rb

@@ -0,0 +1,48 @@
+module Fastlane
+  module Actions
+    class AndroidShutdownEmulatorAction < Action
+      def self.run(params)
+        helper = Fastlane::Helper::Android::EmulatorHelper.new
+        helper.shut_down_emulators!(serials: params[:serials])
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Shuts down Android emulators'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :serials,
+                                       env_name: 'FL_ANDROID_SHUTDOWN_EMULATOR_SERIALS',
+                                       description: 'The serial(s) of the emulators to shut down. If not provided (nil), will shut them all down',
+                                       type: Array,
+                                       optional: true,
+                                       default_value: nil),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        # If you method provides a return value, you can describe here what it does
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_emulator_helper.rb

@@ -0,0 +1,198 @@
+module Fastlane
+  module Helper
+    module Android
+      # Helper methods to manipulate System Images, AVDs and Android Emulators
+      #
+      class EmulatorHelper
+        BOOT_WAIT = 2
+        BOOT_TIMEOUT = 60
+
+        SHUTDOWN_WAIT = 2
+        SHUTDOWN_TIMEOUT = 60
+
+        def initialize
+          @tools = Fastlane::Helper::Android::ToolsPathHelper.new
+        end
+
+        # Installs the system-image suitable for a given Android `api`, with Google APIs, and for the current machine's architecture
+        #
+        # @param [Integer] api The Android API level to use
+        #
+        # @return [String] The `sdkmanager` package specifier that has been installed
+        #
+        def install_system_image(api:)
+          package = system_image_package(api: api)
+
+          UI.message("Installing System Image for Android #{api} (#{package})")
+          Actions.sh(@tools.sdkmanager, '--install', package)
+          UI.success("System Image #{package} successfully installed.")
+          package
+        end
+
+        # Create an emulator (AVD) for a given `api` number and `device` model
+        #
+        # @param [Integer] api The Android API level to use for this AVD
+        # @param [String] device The Device Model to use for this AVD. Valid values can be found using `avdmanager list devices`
+        # @param [String] name The name to give for the created AVD. Defaults to `<device>_API_<api>`.
+        # @param [String] sdcard The size of the SD card for this device. Defaults to `512M`.
+        #
+        # @return [String] The device name (i.e. either `name` if provided, or the derived `<device>_API_<api>` if provided `name` was `nil``)
+        #
+        def create_avd(api:, device:, system_image: nil, name: nil, sdcard: '512M')
+          package = system_image || system_image_package(api: api)
+          device_name = name || "#{device.gsub(' ', '_').capitalize}_API_#{api}"
+
+          UI.message("Creating AVD `#{device_name}` (#{device}, API #{api})")
+
+          Actions.sh(
+            @tools.avdmanager, 'create', 'avd',
+            '--force',
+            '--package', package,
+            '--device', device,
+            '--sdcard', sdcard,
+            '--name', device_name
+          )
+
+          UI.success("AVD `#{device_name}` successfully created.")
+
+          device_name
+        end
+
+        # Launch the emulator for the given AVD, then return the emulator serial
+        #
+        # @param [String] name name of the AVD to launch
+        # @param [Int] port the TCP port to use to connect to the emulator via adb. If nil (default), will let `emulator` pick the first free one.
+        # @param [Boolean] cold_boot if true, will do a cold boot, if false will try to use a previous snapshot of the device
+        # @param [Boolean] wipe_data if true, will wipe the emulator (i.e. reset the user data image)
+        #
+        # @return [String] emulator serial number corresponding to the launched AVD
+        #
+        def launch_avd(name:, port: nil, cold_boot: true, wipe_data: true)
+          UI.message("Launching emulator for #{name}")
+
+          params = ['-avd', name]
+          params << ['-port', port.to_s] unless port.nil?
+          params << '-no-snapshot' if cold_boot
+          params << '-wipe-data' if wipe_data
+
+          UI.command([@tools.emulator, *params].shelljoin)
+          # We want to launch emulator in the background to not block the rest of the code, so we can't use `Actions.sh` here
+          # We also want to filter the `stdout`+`stderr` emitted by the `emulator` process in the background,
+          # to limit verbosity and only print error lines, and also prefix those clearly (because they might happen
+          # at any moment in the background, so in parallel/the middle of other fastlane logs).
+          t = Thread.new do
+            Open3.popen2e(@tools.emulator, *params) do |i, oe, wait_thr|
+              i.close
+              until oe.eof?
+                line = oe.readline
+                UI.error("📱 [emulator]: #{line}") if line.start_with?(/ERROR|PANIC/)
+                next unless line.include?('PANIC: Broken AVD system path')
+
+                UI.user_error! <<~HINT
+                  #{line}
+                  Verify that your `sdkmanager/avdmanager` tools are not installed in a different SDK root than your `emulator` tool
+                  (which can happen if you installed Android's command-line tools via `brew`, but the `emulator` via Android Studio, or vice-versa)
+                HINT
+              end
+              UI.error("📱 [emulator]: exited with non-zero status code: #{wait_thr.value.exitstatus}") unless wait_thr.value.success?
+            end
+          end
+          t.abort_on_exception = true # To bubble up any exception like `UI.user_error!` back to the main thread here
+
+          UI.message('Waiting for emulator to start...')
+          # Loop until the emulator has started and shows up in `adb devices -l` so we can find its serial
+          serial = nil
+          retry_loop(time_between_retries: BOOT_WAIT, timeout: BOOT_TIMEOUT, description: 'waiting for emulator to start') do
+            serial = find_serial(avd_name: name)
+            !serial.nil?
+          end
+          UI.message("Found device `#{name}` with serial `#{serial}`")
+
+          # Once the emulator has started, wait for the device in the emulator to finish booting
+          UI.message('Waiting for device to finish booting...')
+          retry_loop(time_between_retries: BOOT_WAIT, timeout: BOOT_TIMEOUT, description: 'waiting for device to finish booting') do
+            Actions.sh(@tools.adb, '-s', serial, 'shell', 'getprop', 'sys.boot_completed').chomp == '1'
+          end
+
+          UI.success("Emulator #{name} successfully booted as `#{serial}`.")
+
+          serial
+        end
+
+        # @return [Array<Fastlane::Helper::AdbDevice>] List of currently booted emulators
+        #
+        def running_emulators
+          helper = Fastlane::Helper::AdbHelper.new(adb_path: @tools.adb)
+          helper.load_all_devices.select { |device| device.serial.include?('emulator') }
+        end
+
+        def find_serial(avd_name:)
+          running_emulators.find do |candidate|
+            command = [@tools.adb, '-s', candidate.serial, 'emu', 'avd', 'name']
+            UI.command(command.shelljoin)
+            candidate_name = Actions.sh(*command, log: false).split("\n").first.chomp
+            candidate_name == avd_name
+          end&.serial
+        end
+
+        # Trigger a shutdown for all running emulators, and wait until there is no more emulators running.
+        #
+        # @param [Array<String>] serials List of emulator serials to shut down. Will shut down all of them if `nil`.
+        #
+        def shut_down_emulators!(serials: nil)
+          UI.message("Shutting down #{serials || 'all'} emulator(s)...")
+
+          emulators_list = running_emulators.map(&:serial)
+          # Get the intersection of the set of running emulators with the ones we want to shut down
+          emulators_list &= serials unless serials.nil?
+          emulators_list.each do |e|
+            Actions.sh(@tools.adb, '-s', e, 'emu', 'kill') { |_| } # ignore error if no emulator with specified serial is running
+
+            # NOTE: Alternative way of shutting down emulator would be to call the following command instead, which shuts down the emulator more gracefully:
+            # `adb -s #{e} shell reboot -p` # In case you're wondering, `-p` is for "power-off"
+            # But this alternate command:
+            #  - Requires that `-no-snapshot` was used on boot (to avoid being prompted to save current state on shutdown)
+            #  - Disconnects the emulator from `adb` (and thus disappear from `adb devices -l`) for a short amount of time,
+            #    before reconnecting to it but in an `offline` state, until `emulator` finally completely quits and it disappears
+            #    again (for good) from `adb devices --list`.
+            # This means that so if we used alternative, we couldn't really retry_loop until emulator disappears from `running_emulators` to detect
+            # that the shutdown was really complete, as we might as well accidentally detect the intermediate disconnect instead.
+          end
+
+          # Wait until all emulators are killed
+          retry_loop(time_between_retries: SHUTDOWN_WAIT, timeout: SHUTDOWN_TIMEOUT, description: 'waiting for devices to shutdown') do
+            (emulators_list & running_emulators.map(&:serial)).empty?
+          end
+
+          UI.success('All emulators are now shut down.')
+        end
+
+        # Find the system-images package for the provided `api`, with Google APIs, and matching the current platform/architecture this lane is called from.
+        #
+        # @param [Integer] api The Android API level to use for this AVD
+        # @return [String] The `system-images;android-<N>;google_apis;<platform>` package specifier for `sdkmanager` to use in its install command
+        #
+        # @note Results from this method are memoized, to avoid repeating calls to `sdkmanager` when querying for the same api level multiple times.
+        #
+        def system_image_package(api:)
+          @system_image_packages ||= {}
+          @system_image_packages[api] ||= begin
+            platform = `uname -m`.chomp
+            all_packages = `#{@tools.sdkmanager} --list`
+            package = all_packages.match(/^ *(system-images;android-#{api};google_apis;#{platform}(-[^ ]*)?)/)&.captures&.first
+            UI.user_error!("Could not find system-image for API `#{api}` and your platform `#{platform}` in `sdkmanager --list`. Maybe Google removed it for download and it's time to update to a newer API?") if package.nil?
+            package
+          end
+        end
+
+        def retry_loop(time_between_retries:, timeout:, description:)
+          Timeout.timeout(timeout) do
+            sleep(time_between_retries) until yield
+          end
+        rescue Timeout::Error
+          UI.user_error!("Timed out #{description}")
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_tools_path_helper.rb

@@ -0,0 +1,87 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  module Helper
+    module Android
+      # Helper to find the paths of common Android build and SDK tools on the current machine
+      # Based on `$ANDROID_HOME` and the common relative paths those tools are installed in.
+      #
+      class ToolsPathHelper
+        attr_reader :android_home
+
+        def initialize(sdk_root: nil)
+          @android_home = sdk_root || ENV['ANDROID_HOME'] || ENV['ANDROID_SDK_ROOT'] || ENV['ANDROID_SDK']
+        end
+
+        # @param [String] binary The name of the binary to search for
+        # @param [Array<String>] search_paths The search paths, relative to `@android_home`, in which to search for the tools.
+        #        If `android_home` is `nil` or the binary wasn't found in any of the `search_paths`, will fallback to searching in `$PATH`.
+        # @return [String] The absolute path of the tool if found, `nil` if not found.
+        def find_tool_path(binary:, search_paths:)
+          bin_path = unless android_home.nil?
+                       search_paths
+                         .map { |path| File.join(android_home, path, binary) }
+                         .find { |path| File.executable?(path) }
+                     end
+
+          # If not found in any of the `search_paths`, try to look for it in $PATH
+          bin_path ||= Actions.sh('command', '-v', binary) { |err, res, _| res if err&.success? }&.chomp
+
+          # Normalize return value to `nil` if it was not found, empty, or is not an executable
+          bin_path = nil if !bin_path.nil? && (bin_path.empty? || !File.executable?(bin_path))
+
+          bin_path
+        end
+
+        # @param [String] binary The name of the binary to search for
+        # @param [Array<String>] search_paths The search paths, relative to `@android_home`, in which to search for the tools.
+        #        If `android_home` is `nil` or the binary wasn't found in any of the `search_paths`, will fallback to searching in `$PATH`.
+        # @return [String] The absolute path of the tool if found.
+        # @raise [FastlaneCore::Interface::FastlaneError] If the tool couldn't be found.
+        def find_tool_path!(binary:, search_paths:)
+          bin_path = find_tool_path(binary: binary, search_paths: search_paths)
+          UI.user_error!("Unable to find path for #{binary} in #{search_paths.inspect}. Verify you installed the proper Android tools.") if bin_path.nil?
+          bin_path
+        end
+
+        def cmdline_tools_search_paths
+          # It appears that depending on the machines and versions of Android SDK, some versions
+          # installed the command line tools in `tools` and not `latest` subdirectory, hence why
+          # we search both (`latest` first, `tools` as fallback) to cover all our bases.
+          [
+            File.join('cmdline-tools', 'latest', 'bin'),
+            File.join('cmdline-tools', 'tools', 'bin'),
+          ]
+        end
+
+        def sdkmanager
+          @sdkmanager ||= find_tool_path!(
+            binary: 'sdkmanager',
+            search_paths: cmdline_tools_search_paths
+          )
+        end
+
+        def avdmanager
+          @avdmanager ||= find_tool_path!(
+            binary: 'avdmanager',
+            search_paths: cmdline_tools_search_paths
+          )
+        end
+
+        def emulator
+          @emulator ||= find_tool_path!(
+            binary: 'emulator',
+            search_paths: [File.join('emulator')]
+          )
+        end
+
+        def adb
+          @adb ||= find_tool_path!(
+            binary: 'adb',
+            search_paths: [File.join('platform-tools')]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Wpmreleasetoolkit
-    VERSION = '5.5.0'
+    VERSION = '5.6.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 5.6.0
 platform: ruby
 authors:
 - Automattic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2022-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -260,14 +260,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.210'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.210'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -402,6 +402,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_bump_version_release.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_codefreeze_prechecks.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_completecodefreeze_prechecks.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_create_avd_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_create_xml_release_notes.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_current_branch_is_hotfix.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_download_file_by_version.rb
@@ -412,7 +413,9 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_get_app_version.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_get_release_version.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_hotfix_prechecks.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_launch_emulator_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_send_app_size_metrics.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_shutdown_emulator_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_tag_build.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_update_release_notes.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/buildkite_trigger_build_action.rb
@@ -471,8 +474,10 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_update_release_notes.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_validate_ci_build.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/an_metadata_update_helper.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_emulator_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_git_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_localize_helper.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_tools_path_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_version_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/app_size_metrics_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ci_helper.rb