calatrava 0.0.1

data/lib/calatrava/templates/droid/calatrava/src/com/calatrava/bridge/Launcher.java

@@ -0,0 +1,85 @@
+package com.calatrava.bridge;
+
+import android.app.Application;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class Launcher {
+  private static String TAG = Launcher.class.getSimpleName();
+
+  private static String appName;
+  private static RhinoService rhino;
+  private static Context appContext;
+  private static Application application;
+  private static Runnable startUp;
+
+  static ServiceConnection connection = new ServiceConnection() {
+    public void onServiceConnected(ComponentName componentName, IBinder iBinder)
+    {
+      try
+      {
+        rhino = ((RhinoService.LocalBinder) iBinder).getService();
+        PageRegistry.setSharedRegistry(new PageRegistry(appName, appContext, application, rhino));
+        AjaxRequestManager.setSharedManager(new AjaxRequestManager(appContext, rhino));
+        initBridge();
+        startUp.run();
+      }
+      catch (Exception e)
+      {
+        Log.e(TAG, "Unable to start.", e);
+      }
+    }
+
+    public void onServiceDisconnected(ComponentName componentName) {
+
+    }
+  };
+
+  public static void launchKernel(String appName,
+                                  Context appContext,
+                                  Application application,
+                                  Runnable startUp) {
+    Launcher.appName = appName;
+    Launcher.appContext = appContext;
+    Launcher.application = application;
+    Launcher.startUp = startUp;
+
+    Intent serviceIntent = new Intent(appContext, RhinoService.class);
+    appContext.bindService(serviceIntent, connection, Context.BIND_AUTO_CREATE);
+  }
+
+  public static void launchFlow(String flow)
+  {
+    rhino.callJsFunction(flow);
+  }
+
+  private static void initBridge() {
+    AssetRepository assets = new AssetRepository(appContext);
+
+    try {
+      Log.d(TAG, "About to prep the rhino");
+      rhino.initRhino();
+
+      Log.d(TAG, "About to load and start kernel");
+      // Load all the application JS
+      KernelBridge bridge = new KernelBridge(assets, rhino);
+      BufferedReader loadFileReader = new BufferedReader(new InputStreamReader(appContext.getAssets().open("hybrid/load_file.text")), 8192);
+      String line = null;
+      while ((line = loadFileReader.readLine()) != null)
+      {
+        bridge.loadLibrary(line);
+      }
+
+    } catch (IOException e) {
+      Log.d(TAG, "LauncherActivity failed to start: " + e);
+    }
+  }
+}

data/lib/calatrava/templates/droid/calatrava/src/com/calatrava/bridge/PageRegistry.java

