ruboto 0.13.0 → 0.14.0

data/assets/src/org/ruboto/SplashActivity.java

@@ -0,0 +1,394 @@
+package org.ruboto;
+
+import android.app.Activity;
+import android.app.DownloadManager;
+import android.app.DownloadManager.Query;
+import android.app.DownloadManager.Request;
+import android.app.ProgressDialog;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnCancelListener;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.view.View;
+import android.widget.TextView;
+import android.widget.Toast;
+
+
+public class SplashActivity extends Activity {
+    private int splash = 0;
+    private ProgressDialog loadingDialog;
+    private boolean dialogCancelled = false;
+    private BroadcastReceiver receiver;
+    private long enqueue;
+    java.io.File localFile;
+    private static final int INSTALL_REQUEST_CODE = 4242;
+
+    public void onCreate(Bundle bundle) {
+	Log.d("SplashActivity onCreate:");
+        localFile = new java.io.File(getFilesDir(), RUBOTO_APK);
+	try {
+	    splash = Class.forName(getPackageName() + ".R$layout").getField("splash").getInt(null);
+	} catch (Exception e) {
+	    splash = -1;
+	}
+        if (!JRubyAdapter.isInitialized()) {
+	    initJRuby(true);
+	}
+	super.onCreate(bundle);
+    }
+
+    public void onResume() {
+        Log.d("onResume: ");
+        if (!JRubyAdapter.isInitialized() && receiver == null) {
+	    registerPackageInstallReceiver();
+        }
+	super.onResume();
+    }
+    
+    public void onPause() {
+        Log.d("onPause: ");
+        if (receiver != null) {
+            unregisterReceiver(receiver);
+            receiver = null;
+        }
+        super.onPause();
+    }
+
+    public void onDestroy() {
+        Log.d("onDestroy: ");
+        super.onDestroy();
+        if (dialogCancelled) {
+            System.runFinalizersOnExit(true);
+            System.exit(0);
+        }
+    }
+    
+    private void initJRuby(final boolean firstTime) {
+        showProgress();
+        new Thread(new Runnable() {
+		public void run() {
+		    final boolean jrubyOk = JRubyAdapter.setUpJRuby(SplashActivity.this);
+		    if (jrubyOk) {
+			Log.d("onResume: JRuby OK");
+			startUserActivity();
+			hideProgress();
+			finish();
+		    } else {
+			registerPackageInstallReceiver();
+			runOnUiThread(new Runnable() {
+				public void run() {
+				    if (localFile.exists()) {
+					installDownload();
+				    } else {
+					if (firstTime) {
+					    Log.d("onResume: Checking JRuby - IN UI thread");
+					    try {
+						setContentView(Class.forName(getPackageName() + ".R$layout").getField("get_ruboto_core").getInt(null));
+						if (hasInternetPermission()) {
+						    getRubotoCore(null);
+						    return;
+						}
+					    } catch (Exception e) {
+					    }
+					} else {
+					    Toast.makeText(SplashActivity.this,"Failed to initialize Ruboto Core.",Toast.LENGTH_LONG).show();
+					    try {
+						TextView textView = (TextView) findViewById(Class.forName(getPackageName() + ".R$id").getField("text").getInt(null));
+						textView.setText("Woops!  Ruboto Core was installed, but it failed to initialize properly!  I am not sure how to proceed from here.  If you can, please file an error report at http://ruboto.org/");
+					    } catch (Exception e) {
+					    }
+					}
+				    }
+				    hideProgress();
+				}
+			    });
+		    }
+		}
+	    }).start();
+    }
+
+    private static final String RUBOTO_APK = "RubotoCore-release.apk";
+    private static final String RUBOTO_URL = "http://ruboto.org/downloads/" + RUBOTO_APK;
+
+    // Called when the button is pressed.
+    public void getRubotoCore(View view) {
+        try {
+            if (hasInternetPermission() && canInstallFromUnknownSources()) {
+                if (enqueue <= 0) {
+                    DownloadManager dm = (DownloadManager) getSystemService(DOWNLOAD_SERVICE);
+                    Request request = new Request(Uri.parse(RUBOTO_URL));
+                    enqueue = dm.enqueue(request);
+                    hideProgress();
+                    showDownloadProgress("Downloading RubotoCore...");
+                    new Thread(new Runnable() {
+			    public void run() {
+				while (loadingDialog != null && enqueue > 0) {
+				    // FIXME(uwe):  Also set total bytes and bytes downloaded.
+				    loadingDialog.setProgress(getProgressPercentage());
+				    try {
+					Thread.sleep(1000);
+				    } catch (InterruptedException ie) {
+					Log.e("Interupted!");
+				    }
+				}
+			    }
+			}).start();
+                }
+                return;
+            }
+        } catch (Exception e) {
+            Log.e("Exception in direct RubotoCore download: " + e);
+        }
+        try {
+            startActivity(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("market://details?id=org.ruboto.core")));
+        } catch (android.content.ActivityNotFoundException anfe) {
+            Intent intent = new Intent(android.content.Intent.ACTION_VIEW, Uri.parse(RUBOTO_URL));
+            startActivity(intent);
+        }
+    }
+
+    private void showProgress() {
+        if (loadingDialog == null) {
+            if (splash > 0) {
+                Log.i("Showing splash");
+                requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
+                setContentView(splash);
+            } else {
+                Log.i("Showing progress");
+                loadingDialog = ProgressDialog.show(this, null, "Starting...", true, true);
+                loadingDialog.setCanceledOnTouchOutside(false);
+                loadingDialog.setOnCancelListener(new OnCancelListener() {
+			public void onCancel(DialogInterface dialog) {
+			    dialogCancelled = true;
+			    finish();
+			}
+		    });
+            }
+        }
+    }
+
+    private void showDownloadProgress(String message) {
+        if (loadingDialog == null) {
+            if (splash > 0) {
+                Log.i("Showing splash");
+                requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
+                setContentView(splash);
+            } else {
+                Log.i("Showing progress");
+                loadingDialog = new ProgressDialog(this);
+                loadingDialog.setTitle(null);
+                loadingDialog.setMessage(message);
+                loadingDialog.setIndeterminate(false);
+                loadingDialog.setMax(100);
+                loadingDialog.setProgressStyle(android.app.ProgressDialog.STYLE_HORIZONTAL);
+                loadingDialog.setCancelable(true);
+                loadingDialog.setCanceledOnTouchOutside(false);
+                loadingDialog.setOnCancelListener(new OnCancelListener() {
+			public void onCancel(DialogInterface dialog) {
+			    dialogCancelled = true;
+			    finish();
+			}
+		    });
+                loadingDialog.show();
+            }
+        } else {
+            loadingDialog.setMessage(message);
+        }
+    }
+
+    private void hideProgress() {
+        if (loadingDialog != null) {
+            Log.d("Hide progress");
+            loadingDialog.dismiss();
+            loadingDialog = null;
+        }
+    }
+
+    private void registerPackageInstallReceiver() {
+        receiver = new BroadcastReceiver(){
+		public void onReceive(Context context, Intent intent) {
+		    Log.d("Received intent: " + intent + " (" + intent.getExtras() + ")");
+		    if (DownloadManager.ACTION_DOWNLOAD_COMPLETE.equals(intent.getAction())) {
+			long downloadId = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, 0);
+			if (downloadId == enqueue) {
+			    if (localFile.exists()) {
+				return;
+			    }
+			    Query query = new Query();
+			    query.setFilterById(enqueue);
+			    DownloadManager dm = (DownloadManager) getSystemService(DOWNLOAD_SERVICE);
+			    Cursor c = dm.query(query);
+			    if (c.moveToFirst()) {
+				hideProgress();
+				int status = c.getInt(c.getColumnIndex(DownloadManager.COLUMN_STATUS));
+				if (DownloadManager.STATUS_SUCCESSFUL == status) {
+				    storeDownload(dm, downloadId);
+				    installDownload();
+				} else {
+				    int reason = c.getInt(c.getColumnIndex(DownloadManager.COLUMN_REASON));
+				    Toast.makeText(context,"Download failed (" + status + "): " + reason, Toast.LENGTH_LONG).show();
+				}
+			    } else {
+				Toast.makeText(context,"Download diappeared!", Toast.LENGTH_LONG).show();
+			    }
+			    c.close();
+			}
+		    } else if (Intent.ACTION_PACKAGE_ADDED.equals(intent.getAction())) {
+			if (intent.getData().toString().equals("package:org.ruboto.core")) {
+			    Toast.makeText(context,"Ruboto Core is now installed.",Toast.LENGTH_LONG).show();
+			    deleteFile(RUBOTO_APK);
+			    if (receiver != null) {
+        	                unregisterReceiver(receiver);
+        	                receiver = null;
+			    }
+			    initJRuby(false);
+			} else {
+			    Toast.makeText(context,"Installed: " + intent.getData().toString(),Toast.LENGTH_LONG).show();
+			}
+		    }
+		}
+	    };
+        IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
+        filter.addDataScheme("package");
+        registerReceiver(receiver, filter);
+        IntentFilter download_filter = new IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE);
+        registerReceiver(receiver, download_filter);
+    }
+
+    private void storeDownload(DownloadManager dm, long downloadId) {
+        try {
+            android.os.ParcelFileDescriptor file = dm.openDownloadedFile(downloadId);
+            java.io.InputStream fileStream = new java.io.FileInputStream(file.getFileDescriptor());
+            java.io.FileOutputStream fos = openFileOutput(RUBOTO_APK, MODE_WORLD_READABLE);
+            byte[] buffer = new byte[1024];
+            int length;
+            while((length = fileStream.read(buffer)) > 0) {
+                fos.write(buffer, 0, length);
+            }
+            fos.flush();
+            fileStream.close();
+            fos.close();
+            dm.remove(downloadId);
+            enqueue = 0;
+        } catch (java.io.IOException ioe) {
+            Log.e("Exception copying RubotoCore: " + ioe);
+            Toast.makeText(this, "Exception copying RubotoCore: " + ioe, Toast.LENGTH_LONG).show();
+        }
+    }
+
+    // FIXME(uwe): Remove when we stop supporting Android < 4.0.3
+    private void installDownload() {
+        if (android.os.Build.VERSION.SDK_INT < 15) {
+            installDownload_10();
+        } else {
+            installDownload_15();
+        }
+    }
+    // EMXIF
+
+    // FIXME(uwe): Remove when we stop supporting Android < 4.0.3
+    private void installDownload_10() {
+        Uri uri = Uri.fromFile(localFile);
+        SplashActivity.this.grantUriPermission("com.android.packageinstaller", uri, Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        Intent installIntent = new Intent(Intent.ACTION_VIEW);
+        installIntent.setDataAndType(uri, "application/vnd.android.package-archive");
+        installIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        startActivityForResult(installIntent, INSTALL_REQUEST_CODE);
+    }
+    // EMXIF
+
+    // FIXME(uwe):  Use constants when we stop suporting Android < 4.0.3
+    private void installDownload_15() {
+        Uri uri = Uri.fromFile(localFile);
+        SplashActivity.this.grantUriPermission("com.android.packageinstaller", uri, Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        Intent installIntent = new Intent("android.intent.action.INSTALL_PACKAGE"); // Intent.ACTION_INSTALL_PACKAGE
+        installIntent.setDataAndType(uri, "application/vnd.android.package-archive");
+        installIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        // FIXME(uwe): Remove when we stop supporting Android api level < 16
+        installIntent.putExtra("android.intent.extra.ALLOW_REPLACE", true); // Intent.EXTRA_ALLOW_REPLACE
+        // EMXIF
+        installIntent.putExtra("android.intent.extra.INSTALLER_PACKAGE_NAME", getPackageName()); // Intent.EXTRA_INSTALLER_PACKAGE_NAME
+        installIntent.putExtra("android.intent.extra.NOT_UNKNOWN_SOURCE", true); // Intent.EXTRA_NOT_UNKNOWN_SOURCE
+        installIntent.putExtra("android.intent.extra.RETURN_RESULT", true); // Intent.EXTRA_RETURN_RESULT
+        startActivityForResult(installIntent, INSTALL_REQUEST_CODE);
+    }
+    // EMXIF
+
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        Log.d("onActivityResult: " + requestCode + ", " + resultCode + ", " + data);
+        Log.d("onActivityResult: " + INSTALL_REQUEST_CODE + ", " + RESULT_OK + ", " + RESULT_CANCELED);
+        if (requestCode == INSTALL_REQUEST_CODE) {
+            if (resultCode == RESULT_OK) {
+                Log.d("onActivityResult: Install OK.");
+            } else if (resultCode == RESULT_CANCELED) {
+                Log.d("onActivityResult: Install canceled.");
+                // FIXME(uwe): Maybe show a dialog explaining that RubotoCore is needed and try again?
+                deleteFile(RUBOTO_APK);
+                if (!JRubyAdapter.isInitialized()) {
+                    finish();
+                }
+                // EMXIF
+            } else {
+                Log.e("onActivityResult: resultCode: " + resultCode);
+            }
+        }
+        super.onActivityResult(requestCode, resultCode, data);
+    }
+
+    private boolean hasInternetPermission() {
+        String permission = "android.permission.INTERNET";
+        int res = checkCallingOrSelfPermission(permission);
+        return (res == PackageManager.PERMISSION_GRANTED);
+    }
+
+    private boolean canInstallFromUnknownSources() {
+        Uri settingsUri = Settings.Secure.CONTENT_URI;
+        String[] projection = new String[]{Settings.System.VALUE};
+        String selection = Settings.Secure.NAME + " = ? AND " + Settings.Secure.VALUE + " = ?";
+
+        // FIXME(uwe): Use android.provider.Settings.Global.INSTALL_NON_MARKET_APPS
+        //             when we stop supporting Android api level < 17
+        String[] selectionArgs = {Settings.Secure.INSTALL_NON_MARKET_APPS, String.valueOf(1)};
+        // EMXIF
+
+        Cursor query = getContentResolver().query(settingsUri, projection,
+						  selection, selectionArgs, null);
+        return query.getCount() == 1;
+    }
+
+    // Get the downloaded percent
+    private int getProgressPercentage() {
+        int downloadedBytesSoFar = 0, totalBytes = 0, percentage = 0;
+        DownloadManager dm = (DownloadManager) getSystemService(DOWNLOAD_SERVICE);
+        try {
+            Cursor c = dm.query(new DownloadManager.Query().setFilterById(enqueue));
+            if (c.moveToFirst()) {
+                int soFarIndex =c.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR);
+                downloadedBytesSoFar = (int) c.getLong(soFarIndex);
+                int totalSizeIndex = c.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES);
+                totalBytes = (int) c.getLong(totalSizeIndex);
+            }
+            System.out.println("PERCEN ------" + downloadedBytesSoFar
+			       + " ------ " + totalBytes + "****" + percentage);
+            percentage = (downloadedBytesSoFar * 100 / totalBytes);
+            System.out.println("percentage % " + percentage);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return percentage;
+    }
+
+    private void startUserActivity() {
+      if (getIntent().hasExtra(Intent.EXTRA_INTENT)) {
+        startActivity((Intent)getIntent().getParcelableExtra(Intent.EXTRA_INTENT));
+      }
+    }
+
+}

