calabash 1.2.1 → 1.9.9.pre1

data/lib/calabash/android/environment.rb

@@ -0,0 +1,470 @@
+require 'rexml/document'
+require 'timeout'
+require 'luffa'
+require 'timeout'
+
+if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+  require 'win32/registry'
+end
+
+module Calabash
+  module Android
+    class Environment < Calabash::Environment
+      class InvalidEnvironmentError < RuntimeError; end
+      class InvalidJavaSDKHome < RuntimeError; end
+
+      private
+
+      def self.set_android_dependencies(android_dependencies)
+        @@android_dependencies = android_dependencies
+      end
+
+      def self.set_java_dependencies(java_dependencies)
+        @@java_dependencies = java_dependencies
+      end
+
+      def self.android_dependencies(key)
+        if @@android_dependencies.has_key?(key)
+          file = @@android_dependencies[key]
+
+          unless File.exists?(file)
+            raise "No such file '#{file}'"
+          end
+
+          file
+        else
+          raise "No such dependency '#{key}'"
+        end
+      end
+
+      def self.java_dependencies(key)
+        if key == :ant_path
+          ant_executable
+        elsif @@java_dependencies.has_key?(key)
+          file = @@java_dependencies[key]
+
+          unless File.exists?(file)
+            raise "No such file '#{file}'"
+          end
+
+          file
+        else
+          raise "No such dependency '#{key}'"
+        end
+      end
+
+      public
+
+      def self.adb_path
+        android_dependencies(:adb_path)
+      end
+
+      def self.aapt_path
+        android_dependencies(:aapt_path)
+      end
+
+      def self.zipalign_path
+        android_dependencies(:zipalign_path)
+      end
+
+      def self.android_jar_path
+        android_dependencies(:android_jar_path)
+      end
+
+      def self.java_path
+        java_dependencies(:java_path)
+      end
+
+      def self.keytool_path
+        java_dependencies(:keytool_path)
+      end
+
+      def self.jarsigner_path
+        java_dependencies(:jarsigner_path)
+      end
+
+      def self.ant_path
+        java_dependencies(:ant_path)
+      end
+
+      def self.setup
+        if Environment.variable('ANDROID_HOME')
+          android_sdk_location = Environment.variable('ANDROID_HOME')
+          Logger.debug("Setting Android SDK location to $ANDROID_HOME")
+        else
+          android_sdk_location = detect_android_sdk_location
+        end
+
+        if android_sdk_location.nil?
+          Logger.error 'Could not find an Android SDK please make sure it is installed.'
+          Logger.error 'You can read about how Calabash is searching for an Android SDK and how you can help here:'
+          Logger.error 'https://github.com/calabash/calabash-android/blob/master/documentation/installation.md#prerequisites'
+
+          raise 'Could not find an Android SDK'
+        end
+
+        Logger.debug("Android SDK location set to '#{android_sdk_location}'")
+
+        begin
+          set_android_dependencies(locate_android_dependencies(android_sdk_location))
+        rescue InvalidEnvironmentError => e
+          Logger.error 'Could not locate Android dependency'
+          Logger.error 'You can read about how Calabash is searching for an Android SDK and how you can help here:'
+          Logger.error 'https://github.com/calabash/calabash-android/blob/master/documentation/installation.md#prerequisites'
+
+          raise e
+        end
+
+        if Environment.variable('JAVA_HOME')
+          java_sdk_home = Environment.variable('JAVA_HOME')
+          Logger.debug("Setting Java SDK location to $JAVA_HOME")
+        else
+          java_sdk_home = detect_java_sdk_location
+        end
+
+        Logger.debug("Java SDK location set to '#{java_sdk_home}'")
+
+        begin
+          set_java_dependencies(locate_java_dependencies(java_sdk_home))
+        rescue InvalidJavaSDKHome => e
+          Logger.error "Could not find Java Development Kit please make sure it is installed."
+          Logger.error "You can read about how Calabash is searching for a JDK and how you can help here:"
+          Logger.error "https://github.com/calabash/calabash-android/blob/master/documentation/installation.md#prerequisites"
+
+          raise e
+        rescue InvalidEnvironmentError => e
+          Logger.error "Could not find Java dependency"
+          Logger.error "You can read about how Calabash is searching for a JDK and how you can help here:"
+          Logger.error "https://github.com/calabash/calabash-android/blob/master/documentation/installation.md#prerequisites"
+
+          raise e
+        end
+      end
+
+      private
+
+      def self.tools_directory
+        tools_directories = tools_directories(Environment.variable('ANDROID_HOME'))
+
+        File.join(Environment.variable('ANDROID_HOME'), tools_directories.first)
+      end
+
+      def self.tools_directories(android_sdk_location)
+        build_tools_files = list_files(File.join(android_sdk_location, 'build-tools')).select {|file| File.directory?(file)}
+
+        build_tools_directories =
+            build_tools_files.select do |dir|
+              begin
+                Luffa::Version.new(File.basename(dir))
+                true
+              rescue ArgumentError
+                false
+              end
+            end.sort do |a, b|
+              Luffa::Version.compare(Luffa::Version.new(File.basename(a)), Luffa::Version.new(File.basename(b)))
+            end.reverse.map{|dir| File.join('build-tools', File.basename(dir))}
+
+        if build_tools_directories.empty?
+          build_tools_directories = [File.join('build-tools', File.basename(build_tools_files.reverse.first))]
+        end
+
+        build_tools_directories + ['platform-tools', 'tools']
+      end
+
+      def self.platform_directory(android_sdk_location)
+        files = list_files(File.join(android_sdk_location, 'platforms'))
+                    .select {|file| File.directory?(file)}
+
+        sorted_files = files.sort_by {|item| '%08s' % item.split('-').last}.reverse
+
+        File.join('platforms', File.basename(sorted_files.first))
+      end
+
+      def self.locate_android_dependencies(android_sdk_location)
+        adb_path = scan_for_path(android_sdk_location, adb_executable, ['platform-tools'])
+        aapt_path = scan_for_path(android_sdk_location, aapt_executable, tools_directories(android_sdk_location))
+        zipalign_path = scan_for_path(android_sdk_location, zipalign_executable, tools_directories(android_sdk_location))
+
+        if adb_path.nil?
+          raise InvalidEnvironmentError,
+                "Could not find '#{adb_executable}' in '#{android_sdk_location}'"
+        end
+
+        if aapt_path.nil?
+          raise InvalidEnvironmentError,
+                "Could not find '#{aapt_executable}' in '#{android_sdk_location}'"
+        end
+
+        if zipalign_path.nil?
+          raise InvalidEnvironmentError,
+                "Could not find '#{zipalign_executable}' in '#{android_sdk_location}'"
+        end
+
+        Logger.debug("Set aapt path to '#{aapt_path}'")
+        Logger.debug("Set zipalign path to '#{zipalign_path}'")
+        Logger.debug("Set adb path to '#{adb_path}'")
+
+        android_jar_path = scan_for_path(File.join(android_sdk_location, 'platforms'), 'android.jar', [File.basename(platform_directory(android_sdk_location))])
+
+        if android_jar_path.nil?
+          raise InvalidEnvironmentError,
+                "Could not find 'android.jar' in '#{File.join(android_sdk_location, 'platforms')}'"
+        end
+
+        Logger.debug("Set android jar path to '#{android_jar_path}'")
+
+        {
+            aapt_path: aapt_path,
+            zipalign_path: zipalign_path,
+            adb_path: adb_path,
+            android_jar_path: android_jar_path
+        }
+      end
+
+      def self.locate_java_dependencies(java_sdk_location)
+        # For the Java dependencies, we will use the PATH elements of they exist
+        on_path = find_executable_on_path(java_executable)
+
+        if on_path
+          Logger.debug('Found java on PATH')
+          java_path = on_path
+        else
+          if java_sdk_location.nil? || java_sdk_location.empty?
+            raise InvalidJavaSDKHome,
+                  "Could not locate '#{java_executable}' on path, and Java SDK Home is invalid."
+          end
+
+          java_path = scan_for_path(java_sdk_location, java_executable, ['bin'])
+        end
+
+        Logger.debug("Set java path to '#{java_path}'")
+
+        on_path = find_executable_on_path(keytool_executable)
+
+        if on_path
+          Logger.debug('Found keytool on PATH')
+          keytool_path = on_path
+        else
+          if java_sdk_location.nil? || java_sdk_location.empty?
+            raise InvalidJavaSDKHome,
+                  "Could not locate '#{keytool_executable}' on path, and Java SDK Home is invalid."
+          end
+
+          keytool_path = scan_for_path(java_sdk_location, keytool_executable, ['bin'])
+        end
+
+        Logger.debug("Set keytool path to '#{keytool_path}'")
+
+        on_path = find_executable_on_path(jarsigner_executable)
+
+        if on_path
+          Logger.debug('Found jarsigner on PATH')
+          jarsigner_path = on_path
+        else
+          if java_sdk_location.nil? || java_sdk_location.empty?
+            raise InvalidJavaSDKHome,
+                  "Could not locate '#{jarsigner_executable}' on path, and Java SDK Home is invalid."
+          end
+
+          jarsigner_path = scan_for_path(java_sdk_location, jarsigner_executable, ['bin'])
+        end
+
+        Logger.debug("Set jarsigner path to '#{jarsigner_path}'")
+
+        if java_path.nil?
+          raise InvalidEnvironmentError,
+                "Could not find '#{java_executable}' on PATH or in '#{java_sdk_location}'"
+        end
+
+        if keytool_path.nil?
+          raise InvalidEnvironmentError,
+                "Could not find '#{keytool_executable}' on PATH or in '#{java_sdk_location}'"
+        end
+
+        if jarsigner_path.nil?
+          raise InvalidEnvironmentError,
+                "Could not find '#{jarsigner_executable}' on PATH or in '#{java_sdk_location}'"
+        end
+
+        {
+            java_path: java_path,
+            keytool_path: keytool_path,
+            jarsigner_path: jarsigner_path
+        }
+      end
+
+      def self.scan_for_path(path, file_name, expected_sub_folders = nil)
+        # Optimization for expected folders
+        if expected_sub_folders && !expected_sub_folders.empty?
+          expected_sub_folders.each do |expected_sub_folder|
+            result = scan_for_path(File.join(path, expected_sub_folder), file_name)
+
+            return result if result
+          end
+
+          Logger.warn("Did not find '#{file_name}' in any standard directory of '#{path}'. Calabash will therefore take longer to load")
+          Logger.debug(" - Expected to find '#{file_name}' in any of:")
+
+          expected_sub_folders.each do |expected_sub_folder|
+            Logger.debug(" - #{File.join(path, expected_sub_folder)}")
+          end
+        end
+
+        files = list_files(path).sort.reverse
+
+        if files.reject{|file| File.directory?(file)}.
+            map{|file| File.basename(file)}.include?(file_name)
+          return File.join(path, file_name)
+        else
+          files.select{|file| File.directory?(file)}.each do |dir|
+            result = scan_for_path(dir, file_name)
+
+            return result if result
+          end
+        end
+
+        nil
+      end
+
+      def self.detect_android_sdk_location
+        if File.exist?(monodroid_config_file)
+          sdk_location = read_attribute_from_monodroid_config('android-sdk', 'path')
+
+          if sdk_location
+            Logger.debug("Setting Android SDK location from '#{monodroid_config_file}'")
+
+            return sdk_location
+          end
+        end
+
+        if File.exist?('~/Library/Developer/Xamarin/android-sdk-mac_x86/')
+          return '~/Library/Developer/Xamarin/android-sdk-mac_x86/'
+        end
+
+        if File.exist?('C:\\Android\\android-sdk')
+          return 'C:\\Android\\android-sdk'
+        end
+
+        if is_windows?
+          from_registry = read_registry(::Win32::Registry::HKEY_CURRENT_USER, "Software\\Novell\\Mono for Android", 'AndroidSdkDirectory')
+
+          if from_registry && File.exist?(from_registry)
+            Logger.debug("Setting Android SDK location from HKEY_CURRENT_USER Software\\Novell\\Mono for Android")
+            return from_registry
+          end
+
+          from_registry = read_registry(::Win32::Registry::HKEY_LOCAL_MACHINE, 'Software\\Android SDK Tools', 'Path')
+
+          if from_registry && File.exist?(from_registry)
+            Logger.debug("Setting Android SDK location from HKEY_LOCAL_MACHINE Software\\Android SDK Tools")
+            return from_registry
+          end
+        end
+
+        nil
+      end
+
+      def self.detect_java_sdk_location
+        if File.exist?(monodroid_config_file)
+          sdk_location = read_attribute_from_monodroid_config('java-sdk', 'path')
+
+          if sdk_location
+            Logger.debug("Setting Java SDK location from '#{monodroid_config_file}'")
+
+            return sdk_location
+          end
+        end
+
+        java_versions = ['1.9', '1.8', '1.7', '1.6']
+
+        if is_windows?
+          java_versions.each do |java_version|
+            key = "SOFTWARE\\JavaSoft\\Java Development Kit\\#{java_version}"
+            from_registry = read_registry(::Win32::Registry::HKEY_LOCAL_MACHINE, key, 'JavaHome')
+
+            if from_registry && File.exist?(from_registry)
+              Logger.debug("Setting Java SDK location from HKEY_LOCAL_MACHINE #{key}")
+              return from_registry
+            end
+          end
+        end
+
+        nil
+      end
+
+      def self.monodroid_config_file
+        File.expand_path('~/.config/xbuild/monodroid-config.xml')
+      end
+
+      def self.read_attribute_from_monodroid_config(element, attribute)
+        REXML::Document.new(IO.read(monodroid_config_file)).elements["//#{element}"].attributes[attribute]
+      end
+
+      def self.find_executable_on_path(executable)
+        path_elements.each do |x|
+          f = File.join(x, executable)
+          return f if File.exists?(f)
+        end
+
+        nil
+      end
+
+      def self.path_elements
+        return [] unless Environment.variable('PATH')
+        Environment.variable('PATH').split (/[:;]/)
+      end
+
+      def self.zipalign_executable
+        is_windows? ? 'zipalign.exe' : 'zipalign'
+      end
+
+      def self.jarsigner_executable
+        is_windows? ? 'jarsigner.exe' : 'jarsigner'
+      end
+
+      def self.java_executable
+        is_windows? ? 'java.exe' : 'java'
+      end
+
+      def self.keytool_executable
+        is_windows? ? 'keytool.exe' : 'keytool'
+      end
+
+      def self.adb_executable
+        is_windows? ? 'adb.exe' : 'adb'
+      end
+
+      def self.aapt_executable
+        is_windows? ? 'aapt.exe' : 'aapt'
+      end
+
+      def self.ant_executable
+        is_windows? ? 'ant.exe' : 'ant'
+      end
+
+      def self.is_windows?
+        (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+      end
+
+      def self.read_registry(root_key, key, value)
+        begin
+          root_key.open(key)[value]
+        rescue
+          nil
+        end
+      end
+
+      def self.list_files(path)
+        # Dir.glob does not accept backslashes, even on windows. We have to
+        # substitute all backwards slashes to forward.
+        # C:\foo becomes C:/foo
+
+        if is_windows?
+          Dir.glob(File.join(path, '*').gsub('\\', '/'))
+        else
+          Dir.glob(File.join(path, '*'))
+        end
+      end
+    end
+  end
+end