ruboto 1.0.3 → 1.1.0

data/assets/src/ruboto/util/toast.rb

@@ -7,11 +7,11 @@
 #######################################################
 
 Java::android.content.Context.class_eval do
-  def toast(text, duration=5000)
+  def toast(text, duration=android.widget.Toast::LENGTH_SHORT)
     Java::android.widget.Toast.makeText(self, text, duration).show
   end
 
-  def toast_result(result, success, failure, duration=5000)
+  def toast_result(result, success, failure, duration=android.widget.Toast::LENGTH_SHORT)
     toast(result ? success : failure, duration)
   end
 end

data/lib/ruboto/commands/base.rb

@@ -40,32 +40,37 @@ module Ruboto
               }
               option('activity') {
                 argument :required
-                description 'Name of your primary Activity.  Defaults to the name of the application with Activity appended.'
+                description 'Name of your primary Activity.  Defaults to the name of the application with "Activity" appended.'
               }
               option('path') {
                 argument :required
                 description 'Path to where you want your app.  Defaults to the last part of the package name.'
               }
+              # FIXME(uwe): Change to cast to integer for better comparison
               option('target', 't') {
                 argument :required
                 defaults DEFAULT_TARGET_SDK
-                description "Android version to target. Must begin with 'android-' (e.g., 'android-10' for gingerbread)"
-                cast {|t| t =~ /^(\d+)$/ ? "android-#$1" : t}
-                validate {|t| t =~ /^android-\d+$/}
+                description "Android version to target (e.g., 'android-19' or '19' for kitkat)"
+                cast { |t| t =~ /^(\d+)$/ ? "android-#$1" : t }
+                validate { |t| t =~ /^android-\d+$/ }
               }
               option('min-sdk') {
                 argument :required
-                description "Minimum android version supported. Must begin with 'android-'."
+                description "Minimum android version supported. (e.g., 'android-19' or '19' for kitkat)"
+                cast { |t| t =~ /^(\d+)$/ ? "android-#$1" : t }
+                validate { |t| t =~ /^android-\d+$/ }
               }
               option('with-jruby') {
-                description 'Generate the JRuby jars jar'
-                cast :boolean
+                description 'Install the JRuby jars in your libs directory.  Optionally set the JRuby version to install.  Otherwise the latest available version is installed.'
+                argument :optional
+                cast { |v| Gem::Version.new(v) }
+                validate { |v| Gem::Version.correct?(v) }
               }
               option('ruby-version') {
                 description 'Using what version of Ruby? (e.g., 1.8, 1.9, 2.0)'
                 argument :required
                 cast :float
-                validate {|rv| [1.8, 1.9, 2.0].include?(rv)}
+                validate { |rv| [1.8, 1.9, 2.0].include?(rv) }
               }
               option('force') {
                 description 'Force creation of project even if the path exists'
@@ -108,7 +113,7 @@ module Ruboto
 
                 Dir.chdir root do
                   update_manifest min_sdk[/\d+/], target[/\d+/], true
-                  update_test true
+                  update_test true, target[/\d+/].to_i
                   update_assets
 
                   if ruby_version
@@ -120,8 +125,10 @@ module Ruboto
                   update_ruboto true
                   update_icons true
                   update_classes nil, 'exclude'
-                  update_jruby true if with_jruby
-                  update_dx_jar true if with_jruby
+                  if with_jruby
+                    update_jruby true, with_jruby
+                    update_dx_jar true
+                  end
                   update_core_classes 'exclude'
 
                   log_action('Generating the default Activity and script') do
@@ -138,8 +145,15 @@ module Ruboto
               include Ruboto::Util::Build
               include Ruboto::Util::Update
 
+              argument('version') {
+                required false
+                description 'The JRuby version to install.'
+                cast { |v| Gem::Version.new(v) }
+                validate { |v| Gem::Version.correct?(v) }
+              }
+
               def run
-                update_jruby true
+                update_jruby true, params['version'].value
               end
             end
 
@@ -333,20 +347,25 @@ module Ruboto
             include Ruboto::Util::LogAction
             include Ruboto::Util::Update
 
-            argument('what') {
-              required
-              # FIXME(uwe): Deprecated "ruboto update ruboto" in Ruboto 0.8.1.  Remove september 2013.
-              validate { |i| %w(jruby app ruboto).include?(i) }
-              description "What do you want to update: 'app', 'jruby', or 'ruboto'"
-            }
-
-            option('force') {
-              description "force an update even if the version hasn't changed"
-            }
+            mode 'app' do
+              # FIXME(uwe): Change to cast to integer for better comparison
+              option('target', 't') {
+                argument :required
+                description "Android version to target (e.g., 'android-19' or '19' for kitkat)"
+                cast { |t| t =~ /^(\d+)$/ ? "android-#$1" : t }
+                validate { |t| t =~ /^android-\d+$/ }
+              }
+              option('with-jruby') {
+                description 'Install the JRuby jars in your libs directory.  Optionally set the JRuby version to install.  Otherwise the latest available version is installed.  If the JRuby jars are already present in your project, this option is implied.'
+                argument :optional
+                cast { |v| Gem::Version.new(v) }
+                validate { |v| Gem::Version.correct?(v) }
+              }
+              option('force') {
+                description "force an update even if the version hasn't changed"
+              }
 
-            def run
-              case params['what'].value
-              when 'app' then
+              def run
                 force = params['force'].value
                 old_version = read_ruboto_version
                 if old_version && Gem::Version.new(old_version) < Gem::Version.new(Ruboto::UPDATE_VERSION_LIMIT)
@@ -358,21 +377,45 @@ module Ruboto
                   system "ruboto _#{Ruboto::UPDATE_VERSION_LIMIT}_ update app"
                   raise "Ruboto update app to #{Ruboto::UPDATE_VERSION_LIMIT} failed!" unless $? == 0
                 end
-                update_android
-                update_test force
+
+                if (target = params['target'].value)
+                  abort "Target must match android-<number>: got #{target}" unless target =~ /^android-(\d+)$/
+                  abort "Minimum Android api level is #{MINIMUM_SUPPORTED_SDK}: got #{target}" unless $1.to_i >= MINIMUM_SUPPORTED_SDK_LEVEL
+                  target_level = target[/\d+/].to_i
+                  update_android(target_level)
+                  update_test force, target_level
+                else
+                  update_android
+                  update_test force
+                end
+
                 update_assets
                 update_ruboto force
                 update_classes old_version, force
                 update_dx_jar force
-                update_jruby force
+                update_jruby force, params['with-jruby'].value
                 update_manifest nil, nil, force
                 update_icons force
                 update_core_classes 'exclude'
                 update_bundle
-              when 'jruby' then
-                update_jruby(params['force'].value, true) || abort
-              else
-                raise "Unknown update target: #{params['what'].value.inspect}"
+              end
+            end
+
+            mode 'jruby' do
+
+              argument('version') {
+                required false
+                description 'The JRuby version to install.  The jruby-jars gem of the same version should be installed on your system already.'
+                cast { |v| Gem::Version.new(v) }
+                validate { |v| Gem::Version.correct?(v) }
+              }
+
+              option('force') {
+                description "force an update even if the version hasn't changed"
+              }
+
+              def run
+                update_jruby(params['force'].value, params['version'].value, true) || abort
               end
             end
           end
@@ -386,8 +429,8 @@ module Ruboto
               argument :required
               default DEFAULT_TARGET_SDK
               arity -1
-              cast {|t| t =~ /^(\d+)$/ ? "android-#$1" : t}
-              validate {|t| t =~ /^android-\d+$/}
+              cast { |t| t =~ /^(\d+)$/ ? "android-#$1" : t }
+              validate { |t| t =~ /^android-\d+$/ }
             }
 
             option('yes', 'y') {
@@ -412,12 +455,17 @@ module Ruboto
               required unless api_level
               argument :required
               default(api_level) if api_level
-              cast {|t| t =~ /^(\d+)$/ ? "android-#$1" : t}
-              validate {|t| t =~ /^android-(\d+)$/ && sdk_level_name($1.to_i)}
+              cast { |t| t =~ /^(\d+)$/ ? "android-#$1" : t }
+              validate { |t| t =~ /^android-(\d+)$/ && sdk_level_name($1.to_i) }
+            }
+
+            option('no-snapshot', 's') {
+              extend Ruboto::Util::Emulator
+              description 'do not use a snapshot when starting the emulator'
             }
 
             def run
