ruboto 0.6.0 → 0.7.0

data/assets/src/RubotoBroadcastReceiver.java

@@ -4,7 +4,7 @@ import java.io.IOException;
 
 public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
     private String scriptName = null;
-    private boolean initialized = false;
+    private Object rubyInstance;
 
     public void setCallbackProc(int id, Object obj) {
         // Error: no callbacks
@@ -25,17 +25,33 @@ public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
         if (name != null) {
             setScriptName(name);
         
-            if (Script.isInitialized()) {
+            if (JRubyAdapter.isInitialized()) {
                 loadScript();
             }
         }
     }
 
     protected void loadScript() {
-        Script.put("$broadcast_receiver", this);
+
+        // TODO(uwe):  Only needed for non-class-based definitions
+        // Can be removed if we stop supporting non-class-based definitions
+    	JRubyAdapter.put("$broadcast_receiver", this);
+    	// TODO end
+
         if (scriptName != null) {
             try {
-                new Script(scriptName).execute();
+                String rubyClassName = Script.toCamelCase(scriptName);
+                System.out.println("Looking for Ruby class: " + rubyClassName);
+                Object rubyClass = JRubyAdapter.get(rubyClassName);
+                if (rubyClass == null) {
+                    System.out.println("Loading script: " + scriptName);
+                    JRubyAdapter.exec(new Script(scriptName).getContents());
+                    rubyClass = JRubyAdapter.get(rubyClassName);
+                }
+                if (rubyClass != null) {
+                    System.out.println("Instanciating Ruby class: " + rubyClassName);
+                    rubyInstance = JRubyAdapter.callMethod(rubyClass, "new", this, Object.class);
+                }
             } catch(IOException e) {
                 throw new RuntimeException("IOException loading broadcast receiver script", e);
             }
@@ -43,16 +59,21 @@ public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
     }
 
     public void onReceive(android.content.Context context, android.content.Intent intent) {
-        Script.put("$context", context);
-        Script.put("$broadcast_receiver", this);
-        Script.put("$intent", intent);
-
         try {
-            Script.execute("$broadcast_receiver.on_receive($context, $intent)");
+            System.out.println("onReceive: " + rubyInstance);
+            if (rubyInstance != null) {
+            	JRubyAdapter.callMethod(rubyInstance, "on_receive", new Object[]{context, intent});
+            } else {
+                // TODO(uwe):  Only needed for non-class-based definitions
+                // Can be removed if we stop supporting non-class-based definitions
+                JRubyAdapter.put("$context", context);
+                JRubyAdapter.put("$broadcast_receiver", this);
+                JRubyAdapter.put("$intent", intent);
+            	JRubyAdapter.execute("$broadcast_receiver.on_receive($context, $intent)");
+            	// TODO end
+            }
         } catch(Exception e) {
             e.printStackTrace();
         }
     }
 }	
-
-

data/assets/src/RubotoService.java

@@ -2,12 +2,11 @@ package THE_PACKAGE;
 
 import org.ruboto.Script;
 import java.io.IOException;
-import android.app.ProgressDialog;
 
 public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
   private String scriptName;
-  private String remoteVariable = "";
   public Object[] args;
+  private Object rubyInstance;
 
 THE_CONSTANTS
 
@@ -17,11 +16,6 @@ THE_CONSTANTS
     callbackProcs[id] = obj;
   }
 	
-  public THE_RUBOTO_CLASS setRemoteVariable(String var) {
-    remoteVariable = ((var == null) ? "" : (var + "."));
-    return this;
-  }
-
   public void setScriptName(String name){
     scriptName = name;
   }
