ruboto 0.5.2

data/assets/samples/sample_broadcast_receiver.rb

@@ -0,0 +1,6 @@
+require 'ruboto'
+
+# 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/samples/sample_broadcast_receiver_test.rb

@@ -0,0 +1 @@
+# TODO

data/assets/samples/sample_service.rb

@@ -0,0 +1,14 @@
+require 'ruboto'
+
+$service.handle_create do
+  # define what your service does. Directly put any code that you want
+  # executed when onCreate gets called. Define the rest of the
+  # behavior with handle_ blocks. See the README for more info.
+
+  # Services are complicated and don't really make sense unless you
+  # show the interaction between the Service and other parts of your
+  # app
+  # For now, just take a look at the explanation and example in
+  # online:
+  # http://developer.android.com/reference/android/app/Service.html
+end

data/assets/samples/sample_service_test.rb

@@ -0,0 +1 @@
+# TODO

data/assets/src/InheritingActivity.java

@@ -0,0 +1,195 @@
+package THE_PACKAGE;
+
+import java.io.File;
+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 {
+    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");
+        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();
+    }
+
+	private static final String RUBOTO_APK = "RubotoCore-release.apk";
+	private static final String RUBOTO_URL = "https://github.com/downloads/ruboto/ruboto/" + RUBOTO_APK;
+
+    // Called when the button 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));
+                Intent intent = new Intent(android.content.Intent.ACTION_VIEW, Uri.parse(RUBOTO_URL));
+                startActivity(intent);
+            } 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

@@ -0,0 +1,27 @@
+package THE_PACKAGE;
+
+import org.ruboto.Script;
+
+public class InheritingBroadcastReceiver extends org.ruboto.RubotoBroadcastReceiver {
+    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

@@ -0,0 +1,19 @@
+package THE_PACKAGE;
+
+import org.ruboto.Script;
+
+public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
+
+THE_CONSTANTS
+
+    private Object[] callbackProcs = new Object[CONSTANTS_COUNT];
+
+THE_CONSTRUCTORS
+
+  public void setCallbackProc(int id, Object obj) {
+    callbackProcs[id] = obj;
+  }
+	
+THE_METHODS
+
+}

data/assets/src/InheritingService.java

@@ -0,0 +1,9 @@
+package THE_PACKAGE;
+
+public class InheritingService extends org.ruboto.RubotoService {
+	public void onCreate() {
+		setScriptName("start.rb");
+		super.onCreate();
+	}
+
+}

data/assets/src/RubotoActivity.java

@@ -0,0 +1,111 @@
+package THE_PACKAGE;
+
+import java.io.IOException;
+
+import org.ruboto.Script;
+
+import android.app.ProgressDialog;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import android.view.View;
+import android.widget.TextView;
+
+public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
+    private String scriptName;
+    private String remoteVariable = null;
+    private Object[] args;
+    private Bundle configBundle;
+
+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;
+        return this;
+    }
+
+    public String getRemoteVariableCall(String call) {
+        return (remoteVariable == null ? "" : (remoteVariable + ".")) + call;
+    }
+
+    public void setScriptName(String name) {
+        scriptName = name;
+    }
+
+    /****************************************************************************************
+     *
+     *  Activity Lifecycle: onCreate
+     */
+	
+    @Override
+    public void onCreate(Bundle bundle) {
+        args = new Object[1];
+        args[0] = bundle;
+
+        configBundle = getIntent().getBundleExtra("RubotoActivity Config");
+
+        if (configBundle != null) {
+            if (configBundle.containsKey("Theme")) {
+                setTheme(configBundle.getInt("Theme"));
+            }
+            if (configBundle.containsKey("Script")) {
+                if (this.getClass().getName() == RubotoActivity.class.getName()) {
+                    setScriptName(configBundle.getString("Script"));
+                } else {
+                    throw new IllegalArgumentException("Only local Intents may set script name.");
+                }
+            }
+        }
+
+        super.onCreate(bundle);
+    
+        if (Script.isInitialized()) {
+            prepareJRuby();
+    	    loadScript();
+        }
+    }
+
+    // This causes JRuby to initialize and takes while
+    protected void prepareJRuby() {
+        Script.put("$activity", this);
+        Script.put("$bundle", args[0]);
+    }
+
+    protected void loadScript() {
+        try {
+            if (scriptName != null) {
+                new Script(scriptName).execute();
+            } else if (configBundle != null && configBundle.getString("Remote Variable") != null) {
+                setRemoteVariable(configBundle.getString("Remote Variable"));
+                if (configBundle.getBoolean("Define Remote Variable")) {
+                    Script.put(remoteVariable, this);
+                }
+                if (configBundle.getString("Initialize Script") != null) {
+                    Script.execute(configBundle.getString("Initialize Script"));
+                }
+                Script.execute(getRemoteVariableCall("on_create($bundle)"));
+            } else {
+                throw new RuntimeException("Neither script name nor remote variable was set.");
+            }
+        } catch(IOException e){
+            e.printStackTrace();
+            ProgressDialog.show(this, "Script failed", "Something bad happened", true, true);
+        }
+    }
+
+  /****************************************************************************************
+   * 
+   *  Generated Methods
+   */
+
+THE_METHODS
+
+}

data/assets/src/RubotoBroadcastReceiver.java

@@ -0,0 +1,51 @@
+package THE_PACKAGE;
+
+import java.io.IOException;
+
+public abstract class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
+    private String scriptName;
+    private String remoteVariable = "";
+
+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;
+    }
+
+    public THE_RUBOTO_CLASS(String scriptName) {
+        setScriptName(scriptName);
+        if (Script.isInitialized()) {
+            loadScript();
+        }
+    }
+
+    protected void loadScript() {
+        Script.put("$broadcast_receiver", this);
+        try {
+            new Script(scriptName).execute();
+        } catch(IOException e) {
+            throw new RuntimeException("IOException loading broadcast receiver script", e);
+        }
+    }
+
+    /****************************************************************************************
+     * 
+     *  Generated Methods
+     */
+
+THE_METHODS
+
+}	
+
+