-              start_emulator(params['target'].value)
+              start_emulator(params['target'].value, params['no-snapshot'].value)
             end
           end
 

data/lib/ruboto/util/emulator.rb

@@ -11,7 +11,7 @@ module Ruboto
         Ruboto::SdkVersions::API_LEVEL_TO_VERSION[sdk_level] || "api_#{sdk_level}"
       end
 
-      def start_emulator(sdk_level)
+      def start_emulator(sdk_level, no_snapshot)
         sdk_level = sdk_level.gsub(/^android-/, '').to_i
         STDOUT.sync = true
         if RbConfig::CONFIG['host_cpu'] == 'x86_64'
@@ -24,11 +24,6 @@ module Ruboto
           emulator_cmd = 'emulator-arm'
         end
 
-        emulator_opts = '-partition-size 256'
-        if !ON_MAC_OS_X && !ON_WINDOWS && ENV['DISPLAY'].nil?
-          emulator_opts << ' -no-window -no-audio'
-        end
-
         avd_name = "Android_#{sdk_level_name(sdk_level)}"
         new_snapshot = false
 
@@ -55,6 +50,12 @@ module Ruboto
 
         # FIXME(uwe):  Change use of "killall" to use the Ruby Process API
         loop do
+          emulator_opts = '-partition-size 256'
+          emulator_opts << ' -no-snapshot-load' if no_snapshot
+          if !ON_MAC_OS_X && !ON_WINDOWS && ENV['DISPLAY'].nil?
+            emulator_opts << ' -no-window -no-audio'
+          end
+
           `killall -0 #{emulator_cmd} 2> /dev/null`
           if $? == 0
             `killall #{emulator_cmd}`
