ruboto 1.4.1 → 1.5.0

data/assets/rakelib/ruboto.stdlib.rake

@@ -181,6 +181,12 @@ def remove_unneeded_parts_of_stdlib
   end
 end
 
+def add_fake_jar(source_file, jar_load_code)
+  File.write(source_file, jar_load_code)
+  open("#{File.dirname(source_file)}/.jrubydir", 'a') { |f| f.puts File.basename source_file }
+end
+private :add_fake_jar
+
 def cleanup_jars
   Dir.chdir 'new' do
     cmd_line_jar_found = false
@@ -224,6 +230,7 @@ def cleanup_jars
       print "#{File.basename(j).chomp('.jar')}..."
       system "jar xf #{j}"
       FileUtils.rm j
+
       if ENV['STRIP_INVOKERS']
         invokers = Dir['**/*$INVOKER$*.class']
         if invokers.size > 0
@@ -252,6 +259,22 @@ def cleanup_jars
           Java::json.ext.ParserService.new.basicLoad(JRuby.runtime)
         END_CODE
       elsif j =~ %r{jopenssl.jar$}
+        # FIXME(uwe): Use our own patched version of OpenSSL until jruby-openssl 0.9.16 is released
+        # FIXME(uwe): Remove before Ruboto release!
+        # FIXME(uwe): Remove after jruby-openssl 0.9.16 is added to the jruby-1_7 branch
+        if File.exists? 'org/jruby/ext/openssl/OpenSSL.class'
+          puts '*' * 80
+          puts 'Patching OpenSSL'
+          FileUtils.rm 'org/jruby/ext/openssl/OpenSSL.class'
+          FileUtils.mkdir_p '../../../src/org/jruby/ext/openssl'
+          # require 'ruboto'
+          # FileUtils.cp "#{Ruboto::ASSETS}/src/org/jruby/ext/openssl/OpenSSL.java",
+          #     '../../../src/org/jruby/ext/openssl/OpenSSL.java'
+          FileUtils.cp File.expand_path('../../../assets/src/org/jruby/ext/openssl/OpenSSL.java', File.dirname(__FILE__)),
+              '../../../src/org/jruby/ext/openssl/OpenSSL.java'
+          puts '*' * 80
+        end
+        # EMXIF
         jar_load_code = <<-END_CODE
           require 'jruby'
           puts 'Starting JOpenSSL Service'
@@ -279,10 +302,11 @@ def cleanup_jars
         END_CODE
       else
         jar_load_code = ''
+        add_fake_jar("#{j}", jar_load_code)
       end
 
-      File.open("#{j}.rb", 'w') { |f| f << jar_load_code }
-      File.open("#{j}.jar.rb", 'w') { |f| f << jar_load_code }
+      add_fake_jar("#{j}.rb", jar_load_code)
+      # add_fake_jar("#{j}.jar.rb", jar_load_code)
     end
     unless cmd_line_jar_found
       puts "\nWARNING:  No command line jar filtered.  Has it changed?"

data/assets/ruboto.yml

@@ -1,10 +1,40 @@
+###################################
+#
+# emulator:
+#
+#   Specifies which emulator to use when running `ruboto emulator`.
+#
+#   Name of the AVD to be used.  It will be created if not already present.
+#   default: "Android_#{android_version}"
+#
+#   name: Android_4.0.3_tablet
+#
+#   Name of the Android device to be used as template.  Setting this options
+#   disables the "skin" option on AVD creation and starts the emulator without
+#   the "-no-skin" option.
+#   default: Nexus One
+#
+#   device: Nexus 10
+#
+#   Name of the Android emulator skin to use when creating the AVD.
+#   default: HVGA
+#
+#   skin: HVGA
+#
+# Example:
+#
+# emulator:
+#   name: Android_4.0.3_tablet # default: "Android_#{android_version}"
+#   device: Nexus 10           # default: Nexus One
+#   skin: HVGA                 # default: HVGA
+
 ###################################
 #
 # heap_alloc
-#   
+#
 #    Forces the heap to grow by a number of megabytes.
 #    Can result in improved start-up performance because
-#      it prevents the heap from growing through smaller 
+#      it prevents the heap from growing through smaller
 #      increments.
 #
 # heap_alloc: 13

data/assets/src/org/jruby/ext/openssl/OpenSSL.java

