ruboto-core 0.3.3 → 0.4.0

data/README.md

@@ -172,9 +172,9 @@ The main thing Ruboto offers you is the ability to write Ruby scripts to define
 
 Here's how it works:
 
-First of all, your scripts are found in `assets/scripts/` and the script name is the same as the name of your class, only under_scored instead of CamelCased. Android classes have all of these methods that get called in certain situations. `Activity.onDestroy()` gets called when the activity gets killed, for example. Save weird cases (like the "launching" methods that need to setup JRuby), to script the method onFooBar, you call the Ruby method handle_foo_bar on the Android object. In your scripts, they are defined as `$class_name`. That was really abstract, so here's an example. 
+First of all, your scripts are found in `src/` and the script name is the same as the name of your class, only under_scored instead of CamelCased. Android classes have all of these methods that get called in certain situations. `Activity.onDestroy()` gets called when the activity gets killed, for example. Save weird cases (like the "launching" methods that need to setup JRuby), to script the method onFooBar, you call the Ruby method handle_foo_bar on the Android object. In your scripts, they are defined as `$class_name`. That was really abstract, so here's an example.
 
-You generate an app with the option `--activity FooActivity`, which means that ruboto will generate a FooActivity for you. So you open `assets/scripts/foo_activity.rb` in your favorite text editor. If you want an activity that does nothing but Log when it gets launched and when it gets destroyed (in the onCreate and onPause methods). You want your script to look like this:
+You generate an app with the option `--activity FooActivity`, which means that ruboto will generate a FooActivity for you. So you open `src/foo_activity.rb` in your favorite text editor. If you want an activity that does nothing but Log when it gets launched and when it gets destroyed (in the onCreate and onPause methods). You want your script to look like this:
 
     require 'ruboto.rb' #scripts will not work without doing this
     $activity.handle_create do |bundle|