@@ -33,20 +27,36 @@ THE_CONSTANTS
 	
   @Override
   public void onCreate() {
+	System.out.println("RubotoService.onCreate()");
     args = new Object[0];
 
     super.onCreate();
 
-    if (Script.setUpJRuby(this)) {
-        Script.defineGlobalVariable("$context", this);
-        Script.defineGlobalVariable("$service", this);
+    if (JRubyAdapter.setUpJRuby(this)) {
+        // TODO(uwe):  Only needed for non-class-based definitions
+        // Can be removed if we stop supporting non-class-based definitions
+    	JRubyAdapter.defineGlobalVariable("$context", this);
+    	JRubyAdapter.defineGlobalVariable("$service", this);
+    	// TODO end
 
         try {
             if (scriptName != null) {
-                new Script(scriptName).execute();
+                String rubyClassName = Script.toCamelCase(scriptName);
+                System.out.println("Looking for Ruby class: " + rubyClassName);
+                Object rubyClass = JRubyAdapter.get(rubyClassName);
+                if (rubyClass == null) {
+                    System.out.println("Loading script: " + scriptName);
+                    JRubyAdapter.exec(new Script(scriptName).getContents());
+                    rubyClass = JRubyAdapter.get(rubyClassName);
+                }
+                if (rubyClass != null) {
+                    System.out.println("Instanciating Ruby class: " + rubyClassName);
+                    rubyInstance = JRubyAdapter.callMethod(rubyClass, "new", this, Object.class);
+                    JRubyAdapter.callMethod(rubyInstance, "on_create");
+                }
             } else {
-                Script.execute("$service.initialize_ruboto");
-                Script.execute("$service.on_create");
+            	JRubyAdapter.execute("$service.initialize_ruboto");
+            	JRubyAdapter.execute("$service.on_create");
             }
         } catch(IOException e) {
             e.printStackTrace();

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

@@ -1,10 +1,5 @@
 package org.ruboto;
 
-import java.io.File;
-import java.io.IOException;
-
-import org.ruboto.Script;
-
 import android.app.ProgressDialog;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -14,8 +9,6 @@ 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;
@@ -28,7 +21,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
     protected boolean appStarted = false;
 
 	public void onCreate(Bundle bundle) {
-        Log.d("RUBOTO", "onCreate: ");
+        Log.d("onCreate: ");
 
 	    try {
     		splash = Class.forName(getPackageName() + ".R$layout").getField("splash").getInt(null);
@@ -36,32 +29,32 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
 		    splash = -1;
 		}
 
-        if (Script.isInitialized()) {
+        if (JRubyAdapter.isInitialized()) {
             appStarted = true;
 		}
 	    super.onCreate(bundle);
 	}
 
     public void onResume() {
-        Log.d("RUBOTO", "onResume: ");
+        Log.d("onResume: ");
 
         if(appStarted) {
-            Log.d("RUBOTO", "onResume: App already started!");
+            Log.d("onResume: App already started!");
             super.onResume();
             return;
         }
 
-        Log.d("RUBOTO", "onResume: Checking JRuby");
-        if (Script.isInitialized()) {
-            Log.d("RUBOTO", "Already initialized");
+        Log.d("onResume: Checking JRuby");
+        if (JRubyAdapter.isInitialized()) {
+            Log.d("Already initialized");
     	    fireRubotoActivity();
         } else {
-            Log.d("RUBOTO", "Not initialized");
+            Log.d("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());
+                    Log.i("received broadcast: " + intent);
+                    Log.i("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) {
@@ -82,7 +75,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
     }
 
     public void onPause() {
-        Log.d("RUBOTO", "onPause: ");
+        Log.d("onPause: ");
 
         if (receiver != null) {
     	    unregisterReceiver(receiver);
@@ -92,7 +85,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
     }
 
     public void onDestroy() {
-        Log.d("RUBOTO", "onDestroy: ");
+        Log.d("onDestroy: ");
 
         super.onDestroy();
         if (dialogCancelled) {
@@ -104,9 +97,9 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
     private void initJRuby(final boolean firstTime) {
         new Thread(new Runnable() {
             public void run() {
-                final boolean jrubyOk = Script.setUpJRuby(EntryPointActivity.this);
+                final boolean jrubyOk = JRubyAdapter.setUpJRuby(EntryPointActivity.this);
                 if (jrubyOk) {
-                    Log.d("RUBOTO", "onResume: JRuby OK");
+                    Log.d("onResume: JRuby OK");
                     prepareJRuby();
                     runOnUiThread(new Runnable() {
                         public void run() {
@@ -117,7 +110,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
                     runOnUiThread(new Runnable() {
                         public void run() {
                             if (firstTime) {
-                                Log.d("RUBOTO", "onResume: Checking JRuby - IN UI thread");
+                                Log.d("onResume: Checking JRuby - IN UI thread");
                                 try {
                                     setContentView(Class.forName(getPackageName() + ".R$layout").getField("get_ruboto_core").getInt(null));
                                 } catch (Exception e) {
@@ -147,7 +140,6 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
             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));
                 Intent intent = new Intent(android.content.Intent.ACTION_VIEW, Uri.parse(RUBOTO_URL));
                 startActivity(intent);
             } catch (Exception e) {}
@@ -157,7 +149,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
     protected void fireRubotoActivity() {
         if(appStarted) return;
         appStarted = true;
-        Log.i("RUBOTO", "Starting activity");
+        Log.i("Starting activity");
         loadScript();
         onStart();
         super.onResume();
@@ -166,7 +158,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
 
     private void showProgress() {
         if (loadingDialog == null) {
-            Log.i("RUBOTO", "Showing progress");
+            Log.i("Showing progress");
             if (splash > 0) {
                 requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
                 setContentView(splash);
@@ -185,7 +177,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
 
     private void hideProgress() {
         if (loadingDialog != null) {
-            Log.d("RUBOTO", "Hide progress");
+            Log.d("Hide progress");
             loadingDialog.dismiss();
             loadingDialog = null;
         }

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

@@ -0,0 +1,468 @@
+package org.ruboto;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.os.Environment;
+import dalvik.system.PathClassLoader;
+
+public class JRubyAdapter {
+    private static Object ruby;
+    private static boolean isDebugBuild = false;
+    private static PrintStream output = null;
+    private static boolean initialized = false;
+    private static String localContextScope = "SINGLETON";
+    private static String localVariableBehavior = "TRANSIENT";
+    private static String RUBOTO_CORE_VERSION_NAME;
+
+	public static void callMethod(Object receiver, String methodName, Object[] args) {
+        try {
+            Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object[].class);
+            callMethodMethod.invoke(ruby, receiver, methodName, args);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            printStackTrace(ite);
+            if (isDebugBuild) {
+                throw new RuntimeException(ite);
+            }
+        }
+    }
+
+	public static void callMethod(Object object, String methodName, Object arg) {
+		callMethod(object, methodName, new Object[] { arg });
+	}
+
+	public static void callMethod(Object object, String methodName) {
+		callMethod(object, methodName, new Object[] {});
+	}
+
+	@SuppressWarnings("unchecked")
+	public static <T> T callMethod(Object receiver, String methodName, Object[] args, Class<T> returnType) {
+        try {
+            Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object[].class, Class.class);
+            return (T) callMethodMethod.invoke(ruby, receiver, methodName, args, returnType);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            printStackTrace(ite);
+        }
+        return null;
+	}
+
+	@SuppressWarnings("unchecked")
+	public static <T> T callMethod(Object receiver, String methodName, Object arg, Class<T> returnType) {
+    try {
+      Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object.class, Class.class);
+      return (T) callMethodMethod.invoke(ruby, receiver, methodName, arg, returnType);
+    } catch (NoSuchMethodException nsme) {
+      throw new RuntimeException(nsme);
+    } catch (IllegalAccessException iae) {
+      throw new RuntimeException(iae);
+    } catch (java.lang.reflect.InvocationTargetException ite) {
+      printStackTrace(ite);
+    }
+    return null;
+	}
+
+	@SuppressWarnings("unchecked")
+	public static <T> T callMethod(Object receiver, String methodName, Class<T> returnType) {
+    try {
+      Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Class.class);
+      return (T) callMethodMethod.invoke(ruby, receiver, methodName, returnType);
+    } catch (NoSuchMethodException nsme) {
+      throw new RuntimeException(nsme);
+    } catch (IllegalAccessException iae) {
+      throw new RuntimeException(iae);
+    } catch (java.lang.reflect.InvocationTargetException ite) {
+      printStackTrace(ite);
+    }
+    return null;
+	}
+
+    /**
+     * @deprecated  As of Ruboto 0.7.0, replaced by {@link #put(String name, Object object)}
+     */
+    @Deprecated public static void defineGlobalConstant(String name, Object object) {
+    	put(name, object);
+    }
+
+    /**
+     * @deprecated  As of Ruboto 0.7.0, replaced by {@link #put(String name, Object object)}
+     */
+    @Deprecated public static void defineGlobalVariable(String name, Object object) {
+    	put(name, object);
+    }
+
+    /**
+     * @deprecated  As of Ruboto 0.7.0, replaced by {@link #runScriptlet(String code)}
+     */
+	@Deprecated public static Object exec(String code) {
+        try {
+            Method runScriptletMethod = ruby.getClass().getMethod("runScriptlet", String.class);
+            return runScriptletMethod.invoke(ruby, code);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            if (isDebugBuild) {
+                throw ((RuntimeException) ite.getCause());
+            } else {
+                return null;
+            }
+        }
+	}
+
+    /**
+     * @deprecated  As of Ruboto 0.7.0, replaced by {@link #runScriptlet(String code)}
+     */
+    @Deprecated public static String execute(String code) {
+        Object result = exec(code);
+        return result != null ? result.toString() : "nil";
+        // TODO: Why is callMethod returning "main"?
+        // return result != null ? callMethod(result, "inspect", String.class) : "null";
+    }
+
+    public static Object get(String name) {
+        try {
+            Method getMethod = ruby.getClass().getMethod("get", String.class);
+            return getMethod.invoke(ruby, name);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            throw new RuntimeException(ite);
+        }
+    }
+
+	public static String getPlatformVersionName() {
+		return RUBOTO_CORE_VERSION_NAME;
+	}
+
+    public static String getScriptFilename() {
+        return callScriptingContainerMethod(String.class, "getScriptFilename");
+    }
+
+	public static boolean isDebugBuild() {
+		return isDebugBuild;
+	}
+
+	public static synchronized boolean isInitialized() {
+		return initialized;
+	}
+
+    public static void put(String name, Object object) {
+        try {
+            Method putMethod = ruby.getClass().getMethod("put", String.class, Object.class);
+            putMethod.invoke(ruby, name, object);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            throw new RuntimeException(ite);
+        }
+    }
+
+	public static Object runScriptlet(String code) {
+        try {
+            Method runScriptletMethod = ruby.getClass().getMethod("runScriptlet", String.class);
+            return runScriptletMethod.invoke(ruby, code);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            if (isDebugBuild) {
+                throw ((RuntimeException) ite.getCause());
+            } else {
+                return null;
+            }
+        }
+	}
+
+    public static synchronized boolean setUpJRuby(Context appContext) {
+        return setUpJRuby(appContext, output == null ? System.out : output);
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static synchronized boolean setUpJRuby(Context appContext, PrintStream out) {
+        if (!initialized) {
+            // BEGIN Ruboto HeapAlloc
+            @SuppressWarnings("unused")
+			byte[] arrayForHeapAllocation = new byte[13 * 1024 * 1024];
+            arrayForHeapAllocation = null;
+            // END Ruboto HeapAlloc
+            setDebugBuild(appContext);
+            Log.d("Setting up JRuby runtime (" + (isDebugBuild ? "DEBUG" : "RELEASE") + ")");
+            System.setProperty("jruby.bytecode.version", "1.6");
+            System.setProperty("jruby.interfaces.useProxy", "true");
+            System.setProperty("jruby.management.enabled", "false");
+            System.setProperty("jruby.objectspace.enabled", "false");
+            System.setProperty("jruby.thread.pooling", "true");
+            System.setProperty("jruby.native.enabled", "false");
+            // System.setProperty("jruby.compat.version", "RUBY1_8"); // RUBY1_9 is the default
+
+            // Uncomment these to debug Ruby source loading
+            // System.setProperty("jruby.debug.loadService", "true");
+            // System.setProperty("jruby.debug.loadService.timing", "true");
+
+
+            ClassLoader classLoader;
+            Class<?> scriptingContainerClass;
+            String apkName = null;
+
+            try {
+                scriptingContainerClass = Class.forName("org.jruby.embed.ScriptingContainer");
+                System.out.println("Found JRuby in this APK");
+                classLoader = JRubyAdapter.class.getClassLoader();
+                try {
+                    apkName = appContext.getPackageManager().getApplicationInfo(appContext.getPackageName(), 0).sourceDir;
+                } catch (NameNotFoundException e) {}
+            } catch (ClassNotFoundException e1) {
+                String packageName = "org.ruboto.core";
+                try {
+                	PackageInfo pkgInfo = appContext.getPackageManager().getPackageInfo(packageName, 0);
+                    apkName = pkgInfo.applicationInfo.sourceDir;
+                	RUBOTO_CORE_VERSION_NAME = pkgInfo.versionName;
+                } catch (PackageManager.NameNotFoundException e2) {
+                    out.println("JRuby not found in local APK:");
+                    e1.printStackTrace(out);
+                    out.println("JRuby not found in platform APK:");
+                    e2.printStackTrace(out);
+                    return false;
+                }
+
+                System.out.println("Found JRuby in platform APK");
+                classLoader = new PathClassLoader(apkName, JRubyAdapter.class.getClassLoader());
+
+                try {
+                    scriptingContainerClass = Class.forName("org.jruby.embed.ScriptingContainer", true, classLoader);
+                } catch (ClassNotFoundException e) {
+                    // FIXME(uwe): ScriptingContainer not found in the platform APK...
+                    e.printStackTrace();
+                    return false;
+                }
+            }
+
+            try {
+                Class scopeClass = Class.forName("org.jruby.embed.LocalContextScope", true, scriptingContainerClass.getClassLoader());
+                Class behaviorClass = Class.forName("org.jruby.embed.LocalVariableBehavior", true, scriptingContainerClass.getClassLoader());
+
+                ruby = scriptingContainerClass
+                         .getConstructor(scopeClass, behaviorClass)
+                         .newInstance(Enum.valueOf(scopeClass, localContextScope), 
+                                      Enum.valueOf(behaviorClass, localVariableBehavior));
+
+                Class compileModeClass = Class.forName("org.jruby.RubyInstanceConfig$CompileMode", true, classLoader);
+                callScriptingContainerMethod(Void.class, "setCompileMode", Enum.valueOf(compileModeClass, "OFF"));
+
+                // Class traceTypeClass = Class.forName("org.jruby.runtime.backtrace.TraceType", true, classLoader);
+        	    // Method traceTypeForMethod = traceTypeClass.getMethod("traceTypeFor", String.class);
+        	    // Object traceTypeRaw = traceTypeForMethod.invoke(null, "raw");
+                // callScriptingContainerMethod(Void.class, "setTraceType", traceTypeRaw);
+
+                // FIXME(uwe): Write tutorial on profiling.
+                // container.getProvider().getRubyInstanceConfig().setProfilingMode(mode);
+
+                // callScriptingContainerMethod(Void.class, "setClassLoader", classLoader);
+        	    Method setClassLoaderMethod = ruby.getClass().getMethod("setClassLoader", ClassLoader.class);
+        	    setClassLoaderMethod.invoke(ruby, classLoader);
+
+                Thread.currentThread().setContextClassLoader(classLoader);
+
+                String defaultCurrentDir = appContext.getFilesDir().getPath();
+                Log.d("Setting JRuby current directory to " + defaultCurrentDir);
+                callScriptingContainerMethod(Void.class, "setCurrentDirectory", defaultCurrentDir);
+
+                if (out != null) {
+                  output = out;
+                  setOutputStream(out);
+                } else if (output != null) {
+                  setOutputStream(output);
+                }
+
+                String jrubyHome = "file:" + apkName + "!";
+                Log.i("Setting JRUBY_HOME: " + jrubyHome);
+                System.setProperty("jruby.home", jrubyHome);
+
+                addLoadPath(scriptsDirName(appContext));
+
+                initialized = true;
+            } catch (ClassNotFoundException e) {
+                handleInitException(e);
+            } catch (IllegalArgumentException e) {
+                handleInitException(e);
+            } catch (SecurityException e) {
+                handleInitException(e);
+            } catch (InstantiationException e) {
+                handleInitException(e);
+            } catch (IllegalAccessException e) {
+                handleInitException(e);
+            } catch (InvocationTargetException e) {
+                handleInitException(e);
+            } catch (NoSuchMethodException e) {
+                handleInitException(e);
+            }
+        }
+        return initialized;
+    }
+
+    public static void setScriptFilename(String name) {
+        callScriptingContainerMethod(Void.class, "setScriptFilename", name);
+    }
+
+	public static boolean usesPlatformApk() {
+		return RUBOTO_CORE_VERSION_NAME != null;
+	}
+
+    // Private methods
+
+    private static Boolean addLoadPath(String scriptsDir) {
+        if (new File(scriptsDir).exists()) {
+            Log.i("Added directory to load path: " + scriptsDir);
+            Script.addDir(scriptsDir);
+            runScriptlet("$:.unshift '" + scriptsDir + "' ; $:.uniq!");
+            Log.d("Changing JRuby current directory to " + scriptsDir);
+            callScriptingContainerMethod(Void.class, "setCurrentDirectory", scriptsDir);
+            return true;
+        } else {
+            Log.i("Extra scripts dir not present: " + scriptsDir);
+            return false;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T callScriptingContainerMethod(Class<T> returnType, String methodName, Object... args) {
+        Class<?>[] argClasses = new Class[args.length];
+        for (int i = 0; i < argClasses.length; i++) {
+            argClasses[i] = args[i].getClass();
+        }
+        try {
+        	Method method = ruby.getClass().getMethod(methodName, argClasses);
+        	T result = (T) method.invoke(ruby, args);
+            return result;
+        } catch (RuntimeException re) {
+            re.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            printStackTrace(e);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private static void handleInitException(Exception e) {
+        Log.e("Exception starting JRuby");
+        Log.e(e.getMessage() != null ? e.getMessage() : e.getClass().getName());
+        e.printStackTrace();
+        ruby = null;
+    }
+
+	static void printStackTrace(Throwable t) {
+        // TODO(uwe):  Simplify this when Issue #144 is resolved
+        try {
+            t.printStackTrace(output);
+    	} catch (NullPointerException npe) {
+    	    // TODO(uwe): printStackTrace should not fail
+            for (java.lang.StackTraceElement ste : t.getStackTrace()) {
+                output.append(ste.toString() + "\n");
+            }
+    	}
+	}
+
+    private static String scriptsDirName(Context context) {
+        File storageDir = null;
+        if (JRubyAdapter.isDebugBuild()) {
+
+            // FIXME(uwe): Simplify this as soon as we drop support for android-7
+            if (android.os.Build.VERSION.SDK_INT >= 8) {
+                try {
+					Method method = context.getClass().getMethod("getExternalFilesDir", String.class);
+					storageDir = (File) method.invoke(context, (Object) null);
+				} catch (SecurityException e) {
+					JRubyAdapter.printStackTrace(e);
+				} catch (NoSuchMethodException e) {
+					JRubyAdapter.printStackTrace(e);
+				} catch (IllegalArgumentException e) {
+					JRubyAdapter.printStackTrace(e);
+				} catch (IllegalAccessException e) {
+					JRubyAdapter.printStackTrace(e);
+				} catch (InvocationTargetException e) {
+					JRubyAdapter.printStackTrace(e);
+				}
+            } else {
+                storageDir = new File(Environment.getExternalStorageDirectory(), "Android/data/" + context.getPackageName() + "/files");
+                Log.e("Calculated path to sdcard the old way: " + storageDir);
+            }
+            // FIXME end
+
+            if (storageDir == null || (!storageDir.exists() && !storageDir.mkdirs())) {
+                Log.e("Development mode active, but sdcard is not available.  Make sure you have added\n<uses-permission android:name='android.permission.WRITE_EXTERNAL_STORAGE' />\nto your AndroidManifest.xml file.");
+                storageDir = context.getFilesDir();
+            }
+        } else {
+            storageDir = context.getFilesDir();
+        }
+        return storageDir.getAbsolutePath() + "/scripts";
+    }
+
+    private static void setDebugBuild(Context context) {
+        PackageManager pm = context.getPackageManager();
+        PackageInfo pi;
+        try {
+            pi = pm.getPackageInfo(context.getPackageName(), 0);
+            isDebugBuild = ((pi.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0);
+        } catch (NameNotFoundException e) {
+            isDebugBuild = false;
+        }
+    }
+
+    private static void setLocalContextScope(String val) {
+        localContextScope = val;
+    }
+
+    private static void setLocalVariableBehavior(String val) {
+        localVariableBehavior = val;
+    }
+
+    private static void setOutputStream(PrintStream out) {
+      if (ruby == null) {
+        output = out;
+      } else {
+        try {
+          Method setOutputMethod = ruby.getClass().getMethod("setOutput", PrintStream.class);
+          setOutputMethod.invoke(ruby, out);
+          Method setErrorMethod = ruby.getClass().getMethod("setError", PrintStream.class);
+          setErrorMethod.invoke(ruby, out);
+        } catch (IllegalArgumentException e) {
+            handleInitException(e);
+        } catch (SecurityException e) {
+            handleInitException(e);
+        } catch (IllegalAccessException e) {
+            handleInitException(e);
+        } catch (InvocationTargetException e) {
+            handleInitException(e);
+        } catch (NoSuchMethodException e) {
+            handleInitException(e);
+        }
+      }
+    }
+
+}