calatrava 0.0.1

data/lib/calatrava/templates/droid/calatrava/src/com/calatrava/shell/WebViewActivity.java

@@ -0,0 +1,247 @@
+package com.calatrava.shell;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.graphics.Color;
+import android.util.Log;
+import android.webkit.JsResult;
+import android.webkit.WebChromeClient;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+import com.calatrava.bridge.RegisteredActivity;
+import com.calatrava.bridge.RhinoService;
+import com.calatrava.bridge.PageRegistry;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.Semaphore;
+
+public abstract class WebViewActivity extends RegisteredActivity {
+  private String TAG = WebViewActivity.class.getSimpleName();
+
+  private JSContainer jsContainer;
+  private WebView webView;
+  private boolean pageReady = false;
+  private RhinoService rhino;
+
+  private BroadcastReceiver receiver = new BroadcastReceiver() {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      if ("com.calatrava.dialog".equals(intent.getAction())) {
+        String name = intent.getExtras().getString("name");
+        webView.loadUrl("javascript:window." + getPageName() + "View.showDialog('" + name + "');");
+      }
+    }
+  };
+
+  @Override
+  protected void onRhinoConnected(RhinoService rhino) {
+    this.rhino = rhino;
+    jsContainer = new JSContainer(rhino, getPageName());
+    loadPage();
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+
+    onPageLoadCompleted();
+
+    if (rhino != null) {
+      pageHasOpened();
+    }
+    registerReceiver(receiver, new IntentFilter("com.calatrava.dialog"));
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+
+    PageRegistry.sharedRegistry().pageOffscreen(getPageName());
+    unregisterReceiver(receiver);
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+
+    PageRegistry.sharedRegistry().unregisterPage(getPageName());
+  }
+
+  public String getFieldValue(final String field) {
+    assert (getFields().contains(field));
+
+    Log.d(TAG, "Get value for field: " + field + " on page '" + getPageName() + "'");
+
+    FutureTask<String> fieldValue = new FutureTask<String>(new Callable<String>() {
+      public String call() throws Exception {
+        webView.loadUrl("javascript:container.provideValueFor('" + field + "', window." + getPageName() + "View.get('" + field + "'));");
+        return jsContainer.retrieveValueFor(field);
+      }
+    });
+
+    runOnUiThread(fieldValue);
+
+    String value;
+    try {
+      value = fieldValue.get();
+    } catch (Exception e) {
+      e.printStackTrace();
+      // TODO: Signal failure to the UI thread
+      return "";
+    }
+
+    Log.d(TAG, "(getFieldValue) : Got the field [" + field + "] value = " + value);
+    return value;
+  }
+
+  public void render(final String json) {
+    runOnUiThread(new Runnable() {
+      public void run() {
+        jsContainer.setJsObject(json);
+        Log.d(TAG, "render page: " + getPageName());
+
+        webView.loadUrl("javascript:container.onRenderComplete(window." + getPageName() + "View.render(JSON.parse(container.getJsObject())));");
+      }
+    });
+  }
+
+  protected abstract String getPageName();
+
+  protected abstract List<String> getEvents();
+
+  protected abstract List<String> getFields();
+    
+  protected int getBackgroundColor(){
+    return Color.TRANSPARENT;
+  }
+
+  protected void loadPage() {
+    PageRegistry.sharedRegistry().registerPage(getPageName(), this);
+
+    webView = new WebView(this);
+    setContentView(webView);
+
+    webView.getSettings().setJavaScriptEnabled(true);
+    webView.getSettings().setDomStorageEnabled(true);
+    webView.setScrollBarStyle(webView.SCROLLBARS_OUTSIDE_OVERLAY);
+    webView.setScrollbarFadingEnabled(true);
+    webView.setBackgroundColor(0xffffffff);
+    webView.addJavascriptInterface(jsContainer, "container");
+
+    webView.setWebViewClient(new WebViewClient() {
+      @Override
+      public void onPageFinished(WebView view, String url) {
+        super.onPageFinished(view, url);
+        Log.d(TAG, "Webview finished loading a URL");
+
+        pageReady = true;
+        onPageLoadCompleted();
+      }
+    });
+
+    webView.setWebChromeClient(new WebChromeClient() {
+      @Override
+      public boolean onJsAlert(WebView view, String url, String message, JsResult result) {
+        Log.d(TAG, "Received JS alert: '" + message + "'");
+        return false;
+      }
+    });
+
+    webView.loadUrl("file:///android_asset/hybrid/views/" + getPageName() + ".html");
+    pageHasOpened();
+  }
+
+  private void pageHasOpened() {
+    rhino.triggerEvent(getPageName(), "pageOpened", new String[] {});
+  }
+
+  private void onPageLoadCompleted() {
+    if (jsContainer != null && pageReady) {
+      jsContainer.onRenderComplete(null);
+
+      for (String field : getFields()) {
+        jsContainer.hasField(field);
+      }
+
+      PageRegistry.sharedRegistry().pageOnscreen(getPageName());
+    }
+  }
+
+  public class JSContainer {
+    private String TAG = JSContainer.class.getSimpleName();
+
+    private Map<String, String> lastValue = new HashMap<String, String>();
+    private Map<String, Semaphore> valueAvailable = new HashMap<String, Semaphore>();
+    private RhinoService rhino;
+    private String pageName;
+    private String jsObject;
+
+    public JSContainer(RhinoService rhino, String pageName) {
+      this.rhino = rhino;
+      this.pageName = pageName;
+    }
+
+    public void setJsObject(String jsObject) {
+      this.jsObject = jsObject;
+    }
+
+    public String getJsObject() {
+      return jsObject;
+    }
+
+    public void hasField(String field) {
+      valueAvailable.put(field, new Semaphore(0));
+    }
+
+    public void provideValueFor(String field, String value) {
+      Log.d(TAG, "Got value '" + value + "' for field '" + field + "'");
+      lastValue.put(field, value);
+      valueAvailable.get(field).release();
+    }
+
+    public String retrieveValueFor(String field) {
+      try {
+        valueAvailable.get(field).acquire();
+      } catch (InterruptedException e) {
+        return retrieveValueFor(field);
+      }
+
+      String value = lastValue.remove(field);
+      Log.d(TAG, "Reading value '" + value + "' for field '" + field + "'");
+      return value;
+    }
+
+    public void handleEvent(String event, String... extraArgs) {
+      Log.d(TAG, "User clicked");
+      Log.d(TAG, "Current thread is " + Thread.currentThread().getId());
+
+      if (extraArgs != null) {
+        Log.d(TAG, "extraArgs = " + extraArgs.length);
+        for (String arg : extraArgs) {
+          Log.d(TAG, "arg = '" + arg + "'");
+        }
+      } else {
+        Log.d(TAG, "extraArgs were null!");
+      }
+      rhino.triggerEvent(pageName, event, extraArgs);
+    }
+
+    public void onRenderComplete(Object ignored) {
+      runOnUiThread(new Runnable() {
+        public void run() {
+          for (String event : getEvents()) {
+            Log.d(TAG, "About to bind event '" + event + "'");
+            webView.loadUrl("javascript:window." + getPageName() + "View.bind('" + event + "', function() { container.handleEvent('" + event + "', _.toArray(arguments)); });");
+          }
+        }
+      });
+    }
+  }
+}