@@ -198,7 +198,7 @@ Each class has only one method that you can nest other calls inside of (ie. what
 
 The arguments passed to the block you give `handle_` methods are the same as the arguments that the java methods take. Consult the Android documentation.
 
-Activities also have some special methods defined to make things easier. The easiest way to get an idea of what they are is looking over the [demo scripts](http://github.com/ruboto/ruboto-irb/tree/master/assets/demo-scripts/). You can also read the [ruboto.rb file](http://github.com/ruboto/ruboto-core/blob/master/assets/assets/scripts/ruboto.rb) where everything is defined.
+Activities also have some special methods defined to make things easier. The easiest way to get an idea of what they are is looking over the [demo scripts](http://github.com/ruboto/ruboto-irb/tree/master/assets/demo-scripts/). You can also read the [ruboto.rb file](http://github.com/ruboto/ruboto-core/blob/master/assets/src/ruboto.rb) where everything is defined.
 
 Testing
 -------

data/Rakefile

@@ -1,3 +1,22 @@
+require 'rexml/document'
+
+PLATFORM_PROJECT = File.expand_path('tmp/RubotoCore', File.dirname(__FILE__))
+PLATFORM_DEBUG_APK = "#{PLATFORM_PROJECT}/bin/RubotoCore-debug.apk"
+PLATFORM_RELEASE_APK = "#{PLATFORM_PROJECT}/bin/RubotoCore-release.apk"
+MANIFEST_FILE = "AndroidManifest.xml"
+
+# FIXME(uwe):  Remove when we stop supporting JRuby 1.5.6
+if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
+  gem_spec = Gem::Specification.find_by_path 'jruby-jars'
+else
+  gem_spec = Gem.searcher.find('jruby-jars')
+end
+raise StandardError.new("Can't find Gem specification jruby-jars.") unless gem_spec
+JRUBY_JARS_VERSION = gem_spec.version
+ON_JRUBY_JARS_1_5_6 = JRUBY_JARS_VERSION == Gem::Version.new('1.5.6')
+# FIXME end
+
+
 task :default => :gem
 
 desc "Generate a gem"
@@ -17,3 +36,59 @@ task :test do
     require f.chomp('.rb')
   end
 end
+
+namespace :platform do
+  desc 'Remove Ruboto Core platform project'
+  task :clean do
+    FileUtils.rm_rf PLATFORM_PROJECT
+  end
+
+  desc 'Generate the Ruboto Core platform project'
+  task :project => PLATFORM_PROJECT
+
+  file PLATFORM_PROJECT do
+    sh "ruby -rubygems -I#{File.expand_path('lib', File.dirname(__FILE__))} bin/ruboto gen app --package org.ruboto.core --name RubotoCore --with-jruby #{'--with-psych' unless ON_JRUBY_JARS_1_5_6} --path #{PLATFORM_PROJECT}"
+    Dir.chdir(PLATFORM_PROJECT) do
+      manifest = REXML::Document.new(File.read(MANIFEST_FILE))
+      manifest.root.attributes['android:versionCode'] = '2'
+      manifest.root.attributes['android:versionName'] = '0.4.1'
+      manifest.root.attributes['android:installLocation'] = 'auto' # or 'preferExternal' ?
+      manifest.root.elements['uses-sdk'].attributes['android:targetSdkVersion'] = '8'
+      File.open(MANIFEST_FILE, 'w') { |f| manifest.document.write(f, 4) }
+      File.open('default.properties', 'w'){|f| f << "target=android-8\n"}
+      keystore_file = File.expand_path('~/android_market.keystore')
+      if File.exists?(keystore_file)
+        File.open('local.properties', 'a'){|f| f << "key.store=#{keystore_file}\nkey.alias=android_market\n"}
+      end
+    end
+  end
+
+  file PLATFORM_DEBUG_APK => PLATFORM_PROJECT do
+    Dir.chdir(PLATFORM_PROJECT) do
+      sh 'rake debug'
+    end
+  end
+
+  desc 'Generate a Ruboto Core platform release apk'
+  task :release => PLATFORM_RELEASE_APK
+
+  file PLATFORM_RELEASE_APK => PLATFORM_PROJECT do
+    Dir.chdir(PLATFORM_PROJECT) do
+      sh 'rake release'
+    end
+  end
+
+  desc 'Install the Ruboto Core platform debug apk'
+  task :install => PLATFORM_DEBUG_APK do
+    Dir.chdir(PLATFORM_PROJECT) do
+      sh 'rake install'
+    end
+  end
+
+  desc 'Uninstall the Ruboto Core platform debug apk'
+  task :uninstall => PLATFORM_PROJECT do
+    Dir.chdir(PLATFORM_PROJECT) do
+      sh 'rake uninstall'
+    end
+  end
+end

data/assets/Rakefile

@@ -3,7 +3,7 @@ require 'time'
 def manifest() @manifest ||= REXML::Document.new(File.read(MANIFEST_FILE)) end
 def package() manifest.root.attribute('package') end
 def build_project_name() @build_project_name ||= REXML::Document.new(File.read('build.xml')).elements['project'].attribute(:name).value end
-def sdcard_path() @sdcard_path ||= "/mnt/sdcard/Android/data/#{package}/files" end
+def scripts_path() @sdcard_path ||= "/mnt/sdcard/Android/data/#{package}/files/scripts" end
 def app_files_path() @app_files_path ||= "/data/data/#{package}/files" end
 
 require 'rake/clean'
@@ -15,11 +15,13 @@ BUNDLE_PATH        = File.expand_path 'tmp/bundle'
 MANIFEST_FILE      = File.expand_path 'AndroidManifest.xml'
 RUBOTO_CONFIG_FILE = File.expand_path 'ruboto.yml'
 GEM_FILE           = File.expand_path('Gemfile.apk')
+GEM_LOCK_FILE      = File.expand_path('Gemfile.apk.lock')
 APK_FILE           = File.expand_path "bin/#{build_project_name}-debug.apk"
 TEST_APK_FILE      = File.expand_path "test/bin/#{build_project_name}Test-debug.apk"
 JRUBY_JARS         = Dir[File.expand_path 'libs/jruby-*.jar']
 RESOURCE_FILES     = Dir[File.expand_path 'res/**/*']
 JAVA_SOURCE_FILES  = Dir[File.expand_path 'src/**/*.java']
+RUBY_SOURCE_FILES  = Dir[File.expand_path 'src/**/*.rb']
 
 CLEAN.include('tmp', 'bin')
 
@@ -45,11 +47,32 @@ end
 desc 'build debug package'
 task :debug => APK_FILE
 
+namespace :debug do
+  desc 'build debug package if compiled files have changed'
+  task :quick => [MANIFEST_FILE, RUBOTO_CONFIG_FILE, BUNDLE_JAR] + JRUBY_JARS + JAVA_SOURCE_FILES + RESOURCE_FILES do |t|
+    build_apk(t)
+  end
+end
+
 desc "build package and install it on the emulator or device"
 task :install => APK_FILE do
   install_apk
 end
 
+namespace :install do
+  desc 'uninstall, build, and install the application'
+  task :clean => [:uninstall, APK_FILE, :install]
+
+  desc 'Install the application, but only if compiled files are changed.'
+  task :quick => 'debug:quick' do
+    install_apk
+  end
+end
+
+task :release do
+  sh 'ant release'
+end
+
 task :tag => :release do
   unless `git branch` =~ /^\* master$/
     puts "You must be on the master branch to release!"
@@ -75,7 +98,7 @@ end
 
 desc 'Start the emulator with larger disk'
 task :emulator do
-  system 'emulator -partition-size 1024 -avd Android_3.0'
+  sh 'emulator -partition-size 1024 -avd Android_3.0'
 end
 
 task :start do
@@ -93,69 +116,26 @@ task :uninstall do
   uninstall_apk
 end
 
-namespace :install do
-  desc 'Uninstall, build, and install the application'
-  task :clean => [:uninstall, APK_FILE, :install]
-end
-
 file MANIFEST_FILE
 file RUBOTO_CONFIG_FILE
 
-file APK_FILE => [MANIFEST_FILE, RUBOTO_CONFIG_FILE, BUNDLE_JAR] + JRUBY_JARS + JAVA_SOURCE_FILES + RESOURCE_FILES do |t|
-  if File.exist?(APK_FILE)
-    changed_prereqs = t.prerequisites.select do |p|
-      File.exist?(p) && !Dir[p].empty? && Dir[p].map{|f| File.mtime(f)}.max > File.mtime(APK_FILE)
-    end
-
-    if changed_prereqs.empty?
-      puts
-      puts 'skipping'
-      puts
-      next
-    end
-    changed_prereqs.each{|f| puts "#{f} changed."}
-    puts "Forcing rebuild of #{APK_FILE}."
-  end
-  sh 'ant debug'
+file APK_FILE => [MANIFEST_FILE, RUBOTO_CONFIG_FILE, BUNDLE_JAR] + JRUBY_JARS + JAVA_SOURCE_FILES + RESOURCE_FILES + RUBY_SOURCE_FILES do |t|
+  build_apk(t)
 end
 
 desc 'Copy scripts to emulator or device'
-task :update_scripts do
-  if device_path_exists?(sdcard_path)
-    data_dir_name = 'public'
-    data_dir = sdcard_path
-  elsif device_path_exists?(app_files_path)
-    data_dir_name = 'private'
-    data_dir = app_files_path
-  else
-    puts 'Cannot find the scripts directory on the device.'
-    unless manifest.root.elements["uses-permission[@android:name='android.permission.WRITE_EXTERNAL_STORAGE']"]
-      puts 'If you have a non-rooted device, you need to add'
-      puts %q{    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />}
-      puts 'to the AndroidManifest.xml file to enable the update_scripts rake task.'
-    end
-    puts "Reverting to uninstalling and re-installing the apk."
-    Rake::Task[:uninstall].reenable
-    Rake::Task[:uninstall].invoke
-    FileUtils.rm_f APK_FILE
-    Rake::Task[APK_FILE].reenable
-    Rake::Task[APK_FILE].invoke
-    Rake::Task[:install].reenable
-    Rake::Task[:install].invoke
-    next
-  end
-  Rake::Task['install'].invoke
-  puts "Pushing files to apk #{data_dir_name} file area."
+task :update_scripts => ['install:quick'] do
+  `adb shell mkdir -p #{scripts_path}` if !device_path_exists?(scripts_path)
+  puts "Pushing files to apk public file area."
   last_update = File.exists?(UPDATE_MARKER_FILE) ? Time.parse(File.read(UPDATE_MARKER_FILE)) : Time.parse('1970-01-01T00:00:00')
-  Dir.chdir('assets') do
-    ['scripts'].each do |asset_dir|
-      Dir["#{asset_dir}/*"].each do |asset_file|
-        next if File.directory? asset_file
-        next if File.mtime(asset_file) < last_update
-        next if asset_file =~ /~$/
-        print "#{asset_file}: " ; $stdout.flush
-        `adb push #{asset_file} #{data_dir}/#{asset_file}`
-      end
+  # TODO(uwe): Use `adb sync src` instead?
+  Dir.chdir('src') do
+    Dir["**/*.rb"].each do |script_file|
+      next if File.directory? script_file
+      next if File.mtime(script_file) < last_update
+      next if script_file =~ /~$/
+      print "#{script_file}: "; $stdout.flush
+      `adb push #{script_file} #{scripts_path}/#{script_file}`
     end
   end
   mark_update
@@ -166,43 +146,29 @@ namespace :update_scripts do
   task :restart => [:stop, :update_scripts, :start]
 end
 
-task :update_test_scripts do
-  test_scripts_path = "/data/data/#{package}.tests/files/scripts"
-  # TODO(uwe): Investigate if we can just push the scripts instead of building and installing the instrumentation APK
-  if package_installed?(true) && device_path_exists?(test_scripts_path)
-    Dir['test/assets/scripts/*.rb'].each do |script|
-      print "#{script}: " ; $stdout.flush
-      `adb push #{script} #{test_scripts_path}`
-    end
-    `adb shell ps | grep #{package}.tests | awk '{print $2}' | xargs adb shell kill`
-  else
-    Dir.chdir 'test' do
-      sh 'ant install'
-    end
-  end
-end
-
 task :test => :uninstall do
   Dir.chdir('test') do
     puts 'Running tests'
-    system "adb uninstall #{package}.tests"
-    system "ant run-tests"
+    sh "adb uninstall #{package}.tests"
+    sh "ant run-tests"
   end
 end
 
 namespace :test do
-  task :quick => [:update_scripts, :update_test_scripts] do
+  task :quick => :update_scripts do
     Dir.chdir('test') do
       puts 'Running quick tests'
+      sh 'ant install'
       sh "ant run-tests-quick"
     end
   end
 end
 
 file GEM_FILE
+file GEM_LOCK_FILE
 
 desc 'Generate bundle jar from Gemfile'
-file BUNDLE_JAR => GEM_FILE do
+file BUNDLE_JAR => [GEM_FILE, GEM_LOCK_FILE] do
   next unless File.exists? GEM_FILE
   puts "Generating #{BUNDLE_JAR}"
 
@@ -248,15 +214,24 @@ end
   # Expand JARs
   Dir.chdir "#{BUNDLE_PATH}/ruby/1.8/gems" do
     Dir['*'].each do |gem_lib|
-      next if gem_lib =~ /jdbc-sqlite/
       Dir.chdir "#{gem_lib}/lib" do
         Dir['**/*.jar'].each do |jar|
-          puts "Expanding #{gem_lib} #{jar} into #{BUNDLE_JAR}"
-
-          `jar xf #{jar}`
+          unless gem_lib =~ /jdbc-sqlite/
+            puts "Expanding #{gem_lib} #{jar} into #{BUNDLE_JAR}"
+            `jar xf #{jar}`
+            if jar == 'arjdbc/jdbc/adapter_java.jar'
+              service_load_code =
+"require 'jruby'
+Java::arjdbc.jdbc.AdapterJavaService.new.basicLoad(JRuby.runtime)
+"
+              File.open(jar + '.rb', 'w'){|f| f << service_load_code}
+              File.open(jar.chomp('.jar') + '.rb', 'w'){|f| f << service_load_code} if jar.end_with?('.jar')
+            else
+              FileUtils.touch(jar + '.rb')
+              FileUtils.touch(jar.chomp('.jar') + '.rb') if jar.end_with?('.jar')
+            end
+          end
           FileUtils.rm_f(jar)
-          # FileUtils.touch(jar + '.rb')
-          # FileUtils.touch(jar.chomp('jar') + 'rb')
         end
       end
     end
@@ -280,7 +255,11 @@ def mark_update(time = Time.now)
 end
 
 def clear_update
-  FileUtils.rm_f UPDATE_MARKER_FILE
+  mark_update File.ctime APK_FILE
+  if device_path_exists?(scripts_path)
+    sh "adb shell rm -r #{scripts_path}"
+    puts "Deleted scripts directory #{scripts_path}"
+  end
 end
 
 def strings(name)
@@ -335,6 +314,18 @@ def replace_faulty_code(faulty_file, faulty_code)
   end
 end
 
+def build_apk(t)
+  if File.exist?(APK_FILE)
+    changed_prereqs = t.prerequisites.select do |p|
+      File.file?(p) && !Dir[p].empty? && Dir[p].map{|f| File.mtime(f)}.max > File.mtime(APK_FILE)
+    end
+    return if changed_prereqs.empty?
+    changed_prereqs.each{|f| puts "#{f} changed."}
+    puts "Forcing rebuild of #{APK_FILE}."
+  end
+  sh 'ant debug'
+end
+
 def install_apk
   case package_installed?
   when true

data/assets/res/layout/get_ruboto_core.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:orientation="vertical"
+    android:gravity="center_horizontal|center_vertical"
+>
+<!--                                                                                                                                                                                                                                 
+-->
+  <ImageButton
+      android:id="@+id/image"
+      android:layout_width="fill_parent"
+      android:layout_height="fill_parent"
+      android:src="@drawable/icon"
+      android:layout_weight="1"
+      android:scaleType="fitCenter"
+      android:onClick="getRubotoCore"
+  />
+  <TextView android:id="@+id/text"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Welcome to Ruboto!  This is the first Ruboto application installed on this device.  To continue, you need to install the Ruboto Core platform package.  Click on the image above to go to the market and d\
+ownload and install the Ruboto Core platform package.  Then return back here to start the app." />
+</LinearLayout>

data/assets/samples/sample_broadcast_receiver.rb

@@ -1,7 +1,6 @@
 require 'ruboto'
 
-# despite the name, the when_launched block will get called whenever
-# the BroadcastReceiver receives an intent (whenever onReceive is called)
+# will get called whenever the BroadcastReceiver receives an intent (whenever onReceive is called)
 $broadcast_receiver.handle_receive do |context, intent|
   Log.v "MYAPP", intent.getExtras.to_s
 end

data/assets/src/InheritingActivity.java

@@ -1,14 +1,190 @@
 package THE_PACKAGE;
 
+import java.io.IOException;
+
+import org.ruboto.Script;
+
+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.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import android.view.View;
+import android.widget.TextView;
+import android.widget.Toast;
+
 public class InheritingActivity extends org.ruboto.RubotoActivity {
-	public void onCreate(android.os.Bundle arg0) {
-		try {
-			setSplash(Class.forName("THE_PACKAGE.R$layout").getField("splash")
-					.getInt(null));
+    private int splash = 0;
+    private ProgressDialog loadingDialog;
+    private boolean dialogCancelled = false;
+    private BroadcastReceiver receiver;
+    private boolean appStarted = false;
+
+	public void onCreate(Bundle bundle) {
+        Log.d("RUBOTO", "onCreate: ");
+
+	    try {
+    		splash = Class.forName(getPackageName() + ".R$layout").getField("splash").getInt(null);
 		} catch (Exception e) {
+		    splash = -1;
 		}
 
 		setScriptName("start.rb");
-		super.onCreate(arg0);
+        if (Script.isInitialized()) {
+            appStarted = true;
+		}
+	    super.onCreate(bundle);
 	}
+
+    public void onResume() {
+        Log.d("RUBOTO", "onResume: ");
+
+        if(appStarted) {
+            Log.d("RUBOTO", "onResume: App already started!");
+            super.onResume();
+            return;
+        }
+
+        Log.d("RUBOTO", "onResume: Checking JRuby");
+        if (Script.isInitialized()) {
+            Log.d("RUBOTO", "Already initialized");
+    	    fireRubotoActivity();
+        } else {
+            Log.d("RUBOTO", "Not initialized");
+            showProgress();
+            receiver = new BroadcastReceiver(){
+                public void onReceive(Context context, Intent intent) {
+                    Log.i("RUBOTO", "received broadcast: " + intent);
+                    Log.i("RUBOTO", "URI: " + intent.getData());
+                    if (intent.getData().toString().equals("package:org.ruboto.core")) {
+                        Toast.makeText(context,"Ruboto Core is now installed.",Toast.LENGTH_SHORT).show();
+                        if (receiver != null) {
+                    	    unregisterReceiver(receiver);
+                    	    receiver = null;
+                        }
+                        showProgress();
+                        initJRuby(false);
+                    }
+                }
+            };
+            IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
+            filter.addDataScheme("package");
+            registerReceiver(receiver, filter);
+            initJRuby(true);
+            super.onResume();
+        }
+    }
+
+    public void onPause() {
+        Log.d("RUBOTO", "onPause: ");
+
+        if (receiver != null) {
+    	    unregisterReceiver(receiver);
+    	    receiver = null;
+        }
+        super.onPause();
+    }
+
+    public void onDestroy() {
+        Log.d("RUBOTO", "onDestroy: ");
+
+        super.onDestroy();
+        if (dialogCancelled) {
+            System.runFinalizersOnExit(true);
+            System.exit(0);
+        }
+    }
+
+    private void initJRuby(final boolean firstTime) {
+        new Thread(new Runnable() {
+            public void run() {
+                final boolean jrubyOk = Script.setUpJRuby(InheritingActivity.this);
+                if (jrubyOk) {
+                    Log.d("RUBOTO", "onResume: JRuby OK");
+                    prepareJRuby();
+                    runOnUiThread(new Runnable() {
+                        public void run() {
+                            fireRubotoActivity();
+                        }
+                    });
+                } else {
+                    runOnUiThread(new Runnable() {
+                        public void run() {
+                            if (firstTime) {
+                                Log.d("RUBOTO", "onResume: Checking JRuby - IN UI thread");
+                                try {
+                                    setContentView(Class.forName(getPackageName() + ".R$layout").getField("get_ruboto_core").getInt(null));
+                                } catch (Exception e) {
+                                }
+                            } else {
+                                Toast.makeText(InheritingActivity.this,"Failed to initialize Ruboto Core.",Toast.LENGTH_SHORT).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();
+    }
+
+    // Called when buton is pressed.
+    public void getRubotoCore(View view) {
+        try {
+            startActivity(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("market://details?id=org.ruboto.core")));
+        } catch (android.content.ActivityNotFoundException anfe) {
+            try {
+                TextView textView = (TextView) findViewById(Class.forName(getPackageName() + ".R$id").getField("text").getInt(null));
+                textView.setText("Could not find the Android Market App.  You will have to install Ruboto Core manually.  Bummer!");
+            } catch (Exception e) {}
+        }
+    }
+
+    private void fireRubotoActivity() {
+        if(appStarted) return;
+        appStarted = true;
+        Log.i("RUBOTO", "Starting activity");
+        loadScript();
+        onStart();
+        super.onResume();
+        hideProgress();
+    }
+
+    private void showProgress() {
+        if (loadingDialog == null) {
+            Log.i("RUBOTO", "Showing progress");
+            if (splash > 0) {
+                requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
+                setContentView(splash);
+            } else {
+                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 hideProgress() {
+        if (loadingDialog != null) {
+            Log.d("RUBOTO", "Hide progress");
+            loadingDialog.dismiss();
+            loadingDialog = null;
+        }
+    }
+
 }

data/assets/src/InheritingBroadcastReceiver.java

@@ -1,10 +1,27 @@
 package THE_PACKAGE;
 
+import org.ruboto.Script;
+
 public class InheritingBroadcastReceiver extends org.ruboto.RubotoBroadcastReceiver {
-	public void onReceive(android.content.Context arg0,
-			android.content.Intent arg1) {
-		setScriptName("start.rb");
-		super.onReceive(arg0, arg1);
-	}
+    private boolean scriptLoaded = false;
+
+    public InheritingBroadcastReceiver() {
+        super("start.rb");
+        if (Script.isInitialized()) {
+            scriptLoaded = true;
+        }
+    }
+
+    public void onReceive(android.content.Context context, android.content.Intent intent) {
+        if (!scriptLoaded) {
+            if (Script.setUpJRuby(context)) {
+                loadScript();
+                scriptLoaded = true;
+            } else {
+                // FIXME(uwe): What to do if the Ruboto Core platform is missing?
+            }
+        }
+        super.onReceive(context, intent);
+    }
 
 }

data/assets/src/InheritingClass.java

@@ -1,28 +1,19 @@
 package THE_PACKAGE;
 
-import org.jruby.embed.ScriptingContainer;
-import org.jruby.javasupport.util.RuntimeHelpers;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.javasupport.JavaUtil;
-import org.jruby.exceptions.RaiseException;
 import org.ruboto.Script;
 
 public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
-  private ScriptingContainer __ruby__;
 
 THE_CONSTANTS
-  private IRubyObject[] callbackProcs = new IRubyObject[CONSTANTS_COUNT];
 
-THE_CONSTRUCTORS
+    private Object[] callbackProcs = new Object[CONSTANTS_COUNT];
 
-  private ScriptingContainer getRuby() {
-    if (__ruby__ == null) __ruby__ = Script.getRuby();
-    return __ruby__;
-  }
+THE_CONSTRUCTORS
 
-  public void setCallbackProc(int id, IRubyObject obj) {
+  public void setCallbackProc(int id, Object obj) {
     callbackProcs[id] = obj;
   }
 	
 THE_METHODS
+
 }