ruboto 0.5.2

data/assets/src/RubotoService.java

@@ -0,0 +1,61 @@
+package THE_PACKAGE;
+
+import org.ruboto.Script;
+import java.io.IOException;
+import android.app.ProgressDialog;
+
+public abstract class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
+  private String scriptName;
+  private String remoteVariable = "";
+  public Object[] args;
+
+THE_CONSTANTS
+
+  private Object[] callbackProcs = new Object[CONSTANTS_COUNT];
+
+  public void setCallbackProc(int id, Object obj) {
+    callbackProcs[id] = obj;
+  }
+	
+  public THE_RUBOTO_CLASS setRemoteVariable(String var) {
+    remoteVariable = ((var == null) ? "" : (var + "."));
+    return this;
+  }
+
+  public void setScriptName(String name){
+    scriptName = name;
+  }
+
+  /****************************************************************************************
+   * 
+   *  Activity Lifecycle: onCreate
+   */
+	
+  @Override
+  public void onCreate() {
+    args = new Object[0];
+
+    super.onCreate();
+
+    if (Script.setUpJRuby(this)) {
+        Script.defineGlobalVariable("$service", this);
+        try {
+            new Script(scriptName).execute();
+        } catch(IOException e) {
+            e.printStackTrace();
+        }
+    } else {
+      // FIXME(uwe):  What to do if the Ruboto Core plarform cannot be found?
+    }
+  }
+
+  /****************************************************************************************
+   * 
+   *  Generated Methods
+   */
+
+THE_METHODS
+
+}
+
+

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

@@ -0,0 +1,11 @@
+package org.ruboto;
+
+/***********************************************************
+ * 
+ * Extends RubotoActivity to specify Theme.Dialog in
+ * the AndroidManifest.xml file.
+ *
+ */
+
+public class RubotoDialog extends RubotoActivity {
+}

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