@@ -0,0 +1,225 @@
+package com.calatrava.bridge;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ContextWrapper;
+import android.net.Uri;
+import android.util.Log;
+import android.content.pm.PackageManager.NameNotFoundException;
+
+import org.mozilla.javascript.ScriptableObject;
+
+import com.calatrava.CalatravaPage;
+
+import java.util.*;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+
+import dalvik.system.DexFile;
+import dalvik.system.PathClassLoader;
+import dalvik.system.DexClassLoader;
+
+import java.lang.annotation.Annotation;
+
+public class PageRegistry {
+  public static String TAG = PageRegistry.class.getSimpleName();
+  private static PageRegistry sharedRegistry;
+
+  private Context appContext;
+  private RhinoService rhino;
+  private Map<String, Class<?>> pageFactories = new HashMap<String, Class<?>>();
+  private Map<String, RegisteredPage> registeredPages = new HashMap<String, RegisteredPage>();
+
+  public static PageRegistry sharedRegistry() {
+    return sharedRegistry;
+  }
+
+  public static void setSharedRegistry(PageRegistry shared) {
+    Log.d(TAG, "Set shared page registry");
+    sharedRegistry = shared;
+  }
+
+  public PageRegistry(String appName, Context appContext, Application app, RhinoService rhino)
+    throws IOException, URISyntaxException, ClassNotFoundException, NameNotFoundException
+  {
+    this.appContext = appContext;
+    this.rhino = rhino;
+
+    // Find all the logical page classes in the app
+    Log.d(TAG, "Searching for Calatrava pages in '" + appName + "'");
+    addPages(appName, appContext);
+  }
+
+  private void addPages(String packageName, Context context)
+    throws IOException, URISyntaxException, ClassNotFoundException, NameNotFoundException
+  {
+    String apkName = context.getPackageManager().getApplicationInfo(packageName, 0).sourceDir;
+    DexFile dexFile = new DexFile(apkName);
+    PathClassLoader classLoader2 = new PathClassLoader(apkName, Thread.currentThread().getContextClassLoader());
+    DexClassLoader classLoader = new DexClassLoader(apkName, new ContextWrapper(context).getCacheDir().getAbsolutePath(), null, classLoader2);
+
+    Enumeration<String> entries = dexFile.entries();
+    while (entries.hasMoreElements())
+    {
+      String entry = entries.nextElement();
+      // only check items that exist in source package and not in libraries, etc.
+      if (entry.startsWith(packageName))
+      {
+        Class<?> entryClass = classLoader.loadClass(entry);
+        if (entryClass != null)
+        {
+          Annotation[] annotations = entryClass.getAnnotations();
+          for (Annotation annotation : annotations)
+          {
+            if (annotation instanceof CalatravaPage)
+            {
+              String pageName = ((CalatravaPage)annotation).name();
+              Log.d(TAG, "Registering Calatrava page: " + pageName);
+              pageFactories.put(pageName, entryClass);
+            }
+          }
+        }
+      }               
+    }
+  }
+  
+  public void changePage(String target) {
+    Log.d(TAG, "changePage('" + target + "')");
+    Class activityClass = pageFactories.get(target);
+    Log.d(TAG, "Activity to be started: " + activityClass.getSimpleName());
+    appContext.startActivity(new Intent(appContext, activityClass));
+  }
+
+  public void displayWidget(String name, String options) {
+    appContext.sendBroadcast(new Intent("com.calatrava.widget").putExtra("name", name).putExtra("options", options));
+  }
+
+  public void displayDialog(String dialogName) {
+    appContext.sendBroadcast(new Intent("com.calatrava.dialog").putExtra("name", dialogName));
+  }
+
+  public void alert(String message) {
+    Log.d(TAG, "Broadcasting alert message: '" + message + "'");
+    appContext.sendBroadcast(new Intent("com.calatrava.alert").putExtra("message", message));
+  }
+
+  public void openUrl(String url) {
+    Intent browser = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
+    appContext.startActivity(browser);
+  }
+
+  public void track(String pageName, String channel, String eventName, Object variables, Object properties) {
+  }
+
+  public void startTimer(int timeout, final String timerId) {
+    final Timer timer = new Timer();
+    timer.schedule(new TimerTask() {
+      @Override
+      public void run() {
+        timer.cancel();
+        timer.purge();
+        rhino.callJsFunction("tw.bridge.timers.fireTimer", new String[] {timerId});
+      }
+    }, 1000 * timeout);
+  }
+
+  private HashMap<String, String> jsObjectToMap(ScriptableObject obj) {
+    HashMap<String, String> map = new HashMap<String, String>();
+    for (Object k : obj.getIds()) {
+      if (k instanceof String) {
+        map.put((String) k, ScriptableObject.getProperty(obj, (String) k).toString());
+      }
+    }
+    return map;
+  }
+
+  private void ensureRegisteredPage(String name, RegisteredActivity page) {
+    if (registeredPages.get(name) == null) {
+      registeredPages.put(name, new RegisteredPage(page));
+    } else if (page != null) {
+      registeredPages.get(name).setPage(page);
+    }
+  }
+
+  public void registerPage(String name, RegisteredActivity page) {
+    ensureRegisteredPage(name, page);
+  }
+
+  public void unregisterPage(String pageName) {
+    registeredPages.remove(pageName);
+  }
+
+  public String getValueForField(String page, String field) {
+    Log.d(TAG, "Requesting field '" + field + "' from page '" + page + "'");
+    ensureRegisteredPage(page, null);
+    return registeredPages.get(page).getFieldValue(field);
+  }
+
+  public void renderPage(String page, String renderJson) {
+    Log.d(TAG, "renderPage: '" + page + "' Response object: " + renderJson);
+
+    ensureRegisteredPage(page, null);
+    registeredPages.get(page).render(renderJson);
+  }
+
+  public void pageOffscreen(String page) {
+    ensureRegisteredPage(page, null);
+    registeredPages.get(page).pageOffscreen();
+  }
+
+  public void pageOnscreen(String page) {
+    ensureRegisteredPage(page, null);
+    registeredPages.get(page).pageOnscreen();
+  }
+
+  private class RegisteredPage {
+    private RegisteredActivity activity;
+    List<String> pendingRenders = new ArrayList<String>();
+    boolean onScreen = false;
+
+    private RegisteredPage(RegisteredActivity activity) {
+      this.activity = activity;
+    }
+
+    public RegisteredActivity getPage() {
+      return activity;
+    }
+
+    public void setPage(RegisteredActivity page) {
+      this.activity = page;
+    }
+
+    public void render(String renderJson) {
+      if (activity != null && onScreen) {
+        activity.render(renderJson);
+      } else {
+        pendingRenders.add(renderJson);
+      }
+    }
+
+    public String getFieldValue(String field) {
+      if (activity != null) {
+        return activity.getFieldValue(field);
+      } else {
+        return "";
+      }
+    }
+
+    public void pageOffscreen() {
+      onScreen = false;
+    }
+
+    public void pageOnscreen() {
+      onScreen = true;
+
+      for (String pendingRender : pendingRenders) {
+        Log.d(TAG, "Pending activity for: " + pendingRender);
+
+        activity.render(pendingRender);
+      }
+      pendingRenders.clear();
+    }
+  }
+}