data/assets/src/ruboto/activity.rb

@@ -14,9 +14,24 @@ require 'ruboto/package'
 #
 module Ruboto
   module Context
-    def start_ruboto_dialog(remote_variable, theme=Java::android.R.style::Theme_Dialog, &block)
-      java_import 'org.ruboto.RubotoDialog'
-      start_ruboto_activity(remote_variable, RubotoDialog, theme, &block)
+    def start_ruboto_dialog(class_name = nil, options = nil, &block)
+      if options.nil?
+        if class_name.is_a?(Hash)
+          options = class_name
+          class_name = nil
+        else
+          options = {}
+        end
+      end
+
+      unless options.key?(:java_class)
+        java_import 'org.ruboto.RubotoDialog'
+        options[:java_class] = RubotoDialog
+      end
+
+      options[:theme] = android.R.style::Theme_Dialog unless options.key?(:theme)
+
+      start_ruboto_activity(class_name, options, &block)
     end
 
     def start_ruboto_activity(class_name = nil, options = nil, &block)
@@ -43,6 +58,7 @@ module Ruboto
       # EMXIF
 
       script_name = options.delete(:script)
+      extras = options.delete(:extras)
       raise "Unknown options: #{options}" unless options.empty?
 
       if class_name.nil? && block_given?