@@ -0,0 +1,320 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2014 Karol Bucek LTD.
+ *
+ * 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.
+ */
+package org.jruby.ext.openssl;
+
+import java.security.NoSuchProviderException;
+import java.util.Map;
+
+import org.jruby.CompatVersion;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.SafePropertyAccessor;
+
+/**
+ * OpenSSL (methods as well as an entry point)
+ *
+ * @author kares
+ */
+@JRubyModule(name = "OpenSSL")
+public final class OpenSSL {
+
+    public static void load(final Ruby runtime) {
+        System.out.println("CUSTOM OpenSSL load");
+        createOpenSSL(runtime);
+    }
+
+    public static boolean isProviderAvailable() {
+        System.out.println("CUSTOM OpenSSL isProviderAvailable");
+        return SecurityHelper.isProviderAvailable("BC");
+    }
+
+    public static void createOpenSSL(final Ruby runtime) {
+        System.out.println("CUSTOM OpenSSL createOpenSSL");
+        boolean registerProvider = SafePropertyAccessor.getBoolean("jruby.openssl.provider.register");
+        SecurityHelper.setRegisterProvider( registerProvider );
+
+        System.out.println("OpenSSL createOpenSSL create module");
+        final RubyModule _OpenSSL = runtime.getOrCreateModule("OpenSSL");
+        System.out.println("OpenSSL createOpenSSL create OpenSSLError");
+        RubyClass _StandardError = runtime.getClass("StandardError");
+        _OpenSSL.defineClassUnder("OpenSSLError", _StandardError, _StandardError.getAllocator());
+        System.out.println("OpenSSL createOpenSSL defineAnnotatedMethods");
+        _OpenSSL.defineAnnotatedMethods(OpenSSL.class);
+
+        // set OpenSSL debug internal flag early on so it can print traces even while loading extension
+        System.out.println("OpenSSL createOpenSSL debug");
+        setDebug(_OpenSSL, runtime.newBoolean( SafePropertyAccessor.getBoolean("jruby.openssl.debug") ) );
+
+        System.out.println("OpenSSL createOpenSSL warn");
+        final String warn = SafePropertyAccessor.getProperty("jruby.openssl.warn");
+        if ( warn != null ) OpenSSL.warn = Boolean.parseBoolean(warn);
+
+        System.out.println("OpenSSL createOpenSSL createPKey");
+        PKey.createPKey(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createBN");
+        BN.createBN(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createDigest");
+        Digest.createDigest(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createCipher");
+        Cipher.createCipher(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createRandom");
+        Random.createRandom(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createHMAC");
+        HMAC.createHMAC(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createConfig");
+        Config.createConfig(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createASN1");
+        ASN1.createASN1(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createX509");
+        X509.createX509(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createNetscapeSPKI");
+        NetscapeSPKI.createNetscapeSPKI(runtime, _OpenSSL);
+        try {
+        System.out.println("OpenSSL createOpenSSL createSSL");
+        SSL.createSSL(runtime, _OpenSSL);
+        } catch (Throwable e) {
+            System.out.println("Got exception creating SSL:");
+            e.printStackTrace();
+        }
+        System.out.println("OpenSSL createOpenSSL createPKCS7");
+        PKCS7.createPKCS7(runtime, _OpenSSL);
+        System.out.println("OpenSSL createOpenSSL createPKCS5");
+        PKCS5.createPKCS5(runtime, _OpenSSL);
+
+        System.out.println("OpenSSL createOpenSSL require version");
+        runtime.getLoadService().require("jopenssl/version");
+
+        // MRI 1.8.7 :
+        // OpenSSL::VERSION: "1.0.0"
+        // OpenSSL::OPENSSL_VERSION: "OpenSSL 1.0.1c 10 May 2012"
+        // OpenSSL::OPENSSL_VERSION_NUMBER: 268439615
+        // MRI 1.9.3 / 2.2.3 :
+        // OpenSSL::VERSION: "1.1.0"
+        // OpenSSL::OPENSSL_VERSION: "OpenSSL 1.0.1f 6 Jan 2014"
+        // OpenSSL::OPENSSL_VERSION_NUMBER: 268439663
+        // OpenSSL::OPENSSL_LIBRARY_VERSION: ""OpenSSL 1.0.2d 9 Jul 2015"
+        // OpenSSL::FIPS: false
+
+        System.out.println("OpenSSL createOpenSSL check version");
+        final byte[] version = { '1','.','1','.','0' };
+        final boolean ruby18 = runtime.getInstanceConfig().getCompatVersion() == CompatVersion.RUBY1_8;
+        if ( ruby18 ) version[2] = '0'; // 1.0.0 compatible on 1.8
+
+        System.out.println("OpenSSL createOpenSSL set version");
+        _OpenSSL.setConstant("VERSION", StringHelper.newString(runtime, version));
+
+        System.out.println("OpenSSL createOpenSSL get Jopenssl version");
+        final RubyModule _Jopenssl = runtime.getModule("Jopenssl");
+        final RubyModule _Version = (RubyModule) _Jopenssl.getConstantAt("Version");
+        final RubyString jVERSION = _Version.getConstantAt("VERSION").asString();
+
+        final byte[] JRuby_OpenSSL_ = { 'J','R','u','b','y','-','O','p','e','n','S','S','L',' ' };
+        final int OPENSSL_VERSION_NUMBER = 999999999; // NOTE: smt more useful?
+
+        ByteList OPENSSL_VERSION = new ByteList( jVERSION.getByteList().length() + JRuby_OpenSSL_.length );
+        OPENSSL_VERSION.setEncoding( jVERSION.getEncoding() );
+        OPENSSL_VERSION.append( JRuby_OpenSSL_ );
+        OPENSSL_VERSION.append( jVERSION.getByteList() );
+
+        final RubyString VERSION;
+        _OpenSSL.setConstant("OPENSSL_VERSION", VERSION = runtime.newString(OPENSSL_VERSION));
+        _OpenSSL.setConstant("OPENSSL_VERSION_NUMBER", runtime.newFixnum(OPENSSL_VERSION_NUMBER));
+        if ( ! ruby18 ) {
+            // MRI 2.3 tests do: /\AOpenSSL +0\./ !~ OpenSSL::OPENSSL_LIBRARY_VERSION
+            _OpenSSL.setConstant("OPENSSL_LIBRARY_VERSION", VERSION);
+            _OpenSSL.setConstant("OPENSSL_FIPS", runtime.getFalse());
+        }
+        System.out.println("OpenSSL createOpenSSL...OK");
+    }
+
+    static RubyClass _OpenSSLError(final Ruby runtime) {
+        return runtime.getModule("OpenSSL").getClass("OpenSSLError");
+    }
+
+    // OpenSSL module methods :
+
+    @JRubyMethod(name = "errors", meta = true)
+    public static IRubyObject errors(IRubyObject self) {
+        final Ruby runtime = self.getRuntime();
+        RubyArray result = runtime.newArray();
+        for (Map.Entry<Integer, String> e : X509.getErrors().entrySet()) {
+            result.add( runtime.newString( e.getValue() ) );
+        }
+        return result;
+    }
+
+    @JRubyMethod(name = "debug", meta = true)
+    public static IRubyObject getDebug(IRubyObject self) {
+        return (IRubyObject) getDebug((RubyModule) self);
+    }
+
+    private static Object getDebug(RubyModule self) {
+        return self.getInternalVariable("debug");
+    }
+
+    @JRubyMethod(name = "debug=", meta = true)
+    public static IRubyObject setDebug(IRubyObject self, IRubyObject debug) {
+        ((RubyModule) self).setInternalVariable("debug", debug);
+        OpenSSL.debug = debug.isTrue();
+        return debug;
+    }
+
+    @JRubyMethod(name = "Digest", meta = true)
+    public static IRubyObject Digest(final IRubyObject self, final IRubyObject name) {
+        // OpenSSL::Digest("MD5") -> OpenSSL::Digest::MD5
+        final Ruby runtime = self.getRuntime();
+        final RubyClass Digest = runtime.getModule("OpenSSL").getClass("Digest");
+        return Digest.getConstantAt( name.asString().toString() );
+    }
+
+    // API "stubs" in JRuby-OpenSSL :
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject deprecated_warning_flag(final IRubyObject self) {
+        return self.getRuntime().getNil(); // no-op in JRuby-OpenSSL
+    }
+
+    @JRubyMethod(meta = true, rest = true) // check_func(func, header)
+    public static IRubyObject check_func(final IRubyObject self, final IRubyObject[] args) {
+        return self.getRuntime().getNil(); // no-op in JRuby-OpenSSL
+    }
+
+    // Added in 2.0; not masked because it does nothing anyway (there's no reader in MRI)
+    @JRubyMethod(name = "fips_mode=", meta = true)
+    public static IRubyObject set_fips_mode(ThreadContext context, IRubyObject self, IRubyObject value) {
+        if ( value.isTrue() ) {
+            warn(context, "WARNING: FIPS mode not supported on JRuby-OpenSSL");
+        }
+        return value;
+    }
+
+    // internal (package-level) helpers :
+
+    private static boolean debug;
+
+    // on by default, warnings can be disabled using -Djruby.openssl.warn=false
+    private static boolean warn = true;
+
+    static boolean isDebug() { return debug; }
+
+    static void debugStackTrace(final Throwable e) {
+        if ( isDebug() ) e.printStackTrace(System.out);
+    }
+
+    static void debug(final String msg) {
+        if ( isDebug() ) System.out.println(msg);
+    }
+
+    static void debug(final String msg, final Throwable e) {
+        if ( isDebug() ) System.out.println(msg + ' ' + e);
+    }
+
+    static boolean isDebug(final Ruby runtime) {
+        final RubyModule OpenSSL = runtime.getModule("OpenSSL");
+        if ( OpenSSL == null ) return debug; // debug early on
+        return getDebug( OpenSSL ) == runtime.getTrue();
+    }
+
+    static void debugStackTrace(final Ruby runtime, final Throwable e) {
+        if ( isDebug(runtime) ) e.printStackTrace(runtime.getOut());
+    }
+
+    static void debug(final Ruby runtime, final String msg) {
+        if ( isDebug(runtime) ) runtime.getOut().println(msg);
+    }
+
+    static void debug(final Ruby runtime, final String msg, final Throwable e) {
+        if ( isDebug(runtime) ) runtime.getOut().println(msg + ' ' + e);
+    }
+
+    static void warn(final ThreadContext context, final String msg) {
+        warn(context, RubyString.newString(context.runtime, msg));
+    }
+
+    static void warn(final ThreadContext context, final IRubyObject msg) {
+        if ( warn ) context.runtime.getModule("OpenSSL").callMethod(context, "warn", msg);
+    }
+
+    private static String javaVersion(final String def) {
+        final String javaVersionProperty =
+                SafePropertyAccessor.getProperty("java.version", def);
+        if (javaVersionProperty == "0") { // Android
+            return "1.7.0";
+        } else {
+            return javaVersionProperty;
+        }
+    }
+
+    static boolean javaVersion7(final boolean atLeast) {
+        final int gt = "1.7".compareTo( javaVersion("0.0").substring(0, 3) );
+        return atLeast ? gt <= 0 : gt == 0;
+    }
+
+    static boolean javaVersion8(final boolean atLeast) {
+        final int gt = "1.8".compareTo( javaVersion("0.0").substring(0, 3) );
+        return atLeast ? gt <= 0 : gt == 0;
+    }
+
+    private static String javaName(final String def) {
+        // Sun Java 6 or Oracle Java 7/8
+        // "Java HotSpot(TM) Server VM" or "Java HotSpot(TM) 64-Bit Server VM"
+        // OpenJDK :
+        // "OpenJDK 64-Bit Server VM"
+        return SafePropertyAccessor.getProperty("java.vm.name", def);
+    }
+
+    static boolean javaHotSpot() {
+        return javaName("").contains("HotSpot(TM)");
+    }
+
+    static boolean javaOpenJDK() {
+        return javaName("").contains("OpenJDK");
+    }
+
+    //
+
+    static IRubyObject to_der_if_possible(final ThreadContext context, IRubyObject obj) {
+        if ( ! obj.respondsTo("to_der"))  return obj;
+        return obj.callMethod(context, "to_der");
+    }
+
+    //
+
+    static String bcExceptionMessage(NoSuchProviderException ex) {
+        return "You need to configure JVM/classpath to enable BouncyCastle Security Provider: " + ex;
+    }
+
+    static String bcExceptionMessage(NoClassDefFoundError ex) {
+        return "You need to configure JVM/classpath to enable BouncyCastle Security Provider: " + ex;
+    }
+
+}

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

@@ -10,6 +10,7 @@
 class Object
   def with_large_stack(opts = {}, &block)
     opts = {:size => opts} if opts.is_a? Integer
+    opts = {:name => opts} if opts.is_a? String
     opts = {:name => 'Block with large stack'}.update(opts)
     exception = nil
     result = nil
@@ -23,6 +24,7 @@ end
 class Thread
   def self.with_large_stack(opts = {}, &block)
     opts = {:size => opts} if opts.is_a? Integer
+    opts = {:name => opts} if opts.is_a? String
     stack_size_kb = opts.delete(:size) || 64
     name = opts.delete(:name) || 'Thread with large stack'
     raise "Unknown option(s): #{opts.inspect}" unless opts.empty?

data/lib/ruboto/util/emulator.rb

@@ -5,6 +5,8 @@ require 'ruboto/sdk_locations'
 module Ruboto
   module Util
     module Emulator
+      include Ruboto::Util::Verify
+
       ON_WINDOWS = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw/i)
       ON_MAC_OS_X = RbConfig::CONFIG['host_os'] =~ /^darwin/
       ON_LINUX = RbConfig::CONFIG['host_os'] =~ /linux/
@@ -19,7 +21,7 @@ module Ruboto
         STDOUT.sync = true
         if RbConfig::CONFIG['host_cpu'] == 'x86_64'
           if ON_MAC_OS_X
-            emulator_cmd = '-m "emulator64-(arm|x86)"'
+            emulator_cmd = '-m "emulator64-(crash-service|arm|x86)"'
           elsif ON_LINUX
             emulator_cmd = '-r "emulator64-(arm|x86)"'
           else
@@ -29,7 +31,9 @@ module Ruboto
           emulator_cmd = 'emulator-arm'
         end
 
-        avd_name = "Android_#{sdk_level_name(sdk_level)}"
+        emulator_config = verify_ruboto_config['emulator']
+        avd_name = (emulator_config && emulator_config['name']) || "Android_#{sdk_level_name(sdk_level)}"
+        android_device = (emulator_config && emulator_config['device']) || "Nexus One"
         new_snapshot = false
 
         if `adb devices` =~ /emulator-5554/
@@ -57,8 +61,8 @@ module Ruboto
         # FIXME(uwe):  Change use of "killall" to use the Ruby Process API
         loop do
           emulator_opts = '-partition-size 256'
-          emulator_opts << ' -noskin'
-          emulator_opts << ' -no-snapshot-load' if no_snapshot
+          emulator_opts << ' -noskin' unless android_device
+          emulator_opts << ' -no-snapshot' if no_snapshot
           if !ON_MAC_OS_X && !ON_WINDOWS && ENV['DISPLAY'].nil?
             emulator_opts << ' -no-window -no-audio'
           end
@@ -90,15 +94,13 @@ module Ruboto
           avd_home = "#{ENV['HOME'].gsub('\\', '/')}/.android/avd/#{avd_name}.avd"
           manifest_file = 'AndroidManifest.xml'
           large_heap = (!File.exists?(manifest_file)) || (File.read(manifest_file) =~ /largeHeap/)
-          heap_size = large_heap ? 256 : 48
+          heap_size = large_heap ? 256 : 64
 
-          unless File.exists? avd_home
-            create_avd(avd_home, avd_name, heap_size, sdk_level)
-            new_snapshot = true
+          if File.exists? avd_home
+            patch_config_ini(avd_home, heap_size, no_snapshot)
           else
-            # FIXME(uwe):  Patch old emulator AVDs.  Remove December 2016.
-            patch_config_ini(avd_home, heap_size)
-            # EMXIF
+            create_avd(avd_home, avd_name, android_device, heap_size, sdk_level)
+            new_snapshot = true
           end
 
           puts "Start emulator #{avd_name}#{' without snapshot' if no_snapshot}"
@@ -121,7 +123,7 @@ module Ruboto
           `killall -0 #{emulator_cmd} 2> /dev/null`
           if $? != 0
             puts 'Unable to start the emulator.  Retrying without loading snapshot.'
-            system "emulator -no-snapshot-load -avd #{avd_name} #{emulator_opts} #{'&' unless ON_WINDOWS}"
+            system "emulator -no-snapshot -avd #{avd_name} #{emulator_opts} #{'&' unless ON_WINDOWS}"
             10.times do |i|
               `killall -0 #{emulator_cmd} 2> /dev/null`
               if $? == 0
@@ -191,7 +193,7 @@ EOF
         puts "Emulator #{avd_name} started OK."
       end
 
-      def create_avd(avd_home, avd_name, heap_size, sdk_level)
+      def create_avd(avd_home, avd_name, android_device, heap_size, sdk_level)
         puts "Creating AVD #{avd_name}"
 
         target = `android list target`.split(/----------\n/).
@@ -224,7 +226,12 @@ EOF
           abi_opt = '--abi armeabi-v7a'
         end
 
-        skin = 'HVGA'
+        ruboto_config_filename = 'ruboto.yml'
+        if File.exists?(ruboto_config_filename)
+          ruboto_config = YAML.load_file(ruboto_config_filename)
+          skin = ruboto_config['emulator'] && ruboto_config['emulator']['skin']
+        end
+        skin ||= '768x1280'
         # skin_filename = "#{Ruboto::SdkLocations::ANDROID_HOME}/platforms/android-#{sdk_level}/skins/#{skin}/hardware.ini"
         # if File.exists?(skin_filename)
         #   old_skin_config = File.read(skin_filename)
@@ -234,7 +241,7 @@ EOF
         #   File.write(skin_filename, new_skin_config) if new_skin_config != old_skin_config
         # end
 
-        puts `echo no | android create avd -a -n #{avd_name} -t android-#{sdk_level} #{abi_opt} -c 64M -s #{skin} -d "Nexus One"`
+        puts `echo no | android create avd -a -n #{avd_name} -t android-#{sdk_level} #{abi_opt} -c 64M #{"-s #{skin}" if skin} -d "#{android_device}"`
 
         if $? != 0
           puts 'Failed to create AVD.'
@@ -242,25 +249,34 @@ EOF
         end
         patch_config_ini(avd_home, heap_size)
 
-        # hw_config_file_name = "#{avd_home}/hardware-qemu.ini"
-        # if File.exists?(hw_config_file_name)
-        #   old_hw_config = File.read(hw_config_file_name)
-        #   new_hw_config = old_hw_config.gsub(/vm.heapSize=([0-9]*)/) { |m| $1.to_i < heap_size ? "vm.heapSize=#{heap_size}" : m }
-        #   File.write(hw_config_file_name, new_hw_config) if new_hw_config != old_hw_config
-        # end
+        hw_config_file_name = "#{avd_home}/hardware-qemu.ini"
+        if File.exists?(hw_config_file_name)
+          old_hw_config = File.read(hw_config_file_name)
+          new_hw_config = old_hw_config.dup
+          update_heap_size(new_hw_config, heap_size)
+          File.write(hw_config_file_name, new_hw_config) if new_hw_config != old_hw_config
+        end
       end
 
-      def patch_config_ini(avd_home, heap_size)
+      def update_heap_size(new_hw_config, heap_size)
+        old_heap = read_property(new_hw_config, 'vm.heapSize')
+        if old_heap.nil? || old_heap.to_i < heap_size
+          add_property(new_hw_config, 'vm.heapSize', heap_size)
+        end
+      end
+
+      def patch_config_ini(avd_home, heap_size, no_snapshot)
         avd_config_file_name = "#{avd_home}/config.ini"
         old_avd_config = File.read(avd_config_file_name)
         new_avd_config = old_avd_config.dup
-        new_avd_config.gsub!(/vm.heapSize=([0-9]*)/) { |m| $1.to_i < heap_size ? "vm.heapSize=#{heap_size}" : m }
+        update_heap_size(new_avd_config, heap_size)
         # add_property(new_avd_config, 'hw.device.manufacturer', 'Generic')
         # add_property(new_avd_config, 'hw.device.name', '3.2" HVGA slider (ADP1)')
         # add_property(new_avd_config, 'hw.keyboard.lid', 'no')
-        add_property(new_avd_config, 'hw.lcd.density', '160')
+        # add_property(new_avd_config, 'hw.lcd.density', '160')
         add_property(new_avd_config, 'hw.mainKeys', 'no')
         # add_property(new_avd_config, 'hw.sdCard', 'yes')
+        add_property(new_avd_config, 'snapshot.present', (!no_snapshot).to_s)
         File.write(avd_config_file_name, new_avd_config) if new_avd_config != old_avd_config
       end
 
@@ -268,17 +284,23 @@ EOF
         `adb get-state`.gsub(/^WARNING:.*$/, '').chomp == 'device'
       end
 
-      def add_property(new_avd_config, property_name, value)
+      def read_property(config, property_name)
+        pattern = /^#{property_name}=(.*)$/
+        config =~ pattern
+        $1
+      end
+
+      def add_property(config, property_name, value)
         pattern = /^#{property_name}=(.*)$/
-        property = "#{property_name}=#{value}"
-        if new_avd_config =~ pattern
-          if $1 != value
-            new_avd_config.gsub! pattern, property
-            puts "Changed property: #{property}"
+        new_property = "#{property_name}=#{value}"
+        if (old_property = read_property(config, property_name))
+          if old_property != value
+            config.gsub! pattern, new_property
+            puts "Changed property: #{new_property} (was #{old_property.inspect})"
           end
         else
-          new_avd_config << "#{property}\n"
-          puts "Added property: #{property}"
+          config << "#{new_property}\n"
+          puts "Added property: #{new_property}"
         end
       end
     end