data/lib/calatrava/templates/droid/calatrava/src/com/calatrava/bridge/RegisteredActivity.java

@@ -0,0 +1,86 @@
+package com.calatrava.bridge;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.*;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.util.Log;
+
+public abstract class RegisteredActivity extends Activity {
+  private String TAG = RegisteredActivity.class.getSimpleName();
+
+  private RhinoService rhino;
+  private RequestLoader spinner = new RequestLoader(this);
+  private ServiceConnection connection = new ServiceConnection() {
+    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+      rhino = ((RhinoService.LocalBinder) iBinder).getService();
+      RegisteredActivity.this.onRhinoConnected(rhino);
+    }
+
+    public void onServiceDisconnected(ComponentName componentName) {
+
+    }
+  };
+
+  private BroadcastReceiver receiver = new BroadcastReceiver() {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      Log.d(TAG, "Received broadcast");
+      if (intent.getAction().endsWith("start")) {
+        spinner.onLoadingStart();
+      } else if (intent.getAction().endsWith("finish")) {
+        spinner.onLoadingFinish();
+      } else {
+        AlertDialog.Builder builder = new AlertDialog.Builder(RegisteredActivity.this);
+        builder.setMessage(intent.getExtras().getString("message"))
+            .setCancelable(false)
+            .setPositiveButton("OK", new DialogInterface.OnClickListener() {
+              @Override
+              public void onClick(DialogInterface dialogInterface, int i) {
+                dialogInterface.dismiss();
+              }
+            });
+        AlertDialog dialog = builder.create();
+        dialog.show();
+      }
+    }
+  };
+
+  @Override
+  protected void onCreate(Bundle availableData) {
+    super.onCreate(availableData);
+    Intent serviceIntent = new Intent(this, RhinoService.class);
+    bindService(serviceIntent, connection, Context.BIND_AUTO_CREATE);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    registerReceiver(receiver, new IntentFilter("com.calatrava.ajax.start"));
+    registerReceiver(receiver, new IntentFilter("com.calatrava.ajax.finish"));
+    registerReceiver(receiver, new IntentFilter("com.calatrava.alert"));
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    unregisterReceiver(receiver);
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    unbindService(connection);
+  }
+  
+  public void invokeWidgetCallback(String...args) {
+    rhino.callJsFunction("tw.bridge.widgets.invokeCallback", args);
+  }
+
+  protected abstract void onRhinoConnected(RhinoService rhino);
+
+  public abstract String getFieldValue(String field);
+
+  public abstract void render(final String json);
+}

data/lib/calatrava/templates/droid/calatrava/src/com/calatrava/bridge/RequestLoader.java

@@ -0,0 +1,31 @@
+package com.calatrava.bridge;
+
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.util.Log;
+
+public class RequestLoader {
+  private String TAG = RequestLoader.class.getSimpleName();
+
+  private ProgressDialog dialog;
+  private Activity parent;
+
+  public RequestLoader(Activity parent) {
+    this.parent = parent;
+  }
+
+  public void onLoadingStart() {
+    Log.d(TAG, "About to create loader");
+    dialog = new ProgressDialog(parent);
+    dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
+    dialog.setMessage("Loading...");
+    dialog.setCancelable(false);
+    dialog.show();
+  }
+  
+  public void onLoadingFinish() {
+    dialog.hide();
+  }
+}

data/lib/calatrava/templates/droid/calatrava/src/com/calatrava/bridge/RhinoService.java