@@ -50,6 +66,8 @@ module Ruboto
             "#{java_class.name.split('::').last}_#{source_descriptor(block)[0].split('/').last.gsub(/[.-]+/, '_')}_#{source_descriptor(block)[1]}"
       end
 
+      class_name = class_name.to_s
+
       if Object.const_defined?(class_name)
         Object.const_get(class_name).class_eval(&block) if block_given?
       else
@@ -60,6 +78,7 @@ module Ruboto
       i.putExtra(Ruboto::THEME_KEY, theme) if theme
       i.putExtra(Ruboto::CLASS_NAME_KEY, class_name) if class_name
       i.putExtra(Ruboto::SCRIPT_NAME_KEY, script_name) if script_name
+      extras.each { |k, v| i.putExtra(k.to_s, v) } if extras
       startActivity i
       self
     end

data/lib/ruboto/commands/base.rb

@@ -103,10 +103,10 @@ module Ruboto
                   update_assets
                   update_ruboto true
                   update_icons true
-                  update_classes nil, true
+                  update_classes nil, 'exclude'
                   update_jruby true if with_jruby
                   update_dx_jar true if with_jruby
-                  update_core_classes 'include'
+                  update_core_classes 'exclude'
 
                   log_action('Generating the default Activity and script') do
                     generate_inheriting_file 'Activity', activity, package
