fastlane-plugin-automated_test_emulator_run 1.3.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4efe1400bac26d1735995b06154b3346abffb700
-  data.tar.gz: fbd8571537739c15d7d6d68882966f51e51b0b0d
+  metadata.gz: 2b032b461fca83d22afe6d7d6719ba99e7105609
+  data.tar.gz: 50564704edf446c44eb40fac017886523cd7666e
 SHA512:
-  metadata.gz: 86e0d37ccc35d80c396a5e4bea8b5f16d1bbafbbc2daafd1849746de37197a1a94df13df19802ef388518d0364b47efd6381e5238f807c1647e8869e105eb243
-  data.tar.gz: 59175c009d68a99b117508782ab199ebe699df48cb8a91d606274cfe5dc4d7d3f3448d04080ab0c7310d517265bce3db80e5fc2632dfbe77f0403c272178109b
+  metadata.gz: 7fad381af5c445a754553460e24bf37c90fab34ca31a7a2b8e2952c033e8f7eb9c0ba6094c8f2d6086aa275ab4c8ae8a5745c6ef971d91960a9a4adee33a4bfc
+  data.tar.gz: 623bb718b4f2768594ef20d673197ba2834500867c608fc91bfd8318b38b80f3a4ddb5aa325012e6cc4a1e19101aa19c42778764f2cb7fc9facea53146aad7a0

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

@@ -48,7 +48,7 @@ module Fastlane
            
             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)
+                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)
@@ -192,8 +192,9 @@ module Fastlane
 
         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
 
@@ -206,37 +207,55 @@ module Fastlane
           launch_status = false
           loop do
             currentTime = Time.now
-            devices = Action.sh(adb_controller.command_get_devices)
+            if ((currentTime - lastCheckTime) * 1000) > interval 
+              lastCheckTime = currentTime
+              devices = Action.sh(adb_controller.command_get_devices)
+
+              # 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 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
+              # Check for unauthorized statuses and break further check if any found - WORKAROUND (temporary I hope...)
+              any_of_devices_unauthorized = devices.include?("unauthorized")
+              if any_of_devices_unauthorized
+                UI.message(["This seems to be bug of recent Build Tools 25.0.2. Device is launched but ADB status froze with value 'unauthorized'."].join("").red)
+                UI.message(["Unfortunately to workaround this, ADB server has to be restarted - in order to update device statuses. We hope it can be fixed soon. More info at:"].join("").red)
+                UI.message(["https://github.com/AzimoLabs/fastlane-plugin-automated-test-emulator-run/issues/8"].join("").yellow)
+
+                # Restart ADB
+                UI.message("Restarting adb".yellow)
+                Action.sh(adb_controller.command_stop)
+                Action.sh(adb_controller.command_start)
+                next
               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
+              # 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
-              all_devices_booted = false unless is_booted
-            end
 
-            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 timout 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
 
-            if (all_devices_booted && all_devices_visible)
-              launch_status = true
-              break
+              # Quit if all devices booted
+              if (all_devices_booted && all_devices_visible)
+                launch_status = true
+                break
+              end
             end
-            sleep(10)
           end
           return launch_status
         end
@@ -272,7 +291,7 @@ module Fastlane
           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'],
+                                       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,

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

@@ -12,7 +12,7 @@ module Fastlane
 
           # Get paths
           path_sdk = "#{params[:SDK_path]}"
-          path_android_binary = path_sdk + "/tools/android"
+          path_avdmanager_binary = path_sdk + "/tools/bin/avdmanager"
           path_adb = path_sdk + "/platform-tools/adb"
 
           # ADB shell command parts
@@ -45,7 +45,7 @@ module Fastlane
            ].join(" ")
 
           adb_controller.command_get_avds = [
-           path_android_binary, 
+           path_avdmanager_binary, 
            sh_list_avd_adb].join(" ").chomp
   
           return adb_controller

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

@@ -19,7 +19,7 @@ module Fastlane
 
           # Get paths
           path_sdk = "#{params[:SDK_path]}"
-          path_android_binary = path_sdk + "/tools/android"
+          path_avdmanager_binary = path_sdk + "/tools/bin/avdmanager"
           path_adb = path_sdk + "/platform-tools/adb"
           path_avd = "#{params[:AVD_path]}"
 
@@ -27,13 +27,12 @@ module Fastlane
           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"
+          sh_create_avd_package = ["--package \"", avd_scheme.create_avd_package, "\""].join("")
 
-          if avd_scheme.create_avd_target.eql? "" 
-            sh_create_avd_target = ""
+          if avd_scheme.create_avd_device.eql? "" 
+            sh_create_avd_device = ""
           else
-            sh_create_avd_target = ["--target \"", avd_scheme.create_avd_target, "\""].join("")
+            sh_create_avd_device = ["--device \"", avd_scheme.create_avd_device, "\""].join("")
           end
 
           if avd_scheme.create_avd_abi.eql? "" 
@@ -41,6 +40,15 @@ module Fastlane
           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_binray = [path_sdk, "/tools/", avd_scheme.launch_avd_launch_binary_name].join("")
@@ -66,13 +74,15 @@ module Fastlane
           # 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(" ")
+            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 &"
@@ -86,7 +96,7 @@ module Fastlane
            avd_output].join(" ")
 
           avd_controller.command_delete_avd = [
-           path_android_binary,
+           path_avdmanager_binary,
            sh_delete_avd].join(" ")
 
           if path_avd.nil? || (avd_scheme.create_avd_hardware_config_filepath.eql? "")

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

@@ -2,7 +2,7 @@ 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, 
+      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
 
@@ -27,10 +27,13 @@ module Fastlane
 
             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_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.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']
@@ -130,8 +133,14 @@ module Fastlane
           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")
+          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")
@@ -139,9 +148,6 @@ module Fastlane
           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
@@ -154,7 +160,6 @@ module Fastlane
           if avd_scheme.launch_avd_additional_options.nil? 
               errors.push("launch_avd_additional_options not found")
           end
-
           return errors
         end
 

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

@@ -1,5 +1,5 @@
 module Fastlane
   module AutomatedTestEmulatorRun
-    VERSION = "1.3.2"
+    VERSION = "1.4.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: 1.3.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Kamil Krzyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2017-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry