fastlane-plugin-automated_test_emulator_run 0.5.16 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d20910735d239a742e4b85f5b1aca3ad68a30db4
-  data.tar.gz: b938c98f800c87dbe949e4f2d7faccd4f4259de1
+  metadata.gz: 5719e5040624f349907cc2c01d6c7030c3827d01
+  data.tar.gz: 061d66711e351773c997e350f7c3b53c7326a0bc
 SHA512:
-  metadata.gz: 604fd356c0bcd108a04d4efb2a8f5dcd1e299a409be537d032a1a227ae13e8f726d54a0a1998342eeb7d5f1be123a26d5b40f1cdecadea45f8b15142e12c6f25
-  data.tar.gz: 7b82e7698f12687e787deef708c3f0b62bfeae22d08b26b853ac89e70db323e5702a6f1ffe591e32a9ec54928ba7a8feee0d6a65b1e4dbbdfb9da4067d2d6995
+  metadata.gz: 115cbc0163872401a1c40a69d2a1d17a8b96f5c9933cfee62015a4d3c9cb1273cb8ac4bf6f45115b0d0a546d99b87d72d0428de98021c1fa81a4e91df177a17c
+  data.tar.gz: a7fb87f8726d0abd1ff80deb01403227894953eee782efd78e64ed4ee38d0c89933f69c7f9fa04b53d394e643837204dea70ede1e5c6b6c543676b9d75a76382

data/README.md