@@ -351,7 +351,7 @@ module Ruboto
                 update_jruby force
                 update_manifest nil, nil, force
                 update_icons force
-                update_core_classes 'include'
+                update_core_classes 'exclude'
                 update_bundle
               when 'jruby' then
                 update_jruby(params['force'].value, true) || abort
@@ -394,12 +394,14 @@ module Ruboto
             api_level = project_api_level
 
             option('target', 't') {
-              description 'sets the target Android API level for the emulator (example: -t android-15)'
+              extend Ruboto::Util::Emulator
+              description 'sets the target Android API level for the emulator'
+              examples Ruboto::Util::Emulator::API_LEVEL_TO_VERSION.keys.join(', ')
               required unless api_level
               argument :required
               default(api_level) if api_level
               cast {|t| t =~ /^(\d+)$/ ? "android-#$1" : t}
-              validate {|t| t =~ /^android-\d+$/}
+              validate {|t| t =~ /^android-(\d+)$/ && sdk_level_name($1.to_i)}
             }
 
             def run

data/lib/ruboto/util/emulator.rb

@@ -6,8 +6,8 @@ module Ruboto
       ON_WINDOWS = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw/i)
 
       API_LEVEL_TO_VERSION = {
-          7 => '2.1', 8 => '2.2', 10 => '2.3.3', 11 => '3.0', 12 => '3.1',
-          13 => '3.2', 14 => '4.0', 15 => '4.0.3', 16 => '4.1.2', 17 => '4.2.2',
+          10 => '2.3.3', 11 => '3.0', 12 => '3.1', 13 => '3.2', 14 => '4.0',
+          15 => '4.0.3', 16 => '4.1.2', 17 => '4.2.2',
       }
 
       def sdk_level_name(sdk_level)