data/lib/calatrava/templates/droid/manifest.yml

@@ -0,0 +1 @@
+- converter

data/lib/calatrava/templates/ios/Podfile.calatrava

@@ -0,0 +1,5 @@
+platform :ios, '5.0'
+
+xcodeproj '{{ project_name}}.xcodeproj'
+
+pod 'calatrava', :git => 'https://github.com/calatrava/calatrava-ios'

data/lib/calatrava/templates/ios/manifest.yml

@@ -0,0 +1 @@
+- converter

data/lib/calatrava/templates/ios/res/js/bridge.js

@@ -0,0 +1,249 @@
+var tw = tw || {};
+tw.bridge = tw.bridge || {};
+
+// json.js does stupid things to the Object prototype
+Object.prototype.toJSONString = "";
+Object.prototype.parseJSON = "";
+
+function generateRandomString(){
+  var str = '';
+  var i;
+  for (i = 0; i < 32; ++i) {
+    var r = Math.floor(Math.random() * 16);
+    str = str + r.toString(16);
+  }
+  return str.toUpperCase();
+}
+
+function bridgeDispatch(proxyId) {
+  var extraArgs = _.map(_.toArray(arguments).slice(1), function(obj) { return obj.valueOf(); });
+  var proxyPage = tw.bridge.pages.pageByProxyId(proxyId);
+  proxyPage.dispatch.apply(proxyPage, extraArgs);
+}
+
+function bridgeSuccessfulResponse(requestId, response) {
+  tw.bridge.requests.successfulResponse(requestId, response);
+}
+
+function bridgeFailureResponse(requestId, errorCode, response) {
+  tw.bridge.requests.failureResponse(requestId, errorCode, response);
+}
+
+function bridgeFireTimer(timerId) {
+  tw.bridge.timers.fireTimer(timerId);
+}
+
+function bridgeInvokeCallback(widgetName) {
+  var extraArgs = _.map(_.toArray(arguments).slice(1), function(obj) { return obj.valueOf(); });
+  tw.bridge.widgets.callback(widgetName).apply(this, extraArgs);
+}
+
+tw.bridge.changePage = function(target) {
+  tw.bridge.runtime.changePage(target);
+  return target;
+};
+
+tw.bridge.widgets = (function() {
+  var callbacks;
+  callbacks = {};
+  return {
+    display: function(name, options, callback) {
+      TWBridgePageRegistry.sharedRegistry.displayWidget_withOptions(name, options);
+      return callbacks[name] = callback;
+    },
+    callback: function(name) {
+      return callbacks[name];
+    }
+  };
+})();
+
+tw.bridge.alert = function(message) {
+  TWBridgePageRegistry.sharedRegistry.alert(message);
+};
+
+tw.bridge.openUrl = function(url) {
+  tw.bridge.runtime.openUrl(url);
+};
+
+tw.bridge.trackEvent = function(event) {
+};
+
+tw.bridge.log = function(message) {
+  tw.bridge.runtime.log(message);
+};
+
+tw.bridge.request = function(options) {
+  if (options.contentType) {
+    options.customHeaders = options.customHeaders || {};
+    options.customHeaders['Content-Type'] = options.contentType;
+  }
+  tw.bridge.requests.issue(
+    options.url,
+    options.method,
+    options.body,
+    options.success,
+    options.failure,
+	  options.customHeaders);
+};
+
+tw.bridge.pageObject = function(pageName) {
+  var proxyId = generateRandomString(),
+    handlerRegistry = {};
+
+  tw.bridge.runtime.registerProxyForPage(proxyId, pageName);
+
+  function bind(event, handler) {
+    handlerRegistry[event] = handler;
+    tw.bridge.runtime.attachProxyEventHandler(proxyId, event);
+  }
+
+  function dispatch(event) {
+    args = _.toArray(arguments).slice(1);
+    if (handlerRegistry[event]) {
+      handlerRegistry[event].apply(this, args);
+    }
+  }
+
+  function get(field) {
+    return tw.bridge.runtime.valueOfProxyField(proxyId, field);
+  }
+
+  function cleanValues(jsObject) {
+    _.each(_.keys(jsObject), function(key) {
+      if (jsObject[key] === null || jsObject[key] === undefined) {
+        delete jsObject[key];
+      } else if (jsObject[key] === false) {
+        jsObject[key] = 0;
+      } else {
+        tw.bridge.log("key = '" + key + "'; value = '" + jsObject[key] + "'");
+        if (jsObject[key] instanceof Object) {
+          cleanValues(jsObject[key]);
+        }
+      }
+    });
+  }
+
+  function render(viewObject) {
+    // Clean off properties that cause problems when marshalling
+    if (viewObject.hasOwnProperty('toJSONString')) {
+      viewObject.toJSONString = null;
+    }
+
+    // Delete any keys that have a null value to avoid the Obj-C JSON
+    // serialization failure
+    if (viewObject != undefined) {
+      cleanValues(viewObject);
+    }
+    if (viewObject.hasOwnProperty('parseJSON')) {
+      viewObject.parseJSON = null;
+    }
+
+    tw.bridge.runtime.renderProxy(viewObject, proxyId);
+  }
+
+  return {
+    proxyId: proxyId,
+    bind: bind,
+    dispatch: dispatch,
+    get: get,
+    render: render
+  };
+};
+
+tw.bridge.pages = (function() {
+  var pagesByName = {},
+    pagesByProxyId = {};
+
+  function pageNamed(pageName) {
+    if (!pagesByName[pageName]) {
+      var page = tw.bridge.pageObject(pageName);
+      pagesByName[pageName] = page;
+      pagesByProxyId[page.proxyId] = page;
+    }
+    return pagesByName[pageName];
+  }
+
+  function pageByProxyId(proxyId) {
+    return pagesByProxyId[proxyId];
+  }
+
+  return {
+    pageNamed: pageNamed,
+    pageByProxyId: pageByProxyId
+  };
+}());
+
+tw.bridge.requests = (function() {
+  var successHandlersById = {},
+    failureHandlersById = {};
+
+  function issue(url, method, body, success, failure, customHeaders) {
+    var requestId = generateRandomString();
+    bodyStr = body;
+
+    if (bodyStr && bodyStr.constructor !== String) {
+      bodyStr = JSON.stringify(body);
+    }
+
+    successHandlersById[requestId] = success;
+    failureHandlersById[requestId] = failure;
+    tw.bridge.runtime.issueRequest({
+      requestId: requestId,
+      url: url,
+      method: method,
+      body: bodyStr,
+      headers: customHeaders
+    });
+  }
+
+  function successfulResponse(requestId, response) {    
+    successHandlersById[requestId](response);
+    clearHandlers(requestId);
+  }
+
+  function failureResponse(requestId, errorCode, response) {
+    failureHandlersById[requestId](errorCode, response);
+    clearHandlers(requestId);
+  }
+
+  function clearHandlers(requestId) {
+    successHandlersById[requestId] = null;
+    failureHandlersById[requestId] = null;    
+  }
+
+  return {
+    successfulResponse: successfulResponse,
+    failureResponse: failureResponse,
+    issue: issue
+  };
+}());
+
+tw.bridge.timers = (function () {
+  callbacks = {};
+
+  return {
+    start: function(timeout, callback) {
+      var timerId = generateRandomString();
+      callbacks[timerId] = callback;
+      tw.bridge.runtime.startTimerWithTimeout(timerId, timeout);
+      return timerId;
+    },
+    fireTimer: function(timerId) {
+      if (callbacks[timerId]) {
+        callbacks[timerId]();
+      }
+    },
+    clearTimer: function(timerId) {
+      delete callbacks[timerId];
+    }
+  };
+}());
+
+tw.bridge.dialog = (function() {
+  return {
+    display: function(name) {
+      TWBridgePageRegistry.sharedRegistry.displayDialog(name)
+    }
+  };
+}());
+