@@ -0,0 +1,212 @@
+package com.calatrava.bridge;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.*;
+import android.util.Log;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.lang.String;
+import java.lang.ThreadGroup;
+import java.util.concurrent.CountDownLatch;
+
+public class RhinoService extends Service {
+  public static String TAG = RhinoService.class.getSimpleName();
+
+  private Scriptable mScope;
+  private JSEvalThread evaller = new JSEvalThread();
+
+  private final IBinder mBinder = new LocalBinder();
+  
+  CountDownLatch countDownLatch = new CountDownLatch(1);
+
+  @Override
+  public IBinder onBind(Intent intent) {
+    return mBinder;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    Log.d(TAG, "RhinoService created.");
+  }
+
+  public void initRhino() {
+    Context ctxt = enterContext();
+    try {
+      mScope = ctxt.initStandardObjects();
+
+      Object wrappedRegistry = Context.javaToJS(PageRegistry.sharedRegistry(), mScope);
+      ScriptableObject.putProperty(mScope, "pageRegistry", wrappedRegistry);
+
+      Object wrappedAjaxRequestManagerRegistry = Context.javaToJS(AjaxRequestManager.sharedManager(), mScope);
+      ScriptableObject.putProperty(mScope, "ajaxRequestManagerRegistry", wrappedAjaxRequestManagerRegistry);
+
+      evaller.start();
+      try {
+        countDownLatch.await();
+      } catch (InterruptedException e) {
+        Log.d(TAG, "Interrupted Exception when waiting for JSEvalThread");
+        e.printStackTrace();
+      }
+    } finally {
+      Context.exit();
+    }
+  }
+
+  private Context enterContext() {
+    Context ctxt = Context.enter();
+    // No pre-compilation
+    ctxt.setOptimizationLevel(-1);
+    return ctxt;
+  }
+
+  @Override
+  public void onDestroy() {
+    Log.d(TAG, "RhinoService destroyed.");
+    super.onDestroy();
+  }
+
+  public void load(Reader source, String name) {
+    evaller.load(source, name);
+  }
+
+  public void triggerEvent(String page, String eventId, String[] extraArgs) {
+    evaller.triggerEvent(page, eventId, extraArgs);
+  }
+
+  public void invokeSuccessCallback(String requestId, String response) {
+    evaller.ajaxSuccessfulResponse(requestId, response);
+  }
+
+  public void invokeFailureCallback(String requestId, int statusCode, String responseBody) {
+    evaller.ajaxFailureResponse(requestId, statusCode, responseBody);
+  }
+
+  public void callJsFunction(String function) {
+    evaller.callJsFunction(function);
+  }
+
+  public void callJsFunction(String function, String[] args) {
+    evaller.callJsFunction(function, args);
+  }
+
+  public class LocalBinder extends Binder {
+    public RhinoService getService() {
+      return RhinoService.this;
+    }
+  }
+
+  class JSEvalThread extends Thread {
+    private Handler handler;
+    private Context ctxt;
+
+    public JSEvalThread() {
+      super(null, null, "js eval thread", 32768);
+    }
+    
+    public void load(final Reader source, final String name) {
+      handler.post(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            Log.d(TAG, "Loading file: '" + name + "'");
+            ctxt.evaluateReader(mScope, source, name, 0, null);
+          } catch (IOException e) {
+            Log.e(TAG, "Error loading file: '" + name + "'", e);
+          }
+        }
+      });
+    }
+
+    public void callJsFunction(String function) {
+      String js = "{0}();"
+          .replace("{0}", function);
+      dispatchJs(js);
+    }
+
+    public void callJsFunction(String function, String[] args) {
+      StringBuilder sb = new StringBuilder("");
+      boolean first = true;
+      for (String arg : args) {
+        if (!first) {
+          sb.append(",");
+        }
+        first = false;
+        sb.append("'" + arg + "'");
+      }
+
+      String js = "{0}({1});"
+        .replace("{0}", function)
+        .replace("{1}", sb.toString());
+
+      Log.d(TAG, "Dispatching: " + js);
+
+      dispatchJs(js);
+    }
+
+    public void triggerEvent(String page, String eventId, String[] extraArgs) {
+      StringBuilder sb = new StringBuilder("");
+      for (String arg : extraArgs) {
+        sb.append(", '");
+        sb.append(arg);
+        sb.append("'");
+      }
+      String js = "tw.bridge.dispatchEvent('{0}', '{1}'{2});"
+          .replace("{0}", page)
+          .replace("{1}", eventId)
+          .replace("{2}", sb.toString());
+
+      Log.d(TAG, "Dispatching: " + js);
+
+      dispatchJs(js);
+    }
+
+    public void ajaxSuccessfulResponse(String requestId, String json) {
+      String js = "tw.bridge.requests.successfulResponse('{0}', '{1}');"
+          .replace("{0}", requestId)
+          .replace("{1}", json);
+      dispatchJs(js);
+    }
+
+    public void ajaxFailureResponse(String requestId, int statusCode, String responseBody) {
+      String js = "tw.bridge.requests.failureResponse('{0}', {1}, '{2}');"
+          .replace("{0}", requestId)
+          .replace("{1}", Integer.toString(statusCode))
+          .replace("{2}", responseBody);
+      dispatchJs(js);
+    }
+
+    public void run() {
+      Looper.prepare();
+      ctxt = enterContext();
+
+      try {
+        handler = new Handler();
+        countDownLatch.countDown();
+        Looper.loop();
+      }
+      finally {
+        Context.exit();
+      }
+    }
+
+    private void dispatchJs(final String js) {
+      handler.post(new Runnable() {
+        @Override
+        public void run() {
+          eval(js);
+        }
+      });
+    }
+
+    private void eval(String jsCode) {
+      ctxt.evaluateString(mScope, jsCode, "<Bridge>", 1, null);
+    }
+
+  }
+}