@@ -52,6 +52,7 @@ module Ruboto
           puts 'No emulator is running.'
         end
 
+        # FIXME(uwe):  Change use of "killall" to use the Ruby Process API
         loop do
           `killall -0 #{emulator_cmd} 2> /dev/null`
           if $? == 0
@@ -83,16 +84,18 @@ module Ruboto
             abi_opt = '--abi armeabi'
           end
 
-          unless File.exists? "#{ENV['HOME']}/.android/avd/#{avd_name}.avd"
+          avd_home = "#{ENV['HOME'].gsub('\\', '/')}/.android/avd/#{avd_name}.avd"
+          unless File.exists? avd_home
             puts "Creating AVD #{avd_name}"
             puts `echo n | android create avd -a -n #{avd_name} -t android-#{sdk_level} #{abi_opt} -c 64M -s HVGA`
             if $? != 0
               puts 'Failed to create AVD.'
               exit 3
             end
-            avd_config_file_name = "#{ENV['HOME']}/.android/avd/#{avd_name}.avd/config.ini"
+            avd_config_file_name = "#{avd_home}/config.ini"
             old_avd_config = File.read(avd_config_file_name)
-            heap_size = (File.read('AndroidManifest.xml') =~ /largeHeap/) ? 256 : 48
+            manifest_file = 'AndroidManifest.xml'
+            heap_size = (File.exists?(manifest_file) && File.read(manifest_file) =~ /largeHeap/) ? 256 : 48
             new_avd_config = old_avd_config.gsub(/vm.heapSize=([0-9]*)/) { |m| p m; m.to_i < heap_size ? "vm.heapSize=#{heap_size}" : m }
             File.write(avd_config_file_name, new_avd_config) if new_avd_config != old_avd_config
             new_snapshot = true
