ruboto 1.0.3 → 1.1.0

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

@@ -0,0 +1,329 @@
+/*
+ * Copyright 2013 ThinkFree
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.ruboto;
+
+import android.app.Activity;
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.AssetManager;
+import android.os.Build;
+import android.util.Log;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Observable;
+import java.util.Observer;
+
+import dalvik.system.PathClassLoader;
+
+/**
+ * Easy class loading for multi-dex Android application.
+ *
+ * 1) call validateClassPath() from Application.onCreate()
+ * 2) check dexOptRequired then addAllJARsAssets() on non-UI thread.
+ *
+ * @author Alan Goo
+ */
+public class DexDex {
+    public static final String DIR_SUBDEX = "dexdex";
+
+    private static final String TAG = "DexDex";
+
+    private static final int SDK_INT_ICS = 14;
+
+    private static final int SDK_INT_KITKAT = 19;
+
+    private static final int BUF_SIZE = 8 * 1024;
+    public static final int PROGRESS_COMPLETE = 100;
+
+    private static ArrayList<String> theAppended = new ArrayList<String>();
+
+    public static boolean debug = false;
+
+    public static boolean dexOptRequired = false;
+
+    private static Activity uiBlockedActivity = null;
+
+    /**
+     * just reuse existing interface for convenience
+     * @hide
+     */
+    public static Observer dexOptProgressObserver = null;
+
+    private DexDex() {
+        // do not create an instance
+    }
+
+    private static boolean shouldDexOpt(File apkFile, File dexDir, String[] names) {
+        boolean result = shouldDexOptImpl(apkFile, dexDir, names);
+        if(debug) {
+            Log.d(TAG, "shouldDexOpt(" + apkFile + "," + dexDir + "," + Arrays.deepToString(names) + ") => " + result
+                + " on " + Thread.currentThread());
+        }
+        return result;
+    }
+
+    private static boolean shouldDexOptImpl(File apkFile, File dexDir, String[] names) {
+        long apkDate = apkFile.lastModified();
+        // APK upgrade case
+        if(debug) {
+            Log.d(TAG, "APK Date : " + apkDate + " ,dexDir date : " + dexDir.lastModified());
+        }
+        if (apkDate > dexDir.lastModified()) {
+            return true;
+        }
+        // clean install (or crash during install) case
+        for (int i = 0; i < names.length; i++) {
+            String name = names[i];
+            File dexJar = new File(dexDir, name);
+            if (dexJar.exists()) {
+                if (dexJar.lastModified() < apkDate) {
+                    return true;
+                }
+            } else {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Should be called from <code>Application.onCreate()</code>.
+     * it returns quickly with little disk I/O.
+     */
+    public static void validateClassPath(final Context app) {
+        try {
+            String[] arrJars = createSubDexList(app);
+            if(debug) {
+                Log.d(TAG, "validateClassPath : " + Arrays.deepToString(arrJars));
+            }
+            File apkFile = new File(app.getApplicationInfo().sourceDir);
+            final File dexDir = app.getDir(DIR_SUBDEX, Context.MODE_PRIVATE); // this API creates the directory if not exist
+            dexOptRequired = shouldDexOpt(apkFile, dexDir, arrJars);
+            if (dexOptRequired) {
+                Thread dexOptThread = new Thread("DexDex - DexOpting for " + Arrays.deepToString(arrJars)) {
+                    @Override
+                    public void run() {
+                        DexDex.addAllJARsInAssets(app);
+                        // finished
+                        dexOptRequired = false;
+
+                        if(dexOptProgressObserver!=null) {
+                            dexOptProgressObserver.update(null, PROGRESS_COMPLETE);
+                            dexOptProgressObserver = null;
+                        }
+
+                        if (uiBlockedActivity != null) {
+                            uiBlockedActivity.runOnUiThread(new Runnable() {
+                                @Override
+                                public void run() {
+                                    // FIXME(uwe): Simplify when we stop supporting android-11
+                                    // if (Build.VERSION.SDK_INT < 11) {
+                                        Intent callerIntent = uiBlockedActivity.getIntent();
+                                        uiBlockedActivity.finish();
+                                        uiBlockedActivity.startActivity(callerIntent);
+                                    // } else {
+                                    //     uiBlockedActivity.recreate();
+                                    // }
+                                    // EMXIF
+                                    uiBlockedActivity = null;
+                                }
+                            });
+                        }
+                    }
+                };
+                dexOptThread.start();
+            } else {
+                // all dex JAR are stable
+                appendOdexesToClassPath(app, dexDir, arrJars);
+            }
+            if(debug) {
+                Log.d(TAG, "validateClassPath - dexDir : " + dexDir);
+            }
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    /** find and append all JARs */
+    public static void addAllJARsInAssets(final Context cxt) {
+        try {
+            if(debug) {
+                Log.d(TAG, "addAllJARsInAssets on " + Thread.currentThread());
+            }
+            String[] arrJars = createSubDexList(cxt);
+            copyJarsFromAssets(cxt, arrJars);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static String[] createSubDexList(final Context cxt) throws IOException {
+        String[] files = cxt.getAssets().list("");
+        ArrayList<String> jarList = new ArrayList<String>();
+        for (int i = 0; i < files.length; i++) {
+            String jar = files[i];
+            if (jar.endsWith(".jar")) {
+                jarList.add(jar);
+            }
+        }
+        String[] arrJars = new String[jarList.size()];
+        jarList.toArray(arrJars);
+        return arrJars;
+    }
+
+    /**
+     * MUST be called on non-Main Thread
+     * @param names array of file names in 'assets' directory
+     */
+    public static void copyJarsFromAssets(final Context cxt, final String[] names) {
+        if(debug) {
+            Log.d(TAG, "copyJarsFromAssets(" + Arrays.deepToString(names) + ")");
+        }
+        final File dexDir = cxt.getDir(DIR_SUBDEX, Context.MODE_PRIVATE); // this API creates the directory if not exist
+        File apkFile = new File(cxt.getApplicationInfo().sourceDir);
+        // should copy subdex JARs to dexDir?
+        final boolean shouldInit = shouldDexOpt(apkFile, dexDir, names);
+        if (shouldInit) {
+            try {
+                copyToInternal(cxt, dexDir, names);
+                appendOdexesToClassPath(cxt, dexDir, names);
+            } catch (Exception e) {
+                e.printStackTrace();
+                throw new RuntimeException(e);
+            }
+        } else {
+            if (!inAppended(names)) {
+                appendOdexesToClassPath(cxt, dexDir, names);
+            }
+        }
+    }
+
+    /** checks if all <code>names</code> elements are in <code>theAppended</code> */
+    private static boolean inAppended(String[] names) {
+        for (int i = 0; i < names.length; i++) {
+            if (!theAppended.contains(names[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * append DexOptimized dex files to the classpath.
+     * @return true if additional DexOpt is required, false otherwise.
+     */
+    private static boolean appendOdexesToClassPath(Context cxt, File dexDir, String[] names) {
+        // non-existing ZIP in classpath causes an exception on ICS
+        // so filter out the non-existent
+        String strDexDir = dexDir.getAbsolutePath();
+        ArrayList<String> jarPaths = new ArrayList<String>();
+        for (int i = 0; i < names.length; i++) {
+            String jarPath = strDexDir + '/' + names[i];
+            File f = new File(jarPath);
+            if (f.isFile()) {
+                jarPaths.add(jarPath);
+            }
+        }
+
+        String[] jarsOfDex = new String[jarPaths.size()];
+        jarPaths.toArray(jarsOfDex);
+
+        PathClassLoader pcl = (PathClassLoader) cxt.getClassLoader();
+        // do something dangerous
+        try {
+            if (Build.VERSION.SDK_INT < SDK_INT_ICS) {
+                FrameworkHack.appendDexListImplUnderICS(jarsOfDex, pcl, dexDir);
+            } else { // ICS+
+                boolean kitkatPlus = Build.VERSION.SDK_INT >= SDK_INT_KITKAT;
+                ArrayList<File> jarFiles = DexDex.strings2Files(jarsOfDex);
+                FrameworkHack.appendDexListImplICS(jarFiles, pcl, dexDir, kitkatPlus);
+            }
+            // update theAppended if succeeded to prevent duplicated classpath entry
+            for (String jarName : names) {
+                theAppended.add(jarName);
+            }
+            if(debug) {
+                Log.d(TAG, "appendOdexesToClassPath completed : " + pcl);
+                Log.d(TAG, "theAppended : " + theAppended);
+            }
+        } catch (Exception ex) {
+            throw new RuntimeException(ex);
+        }
+        return true;
+    }
+
+    private static void copyToInternal(Context cxt, File destDir, String[] names) {
+        String strDestDir = destDir.getAbsolutePath();
+        AssetManager assets = cxt.getAssets();
+        byte[] buf = new byte[BUF_SIZE];
+        for (int i = 0; i < names.length; i++) {
+            String name = names[i];
+            String destPath = strDestDir + '/' + name;
+
+            try {
+                BufferedInputStream bis = new BufferedInputStream(assets.open(name));
+                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destPath));
+                int len;
+                while ((len = bis.read(buf, 0, BUF_SIZE)) > 0) {
+                    bos.write(buf, 0, len);
+                }
+                bis.close();
+                bos.close();
+            } catch (IOException ioe) {
+                ioe.printStackTrace();
+            }
+        }
+        destDir.setLastModified(System.currentTimeMillis());
+    }
+
+    private static ArrayList<File> strings2Files(String[] paths) {
+        ArrayList<File> result = new ArrayList<File>(paths.length);
+        int size = paths.length;
+        for (int i = 0; i < size; i++) {
+            result.add(new File(paths[i]));
+        }
+        return result;
+    }
+
+    public static void showUiBlocker(Activity startActivity, CharSequence title, CharSequence msg) {
+        if(debug) {
+            Log.d(TAG, "showUiBlocker() for " + startActivity);
+        }
+        uiBlockedActivity = startActivity;
+        final ProgressDialog progressDialog = new ProgressDialog(startActivity);
+        progressDialog.setMessage(msg);
+        progressDialog.setTitle(title);
+        progressDialog.setIndeterminate(true);
+        dexOptProgressObserver = new Observer() {
+            @Override
+            public void update(Observable observable, Object o) {
+                if(o==Integer.valueOf(PROGRESS_COMPLETE)) {
+                    progressDialog.dismiss();
+                }
+            }
+        };
+        
+        progressDialog.show();
+    }
+}

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

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2013 ThinkFree
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.ruboto;
+
+import android.util.Log;
+import dalvik.system.DexFile;
+import dalvik.system.PathClassLoader;
+
+import java.io.File;
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.zip.ZipFile;
+
+/**
+ * Collection of dirty codes. don't tell android team this mess.
+ * @author Alan Goo
+ */
+public class FrameworkHack {
+    private static final String TAG = "FrameworkHack";
+    public static boolean debug = false;
+
+    private FrameworkHack() {
+        // do not create an instance
+    }
+
+    /**
+     * dalvik do not have security manager
+     */
+    private static void forceSet(Object obj, Field f, Object val) throws IllegalAccessException {
+        f.setAccessible(true);
+        f.set(obj, val);
+    }
+
+    private static Object forceGetFirst(Object obj, Field fArray) throws IllegalAccessException {
+        fArray.setAccessible(true);
+        Object[] vArray = (Object[]) fArray.get(obj);
+        return vArray[0];
+    }
+
+    private static String joinPaths(String[] paths) {
+        if (paths == null) {
+            return "";
+        }
+        StringBuilder buf = new StringBuilder();
+        for (int i = 0; i < paths.length; i++) {
+            buf.append(paths[i]);
+            buf.append(':');
+        }
+        return buf.toString();
+    }
+
+    // https://android.googlesource.com/platform/dalvik/+/android-1.6_r1/libcore/dalvik/src/main/java/dalvik/system/PathClassLoader.java
+    public static void appendDexListImplUnderICS(String[] jarPathsToAppend, PathClassLoader pcl, File optDir)
+            throws Exception {
+        int oldSize = 1; // gonna assume the original path had single entry for simplicity
+        Class pclClass = pcl.getClass();
+        Field fPath = pclClass.getDeclaredField("path");
+        fPath.setAccessible(true);
+        String orgPath = fPath.get(pcl).toString();
+        String pathToAdd = joinPaths(jarPathsToAppend);
+        String path = orgPath + ':' + pathToAdd;
+        forceSet(pcl, fPath, path);
+
+        boolean wantDex = System.getProperty("android.vm.dexfile", "").equals("true");
+        File[] files = new File[oldSize + jarPathsToAppend.length];
+        ZipFile[] zips = new ZipFile[oldSize + jarPathsToAppend.length];
+        DexFile[] dexs = new DexFile[oldSize + jarPathsToAppend.length];
+
+        Field fmPaths = pclClass.getDeclaredField("mPaths");
+        String[] newMPaths = new String[oldSize + jarPathsToAppend.length];
+        // set originals
+        newMPaths[0] = (String) forceGetFirst(pcl, fmPaths);
+        forceSet(pcl, fmPaths, newMPaths);
+        Field fmFiles = pclClass.getDeclaredField("mFiles");
+        files[0] = (File) forceGetFirst(pcl, fmFiles);
+        Field fmZips = pclClass.getDeclaredField("mZips");
+        zips[0] = (ZipFile) forceGetFirst(pcl, fmZips);
+        Field fmDexs = pclClass.getDeclaredField("mDexs");
+        dexs[0] = (DexFile) forceGetFirst(pcl, fmDexs);
+
+        for (int i = 0; i < jarPathsToAppend.length; i++) {
+            newMPaths[oldSize + i] = jarPathsToAppend[i];
+            File pathFile = new File(jarPathsToAppend[i]);
+            files[oldSize + i] = pathFile;
+            zips[oldSize + i] = new ZipFile(pathFile);
+            if (wantDex) {
+                String outDexName = pathFile.getName() + ".dex";
+                File outFile = new File(optDir, outDexName);
+                dexs[oldSize + i] = DexFile.loadDex(pathFile.getAbsolutePath(), outFile.getAbsolutePath(), 0);
+            }
+        }
+        forceSet(pcl, fmFiles, files);
+        forceSet(pcl, fmZips, zips);
+        forceSet(pcl, fmDexs, dexs);
+    }
+
+    // https://android.googlesource.com/platform/libcore/+/master/libdvm/src/main/java/dalvik/system/BaseDexClassLoader.java
+    // https://android.googlesource.com/platform/libcore/+/master/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
+    public static void appendDexListImplICS(ArrayList<File> jarFiles, PathClassLoader pcl, File optDir,
+                                            boolean kitkatPlus) throws Exception {
+        if(debug) {
+            Log.d(TAG, "appendDexListImplICS(" + jarFiles);
+        }
+        // to save original values
+        Class bdclClass = Class.forName("dalvik.system.BaseDexClassLoader");
+        // ICS+ - pathList
+        Field fPathList = bdclClass.getDeclaredField("pathList");
+        fPathList.setAccessible(true);
+        Object dplObj = fPathList.get(pcl);
+        // to call DexPathList.makeDexElements() for additional jar(apk)s
+        Class dplClass = dplObj.getClass();
+        Field fDexElements = dplClass.getDeclaredField("dexElements");
+        fDexElements.setAccessible(true);
+        Object objOrgDexElements = fDexElements.get(dplObj);
+        int orgDexCount = Array.getLength(objOrgDexElements);
+        if(debug) {
+            Log.d(TAG, "orgDexCount : " + orgDexCount);
+            debugDexElements(objOrgDexElements);
+        }
+        Class clazzElement = Class.forName("dalvik.system.DexPathList$Element");
+        // create new merged array
+        int jarCount = jarFiles.size();
+        Object newDexElemArray = Array.newInstance(clazzElement, orgDexCount + jarCount);
+        System.arraycopy(objOrgDexElements, 0, newDexElemArray, 0, orgDexCount);
+        Method mMakeDexElements = null;
+        if (kitkatPlus) {
+            mMakeDexElements =
+                    dplClass.getDeclaredMethod("makeDexElements", ArrayList.class, File.class, ArrayList.class);
+        } else {
+            mMakeDexElements = dplClass.getDeclaredMethod("makeDexElements", ArrayList.class, File.class);
+        }
+        mMakeDexElements.setAccessible(true);
+        Object elemsToAdd;
+        if (kitkatPlus) {
+            elemsToAdd = mMakeDexElements.invoke(null, jarFiles, optDir, new ArrayList());
+        } else {
+            elemsToAdd = mMakeDexElements.invoke(null, jarFiles, optDir);
+        }
+        for (int i = 0; i < jarCount; i++) {
+            int pos = orgDexCount + i;
+            Object elemToAdd = Array.get(elemsToAdd, i);
+            Array.set(newDexElemArray, pos, elemToAdd);
+        }
+        if(debug) {
+            Log.d(TAG, "appendDexListImplICS() " + Arrays.deepToString((Object[]) newDexElemArray));
+        }
+        forceSet(dplObj, fDexElements, newDexElemArray);
+    }
+
+    private static void debugDexElements(Object dexElements) throws Exception {
+        Object[] objArray = (Object[]) dexElements;
+        Class clazzElement = Class.forName("dalvik.system.DexPathList$Element");
+        Field fFile = clazzElement.getDeclaredField("file");
+        fFile.setAccessible(true);
+        for (int i = 0; i < objArray.length; i++) {
+            File f = (File) fFile.get(objArray[i]);
+            Log.d(TAG, "[" + i + "] " + f);
+        }
+    }
+}

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

@@ -11,6 +11,7 @@ import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
+import android.os.Build;
 import android.os.Environment;
 import dalvik.system.PathClassLoader;
 
@@ -135,7 +136,7 @@ public class JRubyAdapter {
             System.setProperty("jruby.backtrace.style", "normal"); // normal raw full mri
             System.setProperty("jruby.bytecode.version", "1.6");
             // BEGIN Ruboto RubyVersion
-            // System.setProperty("jruby.compat.version", "RUBY1_9"); // RUBY1_9 is the default in JRuby 1.7
+            // System.setProperty("jruby.compat.version", "RUBY2_0"); // RUBY1_9 is the default in JRuby 1.7
             // END Ruboto RubyVersion
             // System.setProperty("jruby.compile.backend", "DALVIK");
             System.setProperty("jruby.compile.mode", "OFF"); // OFF OFFIR JITIR? FORCE FORCEIR
@@ -157,6 +158,18 @@ public class JRubyAdapter {
             System.setProperty("jruby.ji.upper.case.package.name.allowed", "true");
             System.setProperty("jruby.class.cache.path", appContext.getDir("dex", 0).getAbsolutePath());
 
+            // FIXME(uwe): Simplify when we stop supporting android-15
+            if (Build.VERSION.SDK_INT >= 16) {
+                DexDex.debug = true;
+                DexDex.validateClassPath(appContext);
+                while (DexDex.dexOptRequired) {
+                    System.out.println("Waiting for class loader setup...");
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException ie) {}
+                }
+            }
+
             ClassLoader classLoader;
             Class<?> scriptingContainerClass;
             String apkName = null;
@@ -240,6 +253,9 @@ public class JRubyAdapter {
                     rubyInstanceConfigClass.getMethod("setError", PrintStream.class).invoke(config, output);
                 }
 
+                System.out.println("Ruby version: " + rubyInstanceConfigClass
+                        .getMethod("getCompatVersion").invoke(config));
+
                 // This will become the global runtime and be used by our ScriptingContainer
                 rubyClass.getMethod("newInstance", rubyInstanceConfigClass).invoke(null, config);
 
@@ -265,19 +281,27 @@ public class JRubyAdapter {
 
                 Thread.currentThread().setContextClassLoader(classLoader);
 
+                String scriptsDir = scriptsDirName(appContext);
+                addLoadPath(scriptsDir);
                 if (appContext.getFilesDir() != null) {
                     String defaultCurrentDir = appContext.getFilesDir().getPath();
                     Log.d("Setting JRuby current directory to " + defaultCurrentDir);
                     callScriptingContainerMethod(Void.class, "setCurrentDirectory", defaultCurrentDir);
                 } else {
                     Log.e("Unable to find app files dir!");
+                    if (new File(scriptsDir).exists()) {
+                        Log.d("Changing JRuby current directory to " + scriptsDir);
+                        callScriptingContainerMethod(Void.class, "setCurrentDirectory", scriptsDir);
+                    }
                 }
 
-                addLoadPath(scriptsDirName(appContext));
                 put("$package_name", appContext.getPackageName());
 
                 runScriptlet("::RUBOTO_JAVA_PROXIES = {}");
 
+                System.out.println("JRuby version: " + Class.forName("org.jruby.runtime.Constants", true, scriptingContainerClass.getClassLoader())
+                        .getDeclaredField("VERSION").get(String.class));
+
                 initialized = true;
             } catch (ClassNotFoundException e) {
                 handleInitException(e);
@@ -293,6 +317,8 @@ public class JRubyAdapter {
                 handleInitException(e);
             } catch (NoSuchMethodException e) {
                 handleInitException(e);
+            } catch (NoSuchFieldException e) {
+                handleInitException(e);
             }
         }
         return initialized;
@@ -311,8 +337,6 @@ public class JRubyAdapter {
             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);

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

@@ -34,7 +34,7 @@ public class ScriptLoader {
                     Log.d("Found script.");
                     rubyInstance = component;
                     final String script = rubyScript.getContents();
-                    boolean scriptContainsClass = script.matches("(?s).*class "
+                    boolean scriptContainsClass = script.matches("(?s).*class\\s+"
                             + component.getScriptInfo().getRubyClassName() + ".*");
                     boolean hasBackingJavaClass = component.getScriptInfo().getRubyClassName()
                             .equals(component.getClass().getSimpleName());

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

@@ -38,6 +38,7 @@ public class SplashActivity extends Activity {
         } catch (Exception e) {
             splash = -1;
         }
+        requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
         if (!JRubyAdapter.isInitialized()) {
             initJRuby(true);
         }
@@ -164,7 +165,6 @@ public class SplashActivity extends Activity {
         if (loadingDialog == null) {
             if (splash > 0) {
                 Log.i("Showing splash");
-                requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
                 setContentView(splash);
             } else {
                 Log.i("Showing progress");
@@ -184,7 +184,6 @@ public class SplashActivity extends Activity {
         if (loadingDialog == null) {
             if (splash > 0) {
                 Log.i("Showing splash");
-                requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
                 setContentView(splash);
             } else {
                 Log.i("Showing progress");

data/assets/src/ruboto/activity/reload.rb

@@ -43,6 +43,7 @@ module Ruboto::Activity::Reload
       file_string = reload_intent.get_string_extra('reload')
       if file_string
         scripts_dir = @activity.getExternalFilesDir(nil).absolute_path + '/scripts'
+        files = file_string.split(/(?<!&);/).map { |f| f.gsub(/&(.)/) { |m| m[1] } }
         files.each do |file|
           Log.d "load file: #{scripts_dir}/#{file}"
           load "#{scripts_dir}/#{file}"

data/assets/src/ruboto/activity.rb

@@ -59,12 +59,18 @@ module Ruboto
 
       script_name = options.delete(:script)
       extras = options.delete(:extras)
+      flags = options.delete(:flags)
+
       raise "Unknown options: #{options}" unless options.empty?
 
-      if class_name.nil? && block_given?
-        src_desc = source_descriptor(block)
-        class_name =
-            "#{java_class.name.split('::').last}_#{src_desc[0].split('/').last.gsub(/[.-]+/, '_')}_#{src_desc[1]}"
+      if class_name.nil?
+        if block_given?
+          src_desc = source_descriptor(block)
+          class_name =
+              "#{java_class.name.split('::').last}_#{src_desc[0].split('/').last.gsub(/[.-]+/, '_')}_#{src_desc[1]}"
+        else
+          class_name = java_class.name.split('::').last
+        end
       end
 
       class_name = class_name.to_s
@@ -76,6 +82,7 @@ module Ruboto
       end
       i = android.content.Intent.new
       i.setClass self, java_class.java_class
+      i.add_flags(flags) if flags
       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
@@ -124,4 +131,3 @@ end
 java_import 'android.app.Activity'
 java_import 'org.ruboto.RubotoActivity'
 ruboto_configure_activity(RubotoActivity)
-