@@ -2,39 +2,77 @@
 
 [![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)
 
-## Getting Started
+## About automated_test_emulator_run
 
-This project is a [fastlane](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-automated_test_emulator_run`, add it to your project by running:
+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.
 
-```bash
-fastlane add_plugin automated_test_emulator_run
-```
+## Getting Started
 
-## About automated_test_emulator_run
+This project is a [fastlane](https://github.com/fastlane/fastlane) plugin.
 
-Allows to wrap gradle task or shell command that runs integrated tests that prepare and starts single AVD before test run. After tests are finished, emulator is killed and deleted.
+1. To get started with `fastlane-plugin-automated_test_emulator_run`, add it to your project by running:
 
-**Note to author:** Add a more detailed description about this plugin here. If your plugin contains multiple actions, make sure to mention them here.
+  ```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.
 
-## Example
+3. Wrap your test launch command with plugin and provide link to \*.JSON config.
 
-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`. 
+## Example of Fastfile
 
-**Note to author:** Please set up a sample project to make it easy for users to explore what your plugin does. Provide everything that is necessary to try out the plugin in this project (including a sample Xcode/Android project if necessary)
+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`.
 
-## Run tests for this plugin
+## JSON config
 
-To run both the tests, and code style validation, run
+What is JSON config?
 
-```
-rake
-```
+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.
 
-To automatically fix many of the styling issues, use 
+JSON file scheme:
 ```
-rubocop -a
+{
+    "avd_list":
+    [
+        {
+          "avd_name": "",  
+
+          "create_avd_target": "",
+          "create_avd_abi": "",
+          "create_avd_hardware_config_filepath": "",
+          "create_avd_additional_options": "",  
+
+          "launch_avd_snapshot_filepath": "",
+          "launch_avd_launch_binary_name": "",
+          "launch_avd_port": "",
+          "launch_avd_additional_options": ""
+        }
+    ]
+}
 ```
 
+Parameters:
+- `avd_name` - name of your AVD, avoid using spaces, this file is necessary
+- `create_avd_target` - Android target api level (https://developer.android.com/guide/topics/manifest/uses-sdk-element.html)
+- `create_avd_abi` - CPU architecture used by AVD (https://developer.android.com/ndk/guides/abis.html)
+- `create_avd_hardware_config_filepath` - path to config.ini file containing custom config for your AVD device. 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 will 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", "emulator64-x86")
+- `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)
+
+Hints:
+
+- 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`)
+
+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.

data/lib/fastlane/plugin/automated_test_emulator_run.rb

@@ -2,15 +2,14 @@ require 'fastlane/plugin/automated_test_emulator_run/version'
 
 module Fastlane
   module AutomatedTestEmulatorRun
-    # Return all .rb files inside the "actions" and "helper" directory
     def self.all_classes
-      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+      Dir[File.expand_path('**/{actions,factory,provider}/*.rb', File.dirname(__FILE__))]
     end
   end
 end
 
-# By default we want to import all available actions and helpers
-# A plugin can contain any number of actions and plugins
 Fastlane::AutomatedTestEmulatorRun.all_classes.each do |current|
   require current
 end
+
+

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

@@ -1,268 +1,232 @@
 require 'open3'
-require 'tempfile'
+require 'json'
 
 module Fastlane
   module Actions
-     module SharedValues
-     end
 
-    class AutomatedTestEmulatorRunAction < Action
+      class AutomatedTestEmulatorRunAction < Action
+        def self.run(params)
+          UI.message("The automated_test_emulator_run plugin is working!")
 
-      def self.run(params)
-        gradle = Helper::GradleHelper.new(gradle_path: Dir["./gradlew"].last)
+          # Parse JSON with AVD launch confing to array of AVD_scheme objects
+          avd_schemes = Provider::AvdSchemeProvider.get_avd_schemes(params)
 
-        UI.message("The automated_test_emulator_run plugin is working!")
+          # ADB, AVD helper classes
+          adb_controller = Factory::AdbControllerFactory.get_adb_controller(params)
+          avd_controllers = []
 
-        # Find unused port
-        port = getUnusedTcpPort
-        if params[:avd_port].nil? 
-          port = getUnusedTcpPort
-          UI.message(["Open port found", port].join(" ").yellow)
-        else
-          port = "#{params[:avd_port]}"
-          UI.message(["Port set by user to:", port].join(" ").yellow)
-        end
-
-        # Set up params 
-        UI.message("Preparing parameters...".yellow)
-
-          # AVD general params
-          sdkRoot = "#{params[:sdk_path]}"
-          avd_name = "--name \"#{params[:avd_name]}\""
-
-          # AVD create params
-          target_id = "--target \"#{params[:target_id]}\""
-          avd_abi = "--abi #{params[:avd_abi]}" unless params[:avd_abi].nil?
-          avd_tag = "--tag #{params[:avd_tag]}" unless params[:avd_tag].nil?
-          avd_create_options = params[:avd_create_options] unless params[:avd_create_options].nil?
-
-          # AVD start params
-          emulator_binary = "#{params[:emulator_binary]}"
-          avd_initdata = "-wipe-data -initdata #{params[:initdata_snapshot_path]}" unless params[:initdata_snapshot_path].nil?
-          avd_port = ["-port", port].join(" ")
-          avd_start_options = params[:avd_start_options] unless params[:avd_start_options].nil?
-
-        # Set up commands
-        UI.message("Setting up run commands".yellow)
-        create_avd_command = ["echo \"no\" |", sdkRoot + "/tools/android", "create avd", avd_name, target_id, avd_abi, avd_tag, avd_create_options].join(" ")
-        get_devices_command = sdkRoot + "/tools/android list avd".chomp
-        start_avd_command = [sdkRoot + "/tools/" + emulator_binary, avd_port, "-avd #{params[:avd_name]}", avd_initdata, avd_start_options, "&>/dev/null &"].join(" ")
-        shell_command = "#{params[:shell_command]}" unless params[:shell_command].nil?
-        gradle_task = "#{params[:gradle_task]}" unless params[:gradle_task].nil?
-
-        # Recreating AVD
-        UI.message("Creating AVD...".yellow)
-        createEmulator(get_devices_command, create_avd_command, params, sdkRoot)
-
-        # Starting AVD
-        UI.message("Starting AVD....".yellow)
-        launchEmulator(start_avd_command, get_devices_command, create_avd_command, sdkRoot, port, params)
-      
-        UI.message("Starting tests".green)
-        begin
-          unless shell_command.nil?
-            UI.message("Using shell command".green)
-            Action.sh(shell_command)
+          # Create AVD_Controller class for each AVD_scheme
+          for i in 0..(avd_schemes.length - 1)
+            avd_scheme = avd_schemes[i]
+            avd_controller = Factory::AvdControllerFactory.get_avd_controller(params, avd_scheme)
+            avd_controllers << avd_controller
           end
 
-          unless gradle_task.nil?
-            UI.message("Using gradle task".green)
-            gradle.trigger(task: params[:gradle_task], flags: params[:gradle_flags], serial: nil)
-          end
-        end
+          all_avd_launched = false
 
-        waitFor_emulatorStop(sdkRoot, port, params)
-      end
+          while(!all_avd_launched)
 
-      def self.getUnusedTcpPort 
-        min_port = 5556
-        max_port = 5586
+            # 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 - 1)
+              avd_scheme = avd_schemes[i]
+              avd_controller = avd_controllers[i]
+              
+              # Delete existing AVDs
+              if !devices.match(avd_scheme.avd_name).nil?
+                UI.message(["Deleting existing AVD with name:", avd_scheme.avd_name].join(" ").yellow)
+                Action.sh(avd_controller.command_delete_avd)
+              end
 
-        port = min_port
-        while port < max_port  do
-           unless system(["lsof -i:", port].join(""), out: '/dev/null')
-              break
-           end
-           port +=1
-        end
-        return port
-      end
+              # Re-create deleted AVDs
+              UI.message("Creating new AVD".yellow)
+              Action.sh(avd_controller.command_create_avd)
+            end
 
-      def self.createEmulator(get_devices_command, create_avd_command, params, sdkRoot)
-        UI.message("Getting avaliable devices".yellow)
-        devices = Action.sh(get_devices_command)
+            # Restart ADB
+            UI.message("Restarting adb".yellow)
+            Action.sh(adb_controller.command_stop)
+            Action.sh(adb_controller.command_start)
+
+            # Applying custom configs (it's not done directly after create because 'cat' operation seems to fail overwrite)
+            for i in 0..(avd_schemes.length - 1)
+              avd_scheme = avd_schemes[i]
+              avd_controller = avd_controllers[i]
+            
+              UI.message(["Attemting to apply custom config to ", avd_scheme.avd_name].join("").yellow)
+              if avd_controller.command_apply_config_avd.eql? "" 
+                 UI.message(["No config file found for AVD '", avd_scheme.avd_name, "'. AVD won't have config.ini applied."].join("").yellow)
+              else
+                UI.message(["Config file found! Applying custom config to: ", avd_scheme.avd_name].join("").yellow)
+                Action.sh(avd_controller.command_apply_config_avd)
+              end
+            end
 
-        unless devices.match(/#{params[:avd_name]}/).nil?
-           UI.message("Deleting existing AVD to create fresh one".yellow)
-           Action.sh(sdkRoot + "/tools/android delete avd -n #{params[:avd_name]}")
-        end
+            # Launching AVDs
+            UI.message("Launching all AVDs at the same time".yellow)
+            for i in 0..(avd_schemes.length - 1)
+              avd_scheme = avd_schemes[i]
+              avd_controller = avd_controllers[i]
 
-        Action.sh(create_avd_command)
-      end
+              Action.sh(avd_controller.command_start_avd)
+            end
 
-      def self.launchEmulator(start_avd_command, get_devices_command, create_avd_command, sdkRoot, port, params)
-        restart_adb(sdkRoot)
-        Action.sh(start_avd_command)
-        waitFor_emulatorBoot(start_avd_command, get_devices_command, create_avd_command, sdkRoot, port, params)
-      end
+            # Wait for AVDs finish booting
+            UI.message("Waiting for AVDs to finish booting".yellow)
+            boot_status = []
+            for i in 0..(avd_schemes.length - 1)
+              boot_status << false
+            end
 
-      def self.waitFor_emulatorBoot(start_avd_command, get_devices_command, create_avd_command, sdkRoot, port, params)
-        UI.message("Waiting for emulator to finish booting.....".yellow)
-        startParams = "#{params[:avd_start_options]}"
-
-        if startParams.include? "-no-window" 
-          Action.sh(sdkRoot + "/platform-tools/adb wait-for-device")
-          Action.sh(sdkRoot + "/platform-tools/adb devices")
-          return true
-        else
-          timeoutInSeconds= 150.0
-          startTime = Time.now
-          loop do
-            dev_bootcomplete, _stdeerr, _status = Open3.capture3(sdkRoot + ["/platform-tools/adb -s emulator-", port].join("") + " shell getprop dev.bootcomplete")
-            sys_boot_completed, _stdeerr, _status = Open3.capture3(sdkRoot + ["/platform-tools/adb -s emulator-", port].join("") + " shell getprop sys.boot_completed")
-            bootanim, _stdeerr, _status = Open3.capture3(sdkRoot + ["/platform-tools/adb -s emulator-", port].join("") + " shell getprop init.svc.bootanim")
-            currentTime = Time.now
-
-            if (currentTime - startTime) >= timeoutInSeconds
-              UI.message("Emulator loading took more than 2 minutes 30 seconds. Restarting emulator launch until.".yellow)
-              adb_devices_result = Action.sh(sdkRoot + "/platform-tools/adb devices")
-              if adb_devices_result.include? "offline"
-                kill_emulator(sdkRoot, port, params)
-
-                delayInSeconds = 20.0
-                sleep(delayInSeconds)
-
-                delete_emulator(sdkRoot, port, params)
-
-                createEmulator(get_devices_command, create_avd_command, params, sdkRoot)
-
-                launchEmulator(start_avd_command, get_devices_command, create_avd_command, sdkRoot, port, params)
+            UI.message("Performing wait for params: dev.bootcomplete, sys.boot_completed, init.svc.bootanim".yellow)
+            for i in 0..(avd_schemes.length - 1)
+              avd_controller = avd_controllers[i]
+              status = wait_for_emulator_boot(adb_controller, avd_controller)
+              
+              if (!status)
+                all_avd_launched = false
                 break
               end
-              return false
+              all_avd_launched = true
             end
 
-            if (dev_bootcomplete.strip == "1" && sys_boot_completed.strip == "1" && bootanim.strip == "stopped")
-              UI.message("Emulator Booted!".green)
-              return true
+            # Deciding if AVD launch should be restarted
+            devices = Action.sh(adb_controller.command_get_devices)
+            if all_avd_launched
+              UI.message("AVDs Booted!".green)
+            else
+              for i in 0..(avd_schemes.length - 1)
+                avd_scheme = avd_schemes[i]
+                avd_controller = avd_controllers[i]
+
+                # Kill all emulators
+                if !devices.match(["emulator-", avd_scheme.launch_avd_port].join("")).nil?
+                  Action.sh(avd_controller.command_kill_device)
+                end
+              end
             end
+
           end
-        end
-      end
 
-      def self.restart_adb(sdkRoot)
-          UI.message("Restarting adb..".green)
-          Action.sh(sdkRoot + "/platform-tools/adb kill-server")
-          Action.sh(sdkRoot + "/platform-tools/adb start-server")
-      end
+          # Launching tests
+          gradle = Helper::GradleHelper.new(gradle_path: Dir["./gradlew"].last)
 
-      def self.kill_emulator(sdkRoot, port, params)
-          UI.message("Shutting down emulator...".green)
-          Action.sh(sdkRoot + "/platform-tools/adb -s " + ["emulator-", port].join("") + " emu kill &>/dev/null")
-      end
+          shell_task = "#{params[:shell_task]}" unless params[:shell_task].nil?
+          gradle_task = "#{params[:gradle_task]}" unless params[:gradle_task].nil?
 
-      def self.delete_emulator(sdkRoot, port, params) 
-          UI.message("Deleting emulator....".green)
-          Action.sh(sdkRoot + "/tools/android delete avd -n #{params[:avd_name]}")
-      end
+          UI.message("Starting tests".green)
+          begin
+            unless shell_task.nil?
+              UI.message("Using shell task".green)
+              Action.sh(shell_task)
+            end
 
-      def self.waitFor_emulatorStop(sdkRoot, port, params)
-          kill_emulator(sdkRoot, port, params)
+            unless gradle_task.nil?
+              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 - 1)
+              avd_scheme = avd_schemes[i]
+              avd_controller = avd_controllers[i]
+
+              # Kill all emulators
+              if !devices.match(["emulator-", avd_scheme.launch_avd_port].join("")).nil?
+                Action.sh(avd_controller.command_kill_device)
+              end
 
-          delayInSeconds = 20.0
-          sleep(delayInSeconds)
+              # Delete AVDs
+              Action.sh(avd_controller.command_delete_avd)
+            end
+          end
 
-          delete_emulator(sdkRoot, port, params)
-      end
+        end
+
+        def self.wait_for_emulator_boot(adb_controller, avd_controller)
+            timeoutInSeconds= 240.0
+            startTime = Time.now
 
-      def self.available_options
+            launch_status = false
+            loop do
+              dev_bootcomplete, _stdeerr, _status = Open3.capture3([avd_controller.command_get_property, "dev.bootcomplete"].join(" ")) 
+              sys_boot_completed, _stdeerr, _status = Open3.capture3([avd_controller.command_get_property, "sys.boot_completed"].join(" ")) 
+              bootanim, _stdeerr, _status = Open3.capture3([avd_controller.command_get_property, "init.svc.bootanim"].join(" ")) 
+              currentTime = Time.now
+
+              if (currentTime - startTime) >= timeoutInSeconds
+                UI.message("AVD loading took more than 4 minutes. Restarting launch".red)
+                launch_status = false
+                break
+              end
+
+              if (dev_bootcomplete.strip == "1" && sys_boot_completed.strip == "1" && bootanim.strip == "stopped")
+                launch_status = true
+                break
+              end
+            end
+            return launch_status
+        end
+       
+        def self.available_options
         [
-          FastlaneCore::ConfigItem.new(key: :avd_name,
-                                     env_name: "AVD_NAME",
-                                     description: "Name of the avd to be created",
-                                     is_string: true,
-                                     optional: false),
-          FastlaneCore::ConfigItem.new(key: :target_id,
-                                     env_name: "TARGET_ID",
-                                     description: "Target id of the avd to be created, get list of installed target by running command 'android list targets'",
-                                     is_string: true,
-                                     optional: false),
-          FastlaneCore::ConfigItem.new(key: :avd_create_options,
-                                     env_name: "AVD_CREATE_OPTIONS",
-                                     description: "Other avd options, used during avd creation, in the form of a <option>=<value> list, i.e \"--scale 96dpi --dpi-device 160\"",
-                                     is_string: true,
-                                     optional: true),
-          FastlaneCore::ConfigItem.new(key: :avd_abi,
-                                     env_name: "AVD_ABI",
-                                     description: "The ABI to use for the AVD. The default is to auto-select the ABI if the platform has only one ABI for its system images",
+          #paths
+          FastlaneCore::ConfigItem.new(key: :AVD_path,
+                                     env_name: "AVD_PATH",
+                                     description: "The path to your android AVD directory (root). HOME/.android/avd by default",
                                      is_string: true,
+                                     default_value: ENV['HOME'] + '/.android/avd',
                                      optional: true),
-          FastlaneCore::ConfigItem.new(key: :avd_tag,
-                                     env_name: "AVD_TAG",
-                                     description: "The sys-img tag to use for the AVD. The default is to auto-select if the platform has only one tag for its system images",
+          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: true),
-          FastlaneCore::ConfigItem.new(key: :sdk_path,
+                                     optional: false),
+          FastlaneCore::ConfigItem.new(key: :SDK_path,
                                      env_name: "SDK_PATH",
                                      description: "The path to your android sdk directory (root). ANDROID_HOME by default",
                                      is_string: true,
                                      default_value: ENV['ANDROID_HOME'],
                                      optional: true),
 
-          FastlaneCore::ConfigItem.new(key: :shell_command,
-                                     env_name: "SHELL_COMMAND",
-                                     description: "The shell command you want to execute",
-                                     is_string: true,
-                                     conflicting_options: [:gradle_task], 
-                                     optional: true),
+    
+          #launch commands
+          FastlaneCore::ConfigItem.new(key: :shell_task,
+                                   env_name: "SHELL_TASK",
+                                   description: "The shell command you want to execute",
+                                   is_string: true,
+                                   conflicting_options: [:gradle_task], 
+                                   optional: true),
           FastlaneCore::ConfigItem.new(key: :gradle_task,
-                                     env_name: "GRADLE_TASK",
-                                     description: "The gradle task you want to execute",
-                                     is_string: true,
-                                     conflicting_options: [:shell_command],
-                                     optional: true),
+                                   env_name: "GRADLE_TASK",
+                                   description: "The gradle task you want to execute",
+                                   is_string: true,
+                                   conflicting_options: [:shell_command],
+                                   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`",
-                                     optional: true,
-                                     conflicting_options: [:shell_command],
-                                     is_string: true),
-           
-          FastlaneCore::ConfigItem.new(key: :emulator_binary,
-                                     env_name: "EMULATOR_BINARY",
-                                     description: "Emulator binary file you would like to use in order to start emulator",
-                                     is_string: true,
-                                     default_value: "emulator",
-                                     optional: true),
-          FastlaneCore::ConfigItem.new(key: :avd_port,
-                                     env_name: "AVD_PORT",
-                                     description: "Possible to specify port on which emulator should run",
-                                     is_string: true,
-                                     optional: true),
-          FastlaneCore::ConfigItem.new(key: :avd_start_options,
-                                     env_name: "AVD_START_OPTIONS",
-                                     description: "Additonal run parameters e.g. gpu, audio, boot animation",
-                                     is_string: true,
-                                     optional: true),
-          FastlaneCore::ConfigItem.new(key: :initdata_snapshot_path,
-                                     env_name: "INIT_DATA_PATH",
-                                     description: "The path to userdata-qemu which will be used to initialize AVD status",
-                                     is_string: true,
-                                     optional: true),
+                                   env_name: "GRADLE_FLAGS",
+                                   description: "All parameter flags you want to pass to the gradle command, e.g. `--exitcode --xml file.xml`",
+                                   optional: true,
+                                   conflicting_options: [:shell_command],
+                                   is_string: true),
         ]
-      end
+        end
 
-      def self.description
-        "Starts single emulator before running tests."
-      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
-        ["joshrlesch, modified by F1sherKK"]
-      end
+        def self.authors
+            ["F1sherKK"]
+        end
 
-      def self.is_supported?(platform)
-        platform == :android
+        def self.is_supported?(platform)
+            platform == :android
+        end
       end
-    end
   end
 end

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

@@ -0,0 +1,55 @@
+module Fastlane
+  module Factory
+
+    class ADB_Controller
+      attr_accessor :command_stop, :command_start, :command_get_devices, :command_wait_for_device, :command_get_avds
+    end
+
+    class AdbControllerFactory
+  
+        def self.get_adb_controller(params)
+          UI.message(["Preparing commands for Android ADB"].join(" ").yellow)
+
+          # Get paths
+          path_sdk = "#{params[:SDK_path]}"
+          path_android_binary = path_sdk + "/tools/android"
+          path_adb = path_sdk + "/platform-tools/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.command_get_avds = [
+           path_android_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,109 @@
+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
+    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
+          path_sdk = "#{params[:SDK_path]}"
+          path_android_binary = path_sdk + "/tools/android"
+          path_adb = path_sdk + "/platform-tools/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_additional_options = avd_scheme.create_avd_additional_options
+          sh_create_config_loc = "#{path_avd}/#{avd_scheme.avd_name}.avd/config.ini"
+
+          if avd_scheme.create_avd_target.eql? "" 
+            sh_create_avd_target = ""
+          else
+            sh_create_avd_target = ["--target \"", avd_scheme.create_avd_target, "\""].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
+          
+          # Launch AVD shell command parts
+          sh_launch_emulator_binray = [path_sdk, "/tools/", 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_android_binary, 
+           sh_create_avd, 
+           sh_create_avd_name, 
+           sh_create_avd_target, 
+           sh_create_avd_abi, 
+           sh_create_avd_additional_options].join(" ")
+
+          avd_controller.command_start_avd = [
+           sh_launch_emulator_binray, 
+           sh_launch_avd_port, 
+           sh_launch_avd_name, 
+           sh_launch_avd_snapshot, 
+           sh_launch_avd_additional_options, 
+           "&>/dev/null &"].join(" ")
+
+          avd_controller.command_delete_avd = [
+           path_android_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/provider/avd_setup_provider.rb

@@ -0,0 +1,167 @@
+module Fastlane
+  module Provider
+
+    class AVD_scheme
+      attr_accessor :avd_name, :create_avd_target, :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 - 1)
+            avd_hash = avd_hash_list[i]
+
+            avd_scheme = AVD_scheme.new
+            avd_scheme.avd_name = avd_hash['avd_name']
+            avd_scheme.create_avd_target = avd_hash['create_avd_target']
+            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.create_avd_additional_options = avd_hash['create_avd_additional_options']
+            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 - 1)
+            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 - 1)
+            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 - 1)
+            
+            while port < max_port  do
+              if !system("lsof -i:#{port}", out: '/dev/null')
+
+                is_port_reserved = false
+                for j in 0..(reserved_ports.length - 1) 
+                  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_target.nil? 
+              errors.push("create_avd_target 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.create_avd_additional_options.nil? 
+              errors.push("create_avd_additional_options 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

@@ -1,5 +1,5 @@
 module Fastlane
   module AutomatedTestEmulatorRun
-    VERSION = "0.5.16"
+    VERSION = "1.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-automated_test_emulator_run
 version: !ruby/object:Gem::Version
-  version: 0.5.16
+  version: 1.0.0
 platform: ruby
 authors:
 - Kamil Krzyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-07 00:00:00.000000000 Z
+date: 2016-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -104,7 +104,9 @@ files:
 - README.md
 - lib/fastlane/plugin/automated_test_emulator_run.rb
 - lib/fastlane/plugin/automated_test_emulator_run/actions/automated_test_emulator_run_action.rb
-- lib/fastlane/plugin/automated_test_emulator_run/helper/automated_test_emulator_run_helper.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/provider/avd_setup_provider.rb
 - lib/fastlane/plugin/automated_test_emulator_run/version.rb
 homepage: https://github.com/AzimoLabs/fastlane-plugin-automated-test-emulator-run
 licenses:
@@ -129,7 +131,7 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Allows to wrap gradle task or shell command that runs integrated tests that
-  prepare and starts single AVD before test run. After tests are finished, emulator
-  is killed and deleted.
+summary: Starts n 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: []

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

@@ -1,12 +0,0 @@
-module Fastlane
-  module Helper
-    class AutomatedTestEmulatorRunHelper
-      # class methods that you define here become available in your action
-      # as `Helper::AutomatedTestEmulatorRunHelper.your_method`
-      #
-      def self.show_message
-        UI.message("Hello from the automated_test_emulator_run plugin helper!")
-      end
-    end
-  end
-end