@@ -163,7 +166,7 @@ module Ruboto
   for i in 1 2 3 4 5 6 7 8 9 10 ; do
     sleep 6
     adb shell input keyevent 82 >/dev/null 2>&1
-    if [ "$?" == "0" ] ; then
+    if [ "$?" = "0" ] ; then
       set -e
       adb shell input keyevent 82 >/dev/null 2>&1
       adb shell input keyevent 4 >/dev/null 2>&1

data/lib/ruboto/util/setup.rb

@@ -46,7 +46,7 @@ module Ruboto
         case RbConfig::CONFIG['host_os']
         when /^darwin(.*)/ then
           'macosx'
-        when /^linux(.*)/ then
+        when /linux/ then
           'linux'
         when /^mswin32|windows(.*)/ then
           'windows'
@@ -60,7 +60,7 @@ module Ruboto
         if RbConfig::CONFIG['host_os'] =~ /^mswin32|windows(.*)/
           'AppData/Local/Android/android-sdk'
         else
-          "android-sdk-#{android_package_os_id}"
+          ENV['ANDROID_HOME'] ? ENV['ANDROID_HOME'] : File.join(File.expand_path('~'), "android-sdk-#{android_package_os_id}")
         end
       end
 
@@ -68,7 +68,7 @@ module Ruboto
         case RbConfig::CONFIG['host_os']
         when /^darwin(.*)/ then
           '.profile'
-        when /^linux(.*)/ then
+        when /linux/ then
           '.bashrc'
         when /^mswin32|windows(.*)/ then
           'windows'
@@ -118,22 +118,22 @@ module Ruboto
 
       def check_for_emulator
         @emulator_loc = check_for('emulator', 'Android Emulator',
-                                  File.join(File.expand_path('~'), android_package_directory, 'tools', 'emulator'))
+                                  File.join(android_package_directory, 'tools', 'emulator'))
       end
 
       def check_for_platform_tools
         @adb_loc = check_for('adb', 'Android SDK Command adb',
-                             File.join(File.expand_path('~'), android_package_directory, 'platform-tools', 'adb'))
+                             File.join(android_package_directory, 'platform-tools', 'adb'))
       end
 
       def check_for_build_tools
         @dx_loc = check_for('dx', 'Android SDK Command dx',
-                            Dir[File.join(File.expand_path('~'), android_package_directory, 'build-tools', '*', 'dx')][-1])
+                            Dir[File.join(android_package_directory, 'build-tools', '*', 'dx')][-1])
       end
 
       def check_for_android_sdk
         @android_loc = check_for('android', 'Android Package Installer',
-                                 File.join(File.expand_path('~'), android_package_directory, 'tools', 'android'))
+                                 File.join(android_package_directory, 'tools', 'android'))
       end
 
       def check_for(cmd, pretty_name=nil, alt_dir=nil)