@@ -98,15 +99,26 @@ module Ruboto
               has_haxm = abis.find { |a| a =~ /x86/ }
             end
 
-            if has_haxm
-              abi_opt = '--abi x86'
+            # FIXME(uwe): The x86 emulator does not respect the heap setting and
+            # restricts to a 16MB heap on Android 2.3 which will crash any
+            # Ruboto app.  Remove the first "if" below when heap setting works
+            # on x86 emulator.
+            # https://code.google.com/p/android/issues/detail?id=37597
+            # https://code.google.com/p/android/issues/detail?id=61596
+            if sdk_level == 10
+              abi_opt = '--abi armeabi'
             else
-              if [17, 16, 15, 13, 11].include? sdk_level
-                abi_opt = '--abi armeabi-v7a'
-              elsif sdk_level == 10
-                abi_opt = '--abi armeabi'
+              if has_haxm
+                abi_opt = '--abi x86'
+              else
+                if [17, 16, 15, 13, 11].include? sdk_level
+                  abi_opt = '--abi armeabi-v7a'
+                elsif sdk_level == 10
+                  abi_opt = '--abi armeabi'
+                end
               end
             end
+            # EMXIF
 
             puts `echo n | android create avd -a -n #{avd_name} -t android-#{sdk_level} #{abi_opt} -c 64M -s HVGA`
 
@@ -128,7 +140,7 @@ module Ruboto
             new_snapshot = true
           end
 
-          puts 'Start emulator'
+          puts "Start emulator#{' without snapshot' if no_snapshot}"
           system "emulator -avd #{avd_name} #{emulator_opts} #{'&' unless ON_WINDOWS}"
           return if ON_WINDOWS
 
@@ -174,8 +186,14 @@ module Ruboto
             end
             puts
             break if device_ready?
+            puts 'Device started, but failed to respond.'
+            unless no_snapshot
+              puts 'Retrying without loading snapshot.'
+              no_snapshot = true
+            end
+          else
+            puts 'Unable to start the emulator.'
           end
-          puts 'Unable to start the emulator.'
         end
 
         if new_snapshot

data/lib/ruboto/util/setup.rb

@@ -7,6 +7,7 @@ module Ruboto
       include Ruboto::Util::Verify
       REPOSITORY_BASE = 'http://dl-ssl.google.com/android/repository'
       REPOSITORY_URL = "#{REPOSITORY_BASE}/repository-8.xml"
+      SDK_DOWNLOAD_PAGE = 'http://developer.android.com/sdk/index.html?hl=sk'
 
       RUBOTO_GEM_ROOT = File.expand_path '../../../..', __FILE__
       WINDOWS_ELEVATE_CMD = "#{RUBOTO_GEM_ROOT}/bin/elevate_32.exe -c -w"
@@ -124,6 +125,30 @@ module Ruboto
         version
       end
 
