fastlane-plugin-automated_test_emulator_run_next 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 27b646d002da322ae2a1b3b78901c8c1bcd37ce1034101c6ee7d48a90c7f4d7e
+  data.tar.gz: a1ca615cb563af564f750ec0248c5e8b48700f62035758f7b6899e487eeed826
+SHA512:
+  metadata.gz: c4a7e1d9ec62d6dc7e29a87711f99354d65b6f35ab12529e8c71cc6d9679b28265224f34aeb5abc6280c9f30788062f44ae507bd69a18993b98d1fc1ea3374fa
+  data.tar.gz: 33af3bd42137dc73fc7ffbb550efacbdbe4fd1b7e8b7823ab31784f74182d09a1435845c04369fb3ad3f3037f4d2d8fe472ce7a64baf699c6df486665677e32a

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright for portions of this project are held by [Kamil Krzyk, 2016] as part of project Automated Test Emulator Run. All other copyright for this project are held by [Hiroto Nakamura <hiroto.nakamura95@gmail.com>, 2022].
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# automated_test_emulator_run plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-automated_test_emulator_run)
+
+## About this fork
+
+Forked from original gem as it looks to be abandoned by its original author(s). This fork aims to add support for the [Android Command line tools](https://developer.android.com/studio/command-line) as well as include some improvements that would be useful additions to the base functionality of the plugin.
+
+## About automated_test_emulator_run
+
+Starts any number of AVDs. AVDs are created and configured automatically according to user liking before instrumentation test process starts (started either via shell command or from gradle) and killed/deleted after test process finishes.
+
+## Getting Started
+
+This project is a [fastlane](https://github.com/fastlane/fastlane) plugin.
+
+1. To get started with `fastlane-plugin-automated_test_emulator_run`, add it to your project by running:
+
+  ```bash
+  fastlane add_plugin automated_test_emulator_run
+  ```
+2. Create your \*.JSON config file to create AVD launch plan according to schema below/provided example.
+
+3. Wrap your test launch command with plugin and provide link to \*.JSON config.
+
+## Example of Fastfile
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+## JSON config
+
+What is JSON config?
+
+It is a core of this plugin. User can specify any number of AVD devices in JSON file. Each AVD can be configured separately. Plugin will read JSON file and create fresh, new, untouched AVDs on host - use them in tests - and then delete them after test process finishes.
+
+JSON file scheme:
+```
+{
+    "avd_list":
+    [
+        {
+          "avd_name": "",
+
+          "create_avd_package": "",
+          "create_avd_device": "",
+          "create_avd_tag": "",
+          "create_avd_abi": "",
+          "create_avd_additional_options": "",
+          "create_avd_hardware_config_filepath": "",
+
+          "launch_avd_port": "",
+          "launch_avd_snapshot_filepath": "",
+          "launch_avd_launch_binary_name": "",
+          "launch_avd_additional_options": ""
+        }
+    ]
+}
+```
+
+Parameters:
+<br>For official help refer to `avdmanager` binary file: `<sdk_root>/cmdline-tools/latest/bin/avdmanager create avd`
+- `avd_name` - name of your AVD, avoid using spaces, this field is necessary
+- `create_avd_package` - path to system image in example "system-images;android-23;google_apis;x86_64"
+- `create_avd_device` - name of your device visible on `avdmanager list device` list
+- `create_avd_tag` - the sys-img tag to use for the AVD. e.g. if you are using Google Apis then set it to "google_apis"
+- `create_avd_abi` - abi for AVD e.g. "x86" or "x86_64" (https://developer.android.com/ndk/guides/abis.html)
+- `create_avd_hardware_config_filepath` - path to config.ini file containing custom config for your AVD. After AVD is created this file will be copied into AVD location before it launches.
+- `create_avd_additional_options` - if you think that you need something more you can just add your create parameters here (e.g. "--sdcard 128M", https://developer.android.com/studio/tools/help/android.html)
+- `launch_avd_snapshot_filepath` - plugin might (if you set it) delete and re-create AVD before test start. That means all your permissions and settings will be lost on each emulator run. If you want to apply qemu image with saved AVD state you can put path to it in this field. It will be applied by using "-wipe-data -initdata <path to your file>"
+- `launch_avd_launch_binary_name` - depending on your CPU architecture you need to choose binary file which should launch your AVD (e.g. "emulator", "emulator64-arm")
+- `launch_avd_port` - port on which you wish your AVD should be launched, if you leave this field empty it will be assigned automatically
+- `launch_avd_additional_options` - if you need more customization add your parameters here (e.g. "-gpu on -no-boot-anim -no-window", https://developer.android.com/studio/run/emulator-commandline.html)
+
+Note:
+- parameter `--path` is not supported, if you want to change directory to where your AVD are created edit your env variable ANDROID_SDK_HOME. Which is set to `~/.android/avd` by default.
+
+Hints:
+- <b> After change from `android` bin to `avdmanager` bin, default settings of AVD created from terminal has changed. No resolution is set. We highly recommend to use config.ini files which you can set to `create_avd_hardware_config_filepath` or specify resolution in `create_avd_additional_options`. </b>
+- all fields need to be present in JSON, if you don't need any of the parameters just leave it empty
+- pick even ports for your AVDs
+- if you can't launch more than 2 AVDs be sure to check how much memory is your HAXM allowed to use (by default it is 2GB and that will allow you to launch around 2 AVDs) If you face any problems with freezing AVDs then be sure to reinstall your HAXM and allow it to use more of RAM (https://software.intel.com/en-us/android/articles/intel-hardware-accelerated-execution-manager)
+- make sure you have all targets/abis installed on your PC if you want to use them (type in terminal: `android list targets`)
+- we recommend adding `-gpu on` to your launching options for each device, it helps when working with many AVDs
+
+Example:
+
+[Example of complete JSON file can be found here.](fastlane/examples/AVD_setup.json)
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://github.com/fastlane/fastlane/blob/master/fastlane/docs/PluginsTroubleshooting.md) doc in the main `fastlane` repo.
+
+## Using `fastlane` Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Plugins.md).
+
+## About `fastlane`
+
+`fastlane` is the easiest way to automate building and releasing your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).
+

data/lib/fastlane/plugin/automated_test_emulator_run/actions/automated_test_emulator_run_action.rb

@@ -0,0 +1,518 @@
+require 'open3'
+require 'json'
+
+module Fastlane
+  module Actions
+
+      class AutomatedTestEmulatorRunAction < Action
+        def self.run(params)
+          UI.message("The automated_test_emulator_run plugin is working!")
+
+          # Parse JSON with AVD launch confing to array of AVD_scheme objects
+          avd_schemes = Provider::AvdSchemeProvider.get_avd_schemes(params)
+
+          # ADB, AVD helper classes
+          adb_controller = Factory::AdbControllerFactory.get_adb_controller(params)
+          avd_controllers = []
+
+          # Create AVD_Controller class for each AVD_scheme
+          for i in 0...avd_schemes.length 
+            avd_controller = Factory::AvdControllerFactory.get_avd_controller(params, avd_schemes[i])
+            avd_controllers << avd_controller
+
+            if params[:verbose] 
+              # Checking for output files
+              if File.exists?(avd_controller.output_file.path) 
+                UI.message([
+                  "Successfully created tmp output file for AVD:", 
+                  avd_schemes[i].avd_name + ".", 
+                  "File: " + avd_controller.output_file.path].join(" ").green)
+              else
+                UI.message([
+                  "Unable to create output file for AVD:", 
+                  avd_schemes[i].avd_name + ".", 
+                  "Output will be delegated to null and lost. Check your save/read permissions."].join(" ").red)
+              end
+            end
+          end
+
+          # Reseting wait states
+          all_avd_launched = false
+          adb_launch_complete = false 
+          param_launch_complete = false
+
+          while(!all_avd_launched)
+            # Preparation
+            UI.message("Configuring environment in order to launch emulators: ".yellow)
+            UI.message("Getting avaliable AVDs".yellow)
+            devices = Action.sh(adb_controller.command_get_avds)
+           
+            for i in 0...avd_schemes.length           
+              unless devices.match(avd_schemes[i].avd_name).nil?
+                UI.message(["AVD with name '", avd_schemes[i].avd_name, "' currently exists."].join("").yellow)
+                if params[:AVD_recreate_new]
+                  # Delete existing AVDs
+                  UI.message("AVD_create_new parameter set to true.".yellow)
+                  UI.message(["Deleting existing AVD with name:", avd_schemes[i].avd_name].join(" ").yellow)
+                  Action.sh(avd_controllers[i].command_delete_avd)
+                 
+                  # Re-create AVD
+                  UI.message(["Re-creating new AVD."].join(" ").yellow)
+                  Action.sh(avd_controllers[i].command_create_avd)
+                else 
+                  # Use existing AVD
+                  UI.message("AVD_recreate_new parameter set to false.".yellow)
+                  UI.message("Using existing AVD for tests.".yellow)
+                end
+              else 
+                # Create AVD
+                UI.message(["AVD with name '", avd_schemes[i].avd_name, "' does not exist. Creating new AVD."].join("").yellow)
+                Action.sh(avd_controllers[i].command_create_avd)
+              end
+            end
+
+            # Restart ADB
+            if params[:ADB_restart]
+              UI.message("Restarting adb".yellow)
+              Action.sh(adb_controller.command_stop)
+              Action.sh(adb_controller.command_start)
+            else
+              UI.message("ADB won't be restarted. 'ADB_restart' set to false.".yellow)
+            end
+
+            # Applying custom configs (it's not done directly after create because 'cat' operation seems to fail overwrite)
+            for i in 0...avd_schemes.length
+              UI.message(["Attemting to apply custom config to ", avd_schemes[i].avd_name].join("").yellow)
+              if avd_controllers[i].command_apply_config_avd.eql? "" 
+                 UI.message(["No config file found for AVD '", avd_schemes[i].avd_name, "'. AVD won't have config.ini applied."].join("").yellow)
+              else
+                UI.message(["Config file found! Applying custom config to: ", avd_schemes[i].avd_name].join("").yellow)
+                Action.sh(avd_controllers[i].command_apply_config_avd)
+              end
+            end
+
+            # Launching AVDs
+            UI.message("Launching all AVDs at the same time.".yellow)
+            for i in 0...avd_controllers.length
+              Process.fork do
+                Action.sh(avd_controllers[i].command_start_avd)
+              end
+            end
+
+            # Wait for AVDs finish booting
+            UI.message("Waiting for AVDs to finish booting.".yellow)
+            UI.message("Performing wait for ADB boot".yellow)
+            adb_launch_complete = wait_for_emulator_boot_by_adb(adb_controller, avd_schemes, "#{params[:AVD_adb_launch_timeout]}")
+
+            # Wait for AVD params finish booting
+            if adb_launch_complete
+              UI.message("Wait for ADB boot completed with success".yellow)
+
+              if (params[:AVD_wait_for_bootcomplete] || params[:AVD_wait_for_boot_completed] || params[:AVD_wait_for_bootanim])
+                message = "Performing wait for params: "
+                
+                if params[:AVD_wait_for_bootcomplete]
+                  message += "'dev.bootcomplete', "
+                end
+               
+                if params[:AVD_wait_for_boot_completed]
+                  message += "'sys.boot_completed', "
+                end
+               
+                if params[:AVD_wait_for_bootanim]
+                  message += "'init.svc.bootanim', "
+                end
+               
+                message = message[0...-2] + "."
+                UI.message(message.yellow)
+
+                param_launch_complete = wait_for_emulator_boot_by_params(params, adb_controller, avd_controllers, avd_schemes, "#{params[:AVD_param_launch_timeout]}")
+              else
+                UI.message("Wait for AVD launch params was turned off. Skipping...".yellow)
+                param_launch_complete = true
+              end
+            else 
+              UI.message("Wait for ADB boot failed".yellow)
+            end
+
+            all_avd_launched = adb_launch_complete && param_launch_complete
+
+            # Deciding if AVD launch should be restarted
+            devices_output = Action.sh(adb_controller.command_get_devices)
+
+            devices = ""
+            devices_output.each_line do |line|
+              if line.include?("emulator-")
+                devices += line.sub(/\t/, " ")  
+              end
+            end
+            
+            if all_avd_launched
+              UI.message("AVDs Booted!".green)
+              if params[:logcat]
+                for i in 0...avd_schemes.length
+                  device = ["emulator-", avd_schemes[i].launch_avd_port].join('')
+                  cmd = [adb_controller.adb_path, '-s', device, 'logcat -c'].join(' ')
+                  Action.sh(cmd) unless devices.match(device).nil?
+                end
+              end
+            else
+              for i in 0...avd_schemes.length
+                if params[:verbose] 
+                  # Display AVD output
+                  if (File.exists?(avd_controllers[i].output_file.path))
+                    UI.message(["Displaying log for AVD:", avd_schemes[i].avd_name].join(" ").red)
+                    UI.message(avd_controllers[i].output_file.read.blue)
+                  end
+                end
+                
+                # Killing devices
+                unless devices.match(["emulator-", avd_schemes[i].launch_avd_port].join("")).nil?
+                  Action.sh(avd_controllers[i].command_kill_device)
+                end
+              end
+            end
+          end
+
+          # Launching tests
+          shell_task = "#{params[:shell_task]}" unless params[:shell_task].nil?
+          gradle_task = "#{params[:gradle_task]}" unless params[:gradle_task].nil?
+          lane_task = params[:lane] unless params[:lane].nil?
+
+          UI.message("Starting tests".green)
+          begin
+            unless lane_task.nil?
+              UI.message("Using lane task.".green)
+              Fastlane::LaneManager.cruise_lane(params[:lane_platform], lane_task, params[:lane_options])
+            end
+
+            unless shell_task.nil?
+              UI.message("Using shell task.".green)
+              Action.sh(shell_task)
+            end
+
+            unless gradle_task.nil?
+              gradle = Helper::GradleHelper.new(gradle_path: Dir["./gradlew"].last)
+
+              UI.message("Using gradle task.".green)
+              gradle.trigger(task: params[:gradle_task], flags: params[:gradle_flags], serial: nil)
+            end
+          ensure 
+            # Clean up
+            for i in 0...avd_schemes.length
+              # Kill all emulators
+              device = ["emulator-", avd_schemes[i].launch_avd_port].join("")
+              unless devices.match(device).nil?
+                if params[:logcat]
+                  file = [device, '.log'].join('')
+                  cmd = [adb_controller.adb_path, '-s', device, 'logcat -d >', file].join(' ')
+                  Action.sh(cmd)
+                end
+                Action.sh(avd_controllers[i].command_kill_device)
+              end
+
+              if params[:verbose]
+                # Display AVD output
+                if (File.exists?(avd_controllers[i].output_file.path))
+                  UI.message("Displaying log from AVD to console:".green)
+                  UI.message(avd_controllers[i].output_file.read.blue)
+
+                  UI.message("Removing temp file.".green)
+                  avd_controllers[i].output_file.close
+                  avd_controllers[i].output_file.unlink
+                end
+              end
+
+              # Delete AVDs
+              if params[:AVD_clean_after]
+                UI.message("AVD_clean_after param set to true. Deleting AVDs.".green)
+                Action.sh(avd_controllers[i].command_delete_avd)
+              else
+                UI.message("AVD_clean_after param set to false. Created AVDs won't be deleted.".green)
+              end
+            end
+          end
+        end
+
+        def self.wait_for_emulator_boot_by_adb(adb_controller, avd_schemes, timeout)
+          timeoutInSeconds= timeout.to_i
+          interval = 1000 * 10
+          startTime = Time.now
+          lastCheckTime = Time.now
+          launch_status_hash = Hash.new
+          device_visibility_hash = Hash.new
+
+          for i in 0...avd_schemes.length
+            device_name = ["emulator-", avd_schemes[i].launch_avd_port].join("")
+            launch_status_hash.store(device_name, false)
+            device_visibility_hash.store(device_name, false)
+          end
+
+          launch_status = false
+          loop do
+            currentTime = Time.now
+            if ((currentTime - lastCheckTime) * 1000) > interval 
+              lastCheckTime = currentTime
+              devices_output = Action.sh(adb_controller.command_get_devices)
+
+              devices = ""
+              devices_output.each_line do |line|
+                if line.include?("emulator-")
+                  devices += line.sub(/\t/, " ")  
+                end
+              end
+
+              # Check if device is visible
+              all_devices_visible = true
+              device_visibility_hash.each do |name, is_visible|
+                unless (devices.match(name).nil? || is_visible)
+                  device_visibility_hash[name] = true
+                end
+                  all_devices_visible = false unless is_visible
+              end
+
+              # Check if device is booted
+              all_devices_booted = true
+              launch_status_hash.each do |name, is_booted|
+                unless (devices.match(name + " device").nil? || is_booted)
+                  launch_status_hash[name] = true
+                end
+                all_devices_booted = false unless launch_status_hash[name]
+              end
+
+              # Quit if timeout reached
+              if ((currentTime - startTime) >= timeoutInSeconds) 
+                UI.message(["AVD ADB loading took more than ", timeout, ". Attempting to re-launch."].join("").red)
+                launch_status = false
+                break
+              end
+
+              # Quit if all devices booted
+              if (all_devices_booted && all_devices_visible)
+                launch_status = true
+                break
+              end
+            end
+          end
+          return launch_status
+        end
+
+        def self.wait_for_emulator_boot_by_params(params, adb_controller, avd_controllers, avd_schemes, timeout)
+          timeout_in_seconds= timeout.to_i
+          interval = 1000 * 10
+          all_params_launched = false
+          start_time = last_scan_ended = Time.now
+          device_boot_statuses = Hash.new
+
+          loop do
+            current_time = Time.now
+
+            # Performing single scan over each device
+            if (((current_time - last_scan_ended) * 1000) >= interval || start_time == last_scan_ended)
+              for i in 0...avd_schemes.length
+                avd_schema = avd_schemes[i]
+                avd_controller = avd_controllers[i]
+                avd_param_boot_hash = Hash.new
+                avd_param_status_hash = Hash.new
+                avd_booted = false
+                
+                # Retreiving device parameters according to config
+                if params[:AVD_wait_for_bootcomplete]
+                  dev_bootcomplete, _stdeerr, _status = Open3.capture3([avd_controller.command_get_property, "dev.bootcomplete"].join(" "))
+                  avd_param_boot_hash.store("dev.bootcomplete", dev_bootcomplete.strip.eql?("1"))
+                  avd_param_status_hash.store("dev.bootcomplete", dev_bootcomplete)
+                end
+
+                if params[:AVD_wait_for_boot_completed] 
+                   sys_boot_completed, _stdeerr, _status = Open3.capture3([avd_controller.command_get_property, "sys.boot_completed"].join(" "))
+                   avd_param_boot_hash.store("sys.boot_completed", sys_boot_completed.strip.eql?("1"))
+                   avd_param_status_hash.store("sys.boot_completed", sys_boot_completed)
+                end
+
+                if params[:AVD_wait_for_bootanim]
+                   bootanim, _stdeerr, _status = Open3.capture3([avd_controller.command_get_property, "init.svc.bootanim"].join(" ")) 
+                   avd_param_boot_hash.store("init.svc.bootanim", bootanim.strip.eql?("stopped"))
+                   avd_param_status_hash.store("init.svc.bootanim", bootanim)
+                end
+                
+                # Checking for param statuses
+                avd_param_boot_hash.each do |name, is_booted|
+                  if !is_booted
+                    break
+                  end
+                  avd_booted = true
+                end
+                device_boot_statuses.store(avd_schema.avd_name, avd_booted)
+
+                # Plotting current wait results
+                device_log = "Device 'emulator-" + avd_schemes[i].launch_avd_port.to_s + "' launch status:"
+                UI.message(device_log.magenta)
+                avd_param_boot_hash.each do |name, is_booted|
+                  device_log = "'" + name + "' - '" + avd_param_status_hash[name].strip + "' (launched: " + is_booted.to_s + ")"
+                  UI.message(device_log.magenta)
+                end
+              end
+              last_scan_ended = Time.now
+            end
+         
+            # Checking if wait doesn't last too long
+            if (current_time - start_time) >= timeout_in_seconds
+              UI.message(["AVD param loading took more than ", timeout, ". Attempting to re-launch."].join("").red)
+              all_params_launched = false
+              break
+            end
+
+            # Finishing wait with success if all params are loaded for every device
+            device_boot_statuses.each do |name, is_booted|
+              if !is_booted
+                break
+              end
+              all_params_launched = true
+            end
+            if all_params_launched 
+              break
+            end
+          end 
+          return all_params_launched
+        end
+       
+        def self.available_options
+        [
+          #paths
+          FastlaneCore::ConfigItem.new(key: :AVD_path,
+                                       env_name: "AVD_PATH",
+                                       description: "The path to your android AVD directory (root). ANDROID_SDK_HOME by default",
+                                       default_value: (ENV['ANDROID_SDK_HOME'].nil? or ENV['ANDROID_SDK_HOME'].eql?("")) ? "~/.android/avd" : ENV['ANDROID_SDK_HOME'],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_setup_path,
+                                       env_name: "AVD_SETUP_PATH",
+                                       description: "Location to AVD_setup.json file which contains info about how many AVD should be launched and their configs",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :SDK_path,
+                                       env_name: "SDK_PATH",
+                                       description: "The path to your android sdk directory (root). ANDROID_SDK_HOME by default",
+                                       default_value: ENV['ANDROID_SDK_HOME'] || ENV['ANDROID_HOME'],
+                                       is_string: true,
+                                       optional: true),
+
+
+          #launch config params
+          FastlaneCore::ConfigItem.new(key: :AVD_param_launch_timeout,
+                                       env_name: "AVD_PARAM_LAUNCH_TIMEOUT",
+                                       description: "Timeout in seconds. Even though ADB might find all devices you still might want to wait for animations to finish and system to boot. Default 60 seconds",
+                                       default_value: 60,
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_adb_launch_timeout,
+                                       env_name: "AVD_ADB_LAUNCH_TIMEOUT",
+                                       description: "Timeout in seconds. Wait until ADB finds all devices specified in config and sets their value to 'device'. Default 240 seconds",
+                                       default_value: 240,
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_recreate_new,
+                                       env_name: "AVD_RECREATE_NEW",
+                                       description: "Allow to decide if AVDs from AVD_setup.json (in case they already exist) should be deleted and created from scratch",
+                                       default_value: true,
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_clean_after,
+                                       env_name: "AVD_CLEAN_AFTER",
+                                       description: "Allow to decide if AVDs should be deleted from PC after test session ends",
+                                       default_value: true,
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :ADB_restart,
+                                       env_name: "ADB_RESTART",
+                                       description: "Allows to switch adb restarting on/off",
+                                       default_value: true,
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_wait_for_bootcomplete,
+                                       env_name: "AVD_BOOTCOMPLETE_WAIT",
+                                       description: "Allows to switch wait for 'dev.bootcomplete' AVD launch param on/off",
+                                       default_value: true,
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_wait_for_boot_completed,
+                                       env_name: "AVD_BOOT_COMPLETED_WAIT",
+                                       description: "Allows to switch wait for 'sys.boot_completed' AVD launch param on/off",
+                                       default_value: true,
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_wait_for_bootanim,
+                                       env_name: "ABD_BOOTANIM_WAIT",
+                                       description: "Allows to switch wait for 'init.svc.bootanim' AVD launch param on/off",
+                                       default_value: true,
+                                       is_string: false,
+                                       optional: true),
+          
+          #launch commands
+          FastlaneCore::ConfigItem.new(key: :shell_task,
+                                       env_name: "SHELL_TASK",
+                                       description: "The shell command you want to execute",
+                                       conflicting_options: [:gradle_task, :lane], 
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :gradle_task,
+                                       env_name: "GRADLE_TASK",
+                                       description: "The gradle task you want to execute",
+                                       conflicting_options: [:shell_command, :lane],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :gradle_flags,
+                                       env_name: "GRADLE_FLAGS",
+                                       description: "All parameter flags you want to pass to the gradle command, e.g. `--exitcode --xml file.xml`",
+                                       conflicting_options: [:shell_command, :lane],
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :lane,
+                                       env_name: "LANE",
+                                       description: "The lane you want to execute",
+                                       conflicting_options: [:shell_command, :gradle_task],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :lane_platform,
+                                       env_name: "LANE_PLATFORM",
+                                       description: "The platform of the lane you want to execute",
+                                       conflicting_options: [:shell_command, :gradle_task],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :lane_options,
+                                       env_name: "LANE_OPTIONS",
+                                       description: "The options of the lane you want to execute",
+                                       conflicting_options: [:shell_command, :gradle_task],
+                                       is_string: false,
+                                       optional: true),
+
+          #mode
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "AVD_VERBOSE",
+                                       description: "Allows to turn on/off mode verbose which displays output of AVDs",
+                                       default_value: false,
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :logcat,
+                                       env_name: "ADB_LOGCAT",
+                                       description: "Allows to turn logcat on/off so you can debug crashes and such",
+                                       default_value: false,
+                                       is_string: false,
+                                       optional: true),
+        ]
+        end
+
+        def self.description
+            "Starts AVD, based on AVD_setup.json file, before test launch and kills it after testing is done."
+        end
+
+        def self.authors
+            ["F1sherKK"]
+        end
+
+        def self.is_supported?(platform)
+            platform == :android
+        end
+      end
+  end
+end

data/lib/fastlane/plugin/automated_test_emulator_run/factory/adb_controller_factory.rb

@@ -0,0 +1,62 @@
+module Fastlane
+  module Factory
+
+    class ADB_Controller
+      attr_accessor :command_stop,
+                    :command_start,
+                    :command_get_devices,
+                    :command_wait_for_device,
+                    :command_get_avds,
+                    :adb_path
+    end
+
+    class AdbControllerFactory
+  
+        def self.get_adb_controller(params)
+          UI.message(["Preparing commands for Android ADB"].join(" ").yellow)
+
+          # Get paths
+          sdk_helper = Helper::SdkHelper.new(params)
+          path_avdmanager_binary = sdk_helper.avd_manager
+          path_adb = sdk_helper.adb
+
+          # ADB shell command parts
+          sh_stop_adb = "kill-server"
+          sh_start_adb = "start-server"
+          sh_devices_adb = "devices"
+          sh_wait_for_device_adb = "wait-for-device"
+          sh_list_avd_adb = "list avd"
+
+          # Assemble ADB controller
+          adb_controller = ADB_Controller.new
+          adb_controller.command_stop = [
+           path_adb,
+           sh_stop_adb
+           ].join(" ")
+  
+          adb_controller.command_start = [
+           path_adb,
+           sh_start_adb
+           ].join(" ")
+  
+          adb_controller.command_get_devices = [
+           path_adb,
+           sh_devices_adb
+           ].join(" ")
+  
+          adb_controller.command_wait_for_device = [
+           path_adb,
+           sh_wait_for_device_adb
+           ].join(" ")
+
+          adb_controller.adb_path = path_adb
+
+          adb_controller.command_get_avds = [
+           path_avdmanager_binary, 
+           sh_list_avd_adb].join(" ").chomp
+  
+          return adb_controller
+        end 
+    end
+  end
+end

data/lib/fastlane/plugin/automated_test_emulator_run/factory/avd_controller_factory.rb

@@ -0,0 +1,129 @@
+require 'tempfile'
+
+module Fastlane
+  module Factory
+
+    class AVD_Controller
+        attr_accessor :command_create_avd, :command_start_avd, :command_delete_avd, :command_apply_config_avd, :command_get_property, :command_kill_device,
+                      :output_file
+
+        def self.create_output_file(params)
+          output_file = Tempfile.new('emulator_output', '#{params[:AVD_path]}')
+        end
+    end
+
+    class AvdControllerFactory
+  
+        def self.get_avd_controller(params, avd_scheme)
+          UI.message(["Preparing parameters and commands for emulator:", avd_scheme.avd_name].join(" ").yellow)
+
+          # Get paths
+          sdk_helper = Helper::SdkHelper.new(params)
+          path_avdmanager_binary = sdk_helper.avd_manager
+          path_adb = sdk_helper.adb
+          path_avd = "#{params[:AVD_path]}"
+
+          # Create AVD shell command parts
+          sh_create_answer_no = "echo \"no\" |"
+          sh_create_avd = "create avd"
+          sh_create_avd_name = ["--name \"", avd_scheme.avd_name, "\""].join("")
+          sh_create_avd_package = ["--package \"", avd_scheme.create_avd_package, "\""].join("")
+
+          if avd_scheme.create_avd_device.eql? "" 
+            sh_create_avd_device = ""
+          else
+            sh_create_avd_device = ["--device \"", avd_scheme.create_avd_device, "\""].join("")
+          end
+
+          if avd_scheme.create_avd_abi.eql? "" 
+            sh_create_avd_abi = ""
+          else
+            sh_create_avd_abi = ["--abi ", avd_scheme.create_avd_abi].join("")
+          end
+
+          if avd_scheme.create_avd_tag.eql? "" 
+            sh_create_avd_tag = ""
+          else
+            sh_create_avd_tag = ["--tag ", avd_scheme.create_avd_tag].join("")
+          end
+
+          sh_create_avd_additional_options = avd_scheme.create_avd_additional_options
+          sh_create_config_loc = "#{path_avd}/#{avd_scheme.avd_name}.avd/config.ini"
+          
+          # Launch AVD shell command parts
+          sh_launch_emulator_binary = [sdk_helper.emulator_dir, avd_scheme.launch_avd_launch_binary_name].join("")
+          sh_launch_avd_name = ["-avd ", avd_scheme.avd_name].join("")
+          sh_launch_avd_additional_options = avd_scheme.launch_avd_additional_options
+          sh_launch_avd_port = ["-port", avd_scheme.launch_avd_port].join(" ") 
+          
+          if avd_scheme.launch_avd_snapshot_filepath.eql? ""
+             sh_launch_avd_snapshot = ""
+          else
+             sh_launch_avd_snapshot = ["-wipe-data -initdata ", avd_scheme.launch_avd_snapshot_filepath].join("")
+          end   
+
+          # Re-create AVD shell command parts
+          sh_delete_avd = ["delete avd -n ", avd_scheme.avd_name].join("")
+
+          # ADB related shell command parts
+          sh_specific_device = "-s"
+          sh_device_name_adb = ["emulator-", avd_scheme.launch_avd_port].join("")
+          sh_get_property = "shell getprop"
+          sh_kill_device = "emu kill"
+
+          # Assemble AVD controller
+          avd_controller = AVD_Controller.new
+          avd_controller.command_create_avd = [
+            sh_create_answer_no, 
+            path_avdmanager_binary,
+            sh_create_avd,
+            sh_create_avd_name,
+            sh_create_avd_package,
+            sh_create_avd_device,
+            sh_create_avd_tag,
+            sh_create_avd_abi,
+            sh_create_avd_additional_options].join(" ")
+
+          avd_controller.output_file = Tempfile.new('emulator_output')
+          avd_output = File.exists?(avd_controller.output_file) ? ["&>", avd_controller.output_file.path, "&"].join("") : "&>/dev/null &"
+          
+          avd_controller.command_start_avd = [
+           sh_launch_emulator_binary, 
+           sh_launch_avd_port, 
+           sh_launch_avd_name, 
+           sh_launch_avd_snapshot, 
+           sh_launch_avd_additional_options, 
+           avd_output].join(" ")
+
+          avd_controller.command_delete_avd = [
+           path_avdmanager_binary,
+           sh_delete_avd].join(" ")
+
+          if path_avd.nil? || (avd_scheme.create_avd_hardware_config_filepath.eql? "")
+            avd_controller.command_apply_config_avd = ""
+          else
+            avd_controller.command_apply_config_avd = [
+              "cat",
+              avd_scheme.create_avd_hardware_config_filepath,
+              ">",
+              sh_create_config_loc].join(" ")
+          end
+          
+          avd_controller.command_get_property = [
+           path_adb,
+           sh_specific_device,
+           sh_device_name_adb,
+           sh_get_property].join(" ")
+
+          avd_controller.command_kill_device = [
+           path_adb,
+           sh_specific_device,
+           sh_device_name_adb,
+           sh_kill_device,
+           "&>/dev/null"].join(" ")
+
+          return avd_controller
+        end 
+    end
+  end
+end

data/lib/fastlane/plugin/automated_test_emulator_run/helper/sdk_tools_helper.rb

@@ -0,0 +1,35 @@
+module Fastlane
+  module Helper
+    class SdkHelper
+      def initialize(params)
+        @sdk_root_path = params[:SDK_path]
+      end
+
+      def command_line_tools_dir
+        return "#{@sdk_root_path}/cmdline-tools/latest/bin" if File.exist?("#{@sdk_root_path}/cmdline-tools/latest/bin")
+
+        return tools_dir # Fallback on old tools path
+      end
+
+      def tools_dir
+        return "#{@sdk_root_path}/tools/bin"
+      end
+
+      def platform_tools_dir
+        return "#{@sdk_root_path}/platform-tools"
+      end
+
+      def emulator_dir
+        return "#{@sdk_root_path}/emulator/"
+      end
+
+      def adb
+        return "#{platform_tools_dir}/adb"
+      end
+
+      def avd_manager
+        return "#{command_line_tools_dir}/avdmanager"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/automated_test_emulator_run/provider/avd_setup_provider.rb

@@ -0,0 +1,172 @@
+module Fastlane
+  module Provider
+
+    class AVD_scheme
+      attr_accessor :avd_name, :create_avd_package, :create_avd_device, :create_avd_tag, :create_avd_abi, :create_avd_hardware_config_filepath, :create_avd_additional_options, 
+                    :launch_avd_port, :launch_avd_launch_binary_name, :launch_avd_additional_options, :launch_avd_snapshot_filepath
+    end
+
+    class AvdSchemeProvider
+      
+        def self.get_avd_schemes(params)
+        
+          # Read JSON into string variable
+          avd_setup_json = read_avd_setup(params)
+          if avd_setup_json.nil? 
+            throw_error("Unable to read AVD_setup.json. Check JSON file structure or file path.")
+          end
+
+          # Read JSON into Hash
+          avd_setup = JSON.parse(avd_setup_json)
+          avd_hash_list = avd_setup['avd_list']
+
+          # Create AVD_scheme objects and fill them with data
+          avd_scheme_list = []
+          for i in 0...avd_hash_list.length
+            avd_hash = avd_hash_list[i]
+
+            avd_scheme = AVD_scheme.new
+            avd_scheme.avd_name = avd_hash['avd_name']
+
+            avd_scheme.create_avd_package = avd_hash['create_avd_package']
+            avd_scheme.create_avd_device = avd_hash['create_avd_device']
+            avd_scheme.create_avd_tag = avd_hash['create_avd_tag']
+            avd_scheme.create_avd_abi = avd_hash['create_avd_abi']
+            avd_scheme.create_avd_hardware_config_filepath = avd_hash['create_avd_hardware_config_filepath']
+
+            avd_scheme.launch_avd_port = avd_hash['launch_avd_port']
+            avd_scheme.launch_avd_launch_binary_name = avd_hash['launch_avd_launch_binary_name']
+            avd_scheme.launch_avd_additional_options = avd_hash['launch_avd_additional_options']
+            avd_scheme.launch_avd_snapshot_filepath = avd_hash['launch_avd_snapshot_filepath']
+
+            errors = check_avd_fields(avd_scheme)
+            unless errors.empty?
+              error_log = "Error! Fields not found in JSON: \n"
+              errors.each { |error| error_log += error + "\n" }
+              throw_error(error_log)
+            end
+
+            avd_scheme_list << avd_scheme
+          end
+          
+          # Prepare list of open ports for AVD_schemes without ports set in JSON
+          avaliable_ports = get_unused_even_tcp_ports(5556, 5586, avd_scheme_list)
+
+          # Fill empty AVD_schemes with open ports
+          for i in 0...avd_scheme_list.length
+            avd_scheme = avd_scheme_list[i]
+            if avd_scheme.launch_avd_port.eql? ""
+              avd_scheme.launch_avd_port = avaliable_ports[0]
+              avaliable_ports.delete(avaliable_ports[0])
+            end
+          end
+
+          return avd_scheme_list
+        end 
+
+        def self.get_unused_even_tcp_ports(min_port, max_port, avd_scheme_list) 
+          if min_port % 2 != 0
+            min_port += 1
+          end
+
+          if max_port % 2 != 0
+            max_port += 1
+          end
+
+          avaliable_ports = []
+          reserved_ports = []
+
+          # Gather ports requested in JSON config
+          for i in 0...avd_scheme_list.length
+            avd_scheme = avd_scheme_list[i]
+            unless avd_scheme.launch_avd_port.eql? ""
+              reserved_ports << avd_scheme.launch_avd_port
+            end
+          end
+
+          # Find next open port which wasn't reserved in JSON config
+          port = min_port
+          for i in 0...avd_scheme_list.length
+            
+            while port < max_port  do
+              if !system("lsof -i:#{port}", out: '/dev/null')
+
+                is_port_reserved = false
+                for j in 0...reserved_ports.length 
+                  if reserved_ports[j].eql?(port.to_s)
+                    is_port_reserved = true
+                    break
+                  end
+                end
+
+                if is_port_reserved
+                  port = port + 2
+                  break
+                end
+
+                avaliable_ports << port
+                port = port + 2
+                break
+              else 
+                port = port + 2
+              end
+            end
+          end
+
+          return avaliable_ports
+        end
+
+        def self.read_avd_setup(params)
+          if File.exists?(File.expand_path("#{params[:AVD_setup_path]}"))
+            file = File.open(File.expand_path("#{params[:AVD_setup_path]}"), "rb")
+            json = file.read
+            file.close
+            return json
+          else
+            return nil
+          end
+        end
+
+        def self.check_avd_fields(avd_scheme)
+          errors = []
+            
+          if avd_scheme.avd_name.nil? 
+              errors.push("avd_name not found")
+          end
+          if avd_scheme.create_avd_package.nil? 
+              errors.push("create_avd_package not found")
+          end
+          if avd_scheme.create_avd_device.nil? 
+              errors.push("create_avd_device not found")
+          end
+          if avd_scheme.create_avd_tag.nil? 
+              errors.push("create_avd_tag not found")
+          end
+          if avd_scheme.create_avd_abi.nil? 
+              errors.push("create_avd_abi not found")
+          end
+          if avd_scheme.create_avd_hardware_config_filepath.nil? 
+              errors.push("create_avd_hardware_config_filepath not found")
+          end
+          if avd_scheme.launch_avd_snapshot_filepath.nil? 
+              errors.push("launch_avd_snapshot_filepath not found")
+          end
+          if avd_scheme.launch_avd_launch_binary_name.nil?
+            errors.push("launch_avd_launch_binary_name not found")
+          end
+          if avd_scheme.launch_avd_port.nil? 
+              errors.push("launch_avd_port not found")
+          end
+          if avd_scheme.launch_avd_additional_options.nil? 
+              errors.push("launch_avd_additional_options not found")
+          end
+          return errors
+        end
+
+        def self.throw_error(message) 
+          UI.message("Error: ".red + message.red)
+          raise Exception, "Lane was stopped by plugin"
+        end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module AutomatedTestEmulatorRun
+    VERSION = "1.0.1"
+  end
+end

data/lib/fastlane/plugin/automated_test_emulator_run_next.rb

@@ -0,0 +1,15 @@
+require 'fastlane/plugin/automated_test_emulator_run/version'
+
+module Fastlane
+  module AutomatedTestEmulatorRunNext
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,factory,provider,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+Fastlane::AutomatedTestEmulatorRunNext.all_classes.each do |current|
+  require current
+end
+
+

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-automated_test_emulator_run_next
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Hiroto Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.98.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.98.0
+description: 
+email: hiroto.nakamura95@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/automated_test_emulator_run/actions/automated_test_emulator_run_action.rb
+- lib/fastlane/plugin/automated_test_emulator_run/factory/adb_controller_factory.rb
+- lib/fastlane/plugin/automated_test_emulator_run/factory/avd_controller_factory.rb
+- lib/fastlane/plugin/automated_test_emulator_run/helper/sdk_tools_helper.rb
+- lib/fastlane/plugin/automated_test_emulator_run/provider/avd_setup_provider.rb
+- lib/fastlane/plugin/automated_test_emulator_run/version.rb
+- lib/fastlane/plugin/automated_test_emulator_run_next.rb
+homepage: https://github.com/Hiroto-N/fastlane-plugin-automated-test-emulator-run
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Starts multiple AVDs based on JSON file config. AVDs are created and configured
+  according to user liking before instrumentation test process (started either via
+  shell command or gradle) and killed/deleted after test process finishes.
+test_files: []