@@ -172,6 +172,7 @@ module Ruboto
         install_java(accept_all) unless @java_loc && @javac_loc
         install_ant(accept_all) unless @ant_loc
         install_android_sdk(accept_all) unless @android_loc
+        check_all(api_levels)
         install_android_tools(accept_all) unless @dx_loc && @adb_loc && @emulator_loc # build-tools, platform-tools and tools
         if @android_loc
           api_levels.each do |api_level|
@@ -183,7 +184,7 @@ module Ruboto
       def install_java(accept_all)
         case RbConfig::CONFIG['host_os']
         when /^darwin(.*)/
-        when /^linux(.*)/
+        when /linux/
         when /^mswin32|windows(.*)/
           # FIXME(uwe):  Detect and warn if we are not "elevated" with adminstrator rights.
           #set IS_ELEVATED=0
@@ -238,7 +239,7 @@ module Ruboto
       def install_ant(accept_all)
         case RbConfig::CONFIG['host_os']
         when /^darwin(.*)/
-        when /^linux(.*)/
+        when /linux/
         when /^mswin32|windows(.*)/
           # FIXME(uwe):  Detect and warn if we are not "elevated" with adminstrator rights.
           #set IS_ELEVATED=0
@@ -357,7 +358,7 @@ module Ruboto
                 system "wget http://dl.google.com/android/#{asdk_file_name}"
                 system "unzip #{'-o ' if accept_all}#{asdk_file_name}"
                 system "rm #{asdk_file_name}"
-              when /^linux(.*)/
+              when /linux/
                 asdk_file_name = "android-sdk_r#{get_tools_version}-#{android_package_os_id}.tgz"
                 system "wget http://dl.google.com/android/#{asdk_file_name}"
                 system "tar -xzf #{asdk_file_name}"
@@ -389,10 +390,12 @@ module Ruboto
             end
           end
           check_for_android_sdk
-          unless @android_loc
-            ENV['ANDROID_HOME'] = @android_loc.gsub(File::SEPARATOR, File::ALT_SEPARATOR || File::SEPARATOR)
+          unless @android_loc.nil?
+            ENV['ANDROID_HOME'] = (File.expand_path File.dirname(@android_loc)+"/..").gsub(File::SEPARATOR, File::ALT_SEPARATOR || File::SEPARATOR)
             puts "Setting the ANDROID_HOME environment variable to #{ENV['ANDROID_HOME']}"
-            system %Q{setx ANDROID_HOME "#{ENV['ANDROID_HOME']}"}
+            if RbConfig::CONFIG['host_os'] =~ /^mswin32|windows(.*)/
+              system %Q{setx ANDROID_HOME "#{ENV['ANDROID_HOME']}"}
+            end
             @missing_paths << "#{File.dirname(@android_loc)}"
           end
         end
@@ -406,7 +409,7 @@ module Ruboto
             a = STDIN.gets.chomp.upcase
           end
           if accept_all || a == 'Y' || a.empty?
-            update_cmd = "android --silent update sdk --no-ui --filter build-tools-#{get_tools_version('build-tool')},platform-tool,tool --force"
+            update_cmd = "android --silent update sdk --no-ui --filter build-tools-#{get_tools_version('build-tool')},platform-tool,tool -a --force"
             update_sdk(update_cmd, accept_all)
             check_for_build_tools
             check_for_platform_tools
@@ -489,11 +492,6 @@ module Ruboto
               config_file_name = File.expand_path("~/#{a.nil? || a.empty? ? path_setup_file : a}")
               old_config = File.read(config_file_name)
               new_config = old_config.dup
-
-              # FIXME(uwe): Remove for Ruboto > 0.13.0
-              new_config.gsub! /\n*# BEGIN Ruboto PATH setup\n.*?\n# END Ruboto PATH setup\n*/m, ''
-              # EMXIF
-
               new_config.gsub! /\n*# BEGIN Ruboto setup\n.*?\n# END Ruboto setup\n*/m, ''
               new_config << "\n\n# BEGIN Ruboto setup\n"
               new_config << "source #{rubotorc}\n"