@@ -0,0 +1,545 @@
+package org.ruboto;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.AssetManager;
+import android.net.Uri;
+import android.os.Environment;
+import android.util.Log;
+
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+
+import dalvik.system.PathClassLoader;
+
+public class Script {
+    private static String scriptsDir = "scripts";
+    private static File scriptsDirFile = null;
+
+    private String name = null;
+    private static Object ruby;
+    private static boolean initialized = false;
+
+    private static String localContextScope = "SINGLETON";
+    private static String localVariableBehavior = "TRANSIENT";
+
+    public static final String TAG = "RUBOTO"; // for logging
+    private static String JRUBY_VERSION;
+
+    /*************************************************************************************************
+     * 
+     * Static Methods: ScriptingContainer config
+     */
+
+    public static void setLocalContextScope(String val) {
+        localContextScope = val;
+    }
+
+    public static void setLocalVariableBehavior(String val) {
+        localVariableBehavior = val;
+    }
+
+    /*************************************************************************************************
+     * 
+     * Static Methods: JRuby Execution
+     */
+
+    public static final FilenameFilter RUBY_FILES = new FilenameFilter() {
+        public boolean accept(File dir, String fname) {
+            return fname.endsWith(".rb");
+        }
+    };
+
+	public static synchronized boolean isInitialized() {
+		return initialized;
+	}
+
+    public static synchronized boolean setUpJRuby(Context appContext) {
+        return setUpJRuby(appContext, System.out);
+    }
+
+    public static synchronized boolean setUpJRuby(Context appContext, PrintStream out) {
+        if (!initialized) {
+            Log.d(TAG, "Setting up JRuby runtime");
+            System.setProperty("jruby.bytecode.version", "1.5");
+            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");
+
+            // 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 = Script.class.getClassLoader();
+                try {
+                    apkName = appContext.getPackageManager().getApplicationInfo(appContext.getPackageName(), 0).sourceDir;
+                } catch (NameNotFoundException e) {}
+            } catch (ClassNotFoundException e1) {
+                String packageName = "org.ruboto.core";
+                try {
+                    apkName = appContext.getPackageManager().getApplicationInfo(packageName, 0).sourceDir;
+                } catch (PackageManager.NameNotFoundException e) {
+                    System.out.println("JRuby not found");
+                    return false;
+                }
+
+                System.out.println("Found JRuby in platform APK");
+                if (true) {
+                    classLoader = new PathClassLoader(apkName, Script.class.getClassLoader());
+                } else {
+                    // Alternative way to get the class loader.  The other way is rumoured to have memory leaks.
+                try {
+                        Context platformAppContext = appContext.createPackageContext(packageName, Context.CONTEXT_INCLUDE_CODE + Context.CONTEXT_IGNORE_SECURITY);
+                        classLoader = platformAppContext.getClassLoader();
+                    } catch (PackageManager.NameNotFoundException e) {
+                        System.out.println("Could not create package context even if application info could be found.  Should never happen.");
+                        return false;
+                    }
+                }
+
+                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 {
+                try {
+                    JRUBY_VERSION = (String) Class.forName("org.jruby.runtime.Constants", true, classLoader).getDeclaredField("VERSION").get(String.class);
+                } catch (java.lang.NoSuchFieldException nsfex) {
+                    nsfex.printStackTrace();
+                    JRUBY_VERSION = "ERROR";
+                }
+
+                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(TAG, "Setting JRuby current directory to " + defaultCurrentDir);
+                callScriptingContainerMethod(Void.class, "setCurrentDirectory", defaultCurrentDir);
+
+                if (out != null) {
+                    // callScriptingContainerMethod(Void.class, "setOutput", out);
+        	        Method setOutputMethod = ruby.getClass().getMethod("setOutput", PrintStream.class);
+        	        setOutputMethod.invoke(ruby, out);
+
+                    // callScriptingContainerMethod(Void.class, "setError", out);
+        	        Method setErrorMethod = ruby.getClass().getMethod("setError", PrintStream.class);
+        	        setErrorMethod.invoke(ruby, out);
+                }
+
+                String jrubyHome = "file:" + apkName + "!";
+                Log.i(TAG, "Setting JRUBY_HOME: " + jrubyHome);
+                System.setProperty("jruby.home", jrubyHome);
+
+                String extraScriptsDir = scriptsDirName(appContext);
+                Log.i(TAG, "Checking scripts in " + extraScriptsDir);
+                if (configDir(extraScriptsDir)) {
+                    Log.i(TAG, "Added extra scripts path: " + extraScriptsDir);
+                }
+                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;
+    }
+
+    private static void handleInitException(Exception e) {
+        Log.e(TAG, "Exception starting JRuby");
+        Log.e(TAG, e.getMessage() != null ? e.getMessage() : e.getClass().getName());
+        e.printStackTrace();
+        ruby = null;
+    }
+
+    @SuppressWarnings("unchecked")
+    public 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);
+        	System.out.println("callScriptingContainerMethod: method: " + method);
+        	T result = (T) method.invoke(ruby, args);
+        	System.out.println("callScriptingContainerMethod: result: " + result);
+            return result;
+        } catch (RuntimeException re) {
+            re.printStackTrace();
+        } catch (IllegalAccessException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+        	try {
+                e.printStackTrace();
+        	} catch (NullPointerException npe) {
+        	}
+        } catch (NoSuchMethodException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    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 exec(String code) {
+        // return callScriptingContainerMethod(Object.class, "runScriptlet", 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) {
+            throw ((RuntimeException) ite.getCause());
+        }
+	}
+
+    public static void defineGlobalConstant(String name, Object object) {
+    	put(name, object);
+    }
+
+    public static void put(String name, Object object) {
+        // callScriptingContainerMethod(Void.class, "put", name, 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 void defineGlobalVariable(String name, Object object) {
+		defineGlobalConstant(name, object);
+    }
+
+    /*************************************************************************************************
+    *
+    * Static Methods: Scripts Directory
+    */
+    
+    public static void setDir(String dir) {
+    	scriptsDir = dir;
+    	scriptsDirFile = new File(dir);
+        if (ruby != null) {
+            Log.d(TAG, "Changing JRuby current directory to " + scriptsDir);
+            callScriptingContainerMethod(Void.class, "setCurrentDirectory", scriptsDir);
+        }
+    }
+    
+    public static String getDir() {
+    	return scriptsDir;
+    }
+
+    public static File getDirFile() {
+    	return scriptsDirFile;
+    }
+
+    private static void setLoadPath(List<String> loadPath) {
+        // callScriptingContainerMethod(Void.class, "setLoadPaths", loadPath);
+        try {
+            Method setLoadPathsMethod = ruby.getClass().getMethod("setLoadPaths", List.class);
+            setLoadPathsMethod.invoke(ruby, loadPath);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            throw new RuntimeException(ite);
+        }
+    }
+
+    private static List<String> getLoadPath() {
+        return callScriptingContainerMethod(List.class, "getLoadPaths");
+    }
+
+    public static Boolean configDir(String scriptsDir) {
+        if (new File(scriptsDir).exists()) {
+            Log.i(TAG, "Found extra scripts dir: " + scriptsDir);
+            setDir(scriptsDir);
+            exec("$:.unshift '" + scriptsDir + "' ; $:.uniq! ; p $:");
+            return true;
+        } else {
+            Log.i(TAG, "Extra scripts dir not present: " + scriptsDir);
+            return false;
+        }
+    }
+
+    private static void copyScripts(String from, File to, AssetManager assets) {
+        try {
+            byte[] buffer = new byte[8192];
+            for (String f : assets.list(from)) {
+                File dest = new File(to, f);
+
+                if (dest.exists()) {
+                    continue;
+                }
+
+                Log.d(TAG, "copying file from " + from + "/" + f + " to " + dest);
+
+                if (assets.list(from + "/" + f).length == 0) {
+                    InputStream is = assets.open(from + "/" + f);
+                    OutputStream fos = new BufferedOutputStream(new FileOutputStream(dest), 8192);
+
+                    int n;
+                    while ((n = is.read(buffer, 0, buffer.length)) != -1) {
+                        fos.write(buffer, 0, n);
+                    }
+                    is.close();
+                    fos.close();
+                } else {
+                    dest.mkdir();
+                    copyScripts(from + "/" + f, dest, assets);
+                }
+            }
+        } catch (IOException iox) {
+            Log.e(TAG, "error copying scripts", iox);
+        }
+    }
+
+    public static void copyAssets(Context context, String directory) {
+    	File dest = new File(scriptsDirFile.getParentFile(), directory);
+		if (dest.exists() || dest.mkdir()) {
+            copyScripts(directory, dest, context.getAssets());
+		} else {
+            throw new RuntimeException("Unable to create scripts directory: " + dest);
+		}
+    }
+    
+    private static boolean isDebugBuild(Context context) {
+        PackageManager pm = context.getPackageManager();
+        PackageInfo pi;
+        try {
+            pi = pm.getPackageInfo(context.getPackageName(), 0);
+            return ((pi.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0);
+        } catch (NameNotFoundException e) {
+            return false;
+        }
+
+    }
+
+    private static String scriptsDirName(Context context) {
+        File storageDir = null;
+        if (isDebugBuild(context)) {
+
+            // FIXME(uwe): Simplify this as soon as we drop support for android-7 or JRuby 1.5.6 or JRuby 1.6.2
+            Log.i(TAG, "JRuby VERSION: " + JRUBY_VERSION);
+            if (!JRUBY_VERSION.equals("1.5.6") && !JRUBY_VERSION.equals("1.6.2") && android.os.Build.VERSION.SDK_INT >= 8) {
+                put("script_context", context);
+                storageDir = (File) exec("script_context.getExternalFilesDir(nil)");
+            } else {
+                storageDir = new File(Environment.getExternalStorageDirectory(), "Android/data/" + context.getPackageName() + "/files");
+                Log.e(TAG, "Calculated path to sdcard the old way: " + storageDir);
+            }
+            // FIXME end
+
+            if (storageDir == null || (!storageDir.exists() && !storageDir.mkdirs())) {
+                Log.e(TAG,
+                        "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 copyScriptsIfNeeded(Context context) {
+        String to = scriptsDirName(context);
+		Log.i(TAG, "Checking scripts in " + to);
+
+        /* the if makes sure we only do this the first time */
+        if (configDir(to)) {
+			Log.i(TAG, "Copying scripts to " + to);
+        	copyAssets(context, "scripts");
+        }
+    }
+
+
+    /*************************************************************************************************
+    *
+    * Constructors
+    */
+
+    public Script(String name) {
+        this.name = name;
+    }
+
+    /*************************************************************************************************
+     *
+     * Attribute Access
+     */
+
+    public String getName() {
+        return name;
+    }
+
+    public File getFile() {
+        return new File(getDir(), name);
+    }
+
+    public Script setName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public String getContents() throws IOException {
+        InputStream is;
+        if (new File(scriptsDir + "/" + name).exists()) {
+            is = new java.io.FileInputStream(scriptsDir + "/" + name);
+        } else {
+            is = getClass().getClassLoader().getResourceAsStream(name);
+        }
+        BufferedReader buffer = new BufferedReader(new java.io.InputStreamReader(is), 8192);
+        StringBuilder source = new StringBuilder();
+        while (true) {
+            String line = buffer.readLine();
+			if (line == null) {
+				break;
+			}
+            source.append(line).append("\n");
+        }
+        buffer.close();
+        return source.toString();
+    }
+
+    /*************************************************************************************************
+     *
+     * Script Actions
+     */
+
+    public static String getScriptFilename() {
+        return callScriptingContainerMethod(String.class, "getScriptFilename");
+    }
+
+    public static void setScriptFilename(String name) {
+        callScriptingContainerMethod(Void.class, "setScriptFilename", name);
+    }
+
+    public String execute() throws IOException {
+    	Script.setScriptFilename(getClass().getClassLoader().getResource(name).getPath());
+        return Script.execute(getContents());
+    }
+
+	public static void callMethod(Object receiver, String methodName, Object[] args) {
+		// callScriptingContainerMethod(Void.class, "callMethod", receiver, methodName, 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) {
+            throw (RuntimeException)(ite.getCause());
+        }
+    }
+
+	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) {
+		// return callScriptingContainerMethod(returnType, "callMethod", receiver, methodName, args, 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) {
+            throw (RuntimeException) ite.getCause();
+        }
+	}
+
+	public static <T> T callMethod(Object receiver, String methodName,
+			Object arg, Class<T> returnType) {
+		return callMethod(receiver, methodName, new Object[]{arg}, returnType);
+	}
+
+	public static <T> T callMethod(Object receiver, String methodName,
+			Class<T> returnType) {
+		return callMethod(receiver, methodName, new Object[]{}, returnType);
+	}
+
+}
+