+      def get_android_sdk_version
+        require 'net/http'
+        require 'uri'
+
+        # Get's the Page to Scrape
+        page_content = Net::HTTP.get(URI.parse(SDK_DOWNLOAD_PAGE))
+
+        case android_package_os_id
+        when MAC_OS_X
+          regex = '(\>android-sdk.*macosx.zip)'
+        when LINUX
+          regex = '(\>android-sdk.*.tgz)'
+        when WINDOWS
+          regex = '(\>installer_.*.exe)'
+        else #Error
+          nil
+        end
+
+        link = page_content.scan(/#{regex}/).to_s
+        version = link.match( /(\d+).(\d+).(\d+)/ )[0]
+
+        version
+      end
+
       #########################################
       #
       # Check Methods
@@ -164,8 +189,7 @@ module Ruboto
           found = File.exists?(@haxm_kext_loc)
           @haxm_kext_loc = nil unless found
           puts "#{'%-25s' % 'Intel HAXM'}: #{(found ? 'Found' : 'Not found')}"
-          @haxm_installer_loc = File.join(android_package_directory, 'extras', 'intel', 'Hardware_Accelerated_Execution_Manager', 'IntelHAXM.dmg')
-          @haxm_installer_loc = nil unless File.exists?(@haxm_installer_loc)
+          @haxm_installer_loc = Dir[File.join(android_package_directory, 'extras', 'intel', 'Hardware_Accelerated_Execution_Manager', 'IntelHAXM*.dmg')].first
         when LINUX
           @haxm_installer_loc = 'Not supported, yet.'
           @haxm_kext_loc = 'Not supported, yet.'
@@ -175,8 +199,7 @@ module Ruboto
           found = ($? == 0)
           @haxm_kext_loc = nil unless found
           puts "#{'%-25s' % 'Intel HAXM'}: #{(found ? 'Found' : 'Not found')}"
-          @haxm_installer_loc = File.join(android_package_directory, 'extras', 'intel', 'Hardware_Accelerated_Execution_Manager', 'IntelHaxm.exe')
-          @haxm_installer_loc = nil unless File.exists?(@haxm_installer_loc)
+          @haxm_installer_loc = Dir[File.join(android_package_directory, 'extras', 'intel', 'Hardware_Accelerated_Execution_Manager', 'IntelHaxm*.exe')].first
           return
         end
       end
@@ -264,7 +287,7 @@ module Ruboto
 	            `sudo #{installer} install -y #{package_name}`
 	          else
 	            puts
-	            puts 'You can install #{pretty_name} manually by:'
+	            puts "You can install #{pretty_name} manually by:"
 	            puts "sudo #{installer} install #{package_name}"
 	            puts
 	          end
@@ -451,12 +474,12 @@ module Ruboto
             Dir.chdir File.expand_path('~/') do
               case android_package_os_id
               when MAC_OS_X
-                asdk_file_name = "android-sdk_r#{get_tools_version}-#{android_package_os_id}.zip"
+                asdk_file_name = "android-sdk_r#{get_android_sdk_version}-#{android_package_os_id}.zip"
                 download(asdk_file_name)
                 unzip(accept_all, asdk_file_name)
                 FileUtils.rm_f asdk_file_name
               when LINUX
-                asdk_file_name = "android-sdk_r#{get_tools_version}-#{android_package_os_id}.tgz"
+                asdk_file_name = "android-sdk_r#{get_android_sdk_version}-#{android_package_os_id}.tgz"
                 download asdk_file_name
                 system "tar -xzf #{asdk_file_name}"
                 FileUtils.rm_f asdk_file_name
@@ -469,7 +492,7 @@ module Ruboto
                 #    exit /b 1
                 #)
 
-                asdk_file_name = "installer_r#{get_tools_version}-#{android_package_os_id}.exe"
+                asdk_file_name = "installer_r#{get_android_sdk_version}-#{android_package_os_id}.exe"
                 download(asdk_file_name)
                 puts "Installing #{asdk_file_name}..."
                 system "#{WINDOWS_ELEVATE_CMD} #{asdk_file_name}"
@@ -548,15 +571,14 @@ module Ruboto
             case android_package_os_id
             when MAC_OS_X
               system "hdiutil attach #{@haxm_installer_loc}"
-              # FIXME(uwe): Detect volume
-              # FIXME(uwe): Detect mpkg file with correct version.
-              system 'sudo -S installer -pkg /Volumes/IntelHAXM_1.0.6/IntelHAXM_1.0.6.mpkg -target /'
+              fileName = Dir['/Volumes/IntelHAXM*/IntelHAXM*.mpkg'][0]
+              system "sudo -S installer -pkg #{fileName} -target /"
             when LINUX
               puts '    HAXM installation on Linux is not supported, yet.'
               return
             when WINDOWS
               cmd = @haxm_installer_loc.gsub('/', "\\")
-              puts "Running the HAXM installer"
+              puts 'Running the HAXM installer'
               system %Q{#{WINDOWS_ELEVATE_CMD} "#{cmd}"}
               raise "Unexpected return code: #{$?.exitstatus}" unless $? == 0
               return