diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..d6432d8
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,22 @@
+#
+##  Copyright (C) 2016 Google, Inc.
+#
+##  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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
+
diff --git a/Common/Android.mk b/Common/Android.mk
new file mode 100644
index 0000000..fc92181
--- /dev/null
+++ b/Common/Android.mk
@@ -0,0 +1,35 @@
+#
+#  Copyright (C) 2016 Google, Inc.
+#
+#  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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+
+LOCAL_MODULE := sl4a.Common
+LOCAL_MODULE_OWNER := google
+
+LOCAL_STATIC_JAVA_LIBRARIES := guava android-common sl4a.Utils
+LOCAL_JAVA_LIBRARIES := telephony-common
+LOCAL_JAVA_LIBRARIES += ims-common
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src/com/googlecode/android_scripting)
+LOCAL_SRC_FILES += $(call all-java-files-under, src/org/apache/commons/codec)
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+include $(CLEAR_VARS)
+include $(BUILD_MULTI_PREBUILT)
diff --git a/Common/src/com/googlecode/android_scripting/BaseApplication.java b/Common/src/com/googlecode/android_scripting/BaseApplication.java
new file mode 100644
index 0000000..f0b6905
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/BaseApplication.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.Application;
+
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.trigger.TriggerRepository;
+
+public class BaseApplication extends Application {
+
+  private final FutureActivityTaskExecutor mTaskExecutor = new FutureActivityTaskExecutor(this);
+  private TriggerRepository mTriggerRepository;
+
+  protected InterpreterConfiguration mConfiguration;
+
+  public FutureActivityTaskExecutor getTaskExecutor() {
+    return mTaskExecutor;
+  }
+
+  @Override
+  public void onCreate() {
+    mConfiguration = new InterpreterConfiguration(this);
+    mConfiguration.startDiscovering();
+    mTriggerRepository = new TriggerRepository(this);
+  }
+
+  public InterpreterConfiguration getInterpreterConfiguration() {
+    return mConfiguration;
+  }
+
+  public TriggerRepository getTriggerRepository() {
+    return mTriggerRepository;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/Constants.java b/Common/src/com/googlecode/android_scripting/Constants.java
new file mode 100644
index 0000000..4b18bba
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/Constants.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.ComponentName;
+
+public interface Constants {
+
+  public static final String ACTION_LAUNCH_FOREGROUND_SCRIPT =
+      "com.googlecode.android_scripting.action.LAUNCH_FOREGROUND_SCRIPT";
+  public static final String ACTION_LAUNCH_BACKGROUND_SCRIPT =
+      "com.googlecode.android_scripting.action.LAUNCH_BACKGROUND_SCRIPT";
+  public static final String ACTION_LAUNCH_SCRIPT_FOR_RESULT =
+      "com.googlecode.android_scripting.action.ACTION_LAUNCH_SCRIPT_FOR_RESULT";
+  public static final String ACTION_LAUNCH_INTERPRETER =
+      "com.googlecode.android_scripting.action.LAUNCH_INTERPRETER";
+  public static final String ACTION_EDIT_SCRIPT =
+      "com.googlecode.android_scripting.action.EDIT_SCRIPT";
+  public static final String ACTION_SAVE_SCRIPT =
+      "com.googlecode.android_scripting.action.SAVE_SCRIPT";
+  public static final String ACTION_SAVE_AND_RUN_SCRIPT =
+      "com.googlecode.android_scripting.action.SAVE_AND_RUN_SCRIPT";
+  public static final String ACTION_KILL_PROCESS =
+      "com.googlecode.android_scripting.action.KILL_PROCESS";
+  public static final String ACTION_KILL_ALL = "com.googlecode.android_scripting.action.KILL_ALL";
+  public static final String ACTION_SHOW_RUNNING_SCRIPTS =
+      "com.googlecode.android_scripting.action.SHOW_RUNNING_SCRIPTS";
+  public static final String ACTION_CANCEL_NOTIFICATION =
+      "com.googlecode.android_scripting.action.CANCEL_NOTIFICAITON";
+  public static final String ACTION_ACTIVITY_RESULT =
+      "com.googlecode.android_scripting.action.ACTIVITY_RESULT";
+  public static final String ACTION_LAUNCH_SERVER =
+      "com.googlecode.android_scripting.action.LAUNCH_SERVER";
+
+  public static final String EXTRA_RESULT = "SCRIPT_RESULT";
+  public static final String EXTRA_SCRIPT_PATH =
+      "com.googlecode.android_scripting.extra.SCRIPT_PATH";
+  public static final String EXTRA_SCRIPT_CONTENT =
+      "com.googlecode.android_scripting.extra.SCRIPT_CONTENT";
+  public static final String EXTRA_INTERPRETER_NAME =
+      "com.googlecode.android_scripting.extra.INTERPRETER_NAME";
+
+  public static final String EXTRA_USE_EXTERNAL_IP =
+      "com.googlecode.android_scripting.extra.USE_PUBLIC_IP";
+  public static final String EXTRA_USE_SERVICE_PORT =
+      "com.googlecode.android_scripting.extra.USE_SERVICE_PORT";
+  public static final String EXTRA_SCRIPT_TEXT =
+      "com.googlecode.android_scripting.extra.SCRIPT_TEXT";
+  public static final String EXTRA_RPC_HELP_TEXT =
+      "com.googlecode.android_scripting.extra.RPC_HELP_TEXT";
+  public static final String EXTRA_API_PROMPT_RPC_NAME =
+      "com.googlecode.android_scripting.extra.API_PROMPT_RPC_NAME";
+  public static final String EXTRA_API_PROMPT_VALUES =
+      "com.googlecode.android_scripting.extra.API_PROMPT_VALUES";
+  public static final String EXTRA_PROXY_PORT = "com.googlecode.android_scripting.extra.PROXY_PORT";
+  public static final String EXTRA_PROCESS_ID =
+      "com.googlecode.android_scripting.extra.SCRIPT_PROCESS_ID";
+  public static final String EXTRA_IS_NEW_SCRIPT =
+      "com.googlecode.android_scripting.extra.IS_NEW_SCRIPT";
+  public static final String EXTRA_TRIGGER_ID =
+      "com.googlecode.android_scripting.extra.EXTRA_TRIGGER_ID";
+  public static final String EXTRA_LAUNCH_IN_BACKGROUND =
+      "com.googlecode.android_scripting.extra.EXTRA_LAUNCH_IN_BACKGROUND";
+  public static final String EXTRA_TASK_ID = "com.googlecode.android_scripting.extra.EXTRA_TASK_ID";
+
+  // BluetoothDeviceManager
+  public static final String EXTRA_DEVICE_ADDRESS =
+      "com.googlecode.android_scripting.extra.device_address";
+
+  public static final ComponentName SL4A_SERVICE_COMPONENT_NAME = new ComponentName(
+      "com.googlecode.android_scripting",
+      "com.googlecode.android_scripting.activity.ScriptingLayerService");
+  public static final ComponentName SL4A_SERVICE_LAUNCHER_COMPONENT_NAME = new ComponentName(
+      "com.googlecode.android_scripting",
+      "com.googlecode.android_scripting.activity.ScriptingLayerServiceLauncher");
+  public static final ComponentName BLUETOOTH_DEVICE_LIST_COMPONENT_NAME = new ComponentName(
+      "com.googlecode.android_scripting",
+      "com.googlecode.android_scripting.activity.BluetoothDeviceList");
+  public static final ComponentName TRIGGER_SERVICE_COMPONENT_NAME = new ComponentName(
+      "com.googlecode.android_scripting",
+      "com.googlecode.android_scripting.activity.TriggerService");
+
+  // Preference Keys
+
+  public static final String FORCE_BROWSER = "helpForceBrowser";
+  public final static String HIDE_NOTIFY = "hideServiceNotifications";
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/Exec.java b/Common/src/com/googlecode/android_scripting/Exec.java
new file mode 100644
index 0000000..778b5a3
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/Exec.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import java.io.FileDescriptor;
+
+/**
+ * Tools for executing commands.
+ */
+public class Exec {
+  /**
+   * @param cmd
+   *          The command to execute
+   * @param arg0
+   *          The first argument to the command, may be null
+   * @param arg1
+   *          the second argument to the command, may be null
+   * @return the file descriptor of the started process.
+   *
+   */
+  public static FileDescriptor createSubprocess(String command, String[] arguments,
+      String[] environmentVariables, String workingDirectory) {
+    return createSubprocess(command, arguments, environmentVariables, workingDirectory, null);
+  }
+
+  /**
+   * @param cmd
+   *          The command to execute
+   * @param arguments
+   *          Array of arguments, may be null
+   * @param environmentVariables
+   *          Array of environment variables, may be null
+   * @param processId
+   *          A one-element array to which the process ID of the started process will be written.
+   * @return the file descriptor of the opened process's psuedo-terminal.
+   *
+   */
+  public static native FileDescriptor createSubprocess(String command, String[] arguments,
+      String[] environmentVariables, String workingDirectory, int[] processId);
+
+  public static native void setPtyWindowSize(FileDescriptor fd, int row, int col, int xpixel,
+      int ypixel);
+
+  /**
+   * Causes the calling thread to wait for the process associated with the receiver to finish
+   * executing.
+   *
+   * @return The exit value of the Process being waited on
+   *
+   */
+  public static native int waitFor(int processId);
+
+  static {
+    System.loadLibrary("com_googlecode_android_scripting_Exec");
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/FeaturedInterpreters.java b/Common/src/com/googlecode/android_scripting/FeaturedInterpreters.java
new file mode 100644
index 0000000..005560b
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/FeaturedInterpreters.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.Context;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class FeaturedInterpreters {
+  private static final Map<String, FeaturedInterpreter> mNameMap =
+      new HashMap<String, FeaturedInterpreter>();
+  private static final Map<String, FeaturedInterpreter> mExtensionMap =
+      new HashMap<String, FeaturedInterpreter>();
+
+  static {
+    try {
+      FeaturedInterpreter interpreters[] =
+          {
+            new FeaturedInterpreter("BeanShell 2.0b4", ".bsh",
+                "http://android-scripting.googlecode.com/files/beanshell_for_android_r2.apk"),
+            new FeaturedInterpreter("JRuby", ".rb",
+                "https://github.com/downloads/ruboto/sl4a_jruby_interpreter/JRubyForAndroid_r2dev.apk"),
+            new FeaturedInterpreter("Lua 5.1.4", ".lua",
+                "http://android-scripting.googlecode.com/files/lua_for_android_r1.apk"),
+            new FeaturedInterpreter("Perl 5.10.1", ".pl",
+                "http://android-scripting.googlecode.com/files/perl_for_android_r1.apk"),
+            new FeaturedInterpreter("Python 2.6.2", ".py",
+                "http://python-for-android.googlecode.com/files/PythonForAndroid_r5.apk"),
+            new FeaturedInterpreter("Rhino 1.7R2", ".js",
+                "http://android-scripting.googlecode.com/files/rhino_for_android_r2.apk"),
+            new FeaturedInterpreter("PHP 5.3.3", ".php",
+                "http://php-for-android.googlecode.com/files/phpforandroid_r1.apk") };
+      for (FeaturedInterpreter interpreter : interpreters) {
+        mNameMap.put(interpreter.mmName, interpreter);
+        mExtensionMap.put(interpreter.mmExtension, interpreter);
+      }
+    } catch (MalformedURLException e) {
+      Log.e(e);
+    }
+  }
+
+  public static List<String> getList() {
+    ArrayList<String> list = new ArrayList<String>(mNameMap.keySet());
+    Collections.sort(list);
+    return list;
+  }
+
+  public static URL getUrlForName(String name) {
+    if (!mNameMap.containsKey(name)) {
+      return null;
+    }
+    return mNameMap.get(name).mmUrl;
+  }
+
+  public static String getInterpreterNameForScript(String fileName) {
+    String extension = getExtension(fileName);
+    if (extension == null || !mExtensionMap.containsKey(extension)) {
+      return null;
+    }
+    return mExtensionMap.get(extension).mmName;
+  }
+
+  public static boolean isSupported(String fileName) {
+    String extension = getExtension(fileName);
+    return (extension != null) && (mExtensionMap.containsKey(extension));
+  }
+
+  public static int getInterpreterIcon(Context context, String key) {
+    String packageName = context.getPackageName();
+    String name = "_icon";
+    if (key.contains(".")) {
+      name = key.substring(key.lastIndexOf('.') + 1) + name;
+    } else {
+      name = key + name;
+    }
+    return context.getResources().getIdentifier(name, "drawable", packageName);
+  }
+
+  private static String getExtension(String fileName) {
+    int dotIndex = fileName.lastIndexOf('.');
+    if (dotIndex == -1) {
+      return null;
+    }
+    return fileName.substring(dotIndex);
+  }
+
+  private static class FeaturedInterpreter {
+    private final String mmName;
+    private final String mmExtension;
+    private final URL mmUrl;
+
+    private FeaturedInterpreter(String name, String extension, String url)
+        throws MalformedURLException {
+      mmName = name;
+      mmExtension = extension;
+      mmUrl = new URL(url);
+    }
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/FutureActivityTaskExecutor.java b/Common/src/com/googlecode/android_scripting/FutureActivityTaskExecutor.java
new file mode 100644
index 0000000..374d122
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/FutureActivityTaskExecutor.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.Context;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.activity.FutureActivity;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class FutureActivityTaskExecutor {
+
+  private final Context mContext;
+  private final Map<Integer, FutureActivityTask<?>> mTaskMap =
+      new ConcurrentHashMap<Integer, FutureActivityTask<?>>();
+  private final AtomicInteger mIdGenerator = new AtomicInteger(0);
+
+  public FutureActivityTaskExecutor(Context context) {
+    mContext = context;
+  }
+
+  public void execute(FutureActivityTask<?> task) {
+    int id = mIdGenerator.incrementAndGet();
+    mTaskMap.put(id, task);
+    launchHelper(id);
+  }
+
+  public FutureActivityTask<?> getTask(int id) {
+    return mTaskMap.remove(id);
+  }
+
+  private void launchHelper(int id) {
+    Intent helper = new Intent(mContext, FutureActivity.class);
+    helper.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
+    helper.putExtra(Constants.EXTRA_TASK_ID, id);
+    mContext.startActivity(helper);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/IntentBuilders.java b/Common/src/com/googlecode/android_scripting/IntentBuilders.java
new file mode 100644
index 0000000..9941c4e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/IntentBuilders.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.PendingIntent;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Parcelable;
+
+import com.googlecode.android_scripting.interpreter.Interpreter;
+
+import java.io.File;
+
+public class IntentBuilders {
+  /** An arbitrary value that is used to identify pending intents for executing scripts. */
+  private static final int EXECUTE_SCRIPT_REQUEST_CODE = 0x12f412a;
+
+  private IntentBuilders() {
+    // Utility class.
+  }
+
+  public static Intent buildTriggerServiceIntent() {
+    Intent intent = new Intent();
+    intent.setComponent(Constants.TRIGGER_SERVICE_COMPONENT_NAME);
+    return intent;
+  }
+
+  /**
+   * Builds an intent that will launch a script in the background.
+   *
+   * @param script
+   *          the script to launch
+   * @return the intent that will launch the script
+   */
+  public static Intent buildStartInBackgroundIntent(File script) {
+    final ComponentName componentName = Constants.SL4A_SERVICE_LAUNCHER_COMPONENT_NAME;
+    Intent intent = new Intent();
+    intent.setComponent(componentName);
+    intent.setAction(Constants.ACTION_LAUNCH_BACKGROUND_SCRIPT);
+    intent.putExtra(Constants.EXTRA_SCRIPT_PATH, script.getAbsolutePath());
+    return intent;
+  }
+
+  /**
+   * Builds an intent that launches a script in a terminal.
+   *
+   * @param script
+   *          the script to launch
+   * @return the intent that will launch the script
+   */
+  public static Intent buildStartInTerminalIntent(File script) {
+    final ComponentName componentName = Constants.SL4A_SERVICE_LAUNCHER_COMPONENT_NAME;
+    Intent intent = new Intent();
+    intent.setComponent(componentName);
+    intent.setAction(Constants.ACTION_LAUNCH_FOREGROUND_SCRIPT);
+    intent.putExtra(Constants.EXTRA_SCRIPT_PATH, script.getAbsolutePath());
+    return intent;
+  }
+
+  /**
+   * Builds an intent that launches an interpreter.
+   *
+   * @param interpreterName
+   *          the interpreter to launch
+   * @return the intent that will launch the interpreter
+   */
+  public static Intent buildStartInterpreterIntent(String interpreterName) {
+    final ComponentName componentName = Constants.SL4A_SERVICE_LAUNCHER_COMPONENT_NAME;
+    Intent intent = new Intent();
+    intent.setComponent(componentName);
+    intent.setAction(Constants.ACTION_LAUNCH_INTERPRETER);
+    intent.putExtra(Constants.EXTRA_INTERPRETER_NAME, interpreterName);
+    return intent;
+  }
+
+  /**
+   * Builds an intent that creates a shortcut to launch the provided interpreter.
+   *
+   * @param interpreter
+   *          the interpreter to link to
+   * @param iconResource
+   *          the icon resource to associate with the shortcut
+   * @return the intent that will create the shortcut
+   */
+  public static Intent buildInterpreterShortcutIntent(Interpreter interpreter,
+      Parcelable iconResource) {
+    Intent intent = new Intent();
+    intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT,
+        buildStartInterpreterIntent(interpreter.getName()));
+    intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, interpreter.getNiceName());
+    intent.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, iconResource);
+    return intent;
+  }
+
+  /**
+   * Builds an intent that creates a shortcut to launch the provided script in the background.
+   *
+   * @param script
+   *          the script to link to
+   * @param iconResource
+   *          the icon resource to associate with the shortcut
+   * @return the intent that will create the shortcut
+   */
+  public static Intent buildBackgroundShortcutIntent(File script, Parcelable iconResource) {
+    Intent intent = new Intent();
+    intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, buildStartInBackgroundIntent(script));
+    intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, script.getName());
+    intent.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, iconResource);
+    return intent;
+  }
+
+  /**
+   * Builds an intent that creates a shortcut to launch the provided script in a terminal.
+   *
+   * @param script
+   *          the script to link to
+   * @param iconResource
+   *          the icon resource to associate with the shortcut
+   * @return the intent that will create the shortcut
+   */
+  public static Intent buildTerminalShortcutIntent(File script, Parcelable iconResource) {
+    Intent intent = new Intent();
+    intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, buildStartInTerminalIntent(script));
+    intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, script.getName());
+    intent.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, iconResource);
+    return intent;
+  }
+
+  /**
+   * Creates a pending intent that can be used to start the trigger service.
+   *
+   * @param context
+   *          the context under whose authority to launch the intent
+   *
+   * @return {@link PendingIntent} object for running the trigger service
+   */
+  public static PendingIntent buildTriggerServicePendingIntent(Context context) {
+    final Intent intent = buildTriggerServiceIntent();
+    return PendingIntent.getService(context, EXECUTE_SCRIPT_REQUEST_CODE, intent,
+        PendingIntent.FLAG_UPDATE_CURRENT);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/Process.java b/Common/src/com/googlecode/android_scripting/Process.java
new file mode 100644
index 0000000..25a80be
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/Process.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+import com.trilead.ssh2.StreamGobbler;
+
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Process {
+
+  private static final int DEFAULT_BUFFER_SIZE = 8192;
+
+  private final List<String> mArguments;
+  private final Map<String, String> mEnvironment;
+
+  private static final int PID_INIT_VALUE = -1;
+
+  private File mBinary;
+  private String mName;
+  private long mStartTime;
+  private long mEndTime;
+
+  protected final AtomicInteger mPid;
+  protected FileDescriptor mFd;
+  protected OutputStream mOut;
+  protected InputStream mIn;
+  protected File mLog;
+
+  public Process() {
+    mArguments = new ArrayList<String>();
+    mEnvironment = new HashMap<String, String>();
+    mPid = new AtomicInteger(PID_INIT_VALUE);
+  }
+
+  public void addArgument(String argument) {
+    mArguments.add(argument);
+  }
+
+  public void addAllArguments(List<String> arguments) {
+    mArguments.addAll(arguments);
+  }
+
+  public void putAllEnvironmentVariables(Map<String, String> environment) {
+    mEnvironment.putAll(environment);
+  }
+
+  public void putEnvironmentVariable(String key, String value) {
+    mEnvironment.put(key, value);
+  }
+
+  public void setBinary(File binary) {
+    if (!binary.exists()) {
+      throw new RuntimeException("Binary " + binary + " does not exist!");
+    }
+    mBinary = binary;
+  }
+
+  public Integer getPid() {
+    return mPid.get();
+  }
+
+  public FileDescriptor getFd() {
+    return mFd;
+  }
+
+  public OutputStream getOut() {
+    return mOut;
+  }
+
+  public OutputStream getErr() {
+    return getOut();
+  }
+
+  public File getLogFile() {
+    return mLog;
+  }
+
+  public InputStream getIn() {
+    return mIn;
+  }
+
+  public void start(final Runnable shutdownHook) {
+    if (isAlive()) {
+      throw new RuntimeException("Attempted to start process that is already running.");
+    }
+
+    String binaryPath = mBinary.getAbsolutePath();
+    Log.v("Executing " + binaryPath + " with arguments " + mArguments + " and with environment "
+        + mEnvironment.toString());
+
+    int[] pid = new int[1];
+    String[] argumentsArray = mArguments.toArray(new String[mArguments.size()]);
+    mLog = new File(String.format("%s/%s.log", InterpreterConstants.SDCARD_SL4A_ROOT, getName()));
+
+    mFd =
+        Exec.createSubprocess(binaryPath, argumentsArray, getEnvironmentArray(),
+            getWorkingDirectory(), pid);
+    mPid.set(pid[0]);
+    mOut = new FileOutputStream(mFd);
+    mIn = new StreamGobbler(new FileInputStream(mFd), mLog, DEFAULT_BUFFER_SIZE);
+    mStartTime = System.currentTimeMillis();
+
+    new Thread(new Runnable() {
+      public void run() {
+        int result = Exec.waitFor(mPid.get());
+        mEndTime = System.currentTimeMillis();
+        int pid = mPid.getAndSet(PID_INIT_VALUE);
+        Log.v("Process " + pid + " exited with result code " + result + ".");
+        try {
+          mIn.close();
+        } catch (IOException e) {
+          Log.e(e);
+        }
+        try {
+          mOut.close();
+        } catch (IOException e) {
+          Log.e(e);
+        }
+        if (shutdownHook != null) {
+          shutdownHook.run();
+        }
+      }
+    }).start();
+  }
+
+  private String[] getEnvironmentArray() {
+    List<String> environmentVariables = new ArrayList<String>();
+    for (Entry<String, String> entry : mEnvironment.entrySet()) {
+      environmentVariables.add(entry.getKey() + "=" + entry.getValue());
+    }
+    String[] environment = environmentVariables.toArray(new String[environmentVariables.size()]);
+    return environment;
+  }
+
+  public void kill() {
+    if (isAlive()) {
+      android.os.Process.killProcess(mPid.get());
+      Log.v("Killed process " + mPid);
+    }
+  }
+
+  public boolean isAlive() {
+    return (mFd != null && mFd.valid()) && mPid.get() != PID_INIT_VALUE;
+  }
+
+  public String getUptime() {
+    long ms;
+    if (!isAlive()) {
+      ms = mEndTime - mStartTime;
+    } else {
+      ms = System.currentTimeMillis() - mStartTime;
+    }
+    StringBuilder buffer = new StringBuilder();
+    int days = (int) (ms / (1000 * 60 * 60 * 24));
+    int hours = (int) (ms % (1000 * 60 * 60 * 24)) / 3600000;
+    int minutes = (int) (ms % 3600000) / 60000;
+    int seconds = (int) (ms % 60000) / 1000;
+    if (days != 0) {
+      buffer.append(String.format("%02d:%02d:", days, hours));
+    } else if (hours != 0) {
+      buffer.append(String.format("%02d:", hours));
+    }
+    buffer.append(String.format("%02d:%02d", minutes, seconds));
+    return buffer.toString();
+  }
+
+  public String getName() {
+    return mName;
+  }
+
+  public void setName(String name) {
+    mName = name;
+  }
+
+  public String getWorkingDirectory() {
+    return null;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/Version.java b/Common/src/com/googlecode/android_scripting/Version.java
new file mode 100644
index 0000000..4ef9fff
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/Version.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+
+public class Version {
+
+  private Version() {
+    // Utility class.
+  }
+
+  public static String getVersion(Context context) {
+    try {
+      PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+      return info.versionName;
+    } catch (PackageManager.NameNotFoundException e) {
+      Log.e("Package name not found", e);
+    }
+    return "?";
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/activity/FutureActivity.java b/Common/src/com/googlecode/android_scripting/activity/FutureActivity.java
new file mode 100644
index 0000000..20e1bf9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/activity/FutureActivity.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Activity;
+import android.app.Service;
+import android.content.Intent;
+import android.content.pm.ResolveInfo;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.View;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.FutureActivityTaskExecutor;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+
+/**
+ * This {@link Activity} is launched by {@link RpcReceiver}s in order to perform operations that a
+ * {@link Service} is unable to do. For example: start another activity for result, show dialogs,
+ * etc.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class FutureActivity extends Activity {
+  private FutureActivityTask<?> mTask;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    Log.v("FutureActivity created.");
+    int id = getIntent().getIntExtra(Constants.EXTRA_TASK_ID, 0);
+    if (id == 0) {
+      throw new RuntimeException("FutureActivityTask ID is not specified.");
+    }
+    FutureActivityTaskExecutor taskQueue = ((BaseApplication) getApplication()).getTaskExecutor();
+    mTask = taskQueue.getTask(id);
+    if (mTask == null) { // TODO: (Robbie) This is now less of a kludge. Would still like to know
+                         // what is happening.
+      Log.w("FutureActivity has no task!");
+      try {
+        Intent intent = new Intent(Intent.ACTION_MAIN); // Should default to main of current app.
+        intent.addCategory(Intent.CATEGORY_LAUNCHER);
+        String packageName = getPackageName();
+        for (ResolveInfo resolve : getPackageManager().queryIntentActivities(intent, 0)) {
+          if (resolve.activityInfo.packageName.equals(packageName)) {
+            intent.setClassName(packageName, resolve.activityInfo.name);
+            break;
+          }
+        }
+        startActivity(intent);
+      } catch (Exception e) {
+        Log.e("Can't find main activity.");
+      }
+    } else {
+      mTask.setActivity(this);
+      mTask.onCreate();
+    }
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    if (mTask != null) {
+      mTask.onStart();
+    }
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    if (mTask != null) {
+      mTask.onResume();
+    }
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    if (mTask != null) {
+      mTask.onPause();
+    }
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    if (mTask != null) {
+      mTask.onStop();
+    }
+  }
+
+  @Override
+  protected void onDestroy() {
+    super.onDestroy();
+    if (mTask != null) {
+      mTask.onDestroy();
+    }
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    if (mTask != null) {
+      mTask.onCreateContextMenu(menu, v, menuInfo);
+    }
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    super.onPrepareOptionsMenu(menu);
+    if (mTask == null) {
+      return false;
+    } else {
+      return mTask.onPrepareOptionsMenu(menu);
+    }
+  }
+
+  @Override
+  public void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (mTask != null) {
+      mTask.onActivityResult(requestCode, resultCode, data);
+    }
+  }
+
+  @Override
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    if (mTask != null) {
+      return mTask.onKeyDown(keyCode, event);
+    }
+    return false;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/event/Event.java b/Common/src/com/googlecode/android_scripting/event/Event.java
new file mode 100644
index 0000000..3c0baf4
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/event/Event.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.event;
+
+import com.google.common.base.Preconditions;
+
+public class Event {
+
+  private String mName;
+  private Object mData;
+  private double mCreationTime;
+
+  public Event(String name, Object data) {
+    Preconditions.checkNotNull(name);
+    setName(name);
+    setData(data);
+    mCreationTime = System.currentTimeMillis();
+  }
+
+  public void setName(String name) {
+    mName = name;
+  }
+
+  public String getName() {
+    return mName;
+  }
+
+  public void setData(Object data) {
+    mData = data;
+  }
+
+  public Object getData() {
+    return mData;
+  }
+
+  public double getCreationTime() {
+    return mCreationTime;
+  }
+
+  public boolean nameEquals(String name) {
+    return mName.equals(name);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/event/EventObserver.java b/Common/src/com/googlecode/android_scripting/event/EventObserver.java
new file mode 100644
index 0000000..6f4066e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/event/EventObserver.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.event;
+
+
+public interface EventObserver {
+        public void onEventReceived(Event event);
+}
diff --git a/Common/src/com/googlecode/android_scripting/event/EventServer.java b/Common/src/com/googlecode/android_scripting/event/EventServer.java
new file mode 100644
index 0000000..325c740
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/event/EventServer.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.event;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.SimpleServer;
+import com.googlecode.android_scripting.jsonrpc.JsonBuilder;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.Vector;
+import java.util.concurrent.CountDownLatch;
+
+import org.json.JSONException;
+
+/**
+ * An Event Forwarding server that forwards events from the rpc queue in realtime to listener
+ * clients.
+ *
+ */
+public class EventServer extends SimpleServer implements EventObserver {
+  private static final Vector<Listener> mListeners = new Vector<Listener>();
+  private InetSocketAddress address = null;
+
+  public EventServer() {
+    this(0);
+  }
+
+  public EventServer(int port) {
+    address = startAllInterfaces(port);
+  }
+
+  public InetSocketAddress getAddress() {
+    return address;
+  }
+
+  @Override
+  public void shutdown() {
+    onEventReceived(new Event("sl4a", "{\"shutdown\": \"event-server\"}"));
+    for (Listener listener : mListeners) {
+      mListeners.remove(listener);
+      listener.lock.countDown();
+    }
+    super.shutdown();
+  }
+
+  @Override
+  protected void handleConnection(Socket socket) throws IOException {
+    Log.d("handle event connection.");
+    Listener l = new Listener(socket);
+    Log.v("Adding EventServer listener " + socket.getPort());
+    mListeners.add(l);
+    // we are running in the socket accept thread
+    // wait until the event dispatcher gets us the events
+    // or we die, what ever happens first
+    try {
+      l.lock.await();
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+    try {
+      l.sock.close();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+    Log.v("Ending EventServer listener " + socket.getPort());
+  }
+
+  @Override
+  public void onEventReceived(Event event) {
+    Object result = null;
+    try {
+      result = JsonBuilder.build(event);
+    } catch (JSONException e) {
+      return;
+    }
+
+    Log.v("EventServer dispatching " + result);
+
+    for (Listener listener : mListeners) {
+      if (!listener.out.checkError()) {
+        listener.out.write(result + "\n");
+        listener.out.flush();
+      } else {
+        // let the socket accept thread we're done
+        mListeners.remove(listener);
+        listener.lock.countDown();
+      }
+    }
+  }
+
+  private class Listener {
+    private Socket sock;
+    private PrintWriter out;
+    private CountDownLatch lock = new CountDownLatch(1);
+
+    public Listener(Socket l) throws IOException {
+      sock = l;
+      out = new PrintWriter(l.getOutputStream(), true);
+    }
+  }
+
+  @Override
+  protected void handleRPCConnection(Socket sock, Integer UID, BufferedReader reader, PrintWriter writer)
+      throws Exception {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ActivityResultFacade.java b/Common/src/com/googlecode/android_scripting/facade/ActivityResultFacade.java
new file mode 100644
index 0000000..a90fba4
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ActivityResultFacade.java
@@ -0,0 +1,327 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Activity;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.io.Serializable;
+
+/**
+ * Allows you to return results to a startActivityForResult call.
+ *
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public class ActivityResultFacade extends RpcReceiver {
+
+  private static final String sRpcDescription =
+      "Sets the result of a script execution. Whenever the script APK is called via "
+          + "startActivityForResult(), the resulting intent will contain " + Constants.EXTRA_RESULT
+          + " extra with the given value.";
+  private static final String sCodeDescription =
+      "The result code to propagate back to the originating activity, often RESULT_CANCELED (0) "
+          + "or RESULT_OK (-1)";
+
+  private Activity mActivity = null;
+  private Intent mResult = null;
+  private int mResultCode;
+
+  public ActivityResultFacade(FacadeManager manager) {
+    super(manager);
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultBoolean(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Boolean resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.booleanValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultByte(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Byte resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.byteValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultShort(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Short resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.shortValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultChar(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Character resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.charValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultInteger(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Integer resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.intValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultLong(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Long resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.longValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultFloat(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Float resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.floatValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultDouble(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Double resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue.doubleValue());
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultString(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") String resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultBooleanArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Boolean[] resultValue) {
+    mResult = new Intent();
+    boolean[] array = new boolean[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultByteArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Byte[] resultValue) {
+    mResult = new Intent();
+    byte[] array = new byte[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultShortArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Short[] resultValue) {
+    mResult = new Intent();
+    short[] array = new short[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultCharArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Character[] resultValue) {
+    mResult = new Intent();
+    char[] array = new char[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultIntegerArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Integer[] resultValue) {
+    mResult = new Intent();
+    int[] array = new int[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultLongArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Long[] resultValue) {
+    mResult = new Intent();
+    long[] array = new long[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultFloatArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Float[] resultValue) {
+    mResult = new Intent();
+    float[] array = new float[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultDoubleArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Double[] resultValue) {
+    mResult = new Intent();
+    double[] array = new double[resultValue.length];
+    for (int i = 0; i < resultValue.length; i++) {
+      array[i] = resultValue[i];
+    }
+    mResult.putExtra(Constants.EXTRA_RESULT, array);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultStringArray(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") String[] resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  @Rpc(description = sRpcDescription)
+  public synchronized void setResultSerializable(
+      @RpcParameter(name = "resultCode", description = sCodeDescription) Integer resultCode,
+      @RpcParameter(name = "resultValue") Serializable resultValue) {
+    mResult = new Intent();
+    mResult.putExtra(Constants.EXTRA_RESULT, resultValue);
+    mResultCode = resultCode;
+    if (mActivity != null) {
+      setResult();
+    }
+  }
+
+  public synchronized void setActivity(Activity activity) {
+    mActivity = activity;
+    if (mResult != null) {
+      setResult();
+    }
+  }
+
+  private void setResult() {
+    mActivity.setResult(mResultCode, mResult);
+    mActivity.finish();
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/AndroidFacade.java b/Common/src/com/googlecode/android_scripting/facade/AndroidFacade.java
new file mode 100644
index 0000000..1de3055
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/AndroidFacade.java
@@ -0,0 +1,1037 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.ClipData;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.StatFs;
+import android.os.Vibrator;
+import android.content.ClipboardManager;
+import android.text.InputType;
+import android.text.method.PasswordTransformationMethod;
+import android.widget.EditText;
+import android.widget.Toast;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.FileUtils;
+import com.googlecode.android_scripting.FutureActivityTaskExecutor;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.NotificationIdFactory;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcDeprecated;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+import java.util.concurrent.TimeUnit;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Some general purpose Android routines.<br>
+ * <h2>Intents</h2> Intents are returned as a map, in the following form:<br>
+ * <ul>
+ * <li><b>action</b> - action.
+ * <li><b>data</b> - url
+ * <li><b>type</b> - mime type
+ * <li><b>packagename</b> - name of package. If used, requires classname to be useful (optional)
+ * <li><b>classname</b> - name of class. If used, requires packagename to be useful (optional)
+ * <li><b>categories</b> - list of categories
+ * <li><b>extras</b> - map of extras
+ * <li><b>flags</b> - integer flags.
+ * </ul>
+ * <br>
+ * An intent can be built using the {@see #makeIntent} call, but can also be constructed exterally.
+ *
+ */
+public class AndroidFacade extends RpcReceiver {
+  /**
+   * An instance of this interface is passed to the facade. From this object, the resource IDs can
+   * be obtained.
+   */
+
+  public interface Resources {
+    int getLogo48();
+  }
+
+  private final Service mService;
+  private final Handler mHandler;
+  private final Intent mIntent;
+  private final FutureActivityTaskExecutor mTaskQueue;
+
+  private final Vibrator mVibrator;
+  private final NotificationManager mNotificationManager;
+
+  private final Resources mResources;
+  private ClipboardManager mClipboard = null;
+
+  @Override
+  public void shutdown() {
+  }
+
+  public AndroidFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mIntent = manager.getIntent();
+    BaseApplication application = ((BaseApplication) mService.getApplication());
+    mTaskQueue = application.getTaskExecutor();
+    mHandler = new Handler(mService.getMainLooper());
+    mVibrator = (Vibrator) mService.getSystemService(Context.VIBRATOR_SERVICE);
+    mNotificationManager =
+        (NotificationManager) mService.getSystemService(Context.NOTIFICATION_SERVICE);
+    mResources = manager.getAndroidFacadeResources();
+  }
+
+  ClipboardManager getClipboardManager() {
+    Object clipboard = null;
+    if (mClipboard == null) {
+      try {
+        clipboard = mService.getSystemService(Context.CLIPBOARD_SERVICE);
+      } catch (Exception e) {
+        Looper.prepare(); // Clipboard manager won't work without this on higher SDK levels...
+        clipboard = mService.getSystemService(Context.CLIPBOARD_SERVICE);
+      }
+      mClipboard = (ClipboardManager) clipboard;
+      if (mClipboard == null) {
+        Log.w("Clipboard managed not accessible.");
+      }
+    }
+    return mClipboard;
+  }
+
+  public Intent startActivityForResult(final Intent intent) {
+    FutureActivityTask<Intent> task = new FutureActivityTask<Intent>() {
+      @Override
+      public void onCreate() {
+        super.onCreate();
+        try {
+          startActivityForResult(intent, 0);
+        } catch (Exception e) {
+          intent.putExtra("EXCEPTION", e.getMessage());
+          setResult(intent);
+        }
+      }
+
+      @Override
+      public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        setResult(data);
+      }
+    };
+    mTaskQueue.execute(task);
+
+    try {
+      return task.getResult();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    } finally {
+      task.finish();
+    }
+  }
+
+  public int startActivityForResultCodeWithTimeout(final Intent intent,
+    final int request, final int timeout) {
+    FutureActivityTask<Integer> task = new FutureActivityTask<Integer>() {
+      @Override
+      public void onCreate() {
+        super.onCreate();
+        try {
+          startActivityForResult(intent, request);
+        } catch (Exception e) {
+          intent.putExtra("EXCEPTION", e.getMessage());
+        }
+      }
+
+      @Override
+      public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (request == requestCode){
+            setResult(resultCode);
+        }
+      }
+    };
+    mTaskQueue.execute(task);
+
+    try {
+      return task.getResult(timeout, TimeUnit.SECONDS);
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    } finally {
+      task.finish();
+    }
+  }
+
+  // TODO(damonkohler): Pull this out into proper argument deserialization and support
+  // complex/nested types being passed in.
+  public static void putExtrasFromJsonObject(JSONObject extras,
+                                             Intent intent) throws JSONException {
+    JSONArray names = extras.names();
+    for (int i = 0; i < names.length(); i++) {
+      String name = names.getString(i);
+      Object data = extras.get(name);
+      if (data == null) {
+        continue;
+      }
+      if (data instanceof Integer) {
+        intent.putExtra(name, (Integer) data);
+      }
+      if (data instanceof Float) {
+        intent.putExtra(name, (Float) data);
+      }
+      if (data instanceof Double) {
+        intent.putExtra(name, (Double) data);
+      }
+      if (data instanceof Long) {
+        intent.putExtra(name, (Long) data);
+      }
+      if (data instanceof String) {
+        intent.putExtra(name, (String) data);
+      }
+      if (data instanceof Boolean) {
+        intent.putExtra(name, (Boolean) data);
+      }
+      // Nested JSONObject
+      if (data instanceof JSONObject) {
+        Bundle nestedBundle = new Bundle();
+        intent.putExtra(name, nestedBundle);
+        putNestedJSONObject((JSONObject) data, nestedBundle);
+      }
+      // Nested JSONArray. Doesn't support mixed types in single array
+      if (data instanceof JSONArray) {
+        // Empty array. No way to tell what type of data to pass on, so skipping
+        if (((JSONArray) data).length() == 0) {
+          Log.e("Empty array not supported in JSONObject, skipping");
+          continue;
+        }
+        // Integer
+        if (((JSONArray) data).get(0) instanceof Integer) {
+          Integer[] integerArrayData = new Integer[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            integerArrayData[j] = ((JSONArray) data).getInt(j);
+          }
+          intent.putExtra(name, integerArrayData);
+        }
+        // Double
+        if (((JSONArray) data).get(0) instanceof Double) {
+          Double[] doubleArrayData = new Double[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            doubleArrayData[j] = ((JSONArray) data).getDouble(j);
+          }
+          intent.putExtra(name, doubleArrayData);
+        }
+        // Long
+        if (((JSONArray) data).get(0) instanceof Long) {
+          Long[] longArrayData = new Long[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            longArrayData[j] = ((JSONArray) data).getLong(j);
+          }
+          intent.putExtra(name, longArrayData);
+        }
+        // String
+        if (((JSONArray) data).get(0) instanceof String) {
+          String[] stringArrayData = new String[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            stringArrayData[j] = ((JSONArray) data).getString(j);
+          }
+          intent.putExtra(name, stringArrayData);
+        }
+        // Boolean
+        if (((JSONArray) data).get(0) instanceof Boolean) {
+          Boolean[] booleanArrayData = new Boolean[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            booleanArrayData[j] = ((JSONArray) data).getBoolean(j);
+          }
+          intent.putExtra(name, booleanArrayData);
+        }
+      }
+    }
+  }
+
+  // Contributed by Emmanuel T
+  // Nested Array handling contributed by Sergey Zelenev
+  private static void putNestedJSONObject(JSONObject jsonObject, Bundle bundle)
+      throws JSONException {
+    JSONArray names = jsonObject.names();
+    for (int i = 0; i < names.length(); i++) {
+      String name = names.getString(i);
+      Object data = jsonObject.get(name);
+      if (data == null) {
+        continue;
+      }
+      if (data instanceof Integer) {
+        bundle.putInt(name, ((Integer) data).intValue());
+      }
+      if (data instanceof Float) {
+        bundle.putFloat(name, ((Float) data).floatValue());
+      }
+      if (data instanceof Double) {
+        bundle.putDouble(name, ((Double) data).doubleValue());
+      }
+      if (data instanceof Long) {
+        bundle.putLong(name, ((Long) data).longValue());
+      }
+      if (data instanceof String) {
+        bundle.putString(name, (String) data);
+      }
+      if (data instanceof Boolean) {
+        bundle.putBoolean(name, ((Boolean) data).booleanValue());
+      }
+      // Nested JSONObject
+      if (data instanceof JSONObject) {
+        Bundle nestedBundle = new Bundle();
+        bundle.putBundle(name, nestedBundle);
+        putNestedJSONObject((JSONObject) data, nestedBundle);
+      }
+      // Nested JSONArray. Doesn't support mixed types in single array
+      if (data instanceof JSONArray) {
+        // Empty array. No way to tell what type of data to pass on, so skipping
+        if (((JSONArray) data).length() == 0) {
+          Log.e("Empty array not supported in nested JSONObject, skipping");
+          continue;
+        }
+        // Integer
+        if (((JSONArray) data).get(0) instanceof Integer) {
+          int[] integerArrayData = new int[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            integerArrayData[j] = ((JSONArray) data).getInt(j);
+          }
+          bundle.putIntArray(name, integerArrayData);
+        }
+        // Double
+        if (((JSONArray) data).get(0) instanceof Double) {
+          double[] doubleArrayData = new double[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            doubleArrayData[j] = ((JSONArray) data).getDouble(j);
+          }
+          bundle.putDoubleArray(name, doubleArrayData);
+        }
+        // Long
+        if (((JSONArray) data).get(0) instanceof Long) {
+          long[] longArrayData = new long[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            longArrayData[j] = ((JSONArray) data).getLong(j);
+          }
+          bundle.putLongArray(name, longArrayData);
+        }
+        // String
+        if (((JSONArray) data).get(0) instanceof String) {
+          String[] stringArrayData = new String[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            stringArrayData[j] = ((JSONArray) data).getString(j);
+          }
+          bundle.putStringArray(name, stringArrayData);
+        }
+        // Boolean
+        if (((JSONArray) data).get(0) instanceof Boolean) {
+          boolean[] booleanArrayData = new boolean[((JSONArray) data).length()];
+          for (int j = 0; j < ((JSONArray) data).length(); ++j) {
+            booleanArrayData[j] = ((JSONArray) data).getBoolean(j);
+          }
+          bundle.putBooleanArray(name, booleanArrayData);
+        }
+      }
+    }
+  }
+
+  void startActivity(final Intent intent) {
+    try {
+      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+      mService.startActivity(intent);
+    } catch (Exception e) {
+      Log.e("Failed to launch intent.", e);
+    }
+  }
+
+  private Intent buildIntent(String action, String uri, String type, JSONObject extras,
+      String packagename, String classname, JSONArray categories) throws JSONException {
+    Intent intent = new Intent();
+    if (action != null) {
+      intent.setAction(action);
+    }
+    intent.setDataAndType(uri != null ? Uri.parse(uri) : null, type);
+    if (packagename != null && classname != null) {
+      intent.setComponent(new ComponentName(packagename, classname));
+    }
+    if (extras != null) {
+      putExtrasFromJsonObject(extras, intent);
+    }
+    if (categories != null) {
+      for (int i = 0; i < categories.length(); i++) {
+        intent.addCategory(categories.getString(i));
+      }
+    }
+    return intent;
+  }
+
+  // TODO(damonkohler): It's unnecessary to add the complication of choosing between startActivity
+  // and startActivityForResult. It's probably better to just always use the ForResult version.
+  // However, this makes the call always blocking. We'd need to add an extra boolean parameter to
+  // indicate if we should wait for a result.
+  @Rpc(description = "Starts an activity and returns the result.",
+       returns = "A Map representation of the result Intent.")
+  public Intent startActivityForResult(
+      @RpcParameter(name = "action")
+      String action,
+      @RpcParameter(name = "uri")
+      @RpcOptional String uri,
+      @RpcParameter(name = "type", description = "MIME type/subtype of the URI")
+      @RpcOptional String type,
+      @RpcParameter(name = "extras", description = "a Map of extras to add to the Intent")
+      @RpcOptional JSONObject extras,
+      @RpcParameter(name = "packagename",
+                    description = "name of package. If used, requires classname to be useful")
+      @RpcOptional String packagename,
+      @RpcParameter(name = "classname",
+                    description = "name of class. If used, requires packagename to be useful")
+      @RpcOptional String classname
+      ) throws JSONException {
+    final Intent intent = buildIntent(action, uri, type, extras, packagename, classname, null);
+    return startActivityForResult(intent);
+  }
+
+  @Rpc(description = "Starts an activity and returns the result.",
+       returns = "A Map representation of the result Intent.")
+  public Intent startActivityForResultIntent(
+      @RpcParameter(name = "intent",
+                    description = "Intent in the format as returned from makeIntent")
+      Intent intent) {
+    return startActivityForResult(intent);
+  }
+
+  private void doStartActivity(final Intent intent, Boolean wait) throws Exception {
+    if (wait == null || wait == false) {
+      startActivity(intent);
+    } else {
+      FutureActivityTask<Intent> task = new FutureActivityTask<Intent>() {
+        private boolean mSecondResume = false;
+
+        @Override
+        public void onCreate() {
+          super.onCreate();
+          startActivity(intent);
+        }
+
+        @Override
+        public void onResume() {
+          if (mSecondResume) {
+            finish();
+          }
+          mSecondResume = true;
+        }
+
+        @Override
+        public void onDestroy() {
+          setResult(null);
+        }
+
+      };
+      mTaskQueue.execute(task);
+
+      try {
+        task.getResult();
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  /**
+   * Creates a new AndroidFacade that simplifies the interface to various Android APIs.
+   *
+   * @param service
+   *          is the {@link Context} the APIs will run under
+   */
+
+  @Rpc(description = "Put a text string in the clipboard.")
+  public void setTextClip(@RpcParameter(name = "text")
+                          String text,
+                          @RpcParameter(name = "label")
+                          @RpcOptional @RpcDefault(value = "copiedText")
+                          String label) {
+    getClipboardManager().setPrimaryClip(ClipData.newPlainText(label, text));
+  }
+
+  @Rpc(description = "Get the device serial number.")
+  public String getBuildSerial() {
+      return Build.SERIAL;
+  }
+
+  @Rpc(description = "Get the name of system bootloader version number.")
+  public String getBuildBootloader() {
+    return android.os.Build.BOOTLOADER;
+  }
+
+  @Rpc(description = "Get the name of the industrial design.")
+  public String getBuildIndustrialDesignName() {
+    return Build.DEVICE;
+  }
+
+  @Rpc(description = "Get the build ID string meant for displaying to the user")
+  public String getBuildDisplay() {
+    return Build.DISPLAY;
+  }
+
+  @Rpc(description = "Get the string that uniquely identifies this build.")
+  public String getBuildFingerprint() {
+    return Build.FINGERPRINT;
+  }
+
+  @Rpc(description = "Get the name of the hardware (from the kernel command "
+      + "line or /proc)..")
+  public String getBuildHardware() {
+    return Build.HARDWARE;
+  }
+
+  @Rpc(description = "Get the device host.")
+  public String getBuildHost() {
+    return Build.HOST;
+  }
+
+  @Rpc(description = "Get Either a changelist number, or a label like."
+      + " \"M4-rc20\".")
+  public String getBuildID() {
+    return android.os.Build.ID;
+  }
+
+  @Rpc(description = "Returns true if we are running a debug build such"
+      + " as \"user-debug\" or \"eng\".")
+  public boolean getBuildIsDebuggable() {
+    return Build.IS_DEBUGGABLE;
+  }
+
+  @Rpc(description = "Get the name of the overall product.")
+  public String getBuildProduct() {
+    return android.os.Build.PRODUCT;
+  }
+
+  @Rpc(description = "Get an ordered list of 32 bit ABIs supported by this "
+      + "device. The most preferred ABI is the first element in the list")
+  public String[] getBuildSupported32BitAbis() {
+    return Build.SUPPORTED_32_BIT_ABIS;
+  }
+
+  @Rpc(description = "Get an ordered list of 64 bit ABIs supported by this "
+      + "device. The most preferred ABI is the first element in the list")
+  public String[] getBuildSupported64BitAbis() {
+    return Build.SUPPORTED_64_BIT_ABIS;
+  }
+
+  @Rpc(description = "Get an ordered list of ABIs supported by this "
+      + "device. The most preferred ABI is the first element in the list")
+  public String[] getBuildSupportedBitAbis() {
+    return Build.SUPPORTED_ABIS;
+  }
+
+  @Rpc(description = "Get comma-separated tags describing the build,"
+      + " like \"unsigned,debug\".")
+  public String getBuildTags() {
+    return Build.TAGS;
+  }
+
+  @Rpc(description = "Get The type of build, like \"user\" or \"eng\".")
+  public String getBuildType() {
+    return Build.TYPE;
+  }
+  @Rpc(description = "Returns the board name.")
+  public String getBuildBoard() {
+    return Build.BOARD;
+  }
+
+  @Rpc(description = "Returns the brand name.")
+  public String getBuildBrand() {
+    return Build.BRAND;
+  }
+
+  @Rpc(description = "Returns the manufacturer name.")
+  public String getBuildManufacturer() {
+    return Build.MANUFACTURER;
+  }
+
+  @Rpc(description = "Returns the model name.")
+  public String getBuildModel() {
+    return Build.MODEL;
+  }
+
+  @Rpc(description = "Returns the build number.")
+  public String getBuildNumber() {
+    return Build.FINGERPRINT;
+  }
+
+  @Rpc(description = "Returns the SDK version.")
+  public Integer getBuildSdkVersion() {
+    return Build.VERSION.SDK_INT;
+  }
+
+  @Rpc(description = "Returns the current device time.")
+  public Long getBuildTime() {
+    return Build.TIME;
+  }
+
+  @Rpc(description = "Read all text strings copied by setTextClip from the clipboard.")
+  public List<String> getTextClip() {
+    ClipboardManager cm = getClipboardManager();
+    ArrayList<String> texts = new ArrayList<String>();
+    if(!cm.hasPrimaryClip()) {
+      return texts;
+    }
+    ClipData cd = cm.getPrimaryClip();
+    for(int i=0; i<cd.getItemCount(); i++) {
+      texts.add(cd.getItemAt(i).coerceToText(mService).toString());
+    }
+    return texts;
+  }
+
+  /**
+   * packagename and classname, if provided, are used in a 'setComponent' call.
+   */
+  @Rpc(description = "Starts an activity.")
+  public void startActivity(
+      @RpcParameter(name = "action")
+      String action,
+      @RpcParameter(name = "uri")
+      @RpcOptional String uri,
+      @RpcParameter(name = "type", description = "MIME type/subtype of the URI")
+      @RpcOptional String type,
+      @RpcParameter(name = "extras", description = "a Map of extras to add to the Intent")
+      @RpcOptional JSONObject extras,
+      @RpcParameter(name = "wait", description = "block until the user exits the started activity")
+      @RpcOptional Boolean wait,
+      @RpcParameter(name = "packagename",
+                    description = "name of package. If used, requires classname to be useful")
+      @RpcOptional String packagename,
+      @RpcParameter(name = "classname",
+                    description = "name of class. If used, requires packagename to be useful")
+      @RpcOptional String classname
+      ) throws Exception {
+    final Intent intent = buildIntent(action, uri, type, extras, packagename, classname, null);
+    doStartActivity(intent, wait);
+  }
+
+  @Rpc(description = "Send a broadcast.")
+  public void sendBroadcast(
+      @RpcParameter(name = "action")
+      String action,
+      @RpcParameter(name = "uri")
+      @RpcOptional String uri,
+      @RpcParameter(name = "type", description = "MIME type/subtype of the URI")
+      @RpcOptional String type,
+      @RpcParameter(name = "extras", description = "a Map of extras to add to the Intent")
+      @RpcOptional JSONObject extras,
+      @RpcParameter(name = "packagename",
+                    description = "name of package. If used, requires classname to be useful")
+      @RpcOptional String packagename,
+      @RpcParameter(name = "classname",
+                    description = "name of class. If used, requires packagename to be useful")
+      @RpcOptional String classname
+      ) throws JSONException {
+    final Intent intent = buildIntent(action, uri, type, extras, packagename, classname, null);
+    try {
+      mService.sendBroadcast(intent);
+    } catch (Exception e) {
+      Log.e("Failed to broadcast intent.", e);
+    }
+  }
+
+  @Rpc(description = "Starts a service.")
+  public void startService(
+      @RpcParameter(name = "uri")
+      @RpcOptional String uri,
+      @RpcParameter(name = "extras", description = "a Map of extras to add to the Intent")
+      @RpcOptional JSONObject extras,
+      @RpcParameter(name = "packagename",
+                    description = "name of package. If used, requires classname to be useful")
+      @RpcOptional String packagename,
+      @RpcParameter(name = "classname",
+                    description = "name of class. If used, requires packagename to be useful")
+      @RpcOptional String classname
+      ) throws Exception {
+    final Intent intent = buildIntent(null /* action */, uri, null /* type */, extras, packagename,
+                                      classname, null /* categories */);
+    mService.startService(intent);
+  }
+
+  @Rpc(description = "Create an Intent.", returns = "An object representing an Intent")
+  public Intent makeIntent(
+      @RpcParameter(name = "action")
+      String action,
+      @RpcParameter(name = "uri")
+      @RpcOptional String uri,
+      @RpcParameter(name = "type", description = "MIME type/subtype of the URI")
+      @RpcOptional String type,
+      @RpcParameter(name = "extras", description = "a Map of extras to add to the Intent")
+      @RpcOptional JSONObject extras,
+      @RpcParameter(name = "categories", description = "a List of categories to add to the Intent")
+      @RpcOptional JSONArray categories,
+      @RpcParameter(name = "packagename",
+                    description = "name of package. If used, requires classname to be useful")
+      @RpcOptional String packagename,
+      @RpcParameter(name = "classname",
+                    description = "name of class. If used, requires packagename to be useful")
+      @RpcOptional String classname,
+      @RpcParameter(name = "flags", description = "Intent flags")
+      @RpcOptional Integer flags
+      ) throws JSONException {
+    Intent intent = buildIntent(action, uri, type, extras, packagename, classname, categories);
+    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    if (flags != null) {
+      intent.setFlags(flags);
+    }
+    return intent;
+  }
+
+  @Rpc(description = "Start Activity using Intent")
+  public void startActivityIntent(
+      @RpcParameter(name = "intent",
+                    description = "Intent in the format as returned from makeIntent")
+      Intent intent,
+      @RpcParameter(name = "wait",
+                    description = "block until the user exits the started activity")
+      @RpcOptional Boolean wait
+      ) throws Exception {
+    doStartActivity(intent, wait);
+  }
+
+  @Rpc(description = "Send Broadcast Intent")
+  public void sendBroadcastIntent(
+      @RpcParameter(name = "intent",
+                    description = "Intent in the format as returned from makeIntent")
+      Intent intent
+      ) throws Exception {
+    mService.sendBroadcast(intent);
+  }
+
+  @Rpc(description = "Start Service using Intent")
+  public void startServiceIntent(
+      @RpcParameter(name = "intent",
+                    description = "Intent in the format as returned from makeIntent")
+      Intent intent
+      ) throws Exception {
+    mService.startService(intent);
+  }
+
+  @Rpc(description = "Vibrates the phone or a specified duration in milliseconds.")
+  public void vibrate(
+      @RpcParameter(name = "duration", description = "duration in milliseconds")
+      @RpcDefault("300")
+      Integer duration) {
+    mVibrator.vibrate(duration);
+  }
+
+  @Rpc(description = "Displays a short-duration Toast notification.")
+  public void makeToast(@RpcParameter(name = "message") final String message) {
+    mHandler.post(new Runnable() {
+      public void run() {
+        Toast.makeText(mService, message, Toast.LENGTH_SHORT).show();
+      }
+    });
+  }
+
+  private String getInputFromAlertDialog(final String title, final String message,
+      final boolean password) {
+    final FutureActivityTask<String> task = new FutureActivityTask<String>() {
+      @Override
+      public void onCreate() {
+        super.onCreate();
+        final EditText input = new EditText(getActivity());
+        if (password) {
+          input.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);
+          input.setTransformationMethod(new PasswordTransformationMethod());
+        }
+        AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
+        alert.setTitle(title);
+        alert.setMessage(message);
+        alert.setView(input);
+        alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int whichButton) {
+            dialog.dismiss();
+            setResult(input.getText().toString());
+            finish();
+          }
+        });
+        alert.setOnCancelListener(new DialogInterface.OnCancelListener() {
+          @Override
+          public void onCancel(DialogInterface dialog) {
+            dialog.dismiss();
+            setResult(null);
+            finish();
+          }
+        });
+        alert.show();
+      }
+    };
+    mTaskQueue.execute(task);
+
+    try {
+      return task.getResult();
+    } catch (Exception e) {
+      Log.e("Failed to display dialog.", e);
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Rpc(description = "Queries the user for a text input.")
+  @RpcDeprecated(value = "dialogGetInput", release = "r3")
+  public String getInput(
+      @RpcParameter(name = "title", description = "title of the input box")
+      @RpcDefault("SL4A Input")
+      final String title,
+      @RpcParameter(name = "message", description = "message to display above the input box")
+      @RpcDefault("Please enter value:")
+      final String message) {
+    return getInputFromAlertDialog(title, message, false);
+  }
+
+  @Rpc(description = "Queries the user for a password.")
+  @RpcDeprecated(value = "dialogGetPassword", release = "r3")
+  public String getPassword(
+      @RpcParameter(name = "title", description = "title of the input box")
+      @RpcDefault("SL4A Password Input")
+      final String title,
+      @RpcParameter(name = "message", description = "message to display above the input box")
+      @RpcDefault("Please enter password:")
+      final String message) {
+    return getInputFromAlertDialog(title, message, true);
+  }
+
+  @Rpc(description = "Displays a notification that will be canceled when the user clicks on it.")
+  public void notify(@RpcParameter(name = "title", description = "title") String title,
+      @RpcParameter(name = "message") String message) {
+    // This contentIntent is a noop.
+    PendingIntent contentIntent = PendingIntent.getService(mService, 0, new Intent(), 0);
+    Notification.Builder builder = new Notification.Builder(mService);
+    builder.setSmallIcon(mResources.getLogo48())
+           .setTicker(message)
+           .setWhen(System.currentTimeMillis())
+           .setContentTitle(title)
+           .setContentText(message)
+           .setContentIntent(contentIntent);
+    Notification notification = builder.build();
+    notification.flags = Notification.FLAG_AUTO_CANCEL;
+    // Get a unique notification id from the application.
+    final int notificationId = NotificationIdFactory.create();
+    mNotificationManager.notify(notificationId, notification);
+  }
+
+  @Rpc(description = "Returns the intent that launched the script.")
+  public Object getIntent() {
+    return mIntent;
+  }
+
+  @Rpc(description = "Launches an activity that sends an e-mail message to a given recipient.")
+  public void sendEmail(
+      @RpcParameter(name = "to", description = "A comma separated list of recipients.")
+      final String to,
+      @RpcParameter(name = "subject") final String subject,
+      @RpcParameter(name = "body") final String body,
+      @RpcParameter(name = "attachmentUri")
+      @RpcOptional final String attachmentUri) {
+    final Intent intent = new Intent(android.content.Intent.ACTION_SEND);
+    intent.setType("plain/text");
+    intent.putExtra(android.content.Intent.EXTRA_EMAIL, to.split(","));
+    intent.putExtra(android.content.Intent.EXTRA_SUBJECT, subject);
+    intent.putExtra(android.content.Intent.EXTRA_TEXT, body);
+    if (attachmentUri != null) {
+      intent.putExtra(android.content.Intent.EXTRA_STREAM, Uri.parse(attachmentUri));
+    }
+    startActivity(intent);
+  }
+
+  @Rpc(description = "Returns package version code.")
+  public int getPackageVersionCode(@RpcParameter(name = "packageName") final String packageName) {
+    int result = -1;
+    PackageInfo pInfo = null;
+    try {
+      pInfo =
+          mService.getPackageManager().getPackageInfo(packageName, PackageManager.GET_META_DATA);
+    } catch (NameNotFoundException e) {
+      pInfo = null;
+    }
+    if (pInfo != null) {
+      result = pInfo.versionCode;
+    }
+    return result;
+  }
+
+  @Rpc(description = "Returns package version name.")
+  public String getPackageVersion(@RpcParameter(name = "packageName") final String packageName) {
+    PackageInfo packageInfo = null;
+    try {
+      packageInfo =
+          mService.getPackageManager().getPackageInfo(packageName, PackageManager.GET_META_DATA);
+    } catch (NameNotFoundException e) {
+      return null;
+    }
+    if (packageInfo != null) {
+      return packageInfo.versionName;
+    }
+    return null;
+  }
+
+  @Rpc(description = "Checks if SL4A's version is >= the specified version.")
+  public boolean requiredVersion(
+          @RpcParameter(name = "requiredVersion") final Integer version) {
+    boolean result = false;
+    int packageVersion = getPackageVersionCode(
+            "com.googlecode.android_scripting");
+    if (version > -1) {
+      result = (packageVersion >= version);
+    }
+    return result;
+  }
+
+  @Rpc(description = "Writes message to logcat at verbose level")
+  public void logV(
+          @RpcParameter(name = "message")
+          String message) {
+      android.util.Log.v("SL4A: ", message);
+  }
+
+  @Rpc(description = "Writes message to logcat at info level")
+  public void logI(
+          @RpcParameter(name = "message")
+          String message) {
+      android.util.Log.i("SL4A: ", message);
+  }
+
+  @Rpc(description = "Writes message to logcat at debug level")
+  public void logD(
+          @RpcParameter(name = "message")
+          String message) {
+      android.util.Log.d("SL4A: ", message);
+  }
+
+  @Rpc(description = "Writes message to logcat at warning level")
+  public void logW(
+          @RpcParameter(name = "message")
+          String message) {
+      android.util.Log.w("SL4A: ", message);
+  }
+
+  @Rpc(description = "Writes message to logcat at error level")
+  public void logE(
+          @RpcParameter(name = "message")
+          String message) {
+      android.util.Log.e("SL4A: ", message);
+  }
+
+  @Rpc(description = "Writes message to logcat at wtf level")
+  public void logWTF(
+          @RpcParameter(name = "message")
+          String message) {
+      android.util.Log.wtf("SL4A: ", message);
+  }
+
+  /**
+   *
+   * Map returned:
+   *
+   * <pre>
+   *   TZ = Timezone
+   *     id = Timezone ID
+   *     display = Timezone display name
+   *     offset = Offset from UTC (in ms)
+   *   SDK = SDK Version
+   *   download = default download path
+   *   appcache = Location of application cache
+   *   sdcard = Space on sdcard
+   *     availblocks = Available blocks
+   *     blockcount = Total Blocks
+   *     blocksize = size of block.
+   * </pre>
+   */
+  @Rpc(description = "A map of various useful environment details")
+  public Map<String, Object> environment() {
+    Map<String, Object> result = new HashMap<String, Object>();
+    Map<String, Object> zone = new HashMap<String, Object>();
+    Map<String, Object> space = new HashMap<String, Object>();
+    TimeZone tz = TimeZone.getDefault();
+    zone.put("id", tz.getID());
+    zone.put("display", tz.getDisplayName());
+    zone.put("offset", tz.getOffset((new Date()).getTime()));
+    result.put("TZ", zone);
+    result.put("SDK", android.os.Build.VERSION.SDK_INT);
+    result.put("download", FileUtils.getExternalDownload().getAbsolutePath());
+    result.put("appcache", mService.getCacheDir().getAbsolutePath());
+    try {
+      StatFs fs = new StatFs("/sdcard");
+      space.put("availblocks", fs.getAvailableBlocksLong());
+      space.put("blocksize", fs.getBlockSizeLong());
+      space.put("blockcount", fs.getBlockCountLong());
+    } catch (Exception e) {
+      space.put("exception", e.toString());
+    }
+    result.put("sdcard", space);
+    return result;
+  }
+
+  @Rpc(description = "Get list of constants (static final fields) for a class")
+  public Bundle getConstants(
+      @RpcParameter(name = "classname", description = "Class to get constants from")
+      String classname)
+      throws Exception {
+    Bundle result = new Bundle();
+    int flags = Modifier.FINAL | Modifier.PUBLIC | Modifier.STATIC;
+    Class<?> clazz = Class.forName(classname);
+    for (Field field : clazz.getFields()) {
+      if ((field.getModifiers() & flags) == flags) {
+        Class<?> type = field.getType();
+        String name = field.getName();
+        if (type == int.class) {
+          result.putInt(name, field.getInt(null));
+        } else if (type == long.class) {
+          result.putLong(name, field.getLong(null));
+        } else if (type == double.class) {
+          result.putDouble(name, field.getDouble(null));
+        } else if (type == char.class) {
+          result.putChar(name, field.getChar(null));
+        } else if (type instanceof Object) {
+          result.putString(name, field.get(null).toString());
+        }
+      }
+    }
+    return result;
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ApplicationManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/ApplicationManagerFacade.java
new file mode 100644
index 0000000..69ed5ad
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ApplicationManagerFacade.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningAppProcessInfo;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Facade for managing Applications.
+ *
+ */
+public class ApplicationManagerFacade extends RpcReceiver {
+
+  private final Service mService;
+  private final AndroidFacade mAndroidFacade;
+  private final ActivityManager mActivityManager;
+  private final PackageManager mPackageManager;
+
+  public ApplicationManagerFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mAndroidFacade = manager.getReceiver(AndroidFacade.class);
+    mActivityManager = (ActivityManager) mService.getSystemService(Context.ACTIVITY_SERVICE);
+    mPackageManager = mService.getPackageManager();
+  }
+
+  @Rpc(description = "Returns a list of all launchable application class names.")
+  public Map<String, String> getLaunchableApplications() {
+    Intent intent = new Intent(Intent.ACTION_MAIN);
+    intent.addCategory(Intent.CATEGORY_LAUNCHER);
+    List<ResolveInfo> resolveInfos = mPackageManager.queryIntentActivities(intent, 0);
+    Map<String, String> applications = new HashMap<String, String>();
+    for (ResolveInfo info : resolveInfos) {
+      applications.put(info.loadLabel(mPackageManager).toString(), info.activityInfo.name);
+    }
+    return applications;
+  }
+
+  @Rpc(description = "Start activity with the given class name.")
+  public void launch(@RpcParameter(name = "className") String className) {
+    Intent intent = new Intent(Intent.ACTION_MAIN);
+    String packageName = className.substring(0, className.lastIndexOf("."));
+    intent.setClassName(packageName, className);
+    mAndroidFacade.startActivity(intent);
+  }
+
+  @Rpc(description = "Launch the specified app.")
+  public void appLaunch(@RpcParameter(name = "name") String name) {
+      Intent LaunchIntent = mPackageManager.getLaunchIntentForPackage(name);
+      mService.startActivity(LaunchIntent);
+  }
+
+  @Rpc(description = "Kill the specified app.")
+  public Boolean appKill(@RpcParameter(name = "name") String name) {
+      for (RunningAppProcessInfo info : mActivityManager.getRunningAppProcesses()) {
+          if (info.processName.contains(name)) {
+              Log.d("Killing " + info.processName);
+              android.os.Process.killProcess(info.pid);
+              android.os.Process.sendSignal(info.pid, android.os.Process.SIGNAL_KILL);
+              mActivityManager.killBackgroundProcesses(info.processName);
+              return true;
+          }
+      }
+      return false;
+  }
+
+  @Rpc(description = "Returns a list of packages running activities or services.", returns = "List of packages running activities.")
+  public List<String> getRunningPackages() {
+    Set<String> runningPackages = new HashSet<String>();
+    List<ActivityManager.RunningAppProcessInfo> appProcesses =
+        mActivityManager.getRunningAppProcesses();
+    for (ActivityManager.RunningAppProcessInfo info : appProcesses) {
+      runningPackages.addAll(Arrays.asList(info.pkgList));
+    }
+    List<ActivityManager.RunningServiceInfo> serviceProcesses =
+        mActivityManager.getRunningServices(Integer.MAX_VALUE);
+    for (ActivityManager.RunningServiceInfo info : serviceProcesses) {
+      runningPackages.add(info.service.getPackageName());
+    }
+    return new ArrayList<String>(runningPackages);
+  }
+
+  @Rpc(description = "Force stops a package.")
+  public void forceStopPackage(
+      @RpcParameter(name = "packageName", description = "name of package") String packageName) {
+    mActivityManager.restartPackage(packageName);
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/BatteryManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/BatteryManagerFacade.java
new file mode 100644
index 0000000..5d0b34e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/BatteryManagerFacade.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.BatteryManager;
+import android.os.Bundle;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcStartEvent;
+import com.googlecode.android_scripting.rpc.RpcStopEvent;
+
+import java.lang.reflect.Field;
+
+/**
+ * Exposes Batterymanager API. Note that in order to use any of the batteryGet* functions, you need
+ * to batteryStartMonitoring, and then wait for a "battery" event. Sleeping for a second will
+ * usually work just as well.
+ *
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ * @author Robbie Matthews (rjmatthews62@gmail.com)
+ */
+public class BatteryManagerFacade extends RpcReceiver {
+
+  private final Service mService;
+  private final EventFacade mEventFacade;
+  private final int mSdkVersion;
+
+  private BatteryStateListener mReceiver;
+
+  private volatile Bundle mBatteryData = null;
+  private volatile Integer mBatteryStatus = null;
+  private volatile Integer mBatteryHealth = null;
+  private volatile Integer mPlugType = null;
+
+  private volatile Boolean mBatteryPresent = null;
+  private volatile Integer mBatteryLevel = null;
+  private volatile Integer mBatteryMaxLevel = null;
+  private volatile Integer mBatteryVoltage = null;
+  private volatile Integer mBatteryTemperature = null;
+  private volatile String mBatteryTechnology = null;
+
+  public BatteryManagerFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mSdkVersion = manager.getSdkLevel();
+    mEventFacade = manager.getReceiver(EventFacade.class);
+    mReceiver = null;
+    mBatteryData = null;
+  }
+
+  private class BatteryStateListener extends BroadcastReceiver {
+
+    private final EventFacade mmEventFacade;
+
+    private BatteryStateListener(EventFacade facade) {
+      mmEventFacade = facade;
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      mBatteryStatus = intent.getIntExtra("status", 1);
+      mBatteryHealth = intent.getIntExtra("health", 1);
+      mPlugType = intent.getIntExtra("plugged", -1);
+      if (mSdkVersion >= 5) {
+        mBatteryPresent =
+            intent.getBooleanExtra(getBatteryManagerFieldValue("EXTRA_PRESENT"), false);
+        mBatteryLevel = intent.getIntExtra(getBatteryManagerFieldValue("EXTRA_LEVEL"), -1);
+        mBatteryMaxLevel = intent.getIntExtra(getBatteryManagerFieldValue("EXTRA_SCALE"), 0);
+        mBatteryVoltage = intent.getIntExtra(getBatteryManagerFieldValue("EXTRA_VOLTAGE"), -1);
+        mBatteryTemperature =
+            intent.getIntExtra(getBatteryManagerFieldValue("EXTRA_TEMPERATURE"), -1);
+        mBatteryTechnology = intent.getStringExtra(getBatteryManagerFieldValue("EXTRA_TECHNOLOGY"));
+      }
+      Bundle data = new Bundle();
+      data.putInt("status", mBatteryStatus);
+      data.putInt("health", mBatteryHealth);
+      data.putInt("plugged", mPlugType);
+      if (mSdkVersion >= 5) {
+        data.putBoolean("battery_present", mBatteryPresent);
+        if (mBatteryMaxLevel == null || mBatteryMaxLevel == 100 || mBatteryMaxLevel == 0) {
+          data.putInt("level", mBatteryLevel);
+        } else {
+          data.putInt("level", (int) (mBatteryLevel * 100.0 / mBatteryMaxLevel));
+        }
+        data.putInt("voltage", mBatteryVoltage);
+        data.putInt("temperature", mBatteryTemperature);
+        data.putString("technology", mBatteryTechnology);
+      }
+      mBatteryData = data;
+      mmEventFacade.postEvent("battery", mBatteryData.clone());
+    }
+  }
+
+  private String getBatteryManagerFieldValue(String name) {
+    try {
+      Field f = BatteryManager.class.getField(name);
+      return f.get(null).toString();
+    } catch (Exception e) {
+      Log.e(e);
+    }
+    return null;
+  }
+
+  @Rpc(description = "Returns the most recently recorded battery data.")
+  public Bundle readBatteryData() {
+    return mBatteryData;
+  }
+
+  /**
+   * throws "battery" events
+   */
+  @Rpc(description = "Starts tracking battery state.")
+  @RpcStartEvent("battery")
+  public void batteryStartMonitoring() {
+    if (mReceiver == null) {
+      IntentFilter filter = new IntentFilter();
+      filter.addAction(Intent.ACTION_BATTERY_CHANGED);
+      mReceiver = new BatteryStateListener(mEventFacade);
+      mService.registerReceiver(mReceiver, filter);
+    }
+  }
+
+  @Rpc(description = "Stops tracking battery state.")
+  @RpcStopEvent("battery")
+  public void batteryStopMonitoring() {
+    if (mReceiver != null) {
+      mService.unregisterReceiver(mReceiver);
+      mReceiver = null;
+    }
+    mBatteryData = null;
+  }
+
+  @Override
+  public void shutdown() {
+    batteryStopMonitoring();
+  }
+
+  @Rpc(description = "Returns  the most recently received battery status data:" + "\n1 - unknown;"
+      + "\n2 - charging;" + "\n3 - discharging;" + "\n4 - not charging;" + "\n5 - full;")
+  public Integer batteryGetStatus() {
+    return mBatteryStatus;
+  }
+
+  @Rpc(description = "Returns the most recently received battery health data:" + "\n1 - unknown;"
+      + "\n2 - good;" + "\n3 - overheat;" + "\n4 - dead;" + "\n5 - over voltage;"
+      + "\n6 - unspecified failure;")
+  public Integer batteryGetHealth() {
+    return mBatteryHealth;
+  }
+
+  /** Power source is an AC charger. */
+  public static final int BATTERY_PLUGGED_AC = 1;
+  /** Power source is a USB port. */
+  public static final int BATTERY_PLUGGED_USB = 2;
+
+  @Rpc(description = "Returns the most recently received plug type data:" + "\n-1 - unknown"
+      + "\n0 - unplugged;" + "\n1 - power source is an AC charger"
+      + "\n2 - power source is a USB port")
+  public Integer batteryGetPlugType() {
+    return mPlugType;
+  }
+
+  @Rpc(description = "Returns the most recently received battery presence data.")
+  public Boolean batteryCheckPresent() {
+    return mBatteryPresent;
+  }
+
+  @Rpc(description = "Returns the most recently received battery level (percentage).")
+  public Integer batteryGetLevel() {
+    if (mBatteryMaxLevel == null || mBatteryMaxLevel == 100 || mBatteryMaxLevel == 0) {
+      return mBatteryLevel;
+    } else {
+      return (int) (mBatteryLevel * 100.0 / mBatteryMaxLevel);
+    }
+  }
+
+  @Rpc(description = "Returns the most recently received battery voltage.")
+  public Integer batteryGetVoltage() {
+    return mBatteryVoltage;
+  }
+
+  @Rpc(description = "Returns the most recently received battery temperature.")
+  public Integer batteryGetTemperature() {
+    return mBatteryTemperature;
+  }
+
+  @Rpc(description = "Returns the most recently received battery technology data.")
+  public String batteryGetTechnology() {
+    return mBatteryTechnology;
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/CameraFacade.java b/Common/src/com/googlecode/android_scripting/facade/CameraFacade.java
new file mode 100644
index 0000000..ff353f9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/CameraFacade.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.Intent;
+import android.hardware.Camera;
+import android.hardware.Camera.AutoFocusCallback;
+import android.hardware.Camera.Parameters;
+import android.hardware.Camera.PictureCallback;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.MediaStore;
+import android.view.SurfaceHolder;
+import android.view.SurfaceHolder.Callback;
+import android.view.SurfaceView;
+import android.view.WindowManager;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.FileUtils;
+import com.googlecode.android_scripting.FutureActivityTaskExecutor;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * Access Camera functions.
+ *
+ */
+public class CameraFacade extends RpcReceiver {
+
+  private final Service mService;
+  private final Parameters mParameters;
+
+  private class BooleanResult {
+    boolean mmResult = false;
+  }
+
+  public Camera openCamera(int cameraId) throws Exception {
+    int sSdkLevel = Integer.parseInt(android.os.Build.VERSION.SDK);
+    Camera result;
+    if (sSdkLevel < 9) {
+      result = Camera.open();
+    } else {
+      Method openCamera = Camera.class.getMethod("open", int.class);
+      result = (Camera) openCamera.invoke(null, cameraId);
+    }
+    return result;
+  }
+
+  public CameraFacade(FacadeManager manager) throws Exception {
+    super(manager);
+    mService = manager.getService();
+    Camera camera = openCamera(0);
+    try {
+      mParameters = camera.getParameters();
+    } finally {
+      camera.release();
+    }
+  }
+
+  @Rpc(description = "Take a picture and save it to the specified path.", returns = "A map of Booleans autoFocus and takePicture where True indicates success. cameraId also included.")
+  public Bundle cameraCapturePicture(
+      @RpcParameter(name = "targetPath") final String targetPath,
+      @RpcParameter(name = "useAutoFocus") @RpcDefault("true") Boolean useAutoFocus,
+      @RpcParameter(name = "cameraId", description = "Id of camera to use. SDK 9") @RpcDefault("0") Integer cameraId)
+      throws Exception {
+    final BooleanResult autoFocusResult = new BooleanResult();
+    final BooleanResult takePictureResult = new BooleanResult();
+    Camera camera = openCamera(cameraId);
+    camera.setParameters(mParameters);
+
+    try {
+      Method method = camera.getClass().getMethod("setDisplayOrientation", int.class);
+      method.invoke(camera, 90);
+    } catch (Exception e) {
+      Log.e(e);
+    }
+
+    try {
+      FutureActivityTask<SurfaceHolder> previewTask = setPreviewDisplay(camera);
+      camera.startPreview();
+      if (useAutoFocus) {
+        autoFocus(autoFocusResult, camera);
+      }
+      takePicture(new File(targetPath), takePictureResult, camera);
+      previewTask.finish();
+    } catch (Exception e) {
+      Log.e(e);
+    } finally {
+      camera.release();
+    }
+
+    Bundle result = new Bundle();
+    result.putBoolean("autoFocus", autoFocusResult.mmResult);
+    result.putBoolean("takePicture", takePictureResult.mmResult);
+    result.putInt("cameraId", cameraId);
+    return result;
+  }
+
+  private FutureActivityTask<SurfaceHolder> setPreviewDisplay(Camera camera) throws IOException,
+      InterruptedException {
+    FutureActivityTask<SurfaceHolder> task = new FutureActivityTask<SurfaceHolder>() {
+      @Override
+      public void onCreate() {
+        super.onCreate();
+        final SurfaceView view = new SurfaceView(getActivity());
+        getActivity().setContentView(view);
+        getActivity().getWindow().setSoftInputMode(
+            WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED);
+        view.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
+        view.getHolder().addCallback(new Callback() {
+          @Override
+          public void surfaceDestroyed(SurfaceHolder holder) {
+          }
+
+          @Override
+          public void surfaceCreated(SurfaceHolder holder) {
+            setResult(view.getHolder());
+          }
+
+          @Override
+          public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+          }
+        });
+      }
+    };
+    FutureActivityTaskExecutor taskQueue =
+        ((BaseApplication) mService.getApplication()).getTaskExecutor();
+    taskQueue.execute(task);
+    camera.setPreviewDisplay(task.getResult());
+    return task;
+  }
+
+  private void takePicture(final File file, final BooleanResult takePictureResult,
+      final Camera camera) throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+    camera.takePicture(null, null, new PictureCallback() {
+      @Override
+      public void onPictureTaken(byte[] data, Camera camera) {
+        if (!FileUtils.makeDirectories(file.getParentFile(), 0755)) {
+          takePictureResult.mmResult = false;
+          return;
+        }
+        try {
+          FileOutputStream output = new FileOutputStream(file);
+          output.write(data);
+          output.close();
+          takePictureResult.mmResult = true;
+        } catch (FileNotFoundException e) {
+          Log.e("Failed to save picture.", e);
+          takePictureResult.mmResult = false;
+          return;
+        } catch (IOException e) {
+          Log.e("Failed to save picture.", e);
+          takePictureResult.mmResult = false;
+          return;
+        } finally {
+          latch.countDown();
+        }
+      }
+    });
+    latch.await();
+  }
+
+  private void autoFocus(final BooleanResult result, final Camera camera)
+      throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+    {
+      camera.autoFocus(new AutoFocusCallback() {
+        @Override
+        public void onAutoFocus(boolean success, Camera camera) {
+          result.mmResult = success;
+          latch.countDown();
+        }
+      });
+      latch.await();
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    // Nothing to clean up.
+  }
+
+  @Rpc(description = "Starts the image capture application to take a picture and saves it to the specified path.")
+  public void cameraInteractiveCapturePicture(
+      @RpcParameter(name = "targetPath") final String targetPath) {
+    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
+    File file = new File(targetPath);
+    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
+    AndroidFacade facade = mManager.getReceiver(AndroidFacade.class);
+    facade.startActivityForResult(intent);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/CommonIntentsFacade.java b/Common/src/com/googlecode/android_scripting/facade/CommonIntentsFacade.java
new file mode 100644
index 0000000..ffa464c
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/CommonIntentsFacade.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.SearchManager;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.net.Uri;
+import android.provider.Contacts.People;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.io.File;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * A selection of commonly used intents. <br>
+ * <br>
+ * These can be used to trigger some common tasks.
+ *
+ */
+public class CommonIntentsFacade extends RpcReceiver {
+
+  private final AndroidFacade mAndroidFacade;
+
+  public CommonIntentsFacade(FacadeManager manager) {
+    super(manager);
+    mAndroidFacade = manager.getReceiver(AndroidFacade.class);
+  }
+
+  @Override
+  public void shutdown() {
+  }
+
+  @Rpc(description = "Display content to be picked by URI (e.g. contacts)", returns = "A map of result values.")
+  public Intent pick(@RpcParameter(name = "uri") String uri) throws JSONException {
+    return mAndroidFacade.startActivityForResult(Intent.ACTION_PICK, uri, null, null, null, null);
+  }
+
+  @Rpc(description = "Starts the barcode scanner.", returns = "A Map representation of the result Intent.")
+  public Intent scanBarcode() throws JSONException {
+    try {
+      return mAndroidFacade.startActivityForResult("com.google.zxing.client.android.SCAN", null,
+        null, null, null, null);
+    } catch (ActivityNotFoundException e) {
+        Log.e("No Activity found to scan a barcode!", e);
+        return null;
+    }
+  }
+
+  private void view(Uri uri, String type) {
+    Intent intent = new Intent(Intent.ACTION_VIEW);
+    intent.setDataAndType(uri, type);
+    mAndroidFacade.startActivity(intent);
+  }
+
+  @Rpc(description = "Start activity with view action by URI (i.e. browser, contacts, etc.).")
+  public void view(
+      @RpcParameter(name = "uri") String uri,
+      @RpcParameter(name = "type", description = "MIME type/subtype of the URI") @RpcOptional String type,
+      @RpcParameter(name = "extras", description = "a Map of extras to add to the Intent") @RpcOptional JSONObject extras)
+      throws Exception {
+    mAndroidFacade.startActivity(Intent.ACTION_VIEW, uri, type, extras, true, null, null);
+  }
+
+  @Rpc(description = "Opens a map search for query (e.g. pizza, 123 My Street).")
+  public void viewMap(@RpcParameter(name = "query, e.g. pizza, 123 My Street") String query)
+      throws Exception {
+    view("geo:0,0?q=" + query, null, null);
+  }
+
+  @Rpc(description = "Opens the list of contacts.")
+  public void viewContacts() throws JSONException {
+    view(People.CONTENT_URI, null);
+  }
+
+  @Rpc(description = "Opens the browser to display a local HTML file.")
+  public void viewHtml(
+      @RpcParameter(name = "path", description = "the path to the HTML file") String path)
+      throws JSONException {
+    File file = new File(path);
+    view(Uri.fromFile(file), "text/html");
+  }
+
+  @Rpc(description = "Starts a search for the given query.")
+  public void search(@RpcParameter(name = "query") String query) {
+    Intent intent = new Intent(Intent.ACTION_SEARCH);
+    intent.putExtra(SearchManager.QUERY, query);
+    mAndroidFacade.startActivity(intent);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ConnectivityManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/ConnectivityManagerFacade.java
new file mode 100644
index 0000000..594c934
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ConnectivityManagerFacade.java
@@ -0,0 +1,721 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.ConnectivityManager.NetworkCallback;
+import android.net.ConnectivityManager.PacketKeepaliveCallback;
+import android.net.ConnectivityManager.PacketKeepalive;
+import android.net.LinkProperties;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkRequest;
+import android.net.NetworkInfo;
+import android.provider.Settings.SettingNotFoundException;
+import android.os.Bundle;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.telephony.TelephonyConstants;
+import com.googlecode.android_scripting.facade.telephony.TelephonyEvents;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.HashMap;
+
+/**
+ * Access ConnectivityManager functions.
+ */
+public class ConnectivityManagerFacade extends RpcReceiver {
+
+    public static int AIRPLANE_MODE_OFF = 0;
+    public static int AIRPLANE_MODE_ON = 1;
+
+    class ConnectivityReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+
+            if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
+                Log.e("ConnectivityReceiver received non-connectivity action!");
+                return;
+            }
+
+            Bundle b = intent.getExtras();
+
+            if (b == null) {
+                Log.e("ConnectivityReceiver failed to receive extras!");
+                return;
+            }
+
+            int netType =
+                    b.getInt(ConnectivityManager.EXTRA_NETWORK_TYPE,
+                            ConnectivityManager.TYPE_NONE);
+
+            if (netType == ConnectivityManager.TYPE_NONE) {
+                Log.i("ConnectivityReceiver received change to TYPE_NONE.");
+                return;
+            }
+
+            /*
+             * Technically there is a race condition here, but retrieving the NetworkInfo from the
+             * bundle is deprecated. See ConnectivityManager.EXTRA_NETWORK_INFO
+             */
+            for (NetworkInfo info : mManager.getAllNetworkInfo()) {
+                if (info.getType() == netType) {
+                    mEventFacade.postEvent(TelephonyConstants.EventConnectivityChanged, info);
+                }
+            }
+        }
+    }
+
+    class PacketKeepaliveReceiver extends PacketKeepaliveCallback {
+        public static final int EVENT_INVALID = -1;
+        public static final int EVENT_NONE = 0;
+        public static final int EVENT_STARTED = 1 << 0;
+        public static final int EVENT_STOPPED = 1 << 1;
+        public static final int EVENT_ERROR = 1 << 2;
+        public static final int EVENT_ALL = EVENT_STARTED |
+                EVENT_STOPPED |
+                EVENT_ERROR;
+        private int mEvents;
+        public String mId;
+        public PacketKeepalive mPacketKeepalive;
+
+        public PacketKeepaliveReceiver(int events) {
+            super();
+            mEvents = events;
+            mId = this.toString();
+        }
+
+        public void startListeningForEvents(int events) {
+            mEvents |= events & EVENT_ALL;
+        }
+
+        public void stopListeningForEvents(int events) {
+            mEvents &= ~(events & EVENT_ALL);
+        }
+
+        @Override
+        public void onStarted() {
+            Log.d("PacketKeepaliveCallback on start!");
+            if ((mEvents & EVENT_STARTED) == EVENT_STARTED) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventPacketKeepaliveCallback,
+                    new TelephonyEvents.PacketKeepaliveEvent(
+                        mId,
+                        getPacketKeepaliveReceiverEventString(EVENT_STARTED)));
+            }
+        }
+
+        @Override
+        public void onStopped() {
+            Log.d("PacketKeepaliveCallback on stop!");
+            if ((mEvents & EVENT_STOPPED) == EVENT_STOPPED) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventPacketKeepaliveCallback,
+                    new TelephonyEvents.PacketKeepaliveEvent(
+                        mId,
+                        getPacketKeepaliveReceiverEventString(EVENT_STOPPED)));
+            }
+        }
+
+        @Override
+        public void onError(int error) {
+            Log.d("PacketKeepaliveCallback on error! - code:" + error);
+            if ((mEvents & EVENT_ERROR) == EVENT_ERROR) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventPacketKeepaliveCallback,
+                    new TelephonyEvents.PacketKeepaliveEvent(
+                        mId,
+                        getPacketKeepaliveReceiverEventString(EVENT_ERROR)));
+            }
+        }
+    }
+
+    class NetworkCallback extends ConnectivityManager.NetworkCallback {
+        public static final int EVENT_INVALID = -1;
+        public static final int EVENT_NONE = 0;
+        public static final int EVENT_PRECHECK = 1 << 0;
+        public static final int EVENT_AVAILABLE = 1 << 1;
+        public static final int EVENT_LOSING = 1 << 2;
+        public static final int EVENT_LOST = 1 << 3;
+        public static final int EVENT_UNAVAILABLE = 1 << 4;
+        public static final int EVENT_CAPABILITIES_CHANGED = 1 << 5;
+        public static final int EVENT_SUSPENDED = 1 << 6;
+        public static final int EVENT_RESUMED = 1 << 7;
+        public static final int EVENT_LINK_PROPERTIES_CHANGED = 1 << 8;
+        public static final int EVENT_ALL = EVENT_PRECHECK |
+                EVENT_AVAILABLE |
+                EVENT_LOSING |
+                EVENT_LOST |
+                EVENT_UNAVAILABLE |
+                EVENT_CAPABILITIES_CHANGED |
+                EVENT_SUSPENDED |
+                EVENT_RESUMED |
+                EVENT_LINK_PROPERTIES_CHANGED;
+
+        private int mEvents;
+        public String mId;
+
+        public NetworkCallback(int events) {
+            super();
+            mEvents = events;
+            mId = this.toString();
+        }
+
+        public void startListeningForEvents(int events) {
+            mEvents |= events & EVENT_ALL;
+        }
+
+        public void stopListeningForEvents(int events) {
+            mEvents &= ~(events & EVENT_ALL);
+        }
+
+        @Override
+        public void onPreCheck(Network network) {
+            Log.d("NetworkCallback onPreCheck");
+            if ((mEvents & EVENT_PRECHECK) == EVENT_PRECHECK) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_PRECHECK),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+
+        @Override
+        public void onAvailable(Network network) {
+            Log.d("NetworkCallback onAvailable");
+            if ((mEvents & EVENT_AVAILABLE) == EVENT_AVAILABLE) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_AVAILABLE),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+
+        @Override
+        public void onLosing(Network network, int maxMsToLive) {
+            Log.d("NetworkCallback onLosing");
+            if ((mEvents & EVENT_LOSING) == EVENT_LOSING) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_LOSING),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        maxMsToLive));
+            }
+        }
+
+        @Override
+        public void onLost(Network network) {
+            Log.d("NetworkCallback onLost");
+            if ((mEvents & EVENT_LOST) == EVENT_LOST) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_LOST),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+
+        @Override
+        public void onUnavailable() {
+            Log.d("NetworkCallback onUnavailable");
+            if ((mEvents & EVENT_UNAVAILABLE) == EVENT_UNAVAILABLE) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_UNAVAILABLE),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+
+        @Override
+        public void onCapabilitiesChanged(Network network,
+                NetworkCapabilities networkCapabilities) {
+            Log.d("NetworkCallback onCapabilitiesChanged. RSSI:" +
+                    networkCapabilities.getSignalStrength());
+            if ((mEvents & EVENT_CAPABILITIES_CHANGED) == EVENT_CAPABILITIES_CHANGED) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_CAPABILITIES_CHANGED),
+                        networkCapabilities.getSignalStrength(),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+
+        @Override
+        public void onNetworkSuspended(Network network) {
+            Log.d("NetworkCallback onNetworkSuspended");
+            if ((mEvents & EVENT_SUSPENDED) == EVENT_SUSPENDED) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_SUSPENDED),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+
+        @Override
+        public void onLinkPropertiesChanged(Network network,
+                LinkProperties linkProperties) {
+            Log.d("NetworkCallback onLinkPropertiesChanged");
+            if ((mEvents & EVENT_LINK_PROPERTIES_CHANGED) == EVENT_LINK_PROPERTIES_CHANGED) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_LINK_PROPERTIES_CHANGED),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+
+        @Override
+        public void onNetworkResumed(Network network) {
+            Log.d("NetworkCallback onNetworkResumed");
+            if ((mEvents & EVENT_RESUMED) == EVENT_RESUMED) {
+                mEventFacade.postEvent(
+                    TelephonyConstants.EventNetworkCallback,
+                    new TelephonyEvents.NetworkCallbackEvent(
+                        mId,
+                        getNetworkCallbackEventString(EVENT_RESUMED),
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE,
+                        TelephonyEvents.NetworkCallbackEvent.INVALID_VALUE));
+            }
+        }
+    }
+
+    private static int getNetworkCallbackEvent(String event) {
+        switch (event) {
+            case TelephonyConstants.NetworkCallbackPreCheck:
+                return NetworkCallback.EVENT_PRECHECK;
+            case TelephonyConstants.NetworkCallbackAvailable:
+                return NetworkCallback.EVENT_AVAILABLE;
+            case TelephonyConstants.NetworkCallbackLosing:
+                return NetworkCallback.EVENT_LOSING;
+            case TelephonyConstants.NetworkCallbackLost:
+                return NetworkCallback.EVENT_LOST;
+            case TelephonyConstants.NetworkCallbackUnavailable:
+                return NetworkCallback.EVENT_UNAVAILABLE;
+            case TelephonyConstants.NetworkCallbackCapabilitiesChanged:
+                return NetworkCallback.EVENT_CAPABILITIES_CHANGED;
+            case TelephonyConstants.NetworkCallbackSuspended:
+                return NetworkCallback.EVENT_SUSPENDED;
+            case TelephonyConstants.NetworkCallbackResumed:
+                return NetworkCallback.EVENT_RESUMED;
+            case TelephonyConstants.NetworkCallbackLinkPropertiesChanged:
+                return NetworkCallback.EVENT_LINK_PROPERTIES_CHANGED;
+        }
+        return NetworkCallback.EVENT_INVALID;
+    }
+
+    private static String getNetworkCallbackEventString(int event) {
+        switch (event) {
+            case NetworkCallback.EVENT_PRECHECK:
+                return TelephonyConstants.NetworkCallbackPreCheck;
+            case NetworkCallback.EVENT_AVAILABLE:
+                return TelephonyConstants.NetworkCallbackAvailable;
+            case NetworkCallback.EVENT_LOSING:
+                return TelephonyConstants.NetworkCallbackLosing;
+            case NetworkCallback.EVENT_LOST:
+                return TelephonyConstants.NetworkCallbackLost;
+            case NetworkCallback.EVENT_UNAVAILABLE:
+                return TelephonyConstants.NetworkCallbackUnavailable;
+            case NetworkCallback.EVENT_CAPABILITIES_CHANGED:
+                return TelephonyConstants.NetworkCallbackCapabilitiesChanged;
+            case NetworkCallback.EVENT_SUSPENDED:
+                return TelephonyConstants.NetworkCallbackSuspended;
+            case NetworkCallback.EVENT_RESUMED:
+                return TelephonyConstants.NetworkCallbackResumed;
+            case NetworkCallback.EVENT_LINK_PROPERTIES_CHANGED:
+                return TelephonyConstants.NetworkCallbackLinkPropertiesChanged;
+        }
+        return TelephonyConstants.NetworkCallbackInvalid;
+    }
+
+    private static int getPacketKeepaliveReceiverEvent(String event) {
+        switch (event) {
+            case TelephonyConstants.PacketKeepaliveCallbackStarted:
+                return PacketKeepaliveReceiver.EVENT_STARTED;
+            case TelephonyConstants.PacketKeepaliveCallbackStopped:
+                return PacketKeepaliveReceiver.EVENT_STOPPED;
+            case TelephonyConstants.PacketKeepaliveCallbackError:
+                return PacketKeepaliveReceiver.EVENT_ERROR;
+        }
+        return PacketKeepaliveReceiver.EVENT_INVALID;
+    }
+
+    private static String getPacketKeepaliveReceiverEventString(int event) {
+        switch (event) {
+            case PacketKeepaliveReceiver.EVENT_STARTED:
+                return TelephonyConstants.PacketKeepaliveCallbackStarted;
+            case PacketKeepaliveReceiver.EVENT_STOPPED:
+                return TelephonyConstants.PacketKeepaliveCallbackStopped;
+            case PacketKeepaliveReceiver.EVENT_ERROR:
+                return TelephonyConstants.PacketKeepaliveCallbackError;
+        }
+        return TelephonyConstants.PacketKeepaliveCallbackInvalid;
+    }
+
+    private final ConnectivityManager mManager;
+    private final Service mService;
+    private final Context mContext;
+    private final ConnectivityReceiver mConnectivityReceiver;
+    private final EventFacade mEventFacade;
+    private PacketKeepalive mPacketKeepalive;
+    private NetworkCallback mNetworkCallback;
+    private static HashMap<String, PacketKeepaliveReceiver> mPacketKeepaliveReceiverMap =
+            new HashMap<String, PacketKeepaliveReceiver>();
+    private static HashMap<String, NetworkCallback> mNetworkCallbackMap =
+            new HashMap<String, NetworkCallback>();
+    private boolean mTrackingConnectivityStateChange;
+
+    public ConnectivityManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mContext = mService.getBaseContext();
+        mManager = (ConnectivityManager) mService.getSystemService(Context.CONNECTIVITY_SERVICE);
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mConnectivityReceiver = new ConnectivityReceiver();
+        mTrackingConnectivityStateChange = false;
+    }
+
+    @Rpc(description = "Listen for connectivity changes")
+    public void connectivityStartTrackingConnectivityStateChange() {
+        if (!mTrackingConnectivityStateChange) {
+            mTrackingConnectivityStateChange = true;
+            mContext.registerReceiver(mConnectivityReceiver,
+                    new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
+        }
+    }
+
+    @Rpc(description = "start natt keep alive")
+    public String connectivityStartNattKeepalive(Integer intervalSeconds, String srcAddrString,
+            Integer srcPort, String dstAddrString) throws UnknownHostException {
+        try {
+            Network mNetwork = mManager.getActiveNetwork();
+            InetAddress srcAddr = InetAddress.getByName(srcAddrString);
+            InetAddress dstAddr = InetAddress.getByName(dstAddrString);
+            Log.d("startNattKeepalive srcAddr:" + srcAddr.getHostAddress());
+            Log.d("startNattKeepalive dstAddr:" + dstAddr.getHostAddress());
+            Log.d("startNattKeepalive srcPort:" + srcPort);
+            Log.d("startNattKeepalive intervalSeconds:" + intervalSeconds);
+            PacketKeepaliveReceiver mPacketKeepaliveReceiver = new PacketKeepaliveReceiver(
+                    PacketKeepaliveReceiver.EVENT_ALL);
+            mPacketKeepalive = mManager.startNattKeepalive(mNetwork, (int) intervalSeconds,
+                    mPacketKeepaliveReceiver, srcAddr, (int) srcPort, dstAddr);
+            if (mPacketKeepalive != null) {
+                mPacketKeepaliveReceiver.mPacketKeepalive = mPacketKeepalive;
+                String key = mPacketKeepaliveReceiver.mId;
+                mPacketKeepaliveReceiverMap.put(key, mPacketKeepaliveReceiver);
+                return key;
+            } else {
+                Log.e("startNattKeepalive fail, startNattKeepalive return null");
+                return null;
+            }
+        } catch (UnknownHostException e) {
+            Log.e("startNattKeepalive UnknownHostException");
+            return null;
+        }
+    }
+
+    @Rpc(description = "stop natt keep alive")
+    public Boolean connectivityStopNattKeepalive(String key) {
+        PacketKeepaliveReceiver mPacketKeepaliveReceiver =
+                mPacketKeepaliveReceiverMap.get(key);
+        if (mPacketKeepaliveReceiver != null) {
+            mPacketKeepaliveReceiverMap.remove(key);
+            mPacketKeepaliveReceiver.mPacketKeepalive.stop();
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Rpc(description = "start listening for NattKeepalive Event")
+    public Boolean connectivityNattKeepaliveStartListeningForEvent(String key, String eventString) {
+        PacketKeepaliveReceiver mPacketKeepaliveReceiver =
+                mPacketKeepaliveReceiverMap.get(key);
+        if (mPacketKeepaliveReceiver != null) {
+            int event = getPacketKeepaliveReceiverEvent(eventString);
+            if (event == PacketKeepaliveReceiver.EVENT_INVALID) {
+                return false;
+            }
+            mPacketKeepaliveReceiver.startListeningForEvents(event);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Rpc(description = "stop listening for NattKeepalive Event")
+    public Boolean connectivityNattKeepaliveStopListeningForEvent(String key, String eventString) {
+        PacketKeepaliveReceiver mPacketKeepaliveReceiver =
+                mPacketKeepaliveReceiverMap.get(key);
+        if (mPacketKeepaliveReceiver != null) {
+            int event = getPacketKeepaliveReceiverEvent(eventString);
+            if (event == PacketKeepaliveReceiver.EVENT_INVALID) {
+                return false;
+            }
+            mPacketKeepaliveReceiver.stopListeningForEvents(event);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Rpc(description = "start listening for NetworkCallback Event")
+    public Boolean connectivityNetworkCallbackStartListeningForEvent(String key, String eventString) {
+        NetworkCallback mNetworkCallback = mNetworkCallbackMap.get(key);
+        if (mNetworkCallback != null) {
+            int event = getNetworkCallbackEvent(eventString);
+            if (event == NetworkCallback.EVENT_INVALID) {
+                return false;
+            }
+            mNetworkCallback.startListeningForEvents(event);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Rpc(description = "stop listening for NetworkCallback Event")
+    public Boolean connectivityNetworkCallbackStopListeningForEvent(String key, String eventString) {
+        NetworkCallback mNetworkCallback = mNetworkCallbackMap.get(key);
+        if (mNetworkCallback != null) {
+            int event = getNetworkCallbackEvent(eventString);
+            if (event == NetworkCallback.EVENT_INVALID) {
+                return false;
+            }
+            mNetworkCallback.stopListeningForEvents(event);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Rpc(description = "Set Rssi Threshold Monitor")
+    public String connectivitySetRssiThresholdMonitor(Integer rssi) {
+        Log.d("SL4A:setRssiThresholdMonitor rssi = " + rssi);
+        NetworkRequest.Builder builder = new NetworkRequest.Builder();
+        builder.setSignalStrength((int) rssi);
+        builder.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
+        NetworkRequest networkRequest = builder.build();
+        mNetworkCallback = new NetworkCallback(NetworkCallback.EVENT_ALL);
+        mManager.registerNetworkCallback(networkRequest, mNetworkCallback);
+        String key = mNetworkCallback.mId;
+        mNetworkCallbackMap.put(key, mNetworkCallback);
+        return key;
+    }
+
+    @Rpc(description = "Stop Rssi Threshold Monitor")
+    public Boolean connectivityStopRssiThresholdMonitor(String key) {
+        Log.d("SL4A:stopRssiThresholdMonitor key = " + key);
+        return connectivityUnregisterNetworkCallback(key);
+    }
+
+    private NetworkRequest buildNetworkRequestFromJson(JSONObject configJson)
+            throws JSONException {
+        NetworkRequest.Builder builder = new NetworkRequest.Builder();
+
+        if (configJson.has("TransportType")) {
+            Log.d("build TransportType" + configJson.getInt("TransportType"));
+            builder.addTransportType(configJson.getInt("TransportType"));
+        }
+        if (configJson.has("SignalStrength")) {
+            Log.d("build SignalStrength" + configJson.getInt("SignalStrength"));
+            builder.setSignalStrength(configJson.getInt("SignalStrength"));
+        }
+        if (configJson.has("Capability")) {
+            JSONArray capabilities = configJson.getJSONArray("Capability");
+            for (int i = 0; i < capabilities.length(); i++) {
+                Log.d("build Capability" + capabilities.getInt(i));
+                builder.addCapability(capabilities.getInt(i));
+            }
+        }
+        if (configJson.has("LinkUpstreamBandwidthKbps")) {
+            Log.d("build LinkUpstreamBandwidthKbps" + configJson.getInt(
+                    "LinkUpstreamBandwidthKbps"));
+            builder.setLinkUpstreamBandwidthKbps(configJson.getInt(
+                    "LinkUpstreamBandwidthKbps"));
+        }
+        if (configJson.has("LinkDownstreamBandwidthKbps")) {
+            Log.d("build LinkDownstreamBandwidthKbps" + configJson.getInt(
+                    "LinkDownstreamBandwidthKbps"));
+            builder.setLinkDownstreamBandwidthKbps(configJson.getInt(
+                    "LinkDownstreamBandwidthKbps"));
+        }
+        if (configJson.has("NetworkSpecifier")) {
+            Log.d("build NetworkSpecifier" + configJson.getString("NetworkSpecifier"));
+            builder.setNetworkSpecifier(configJson.getString(
+                    "NetworkSpecifier"));
+        }
+        NetworkRequest networkRequest = builder.build();
+        return networkRequest;
+    }
+
+    @Rpc(description = "register a network callback")
+    public String connectivityRegisterNetworkCallback(@RpcParameter(name = "configJson")
+    JSONObject configJson) throws JSONException {
+        NetworkRequest networkRequest = buildNetworkRequestFromJson(configJson);
+        mNetworkCallback = new NetworkCallback(NetworkCallback.EVENT_ALL);
+        mManager.registerNetworkCallback(networkRequest, mNetworkCallback);
+        String key = mNetworkCallback.mId;
+        mNetworkCallbackMap.put(key, mNetworkCallback);
+        return key;
+    }
+
+    @Rpc(description = "unregister a network callback")
+    public Boolean connectivityUnregisterNetworkCallback(@RpcParameter(name = "key")
+    String key) {
+        mNetworkCallback = mNetworkCallbackMap.get(key);
+        if (mNetworkCallback != null) {
+            mNetworkCallbackMap.remove(key);
+            mManager.unregisterNetworkCallback(mNetworkCallback);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Rpc(description = "request a network")
+    public String connectivityRequestNetwork(@RpcParameter(name = "configJson")
+    JSONObject configJson) throws JSONException {
+        NetworkRequest networkRequest = buildNetworkRequestFromJson(configJson);
+        mNetworkCallback = new NetworkCallback(NetworkCallback.EVENT_ALL);
+        mManager.requestNetwork(networkRequest, mNetworkCallback);
+        String key = mNetworkCallback.mId;
+        mNetworkCallbackMap.put(key, mNetworkCallback);
+        return key;
+    }
+
+    @Rpc(description = "Stop listening for connectivity changes")
+    public void connectivityStopTrackingConnectivityStateChange() {
+        if (mTrackingConnectivityStateChange) {
+            mTrackingConnectivityStateChange = false;
+            mContext.unregisterReceiver(mConnectivityReceiver);
+        }
+    }
+
+    @Rpc(description = "Get the extra information about the network state provided by lower network layers.")
+    public String connectivityNetworkGetActiveConnectionExtraInfo() {
+        NetworkInfo current = mManager.getActiveNetworkInfo();
+        if (current == null) {
+            Log.d("No network is active at the moment.");
+            return null;
+        }
+        return current.getExtraInfo();
+    }
+
+    @Rpc(description = "Return the subtype name of the current network, null if not connected")
+    public String connectivityNetworkGetActiveConnectionSubtypeName() {
+        NetworkInfo current = mManager.getActiveNetworkInfo();
+        if (current == null) {
+            Log.d("No network is active at the moment.");
+            return null;
+        }
+        return current.getSubtypeName();
+    }
+
+    @Rpc(description = "Return a human-readable name describe the type of the network, e.g. WIFI")
+    public String connectivityNetworkGetActiveConnectionTypeName() {
+        NetworkInfo current = mManager.getActiveNetworkInfo();
+        if (current == null) {
+            Log.d("No network is active at the moment.");
+            return null;
+        }
+        return current.getTypeName();
+    }
+
+    @Rpc(description = "Get connection status information about all network types supported by the device.")
+    public NetworkInfo[] connectivityNetworkGetAllInfo() {
+        return mManager.getAllNetworkInfo();
+    }
+
+    @Rpc(description = "Check whether the active network is connected to the Internet.")
+    public Boolean connectivityNetworkIsConnected() {
+        NetworkInfo current = mManager.getActiveNetworkInfo();
+        if (current == null) {
+            Log.d("No network is active at the moment.");
+            return false;
+        }
+        return current.isConnected();
+    }
+
+    @Rpc(description = "Checks the airplane mode setting.",
+            returns = "True if airplane mode is enabled.")
+    public Boolean connectivityCheckAirplaneMode() {
+        try {
+            return android.provider.Settings.System.getInt(mService.getContentResolver(),
+                    android.provider.Settings.Global.AIRPLANE_MODE_ON) == AIRPLANE_MODE_ON;
+        } catch (SettingNotFoundException e) {
+            return false;
+        }
+    }
+
+    @Rpc(description = "Toggles airplane mode on and off.",
+            returns = "True if airplane mode is enabled.")
+    public void connectivityToggleAirplaneMode(@RpcParameter(name = "enabled")
+    @RpcOptional
+    Boolean enabled) {
+        if (enabled == null) {
+            enabled = !connectivityCheckAirplaneMode();
+        }
+        mManager.setAirplaneMode(enabled);
+    }
+
+    @Rpc(description = "Check if tethering supported or not.",
+            returns = "True if tethering is supported.")
+    public boolean connectivityIsTetheringSupported() {
+        return mManager.isTetheringSupported();
+    }
+
+    @Override
+    public void shutdown() {
+        connectivityStopTrackingConnectivityStateChange();
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ContactsFacade.java b/Common/src/com/googlecode/android_scripting/facade/ContactsFacade.java
new file mode 100644
index 0000000..4ab4a1d
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ContactsFacade.java
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.Intent;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.ContactsContract;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Provides access to contacts related functionality.
+ *
+ * @author MeanEYE.rcf (meaneye.rcf@gmail.com
+ */
+public class ContactsFacade extends RpcReceiver {
+  private static final Uri CONTACTS_URI = Uri.parse("content://contacts/people");
+  private final ContentResolver mContentResolver;
+  private final Service mService;
+  private final CommonIntentsFacade mCommonIntentsFacade;
+  public Uri mPhoneContent = null;
+  public String mContactId;
+  public String mPrimary;
+  public String mPhoneNumber;
+  public String mHasPhoneNumber;
+
+  public ContactsFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mContentResolver = mService.getContentResolver();
+    mCommonIntentsFacade = manager.getReceiver(CommonIntentsFacade.class);
+    try {
+      // Backward compatibility... get contract stuff using reflection
+      Class<?> phone = Class.forName("android.provider.ContactsContract$CommonDataKinds$Phone");
+      mPhoneContent = (Uri) phone.getField("CONTENT_URI").get(null);
+      mContactId = (String) phone.getField("CONTACT_ID").get(null);
+      mPrimary = (String) phone.getField("IS_PRIMARY").get(null);
+      mPhoneNumber = (String) phone.getField("NUMBER").get(null);
+      mHasPhoneNumber = (String) phone.getField("HAS_PHONE_NUMBER").get(null);
+    } catch (Exception e) {
+    }
+  }
+
+  private Uri buildUri(Integer id) {
+    Uri uri = ContentUris.withAppendedId(ContactsContract.Contacts.CONTENT_URI, id);
+    return uri;
+  }
+
+  @Rpc(description = "Displays a list of contacts to pick from.", returns = "A map of result values.")
+  public Intent pickContact() throws JSONException {
+    return mCommonIntentsFacade.pick("content://contacts/people");
+  }
+
+  @Rpc(description = "Displays a list of phone numbers to pick from.", returns = "The selected phone number.")
+  public String pickPhone() throws JSONException {
+    String result = null;
+    Intent data = mCommonIntentsFacade.pick("content://contacts/phones");
+    if (data != null) {
+      Uri phoneData = data.getData();
+      Cursor cursor = mService.getContentResolver().query(phoneData, null, null, null, null);
+      if (cursor != null) {
+        if (cursor.moveToFirst()) {
+          result = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.PhoneLookup.NUMBER));
+        }
+        cursor.close();
+      }
+    }
+    return result;
+  }
+
+  @Rpc(description = "Returns a List of all possible attributes for contacts.")
+  public List<String> contactsGetAttributes() {
+    List<String> result = new ArrayList<String>();
+    Cursor cursor = mContentResolver.query(CONTACTS_URI, null, null, null, null);
+    if (cursor != null) {
+      String[] columns = cursor.getColumnNames();
+      for (int i = 0; i < columns.length; i++) {
+        result.add(columns[i]);
+      }
+      cursor.close();
+    }
+    return result;
+  }
+
+  // TODO(MeanEYE.rcf): Add ability to narrow selection by providing named pairs of attributes.
+  @Rpc(description = "Returns a List of all contact IDs.")
+  public List<Integer> contactsGetIds() {
+    List<Integer> result = new ArrayList<Integer>();
+    String[] columns = { "_id" };
+    Cursor cursor = mContentResolver.query(CONTACTS_URI, columns, null, null, null);
+    if (cursor != null) {
+      while (cursor.moveToNext()) {
+        result.add(cursor.getInt(0));
+      }
+      cursor.close();
+    }
+    return result;
+  }
+
+  @Rpc(description = "Returns a List of all contacts.", returns = "a List of contacts as Maps")
+  public List<JSONObject> contactsGet(
+      @RpcParameter(name = "attributes") @RpcOptional JSONArray attributes) throws JSONException {
+    List<JSONObject> result = new ArrayList<JSONObject>();
+    String[] columns;
+    if (attributes == null || attributes.length() == 0) {
+      // In case no attributes are specified we set the default ones.
+      columns = new String[] { "_id", "name", "primary_phone", "primary_email", "type" };
+    } else {
+      // Convert selected attributes list into usable string list.
+      columns = new String[attributes.length()];
+      for (int i = 0; i < attributes.length(); i++) {
+        columns[i] = attributes.getString(i);
+      }
+    }
+    List<String> queryList = new ArrayList<String>();
+    for (String s : columns) {
+      queryList.add(s);
+    }
+    if (!queryList.contains("_id")) {
+      queryList.add("_id");
+    }
+
+    String[] query = queryList.toArray(new String[queryList.size()]);
+    Cursor cursor = mContentResolver.query(CONTACTS_URI, query, null, null, null);
+    if (cursor != null) {
+      int idIndex = cursor.getColumnIndex("_id");
+      while (cursor.moveToNext()) {
+        String id = cursor.getString(idIndex);
+        JSONObject message = new JSONObject();
+        for (int i = 0; i < columns.length; i++) {
+          String key = columns[i];
+          String value = cursor.getString(cursor.getColumnIndex(key));
+          if (mPhoneNumber != null) {
+            if (key.equals("primary_phone")) {
+              value = findPhone(id);
+            }
+          }
+          message.put(key, value);
+        }
+        result.add(message);
+      }
+      cursor.close();
+    }
+    return result;
+  }
+
+  private String findPhone(String id) {
+    String result = null;
+    if (id == null || id.equals("")) {
+      return result;
+    }
+    try {
+      if (Integer.parseInt(id) > 0) {
+        Cursor pCur =
+            mContentResolver.query(mPhoneContent, new String[] { mPhoneNumber }, mContactId
+                + " = ? and " + mPrimary + "=1", new String[] { id }, null);
+        if (pCur != null) {
+          pCur.getColumnNames();
+          while (pCur.moveToNext()) {
+            result = pCur.getString(0);
+            break;
+          }
+        }
+        pCur.close();
+      }
+    } catch (Exception e) {
+      return null;
+    }
+    return result;
+  }
+
+  @Rpc(description = "Returns contacts by ID.")
+  public JSONObject contactsGetById(@RpcParameter(name = "id") Integer id,
+      @RpcParameter(name = "attributes") @RpcOptional JSONArray attributes) throws JSONException {
+    JSONObject result = null;
+    Uri uri = buildUri(id);
+    String[] columns;
+    if (attributes == null || attributes.length() == 0) {
+      // In case no attributes are specified we set the default ones.
+      columns = new String[] { "_id", "name", "primary_phone", "primary_email", "type" };
+    } else {
+      // Convert selected attributes list into usable string list.
+      columns = new String[attributes.length()];
+      for (int i = 0; i < attributes.length(); i++) {
+        columns[i] = attributes.getString(i);
+      }
+    }
+    Cursor cursor = mContentResolver.query(uri, columns, null, null, null);
+    if (cursor != null) {
+      result = new JSONObject();
+      cursor.moveToFirst();
+      for (int i = 0; i < columns.length; i++) {
+        result.put(columns[i], cursor.getString(i));
+      }
+      cursor.close();
+    }
+    return result;
+  }
+
+  // TODO(MeanEYE.rcf): Add ability to narrow selection by providing named pairs of attributes.
+  @Rpc(description = "Returns the number of contacts.")
+  public Integer contactsGetCount() {
+    Integer result = 0;
+    Cursor cursor = mContentResolver.query(CONTACTS_URI, null, null, null, null);
+    if (cursor != null) {
+      result = cursor.getCount();
+      cursor.close();
+    }
+    return result;
+  }
+
+  private String[] jsonToArray(JSONArray array) throws JSONException {
+    String[] result = null;
+    if (array != null && array.length() > 0) {
+      result = new String[array.length()];
+      for (int i = 0; i < array.length(); i++) {
+        result[i] = array.getString(i);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Exactly as per <a href=
+   * "http://developer.android.com/reference/android/content/ContentResolver.html#query%28android.net.Uri,%20java.lang.String[],%20java.lang.String,%20java.lang.String[],%20java.lang.String%29"
+   * >ContentResolver.query</a>
+   */
+  @Rpc(description = "Content Resolver Query", returns = "result of query as Maps")
+  public List<JSONObject> queryContent(
+      @RpcParameter(name = "uri", description = "The URI, using the content:// scheme, for the content to retrieve.") String uri,
+      @RpcParameter(name = "attributes", description = "A list of which columns to return. Passing null will return all columns") @RpcOptional JSONArray attributes,
+      @RpcParameter(name = "selection", description = "A filter declaring which rows to return") @RpcOptional String selection,
+      @RpcParameter(name = "selectionArgs", description = "You may include ?s in selection, which will be replaced by the values from selectionArgs") @RpcOptional JSONArray selectionArgs,
+      @RpcParameter(name = "order", description = "How to order the rows") @RpcOptional String order)
+      throws JSONException {
+    List<JSONObject> result = new ArrayList<JSONObject>();
+    String[] columns = jsonToArray(attributes);
+    String[] args = jsonToArray(selectionArgs);
+    Cursor cursor = mContentResolver.query(Uri.parse(uri), columns, selection, args, order);
+    if (cursor != null) {
+      String[] names = cursor.getColumnNames();
+      while (cursor.moveToNext()) {
+        JSONObject message = new JSONObject();
+        for (int i = 0; i < cursor.getColumnCount(); i++) {
+          String key = names[i];
+          String value = cursor.getString(i);
+          message.put(key, value);
+        }
+        result.add(message);
+      }
+      cursor.close();
+    }
+    return result;
+  }
+
+  @Rpc(description = "Content Resolver Query Attributes", returns = "a list of available columns for a given content uri")
+  public JSONArray queryAttributes(
+      @RpcParameter(name = "uri", description = "The URI, using the content:// scheme, for the content to retrieve.") String uri)
+      throws JSONException {
+    JSONArray result = new JSONArray();
+    Cursor cursor = mContentResolver.query(Uri.parse(uri), null, "1=0", null, null);
+    if (cursor != null) {
+      String[] names = cursor.getColumnNames();
+      for (String name : names) {
+        result.put(name);
+      }
+      cursor.close();
+    }
+    return result;
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/DisplayFacade.java b/Common/src/com/googlecode/android_scripting/facade/DisplayFacade.java
new file mode 100644
index 0000000..d0c472c
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/DisplayFacade.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import java.util.HashMap;
+
+import android.app.Service;
+import android.content.Context;
+import android.graphics.Point;
+import android.hardware.display.DisplayManager;
+import android.util.DisplayMetrics;
+import android.view.Display;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class DisplayFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final DisplayManager mDisplayManager;
+    private HashMap<Integer, Display> mDisplays;
+
+    public DisplayFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mDisplayManager = (DisplayManager) mService.getSystemService(Context.DISPLAY_SERVICE);
+        updateDisplays(mDisplayManager.getDisplays());
+    }
+
+    private void updateDisplays(Display[] displays) {
+        if (mDisplays == null) {
+            mDisplays = new HashMap<Integer, Display>();
+        }
+        mDisplays.clear();
+        for(Display d : displays) {
+            mDisplays.put(d.getDisplayId(), d);
+        }
+    }
+
+    @Rpc(description = "Get a list of IDs of the logical displays connected."
+                     + "Also updates the cached displays.")
+    public Integer[] displayGetDisplays() {
+        Display[] displays = mDisplayManager.getDisplays();
+        updateDisplays(displays);
+        Integer[] results = new Integer[displays.length];
+        for(int i = 0; i < displays.length; i++) {
+            results[i] = displays[i].getDisplayId();
+        }
+        return results;
+    }
+
+    @Rpc(description = "Get the size of the specified display in pixels.")
+    public Point displayGetSize(
+            @RpcParameter(name = "displayId")
+            @RpcDefault(value = "0")
+            Integer displayId) {
+        Point outSize = new Point();
+        Display d = mDisplays.get(displayId);
+        d.getSize(outSize);
+        return outSize;
+    }
+
+    @Rpc(description = "Get the maximum screen size dimension that will happen.")
+    public Integer displayGetMaximumSizeDimension(
+            @RpcParameter(name = "displayId")
+            @RpcDefault(value = "0")
+            Integer displayId) {
+        Display d = mDisplays.get(displayId);
+        return d.getMaximumSizeDimension();
+    }
+
+    @Rpc(description = "Get display metrics based on the real size of this display.")
+    public DisplayMetrics displayGetRealMetrics(
+            @RpcParameter(name = "displayId")
+            @RpcDefault(value = "0")
+            Integer displayId) {
+        Display d = mDisplays.get(displayId);
+        DisplayMetrics outMetrics = new DisplayMetrics();
+        d.getRealMetrics(outMetrics);
+        return outMetrics;
+    }
+
+    @Override
+    public void shutdown() {
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/EventFacade.java b/Common/src/com/googlecode/android_scripting/facade/EventFacade.java
new file mode 100644
index 0000000..36e620d
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/EventFacade.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+
+import org.json.JSONException;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.event.Event;
+import com.googlecode.android_scripting.event.EventObserver;
+import com.googlecode.android_scripting.event.EventServer;
+import com.googlecode.android_scripting.future.FutureResult;
+import com.googlecode.android_scripting.jsonrpc.JsonBuilder;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcDeprecated;
+import com.googlecode.android_scripting.rpc.RpcName;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Manage the event queue. <br>
+ * <br>
+ * <b>Usage Notes:</b><br>
+ * EventFacade APIs interact with the Event Queue (a data buffer containing up to 1024 event
+ * entries).<br>
+ * Events are automatically entered into the Event Queue following API calls such as startSensing()
+ * and startLocating().<br>
+ * The Event Facade provides control over how events are entered into (and removed from) the Event
+ * Queue.<br>
+ * The Event Queue provides a useful means of recording background events (such as sensor data) when
+ * the phone is busy with foreground activities.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ */
+public class EventFacade extends RpcReceiver {
+    /**
+     * The maximum length of the event queue. Old events will be discarded when this limit is
+     * exceeded.
+     */
+    private static final int MAX_QUEUE_SIZE = 1024;
+    private final Queue<Event> mEventQueue = new ConcurrentLinkedQueue<Event>();
+    private final CopyOnWriteArrayList<EventObserver> mGlobalEventObservers =
+            new CopyOnWriteArrayList<EventObserver>();
+    private final Multimap<String, EventObserver> mNamedEventObservers = Multimaps
+            .synchronizedListMultimap(ArrayListMultimap.<String, EventObserver> create());
+    private EventServer mEventServer = null;
+    private final HashMap<String, BroadcastListener> mBroadcastListeners =
+            new HashMap<String, BroadcastListener>();
+    private final Context mContext;
+    private boolean bEventServerRunning;
+
+    public EventFacade(FacadeManager manager) {
+        super(manager);
+        mContext = manager.getService().getApplicationContext();
+        Log.v("Creating new EventFacade Instance()");
+        bEventServerRunning = false;
+    }
+
+    /**
+     * Example (python): droid.eventClearBuffer()
+     */
+    @Rpc(description = "Clears all events from the event buffer.")
+    public void eventClearBuffer() {
+        mEventQueue.clear();
+    }
+
+    /**
+     * Registers a listener for a new broadcast signal
+     */
+    @Rpc(description = "Registers a listener for a new broadcast signal")
+    public boolean eventRegisterForBroadcast(
+            @RpcParameter(name = "category") String category,
+            @RpcParameter(name = "enqueue",
+                    description = "Should this events be added to the event queue or only dispatched") @RpcDefault(value = "true") Boolean enqueue) {
+        if (mBroadcastListeners.containsKey(category)) {
+            return false;
+        }
+
+        BroadcastListener b = new BroadcastListener(this, enqueue.booleanValue());
+        IntentFilter c = new IntentFilter(category);
+        mContext.registerReceiver(b, c);
+        mBroadcastListeners.put(category, b);
+
+        return true;
+    }
+
+    @Rpc(description = "Stop listening for a broadcast signal")
+    public void eventUnregisterForBroadcast(
+            @RpcParameter(name = "category") String category) {
+        if (!mBroadcastListeners.containsKey(category)) {
+            return;
+        }
+
+        mContext.unregisterReceiver(mBroadcastListeners.get(category));
+        mBroadcastListeners.remove(category);
+    }
+
+    @Rpc(description = "Lists all the broadcast signals we are listening for")
+    public Set<String> eventGetBrodcastCategories() {
+        return mBroadcastListeners.keySet();
+    }
+
+    /**
+     * Actual data returned in the map will depend on the type of event.
+     *
+     * <pre>
+     * Example (python):
+     *     import android, time
+     *     droid = android.Android()
+     *     droid.startSensing()
+     *     time.sleep(1)
+     *     droid.eventClearBuffer()
+     *     time.sleep(1)
+     *     e = eventPoll(1).result
+     *     event_entry_number = 0
+     *     x = e[event_entry_ number]['data']['xforce']
+     * </pre>
+     *
+     * e has the format:<br>
+     * [{u'data': {u'accuracy': 0, u'pitch': -0.48766891956329345, u'xmag': -5.6875, u'azimuth':
+     * 0.3312483489513397, u'zforce': 8.3492730000000002, u'yforce': 4.5628165999999997, u'time':
+     * 1297072704.813, u'ymag': -11.125, u'zmag': -42.375, u'roll': -0.059393649548292161,
+     * u'xforce': 0.42223078000000003}, u'name': u'sensors', u'time': 1297072704813000L}]<br>
+     * x has the string value of the x force data (0.42223078000000003) at the time of the event
+     * entry. </pre>
+     */
+
+    @Rpc(description = "Returns and removes the oldest n events (i.e. location or sensor update, etc.) from the event buffer.",
+            returns = "A List of Maps of event properties.")
+    public List<Event> eventPoll(
+            @RpcParameter(name = "number_of_events") @RpcDefault("1") Integer number_of_events) {
+        List<Event> events = Lists.newArrayList();
+        for (int i = 0; i < number_of_events; i++) {
+            Event event = mEventQueue.poll();
+            if (event == null) {
+                break;
+            }
+            events.add(event);
+        }
+        return events;
+    }
+
+    @Rpc(description = "Blocks until an event with the supplied name occurs. Event is removed from the buffer if removeEvent is True.",
+            returns = "Map of event properties.")
+    public Event eventWaitFor(
+            @RpcParameter(name = "eventName")
+            final String eventName,
+            @RpcParameter(name = "removeEvent")
+            final Boolean removeEvent,
+            @RpcParameter(name = "timeout", description = "the maximum time to wait (in ms)") @RpcOptional Integer timeout)
+            throws InterruptedException {
+        Event result = null;
+        final FutureResult<Event> futureEvent;
+        synchronized (mEventQueue) { // First check to make sure it isn't already there
+            for (Event event : mEventQueue) {
+                if (event.getName().equals(eventName)) {
+                    result = event;
+                    if (removeEvent)
+                        mEventQueue.remove(event);
+                    return result;
+                }
+            }
+            futureEvent = new FutureResult<Event>();
+            addNamedEventObserver(eventName, new EventObserver() {
+                @Override
+                public void onEventReceived(Event event) {
+                    if (event.getName().equals(eventName)) {
+                        synchronized (futureEvent) {
+                            if (!futureEvent.isDone()) {
+                                futureEvent.set(event);
+                                // TODO(navtej) Remove log.
+                                Log.v(String.format("Removeing observer (%s) got event  (%s)",
+                                        this,
+                                        event));
+                                removeEventObserver(this);
+                            }
+                            if (removeEvent)
+                                mEventQueue.remove(event);
+                        }
+                    }
+                }
+            });
+        }
+        if (futureEvent != null) {
+            if (timeout != null) {
+                result = futureEvent.get(timeout, TimeUnit.MILLISECONDS);
+            } else {
+                result = futureEvent.get();
+            }
+        }
+        return result;
+    }
+
+    @Rpc(description = "Blocks until an event occurs. The returned event is removed from the buffer.",
+            returns = "Map of event properties.")
+    public Event eventWait(
+            @RpcParameter(name = "timeout", description = "the maximum time to wait") @RpcOptional Integer timeout)
+            throws InterruptedException {
+        Event result = null;
+        final FutureResult<Event> futureEvent = new FutureResult<Event>();
+        EventObserver observer;
+        synchronized (mEventQueue) { // Anything in queue?
+            if (mEventQueue.size() > 0) {
+                return mEventQueue.poll(); // return it.
+            }
+            observer = new EventObserver() {
+                @Override
+                public void onEventReceived(Event event) { // set up observer for any events.
+                    synchronized (futureEvent) {
+                        if (!futureEvent.isDone()) {
+                            futureEvent.set(event);
+                            // TODO(navtej) Remove log.
+                            Log.v(String.format("onEventReceived for event (%s)", event));
+                        }
+                    }
+                }
+            };
+            addGlobalEventObserver(observer);
+        }
+        if (timeout != null) {
+            result = futureEvent.get(timeout, TimeUnit.MILLISECONDS);
+        } else {
+            result = futureEvent.get();
+        }
+        if (result != null) {
+            mEventQueue.remove(result);
+        }
+        // TODO(navtej) Remove log.
+        Log.v(String.format("Removeing observer (%s) got event  (%s)", observer, result));
+        if (observer != null) {
+            removeEventObserver(observer); // Make quite sure this goes away.
+        }
+        return result;
+    }
+
+    /**
+     * <pre>
+     * Example:
+     *   import android
+     *   from datetime import datetime
+     *   droid = android.Android()
+     *   t = datetime.now()
+     *   droid.eventPost('Some Event', t)
+     * </pre>
+     */
+    @Rpc(description = "Post an event to the event queue.")
+    public void eventPost(
+            @RpcParameter(name = "name", description = "Name of event") String name,
+            @RpcParameter(name = "data", description = "Data contained in event.") String data,
+            @RpcParameter(name = "enqueue",
+                    description = "Set to False if you don't want your events to be added to the event queue, just dispatched.") @RpcOptional @RpcDefault("false") Boolean enqueue) {
+        postEvent(name, data, enqueue.booleanValue());
+    }
+
+    /**
+     * Post an event and queue it
+     */
+    public void postEvent(String name, Object data) {
+        postEvent(name, data, true);
+    }
+
+    /**
+     * Posts an event with to the event queue.
+     */
+    public void postEvent(String name, Object data, boolean enqueue) {
+        Event event = new Event(name, data);
+        if (enqueue != false) {
+            synchronized (mEventQueue) {
+                while (mEventQueue.size() >= MAX_QUEUE_SIZE) {
+                    mEventQueue.remove();
+                }
+                mEventQueue.add(event);
+            }
+            Log.v(String.format("postEvent(%s)", name));
+        }
+        synchronized (mNamedEventObservers) {
+            for (EventObserver observer : mNamedEventObservers.get(name)) {
+                observer.onEventReceived(event);
+            }
+        }
+        synchronized (mGlobalEventObservers) {
+            // TODO(navtej) Remove log.
+            Log.v(String.format("mGlobalEventObservers size (%s)", mGlobalEventObservers.size()));
+            for (EventObserver observer : mGlobalEventObservers) {
+                observer.onEventReceived(event);
+            }
+        }
+    }
+
+    @RpcDeprecated(value = "eventPost", release = "r4")
+    @Rpc(description = "Post an event to the event queue.")
+    @RpcName(name = "postEvent")
+    public void rpcPostEvent(
+            @RpcParameter(name = "name") String name,
+            @RpcParameter(name = "data") String data) {
+        postEvent(name, data);
+    }
+
+    @RpcDeprecated(value = "eventPoll", release = "r4")
+    @Rpc(description = "Returns and removes the oldest event (i.e. location or sensor update, etc.) from the event buffer.",
+            returns = "Map of event properties.")
+    public Event receiveEvent() {
+        return mEventQueue.poll();
+    }
+
+    @RpcDeprecated(value = "eventWaitFor", release = "r4")
+    @Rpc(description = "Blocks until an event with the supplied name occurs. Event is removed from the buffer if removeEvent is True.",
+            returns = "Map of event properties.")
+    public Event waitForEvent(
+            @RpcParameter(name = "eventName")
+            final String eventName,
+            @RpcOptional
+            final Boolean removeEvent,
+            @RpcParameter(name = "timeout", description = "the maximum time to wait") @RpcOptional Integer timeout)
+            throws InterruptedException {
+        return eventWaitFor(eventName, removeEvent, timeout);
+    }
+
+    @Rpc(description = "Opens up a socket where you can read for events posted")
+    public int startEventDispatcher(
+            @RpcParameter(name = "port", description = "Port to use") @RpcDefault("0") @RpcOptional() Integer port) {
+        if (mEventServer == null) {
+            if (port == null) {
+                port = 0;
+            }
+            mEventServer = new EventServer(port);
+            addGlobalEventObserver(mEventServer);
+            bEventServerRunning = true;
+        }
+        return mEventServer.getAddress().getPort();
+    }
+
+    @Rpc(description = "sl4a session is shutting down, send terminate event to client.")
+    public void closeSl4aSession() {
+        eventClearBuffer();
+        postEvent("EventDispatcherShutdown", null);
+    }
+
+    @Rpc(description = "Stops the event server, you can't read in the port anymore")
+    public void stopEventDispatcher() throws RuntimeException {
+        if (bEventServerRunning == true) {
+            if (mEventServer == null) {
+                throw new RuntimeException("Not running");
+            }
+            bEventServerRunning = false;
+            mEventServer.shutdown();
+            Log.v(String.format("stopEventDispatcher   (%s)", mEventServer));
+            removeEventObserver(mEventServer);
+            mEventServer = null;
+        }
+        return;
+    }
+
+    @Override
+    public void shutdown() {
+
+        try {
+            stopEventDispatcher();
+        } catch (Exception e) {
+            Log.e("Exception tearing down event dispatcher", e);
+        }
+        mGlobalEventObservers.clear();
+        mEventQueue.clear();
+    }
+
+    public void addNamedEventObserver(String eventName, EventObserver observer) {
+        mNamedEventObservers.put(eventName, observer);
+    }
+
+    public void addGlobalEventObserver(EventObserver observer) {
+        mGlobalEventObservers.add(observer);
+    }
+
+    public void removeEventObserver(EventObserver observer) {
+        mNamedEventObservers.removeAll(observer);
+        mGlobalEventObservers.remove(observer);
+    }
+
+    public class BroadcastListener extends android.content.BroadcastReceiver {
+        private EventFacade mParent;
+        private boolean mEnQueue;
+
+        public BroadcastListener(EventFacade parent, boolean enqueue) {
+            mParent = parent;
+            mEnQueue = enqueue;
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            Bundle data;
+            if (intent.getExtras() != null) {
+                data = (Bundle) intent.getExtras().clone();
+            } else {
+                data = new Bundle();
+            }
+            data.putString("action", intent.getAction());
+            try {
+                mParent.eventPost("sl4a", JsonBuilder.build(data).toString(), mEnQueue);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/FacadeManager.java b/Common/src/com/googlecode/android_scripting/facade/FacadeManager.java
new file mode 100644
index 0000000..90de7f9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/FacadeManager.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.exception.Sl4aException;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
+import com.googlecode.android_scripting.rpc.RpcDeprecated;
+import com.googlecode.android_scripting.rpc.RpcMinSdk;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collection;
+
+public class FacadeManager extends RpcReceiverManager {
+
+  private final Service mService;
+  private final Intent mIntent;
+  private int mSdkLevel;
+
+  public FacadeManager(int sdkLevel, Service service, Intent intent,
+      Collection<Class<? extends RpcReceiver>> classList) {
+    super(classList);
+    mSdkLevel = sdkLevel;
+    mService = service;
+    mIntent = intent;
+  }
+
+  public int getSdkLevel() {
+    return mSdkLevel;
+  }
+
+  public Service getService() {
+    return mService;
+  }
+
+  public Intent getIntent() {
+    return mIntent;
+  }
+
+  @Override
+  public Object invoke(Class<? extends RpcReceiver> clazz, Method method, Object[] args)
+      throws Exception {
+    try {
+      if (method.isAnnotationPresent(RpcDeprecated.class)) {
+        String replacedBy = method.getAnnotation(RpcDeprecated.class).value();
+        String title = method.getName() + " is deprecated";
+        Log.notify(mService, title, title, String.format("Please use %s instead.", replacedBy));
+      } else if (method.isAnnotationPresent(RpcMinSdk.class)) {
+        int requiredSdkLevel = method.getAnnotation(RpcMinSdk.class).value();
+        if (mSdkLevel < requiredSdkLevel) {
+          throw new Sl4aException(String.format("%s requires API level %d, current level is %d",
+              method.getName(), requiredSdkLevel, mSdkLevel));
+        }
+      }
+      return super.invoke(clazz, method, args);
+    } catch (InvocationTargetException e) {
+      if (e.getCause() instanceof SecurityException) {
+        Log.notify(mService, "RPC invoke failed...", mService.getPackageName(), e.getCause()
+            .getMessage());
+      }
+      throw e;
+    }
+  }
+
+  public AndroidFacade.Resources getAndroidFacadeResources() {
+    return new AndroidFacade.Resources() {
+      @Override
+      public int getLogo48() {
+        // TODO(Alexey): As an alternative, ask application for resource ids.
+        String packageName = mService.getApplication().getPackageName();
+        return mService.getResources().getIdentifier("script_logo_48", "drawable", packageName);
+      }
+    };
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/FacadeManagerFactory.java b/Common/src/com/googlecode/android_scripting/facade/FacadeManagerFactory.java
new file mode 100644
index 0000000..e436d03
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/FacadeManagerFactory.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManagerFactory;
+
+import java.util.HashMap;
+import java.util.Collection;
+import java.util.Map;
+
+public class FacadeManagerFactory implements RpcReceiverManagerFactory {
+
+  private final int mSdkLevel;
+  private final Service mService;
+  private final Intent mIntent;
+  private final Collection<Class<? extends RpcReceiver>> mClassList;
+  private final Map<Integer, RpcReceiverManager> mFacadeManagers;
+
+  public FacadeManagerFactory(int sdkLevel, Service service, Intent intent,
+      Collection<Class<? extends RpcReceiver>> classList) {
+    mSdkLevel = sdkLevel;
+    mService = service;
+    mIntent = intent;
+    mClassList = classList;
+    mFacadeManagers = new HashMap<Integer, RpcReceiverManager>();
+  }
+
+  @Override
+  public FacadeManager create(Integer UID) {
+    FacadeManager facadeManager = new FacadeManager(mSdkLevel, mService, mIntent, mClassList);
+    mFacadeManagers.put(UID, facadeManager);
+    return facadeManager;
+  }
+
+  @Override
+  public Map<Integer, RpcReceiverManager> getRpcReceiverManagers() {
+    return mFacadeManagers;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/LocationFacade.java b/Common/src/com/googlecode/android_scripting/facade/LocationFacade.java
new file mode 100644
index 0000000..eed244e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/LocationFacade.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.Context;
+import android.location.Address;
+import android.location.Geocoder;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Bundle;
+
+import com.google.common.collect.Maps;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.rpc.RpcStartEvent;
+import com.googlecode.android_scripting.rpc.RpcStopEvent;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * This facade exposes the LocationManager related functionality.<br>
+ * <br>
+ * <b>Overview</b><br>
+ * Once activated by 'startLocating' the LocationFacade attempts to return location data collected
+ * via GPS or the cell network. If neither are available the last known location may be retrieved.
+ * If both are available the format of the returned data is:<br>
+ * {u'network': {u'altitude': 0, u'provider': u'network', u'longitude': -0.38509020000000002,
+ * u'time': 1297079691231L, u'latitude': 52.410557300000001, u'speed': 0, u'accuracy': 75}, u'gps':
+ * {u'altitude': 51, u'provider': u'gps', u'longitude': -0.38537094593048096, u'time':
+ * 1297079709000L, u'latitude': 52.41076922416687, u'speed': 0, u'accuracy': 24}}<br>
+ * If neither are available {} is returned. <br>
+ * Example (python):<br>
+ *
+ * <pre>
+ * import android, time
+ * droid = android.Android()
+ * droid.startLocating()
+ * time.sleep(15)
+ * loc = droid.readLocation().result
+ * if loc = {}:
+ *   loc = getLastKnownLocation().result
+ * if loc != {}:
+ *   try:
+ *     n = loc['gps']
+ *   except KeyError:
+ *     n = loc['network']
+ *   la = n['latitude']
+ *   lo = n['longitude']
+ *   address = droid.geocode(la, lo).result
+ * droid.stopLocating()
+ * </pre>
+ *
+ * The address format is:<br>
+ * [{u'thoroughfare': u'Some Street', u'locality': u'Some Town', u'sub_admin_area': u'Some Borough',
+ * u'admin_area': u'Some City', u'feature_name': u'House Numbers', u'country_code': u'GB',
+ * u'country_name': u'United Kingdom', u'postal_code': u'ST1 1'}]
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Felix Arends (felix.arends@gmail.com)
+ */
+public class LocationFacade extends RpcReceiver {
+  private final EventFacade mEventFacade;
+  private final Service mService;
+  private final Map<String, Location> mLocationUpdates;
+  private final LocationManager mLocationManager;
+  private final Geocoder mGeocoder;
+
+  private final LocationListener mLocationListener = new LocationListener() {
+    @Override
+    public synchronized void onLocationChanged(Location location) {
+      mLocationUpdates.put(location.getProvider(), location);
+      Map<String, Location> copy = Maps.newHashMap();
+      for (Entry<String, Location> entry : mLocationUpdates.entrySet()) {
+        copy.put(entry.getKey(), entry.getValue());
+      }
+      mEventFacade.postEvent("location", copy);
+    }
+
+    @Override
+    public void onProviderDisabled(String provider) {
+    }
+
+    @Override
+    public void onProviderEnabled(String provider) {
+    }
+
+    @Override
+    public void onStatusChanged(String provider, int status, Bundle extras) {
+    }
+  };
+
+  public LocationFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mEventFacade = manager.getReceiver(EventFacade.class);
+    mGeocoder = new Geocoder(mService);
+    mLocationManager = (LocationManager) mService.getSystemService(Context.LOCATION_SERVICE);
+    mLocationUpdates = new HashMap<String, Location>();
+  }
+
+  @Override
+  public void shutdown() {
+    stopLocating();
+  }
+
+  @Rpc(description = "Returns availables providers on the phone")
+  public List<String> locationProviders() {
+    return mLocationManager.getAllProviders();
+  }
+
+  @Rpc(description = "Ask if provider is enabled")
+  public boolean locationProviderEnabled(
+      @RpcParameter(name = "provider", description = "Name of location provider") String provider) {
+    return mLocationManager.isProviderEnabled(provider);
+  }
+
+  @Rpc(description = "Starts collecting location data.")
+  @RpcStartEvent("location")
+  public void startLocating(
+      @RpcParameter(name = "minDistance", description = "minimum time between updates in milliseconds") @RpcDefault("60000") Integer minUpdateTime,
+      @RpcParameter(name = "minUpdateDistance", description = "minimum distance between updates in meters") @RpcDefault("30") Integer minUpdateDistance) {
+    for (String provider : mLocationManager.getAllProviders()) {
+      mLocationManager.requestLocationUpdates(provider, minUpdateTime, minUpdateDistance,
+          mLocationListener, mService.getMainLooper());
+    }
+  }
+
+  @Rpc(description = "Returns the current location as indicated by all available providers.", returns = "A map of location information by provider.")
+  public Map<String, Location> readLocation() {
+    return mLocationUpdates;
+  }
+
+  @Rpc(description = "Stops collecting location data.")
+  @RpcStopEvent("location")
+  public synchronized void stopLocating() {
+    mLocationManager.removeUpdates(mLocationListener);
+    mLocationUpdates.clear();
+  }
+
+  @Rpc(description = "Returns the last known location of the device.", returns = "A map of location information by provider.")
+  public Map<String, Location> getLastKnownLocation() {
+    Map<String, Location> location = new HashMap<String, Location>();
+    for (String provider : mLocationManager.getAllProviders()) {
+      location.put(provider, mLocationManager.getLastKnownLocation(provider));
+    }
+    return location;
+  }
+
+  @Rpc(description = "Returns a list of addresses for the given latitude and longitude.", returns = "A list of addresses.")
+  public List<Address> geocode(
+      @RpcParameter(name = "latitude") Double latitude,
+      @RpcParameter(name = "longitude") Double longitude,
+      @RpcParameter(name = "maxResults", description = "maximum number of results") @RpcDefault("1") Integer maxResults)
+      throws IOException {
+    return mGeocoder.getFromLocation(latitude, longitude, maxResults);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/PreferencesFacade.java b/Common/src/com/googlecode/android_scripting/facade/PreferencesFacade.java
new file mode 100644
index 0000000..31225ff
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/PreferencesFacade.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.Service;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.preference.PreferenceManager;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * This facade allows access to the Preferences interface.
+ *
+ * <br>
+ * <b>Notes:</b> <br>
+ * <b>filename</b> - Filename indicates which preference file to refer to. If no filename is
+ * supplied (the default) then the SharedPreferences uses is the default for the SL4A application.<br>
+ * <b>prefPutValue</b> - uses "MODE_PRIVATE" when writing to preferences. Save values to the default
+ * shared preferences is explicitly disallowed.<br>
+ * <br>
+ * See <a
+ * href=http://developer.android.com/reference/java/util/prefs/Preferences.html>Preferences</a> and
+ * <a href=http://developer.android.com/guide/topics/data/data-storage.html#pref>Shared
+ * Preferences</a> in the android documentation on how preferences work.
+ *
+ * @author Robbie Matthews (rjmatthews62@gmail.com)
+ */
+
+public class PreferencesFacade extends RpcReceiver {
+
+  private Service mService;
+
+  public PreferencesFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+  }
+
+  @Rpc(description = "Read a value from shared preferences")
+  public Object prefGetValue(
+      @RpcParameter(name = "key") String key,
+      @RpcParameter(name = "filename", description = "Desired preferences file. If not defined, uses the default Shared Preferences.") @RpcOptional String filename) {
+    SharedPreferences p = getPref(filename);
+    return p.getAll().get(key);
+  }
+
+  @Rpc(description = "Write a value to shared preferences")
+  public void prefPutValue(
+      @RpcParameter(name = "key") String key,
+      @RpcParameter(name = "value") Object value,
+      @RpcParameter(name = "filename", description = "Desired preferences file. If not defined, uses the default Shared Preferences.") @RpcOptional String filename)
+      throws IOException {
+    if (filename == null || filename.equals("")) {
+      throw new IOException("Can't write to default preferences.");
+    }
+    SharedPreferences p = getPref(filename);
+    Editor e = p.edit();
+    if (value instanceof Boolean) {
+      e.putBoolean(key, (Boolean) value);
+    } else if (value instanceof Long) {
+      e.putLong(key, (Long) value);
+    } else if (value instanceof Integer) {
+      e.putLong(key, (Integer) value);
+    } else if (value instanceof Float) {
+      e.putFloat(key, (Float) value);
+    } else if (value instanceof Double) { // TODO: Not sure if this is a good idea
+      e.putFloat(key, ((Double) value).floatValue());
+    } else {
+      e.putString(key, value.toString());
+    }
+    e.commit();
+  }
+
+  @Rpc(description = "Get list of Shared Preference Values", returns = "Map of key,value")
+  public Map<String, ?> prefGetAll(
+      @RpcParameter(name = "filename", description = "Desired preferences file. If not defined, uses the default Shared Preferences.") @RpcOptional String filename) {
+    return getPref(filename).getAll();
+  }
+
+  private SharedPreferences getPref(String filename) {
+    if (filename == null || filename.equals("")) {
+      return PreferenceManager.getDefaultSharedPreferences(mService);
+    }
+    return mService.getSharedPreferences(filename, 0);
+
+  }
+
+  @Override
+  public void shutdown() {
+
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/SensorManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/SensorManagerFacade.java
new file mode 100644
index 0000000..6c4c7b7
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/SensorManagerFacade.java
@@ -0,0 +1,496 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Bundle;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcDeprecated;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.rpc.RpcStartEvent;
+import com.googlecode.android_scripting.rpc.RpcStopEvent;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Exposes the SensorManager related functionality. <br>
+ * <br>
+ * <b>Guidance notes</b> <br>
+ * For reasons of economy the sensors on smart phones are usually low cost and, therefore, low
+ * accuracy (usually represented by 10 bit data). The floating point data values obtained from
+ * sensor readings have up to 16 decimal places, the majority of which are noise. On many phones the
+ * accelerometer is limited (by the phone manufacturer) to a maximum reading of 2g. The magnetometer
+ * (which also provides orientation readings) is strongly affected by the presence of ferrous metals
+ * and can give large errors in vehicles, on board ship etc.
+ *
+ * Following a startSensingTimed(A,B) api call sensor events are entered into the Event Queue (see
+ * EventFacade). For the A parameter: 1 = All Sensors, 2 = Accelerometer, 3 = Magnetometer and 4 =
+ * Light. The B parameter is the minimum delay between recordings in milliseconds. To avoid
+ * duplicate readings the minimum delay should be 20 milliseconds. The light sensor will probably be
+ * much slower (taking about 1 second to register a change in light level). Note that if the light
+ * level is constant no sensor events will be registered by the light sensor.
+ *
+ * Following a startSensingThreshold(A,B,C) api call sensor events greater than a given threshold
+ * are entered into the Event Queue. For the A parameter: 1 = Orientation, 2 = Accelerometer, 3 =
+ * Magnetometer and 4 = Light. The B parameter is the integer value of the required threshold level.
+ * For orientation sensing the integer threshold value is in milliradians. Since orientation events
+ * can exceed the threshold value for long periods only crossing and return events are recorded. The
+ * C parameter is the required axis (XYZ) of the sensor: 0 = No axis, 1 = X, 2 = Y, 3 = X+Y, 4 = Z,
+ * 5= X+Z, 6 = Y+Z, 7 = X+Y+Z. For orientation X = azimuth, Y = pitch and Z = roll. <br>
+ *
+ * <br>
+ * <b>Example (python)</b>
+ *
+ * <pre>
+ * import android, time
+ * droid = android.Android()
+ * droid.startSensingTimed(1, 250)
+ * time.sleep(1)
+ * s1 = droid.readSensors().result
+ * s2 = droid.sensorsGetAccuracy().result
+ * s3 = droid.sensorsGetLight().result
+ * s4 = droid.sensorsReadAccelerometer().result
+ * s5 = droid.sensorsReadMagnetometer().result
+ * s6 = droid.sensorsReadOrientation().result
+ * droid.stopSensing()
+ * </pre>
+ *
+ * Returns:<br>
+ * s1 = {u'accuracy': 3, u'pitch': -0.47323511242866517, u'xmag': 1.75, u'azimuth':
+ * -0.26701245009899138, u'zforce': 8.4718560000000007, u'yforce': 4.2495484000000001, u'time':
+ * 1297160391.2820001, u'ymag': -8.9375, u'zmag': -41.0625, u'roll': -0.031366908922791481,
+ * u'xforce': 0.23154590999999999}<br>
+ * s2 = 3 (Highest accuracy)<br>
+ * s3 = None ---(not available on many phones)<br>
+ * s4 = [0.23154590999999999, 4.2495484000000001, 8.4718560000000007] ----(x, y, z accelerations)<br>
+ * s5 = [1.75, -8.9375, -41.0625] -----(x, y, z magnetic readings)<br>
+ * s6 = [-0.26701245009899138, -0.47323511242866517, -0.031366908922791481] ---(azimuth, pitch, roll
+ * in radians)<br>
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Felix Arends (felix.arends@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ * @author Robbie Mathews (rjmatthews62@gmail.com)
+ * @author John Karwatzki (jokar49@gmail.com)
+ */
+public class SensorManagerFacade extends RpcReceiver {
+  private final EventFacade mEventFacade;
+  private final SensorManager mSensorManager;
+
+  private volatile Bundle mSensorReadings;
+
+  private volatile Integer mAccuracy;
+  private volatile Integer mSensorNumber;
+  private volatile Integer mXAxis = 0;
+  private volatile Integer mYAxis = 0;
+  private volatile Integer mZAxis = 0;
+  private volatile Integer mThreshing = 0;
+  private volatile Integer mThreshOrientation = 0;
+  private volatile Integer mXCrossed = 0;
+  private volatile Integer mYCrossed = 0;
+  private volatile Integer mZCrossed = 0;
+
+  private volatile Float mThreshold;
+  private volatile Float mXForce;
+  private volatile Float mYForce;
+  private volatile Float mZForce;
+
+  private volatile Float mXMag;
+  private volatile Float mYMag;
+  private volatile Float mZMag;
+
+  private volatile Float mLight;
+
+  private volatile Double mAzimuth;
+  private volatile Double mPitch;
+  private volatile Double mRoll;
+
+  private volatile Long mLastTime;
+  private volatile Long mDelayTime;
+
+  private SensorEventListener mSensorListener;
+
+  public SensorManagerFacade(FacadeManager manager) {
+    super(manager);
+    mEventFacade = manager.getReceiver(EventFacade.class);
+    mSensorManager = (SensorManager) manager.getService().getSystemService(Context.SENSOR_SERVICE);
+  }
+
+  @Rpc(description = "Starts recording sensor data to be available for polling.")
+  @RpcStartEvent("sensors")
+  public void startSensingTimed(
+      @RpcParameter(name = "sensorNumber", description = "1 = All, 2 = Accelerometer, 3 = Magnetometer and 4 = Light") Integer sensorNumber,
+      @RpcParameter(name = "delayTime", description = "Minimum time between readings in milliseconds") Integer delayTime) {
+    mSensorNumber = sensorNumber;
+    if (delayTime < 20) {
+      delayTime = 20;
+    }
+    mDelayTime = (long) (delayTime);
+    mLastTime = System.currentTimeMillis();
+    if (mSensorListener == null) {
+      mSensorListener = new SensorValuesCollector();
+      mSensorReadings = new Bundle();
+      switch (mSensorNumber) {
+      case 1:
+        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_ALL)) {
+          mSensorManager.registerListener(mSensorListener, sensor,
+              SensorManager.SENSOR_DELAY_FASTEST);
+        }
+        break;
+      case 2:
+        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER)) {
+          mSensorManager.registerListener(mSensorListener, sensor,
+              SensorManager.SENSOR_DELAY_FASTEST);
+        }
+        break;
+      case 3:
+        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_MAGNETIC_FIELD)) {
+          mSensorManager.registerListener(mSensorListener, sensor,
+              SensorManager.SENSOR_DELAY_FASTEST);
+        }
+        break;
+      case 4:
+        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_LIGHT)) {
+          mSensorManager.registerListener(mSensorListener, sensor,
+              SensorManager.SENSOR_DELAY_FASTEST);
+        }
+      }
+    }
+  }
+
+  @Rpc(description = "Records to the Event Queue sensor data exceeding a chosen threshold.")
+  @RpcStartEvent("threshold")
+  public void startSensingThreshold(
+
+      @RpcParameter(name = "sensorNumber", description = "1 = Orientation, 2 = Accelerometer, 3 = Magnetometer and 4 = Light") Integer sensorNumber,
+      @RpcParameter(name = "threshold", description = "Threshold level for chosen sensor (integer)") Integer threshold,
+      @RpcParameter(name = "axis", description = "0 = No axis, 1 = X, 2 = Y, 3 = X+Y, 4 = Z, 5= X+Z, 6 = Y+Z, 7 = X+Y+Z") Integer axis) {
+    mSensorNumber = sensorNumber;
+    mXAxis = axis & 1;
+    mYAxis = axis & 2;
+    mZAxis = axis & 4;
+    if (mSensorNumber == 1) {
+      mThreshing = 0;
+      mThreshOrientation = 1;
+      mThreshold = ((float) threshold) / ((float) 1000);
+    } else {
+      mThreshing = 1;
+      mThreshold = (float) threshold;
+    }
+    startSensingTimed(mSensorNumber, 20);
+  }
+
+  @Rpc(description = "Returns the most recently recorded sensor data.")
+  public Bundle readSensors() {
+    if (mSensorReadings == null) {
+      return null;
+    }
+    synchronized (mSensorReadings) {
+      return new Bundle(mSensorReadings);
+    }
+  }
+
+  @Rpc(description = "Stops collecting sensor data.")
+  @RpcStopEvent("sensors")
+  public void stopSensing() {
+    mSensorManager.unregisterListener(mSensorListener);
+    mSensorListener = null;
+    mSensorReadings = null;
+    mThreshing = 0;
+    mThreshOrientation = 0;
+  }
+
+  @Rpc(description = "Returns the most recently received accuracy value.")
+  public Integer sensorsGetAccuracy() {
+    return mAccuracy;
+  }
+
+  @Rpc(description = "Returns the most recently received light value.")
+  public Float sensorsGetLight() {
+    return mLight;
+  }
+
+  @Rpc(description = "Returns the most recently received accelerometer values.", returns = "a List of Floats [(acceleration on the) X axis, Y axis, Z axis].")
+  public List<Float> sensorsReadAccelerometer() {
+    synchronized (mSensorReadings) {
+      return Arrays.asList(mXForce, mYForce, mZForce);
+    }
+  }
+
+  @Rpc(description = "Returns the most recently received magnetic field values.", returns = "a List of Floats [(magnetic field value for) X axis, Y axis, Z axis].")
+  public List<Float> sensorsReadMagnetometer() {
+    synchronized (mSensorReadings) {
+      return Arrays.asList(mXMag, mYMag, mZMag);
+    }
+  }
+
+  @Rpc(description = "Returns the most recently received orientation values.", returns = "a List of Doubles [azimuth, pitch, roll].")
+  public List<Double> sensorsReadOrientation() {
+    synchronized (mSensorReadings) {
+      return Arrays.asList(mAzimuth, mPitch, mRoll);
+    }
+  }
+
+  @Rpc(description = "Starts recording sensor data to be available for polling.")
+  @RpcDeprecated(value = "startSensingTimed or startSensingThreshhold", release = "4")
+  public void startSensing(
+      @RpcParameter(name = "sampleSize", description = "number of samples for calculating average readings") @RpcDefault("5") Integer sampleSize) {
+    if (mSensorListener == null) {
+      startSensingTimed(1, 220);
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    stopSensing();
+  }
+
+  private class SensorValuesCollector implements SensorEventListener {
+    private final static int MATRIX_SIZE = 9;
+
+    private final RollingAverage mmAzimuth;
+    private final RollingAverage mmPitch;
+    private final RollingAverage mmRoll;
+
+    private float[] mmGeomagneticValues;
+    private float[] mmGravityValues;
+    private float[] mmR;
+    private float[] mmOrientation;
+
+    public SensorValuesCollector() {
+      mmAzimuth = new RollingAverage();
+      mmPitch = new RollingAverage();
+      mmRoll = new RollingAverage();
+    }
+
+    private void postEvent() {
+      mSensorReadings.putDouble("time", System.currentTimeMillis() / 1000.0);
+      mEventFacade.postEvent("sensors", mSensorReadings.clone());
+    }
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+      if (mSensorReadings == null) {
+        return;
+      }
+      synchronized (mSensorReadings) {
+        mSensorReadings.putInt("accuracy", accuracy);
+        mAccuracy = accuracy;
+
+      }
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+      if (mSensorReadings == null) {
+        return;
+      }
+      synchronized (mSensorReadings) {
+        switch (event.sensor.getType()) {
+        case Sensor.TYPE_ACCELEROMETER:
+          mXForce = event.values[0];
+          mYForce = event.values[1];
+          mZForce = event.values[2];
+          if (mThreshing == 0) {
+            mSensorReadings.putFloat("xforce", mXForce);
+            mSensorReadings.putFloat("yforce", mYForce);
+            mSensorReadings.putFloat("zforce", mZForce);
+            if ((mSensorNumber == 2) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
+              mLastTime = System.currentTimeMillis();
+              postEvent();
+            }
+          }
+          if ((mThreshing == 1) && (mSensorNumber == 2)) {
+            if ((Math.abs(mXForce) > mThreshold) && (mXAxis == 1)) {
+              mSensorReadings.putFloat("xforce", mXForce);
+              postEvent();
+            }
+
+            if ((Math.abs(mYForce) > mThreshold) && (mYAxis == 2)) {
+              mSensorReadings.putFloat("yforce", mYForce);
+              postEvent();
+            }
+
+            if ((Math.abs(mZForce) > mThreshold) && (mZAxis == 4)) {
+              mSensorReadings.putFloat("zforce", mZForce);
+              postEvent();
+            }
+          }
+
+          mmGravityValues = event.values.clone();
+          break;
+        case Sensor.TYPE_MAGNETIC_FIELD:
+          mXMag = event.values[0];
+          mYMag = event.values[1];
+          mZMag = event.values[2];
+          if (mThreshing == 0) {
+            mSensorReadings.putFloat("xMag", mXMag);
+            mSensorReadings.putFloat("yMag", mYMag);
+            mSensorReadings.putFloat("zMag", mZMag);
+            if ((mSensorNumber == 3) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
+              mLastTime = System.currentTimeMillis();
+              postEvent();
+            }
+          }
+          if ((mThreshing == 1) && (mSensorNumber == 3)) {
+            if ((Math.abs(mXMag) > mThreshold) && (mXAxis == 1)) {
+              mSensorReadings.putFloat("xforce", mXMag);
+              postEvent();
+            }
+            if ((Math.abs(mYMag) > mThreshold) && (mYAxis == 2)) {
+              mSensorReadings.putFloat("yforce", mYMag);
+              postEvent();
+            }
+            if ((Math.abs(mZMag) > mThreshold) && (mZAxis == 4)) {
+              mSensorReadings.putFloat("zforce", mZMag);
+              postEvent();
+            }
+          }
+          mmGeomagneticValues = event.values.clone();
+          break;
+        case Sensor.TYPE_LIGHT:
+          mLight = event.values[0];
+          if (mThreshing == 0) {
+            mSensorReadings.putFloat("light", mLight);
+            if ((mSensorNumber == 4) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
+              mLastTime = System.currentTimeMillis();
+              postEvent();
+            }
+          }
+          if ((mThreshing == 1) && (mSensorNumber == 4)) {
+            if (mLight > mThreshold) {
+              mSensorReadings.putFloat("light", mLight);
+              postEvent();
+            }
+          }
+          break;
+
+        }
+        if (mSensorNumber == 1) {
+          if (mmGeomagneticValues != null && mmGravityValues != null) {
+            if (mmR == null) {
+              mmR = new float[MATRIX_SIZE];
+            }
+            if (SensorManager.getRotationMatrix(mmR, null, mmGravityValues, mmGeomagneticValues)) {
+              if (mmOrientation == null) {
+                mmOrientation = new float[3];
+              }
+              SensorManager.getOrientation(mmR, mmOrientation);
+              mmAzimuth.add(mmOrientation[0]);
+              mmPitch.add(mmOrientation[1]);
+              mmRoll.add(mmOrientation[2]);
+
+              mAzimuth = mmAzimuth.get();
+              mPitch = mmPitch.get();
+              mRoll = mmRoll.get();
+              if (mThreshOrientation == 0) {
+                mSensorReadings.putDouble("azimuth", mAzimuth);
+                mSensorReadings.putDouble("pitch", mPitch);
+                mSensorReadings.putDouble("roll", mRoll);
+                if ((mSensorNumber == 1) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
+                  mLastTime = System.currentTimeMillis();
+                  postEvent();
+                }
+              }
+              if ((mThreshOrientation == 1) && (mSensorNumber == 1)) {
+                if ((mXAxis == 1) && (mXCrossed == 0)) {
+                  if (Math.abs(mAzimuth) > ((double) mThreshold)) {
+                    mSensorReadings.putDouble("azimuth", mAzimuth);
+                    postEvent();
+                    mXCrossed = 1;
+                  }
+                }
+                if ((mXAxis == 1) && (mXCrossed == 1)) {
+                  if (Math.abs(mAzimuth) < ((double) mThreshold)) {
+                    mSensorReadings.putDouble("azimuth", mAzimuth);
+                    postEvent();
+                    mXCrossed = 0;
+                  }
+                }
+                if ((mYAxis == 2) && (mYCrossed == 0)) {
+                  if (Math.abs(mPitch) > ((double) mThreshold)) {
+                    mSensorReadings.putDouble("pitch", mPitch);
+                    postEvent();
+                    mYCrossed = 1;
+                  }
+                }
+                if ((mYAxis == 2) && (mYCrossed == 1)) {
+                  if (Math.abs(mPitch) < ((double) mThreshold)) {
+                    mSensorReadings.putDouble("pitch", mPitch);
+                    postEvent();
+                    mYCrossed = 0;
+                  }
+                }
+                if ((mZAxis == 4) && (mZCrossed == 0)) {
+                  if (Math.abs(mRoll) > ((double) mThreshold)) {
+                    mSensorReadings.putDouble("roll", mRoll);
+                    postEvent();
+                    mZCrossed = 1;
+                  }
+                }
+                if ((mZAxis == 4) && (mZCrossed == 1)) {
+                  if (Math.abs(mRoll) < ((double) mThreshold)) {
+                    mSensorReadings.putDouble("roll", mRoll);
+                    postEvent();
+                    mZCrossed = 0;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  static class RollingAverage {
+    private final int mmSampleSize;
+    private final double mmData[];
+    private int mmIndex = 0;
+    private boolean mmFilled = false;
+    private double mmSum = 0.0;
+
+    public RollingAverage() {
+      mmSampleSize = 5;
+      mmData = new double[mmSampleSize];
+    }
+
+    public void add(double value) {
+      mmSum -= mmData[mmIndex];
+      mmData[mmIndex] = value;
+      mmSum += mmData[mmIndex];
+      ++mmIndex;
+      mmIndex %= mmSampleSize;
+      mmFilled = (!mmFilled) ? mmIndex == 0 : mmFilled;
+    }
+
+    public double get() throws IllegalStateException {
+      if (!mmFilled && mmIndex == 0) {
+        throw new IllegalStateException("No values to average.");
+      }
+      return (mmFilled) ? (mmSum / mmSampleSize) : (mmSum / mmIndex);
+    }
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/SettingsFacade.java b/Common/src/com/googlecode/android_scripting/facade/SettingsFacade.java
new file mode 100644
index 0000000..42e2fd9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/SettingsFacade.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.app.AlarmManager;
+import android.app.Service;
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.os.PowerManager;
+import android.os.SystemClock;
+import android.os.UserHandle;
+import android.provider.Settings.SettingNotFoundException;
+import android.view.WindowManager;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.FutureActivityTaskExecutor;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Exposes phone settings functionality.
+ *
+ * @author Frank Spychalski (frank.spychalski@gmail.com)
+ */
+public class SettingsFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final AndroidFacade mAndroidFacade;
+    private final AudioManager mAudio;
+    private final PowerManager mPower;
+    private final AlarmManager mAlarm;
+    private final LockPatternUtils mLockPatternUtils;
+
+    /**
+     * Creates a new SettingsFacade.
+     *
+     * @param service is the {@link Context} the APIs will run under
+     */
+    public SettingsFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mAndroidFacade = manager.getReceiver(AndroidFacade.class);
+        mAudio = (AudioManager) mService.getSystemService(Context.AUDIO_SERVICE);
+        mPower = (PowerManager) mService.getSystemService(Context.POWER_SERVICE);
+        mAlarm = (AlarmManager) mService.getSystemService(Context.ALARM_SERVICE);
+        mLockPatternUtils = new LockPatternUtils(mService);
+    }
+
+    @Rpc(description = "Sets the screen timeout to this number of seconds.",
+            returns = "The original screen timeout.")
+    public Integer setScreenTimeout(@RpcParameter(name = "value") Integer value) {
+        Integer oldValue = getScreenTimeout();
+        android.provider.Settings.System.putInt(mService.getContentResolver(),
+                android.provider.Settings.System.SCREEN_OFF_TIMEOUT, value * 1000);
+        return oldValue;
+    }
+
+    @Rpc(description = "Returns the current screen timeout in seconds.",
+            returns = "the current screen timeout in seconds.")
+    public Integer getScreenTimeout() {
+        try {
+            return android.provider.Settings.System.getInt(mService.getContentResolver(),
+                    android.provider.Settings.System.SCREEN_OFF_TIMEOUT) / 1000;
+        } catch (SettingNotFoundException e) {
+            return 0;
+        }
+    }
+
+    @Rpc(description = "Checks the ringer silent mode setting.",
+            returns = "True if ringer silent mode is enabled.")
+    public Boolean checkRingerSilentMode() {
+        return mAudio.getRingerMode() == AudioManager.RINGER_MODE_SILENT;
+    }
+
+    @Rpc(description = "Toggles ringer silent mode on and off.",
+            returns = "True if ringer silent mode is enabled.")
+    public Boolean toggleRingerSilentMode(
+            @RpcParameter(name = "enabled") @RpcOptional Boolean enabled) {
+        if (enabled == null) {
+            enabled = !checkRingerSilentMode();
+        }
+        mAudio.setRingerMode(enabled ? AudioManager.RINGER_MODE_SILENT
+                : AudioManager.RINGER_MODE_NORMAL);
+        return enabled;
+    }
+
+    @Rpc(description = "Set the ringer to a specified mode")
+    public void setRingerMode(@RpcParameter(name = "mode") Integer mode) throws Exception {
+        if (AudioManager.isValidRingerMode(mode)) {
+            mAudio.setRingerMode(mode);
+        } else {
+            throw new Exception("Ringer mode " + mode + " does not exist.");
+        }
+    }
+
+    @Rpc(description = "Returns the current ringtone mode.",
+            returns = "An integer representing the current ringer mode")
+    public Integer getRingerMode() {
+        return mAudio.getRingerMode();
+    }
+
+    @Rpc(description = "Returns the maximum ringer volume.")
+    public int getMaxRingerVolume() {
+        return mAudio.getStreamMaxVolume(AudioManager.STREAM_RING);
+    }
+
+    @Rpc(description = "Returns the current ringer volume.")
+    public int getRingerVolume() {
+        return mAudio.getStreamVolume(AudioManager.STREAM_RING);
+    }
+
+    @Rpc(description = "Sets the ringer volume.")
+    public void setRingerVolume(@RpcParameter(name = "volume") Integer volume) {
+        mAudio.setStreamVolume(AudioManager.STREAM_RING, volume, 0);
+    }
+
+    @Rpc(description = "Returns the maximum media volume.")
+    public int getMaxMediaVolume() {
+        return mAudio.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
+    }
+
+    @Rpc(description = "Returns the current media volume.")
+    public int getMediaVolume() {
+        return mAudio.getStreamVolume(AudioManager.STREAM_MUSIC);
+    }
+
+    @Rpc(description = "Sets the media volume.")
+    public void setMediaVolume(@RpcParameter(name = "volume") Integer volume) {
+        mAudio.setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0);
+    }
+
+    @Rpc(description = "Returns the screen backlight brightness.",
+            returns = "the current screen brightness between 0 and 255")
+    public Integer getScreenBrightness() {
+        try {
+            return android.provider.Settings.System.getInt(mService.getContentResolver(),
+                    android.provider.Settings.System.SCREEN_BRIGHTNESS);
+        } catch (SettingNotFoundException e) {
+            return 0;
+        }
+    }
+
+    @Rpc(description = "return the system time since boot in nanoseconds")
+    public long getSystemElapsedRealtimeNanos() {
+        return SystemClock.elapsedRealtimeNanos();
+    }
+
+    @Rpc(description = "Sets the the screen backlight brightness.",
+            returns = "the original screen brightness.")
+    public Integer setScreenBrightness(
+            @RpcParameter(name = "value", description = "brightness value between 0 and 255") Integer value) {
+        if (value < 0) {
+            value = 0;
+        } else if (value > 255) {
+            value = 255;
+        }
+        final int brightness = value;
+        Integer oldValue = getScreenBrightness();
+        android.provider.Settings.System.putInt(mService.getContentResolver(),
+                android.provider.Settings.System.SCREEN_BRIGHTNESS, brightness);
+
+        FutureActivityTask<Object> task = new FutureActivityTask<Object>() {
+            @Override
+            public void onCreate() {
+                super.onCreate();
+                WindowManager.LayoutParams lp = getActivity().getWindow().getAttributes();
+                lp.screenBrightness = brightness * 1.0f / 255;
+                getActivity().getWindow().setAttributes(lp);
+                setResult(null);
+                finish();
+            }
+        };
+
+        FutureActivityTaskExecutor taskExecutor =
+                ((BaseApplication) mService.getApplication()).getTaskExecutor();
+        taskExecutor.execute(task);
+
+        return oldValue;
+    }
+
+    @Rpc(description = "Returns true if the device is in an interactive state.")
+    public Boolean isDeviceInteractive() throws Exception {
+        return mPower.isInteractive();
+    }
+
+    @Rpc(description = "Issues a request to put the device to sleep after a delay.")
+    public void goToSleep(Integer delay) {
+        mPower.goToSleep(SystemClock.uptimeMillis() + delay);
+    }
+
+    @Rpc(description = "Issues a request to put the device to sleep right away.")
+    public void goToSleepNow() {
+        mPower.goToSleep(SystemClock.uptimeMillis());
+    }
+
+    @Rpc(description = "Issues a request to wake the device up right away.")
+    public void wakeUpNow() {
+        mPower.wakeUp(SystemClock.uptimeMillis());
+    }
+
+    @Rpc(description = "Get Up time of device.",
+            returns = "Long value of device up time in milliseconds.")
+    public long getDeviceUpTime() throws Exception {
+        return SystemClock.elapsedRealtime();
+    }
+
+    @Rpc(description = "Set a string password to the device.")
+    public void setDevicePassword(@RpcParameter(name = "password") String password) {
+        // mLockPatternUtils.setLockPatternEnabled(true, UserHandle.myUserId());
+        mLockPatternUtils.setLockScreenDisabled(false, UserHandle.myUserId());
+        mLockPatternUtils.setCredentialRequiredToDecrypt(true);
+        mLockPatternUtils.saveLockPassword(password, null,
+                DevicePolicyManager.PASSWORD_QUALITY_NUMERIC, UserHandle.myUserId());
+    }
+
+    @Rpc(description = "Disable screen lock password on the device.")
+    public void disableDevicePassword() {
+        mLockPatternUtils.clearEncryptionPassword();
+        // mLockPatternUtils.setLockPatternEnabled(false, UserHandle.myUserId());
+        mLockPatternUtils.setLockScreenDisabled(true, UserHandle.myUserId());
+        mLockPatternUtils.setCredentialRequiredToDecrypt(false);
+        mLockPatternUtils.clearEncryptionPassword();
+        mLockPatternUtils.clearLock(UserHandle.myUserId());
+        mLockPatternUtils.setLockScreenDisabled(true, UserHandle.myUserId());
+    }
+
+    @Rpc(description = "Set the system time in epoch.")
+    public void setTime(Long currentTime) {
+        mAlarm.setTime(currentTime);
+    }
+
+    @Rpc(description = "Set the system time zone.")
+    public void setTimeZone(@RpcParameter(name = "timeZone") String timeZone) {
+        mAlarm.setTimeZone(timeZone);
+    }
+
+    @Rpc(description = "Show Home Screen")
+    public void showHomeScreen() {
+        Intent intent = new Intent(Intent.ACTION_MAIN);
+        intent.addCategory(Intent.CATEGORY_HOME);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        try {
+            mAndroidFacade.startActivityIntent(intent, false);
+        } catch (RuntimeException e) {
+            Log.d("showHomeScreen RuntimeException" + e);
+        } catch (Exception e){
+            Log.d("showHomeScreen exception" + e);
+        }
+    }
+
+    @Override
+    public void shutdown() {
+        // Nothing to do yet.
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/SpeechRecognitionFacade.java b/Common/src/com/googlecode/android_scripting/facade/SpeechRecognitionFacade.java
new file mode 100644
index 0000000..5409002
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/SpeechRecognitionFacade.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.content.Intent;
+import android.speech.RecognizerIntent;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.util.ArrayList;
+
+/**
+ * A facade containing RPC implementations related to the speech-to-text functionality of Android.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ *
+ */
+public class SpeechRecognitionFacade extends RpcReceiver {
+  private final AndroidFacade mAndroidFacade;
+
+  /**
+   * @param activityLauncher
+   *          a helper object that launches activities in a blocking manner
+   */
+  public SpeechRecognitionFacade(FacadeManager manager) {
+    super(manager);
+    mAndroidFacade = manager.getReceiver(AndroidFacade.class);
+  }
+
+  @Rpc(description = "Recognizes user's speech and returns the most likely result.", returns = "An empty string in case the speech cannot be recongnized.")
+  public String recognizeSpeech(
+      @RpcParameter(name = "prompt", description = "text prompt to show to the user when asking them to speak") @RpcOptional final String prompt,
+      @RpcParameter(name = "language", description = "language override to inform the recognizer that it should expect speech in a language different than the one set in the java.util.Locale.getDefault()") @RpcOptional final String language,
+      @RpcParameter(name = "languageModel", description = "informs the recognizer which speech model to prefer (see android.speech.RecognizeIntent)") @RpcOptional final String languageModel) {
+    final Intent recognitionIntent =
+        new Intent(android.speech.RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
+
+    // Setup intent parameters (if provided).
+    if (language != null) {
+      recognitionIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, "");
+    }
+    if (languageModel != null) {
+      recognitionIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, "");
+    }
+    if (prompt != null) {
+      recognitionIntent.putExtra(RecognizerIntent.EXTRA_PROMPT, "");
+    }
+
+    // Run the activity an retrieve the result.
+    final Intent data = mAndroidFacade.startActivityForResult(recognitionIntent);
+
+    if (data.hasExtra(android.speech.RecognizerIntent.EXTRA_RESULTS)) {
+      // The result consists of an array-list containing one entry for each
+      // possible result. The most likely result is the first entry.
+      ArrayList<String> results =
+          data.getStringArrayListExtra(android.speech.RecognizerIntent.EXTRA_RESULTS);
+      return results.get(0);
+    }
+
+    return "";
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/TextToSpeechFacade.java b/Common/src/com/googlecode/android_scripting/facade/TextToSpeechFacade.java
new file mode 100644
index 0000000..26991fb
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/TextToSpeechFacade.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.os.SystemClock;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.TextToSpeech.OnInitListener;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * Provides Text To Speech services
+ */
+
+public class TextToSpeechFacade extends RpcReceiver {
+
+  private final TextToSpeech mTts;
+  private final CountDownLatch mOnInitLock;
+
+  public TextToSpeechFacade(FacadeManager manager) {
+    super(manager);
+    mOnInitLock = new CountDownLatch(1);
+    mTts = new TextToSpeech(manager.getService(), new OnInitListener() {
+      @Override
+      public void onInit(int arg0) {
+        mOnInitLock.countDown();
+      }
+    });
+  }
+
+  @Override
+  public void shutdown() {
+    while (mTts.isSpeaking()) {
+      SystemClock.sleep(100);
+    }
+    mTts.shutdown();
+  }
+
+  @Rpc(description = "Speaks the provided message via TTS.")
+  public void ttsSpeak(@RpcParameter(name = "message") String message) throws InterruptedException {
+    mOnInitLock.await();
+    if (message != null) {
+      mTts.speak(message, TextToSpeech.QUEUE_ADD, null);
+    }
+  }
+
+  @Rpc(description = "Returns True if speech is currently in progress.")
+  public Boolean ttsIsSpeaking() throws InterruptedException {
+    mOnInitLock.await();
+    return mTts.isSpeaking();
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ToneGeneratorFacade.java b/Common/src/com/googlecode/android_scripting/facade/ToneGeneratorFacade.java
new file mode 100644
index 0000000..c0bfe5f
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ToneGeneratorFacade.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.media.AudioManager;
+import android.media.ToneGenerator;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Generate DTMF tones.
+ *
+ */
+public class ToneGeneratorFacade extends RpcReceiver {
+
+  private final ToneGenerator mToneGenerator;
+
+  public ToneGeneratorFacade(FacadeManager manager) {
+    super(manager);
+    mToneGenerator = new ToneGenerator(AudioManager.STREAM_MUSIC, 100);
+  }
+
+  @Rpc(description = "Generate DTMF tones for the given phone number.")
+  public void generateDtmfTones(
+      @RpcParameter(name = "phoneNumber") String phoneNumber,
+      @RpcParameter(name = "toneDuration", description = "duration of each tone in milliseconds") @RpcDefault("100") Integer toneDuration)
+      throws InterruptedException {
+    try {
+      for (int i = 0; i < phoneNumber.length(); i++) {
+        switch (phoneNumber.charAt(i)) {
+        case '0':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_0);
+          Thread.sleep(toneDuration);
+          break;
+        case '1':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_1);
+          Thread.sleep(toneDuration);
+          break;
+        case '2':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_2);
+          Thread.sleep(toneDuration);
+          break;
+        case '3':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_3);
+          Thread.sleep(toneDuration);
+          break;
+        case '4':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_4);
+          Thread.sleep(toneDuration);
+          break;
+        case '5':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_5);
+          Thread.sleep(toneDuration);
+          break;
+        case '6':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_6);
+          Thread.sleep(toneDuration);
+          break;
+        case '7':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_7);
+          Thread.sleep(toneDuration);
+          break;
+        case '8':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_8);
+          Thread.sleep(toneDuration);
+          break;
+        case '9':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_9);
+          Thread.sleep(toneDuration);
+          break;
+        case '*':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_S);
+          Thread.sleep(toneDuration);
+          break;
+        case '#':
+          mToneGenerator.startTone(ToneGenerator.TONE_DTMF_P);
+          Thread.sleep(toneDuration);
+          break;
+        default:
+          throw new RuntimeException("Cannot generate tone for '" + phoneNumber.charAt(i) + "'");
+        }
+      }
+    } finally {
+      mToneGenerator.stopTone();
+    }
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/WakeLockFacade.java b/Common/src/com/googlecode/android_scripting/facade/WakeLockFacade.java
new file mode 100644
index 0000000..966e286
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/WakeLockFacade.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import android.content.Context;
+import android.os.PowerManager;
+import android.os.PowerManager.WakeLock;
+
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * A facade exposing some of the functionality of the PowerManager, in particular wake locks.
+ *
+ * @author Felix Arends (felixarends@gmail.com)
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class WakeLockFacade extends RpcReceiver {
+
+    private final static String WAKE_LOCK_TAG =
+            "com.googlecode.android_scripting.facade.PowerManagerFacade";
+    private final PowerManager mmPowerManager;
+
+    private enum WakeLockType {
+        FULL, PARTIAL, BRIGHT, DIM
+    }
+
+    private class WakeLockManager {
+        private final Map<WakeLockType, WakeLock> mmLocks = new HashMap<WakeLockType, WakeLock>();
+
+        public WakeLockManager(PowerManager mmPowerManager) {
+            addWakeLock(WakeLockType.PARTIAL, PowerManager.PARTIAL_WAKE_LOCK);
+            addWakeLock(WakeLockType.FULL, PowerManager.FULL_WAKE_LOCK
+                    | PowerManager.ON_AFTER_RELEASE);
+            addWakeLock(WakeLockType.BRIGHT, PowerManager.SCREEN_BRIGHT_WAKE_LOCK
+                    | PowerManager.ON_AFTER_RELEASE);
+            addWakeLock(WakeLockType.DIM, PowerManager.SCREEN_DIM_WAKE_LOCK
+                    | PowerManager.ON_AFTER_RELEASE);
+        }
+
+        private void addWakeLock(WakeLockType type, int flags) {
+            WakeLock full = mmPowerManager.newWakeLock(flags, WAKE_LOCK_TAG);
+            full.setReferenceCounted(false);
+            mmLocks.put(type, full);
+        }
+
+        public void acquire(WakeLockType type) {
+            mmLocks.get(type).acquire();
+            for (Entry<WakeLockType, WakeLock> entry : mmLocks.entrySet()) {
+                if (entry.getKey() != type) {
+                    entry.getValue().release();
+                }
+            }
+        }
+
+        public void release() {
+            for (Entry<WakeLockType, WakeLock> entry : mmLocks.entrySet()) {
+                entry.getValue().release();
+            }
+        }
+    }
+
+    private final WakeLockManager mManager;
+
+    public WakeLockFacade(FacadeManager manager) {
+        super(manager);
+        mmPowerManager = (PowerManager) manager.getService()
+                .getSystemService(Context.POWER_SERVICE);
+        mManager = new WakeLockManager(mmPowerManager);
+    }
+
+    @Rpc(description = "Acquires a full wake lock (CPU on, screen bright, keyboard bright).")
+    public void wakeLockAcquireFull() {
+        mManager.acquire(WakeLockType.FULL);
+    }
+
+    @Rpc(description = "Acquires a partial wake lock (CPU on).")
+    public void wakeLockAcquirePartial() {
+        mManager.acquire(WakeLockType.PARTIAL);
+    }
+
+    @Rpc(description = "Acquires a bright wake lock (CPU on, screen bright).")
+    public void wakeLockAcquireBright() {
+        mManager.acquire(WakeLockType.BRIGHT);
+    }
+
+    @Rpc(description = "Acquires a dim wake lock (CPU on, screen dim).")
+    public void wakeLockAcquireDim() {
+        mManager.acquire(WakeLockType.DIM);
+    }
+
+    @Rpc(description = "Releases the wake lock.")
+    public void wakeLockRelease() {
+        mManager.release();
+    }
+
+    @Override
+    public void shutdown() {
+        wakeLockRelease();
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothA2dpFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothA2dpFacade.java
new file mode 100644
index 0000000..4a98d71
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothA2dpFacade.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.List;
+
+import android.app.Service;
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.BluetoothUuid;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class BluetoothA2dpFacade extends RpcReceiver {
+  static final ParcelUuid[] SINK_UUIDS = {
+    BluetoothUuid.AudioSink, BluetoothUuid.AdvAudioDist,
+  };
+  private final Service mService;
+  private final BluetoothAdapter mBluetoothAdapter;
+
+  private static boolean sIsA2dpReady = false;
+  private static BluetoothA2dp sA2dpProfile = null;
+
+  public BluetoothA2dpFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+    mBluetoothAdapter.getProfileProxy(mService, new A2dpServiceListener(),
+        BluetoothProfile.A2DP);
+  }
+
+  class A2dpServiceListener implements BluetoothProfile.ServiceListener {
+    @Override
+    public void onServiceConnected(int profile, BluetoothProfile proxy) {
+      sA2dpProfile = (BluetoothA2dp) proxy;
+      sIsA2dpReady = true;
+    }
+
+    @Override
+    public void onServiceDisconnected(int profile) {
+      sIsA2dpReady = false;
+    }
+  }
+
+  public Boolean a2dpConnect(BluetoothDevice device) {
+    List<BluetoothDevice> sinks = sA2dpProfile.getConnectedDevices();
+    if (sinks != null) {
+      for (BluetoothDevice sink : sinks) {
+        sA2dpProfile.disconnect(sink);
+      }
+    }
+    return sA2dpProfile.connect(device);
+  }
+
+  public Boolean a2dpDisconnect(BluetoothDevice device) {
+    if (sA2dpProfile.getPriority(device) > BluetoothProfile.PRIORITY_ON) {
+      sA2dpProfile.setPriority(device, BluetoothProfile.PRIORITY_ON);
+    }
+    return sA2dpProfile.disconnect(device);
+  }
+
+  /**
+   * Checks to see if the A2DP profile is ready for use.
+   *
+   * @return Returns true if the A2DP Profile is ready.
+   */
+  @Rpc(description = "Is A2dp profile ready.")
+  public Boolean bluetoothA2dpIsReady() {
+    return sIsA2dpReady;
+  }
+
+  /**
+   * Connect to remote device using the A2DP profile.
+   *
+   * @param deviceId the name or mac address of the remote Bluetooth device.
+   * @return True if connected successfully.
+   * @throws Exception
+   */
+  @Rpc(description = "Connect to an A2DP device.")
+  public Boolean bluetoothA2dpConnect(
+      @RpcParameter(name = "deviceID", description = "Name or MAC address of a bluetooth device.")
+      String deviceID)
+      throws Exception {
+    if (sA2dpProfile == null)
+      return false;
+    BluetoothDevice mDevice = BluetoothFacade.getDevice(
+        BluetoothFacade.DiscoveredDevices, deviceID);
+    Log.d("Connecting to device " + mDevice.getAliasName());
+    return a2dpConnect(mDevice);
+  }
+
+  /**
+   * Disconnect a remote device using the A2DP profile.
+   *
+   * @param deviceId the name or mac address of the remote Bluetooth device.
+   * @return True if connected successfully.
+   * @throws Exception
+   */
+  @Rpc(description = "Disconnect an A2DP device.")
+  public Boolean bluetoothA2dpDisconnect(
+      @RpcParameter(name = "deviceID", description = "Name or MAC address of a device.")
+      String deviceID)
+      throws Exception {
+    if (sA2dpProfile == null)
+      return false;
+    List<BluetoothDevice> connectedA2dpDevices = sA2dpProfile.getConnectedDevices();
+    Log.d("Connected a2dp devices " + connectedA2dpDevices);
+    BluetoothDevice mDevice = BluetoothFacade.getDevice(connectedA2dpDevices, deviceID);
+    return a2dpDisconnect(mDevice);
+  }
+
+  /**
+   * Get the list of devices connected through the A2DP profile.
+   *
+   * @return List of bluetooth devices that are in one of the following states:
+   *   connected, connecting, and disconnecting.
+   */
+  @Rpc(description = "Get all the devices connected through A2DP.")
+  public List<BluetoothDevice> bluetoothA2dpGetConnectedDevices() {
+    while (!sIsA2dpReady);
+    return sA2dpProfile.getDevicesMatchingConnectionStates(
+          new int[] {BluetoothProfile.STATE_CONNECTED,
+                     BluetoothProfile.STATE_CONNECTING,
+                     BluetoothProfile.STATE_DISCONNECTING});
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothAvrcpFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothAvrcpFacade.java
new file mode 100644
index 0000000..97dcdff
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothAvrcpFacade.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+
+import android.app.Service;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothAvrcpController;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.BluetoothUuid;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class BluetoothAvrcpFacade extends RpcReceiver {
+  static final ParcelUuid[] AVRCP_UUIDS = {
+    BluetoothUuid.AvrcpTarget, BluetoothUuid.AvrcpController
+  };
+  private final Service mService;
+  private final BluetoothAdapter mBluetoothAdapter;
+
+  private static boolean sIsAvrcpReady = false;
+  private static BluetoothAvrcpController sAvrcpProfile = null;
+
+  public BluetoothAvrcpFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+    mBluetoothAdapter.getProfileProxy(mService, new AvrcpServiceListener(),
+        BluetoothProfile.AVRCP_CONTROLLER);
+  }
+
+  class AvrcpServiceListener implements BluetoothProfile.ServiceListener {
+    @Override
+    public void onServiceConnected(int profile, BluetoothProfile proxy) {
+      sAvrcpProfile = (BluetoothAvrcpController) proxy;
+      sIsAvrcpReady = true;
+    }
+
+    @Override
+    public void onServiceDisconnected(int profile) {
+      sIsAvrcpReady = false;
+    }
+  }
+
+  @Rpc(description = "Is Avrcp profile ready.")
+  public Boolean bluetoothAvrcpIsReady() {
+    return sIsAvrcpReady;
+  }
+
+  @Rpc(description = "Get all the devices connected through AVRCP.")
+  public List<BluetoothDevice> bluetoothAvrcpGetConnectedDevices() {
+    if (!sIsAvrcpReady) {
+        Log.d("AVRCP profile is not ready.");
+        return null;
+    }
+    return sAvrcpProfile.getConnectedDevices();
+  }
+
+  @Rpc(description = "Close AVRCP connection.")
+  public void bluetoothAvrcpDisconnect() throws NoSuchMethodException,
+                                                IllegalAccessException,
+                                                IllegalArgumentException,
+                                                InvocationTargetException {
+      if (!sIsAvrcpReady) {
+          Log.d("AVRCP profile is not ready.");
+          return;
+      }
+      Method m = sAvrcpProfile.getClass().getMethod("close");
+      m.invoke(sAvrcpProfile);
+  }
+
+  @Rpc(description = "Send AVRPC passthrough command.")
+  public void bluetoothAvrcpSendPassThroughCmd(
+          @RpcParameter(name = "deviceID",
+                        description = "Name or MAC address of a bluetooth device.")
+          String deviceID,
+          @RpcParameter(name = "keyCode")
+          Integer keyCode,
+          @RpcParameter(name = "keyState")
+          Integer keyState) throws Exception {
+      if (!sIsAvrcpReady) {
+          Log.d("AVRCP profile is not ready.");
+          return;
+      }
+      BluetoothDevice mDevice = BluetoothFacade.getDevice(sAvrcpProfile.getConnectedDevices(),
+                                                          deviceID);
+      sAvrcpProfile.sendPassThroughCmd(mDevice, keyCode, keyState);
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothBroadcastHelper.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothBroadcastHelper.java
new file mode 100644
index 0000000..dc230cb
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothBroadcastHelper.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+
+public class BluetoothBroadcastHelper {
+
+  private static BroadcastReceiver mListener;
+  private final Context mContext;
+  private final BroadcastReceiver mReceiver;
+  private final String[] mActions = {BluetoothDevice.ACTION_FOUND,
+                                     BluetoothDevice.ACTION_UUID,
+                                     BluetoothAdapter.ACTION_DISCOVERY_STARTED,
+                                     BluetoothAdapter.ACTION_DISCOVERY_FINISHED};
+
+  public BluetoothBroadcastHelper(Context context, BroadcastReceiver listener) {
+    mContext = context;
+    mListener = listener;
+    mReceiver = new BluetoothReceiver();
+  }
+
+  public void startReceiver() {
+    IntentFilter mIntentFilter = new IntentFilter();
+    for(String action : mActions) {
+      mIntentFilter.addAction(action);
+    }
+    mContext.registerReceiver(mReceiver, mIntentFilter);
+  }
+
+  public static class BluetoothReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      mListener.onReceive(context, intent);
+    }
+  }
+
+  public void stopReceiver() {
+    mContext.unregisterReceiver(mReceiver);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothConnectionFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothConnectionFacade.java
new file mode 100644
index 0000000..7fb768f
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothConnectionFacade.java
@@ -0,0 +1,410 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import android.app.Service;
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothHeadset;
+import android.bluetooth.BluetoothInputDevice;
+import android.bluetooth.BluetoothUuid;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class BluetoothConnectionFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final BluetoothAdapter mBluetoothAdapter;
+    private final BluetoothPairingHelper mPairingHelper;
+    private final Map<String, BroadcastReceiver> listeningDevices;
+    private final EventFacade mEventFacade;
+
+    private final IntentFilter mDiscoverConnectFilter;
+    private final IntentFilter mPairingFilter;
+    private final IntentFilter mBondFilter;
+    private final IntentFilter mA2dpStateChangeFilter;
+    private final IntentFilter mHidStateChangeFilter;
+    private final IntentFilter mHspStateChangeFilter;
+
+    private final Bundle mGoodNews;
+    private final Bundle mBadNews;
+
+    private BluetoothA2dpFacade mA2dpProfile;
+    private BluetoothHidFacade mHidProfile;
+    private BluetoothHspFacade mHspProfile;
+
+    public BluetoothConnectionFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+        mPairingHelper = new BluetoothPairingHelper();
+        // Use a synchronized map to avoid racing problems
+        listeningDevices = Collections.synchronizedMap(new HashMap<String, BroadcastReceiver>());
+
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mA2dpProfile = manager.getReceiver(BluetoothA2dpFacade.class);
+        mHidProfile = manager.getReceiver(BluetoothHidFacade.class);
+        mHspProfile = manager.getReceiver(BluetoothHspFacade.class);
+
+        mDiscoverConnectFilter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
+        mDiscoverConnectFilter.addAction(BluetoothDevice.ACTION_UUID);
+        mDiscoverConnectFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+
+        mPairingFilter = new IntentFilter(BluetoothDevice.ACTION_PAIRING_REQUEST);
+        mPairingFilter.addAction(BluetoothDevice.ACTION_CONNECTION_ACCESS_REQUEST);
+        mPairingFilter.setPriority(999);
+
+        mBondFilter = new IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
+        mBondFilter.addAction(BluetoothDevice.ACTION_FOUND);
+        mBondFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+
+        mA2dpStateChangeFilter = new IntentFilter(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
+        mHidStateChangeFilter = new IntentFilter(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
+        mHspStateChangeFilter = new IntentFilter(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
+
+        mGoodNews = new Bundle();
+        mGoodNews.putBoolean("Status", true);
+        mBadNews = new Bundle();
+        mBadNews.putBoolean("Status", false);
+    }
+
+    private void unregisterCachedListener(String listenerId) {
+        BroadcastReceiver listener = listeningDevices.remove(listenerId);
+        if (listener != null) {
+            mService.unregisterReceiver(listener);
+        }
+    }
+
+    /**
+     * Connect to a specific device upon its discovery
+     */
+    public class DiscoverConnectReceiver extends BroadcastReceiver {
+        private final String mDeviceID;
+        private BluetoothDevice mDevice;
+
+        /**
+         * Constructor
+         *
+         * @param deviceID Either the device alias name or mac address.
+         * @param bond If true, bond the device only.
+         */
+        public DiscoverConnectReceiver(String deviceID) {
+            super();
+            mDeviceID = deviceID;
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            // The specified device is found.
+            if (action.equals(BluetoothDevice.ACTION_FOUND)) {
+                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+                if (BluetoothFacade.deviceMatch(device, mDeviceID)) {
+                    Log.d("Found device " + device.getAliasName() + " for connection.");
+                    mBluetoothAdapter.cancelDiscovery();
+                    mDevice = device;
+                }
+            // After discovery stops.
+            } else if (action.equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
+                if (mDevice == null) {
+                    Log.d("Device " + mDeviceID + " not discovered.");
+                    mEventFacade.postEvent("Bond" + mDeviceID, mBadNews);
+                    return;
+                }
+                boolean status = mDevice.fetchUuidsWithSdp();
+                Log.d("Initiated ACL connection: " + status);
+            } else if (action.equals(BluetoothDevice.ACTION_UUID)) {
+                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+                if (BluetoothFacade.deviceMatch(device, mDeviceID)) {
+                    Log.d("Initiating connections.");
+                    connectProfile(device, mDeviceID);
+                    mService.unregisterReceiver(listeningDevices.remove("Connect" + mDeviceID));
+                }
+            }
+        }
+    }
+
+    /**
+     * Connect to a specific device upon its discovery
+     */
+    public class DiscoverBondReceiver extends BroadcastReceiver {
+        private final String mDeviceID;
+        private BluetoothDevice mDevice = null;
+        private boolean started = false;
+
+        /**
+         * Constructor
+         *
+         * @param deviceID Either the device alias name or Mac address.
+         */
+        public DiscoverBondReceiver(String deviceID) {
+            super();
+            mDeviceID = deviceID;
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            // The specified device is found.
+            if (action.equals(BluetoothDevice.ACTION_FOUND)) {
+                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+                if (BluetoothFacade.deviceMatch(device, mDeviceID)) {
+                    Log.d("Found device " + device.getAliasName() + " for connection.");
+                    mBluetoothAdapter.cancelDiscovery();
+                    mDevice = device;
+                }
+            // After discovery stops.
+            } else if (action.equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
+                if (mDevice == null) {
+                    Log.d("Device " + mDeviceID + " was not discovered.");
+                    mEventFacade.postEvent("Bond", mBadNews);
+                    return;
+                }
+                // Attempt to initiate bonding.
+                if (!started) {
+                    Log.d("Bond with " + mDevice.getAliasName());
+                    if (mDevice.createBond()) {
+                        started = true;
+                        Log.d("Bonding started.");
+                    } else {
+                        Log.e("Failed to bond with " + mDevice.getAliasName());
+                        mEventFacade.postEvent("Bond", mBadNews);
+                        mService.unregisterReceiver(listeningDevices.remove("Bond" + mDeviceID));
+                    }
+                }
+            } else if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {
+                Log.d("Bond state changing.");
+                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+                if (BluetoothFacade.deviceMatch(device, mDeviceID)) {
+                    int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1);
+                    Log.d("New state is " + state);
+                    if (state == BluetoothDevice.BOND_BONDED) {
+                        Log.d("Bonding with " + mDeviceID + " successful.");
+                        mEventFacade.postEvent("Bond" + mDeviceID, mGoodNews);
+                        mService.unregisterReceiver(listeningDevices.remove("Bond" + mDeviceID));
+                    }
+                }
+            }
+        }
+    }
+
+    public class ConnectStateChangeReceiver extends BroadcastReceiver {
+        private final String mDeviceID;
+
+        public ConnectStateChangeReceiver(String deviceID) {
+            mDeviceID = deviceID;
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+            // Check if received the specified device
+            if (!BluetoothFacade.deviceMatch(device, mDeviceID)) {
+                return;
+            }
+            if (action.equals(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED)) {
+                int state = intent.getIntExtra(BluetoothA2dp.EXTRA_STATE, -1);
+                if (state == BluetoothA2dp.STATE_CONNECTED) {
+                	Bundle a2dpGoodNews = (Bundle) mGoodNews.clone();
+                	a2dpGoodNews.putString("Type", "a2dp");
+                    mEventFacade.postEvent("A2dpConnect" + mDeviceID, a2dpGoodNews);
+                    unregisterCachedListener("A2dpConnecting" + mDeviceID);
+                } else if (state == BluetoothA2dp.STATE_CONNECTING) {
+                }
+            }else if (action.equals(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED)) {
+                int state = intent.getIntExtra(BluetoothInputDevice.EXTRA_STATE, -1);
+                if (state == BluetoothInputDevice.STATE_CONNECTED) {
+                    mEventFacade.postEvent("HidConnect" + mDeviceID, mGoodNews);
+                    unregisterCachedListener("HidConnecting" + mDeviceID);
+                }
+            } else if (action.equals(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)) {
+                int state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, -1);
+                if (state == BluetoothHeadset.STATE_CONNECTED) {
+                    mEventFacade.postEvent("HspConnect" + mDeviceID, mGoodNews);
+                    unregisterCachedListener("HspConnecting" + mDeviceID);
+                }
+            }
+        }
+    }
+
+    private void connectProfile(BluetoothDevice device, String deviceID) {
+        mService.registerReceiver(mPairingHelper, mPairingFilter);
+        ParcelUuid[] deviceUuids = device.getUuids();
+        Log.d("Device uuid is " + deviceUuids);
+        if (deviceUuids == null) {
+        	mEventFacade.postEvent("Connect", mBadNews);
+        }
+        if (BluetoothUuid.containsAnyUuid(BluetoothA2dpFacade.SINK_UUIDS, deviceUuids)) {
+            Log.d("Connecting to " + device.getAliasName());
+            boolean status = mA2dpProfile.a2dpConnect(device);
+            if (status) {
+                Log.d("Connecting A2dp...");
+                ConnectStateChangeReceiver receiver = new ConnectStateChangeReceiver(deviceID);
+                mService.registerReceiver(receiver, mA2dpStateChangeFilter);
+                listeningDevices.put("A2dpConnecting" + deviceID, receiver);
+            } else {
+                Log.d("Failed starting A2dp connection.");
+                Bundle a2dpBadNews = (Bundle) mBadNews.clone();
+                a2dpBadNews.putString("Type", "a2dp");
+                mEventFacade.postEvent("Connect", a2dpBadNews);
+            }
+        }
+        if (BluetoothUuid.containsAnyUuid(BluetoothHidFacade.UUIDS, deviceUuids)) {
+            boolean status = mHidProfile.hidConnect(device);
+            if (status) {
+                Log.d("Connecting Hid...");
+                ConnectStateChangeReceiver receiver = new ConnectStateChangeReceiver(deviceID);
+                mService.registerReceiver(receiver, mHidStateChangeFilter);
+                listeningDevices.put("HidConnecting" + deviceID, receiver);
+            } else {
+                Log.d("Failed starting Hid connection.");
+                mEventFacade.postEvent("HidConnect" + deviceID, mBadNews);
+            }
+        }
+        if (BluetoothUuid.containsAnyUuid(BluetoothHspFacade.UUIDS, deviceUuids)) {
+            boolean status = mHspProfile.hspConnect(device);
+            if (status) {
+                Log.d("Connecting Hsp...");
+                ConnectStateChangeReceiver receiver = new ConnectStateChangeReceiver(deviceID);
+                mService.registerReceiver(receiver, mHspStateChangeFilter);
+                listeningDevices.put("HspConnecting" + deviceID, receiver);
+            } else {
+                Log.d("Failed starting Hsp connection.");
+                mEventFacade.postEvent("HspConnect" + deviceID, mBadNews);
+            }
+        }
+        mService.unregisterReceiver(mPairingHelper);
+    }
+
+    @Rpc(description = "Start intercepting all bluetooth connection pop-ups.")
+    public void bluetoothStartPairingHelper() {
+        mService.registerReceiver(mPairingHelper, mPairingFilter);
+    }
+
+    @Rpc(description = "Return a list of devices connected through bluetooth")
+    public List<BluetoothDevice> bluetoothGetConnectedDevices() {
+        ArrayList<BluetoothDevice> results = new ArrayList<BluetoothDevice>();
+        for (BluetoothDevice bd : mBluetoothAdapter.getBondedDevices()) {
+            if (bd.isConnected()) {
+                results.add(bd);
+            }
+        }
+        return results;
+    }
+
+    @Rpc(description = "Return true if a bluetooth device is connected.")
+    public Boolean bluetoothIsDeviceConnected(String deviceID) {
+        for (BluetoothDevice bd : mBluetoothAdapter.getBondedDevices()) {
+            if (BluetoothFacade.deviceMatch(bd, deviceID)) {
+                return bd.isConnected();
+            }
+        }
+        return false;
+    }
+
+    @Rpc(description = "Connect to a specified device once it's discovered.",
+         returns = "Whether discovery started successfully.")
+    public Boolean bluetoothDiscoverAndConnect(
+            @RpcParameter(name = "deviceID",
+                          description = "Name or MAC address of a bluetooth device.")
+            String deviceID) {
+        mBluetoothAdapter.cancelDiscovery();
+        if (listeningDevices.containsKey(deviceID)) {
+            Log.d("This device is already in the process of discovery and connecting.");
+            return true;
+        }
+        DiscoverConnectReceiver receiver = new DiscoverConnectReceiver(deviceID);
+        listeningDevices.put("Connect" + deviceID, receiver);
+        mService.registerReceiver(receiver, mDiscoverConnectFilter);
+        return mBluetoothAdapter.startDiscovery();
+    }
+
+    @Rpc(description = "Bond to a specified device once it's discovered.",
+         returns = "Whether discovery started successfully. ")
+    public Boolean bluetoothDiscoverAndBond(
+            @RpcParameter(name = "deviceID",
+                          description = "Name or MAC address of a bluetooth device.")
+            String deviceID) {
+        mBluetoothAdapter.cancelDiscovery();
+        if (listeningDevices.containsKey(deviceID)) {
+            Log.d("This device is already in the process of discovery and bonding.");
+            return true;
+        }
+        if (BluetoothFacade.deviceExists(mBluetoothAdapter.getBondedDevices(), deviceID)) {
+            Log.d("Device " + deviceID + " is already bonded.");
+            mEventFacade.postEvent("Bond" + deviceID, mGoodNews);
+            return true;
+        }
+        DiscoverBondReceiver receiver = new DiscoverBondReceiver(deviceID);
+        if (listeningDevices.containsKey("Bond" + deviceID)) {
+            mService.unregisterReceiver(listeningDevices.remove("Bond" + deviceID));
+        }
+        listeningDevices.put("Bond" + deviceID, receiver);
+        mService.registerReceiver(receiver, mBondFilter);
+        Log.d("Start discovery for bonding.");
+        return mBluetoothAdapter.startDiscovery();
+    }
+
+    @Rpc(description = "Unbond a device.",
+         returns = "Whether the device was successfully unbonded.")
+    public Boolean bluetoothUnbond(
+            @RpcParameter(name = "deviceID",
+                          description = "Name or MAC address of a bluetooth device.")
+            String deviceID) throws Exception {
+        BluetoothDevice mDevice = BluetoothFacade.getDevice(mBluetoothAdapter.getBondedDevices(),
+                deviceID);
+        return mDevice.removeBond();
+    }
+
+    @Rpc(description = "Connect to a device that is already bonded.")
+    public void bluetoothConnectBonded(
+            @RpcParameter(name = "deviceID",
+                          description = "Name or MAC address of a bluetooth device.")
+            String deviceID) throws Exception {
+        BluetoothDevice mDevice = BluetoothFacade.getDevice(mBluetoothAdapter.getBondedDevices(),
+                deviceID);
+        connectProfile(mDevice, deviceID);
+    }
+
+    @Override
+    public void shutdown() {
+        for(BroadcastReceiver receiver : listeningDevices.values()) {
+            mService.unregisterReceiver(receiver);
+        }
+        listeningDevices.clear();
+        mService.unregisterReceiver(mPairingHelper);
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothDiscoveryHelper.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothDiscoveryHelper.java
new file mode 100644
index 0000000..f625f03
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothDiscoveryHelper.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+
+import java.util.Set;
+
+import com.googlecode.android_scripting.Log;
+
+public class BluetoothDiscoveryHelper {
+
+  public static interface BluetoothDiscoveryListener {
+    public void addBondedDevice(String name, String address);
+
+    public void addDevice(String name, String address);
+
+    public void scanDone();
+  }
+
+  private final Context mContext;
+  private final BluetoothDiscoveryListener mListener;
+  private final BroadcastReceiver mReceiver;
+
+  public BluetoothDiscoveryHelper(Context context, BluetoothDiscoveryListener listener) {
+    mContext = context;
+    mListener = listener;
+    mReceiver = new BluetoothReceiver();
+  }
+
+  private class BluetoothReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      final String action = intent.getAction();
+
+      if (BluetoothDevice.ACTION_FOUND.equals(action)) {
+        // Get the BluetoothDevice object from the Intent.
+        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+        Log.d("Found device " + device.getAliasName());
+        // If it's already paired, skip it, because it's been listed already.
+        if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
+          mListener.addDevice(device.getName(), device.getAddress());
+        }
+      } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
+        mListener.scanDone();
+      }
+    }
+  }
+
+  public void startDiscovery() {
+    BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+
+    if (bluetoothAdapter.isDiscovering()) {
+      bluetoothAdapter.cancelDiscovery();
+    }
+
+    Set<BluetoothDevice> pairedDevices = bluetoothAdapter.getBondedDevices();
+    for (BluetoothDevice device : pairedDevices) {
+      mListener.addBondedDevice(device.getName(), device.getAddress());
+    }
+
+    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
+    filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+    mContext.registerReceiver(mReceiver, filter);
+
+    if (!bluetoothAdapter.isEnabled()) {
+      bluetoothAdapter.enable();
+    }
+
+    bluetoothAdapter.startDiscovery();
+  }
+
+  public void cancel() {
+    mContext.unregisterReceiver(mReceiver);
+    mListener.scanDone();
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothFacade.java
new file mode 100644
index 0000000..474e6d9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothFacade.java
@@ -0,0 +1,378 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import android.app.Service;
+import android.bluetooth.BluetoothActivityEnergyInfo;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Basic Bluetooth functions.
+ */
+public class BluetoothFacade extends RpcReceiver {
+    private final Service mService;
+    private final BroadcastReceiver mDiscoveryReceiver;
+    private final IntentFilter discoveryFilter;
+    private final EventFacade mEventFacade;
+    private final BluetoothStateReceiver mStateReceiver;
+    private final BleStateReceiver mBleStateReceiver;
+    private Map<String, BluetoothConnection> connections =
+            new HashMap<String, BluetoothConnection>();
+    private BluetoothAdapter mBluetoothAdapter;
+
+    public static ConcurrentHashMap<String, BluetoothDevice> DiscoveredDevices;
+
+    public BluetoothFacade(FacadeManager manager) {
+        super(manager);
+        mBluetoothAdapter = MainThread.run(manager.getService(), new Callable<BluetoothAdapter>() {
+            @Override
+            public BluetoothAdapter call() throws Exception {
+                return BluetoothAdapter.getDefaultAdapter();
+            }
+        });
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mService = manager.getService();
+
+        DiscoveredDevices = new ConcurrentHashMap<String, BluetoothDevice>();
+        discoveryFilter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
+        discoveryFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+        mDiscoveryReceiver = new DiscoveryCacheReceiver();
+        mStateReceiver = new BluetoothStateReceiver();
+        mBleStateReceiver = new BleStateReceiver();
+    }
+
+    class DiscoveryCacheReceiver extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (action.equals(BluetoothDevice.ACTION_FOUND)) {
+                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+                Log.d("Found device " + device.getAliasName());
+                if (!DiscoveredDevices.containsKey(device.getAddress())) {
+                    String name = device.getAliasName();
+                    if (name != null) {
+                        DiscoveredDevices.put(device.getAliasName(), device);
+                    }
+                    DiscoveredDevices.put(device.getAddress(), device);
+                }
+            } else if (action.equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
+                mEventFacade.postEvent("BluetoothDiscoveryFinished", new Bundle());
+                mService.unregisterReceiver(mDiscoveryReceiver);
+            }
+        }
+    }
+
+    class BluetoothStateReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
+                final int state = mBluetoothAdapter.getState();
+                Bundle msg = new Bundle();
+                if (state == BluetoothAdapter.STATE_ON) {
+                    msg.putString("State", "ON");
+                    mEventFacade.postEvent("BluetoothStateChangedOn", msg);
+                    mService.unregisterReceiver(mStateReceiver);
+                } else if(state == BluetoothAdapter.STATE_OFF) {
+                    msg.putString("State", "OFF");
+                    mEventFacade.postEvent("BluetoothStateChangedOff", msg);
+                    mService.unregisterReceiver(mStateReceiver);
+                }
+                msg.clear();
+            }
+        }
+    }
+
+    class BleStateReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (action.equals(BluetoothAdapter.ACTION_BLE_STATE_CHANGED)) {
+                int state = mBluetoothAdapter.getLeState();
+                if (state == BluetoothAdapter.STATE_BLE_ON) {
+                    mEventFacade.postEvent("BleStateChangedOn", new Bundle());
+                    mService.unregisterReceiver(mBleStateReceiver);
+                } else if (state == BluetoothAdapter.STATE_OFF) {
+                    mEventFacade.postEvent("BleStateChangedOff", new Bundle());
+                    mService.unregisterReceiver(mBleStateReceiver);
+                }
+            }
+        }
+    }
+
+
+    public static boolean deviceMatch(BluetoothDevice device, String deviceID) {
+        return deviceID.equals(device.getAliasName()) || deviceID.equals(device.getAddress());
+    }
+
+    public static <T> BluetoothDevice getDevice(ConcurrentHashMap<String, T> devices, String device)
+            throws Exception {
+        if (devices.containsKey(device)) {
+            return (BluetoothDevice) devices.get(device);
+        } else {
+            throw new Exception("Can't find device " + device);
+        }
+    }
+
+    public static BluetoothDevice getDevice(Collection<BluetoothDevice> devices, String deviceID)
+            throws Exception {
+        Log.d("Looking for " + deviceID);
+        for (BluetoothDevice bd : devices) {
+            Log.d(bd.getAliasName() + " " + bd.getAddress());
+            if (deviceMatch(bd, deviceID)) {
+                Log.d("Found match " + bd.getAliasName() + " " + bd.getAddress());
+                return bd;
+            }
+        }
+        throw new Exception("Can't find device " + deviceID);
+    }
+
+    public static boolean deviceExists(Collection<BluetoothDevice> devices, String deviceID) {
+        for (BluetoothDevice bd : devices) {
+            if (deviceMatch(bd, deviceID)) {
+                Log.d("Found match " + bd.getAliasName() + " " + bd.getAddress());
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Rpc(description = "Requests that the device be made connectable.")
+    public void bluetoothMakeConnectable() {
+        mBluetoothAdapter
+                .setScanMode(BluetoothAdapter.SCAN_MODE_CONNECTABLE);
+    }
+
+    @Rpc(description = "Requests that the device be discoverable for Bluetooth connections.")
+    public void bluetoothMakeDiscoverable(
+            @RpcParameter(name = "duration",
+                          description = "period of time, in seconds,"
+                                      + "during which the device should be discoverable")
+            @RpcDefault("300")
+            Integer duration) {
+        Log.d("Making discoverable for " + duration + " seconds.\n");
+        mBluetoothAdapter
+                .setScanMode(BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE, duration);
+    }
+
+    @Rpc(description = "Requests that the device be not discoverable.")
+    public void bluetoothMakeUndiscoverable() {
+        Log.d("Making undiscoverable\n");
+        mBluetoothAdapter.setScanMode(BluetoothAdapter.SCAN_MODE_NONE);
+    }
+
+    @Rpc(description = "Queries a remote device for it's name or null if it can't be resolved")
+    public String bluetoothGetRemoteDeviceName(
+            @RpcParameter(name = "address", description = "Bluetooth Address For Target Device")
+            String address) {
+        try {
+            BluetoothDevice mDevice;
+            mDevice = mBluetoothAdapter.getRemoteDevice(address);
+            return mDevice.getName();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    @Rpc(description = "Get local Bluetooth device name")
+    public String bluetoothGetLocalName() {
+        return mBluetoothAdapter.getName();
+    }
+
+    @Rpc(description = "Sets the Bluetooth visible device name", returns = "true on success")
+    public boolean bluetoothSetLocalName(
+        @RpcParameter(name = "name", description = "New local name")
+        String name) {
+        return mBluetoothAdapter.setName(name);
+    }
+
+    @Rpc(description = "Returns the hardware address of the local Bluetooth adapter. ")
+    public String bluetoothGetLocalAddress() {
+        return mBluetoothAdapter.getAddress();
+    }
+
+    @Rpc(description = "Returns the UUIDs supported by local Bluetooth adapter.")
+    public ParcelUuid[] bluetoothGetLocalUuids() {
+        return mBluetoothAdapter.getUuids();
+    }
+
+    @Rpc(description = "Gets the scan mode for the local dongle.\r\n" + "Return values:\r\n"
+            + "\t-1 when Bluetooth is disabled.\r\n"
+            + "\t0 if non discoverable and non connectable.\r\n"
+            + "\r1 connectable non discoverable." + "\r3 connectable and discoverable.")
+    public int bluetoothGetScanMode() {
+        if (mBluetoothAdapter.getState() == BluetoothAdapter.STATE_OFF
+                || mBluetoothAdapter.getState() == BluetoothAdapter.STATE_TURNING_OFF) {
+            return -1;
+        }
+        switch (mBluetoothAdapter.getScanMode()) {
+            case BluetoothAdapter.SCAN_MODE_NONE:
+                return 0;
+            case BluetoothAdapter.SCAN_MODE_CONNECTABLE:
+                return 1;
+            case BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE:
+                return 3;
+            default:
+                return mBluetoothAdapter.getScanMode() - 20;
+        }
+    }
+
+    @Rpc(description = "Return the set of BluetoothDevice that are paired to the local adapter.")
+    public Set<BluetoothDevice> bluetoothGetBondedDevices() {
+        return mBluetoothAdapter.getBondedDevices();
+    }
+
+    @Rpc(description = "Checks Bluetooth state.", returns = "True if Bluetooth is enabled.")
+    public Boolean bluetoothCheckState() {
+        return mBluetoothAdapter.isEnabled();
+    }
+
+    @Rpc(description = "Toggle Bluetooth on and off.", returns = "True if Bluetooth is enabled.")
+    public Boolean bluetoothToggleState(@RpcParameter(name = "enabled")
+    @RpcOptional
+    Boolean enabled,
+            @RpcParameter(name = "prompt",
+                          description = "Prompt the user to confirm changing the Bluetooth state.")
+            @RpcDefault("false")
+            Boolean prompt) {
+        mService.registerReceiver(mStateReceiver,
+                                  new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED));
+        if (enabled == null) {
+            enabled = !bluetoothCheckState();
+        }
+        if (enabled) {
+            mBluetoothAdapter.enable();
+        } else {
+            shutdown();
+            mBluetoothAdapter.disable();
+        }
+        return enabled;
+    }
+
+
+    @Rpc(description = "Start the remote device discovery process. ",
+         returns = "true on success, false on error")
+    public Boolean bluetoothStartDiscovery() {
+        DiscoveredDevices.clear();
+        mService.registerReceiver(mDiscoveryReceiver, discoveryFilter);
+        return mBluetoothAdapter.startDiscovery();
+    }
+
+    @Rpc(description = "Cancel the current device discovery process.",
+         returns = "true on success, false on error")
+    public Boolean bluetoothCancelDiscovery() {
+        try {
+            mService.unregisterReceiver(mDiscoveryReceiver);
+        } catch (IllegalArgumentException e) {
+            Log.d("IllegalArgumentExeption found when trying to unregister reciever");
+        }
+        return mBluetoothAdapter.cancelDiscovery();
+    }
+
+    @Rpc(description = "If the local Bluetooth adapter is currently"
+                     + "in the device discovery process.")
+    public Boolean bluetoothIsDiscovering() {
+        return mBluetoothAdapter.isDiscovering();
+    }
+
+    @Rpc(description = "Get all the discovered bluetooth devices.")
+    public Collection<BluetoothDevice> bluetoothGetDiscoveredDevices() {
+        while (bluetoothIsDiscovering())
+            ;
+        return DiscoveredDevices.values();
+    }
+
+    @Rpc(description = "Enable or disable the Bluetooth HCI snoop log")
+    public boolean bluetoothConfigHciSnoopLog(
+            @RpcParameter(name = "value", description = "enable or disable log")
+            Boolean value
+            ) {
+        return mBluetoothAdapter.configHciSnoopLog(value);
+    }
+
+    @Rpc(description = "Get Bluetooth controller activity energy info.")
+    public String bluetoothGetControllerActivityEnergyInfo(
+        @RpcParameter(name = "value")
+        Integer value
+            ) {
+        BluetoothActivityEnergyInfo energyInfo = mBluetoothAdapter
+            .getControllerActivityEnergyInfo(value);
+        while (energyInfo == null) {
+          energyInfo = mBluetoothAdapter.getControllerActivityEnergyInfo(value);
+        }
+        return energyInfo.toString();
+    }
+
+    @Rpc(description = "Return true if hardware has entries" +
+            "available for matching beacons.")
+    public boolean bluetoothIsHardwareTrackingFiltersAvailable() {
+        return mBluetoothAdapter.isHardwareTrackingFiltersAvailable();
+    }
+
+    @Rpc(description = "Gets the current state of LE.")
+    public int bluetoothGetLeState() {
+        return mBluetoothAdapter.getLeState();
+    }
+
+    @Rpc(description = "Enables BLE functionalities.")
+    public boolean bluetoothEnableBLE() {
+        mService.registerReceiver(mBleStateReceiver,
+            new IntentFilter(BluetoothAdapter.ACTION_BLE_STATE_CHANGED));
+        return mBluetoothAdapter.enableBLE();
+    }
+
+    @Rpc(description = "Disables BLE functionalities.")
+    public boolean bluetoothDisableBLE() {
+        mService.registerReceiver(mBleStateReceiver,
+            new IntentFilter(BluetoothAdapter.ACTION_BLE_STATE_CHANGED));
+        return mBluetoothAdapter.disableBLE();
+    }
+
+    @Override
+    public void shutdown() {
+        for (Map.Entry<String, BluetoothConnection> entry : connections.entrySet()) {
+            entry.getValue().stop();
+        }
+        connections.clear();
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothHidFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothHidFacade.java
new file mode 100644
index 0000000..8db50f1
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothHidFacade.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.List;
+
+import android.app.Service;
+import android.bluetooth.BluetoothInputDevice;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.BluetoothUuid;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class BluetoothHidFacade extends RpcReceiver {
+  public final static ParcelUuid[] UUIDS = { BluetoothUuid.Hid };
+
+  private final Service mService;
+  private final BluetoothAdapter mBluetoothAdapter;
+
+  private static boolean sIsHidReady = false;
+  private static BluetoothInputDevice sHidProfile = null;
+
+  public BluetoothHidFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+    mBluetoothAdapter.getProfileProxy(mService, new HidServiceListener(),
+        BluetoothProfile.INPUT_DEVICE);
+  }
+
+  class HidServiceListener implements BluetoothProfile.ServiceListener {
+    @Override
+    public void onServiceConnected(int profile, BluetoothProfile proxy) {
+      sHidProfile = (BluetoothInputDevice) proxy;
+      sIsHidReady = true;
+    }
+
+    @Override
+    public void onServiceDisconnected(int profile) {
+      sIsHidReady = false;
+    }
+  }
+
+  public Boolean hidConnect(BluetoothDevice device) {
+    if (sHidProfile == null) return false;
+    return sHidProfile.connect(device);
+  }
+
+  public Boolean hidDisconnect(BluetoothDevice device) {
+    if (sHidProfile == null) return false;
+    return sHidProfile.disconnect(device);
+  }
+
+  @Rpc(description = "Is Hid profile ready.")
+  public Boolean bluetoothHidIsReady() {
+    return sIsHidReady;
+  }
+
+  @Rpc(description = "Connect to an HID device.")
+  public Boolean bluetoothHidConnect(
+      @RpcParameter(name = "device", description = "Name or MAC address of a bluetooth device.")
+      String device)
+      throws Exception {
+    if (sHidProfile == null)
+      return false;
+    BluetoothDevice mDevice = BluetoothFacade.getDevice(BluetoothFacade.DiscoveredDevices, device);
+    Log.d("Connecting to device " + mDevice.getAliasName());
+    return hidConnect(mDevice);
+  }
+
+  @Rpc(description = "Disconnect an HID device.")
+  public Boolean bluetoothHidDisconnect(
+      @RpcParameter(name = "device", description = "Name or MAC address of a device.")
+      String device)
+      throws Exception {
+    if (sHidProfile == null)
+      return false;
+    Log.d("Connected devices: " + sHidProfile.getConnectedDevices());
+    BluetoothDevice mDevice = BluetoothFacade.getDevice(sHidProfile.getConnectedDevices(),
+                                                        device);
+    return hidDisconnect(mDevice);
+  }
+
+  @Rpc(description = "Get all the devices connected through HID.")
+  public List<BluetoothDevice> bluetoothHidGetConnectedDevices() {
+    while (!sIsHidReady);
+    return sHidProfile.getConnectedDevices();
+  }
+
+  @Rpc(description = "Get the connection status of a device.")
+  public Integer bluetoothHidGetConnectionStatus(
+          @RpcParameter(name = "deviceID",
+                        description = "Name or MAC address of a bluetooth device.")
+          String deviceID) {
+      if (sHidProfile == null) {
+          return BluetoothProfile.STATE_DISCONNECTED;
+      }
+      List<BluetoothDevice> deviceList = sHidProfile.getConnectedDevices();
+      BluetoothDevice device;
+      try {
+          device = BluetoothFacade.getDevice(deviceList, deviceID);
+      } catch (Exception e) {
+          return BluetoothProfile.STATE_DISCONNECTED;
+      }
+      return sHidProfile.getConnectionState(device);
+  }
+
+  @Rpc(description = "Send Set_Report command to the connected HID input device.")
+  public Boolean bluetoothHidSetReport(
+          @RpcParameter(name = "deviceID",
+          description = "Name or MAC address of a bluetooth device.")
+          String deviceID,
+          @RpcParameter(name = "type")
+          @RpcDefault(value = "1")
+          String type,
+          @RpcParameter(name = "report")
+          String report) throws Exception {
+      BluetoothDevice device = BluetoothFacade.getDevice(sHidProfile.getConnectedDevices(),
+              deviceID);
+      Log.d("type " + type.getBytes()[0]);
+      return sHidProfile.setReport(device, type.getBytes()[0], report);
+  }
+
+  @Rpc(description = "Send Get_Report command to the connected HID input device.")
+  public Boolean bluetoothHidGetReport(
+          @RpcParameter(name = "deviceID",
+          description = "Name or MAC address of a bluetooth device.")
+          String deviceID,
+          @RpcParameter(name = "type")
+          @RpcDefault(value = "1")
+          String type,
+          @RpcParameter(name = "reportId")
+          String reportId,
+          @RpcParameter(name = "buffSize")
+          Integer buffSize) throws Exception {
+      BluetoothDevice device = BluetoothFacade.getDevice(sHidProfile.getConnectedDevices(),
+              deviceID);
+      Log.d("type " + type.getBytes()[0] + "reportId " + reportId.getBytes()[0]);
+      return sHidProfile.getReport(device, type.getBytes()[0], reportId.getBytes()[0], buffSize);
+  }
+
+  @Rpc(description = "Send data to a connected HID device.")
+  public Boolean bluetoothHidSendData(
+          @RpcParameter(name = "deviceID",
+          description = "Name or MAC address of a bluetooth device.")
+          String deviceID,
+          @RpcParameter(name = "report")
+          String report) throws Exception {
+      BluetoothDevice device = BluetoothFacade.getDevice(sHidProfile.getConnectedDevices(),
+              deviceID);
+      return sHidProfile.sendData(device, report);
+  }
+
+  @Rpc(description = "Send virtual unplug to a connected HID device.")
+  public Boolean bluetoothHidVirtualUnplug(
+          @RpcParameter(name = "deviceID",
+          description = "Name or MAC address of a bluetooth device.")
+          String deviceID) throws Exception {
+      BluetoothDevice device = BluetoothFacade.getDevice(sHidProfile.getConnectedDevices(),
+              deviceID);
+      return sHidProfile.virtualUnplug(device);
+  }
+
+  @Rpc(description = "Test byte transfer.")
+  public byte[] testByte() {
+      byte[] bts = {0b01,0b10,0b11,0b100};
+      return bts;
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothHspFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothHspFacade.java
new file mode 100644
index 0000000..f4514cc
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothHspFacade.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.List;
+
+import android.app.Service;
+import android.bluetooth.BluetoothHeadset;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.BluetoothUuid;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class BluetoothHspFacade extends RpcReceiver {
+  static final ParcelUuid[] UUIDS = {
+    BluetoothUuid.HSP, BluetoothUuid.Handsfree
+  };
+
+  private final Service mService;
+  private final BluetoothAdapter mBluetoothAdapter;
+
+  private static boolean sIsHspReady = false;
+  private static BluetoothHeadset sHspProfile = null;
+
+  public BluetoothHspFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+    mBluetoothAdapter.getProfileProxy(mService, new HspServiceListener(),
+        BluetoothProfile.HEADSET);
+  }
+
+  class HspServiceListener implements BluetoothProfile.ServiceListener {
+    @Override
+    public void onServiceConnected(int profile, BluetoothProfile proxy) {
+      sHspProfile = (BluetoothHeadset) proxy;
+      sIsHspReady = true;
+    }
+
+    @Override
+    public void onServiceDisconnected(int profile) {
+      sIsHspReady = false;
+    }
+  }
+
+  public Boolean hspConnect(BluetoothDevice device) {
+    if (sHspProfile == null) return false;
+    return sHspProfile.connect(device);
+  }
+
+  public Boolean hspDisconnect(BluetoothDevice device) {
+    if (sHspProfile == null) return false;
+    return sHspProfile.disconnect(device);
+  }
+
+  @Rpc(description = "Is Hsp profile ready.")
+  public Boolean bluetoothHspIsReady() {
+    return sIsHspReady;
+  }
+
+  @Rpc(description = "Connect to an HSP device.")
+  public Boolean bluetoothHspConnect(
+      @RpcParameter(name = "device", description = "Name or MAC address of a bluetooth device.")
+      String device)
+      throws Exception {
+    if (sHspProfile == null)
+      return false;
+    BluetoothDevice mDevice = BluetoothFacade.getDevice(BluetoothFacade.DiscoveredDevices, device);
+    Log.d("Connecting to device " + mDevice.getAliasName());
+    return hspConnect(mDevice);
+  }
+
+  @Rpc(description = "Disconnect an HSP device.")
+  public Boolean bluetoothHspDisconnect(
+      @RpcParameter(name = "device", description = "Name or MAC address of a device.")
+      String device)
+      throws Exception {
+    if (sHspProfile == null)
+      return false;
+    Log.d("Connected devices: " + sHspProfile.getConnectedDevices());
+    BluetoothDevice mDevice = BluetoothFacade.getDevice(sHspProfile.getConnectedDevices(),
+                                                        device);
+    return hspDisconnect(mDevice);
+  }
+
+  @Rpc(description = "Get all the devices connected through HSP.")
+  public List<BluetoothDevice> bluetoothHspGetConnectedDevices() {
+    while (!sIsHspReady);
+    return sHspProfile.getConnectedDevices();
+  }
+
+  @Rpc(description = "Get the connection status of a device.")
+  public Integer bluetoothHspGetConnectionStatus(
+          @RpcParameter(name = "deviceID",
+                        description = "Name or MAC address of a bluetooth device.")
+          String deviceID) {
+      if (sHspProfile == null) {
+          return BluetoothProfile.STATE_DISCONNECTED;
+      }
+      List<BluetoothDevice> deviceList = sHspProfile.getConnectedDevices();
+      BluetoothDevice device;
+      try {
+          device = BluetoothFacade.getDevice(deviceList, deviceID);
+      } catch (Exception e) {
+          return BluetoothProfile.STATE_DISCONNECTED;
+      }
+      return sHspProfile.getConnectionState(device);
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothLeAdvertiseFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothLeAdvertiseFacade.java
new file mode 100644
index 0000000..3537c9a
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothLeAdvertiseFacade.java
@@ -0,0 +1,605 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import android.app.Service;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.le.AdvertiseCallback;
+import android.bluetooth.le.AdvertiseData;
+import android.bluetooth.le.AdvertiseData.Builder;
+import android.bluetooth.le.AdvertiseSettings;
+import android.bluetooth.le.BluetoothLeAdvertiser;
+import android.os.Bundle;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.ConvertUtils;
+
+/**
+ * BluetoothLe Advertise functions.
+ */
+
+public class BluetoothLeAdvertiseFacade extends RpcReceiver {
+
+    private final EventFacade mEventFacade;
+    private BluetoothAdapter mBluetoothAdapter;
+    private static int BleAdvertiseCallbackCount;
+    private static int BleAdvertiseSettingsCount;
+    private static int BleAdvertiseDataCount;
+    private final HashMap<Integer, myAdvertiseCallback> mAdvertiseCallbackList;
+    private final BluetoothLeAdvertiser mAdvertise;
+    private final Service mService;
+    private Builder mAdvertiseDataBuilder;
+    private android.bluetooth.le.AdvertiseSettings.Builder mAdvertiseSettingsBuilder;
+    private final HashMap<Integer, AdvertiseData> mAdvertiseDataList;
+    private final HashMap<Integer, AdvertiseSettings> mAdvertiseSettingsList;
+
+    public BluetoothLeAdvertiseFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mBluetoothAdapter = MainThread.run(mService,
+                new Callable<BluetoothAdapter>() {
+                    @Override
+                    public BluetoothAdapter call() throws Exception {
+                        return BluetoothAdapter.getDefaultAdapter();
+                    }
+                });
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mAdvertiseCallbackList = new HashMap<Integer, myAdvertiseCallback>();
+        mAdvertise = mBluetoothAdapter.getBluetoothLeAdvertiser();
+        mAdvertiseDataList = new HashMap<Integer, AdvertiseData>();
+        mAdvertiseSettingsList = new HashMap<Integer, AdvertiseSettings>();
+        mAdvertiseDataBuilder = new Builder();
+        mAdvertiseSettingsBuilder = new android.bluetooth.le.AdvertiseSettings.Builder();
+    }
+
+    /**
+     * Constructs a myAdvertiseCallback obj and returns its index
+     *
+     * @return myAdvertiseCallback.index
+     */
+    @Rpc(description = "Generate a new myAdvertisement Object")
+    public Integer bleGenBleAdvertiseCallback() {
+        BleAdvertiseCallbackCount += 1;
+        int index = BleAdvertiseCallbackCount;
+        myAdvertiseCallback mCallback = new myAdvertiseCallback(index);
+        mAdvertiseCallbackList.put(mCallback.index,
+                mCallback);
+        return mCallback.index;
+    }
+
+    /**
+     * Constructs a AdvertiseData obj and returns its index
+     *
+     * @return index
+     */
+    @Rpc(description = "Constructs a new Builder obj for AdvertiseData and returns its index")
+    public Integer bleBuildAdvertiseData() {
+        BleAdvertiseDataCount += 1;
+        int index = BleAdvertiseDataCount;
+        mAdvertiseDataList.put(index,
+                mAdvertiseDataBuilder.build());
+        mAdvertiseDataBuilder = new Builder();
+        return index;
+    }
+
+    /**
+     * Constructs a Advertise Settings obj and returns its index
+     *
+     * @return index
+     */
+    @Rpc(description = "Constructs a new Builder obj for AdvertiseData and returns its index")
+    public Integer bleBuildAdvertiseSettings() {
+        BleAdvertiseSettingsCount += 1;
+        int index = BleAdvertiseSettingsCount;
+        mAdvertiseSettingsList.put(index,
+                mAdvertiseSettingsBuilder.build());
+        mAdvertiseSettingsBuilder = new android.bluetooth.le.AdvertiseSettings.Builder();
+        return index;
+    }
+
+    /**
+     * Stops a ble advertisement
+     *
+     * @param index the id of the advertisement to stop advertising on
+     * @throws Exception
+     */
+    @Rpc(description = "Stops an ongoing ble advertisement")
+    public void bleStopBleAdvertising(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mAdvertiseCallbackList.get(index) != null) {
+            Log.d("bluetooth_le mAdvertise " + index);
+            mAdvertise.stopAdvertising(mAdvertiseCallbackList
+                    .get(index));
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Starts ble advertising
+     *
+     * @param callbackIndex The advertisementCallback index
+     * @param dataIndex the AdvertiseData index
+     * @param settingsIndex the advertisementsettings index
+     * @throws Exception
+     */
+    @Rpc(description = "Starts ble advertisement")
+    public void bleStartBleAdvertising(
+            @RpcParameter(name = "callbackIndex")
+            Integer callbackIndex,
+            @RpcParameter(name = "dataIndex")
+            Integer dataIndex,
+            @RpcParameter(name = "settingsIndex")
+            Integer settingsIndex
+            ) throws Exception {
+        AdvertiseData mData = new AdvertiseData.Builder().build();
+        AdvertiseSettings mSettings = new AdvertiseSettings.Builder().build();
+        if (mAdvertiseDataList.get(dataIndex) != null) {
+            mData = mAdvertiseDataList.get(dataIndex);
+        } else {
+            throw new Exception("Invalid dataIndex input:" + Integer.toString(dataIndex));
+        }
+        if (mAdvertiseSettingsList.get(settingsIndex) != null) {
+            mSettings = mAdvertiseSettingsList.get(settingsIndex);
+        } else {
+            throw new Exception("Invalid settingsIndex input:" + Integer.toString(settingsIndex));
+        }
+        if (mAdvertiseCallbackList.get(callbackIndex) != null) {
+            Log.d("bluetooth_le starting a background advertisement on callback index: "
+                    + Integer.toString(callbackIndex));
+            mAdvertise
+                    .startAdvertising(mSettings, mData, mAdvertiseCallbackList.get(callbackIndex));
+        } else {
+            throw new Exception("Invalid callbackIndex input" + Integer.toString(callbackIndex));
+        }
+    }
+
+    /**
+     * Starts ble advertising with a scanResponse. ScanResponses are created in the same way
+     * AdvertiseData is created since they share the same object type.
+     *
+     * @param callbackIndex The advertisementCallback index
+     * @param dataIndex the AdvertiseData index
+     * @param settingsIndex the advertisementsettings index
+     * @param scanResponseIndex the scanResponse index
+     * @throws Exception
+     */
+    @Rpc(description = "Starts ble advertisement")
+    public void bleStartBleAdvertisingWithScanResponse(
+            @RpcParameter(name = "callbackIndex")
+            Integer callbackIndex,
+            @RpcParameter(name = "dataIndex")
+            Integer dataIndex,
+            @RpcParameter(name = "settingsIndex")
+            Integer settingsIndex,
+            @RpcParameter(name = "scanResponseIndex")
+            Integer scanResponseIndex
+            ) throws Exception {
+        AdvertiseData mData = new AdvertiseData.Builder().build();
+        AdvertiseSettings mSettings = new AdvertiseSettings.Builder().build();
+        AdvertiseData mScanResponse = new AdvertiseData.Builder().build();
+
+        if (mAdvertiseDataList.get(dataIndex) != null) {
+            mData = mAdvertiseDataList.get(dataIndex);
+        } else {
+            throw new Exception("Invalid dataIndex input:" + Integer.toString(dataIndex));
+        }
+        if (mAdvertiseSettingsList.get(settingsIndex) != null) {
+            mSettings = mAdvertiseSettingsList.get(settingsIndex);
+        } else {
+            throw new Exception("Invalid settingsIndex input:" + Integer.toString(settingsIndex));
+        }
+        if (mAdvertiseDataList.get(scanResponseIndex) != null) {
+            mScanResponse = mAdvertiseDataList.get(scanResponseIndex);
+        } else {
+            throw new Exception("Invalid scanResponseIndex input:"
+                    + Integer.toString(settingsIndex));
+        }
+        if (mAdvertiseCallbackList.get(callbackIndex) != null) {
+            Log.d("bluetooth_le starting a background advertise on callback index: "
+                    + Integer.toString(callbackIndex));
+            mAdvertise
+                    .startAdvertising(mSettings, mData, mScanResponse,
+                            mAdvertiseCallbackList.get(callbackIndex));
+        } else {
+            throw new Exception("Invalid callbackIndex input" + Integer.toString(callbackIndex));
+        }
+    }
+
+    /**
+     * Get ble advertisement settings mode
+     *
+     * @param index the advertise settings object to use
+     * @return the mode of the advertise settings object
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement settings mode")
+    public int bleGetAdvertiseSettingsMode(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mAdvertiseSettingsList.get(index) != null) {
+            AdvertiseSettings mSettings = mAdvertiseSettingsList.get(index);
+            return mSettings.getMode();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ble advertisement settings tx power level
+     *
+     * @param index the advertise settings object to use
+     * @return the tx power level of the advertise settings object
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement settings tx power level")
+    public int bleGetAdvertiseSettingsTxPowerLevel(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mAdvertiseSettingsList.get(index) != null) {
+            AdvertiseSettings mSettings = mAdvertiseSettingsList.get(index);
+            return mSettings.getTxPowerLevel();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ble advertisement settings isConnectable value
+     *
+     * @param index the advertise settings object to use
+     * @return the boolean value whether the advertisement will indicate
+     * connectable.
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement settings isConnectable value")
+    public boolean bleGetAdvertiseSettingsIsConnectable(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mAdvertiseSettingsList.get(index) != null) {
+            AdvertiseSettings mSettings = mAdvertiseSettingsList.get(index);
+            return mSettings.isConnectable();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ble advertisement data include tx power level
+     *
+     * @param index the advertise data object to use
+     * @return True if include tx power level, false otherwise
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement data include tx power level")
+    public Boolean bleGetAdvertiseDataIncludeTxPowerLevel(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mAdvertiseDataList.get(index) != null) {
+            AdvertiseData mData = mAdvertiseDataList.get(index);
+            return mData.getIncludeTxPowerLevel();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ble advertisement data manufacturer specific data
+     *
+     * @param index the advertise data object to use
+     * @param manufacturerId the id that corresponds to the manufacturer specific data.
+     * @return the corresponding manufacturer specific data to the manufacturer id.
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement data manufacturer specific data")
+    public String bleGetAdvertiseDataManufacturerSpecificData(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "manufacturerId")
+            Integer manufacturerId) throws Exception {
+        if (mAdvertiseDataList.get(index) != null) {
+            AdvertiseData mData = mAdvertiseDataList.get(index);
+            if (mData.getManufacturerSpecificData() != null) {
+                return ConvertUtils.convertByteArrayToString(mData.getManufacturerSpecificData().get(manufacturerId));
+            } else {
+                throw new Exception("Invalid manufacturerId input:" + Integer.toString(manufacturerId));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+
+        }
+    }
+
+    /**
+     * Get ble advertisement data include device name
+     *
+     * @param index the advertise data object to use
+     * @return the advertisement data's include device name
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement include device name")
+    public Boolean bleGetAdvertiseDataIncludeDeviceName(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mAdvertiseDataList.get(index) != null) {
+            AdvertiseData mData = mAdvertiseDataList.get(index);
+            return mData.getIncludeDeviceName();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ble advertisement Service Data
+     *
+     * @param index the advertise data object to use
+     * @param serviceUuid the uuid corresponding to the service data.
+     * @return the advertisement data's service data
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement Service Data")
+    public String bleGetAdvertiseDataServiceData(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "serviceUuid")
+            String serviceUuid) throws Exception {
+        ParcelUuid uuidKey = ParcelUuid.fromString(serviceUuid);
+        if (mAdvertiseDataList.get(index) != null) {
+            AdvertiseData mData = mAdvertiseDataList.get(index);
+            if (mData.getServiceData().containsKey(uuidKey)) {
+                return ConvertUtils.convertByteArrayToString(mData.getServiceData().get(uuidKey));
+            } else {
+                throw new Exception("Invalid serviceUuid input:" + serviceUuid);
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ble advertisement Service Uuids
+     *
+     * @param index the advertise data object to use
+     * @return the advertisement data's Service Uuids
+     * @throws Exception
+     */
+    @Rpc(description = "Get ble advertisement Service Uuids")
+    public List<ParcelUuid> bleGetAdvertiseDataServiceUuids(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mAdvertiseDataList.get(index) != null) {
+            AdvertiseData mData = mAdvertiseDataList.get(index);
+            return mData.getServiceUuids();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Set ble advertisement data service uuids
+     *
+     * @param uuidList
+     * @throws Exception
+     */
+    @Rpc(description = "Set ble advertisement data service uuids")
+    public void bleSetAdvertiseDataSetServiceUuids(
+            @RpcParameter(name = "uuidList")
+            String[] uuidList
+            ) {
+        for (String uuid : uuidList) {
+            mAdvertiseDataBuilder.addServiceUuid(ParcelUuid.fromString(uuid));
+        }
+    }
+
+    /**
+     * Set ble advertise data service uuids
+     *
+     * @param serviceDataUuid
+     * @param serviceData
+     * @throws Exception
+     */
+    @Rpc(description = "Set ble advertise data service uuids")
+    public void bleAddAdvertiseDataServiceData(
+            @RpcParameter(name = "serviceDataUuid")
+            String serviceDataUuid,
+            @RpcParameter(name = "serviceData")
+            String serviceData
+            ) {
+        mAdvertiseDataBuilder.addServiceData(
+                ParcelUuid.fromString(serviceDataUuid),
+                ConvertUtils.convertStringToByteArray(serviceData));
+    }
+
+    /**
+     * Set ble advertise data manufacturer id
+     *
+     * @param manufacturerId the manufacturer id to set
+     * @param manufacturerSpecificData the manufacturer specific data to set
+     * @throws Exception
+     */
+    @Rpc(description = "Set ble advertise data manufacturerId")
+    public void bleAddAdvertiseDataManufacturerId(
+            @RpcParameter(name = "manufacturerId")
+            Integer manufacturerId,
+            @RpcParameter(name = "manufacturerSpecificData")
+            String manufacturerSpecificData
+            ) {
+        mAdvertiseDataBuilder.addManufacturerData(manufacturerId,
+                ConvertUtils.convertStringToByteArray(manufacturerSpecificData));
+    }
+
+    /**
+     * Set ble advertise settings advertise mode
+     *
+     * @param advertiseMode
+     * @throws Exception
+     */
+    @Rpc(description = "Set ble advertise settings advertise mode")
+    public void bleSetAdvertiseSettingsAdvertiseMode(
+            @RpcParameter(name = "advertiseMode")
+            Integer advertiseMode
+            ) {
+        mAdvertiseSettingsBuilder.setAdvertiseMode(advertiseMode);
+    }
+
+    /**
+     * Set ble advertise settings tx power level
+     *
+     * @param txPowerLevel the tx power level to set
+     * @throws Exception
+     */
+    @Rpc(description = "Set ble advertise settings tx power level")
+    public void bleSetAdvertiseSettingsTxPowerLevel(
+            @RpcParameter(name = "txPowerLevel")
+            Integer txPowerLevel
+            ) {
+        mAdvertiseSettingsBuilder.setTxPowerLevel(txPowerLevel);
+    }
+
+    /**
+     * Set ble advertise settings the isConnectable value
+     *
+     * @param type the isConnectable value
+     * @throws Exception
+     */
+    @Rpc(description = "Set ble advertise settings isConnectable value")
+    public void bleSetAdvertiseSettingsIsConnectable(
+            @RpcParameter(name = "value")
+            Boolean value
+            ) {
+        mAdvertiseSettingsBuilder.setConnectable(value);
+    }
+
+    /**
+     * Set ble advertisement data include tx power level
+     *
+     * @param includeTxPowerLevel boolean whether to include the tx power level or not in the
+     *            advertisement
+     */
+    @Rpc(description = "Set ble advertisement data include tx power level")
+    public void bleSetAdvertiseDataIncludeTxPowerLevel(
+            @RpcParameter(name = "includeTxPowerLevel")
+            Boolean includeTxPowerLevel
+            ) {
+        mAdvertiseDataBuilder.setIncludeTxPowerLevel(includeTxPowerLevel);
+    }
+
+    /**
+     * Set ble advertisement settings set timeout
+     *
+     * @param timeoutSeconds Limit advertising to a given amount of time.
+     */
+    @Rpc(description = "Set ble advertisement data include tx power level")
+    public void bleSetAdvertiseSettingsTimeout(
+            @RpcParameter(name = "timeoutSeconds")
+            Integer timeoutSeconds
+            ) {
+        mAdvertiseSettingsBuilder.setTimeout(timeoutSeconds);
+    }
+
+    /**
+     * Set ble advertisement data include device name
+     *
+     * @param includeDeviceName boolean whether to include device name or not in the
+     *            advertisement
+     */
+    @Rpc(description = "Set ble advertisement data include device name")
+    public void bleSetAdvertiseDataIncludeDeviceName(
+            @RpcParameter(name = "includeDeviceName")
+            Boolean includeDeviceName
+            ) {
+        mAdvertiseDataBuilder.setIncludeDeviceName(includeDeviceName);
+    }
+
+    private class myAdvertiseCallback extends AdvertiseCallback {
+        public Integer index;
+        private final Bundle mResults;
+        String mEventType;
+
+        public myAdvertiseCallback(int idx) {
+            index = idx;
+            mEventType = "BleAdvertise";
+            mResults = new Bundle();
+        }
+
+        @Override
+        public void onStartSuccess(AdvertiseSettings settingsInEffect) {
+            Log.d("bluetooth_le_advertisement onSuccess " + mEventType + " "
+                    + index);
+            mResults.putString("Type", "onSuccess");
+            mResults.putParcelable("SettingsInEffect", settingsInEffect);
+            mEventFacade.postEvent(mEventType + index + "onSuccess", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onStartFailure(int errorCode) {
+            String errorString = "UNKNOWN_ERROR_CODE";
+            if (errorCode == AdvertiseCallback.ADVERTISE_FAILED_ALREADY_STARTED) {
+                errorString = "ADVERTISE_FAILED_ALREADY_STARTED";
+            } else if (errorCode == AdvertiseCallback.ADVERTISE_FAILED_DATA_TOO_LARGE) {
+                errorString = "ADVERTISE_FAILED_DATA_TOO_LARGE";
+            } else if (errorCode == AdvertiseCallback.ADVERTISE_FAILED_FEATURE_UNSUPPORTED) {
+                errorString = "ADVERTISE_FAILED_FEATURE_UNSUPPORTED";
+            } else if (errorCode == AdvertiseCallback.ADVERTISE_FAILED_INTERNAL_ERROR) {
+                errorString = "ADVERTISE_FAILED_INTERNAL_ERROR";
+            } else if (errorCode == AdvertiseCallback.ADVERTISE_FAILED_TOO_MANY_ADVERTISERS) {
+                errorString = "ADVERTISE_FAILED_TOO_MANY_ADVERTISERS";
+            }
+            Log.d("bluetooth_le_advertisement onFailure " + mEventType + " "
+                    + index + " error " + errorString);
+            mResults.putString("Type", "onFailure");
+            mResults.putInt("ErrorCode", errorCode);
+            mResults.putString("Error", errorString);
+            mEventFacade.postEvent(mEventType + index + "onFailure",
+                    mResults.clone());
+            mResults.clear();
+        }
+    }
+
+    @Override
+    public void shutdown() {
+        if (mBluetoothAdapter.getState() == BluetoothAdapter.STATE_ON) {
+            for (myAdvertiseCallback mAdvertise : mAdvertiseCallbackList
+                .values()) {
+                if (mAdvertise != null) {
+                    try{
+                        mBluetoothAdapter.getBluetoothLeAdvertiser()
+                            .stopAdvertising(mAdvertise);
+                    } catch (NullPointerException e) {
+                        Log.e("Failed to stop ble advertising.", e);
+                    }
+                }
+            }
+        }
+        mAdvertiseCallbackList.clear();
+        mAdvertiseSettingsList.clear();
+        mAdvertiseDataList.clear();
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothLeScanFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothLeScanFacade.java
new file mode 100644
index 0000000..7ae78a2
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothLeScanFacade.java
@@ -0,0 +1,924 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+
+import android.app.Service;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.le.BluetoothLeScanner;
+import android.bluetooth.le.ScanCallback;
+import android.bluetooth.le.ScanFilter;
+import android.bluetooth.BluetoothAdapter.LeScanCallback;
+import android.bluetooth.le.ScanFilter.Builder;
+import android.bluetooth.le.ScanResult;
+import android.bluetooth.le.ScanSettings;
+import android.os.Bundle;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.ConvertUtils;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * BluetoothLe Scan functions.
+ */
+
+public class BluetoothLeScanFacade extends RpcReceiver {
+
+    private final EventFacade mEventFacade;
+
+    private BluetoothAdapter mBluetoothAdapter;
+    private static int ScanCallbackCount;
+    private static int FilterListCount;
+    private static int LeScanCallbackCount;
+    private static int ScanSettingsCount;
+    private final Service mService;
+    private final BluetoothLeScanner mScanner;
+    private android.bluetooth.le.ScanSettings.Builder mScanSettingsBuilder;
+    private Builder mScanFilterBuilder;
+    private final HashMap<Integer, myScanCallback> mScanCallbackList;
+    private final HashMap<Integer, myLeScanCallback> mLeScanCallbackList;
+    private final HashMap<Integer, ArrayList<ScanFilter>> mScanFilterList;
+    private final HashMap<Integer, ScanSettings> mScanSettingsList;
+
+    public BluetoothLeScanFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mBluetoothAdapter = MainThread.run(mService,
+                new Callable<BluetoothAdapter>() {
+                    @Override
+                    public BluetoothAdapter call() throws Exception {
+                        return BluetoothAdapter.getDefaultAdapter();
+                    }
+                });
+        mScanner = mBluetoothAdapter.getBluetoothLeScanner();
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mScanFilterList = new HashMap<Integer, ArrayList<ScanFilter>>();
+        mLeScanCallbackList = new HashMap<Integer, myLeScanCallback>();
+        mScanSettingsList = new HashMap<Integer, ScanSettings>();
+        mScanCallbackList = new HashMap<Integer, myScanCallback>();
+        mScanFilterBuilder = new Builder();
+        mScanSettingsBuilder = new android.bluetooth.le.ScanSettings.Builder();
+    }
+
+    /**
+     * Constructs a myScanCallback obj and returns its index
+     *
+     * @return Integer myScanCallback.index
+     */
+    @Rpc(description = "Generate a new myScanCallback Object")
+    public Integer bleGenScanCallback() {
+        ScanCallbackCount += 1;
+        int index = ScanCallbackCount;
+        myScanCallback mScan = new myScanCallback(index);
+        mScanCallbackList.put(mScan.index, mScan);
+        return mScan.index;
+    }
+
+    /**
+     * Constructs a myLeScanCallback obj and returns its index
+     *
+     * @return Integer myScanCallback.index
+     */
+    @Rpc(description = "Generate a new myScanCallback Object")
+    public Integer bleGenLeScanCallback() {
+        LeScanCallbackCount += 1;
+        int index = LeScanCallbackCount;
+        myLeScanCallback mScan = new myLeScanCallback(index);
+        mLeScanCallbackList.put(mScan.index, mScan);
+        return mScan.index;
+    }
+
+    /**
+     * Constructs a new filter list array and returns its index
+     *
+     * @return Integer index
+     */
+    @Rpc(description = "Generate a new Filter list")
+    public Integer bleGenFilterList() {
+        FilterListCount += 1;
+        int index = FilterListCount;
+        mScanFilterList.put(index, new ArrayList<ScanFilter>());
+        return index;
+    }
+
+    /**
+     * Constructs a new filter list array and returns its index
+     *
+     * @return Integer index
+     */
+    @Rpc(description = "Generate a new Filter list")
+    public Integer bleBuildScanFilter(
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex
+            ) {
+        mScanFilterList.get(filterIndex).add(mScanFilterBuilder.build());
+        mScanFilterBuilder = new Builder();
+        return mScanFilterList.get(filterIndex).size()-1;
+    }
+
+    /**
+     * Constructs a new scan setting and returns its index
+     *
+     * @return Integer index
+     */
+    @Rpc(description = "Generate a new scan settings Object")
+    public Integer bleBuildScanSetting() {
+        ScanSettingsCount += 1;
+        int index = ScanSettingsCount;
+        mScanSettingsList.put(index, mScanSettingsBuilder.build());
+        mScanSettingsBuilder = new android.bluetooth.le.ScanSettings.Builder();
+        return index;
+    }
+
+    /**
+     * Stops a ble scan
+     *
+     * @param index the id of the myScan whose ScanCallback to stop
+     * @throws Exception
+     */
+    @Rpc(description = "Stops an ongoing ble advertisement scan")
+    public void bleStopBleScan(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        Log.d("bluetooth_le_scan mScanCallback " + index);
+        if (mScanCallbackList.get(index) != null) {
+            myScanCallback mScanCallback = mScanCallbackList.get(index);
+            mScanner.stopScan(mScanCallback);
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Stops a classic ble scan
+     *
+     * @param index the id of the myScan whose LeScanCallback to stop
+     * @throws Exception
+     */
+    @Rpc(description = "Stops an ongoing classic ble scan")
+    public void bleStopClassicBleScan(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        Log.d("bluetooth_le_scan mLeScanCallback " + index);
+        if (mLeScanCallbackList.get(index) != null) {
+            myLeScanCallback mLeScanCallback = mLeScanCallbackList.get(index);
+            mBluetoothAdapter.stopLeScan(mLeScanCallback);
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Starts a ble scan
+     *
+     * @param index the id of the myScan whose ScanCallback to start
+     * @throws Exception
+     */
+    @Rpc(description = "Starts a ble advertisement scan")
+    public void bleStartBleScan(
+            @RpcParameter(name = "filterListIndex")
+            Integer filterListIndex,
+            @RpcParameter(name = "scanSettingsIndex")
+            Integer scanSettingsIndex,
+            @RpcParameter(name = "callbackIndex")
+            Integer callbackIndex
+            ) throws Exception {
+        Log.d("bluetooth_le_scan starting a background scan");
+        ArrayList<ScanFilter> mScanFilters = new ArrayList<ScanFilter>();
+        mScanFilters.add(new ScanFilter.Builder().build());
+        ScanSettings mScanSettings = new ScanSettings.Builder().build();
+        if (mScanFilterList.get(filterListIndex) != null) {
+            mScanFilters = mScanFilterList.get(filterListIndex);
+        } else {
+            throw new Exception("Invalid filterListIndex input:"
+                    + Integer.toString(filterListIndex));
+        }
+        if (mScanSettingsList.get(scanSettingsIndex) != null) {
+            mScanSettings = mScanSettingsList.get(scanSettingsIndex);
+        } else if (!mScanSettingsList.isEmpty()) {
+            throw new Exception("Invalid scanSettingsIndex input:"
+                    + Integer.toString(scanSettingsIndex));
+        }
+        if (mScanCallbackList.get(callbackIndex) != null) {
+            mScanner.startScan(mScanFilters, mScanSettings, mScanCallbackList.get(callbackIndex));
+        } else {
+            throw new Exception("Invalid filterListIndex input:"
+                    + Integer.toString(filterListIndex));
+        }
+    }
+
+    /**
+     * Starts a classic ble scan
+     *
+     * @param index the id of the myScan whose ScanCallback to start
+     * @throws Exception
+     */
+    @Rpc(description = "Starts a classic ble advertisement scan")
+    public boolean bleStartClassicBleScan(
+            @RpcParameter(name = "leCallbackIndex")
+            Integer leCallbackIndex
+            ) throws Exception {
+        Log.d("bluetooth_le_scan starting a background scan");
+        boolean result = false;
+        if (mLeScanCallbackList.get(leCallbackIndex) != null) {
+            result = mBluetoothAdapter.startLeScan(mLeScanCallbackList.get(leCallbackIndex));
+        } else {
+            throw new Exception("Invalid leCallbackIndex input:"
+                    + Integer.toString(leCallbackIndex));
+        }
+        return result;
+    }
+
+    /**
+     * Starts a classic ble scan with service Uuids
+     *
+     * @param index the id of the myScan whose ScanCallback to start
+     * @throws Exception
+     */
+    @Rpc(description = "Starts a classic ble advertisement scan with service Uuids")
+    public boolean bleStartClassicBleScanWithServiceUuids(
+            @RpcParameter(name = "leCallbackIndex")
+            Integer leCallbackIndex,
+            @RpcParameter(name = "serviceUuids")
+            String[] serviceUuidList
+            ) throws Exception {
+        Log.d("bluetooth_le_scan starting a background scan");
+        UUID[] serviceUuids = new UUID[serviceUuidList.length];
+        for (int i = 0; i < serviceUuidList.length; i++) {
+            serviceUuids[i] = UUID.fromString(serviceUuidList[i]);
+        }
+        boolean result = false;
+        if (mLeScanCallbackList.get(leCallbackIndex) != null) {
+            result = mBluetoothAdapter.startLeScan(serviceUuids,
+                    mLeScanCallbackList.get(leCallbackIndex));
+            System.out.println(result);
+        } else {
+            throw new Exception("Invalid leCallbackIndex input:"
+                    + Integer.toString(leCallbackIndex));
+        }
+        System.out.println(result);
+        return result;
+    }
+
+    /**
+     * Trigger onBatchScanResults
+     *
+     * @throws Exception
+     */
+    @Rpc(description = "Gets the results of the ble ScanCallback")
+    public void bleFlushPendingScanResults(
+            @RpcParameter(name = "callbackIndex")
+            Integer callbackIndex
+            ) throws Exception {
+        if (mScanCallbackList.get(callbackIndex) != null) {
+            mBluetoothAdapter
+                    .getBluetoothLeScanner().flushPendingScanResults(
+                            mScanCallbackList.get(callbackIndex));
+        } else {
+            throw new Exception("Invalid callbackIndex input:"
+                    + Integer.toString(callbackIndex));
+        }
+    }
+
+    /**
+     * Set scanSettings for ble scan. Note: You have to set all variables at once.
+     *
+     * @param callbackType Bluetooth LE scan callback type
+     * @param reportDelaySeconds Time of delay for reporting the scan result
+     * @param scanMode Bluetooth LE scan mode.
+     * @param scanResultType Bluetooth LE scan result type
+     * @throws Exception
+     */
+
+    /**
+     * Set the scan setting's callback type
+     * @param callbackType Bluetooth LE scan callback type
+     */
+    @Rpc(description = "Set the scan setting's callback type")
+    public void bleSetScanSettingsCallbackType(
+            @RpcParameter(name = "callbackType")
+            Integer callbackType) {
+        mScanSettingsBuilder.setCallbackType(callbackType);
+    }
+
+    /**
+     * Set the scan setting's report delay millis
+     * @param reportDelayMillis Time of delay for reporting the scan result
+     */
+    @Rpc(description = "Set the scan setting's report delay millis")
+    public void bleSetScanSettingsReportDelayMillis(
+            @RpcParameter(name = "reportDelayMillis")
+            Long reportDelayMillis) {
+        mScanSettingsBuilder.setReportDelay(reportDelayMillis);
+    }
+
+    /**
+     * Set the scan setting's scan mode
+     * @param scanMode Bluetooth LE scan mode.
+     */
+    @Rpc(description = "Set the scan setting's scan mode")
+    public void bleSetScanSettingsScanMode(
+            @RpcParameter(name = "scanMode")
+            Integer scanMode) {
+        mScanSettingsBuilder.setScanMode(scanMode);
+    }
+
+    /**
+     * Set the scan setting's scan result type
+     * @param scanResultType Bluetooth LE scan result type
+     */
+    @Rpc(description = "Set the scan setting's scan result type")
+    public void bleSetScanSettingsResultType(
+            @RpcParameter(name = "scanResultType")
+            Integer scanResultType) {
+        mScanSettingsBuilder.setScanResultType(scanResultType);
+    }
+    /**
+     * Get ScanSetting's callback type
+     *
+     * @param index the ScanSetting object to use
+     * @return the ScanSetting's callback type
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanSetting's callback type")
+    public Integer bleGetScanSettingsCallbackType(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mScanSettingsList.get(index) != null) {
+            ScanSettings mScanSettings = mScanSettingsList.get(index);
+            return mScanSettings.getCallbackType();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanSetting's report delay in milli seconds
+     *
+     * @param index the ScanSetting object to useSystemClock
+     * @return the ScanSetting's report delay in milliseconds
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanSetting's report delay milliseconds")
+    public Long bleGetScanSettingsReportDelayMillis(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mScanSettingsList.get(index) != null) {
+            ScanSettings mScanSettings = mScanSettingsList.get(index);
+            return mScanSettings.getReportDelayMillis();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanSetting's scan mode
+     *
+     * @param index the ScanSetting object to use
+     * @return the ScanSetting's scan mode
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanSetting's scan mode")
+    public Integer bleGetScanSettingsScanMode(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mScanSettingsList.get(index) != null) {
+            ScanSettings mScanSettings = mScanSettingsList.get(index);
+            return mScanSettings.getScanMode();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanSetting's scan result type
+     *
+     * @param index the ScanSetting object to use
+     * @return the ScanSetting's scan result type
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanSetting's scan result type")
+    public Integer bleGetScanSettingsScanResultType(
+            @RpcParameter(name = "index")
+            Integer index) throws Exception {
+        if (mScanSettingsList.get(index) != null) {
+            ScanSettings mScanSettings = mScanSettingsList.get(index);
+            return mScanSettings.getScanResultType();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's Manufacturer Id
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's manufacturer id
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's Manufacturer Id")
+    public Integer bleGetScanFilterManufacturerId(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                return mScanFilterList.get(index)
+                        .get(filterIndex).getManufacturerId();
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's device address
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's device address
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's device address")
+    public String bleGetScanFilterDeviceAddress(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                return mScanFilterList.get(index).get(filterIndex).getDeviceAddress();
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's device name
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's device name
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's device name")
+    public String bleGetScanFilterDeviceName(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                return mScanFilterList.get(index).get(filterIndex).getDeviceName();
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's manufacturer data
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's manufacturer data
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's manufacturer data")
+    public String bleGetScanFilterManufacturerData(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                return ConvertUtils.convertByteArrayToString(mScanFilterList.get(index)
+                        .get(filterIndex).getManufacturerData());
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's manufacturer data mask
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's manufacturer data mask
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's manufacturer data mask")
+    public String bleGetScanFilterManufacturerDataMask(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                return ConvertUtils.convertByteArrayToString(mScanFilterList.get(index)
+                        .get(filterIndex).getManufacturerDataMask());
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's service data
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's service data
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's service data")
+    public String bleGetScanFilterServiceData(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                return ConvertUtils.convertByteArrayToString(mScanFilterList
+                        .get(index).get(filterIndex).getServiceData());
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's service data mask
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's service data mask
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's service data mask")
+    public String bleGetScanFilterServiceDataMask(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                return ConvertUtils.convertByteArrayToString(mScanFilterList.get(index)
+                        .get(filterIndex).getServiceDataMask());
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's service uuid
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's service uuid
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's service uuid")
+    public String bleGetScanFilterServiceUuid(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                if (mScanFilterList.get(index).get(filterIndex).getServiceUuid() != null) {
+                    return mScanFilterList.get(index).get(filterIndex).getServiceUuid().toString();
+                } else {
+                    throw new Exception("No Service Uuid set for filter:"
+                            + Integer.toString(filterIndex));
+                }
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get ScanFilter's service uuid mask
+     *
+     * @param index the ScanFilter object to use
+     * @return the ScanFilter's service uuid mask
+     * @throws Exception
+     */
+    @Rpc(description = "Get ScanFilter's service uuid mask")
+    public String bleGetScanFilterServiceUuidMask(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "filterIndex")
+            Integer filterIndex)
+            throws Exception {
+        if (mScanFilterList.get(index) != null) {
+            if (mScanFilterList.get(index).get(filterIndex) != null) {
+                if (mScanFilterList.get(index).get(filterIndex).getServiceUuidMask() != null) {
+                    return mScanFilterList.get(index).get(filterIndex).getServiceUuidMask()
+                            .toString();
+                } else {
+                    throw new Exception("No Service Uuid Mask set for filter:"
+                            + Integer.toString(filterIndex));
+                }
+            } else {
+                throw new Exception("Invalid filterIndex input:" + Integer.toString(filterIndex));
+            }
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Add filter "macAddress" to existing ScanFilter
+     *
+     * @param macAddress the macAddress to filter against
+     * @throws Exception
+     */
+    @Rpc(description = "Add filter \"macAddress\" to existing ScanFilter")
+    public void bleSetScanFilterDeviceAddress(
+            @RpcParameter(name = "macAddress")
+            String macAddress
+            ) {
+            mScanFilterBuilder.setDeviceAddress(macAddress);
+    }
+
+    /**
+     * Add filter "manufacturereDataId and/or manufacturerData" to existing ScanFilter
+     *
+     * @param manufacturerDataId the manufacturer data id to filter against
+     * @param manufacturerDataMask the manufacturere data mask to filter against
+     * @throws Exception
+     */
+    @Rpc(description = "Add filter \"manufacturereDataId and/or manufacturerData\" to existing ScanFilter")
+    public void bleSetScanFilterManufacturerData(
+            @RpcParameter(name = "manufacturerDataId")
+            Integer manufacturerDataId,
+            @RpcParameter(name = "manufacturerData")
+            String manufacturerData,
+            @RpcParameter(name = "manufacturerDataMask")
+            @RpcOptional
+            String manufacturerDataMask
+            ){
+        if (manufacturerDataMask != null) {
+            mScanFilterBuilder.setManufacturerData(manufacturerDataId,
+                    ConvertUtils.convertStringToByteArray(manufacturerData),
+                    ConvertUtils.convertStringToByteArray(manufacturerDataMask));
+        } else {
+            mScanFilterBuilder.setManufacturerData(manufacturerDataId,
+                    ConvertUtils.convertStringToByteArray(manufacturerData));
+        }
+    }
+
+    /**
+     * Add filter "serviceData and serviceDataMask" to existing ScanFilter
+     *
+     * @param serviceData the service data to filter against
+     * @param serviceDataMask the servie data mask to filter against
+     * @throws Exception
+     */
+    @Rpc(description = "Add filter \"serviceData and serviceDataMask\" to existing ScanFilter ")
+    public void bleSetScanFilterServiceData(
+            @RpcParameter(name = "serviceUuid")
+            String serviceUuid,
+            @RpcParameter(name = "serviceData")
+            String serviceData,
+            @RpcParameter(name = "serviceDataMask")
+            @RpcOptional
+            String serviceDataMask
+            ) {
+        if (serviceDataMask != null) {
+            mScanFilterBuilder
+                    .setServiceData(
+                            ParcelUuid.fromString(serviceUuid),
+                            ConvertUtils.convertStringToByteArray(serviceData),
+                            ConvertUtils.convertStringToByteArray(
+                                serviceDataMask));
+        } else {
+            mScanFilterBuilder.setServiceData(ParcelUuid.fromString(serviceUuid),
+                    ConvertUtils.convertStringToByteArray(serviceData));
+        }
+    }
+
+    /**
+     * Add filter "serviceUuid and/or serviceMask" to existing ScanFilter
+     *
+     * @param serviceUuid the service uuid to filter against
+     * @param serviceMask the service mask to filter against
+     * @throws Exception
+     */
+    @Rpc(description = "Add filter \"serviceUuid and/or serviceMask\" to existing ScanFilter")
+    public void bleSetScanFilterServiceUuid(
+            @RpcParameter(name = "serviceUuid")
+            String serviceUuid,
+            @RpcParameter(name = "serviceMask")
+            @RpcOptional
+            String serviceMask
+            ) {
+        if (serviceMask != null) {
+            mScanFilterBuilder
+                    .setServiceUuid(ParcelUuid.fromString(serviceUuid),
+                            ParcelUuid.fromString(serviceMask));
+        } else {
+            mScanFilterBuilder.setServiceUuid(ParcelUuid.fromString(serviceUuid));
+        }
+    }
+
+    /**
+     * Add filter "device name" to existing ScanFilter
+     *
+     * @param name the device name to filter against
+     * @throws Exception
+     */
+    @Rpc(description = "Sets the scan filter's device name")
+    public void bleSetScanFilterDeviceName(
+            @RpcParameter(name = "name")
+            String name
+            ) {
+            mScanFilterBuilder.setDeviceName(name);
+    }
+
+    @Rpc(description = "Set the scan setting's match mode")
+    public void bleSetScanSettingsMatchMode(
+            @RpcParameter(name = "mode") Integer mode) {
+        mScanSettingsBuilder.setMatchMode(mode);
+    }
+
+    @Rpc(description = "Get the scan setting's match mode")
+    public int bleGetScanSettingsMatchMode(
+            @RpcParameter(name = "scanSettingsIndex") Integer scanSettingsIndex
+            ) {
+        return mScanSettingsList.get(scanSettingsIndex).getMatchMode();
+    }
+
+    @Rpc(description = "Set the scan setting's number of matches")
+    public void bleSetScanSettingsNumOfMatches(
+            @RpcParameter(name = "matches") Integer matches) {
+        mScanSettingsBuilder.setNumOfMatches(matches);
+    }
+
+    @Rpc(description = "Get the scan setting's number of matches")
+    public int bleGetScanSettingsNumberOfMatches(
+            @RpcParameter(name = "scanSettingsIndex")
+            Integer scanSettingsIndex) {
+        return  mScanSettingsList.get(scanSettingsIndex).getNumOfMatches();
+    }
+
+    private class myScanCallback extends ScanCallback {
+        public Integer index;
+        String mEventType;
+        private final Bundle mResults;
+
+        public myScanCallback(Integer idx) {
+            index = idx;
+            mEventType = "BleScan";
+            mResults = new Bundle();
+        }
+
+        @Override
+        public void onScanFailed(int errorCode) {
+            String errorString = "UNKNOWN_ERROR_CODE";
+            if (errorCode == ScanCallback.SCAN_FAILED_ALREADY_STARTED) {
+                errorString = "SCAN_FAILED_ALREADY_STARTED";
+            } else if (errorCode == ScanCallback.SCAN_FAILED_APPLICATION_REGISTRATION_FAILED) {
+                errorString = "SCAN_FAILED_APPLICATION_REGISTRATION_FAILED";
+            } else if (errorCode == ScanCallback.SCAN_FAILED_FEATURE_UNSUPPORTED) {
+                errorString = "SCAN_FAILED_FEATURE_UNSUPPORTED";
+            } else if (errorCode == ScanCallback.SCAN_FAILED_INTERNAL_ERROR) {
+                errorString = "SCAN_FAILED_INTERNAL_ERROR";
+            }
+            Log.d("bluetooth_le_scan change onScanFailed " + mEventType + " " + index + " error "
+                    + errorString);
+            mResults.putInt("ID", index);
+            mResults.putString("Type", "onScanFailed");
+            mResults.putInt("ErrorCode", errorCode);
+            mResults.putString("Error", errorString);
+            mEventFacade.postEvent(mEventType + index + "onScanFailed",
+                    mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onScanResult(int callbackType, ScanResult result) {
+            Log.d("bluetooth_le_scan change onUpdate " + mEventType + " " + index);
+            mResults.putInt("ID", index);
+            mResults.putInt("CallbackType", callbackType);
+            mResults.putString("Type", "onScanResult");
+            mResults.putParcelable("Result", result);
+            mEventFacade.postEvent(mEventType + index + "onScanResults", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onBatchScanResults(List<ScanResult> results) {
+            Log.d("reportResult " + mEventType + " " + index);
+            mResults.putLong("Timestamp", System.currentTimeMillis() / 1000);
+            mResults.putInt("ID", index);
+            mResults.putString("Type", "onBatchScanResults");
+            mResults.putParcelableList("Results", results);
+            mEventFacade.postEvent(mEventType + index + "onBatchScanResult", mResults.clone());
+            mResults.clear();
+        }
+    }
+
+    private class myLeScanCallback implements LeScanCallback {
+        public Integer index;
+        String mEventType;
+        private final Bundle mResults;
+
+        public myLeScanCallback(Integer idx) {
+            index = idx;
+            mEventType = "ClassicBleScan";
+            mResults = new Bundle();
+        }
+
+        @Override
+        public void onLeScan(BluetoothDevice device, int rssi, byte[] scanRecord) {
+            Log.d("bluetooth_classic_le_scan " + mEventType + " " + index);
+            mResults.putParcelable("Device", device);
+            mResults.putInt("Rssi", rssi);
+            mResults.putString("ScanRecord", ConvertUtils.convertByteArrayToString(scanRecord));
+            mResults.putString("Type", "onLeScan");
+            mEventFacade.postEvent(mEventType + index + "onLeScan", mResults.clone());
+            mResults.clear();
+        }
+    }
+
+    @Override
+    public void shutdown() {
+      if (mBluetoothAdapter.getState() == BluetoothAdapter.STATE_ON) {
+          for (myScanCallback mScanCallback : mScanCallbackList.values()) {
+              if (mScanCallback != null) {
+                  try {
+                    mBluetoothAdapter.getBluetoothLeScanner()
+                      .stopScan(mScanCallback);
+                  } catch (NullPointerException e) {
+                    Log.e("Failed to stop ble scan callback.", e);
+                  }
+              }
+          }
+          for (myLeScanCallback mLeScanCallback : mLeScanCallbackList.values()) {
+              if (mLeScanCallback != null) {
+                  try {
+                      mBluetoothAdapter.stopLeScan(mLeScanCallback);
+                  } catch (NullPointerException e) {
+                    Log.e("Failed to stop classic ble scan callback.", e);
+                  }
+              }
+          }
+      }
+      mScanCallbackList.clear();
+      mScanFilterList.clear();
+      mScanSettingsList.clear();
+      mLeScanCallbackList.clear();
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothMapFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothMapFacade.java
new file mode 100644
index 0000000..f1a593d
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothMapFacade.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.List;
+
+import android.app.Service;
+import android.bluetooth.BluetoothMap;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.BluetoothUuid;
+import android.os.ParcelUuid;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class BluetoothMapFacade extends RpcReceiver {
+  static final ParcelUuid[] MAP_UUIDS = {
+      BluetoothUuid.MAP,
+      BluetoothUuid.MNS,
+      BluetoothUuid.MAS,
+  };
+  private final Service mService;
+  private final BluetoothAdapter mBluetoothAdapter;
+
+  private static boolean sIsMapReady = false;
+  private static BluetoothMap sMapProfile = null;
+
+  public BluetoothMapFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+    mBluetoothAdapter.getProfileProxy(mService, new MapServiceListener(),
+        BluetoothProfile.MAP);
+  }
+
+  class MapServiceListener implements BluetoothProfile.ServiceListener {
+    @Override
+    public void onServiceConnected(int profile, BluetoothProfile proxy) {
+      sMapProfile = (BluetoothMap) proxy;
+      sIsMapReady = true;
+    }
+
+    @Override
+    public void onServiceDisconnected(int profile) {
+      sIsMapReady = false;
+    }
+  }
+
+  public Boolean mapDisconnect(BluetoothDevice device) {
+    if (sMapProfile.getPriority(device) > BluetoothProfile.PRIORITY_ON) {
+      sMapProfile.setPriority(device, BluetoothProfile.PRIORITY_ON);
+    }
+    return sMapProfile.disconnect(device);
+  }
+
+  @Rpc(description = "Is Map profile ready.")
+  public Boolean bluetoothMapIsReady() {
+    return sIsMapReady;
+  }
+
+  @Rpc(description = "Disconnect an MAP device.")
+  public Boolean bluetoothMapDisconnect(
+      @RpcParameter(name = "deviceID", description = "Name or MAC address of a device.")
+      String deviceID)
+      throws Exception {
+    if (sMapProfile == null) return false;
+    List<BluetoothDevice> connectedMapDevices = sMapProfile.getConnectedDevices();
+    Log.d("Connected map devices: " + connectedMapDevices);
+    BluetoothDevice mDevice = BluetoothFacade.getDevice(connectedMapDevices, deviceID);
+    if (!connectedMapDevices.isEmpty() && connectedMapDevices.get(0).equals(mDevice)) {
+        if (sMapProfile.getPriority(mDevice) > BluetoothProfile.PRIORITY_ON) {
+            sMapProfile.setPriority(mDevice, BluetoothProfile.PRIORITY_ON);
+        }
+        return sMapProfile.disconnect(mDevice);
+    } else {
+        return false;
+    }
+  }
+
+  @Rpc(description = "Get all the devices connected through MAP.")
+  public List<BluetoothDevice> bluetoothMapGetConnectedDevices() {
+    while (!sIsMapReady);
+    return sMapProfile.getDevicesMatchingConnectionStates(
+          new int[] {BluetoothProfile.STATE_CONNECTED,
+                     BluetoothProfile.STATE_CONNECTING,
+                     BluetoothProfile.STATE_DISCONNECTING});
+  }
+
+  @Rpc(description = "Get the currently connected remote Bluetooth device (PCE).")
+  public BluetoothDevice bluetoothMapGetClient() {
+    if (sMapProfile == null) { return null; }
+    return sMapProfile.getClient();
+  }
+
+  @Override
+  public void shutdown() {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothPairingHelper.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothPairingHelper.java
new file mode 100644
index 0000000..dbefd70
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothPairingHelper.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.Log;
+
+public class BluetoothPairingHelper extends BroadcastReceiver {
+  public BluetoothPairingHelper() {
+    super();
+    Log.d("Pairing helper created.");
+  }
+  /**
+   * Blindly confirm bluetooth connection/bonding requests.
+   */
+  @Override
+  public void onReceive(Context c, Intent intent) {
+    String action = intent.getAction();
+    Log.d("Bluetooth pairing intent received: " + action);
+    BluetoothDevice mDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+    if(action.equals(BluetoothDevice.ACTION_PAIRING_REQUEST)) {
+      int type = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, BluetoothDevice.ERROR);
+      Log.d("Processing Action Paring Request with type " + type);
+      if(type == BluetoothDevice.PAIRING_VARIANT_PASSKEY_CONFIRMATION ||
+         type == BluetoothDevice.PAIRING_VARIANT_CONSENT) {
+        mDevice.setPairingConfirmation(true);
+        Log.d("Connection confirmed");
+        abortBroadcast(); // Abort the broadcast so Settings app doesn't get it.
+      }
+    }
+    else if(action.equals(BluetoothDevice.ACTION_CONNECTION_ACCESS_REQUEST)) {
+      int type = intent.getIntExtra(BluetoothDevice.EXTRA_ACCESS_REQUEST_TYPE, BluetoothDevice.ERROR);
+      Log.d("Processing Action Connection Access Request type " + type);
+      if(type == BluetoothDevice.REQUEST_TYPE_MESSAGE_ACCESS ||
+         type == BluetoothDevice.REQUEST_TYPE_PHONEBOOK_ACCESS ||
+         type == BluetoothDevice.REQUEST_TYPE_PROFILE_CONNECTION) {
+    	  Intent newIntent = new Intent(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY);
+    	  String mReturnPackage = intent.getStringExtra(BluetoothDevice.EXTRA_PACKAGE_NAME);
+          String mReturnClass = intent.getStringExtra(BluetoothDevice.EXTRA_CLASS_NAME);
+          int mRequestType = intent.getIntExtra(BluetoothDevice.EXTRA_ACCESS_REQUEST_TYPE,
+                  BluetoothDevice.REQUEST_TYPE_MESSAGE_ACCESS);
+          if (mReturnPackage != null && mReturnClass != null) {
+              newIntent.setClassName(mReturnPackage, mReturnClass);
+          }
+    	  newIntent.putExtra(BluetoothDevice.EXTRA_CONNECTION_ACCESS_RESULT,
+    			             BluetoothDevice.CONNECTION_ACCESS_YES);
+          newIntent.putExtra(BluetoothDevice.EXTRA_ALWAYS_ALLOWED, true);
+    	  newIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice);
+    	  newIntent.putExtra(BluetoothDevice.EXTRA_ACCESS_REQUEST_TYPE, mRequestType);
+          Log.d("Sending connection access acceptance intent.");
+          abortBroadcast();
+          c.sendBroadcast(newIntent, android.Manifest.permission.BLUETOOTH_ADMIN);
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothRfcommFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothRfcommFacade.java
new file mode 100644
index 0000000..484fba5
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothRfcommFacade.java
@@ -0,0 +1,463 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import android.app.Service;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothServerSocket;
+import android.bluetooth.BluetoothSocket;
+import android.content.IntentFilter;
+import android.os.ParcelFileDescriptor;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.lang.reflect.Field;
+
+import org.apache.commons.codec.binary.Base64Codec;
+
+/**
+ * Bluetooth functions.
+ *
+ */
+// Discovery functions added by Eden Sayag
+
+public class BluetoothRfcommFacade extends RpcReceiver {
+
+  // UUID for SL4A.
+  private static final String DEFAULT_UUID = "457807c0-4897-11df-9879-0800200c9a66";
+  private static final String SDP_NAME = "SL4A";
+  private final Service mService;
+  private final BluetoothPairingHelper mPairingReceiver;
+  private final BluetoothAdapter mBluetoothAdapter;
+  private Map<String, BluetoothConnection>
+          connections = new HashMap<String, BluetoothConnection>();
+
+  public BluetoothRfcommFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mPairingReceiver = new BluetoothPairingHelper();
+    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+  }
+
+  private BluetoothConnection getConnection(String connID) throws IOException {
+    BluetoothConnection conn = null;
+    if (connID.trim().length() > 0) {
+      conn = connections.get(connID);
+    } else if (connections.size() == 1) {
+      conn = (BluetoothConnection) connections.values().toArray()[0];
+    }
+    if (conn == null) {
+      throw new IOException("Bluetooth not ready for this connID.");
+    }
+    return conn;
+  }
+
+  private String addConnection(BluetoothConnection conn) {
+    String uuid = UUID.randomUUID().toString();
+    connections.put(uuid, conn);
+    conn.setUUID(uuid);
+    return uuid;
+  }
+
+  @Rpc(description = "Connect to a device over Bluetooth. "
+                   + "Blocks until the connection is established or fails.",
+       returns = "True if the connection was established successfully.")
+  public String bluetoothRfcommConnect(
+      @RpcParameter(name = "address", description = "The mac address of the device to connect to.")
+      String address,
+      @RpcParameter(name = "uuid",
+      description = "The UUID passed here must match the UUID used by the server device.")
+      @RpcDefault(DEFAULT_UUID)
+      String uuid)
+      throws IOException {
+    BluetoothDevice mDevice;
+    BluetoothSocket mSocket;
+    BluetoothConnection conn;
+    mDevice = mBluetoothAdapter.getRemoteDevice(address);
+    mSocket = mDevice.createRfcommSocketToServiceRecord(UUID.fromString(uuid));
+
+    // Register a broadcast receiver to bypass manual confirmation
+    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_PAIRING_REQUEST);
+    mService.registerReceiver(mPairingReceiver, filter);
+
+    // Always cancel discovery because it will slow down a connection.
+    mBluetoothAdapter.cancelDiscovery();
+    mSocket.connect();
+    conn = new BluetoothConnection(mSocket);
+
+    mService.unregisterReceiver(mPairingReceiver);
+    return addConnection(conn);
+  }
+
+  @Rpc(description = "Returns active Bluetooth connections.")
+  public Map<String, String> bluetoothRfcommActiveConnections() {
+    Map<String, String> out = new HashMap<String, String>();
+    for (Map.Entry<String, BluetoothConnection> entry : connections.entrySet()) {
+      if (entry.getValue().isConnected()) {
+        out.put(entry.getKey(), entry.getValue().getRemoteBluetoothAddress());
+      }
+    }
+    return out;
+  }
+
+  @Rpc(description = "Returns the name of the connected device.")
+  public String bluetoothRfcommGetConnectedDeviceName(
+      @RpcParameter(name = "connID", description = "Connection id")
+      @RpcOptional @RpcDefault("")
+      String connID)
+      throws IOException {
+    BluetoothConnection conn = getConnection(connID);
+    return conn.getConnectedDeviceName();
+  }
+
+  @Rpc(description = "Listens for and accepts a Bluetooth connection."
+                   + "Blocks until the connection is established or fails.")
+  public String bluetoothRfcommAccept(
+      @RpcParameter(name = "uuid") @RpcDefault(DEFAULT_UUID) String uuid,
+      @RpcParameter(name = "timeout",
+                    description = "How long to wait for a new connection, 0 is wait for ever")
+      @RpcDefault("0") Integer timeout)
+      throws IOException {
+    Log.d("Accept bluetooth connection");
+    BluetoothServerSocket mServerSocket;
+    mServerSocket =
+        mBluetoothAdapter.listenUsingRfcommWithServiceRecord(SDP_NAME, UUID.fromString(uuid));
+    // Register a broadcast receiver to bypass manual confirmation
+    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_PAIRING_REQUEST);
+    mService.registerReceiver(mPairingReceiver, filter);
+
+    BluetoothSocket mSocket = mServerSocket.accept(timeout.intValue());
+    BluetoothConnection conn = new BluetoothConnection(mSocket, mServerSocket);
+    mService.unregisterReceiver(mPairingReceiver);
+    return addConnection(conn);
+  }
+
+  @Rpc(description = "Sends ASCII characters over the currently open Bluetooth connection.")
+  public void bluetoothRfcommWrite(@RpcParameter(name = "ascii") String ascii,
+      @RpcParameter(name = "connID", description = "Connection id") @RpcDefault("") String connID)
+      throws IOException {
+    BluetoothConnection conn = getConnection(connID);
+    try {
+      conn.write(ascii);
+    } catch (IOException e) {
+      connections.remove(conn.getUUID());
+      throw e;
+    }
+  }
+
+  @Rpc(description = "Read up to bufferSize ASCII characters.")
+  public String bluetoothRfcommRead(
+      @RpcParameter(name = "bufferSize") @RpcDefault("4096") Integer bufferSize,
+      @RpcParameter(name = "connID", description = "Connection id") @RpcOptional @RpcDefault("")
+      String connID)
+      throws IOException {
+    BluetoothConnection conn = getConnection(connID);
+    try {
+      return conn.read(bufferSize);
+    } catch (IOException e) {
+      connections.remove(conn.getUUID());
+      throw e;
+    }
+  }
+
+  @Rpc(description = "Send bytes over the currently open Bluetooth connection.")
+  public void bluetoothRfcommWriteBinary(
+      @RpcParameter(name = "base64",
+                    description = "A base64 encoded String of the bytes to be sent.")
+      String base64,
+      @RpcParameter(name = "connID", description = "Connection id")
+      @RpcDefault("") @RpcOptional
+      String connID)
+      throws IOException {
+    BluetoothConnection conn = getConnection(connID);
+    try {
+      conn.write(Base64Codec.decodeBase64(base64));
+    } catch (IOException e) {
+      connections.remove(conn.getUUID());
+      throw e;
+    }
+  }
+
+  @Rpc(description = "Read up to bufferSize bytes and return a chunked, base64 encoded string.")
+  public String bluetoothRfcommReadBinary(
+      @RpcParameter(name = "bufferSize") @RpcDefault("4096") Integer bufferSize,
+      @RpcParameter(name = "connID", description = "Connection id")
+      @RpcDefault("") @RpcOptional
+      String connID)
+      throws IOException {
+
+    BluetoothConnection conn = getConnection(connID);
+    try {
+      return Base64Codec.encodeBase64String(conn.readBinary(bufferSize));
+    } catch (IOException e) {
+      connections.remove(conn.getUUID());
+      throw e;
+    }
+  }
+
+  @Rpc(description = "Returns True if the next read is guaranteed not to block.")
+  public Boolean bluetoothRfcommReadReady(
+      @RpcParameter(name = "connID", description = "Connection id") @RpcDefault("") @RpcOptional
+      String connID)
+      throws IOException {
+    BluetoothConnection conn = getConnection(connID);
+    try {
+      return conn.readReady();
+    } catch (IOException e) {
+      connections.remove(conn.getUUID());
+      throw e;
+    }
+  }
+
+  @Rpc(description = "Read the next line.")
+  public String bluetoothRfcommReadLine(
+      @RpcParameter(name = "connID", description = "Connection id") @RpcOptional @RpcDefault("")
+      String connID)
+      throws IOException {
+    BluetoothConnection conn = getConnection(connID);
+    try {
+      return conn.readLine();
+    } catch (IOException e) {
+      connections.remove(conn.getUUID());
+      throw e;
+    }
+  }
+
+  @Rpc(description = "Stops Bluetooth connection.")
+  public void bluetoothRfcommStop(
+      @RpcParameter
+      (name = "connID", description = "Connection id") @RpcOptional @RpcDefault("")
+      String connID) {
+    BluetoothConnection conn;
+    try {
+      conn = getConnection(connID);
+    } catch (IOException e) {
+      e.printStackTrace();
+      return;
+    }
+    if (conn == null) {
+      return;
+    }
+
+    conn.stop();
+    connections.remove(conn.getUUID());
+  }
+
+  @Override
+  public void shutdown() {
+    for (Map.Entry<String, BluetoothConnection> entry : connections.entrySet()) {
+      entry.getValue().stop();
+    }
+    connections.clear();
+  }
+}
+
+class BluetoothConnection {
+  private BluetoothSocket mSocket;
+  private BluetoothDevice mDevice;
+  private OutputStream mOutputStream;
+  private InputStream mInputStream;
+  private BufferedReader mReader;
+  private BluetoothServerSocket mServerSocket;
+  private String UUID;
+
+  public BluetoothConnection(BluetoothSocket mSocket) throws IOException {
+    this(mSocket, null);
+  }
+
+  public BluetoothConnection(BluetoothSocket mSocket, BluetoothServerSocket mServerSocket)
+      throws IOException {
+    this.mSocket = mSocket;
+    mOutputStream = mSocket.getOutputStream();
+    mInputStream = mSocket.getInputStream();
+    mDevice = mSocket.getRemoteDevice();
+    mReader = new BufferedReader(new InputStreamReader(mInputStream, "ASCII"));
+    this.mServerSocket = mServerSocket;
+  }
+
+  public void setUUID(String UUID) {
+    this.UUID = UUID;
+  }
+
+  public String getUUID() {
+    return UUID;
+  }
+
+  public String getRemoteBluetoothAddress() {
+    return mDevice.getAddress();
+  }
+
+  public boolean isConnected() {
+    if (mSocket == null) {
+      return false;
+    }
+    try {
+      mSocket.getRemoteDevice();
+      mInputStream.available();
+      mReader.ready();
+      return true;
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
+  public void write(byte[] out) throws IOException {
+    if (mOutputStream != null) {
+      mOutputStream.write(out);
+    } else {
+      throw new IOException("Bluetooth not ready.");
+    }
+  }
+
+  public void write(String out) throws IOException {
+    this.write(out.getBytes());
+  }
+
+  public Boolean readReady() throws IOException {
+    if (mReader != null) {
+      return mReader.ready();
+    }
+    throw new IOException("Bluetooth not ready.");
+  }
+
+  public byte[] readBinary() throws IOException {
+    return this.readBinary(4096);
+  }
+
+  public byte[] readBinary(int bufferSize) throws IOException {
+    if (mReader != null) {
+      byte[] buffer = new byte[bufferSize];
+      int bytesRead = mInputStream.read(buffer);
+      if (bytesRead == -1) {
+        Log.e("Read failed.");
+        throw new IOException("Read failed.");
+      }
+      byte[] truncatedBuffer = new byte[bytesRead];
+      System.arraycopy(buffer, 0, truncatedBuffer, 0, bytesRead);
+      return truncatedBuffer;
+    }
+
+    throw new IOException("Bluetooth not ready.");
+
+  }
+
+  public String read() throws IOException {
+    return this.read(4096);
+  }
+
+  public String read(int bufferSize) throws IOException {
+    if (mReader != null) {
+      char[] buffer = new char[bufferSize];
+      int bytesRead = mReader.read(buffer);
+      if (bytesRead == -1) {
+        Log.e("Read failed.");
+        throw new IOException("Read failed.");
+      }
+      return new String(buffer, 0, bytesRead);
+    }
+    throw new IOException("Bluetooth not ready.");
+  }
+
+  public String readLine() throws IOException {
+    if (mReader != null) {
+      return mReader.readLine();
+    }
+    throw new IOException("Bluetooth not ready.");
+  }
+
+  public String getConnectedDeviceName() {
+    return mDevice.getName();
+  }
+
+  private synchronized void clearFileDescriptor() {
+    try {
+      Field field = BluetoothSocket.class.getDeclaredField("mPfd");
+      field.setAccessible(true);
+      ParcelFileDescriptor mPfd = (ParcelFileDescriptor) field.get(mSocket);
+      if (mPfd == null)
+        return;
+      mPfd.close();
+      mPfd = null;
+      try { field.set(mSocket, mPfd); }
+      catch(Exception e) {
+          Log.d("Exception setting mPfd = null in cleanCloseFix(): " + e.toString());
+      }
+    } catch (Exception e) {
+        Log.w("ParcelFileDescriptor could not be cleanly closed.", e);
+    }
+  }
+
+  public void stop() {
+    if (mSocket != null) {
+      try {
+        clearFileDescriptor();
+        mSocket.close();
+      } catch (IOException e) {
+        Log.e(e);
+      }
+    }
+    mSocket = null;
+    if (mServerSocket != null) {
+      try {
+        mServerSocket.close();
+      } catch (IOException e) {
+        Log.e(e);
+      }
+    }
+    mServerSocket = null;
+
+    if (mInputStream != null) {
+      try {
+        mInputStream.close();
+      } catch (IOException e) {
+        Log.e(e);
+      }
+    }
+    mInputStream = null;
+    if (mOutputStream != null) {
+      try {
+        mOutputStream.close();
+      } catch (IOException e) {
+        Log.e(e);
+      }
+    }
+    mOutputStream = null;
+    if (mReader != null) {
+      try {
+        mReader.close();
+      } catch (IOException e) {
+        Log.e(e);
+      }
+    }
+    mReader = null;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/GattClientFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/GattClientFacade.java
new file mode 100644
index 0000000..0a96cd9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/GattClientFacade.java
@@ -0,0 +1,956 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+
+import android.app.Service;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+import android.os.Bundle;
+
+import com.googlecode.android_scripting.ConvertUtils;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.rpc.RpcStopEvent;
+
+public class GattClientFacade extends RpcReceiver {
+    private final EventFacade mEventFacade;
+    private BluetoothAdapter mBluetoothAdapter;
+    private BluetoothManager mBluetoothManager;
+    private final Service mService;
+    private final Context mContext;
+    private final HashMap<Integer, myBluetoothGattCallback> mGattCallbackList;
+    private final HashMap<Integer, BluetoothGatt> mBluetoothGattList;
+    private final HashMap<Integer, BluetoothGattCharacteristic> mCharacteristicList;
+    private final HashMap<Integer, BluetoothGattDescriptor> mDescriptorList;
+    private final HashMap<Integer, BluetoothGattService> mGattServiceList;
+    private final HashMap<Integer, List<BluetoothGattService>> mBluetoothGattDiscoveredServicesList;
+    private final HashMap<Integer, List<BluetoothDevice>> mGattServerDiscoveredDevicesList;
+    private static int GattCallbackCount;
+    private static int BluetoothGattDiscoveredServicesCount;
+    private static int BluetoothGattCount;
+    private static int CharacteristicCount;
+    private static int DescriptorCount;
+    private static int GattServerCallbackCount;
+    private static int GattServerCount;
+    private static int GattServiceCount;
+
+    public GattClientFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mContext = mService.getApplicationContext();
+        mBluetoothAdapter = MainThread.run(mService,
+                new Callable<BluetoothAdapter>() {
+                    @Override
+                    public BluetoothAdapter call() throws Exception {
+                        return BluetoothAdapter.getDefaultAdapter();
+                    }
+                });
+        mBluetoothManager = (BluetoothManager) mContext.getSystemService(Service.BLUETOOTH_SERVICE);
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mGattCallbackList = new HashMap<Integer, myBluetoothGattCallback>();
+        mCharacteristicList = new HashMap<Integer, BluetoothGattCharacteristic>();
+        mBluetoothGattList = new HashMap<Integer, BluetoothGatt>();
+        mDescriptorList = new HashMap<Integer, BluetoothGattDescriptor>();
+        mGattServiceList = new HashMap<Integer, BluetoothGattService>();
+        mBluetoothGattDiscoveredServicesList = new HashMap<Integer, List<BluetoothGattService>>();
+        mGattServerDiscoveredDevicesList = new HashMap<Integer, List<BluetoothDevice>>();
+    }
+
+    /**
+     * Create a BluetoothGatt connection
+     *
+     * @param index of the callback to start a connection on
+     * @param macAddress the mac address of the ble device
+     * @param autoConnect Whether to directly connect to the remote device (false) or to
+     *            automatically connect as soon as the remote device becomes available (true)
+     * @return the index of the BluetoothGatt object
+     * @throws Exception
+     */
+    @Rpc(description = "Create a gatt connection")
+    public int gattClientConnectGatt(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "macAddress")
+            String macAddress,
+            @RpcParameter(name = "autoConnect")
+            Boolean autoConnect
+            ) throws Exception {
+        if (mGattCallbackList.get(index) != null) {
+            BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(macAddress);
+            BluetoothGatt mBluetoothGatt = device.connectGatt(mService.getApplicationContext(),
+                    autoConnect,
+                    mGattCallbackList.get(index));
+            BluetoothGattCount += 1;
+            mBluetoothGattList.put(BluetoothGattCount, mBluetoothGatt);
+            return BluetoothGattCount;
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Trigger discovering of services on the BluetoothGatt object
+     *
+     * @param index The BluetoothGatt object index
+     * @return true, if the remote service discovery has been started
+     * @throws Exception
+     */
+    @Rpc(description = "Trigger discovering of services on the BluetoothGatt object")
+    public boolean gattClientDiscoverServices(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).discoverServices();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Get the services from the BluetoothGatt object
+     *
+     * @param index The BluetoothGatt object index
+     * @return a list of BluetoothGattServices
+     * @throws Exception
+     */
+    @Rpc(description = "Get the services from the BluetoothGatt object")
+    public List<BluetoothGattService> gattClientGetServices(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).getServices();
+        } else {
+            throw new Exception("Invalid index input:" + Integer.toString(index));
+        }
+    }
+
+    /**
+     * Abort reliable write of a bluetooth gatt
+     *
+     * @param index the bluetooth gatt index
+     * @throws Exception
+     */
+    @Rpc(description = "Abort reliable write of a bluetooth gatt")
+    public void gattClientAbortReliableWrite(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            mBluetoothGattList.get(index).abortReliableWrite();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Begin reliable write of a bluetooth gatt
+     *
+     * @param index the bluetooth gatt index
+     * @return
+     * @throws Exception
+     */
+    @Rpc(description = "Begin reliable write of a bluetooth gatt")
+    public boolean gattClientBeginReliableWrite(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).beginReliableWrite();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Configure a bluetooth gatt's MTU
+     *
+     * @param index the bluetooth gatt index
+     * @param mtu the MTU to set
+     * @return
+     * @throws Exception
+     */
+    @Rpc(description = "true, if the new MTU value has been requested successfully")
+    public boolean gattClientRequestMtu(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "mtu")
+            Integer mtu
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).requestMtu(mtu);
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Disconnect a bluetooth gatt
+     *
+     * @param index the bluetooth gatt index
+     * @throws Exception
+     */
+    @Rpc(description = "Disconnect a bluetooth gatt")
+    @RpcStopEvent("GattConnect")
+    public void gattClientDisconnect(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            mBluetoothGattList.get(index).disconnect();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Execute reliable write on a bluetooth gatt
+     *
+     * @param index the bluetooth gatt index
+     * @return true, if the request to execute the transaction has been sent
+     * @throws Exception
+     */
+    @Rpc(description = "Execute reliable write on a bluetooth gatt")
+    public boolean gattExecuteReliableWrite(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).executeReliableWrite();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Get a list of Bluetooth Devices connnected to the bluetooth gatt
+     *
+     * @param index the bluetooth gatt index
+     * @return List of BluetoothDevice Objects
+     * @throws Exception
+     */
+    @Rpc(description = "Get a list of Bluetooth Devices connnected to the bluetooth gatt")
+    public List<BluetoothDevice> gattClientGetConnectedDevices(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).getConnectedDevices();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Get the remote bluetooth device this GATT client targets to
+     *
+     * @param index the bluetooth gatt index
+     * @return the remote bluetooth device this gatt client targets to
+     * @throws Exception
+     */
+    @Rpc(description = "Get the remote bluetooth device this GATT client targets to")
+    public BluetoothDevice gattGetDevice(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).getDevice();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Get the bluetooth devices matching input connection states
+     *
+     * @param index the bluetooth gatt index
+     * @param states the list of states to match
+     * @return The list of BluetoothDevice objects that match the states
+     * @throws Exception
+     */
+    @Rpc(description = "Get the bluetooth devices matching input connection states")
+    public List<BluetoothDevice> gattClientGetDevicesMatchingConnectionStates(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "states")
+            int[] states
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).getDevicesMatchingConnectionStates(states);
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Get the service from an input UUID
+     *
+     * @param index the bluetooth gatt index
+     * @return BluetoothGattService related to the bluetooth gatt
+     * @throws Exception
+     */
+    @Rpc(description = "Get the service from an input UUID")
+    public ArrayList<String> gattClientGetServiceUuidList(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            ArrayList<String> serviceUuidList = new ArrayList<String>();
+            for (BluetoothGattService service : mBluetoothGattList.get(index).getServices()) {
+                serviceUuidList.add(service.getUuid().toString());
+            }
+            return serviceUuidList;
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Reads the requested characteristic from the associated remote device.
+     * @param gattIndex the BluetoothGatt server accociated with the device
+     * @param discoveredServiceListIndex the index returned from the discovered
+     * services callback
+     * @param serviceIndex the service index of the discovered services
+     * @param characteristicUuid the characteristic uuid to read
+     * @return true, if the read operation was initiated successfully
+     * @throws Exception
+     */
+    @Rpc(description = "Reads the requested characteristic from the associated remote device.")
+    public boolean gattClientReadCharacteristic(
+        @RpcParameter(name = "gattIndex") Integer gattIndex,
+        @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex,
+        @RpcParameter(name = "serviceIndex") Integer serviceIndex,
+        @RpcParameter(name = "characteristicUuid") String characteristicUuid) throws Exception {
+      BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex);
+      if (bluetoothGatt == null) {
+        throw new Exception("Invalid gattIndex " + gattIndex);
+      }
+      List<BluetoothGattService> discoveredServiceList =
+          mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex);
+      if (discoveredServiceList == null) {
+        throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex);
+      }
+      BluetoothGattService gattService = discoveredServiceList.get(serviceIndex);
+      if (gattService == null) {
+        throw new Exception("Invalid serviceIndex " + serviceIndex);
+      }
+      UUID cUuid = UUID.fromString(characteristicUuid);
+      BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid);
+      if (gattCharacteristic == null) {
+        throw new Exception("Invalid characteristic uuid: " + characteristicUuid);
+      }
+      return bluetoothGatt.readCharacteristic(gattCharacteristic);
+    }
+
+    /**
+     * Reads the value for a given descriptor from the associated remote device
+     * @param gattIndex - the gatt index to use
+     * @param discoveredServiceListIndex - the discvered serivice list index
+     * @param serviceIndex - the servce index of the discoveredServiceListIndex
+     * @param characteristicUuid - the characteristic uuid in which the descriptor is
+     * @param descriptorUuid - the descriptor uuid to read
+     * @return
+     * @throws Exception
+     */
+    @Rpc(description = "Reads the value for a given descriptor from the associated remote device")
+    public boolean gattClientReadDescriptor(@RpcParameter(name = "gattIndex") Integer gattIndex,
+        @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex,
+        @RpcParameter(name = "serviceIndex") Integer serviceIndex,
+        @RpcParameter(name = "characteristicUuid") String characteristicUuid,
+        @RpcParameter(name = "descriptorUuid") String descriptorUuid) throws Exception {
+      BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex);
+      if (bluetoothGatt == null) {
+        throw new Exception("Invalid gattIndex " + gattIndex);
+      }
+      List<BluetoothGattService> gattServiceList = mBluetoothGattDiscoveredServicesList.get(
+          discoveredServiceListIndex);
+      if (gattServiceList == null) {
+        throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex);
+      }
+      BluetoothGattService gattService = gattServiceList.get(serviceIndex);
+      if (gattService == null) {
+        throw new Exception("Invalid serviceIndex " + serviceIndex);
+      }
+      UUID cUuid = UUID.fromString(characteristicUuid);
+      BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid);
+      if (gattCharacteristic == null) {
+        throw new Exception("Invalid characteristic uuid: " + characteristicUuid);
+      }
+      UUID dUuid = UUID.fromString(descriptorUuid);
+      BluetoothGattDescriptor gattDescriptor = gattCharacteristic.getDescriptor(dUuid);
+      if (gattDescriptor == null) {
+        throw new Exception("Invalid descriptor uuid: " + descriptorUuid);
+      }
+      return bluetoothGatt.readDescriptor(gattDescriptor);
+    }
+
+    /**
+     * Write the value of a given descriptor to the associated remote device
+     *
+     * @param index the bluetooth gatt index
+     * @param serviceIndex the service index to write to
+     * @param characteristicUuid the uuid where the descriptor lives
+     * @param descriptorIndex the descriptor index
+     * @return true, if the write operation was initiated successfully
+     * @throws Exception
+     */
+    @Rpc(description = "Write the value of a given descriptor to the associated remote device")
+    public boolean gattClientWriteDescriptor(@RpcParameter(name = "gattIndex") Integer gattIndex,
+        @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex,
+        @RpcParameter(name = "serviceIndex") Integer serviceIndex,
+        @RpcParameter(name = "characteristicUuid") String characteristicUuid,
+        @RpcParameter(name = "descriptorUuid") String descriptorUuid) throws Exception {
+      BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex);
+      if (bluetoothGatt == null) {
+        throw new Exception("Invalid gattIndex " + gattIndex);
+      }
+      List<BluetoothGattService> discoveredServiceList =
+          mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex);
+      if (discoveredServiceList == null) {
+        throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex);
+      }
+      BluetoothGattService gattService = discoveredServiceList.get(serviceIndex);
+      if (gattService == null) {
+        throw new Exception("Invalid serviceIndex " + serviceIndex);
+      }
+      UUID cUuid = UUID.fromString(characteristicUuid);
+      BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid);
+      if (gattCharacteristic == null) {
+        throw new Exception("Invalid characteristic uuid: " + characteristicUuid);
+      }
+      UUID dUuid = UUID.fromString(descriptorUuid);
+      BluetoothGattDescriptor gattDescriptor = gattCharacteristic.getDescriptor(dUuid);
+      if (gattDescriptor == null) {
+        throw new Exception("Invalid descriptor uuid: " + descriptorUuid);
+      }
+      return bluetoothGatt.writeDescriptor(gattDescriptor);
+    }
+
+    /**
+     * Write the value to a discovered descriptor.
+     * @param gattIndex - the gatt index to use
+     * @param discoveredServiceListIndex - the discovered service list index
+     * @param serviceIndex - the service index of the discoveredServiceListIndex
+     * @param characteristicUuid - the characteristic uuid in which the descriptor is
+     * @param descriptorUuid - the descriptor uuid to read
+     * @param value - the value to set the descriptor to
+     * @return true is the value was set to the descriptor
+     * @throws Exception
+     */
+    @Rpc(description = "Write the value of a given descriptor to the associated remote device")
+    public boolean gattClientDescriptorSetValue(@RpcParameter(name = "gattIndex") Integer gattIndex,
+        @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex,
+        @RpcParameter(name = "serviceIndex") Integer serviceIndex,
+        @RpcParameter(name = "characteristicUuid") String characteristicUuid,
+        @RpcParameter(name = "descriptorUuid") String descriptorUuid,
+        @RpcParameter(name = "value") String value) throws Exception {
+      if (mBluetoothGattList.get(gattIndex) == null) {
+        throw new Exception("Invalid gattIndex " + gattIndex);
+      }
+      List<BluetoothGattService> discoveredServiceList =
+          mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex);
+      if (discoveredServiceList == null) {
+        throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex);
+      }
+      BluetoothGattService gattService = discoveredServiceList.get(serviceIndex);
+      if (gattService == null) {
+        throw new Exception("Invalid serviceIndex " + serviceIndex);
+      }
+      UUID cUuid = UUID.fromString(characteristicUuid);
+      BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid);
+      if (gattCharacteristic == null) {
+        throw new Exception("Invalid characteristic uuid: " + characteristicUuid);
+      }
+      UUID dUuid = UUID.fromString(descriptorUuid);
+      BluetoothGattDescriptor gattDescriptor = gattCharacteristic.getDescriptor(dUuid);
+      if (gattDescriptor == null) {
+        throw new Exception("Invalid descriptor uuid: " + descriptorUuid);
+      }
+        byte[] byteArray = ConvertUtils.convertStringToByteArray(value);
+        return gattDescriptor.setValue(byteArray);
+    }
+
+    /**
+     * Write the value of a given characteristic to the associated remote device
+     *
+     * @param index the bluetooth gatt index
+     * @param serviceIndex the service where the characteristic lives
+     * @param characteristicUuid the characteristic uuid to write to
+     * @return true, if the write operation was successful
+     * @throws Exception
+     */
+    @Rpc(description = "Write the value of a given characteristic to the associated remote device")
+    public boolean gattClientWriteCharacteristic(@RpcParameter(name = "gattIndex") Integer gattIndex,
+        @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex,
+        @RpcParameter(name = "serviceIndex") Integer serviceIndex,
+        @RpcParameter(name = "characteristicUuid") String characteristicUuid) throws Exception {
+      BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex);
+      if (bluetoothGatt == null) {
+        throw new Exception("Invalid gattIndex " + gattIndex);
+      }
+      List<BluetoothGattService> discoveredServiceList =
+          mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex);
+      if (discoveredServiceList == null) {
+        throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex);
+      }
+      BluetoothGattService gattService = discoveredServiceList.get(serviceIndex);
+      if (gattService == null) {
+        throw new Exception("Invalid serviceIndex " + serviceIndex);
+      }
+      UUID cUuid = UUID.fromString(characteristicUuid);
+      BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid);
+      if (gattCharacteristic == null) {
+        throw new Exception("Invalid characteristic uuid: " + characteristicUuid);
+      }
+      return bluetoothGatt.writeCharacteristic(gattCharacteristic);
+    }
+
+    /**
+     * Write the value to a discovered characteristic.
+     * @param gattIndex - the gatt index to use
+     * @param discoveredServiceListIndex - the discovered service list index
+     * @param serviceIndex - the service index of the discoveredServiceListIndex
+     * @param characteristicUuid - the characteristic uuid in which the descriptor is
+     * @param value - the value to set the characteristic to
+     * @return true, if the value was set to the characteristic
+     * @throws Exception
+     */
+    @Rpc(description = "Write the value of a given characteristic to the associated remote device")
+    public boolean gattClientCharacteristicSetValue(@RpcParameter(name = "gattIndex") Integer gattIndex,
+        @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex,
+        @RpcParameter(name = "serviceIndex") Integer serviceIndex,
+        @RpcParameter(name = "characteristicUuid") String characteristicUuid,
+        @RpcParameter(name = "value") String value) throws Exception {
+      if (mBluetoothGattList.get(gattIndex) == null) {
+        throw new Exception("Invalid gattIndex " + gattIndex);
+      }
+      List<BluetoothGattService> discoveredServiceList =
+          mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex);
+      if (discoveredServiceList == null) {
+        throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex);
+      }
+      BluetoothGattService gattService = discoveredServiceList.get(serviceIndex);
+      if (gattService == null) {
+        throw new Exception("Invalid serviceIndex " + serviceIndex);
+      }
+      UUID cUuid = UUID.fromString(characteristicUuid);
+      BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid);
+      if (gattCharacteristic == null) {
+        throw new Exception("Invalid characteristic uuid: " + characteristicUuid);
+      }
+      byte[] byteArray = ConvertUtils.convertStringToByteArray(value);
+      return gattCharacteristic.setValue(byteArray);
+    }
+    /**
+     * Read the RSSI for a connected remote device
+     *
+     * @param index the bluetooth gatt index
+     * @return true, if the RSSI value has been requested successfully
+     * @throws Exception
+     */
+    @Rpc(description = "Read the RSSI for a connected remote device")
+    public boolean gattClientReadRSSI(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).readRemoteRssi();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Clears the internal cache and forces a refresh of the services from the remote device
+     *
+     * @param index the bluetooth gatt index
+     * @return Clears the internal cache and forces a refresh of the services from the remote
+     *         device.
+     * @throws Exception
+     */
+    @Rpc(description = "Clears the internal cache and forces a refresh of the services from the remote device")
+    public boolean gattClientRefresh(
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattList.get(index) != null) {
+            return mBluetoothGattList.get(index).refresh();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Request a connection parameter update.
+     * @param index the bluetooth gatt index
+     * @param connectionPriority connection priority
+     * @return boolean True if successful False otherwise.
+     * @throws Exception
+     */
+    @Rpc(description = "Request a connection parameter update. from the Bluetooth Gatt")
+    public boolean gattClientRequestConnectionPriority(
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "connectionPriority")
+            Integer connectionPriority
+            ) throws Exception {
+        boolean result = false;
+        if (mBluetoothGattList.get(index) != null) {
+            result = mBluetoothGattList.get(index).requestConnectionPriority(
+                    connectionPriority);
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+        return result;
+    }
+
+    /**
+     * Sets the characteristic notification of a bluetooth gatt
+     *
+     * @param index the bluetooth gatt index
+     * @param characteristicIndex the characteristic index
+     * @param enable Enable or disable notifications/indications for a given characteristic
+     * @return true, if the requested notification status was set successfully
+     * @throws Exception
+     */
+    @Rpc(description = "Sets the characteristic notification of a bluetooth gatt")
+    public boolean gattClientSetCharacteristicNotification(
+            @RpcParameter(name = "gattIndex")
+            Integer gattIndex,
+            @RpcParameter(name = "discoveredServiceListIndex")
+            Integer discoveredServiceListIndex,
+            @RpcParameter(name = "serviceIndex")
+            Integer serviceIndex,
+            @RpcParameter(name = "characteristicUuid")
+            String characteristicUuid,
+            @RpcParameter(name = "enable")
+            Boolean enable
+            ) throws Exception {
+        if (mBluetoothGattList.get(gattIndex) != null) {
+            if(mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex) != null) {
+                List<BluetoothGattService> discoveredServiceList =
+                    mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex);
+                if (discoveredServiceList.get(serviceIndex) != null) {
+                    UUID cUuid = UUID.fromString(characteristicUuid);
+                    if (discoveredServiceList.get(serviceIndex).getCharacteristic(cUuid) != null) {
+                        return mBluetoothGattList.get(gattIndex).setCharacteristicNotification(
+                                discoveredServiceList.get(serviceIndex).getCharacteristic(cUuid), enable);
+                    } else {
+                        throw new Exception ("Invalid characteristic uuid: " + characteristicUuid);
+                    }
+                } else {
+                    throw new Exception ("Invalid serviceIndex " + serviceIndex);
+                }
+            } else {
+                throw new Exception("Invalid discoveredServiceListIndex: " + discoveredServiceListIndex);
+            }
+        } else {
+            throw new Exception("Invalid gattIndex input: " + gattIndex);
+        }
+    }
+
+    /**
+     * Create a new GattCallback object
+     *
+     * @return the index of the callback object
+     */
+    @Rpc(description = "Create a new GattCallback object")
+    public Integer gattCreateGattCallback() {
+        GattCallbackCount += 1;
+        int index = GattCallbackCount;
+        mGattCallbackList.put(index, new myBluetoothGattCallback(index));
+        return index;
+    }
+
+    /**
+     * Returns the list of discovered Bluetooth Gatt Services.
+     * @throws Exception
+     */
+    @Rpc(description = "Get Bluetooth Gatt Services")
+    public int gattClientGetDiscoveredServicesCount (
+            @RpcParameter(name = "index")
+            Integer index
+            ) throws Exception {
+        if (mBluetoothGattDiscoveredServicesList.get(index) != null) {
+            return mBluetoothGattDiscoveredServicesList.get(index).size();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Returns the discovered Bluetooth Gatt Service Uuid.
+     * @throws Exception
+     */
+    @Rpc(description = "Get Bluetooth Gatt Service Uuid")
+    public String gattClientGetDiscoveredServiceUuid (
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "serviceIndex")
+            Integer serviceIndex
+            ) throws Exception {
+        List<BluetoothGattService> mBluetoothServiceList =
+            mBluetoothGattDiscoveredServicesList.get(index);
+        if (mBluetoothServiceList != null) {
+            return mBluetoothServiceList.get(serviceIndex).getUuid().toString();
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Get discovered characteristic uuids from the pheripheral device.
+     * @param index the index of the bluetooth gatt discovered services list
+     * @param serviceIndex the service to get
+     * @return the list of characteristic uuids
+     * @throws Exception
+     */
+    @Rpc(description = "Get Bluetooth Gatt Services")
+    public ArrayList<String> gattClientGetDiscoveredCharacteristicUuids (
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "serviceIndex")
+            Integer serviceIndex
+            ) throws Exception {
+        if (mBluetoothGattDiscoveredServicesList.get(index) != null) {
+            if (mBluetoothGattDiscoveredServicesList.get(index).get(serviceIndex) != null) {
+                ArrayList<String> uuidList = new ArrayList<String>();
+                List<BluetoothGattCharacteristic> charList = mBluetoothGattDiscoveredServicesList.get(index).get(serviceIndex).getCharacteristics();
+                for (BluetoothGattCharacteristic mChar : charList) {
+                    uuidList.add(mChar.getUuid().toString());
+                }
+                return uuidList;
+            } else {
+                throw new Exception("Invalid serviceIndex input:" + index);
+            }
+        } else {
+            throw new Exception("Invalid index input:" + index);
+        }
+    }
+
+    /**
+     * Get discovered descriptor uuids from the pheripheral device.
+     * @param index the discovered services list index
+     * @param serviceIndex the service index of the discovered services list
+     * @param characteristicUuid the characteristicUuid to select from the
+     * discovered service which contains the list of descriptors.
+     * @return the list of descriptor uuids
+     * @throws Exception
+     */
+    @Rpc(description = "Get Bluetooth Gatt Services")
+    public ArrayList<String> gattClientGetDiscoveredDescriptorUuids (
+            @RpcParameter(name = "index")
+            Integer index,
+            @RpcParameter(name = "serviceIndex")
+            Integer serviceIndex,
+            @RpcParameter(name = "characteristicUuid")
+            String characteristicUuid
+            ) throws Exception {
+        if (mBluetoothGattDiscoveredServicesList.get(index) != null) {
+            if (mBluetoothGattDiscoveredServicesList.get(index).get(serviceIndex) != null) {
+                BluetoothGattService service = mBluetoothGattDiscoveredServicesList.get(index).get(serviceIndex);
+                UUID cUuid = UUID.fromString(characteristicUuid);
+                if (service.getCharacteristic(cUuid) != null) {
+                    ArrayList<String> uuidList = new ArrayList<String>();
+                    for (BluetoothGattDescriptor mDesc : service.getCharacteristic(cUuid).getDescriptors()) {
+                        uuidList.add(mDesc.getUuid().toString());
+                    }
+                    return uuidList;
+                } else {
+                    throw new Exception("Invalid characeristicUuid : "
+                            + characteristicUuid);
+                }
+            } else {
+                throw new Exception("Invalid serviceIndex input:"
+                        + index);
+            }
+        } else {
+            throw new Exception("Invalid index input:"
+                    + index);
+        }
+    }
+
+    private class myBluetoothGattCallback extends BluetoothGattCallback {
+        private final Bundle mResults;
+        private final int index;
+        private final String mEventType;
+
+        public myBluetoothGattCallback(int idx) {
+            mResults = new Bundle();
+            mEventType = "GattConnect";
+            index = idx;
+        }
+
+        @Override
+        public void onConnectionStateChange(BluetoothGatt gatt, int status,
+                int newState) {
+            Log.d("gatt_connect change onConnectionStateChange " + mEventType + " " + index);
+            if (newState == BluetoothProfile.STATE_CONNECTED) {
+                Log.d("State Connected to mac address "
+                        + gatt.getDevice().getAddress() + " status " + status);
+            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
+                Log.d("State Disconnected from mac address "
+                        + gatt.getDevice().getAddress() + " status " + status);
+            } else if (newState == BluetoothProfile.STATE_CONNECTING) {
+                Log.d("State Connecting to mac address "
+                        + gatt.getDevice().getAddress() + " status " + status);
+            } else if (newState == BluetoothProfile.STATE_DISCONNECTING) {
+                Log.d("State Disconnecting from mac address "
+                        + gatt.getDevice().getAddress() + " status " + status);
+            }
+            mResults.putInt("Status", status);
+            mResults.putInt("State", newState);
+            mEventFacade
+                    .postEvent(mEventType + index + "onConnectionStateChange", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
+            Log.d("gatt_connect change onServicesDiscovered " + mEventType + " " + index);
+            int idx = BluetoothGattDiscoveredServicesCount++;
+            mBluetoothGattDiscoveredServicesList.put(idx, gatt.getServices());
+            mResults.putInt("ServicesIndex", idx);
+            mResults.putInt("Status", status);
+            for (BluetoothGattService se: gatt.getServices()) {
+                System.out.println("SWAG: " + se.getUuid().toString());
+            }
+            mEventFacade
+                    .postEvent(mEventType + index + "onServicesDiscovered", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onCharacteristicRead(BluetoothGatt gatt,
+                BluetoothGattCharacteristic characteristic,
+                int status) {
+            Log.d("gatt_connect change onCharacteristicRead " + mEventType + " " + index);
+            mResults.putInt("Status", status);
+            mResults.putString("CharacteristicUuid", characteristic.getUuid().toString());
+            mEventFacade
+                    .postEvent(mEventType + index + "onCharacteristicRead", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onCharacteristicWrite(BluetoothGatt gatt,
+                BluetoothGattCharacteristic characteristic, int status) {
+            Log.d("gatt_connect change onCharacteristicWrite " + mEventType + " " + index);
+            mResults.putInt("Status", status);
+            mResults.putString("CharacteristicUuid", characteristic.getUuid().toString());
+            mEventFacade
+                    .postEvent(mEventType + index + "onCharacteristicWrite", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onCharacteristicChanged(BluetoothGatt gatt,
+                BluetoothGattCharacteristic characteristic) {
+            Log.d("gatt_connect change onCharacteristicChanged " + mEventType + " " + index);
+            mResults.putInt("ID", index);
+            mResults.putString("CharacteristicUuid", characteristic.getUuid().toString());
+            mEventFacade
+                    .postEvent(mEventType + index + "onCharacteristicChanged", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor,
+                int status) {
+            Log.d("gatt_connect change onServicesDiscovered " + mEventType + " " + index);
+            mResults.putInt("Status", status);
+            mResults.putString("DescriptorUuid", descriptor.getUuid().toString());
+            mEventFacade
+                    .postEvent(mEventType + index + "onDescriptorRead", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor,
+                int status) {
+            Log.d("gatt_connect change onDescriptorWrite " + mEventType + " " + index);
+            mResults.putInt("ID", index);
+            mResults.putInt("Status", status);
+            mResults.putString("DescriptorUuid", descriptor.getUuid().toString());
+            mEventFacade
+                    .postEvent(mEventType + index + "onDescriptorWrite", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
+            Log.d("gatt_connect change onReliableWriteCompleted " + mEventType + " "
+                    + index);
+            mResults.putInt("Status", status);
+            mEventFacade
+                    .postEvent(mEventType + index + "onReliableWriteCompleted", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
+            Log.d("gatt_connect change onReadRemoteRssi " + mEventType + " " + index);
+            mResults.putInt("Status", status);
+            mResults.putInt("Rssi", rssi);
+            mEventFacade
+                    .postEvent(mEventType + index + "onReadRemoteRssi", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
+            Log.d("gatt_connect change onMtuChanged " + mEventType + " " + index);
+            mResults.putInt("Status", status);
+            mResults.putInt("MTU", mtu);
+            mEventFacade
+                    .postEvent(mEventType + index + "onMtuChanged", mResults.clone());
+            mResults.clear();
+        }
+    }
+
+    @Override
+    public void shutdown() {
+        if (!mBluetoothGattList.isEmpty()) {
+            if (mBluetoothGattList.values() != null) {
+                for (BluetoothGatt mBluetoothGatt : mBluetoothGattList.values()) {
+                    mBluetoothGatt.close();
+                }
+            }
+        }
+        mGattCallbackList.clear();
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/bluetooth/GattServerFacade.java b/Common/src/com/googlecode/android_scripting/facade/bluetooth/GattServerFacade.java
new file mode 100644
index 0000000..df03fe2
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/bluetooth/GattServerFacade.java
@@ -0,0 +1,535 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.bluetooth;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+
+import android.app.Service;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattServer;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattServerCallback;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+import android.os.Bundle;
+
+import com.googlecode.android_scripting.ConvertUtils;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+public class GattServerFacade extends RpcReceiver {
+  private final EventFacade mEventFacade;
+  private BluetoothAdapter mBluetoothAdapter;
+  private BluetoothManager mBluetoothManager;
+  private final Service mService;
+  private final Context mContext;
+  private final HashMap<Integer, BluetoothGattCharacteristic> mCharacteristicList;
+  private final HashMap<Integer, BluetoothGattDescriptor> mDescriptorList;
+  private final HashMap<Integer, BluetoothGattServer> mBluetoothGattServerList;
+  private final HashMap<Integer, myBluetoothGattServerCallback> mBluetoothGattServerCallbackList;
+  private final HashMap<Integer, BluetoothGattService> mGattServiceList;
+  private final HashMap<Integer, List<BluetoothGattService>> mBluetoothGattDiscoveredServicesList;
+  private final HashMap<Integer, List<BluetoothDevice>> mGattServerDiscoveredDevicesList;
+  private static int CharacteristicCount;
+  private static int DescriptorCount;
+  private static int GattServerCallbackCount;
+  private static int GattServerCount;
+  private static int GattServiceCount;
+
+  public GattServerFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mContext = mService.getApplicationContext();
+    mBluetoothAdapter = MainThread.run(mService, new Callable<BluetoothAdapter>() {
+      @Override
+      public BluetoothAdapter call() throws Exception {
+        return BluetoothAdapter.getDefaultAdapter();
+      }
+    });
+    mBluetoothManager = (BluetoothManager) mContext.getSystemService(Service.BLUETOOTH_SERVICE);
+    mEventFacade = manager.getReceiver(EventFacade.class);
+    mCharacteristicList = new HashMap<Integer, BluetoothGattCharacteristic>();
+    mDescriptorList = new HashMap<Integer, BluetoothGattDescriptor>();
+    mBluetoothGattServerList = new HashMap<Integer, BluetoothGattServer>();
+    mBluetoothGattServerCallbackList = new HashMap<Integer, myBluetoothGattServerCallback>();
+    mGattServiceList = new HashMap<Integer, BluetoothGattService>();
+    mBluetoothGattDiscoveredServicesList = new HashMap<Integer, List<BluetoothGattService>>();
+    mGattServerDiscoveredDevicesList = new HashMap<Integer, List<BluetoothDevice>>();
+  }
+
+  /**
+   * Open a new Gatt server.
+   *
+   * @param index the bluetooth gatt server callback to open on
+   * @return the index of the newly opened gatt server
+   * @throws Exception
+   */
+  @Rpc(description = "Open new gatt server")
+  public int gattServerOpenGattServer(@RpcParameter(name = "index") Integer index)
+      throws Exception {
+    if (mBluetoothGattServerCallbackList.get(index) != null) {
+      BluetoothGattServer mGattServer =
+          mBluetoothManager.openGattServer(mContext, mBluetoothGattServerCallbackList.get(index));
+      GattServerCount += 1;
+      int in = GattServerCount;
+      mBluetoothGattServerList.put(in, mGattServer);
+      return in;
+    } else {
+      throw new Exception("Invalid index input:" + Integer.toString(index));
+    }
+  }
+
+  /**
+   * Add a service to a bluetooth gatt server
+   *
+   * @param index the bluetooth gatt server to add a service to
+   * @param serviceIndex the service to add to the bluetooth gatt server
+   * @throws Exception
+   */
+  @Rpc(description = "Add service to bluetooth gatt server")
+  public void gattServerAddService(@RpcParameter(name = "index") Integer index,
+      @RpcParameter(name = "serviceIndex") Integer serviceIndex) throws Exception {
+    if (mBluetoothGattServerList.get(index) != null) {
+      if (mGattServiceList.get(serviceIndex) != null) {
+        mBluetoothGattServerList.get(index).addService(mGattServiceList.get(serviceIndex));
+      } else {
+        throw new Exception("Invalid serviceIndex input:" + Integer.toString(serviceIndex));
+      }
+    } else {
+      throw new Exception("Invalid index input:" + Integer.toString(index));
+    }
+  }
+
+  /**
+   * Get connected devices of the gatt server
+   *
+   * @param gattServerIndex the gatt server index
+   * @throws Exception
+   */
+  @Rpc(description = "Return a list of connected gatt devices.")
+  public List<BluetoothDevice> gattServerGetConnectedDevices(
+      @RpcParameter(name = "gattServerIndex") Integer gattServerIndex) throws Exception {
+    if (mBluetoothGattServerList.get(gattServerIndex) == null) {
+      throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
+    }
+    List<BluetoothDevice> connectedDevices =
+        mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT_SERVER);
+    mGattServerDiscoveredDevicesList.put(gattServerIndex, connectedDevices);
+    return connectedDevices;
+  }
+
+  /**
+   * Get connected devices of the gatt server
+   *
+   * @param gattServerIndex the gatt server index
+   * @param bluetoothDeviceIndex the remotely connected bluetooth device
+   * @param requestId the ID of the request that was received with the callback
+   * @param status the status of the request to be sent to the remote devices
+   * @param offset value offset for partial read/write response
+   * @param value the value of the attribute that was read/written
+   * @throws Exception
+   */
+  @Rpc(description = "Send a response after a write.")
+  public void gattServerSendResponse(
+      @RpcParameter(name = "gattServerIndex") Integer gattServerIndex,
+      @RpcParameter(name = "bluetoothDeviceIndex") Integer bluetoothDeviceIndex,
+      @RpcParameter(name = "requestId") Integer requestId,
+      @RpcParameter(name = "status") Integer status, @RpcParameter(name = "offset") Integer offset,
+      @RpcParameter(name = "value") String value) throws Exception {
+
+    BluetoothGattServer gattServer = mBluetoothGattServerList.get(gattServerIndex);
+    if (gattServer == null)
+      throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
+    List<BluetoothDevice> connectedDevices = mGattServerDiscoveredDevicesList.get(gattServerIndex);
+    if (connectedDevices == null)
+      throw new Exception(
+          "Connected device list empty for gattServerIndex:" + Integer.toString(gattServerIndex));
+    BluetoothDevice bluetoothDevice = connectedDevices.get(bluetoothDeviceIndex);
+    if (bluetoothDevice == null)
+      throw new Exception(
+          "Invalid bluetoothDeviceIndex: " + Integer.toString(bluetoothDeviceIndex));
+    gattServer.sendResponse(bluetoothDevice, requestId, status, offset,
+        ConvertUtils.convertStringToByteArray(value));
+  }
+
+  /**
+   * Create a new bluetooth gatt service
+   *
+   * @param uuid the UUID that characterises the service
+   * @param serviceType the service type
+   * @return The index of the new bluetooth gatt service
+   */
+  @Rpc(description = "Create new bluetooth gatt service")
+  public int gattServerCreateService(@RpcParameter(name = "uuid") String uuid,
+      @RpcParameter(name = "serviceType") Integer serviceType) {
+    GattServiceCount += 1;
+    int index = GattServiceCount;
+    mGattServiceList.put(index, new BluetoothGattService(UUID.fromString(uuid), serviceType));
+    return index;
+  }
+
+  /**
+   * Add a characteristic to a bluetooth gatt service
+   *
+   * @param index the bluetooth gatt service index
+   * @param serviceUuid the service Uuid to get
+   * @param characteristicIndex the character index to use
+   * @throws Exception
+   */
+  @Rpc(description = "Add a characteristic to a bluetooth gatt service")
+  public void gattServiceAddCharacteristic(@RpcParameter(name = "index") Integer index,
+      @RpcParameter(name = "serviceUuid") String serviceUuid,
+      @RpcParameter(name = "characteristicIndex") Integer characteristicIndex) throws Exception {
+    if (mBluetoothGattServerList.get(index) != null
+        && mBluetoothGattServerList.get(index).getService(UUID.fromString(serviceUuid)) != null
+        && mCharacteristicList.get(characteristicIndex) != null) {
+      mBluetoothGattServerList.get(index).getService(UUID.fromString(serviceUuid))
+          .addCharacteristic(mCharacteristicList.get(characteristicIndex));
+    } else {
+      if (mBluetoothGattServerList.get(index) == null) {
+        throw new Exception("Invalid index input:" + index);
+      } else if (mCharacteristicList.get(characteristicIndex) == null) {
+        throw new Exception("Invalid characteristicIndex input:" + characteristicIndex);
+      } else {
+        throw new Exception("Invalid serviceUuid input:" + serviceUuid);
+      }
+    }
+  }
+
+  /**
+   * Add a characteristic to a bluetooth gatt service
+   *
+   * @param index the bluetooth gatt service to add a characteristic to
+   * @param characteristicIndex the characteristic to add
+   * @throws Exception
+   */
+  @Rpc(description = "Add a characteristic to a bluetooth gatt service")
+  public void gattServerAddCharacteristicToService(@RpcParameter(name = "index") Integer index,
+      @RpcParameter(name = "characteristicIndex") Integer characteristicIndex
+
+  ) throws Exception {
+    if (mGattServiceList.get(index) != null) {
+      if (mCharacteristicList.get(characteristicIndex) != null) {
+        mGattServiceList.get(index).addCharacteristic(mCharacteristicList.get(characteristicIndex));
+      } else {
+        throw new Exception("Invalid index input:" + index);
+      }
+    } else {
+      throw new Exception("Invalid index input:" + index);
+    }
+  }
+
+  /**
+   * Close a bluetooth gatt
+   *
+   * @param index the bluetooth gatt index to close
+   * @throws Exception
+   */
+  @Rpc(description = "Close a bluetooth gatt")
+  public void gattServerClose(@RpcParameter(name = "index") Integer index) throws Exception {
+    if (mBluetoothGattServerList.get(index) != null) {
+      mBluetoothGattServerList.get(index).close();
+    } else {
+      throw new Exception("Invalid index input:" + index);
+    }
+  }
+
+  /**
+   * Get a list of Bluetooth Devices connnected to the bluetooth gatt
+   *
+   * @param index the bluetooth gatt index
+   * @return List of BluetoothDevice Objects
+   * @throws Exception
+   */
+  @Rpc(description = "Get a list of Bluetooth Devices connnected to the bluetooth gatt")
+  public List<BluetoothDevice> gattGetConnectedDevices(@RpcParameter(name = "index") Integer index)
+      throws Exception {
+    if (mBluetoothGattServerList.get(index) != null) {
+      return mBluetoothGattServerList.get(index).getConnectedDevices();
+    } else {
+      throw new Exception("Invalid index input:" + index);
+    }
+  }
+
+  /**
+   * Get the service from an input UUID
+   *
+   * @param index the bluetooth gatt index
+   * @return BluetoothGattService related to the bluetooth gatt
+   * @throws Exception
+   */
+  @Rpc(description = "Get the service from an input UUID")
+  public ArrayList<String> gattGetServiceUuidList(@RpcParameter(name = "index") Integer index)
+      throws Exception {
+    if (mBluetoothGattServerList.get(index) != null) {
+      ArrayList<String> serviceUuidList = new ArrayList<String>();
+      for (BluetoothGattService service : mBluetoothGattServerList.get(index).getServices()) {
+        serviceUuidList.add(service.getUuid().toString());
+      }
+      return serviceUuidList;
+    } else {
+      throw new Exception("Invalid index input:" + index);
+    }
+  }
+
+  /**
+   * Get the service from an input UUID
+   *
+   * @param index the bluetooth gatt index
+   * @param uuid the String uuid that matches the service
+   * @return BluetoothGattService related to the bluetooth gatt
+   * @throws Exception
+   */
+  @Rpc(description = "Get the service from an input UUID")
+  public BluetoothGattService gattGetService(@RpcParameter(name = "index") Integer index,
+      @RpcParameter(name = "uuid") String uuid) throws Exception {
+    if (mBluetoothGattServerList.get(index) != null) {
+      return mBluetoothGattServerList.get(index).getService(UUID.fromString(uuid));
+    } else {
+      throw new Exception("Invalid index input:" + index);
+    }
+  }
+
+  /**
+   * Add a descriptor to a bluetooth gatt characteristic
+   *
+   * @param index the bluetooth gatt characteristic to add a descriptor to
+   * @param descriptorIndex the descritor index to add to the characteristic
+   * @throws Exception
+   */
+  @Rpc(description = "add descriptor to blutooth gatt characteristic")
+  public void gattServerCharacteristicAddDescriptor(@RpcParameter(name = "index") Integer index,
+      @RpcParameter(name = "descriptorIndex") Integer descriptorIndex) throws Exception {
+    if (mCharacteristicList.get(index) != null) {
+      if (mDescriptorList.get(descriptorIndex) != null) {
+        mCharacteristicList.get(index).addDescriptor(mDescriptorList.get(descriptorIndex));
+      } else {
+        throw new Exception("Invalid descriptorIndex input:" + descriptorIndex);
+      }
+    } else {
+      throw new Exception("Invalid index input:" + index);
+    }
+  }
+
+  /**
+   * Create a new Characteristic object
+   *
+   * @param characteristicUuid uuid The UUID for this characteristic
+   * @param property Properties of this characteristic
+   * @param permission permissions Permissions for this characteristic
+   * @return
+   */
+  @Rpc(description = "Create a new Characteristic object")
+  public int gattServerCreateBluetoothGattCharacteristic(
+      @RpcParameter(name = "characteristicUuid") String characteristicUuid,
+      @RpcParameter(name = "property") Integer property,
+      @RpcParameter(name = "permission") Integer permission) {
+    CharacteristicCount += 1;
+    int index = CharacteristicCount;
+    BluetoothGattCharacteristic characteristic =
+        new BluetoothGattCharacteristic(UUID.fromString(characteristicUuid), property, permission);
+    mCharacteristicList.put(index, characteristic);
+    return index;
+  }
+
+  /**
+   * Create a new GattCallback object
+   *
+   * @return the index of the callback object
+   */
+  @Rpc(description = "Create a new GattCallback object")
+  public Integer gattServerCreateGattServerCallback() {
+    GattServerCallbackCount += 1;
+    int index = GattServerCallbackCount;
+    mBluetoothGattServerCallbackList.put(index, new myBluetoothGattServerCallback(index));
+    return index;
+  }
+
+  /**
+   * Create a new Descriptor object
+   *
+   * @param descriptorUuid the UUID for this descriptor
+   * @param permissions Permissions for this descriptor
+   * @return the index of the Descriptor object
+   */
+  @Rpc(description = "Create a new Descriptor object")
+  public int gattServerCreateBluetoothGattDescriptor(
+      @RpcParameter(name = "descriptorUuid") String descriptorUuid,
+      @RpcParameter(name = "permissions") Integer permissions) {
+    DescriptorCount += 1;
+    int index = DescriptorCount;
+    BluetoothGattDescriptor descriptor =
+        new BluetoothGattDescriptor(UUID.fromString(descriptorUuid), permissions);
+    mDescriptorList.put(index, descriptor);
+    return index;
+  }
+
+  private class myBluetoothGattServerCallback extends BluetoothGattServerCallback {
+    private final Bundle mResults;
+    private final int index;
+    private final String mEventType;
+
+    public myBluetoothGattServerCallback(int idx) {
+      mResults = new Bundle();
+      mEventType = "GattServer";
+      index = idx;
+    }
+
+    @Override
+    public void onServiceAdded(int status, BluetoothGattService service) {
+      Log.d("gatt_server change onServiceAdded " + mEventType + " " + index);
+      mResults.putString("serviceUuid", service.getUuid().toString());
+      mResults.putInt("instanceId", service.getInstanceId());
+      mEventFacade.postEvent(mEventType + index + "onServiceAdded", mResults.clone());
+      mResults.clear();
+    }
+
+    @Override
+    public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset,
+        BluetoothGattCharacteristic characteristic) {
+      Log.d("gatt_server change onCharacteristicReadRequest " + mEventType + " " + index);
+      mResults.putInt("requestId", requestId);
+      mResults.putInt("offset", offset);
+      mResults.putInt("instanceId", characteristic.getInstanceId());
+      mResults.putInt("properties", characteristic.getProperties());
+      mResults.putString("uuid", characteristic.getUuid().toString());
+      mResults.putInt("permissions", characteristic.getPermissions());
+      mEventFacade.postEvent(mEventType + index + "onCharacteristicReadRequest", mResults.clone());
+      mResults.clear();
+    }
+
+    @Override
+    public void onCharacteristicWriteRequest(BluetoothDevice device, int requestId,
+        BluetoothGattCharacteristic characteristic, boolean preparedWrite, boolean responseNeeded,
+        int offset, byte[] value) {
+      Log.d("gatt_server change onCharacteristicWriteRequest " + mEventType + " " + index);
+      mResults.putInt("requestId", requestId);
+      mResults.putInt("offset", offset);
+      mResults.putParcelable("BluetoothDevice", device);
+      mResults.putBoolean("preparedWrite", preparedWrite);
+      mResults.putBoolean("responseNeeded", responseNeeded);
+      mResults.putString("value", ConvertUtils.convertByteArrayToString(value));
+      mResults.putInt("instanceId", characteristic.getInstanceId());
+      mResults.putInt("properties", characteristic.getProperties());
+      mResults.putString("uuid", characteristic.getUuid().toString());
+      mResults.putInt("permissions", characteristic.getPermissions());
+      mEventFacade.postEvent(mEventType + index + "onCharacteristicWriteRequest", mResults.clone());
+      mResults.clear();
+
+    }
+
+    @Override
+    public void onDescriptorReadRequest(BluetoothDevice device, int requestId, int offset,
+        BluetoothGattDescriptor descriptor) {
+      Log.d("gatt_server change onDescriptorReadRequest " + mEventType + " " + index);
+      mResults.putInt("requestId", requestId);
+      mResults.putInt("offset", offset);
+      mResults.putParcelable("BluetoothDevice", device);
+      mResults.putInt("instanceId", descriptor.getInstanceId());
+      mResults.putInt("permissions", descriptor.getPermissions());
+      mResults.putString("uuid", descriptor.getUuid().toString());
+      mEventFacade.postEvent(mEventType + index + "onDescriptorReadRequest", mResults.clone());
+      mResults.clear();
+    }
+
+    @Override
+    public void onDescriptorWriteRequest(BluetoothDevice device, int requestId,
+        BluetoothGattDescriptor descriptor, boolean preparedWrite, boolean responseNeeded,
+        int offset, byte[] value) {
+      Log.d("gatt_server change onDescriptorWriteRequest " + mEventType + " " + index);
+      mResults.putInt("requestId", requestId);
+      mResults.putInt("offset", offset);
+      mResults.putParcelable("BluetoothDevice", device);
+      mResults.putBoolean("preparedWrite", preparedWrite);
+      mResults.putBoolean("responseNeeded", responseNeeded);
+      mResults.putString("value", ConvertUtils.convertByteArrayToString(value));
+      mResults.putInt("instanceId", descriptor.getInstanceId());
+      mResults.putInt("permissions", descriptor.getPermissions());
+      mResults.putString("uuid", descriptor.getUuid().toString());
+      mEventFacade.postEvent(mEventType + index + "onDescriptorWriteRequest", mResults.clone());
+      mResults.clear();
+    }
+
+    @Override
+    public void onExecuteWrite(BluetoothDevice device, int requestId, boolean execute) {
+      Log.d("gatt_server change onExecuteWrite " + mEventType + " " + index);
+      mResults.putParcelable("BluetoothDevice", device);
+      mResults.putInt("requestId", requestId);
+      mResults.putBoolean("execute", execute);
+      mEventFacade.postEvent(mEventType + index + "onExecuteWrite", mResults.clone());
+      mResults.clear();
+    }
+
+    @Override
+    public void onNotificationSent(BluetoothDevice device, int status) {
+      Log.d("gatt_server change onNotificationSent " + mEventType + " " + index);
+      mResults.putParcelable("BluetoothDevice", device);
+      mResults.putInt("status", status);
+      mEventFacade.postEvent(mEventType + index + "onNotificationSent", mResults.clone());
+      mResults.clear();
+    }
+
+    @Override
+    public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
+      Log.d("gatt_server change onConnectionStateChange " + mEventType + " " + index);
+      if (newState == BluetoothProfile.STATE_CONNECTED) {
+        Log.d("State Connected to mac address " + device.getAddress() + " status " + status);
+      } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
+        Log.d("State Disconnected from mac address " + device.getAddress() + " status " + status);
+      }
+      mResults.putParcelable("BluetoothDevice", device);
+      mResults.putInt("status", status);
+      mResults.putInt("newState", newState);
+      mEventFacade.postEvent(mEventType + index + "onConnectionStateChange", mResults.clone());
+      mResults.clear();
+    }
+
+    @Override
+    public void onMtuChanged(BluetoothDevice device, int mtu) {
+      Log.d("gatt_server change onMtuChanged " + mEventType + " " + index);
+      mResults.putParcelable("BluetoothDevice", device);
+      mResults.putInt("mtu", mtu);
+      mEventFacade.postEvent(mEventType + index + "onMtuChanged", mResults.clone());
+      mResults.clear();
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    if (!mBluetoothGattServerList.isEmpty()) {
+      if (mBluetoothGattServerList.values() != null) {
+        for (BluetoothGattServer mBluetoothGattServer : mBluetoothGattServerList.values()) {
+          mBluetoothGattServer.close();
+        }
+      }
+    }
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/media/AudioManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/media/AudioManagerFacade.java
new file mode 100644
index 0000000..b611678
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/media/AudioManagerFacade.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.media;
+
+import android.app.Service;
+import android.content.Context;
+import android.media.AudioManager;
+import android.media.AudioManager.OnAudioFocusChangeListener;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+
+public class AudioManagerFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final EventFacade mEventFacade;
+    private final AudioManager mAudio;
+    private final OnAudioFocusChangeListener mFocusChangeListener;
+    private boolean mIsFocused;
+
+    public AudioManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mAudio = (AudioManager) mService.getSystemService(Context.AUDIO_SERVICE);
+        mFocusChangeListener = new OnAudioFocusChangeListener() {
+            public void onAudioFocusChange(int focusChange) {
+                if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK) {
+                    mIsFocused = false;
+                } else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
+                    mIsFocused = true;
+                }
+            }
+        };
+    }
+
+    @Rpc(description = "Checks whether any music is active.")
+    public Boolean audioIsMusicActive() {
+        return mAudio.isMusicActive();
+    }
+
+    @Rpc(description = "Checks whether A2DP audio routing to the Bluetooth headset is on or off.")
+    public Boolean audioIsBluetoothA2dpOn() {
+        return mAudio.isBluetoothA2dpOn();
+    }
+
+    @Rpc(description = "Request audio focus for sl4a.")
+    public Boolean audioRequestAudioFocus() {
+        int status = mAudio.requestAudioFocus(mFocusChangeListener,
+                                              AudioManager.STREAM_MUSIC,
+                                              AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK);
+        if (status == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+            mIsFocused = true;
+            return true;
+        }
+        mIsFocused = false;
+        return false;
+    }
+
+    @Rpc(description = "Whether sl4a has the audio focus or not.")
+    public Boolean audioIsFocused() {
+        return mIsFocused;
+    }
+
+    @Override
+    public void shutdown() {
+        mAudio.abandonAudioFocus(mFocusChangeListener);
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/media/MediaButtonCallback.java b/Common/src/com/googlecode/android_scripting/facade/media/MediaButtonCallback.java
new file mode 100644
index 0000000..fc7c11e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/media/MediaButtonCallback.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.media;
+
+import android.content.Intent;
+import android.media.session.MediaSession;
+import android.os.Bundle;
+import android.view.KeyEvent;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+
+public class MediaButtonCallback extends MediaSession.Callback {
+    private final EventFacade mEventFacade;
+    public MediaButtonCallback(EventFacade eventFacade) {
+        this.mEventFacade = eventFacade;
+    }
+    private void handleKeyEvent(KeyEvent event) {
+        int keyCode = event.getKeyCode();
+        Log.d("Received ACTION_DOWN with keycode " + keyCode);
+        Bundle msg = new Bundle();
+        if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY) {
+            msg.putString("ButtonPressed", "Play");
+        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_PAUSE) {
+            msg.putString("ButtonPressed", "Pause");
+        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) {
+            msg.putString("ButtonPressed", "PlayPause");
+        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP) {
+            msg.putString("ButtonPressed", "Stop");
+        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_NEXT) {
+            msg.putString("ButtonPressed", "Next");
+        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_PREVIOUS) {
+            msg.putString("ButtonPressed", "Previous");
+        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD) {
+            msg.putString("ButtonPressed", "Forward");
+        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_REWIND) {
+            msg.putString("ButtonPressed", "Rewind");
+        }
+        Log.d("Sending MediaButton event with ButtonPressed value "
+              + msg.getString("ButtonPressed"));
+        this.mEventFacade.postEvent("MediaButton", msg);
+    }
+
+    @Override
+    public boolean onMediaButtonEvent(Intent mediaButtonIntent) {
+        String action = mediaButtonIntent.getAction();
+        Log.d("Received intent with action " + action);
+        if (action.equals(Intent.ACTION_MEDIA_BUTTON)) {
+            KeyEvent event = (KeyEvent) mediaButtonIntent
+                                        .getParcelableExtra(Intent.EXTRA_KEY_EVENT);
+            int keyAction = event.getAction();
+            Log.d("Received KeyEvent with action " + keyAction);
+            if (keyAction == KeyEvent.ACTION_DOWN) {
+                handleKeyEvent(event);
+            } else if (keyAction == KeyEvent.ACTION_UP) {
+                handleKeyEvent(event);
+            }
+            return true;
+        }
+        return super.onMediaButtonEvent(mediaButtonIntent);
+    }
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/facade/media/MediaPlayerFacade.java b/Common/src/com/googlecode/android_scripting/facade/media/MediaPlayerFacade.java
new file mode 100644
index 0000000..3925a38
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/media/MediaPlayerFacade.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.media;
+
+import android.app.Service;
+import android.media.MediaPlayer;
+import android.net.Uri;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+
+/**
+ * This facade exposes basic mediaPlayer functionality. <br>
+ * <br>
+ * <b>Usage Notes:</b><br>
+ * mediaPlayerFacade maintains a list of media streams, identified by a user supplied tag. If the
+ * tag is null or blank, this tag defaults to "default"<br>
+ * Basic operation is: mediaPlayOpen("file:///sdcard/MP3/sample.mp3","mytag",true)<br>
+ * This will look for a media file at /sdcard/MP3/sample.mp3. Other urls should work. If the file
+ * exists and is playable, this will return a true otherwise it will return a false. <br>
+ * If play=true, then the media file will play immediately, otherwise it will wait for a
+ * {@link #mediaPlayStart mediaPlayerStart} command. <br>
+ * When done with the resource, use {@link #mediaPlayClose mediaPlayClose} <br>
+ * You can get information about the loaded media with {@link #mediaPlayInfo mediaPlayInfo} This
+ * returns a map with the following elements:
+ * <ul>
+ * <li>"tag" - user supplied tag identifying this mediaPlayer.
+ * <li>"loaded" - true if loaded, false if not. If false, no other elements are returned.
+ * <li>"duration" - length of the media in milliseconds.
+ * <li>"position" - current position of playback in milliseconds. Controlled by
+ * {@link #mediaPlaySeek mediaPlaySeek}
+ * <li>"isplaying" - shows whether media is playing. Controlled by {@link #mediaPlayPause
+ * mediaPlayPause} and {@link #mediaPlayStart mediaPlayStart}
+ * <li>"url" - the url used to open this media.
+ * <li>"looping" - whether media will loop. Controlled by {@link #mediaPlaySetLooping
+ * mediaPlaySetLooping}
+ * </ul>
+ * <br>
+ * You can use {@link #mediaPlayList mediaPlayList} to get a list of the loaded tags. <br>
+ * {@link #mediaIsPlaying mediaIsPlaying} will return true if the media is playing.<br>
+ * <b>Events:</b><br>
+ * A playing media will throw a <b>"media"</b> event on completion. NB: In remote mode, a media file
+ * will continue playing after the script has finished unless an explicit {@link #mediaPlayClose
+ * mediaPlayClose} event is called.
+ *
+ * @author Robbie Matthews (rjmatthews62@gmail.com)
+ */
+
+public class MediaPlayerFacade extends RpcReceiver implements MediaPlayer.OnCompletionListener {
+
+    private final Service mService;
+    static private final Map<String, MediaPlayer> mPlayers = new Hashtable<String, MediaPlayer>();
+    static private final Map<String, String> mUrls = new Hashtable<String, String>();
+
+    private final EventFacade mEventFacade;
+
+    public MediaPlayerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mEventFacade = manager.getReceiver(EventFacade.class);
+    }
+
+    private String getDefault(String tag) {
+        return (tag == null || tag.equals("")) ? "default" : tag;
+    }
+
+    private MediaPlayer getPlayer(String tag) {
+        tag = getDefault(tag);
+        return mPlayers.get(tag);
+    }
+
+    private String getUrl(String tag) {
+        tag = getDefault(tag);
+        return mUrls.get(tag);
+    }
+
+    private void putMp(String tag, MediaPlayer player, String url) {
+        tag = getDefault(tag);
+        mPlayers.put(tag, player);
+        mUrls.put(tag, url);
+    }
+
+    private void removeMp(String tag) {
+        tag = getDefault(tag);
+        MediaPlayer player = mPlayers.get(tag);
+        if (player != null) {
+            player.stop();
+            player.release();
+        }
+        mPlayers.remove(tag);
+        mUrls.remove(tag);
+    }
+
+    @Rpc(description = "Open a media file", returns = "true if play successful")
+    public synchronized boolean mediaPlayOpen(@RpcParameter(name = "url",
+                                                            description = "url of media resource")
+    String url, @RpcParameter(name = "tag", description = "string identifying resource")
+    @RpcDefault(value = "default")
+    String tag, @RpcParameter(name = "play", description = "start playing immediately")
+    @RpcDefault(value = "true")
+    Boolean play) {
+        removeMp(tag);
+        MediaPlayer player = getPlayer(tag);
+        player = MediaPlayer.create(mService, Uri.parse(url));
+        if (player != null) {
+            putMp(tag, player, url);
+            player.setOnCompletionListener(this);
+            if (play) {
+                player.start();
+            }
+        }
+        return player != null;
+    }
+
+    @Rpc(description = "pause playing media file", returns = "true if successful")
+    public synchronized boolean mediaPlayPause(
+            @RpcParameter(name = "tag", description = "string identifying resource")
+            @RpcDefault(value = "default")
+            String tag) {
+        MediaPlayer player = getPlayer(tag);
+        if (player == null) {
+            return false;
+        }
+        player.pause();
+        return true;
+    }
+
+    @Rpc(description = "Start playing media file.", returns = "true if successful")
+    public synchronized boolean mediaPlayStart(
+            @RpcParameter(name = "tag", description = "string identifying resource")
+            @RpcDefault(value = "default")
+            String tag) {
+        MediaPlayer player = getPlayer(tag);
+        if (player == null) {
+            return false;
+        }
+        player.start();
+        return mediaIsPlaying(tag);
+    }
+
+    @Rpc(description = "Stop playing media file.", returns = "true if successful")
+    public synchronized boolean mediaPlayStop(
+            @RpcParameter(name = "tag", description = "string identifying resource")
+            @RpcDefault(value = "default")
+            String tag) {
+        MediaPlayer player = getPlayer(tag);
+        if (player == null) {
+            return false;
+        }
+        player.stop();
+        return !mediaIsPlaying(tag) && player.getCurrentPosition() == 0;
+    }
+
+    @Rpc(description = "Stop all players.")
+    public synchronized void mediaPlayStopAll() {
+        for (MediaPlayer p : mPlayers.values()) {
+            p.stop();
+        }
+    }
+
+    @Rpc(description = "Seek To Position", returns = "New Position (in ms)")
+    public synchronized int mediaPlaySeek(@RpcParameter(name = "msec",
+                                                        description = "Position in millseconds")
+    Integer msec, @RpcParameter(name = "tag", description = "string identifying resource")
+    @RpcDefault(value = "default")
+    String tag) {
+        MediaPlayer player = getPlayer(tag);
+        if (player == null) {
+            return 0;
+        }
+        player.seekTo(msec);
+        return player.getCurrentPosition();
+    }
+
+    @Rpc(description = "Close media file", returns = "true if successful")
+    public synchronized boolean mediaPlayClose(
+            @RpcParameter(name = "tag", description = "string identifying resource")
+            @RpcDefault(value = "default")
+            String tag) throws Exception {
+        if (!mPlayers.containsKey(tag)) {
+            return false;
+        }
+        removeMp(tag);
+        return true;
+    }
+
+    @Rpc(description = "Checks if media file is playing.", returns = "true if playing")
+    public synchronized boolean mediaIsPlaying(
+            @RpcParameter(name = "tag", description = "string identifying resource")
+            @RpcDefault(value = "default")
+            String tag) {
+        MediaPlayer player = getPlayer(tag);
+        return (player == null) ? false : player.isPlaying();
+    }
+
+    @Rpc(description = "Information on current media", returns = "Media Information")
+    public synchronized Map<String, Object> mediaPlayGetInfo(
+            @RpcParameter(name = "tag", description = "string identifying resource")
+            @RpcDefault(value = "default")
+            String tag) {
+        Map<String, Object> result = new HashMap<String, Object>();
+        MediaPlayer player = getPlayer(tag);
+        result.put("tag", getDefault(tag));
+        if (player == null) {
+            result.put("loaded", false);
+        } else {
+            result.put("loaded", true);
+            result.put("duration", player.getDuration());
+            result.put("position", player.getCurrentPosition());
+            result.put("isplaying", player.isPlaying());
+            result.put("url", getUrl(tag));
+            result.put("looping", player.isLooping());
+        }
+        return result;
+    }
+
+    @Rpc(description = "Lists currently loaded media", returns = "List of Media Tags")
+    public Set<String> mediaPlayList() {
+        return mPlayers.keySet();
+    }
+
+    @Rpc(description = "Set Looping", returns = "True if successful")
+    public synchronized boolean mediaPlaySetLooping(@RpcParameter(name = "enabled")
+    @RpcDefault(value = "true")
+    Boolean enabled, @RpcParameter(name = "tag", description = "string identifying resource")
+    @RpcDefault(value = "default")
+    String tag) {
+        MediaPlayer player = getPlayer(tag);
+        if (player == null) {
+            return false;
+        }
+        player.setLooping(enabled);
+        return true;
+    }
+
+    @Rpc(description = "Checks if media file is playing.", returns = "true if playing")
+    public synchronized void mediaSetNext(
+            @RpcParameter(name = "tag", description = "string identifying resource")
+            @RpcDefault(value = "default")
+            String tag,
+            @RpcParameter(name = "next", description = "tag of the next track to play.")
+            String next) {
+        MediaPlayer player = getPlayer(tag);
+        MediaPlayer nPlayer = getPlayer(next);
+        if (player == null) {
+            throw new NullPointerException("Non-existent player tag " + tag);
+        }
+        if (nPlayer == null) {
+            throw new NullPointerException("Non-existent player tag " + next);
+        }
+        player.setNextMediaPlayer(nPlayer);
+    }
+
+    @Override
+    public synchronized void shutdown() {
+        for (String key : mPlayers.keySet()) {
+            MediaPlayer player = mPlayers.get(key);
+            if (player != null) {
+                player.stop();
+                player.release();
+                player = null;
+            }
+        }
+        mPlayers.clear();
+        mUrls.clear();
+    }
+
+    @Override
+    public void onCompletion(MediaPlayer player) {
+        String tag = getTag(player);
+        if (tag != null) {
+            Map<String, Object> data = new HashMap<String, Object>();
+            data.put("action", "complete");
+            data.put("tag", tag);
+            mEventFacade.postEvent("media", data);
+        }
+    }
+
+    private String getTag(MediaPlayer player) {
+        for (Entry<String, MediaPlayer> m : mPlayers.entrySet()) {
+            if (m.getValue() == player) {
+                return m.getKey();
+            }
+        }
+        return null;
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/media/MediaRecorderFacade.java b/Common/src/com/googlecode/android_scripting/facade/media/MediaRecorderFacade.java
new file mode 100644
index 0000000..ee67fe6
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/media/MediaRecorderFacade.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.media;
+
+import android.app.Service;
+import android.content.Intent;
+import android.media.MediaRecorder;
+import android.net.Uri;
+import android.provider.MediaStore;
+import android.view.SurfaceHolder;
+import android.view.SurfaceHolder.Callback;
+import android.view.SurfaceView;
+import android.view.WindowManager;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.FutureActivityTaskExecutor;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.AndroidFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A facade for recording media.
+ *
+ * Guidance notes: Use e.g. '/sdcard/file.ext' for your media destination file. A file extension of
+ * mpg will use the default settings for format and codec (often h263 which won't work with common
+ * PC media players). A file extension of mp4 or 3gp will use the appropriate format with the (more
+ * common) h264 codec. A video player such as QQPlayer (from the android market) plays both codecs
+ * and uses the composition matrix (embedded in the video file) to correct for image rotation. Many
+ * PC based media players ignore this matrix. Standard video sizes may be specified.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author John Karwatzki (jokar49@gmail.com)
+ */
+public class MediaRecorderFacade extends RpcReceiver {
+
+  private final MediaRecorder mMediaRecorder = new MediaRecorder();
+  private final Service mService;
+
+  public MediaRecorderFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+  }
+
+  @Rpc(description = "Records audio from the microphone and saves it to the given location.")
+  public void recorderStartMicrophone(@RpcParameter(name = "targetPath") String targetPath)
+      throws IOException {
+    startAudioRecording(targetPath, MediaRecorder.AudioSource.MIC);
+  }
+
+  @Rpc(description = "Records video from the camera and saves it to the given location. "
+      + "\nDuration specifies the maximum duration of the recording session. "
+      + "\nIf duration is 0 this method will return and the recording will only be stopped "
+      + "\nwhen recorderStop is called or when a scripts exits. "
+      + "\nOtherwise it will block for the time period equal to the duration argument."
+      + "\nvideoSize: 0=160x120, 1=320x240, 2=352x288, 3=640x480, 4=800x480.")
+  public void recorderStartVideo(@RpcParameter(name = "targetPath") String targetPath,
+      @RpcParameter(name = "duration") @RpcDefault("0") Integer duration,
+      @RpcParameter(name = "videoSize") @RpcDefault("1") Integer videoSize) throws Exception {
+    int ms = convertSecondsToMilliseconds(duration);
+    startVideoRecording(new File(targetPath), ms, videoSize);
+  }
+
+  private void startVideoRecording(File file, int milliseconds, int videoSize) throws Exception {
+    mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+
+    int audioSource = MediaRecorder.AudioSource.MIC;
+    try {
+      Field source = Class.forName("android.media.MediaRecorder$AudioSource").getField("CAMCORDER");
+      source.getInt(null);
+    } catch (Exception e) {
+      Log.e(e);
+    }
+    int xSize;
+    int ySize;
+    switch (videoSize) {
+    case 0:
+      xSize = 160;
+      ySize = 120;
+      break;
+    case 1:
+      xSize = 320;
+      ySize = 240;
+      break;
+    case 2:
+      xSize = 352;
+      ySize = 288;
+      break;
+    case 3:
+      xSize = 640;
+      ySize = 480;
+      break;
+    case 4:
+      xSize = 800;
+      ySize = 480;
+      break;
+    default:
+      xSize = 320;
+      ySize = 240;
+      break;
+    }
+
+    mMediaRecorder.setAudioSource(audioSource);
+    String extension = file.toString().split("\\.")[1];
+    if (extension.equals("mp4")) {
+      mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
+      mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
+      mMediaRecorder.setVideoSize(xSize, ySize);
+      mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
+    } else if (extension.equals("3gp")) {
+      mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+      mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
+      mMediaRecorder.setVideoSize(xSize, ySize);
+      mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
+    } else {
+
+      mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
+      mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
+      mMediaRecorder.setVideoSize(xSize, ySize);
+      mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT);
+    }
+
+    mMediaRecorder.setOutputFile(file.getAbsolutePath());
+    if (milliseconds > 0) {
+      mMediaRecorder.setMaxDuration(milliseconds);
+    }
+    FutureActivityTask<Exception> prepTask = prepare();
+    mMediaRecorder.start();
+    if (milliseconds > 0) {
+      new CountDownLatch(1).await(milliseconds, TimeUnit.MILLISECONDS);
+    }
+    prepTask.finish();
+  }
+
+  @Rpc(description = "Records video (and optionally audio) from the camera and saves it to the given location. "
+      + "\nDuration specifies the maximum duration of the recording session. "
+      + "\nIf duration is not provided this method will return immediately and the recording will only be stopped "
+      + "\nwhen recorderStop is called or when a scripts exits. "
+      + "\nOtherwise it will block for the time period equal to the duration argument.")
+  public void recorderCaptureVideo(@RpcParameter(name = "targetPath") String targetPath,
+      @RpcParameter(name = "duration") @RpcOptional Integer duration,
+      @RpcParameter(name = "recordAudio") @RpcDefault("true") Boolean recordAudio) throws Exception {
+    int ms = convertSecondsToMilliseconds(duration);
+    startVideoRecording(new File(targetPath), ms, recordAudio);
+  }
+
+  private void startVideoRecording(File file, int milliseconds, boolean withAudio) throws Exception {
+    mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+    if (withAudio) {
+      int audioSource = MediaRecorder.AudioSource.MIC;
+      try {
+        Field source =
+            Class.forName("android.media.MediaRecorder$AudioSource").getField("CAMCORDER");
+        audioSource = source.getInt(null);
+      } catch (Exception e) {
+        Log.e(e);
+      }
+      mMediaRecorder.setAudioSource(audioSource);
+      mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
+      mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
+    } else {
+      mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
+    }
+    mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT);
+    mMediaRecorder.setOutputFile(file.getAbsolutePath());
+    if (milliseconds > 0) {
+      mMediaRecorder.setMaxDuration(milliseconds);
+    }
+    FutureActivityTask<Exception> prepTask = prepare();
+    mMediaRecorder.start();
+    if (milliseconds > 0) {
+      new CountDownLatch(1).await(milliseconds, TimeUnit.MILLISECONDS);
+    }
+    prepTask.finish();
+  }
+
+  private void startAudioRecording(String targetPath, int source) throws IOException {
+    mMediaRecorder.setAudioSource(source);
+    mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
+    mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
+    mMediaRecorder.setOutputFile(targetPath);
+    mMediaRecorder.prepare();
+    mMediaRecorder.start();
+  }
+
+  @Rpc(description = "Stops a previously started recording.")
+  public void recorderStop() {
+    mMediaRecorder.stop();
+    mMediaRecorder.reset();
+  }
+
+  @Rpc(description = "Starts the video capture application to record a video and saves it to the specified path.")
+  public void startInteractiveVideoRecording(@RpcParameter(name = "path") final String path) {
+    Intent intent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
+    File file = new File(path);
+    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
+    AndroidFacade facade = mManager.getReceiver(AndroidFacade.class);
+    facade.startActivityForResult(intent);
+  }
+
+  @Override
+  public void shutdown() {
+    mMediaRecorder.release();
+  }
+
+  // TODO(damonkohler): This shares a lot of code with the CameraFacade. It's probably worth moving
+  // it there.
+  private FutureActivityTask<Exception> prepare() throws Exception {
+    FutureActivityTask<Exception> task = new FutureActivityTask<Exception>() {
+      @Override
+      public void onCreate() {
+        super.onCreate();
+        final SurfaceView view = new SurfaceView(getActivity());
+        getActivity().setContentView(view);
+        getActivity().getWindow().setSoftInputMode(
+            WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED);
+        view.getHolder().addCallback(new Callback() {
+          @Override
+          public void surfaceDestroyed(SurfaceHolder holder) {
+          }
+
+          @Override
+          public void surfaceCreated(SurfaceHolder holder) {
+            try {
+              mMediaRecorder.setPreviewDisplay(view.getHolder().getSurface());
+              mMediaRecorder.prepare();
+              setResult(null);
+            } catch (IOException e) {
+              setResult(e);
+            }
+          }
+
+          @Override
+          public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+          }
+        });
+      }
+    };
+
+    FutureActivityTaskExecutor taskExecutor =
+        ((BaseApplication) mService.getApplication()).getTaskExecutor();
+    taskExecutor.execute(task);
+
+    Exception e = task.getResult();
+    if (e != null) {
+      throw e;
+    }
+    return task;
+  }
+
+  private int convertSecondsToMilliseconds(Integer seconds) {
+    if (seconds == null) {
+      return 0;
+    }
+    return (int) (seconds * 1000L);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/media/MediaScannerFacade.java b/Common/src/com/googlecode/android_scripting/facade/media/MediaScannerFacade.java
new file mode 100644
index 0000000..fd885c7
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/media/MediaScannerFacade.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.media;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.media.MediaScanner;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Environment;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Expose functionalities of MediaScanner related APIs.
+ */
+public class MediaScannerFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final MediaScanner mScanService;
+    private final EventFacade mEventFacade;
+    private final MediaScannerReceiver mReceiver;
+
+    public MediaScannerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mScanService = new MediaScanner(mService, "external");
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mReceiver = new MediaScannerReceiver();
+    }
+
+    public class MediaScannerReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if(action.equals(Intent.ACTION_MEDIA_SCANNER_FINISHED)) {
+                Log.d("Scan finished, posting event.");
+                mEventFacade.postEvent("MediaScanFinished", new Bundle());
+                mService.unregisterReceiver(mReceiver);
+            }
+        }
+    }
+
+    @Rpc(description = "Scan external storage for media files.")
+    public void mediaScanForFiles() {
+        mService.sendBroadcast(new Intent(Intent.ACTION_MEDIA_MOUNTED,
+                               Uri.parse("file://" + Environment.getExternalStorageDirectory())));
+        mService.registerReceiver(mReceiver,
+                                  new IntentFilter(Intent.ACTION_MEDIA_SCANNER_FINISHED));
+    }
+
+    @Rpc(description = "Scan for a media file.")
+    public void mediaScanForOneFile(@RpcParameter(name = "path") String path) {
+        mService.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, Uri.parse(path)));
+    }
+
+    @Override
+    public void shutdown() {
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/media/MediaSessionFacade.java b/Common/src/com/googlecode/android_scripting/facade/media/MediaSessionFacade.java
new file mode 100644
index 0000000..130b392
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/media/MediaSessionFacade.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.media;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
+import android.media.session.MediaController;
+import android.media.session.MediaSession;
+import android.media.session.MediaSessionManager;
+import android.media.session.MediaSessionManager.OnActiveSessionsChangedListener;
+import android.media.session.PlaybackState;
+import android.media.session.MediaSession.Callback;
+import android.view.KeyEvent;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Expose functionalities of MediaSession related classes
+ * like MediaSession, MediaSessionManager, MediaController.
+ *
+ */
+public class MediaSessionFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final EventFacade mEventFacade;
+    private final MediaSession mSession;
+    private final MediaSessionManager mManager;
+    private final OnActiveSessionsChangedListener mSessionListener;
+    private final Callback mCallback;
+
+    private List<MediaController> mActiveControllers = null;
+
+    public MediaSessionFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        Log.d("Creating MediaSession.");
+        mSession = new MediaSession(mService, "SL4A");
+        mSession.setFlags(MediaSession.FLAG_HANDLES_MEDIA_BUTTONS);
+        mManager = (MediaSessionManager) mService.getSystemService(Context.MEDIA_SESSION_SERVICE);
+        mCallback = new MediaButtonCallback(mEventFacade);
+        mSessionListener = new MediaSessionListener();
+        mManager.addOnActiveSessionsChangedListener(mSessionListener,
+                new ComponentName(mService.getPackageName(), this.getClass().getName()));
+        mSession.setActive(true);
+    }
+
+    private class MediaSessionListener implements OnActiveSessionsChangedListener {
+
+        @Override
+        public void onActiveSessionsChanged(List<MediaController> controllers) {
+            Log.d("Active MediaSessions have changed. Update current controller.");
+            int size = controllers.size();
+            for (int i = 0; i < size; i++) {
+                MediaController controller = controllers.get(i);
+                long flags = controller.getFlags();
+                // We only care about sessions that handle transport controls,
+                // which will be true for apps using RCC
+                if ((flags & MediaSession.FLAG_HANDLES_TRANSPORT_CONTROLS) != 0) {
+                    Log.d("The current active MediaSessions is " + controller.getTag());
+                    return;
+                }
+            }
+        }
+    }
+
+    @Rpc(description = "Retrieve a list of active sessions.")
+    public List<String> mediaGetActiveSessions() {
+        mActiveControllers = mManager.getActiveSessions(null);
+        List<String> results = new ArrayList<String>();
+        for (MediaController mc : mActiveControllers) {
+            results.add(mc.getTag());
+        }
+        return results;
+    }
+
+    @Rpc(description = "Add callback to media session.")
+    public void mediaSessionAddCallback() {
+        MainThread.run(mService, new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                Log.d("Adding callback.");
+                mSession.setCallback(mCallback);
+                PlaybackState.Builder bob = new PlaybackState.Builder();
+                bob.setActions(PlaybackState.ACTION_PLAY |
+                               PlaybackState.ACTION_PAUSE |
+                               PlaybackState.ACTION_STOP);
+                bob.setState(PlaybackState.STATE_PLAYING, 0, 1);
+                mSession.setPlaybackState(bob.build());
+                return null;
+            }
+        });
+    }
+
+    @Rpc(description = "Whether current media session is active.")
+    public Boolean mediaSessionIsActive() {
+        return mSession.isActive();
+    }
+
+    @Rpc(description = "Simulate a media key press.")
+    public void mediaDispatchMediaKeyEvent(String key) {
+        int keyCode;
+        if (key.equals("Play")) {
+            keyCode = KeyEvent.KEYCODE_MEDIA_PLAY;
+        } else if (key.equals("Pause")) {
+            keyCode = KeyEvent.KEYCODE_MEDIA_PAUSE;
+        } else if (key.equals("Stop")) {
+            keyCode = KeyEvent.KEYCODE_MEDIA_STOP;
+        } else if (key.equals("Next")) {
+            keyCode = KeyEvent.KEYCODE_MEDIA_NEXT;
+        } else if (key.equals("Previous")) {
+            keyCode = KeyEvent.KEYCODE_MEDIA_PREVIOUS;
+        } else if (key.equals("Forward")) {
+            keyCode = KeyEvent.KEYCODE_MEDIA_FAST_FORWARD;
+        } else if (key.equals("Rewind")) {
+            keyCode = KeyEvent.KEYCODE_MEDIA_REWIND;
+        } else {
+            Log.d("Unrecognized media key.");
+            return;
+        }
+        KeyEvent keyDown = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
+        KeyEvent keyUp = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
+        mManager.dispatchMediaKeyEvent(keyDown);
+        mManager.dispatchMediaKeyEvent(keyUp);
+    }
+
+    private MediaController getMediaController(int idx) {
+        return mActiveControllers.get(idx);
+    }
+
+    @Rpc(description = "Call Play on the currently active media session.")
+    public void mediaSessionPlay(@RpcParameter(name = "index") @RpcDefault(value = "0")
+                                 Integer idx) {
+        getMediaController(idx).getTransportControls().play();
+    }
+
+    @Rpc(description = "Call Pause on the currently active media session.")
+    public void mediaSessionPause(@RpcParameter(name = "index") @RpcDefault(value = "0")
+                                  Integer idx) {
+        getMediaController(idx).getTransportControls().pause();
+    }
+
+    @Rpc(description = "Call Stop on the currently active media session.")
+    public void mediaSessionStop(@RpcParameter(name = "index") @RpcDefault(value = "0")
+                                 Integer idx) {
+        getMediaController(idx).getTransportControls().stop();
+    }
+
+    @Rpc(description = "Call Next on the currently active media session.")
+    public void mediaSessionNext(@RpcParameter(name = "index") @RpcDefault(value = "0")
+                                 Integer idx) {
+        getMediaController(idx).getTransportControls().skipToNext();
+    }
+
+    @Override
+    public void shutdown() {
+        mSession.setCallback(null);
+        mSession.release();
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/CarrierConfigFacade.java b/Common/src/com/googlecode/android_scripting/facade/telephony/CarrierConfigFacade.java
new file mode 100644
index 0000000..fc4d061
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/CarrierConfigFacade.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import android.app.Activity;
+import android.app.Service;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.telephony.CarrierConfigManager;
+
+import com.googlecode.android_scripting.facade.AndroidFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+
+public class CarrierConfigFacade extends RpcReceiver {
+    private final Service mService;
+    private final AndroidFacade mAndroidFacade;
+    private final CarrierConfigManager mCarrierConfigManager;
+
+    public CarrierConfigFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mAndroidFacade = manager.getReceiver(AndroidFacade.class);
+        mCarrierConfigManager =
+            (CarrierConfigManager)mService.getSystemService(Context.CARRIER_CONFIG_SERVICE);
+    }
+
+    @Rpc(description = "Tethering Entitlement Check")
+    public boolean carrierConfigIsTetheringModeAllowed(String mode, Integer timeout) {
+        String[] mProvisionApp = mService.getResources().getStringArray(
+                com.android.internal.R.array.config_mobile_hotspot_provision_app);
+        /* following check defined in
+        frameworks/base/packages/SettingsLib/src/com/android/settingslib/TetherUtil.java
+        isProvisioningNeeded
+        */
+        if ((mProvisionApp == null) || (mProvisionApp.length != 2)){
+            Log.d("carrierConfigIsTetheringModeAllowed: no check is present.");
+            return true;
+        }
+        Log.d("carrierConfigIsTetheringModeAllowed mProvisionApp 0 " + mProvisionApp[0]);
+        Log.d("carrierConfigIsTetheringModeAllowed mProvisionApp 1 " + mProvisionApp[1]);
+
+        /* defined in frameworks/base/packages/SettingsLib/src/com/android/settingslib/TetherUtil.java
+        public static final int INVALID             = -1;
+        public static final int WIFI_TETHERING      = 0;
+        public static final int USB_TETHERING       = 1;
+        public static final int BLUETOOTH_TETHERING = 2;
+        */
+        // TODO: b/26273844 need to use android.settingslib.TetherUtil to
+        // replace those private defines.
+        final int INVALID             = -1;
+        final int WIFI_TETHERING      = 0;
+        final int USB_TETHERING       = 1;
+        final int BLUETOOTH_TETHERING = 2;
+
+        /* defined in packages/apps/Settings/src/com/android/settings/TetherSettings.java
+        private static final int PROVISION_REQUEST = 0;
+        */
+        final int PROVISION_REQUEST = 0;
+
+        int mTetherChoice = INVALID;
+        if (mode.equals("wifi")){
+            mTetherChoice = WIFI_TETHERING;
+        } else if (mode.equals("usb")) {
+            mTetherChoice = USB_TETHERING;
+        } else if (mode.equals("bluetooth")) {
+            mTetherChoice = BLUETOOTH_TETHERING;
+        }
+        Intent intent = new Intent(Intent.ACTION_MAIN);
+        intent.setClassName(mProvisionApp[0], mProvisionApp[1]);
+        intent.putExtra("TETHER_TYPE", mTetherChoice);
+        int result;
+        try{
+            result = mAndroidFacade.startActivityForResultCodeWithTimeout(
+                intent, PROVISION_REQUEST, timeout);
+        } catch (Exception e) {
+            Log.d("phoneTetherCheck exception" + e.toString());
+            return false;
+        }
+
+        if (result == Activity.RESULT_OK) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public void shutdown() {
+
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/ImsManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/telephony/ImsManagerFacade.java
new file mode 100755
index 0000000..0a67c34
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/ImsManagerFacade.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import android.app.Service;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.telephony.SubscriptionManager;
+
+import com.android.ims.ImsException;
+import com.android.ims.ImsManager;
+import com.android.ims.ImsConfig;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Exposes ImsManager functionality.
+ */
+public class ImsManagerFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final Context mContext;
+    private ImsManager mImsManager;
+
+    public ImsManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mContext = mService.getBaseContext();
+        mImsManager = ImsManager.getInstance(mContext,
+                SubscriptionManager.getDefaultVoicePhoneId());
+    }
+
+    @Rpc(description = "Return True if Enhanced 4g Lte mode is enabled by platform.")
+    public boolean imsIsEnhanced4gLteModeSettingEnabledByPlatform() {
+        return ImsManager.isVolteEnabledByPlatform(mContext);
+    }
+
+    @Rpc(description = "Return True if Enhanced 4g Lte mode is enabled by user.")
+    public boolean imsIsEnhanced4gLteModeSettingEnabledByUser() {
+        return ImsManager.isEnhanced4gLteModeSettingEnabledByUser(mContext);
+    }
+
+    @Rpc(description = "Set Enhanced 4G mode.")
+    public void imsSetEnhanced4gMode(
+            @RpcParameter(name = "enable") Boolean enable) {
+        ImsManager.setEnhanced4gLteModeSetting(mContext, enable);
+    }
+
+    @Rpc(description = "Check for VoLTE Provisioning.")
+    public boolean imsIsVolteProvisionedOnDevice() {
+        return mImsManager.isVolteProvisionedOnDevice(mContext);
+    }
+
+    @Rpc(description = "Set Modem Provisioning for VoLTE")
+    public void imsSetVolteProvisioning(
+            @RpcParameter(name = "enable") Boolean enable)
+            throws ImsException{
+        mImsManager.getConfigInterface().setProvisionedValue(
+                ImsConfig.ConfigConstants.VLT_SETTING_ENABLED,
+                enable? 1 : 0);
+    }
+
+    /**************************
+     * Begin WFC Calling APIs
+     **************************/
+
+    @Rpc(description = "Return True if WiFi Calling is enabled for platform.")
+    public boolean imsIsWfcEnabledByPlatform() {
+        return ImsManager.isWfcEnabledByPlatform(mContext);
+    }
+
+    @Rpc(description = "Set whether or not WFC is enabled during roaming")
+    public void imsSetWfcRoamingSetting(
+                        @RpcParameter(name = "enable")
+            Boolean enable) {
+        ImsManager.setWfcRoamingSetting(mContext, enable);
+
+    }
+
+    @Rpc(description = "Return True if WiFi Calling is enabled during roaming.")
+    public boolean imsIsWfcRoamingEnabledByUser() {
+        return ImsManager.isWfcRoamingEnabledByUser(mContext);
+    }
+
+    @Rpc(description = "Set the Wifi Calling Mode of operation")
+    public void imsSetWfcMode(
+                        @RpcParameter(name = "mode")
+            String mode)
+            throws IllegalArgumentException {
+
+        int mode_val;
+
+        switch (mode.toUpperCase()) {
+            case TelephonyConstants.WFC_MODE_WIFI_ONLY:
+                mode_val =
+                        ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY;
+                break;
+            case TelephonyConstants.WFC_MODE_CELLULAR_PREFERRED:
+                mode_val =
+                        ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED;
+                break;
+            case TelephonyConstants.WFC_MODE_WIFI_PREFERRED:
+                mode_val =
+                        ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED;
+                break;
+            case TelephonyConstants.WFC_MODE_DISABLED:
+                if (ImsManager.isWfcEnabledByPlatform(mContext) &&
+                        ImsManager.isWfcEnabledByUser(mContext) == true) {
+                    ImsManager.setWfcSetting(mContext, false);
+                }
+                return;
+            default:
+                throw new IllegalArgumentException("Invalid WfcMode");
+        }
+
+        ImsManager.setWfcMode(mContext, mode_val);
+        if (ImsManager.isWfcEnabledByPlatform(mContext) &&
+                ImsManager.isWfcEnabledByUser(mContext) == false) {
+            ImsManager.setWfcSetting(mContext, true);
+        }
+
+        return;
+    }
+
+    @Rpc(description = "Return current WFC Mode if Enabled.")
+    public String imsGetWfcMode() {
+        if(ImsManager.isWfcEnabledByUser(mContext) == false) {
+            return TelephonyConstants.WFC_MODE_DISABLED;
+        }
+        return TelephonyUtils.getWfcModeString(
+            ImsManager.getWfcMode(mContext));
+    }
+
+    @Rpc(description = "Return True if WiFi Calling is enabled by user.")
+    public boolean imsIsWfcEnabledByUser() {
+        return ImsManager.isWfcEnabledByUser(mContext);
+    }
+
+    @Rpc(description = "Set whether or not WFC is enabled")
+    public void imsSetWfcSetting(
+                        @RpcParameter(name = "enable")  Boolean enable) {
+        ImsManager.setWfcSetting(mContext,enable);
+    }
+
+    /**************************
+     * Begin VT APIs
+     **************************/
+
+    @Rpc(description = "Return True if Video Calling is enabled by the platform.")
+    public boolean imsIsVtEnabledByPlatform() {
+        return ImsManager.isVtEnabledByPlatform(mContext);
+    }
+
+    @Override
+    public void shutdown() {
+
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/InCallServiceImpl.java b/Common/src/com/googlecode/android_scripting/facade/telephony/InCallServiceImpl.java
new file mode 100644
index 0000000..965735a
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/InCallServiceImpl.java
@@ -0,0 +1,1416 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import android.telecom.Call;
+import android.telecom.Call.Details;
+import android.telecom.CallAudioState;
+import android.telecom.Conference;
+import android.telecom.Connection;
+import android.telecom.ConnectionService;
+import android.telecom.InCallService;
+import android.telecom.Phone;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import android.telecom.VideoProfile.CameraCapabilities;
+
+import com.googlecode.android_scripting.Log;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+
+public class InCallServiceImpl extends InCallService {
+
+    private static InCallServiceImpl mService = null;
+
+    public static InCallServiceImpl getService() {
+        return mService;
+    }
+
+    private static Object mLock = new Object();
+
+    // Provides a return value for getCallState when no call is active
+    public static final int STATE_INVALID = -1;
+
+    // Provides a return value for getCallQuality when input is invalid
+    public static final int QUALITY_INVALID = -1;
+
+    // Provides a return value for getAudioRoute when input is invalid
+    public static final int INVALID_AUDIO_ROUTE = -1;
+
+    public static final int VIDEO_STATE_AUDIO_ONLY = VideoProfile.STATE_AUDIO_ONLY;
+
+    public static final int VIDEO_STATE_TX_ENABLED = VideoProfile.STATE_TX_ENABLED;
+
+    public static final int VIDEO_STATE_RX_ENABLED = VideoProfile.STATE_RX_ENABLED;
+
+    public static final int VIDEO_STATE_BIDIRECTIONAL = VideoProfile.STATE_BIDIRECTIONAL;
+
+    public static final int VIDEO_STATE_TX_PAUSED =
+            VideoProfile.STATE_TX_ENABLED | VideoProfile.STATE_PAUSED;
+
+    public static final int VIDEO_STATE_RX_PAUSED =
+            VideoProfile.STATE_RX_ENABLED | VideoProfile.STATE_PAUSED;
+
+    public static final int VIDEO_STATE_BIDIRECTIONAL_PAUSED =
+            VideoProfile.STATE_BIDIRECTIONAL | VideoProfile.STATE_PAUSED;
+
+    // Container class to return the call ID along with the event
+    public class CallEvent<EventType> {
+
+        private final String mCallId;
+        private final EventType mEvent;
+
+        CallEvent(String callId, EventType event) {
+            mCallId = callId;
+            mEvent = event;
+        }
+
+        public String getCallId() {
+            return mCallId;
+        }
+
+        public EventType getEvent() {
+            return mEvent;
+        }
+    }
+
+    // Currently the same as a call event... here for future use
+    public class VideoCallEvent<EventType> extends CallEvent<EventType> {
+        VideoCallEvent(String callId, EventType event) {
+            super(callId, event);
+        }
+    }
+
+    private class CallCallback extends Call.Callback {
+
+        // Invalid video state (valid >= 0)
+        public static final int STATE_INVALID = InCallServiceImpl.STATE_INVALID;
+
+        public static final int EVENT_INVALID = -1;
+        public static final int EVENT_NONE = 0;
+        public static final int EVENT_STATE_CHANGED = 1 << 0;
+        public static final int EVENT_PARENT_CHANGED = 1 << 1;
+        public static final int EVENT_CHILDREN_CHANGED = 1 << 2;
+        public static final int EVENT_DETAILS_CHANGED = 1 << 3;
+        public static final int EVENT_CANNED_TEXT_RESPONSES_LOADED = 1 << 4;
+        public static final int EVENT_POST_DIAL_WAIT = 1 << 5;
+        public static final int EVENT_VIDEO_CALL_CHANGED = 1 << 6;
+        public static final int EVENT_CALL_DESTROYED = 1 << 7;
+        public static final int EVENT_CONFERENCABLE_CALLS_CHANGED = 1 << 8;
+
+        public static final int EVENT_ALL = EVENT_STATE_CHANGED |
+                EVENT_PARENT_CHANGED |
+                EVENT_CHILDREN_CHANGED |
+                EVENT_DETAILS_CHANGED |
+                EVENT_CANNED_TEXT_RESPONSES_LOADED |
+                EVENT_POST_DIAL_WAIT |
+                EVENT_VIDEO_CALL_CHANGED |
+                EVENT_DETAILS_CHANGED |
+                EVENT_CALL_DESTROYED |
+                EVENT_CONFERENCABLE_CALLS_CHANGED;
+
+        private int mEvents;
+        private String mCallId;
+
+        public CallCallback(String callId, int events) {
+            super();
+            mEvents = events & EVENT_ALL;
+            mCallId = callId;
+        }
+
+        public void startListeningForEvents(int events) {
+            mEvents |= events & EVENT_ALL;
+        }
+
+        public void stopListeningForEvents(int events) {
+            mEvents &= ~(events & EVENT_ALL);
+        }
+
+        @Override
+        public void onStateChanged(
+                Call call, int state) {
+            Log.d("CallCallback:onStateChanged()");
+            if ((mEvents & EVENT_STATE_CHANGED)
+                    == EVENT_STATE_CHANGED) {
+                servicePostEvent(TelephonyConstants.EventTelecomCallStateChanged,
+                        new CallEvent<String>(mCallId, getCallStateString(state)));
+            }
+        }
+
+        @Override
+        public void onParentChanged(
+                Call call, Call parent) {
+            Log.d("CallCallback:onParentChanged()");
+            if ((mEvents & EVENT_PARENT_CHANGED)
+                    == EVENT_PARENT_CHANGED) {
+                servicePostEvent(TelephonyConstants.EventTelecomCallParentChanged,
+                        new CallEvent<String>(mCallId, getCallId(parent)));
+            }
+        }
+
+        @Override
+        public void onChildrenChanged(
+                Call call, List<Call> children) {
+            Log.d("CallCallback:onChildrenChanged()");
+
+            if ((mEvents & EVENT_CHILDREN_CHANGED)
+                    == EVENT_CHILDREN_CHANGED) {
+                List<String> childList = new ArrayList<String>();
+
+                for (Call child : children) {
+                    childList.add(getCallId(child));
+                }
+                servicePostEvent(TelephonyConstants.EventTelecomCallChildrenChanged,
+                        new CallEvent<List<String>>(mCallId, childList));
+            }
+        }
+
+        @Override
+        public void onDetailsChanged(
+                Call call, Details details) {
+            Log.d("CallCallback:onDetailsChanged()");
+
+            if ((mEvents & EVENT_DETAILS_CHANGED)
+                    == EVENT_DETAILS_CHANGED) {
+                servicePostEvent(TelephonyConstants.EventTelecomCallDetailsChanged,
+                        new CallEvent<Details>(mCallId, details));
+            }
+        }
+
+        @Override
+        public void onCannedTextResponsesLoaded(
+                Call call, List<String> cannedTextResponses) {
+            Log.d("CallCallback:onCannedTextResponsesLoaded()");
+            if ((mEvents & EVENT_CANNED_TEXT_RESPONSES_LOADED)
+                    == EVENT_CANNED_TEXT_RESPONSES_LOADED) {
+                servicePostEvent(TelephonyConstants.EventTelecomCallCannedTextResponsesLoaded,
+                        new CallEvent<List<String>>(mCallId, cannedTextResponses));
+            }
+        }
+
+        @Override
+        public void onPostDialWait(
+                Call call, String remainingPostDialSequence) {
+            Log.d("CallCallback:onPostDialWait()");
+            if ((mEvents & EVENT_POST_DIAL_WAIT)
+                    == EVENT_POST_DIAL_WAIT) {
+                servicePostEvent(TelephonyConstants.EventTelecomCallPostDialWait,
+                        new CallEvent<String>(mCallId, remainingPostDialSequence));
+            }
+        }
+
+        @Override
+        public void onVideoCallChanged(
+                Call call, InCallService.VideoCall videoCall) {
+
+            /*
+             * There is a race condition such that the lifetime of the VideoCall is not aligned with
+             * the lifetime of the underlying call object. We are using the onVideoCallChanged
+             * method as a way of determining the lifetime of the VideoCall object rather than
+             * onCallAdded/onCallRemoved.
+             */
+            Log.d("CallCallback:onVideoCallChanged()");
+
+            if (call != null) {
+                String callId = getCallId(call);
+                CallContainer cc = mCallContainerMap.get(callId);
+                if (cc == null) {
+                    Log.d(String.format("Call container returned null for callId %s", callId));
+                }
+                else {
+                    synchronized (mLock) {
+                        if (videoCall == null) {
+                            Log.d("Yo dawg, I heard you like null video calls.");
+                            // Try and see if the videoCall has been added/changed after firing the
+                            // callback
+                            // This probably won't work.
+                            videoCall = call.getVideoCall();
+                        }
+                        if (cc.getVideoCall() != videoCall) {
+                            if (videoCall == null) {
+                                // VideoCall object deleted
+                                cc.updateVideoCall(null, null);
+                                Log.d("Removing video call from call.");
+                            }
+                            else if (cc.getVideoCall() != null) {
+                                // Somehow we have a mismatched VideoCall ID!
+                                Log.d("Mismatched video calls for same call ID.");
+                            }
+                            else {
+                                Log.d("Huzzah, we have a video call!");
+
+                                VideoCallCallback videoCallCallback =
+                                        new VideoCallCallback(callId, VideoCallCallback.EVENT_NONE);
+
+                                videoCall.registerCallback(videoCallCallback);
+
+                                cc.updateVideoCall(
+                                        videoCall,
+                                        videoCallCallback);
+                            }
+                        }
+                        else {
+                            Log.d("Change to existing video call.");
+                        }
+
+                    }
+                }
+            }
+            else {
+                Log.d("passed null call pointer to call callback");
+            }
+
+            if ((mEvents & EVENT_VIDEO_CALL_CHANGED)
+                    == EVENT_VIDEO_CALL_CHANGED) {
+                // TODO: b/26273778 Need to determine what to return;
+                // probably not the whole video call
+                servicePostEvent(TelephonyConstants.EventTelecomCallVideoCallChanged,
+                        new CallEvent<String>(mCallId, videoCall.toString()));
+            }
+        }
+
+        @Override
+        public void onCallDestroyed(Call call) {
+            Log.d("CallCallback:onCallDestroyed()");
+
+            if ((mEvents & EVENT_CALL_DESTROYED)
+                    == EVENT_CALL_DESTROYED) {
+                servicePostEvent(TelephonyConstants.EventTelecomCallDestroyed,
+                        new CallEvent<Call>(mCallId, call));
+            }
+        }
+
+        @Override
+        public void onConferenceableCallsChanged(
+                Call call, List<Call> conferenceableCalls) {
+            Log.d("CallCallback:onConferenceableCallsChanged()");
+
+            if ((mEvents & EVENT_CONFERENCABLE_CALLS_CHANGED)
+                    == EVENT_CONFERENCABLE_CALLS_CHANGED) {
+                List<String> confCallList = new ArrayList<String>();
+                for (Call cc : conferenceableCalls) {
+                    confCallList.add(getCallId(cc));
+                }
+                servicePostEvent(TelephonyConstants.EventTelecomCallConferenceableCallsChanged,
+                        new CallEvent<List<String>>(mCallId, confCallList));
+            }
+        }
+    }
+
+    private class VideoCallCallback extends InCallService.VideoCall.Callback {
+
+        public static final int EVENT_INVALID = -1;
+        public static final int EVENT_NONE = 0;
+        public static final int EVENT_SESSION_MODIFY_REQUEST_RECEIVED = 1 << 0;
+        public static final int EVENT_SESSION_MODIFY_RESPONSE_RECEIVED = 1 << 1;
+        public static final int EVENT_SESSION_EVENT = 1 << 2;
+        public static final int EVENT_PEER_DIMENSIONS_CHANGED = 1 << 3;
+        public static final int EVENT_VIDEO_QUALITY_CHANGED = 1 << 4;
+        public static final int EVENT_DATA_USAGE_CHANGED = 1 << 5;
+        public static final int EVENT_CAMERA_CAPABILITIES_CHANGED = 1 << 6;
+        public static final int EVENT_ALL =
+                EVENT_SESSION_MODIFY_REQUEST_RECEIVED |
+                EVENT_SESSION_MODIFY_RESPONSE_RECEIVED |
+                EVENT_SESSION_EVENT |
+                EVENT_PEER_DIMENSIONS_CHANGED |
+                EVENT_VIDEO_QUALITY_CHANGED |
+                EVENT_DATA_USAGE_CHANGED |
+                EVENT_CAMERA_CAPABILITIES_CHANGED;
+
+        private String mCallId;
+        private int mEvents;
+
+        public VideoCallCallback(String callId, int listeners) {
+
+            mCallId = callId;
+            mEvents = listeners & EVENT_ALL;
+        }
+
+        public void startListeningForEvents(int events) {
+            Log.d(String.format(
+                    "VideoCallCallback(%s):startListeningForEvents(%x): events:%x",
+                    mCallId, events, mEvents));
+
+            mEvents |= events & EVENT_ALL;
+
+        }
+
+        public void stopListeningForEvents(int events) {
+            mEvents &= ~(events & EVENT_ALL);
+        }
+
+        @Override
+        public void onSessionModifyRequestReceived(VideoProfile videoProfile) {
+            Log.d(String.format("VideoCallCallback(%s):onSessionModifyRequestReceived()", mCallId));
+
+            if ((mEvents & EVENT_SESSION_MODIFY_REQUEST_RECEIVED)
+                    == EVENT_SESSION_MODIFY_REQUEST_RECEIVED) {
+                servicePostEvent(TelephonyConstants.EventTelecomVideoCallSessionModifyRequestReceived,
+                        new VideoCallEvent<VideoProfile>(mCallId, videoProfile));
+            }
+
+        }
+
+        @Override
+        public void onSessionModifyResponseReceived(int status,
+                VideoProfile requestedProfile, VideoProfile responseProfile) {
+            Log.d("VideoCallCallback:onSessionModifyResponseReceived()");
+
+            if ((mEvents & EVENT_SESSION_MODIFY_RESPONSE_RECEIVED)
+                    == EVENT_SESSION_MODIFY_RESPONSE_RECEIVED) {
+
+                HashMap<String, VideoProfile> smrrInfo = new HashMap<String, VideoProfile>();
+
+                smrrInfo.put("RequestedProfile", requestedProfile);
+                smrrInfo.put("ResponseProfile", responseProfile);
+
+                servicePostEvent(TelephonyConstants.EventTelecomVideoCallSessionModifyResponseReceived,
+                        new VideoCallEvent<HashMap<String, VideoProfile>>(mCallId, smrrInfo));
+            }
+        }
+
+        @Override
+        public void onCallSessionEvent(int event) {
+            Log.d("VideoCallCallback:onCallSessionEvent()");
+
+            String eventString = getVideoCallSessionEventString(event);
+
+            if ((mEvents & EVENT_SESSION_EVENT)
+                    == EVENT_SESSION_EVENT) {
+                servicePostEvent(TelephonyConstants.EventTelecomVideoCallSessionEvent,
+                        new VideoCallEvent<String>(mCallId, eventString));
+            }
+        }
+
+        @Override
+        public void onPeerDimensionsChanged(int width, int height) {
+            Log.d("VideoCallCallback:onPeerDimensionsChanged()");
+
+            if ((mEvents & EVENT_PEER_DIMENSIONS_CHANGED)
+                    == EVENT_PEER_DIMENSIONS_CHANGED) {
+
+                HashMap<String, Integer> temp = new HashMap<String, Integer>();
+                temp.put("Width", width);
+                temp.put("Height", height);
+
+                servicePostEvent(TelephonyConstants.EventTelecomVideoCallPeerDimensionsChanged,
+                        new VideoCallEvent<HashMap<String, Integer>>(mCallId, temp));
+            }
+        }
+
+        @Override
+        public void onVideoQualityChanged(int videoQuality) {
+            Log.d("VideoCallCallback:onVideoQualityChanged()");
+
+            if ((mEvents & EVENT_VIDEO_QUALITY_CHANGED)
+                    == EVENT_VIDEO_QUALITY_CHANGED) {
+                servicePostEvent(TelephonyConstants.EventTelecomVideoCallVideoQualityChanged,
+                        new VideoCallEvent<String>(mCallId,
+                                getVideoCallQualityString(videoQuality)));
+            }
+        }
+
+        @Override
+        public void onCallDataUsageChanged(long dataUsage) {
+            Log.d("VideoCallCallback:onCallDataUsageChanged()");
+
+            if ((mEvents & EVENT_DATA_USAGE_CHANGED)
+                    == EVENT_DATA_USAGE_CHANGED) {
+                servicePostEvent(TelephonyConstants.EventTelecomVideoCallDataUsageChanged,
+                        new VideoCallEvent<Long>(mCallId, dataUsage));
+            }
+        }
+
+        @Override
+        public void onCameraCapabilitiesChanged(
+                CameraCapabilities cameraCapabilities) {
+            Log.d("VideoCallCallback:onCallDataUsageChanged()");
+
+            if ((mEvents & EVENT_DATA_USAGE_CHANGED)
+                    == EVENT_DATA_USAGE_CHANGED) {
+                servicePostEvent(TelephonyConstants.EventTelecomVideoCallCameraCapabilities,
+                        new VideoCallEvent<CameraCapabilities>(mCallId, cameraCapabilities));
+            }
+
+        }
+    }
+
+    /*
+     * Container Class for Call and CallCallback Objects
+     */
+    private class CallContainer {
+
+        /*
+         * Call Container Members
+         */
+
+        private Call mCall;
+        private CallCallback mCallCallback;
+        private VideoCall mVideoCall;
+        private VideoCallCallback mVideoCallCallback;
+
+        /*
+         * Call Container Functions
+         */
+
+        public CallContainer(Call call,
+                CallCallback callback,
+                VideoCall videoCall,
+                VideoCallCallback videoCallCallback) {
+            mCall = call;
+            mCallCallback = callback;
+            mVideoCall = videoCall;
+            mVideoCallCallback = videoCallCallback;
+        }
+
+        public Call getCall() {
+            return mCall;
+        }
+
+        public CallCallback getCallback() {
+            return mCallCallback;
+        }
+
+        public InCallService.VideoCall getVideoCall() {
+            return mVideoCall;
+        }
+
+        public VideoCallCallback getVideoCallCallback() {
+            return mVideoCallCallback;
+        }
+
+        public void updateVideoCall(VideoCall videoCall, VideoCallCallback videoCallCallback) {
+            if (videoCall == null && videoCallCallback != null) {
+                Log.d("UpdateVideoCall: videoCall and videoCallCallback are null.");
+                return;
+            }
+            mVideoCall = videoCall;
+            mVideoCallCallback = videoCallCallback;
+        }
+    }
+
+    /*
+     * TODO: b/26272583 Refactor so that these are instance members of the
+     * incallservice. Then we can perform null checks using the design pattern
+     * of the "manager" classes.
+     */
+
+    private static EventFacade mEventFacade = null;
+    private static HashMap<String, CallContainer> mCallContainerMap =
+            new HashMap<String, CallContainer>();
+
+    @Override
+    public void onCallAdded(Call call) {
+        Log.d("onCallAdded: " + call.toString());
+        String id = getCallId(call);
+        Log.d("Adding " + id);
+        CallCallback callCallback = new CallCallback(id, CallCallback.EVENT_NONE);
+
+        call.registerCallback(callCallback);
+
+        VideoCall videoCall = call.getVideoCall();
+        VideoCallCallback videoCallCallback = null;
+
+        if (videoCall != null) {
+            synchronized (mLock) {
+                if (getVideoCallById(id) == null) {
+                    videoCallCallback = new VideoCallCallback(id, VideoCallCallback.EVENT_NONE);
+                    videoCall.registerCallback(videoCallCallback);
+                }
+            }
+        }
+        else {
+            // No valid video object
+            Log.d("No Video Call provided to InCallService.");
+        }
+
+        mCallContainerMap.put(id,
+                new CallContainer(call,
+                        callCallback,
+                        videoCall,
+                        videoCallCallback));
+
+        /*
+         * Once we have a call active, anchor the inCallService instance as a psuedo-singleton.
+         * Because object lifetime is not guaranteed we shouldn't do this in the
+         * constructor/destructor.
+         */
+        if (mService == null) {
+            mService = this;
+        }
+        else if (mService != this) {
+            Log.e("Multiple InCall Services Active in SL4A!");
+        }
+    }
+
+    @Override
+    public void onCallRemoved(Call call) {
+        Log.d("onCallRemoved: " + call.toString());
+        String id = getCallId(call);
+        Log.d("Removing " + id);
+
+        mCallContainerMap.remove(id);
+
+        if (mCallContainerMap.size() == 0) {
+            mService = null;
+        }
+    }
+
+    public static void setEventFacade(EventFacade facade) {
+        Log.d(String.format("setEventFacade(): Settings SL4A event facade to %s",
+                (facade != null) ? facade.toString() : "null"));
+        mEventFacade = facade;
+    }
+
+    private static boolean servicePostEvent(String eventName, Object event) {
+
+        if (mEventFacade == null) {
+            Log.d("servicePostEvent():SL4A eventFacade Is Null!!");
+            return false;
+        }
+
+        mEventFacade.postEvent(eventName, event);
+
+        return true;
+    }
+
+    public static String getCallId(Call call) {
+        if (call != null) {
+            return call.toString();
+        }
+        else
+            return "";
+    }
+
+    public static String getVideoCallId(InCallServiceImpl.VideoCall videoCall) {
+        if (videoCall != null)
+            return videoCall.toString();
+        else
+            return "";
+    }
+
+    private static Call getCallById(String callId) {
+
+        CallContainer cc = mCallContainerMap.get(callId);
+
+        if (cc != null) {
+            return cc.getCall();
+        }
+
+        return null;
+    }
+
+    private static CallCallback getCallCallbackById(String callId) {
+
+        CallContainer cc = mCallContainerMap.get(callId);
+
+        if (cc != null) {
+            return cc.getCallback();
+        }
+
+        return null;
+    }
+
+    private static InCallService.VideoCall getVideoCallById(String callId) {
+
+        CallContainer cc = mCallContainerMap.get(callId);
+
+        if (cc != null) {
+            return cc.getVideoCall();
+
+        }
+
+        return null;
+    }
+
+    private static VideoCallCallback
+            getVideoCallListenerById(String callId) {
+
+        CallContainer cc = mCallContainerMap.get(callId);
+
+        if (cc != null) {
+            return cc.getVideoCallCallback();
+        }
+
+        return null;
+    }
+
+    /*
+     * Public Call/Phone Functions
+     */
+
+    public static void callDisconnect(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("callDisconnect: callId is null");
+            return;
+        }
+
+        c.disconnect();
+    }
+
+    public static void holdCall(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("holdCall: callId is null");
+            return;
+        }
+        c.hold();
+    }
+
+    public static void mergeCallsInConference(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("mergeCallsInConference: callId is null");
+            return;
+        }
+        c.mergeConference();
+    }
+
+    public static void splitCallFromConf(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("splitCallFromConf: callId is null");
+            return;
+        }
+        c.splitFromConference();
+    }
+
+    public static void unholdCall(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("unholdCall: callId is null");
+            return;
+        }
+        c.unhold();
+    }
+
+    public static void joinCallsInConf(String callIdOne, String callIdTwo) {
+        Call callOne = getCallById(callIdOne);
+        Call callTwo = getCallById(callIdTwo);
+
+        if (callOne == null || callTwo == null) {
+            Log.d("joinCallsInConf: callOne or CallTwo is null");
+            return;
+        }
+
+        callOne.conference(callTwo);
+    }
+
+    public static Set<String> getCallIdList() {
+        return mCallContainerMap.keySet();
+    }
+
+    public static void clearCallList() {
+        mCallContainerMap.clear();
+    }
+
+    public static String callGetState(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            return getCallStateString(STATE_INVALID);
+        }
+
+        return getCallStateString(c.getState());
+    }
+
+    public static Call.Details callGetDetails(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d(String.format("Couldn't find an active call with ID:%s", callId));
+            return null;
+        }
+
+        return c.getDetails();
+    }
+
+    public static List<String> callGetCallProperties(String callId) {
+        Call.Details details = callGetDetails(callId);
+
+        if (details == null) {
+            return null;
+        }
+
+        return getCallPropertiesString(details.getCallProperties());
+    }
+
+    public static List<String> callGetCallCapabilities(String callId) {
+        Call.Details details = callGetDetails(callId);
+
+        if (details == null) {
+            return null;
+        }
+
+        return getCallCapabilitiesString(details.getCallCapabilities());
+    }
+
+    @SuppressWarnings("deprecation")
+    public static void overrideProximitySensor(Boolean screenOn) {
+        InCallServiceImpl svc = getService();
+        if (svc == null) {
+            Log.d("overrideProximitySensor: InCallServiceImpl is null.");
+            return;
+        }
+
+        Phone phone = svc.getPhone();
+        if (phone == null) {
+            Log.d("overrideProximitySensor: phone is null.");
+            return;
+        }
+
+        phone.setProximitySensorOff(screenOn);
+    }
+
+    public static CallAudioState serviceGetCallAudioState() {
+        InCallServiceImpl svc = getService();
+
+        if (svc != null) {
+            return svc.getCallAudioState();
+        }
+        else {
+            return null;
+        }
+    }
+
+    // Wonky name due to conflict with internal function
+    public static void serviceSetAudioRoute(String route) {
+        InCallServiceImpl svc = getService();
+
+        if (svc == null) {
+            Log.d("serviceSetAudioRoute: InCallServiceImpl is null.");
+            return;
+        }
+
+        int r = getAudioRoute(route);
+
+        Log.d(String.format("Setting Audio Route to %s:%d", route, r));
+
+        if (r == INVALID_AUDIO_ROUTE) {
+            Log.d(String.format("Invalid Audio route %s:%d", route, r));
+            return;
+        }
+        svc.setAudioRoute(r);
+    }
+
+    public static void callStartListeningForEvent(String callId, String strEvent) {
+
+        CallCallback cl = getCallCallbackById(callId);
+
+        if (cl == null) {
+            Log.d("callStartListeningForEvent: CallCallback is null.");
+            return;
+        }
+
+        int event = getCallCallbackEvent(strEvent);
+
+        if (event == CallCallback.EVENT_INVALID) {
+            Log.d("callStartListeningForEvent: event is invalid.");
+            return;
+        }
+
+        cl.startListeningForEvents(event);
+    }
+
+    public static void callStopListeningForEvent(String callId, String strEvent) {
+        CallCallback cl = getCallCallbackById(callId);
+
+        if (cl == null) {
+            Log.d("callStopListeningForEvent: CallCallback is null.");
+            return;
+        }
+
+        int event = getCallCallbackEvent(strEvent);
+
+        if (event == CallCallback.EVENT_INVALID) {
+            Log.d("callStopListeningForEvent: event is invalid.");
+            return;
+        }
+
+        cl.stopListeningForEvents(event);
+    }
+
+    public static void videoCallStartListeningForEvent(String callId, String strEvent) {
+        VideoCallCallback cl = getVideoCallListenerById(callId);
+
+        if (cl == null) {
+            Log.d(String.format("Couldn't find a call with call id:%s", callId));
+            return;
+        }
+
+        int event = getVideoCallCallbackEvent(strEvent);
+
+        if (event == VideoCallCallback.EVENT_INVALID) {
+            Log.d(String.format("Failed to find a valid event:[%s]", strEvent));
+            return;
+        }
+
+        cl.startListeningForEvents(event);
+    }
+
+    public static void videoCallStopListeningForEvent(String callId, String strEvent) {
+        VideoCallCallback cl = getVideoCallListenerById(callId);
+
+        if (cl == null) {
+            Log.d("videoCallStopListeningForEvent: CallCallback is null.");
+            return;
+        }
+
+        int event = getVideoCallCallbackEvent(strEvent);
+
+        if (event == VideoCallCallback.EVENT_INVALID) {
+            Log.d("getVideoCallCallbackEvent: event is invalid.");
+            return;
+        }
+
+        cl.stopListeningForEvents(event);
+    }
+
+    public static String videoCallGetState(String callId) {
+        Call c = getCallById(callId);
+
+        int state = CallCallback.STATE_INVALID;
+
+        if (c == null) {
+            Log.d("videoCallGetState: call is null.");
+        }
+        else {
+            state = c.getDetails().getVideoState();
+        }
+
+        return getVideoCallStateString(state);
+    }
+
+    public static void videoCallSendSessionModifyRequest(
+            String callId, String videoStateString, String videoQualityString) {
+        VideoCall vc = getVideoCallById(callId);
+
+        if (vc == null) {
+            Log.d("Invalid video call for call ID");
+            return;
+        }
+
+        int videoState = getVideoCallState(videoStateString);
+        int videoQuality = getVideoCallQuality(videoQualityString);
+
+        Log.d(String.format("Sending Modify request for %s:%d, %s:%d",
+                videoStateString, videoState, videoQualityString, videoQuality));
+
+        if (videoState == CallCallback.STATE_INVALID ||
+                videoQuality == QUALITY_INVALID || videoQuality == VideoProfile.QUALITY_UNKNOWN) {
+            Log.d("Invalid session modify request!");
+            return;
+        }
+
+        vc.sendSessionModifyRequest(new VideoProfile(videoState, videoQuality));
+    }
+
+    public static void videoCallSendSessionModifyResponse(
+            String callId, String videoStateString, String videoQualityString) {
+        VideoCall vc = getVideoCallById(callId);
+
+        if (vc == null) {
+            Log.d("Invalid video call for call ID");
+            return;
+        }
+
+        int videoState = getVideoCallState(videoStateString);
+        int videoQuality = getVideoCallQuality(videoQualityString);
+
+        Log.d(String.format("Sending Modify request for %s:%d, %s:%d",
+                videoStateString, videoState, videoQualityString, videoQuality));
+
+        if (videoState == CallCallback.STATE_INVALID ||
+                videoQuality == QUALITY_INVALID || videoQuality == VideoProfile.QUALITY_UNKNOWN) {
+            Log.d("Invalid session modify request!");
+            return;
+        }
+
+        vc.sendSessionModifyResponse(new VideoProfile(videoState, videoQuality));
+    }
+
+    public static void callAnswer(String callId, String videoState) {
+        Call c = getCallById(callId);
+
+        if (c == null) {
+            Log.d("callAnswer: call is null.");
+        }
+
+        int state = getVideoCallState(videoState);
+
+        if (state == CallCallback.STATE_INVALID) {
+            Log.d("callAnswer: video state is invalid.");
+            state = VideoProfile.STATE_AUDIO_ONLY;
+        }
+
+        c.answer(state);
+    }
+
+    public static void callReject(String callId, String message) {
+        Call c = getCallById(callId);
+
+        if (c == null) {
+            Log.d("callReject: call is null.");
+        }
+
+        c.reject((message != null) ? true : false, message);
+    }
+
+    public static String getCallParent(String callId) {
+        Call c = getCallById(callId);
+
+        if (c == null) {
+            Log.d("getCallParent: call is null.");
+            return null;
+        }
+        Call callParent = c.getParent();
+        return getCallId(callParent);
+    }
+
+    public static List<String> getCallChildren(String callId) {
+        Call c = getCallById(callId);
+
+        if (c == null) {
+            Log.d("getCallChildren: call is null.");
+            return null;
+        }
+        List<String> childrenList = new ArrayList<String>();
+        List<Call> callChildren = c.getChildren();
+        for (Call call : callChildren) {
+            childrenList.add(getCallId(call));
+        }
+        return childrenList;
+    }
+
+    public static void swapCallsInConference(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("swapCallsInConference: call is null.");
+            return;
+        }
+        c.swapConference();
+    }
+
+    public static void callPlayDtmfTone(String callId, char digit) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("callPlayDtmfTone: call is null.");
+            return;
+        }
+        c.playDtmfTone(digit);
+    }
+
+    public static void callStopDtmfTone(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            Log.d("callStopDtmfTone: call is null.");
+            return;
+        }
+        c.stopDtmfTone();
+    }
+
+    public static List<String> callGetCannedTextResponses(String callId) {
+        Call c = getCallById(callId);
+        if (c == null) {
+            return null;
+        }
+
+        return c.getCannedTextResponses();
+    }
+
+    /*
+     * String Mapping Functions for Facade Parameter Translation
+     */
+
+    public static String getVideoCallStateString(int state) {
+        switch (state) {
+            case VIDEO_STATE_AUDIO_ONLY:
+                return TelephonyConstants.VT_STATE_AUDIO_ONLY;
+            case VIDEO_STATE_TX_ENABLED:
+                return TelephonyConstants.VT_STATE_TX_ENABLED;
+            case VIDEO_STATE_RX_ENABLED:
+                return TelephonyConstants.VT_STATE_RX_ENABLED;
+            case VIDEO_STATE_BIDIRECTIONAL:
+                return TelephonyConstants.VT_STATE_BIDIRECTIONAL;
+            case VIDEO_STATE_TX_PAUSED:
+                return TelephonyConstants.VT_STATE_TX_PAUSED;
+            case VIDEO_STATE_RX_PAUSED:
+                return TelephonyConstants.VT_STATE_RX_PAUSED;
+            case VIDEO_STATE_BIDIRECTIONAL_PAUSED:
+                return TelephonyConstants.VT_STATE_BIDIRECTIONAL_PAUSED;
+            default:
+        }
+        Log.d("getVideoCallStateString: state is invalid.");
+        return TelephonyConstants.VT_STATE_STATE_INVALID;
+    }
+
+    public static int getVideoCallState(String state) {
+        switch (state.toUpperCase()) {
+            case TelephonyConstants.VT_STATE_AUDIO_ONLY:
+                return VIDEO_STATE_AUDIO_ONLY;
+            case TelephonyConstants.VT_STATE_TX_ENABLED:
+                return VIDEO_STATE_TX_ENABLED;
+            case TelephonyConstants.VT_STATE_RX_ENABLED:
+                return VIDEO_STATE_RX_ENABLED;
+            case TelephonyConstants.VT_STATE_BIDIRECTIONAL:
+                return VIDEO_STATE_BIDIRECTIONAL;
+            case TelephonyConstants.VT_STATE_TX_PAUSED:
+                return VIDEO_STATE_TX_PAUSED;
+            case TelephonyConstants.VT_STATE_RX_PAUSED:
+                return VIDEO_STATE_RX_PAUSED;
+            case TelephonyConstants.VT_STATE_BIDIRECTIONAL_PAUSED:
+                return VIDEO_STATE_BIDIRECTIONAL_PAUSED;
+
+            default:
+        }
+        Log.d("getVideoCallState: state is invalid.");
+        return CallCallback.STATE_INVALID;
+    }
+
+    private static int getVideoCallQuality(String quality) {
+
+        switch (quality.toUpperCase()) {
+            case TelephonyConstants.VT_VIDEO_QUALITY_UNKNOWN:
+                return VideoProfile.QUALITY_UNKNOWN;
+            case TelephonyConstants.VT_VIDEO_QUALITY_HIGH:
+                return VideoProfile.QUALITY_HIGH;
+            case TelephonyConstants.VT_VIDEO_QUALITY_MEDIUM:
+                return VideoProfile.QUALITY_MEDIUM;
+            case TelephonyConstants.VT_VIDEO_QUALITY_LOW:
+                return VideoProfile.QUALITY_LOW;
+            case TelephonyConstants.VT_VIDEO_QUALITY_DEFAULT:
+                return VideoProfile.QUALITY_DEFAULT;
+            default:
+        }
+        Log.d("getVideoCallQuality: quality is invalid.");
+        return QUALITY_INVALID;
+    }
+
+    public static String getVideoCallQualityString(int quality) {
+        switch (quality) {
+            case VideoProfile.QUALITY_UNKNOWN:
+                return TelephonyConstants.VT_VIDEO_QUALITY_UNKNOWN;
+            case VideoProfile.QUALITY_HIGH:
+                return TelephonyConstants.VT_VIDEO_QUALITY_HIGH;
+            case VideoProfile.QUALITY_MEDIUM:
+                return TelephonyConstants.VT_VIDEO_QUALITY_MEDIUM;
+            case VideoProfile.QUALITY_LOW:
+                return TelephonyConstants.VT_VIDEO_QUALITY_LOW;
+            case VideoProfile.QUALITY_DEFAULT:
+                return TelephonyConstants.VT_VIDEO_QUALITY_DEFAULT;
+            default:
+        }
+        Log.d("getVideoCallQualityString: quality is invalid.");
+        return TelephonyConstants.VT_VIDEO_QUALITY_INVALID;
+    }
+
+    private static int getCallCallbackEvent(String event) {
+
+        switch (event.toUpperCase()) {
+            case "EVENT_STATE_CHANGED":
+                return CallCallback.EVENT_STATE_CHANGED;
+            case "EVENT_PARENT_CHANGED":
+                return CallCallback.EVENT_PARENT_CHANGED;
+            case "EVENT_CHILDREN_CHANGED":
+                return CallCallback.EVENT_CHILDREN_CHANGED;
+            case "EVENT_DETAILS_CHANGED":
+                return CallCallback.EVENT_DETAILS_CHANGED;
+            case "EVENT_CANNED_TEXT_RESPONSES_LOADED":
+                return CallCallback.EVENT_CANNED_TEXT_RESPONSES_LOADED;
+            case "EVENT_POST_DIAL_WAIT":
+                return CallCallback.EVENT_POST_DIAL_WAIT;
+            case "EVENT_VIDEO_CALL_CHANGED":
+                return CallCallback.EVENT_VIDEO_CALL_CHANGED;
+            case "EVENT_CALL_DESTROYED":
+                return CallCallback.EVENT_CALL_DESTROYED;
+            case "EVENT_CONFERENCABLE_CALLS_CHANGED":
+                return CallCallback.EVENT_CONFERENCABLE_CALLS_CHANGED;
+        }
+        Log.d("getCallCallbackEvent: event is invalid.");
+        return CallCallback.EVENT_INVALID;
+    }
+
+    public static String getCallCallbackEventString(int event) {
+
+        switch (event) {
+            case CallCallback.EVENT_STATE_CHANGED:
+                return "EVENT_STATE_CHANGED";
+            case CallCallback.EVENT_PARENT_CHANGED:
+                return "EVENT_PARENT_CHANGED";
+            case CallCallback.EVENT_CHILDREN_CHANGED:
+                return "EVENT_CHILDREN_CHANGED";
+            case CallCallback.EVENT_DETAILS_CHANGED:
+                return "EVENT_DETAILS_CHANGED";
+            case CallCallback.EVENT_CANNED_TEXT_RESPONSES_LOADED:
+                return "EVENT_CANNED_TEXT_RESPONSES_LOADED";
+            case CallCallback.EVENT_POST_DIAL_WAIT:
+                return "EVENT_POST_DIAL_WAIT";
+            case CallCallback.EVENT_VIDEO_CALL_CHANGED:
+                return "EVENT_VIDEO_CALL_CHANGED";
+            case CallCallback.EVENT_CALL_DESTROYED:
+                return "EVENT_CALL_DESTROYED";
+            case CallCallback.EVENT_CONFERENCABLE_CALLS_CHANGED:
+                return "EVENT_CONFERENCABLE_CALLS_CHANGED";
+        }
+        Log.d("getCallCallbackEventString: event is invalid.");
+        return "EVENT_INVALID";
+    }
+
+    private static int getVideoCallCallbackEvent(String event) {
+
+        switch (event) {
+            case TelephonyConstants.EVENT_VIDEO_SESSION_MODIFY_REQUEST_RECEIVED:
+                return VideoCallCallback.EVENT_SESSION_MODIFY_REQUEST_RECEIVED;
+            case TelephonyConstants.EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED:
+                return VideoCallCallback.EVENT_SESSION_MODIFY_RESPONSE_RECEIVED;
+            case TelephonyConstants.EVENT_VIDEO_SESSION_EVENT:
+                return VideoCallCallback.EVENT_SESSION_EVENT;
+            case TelephonyConstants.EVENT_VIDEO_PEER_DIMENSIONS_CHANGED:
+                return VideoCallCallback.EVENT_PEER_DIMENSIONS_CHANGED;
+            case TelephonyConstants.EVENT_VIDEO_QUALITY_CHANGED:
+                return VideoCallCallback.EVENT_VIDEO_QUALITY_CHANGED;
+            case TelephonyConstants.EVENT_VIDEO_DATA_USAGE_CHANGED:
+                return VideoCallCallback.EVENT_DATA_USAGE_CHANGED;
+            case TelephonyConstants.EVENT_VIDEO_CAMERA_CAPABILITIES_CHANGED:
+                return VideoCallCallback.EVENT_CAMERA_CAPABILITIES_CHANGED;
+        }
+        Log.d("getVideoCallCallbackEvent: event is invalid.");
+        return CallCallback.EVENT_INVALID;
+    }
+
+    public static String getVideoCallCallbackEventString(int event) {
+
+        switch (event) {
+            case VideoCallCallback.EVENT_SESSION_MODIFY_REQUEST_RECEIVED:
+                return TelephonyConstants.EVENT_VIDEO_SESSION_MODIFY_REQUEST_RECEIVED;
+            case VideoCallCallback.EVENT_SESSION_MODIFY_RESPONSE_RECEIVED:
+                return TelephonyConstants.EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED;
+            case VideoCallCallback.EVENT_SESSION_EVENT:
+                return TelephonyConstants.EVENT_VIDEO_SESSION_EVENT;
+            case VideoCallCallback.EVENT_PEER_DIMENSIONS_CHANGED:
+                return TelephonyConstants.EVENT_VIDEO_PEER_DIMENSIONS_CHANGED;
+            case VideoCallCallback.EVENT_VIDEO_QUALITY_CHANGED:
+                return TelephonyConstants.EVENT_VIDEO_QUALITY_CHANGED;
+            case VideoCallCallback.EVENT_DATA_USAGE_CHANGED:
+                return TelephonyConstants.EVENT_VIDEO_DATA_USAGE_CHANGED;
+            case VideoCallCallback.EVENT_CAMERA_CAPABILITIES_CHANGED:
+                return TelephonyConstants.EVENT_VIDEO_CAMERA_CAPABILITIES_CHANGED;
+        }
+        Log.d("getVideoCallCallbackEventString: event is invalid.");
+        return TelephonyConstants.EVENT_VIDEO_INVALID;
+    }
+
+    public static String getCallStateString(int state) {
+        switch (state) {
+            case Call.STATE_NEW:
+                return TelephonyConstants.CALL_STATE_NEW;
+            case Call.STATE_DIALING:
+                return TelephonyConstants.CALL_STATE_DIALING;
+            case Call.STATE_RINGING:
+                return TelephonyConstants.CALL_STATE_RINGING;
+            case Call.STATE_HOLDING:
+                return TelephonyConstants.CALL_STATE_HOLDING;
+            case Call.STATE_ACTIVE:
+                return TelephonyConstants.CALL_STATE_ACTIVE;
+            case Call.STATE_DISCONNECTED:
+                return TelephonyConstants.CALL_STATE_DISCONNECTED;
+            case Call.STATE_PRE_DIAL_WAIT:
+                return TelephonyConstants.CALL_STATE_PRE_DIAL_WAIT;
+            case Call.STATE_CONNECTING:
+                return TelephonyConstants.CALL_STATE_CONNECTING;
+            case Call.STATE_DISCONNECTING:
+                return TelephonyConstants.CALL_STATE_DISCONNECTING;
+            case STATE_INVALID:
+                return TelephonyConstants.CALL_STATE_INVALID;
+            default:
+                return TelephonyConstants.CALL_STATE_UNKNOWN;
+        }
+    }
+
+    private static int getAudioRoute(String audioRoute) {
+        switch (audioRoute.toUpperCase()) {
+            case TelephonyConstants.AUDIO_ROUTE_BLUETOOTH:
+                return CallAudioState.ROUTE_BLUETOOTH;
+            case TelephonyConstants.AUDIO_ROUTE_EARPIECE:
+                return CallAudioState.ROUTE_EARPIECE;
+            case TelephonyConstants.AUDIO_ROUTE_SPEAKER:
+                return CallAudioState.ROUTE_SPEAKER;
+            case TelephonyConstants.AUDIO_ROUTE_WIRED_HEADSET:
+                return CallAudioState.ROUTE_WIRED_HEADSET;
+            case TelephonyConstants.AUDIO_ROUTE_WIRED_OR_EARPIECE:
+                return CallAudioState.ROUTE_WIRED_OR_EARPIECE;
+            default:
+                return INVALID_AUDIO_ROUTE;
+        }
+    }
+
+    public static String getAudioRouteString(int audioRoute) {
+        return CallAudioState.audioRouteToString(audioRoute);
+    }
+
+    public static String getVideoCallSessionEventString(int event) {
+
+        switch (event) {
+            case Connection.VideoProvider.SESSION_EVENT_RX_PAUSE:
+                return TelephonyConstants.SESSION_EVENT_RX_PAUSE;
+            case Connection.VideoProvider.SESSION_EVENT_RX_RESUME:
+                return TelephonyConstants.SESSION_EVENT_RX_RESUME;
+            case Connection.VideoProvider.SESSION_EVENT_TX_START:
+                return TelephonyConstants.SESSION_EVENT_TX_START;
+            case Connection.VideoProvider.SESSION_EVENT_TX_STOP:
+                return TelephonyConstants.SESSION_EVENT_TX_STOP;
+            case Connection.VideoProvider.SESSION_EVENT_CAMERA_FAILURE:
+                return TelephonyConstants.SESSION_EVENT_CAMERA_FAILURE;
+            case Connection.VideoProvider.SESSION_EVENT_CAMERA_READY:
+                return TelephonyConstants.SESSION_EVENT_CAMERA_READY;
+            default:
+                return TelephonyConstants.SESSION_EVENT_UNKNOWN;
+        }
+    }
+
+    public static String getCallCapabilityString(int capability) {
+        switch (capability) {
+            case Call.Details.CAPABILITY_HOLD:
+                return TelephonyConstants.CALL_CAPABILITY_HOLD;
+            case Call.Details.CAPABILITY_SUPPORT_HOLD:
+                return TelephonyConstants.CALL_CAPABILITY_SUPPORT_HOLD;
+            case Call.Details.CAPABILITY_MERGE_CONFERENCE:
+                return TelephonyConstants.CALL_CAPABILITY_MERGE_CONFERENCE;
+            case Call.Details.CAPABILITY_SWAP_CONFERENCE:
+                return TelephonyConstants.CALL_CAPABILITY_SWAP_CONFERENCE;
+            case Call.Details.CAPABILITY_UNUSED_1:
+                return TelephonyConstants.CALL_CAPABILITY_UNUSED_1;
+            case Call.Details.CAPABILITY_RESPOND_VIA_TEXT:
+                return TelephonyConstants.CALL_CAPABILITY_RESPOND_VIA_TEXT;
+            case Call.Details.CAPABILITY_MUTE:
+                return TelephonyConstants.CALL_CAPABILITY_MUTE;
+            case Call.Details.CAPABILITY_MANAGE_CONFERENCE:
+                return TelephonyConstants.CALL_CAPABILITY_MANAGE_CONFERENCE;
+            case Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_RX:
+                return TelephonyConstants.CALL_CAPABILITY_SUPPORTS_VT_LOCAL_RX;
+            case Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX:
+                return TelephonyConstants.CALL_CAPABILITY_SUPPORTS_VT_LOCAL_TX;
+            case Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL:
+                return TelephonyConstants.CALL_CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL;
+            case Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_RX:
+                return TelephonyConstants.CALL_CAPABILITY_SUPPORTS_VT_REMOTE_RX;
+            case Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_TX:
+                return TelephonyConstants.CALL_CAPABILITY_SUPPORTS_VT_REMOTE_TX;
+            case Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL:
+                return TelephonyConstants.CALL_CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL;
+            case Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE:
+                return TelephonyConstants.CALL_CAPABILITY_SEPARATE_FROM_CONFERENCE;
+            case Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE:
+                return TelephonyConstants.CALL_CAPABILITY_DISCONNECT_FROM_CONFERENCE;
+            case Call.Details.CAPABILITY_SPEED_UP_MT_AUDIO:
+                return TelephonyConstants.CALL_CAPABILITY_SPEED_UP_MT_AUDIO;
+            case Call.Details.CAPABILITY_CAN_UPGRADE_TO_VIDEO:
+                return TelephonyConstants.CALL_CAPABILITY_CAN_UPGRADE_TO_VIDEO;
+            case Call.Details.CAPABILITY_CAN_PAUSE_VIDEO:
+                return TelephonyConstants.CALL_CAPABILITY_CAN_PAUSE_VIDEO;
+        }
+        return TelephonyConstants.CALL_CAPABILITY_UNKOWN;
+    }
+
+    public static List<String> getCallCapabilitiesString(int capabilities) {
+        final int[] capabilityConstants = new int[] {
+                Call.Details.CAPABILITY_HOLD,
+                Call.Details.CAPABILITY_SUPPORT_HOLD,
+                Call.Details.CAPABILITY_MERGE_CONFERENCE,
+                Call.Details.CAPABILITY_SWAP_CONFERENCE,
+                Call.Details.CAPABILITY_UNUSED_1,
+                Call.Details.CAPABILITY_RESPOND_VIA_TEXT,
+                Call.Details.CAPABILITY_MUTE,
+                Call.Details.CAPABILITY_MANAGE_CONFERENCE,
+                Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_RX,
+                Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX,
+                Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL,
+                Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_RX,
+                Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_TX,
+                Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL,
+                Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE,
+                Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE,
+                Call.Details.CAPABILITY_SPEED_UP_MT_AUDIO,
+                Call.Details.CAPABILITY_CAN_UPGRADE_TO_VIDEO,
+                Call.Details.CAPABILITY_CAN_PAUSE_VIDEO
+        };
+
+        List<String> capabilityList = new ArrayList<String>();
+
+        for (int capability : capabilityConstants) {
+            if ((capabilities & capability) == capability) {
+                capabilityList.add(getCallCapabilityString(capability));
+            }
+        }
+        return capabilityList;
+    }
+
+    public static String getCallPropertyString(int property) {
+
+        switch (property) {
+            case Call.Details.PROPERTY_CONFERENCE:
+                return TelephonyConstants.CALL_PROPERTY_CONFERENCE;
+            case Call.Details.PROPERTY_GENERIC_CONFERENCE:
+                return TelephonyConstants.CALL_PROPERTY_GENERIC_CONFERENCE;
+            case Call.Details.PROPERTY_EMERGENCY_CALLBACK_MODE:
+                return TelephonyConstants.CALL_PROPERTY_EMERGENCY_CALLBACK_MODE;
+            case Call.Details.PROPERTY_WIFI:
+                return TelephonyConstants.CALL_PROPERTY_WIFI;
+            case Call.Details.PROPERTY_HIGH_DEF_AUDIO:
+                return TelephonyConstants.CALL_PROPERTY_HIGH_DEF_AUDIO;
+            default:
+                return TelephonyConstants.CALL_PROPERTY_UNKNOWN;
+        }
+    }
+
+    public static List<String> getCallPropertiesString(int properties) {
+        final int[] propertyConstants = new int[] {
+                Call.Details.PROPERTY_CONFERENCE,
+                Call.Details.PROPERTY_GENERIC_CONFERENCE,
+                Call.Details.PROPERTY_EMERGENCY_CALLBACK_MODE,
+                Call.Details.PROPERTY_WIFI,
+                Call.Details.PROPERTY_HIGH_DEF_AUDIO
+        };
+
+        List<String> propertyList = new ArrayList<String>();
+
+        for (int property : propertyConstants) {
+            if ((properties & property) == property) {
+                propertyList.add(getCallPropertyString(property));
+            }
+        }
+
+        return propertyList;
+    }
+
+    public static String getCallPresentationInfoString(int presentation) {
+        switch (presentation) {
+            case TelecomManager.PRESENTATION_ALLOWED:
+                return TelephonyConstants.CALL_PRESENTATION_ALLOWED;
+            case TelecomManager.PRESENTATION_RESTRICTED:
+                return TelephonyConstants.CALL_PRESENTATION_RESTRICTED;
+            case TelecomManager.PRESENTATION_PAYPHONE:
+                return TelephonyConstants.CALL_PRESENTATION_PAYPHONE;
+            default:
+                return TelephonyConstants.CALL_PRESENTATION_UNKNOWN;
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/SmsFacade.java b/Common/src/com/googlecode/android_scripting/facade/telephony/SmsFacade.java
new file mode 100644
index 0000000..1744d2b
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/SmsFacade.java
@@ -0,0 +1,990 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import com.google.android.mms.ContentType;
+import com.google.android.mms.InvalidHeaderValueException;
+import com.google.android.mms.pdu.CharacterSets;
+import com.google.android.mms.pdu.EncodedStringValue;
+import com.google.android.mms.pdu.GenericPdu;
+import com.google.android.mms.pdu.PduBody;
+import com.google.android.mms.pdu.PduComposer;
+import com.google.android.mms.pdu.PduHeaders;
+import com.google.android.mms.pdu.PduParser;
+import com.google.android.mms.pdu.PduPart;
+import com.google.android.mms.pdu.PduPersister;
+import com.google.android.mms.pdu.SendConf;
+import com.google.android.mms.pdu.SendReq;
+import com.google.android.mms.MmsException;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.Telephony.Sms.Intents;
+import android.provider.Telephony.Mms;
+import android.telephony.SmsManager;
+import android.telephony.SmsMessage;
+import android.telephony.SmsCbMessage;
+import com.android.internal.telephony.gsm.SmsCbConstants;
+import com.android.internal.telephony.cdma.sms.SmsEnvelope;
+import android.telephony.SmsCbEtwsInfo;
+import android.telephony.SmsCbCmasInfo;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.facade.telephony.TelephonyConstants;
+
+//FIXME: Change the build order to use constants defined in here
+//import com.googlecode.android_scripting.provider.TelephonyTestProvider;
+
+/**
+ * Exposes SmsManager functionality.
+ */
+public class SmsFacade extends RpcReceiver {
+
+    static final boolean DBG = false;
+
+    private final EventFacade mEventFacade;
+    private final SmsManager mSms;
+    private final Context mContext;
+    private final Service mService;
+    private BroadcastReceiver mSmsSendListener;
+    private BroadcastReceiver mSmsIncomingListener;
+    private int mNumExpectedSentEvents;
+    private int mNumExpectedDeliveredEvents;
+    private boolean mListeningIncomingSms;
+    private IntentFilter mEmergencyCBMessage;
+    private BroadcastReceiver mGsmEmergencyCBMessageListener;
+    private BroadcastReceiver mCdmaEmergencyCBMessageListener;
+    private boolean mGsmEmergencyCBListenerRegistered;
+    private boolean mCdmaEmergencyCBListenerRegistered;
+    private boolean mSentReceiversRegistered;
+    private Object lock = new Object();
+
+    private BroadcastReceiver mMmsSendListener;
+    private BroadcastReceiver mMmsIncomingListener;
+    private boolean mListeningIncomingMms;
+
+    TelephonyManager mTelephonyManager;
+
+    private static final String SMS_MESSAGE_STATUS_DELIVERED_ACTION =
+            "com.googlecode.android_scripting.sms.MESSAGE_STATUS_DELIVERED";
+    private static final String SMS_MESSAGE_SENT_ACTION =
+            "com.googlecode.android_scripting.sms.MESSAGE_SENT";
+
+    private static final String EMERGENCY_CB_MESSAGE_RECEIVED_ACTION =
+            "android.provider.Telephony.SMS_EMERGENCY_CB_RECEIVED";
+
+    private static final String MMS_MESSAGE_SENT_ACTION =
+            "com.googlecode.android_scripting.mms.MESSAGE_SENT";
+
+    private final int MAX_MESSAGE_LENGTH = 160;
+    private final int INTERNATIONAL_NUMBER_LENGTH = 12;
+    private final int DOMESTIC_NUMBER_LENGTH = 10;
+
+    private static final String DEFAULT_FROM_PHONE_NUMBER = new String("8675309");
+
+    private final int[] mGsmCbMessageIdList = {
+            SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING,
+            SmsCbConstants.MESSAGE_ID_ETWS_TSUNAMI_WARNING,
+            SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING,
+            SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE,
+            SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_LIKELY,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_IMMEDIATE_LIKELY,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_OBSERVED,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST,
+            SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE
+    };
+
+    private final int[] mCdmaCbMessageIdList = {
+            SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT,
+            SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT,
+            SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT,
+            SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY,
+            SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE
+    };
+
+    public SmsFacade(FacadeManager manager) {
+
+        super(manager);
+        mService = manager.getService();
+        mContext = mService;
+        mSms = SmsManager.getDefault();
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mSmsSendListener = new SmsSendListener();
+        mSmsIncomingListener = new SmsIncomingListener();
+        mNumExpectedSentEvents = 0;
+        mNumExpectedDeliveredEvents = 0;
+        mListeningIncomingSms = false;
+        mGsmEmergencyCBMessageListener = new SmsEmergencyCBMessageListener();
+        mCdmaEmergencyCBMessageListener = new SmsEmergencyCBMessageListener();
+        mGsmEmergencyCBListenerRegistered = false;
+        mCdmaEmergencyCBListenerRegistered = false;
+        mSentReceiversRegistered = false;
+
+        mMmsIncomingListener = new MmsIncomingListener();
+        mMmsSendListener = new MmsSendListener();
+
+        mListeningIncomingMms = false;
+
+        IntentFilter smsFilter = new IntentFilter(SMS_MESSAGE_SENT_ACTION);
+        smsFilter.addAction(SMS_MESSAGE_STATUS_DELIVERED_ACTION);
+
+        IntentFilter mmsFilter = new IntentFilter(MMS_MESSAGE_SENT_ACTION);
+
+        synchronized (lock) {
+            mService.registerReceiver(mSmsSendListener, smsFilter);
+            mService.registerReceiver(mMmsSendListener, mmsFilter);
+            mSentReceiversRegistered = true;
+        }
+
+        mTelephonyManager =
+                (TelephonyManager) mService.getSystemService(Context.TELEPHONY_SERVICE);
+    }
+
+    // FIXME: Move to a utility class
+    // FIXME: remove the MODE_WORLD_READABLE once we verify the use case
+    @SuppressWarnings("deprecation")
+    private boolean writeBytesToFile(String fileName, byte[] pdu) {
+        FileOutputStream writer = null;
+        try {
+            writer = mContext.openFileOutput(fileName, Context.MODE_WORLD_READABLE);
+            writer.write(pdu);
+            return true;
+        } catch (final IOException e) {
+            return false;
+        } finally {
+            if (writer != null) {
+                try {
+                    writer.close();
+                } catch (IOException e) {
+                }
+            }
+        }
+    }
+
+    // FIXME: Move to a utility class
+    private boolean writeBytesToCacheFile(String fileName, byte[] pdu) {
+        File mmsFile = new File(mContext.getCacheDir(), fileName);
+        Log.d(String.format("filename:%s, directory:%s", fileName,
+                mContext.getCacheDir().toString()));
+        FileOutputStream writer = null;
+        try {
+            writer = new FileOutputStream(mmsFile);
+            writer.write(pdu);
+            return true;
+        } catch (final IOException e) {
+            Log.d("writeBytesToCacheFile() failed with " + e.toString());
+            return false;
+        } finally {
+            if (writer != null) {
+                try {
+                    writer.close();
+                } catch (IOException e) {
+                }
+            }
+        }
+    }
+
+    @Deprecated
+    @Rpc(description = "Starts tracking incoming SMS.")
+    public void smsStartTrackingIncomingMessage() {
+        Log.d("Using Deprecated smsStartTrackingIncomingMessage!");
+        smsStartTrackingIncomingSmsMessage();
+    }
+
+    @Rpc(description = "Starts tracking incoming SMS.")
+    public void smsStartTrackingIncomingSmsMessage() {
+        mService.registerReceiver(mSmsIncomingListener,
+                new IntentFilter(Intents.SMS_RECEIVED_ACTION));
+        mListeningIncomingSms = true;
+    }
+
+    @Deprecated
+    @Rpc(description = "Stops tracking incoming SMS.")
+    public void smsStopTrackingIncomingMessage() {
+        Log.d("Using Deprecated smsStopTrackingIncomingMessage!");
+        smsStopTrackingIncomingSmsMessage();
+    }
+
+    @Rpc(description = "Stops tracking incoming SMS.")
+    public void smsStopTrackingIncomingSmsMessage() {
+        if (mListeningIncomingSms) {
+            mListeningIncomingSms = false;
+            try {
+                mService.unregisterReceiver(mSmsIncomingListener);
+            } catch (Exception e) {
+                Log.e("Tried to unregister nonexistent SMS Listener!");
+            }
+        }
+    }
+
+    @Rpc(description = "Starts tracking incoming MMS.")
+    public void smsStartTrackingIncomingMmsMessage() {
+        IntentFilter mmsReceived = new IntentFilter(Intents.MMS_DOWNLOADED_ACTION);
+        mmsReceived.addAction(Intents.WAP_PUSH_RECEIVED_ACTION);
+        mmsReceived.addAction(Intents.DATA_SMS_RECEIVED_ACTION);
+        mService.registerReceiver(mMmsIncomingListener, mmsReceived);
+        mListeningIncomingSms = true;
+    }
+
+    @Rpc(description = "Stops tracking incoming MMS.")
+    public void smsStopTrackingIncomingMmsMessage() {
+        if (mListeningIncomingMms) {
+            mListeningIncomingMms = false;
+            try {
+                mService.unregisterReceiver(mMmsIncomingListener);
+            } catch (Exception e) {
+                Log.e("Tried to unregister nonexistent MMS Listener!");
+            }
+        }
+    }
+
+    // Currently requires 'adb shell su root setenforce 0'
+    @Rpc(description = "Send a multimedia message to a specified number.")
+    public void smsSendMultimediaMessage(
+                        @RpcParameter(name = "toPhoneNumber")
+            String toPhoneNumber,
+                        @RpcParameter(name = "subject")
+            String subject,
+                        @RpcParameter(name = "message")
+            String message,
+            @RpcParameter(name = "fromPhoneNumber")
+            @RpcOptional
+            String fromPhoneNumber,
+            @RpcParameter(name = "fileName")
+            @RpcOptional
+            String fileName) {
+
+        MmsBuilder mms = new MmsBuilder();
+
+        mms.setToPhoneNumber(toPhoneNumber);
+        if (fromPhoneNumber == null) {
+            mTelephonyManager.getLine1Number(); //TODO: b/21592513 - multi-sim awareness
+        }
+
+        if (DBG) {
+            Log.d(String.format(
+                    "Params:toPhoneNumber(%s),subject(%s),message(%s),fromPhoneNumber(%s),filename(%s)",
+                    toPhoneNumber, subject, message,
+                    (fromPhoneNumber != null) ? fromPhoneNumber : "",
+                            (fileName != null) ? fileName : ""));
+        }
+
+        mms.setFromPhoneNumber((fromPhoneNumber != null) ? fromPhoneNumber : DEFAULT_FROM_PHONE_NUMBER);
+        mms.setSubject(subject);
+        mms.setDate();
+        mms.addMessageBody(message);
+        mms.setMessageClass(MmsBuilder.MESSAGE_CLASS_PERSONAL);
+        mms.setMessagePriority(MmsBuilder.DEFAULT_PRIORITY);
+        mms.setDeliveryReport(true);
+        mms.setReadReport(true);
+        // Default to 1 week;
+        mms.setExpirySeconds(MmsBuilder.DEFAULT_EXPIRY_TIME);
+
+        Uri contentUri = null;
+
+        String randomFileName = "mms." + String.valueOf(System.currentTimeMillis()) + ".dat";
+
+        byte[] mmsBytes = mms.build();
+        if (mmsBytes.length == 0) {
+            Log.e("Failed to build PDU!");
+            return;
+        }
+
+        if (writeBytesToCacheFile(randomFileName, mmsBytes) == false) {
+            Log.e("Failed to write PDU to file");
+            return;
+        }
+
+        contentUri = (new Uri.Builder())
+                .authority("com.googlecode.android_scripting.provider.telephonytestprovider")
+                .path("mms/" + randomFileName)
+                .scheme(ContentResolver.SCHEME_CONTENT)
+                .build();
+
+        if (contentUri != null) {
+            Log.d(String.format("URI String: %s", contentUri.toString()));
+
+            SmsManager.getDefault().sendMultimediaMessage(mContext,
+                    contentUri, null/* locationUrl */, null/* configOverrides */,
+                    PendingIntent.getBroadcast(mService, 0,
+                            new Intent(MMS_MESSAGE_SENT_ACTION), 0)
+                    );
+        }
+        else {
+            Log.d("smsSendMultimediaMessage():Content URI String is null");
+        }
+    }
+
+    @Rpc(description = "Send a text message to a specified number.")
+    public void smsSendTextMessage(
+                        @RpcParameter(name = "phoneNumber")
+            String phoneNumber,
+                        @RpcParameter(name = "message")
+            String message,
+                        @RpcParameter(name = "deliveryReportRequired")
+            Boolean deliveryReportRequired) {
+
+        if (message.length() > MAX_MESSAGE_LENGTH) {
+            ArrayList<String> messagesParts = mSms.divideMessage(message);
+            mNumExpectedSentEvents = mNumExpectedDeliveredEvents = messagesParts.size();
+            ArrayList<PendingIntent> sentIntents = new ArrayList<PendingIntent>();
+            ArrayList<PendingIntent> deliveredIntents = new ArrayList<PendingIntent>();
+            for (int i = 0; i < messagesParts.size(); i++) {
+                sentIntents.add(PendingIntent.getBroadcast(mService, 0,
+                        new Intent(SMS_MESSAGE_SENT_ACTION), 0));
+                if (deliveryReportRequired) {
+                    deliveredIntents.add(
+                            PendingIntent.getBroadcast(mService, 0,
+                                    new Intent(SMS_MESSAGE_STATUS_DELIVERED_ACTION), 0));
+                }
+            }
+            mSms.sendMultipartTextMessage(
+                    phoneNumber, null, messagesParts,
+                    sentIntents, deliveryReportRequired ? deliveredIntents : null);
+        } else {
+            mNumExpectedSentEvents = mNumExpectedDeliveredEvents = 1;
+            PendingIntent sentIntent = PendingIntent.getBroadcast(mService, 0,
+                    new Intent(SMS_MESSAGE_SENT_ACTION), 0);
+            PendingIntent deliveredIntent = PendingIntent.getBroadcast(mService, 0,
+                    new Intent(SMS_MESSAGE_STATUS_DELIVERED_ACTION), 0);
+            mSms.sendTextMessage(
+                    phoneNumber, null, message, sentIntent,
+                    deliveryReportRequired ? deliveredIntent : null);
+        }
+    }
+
+    @Rpc(description = "Retrieves all messages currently stored on ICC.")
+    public ArrayList<SmsMessage> smsGetAllMessagesFromIcc() {
+        return SmsManager.getDefault().getAllMessagesFromIcc();
+    }
+
+    @Rpc(description = "Starts tracking GSM Emergency CB Messages.")
+    public void smsStartTrackingGsmEmergencyCBMessage() {
+        if (!mGsmEmergencyCBListenerRegistered) {
+            for (int messageId : mGsmCbMessageIdList) {
+                mSms.enableCellBroadcast(
+                        messageId,
+                        SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+            }
+
+            mEmergencyCBMessage = new IntentFilter(EMERGENCY_CB_MESSAGE_RECEIVED_ACTION);
+            mService.registerReceiver(mGsmEmergencyCBMessageListener,
+                    mEmergencyCBMessage);
+            mGsmEmergencyCBListenerRegistered = true;
+        }
+    }
+
+    @Rpc(description = "Stop tracking GSM Emergency CB Messages")
+    public void smsStopTrackingGsmEmergencyCBMessage() {
+        if (mGsmEmergencyCBListenerRegistered) {
+            mService.unregisterReceiver(mGsmEmergencyCBMessageListener);
+            mGsmEmergencyCBListenerRegistered = false;
+            for (int messageId : mGsmCbMessageIdList) {
+                mSms.disableCellBroadcast(
+                        messageId,
+                        SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+            }
+        }
+    }
+
+    @Rpc(description = "Starts tracking CDMA Emergency CB Messages")
+    public void smsStartTrackingCdmaEmergencyCBMessage() {
+        if (!mCdmaEmergencyCBListenerRegistered) {
+            for (int messageId : mCdmaCbMessageIdList) {
+                mSms.enableCellBroadcast(
+                        messageId,
+                        SmsManager.CELL_BROADCAST_RAN_TYPE_CDMA);
+            }
+            mEmergencyCBMessage = new IntentFilter(EMERGENCY_CB_MESSAGE_RECEIVED_ACTION);
+            mService.registerReceiver(mCdmaEmergencyCBMessageListener,
+                    mEmergencyCBMessage);
+            mCdmaEmergencyCBListenerRegistered = true;
+        }
+    }
+
+    @Rpc(description = "Stop tracking CDMA Emergency CB Message.")
+    public void smsStopTrackingCdmaEmergencyCBMessage() {
+        if (mCdmaEmergencyCBListenerRegistered) {
+            mService.unregisterReceiver(mCdmaEmergencyCBMessageListener);
+            mCdmaEmergencyCBListenerRegistered = false;
+            for (int messageId : mCdmaCbMessageIdList) {
+                mSms.disableCellBroadcast(
+                        messageId,
+                        SmsManager.CELL_BROADCAST_RAN_TYPE_CDMA);
+            }
+        }
+    }
+
+    private class SmsSendListener extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            Bundle event = new Bundle();
+            event.putString("Type", "SmsDeliverStatus");
+            String action = intent.getAction();
+            int resultCode = getResultCode();
+            if (SMS_MESSAGE_STATUS_DELIVERED_ACTION.equals(action)) {
+                if (resultCode == Activity.RESULT_OK) {
+                    if (mNumExpectedDeliveredEvents == 1) {
+                        Log.d("SMS Message delivered successfully");
+                        mEventFacade.postEvent(TelephonyConstants.EventSmsDeliverSuccess, event);
+                    }
+                    if (mNumExpectedDeliveredEvents > 0) {
+                        mNumExpectedDeliveredEvents--;
+                    }
+                } else {
+                    Log.e("SMS Message delivery failed");
+                    // TODO . Need to find the reason for failure from pdu
+                    mEventFacade.postEvent(TelephonyConstants.EventSmsDeliverFailure, event);
+                }
+            } else if (SMS_MESSAGE_SENT_ACTION.equals(action)) {
+                if (resultCode == Activity.RESULT_OK) {
+                    if (mNumExpectedSentEvents == 1) {
+                        event.putString("Type", "SmsSentSuccess");
+                        Log.d("SMS Message sent successfully");
+                        mEventFacade.postEvent(TelephonyConstants.EventSmsSentSuccess, event);
+                    }
+                    if (mNumExpectedSentEvents > 0) {
+                        mNumExpectedSentEvents--;
+                    }
+                } else {
+                    Log.e("SMS Message send failed");
+                    event.putString("Type", "SmsSentFailure");
+                    switch (resultCode) {
+                        case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
+                            event.putString("Reason", "GenericFailure");
+                            break;
+                        case SmsManager.RESULT_ERROR_RADIO_OFF:
+                            event.putString("Reason", "RadioOff");
+                            break;
+                        case SmsManager.RESULT_ERROR_NULL_PDU:
+                            event.putString("Reason", "NullPdu");
+                            break;
+                        case SmsManager.RESULT_ERROR_NO_SERVICE:
+                            event.putString("Reason", "NoService");
+                            break;
+                        case SmsManager.RESULT_ERROR_LIMIT_EXCEEDED:
+                            event.putString("Reason", "LimitExceeded");
+                            break;
+                        case SmsManager.RESULT_ERROR_FDN_CHECK_FAILURE:
+                            event.putString("Reason", "FdnCheckFailure");
+                            break;
+                        default:
+                            event.putString("Reason", "Unknown");
+                            break;
+                    }
+                    mEventFacade.postEvent(TelephonyConstants.EventSmsSentFailure, event);
+                }
+            }
+        }
+    }
+
+    private class SmsIncomingListener extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (Intents.SMS_RECEIVED_ACTION.equals(action)) {
+                Log.d("New SMS Received");
+                Bundle extras = intent.getExtras();
+                int subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
+                if (extras != null) {
+                    Bundle event = new Bundle();
+                    event.putString("Type", "NewSmsReceived");
+                    SmsMessage[] msgs = Intents.getMessagesFromIntent(intent);
+                    StringBuilder smsMsg = new StringBuilder();
+
+                    SmsMessage sms = msgs[0];
+                    String sender = sms.getOriginatingAddress();
+                    event.putString("Sender", formatPhoneNumber(sender));
+
+                    for (int i = 0; i < msgs.length; i++) {
+                        sms = msgs[i];
+                        smsMsg.append(sms.getMessageBody());
+                    }
+                    event.putString("Text", smsMsg.toString());
+                    // TODO
+                    // Need to explore how to get subId information.
+                    event.putInt("subscriptionId", subId);
+                    mEventFacade.postEvent(TelephonyConstants.EventSmsReceived, event);
+                }
+            }
+        }
+    }
+
+    private class MmsSendListener extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            Bundle event = new Bundle();
+            String action = intent.getAction();
+            int resultCode = getResultCode();
+            event.putString("ResultCode", Integer.toString(resultCode));
+            if (MMS_MESSAGE_SENT_ACTION.equals(action)) {
+                if (resultCode == Activity.RESULT_OK) {
+                    Log.d("MMS Message sent successfully");
+                    mEventFacade.postEvent(TelephonyConstants.EventMmsSentSuccess, event);
+                } else {
+                    Log.e(String.format("MMS Message send failed: %d", resultCode));
+                    mEventFacade.postEvent(TelephonyConstants.EventMmsSentFailure, event);
+                }
+            } else {
+                Log.e("MMS Send Listener Received Invalid Event" + intent.toString());
+            }
+        }
+    }
+
+    // b/21569494 - Never receiving ANY of these events: requires debugging
+    private class MmsIncomingListener extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            Log.d("MmsIncomingListener Received an Intent " + intent.toString());
+            String action = intent.getAction();
+            if (Intents.MMS_DOWNLOADED_ACTION.equals(action)) {
+                Log.d("New MMS Downloaded");
+                mEventFacade.postEvent(TelephonyConstants.EventMmsDownloaded, new Bundle());
+            }
+            else if (Intents.WAP_PUSH_RECEIVED_ACTION.equals(action)) {
+                Log.d("New Wap Push Received");
+                mEventFacade.postEvent(TelephonyConstants.EventWapPushReceived, new Bundle());
+            }
+            else if (Intents.DATA_SMS_RECEIVED_ACTION.equals(action)) {
+                Log.d("New Data SMS Received");
+                mEventFacade.postEvent(TelephonyConstants.EventDataSmsReceived, new Bundle());
+            }
+            else {
+                Log.e("MmsIncomingListener Received Unexpected Event" + intent.toString());
+            }
+        }
+    }
+
+    String formatPhoneNumber(String phoneNumber) {
+        String senderNumberStr = null;
+        int len = phoneNumber.length();
+        if (len > 0) {
+            /**
+             * Currently this incomingNumber modification is specific for US numbers.
+             */
+            if ((INTERNATIONAL_NUMBER_LENGTH == len) && ('+' == phoneNumber.charAt(0))) {
+                senderNumberStr = phoneNumber.substring(1);
+            } else if (DOMESTIC_NUMBER_LENGTH == len) {
+                senderNumberStr = '1' + phoneNumber;
+            } else {
+                senderNumberStr = phoneNumber;
+            }
+        }
+        return senderNumberStr;
+    }
+
+    private class SmsEmergencyCBMessageListener extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (EMERGENCY_CB_MESSAGE_RECEIVED_ACTION.equals(intent.getAction())) {
+                Bundle extras = intent.getExtras();
+                if (extras != null) {
+                    Bundle event = new Bundle();
+                    String eventName = null;
+                    SmsCbMessage message = (SmsCbMessage) extras.get("message");
+                    if (message != null) {
+                        if (message.isEmergencyMessage()) {
+                            event.putString("geographicalScope", getGeographicalScope(
+                                    message.getGeographicalScope()));
+                            event.putInt("serialNumber", message.getSerialNumber());
+                            event.putString("location", message.getLocation().toString());
+                            event.putInt("serviceCategory", message.getServiceCategory());
+                            event.putString("language", message.getLanguageCode());
+                            event.putString("message", message.getMessageBody());
+                            event.putString("priority", getPriority(message.getMessagePriority()));
+                            if (message.isCmasMessage()) {
+                                // CMAS message
+                                eventName = TelephonyConstants.EventCmasReceived;
+                                event.putString("cmasMessageClass", getCMASMessageClass(
+                                        message.getCmasWarningInfo().getMessageClass()));
+                                event.putString("cmasCategory", getCMASCategory(
+                                        message.getCmasWarningInfo().getCategory()));
+                                event.putString("cmasResponseType", getCMASResponseType(
+                                        message.getCmasWarningInfo().getResponseType()));
+                                event.putString("cmasSeverity", getCMASSeverity(
+                                        message.getCmasWarningInfo().getSeverity()));
+                                event.putString("cmasUrgency", getCMASUrgency(
+                                        message.getCmasWarningInfo().getUrgency()));
+                                event.putString("cmasCertainty", getCMASCertainty(
+                                        message.getCmasWarningInfo().getCertainty()));
+                            } else if (message.isEtwsMessage()) {
+                                // ETWS message
+                                eventName = TelephonyConstants.EventEtwsReceived;
+                                event.putString("etwsWarningType", getETWSWarningType(
+                                        message.getEtwsWarningInfo().getWarningType()));
+                                event.putBoolean("etwsIsEmergencyUserAlert",
+                                        message.getEtwsWarningInfo().isEmergencyUserAlert());
+                                event.putBoolean("etwsActivatePopup",
+                                        message.getEtwsWarningInfo().isPopupAlert());
+                            } else {
+                                Log.d("Received message is not CMAS or ETWS");
+                            }
+                            if (eventName != null)
+                                mEventFacade.postEvent(eventName, event);
+                        }
+                    }
+                } else {
+                    Log.d("Received  Emergency CB without extras");
+                }
+            }
+        }
+    }
+
+    private static String getETWSWarningType(int type) {
+        switch (type) {
+            case SmsCbEtwsInfo.ETWS_WARNING_TYPE_EARTHQUAKE:
+                return "EARTHQUAKE";
+            case SmsCbEtwsInfo.ETWS_WARNING_TYPE_TSUNAMI:
+                return "TSUNAMI";
+            case SmsCbEtwsInfo.ETWS_WARNING_TYPE_EARTHQUAKE_AND_TSUNAMI:
+                return "EARTHQUAKE_AND_TSUNAMI";
+            case SmsCbEtwsInfo.ETWS_WARNING_TYPE_TEST_MESSAGE:
+                return "TEST_MESSAGE";
+            case SmsCbEtwsInfo.ETWS_WARNING_TYPE_OTHER_EMERGENCY:
+                return "OTHER_EMERGENCY";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getCMASMessageClass(int messageclass) {
+        switch (messageclass) {
+            case SmsCbCmasInfo.CMAS_CLASS_PRESIDENTIAL_LEVEL_ALERT:
+                return "PRESIDENTIAL_LEVEL_ALERT";
+            case SmsCbCmasInfo.CMAS_CLASS_EXTREME_THREAT:
+                return "EXTREME_THREAT";
+            case SmsCbCmasInfo.CMAS_CLASS_SEVERE_THREAT:
+                return "SEVERE_THREAT";
+            case SmsCbCmasInfo.CMAS_CLASS_CHILD_ABDUCTION_EMERGENCY:
+                return "CHILD_ABDUCTION_EMERGENCY";
+            case SmsCbCmasInfo.CMAS_CLASS_REQUIRED_MONTHLY_TEST:
+                return "REQUIRED_MONTHLY_TEST";
+            case SmsCbCmasInfo.CMAS_CLASS_CMAS_EXERCISE:
+                return "CMAS_EXERCISE";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getCMASCategory(int category) {
+        switch (category) {
+            case SmsCbCmasInfo.CMAS_CATEGORY_GEO:
+                return "GEOPHYSICAL";
+            case SmsCbCmasInfo.CMAS_CATEGORY_MET:
+                return "METEOROLOGICAL";
+            case SmsCbCmasInfo.CMAS_CATEGORY_SAFETY:
+                return "SAFETY";
+            case SmsCbCmasInfo.CMAS_CATEGORY_SECURITY:
+                return "SECURITY";
+            case SmsCbCmasInfo.CMAS_CATEGORY_RESCUE:
+                return "RESCUE";
+            case SmsCbCmasInfo.CMAS_CATEGORY_FIRE:
+                return "FIRE";
+            case SmsCbCmasInfo.CMAS_CATEGORY_HEALTH:
+                return "HEALTH";
+            case SmsCbCmasInfo.CMAS_CATEGORY_ENV:
+                return "ENVIRONMENTAL";
+            case SmsCbCmasInfo.CMAS_CATEGORY_TRANSPORT:
+                return "TRANSPORTATION";
+            case SmsCbCmasInfo.CMAS_CATEGORY_INFRA:
+                return "INFRASTRUCTURE";
+            case SmsCbCmasInfo.CMAS_CATEGORY_CBRNE:
+                return "CHEMICAL";
+            case SmsCbCmasInfo.CMAS_CATEGORY_OTHER:
+                return "OTHER";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getCMASResponseType(int type) {
+        switch (type) {
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_SHELTER:
+                return "SHELTER";
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_EVACUATE:
+                return "EVACUATE";
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_PREPARE:
+                return "PREPARE";
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_EXECUTE:
+                return "EXECUTE";
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_MONITOR:
+                return "MONITOR";
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_AVOID:
+                return "AVOID";
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_ASSESS:
+                return "ASSESS";
+            case SmsCbCmasInfo.CMAS_RESPONSE_TYPE_NONE:
+                return "NONE";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getCMASSeverity(int severity) {
+        switch (severity) {
+            case SmsCbCmasInfo.CMAS_SEVERITY_EXTREME:
+                return "EXTREME";
+            case SmsCbCmasInfo.CMAS_SEVERITY_SEVERE:
+                return "SEVERE";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getCMASUrgency(int urgency) {
+        switch (urgency) {
+            case SmsCbCmasInfo.CMAS_URGENCY_IMMEDIATE:
+                return "IMMEDIATE";
+            case SmsCbCmasInfo.CMAS_URGENCY_EXPECTED:
+                return "EXPECTED";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getCMASCertainty(int certainty) {
+        switch (certainty) {
+            case SmsCbCmasInfo.CMAS_CERTAINTY_OBSERVED:
+                return "IMMEDIATE";
+            case SmsCbCmasInfo.CMAS_CERTAINTY_LIKELY:
+                return "LIKELY";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getGeographicalScope(int scope) {
+        switch (scope) {
+            case SmsCbMessage.GEOGRAPHICAL_SCOPE_CELL_WIDE_IMMEDIATE:
+                return "CELL_WIDE_IMMEDIATE";
+            case SmsCbMessage.GEOGRAPHICAL_SCOPE_PLMN_WIDE:
+                return "PLMN_WIDE ";
+            case SmsCbMessage.GEOGRAPHICAL_SCOPE_LA_WIDE:
+                return "LA_WIDE";
+            case SmsCbMessage.GEOGRAPHICAL_SCOPE_CELL_WIDE:
+                return "CELL_WIDE";
+        }
+        return "UNKNOWN";
+    }
+
+    private static String getPriority(int priority) {
+        switch (priority) {
+            case SmsCbMessage.MESSAGE_PRIORITY_NORMAL:
+                return "NORMAL";
+            case SmsCbMessage.MESSAGE_PRIORITY_INTERACTIVE:
+                return "INTERACTIVE";
+            case SmsCbMessage.MESSAGE_PRIORITY_URGENT:
+                return "URGENT";
+            case SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY:
+                return "EMERGENCY";
+        }
+        return "UNKNOWN";
+    }
+
+    @Override
+    public void shutdown() {
+
+        smsStopTrackingIncomingSmsMessage();
+        smsStopTrackingIncomingMmsMessage();
+        smsStopTrackingGsmEmergencyCBMessage();
+        smsStopTrackingCdmaEmergencyCBMessage();
+
+        synchronized (lock) {
+            if (mSentReceiversRegistered) {
+                mService.unregisterReceiver(mSmsSendListener);
+                mService.unregisterReceiver(mMmsSendListener);
+                mSentReceiversRegistered = false;
+            }
+        }
+    }
+
+    private class MmsBuilder {
+
+        public static final String MESSAGE_CLASS_PERSONAL =
+                PduHeaders.MESSAGE_CLASS_PERSONAL_STR;
+
+        public static final String MESSAGE_CLASS_ADVERTISEMENT =
+                PduHeaders.MESSAGE_CLASS_ADVERTISEMENT_STR;
+
+        public static final String MESSAGE_CLASS_INFORMATIONAL =
+                PduHeaders.MESSAGE_CLASS_INFORMATIONAL_STR;
+
+        public static final String MESSAGE_CLASS_AUTO =
+                PduHeaders.MESSAGE_CLASS_AUTO_STR;
+
+        public static final int MESSAGE_PRIORITY_LOW = PduHeaders.PRIORITY_LOW;
+        public static final int MESSAGE_PRIORITY_NORMAL = PduHeaders.PRIORITY_LOW;
+        public static final int MESSAGE_PRIORITY_HIGH = PduHeaders.PRIORITY_LOW;
+
+        private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 60 * 60;
+        private static final int DEFAULT_PRIORITY = PduHeaders.PRIORITY_NORMAL;
+
+        private SendReq mRequest;
+        private PduBody mBody;
+
+        // FIXME: Eventually this should be exposed as a parameter
+        private static final String TEMP_CONTENT_FILE_NAME = "text0.txt";
+
+        // Synchronized Multimedia Internet Language
+        // Fragment for compatibility
+        private static final String sSmilText =
+                "<smil>" +
+                        "<head>" +
+                        "<layout>" +
+                        "<root-layout/>" +
+                        "<region height=\"100%%\" id=\"Text\" left=\"0%%\"" +
+                        " top=\"0%%\" width=\"100%%\"/>" +
+                        "</layout>" +
+                        "</head>" +
+                        "<body>" +
+                        "<par dur=\"8000ms\">" +
+                        "<text src=\"%s\" region=\"Text\"/>" +
+                        "</par>" +
+                        "</body>" +
+                        "</smil>";
+
+        public MmsBuilder() {
+            mRequest = new SendReq();
+            mBody = new PduBody();
+        }
+
+        public void setFromPhoneNumber(String number) {
+            mRequest.setFrom(new EncodedStringValue(number));
+        }
+
+        public void setToPhoneNumber(String number) {
+            mRequest.setTo(new EncodedStringValue[] {
+                    new EncodedStringValue(number) });
+        }
+
+        public void setToPhoneNumbers(List<String> number) {
+            mRequest.setTo(EncodedStringValue.encodeStrings((String[]) number.toArray()));
+        }
+
+        public void setSubject(String subject) {
+            mRequest.setSubject(new EncodedStringValue(subject));
+        }
+
+        public void setDate() {
+            setDate(System.currentTimeMillis() / 1000);
+        }
+
+        public void setDate(long time) {
+            mRequest.setDate(time);
+        }
+
+        public void addMessageBody(String message) {
+            addMessageBody(message, true);
+        }
+
+        public void setMessageClass(String messageClass) {
+            mRequest.setMessageClass(messageClass.getBytes());
+        }
+
+        public void setMessagePriority(int priority) {
+            try {
+                mRequest.setPriority(priority);
+            } catch (InvalidHeaderValueException e) {
+                Log.e("Invalid Header Value "+e.toString());
+            }
+        }
+
+        public void setDeliveryReport(boolean report) {
+            try {
+                mRequest.setDeliveryReport((report) ? PduHeaders.VALUE_YES : PduHeaders.VALUE_NO);
+            } catch (InvalidHeaderValueException e) {
+                Log.e("Invalid Header Value "+e.toString());
+            }
+        }
+
+        public void setReadReport(boolean report) {
+            try {
+                mRequest.setReadReport((report) ? PduHeaders.VALUE_YES : PduHeaders.VALUE_NO);
+            } catch (InvalidHeaderValueException e) {
+                Log.e("Invalid Header Value "+e.toString());
+            }
+        }
+
+        public void setExpirySeconds(int seconds) {
+            mRequest.setExpiry(seconds);
+        }
+
+        public byte[] build() {
+            mRequest.setBody(mBody);
+
+            int msgSize = 0;
+            for (int i = 0; i < mBody.getPartsNum(); i++) {
+                msgSize += mBody.getPart(i).getDataLength();
+            }
+            mRequest.setMessageSize(msgSize);
+
+            return new PduComposer(mContext, mRequest).make();
+        }
+
+        public void addMessageBody(String message, boolean addSmilFragment) {
+            final PduPart part = new PduPart();
+            part.setCharset(CharacterSets.UTF_8);
+            part.setContentType(ContentType.TEXT_PLAIN.getBytes());
+            part.setContentLocation("text0".getBytes());
+            int index = TEMP_CONTENT_FILE_NAME.lastIndexOf(".");
+            String contentId = (index == -1) ? TEMP_CONTENT_FILE_NAME
+                    : TEMP_CONTENT_FILE_NAME.substring(0, index);
+            part.setContentId(contentId.getBytes());
+            part.setContentId("txt".getBytes());
+            part.setData(message.getBytes());
+            mBody.addPart(part);
+            if (addSmilFragment) {
+                addSmilTextFragment(TEMP_CONTENT_FILE_NAME);
+            }
+        }
+
+        private void addSmilTextFragment(String contentFilename) {
+
+            final String smil = String.format(sSmilText, contentFilename);
+            final PduPart smilPart = new PduPart();
+            smilPart.setContentId("smil".getBytes());
+            smilPart.setContentLocation("smil.xml".getBytes());
+            smilPart.setContentType(ContentType.APP_SMIL.getBytes());
+            smilPart.setData(smil.getBytes());
+            mBody.addPart(0, smilPart);
+        }
+    }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/SubscriptionManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/telephony/SubscriptionManagerFacade.java
new file mode 100644
index 0000000..0031bc1
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/SubscriptionManagerFacade.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import android.app.Service;
+import android.content.Context;
+import android.telephony.SubscriptionManager;
+import android.telephony.SubscriptionInfo;
+
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.util.List;
+
+/**
+ * Exposes SubscriptionManager functionality.
+ */
+public class SubscriptionManagerFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final Context mContext;
+    private final SubscriptionManager mSubscriptionManager;
+
+    public SubscriptionManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mContext = mService.getBaseContext();
+        mSubscriptionManager = SubscriptionManager.from(mContext);
+    }
+
+    @Rpc(description = "Return the default subscription ID")
+    public Integer subscriptionGetDefaultSubId() {
+        return SubscriptionManager.getDefaultSubscriptionId();
+    }
+
+    @Rpc(description = "Return the default data subscription ID")
+    public Integer subscriptionGetDefaultDataSubId() {
+        return SubscriptionManager.getDefaultDataSubscriptionId();
+    }
+
+    @Rpc(description = "Set the default data subscription ID")
+    public void subscriptionSetDefaultDataSubId(
+            @RpcParameter(name = "subId")
+            Integer subId) {
+        mSubscriptionManager.setDefaultDataSubId(subId);
+    }
+
+    @Rpc(description = "Return the default voice subscription ID")
+    public Integer subscriptionGetDefaultVoiceSubId() {
+        return SubscriptionManager.getDefaultVoiceSubscriptionId();
+    }
+
+    @Rpc(description = "Set the default voice subscription ID")
+    public void subscriptionSetDefaultVoiceSubId(
+            @RpcParameter(name = "subId")
+            Integer subId) {
+        mSubscriptionManager.setDefaultVoiceSubId(subId);
+    }
+
+    @Rpc(description = "Return the default sms subscription ID")
+    public Integer subscriptionGetDefaultSmsSubId() {
+        return SubscriptionManager.getDefaultSmsSubscriptionId();
+    }
+
+    @Rpc(description = "Set the default sms subscription ID")
+    public void subscriptionSetDefaultSmsSubId(
+            @RpcParameter(name = "subId")
+            Integer subId) {
+        mSubscriptionManager.setDefaultSmsSubId(subId);
+    }
+
+    @Rpc(description = "Return a List of all Subscription Info Records")
+    public List<SubscriptionInfo> subscriptionGetAllSubInfoList() {
+        return mSubscriptionManager.getAllSubscriptionInfoList();
+    }
+
+    @Rpc(description = "Return a List of all Active Subscription Info Records")
+    public List<SubscriptionInfo> subscriptionGetActiveSubInfoList() {
+        return mSubscriptionManager.getActiveSubscriptionInfoList();
+    }
+
+    @Rpc(description = "Return the Subscription Info for a Particular Subscription ID")
+    public SubscriptionInfo subscriptionGetSubInfoForSubscriber(
+            @RpcParameter(name = "subId")
+            Integer subId) {
+        return mSubscriptionManager.getActiveSubscriptionInfo(subId);
+    }
+
+    @Rpc(description = "Set Data Roaming Enabled or Disabled for a particular Subscription ID")
+    public Integer subscriptionSetDataRoaming(Integer roaming, Integer subId) {
+        if (roaming != SubscriptionManager.DATA_ROAMING_DISABLE) {
+            return mSubscriptionManager.setDataRoaming(
+                    SubscriptionManager.DATA_ROAMING_ENABLE, subId);
+        } else {
+            return mSubscriptionManager.setDataRoaming(
+                    SubscriptionManager.DATA_ROAMING_DISABLE, subId);
+        }
+    }
+
+    @Override
+    public void shutdown() {
+
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/TelecomCallFacade.java b/Common/src/com/googlecode/android_scripting/facade/telephony/TelecomCallFacade.java
new file mode 100644
index 0000000..070e649
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/TelecomCallFacade.java
@@ -0,0 +1,293 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import android.app.Service;
+import android.telecom.Call;
+import android.telecom.CallAudioState;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.VideoProfile;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Exposes TelecomManager functionality.
+ */
+public class TelecomCallFacade extends RpcReceiver {
+
+    private final Service mService;
+
+    private List<PhoneAccountHandle> mEnabledAccountHandles = null;
+
+    public TelecomCallFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+
+        InCallServiceImpl.setEventFacade(
+                manager.getReceiver(EventFacade.class));
+    }
+
+    @Override
+    public void shutdown() {
+        InCallServiceImpl.setEventFacade(null);
+    }
+
+    /**
+     * Returns an identifier of the call. When a phone number is available, the number will be
+     * returned. Otherwise, the standard object toString result of the Call object. e.g. A
+     * conference call does not have a single number associated with it, thus the toString Id will
+     * be returned.
+     *
+     * @param call
+     * @return String
+     */
+
+    @Rpc(description = "Disconnect call by callId.")
+    public void telecomCallDisconnect(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        InCallServiceImpl.callDisconnect(callId);
+    }
+
+    @Rpc(description = "Hold call by callId")
+    public void telecomCallHold(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        InCallServiceImpl.holdCall(callId);
+    }
+
+    @Rpc(description = "Merge call to conference by callId")
+    public void telecomCallMergeToConf(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        InCallServiceImpl.mergeCallsInConference(callId);
+    }
+
+    @Rpc(description = "Split call from conference by callId.")
+    public void telecomCallSplitFromConf(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        InCallServiceImpl.splitCallFromConf(callId);
+    }
+
+    @Rpc(description = "Unhold call by callId")
+    public void telecomCallUnhold(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        InCallServiceImpl.unholdCall(callId);
+    }
+
+    @Rpc(description = "Joins two calls into a conference call. "
+            + "Calls are identified by their "
+            + "IDs listed by telecomPhoneGetCallIds")
+    public void telecomCallJoinCallsInConf(
+                        @RpcParameter(name = "callIdOne")
+            String callIdOne,
+                        @RpcParameter(name = "callIdTwo")
+            String callIdTwo) {
+        InCallServiceImpl.joinCallsInConf(callIdOne, callIdTwo);
+    }
+
+    @Rpc(description = "Obtains the current call audio state of the phone.")
+    public CallAudioState telecomCallGetAudioState() {
+        return InCallServiceImpl.serviceGetCallAudioState();
+    }
+
+    @Rpc(description = "Lists the IDs (phone numbers or hex hashes) "
+            + "of the current calls.")
+    public Set<String> telecomCallGetCallIds() {
+        return InCallServiceImpl.getCallIdList();
+    }
+    @Rpc(description = "Get callId's children")
+    public List<String> telecomCallGetCallChildren(
+                        @RpcParameter(name = "callId") String callId) {
+        return InCallServiceImpl.getCallChildren(callId);
+    }
+    @Rpc(description = "Get callId's parent")
+    public String telecomCallGetCallParent(
+                        @RpcParameter(name = "callId") String callId) {
+        return InCallServiceImpl.getCallParent(callId);
+    }
+    @Rpc(description = "Swaps the calls within this conference")
+    public void telecomCallSwapCallsInConference(
+                        @RpcParameter(name = "callId") String callId) {
+        InCallServiceImpl.swapCallsInConference(callId);
+    }
+    @Rpc(description = "Play a dual-tone multi-frequency signaling (DTMF) tone")
+    public void telecomCallPlayDtmfTone(
+                        @RpcParameter(name = "callId") String callId,
+                        @RpcParameter(name = "digit") String digitString) {
+        for(int i = 0; i < digitString.length(); i++) {
+            char c = digitString.charAt(i);
+            InCallServiceImpl.callPlayDtmfTone(callId, c);
+        }
+    }
+    @Rpc(description = "Stop any dual-tone multi-frequency signaling (DTMF) tone")
+    public void telecomCallStopDtmfTone(
+                        @RpcParameter(name = "callId") String callId) {
+        InCallServiceImpl.callStopDtmfTone(callId);
+    }
+    @Rpc(description = "Obtains a list of text message, user to reject call.")
+    public List<String> telecomCallGetCannedTextResponses(
+                        @RpcParameter(name = "callId") String callId) {
+        return InCallServiceImpl.callGetCannedTextResponses(callId);
+    }
+    @Rpc(description = "Reset the Call List.")
+    public void telecomCallClearCallList() {
+        InCallServiceImpl.clearCallList();
+    }
+
+    @Rpc(description = "Get the state of a call according to call id.")
+    public String telecomCallGetCallState(
+                        @RpcParameter(name = "callId")
+            String callId) {
+
+        return InCallServiceImpl.callGetState(callId);
+    }
+
+    @Rpc(description = "Sets the audio route (SPEAKER, BLUETOOTH, etc...).")
+    public void telecomCallSetAudioRoute(
+                        @RpcParameter(name = "route")
+            String route) {
+
+        InCallServiceImpl.serviceSetAudioRoute(route);
+    }
+
+    @Rpc(description = "Turns the proximity sensor off. "
+            + "If screenOnImmediately is true, "
+            + "the screen will be turned on immediately")
+    public void telecomCallOverrideProximitySensor(
+                        @RpcParameter(name = "screenOn")
+            Boolean screenOn) {
+        InCallServiceImpl.overrideProximitySensor(screenOn);
+    }
+
+    @Rpc(description = "Answer a call of a specified id, with video state")
+    public void telecomCallAnswer(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "videoState")
+            String videoState) {
+        InCallServiceImpl.callAnswer(callId, videoState);
+    }
+
+    @Rpc(description = "Answer a call of a specified id, with video state")
+    public void telecomCallReject(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "message")
+            String message) {
+        InCallServiceImpl.callReject(callId, message);
+    }
+
+    @Rpc(description = "Start Listening for a VideoCall Event")
+    public void telecomCallStartListeningForEvent(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "event")
+            String event) {
+        InCallServiceImpl.callStartListeningForEvent(callId, event);
+    }
+
+    @Rpc(description = "Stop Listening for a Call Event")
+    public void telecomCallStopListeningForEvent(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "event")
+            String event) {
+        InCallServiceImpl.callStopListeningForEvent(callId, event);
+    }
+
+    @Rpc(description = "Get the detailed information about a call")
+    public Call.Details telecomCallGetDetails(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        return InCallServiceImpl.callGetDetails(callId);
+    }
+
+    @Rpc(description = "Return the capabilities for a call")
+    public  List<String> telecomCallGetCapabilities(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        return InCallServiceImpl.callGetCallCapabilities(callId);
+    }
+
+    @Rpc(description = "Return the properties for a call")
+    public  List<String> telecomCallGetProperties(
+                        @RpcParameter(name = "callId")
+            String callId) {
+        return InCallServiceImpl.callGetCallProperties(callId);
+    }
+
+    @Rpc(description = "Start Listening for a VideoCall Event")
+    public void telecomCallVideoStartListeningForEvent(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "event")
+            String event) {
+        InCallServiceImpl.videoCallStartListeningForEvent(callId, event);
+    }
+
+    @Rpc(description = "Stop Listening for a VideoCall Event")
+    public void telecomCallVideoStopListeningForEvent(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "event")
+            String event) {
+        InCallServiceImpl.videoCallStopListeningForEvent(callId, event);
+    }
+
+    @Rpc(description = "Get the Video Call State")
+    public String telecomCallVideoGetState(
+                        @RpcParameter(name = "call")
+            String callId) {
+        return InCallServiceImpl.videoCallGetState(callId);
+    }
+
+    @Rpc(description = "Send a request to modify the video call session parameters")
+    public void telecomCallVideoSendSessionModifyRequest(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "videoState")
+            String videoState,
+                        @RpcParameter(name = "videoQuality")
+            String videoQuality) {
+        InCallServiceImpl.videoCallSendSessionModifyRequest(callId, videoState, videoQuality);
+    }
+
+    @Rpc(description = "Send a response to a modify the video call session request")
+    public void telecomCallVideoSendSessionModifyResponse(
+                        @RpcParameter(name = "call")
+            String callId,
+                        @RpcParameter(name = "videoState")
+            String videoState,
+                        @RpcParameter(name = "videoQuality")
+            String videoQuality) {
+        InCallServiceImpl.videoCallSendSessionModifyResponse(callId, videoState, videoQuality);
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/TelecomManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/telephony/TelecomManagerFacade.java
new file mode 100644
index 0000000..caa60ab
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/TelecomManagerFacade.java
@@ -0,0 +1,382 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Field;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import android.app.Service;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.database.Cursor;
+import android.telecom.AudioState;
+import android.telecom.Call;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.net.Uri;
+import android.provider.ContactsContract;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.AndroidFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Exposes TelecomManager functionality.
+ */
+public class TelecomManagerFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final AndroidFacade mAndroidFacade;
+
+    private final TelecomManager mTelecomManager;
+    private final TelephonyManager mTelephonyManager;
+
+    private List<PhoneAccountHandle> mEnabledAccountHandles = null;
+
+    public TelecomManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mTelecomManager = new TelecomManager(mService);
+        mTelephonyManager = new TelephonyManager(mService);
+        mAndroidFacade = manager.getReceiver(AndroidFacade.class);
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Rpc(description = "If there's a ringing call, accept on behalf of the user.")
+    public void telecomAcceptRingingCall(
+            @RpcOptional
+            String videoState) {
+
+        if (videoState == null) {
+            mTelecomManager.acceptRingingCall();
+        }
+        else {
+            int state = InCallServiceImpl.getVideoCallState(videoState);
+
+            if (state == InCallServiceImpl.STATE_INVALID) {
+                Log.e("telecomAcceptRingingCall: video state is invalid!");
+                return;
+            }
+
+            mTelecomManager.acceptRingingCall(state);
+        }
+    }
+
+    @Rpc(description = "Removes the missed-call notification if one is present.")
+    public void telecomCancelMissedCallsNotification() {
+        mTelecomManager.cancelMissedCallsNotification();
+    }
+
+    @Rpc(description = "Remove all Accounts that belong to the calling package from the system.")
+    public void telecomClearAccounts() {
+        mTelecomManager.clearAccounts();
+    }
+
+    @Rpc(description = "End an ongoing call.")
+    public Boolean telecomEndCall() {
+        return mTelecomManager.endCall();
+    }
+
+    @Rpc(description = "Get a list of all PhoneAccounts.")
+    public List<PhoneAccount> telecomGetAllPhoneAccounts() {
+        return mTelecomManager.getAllPhoneAccounts();
+    }
+
+    @Rpc(description = "Get the current call state.")
+    public String telecomGetCallState() {
+        int state = mTelecomManager.getCallState();
+        return TelephonyUtils.getTelephonyCallStateString(state);
+    }
+
+    @Rpc(description = "Get the current tty mode.")
+    public String telecomGetCurrentTtyMode() {
+        int mode = mTelecomManager.getCurrentTtyMode();
+        return TelephonyUtils.getTtyModeString(mode);
+    }
+
+    @Rpc(description = "Bring incallUI to foreground.")
+    public void telecomShowInCallScreen(
+            @RpcParameter(name = "showDialpad")
+            @RpcOptional
+            @RpcDefault("false")
+            Boolean showDialpad) {
+        mTelecomManager.showInCallScreen(showDialpad);
+    }
+
+    @Rpc(description = "Get the list of PhoneAccountHandles with calling capability.")
+    public List<PhoneAccountHandle> telecomGetEnabledPhoneAccounts() {
+        mEnabledAccountHandles = mTelecomManager.getCallCapablePhoneAccounts();
+        return mEnabledAccountHandles;
+    }
+
+    @Rpc(description = "Set the user-chosen default PhoneAccount for making outgoing phone calls.")
+    public void telecomSetUserSelectedOutgoingPhoneAccount(
+                        @RpcParameter(name = "phoneAccountHandleId")
+            String phoneAccountHandleId) throws Exception {
+
+        List<PhoneAccountHandle> accountHandles = mTelecomManager
+                .getAllPhoneAccountHandles();
+        for (PhoneAccountHandle handle : accountHandles) {
+            if (handle.getId().equals(phoneAccountHandleId)) {
+                mTelecomManager.setUserSelectedOutgoingPhoneAccount(handle);
+                Log.d(String.format("Set default Outgoing Phone Account(%s)",
+                        phoneAccountHandleId));
+                return;
+            }
+        }
+        Log.d(String.format(
+                "Failed to find a matching phoneAccountHandleId(%s).",
+                phoneAccountHandleId));
+        throw new Exception(String.format(
+                "Failed to find a matching phoneAccountHandleId(%s).",
+                phoneAccountHandleId));
+    }
+
+    @Rpc(description = "Get the user-chosen default PhoneAccount for making outgoing phone calls.")
+    public PhoneAccountHandle telecomGetUserSelectedOutgoingPhoneAccount() {
+        return mTelecomManager.getUserSelectedOutgoingPhoneAccount();
+    }
+
+    @Rpc(description = "Set the PhoneAccount corresponding to user selected subscription id " +
+                       " for making outgoing phone calls.")
+    public void telecomSetUserSelectedOutgoingPhoneAccountBySubId(
+                        @RpcParameter(name = "subId")
+                        Integer subId) throws Exception {
+          Iterator<PhoneAccountHandle> phoneAccounts =
+               mTelecomManager.getCallCapablePhoneAccounts().listIterator();
+
+          while (phoneAccounts.hasNext()) {
+              PhoneAccountHandle phoneAccountHandle = phoneAccounts.next();
+              PhoneAccount phoneAccount =
+                       mTelecomManager.getPhoneAccount(phoneAccountHandle);
+              if (subId == mTelephonyManager.getSubIdForPhoneAccount(phoneAccount)) {
+                  mTelecomManager.setUserSelectedOutgoingPhoneAccount(phoneAccountHandle);
+                  Log.d(String.format(
+                      "Set default Outgoing Phone Account for subscription(%s)", subId));
+                  return;
+              }
+          }
+          Log.d(String.format(
+                  "Failed to find a matching Phone Account for subscription (%s).",
+                  subId));
+          throw new Exception(String.format(
+                  "Failed to find a matching Phone Account for subscription (%s).",
+                   subId));
+    }
+
+    @Rpc(description = "Returns whether there is an ongoing phone call.")
+    public Boolean telecomIsInCall() {
+        return mTelecomManager.isInCall();
+    }
+
+    @Rpc(description = "Returns whether there is a ringing incoming call.")
+    public Boolean telecomIsRinging() {
+        return mTelecomManager.isRinging();
+    }
+
+    @Rpc(description = "Silences the rigner if there's a ringing call.")
+    public void telecomSilenceRinger() {
+        mTelecomManager.silenceRinger();
+    }
+
+    @Rpc(description = "Swap two calls")
+    public void telecomSwapCalls() {
+        // TODO: b/26273475 Add logic to swap the foreground and back ground calls
+    }
+
+    @Rpc(description = "Toggles call waiting feature on or off for default voice subscription id.")
+    public void toggleCallWaiting(
+            @RpcParameter(name = "enabled")
+            @RpcOptional
+            Boolean enabled) {
+        toggleCallWaitingForSubscription(
+                SubscriptionManager.getDefaultVoiceSubscriptionId(), enabled);
+    }
+
+    @Rpc(description = "Toggles call waiting feature on or off for specified subscription id.")
+    public void toggleCallWaitingForSubscription(
+            @RpcParameter(name = "subId")
+            @RpcOptional
+            Integer subId,
+            @RpcParameter(name = "enabled")
+            @RpcOptional
+            Boolean enabled) {
+        // TODO: b/26273478 Enable or Disable the call waiting feature
+    }
+
+    @Rpc(description = "Sends an MMI string to Telecom for processing")
+    public void telecomHandleMmi(
+                        @RpcParameter(name = "dialString")
+            String dialString) {
+        mTelecomManager.handleMmi(dialString);
+    }
+
+    // TODO: b/20917712 add support to pass arbitrary "Extras" object
+    // for videoCall parameter
+    @Deprecated
+    @Rpc(description = "Calls a phone by resolving a generic URI.")
+    public void telecomCall(
+                        @RpcParameter(name = "uriString")
+            final String uriString,
+            @RpcParameter(name = "videoCall")
+            @RpcOptional
+            @RpcDefault("false")
+            Boolean videoCall) throws Exception {
+
+        Log.w("Function telecomCall is deprecated; please use a URI-specific call");
+
+        Uri uri = Uri.parse(uriString);
+        if (uri.getScheme().equals("content")) {
+            telecomCallContentUri(uriString, videoCall);
+        }
+        else {
+            telecomCallNumber(uriString, videoCall);
+        }
+    }
+
+    // TODO: b/20917712 add support to pass arbitrary "Extras" object
+    // for videoCall parameter
+    @Rpc(description = "Calls a phone by resolving a Content-type URI.")
+    public void telecomCallContentUri(
+                        @RpcParameter(name = "uriString")
+            final String uriString,
+            @RpcParameter(name = "videoCall")
+            @RpcOptional
+            @RpcDefault("false")
+            Boolean videoCall)
+            throws Exception {
+        Uri uri = Uri.parse(uriString);
+        if (!uri.getScheme().equals("content")) {
+            Log.e("Invalid URI!!");
+            return;
+        }
+
+        String phoneNumberColumn = ContactsContract.PhoneLookup.NUMBER;
+        String selectWhere = null;
+        if ((FacadeManager.class.cast(mManager)).getSdkLevel() >= 5) {
+            Class<?> contactsContract_Data_class =
+                    Class.forName("android.provider.ContactsContract$Data");
+            Field RAW_CONTACT_ID_field =
+                    contactsContract_Data_class.getField("RAW_CONTACT_ID");
+            selectWhere = RAW_CONTACT_ID_field.get(null).toString() + "="
+                    + uri.getLastPathSegment();
+            Field CONTENT_URI_field =
+                    contactsContract_Data_class.getField("CONTENT_URI");
+            uri = Uri.parse(CONTENT_URI_field.get(null).toString());
+            Class<?> ContactsContract_CommonDataKinds_Phone_class =
+                    Class.forName("android.provider.ContactsContract$CommonDataKinds$Phone");
+            Field NUMBER_field =
+                    ContactsContract_CommonDataKinds_Phone_class.getField("NUMBER");
+            phoneNumberColumn = NUMBER_field.get(null).toString();
+        }
+        ContentResolver resolver = mService.getContentResolver();
+        Cursor c = resolver.query(uri, new String[] {
+                phoneNumberColumn
+        },
+                selectWhere, null, null);
+        String number = "";
+        if (c.moveToFirst()) {
+            number = c.getString(c.getColumnIndexOrThrow(phoneNumberColumn));
+        }
+        c.close();
+        telecomCallNumber(number, videoCall);
+    }
+
+    // TODO: b/20917712 add support to pass arbitrary "Extras" object
+    // for videoCall parameter
+    @Rpc(description = "Calls a phone number.")
+    public void telecomCallNumber(
+                        @RpcParameter(name = "number")
+            final String number,
+            @RpcParameter(name = "videoCall")
+            @RpcOptional
+            @RpcDefault("false")
+            Boolean videoCall)
+            throws Exception {
+        telecomCallTelUri("tel:" + URLEncoder.encode(number, "ASCII"), videoCall);
+    }
+
+    // TODO: b/20917712 add support to pass arbitrary "Extras" object
+    // for videoCall parameter
+    @Rpc(description = "Calls a phone by Tel-URI.")
+    public void telecomCallTelUri(
+            @RpcParameter(name = "uriString")
+    final String uriString,
+            @RpcParameter(name = "videoCall")
+            @RpcOptional
+            @RpcDefault("false")
+            Boolean videoCall) throws Exception {
+        if (!uriString.startsWith("tel:")) {
+            Log.w("Invalid tel URI" + uriString);
+            return;
+        }
+
+        Intent intent = new Intent(Intent.ACTION_CALL);
+        intent.setDataAndType(Uri.parse(uriString).normalizeScheme(), null);
+
+        if (videoCall) {
+            Log.d("Placing a bi-directional video call");
+            intent.putExtra(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE,
+                    VideoProfile.STATE_BIDIRECTIONAL);
+        }
+
+        mAndroidFacade.startActivityIntent(intent, false);
+    }
+
+    @Rpc(description = "Calls an Emergency number.")
+    public void telecomCallEmergencyNumber(
+                        @RpcParameter(name = "number")
+            final String number)
+            throws Exception {
+        String uriString = "tel:" + URLEncoder.encode(number, "ASCII");
+        mAndroidFacade.startActivity(Intent.ACTION_CALL_PRIVILEGED, uriString,
+                null, null, null, null, null);
+    }
+
+    @Rpc(description = "Dials a contact/phone number by URI.")
+    public void telecomDial(
+            @RpcParameter(name = "uri")
+    final String uri)
+            throws Exception {
+        mAndroidFacade.startActivity(Intent.ACTION_DIAL, uri, null, null, null,
+                null, null);
+    }
+
+    @Rpc(description = "Dials a phone number.")
+    public void telecomDialNumber(@RpcParameter(name = "phone number")
+    final String number)
+            throws Exception, UnsupportedEncodingException {
+        telecomDial("tel:" + URLEncoder.encode(number, "ASCII"));
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyConstants.java b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyConstants.java
new file mode 100644
index 0000000..4c1b466
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyConstants.java
@@ -0,0 +1,460 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+public class TelephonyConstants {
+    /**
+     * Constant for WiFi Calling WFC mode
+     * **/
+    public static final String WFC_MODE_WIFI_ONLY = "WIFI_ONLY";
+    public static final String WFC_MODE_CELLULAR_PREFERRED = "CELLULAR_PREFERRED";
+    public static final String WFC_MODE_WIFI_PREFERRED = "WIFI_PREFERRED";
+    public static final String WFC_MODE_DISABLED = "DISABLED";
+    public static final String WFC_MODE_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for Video Telephony VT state
+     * **/
+    public static final String VT_STATE_AUDIO_ONLY = "AUDIO_ONLY";
+    public static final String VT_STATE_TX_ENABLED = "TX_ENABLED";
+    public static final String VT_STATE_RX_ENABLED = "RX_ENABLED";
+    public static final String VT_STATE_BIDIRECTIONAL = "BIDIRECTIONAL";
+    public static final String VT_STATE_TX_PAUSED = "TX_PAUSED";
+    public static final String VT_STATE_RX_PAUSED = "RX_PAUSED";
+    public static final String VT_STATE_BIDIRECTIONAL_PAUSED = "BIDIRECTIONAL_PAUSED";
+    public static final String VT_STATE_STATE_INVALID = "INVALID";
+
+    /**
+     * Constant for Video Telephony Video quality
+     * **/
+    public static final String VT_VIDEO_QUALITY_DEFAULT = "DEFAULT";
+    public static final String VT_VIDEO_QUALITY_UNKNOWN = "UNKNOWN";
+    public static final String VT_VIDEO_QUALITY_HIGH = "HIGH";
+    public static final String VT_VIDEO_QUALITY_MEDIUM = "MEDIUM";
+    public static final String VT_VIDEO_QUALITY_LOW = "LOW";
+    public static final String VT_VIDEO_QUALITY_INVALID = "INVALID";
+
+    /**
+     * Constant for Call State (for call object)
+     * **/
+    public static final String CALL_STATE_ACTIVE = "ACTIVE";
+    public static final String CALL_STATE_NEW = "NEW";
+    public static final String CALL_STATE_DIALING = "DIALING";
+    public static final String CALL_STATE_RINGING = "RINGING";
+    public static final String CALL_STATE_HOLDING = "HOLDING";
+    public static final String CALL_STATE_DISCONNECTED = "DISCONNECTED";
+    public static final String CALL_STATE_PRE_DIAL_WAIT = "PRE_DIAL_WAIT";
+    public static final String CALL_STATE_CONNECTING = "CONNECTING";
+    public static final String CALL_STATE_DISCONNECTING = "DISCONNECTING";
+    public static final String CALL_STATE_UNKNOWN = "UNKNOWN";
+    public static final String CALL_STATE_INVALID = "INVALID";
+
+    /**
+     * Constant for PRECISE Call State (for call object)
+     * **/
+    public static final String PRECISE_CALL_STATE_ACTIVE = "ACTIVE";
+    public static final String PRECISE_CALL_STATE_ALERTING = "ALERTING";
+    public static final String PRECISE_CALL_STATE_DIALING = "DIALING";
+    public static final String PRECISE_CALL_STATE_INCOMING = "INCOMING";
+    public static final String PRECISE_CALL_STATE_HOLDING = "HOLDING";
+    public static final String PRECISE_CALL_STATE_DISCONNECTED = "DISCONNECTED";
+    public static final String PRECISE_CALL_STATE_WAITING = "WAITING";
+    public static final String PRECISE_CALL_STATE_DISCONNECTING = "DISCONNECTING";
+    public static final String PRECISE_CALL_STATE_IDLE = "IDLE";
+    public static final String PRECISE_CALL_STATE_UNKNOWN = "UNKNOWN";
+    public static final String PRECISE_CALL_STATE_INVALID = "INVALID";
+
+    /**
+     * Constant for DC POWER STATE
+     * **/
+    public static final String DC_POWER_STATE_LOW = "LOW";
+    public static final String DC_POWER_STATE_HIGH = "HIGH";
+    public static final String DC_POWER_STATE_MEDIUM = "MEDIUM";
+    public static final String DC_POWER_STATE_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for Audio Route
+     * **/
+    public static final String AUDIO_ROUTE_EARPIECE = "EARPIECE";
+    public static final String AUDIO_ROUTE_BLUETOOTH = "BLUETOOTH";
+    public static final String AUDIO_ROUTE_SPEAKER = "SPEAKER";
+    public static final String AUDIO_ROUTE_WIRED_HEADSET = "WIRED_HEADSET";
+    public static final String AUDIO_ROUTE_WIRED_OR_EARPIECE = "WIRED_OR_EARPIECE";
+
+    /**
+     * Constant for Call Capability
+     * **/
+    public static final String CALL_CAPABILITY_HOLD = "HOLD";
+    public static final String CALL_CAPABILITY_SUPPORT_HOLD = "SUPPORT_HOLD";
+    public static final String CALL_CAPABILITY_MERGE_CONFERENCE = "MERGE_CONFERENCE";
+    public static final String CALL_CAPABILITY_SWAP_CONFERENCE = "SWAP_CONFERENCE";
+    public static final String CALL_CAPABILITY_UNUSED_1 = "UNUSED_1";
+    public static final String CALL_CAPABILITY_RESPOND_VIA_TEXT = "RESPOND_VIA_TEXT";
+    public static final String CALL_CAPABILITY_MUTE = "MUTE";
+    public static final String CALL_CAPABILITY_MANAGE_CONFERENCE = "MANAGE_CONFERENCE";
+    public static final String CALL_CAPABILITY_SUPPORTS_VT_LOCAL_RX = "SUPPORTS_VT_LOCAL_RX";
+    public static final String CALL_CAPABILITY_SUPPORTS_VT_LOCAL_TX = "SUPPORTS_VT_LOCAL_TX";
+    public static final String CALL_CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL = "SUPPORTS_VT_LOCAL_BIDIRECTIONAL";
+    public static final String CALL_CAPABILITY_SUPPORTS_VT_REMOTE_RX = "SUPPORTS_VT_REMOTE_RX";
+    public static final String CALL_CAPABILITY_SUPPORTS_VT_REMOTE_TX = "SUPPORTS_VT_REMOTE_TX";
+    public static final String CALL_CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL = "SUPPORTS_VT_REMOTE_BIDIRECTIONAL";
+    public static final String CALL_CAPABILITY_SEPARATE_FROM_CONFERENCE = "SEPARATE_FROM_CONFERENCE";
+    public static final String CALL_CAPABILITY_DISCONNECT_FROM_CONFERENCE = "DISCONNECT_FROM_CONFERENCE";
+    public static final String CALL_CAPABILITY_SPEED_UP_MT_AUDIO = "SPEED_UP_MT_AUDIO";
+    public static final String CALL_CAPABILITY_CAN_UPGRADE_TO_VIDEO = "CAN_UPGRADE_TO_VIDEO";
+    public static final String CALL_CAPABILITY_CAN_PAUSE_VIDEO = "CAN_PAUSE_VIDEO";
+    public static final String CALL_CAPABILITY_UNKOWN = "UNKOWN";
+
+    /**
+     * Constant for Call Property
+     * **/
+    public static final String CALL_PROPERTY_HIGH_DEF_AUDIO = "HIGH_DEF_AUDIO";
+    public static final String CALL_PROPERTY_CONFERENCE = "CONFERENCE";
+    public static final String CALL_PROPERTY_GENERIC_CONFERENCE = "GENERIC_CONFERENCE";
+    public static final String CALL_PROPERTY_WIFI = "WIFI";
+    public static final String CALL_PROPERTY_EMERGENCY_CALLBACK_MODE = "EMERGENCY_CALLBACK_MODE";
+    public static final String CALL_PROPERTY_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for Call Presentation
+     * **/
+    public static final String CALL_PRESENTATION_ALLOWED = "ALLOWED";
+    public static final String CALL_PRESENTATION_RESTRICTED = "RESTRICTED";
+    public static final String CALL_PRESENTATION_PAYPHONE = "PAYPHONE";
+    public static final String CALL_PRESENTATION_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for Network RAT
+     * **/
+    public static final String RAT_IWLAN = "IWLAN";
+    public static final String RAT_LTE = "LTE";
+    public static final String RAT_4G = "4G";
+    public static final String RAT_3G = "3G";
+    public static final String RAT_2G = "2G";
+    public static final String RAT_WCDMA = "WCDMA";
+    public static final String RAT_UMTS = "UMTS";
+    public static final String RAT_1XRTT = "1XRTT";
+    public static final String RAT_EDGE = "EDGE";
+    public static final String RAT_GPRS = "GPRS";
+    public static final String RAT_HSDPA = "HSDPA";
+    public static final String RAT_HSUPA = "HSUPA";
+    public static final String RAT_CDMA = "CDMA";
+    public static final String RAT_EVDO = "EVDO";
+    public static final String RAT_EVDO_0 = "EVDO_0";
+    public static final String RAT_EVDO_A = "EVDO_A";
+    public static final String RAT_EVDO_B = "EVDO_B";
+    public static final String RAT_IDEN = "IDEN";
+    public static final String RAT_EHRPD = "EHRPD";
+    public static final String RAT_HSPA = "HSPA";
+    public static final String RAT_HSPAP = "HSPAP";
+    public static final String RAT_GSM = "GSM";
+    public static final String RAT_TD_SCDMA = "TD_SCDMA";
+    public static final String RAT_GLOBAL = "GLOBAL";
+    public static final String RAT_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for Phone Type
+     * **/
+    public static final String PHONE_TYPE_GSM = "GSM";
+    public static final String PHONE_TYPE_NONE = "NONE";
+    public static final String PHONE_TYPE_CDMA = "CDMA";
+    public static final String PHONE_TYPE_SIP = "SIP";
+
+    /**
+     * Constant for SIM State
+     * **/
+    public static final String SIM_STATE_READY = "READY";
+    public static final String SIM_STATE_UNKNOWN = "UNKNOWN";
+    public static final String SIM_STATE_ABSENT = "ABSENT";
+    public static final String SIM_STATE_PUK_REQUIRED = "PUK_REQUIRED";
+    public static final String SIM_STATE_PIN_REQUIRED = "PIN_REQUIRED";
+    public static final String SIM_STATE_NETWORK_LOCKED = "NETWORK_LOCKED";
+    public static final String SIM_STATE_NOT_READY = "NOT_READY";
+    public static final String SIM_STATE_PERM_DISABLED = "PERM_DISABLED";
+    public static final String SIM_STATE_CARD_IO_ERROR = "CARD_IO_ERROR";
+
+    /**
+     * Constant for Data Connection State
+     * **/
+    public static final String DATA_STATE_CONNECTED = "CONNECTED";
+    public static final String DATA_STATE_DISCONNECTED = "DISCONNECTED";
+    public static final String DATA_STATE_CONNECTING = "CONNECTING";
+    public static final String DATA_STATE_SUSPENDED = "SUSPENDED";
+    public static final String DATA_STATE_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for Telephony Manager Call State
+     * **/
+    public static final String TELEPHONY_STATE_RINGING = "RINGING";
+    public static final String TELEPHONY_STATE_IDLE = "IDLE";
+    public static final String TELEPHONY_STATE_OFFHOOK = "OFFHOOK";
+    public static final String TELEPHONY_STATE_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for TTY Mode
+     * **/
+    public static final String TTY_MODE_FULL = "FULL";
+    public static final String TTY_MODE_HCO = "HCO";
+    public static final String TTY_MODE_OFF = "OFF";
+    public static final String TTY_MODE_VCO ="VCO";
+
+    /**
+     * Constant for Service State
+     * **/
+    public static final String SERVICE_STATE_EMERGENCY_ONLY = "EMERGENCY_ONLY";
+    public static final String SERVICE_STATE_IN_SERVICE = "IN_SERVICE";
+    public static final String SERVICE_STATE_OUT_OF_SERVICE = "OUT_OF_SERVICE";
+    public static final String SERVICE_STATE_POWER_OFF = "POWER_OFF";
+    public static final String SERVICE_STATE_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for VoLTE Hand-over Service State
+     * **/
+    public static final String VOLTE_SERVICE_STATE_HANDOVER_STARTED = "STARTED";
+    public static final String VOLTE_SERVICE_STATE_HANDOVER_COMPLETED = "COMPLETED";
+    public static final String VOLTE_SERVICE_STATE_HANDOVER_FAILED = "FAILED";
+    public static final String VOLTE_SERVICE_STATE_HANDOVER_CANCELED = "CANCELED";
+    public static final String VOLTE_SERVICE_STATE_HANDOVER_UNKNOWN = "UNKNOWN";
+
+    /**
+     * Constant for precise call state state listen level
+     * **/
+    public static final String PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND = "FOREGROUND";
+    public static final String PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING = "RINGING";
+    public static final String PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND = "BACKGROUND";
+
+    /**
+     * Constant for Video Call Session Event Name
+     * **/
+    public static final String SESSION_EVENT_RX_PAUSE = "SESSION_EVENT_RX_PAUSE";
+    public static final String SESSION_EVENT_RX_RESUME = "SESSION_EVENT_RX_RESUME";
+    public static final String SESSION_EVENT_TX_START = "SESSION_EVENT_TX_START";
+    public static final String SESSION_EVENT_TX_STOP = "SESSION_EVENT_TX_STOP";
+    public static final String SESSION_EVENT_CAMERA_FAILURE = "SESSION_EVENT_CAMERA_FAILURE";
+    public static final String SESSION_EVENT_CAMERA_READY = "SESSION_EVENT_CAMERA_READY";
+    public static final String SESSION_EVENT_UNKNOWN = "SESSION_EVENT_UNKNOWN";
+
+    /**
+     * Constants used to Register or de-register for Video Call Callbacks
+     * **/
+    public static final String EVENT_VIDEO_SESSION_MODIFY_REQUEST_RECEIVED = "EVENT_VIDEO_SESSION_MODIFY_REQUEST_RECEIVED";
+    public static final String EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED = "EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED";
+    public static final String EVENT_VIDEO_SESSION_EVENT = "EVENT_VIDEO_SESSION_EVENT";
+    public static final String EVENT_VIDEO_PEER_DIMENSIONS_CHANGED = "EVENT_VIDEO_PEER_DIMENSIONS_CHANGED";
+    public static final String EVENT_VIDEO_QUALITY_CHANGED = "EVENT_VIDEO_QUALITY_CHANGED";
+    public static final String EVENT_VIDEO_DATA_USAGE_CHANGED = "EVENT_VIDEO_DATA_USAGE_CHANGED";
+    public static final String EVENT_VIDEO_CAMERA_CAPABILITIES_CHANGED = "EVENT_VIDEO_CAMERA_CAPABILITIES_CHANGED";
+    public static final String EVENT_VIDEO_INVALID = "EVENT_VIDEO_INVALID";
+
+    /**
+     * Constant for Network Preference
+     * **/
+    public static final String NETWORK_MODE_WCDMA_PREF = "NETWORK_MODE_WCDMA_PREF";
+    public static final String NETWORK_MODE_GSM_ONLY = "NETWORK_MODE_GSM_ONLY";
+    public static final String NETWORK_MODE_WCDMA_ONLY = "NETWORK_MODE_WCDMA_ONLY";
+    public static final String NETWORK_MODE_GSM_UMTS = "NETWORK_MODE_GSM_UMTS";
+    public static final String NETWORK_MODE_CDMA = "NETWORK_MODE_CDMA";
+    public static final String NETWORK_MODE_CDMA_NO_EVDO = "NETWORK_MODE_CDMA_NO_EVDO";
+    public static final String NETWORK_MODE_EVDO_NO_CDMA = "NETWORK_MODE_EVDO_NO_CDMA";
+    public static final String NETWORK_MODE_GLOBAL = "NETWORK_MODE_GLOBAL";
+    public static final String NETWORK_MODE_LTE_CDMA_EVDO = "NETWORK_MODE_LTE_CDMA_EVDO";
+    public static final String NETWORK_MODE_LTE_GSM_WCDMA = "NETWORK_MODE_LTE_GSM_WCDMA";
+    public static final String NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA = "NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA";
+    public static final String NETWORK_MODE_LTE_ONLY = "NETWORK_MODE_LTE_ONLY";
+    public static final String NETWORK_MODE_LTE_WCDMA = "NETWORK_MODE_LTE_WCDMA";
+    public static final String NETWORK_MODE_TDSCDMA_ONLY = "NETWORK_MODE_TDSCDMA_ONLY";
+    public static final String NETWORK_MODE_TDSCDMA_WCDMA = "NETWORK_MODE_TDSCDMA_WCDMA";
+    public static final String NETWORK_MODE_LTE_TDSCDMA = "NETWORK_MODE_LTE_TDSCDMA";
+    public static final String NETWORK_MODE_TDSCDMA_GSM = "NETWORK_MODE_TDSCDMA_GSM";
+    public static final String NETWORK_MODE_LTE_TDSCDMA_GSM = "NETWORK_MODE_LTE_TDSCDMA_GSM";
+    public static final String NETWORK_MODE_TDSCDMA_GSM_WCDMA = "NETWORK_MODE_TDSCDMA_GSM_WCDMA";
+    public static final String NETWORK_MODE_LTE_TDSCDMA_WCDMA = "NETWORK_MODE_LTE_TDSCDMA_WCDMA";
+    public static final String NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA = "NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA";
+    public static final String NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA = "NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA";
+    public static final String NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA = "NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA";
+    public static final String NETWORK_MODE_INVALID = "INVALID";
+
+    /**
+     * Constant for Messaging Event Name
+     * **/
+    public static final String EventSmsDeliverSuccess = "SmsDeliverSuccess";
+    public static final String EventSmsDeliverFailure = "SmsDeliverFailure";
+    public static final String EventSmsSentSuccess = "SmsSentSuccess";
+    public static final String EventSmsSentFailure = "SmsSentFailure";
+    public static final String EventSmsReceived = "SmsReceived";
+    public static final String EventMmsSentSuccess = "MmsSentSuccess";
+    public static final String EventMmsSentFailure = "MmsSentFailure";
+    public static final String EventMmsDownloaded = "MmsDownloaded";
+    public static final String EventWapPushReceived = "WapPushReceived";
+    public static final String EventDataSmsReceived = "DataSmsReceived";
+    public static final String EventCmasReceived = "CmasReceived";
+    public static final String EventEtwsReceived = "EtwsReceived";
+
+    /**
+     * Constant for Telecom Call Event Name
+     * **/
+    public static final String EventTelecomCallStateChanged = "TelecomCallStateChanged";
+    public static final String EventTelecomCallParentChanged = "TelecomCallParentChanged";
+    public static final String EventTelecomCallChildrenChanged = "TelecomCallChildrenChanged";
+    public static final String EventTelecomCallDetailsChanged = "TelecomCallDetailsChanged";
+    public static final String EventTelecomCallCannedTextResponsesLoaded = "TelecomCallCannedTextResponsesLoaded";
+    public static final String EventTelecomCallPostDialWait = "TelecomCallPostDialWait";
+    public static final String EventTelecomCallVideoCallChanged = "TelecomCallVideoCallChanged";
+    public static final String EventTelecomCallDestroyed = "TelecomCallDestroyed";
+    public static final String EventTelecomCallConferenceableCallsChanged = "TelecomCallConferenceableCallsChanged";
+
+    /**
+     * Constant for Video Call Event Name
+     * **/
+    public static final String EventTelecomVideoCallSessionModifyRequestReceived = "TelecomVideoCallSessionModifyRequestReceived";
+    public static final String EventTelecomVideoCallSessionModifyResponseReceived = "TelecomVideoCallSessionModifyResponseReceived";
+    public static final String EventTelecomVideoCallSessionEvent = "TelecomVideoCallSessionEvent";
+    public static final String EventTelecomVideoCallPeerDimensionsChanged = "TelecomVideoCallPeerDimensionsChanged";
+    public static final String EventTelecomVideoCallVideoQualityChanged = "TelecomVideoCallVideoQualityChanged";
+    public static final String EventTelecomVideoCallDataUsageChanged = "TelecomVideoCallDataUsageChanged";
+    public static final String EventTelecomVideoCallCameraCapabilities = "TelecomVideoCallCameraCapabilities";
+
+    /**
+     * Constant for Other Event Name
+     * **/
+    public static final String EventCellInfoChanged = "CellInfoChanged";
+    public static final String EventCallStateChanged = "CallStateChanged";
+    public static final String EventPreciseStateChanged = "PreciseStateChanged";
+    public static final String EventDataConnectionRealTimeInfoChanged = "DataConnectionRealTimeInfoChanged";
+    public static final String EventDataConnectionStateChanged = "DataConnectionStateChanged";
+    public static final String EventServiceStateChanged = "ServiceStateChanged";
+    public static final String EventSignalStrengthChanged = "SignalStrengthChanged";
+    public static final String EventVolteServiceStateChanged = "VolteServiceStateChanged";
+    public static final String EventMessageWaitingIndicatorChanged = "MessageWaitingIndicatorChanged";
+    public static final String EventConnectivityChanged = "ConnectivityChanged";
+
+    /**
+     * Constant for Packet Keep Alive Call Back
+     * **/
+    public static final String EventPacketKeepaliveCallback = "PacketKeepaliveCallback";
+
+    /*Sub-Event Names*/
+    public static final String PacketKeepaliveCallbackStarted = "Started";
+    public static final String PacketKeepaliveCallbackStopped = "Stopped";
+    public static final String PacketKeepaliveCallbackError = "Error";
+    public static final String PacketKeepaliveCallbackInvalid = "Invalid";
+
+    /**
+     * Constant for Network Call Back
+     * **/
+    public static final String EventNetworkCallback = "NetworkCallback";
+
+    /*Sub-Event Names*/
+    public static final String NetworkCallbackPreCheck = "PreCheck";
+    public static final String NetworkCallbackAvailable = "Available";
+    public static final String NetworkCallbackLosing = "Losing";
+    public static final String NetworkCallbackLost = "Lost";
+    public static final String NetworkCallbackUnavailable = "Unavailable";
+    public static final String NetworkCallbackCapabilitiesChanged = "CapabilitiesChanged";
+    public static final String NetworkCallbackSuspended = "Suspended";
+    public static final String NetworkCallbackResumed = "Resumed";
+    public static final String NetworkCallbackLinkPropertiesChanged = "LinkPropertiesChanged";
+    public static final String NetworkCallbackInvalid = "Invalid";
+
+    /**
+     * Constant for Signal Strength fields
+     * **/
+    public static class SignalStrengthContainer {
+        public static final String SIGNAL_STRENGTH_GSM = "gsmSignalStrength";
+        public static final String SIGNAL_STRENGTH_GSM_DBM = "gsmDbm";
+        public static final String SIGNAL_STRENGTH_GSM_LEVEL = "gsmLevel";
+        public static final String SIGNAL_STRENGTH_GSM_ASU_LEVEL = "gsmAsuLevel";
+        public static final String SIGNAL_STRENGTH_GSM_BIT_ERROR_RATE = "gsmBitErrorRate";
+        public static final String SIGNAL_STRENGTH_CDMA_DBM = "cdmaDbm";
+        public static final String SIGNAL_STRENGTH_CDMA_LEVEL = "cdmaLevel";
+        public static final String SIGNAL_STRENGTH_CDMA_ASU_LEVEL = "cdmaAsuLevel";
+        public static final String SIGNAL_STRENGTH_CDMA_ECIO = "cdmaEcio";
+        public static final String SIGNAL_STRENGTH_EVDO_DBM = "evdoDbm";
+        public static final String SIGNAL_STRENGTH_EVDO_ECIO = "evdoEcio";
+        public static final String SIGNAL_STRENGTH_LTE = "lteSignalStrength";
+        public static final String SIGNAL_STRENGTH_LTE_DBM = "lteDbm";
+        public static final String SIGNAL_STRENGTH_LTE_LEVEL = "lteLevel";
+        public static final String SIGNAL_STRENGTH_LTE_ASU_LEVEL = "lteAsuLevel";
+        public static final String SIGNAL_STRENGTH_DBM = "dbm";
+        public static final String SIGNAL_STRENGTH_LEVEL = "level";
+        public static final String SIGNAL_STRENGTH_ASU_LEVEL = "asuLevel";
+    }
+
+    public static class CallStateContainer {
+        public static final String INCOMING_NUMBER = "incomingNumber";
+        public static final String SUBSCRIPTION_ID = "subscriptionId";
+        public static final String CALL_STATE = "callState";
+    }
+
+    public static class PreciseCallStateContainer {
+        public static final String TYPE = "type";
+        public static final String CAUSE = "cause";
+        public static final String SUBSCRIPTION_ID = "subscriptionId";
+        public static final String PRECISE_CALL_STATE = "preciseCallState";
+    }
+
+    public static class DataConnectionRealTimeInfoContainer {
+        public static final String TYPE = "type";
+        public static final String TIME = "time";
+        public static final String SUBSCRIPTION_ID = "subscriptionId";
+        public static final String DATA_CONNECTION_POWER_STATE = "dataConnectionPowerState";
+    }
+
+    public static class DataConnectionStateContainer {
+        public static final String TYPE = "type";
+        public static final String DATA_NETWORK_TYPE = "dataNetworkType";
+        public static final String STATE_CODE = "stateCode";
+        public static final String SUBSCRIPTION_ID = "subscriptionId";
+        public static final String DATA_CONNECTION_STATE = "dataConnectionState";
+    }
+
+    public static class ServiceStateContainer {
+        public static final String VOICE_REG_STATE = "voiceRegState";
+        public static final String VOICE_NETWORK_TYPE = "voiceNetworkType";
+        public static final String DATA_REG_STATE = "dataRegState";
+        public static final String DATA_NETWORK_TYPE = "dataNetworkType";
+        public static final String OPERATOR_NAME = "operatorName";
+        public static final String OPERATOR_ID = "operatorId";
+        public static final String IS_MANUAL_NW_SELECTION = "isManualNwSelection";
+        public static final String ROAMING = "roaming";
+        public static final String IS_EMERGENCY_ONLY = "isEmergencyOnly";
+        public static final String NETWORK_ID = "networkId";
+        public static final String SYSTEM_ID = "systemId";
+        public static final String SUBSCRIPTION_ID = "subscriptionId";
+        public static final String SERVICE_STATE = "serviceState";
+    }
+
+    public static class MessageWaitingIndicatorContainer {
+        public static final String IS_MESSAGE_WAITING = "isMessageWaiting";
+    }
+
+    public static class VoLteServiceStateContainer {
+        public static final String SRVCC_STATE = "srvccState";
+    }
+
+    public static class PacketKeepaliveContainer {
+        public static final String ID = "id";
+        public static final String PACKET_KEEPALIVE_EVENT = "packetKeepaliveEvent";
+    }
+
+    public static class NetworkCallbackContainer {
+        public static final String ID = "id";
+        public static final String NETWORK_CALLBACK_EVENT = "networkCallbackEvent";
+        public static final String MAX_MS_TO_LIVE = "maxMsToLive";
+        public static final String RSSI = "rssi";
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyEvents.java b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyEvents.java
new file mode 100644
index 0000000..2c2e621
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyEvents.java
@@ -0,0 +1,362 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+import android.telephony.DataConnectionRealTimeInfo;
+import android.telephony.PreciseCallState;
+import android.telephony.ServiceState;
+import com.googlecode.android_scripting.jsonrpc.JsonSerializable;
+import com.googlecode.android_scripting.facade.telephony.TelephonyConstants;
+import com.googlecode.android_scripting.facade.telephony.TelephonyUtils;
+
+public class TelephonyEvents {
+
+    public static class CallStateEvent implements JsonSerializable {
+        private String mCallState;
+        private String mIncomingNumber;
+        private int mSubscriptionId;
+
+        CallStateEvent(int state, String incomingNumber, int subscriptionId) {
+            mCallState = null;
+            mIncomingNumber = TelephonyUtils.formatIncomingNumber(
+                    incomingNumber);
+            mCallState = TelephonyUtils.getTelephonyCallStateString(
+                    state);
+            mSubscriptionId = subscriptionId;
+        }
+
+        public String getIncomingNumber() {
+            return mIncomingNumber;
+        }
+
+        public int getSubscriptionId() {
+            return mSubscriptionId;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject callState = new JSONObject();
+
+            callState.put(
+                    TelephonyConstants.CallStateContainer.SUBSCRIPTION_ID,
+                    mSubscriptionId);
+            callState.put(
+                    TelephonyConstants.CallStateContainer.INCOMING_NUMBER,
+                    mIncomingNumber);
+            callState.put(TelephonyConstants.CallStateContainer.CALL_STATE,
+                    mCallState);
+
+            return callState;
+        }
+    }
+
+    public static class PreciseCallStateEvent implements JsonSerializable {
+        private PreciseCallState mPreciseCallState;
+        private String mPreciseCallStateString;
+        private String mType;
+        private int mCause;
+        private int mSubscriptionId;
+
+        PreciseCallStateEvent(int newState, String type,
+                PreciseCallState preciseCallState, int subscriptionId) {
+            mPreciseCallStateString = TelephonyUtils.getPreciseCallStateString(
+                    newState);
+            mPreciseCallState = preciseCallState;
+            mType = type;
+            mSubscriptionId = subscriptionId;
+            mCause = preciseCallState.getPreciseDisconnectCause();
+        }
+
+        public String getType() {
+            return mType;
+        }
+
+        public int getSubscriptionId() {
+            return mSubscriptionId;
+        }
+
+        public PreciseCallState getPreciseCallState() {
+            return mPreciseCallState;
+        }
+
+        public int getCause() {
+            return mCause;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject preciseCallState = new JSONObject();
+
+            preciseCallState.put(
+                    TelephonyConstants.PreciseCallStateContainer.SUBSCRIPTION_ID,
+                    mSubscriptionId);
+            preciseCallState.put(
+                    TelephonyConstants.PreciseCallStateContainer.TYPE, mType);
+            preciseCallState.put(
+                    TelephonyConstants.PreciseCallStateContainer.PRECISE_CALL_STATE,
+                    mPreciseCallStateString);
+            preciseCallState.put(
+                    TelephonyConstants.PreciseCallStateContainer.CAUSE, mCause);
+
+            return preciseCallState;
+        }
+    }
+
+    public static class DataConnectionRealTimeInfoEvent implements JsonSerializable {
+        private DataConnectionRealTimeInfo mDataConnectionRealTimeInfo;
+        private String mDataConnectionPowerState;
+        private int mSubscriptionId;
+        private long mTime;
+
+        DataConnectionRealTimeInfoEvent(
+                DataConnectionRealTimeInfo dataConnectionRealTimeInfo,
+                int subscriptionId) {
+            mTime = dataConnectionRealTimeInfo.getTime();
+            mSubscriptionId = subscriptionId;
+            mDataConnectionPowerState = TelephonyUtils.getDcPowerStateString(
+                    dataConnectionRealTimeInfo.getDcPowerState());
+            mDataConnectionRealTimeInfo = dataConnectionRealTimeInfo;
+        }
+
+        public int getSubscriptionId() {
+            return mSubscriptionId;
+        }
+
+        public long getTime() {
+            return mTime;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject dataConnectionRealTimeInfo = new JSONObject();
+
+            dataConnectionRealTimeInfo.put(
+                    TelephonyConstants.DataConnectionRealTimeInfoContainer.SUBSCRIPTION_ID,
+                    mSubscriptionId);
+            dataConnectionRealTimeInfo.put(
+                    TelephonyConstants.DataConnectionRealTimeInfoContainer.TIME,
+                    mTime);
+            dataConnectionRealTimeInfo.put(
+                    TelephonyConstants.DataConnectionRealTimeInfoContainer.DATA_CONNECTION_POWER_STATE,
+                    mDataConnectionPowerState);
+
+            return dataConnectionRealTimeInfo;
+        }
+    }
+
+    public static class DataConnectionStateEvent implements JsonSerializable {
+        private String mDataConnectionState;
+        private int mSubscriptionId;
+        private int mState;
+        private String mDataNetworkType;
+
+        DataConnectionStateEvent(int state, String dataNetworkType,
+                int subscriptionId) {
+            mSubscriptionId = subscriptionId;
+            mDataConnectionState = TelephonyUtils.getDataConnectionStateString(
+                    state);
+            mDataNetworkType = dataNetworkType;
+            mState = state;
+        }
+
+        public int getSubscriptionId() {
+            return mSubscriptionId;
+        }
+
+        public int getState() {
+            return mState;
+        }
+
+        public String getDataNetworkType() {
+            return mDataNetworkType;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject dataConnectionState = new JSONObject();
+
+            dataConnectionState.put(
+                    TelephonyConstants.DataConnectionStateContainer.SUBSCRIPTION_ID,
+                    mSubscriptionId);
+            dataConnectionState.put(
+                    TelephonyConstants.DataConnectionStateContainer.DATA_CONNECTION_STATE,
+                    mDataConnectionState);
+            dataConnectionState.put(
+                    TelephonyConstants.DataConnectionStateContainer.DATA_NETWORK_TYPE,
+                    mDataNetworkType);
+            dataConnectionState.put(
+                    TelephonyConstants.DataConnectionStateContainer.STATE_CODE,
+                    mState);
+
+            return dataConnectionState;
+        }
+    }
+
+    public static class ServiceStateEvent implements JsonSerializable {
+        private String mServiceStateString;
+        private int mSubscriptionId;
+        private ServiceState mServiceState;
+
+        ServiceStateEvent(ServiceState serviceState, int subscriptionId) {
+            mServiceState = serviceState;
+            mSubscriptionId = subscriptionId;
+            mServiceStateString = TelephonyUtils.getNetworkStateString(
+                    serviceState.getState());
+            if (mServiceStateString.equals(
+                    TelephonyConstants.SERVICE_STATE_OUT_OF_SERVICE) &&
+                    serviceState.isEmergencyOnly()) {
+                mServiceStateString = TelephonyConstants.SERVICE_STATE_EMERGENCY_ONLY;
+            }
+        }
+
+        public int getSubscriptionId() {
+            return mSubscriptionId;
+        }
+
+        public ServiceState getServiceState() {
+            return mServiceState;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject serviceState = new JSONObject();
+
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.SUBSCRIPTION_ID,
+                    mSubscriptionId);
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.VOICE_REG_STATE,
+                    TelephonyUtils.getNetworkStateString(
+                            mServiceState.getVoiceRegState()));
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.VOICE_NETWORK_TYPE,
+                    TelephonyUtils.getNetworkTypeString(
+                            mServiceState.getVoiceNetworkType()));
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.DATA_REG_STATE,
+                    TelephonyUtils.getNetworkStateString(
+                            mServiceState.getDataRegState()));
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.DATA_NETWORK_TYPE,
+                    TelephonyUtils.getNetworkTypeString(
+                            mServiceState.getDataNetworkType()));
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.OPERATOR_NAME,
+                    mServiceState.getOperatorAlphaLong());
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.OPERATOR_ID,
+                    mServiceState.getOperatorNumeric());
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.IS_MANUAL_NW_SELECTION,
+                    mServiceState.getIsManualSelection());
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.ROAMING,
+                    mServiceState.getRoaming());
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.IS_EMERGENCY_ONLY,
+                    mServiceState.isEmergencyOnly());
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.NETWORK_ID,
+                    mServiceState.getNetworkId());
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.SYSTEM_ID,
+                    mServiceState.getSystemId());
+            serviceState.put(
+                    TelephonyConstants.ServiceStateContainer.SERVICE_STATE,
+                    mServiceStateString);
+
+            return serviceState;
+        }
+    }
+
+    public static class MessageWaitingIndicatorEvent implements JsonSerializable {
+        private boolean mMessageWaitingIndicator;
+
+        MessageWaitingIndicatorEvent(boolean messageWaitingIndicator) {
+            mMessageWaitingIndicator = messageWaitingIndicator;
+        }
+
+        public boolean getMessageWaitingIndicator() {
+            return mMessageWaitingIndicator;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject messageWaitingIndicator = new JSONObject();
+
+            messageWaitingIndicator.put(
+                    TelephonyConstants.MessageWaitingIndicatorContainer.IS_MESSAGE_WAITING,
+                    mMessageWaitingIndicator);
+
+            return messageWaitingIndicator;
+        }
+    }
+
+    public static class PacketKeepaliveEvent implements JsonSerializable {
+        private String mId;
+        private String mPacketKeepaliveEvent;
+
+        public PacketKeepaliveEvent(String id, String event) {
+            mId = id;
+            mPacketKeepaliveEvent = event;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject packetKeepalive = new JSONObject();
+
+            packetKeepalive.put(
+                    TelephonyConstants.PacketKeepaliveContainer.ID,
+                    mId);
+            packetKeepalive.put(
+                    TelephonyConstants.PacketKeepaliveContainer.PACKET_KEEPALIVE_EVENT,
+                    mPacketKeepaliveEvent);
+
+            return packetKeepalive;
+        }
+    }
+
+    public static class NetworkCallbackEvent implements JsonSerializable {
+        public static final Integer INVALID_VALUE = null;
+        private String mId;
+        private String mNetworkCallbackEvent;
+        private Integer mRssi;
+        private Integer mMaxMsToLive;
+
+        public NetworkCallbackEvent(String id, String event, Integer rssi, Integer maxMsToLive) {
+            mId = id;
+            mNetworkCallbackEvent = event;
+            mRssi = rssi;
+            mMaxMsToLive = maxMsToLive;
+        }
+
+        public JSONObject toJSON() throws JSONException {
+            JSONObject networkCallback = new JSONObject();
+
+            networkCallback.put(
+                    TelephonyConstants.NetworkCallbackContainer.ID,
+                    mId);
+            networkCallback.put(
+                    TelephonyConstants.NetworkCallbackContainer.NETWORK_CALLBACK_EVENT,
+                    mNetworkCallbackEvent);
+            networkCallback.put(
+                    TelephonyConstants.NetworkCallbackContainer.MAX_MS_TO_LIVE,
+                    mMaxMsToLive);
+            networkCallback.put(
+                    TelephonyConstants.NetworkCallbackContainer.RSSI,
+                    mRssi);
+
+            return networkCallback;
+        }
+    }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyManagerFacade.java
new file mode 100644
index 0000000..333274a
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyManagerFacade.java
@@ -0,0 +1,1183 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import android.app.Activity;
+import android.app.Service;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.RemoteException;
+import android.provider.ContactsContract;
+import android.telephony.CellInfo;
+import android.telephony.CellLocation;
+import android.telephony.ModemActivityInfo;
+import android.telephony.NeighboringCellInfo;
+import android.telephony.PhoneStateListener;
+import android.telephony.SignalStrength;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.provider.Telephony;
+import android.telephony.SubscriptionInfo;
+import android.telecom.VideoProfile;
+import android.telecom.TelecomManager;
+import android.util.Base64;
+
+import com.android.internal.telephony.PhoneConstants;
+import com.android.internal.telephony.RILConstants;
+import com.android.internal.telephony.TelephonyProperties;
+import com.google.common.io.BaseEncoding;
+
+import android.content.ContentValues;
+import android.os.SystemProperties;
+
+import com.googlecode.android_scripting.facade.AndroidFacade;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.facade.telephony.TelephonyStateListeners
+                                                   .CallStateChangeListener;
+import com.googlecode.android_scripting.facade.telephony.TelephonyStateListeners
+                                                   .CellInfoChangeListener;
+import com.googlecode.android_scripting.facade.telephony.TelephonyStateListeners
+                                                   .DataConnectionRealTimeInfoChangeListener;
+import com.googlecode.android_scripting.facade.telephony.TelephonyStateListeners
+                                                   .DataConnectionStateChangeListener;
+import com.googlecode.android_scripting.facade.telephony.TelephonyStateListeners
+                                                   .ServiceStateChangeListener;
+import com.googlecode.android_scripting.facade.telephony.TelephonyStateListeners
+                                                   .SignalStrengthChangeListener;
+import com.googlecode.android_scripting.facade.telephony.TelephonyStateListeners
+                                                   .VoiceMailStateChangeListener;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Field;
+import java.net.URLEncoder;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.HashMap;
+
+/**
+ * Exposes TelephonyManager functionality.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Felix Arends (felix.arends@gmail.com)
+ */
+public class TelephonyManagerFacade extends RpcReceiver {
+
+    private final Service mService;
+    private final AndroidFacade mAndroidFacade;
+    private final EventFacade mEventFacade;
+    private final TelephonyManager mTelephonyManager;
+    private final SubscriptionManager mSubscriptionManager;
+    private List<SubscriptionInfo> mSubInfos;
+    private HashMap<Integer, StateChangeListener> StateChangeListeners =
+                             new HashMap<Integer, StateChangeListener>();
+
+    private static final String[] sProjection = new String[] {
+            Telephony.Carriers._ID, // 0
+            Telephony.Carriers.NAME, // 1
+            Telephony.Carriers.APN, // 2
+            Telephony.Carriers.PROXY, // 3
+            Telephony.Carriers.PORT, // 4
+            Telephony.Carriers.USER, // 5
+            Telephony.Carriers.SERVER, // 6
+            Telephony.Carriers.PASSWORD, // 7
+            Telephony.Carriers.MMSC, // 8
+            Telephony.Carriers.MCC, // 9
+            Telephony.Carriers.MNC, // 10
+            Telephony.Carriers.NUMERIC, // 11
+            Telephony.Carriers.MMSPROXY,// 12
+            Telephony.Carriers.MMSPORT, // 13
+            Telephony.Carriers.AUTH_TYPE, // 14
+            Telephony.Carriers.TYPE, // 15
+            Telephony.Carriers.PROTOCOL, // 16
+            Telephony.Carriers.CARRIER_ENABLED, // 17
+            Telephony.Carriers.BEARER_BITMASK, // 18
+            Telephony.Carriers.ROAMING_PROTOCOL, // 19
+            Telephony.Carriers.MVNO_TYPE, // 20
+            Telephony.Carriers.MVNO_MATCH_DATA // 21
+    };
+
+    public TelephonyManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mTelephonyManager =
+                (TelephonyManager) mService.getSystemService(Context.TELEPHONY_SERVICE);
+        mAndroidFacade = manager.getReceiver(AndroidFacade.class);
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mSubscriptionManager = SubscriptionManager.from(mService);
+        mSubInfos = mSubscriptionManager.getAllSubscriptionInfoList();
+        MainThread.run(manager.getService(), new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                // Creating listeners for all subscription IDs
+                for (int i = 0; i < mSubInfos.size(); i++) {
+                    int subId = mSubInfos.get(i).getSubscriptionId();
+                    StateChangeListener tempStateListener =
+                                                     new StateChangeListener();
+                    tempStateListener.mServiceStateChangeListener =
+                        new ServiceStateChangeListener(mEventFacade, subId);
+                    tempStateListener.mSignalStrengthChangeListener =
+                        new SignalStrengthChangeListener(mEventFacade, subId);
+                    tempStateListener.mDataConnectionStateChangeListener =
+                        new DataConnectionStateChangeListener(mEventFacade,
+                                                      mTelephonyManager, subId);
+                    tempStateListener.mCallStateChangeListener =
+                        new CallStateChangeListener(mEventFacade, subId);
+                    tempStateListener.mCellInfoChangeListener =
+                        new CellInfoChangeListener(mEventFacade, subId);
+                    tempStateListener.mDataConnectionRTInfoChangeListener =
+                        new DataConnectionRealTimeInfoChangeListener(mEventFacade,
+                                                                     subId);
+                    tempStateListener.mVoiceMailStateChangeListener =
+                        new VoiceMailStateChangeListener(mEventFacade, subId);
+
+                    StateChangeListeners.put(subId, tempStateListener);
+                }
+                return null;
+            }
+        });
+    }
+
+    @Rpc(description = "Set network preference.")
+    public boolean telephonySetPreferredNetworkTypes(
+        @RpcParameter(name = "nwPreference") String nwPreference) {
+        return telephonySetPreferredNetworkTypesForSubscription(nwPreference,
+                SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Set network preference for subscription.")
+    public boolean telephonySetPreferredNetworkTypesForSubscription(
+            @RpcParameter(name = "nwPreference") String nwPreference,
+            @RpcParameter(name = "subId") Integer subId) {
+        int networkPreferenceInt = TelephonyUtils.getNetworkModeIntfromString(
+            nwPreference);
+        if (RILConstants.RIL_ERRNO_INVALID_RESPONSE != networkPreferenceInt) {
+            return mTelephonyManager.setPreferredNetworkType(
+                subId, networkPreferenceInt);
+        } else {
+            return false;
+        }
+    }
+
+    @Rpc(description = "Get network preference.")
+    public String telephonyGetPreferredNetworkTypes() {
+        return telephonyGetPreferredNetworkTypesForSubscription(
+                SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Get network preference for subscription.")
+    public String telephonyGetPreferredNetworkTypesForSubscription(
+            @RpcParameter(name = "subId") Integer subId) {
+        int networkPreferenceInt = mTelephonyManager.getPreferredNetworkType(subId);
+        return TelephonyUtils.getNetworkModeStringfromInt(networkPreferenceInt);
+    }
+
+    @Rpc(description = "Get current voice network type")
+    public String telephonyGetCurrentVoiceNetworkType() {
+        return telephonyGetCurrentVoiceNetworkTypeForSubscription(
+                SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Get current voice network type for subscription")
+    public String telephonyGetCurrentVoiceNetworkTypeForSubscription(
+            @RpcParameter(name = "subId") Integer subId) {
+        return TelephonyUtils.getNetworkTypeString(
+            mTelephonyManager.getVoiceNetworkType(subId));
+    }
+
+    @Rpc(description = "Get current data network type")
+    public String telephonyGetCurrentDataNetworkType() {
+        return telephonyGetCurrentDataNetworkTypeForSubscription(
+                SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Get current data network type for subscription")
+    public String telephonyGetCurrentDataNetworkTypeForSubscription(
+            @RpcParameter(name = "subId") Integer subId) {
+        return TelephonyUtils.getNetworkTypeString(
+            mTelephonyManager.getDataNetworkType(subId));
+    }
+
+    @Rpc(description = "Get if phone have voice capability")
+    public boolean telephonyIsVoiceCapable() {
+        return mTelephonyManager.isVoiceCapable();
+    }
+
+    @Rpc(description = "Get preferred network setting for " +
+                       "default subscription ID .Return value is integer.")
+    public int telephonyGetPreferredNetworkTypeInteger() {
+        return telephonyGetPreferredNetworkTypeIntegerForSubscription(
+                                         SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Get preferred network setting for " +
+                       "specified subscription ID .Return value is integer.")
+    public int telephonyGetPreferredNetworkTypeIntegerForSubscription(
+               @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getPreferredNetworkType(subId);
+    }
+
+    @Rpc(description = "Starts tracking call state change" +
+                       "for default subscription ID.")
+    public Boolean telephonyStartTrackingCallState() {
+        return telephonyStartTrackingCallStateForSubscription(
+                              SubscriptionManager.getDefaultVoiceSubscriptionId());
+    }
+
+    @Rpc(description = "Starts tracking call state change" +
+                       "for specified subscription ID.")
+    public Boolean telephonyStartTrackingCallStateForSubscription(
+                @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mCallStateChangeListener,
+                CallStateChangeListener.sListeningStates);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Starts tracking cell info change" +
+                       "for default subscription ID.")
+    public Boolean telephonyStartTrackingCellInfoChange() {
+        return telephonyStartTrackingCellInfoChangeForSubscription(
+                              SubscriptionManager.getDefaultVoiceSubscriptionId());
+    }
+
+    @Rpc(description = "Starts tracking cell info change" +
+                       "for specified subscription ID.")
+    public Boolean telephonyStartTrackingCellInfoChangeForSubscription(
+                @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mCellInfoChangeListener,
+                PhoneStateListener.LISTEN_CELL_INFO);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Turn on/off precise listening on fore/background or" +
+                       " ringing calls for default voice subscription ID.")
+    public Boolean telephonyAdjustPreciseCallStateListenLevel(String type,
+                                                          Boolean listen) {
+        return telephonyAdjustPreciseCallStateListenLevelForSubscription(type, listen,
+                                 SubscriptionManager.getDefaultVoiceSubscriptionId());
+    }
+
+    @Rpc(description = "Turn on/off precise listening on fore/background or" +
+                       " ringing calls for specified subscription ID.")
+    public Boolean telephonyAdjustPreciseCallStateListenLevelForSubscription(String type,
+                   Boolean listen,
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            if (type.equals(TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND)) {
+                StateChangeListeners.get(subId).mCallStateChangeListener.listenForeground = listen;
+            } else if (type.equals(TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING)) {
+                StateChangeListeners.get(subId).mCallStateChangeListener.listenRinging = listen;
+            } else if (type.equals(TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND)) {
+                StateChangeListeners.get(subId).mCallStateChangeListener.listenBackground = listen;
+            }
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Stops tracking cell info change " +
+            "for default voice subscription ID.")
+    public Boolean telephonyStopTrackingCellInfoChange() {
+        return telephonyStopTrackingCellInfoChangeForSubscription(
+                SubscriptionManager.getDefaultVoiceSubscriptionId());
+    }
+
+    @Rpc(description = "Stops tracking cell info change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStopTrackingCellInfoChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mCellInfoChangeListener,
+                PhoneStateListener.LISTEN_NONE);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+    @Rpc(description = "Stops tracking call state change " +
+            "for default voice subscription ID.")
+    public Boolean telephonyStopTrackingCallStateChange() {
+        return telephonyStopTrackingCallStateChangeForSubscription(
+                SubscriptionManager.getDefaultVoiceSubscriptionId());
+    }
+
+    @Rpc(description = "Stops tracking call state change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStopTrackingCallStateChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mCallStateChangeListener,
+                PhoneStateListener.LISTEN_NONE);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Starts tracking data connection real time info change" +
+                       "for default subscription ID.")
+    public Boolean telephonyStartTrackingDataConnectionRTInfoChange() {
+        return telephonyStartTrackingDataConnectionRTInfoChangeForSubscription(
+                                 SubscriptionManager.getDefaultDataSubscriptionId());
+    }
+
+    @Rpc(description = "Starts tracking data connection real time info change" +
+                       "for specified subscription ID.")
+    public Boolean telephonyStartTrackingDataConnectionRTInfoChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mDataConnectionRTInfoChangeListener,
+                DataConnectionRealTimeInfoChangeListener.sListeningStates);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Stops tracking data connection real time info change" +
+                       "for default subscription ID.")
+    public Boolean telephonyStopTrackingDataConnectionRTInfoChange() {
+        return telephonyStopTrackingDataConnectionRTInfoChangeForSubscription(
+                                 SubscriptionManager.getDefaultDataSubscriptionId());
+    }
+
+    @Rpc(description = "Stops tracking data connection real time info change" +
+                       "for specified subscription ID.")
+    public Boolean telephonyStopTrackingDataConnectionRTInfoChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mDataConnectionRTInfoChangeListener,
+                PhoneStateListener.LISTEN_NONE);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Starts tracking data connection state change" +
+                       "for default subscription ID..")
+    public Boolean telephonyStartTrackingDataConnectionStateChange() {
+        return telephonyStartTrackingDataConnectionStateChangeForSubscription(
+                                 SubscriptionManager.getDefaultDataSubscriptionId());
+    }
+
+    @Rpc(description = "Starts tracking data connection state change" +
+                       "for specified subscription ID.")
+    public Boolean telephonyStartTrackingDataConnectionStateChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mDataConnectionStateChangeListener,
+                DataConnectionStateChangeListener.sListeningStates);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Stops tracking data connection state change " +
+                       "for default subscription ID..")
+    public Boolean telephonyStopTrackingDataConnectionStateChange() {
+        return telephonyStopTrackingDataConnectionStateChangeForSubscription(
+                                 SubscriptionManager.getDefaultDataSubscriptionId());
+    }
+
+    @Rpc(description = "Stops tracking data connection state change " +
+                       "for specified subscription ID..")
+    public Boolean telephonyStopTrackingDataConnectionStateChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mDataConnectionStateChangeListener,
+                PhoneStateListener.LISTEN_NONE);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Starts tracking service state change " +
+                       "for default subscription ID.")
+    public Boolean telephonyStartTrackingServiceStateChange() {
+        return telephonyStartTrackingServiceStateChangeForSubscription(
+                                 SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Starts tracking service state change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStartTrackingServiceStateChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+         try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mServiceStateChangeListener,
+                ServiceStateChangeListener.sListeningStates);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Stops tracking service state change " +
+                       "for default subscription ID.")
+    public Boolean telephonyStopTrackingServiceStateChange() {
+        return telephonyStopTrackingServiceStateChangeForSubscription(
+                                 SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Stops tracking service state change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStopTrackingServiceStateChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mServiceStateChangeListener,
+                PhoneStateListener.LISTEN_NONE);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Starts tracking signal strength change " +
+                       "for default subscription ID.")
+    public Boolean telephonyStartTrackingSignalStrengthChange() {
+        return telephonyStartTrackingSignalStrengthChangeForSubscription(
+                                 SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Starts tracking signal strength change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStartTrackingSignalStrengthChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+         try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mSignalStrengthChangeListener,
+                SignalStrengthChangeListener.sListeningStates);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Stops tracking signal strength change " +
+                       "for default subscription ID.")
+    public Boolean telephonyStopTrackingSignalStrengthChange() {
+        return telephonyStopTrackingSignalStrengthChangeForSubscription(
+                                 SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Stops tracking signal strength change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStopTrackingSignalStrengthChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mSignalStrengthChangeListener,
+                PhoneStateListener.LISTEN_NONE);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Starts tracking voice mail state change " +
+                       "for default subscription ID.")
+    public Boolean telephonyStartTrackingVoiceMailStateChange() {
+        return telephonyStartTrackingVoiceMailStateChangeForSubscription(
+                                 SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Starts tracking voice mail state change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStartTrackingVoiceMailStateChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+         try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mVoiceMailStateChangeListener,
+                VoiceMailStateChangeListener.sListeningStates);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Stops tracking voice mail state change " +
+                       "for default subscription ID.")
+    public Boolean telephonyStopTrackingVoiceMailStateChange() {
+        return telephonyStopTrackingVoiceMailStateChangeForSubscription(
+                                 SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Stops tracking voice mail state change " +
+                       "for specified subscription ID.")
+    public Boolean telephonyStopTrackingVoiceMailStateChangeForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        try {
+            mTelephonyManager.listen(
+                StateChangeListeners.get(subId).mVoiceMailStateChangeListener,
+                PhoneStateListener.LISTEN_NONE);
+            return true;
+        } catch (Exception e) {
+            Log.e("Invalid subscription ID");
+            return false;
+        }
+    }
+
+    @Rpc(description = "Answers an incoming ringing call.")
+    public void telephonyAnswerCall() throws RemoteException {
+        mTelephonyManager.silenceRinger();
+        mTelephonyManager.answerRingingCall();
+    }
+
+    @Rpc(description = "Returns the current cell location.")
+    public CellLocation telephonyGetCellLocation() {
+        return mTelephonyManager.getCellLocation();
+    }
+
+    @Rpc(description = "Returns the numeric name (MCC+MNC) of registered operator." +
+                       "for default subscription ID")
+    public String telephonyGetNetworkOperator() {
+        return telephonyGetNetworkOperatorForSubscription(
+                        SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the numeric name (MCC+MNC) of registered operator" +
+                       "for specified subscription ID.")
+    public String telephonyGetNetworkOperatorForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getNetworkOperator(subId);
+    }
+
+    @Rpc(description = "Returns the alphabetic name of current registered operator" +
+                       "for specified subscription ID.")
+    public String telephonyGetNetworkOperatorName() {
+        return telephonyGetNetworkOperatorNameForSubscription(
+                        SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the alphabetic name of registered operator " +
+                       "for specified subscription ID.")
+    public String telephonyGetNetworkOperatorNameForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getNetworkOperatorName(subId);
+    }
+
+    @Rpc(description = "Returns the current RAT in use on the device.+" +
+                       "for default subscription ID")
+    public String telephonyGetNetworkType() {
+
+        Log.d("sl4a:getNetworkType() is deprecated!" +
+                "Please use getVoiceNetworkType()" +
+                " or getDataNetworkTpe()");
+
+        return telephonyGetNetworkTypeForSubscription(
+                       SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the current RAT in use on the device" +
+            " for a given Subscription.")
+    public String telephonyGetNetworkTypeForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+
+        Log.d("sl4a:getNetworkTypeForSubscriber() is deprecated!" +
+                "Please use getVoiceNetworkType()" +
+                " or getDataNetworkTpe()");
+
+        return TelephonyUtils.getNetworkTypeString(
+            mTelephonyManager.getNetworkType(subId));
+    }
+
+    @Rpc(description = "Returns the current voice RAT for" +
+            " the default voice subscription.")
+    public String telephonyGetVoiceNetworkType() {
+        return telephonyGetVoiceNetworkTypeForSubscription(
+                         SubscriptionManager.getDefaultVoiceSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the current voice RAT for" +
+            " the specified voice subscription.")
+    public String telephonyGetVoiceNetworkTypeForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return TelephonyUtils.getNetworkTypeString(
+            mTelephonyManager.getVoiceNetworkType(subId));
+    }
+
+    @Rpc(description = "Returns the current data RAT for" +
+            " the defaut data subscription")
+    public String telephonyGetDataNetworkType() {
+        return telephonyGetDataNetworkTypeForSubscription(
+                         SubscriptionManager.getDefaultDataSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the current data RAT for" +
+            " the specified data subscription")
+    public String telephonyGetDataNetworkTypeForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return TelephonyUtils.getNetworkTypeString(
+            mTelephonyManager.getDataNetworkType(subId));
+    }
+
+    @Rpc(description = "Returns the device phone type.")
+    public String telephonyGetPhoneType() {
+        return TelephonyUtils.getPhoneTypeString(
+            mTelephonyManager.getPhoneType());
+    }
+
+    @Rpc(description = "Returns the MCC for default subscription ID")
+    public String telephonyGetSimCountryIso() {
+         return telephonyGetSimCountryIsoForSubscription(
+                      SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Get the latest power consumption stats from the modem")
+    public ModemActivityInfo telephonyGetModemActivityInfo() {
+        ModemActivityInfo info = mTelephonyManager.getModemActivityInfo();
+        return info;
+    }
+
+    @Rpc(description = "Returns the MCC for specified subscription ID")
+    public String telephonyGetSimCountryIsoForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getSimCountryIso(subId);
+    }
+
+    @Rpc(description = "Returns the MCC+MNC for default subscription ID")
+    public String telephonyGetSimOperator() {
+        return telephonyGetSimOperatorForSubscription(
+                  SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the MCC+MNC for specified subscription ID")
+    public String telephonyGetSimOperatorForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getSimOperator(subId);
+    }
+
+    @Rpc(description = "Returns the Service Provider Name (SPN)" +
+                       "for default subscription ID")
+    public String telephonyGetSimOperatorName() {
+        return telephonyGetSimOperatorNameForSubscription(
+                  SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the Service Provider Name (SPN)" +
+                       " for specified subscription ID.")
+    public String telephonyGetSimOperatorNameForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getSimOperatorName(subId);
+    }
+
+    @Rpc(description = "Returns the serial number of the SIM for " +
+                       "default subscription ID, or Null if unavailable")
+    public String telephonyGetSimSerialNumber() {
+        return telephonyGetSimSerialNumberForSubscription(
+                  SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the serial number of the SIM for " +
+                       "specified subscription ID, or Null if unavailable")
+    public String telephonyGetSimSerialNumberForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getSimSerialNumber(subId);
+    }
+
+    @Rpc(description = "Returns the state of the SIM card for default slot ID.")
+    public String telephonyGetSimState() {
+        return telephonyGetSimStateForSlotId(
+                  mTelephonyManager.getDefaultSim());
+    }
+
+    @Rpc(description = "Returns the state of the SIM card for specified slot ID.")
+    public String telephonyGetSimStateForSlotId(
+                  @RpcParameter(name = "slotId") Integer slotId) {
+        return TelephonyUtils.getSimStateString(
+            mTelephonyManager.getSimState(slotId));
+    }
+
+    @Rpc(description = "Get Authentication Challenge Response from a " +
+            "given SIM Application")
+    public String telephonyGetIccSimChallengeResponse(
+        @RpcParameter(name = "appType") Integer appType,
+            @RpcParameter(name = "hexChallenge") String hexChallenge) {
+        return telephonyGetIccSimChallengeResponseForSubscription(
+                SubscriptionManager.getDefaultSubscriptionId(), appType, hexChallenge);
+    }
+
+    @Rpc(description = "Get Authentication Challenge Response from a " +
+            "given SIM Application for a specified Subscription")
+    public String telephonyGetIccSimChallengeResponseForSubscription(
+            @RpcParameter(name = "subId") Integer subId,
+            @RpcParameter(name = "appType") Integer appType,
+            @RpcParameter(name = "hexChallenge") String hexChallenge) {
+
+        try {
+            String b64Data = BaseEncoding.base64().encode(BaseEncoding.base16().decode(hexChallenge));
+            String b64Result = mTelephonyManager.getIccSimChallengeResponse(subId, appType, b64Data);
+            return (b64Result != null)
+                    ? BaseEncoding.base16().encode(BaseEncoding.base64().decode(b64Result)) : null;
+        } catch( Exception e) {
+            Log.e("Exception in phoneGetIccSimChallengeResponseForSubscription" + e.toString());
+            return null;
+        }
+    }
+
+    @Rpc(description = "Returns the unique subscriber ID (such as IMSI) " +
+            "for default subscription ID, or null if unavailable")
+    public String telephonyGetSubscriberId() {
+        return telephonyGetSubscriberIdForSubscription(
+                SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the unique subscriber ID (such as IMSI) " +
+                       "for specified subscription ID, or null if unavailable")
+    public String telephonyGetSubscriberIdForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getSubscriberId(subId);
+    }
+
+    @Rpc(description = "Retrieves the alphabetic id associated with the" +
+                       " voice mail number for default subscription ID.")
+    public String telephonyGetVoiceMailAlphaTag() {
+        return telephonyGetVoiceMailAlphaTagForSubscription(
+                   SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+
+    @Rpc(description = "Retrieves the alphabetic id associated with the " +
+                       "voice mail number for specified subscription ID.")
+    public String telephonyGetVoiceMailAlphaTagForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getVoiceMailAlphaTag(subId);
+    }
+
+    @Rpc(description = "Returns the voice mail number " +
+                       "for default subscription ID; null if unavailable.")
+    public String telephonyGetVoiceMailNumber() {
+        return telephonyGetVoiceMailNumberForSubscription(
+                   SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the voice mail number " +
+                        "for specified subscription ID; null if unavailable.")
+    public String telephonyGetVoiceMailNumberForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getVoiceMailNumber(subId);
+    }
+
+    @Rpc(description = "Get voice message count for specified subscription ID.")
+    public Integer telephonyGetVoiceMailCountForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getVoiceMessageCount(subId);
+    }
+
+    @Rpc(description = "Get voice message count for default subscription ID.")
+    public Integer telephonyGetVoiceMailCount() {
+        return mTelephonyManager.getVoiceMessageCount();
+    }
+
+    @Rpc(description = "Returns true if the device is in  roaming state" +
+                       "for default subscription ID")
+    public Boolean telephonyCheckNetworkRoaming() {
+        return telephonyCheckNetworkRoamingForSubscription(
+                             SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns true if the device is in roaming state " +
+                       "for specified subscription ID")
+    public Boolean telephonyCheckNetworkRoamingForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.isNetworkRoaming(subId);
+    }
+
+    @Rpc(description = "Returns the unique device ID such as MEID or IMEI " +
+                       "for deault sim slot ID, null if unavailable")
+    public String telephonyGetDeviceId() {
+        return telephonyGetDeviceIdForSlotId(mTelephonyManager.getDefaultSim());
+    }
+
+    @Rpc(description = "Returns the unique device ID such as MEID or IMEI for" +
+                       " specified slot ID, null if unavailable")
+    public String telephonyGetDeviceIdForSlotId(
+                  @RpcParameter(name = "slotId")
+                  Integer slotId){
+        return mTelephonyManager.getDeviceId(slotId);
+    }
+
+    @Rpc(description = "Returns the modem sw version, such as IMEI-SV;" +
+                       " null if unavailable")
+    public String telephonyGetDeviceSoftwareVersion() {
+        return mTelephonyManager.getDeviceSoftwareVersion();
+    }
+
+    @Rpc(description = "Returns phone # string \"line 1\", such as MSISDN " +
+                       "for default subscription ID; null if unavailable")
+    public String telephonyGetLine1Number() {
+        return mTelephonyManager.getLine1Number();
+    }
+
+    @Rpc(description = "Returns phone # string \"line 1\", such as MSISDN " +
+                       "for specified subscription ID; null if unavailable")
+    public String telephonyGetLine1NumberForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getLine1Number(subId);
+    }
+
+    @Rpc(description = "Returns the Alpha Tag for the default subscription " +
+                       "ID; null if unavailable")
+    public String telephonyGetLine1AlphaTag() {
+        return mTelephonyManager.getLine1AlphaTag();
+    }
+
+    @Rpc(description = "Returns the Alpha Tag for the specified subscription " +
+                       "ID; null if unavailable")
+    public String telephonyGetLine1AlphaTagForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getLine1AlphaTag(subId);
+    }
+
+    @Rpc(description = "Set the Line1-number (phone number) and Alpha Tag" +
+                       "for the default subscription")
+    public Boolean telephonySetLine1Number(
+                @RpcParameter(name = "number") String number,
+                @RpcOptional
+                @RpcParameter(name = "alphaTag") String alphaTag) {
+        return mTelephonyManager.setLine1NumberForDisplay(alphaTag, number);
+    }
+
+    @Rpc(description = "Set the Line1-number (phone number) and Alpha Tag" +
+                       "for the specified subscription")
+    public Boolean telephonySetLine1NumberForSubscription(
+                @RpcParameter(name = "subId") Integer subId,
+                @RpcParameter(name = "number") String number,
+                @RpcOptional
+                @RpcParameter(name = "alphaTag") String alphaTag) {
+        return mTelephonyManager.setLine1NumberForDisplay(subId, alphaTag, number);
+    }
+
+    @Rpc(description = "Returns the neighboring cell information of the device.")
+    public List<NeighboringCellInfo> telephonyGetNeighboringCellInfo() {
+        return mTelephonyManager.getNeighboringCellInfo();
+    }
+
+    @Rpc(description =  "Sets the minimum reporting interval for CellInfo" +
+                        "0-as quickly as possible, 0x7FFFFFF-off")
+    public void telephonySetCellInfoListRate(
+                @RpcParameter(name = "rate") Integer rate
+            ) {
+        mTelephonyManager.setCellInfoListRate(rate);
+    }
+
+    @Rpc(description = "Returns all observed cell information from all radios"+
+                       "on the device including the primary and neighboring cells")
+    public List<CellInfo> telephonyGetAllCellInfo() {
+        return mTelephonyManager.getAllCellInfo();
+    }
+
+    @Rpc(description = "Returns True if cellular data is enabled for" +
+                       "default data subscription ID.")
+    public Boolean telephonyIsDataEnabled() {
+        return telephonyIsDataEnabledForSubscription(
+                   SubscriptionManager.getDefaultDataSubscriptionId());
+    }
+
+    @Rpc(description = "Returns True if data connection is enabled.")
+    public Boolean telephonyIsDataEnabledForSubscription(
+                   @RpcParameter(name = "subId") Integer subId) {
+        return mTelephonyManager.getDataEnabled(subId);
+    }
+
+    @Rpc(description = "Toggles data connection on /off for" +
+                       " default data subscription ID.")
+    public void telephonyToggleDataConnection(
+                @RpcParameter(name = "enabled")
+                @RpcOptional Boolean enabled) {
+        telephonyToggleDataConnectionForSubscription(
+                         SubscriptionManager.getDefaultDataSubscriptionId(), enabled);
+    }
+
+    @Rpc(description = "Toggles data connection on/off for" +
+                       " specified subscription ID")
+    public void telephonyToggleDataConnectionForSubscription(
+                @RpcParameter(name = "subId") Integer subId,
+                @RpcParameter(name = "enabled")
+                @RpcOptional Boolean enabled) {
+        if (enabled == null) {
+            enabled = !telephonyIsDataEnabledForSubscription(subId);
+        }
+        mTelephonyManager.setDataEnabled(subId, enabled);
+    }
+
+    @Rpc(description = "Sets an APN and make that as preferred APN.")
+    public void telephonySetAPN(@RpcParameter(name = "name") final String name,
+                       @RpcParameter(name = "apn") final String apn,
+                       @RpcParameter(name = "type") @RpcOptional @RpcDefault("")
+                       final String type,
+                       @RpcParameter(name = "subId") @RpcOptional Integer subId) {
+        //TODO: b/26273471 Need to find out how to set APN for specific subId
+        Uri uri;
+        Cursor cursor;
+
+        String mcc = "";
+        String mnc = "";
+
+        String numeric = SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC);
+        // MCC is first 3 chars and then in 2 - 3 chars of MNC
+        if (numeric != null && numeric.length() > 4) {
+            // Country code
+            mcc = numeric.substring(0, 3);
+            // Network code
+            mnc = numeric.substring(3);
+        }
+
+        uri = mService.getContentResolver().insert(
+                Telephony.Carriers.CONTENT_URI, new ContentValues());
+        if (uri == null) {
+            Log.w("Failed to insert new provider into " + Telephony.Carriers.CONTENT_URI);
+            return;
+        }
+
+        cursor = mService.getContentResolver().query(uri, sProjection, null, null, null);
+        cursor.moveToFirst();
+
+        ContentValues values = new ContentValues();
+
+        values.put(Telephony.Carriers.NAME, name);
+        values.put(Telephony.Carriers.APN, apn);
+        values.put(Telephony.Carriers.PROXY, "");
+        values.put(Telephony.Carriers.PORT, "");
+        values.put(Telephony.Carriers.MMSPROXY, "");
+        values.put(Telephony.Carriers.MMSPORT, "");
+        values.put(Telephony.Carriers.USER, "");
+        values.put(Telephony.Carriers.SERVER, "");
+        values.put(Telephony.Carriers.PASSWORD, "");
+        values.put(Telephony.Carriers.MMSC, "");
+        values.put(Telephony.Carriers.TYPE, type);
+        values.put(Telephony.Carriers.MCC, mcc);
+        values.put(Telephony.Carriers.MNC, mnc);
+        values.put(Telephony.Carriers.NUMERIC, mcc + mnc);
+
+        int ret = mService.getContentResolver().update(uri, values, null, null);
+        Log.d("after update " + ret);
+        cursor.close();
+
+        // Make this APN as the preferred
+        String where = "name=\"" + name + "\"";
+
+        Cursor c = mService.getContentResolver().query(
+                Telephony.Carriers.CONTENT_URI,
+                new String[] {
+                        "_id", "name", "apn", "type"
+                }, where, null,
+                Telephony.Carriers.DEFAULT_SORT_ORDER);
+        if (c != null) {
+            c.moveToFirst();
+            String key = c.getString(0);
+            final String PREFERRED_APN_URI = "content://telephony/carriers/preferapn";
+            ContentResolver resolver = mService.getContentResolver();
+            ContentValues prefAPN = new ContentValues();
+            prefAPN.put("apn_id", key);
+            resolver.update(Uri.parse(PREFERRED_APN_URI), prefAPN, null, null);
+        }
+        c.close();
+    }
+
+    @Rpc(description = "Returns the number of APNs defined")
+    public int telephonyGetNumberOfAPNs(
+               @RpcParameter(name = "subId")
+               @RpcOptional Integer subId) {
+        //TODO: b/26273471 Need to find out how to get Number of APNs for specific subId
+        int result = 0;
+        String where = "numeric=\"" + android.os.SystemProperties.get(
+                        TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, "") + "\"";
+
+        Cursor cursor = mService.getContentResolver().query(
+                Telephony.Carriers.CONTENT_URI,
+                new String[] {"_id", "name", "apn", "type"}, where, null,
+                Telephony.Carriers.DEFAULT_SORT_ORDER);
+
+        if (cursor != null) {
+            result = cursor.getCount();
+        }
+        cursor.close();
+        return result;
+    }
+
+    @Rpc(description = "Returns the currently selected APN name")
+    public String telephonyGetSelectedAPN(
+                  @RpcParameter(name = "subId")
+                  @RpcOptional Integer subId) {
+        //TODO: b/26273471 Need to find out how to get selected APN for specific subId
+        String key = null;
+        int ID_INDEX = 0;
+        final String PREFERRED_APN_URI = "content://telephony/carriers/preferapn";
+
+        Cursor cursor = mService.getContentResolver().query(Uri.parse(PREFERRED_APN_URI),
+                new String[] {"name"}, null, null, Telephony.Carriers.DEFAULT_SORT_ORDER);
+
+        if (cursor.getCount() > 0) {
+            cursor.moveToFirst();
+            key = cursor.getString(ID_INDEX);
+        }
+        cursor.close();
+        return key;
+    }
+
+    @Rpc(description = "Returns the current data connection state")
+    public String telephonyGetDataConnectionState() {
+        return TelephonyUtils.getDataConnectionStateString(
+            mTelephonyManager.getDataState());
+    }
+
+    @Rpc(description = "Enables or Disables Video Calling()")
+    public void telephonyEnableVideoCalling(boolean enable) {
+        mTelephonyManager.enableVideoCalling(enable);
+    }
+
+    @Rpc(description = "Returns a boolean of whether or not " +
+            "video calling setting is enabled by the user")
+    public Boolean telephonyIsVideoCallingEnabled() {
+        return mTelephonyManager.isVideoCallingEnabled();
+    }
+
+    @Rpc(description = "Returns a boolean of whether video calling is available for use")
+    public Boolean telephonyIsVideoCallingAvailable() {
+        return mTelephonyManager.isVideoTelephonyAvailable();
+    }
+
+    @Rpc(description = "Returns a boolean of whether or not the device is ims registered")
+    public Boolean telephonyIsImsRegistered() {
+        return mTelephonyManager.isImsRegistered();
+    }
+
+    @Rpc(description = "Returns a boolean of whether or not volte calling is available for use")
+    public Boolean telephonyIsVolteAvailable() {
+        return mTelephonyManager.isVolteAvailable();
+    }
+
+    @Rpc(description = "Returns a boolean of whether or not wifi calling is available for use")
+    public Boolean telephonyIsWifiCallingAvailable() {
+        return mTelephonyManager.isWifiCallingAvailable();
+    }
+
+    @Rpc(description = "Returns the service state for default subscription ID")
+    public String telephonyGetServiceState() {
+        //TODO: b/26273807 need to have framework API to get service state.
+        return telephonyGetServiceStateForSubscription(
+                                 SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the service state for specified subscription ID")
+    public String telephonyGetServiceStateForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        //TODO: b/26273807 need to have framework API to get service state.
+        return null;
+    }
+
+    @Rpc(description = "Returns the call state for default subscription ID")
+    public String telephonyGetCallState() {
+        return telephonyGetCallStateForSubscription(
+                               SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns the call state for specified subscription ID")
+    public String telephonyGetCallStateForSubscription(
+                  @RpcParameter(name = "subId") Integer subId) {
+        return TelephonyUtils.getTelephonyCallStateString(
+            mTelephonyManager.getCallState(subId));
+    }
+
+    @Rpc(description = "Returns current signal strength for default subscription ID.")
+    public SignalStrength telephonyGetSignalStrength() {
+        return telephonyGetSignalStrengthForSubscription(
+                               SubscriptionManager.getDefaultSubscriptionId());
+    }
+
+    @Rpc(description = "Returns current signal strength for specified subscription ID.")
+    public SignalStrength telephonyGetSignalStrengthForSubscription(
+                    @RpcParameter(name = "subId") Integer subId) {
+        return StateChangeListeners.get(subId).mSignalStrengthChangeListener.mSignalStrengths;
+    }
+
+    @Rpc(description = "Returns the sim count.")
+    public int telephonyGetSimCount() {
+        return mTelephonyManager.getSimCount();
+    }
+
+    private static class StateChangeListener {
+        private ServiceStateChangeListener mServiceStateChangeListener;
+        private SignalStrengthChangeListener mSignalStrengthChangeListener;
+        private CallStateChangeListener mCallStateChangeListener;
+        private CellInfoChangeListener mCellInfoChangeListener;
+        private DataConnectionStateChangeListener
+                           mDataConnectionStateChangeListener;
+        private DataConnectionRealTimeInfoChangeListener
+                           mDataConnectionRTInfoChangeListener;
+        private VoiceMailStateChangeListener
+                           mVoiceMailStateChangeListener;
+    }
+
+    @Override
+    public void shutdown() {
+        for (int i = 0; i < mSubInfos.size(); i++) {
+           int subId = mSubInfos.get(i).getSubscriptionId();
+           telephonyStopTrackingCallStateChangeForSubscription(subId);
+           telephonyStopTrackingDataConnectionRTInfoChangeForSubscription(subId);
+           telephonyStopTrackingServiceStateChangeForSubscription(subId);
+           telephonyStopTrackingSignalStrengthChangeForSubscription(subId);
+           telephonyStopTrackingDataConnectionStateChangeForSubscription(subId);
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyStateListeners.java b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyStateListeners.java
new file mode 100644
index 0000000..cb9db74
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyStateListeners.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.telephony.TelephonyEvents;
+import android.os.Bundle;
+import android.telephony.CellInfo;
+import android.telephony.DataConnectionRealTimeInfo;
+import android.telephony.PhoneStateListener;
+import android.telephony.PreciseCallState;
+import android.telephony.ServiceState;
+import android.telephony.SignalStrength;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.telephony.VoLteServiceState;
+
+import java.util.List;
+
+/**
+ * Store all subclasses of PhoneStateListener here.
+ */
+public class TelephonyStateListeners {
+
+    public static class CallStateChangeListener extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+        public static final int sListeningStates = PhoneStateListener.LISTEN_CALL_STATE |
+                                                   PhoneStateListener.LISTEN_PRECISE_CALL_STATE;
+
+        public boolean listenForeground = true;
+        public boolean listenRinging = false;
+        public boolean listenBackground = false;
+        public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
+
+        public CallStateChangeListener(EventFacade ef) {
+            super();
+            mEventFacade = ef;
+            subscriptionId = SubscriptionManager.getDefaultVoiceSubscriptionId();
+        }
+
+        public CallStateChangeListener(EventFacade ef, int subId) {
+            super(subId);
+            mEventFacade = ef;
+            subscriptionId = subId;
+        }
+
+        @Override
+        public void onCallStateChanged(int state, String incomingNumber) {
+            mEventFacade.postEvent(TelephonyConstants.EventCallStateChanged,
+                new TelephonyEvents.CallStateEvent(
+                    state, incomingNumber, subscriptionId));
+        }
+
+        @Override
+        public void onPreciseCallStateChanged(PreciseCallState callState) {
+            int foregroundState = callState.getForegroundCallState();
+            int ringingState = callState.getRingingCallState();
+            int backgroundState = callState.getBackgroundCallState();
+            if (listenForeground &&
+                foregroundState != PreciseCallState.PRECISE_CALL_STATE_NOT_VALID) {
+                processCallState(foregroundState,
+                        TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND,
+                        callState);
+            }
+            if (listenRinging &&
+                ringingState != PreciseCallState.PRECISE_CALL_STATE_NOT_VALID) {
+                processCallState(ringingState,
+                        TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING,
+                        callState);
+            }
+            if (listenBackground &&
+                backgroundState != PreciseCallState.PRECISE_CALL_STATE_NOT_VALID) {
+                processCallState(backgroundState,
+                        TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND,
+                        callState);
+            }
+        }
+
+        private void processCallState(
+            int newState, String which, PreciseCallState callState) {
+            mEventFacade.postEvent(TelephonyConstants.EventPreciseStateChanged,
+                new TelephonyEvents.PreciseCallStateEvent(
+                    newState, which, callState, subscriptionId));
+        }
+    }
+
+    public static class DataConnectionRealTimeInfoChangeListener extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+        public static final int sListeningStates =
+                PhoneStateListener.LISTEN_DATA_CONNECTION_REAL_TIME_INFO;
+        public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
+
+        public DataConnectionRealTimeInfoChangeListener(EventFacade ef) {
+            super();
+            mEventFacade = ef;
+            subscriptionId = SubscriptionManager.getDefaultDataSubscriptionId();
+        }
+
+        public DataConnectionRealTimeInfoChangeListener(EventFacade ef, int subId) {
+            super(subId);
+            mEventFacade = ef;
+            subscriptionId = subId;
+        }
+
+        @Override
+        public void onDataConnectionRealTimeInfoChanged(
+            DataConnectionRealTimeInfo dcRtInfo) {
+            mEventFacade.postEvent(
+                TelephonyConstants.EventDataConnectionRealTimeInfoChanged,
+                new TelephonyEvents.DataConnectionRealTimeInfoEvent(
+                    dcRtInfo, subscriptionId));
+        }
+    }
+
+    public static class DataConnectionStateChangeListener extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+        private final TelephonyManager mTelephonyManager;
+        public static final int sListeningStates =
+                PhoneStateListener.LISTEN_DATA_CONNECTION_STATE;
+        public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
+
+        public DataConnectionStateChangeListener(EventFacade ef, TelephonyManager tm) {
+            super();
+            mEventFacade = ef;
+            mTelephonyManager = tm;
+            subscriptionId = SubscriptionManager.getDefaultDataSubscriptionId();
+        }
+
+        public DataConnectionStateChangeListener(EventFacade ef, TelephonyManager tm, int subId) {
+            super(subId);
+            mEventFacade = ef;
+            mTelephonyManager = tm;
+            subscriptionId = subId;
+        }
+
+        @Override
+        public void onDataConnectionStateChanged(int state) {
+            mEventFacade.postEvent(
+                TelephonyConstants.EventDataConnectionStateChanged,
+                new TelephonyEvents.DataConnectionStateEvent(state,
+                    TelephonyUtils.getNetworkTypeString(
+                                 mTelephonyManager.getDataNetworkType()),
+                    subscriptionId));
+        }
+    }
+
+    public static class ServiceStateChangeListener extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+        public static final int sListeningStates = PhoneStateListener.LISTEN_SERVICE_STATE;
+        public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
+
+        public ServiceStateChangeListener(EventFacade ef) {
+            super();
+            mEventFacade = ef;
+            subscriptionId = SubscriptionManager.getDefaultDataSubscriptionId();
+        }
+
+        public ServiceStateChangeListener(EventFacade ef, int subId) {
+            super(subId);
+            mEventFacade = ef;
+            subscriptionId = subId;
+        }
+
+        @Override
+        public void onServiceStateChanged(ServiceState serviceState) {
+            mEventFacade.postEvent(TelephonyConstants.EventServiceStateChanged,
+                new TelephonyEvents.ServiceStateEvent(
+                    serviceState, subscriptionId));
+        }
+
+    }
+
+    public static class CellInfoChangeListener
+            extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+
+        public CellInfoChangeListener(EventFacade ef) {
+            super();
+            mEventFacade = ef;
+        }
+
+        public CellInfoChangeListener(EventFacade ef, int subId) {
+            super(subId);
+            mEventFacade = ef;
+        }
+
+        @Override
+        public void onCellInfoChanged(List<CellInfo> cellInfo) {
+            mEventFacade.postEvent(
+                TelephonyConstants.EventCellInfoChanged, cellInfo);
+        }
+    }
+
+    public static class VolteServiceStateChangeListener
+            extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+
+        public VolteServiceStateChangeListener(EventFacade ef) {
+            super();
+            mEventFacade = ef;
+        }
+
+        public VolteServiceStateChangeListener(EventFacade ef, int subId) {
+            super(subId);
+            mEventFacade = ef;
+        }
+
+        @Override
+        public void onVoLteServiceStateChanged(VoLteServiceState volteInfo) {
+            mEventFacade.postEvent(
+                    TelephonyConstants.EventVolteServiceStateChanged,
+                    volteInfo);
+        }
+    }
+
+    public static class VoiceMailStateChangeListener extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+
+        public static final int sListeningStates =
+                PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR;
+
+        public VoiceMailStateChangeListener(EventFacade ef) {
+            super();
+            mEventFacade = ef;
+        }
+
+        public VoiceMailStateChangeListener(EventFacade ef, int subId) {
+            super(subId);
+            mEventFacade = ef;
+        }
+
+        @Override
+        public void onMessageWaitingIndicatorChanged(boolean messageWaitingIndicator) {
+            mEventFacade.postEvent(
+                    TelephonyConstants.EventMessageWaitingIndicatorChanged,
+                    new TelephonyEvents.MessageWaitingIndicatorEvent(
+                        messageWaitingIndicator));
+        }
+    }
+
+
+    public static class SignalStrengthChangeListener extends PhoneStateListener {
+
+        private final EventFacade mEventFacade;
+        public SignalStrength mSignalStrengths;
+        public static final int sListeningStates = PhoneStateListener.LISTEN_SIGNAL_STRENGTHS;
+        public SignalStrengthChangeListener(EventFacade ef) {
+            super();
+            mEventFacade = ef;
+        }
+
+        public SignalStrengthChangeListener(EventFacade ef, int subId) {
+            super(subId);
+            mEventFacade = ef;
+        }
+
+        @Override
+        public void onSignalStrengthsChanged(SignalStrength signalStrength) {
+            mSignalStrengths = signalStrength;
+            mEventFacade.postEvent(
+                TelephonyConstants.EventSignalStrengthChanged, signalStrength);
+        }
+    }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyUtils.java b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyUtils.java
new file mode 100644
index 0000000..09e161f
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyUtils.java
@@ -0,0 +1,371 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.telephony;
+import com.android.ims.ImsConfig;
+import com.android.internal.telephony.RILConstants;
+import com.googlecode.android_scripting.Log;
+import android.telecom.TelecomManager;
+import android.telephony.DataConnectionRealTimeInfo;
+import android.telephony.PreciseCallState;
+import android.telephony.ServiceState;
+import android.telephony.TelephonyManager;
+import android.telephony.VoLteServiceState;
+
+/**
+ * Telephony utility functions
+ */
+public class TelephonyUtils {
+
+    public static String getWfcModeString(int mode) {
+       switch(mode) {
+           case ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED:
+               return TelephonyConstants.WFC_MODE_WIFI_PREFERRED;
+           case ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED:
+               return TelephonyConstants.WFC_MODE_CELLULAR_PREFERRED;
+           case ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY:
+               return TelephonyConstants.WFC_MODE_WIFI_ONLY;
+       }
+        Log.d("getWfcModeStringfromInt error. int: " + mode);
+        return TelephonyConstants.WFC_MODE_UNKNOWN;
+    }
+
+    public static String getTtyModeString(int mode) {
+        switch (mode) {
+            case TelecomManager.TTY_MODE_FULL:
+                return TelephonyConstants.TTY_MODE_FULL;
+            case TelecomManager.TTY_MODE_HCO:
+                return TelephonyConstants.TTY_MODE_HCO;
+            case TelecomManager.TTY_MODE_OFF:
+                return TelephonyConstants.TTY_MODE_OFF;
+            case TelecomManager.TTY_MODE_VCO:
+                return TelephonyConstants.TTY_MODE_VCO;
+        }
+        Log.d("getTtyModeString error. int: " + mode);
+        return null;
+    }
+
+    public static String getPhoneTypeString(int type) {
+        switch (type) {
+            case TelephonyManager.PHONE_TYPE_GSM:
+                return TelephonyConstants.PHONE_TYPE_GSM;
+            case TelephonyManager.PHONE_TYPE_NONE:
+                return TelephonyConstants.PHONE_TYPE_NONE;
+            case TelephonyManager.PHONE_TYPE_CDMA:
+                return TelephonyConstants.PHONE_TYPE_CDMA;
+            case TelephonyManager.PHONE_TYPE_SIP:
+                return TelephonyConstants.PHONE_TYPE_SIP;
+        }
+        Log.d("getPhoneTypeString error. int: " + type);
+        return null;
+    }
+
+    public static String getSimStateString(int state) {
+        switch (state) {
+            case TelephonyManager.SIM_STATE_UNKNOWN:
+                return TelephonyConstants.SIM_STATE_UNKNOWN;
+            case TelephonyManager.SIM_STATE_ABSENT:
+                return TelephonyConstants.SIM_STATE_ABSENT;
+            case TelephonyManager.SIM_STATE_PIN_REQUIRED:
+                return TelephonyConstants.SIM_STATE_PIN_REQUIRED;
+            case TelephonyManager.SIM_STATE_PUK_REQUIRED:
+                return TelephonyConstants.SIM_STATE_PUK_REQUIRED;
+            case TelephonyManager.SIM_STATE_NETWORK_LOCKED:
+                return TelephonyConstants.SIM_STATE_NETWORK_LOCKED;
+            case TelephonyManager.SIM_STATE_READY:
+                return TelephonyConstants.SIM_STATE_READY;
+            case TelephonyManager.SIM_STATE_NOT_READY:
+                return TelephonyConstants.SIM_STATE_NOT_READY;
+            case TelephonyManager.SIM_STATE_PERM_DISABLED:
+                return TelephonyConstants.SIM_STATE_PERM_DISABLED;
+            case TelephonyManager.SIM_STATE_CARD_IO_ERROR:
+                return TelephonyConstants.SIM_STATE_CARD_IO_ERROR;
+        }
+        Log.d("getSimStateString error. int: " + state);
+        return TelephonyConstants.SIM_STATE_UNKNOWN;
+    }
+
+    public static String formatIncomingNumber(String incomingNumber) {
+        String mIncomingNumber = null;
+        int len = 0;
+        if (incomingNumber != null) {
+            len = incomingNumber.length();
+        }
+        if (len > 0) {
+            /**
+             * Currently this incomingNumber modification is specific for
+             * US numbers.
+             */
+            if ((12 == len) && ('+' == incomingNumber.charAt(0))) {
+                mIncomingNumber = incomingNumber.substring(1);
+            } else if (10 == len) {
+                mIncomingNumber = '1' + incomingNumber;
+            } else {
+                mIncomingNumber = incomingNumber;
+            }
+        }
+        return mIncomingNumber;
+    }
+
+    public static String getTelephonyCallStateString(int callState) {
+        switch (callState) {
+            case TelephonyManager.CALL_STATE_IDLE:
+                return TelephonyConstants.TELEPHONY_STATE_IDLE;
+            case TelephonyManager.CALL_STATE_OFFHOOK:
+                return TelephonyConstants.TELEPHONY_STATE_OFFHOOK;
+            case TelephonyManager.CALL_STATE_RINGING:
+                return TelephonyConstants.TELEPHONY_STATE_RINGING;
+        }
+        Log.d("getTelephonyCallStateString error. int: " + callState);
+        return TelephonyConstants.TELEPHONY_STATE_UNKNOWN;
+    }
+
+    public static String getPreciseCallStateString(int state) {
+        switch (state) {
+            case PreciseCallState.PRECISE_CALL_STATE_ACTIVE:
+                return TelephonyConstants.PRECISE_CALL_STATE_ACTIVE;
+            case PreciseCallState.PRECISE_CALL_STATE_HOLDING:
+                return TelephonyConstants.PRECISE_CALL_STATE_HOLDING;
+            case PreciseCallState.PRECISE_CALL_STATE_DIALING:
+                return TelephonyConstants.PRECISE_CALL_STATE_DIALING;
+            case PreciseCallState.PRECISE_CALL_STATE_ALERTING:
+                return TelephonyConstants.PRECISE_CALL_STATE_ALERTING;
+            case PreciseCallState.PRECISE_CALL_STATE_INCOMING:
+                return TelephonyConstants.PRECISE_CALL_STATE_INCOMING;
+            case PreciseCallState.PRECISE_CALL_STATE_WAITING:
+                return TelephonyConstants.PRECISE_CALL_STATE_WAITING;
+            case PreciseCallState.PRECISE_CALL_STATE_DISCONNECTED:
+                return TelephonyConstants.PRECISE_CALL_STATE_DISCONNECTED;
+            case PreciseCallState.PRECISE_CALL_STATE_DISCONNECTING:
+                return TelephonyConstants.PRECISE_CALL_STATE_DISCONNECTING;
+            case PreciseCallState.PRECISE_CALL_STATE_IDLE:
+                return TelephonyConstants.PRECISE_CALL_STATE_IDLE;
+            case PreciseCallState.PRECISE_CALL_STATE_NOT_VALID:
+                return TelephonyConstants.PRECISE_CALL_STATE_INVALID;
+        }
+        Log.d("getPreciseCallStateString error. int: " + state);
+        return TelephonyConstants.PRECISE_CALL_STATE_UNKNOWN;
+    }
+
+    public static String getDcPowerStateString(int state) {
+        if (state == DataConnectionRealTimeInfo.DC_POWER_STATE_LOW) {
+            return TelephonyConstants.DC_POWER_STATE_LOW;
+        } else if (state == DataConnectionRealTimeInfo.DC_POWER_STATE_HIGH) {
+            return TelephonyConstants.DC_POWER_STATE_HIGH;
+        } else if (state == DataConnectionRealTimeInfo.DC_POWER_STATE_MEDIUM) {
+            return TelephonyConstants.DC_POWER_STATE_MEDIUM;
+        } else {
+            return TelephonyConstants.DC_POWER_STATE_UNKNOWN;
+        }
+    }
+
+    public static String getDataConnectionStateString(int state) {
+        switch (state) {
+            case TelephonyManager.DATA_DISCONNECTED:
+                return TelephonyConstants.DATA_STATE_DISCONNECTED;
+            case TelephonyManager.DATA_CONNECTING:
+                return TelephonyConstants.DATA_STATE_CONNECTING;
+            case TelephonyManager.DATA_CONNECTED:
+                return TelephonyConstants.DATA_STATE_CONNECTED;
+            case TelephonyManager.DATA_SUSPENDED:
+                return TelephonyConstants.DATA_STATE_SUSPENDED;
+            case TelephonyManager.DATA_UNKNOWN:
+                return TelephonyConstants.DATA_STATE_UNKNOWN;
+        }
+        Log.d("getDataConnectionStateString error. int: " + state);
+        return TelephonyConstants.DATA_STATE_UNKNOWN;
+    }
+
+    public static int getNetworkModeIntfromString(String networkMode) {
+        switch (networkMode) {
+            case TelephonyConstants.NETWORK_MODE_WCDMA_PREF:
+                return RILConstants.NETWORK_MODE_WCDMA_PREF;
+            case TelephonyConstants.NETWORK_MODE_GSM_ONLY:
+                return RILConstants.NETWORK_MODE_GSM_ONLY;
+            case TelephonyConstants.NETWORK_MODE_WCDMA_ONLY:
+                return RILConstants.NETWORK_MODE_WCDMA_ONLY;
+            case TelephonyConstants.NETWORK_MODE_GSM_UMTS:
+                return RILConstants.NETWORK_MODE_GSM_UMTS;
+            case TelephonyConstants.NETWORK_MODE_CDMA:
+                return RILConstants.NETWORK_MODE_CDMA;
+            case TelephonyConstants.NETWORK_MODE_CDMA_NO_EVDO:
+                return RILConstants.NETWORK_MODE_CDMA_NO_EVDO;
+            case TelephonyConstants.NETWORK_MODE_EVDO_NO_CDMA:
+                return RILConstants.NETWORK_MODE_EVDO_NO_CDMA;
+            case TelephonyConstants.NETWORK_MODE_GLOBAL:
+                return RILConstants.NETWORK_MODE_GLOBAL;
+            case TelephonyConstants.NETWORK_MODE_LTE_CDMA_EVDO:
+                return RILConstants.NETWORK_MODE_LTE_CDMA_EVDO;
+            case TelephonyConstants.NETWORK_MODE_LTE_GSM_WCDMA:
+                return RILConstants.NETWORK_MODE_LTE_GSM_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
+                return RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_LTE_ONLY:
+                return RILConstants.NETWORK_MODE_LTE_ONLY;
+            case TelephonyConstants.NETWORK_MODE_LTE_WCDMA:
+                return RILConstants.NETWORK_MODE_LTE_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_TDSCDMA_ONLY:
+                return RILConstants.NETWORK_MODE_TDSCDMA_ONLY;
+            case TelephonyConstants.NETWORK_MODE_TDSCDMA_WCDMA:
+                return RILConstants.NETWORK_MODE_TDSCDMA_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA:
+                return RILConstants.NETWORK_MODE_LTE_TDSCDMA;
+            case TelephonyConstants.NETWORK_MODE_TDSCDMA_GSM:
+                return RILConstants.NETWORK_MODE_TDSCDMA_GSM;
+            case TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_GSM:
+                return RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM;
+            case TelephonyConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA:
+                return RILConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA:
+                return RILConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA:
+                return RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
+                return RILConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA;
+            case TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
+                return RILConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA;
+        }
+        Log.d("getNetworkModeIntfromString error. String: " + networkMode);
+        return RILConstants.RIL_ERRNO_INVALID_RESPONSE;
+    }
+
+    public static String getNetworkModeStringfromInt(int networkMode) {
+        switch (networkMode) {
+            case RILConstants.NETWORK_MODE_WCDMA_PREF:
+                return TelephonyConstants.NETWORK_MODE_WCDMA_PREF;
+            case RILConstants.NETWORK_MODE_GSM_ONLY:
+                return TelephonyConstants.NETWORK_MODE_GSM_ONLY;
+            case RILConstants.NETWORK_MODE_WCDMA_ONLY:
+                return TelephonyConstants.NETWORK_MODE_WCDMA_ONLY;
+            case RILConstants.NETWORK_MODE_GSM_UMTS:
+                return TelephonyConstants.NETWORK_MODE_GSM_UMTS;
+            case RILConstants.NETWORK_MODE_CDMA:
+                return TelephonyConstants.NETWORK_MODE_CDMA;
+            case RILConstants.NETWORK_MODE_CDMA_NO_EVDO:
+                return TelephonyConstants.NETWORK_MODE_CDMA_NO_EVDO;
+            case RILConstants.NETWORK_MODE_EVDO_NO_CDMA:
+                return TelephonyConstants.NETWORK_MODE_EVDO_NO_CDMA;
+            case RILConstants.NETWORK_MODE_GLOBAL:
+                return TelephonyConstants.NETWORK_MODE_GLOBAL;
+            case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO:
+                return TelephonyConstants.NETWORK_MODE_LTE_CDMA_EVDO;
+            case RILConstants.NETWORK_MODE_LTE_GSM_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_LTE_GSM_WCDMA;
+            case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA;
+            case RILConstants.NETWORK_MODE_LTE_ONLY:
+                return TelephonyConstants.NETWORK_MODE_LTE_ONLY;
+            case RILConstants.NETWORK_MODE_LTE_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_LTE_WCDMA;
+            case RILConstants.NETWORK_MODE_TDSCDMA_ONLY:
+                return TelephonyConstants.NETWORK_MODE_TDSCDMA_ONLY;
+            case RILConstants.NETWORK_MODE_TDSCDMA_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_TDSCDMA_WCDMA;
+            case RILConstants.NETWORK_MODE_LTE_TDSCDMA:
+                return TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA;
+            case RILConstants.NETWORK_MODE_TDSCDMA_GSM:
+                return TelephonyConstants.NETWORK_MODE_TDSCDMA_GSM;
+            case RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM:
+                return TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_GSM;
+            case RILConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA;
+            case RILConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA;
+            case RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA;
+            case RILConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA;
+            case RILConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
+                return TelephonyConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA;
+        }
+        Log.d("getNetworkModeStringfromInt error. Int: " + networkMode);
+        return TelephonyConstants.NETWORK_MODE_INVALID;
+    }
+
+    public static String getNetworkTypeString(int type) {
+        switch(type) {
+            case TelephonyManager.NETWORK_TYPE_GPRS:
+                return TelephonyConstants.RAT_GPRS;
+            case TelephonyManager.NETWORK_TYPE_EDGE:
+                return TelephonyConstants.RAT_EDGE;
+            case TelephonyManager.NETWORK_TYPE_UMTS:
+                return TelephonyConstants.RAT_UMTS;
+            case TelephonyManager.NETWORK_TYPE_HSDPA:
+                return TelephonyConstants.RAT_HSDPA;
+            case TelephonyManager.NETWORK_TYPE_HSUPA:
+                return TelephonyConstants.RAT_HSUPA;
+            case TelephonyManager.NETWORK_TYPE_HSPA:
+                return TelephonyConstants.RAT_HSPA;
+            case TelephonyManager.NETWORK_TYPE_CDMA:
+                return TelephonyConstants.RAT_CDMA;
+            case TelephonyManager.NETWORK_TYPE_1xRTT:
+                return TelephonyConstants.RAT_1XRTT;
+            case TelephonyManager.NETWORK_TYPE_EVDO_0:
+                return TelephonyConstants.RAT_EVDO_0;
+            case TelephonyManager.NETWORK_TYPE_EVDO_A:
+                return TelephonyConstants.RAT_EVDO_A;
+            case TelephonyManager.NETWORK_TYPE_EVDO_B:
+                return TelephonyConstants.RAT_EVDO_B;
+            case TelephonyManager.NETWORK_TYPE_EHRPD:
+                return TelephonyConstants.RAT_EHRPD;
+            case TelephonyManager.NETWORK_TYPE_LTE:
+                return TelephonyConstants.RAT_LTE;
+            case TelephonyManager.NETWORK_TYPE_HSPAP:
+                return TelephonyConstants.RAT_HSPAP;
+            case TelephonyManager.NETWORK_TYPE_GSM:
+                return TelephonyConstants.RAT_GSM;
+            case TelephonyManager. NETWORK_TYPE_TD_SCDMA:
+                return TelephonyConstants.RAT_TD_SCDMA;
+            case TelephonyManager.NETWORK_TYPE_IWLAN:
+                return TelephonyConstants.RAT_IWLAN;
+            case TelephonyManager.NETWORK_TYPE_IDEN:
+                return TelephonyConstants.RAT_IDEN;
+        }
+        return TelephonyConstants.RAT_UNKNOWN;
+    }
+
+    public static String getNetworkStateString(int state) {
+        switch(state) {
+            case ServiceState.STATE_EMERGENCY_ONLY:
+                return TelephonyConstants.SERVICE_STATE_EMERGENCY_ONLY;
+            case ServiceState.STATE_IN_SERVICE:
+                return TelephonyConstants.SERVICE_STATE_IN_SERVICE;
+            case ServiceState.STATE_OUT_OF_SERVICE:
+                return TelephonyConstants.SERVICE_STATE_OUT_OF_SERVICE;
+            case ServiceState.STATE_POWER_OFF:
+                return TelephonyConstants.SERVICE_STATE_POWER_OFF;
+            default:
+                return TelephonyConstants.SERVICE_STATE_UNKNOWN;
+        }
+   }
+
+    public static String getSrvccStateString(int srvccState) {
+        switch (srvccState) {
+            case VoLteServiceState.HANDOVER_STARTED:
+                return TelephonyConstants.VOLTE_SERVICE_STATE_HANDOVER_STARTED;
+            case VoLteServiceState.HANDOVER_COMPLETED:
+                return TelephonyConstants.VOLTE_SERVICE_STATE_HANDOVER_COMPLETED;
+            case VoLteServiceState.HANDOVER_FAILED:
+                return TelephonyConstants.VOLTE_SERVICE_STATE_HANDOVER_FAILED;
+            case VoLteServiceState.HANDOVER_CANCELED:
+                return TelephonyConstants.VOLTE_SERVICE_STATE_HANDOVER_CANCELED;
+            default:
+                Log.e(String.format("getSrvccStateString():"
+                        + "unknown state %d", srvccState));
+                return TelephonyConstants.VOLTE_SERVICE_STATE_HANDOVER_UNKNOWN;
+        }
+    };
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/AlertDialogTask.java b/Common/src/com/googlecode/android_scripting/facade/ui/AlertDialogTask.java
new file mode 100644
index 0000000..2a1e48e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/AlertDialogTask.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.AlertDialog.Builder;
+import android.content.DialogInterface;
+import android.text.method.PasswordTransformationMethod;
+import android.widget.EditText;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+/**
+ * Wrapper class for alert dialog running in separate thread.
+ *
+ * @author MeanEYE.rcf (meaneye.rcf@gmail.com)
+ */
+class AlertDialogTask extends DialogTask {
+
+  private final String mTitle;
+  private final String mMessage;
+
+  private final List<String> mItems;
+  private final Set<Integer> mSelectedItems;
+  private final Map<String, Object> mResultMap;
+  private InputType mInputType;
+  private int mEditInputType = 0;
+
+  private String mPositiveButtonText;
+  private String mNegativeButtonText;
+  private String mNeutralButtonText;
+
+  private EditText mEditText;
+  private String mDefaultText;
+
+  private enum InputType {
+    DEFAULT, MENU, SINGLE_CHOICE, MULTI_CHOICE, PLAIN_TEXT, PASSWORD;
+  }
+
+  public AlertDialogTask(String title, String message) {
+    mTitle = title;
+    mMessage = message;
+    mInputType = InputType.DEFAULT;
+    mItems = new ArrayList<String>();
+    mSelectedItems = new TreeSet<Integer>();
+    mResultMap = new HashMap<String, Object>();
+  }
+
+  public void setPositiveButtonText(String text) {
+    mPositiveButtonText = text;
+  }
+
+  public void setNegativeButtonText(String text) {
+    mNegativeButtonText = text;
+  }
+
+  public void setNeutralButtonText(String text) {
+    mNeutralButtonText = text;
+  }
+
+  /**
+   * Set list items.
+   *
+   * @param items
+   */
+  public void setItems(JSONArray items) {
+    mItems.clear();
+    for (int i = 0; i < items.length(); i++) {
+      try {
+        mItems.add(items.getString(i));
+      } catch (JSONException e) {
+        throw new RuntimeException(e);
+      }
+    }
+    mInputType = InputType.MENU;
+  }
+
+  /**
+   * Set single choice items.
+   *
+   * @param items
+   *          a list of items as {@link String}s to display
+   * @param selected
+   *          the index of the item that is selected by default
+   */
+  public void setSingleChoiceItems(JSONArray items, int selected) {
+    setItems(items);
+    mSelectedItems.clear();
+    mSelectedItems.add(selected);
+    mInputType = InputType.SINGLE_CHOICE;
+  }
+
+  /**
+   * Set multi choice items.
+   *
+   * @param items
+   *          a list of items as {@link String}s to display
+   * @param selected
+   *          a list of indices for items that should be selected by default
+   * @throws JSONException
+   */
+  public void setMultiChoiceItems(JSONArray items, JSONArray selected) throws JSONException {
+    setItems(items);
+    mSelectedItems.clear();
+    if (selected != null) {
+      for (int i = 0; i < selected.length(); i++) {
+        mSelectedItems.add(selected.getInt(i));
+      }
+    }
+    mInputType = InputType.MULTI_CHOICE;
+  }
+
+  /**
+   * Returns the list of selected items.
+   */
+  public Set<Integer> getSelectedItems() {
+    return mSelectedItems;
+  }
+
+  public void setTextInput(String defaultText) {
+    mDefaultText = defaultText;
+    mInputType = InputType.PLAIN_TEXT;
+    setEditInputType("text");
+  }
+
+  public void setEditInputType(String editInputType) {
+    String[] list = editInputType.split("\\|");
+    Map<String, Integer> types = ViewInflater.getInputTypes();
+    mEditInputType = 0;
+    for (String flag : list) {
+      Integer v = types.get(flag.trim());
+      if (v != null) {
+        mEditInputType |= v;
+      }
+    }
+    if (mEditInputType == 0) {
+      mEditInputType = android.text.InputType.TYPE_CLASS_TEXT;
+    }
+  }
+
+  public void setPasswordInput() {
+    mInputType = InputType.PASSWORD;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+    if (mTitle != null) {
+      builder.setTitle(mTitle);
+    }
+    // Can't display both a message and items. We'll elect to show the items instead.
+    if (mMessage != null && mItems.isEmpty()) {
+      builder.setMessage(mMessage);
+    }
+    switch (mInputType) {
+    // Add single choice menu items to dialog.
+    case SINGLE_CHOICE:
+      builder.setSingleChoiceItems(getItemsAsCharSequenceArray(), mSelectedItems.iterator().next(),
+          new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int item) {
+              mSelectedItems.clear();
+              mSelectedItems.add(item);
+            }
+          });
+      break;
+    // Add multiple choice items to the dialog.
+    case MULTI_CHOICE:
+      boolean[] selectedItems = new boolean[mItems.size()];
+      for (int i : mSelectedItems) {
+        selectedItems[i] = true;
+      }
+      builder.setMultiChoiceItems(getItemsAsCharSequenceArray(), selectedItems,
+          new DialogInterface.OnMultiChoiceClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int item, boolean isChecked) {
+              if (isChecked) {
+                mSelectedItems.add(item);
+              } else {
+                mSelectedItems.remove(item);
+              }
+            }
+          });
+      break;
+    // Add standard, menu-like, items to dialog.
+    case MENU:
+      builder.setItems(getItemsAsCharSequenceArray(), new DialogInterface.OnClickListener() {
+        public void onClick(DialogInterface dialog, int item) {
+          Map<String, Integer> result = new HashMap<String, Integer>();
+          result.put("item", item);
+          dismissDialog();
+          setResult(result);
+        }
+      });
+      break;
+    case PLAIN_TEXT:
+      mEditText = new EditText(getActivity());
+      if (mDefaultText != null) {
+        mEditText.setText(mDefaultText);
+      }
+      mEditText.setInputType(mEditInputType);
+      builder.setView(mEditText);
+      break;
+    case PASSWORD:
+      mEditText = new EditText(getActivity());
+      mEditText.setInputType(android.text.InputType.TYPE_TEXT_VARIATION_PASSWORD);
+      mEditText.setTransformationMethod(new PasswordTransformationMethod());
+      builder.setView(mEditText);
+      break;
+    default:
+      // No input type specified.
+    }
+    configureButtons(builder, getActivity());
+    addOnCancelListener(builder, getActivity());
+    mDialog = builder.show();
+    mShowLatch.countDown();
+  }
+
+  private CharSequence[] getItemsAsCharSequenceArray() {
+    return mItems.toArray(new CharSequence[mItems.size()]);
+  }
+
+  private Builder addOnCancelListener(final AlertDialog.Builder builder, final Activity activity) {
+    return builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
+      @Override
+      public void onCancel(DialogInterface dialog) {
+        mResultMap.put("canceled", true);
+        setResult();
+      }
+    });
+  }
+
+  private void configureButtons(final AlertDialog.Builder builder, final Activity activity) {
+    DialogInterface.OnClickListener buttonListener = new DialogInterface.OnClickListener() {
+      @Override
+      public void onClick(DialogInterface dialog, int which) {
+        switch (which) {
+        case DialogInterface.BUTTON_POSITIVE:
+          mResultMap.put("which", "positive");
+          break;
+        case DialogInterface.BUTTON_NEGATIVE:
+          mResultMap.put("which", "negative");
+          break;
+        case DialogInterface.BUTTON_NEUTRAL:
+          mResultMap.put("which", "neutral");
+
+          break;
+        }
+        setResult();
+      }
+    };
+    if (mNegativeButtonText != null) {
+      builder.setNegativeButton(mNegativeButtonText, buttonListener);
+    }
+    if (mPositiveButtonText != null) {
+      builder.setPositiveButton(mPositiveButtonText, buttonListener);
+    }
+    if (mNeutralButtonText != null) {
+      builder.setNeutralButton(mNeutralButtonText, buttonListener);
+    }
+  }
+
+  private void setResult() {
+    dismissDialog();
+    if (mInputType == InputType.PLAIN_TEXT || mInputType == InputType.PASSWORD) {
+      mResultMap.put("value", mEditText.getText().toString());
+    }
+    setResult(mResultMap);
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/DatePickerDialogTask.java b/Common/src/com/googlecode/android_scripting/facade/ui/DatePickerDialogTask.java
new file mode 100644
index 0000000..e80bd25
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/DatePickerDialogTask.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.DatePickerDialog;
+import android.content.DialogInterface;
+import android.util.AndroidRuntimeException;
+import android.widget.DatePicker;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Wrapper class for date picker dialog running in separate thread.
+ *
+ * @author MeanEYE.rcf (meaneye.rcf@gmail.com)
+ */
+public class DatePickerDialogTask extends DialogTask {
+  public static int mYear;
+  public static int mMonth;
+  public static int mDay;
+
+  public DatePickerDialogTask(int year, int month, int day) {
+    mYear = year;
+    mMonth = month - 1;
+    mDay = day;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    mDialog = new DatePickerDialog(getActivity(), new DatePickerDialog.OnDateSetListener() {
+      @Override
+      public void onDateSet(DatePicker view, int year, int month, int day) {
+        JSONObject result = new JSONObject();
+        try {
+          result.put("which", "positive");
+          result.put("year", year);
+          result.put("month", month + 1);
+          result.put("day", day);
+          setResult(result);
+        } catch (JSONException e) {
+          throw new AndroidRuntimeException(e);
+        }
+      }
+    }, mYear, mMonth, mDay);
+    mDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+      @Override
+      public void onCancel(DialogInterface view) {
+        JSONObject result = new JSONObject();
+        try {
+          result.put("which", "neutral");
+          result.put("year", mYear);
+          result.put("month", mMonth + 1);
+          result.put("day", mDay);
+          setResult(result);
+        } catch (JSONException e) {
+          throw new AndroidRuntimeException(e);
+        }
+      }
+    });
+    mDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
+      @Override
+      public void onDismiss(DialogInterface dialog) {
+        JSONObject result = new JSONObject();
+        try {
+          result.put("which", "negative");
+          result.put("year", mYear);
+          result.put("month", mMonth + 1);
+          result.put("day", mDay);
+          setResult(result);
+        } catch (JSONException e) {
+          throw new AndroidRuntimeException(e);
+        }
+      }
+    });
+    mDialog.show();
+    mShowLatch.countDown();
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/DialogTask.java b/Common/src/com/googlecode/android_scripting/facade/ui/DialogTask.java
new file mode 100644
index 0000000..ba48fcb
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/DialogTask.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.Dialog;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+
+import java.util.concurrent.CountDownLatch;
+
+abstract class DialogTask extends FutureActivityTask<Object> {
+
+  protected Dialog mDialog;
+  private EventFacade mEventFacade;
+
+  public EventFacade getEventFacade() {
+    return mEventFacade;
+  }
+
+  public void setEventFacade(EventFacade mEventFacade) {
+    this.mEventFacade = mEventFacade;
+  }
+
+  @Override
+  protected void setResult(Object object) {
+    super.setResult(object);
+    EventFacade eventFacade = getEventFacade();
+    if (eventFacade != null) {
+      eventFacade.postEvent("dialog", object);
+    }
+  }
+
+  protected final CountDownLatch mShowLatch = new CountDownLatch(1);
+
+  /**
+   * Returns the wrapped {@link Dialog}.
+   */
+  public Dialog getDialog() {
+    return mDialog;
+  }
+
+  /**
+   * Dismiss the {@link Dialog} and close {@link Sl4aActivity}.
+   */
+  public void dismissDialog() {
+    if (mDialog != null) {
+      mDialog.dismiss();
+      finish();
+    }
+    mDialog = null;
+  }
+
+  /**
+   * Returns the {@link CountDownLatch} that is counted down when the dialog is shown.
+   */
+  public CountDownLatch getShowLatch() {
+    return mShowLatch;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/FullScreenTask.java b/Common/src/com/googlecode/android_scripting/facade/ui/FullScreenTask.java
new file mode 100644
index 0000000..a97d51d
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/FullScreenTask.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.R;
+import android.os.Handler;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+
+import java.io.StringReader;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+
+import org.json.JSONArray;
+import org.xmlpull.v1.XmlPullParser;
+
+public class FullScreenTask extends FutureActivityTask<Object> implements OnClickListener,
+    OnItemClickListener {
+  private EventFacade mEventFacade;
+  private UiFacade mUiFacade;
+  public View mView = null;
+  protected ViewInflater mInflater = new ViewInflater();
+  protected String mLayout;
+  protected final CountDownLatch mShowLatch = new CountDownLatch(1);
+  protected Handler mHandler = null;
+  private List<Integer> mOverrideKeys;
+  protected String mTitle;
+
+  public FullScreenTask(String layout, String title) {
+    super();
+    mLayout = layout;
+    if (title != null) {
+      mTitle = title;
+    } else {
+      mTitle = "SL4a";
+    }
+  }
+
+  @Override
+  public void onCreate() {
+    // super.onCreate();
+    if (mHandler == null) {
+      mHandler = new Handler();
+    }
+    mInflater.getErrors().clear();
+    try {
+      if (mView == null) {
+        StringReader sr = new StringReader(mLayout);
+        XmlPullParser xml = ViewInflater.getXml(sr);
+        mView = mInflater.inflate(getActivity(), xml);
+      }
+    } catch (Exception e) {
+      mInflater.getErrors().add(e.toString());
+      mView = defaultView();
+      mInflater.setIdList(R.id.class);
+    }
+    getActivity().setContentView(mView);
+    getActivity().setTitle(mTitle);
+    mInflater.setClickListener(mView, this, this);
+    mShowLatch.countDown();
+  }
+
+  @Override
+  public void onDestroy() {
+    mEventFacade.postEvent("screen", "destroy");
+    super.onDestroy();
+  }
+
+  /** default view in case of errors */
+  protected View defaultView() {
+    LinearLayout result = new LinearLayout(getActivity());
+    result.setOrientation(LinearLayout.VERTICAL);
+    TextView text = new TextView(getActivity());
+    text.setText("Sample Layout");
+    result.addView(text, LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+    Button b = new Button(getActivity());
+    b.setText("OK");
+    result.addView(b, LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+    return result;
+  }
+
+  public EventFacade getEventFacade() {
+    return mEventFacade;
+  }
+
+  public void setEventFacade(EventFacade eventFacade) {
+    mEventFacade = eventFacade;
+  }
+
+  public void setUiFacade(UiFacade uiFacade) {
+    mUiFacade = uiFacade;
+  }
+
+  public CountDownLatch getShowLatch() {
+    return mShowLatch;
+  }
+
+  public Map<String, Map<String, String>> getViewAsMap() {
+    return mInflater.getViewAsMap(mView);
+  }
+
+  private View getViewByName(String idName) {
+    View result = null;
+    int id = mInflater.getId(idName);
+    if (id != 0) {
+      result = mView.findViewById(id);
+    }
+    return result;
+  }
+
+  public Map<String, String> getViewDetail(String idName) {
+    Map<String, String> result = new HashMap<String, String>();
+    result.put("error", "id not found (" + idName + ")");
+    View v = getViewByName(idName);
+    if (v != null) {
+      result = mInflater.getViewInfo(v);
+    }
+    return result;
+  }
+
+  public String setViewProperty(String idName, String property, String value) {
+    View v = getViewByName(idName);
+    mInflater.getErrors().clear();
+    if (v != null) {
+      SetProperty p = new SetProperty(v, property, value);
+      mHandler.post(p);
+      try {
+        p.mLatch.await();
+      } catch (InterruptedException e) {
+        mInflater.getErrors().add(e.toString());
+      }
+    } else {
+      return "View " + idName + " not found.";
+    }
+    if (mInflater.getErrors().size() == 0) {
+      return "OK";
+    }
+    return mInflater.getErrors().get(0);
+  }
+
+  public String setList(String id, JSONArray items) {
+    View v = getViewByName(id);
+    mInflater.getErrors().clear();
+    if (v != null) {
+      SetList p = new SetList(v, items);
+      mHandler.post(p);
+      try {
+        p.mLatch.await();
+      } catch (InterruptedException e) {
+        mInflater.getErrors().add(e.toString());
+      }
+    } else {
+      return "View " + id + " not found.";
+    }
+    if (mInflater.getErrors().size() == 0) {
+      return "OK";
+    }
+    return mInflater.getErrors().get(0);
+  }
+
+  @Override
+  public void onClick(View view) {
+    mEventFacade.postEvent("click", mInflater.getViewInfo(view));
+  }
+
+  public void loadLayout(String layout) {
+    ViewInflater inflater = new ViewInflater();
+    View view;
+    StringReader sr = new StringReader(layout);
+    try {
+      XmlPullParser xml = ViewInflater.getXml(sr);
+      view = inflater.inflate(getActivity(), xml);
+      mView = view;
+      mInflater = inflater;
+      getActivity().setContentView(mView);
+      mInflater.setClickListener(mView, this, this);
+      mLayout = layout;
+      mView.invalidate();
+    } catch (Exception e) {
+      mInflater.getErrors().add(e.toString());
+    }
+  }
+
+  private class SetProperty implements Runnable {
+    View mView;
+    String mProperty;
+    String mValue;
+    CountDownLatch mLatch = new CountDownLatch(1);
+
+    SetProperty(View view, String property, String value) {
+      mView = view;
+      mProperty = property;
+      mValue = value;
+    }
+
+    @Override
+    public void run() {
+      // TODO Auto-generated method stub
+      mInflater.setProperty(mView, mProperty, mValue);
+      mView.invalidate();
+      mLatch.countDown();
+    }
+  }
+
+  private class SetList implements Runnable {
+    View mView;
+    JSONArray mItems;
+    CountDownLatch mLatch = new CountDownLatch(1);
+
+    SetList(View view, JSONArray items) {
+      mView = view;
+      mItems = items;
+      mLatch.countDown();
+    }
+
+    @Override
+    public void run() {
+      mInflater.setListAdapter(mView, mItems);
+      mView.invalidate();
+    }
+  }
+
+  private class SetLayout implements Runnable {
+    String mLayout;
+    CountDownLatch mLatch = new CountDownLatch(1);
+
+    SetLayout(String layout) {
+      mLayout = layout;
+    }
+
+    @Override
+    public void run() {
+      loadLayout(mLayout);
+      mLatch.countDown();
+    }
+  }
+
+  private class SetTitle implements Runnable {
+    String mSetTitle;
+    CountDownLatch mLatch = new CountDownLatch(1);
+
+    SetTitle(String title) {
+      mSetTitle = title;
+    }
+
+    @Override
+    public void run() {
+      mTitle = mSetTitle;
+      getActivity().setTitle(mSetTitle);
+      mLatch.countDown();
+    }
+  }
+
+  @Override
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    Map<String, String> data = new HashMap<String, String>();
+    data.put("key", String.valueOf(keyCode));
+    data.put("action", String.valueOf(event.getAction()));
+    mEventFacade.postEvent("key", data);
+    boolean overrideKey =
+        (keyCode == KeyEvent.KEYCODE_BACK)
+            || (mOverrideKeys == null ? false : mOverrideKeys.contains(keyCode));
+    return overrideKey;
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    return mUiFacade.onPrepareOptionsMenu(menu);
+  }
+
+  @Override
+  public void onItemClick(AdapterView<?> aview, View aitem, int position, long id) {
+    Map<String, String> data = mInflater.getViewInfo(aview);
+    data.put("position", String.valueOf(position));
+    mEventFacade.postEvent("itemclick", data);
+  }
+
+  public void setOverrideKeys(List<Integer> overrideKeys) {
+    mOverrideKeys = overrideKeys;
+  }
+
+  // Used to hot-switch screens.
+  public void setLayout(String layout) {
+    SetLayout p = new SetLayout(layout);
+    mHandler.post(p);
+    try {
+      p.mLatch.await();
+    } catch (InterruptedException e) {
+      mInflater.getErrors().add(e.toString());
+    }
+  }
+
+  public void setTitle(String title) {
+    SetTitle p = new SetTitle(title);
+    mHandler.post(p);
+    try {
+      p.mLatch.await();
+    } catch (InterruptedException e) {
+      mInflater.getErrors().add(e.toString());
+    }
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/ProgressDialogTask.java b/Common/src/com/googlecode/android_scripting/facade/ui/ProgressDialogTask.java
new file mode 100644
index 0000000..2d9aabf
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/ProgressDialogTask.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.ProgressDialog;
+
+/**
+ * Wrapper class for progress dialog running in separate thread
+ *
+ * @author MeanEYE.rcf (meaneye.rcf@gmail.com)
+ */
+class ProgressDialogTask extends DialogTask {
+
+  private final int mStyle;
+  private final int mMax;
+  private final String mTitle;
+  private final String mMessage;
+  private final Boolean mCancelable;
+
+  public ProgressDialogTask(int style, int max, String title, String message, boolean cancelable) {
+    mStyle = style;
+    mMax = max;
+    mTitle = title;
+    mMessage = message;
+    mCancelable = cancelable;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    mDialog = new ProgressDialog(getActivity());
+    ((ProgressDialog) mDialog).setProgressStyle(mStyle);
+    ((ProgressDialog) mDialog).setMax(mMax);
+    mDialog.setCancelable(mCancelable);
+    mDialog.setTitle(mTitle);
+    ((ProgressDialog) mDialog).setMessage(mMessage);
+    mDialog.show();
+    mShowLatch.countDown();
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/SeekBarDialogTask.java b/Common/src/com/googlecode/android_scripting/facade/ui/SeekBarDialogTask.java
new file mode 100644
index 0000000..3930972
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/SeekBarDialogTask.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.AlertDialog.Builder;
+import android.content.DialogInterface;
+import android.util.AndroidRuntimeException;
+import android.widget.SeekBar;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Wrapper class for dialog box with seek bar.
+ *
+ * @author MeanEYE.rcf (meaneye.rcf@gmail.com)
+ */
+public class SeekBarDialogTask extends DialogTask {
+
+  private SeekBar mSeekBar;
+  private final int mProgress;
+  private final int mMax;
+  private final String mTitle;
+  private final String mMessage;
+  private String mPositiveButtonText;
+  private String mNegativeButtonText;
+
+  public SeekBarDialogTask(int progress, int max, String title, String message) {
+    mProgress = progress;
+    mMax = max;
+    mTitle = title;
+    mMessage = message;
+  }
+
+  public void setPositiveButtonText(String text) {
+    mPositiveButtonText = text;
+  }
+
+  public void setNegativeButtonText(String text) {
+    mNegativeButtonText = text;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    mSeekBar = new SeekBar(getActivity());
+    mSeekBar.setMax(mMax);
+    mSeekBar.setProgress(mProgress);
+    mSeekBar.setPadding(10, 0, 10, 3);
+    mSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
+
+      @Override
+      public void onStopTrackingTouch(SeekBar arg0) {
+      }
+
+      @Override
+      public void onStartTrackingTouch(SeekBar arg0) {
+      }
+
+      @Override
+      public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+        EventFacade eventFacade = getEventFacade();
+        if (eventFacade != null) {
+          JSONObject result = new JSONObject();
+          try {
+            result.put("which", "seekbar");
+            result.put("progress", mSeekBar.getProgress());
+            result.put("fromuser", fromUser);
+            eventFacade.postEvent("dialog", result);
+          } catch (JSONException e) {
+            Log.e(e);
+          }
+        }
+      }
+    });
+
+    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+    if (mTitle != null) {
+      builder.setTitle(mTitle);
+    }
+    if (mMessage != null) {
+      builder.setMessage(mMessage);
+    }
+    builder.setView(mSeekBar);
+    configureButtons(builder, getActivity());
+    addOnCancelListener(builder, getActivity());
+    mDialog = builder.show();
+    mShowLatch.countDown();
+  }
+
+  private Builder addOnCancelListener(final AlertDialog.Builder builder, final Activity activity) {
+    return builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
+      @Override
+      public void onCancel(DialogInterface dialog) {
+        JSONObject result = new JSONObject();
+        try {
+          result.put("canceled", true);
+          result.put("progress", mSeekBar.getProgress());
+        } catch (JSONException e) {
+          Log.e(e);
+        }
+        dismissDialog();
+        setResult(result);
+      }
+    });
+  }
+
+  private void configureButtons(final AlertDialog.Builder builder, final Activity activity) {
+    DialogInterface.OnClickListener buttonListener = new DialogInterface.OnClickListener() {
+      @Override
+      public void onClick(DialogInterface dialog, int which) {
+        JSONObject result = new JSONObject();
+        switch (which) {
+        case DialogInterface.BUTTON_POSITIVE:
+          try {
+            result.put("which", "positive");
+            result.put("progress", mSeekBar.getProgress());
+          } catch (JSONException e) {
+            throw new AndroidRuntimeException(e);
+          }
+          break;
+        case DialogInterface.BUTTON_NEGATIVE:
+          try {
+            result.put("which", "negative");
+            result.put("progress", mSeekBar.getProgress());
+          } catch (JSONException e) {
+            throw new AndroidRuntimeException(e);
+          }
+          break;
+        }
+        dismissDialog();
+        setResult(result);
+      }
+    };
+    if (mNegativeButtonText != null) {
+      builder.setNegativeButton(mNegativeButtonText, buttonListener);
+    }
+    if (mPositiveButtonText != null) {
+      builder.setPositiveButton(mPositiveButtonText, buttonListener);
+    }
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/TimePickerDialogTask.java b/Common/src/com/googlecode/android_scripting/facade/ui/TimePickerDialogTask.java
new file mode 100644
index 0000000..ad71cd3
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/TimePickerDialogTask.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.TimePickerDialog;
+import android.content.DialogInterface;
+import android.util.AndroidRuntimeException;
+import android.widget.TimePicker;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Wrapper class for time picker dialog running in separate thread.
+ *
+ * @author MeanEYE.rcf (meaneye.rcf@gmail.com)
+ */
+public class TimePickerDialogTask extends DialogTask {
+  private final int mHour;
+  private final int mMinute;
+  private final boolean mIs24Hour;
+
+  public TimePickerDialogTask(int hour, int minute, boolean is24hour) {
+    mHour = hour;
+    mMinute = minute;
+    mIs24Hour = is24hour;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    mDialog = new TimePickerDialog(getActivity(), new TimePickerDialog.OnTimeSetListener() {
+      @Override
+      public void onTimeSet(TimePicker view, int hour, int minute) {
+        JSONObject result = new JSONObject();
+        try {
+          result.put("which", "positive");
+          result.put("hour", hour);
+          result.put("minute", minute);
+          setResult(result);
+        } catch (JSONException e) {
+          throw new AndroidRuntimeException(e);
+        }
+      }
+    }, mHour, mMinute, mIs24Hour);
+    mDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+      @Override
+      public void onCancel(DialogInterface view) {
+        JSONObject result = new JSONObject();
+        try {
+          result.put("which", "neutral");
+          result.put("hour", mHour);
+          result.put("minute", mMinute);
+          setResult(result);
+        } catch (JSONException e) {
+          throw new AndroidRuntimeException(e);
+        }
+      }
+    });
+    mDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
+      @Override
+      public void onDismiss(DialogInterface dialog) {
+        JSONObject result = new JSONObject();
+        try {
+          result.put("which", "negative");
+          result.put("hour", mHour);
+          result.put("minute", mMinute);
+          setResult(result);
+        } catch (JSONException e) {
+          throw new AndroidRuntimeException(e);
+        }
+      }
+    });
+    mDialog.show();
+    mShowLatch.countDown();
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/UiFacade.java b/Common/src/com/googlecode/android_scripting/facade/ui/UiFacade.java
new file mode 100644
index 0000000..ccd509e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/UiFacade.java
@@ -0,0 +1,736 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.ProgressDialog;
+import android.app.Service;
+import android.util.AndroidRuntimeException;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.FileUtils;
+import com.googlecode.android_scripting.FutureActivityTaskExecutor;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.interpreter.html.HtmlActivityTask;
+import com.googlecode.android_scripting.interpreter.html.HtmlInterpreter;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+/**
+ * User Interface Facade. <br>
+ * <br>
+ * <b>Usage Notes</b><br>
+ * <br>
+ * The UI facade provides access to a selection of dialog boxes for general user interaction, and
+ * also hosts the {@link #webViewShow} call which allows interactive use of html pages.<br>
+ * The general use of the dialog functions is as follows:<br>
+ * <ol>
+ * <li>Create a dialog using one of the following calls:
+ * <ul>
+ * <li>{@link #dialogCreateInput}
+ * <li>{@link #dialogCreateAlert}
+ * <li>{@link #dialogCreateDatePicker}
+ * <li>{@link #dialogCreateHorizontalProgress}
+ * <li>{@link #dialogCreatePassword}
+ * <li>{@link #dialogCreateSeekBar}
+ * <li>{@link #dialogCreateSpinnerProgress}
+ * </ul>
+ * <li>Set additional features to your dialog
+ * <ul>
+ * <li>{@link #dialogSetItems} Set a list of items. Used like a menu.
+ * <li>{@link #dialogSetMultiChoiceItems} Set a multichoice list of items.
+ * <li>{@link #dialogSetSingleChoiceItems} Set a single choice list of items.
+ * <li>{@link #dialogSetPositiveButtonText}
+ * <li>{@link #dialogSetNeutralButtonText}
+ * <li>{@link #dialogSetNegativeButtonText}
+ * <li>{@link #dialogSetMaxProgress} Set max progress for your progress bar.
+ * </ul>
+ * <li>Display the dialog using {@link #dialogShow}
+ * <li>Update dialog information if needed
+ * <ul>
+ * <li>{@link #dialogSetCurrentProgress}
+ * </ul>
+ * <li>Get the results
+ * <ul>
+ * <li>Using {@link #dialogGetResponse}, which will wait until the user performs an action to close
+ * the dialog box, or
+ * <li>Use eventPoll to wait for a "dialog" event.
+ * <li>You can find out which list items were selected using {@link #dialogGetSelectedItems}, which
+ * returns an array of numeric indices to your list. For a single choice list, there will only ever
+ * be one of these.
+ * </ul>
+ * <li>Once done, use {@link #dialogDismiss} to remove the dialog.
+ * </ol>
+ * <br>
+ * You can also manipulate menu options. The menu options are available for both {@link #dialogShow}
+ * and {@link #fullShow}.
+ * <ul>
+ * <li>{@link #clearOptionsMenu}
+ * <li>{@link #addOptionsMenuItem}
+ * </ul>
+ * <br>
+ * <b>Some notes:</b><br>
+ * Not every dialogSet function is relevant to every dialog type, ie, dialogSetMaxProgress obviously
+ * only applies to dialogs created with a progress bar. Also, an Alert Dialog may have a message or
+ * items, not both. If you set both, items will take priority.<br>
+ * In addition to the above functions, {@link #dialogGetInput} and {@link #dialogGetPassword} are
+ * convenience functions that create, display and return the relevant dialogs in one call.<br>
+ * There is only ever one instance of a dialog. Any dialogCreate call will cause the existing dialog
+ * to be destroyed.
+ *
+ * @author MeanEYE.rcf (meaneye.rcf@gmail.com)
+ */
+public class UiFacade extends RpcReceiver {
+  // This value should not be used for menu groups outside this class.
+  private static final int MENU_GROUP_ID = Integer.MAX_VALUE;
+  private static final String blankLayout = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
+          + "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\""
+          + "android:id=\"@+id/background\" android:orientation=\"vertical\""
+          + "android:layout_width=\"match_parent\" android:layout_height=\"match_parent\""
+          + "android:background=\"#ff000000\"></LinearLayout>";
+
+  private final Service mService;
+  private final FutureActivityTaskExecutor mTaskQueue;
+  private DialogTask mDialogTask;
+  private FullScreenTask mFullScreenTask;
+
+  private final List<UiMenuItem> mContextMenuItems;
+  private final List<UiMenuItem> mOptionsMenuItems;
+  private final AtomicBoolean mMenuUpdated;
+
+  private final EventFacade mEventFacade;
+  private List<Integer> mOverrideKeys = Collections.synchronizedList(new ArrayList<Integer>());
+
+  private float mLastXPosition;
+
+  public UiFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mTaskQueue = ((BaseApplication) mService.getApplication()).getTaskExecutor();
+    mContextMenuItems = new CopyOnWriteArrayList<UiMenuItem>();
+    mOptionsMenuItems = new CopyOnWriteArrayList<UiMenuItem>();
+    mEventFacade = manager.getReceiver(EventFacade.class);
+    mMenuUpdated = new AtomicBoolean(false);
+  }
+
+  /**
+   * For inputType, see <a
+   * href="http://developer.android.com/reference/android/R.styleable.html#TextView_inputType"
+   * >InputTypes</a>. Some useful ones are text, number, and textUri. Multiple flags can be
+   * supplied, seperated by "|", ie: "textUri|textAutoComplete"
+   */
+  @Rpc(description = "Create a text input dialog.")
+  public void dialogCreateInput(
+      @RpcParameter(name = "title", description = "title of the input box") @RpcDefault("Value") final String title,
+      @RpcParameter(name = "message", description = "message to display above the input box") @RpcDefault("Please enter value:") final String message,
+      @RpcParameter(name = "defaultText", description = "text to insert into the input box") @RpcOptional final String text,
+      @RpcParameter(name = "inputType", description = "type of input data, ie number or text") @RpcOptional final String inputType)
+      throws InterruptedException {
+    dialogDismiss();
+    mDialogTask = new AlertDialogTask(title, message);
+    ((AlertDialogTask) mDialogTask).setTextInput(text);
+    if (inputType != null) {
+      ((AlertDialogTask) mDialogTask).setEditInputType(inputType);
+    }
+  }
+
+  @Rpc(description = "Create a password input dialog.")
+  public void dialogCreatePassword(
+      @RpcParameter(name = "title", description = "title of the input box") @RpcDefault("Password") final String title,
+      @RpcParameter(name = "message", description = "message to display above the input box") @RpcDefault("Please enter password:") final String message) {
+    dialogDismiss();
+    mDialogTask = new AlertDialogTask(title, message);
+    ((AlertDialogTask) mDialogTask).setPasswordInput();
+  }
+
+  /**
+   * The result is the user's input, or None (null) if cancel was hit. <br>
+   * Example (python)
+   *
+   * <pre>
+   * import android
+   * droid=android.Android()
+   *
+   * print droid.dialogGetInput("Title","Message","Default").result
+   * </pre>
+   *
+   */
+  @SuppressWarnings("unchecked")
+  @Rpc(description = "Queries the user for a text input.")
+  public String dialogGetInput(
+      @RpcParameter(name = "title", description = "title of the input box") @RpcDefault("Value") final String title,
+      @RpcParameter(name = "message", description = "message to display above the input box") @RpcDefault("Please enter value:") final String message,
+      @RpcParameter(name = "defaultText", description = "text to insert into the input box") @RpcOptional final String text)
+      throws InterruptedException {
+    dialogCreateInput(title, message, text, "text");
+    dialogSetNegativeButtonText("Cancel");
+    dialogSetPositiveButtonText("Ok");
+    dialogShow();
+    Map<String, Object> response = (Map<String, Object>) dialogGetResponse();
+    if ("positive".equals(response.get("which"))) {
+      return (String) response.get("value");
+    } else {
+      return null;
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  @Rpc(description = "Queries the user for a password.")
+  public String dialogGetPassword(
+      @RpcParameter(name = "title", description = "title of the password box") @RpcDefault("Password") final String title,
+      @RpcParameter(name = "message", description = "message to display above the input box") @RpcDefault("Please enter password:") final String message)
+      throws InterruptedException {
+    dialogCreatePassword(title, message);
+    dialogSetNegativeButtonText("Cancel");
+    dialogSetPositiveButtonText("Ok");
+    dialogShow();
+    Map<String, Object> response = (Map<String, Object>) dialogGetResponse();
+    if ("positive".equals(response.get("which"))) {
+      return (String) response.get("value");
+    } else {
+      return null;
+    }
+  }
+
+  @Rpc(description = "Create a spinner progress dialog.")
+  public void dialogCreateSpinnerProgress(@RpcParameter(name = "title") @RpcOptional String title,
+      @RpcParameter(name = "message") @RpcOptional String message,
+      @RpcParameter(name = "maximum progress") @RpcDefault("100") Integer max) {
+    dialogDismiss(); // Dismiss any existing dialog.
+    mDialogTask = new ProgressDialogTask(ProgressDialog.STYLE_SPINNER, max, title, message, true);
+  }
+
+  @Rpc(description = "Create a horizontal progress dialog.")
+  public void dialogCreateHorizontalProgress(
+      @RpcParameter(name = "title") @RpcOptional String title,
+      @RpcParameter(name = "message") @RpcOptional String message,
+      @RpcParameter(name = "maximum progress") @RpcDefault("100") Integer max) {
+    dialogDismiss(); // Dismiss any existing dialog.
+    mDialogTask =
+        new ProgressDialogTask(ProgressDialog.STYLE_HORIZONTAL, max, title, message, true);
+  }
+
+  /**
+   * <b>Example (python)</b>
+   *
+   * <pre>
+   *   import android
+   *   droid=android.Android()
+   *   droid.dialogCreateAlert("I like swords.","Do you like swords?")
+   *   droid.dialogSetPositiveButtonText("Yes")
+   *   droid.dialogSetNegativeButtonText("No")
+   *   droid.dialogShow()
+   *   response=droid.dialogGetResponse().result
+   *   droid.dialogDismiss()
+   *   if response.has_key("which"):
+   *     result=response["which"]
+   *     if result=="positive":
+   *       print "Yay! I like swords too!"
+   *     elif result=="negative":
+   *       print "Oh. How sad."
+   *   elif response.has_key("canceled"): # Yes, I know it's mispelled.
+   *     print "You can't even make up your mind?"
+   *   else:
+   *     print "Unknown response=",response
+   *
+   *   print "Done"
+   * </pre>
+   */
+  @Rpc(description = "Create alert dialog.")
+  public void dialogCreateAlert(@RpcParameter(name = "title") @RpcOptional String title,
+      @RpcParameter(name = "message") @RpcOptional String message) {
+    dialogDismiss(); // Dismiss any existing dialog.
+    mDialogTask = new AlertDialogTask(title, message);
+  }
+
+  /**
+   * Will produce "dialog" events on change, containing:
+   * <ul>
+   * <li>"progress" - Position chosen, between 0 and max
+   * <li>"which" = "seekbar"
+   * <li>"fromuser" = true/false change is from user input
+   * </ul>
+   * Response will contain a "progress" element.
+   */
+  @Rpc(description = "Create seek bar dialog.")
+  public void dialogCreateSeekBar(
+      @RpcParameter(name = "starting value") @RpcDefault("50") Integer progress,
+      @RpcParameter(name = "maximum value") @RpcDefault("100") Integer max,
+      @RpcParameter(name = "title") String title, @RpcParameter(name = "message") String message) {
+    dialogDismiss(); // Dismiss any existing dialog.
+    mDialogTask = new SeekBarDialogTask(progress, max, title, message);
+  }
+
+  @Rpc(description = "Create time picker dialog.")
+  public void dialogCreateTimePicker(
+      @RpcParameter(name = "hour") @RpcDefault("0") Integer hour,
+      @RpcParameter(name = "minute") @RpcDefault("0") Integer minute,
+      @RpcParameter(name = "is24hour", description = "Use 24 hour clock") @RpcDefault("false") Boolean is24hour) {
+    dialogDismiss(); // Dismiss any existing dialog.
+    mDialogTask = new TimePickerDialogTask(hour, minute, is24hour);
+  }
+
+  @Rpc(description = "Create date picker dialog.")
+  public void dialogCreateDatePicker(@RpcParameter(name = "year") @RpcDefault("1970") Integer year,
+      @RpcParameter(name = "month") @RpcDefault("1") Integer month,
+      @RpcParameter(name = "day") @RpcDefault("1") Integer day) {
+    dialogDismiss(); // Dismiss any existing dialog.
+    mDialogTask = new DatePickerDialogTask(year, month, day);
+  }
+
+  @Rpc(description = "Dismiss dialog.")
+  public void dialogDismiss() {
+    if (mDialogTask != null) {
+      mDialogTask.dismissDialog();
+      mDialogTask = null;
+    }
+  }
+
+  @Rpc(description = "Show dialog.")
+  public void dialogShow() throws InterruptedException {
+    if (mDialogTask != null && mDialogTask.getDialog() == null) {
+      mDialogTask.setEventFacade(mEventFacade);
+      mTaskQueue.execute(mDialogTask);
+      mDialogTask.getShowLatch().await();
+    } else {
+      throw new RuntimeException("No dialog to show.");
+    }
+  }
+
+  @Rpc(description = "Set progress dialog current value.")
+  public void dialogSetCurrentProgress(@RpcParameter(name = "current") Integer current) {
+    if (mDialogTask != null && mDialogTask instanceof ProgressDialogTask) {
+      ((ProgressDialog) mDialogTask.getDialog()).setProgress(current);
+    } else {
+      throw new RuntimeException("No valid dialog to assign value to.");
+    }
+  }
+
+  @Rpc(description = "Set progress dialog maximum value.")
+  public void dialogSetMaxProgress(@RpcParameter(name = "max") Integer max) {
+    if (mDialogTask != null && mDialogTask instanceof ProgressDialogTask) {
+      ((ProgressDialog) mDialogTask.getDialog()).setMax(max);
+    } else {
+      throw new RuntimeException("No valid dialog to set maximum value of.");
+    }
+  }
+
+  @Rpc(description = "Set alert dialog positive button text.")
+  public void dialogSetPositiveButtonText(@RpcParameter(name = "text") String text) {
+    if (mDialogTask != null && mDialogTask instanceof AlertDialogTask) {
+      ((AlertDialogTask) mDialogTask).setPositiveButtonText(text);
+    } else if (mDialogTask != null && mDialogTask instanceof SeekBarDialogTask) {
+      ((SeekBarDialogTask) mDialogTask).setPositiveButtonText(text);
+    } else {
+      throw new AndroidRuntimeException("No dialog to add button to.");
+    }
+  }
+
+  @Rpc(description = "Set alert dialog button text.")
+  public void dialogSetNegativeButtonText(@RpcParameter(name = "text") String text) {
+    if (mDialogTask != null && mDialogTask instanceof AlertDialogTask) {
+      ((AlertDialogTask) mDialogTask).setNegativeButtonText(text);
+    } else if (mDialogTask != null && mDialogTask instanceof SeekBarDialogTask) {
+      ((SeekBarDialogTask) mDialogTask).setNegativeButtonText(text);
+    } else {
+      throw new AndroidRuntimeException("No dialog to add button to.");
+    }
+  }
+
+  @Rpc(description = "Set alert dialog button text.")
+  public void dialogSetNeutralButtonText(@RpcParameter(name = "text") String text) {
+    if (mDialogTask != null && mDialogTask instanceof AlertDialogTask) {
+      ((AlertDialogTask) mDialogTask).setNeutralButtonText(text);
+    } else {
+      throw new AndroidRuntimeException("No dialog to add button to.");
+    }
+  }
+
+  // TODO(damonkohler): Make RPC layer translate between JSONArray and List<Object>.
+  /**
+   * This effectively creates list of options. Clicking on an item will immediately return an "item"
+   * element, which is the index of the selected item.
+   */
+  @Rpc(description = "Set alert dialog list items.")
+  public void dialogSetItems(@RpcParameter(name = "items") JSONArray items) {
+    if (mDialogTask != null && mDialogTask instanceof AlertDialogTask) {
+      ((AlertDialogTask) mDialogTask).setItems(items);
+    } else {
+      throw new AndroidRuntimeException("No dialog to add list to.");
+    }
+  }
+
+  /**
+   * This creates a list of radio buttons. You can select one item out of the list. A response will
+   * not be returned until the dialog is closed, either with the Cancel key or a button
+   * (positive/negative/neutral). Use {@link #dialogGetSelectedItems()} to find out what was
+   * selected.
+   */
+  @Rpc(description = "Set dialog single choice items and selected item.")
+  public void dialogSetSingleChoiceItems(
+      @RpcParameter(name = "items") JSONArray items,
+      @RpcParameter(name = "selected", description = "selected item index") @RpcDefault("0") Integer selected) {
+    if (mDialogTask != null && mDialogTask instanceof AlertDialogTask) {
+      ((AlertDialogTask) mDialogTask).setSingleChoiceItems(items, selected);
+    } else {
+      throw new AndroidRuntimeException("No dialog to add list to.");
+    }
+  }
+
+  /**
+   * This creates a list of check boxes. You can select multiple items out of the list. A response
+   * will not be returned until the dialog is closed, either with the Cancel key or a button
+   * (positive/negative/neutral). Use {@link #dialogGetSelectedItems()} to find out what was
+   * selected.
+   */
+
+  @Rpc(description = "Set dialog multiple choice items and selection.")
+  public void dialogSetMultiChoiceItems(
+      @RpcParameter(name = "items") JSONArray items,
+      @RpcParameter(name = "selected", description = "list of selected items") @RpcOptional JSONArray selected)
+      throws JSONException {
+    if (mDialogTask != null && mDialogTask instanceof AlertDialogTask) {
+      ((AlertDialogTask) mDialogTask).setMultiChoiceItems(items, selected);
+    } else {
+      throw new AndroidRuntimeException("No dialog to add list to.");
+    }
+  }
+
+  @Rpc(description = "Returns dialog response.")
+  public Object dialogGetResponse() {
+    try {
+      return mDialogTask.getResult();
+    } catch (Exception e) {
+      throw new AndroidRuntimeException(e);
+    }
+  }
+
+  @Rpc(description = "This method provides list of items user selected.", returns = "Selected items")
+  public Set<Integer> dialogGetSelectedItems() {
+    if (mDialogTask != null && mDialogTask instanceof AlertDialogTask) {
+      return ((AlertDialogTask) mDialogTask).getSelectedItems();
+    } else {
+      throw new AndroidRuntimeException("No dialog to add list to.");
+    }
+  }
+
+  /**
+   * See <a href=http://code.google.com/p/android-scripting/wiki/UsingWebView>wiki page</a> for more
+   * detail.
+   */
+  @Rpc(description = "Display a WebView with the given URL.")
+  public void webViewShow(
+      @RpcParameter(name = "url") String url,
+      @RpcParameter(name = "wait", description = "block until the user exits the WebView") @RpcOptional Boolean wait)
+      throws IOException {
+    String jsonSrc = FileUtils.readFromAssetsFile(mService, HtmlInterpreter.JSON_FILE);
+    String AndroidJsSrc = FileUtils.readFromAssetsFile(mService, HtmlInterpreter.ANDROID_JS_FILE);
+    HtmlActivityTask task = new HtmlActivityTask(mManager, AndroidJsSrc, jsonSrc, url, false);
+    mTaskQueue.execute(task);
+    if (wait != null && wait) {
+      try {
+        task.getResult();
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  /**
+   * Context menus are used primarily with {@link #webViewShow}
+   */
+  @Rpc(description = "Adds a new item to context menu.")
+  public void addContextMenuItem(
+      @RpcParameter(name = "label", description = "label for this menu item") String label,
+      @RpcParameter(name = "event", description = "event that will be generated on menu item click") String event,
+      @RpcParameter(name = "eventData") @RpcOptional Object data) {
+    mContextMenuItems.add(new UiMenuItem(label, event, data, null));
+  }
+
+  /**
+   * <b>Example (python)</b>
+   *
+   * <pre>
+   * import android
+   * droid=android.Android()
+   *
+   * droid.addOptionsMenuItem("Silly","silly",None,"star_on")
+   * droid.addOptionsMenuItem("Sensible","sensible","I bet.","star_off")
+   * droid.addOptionsMenuItem("Off","off",None,"ic_menu_revert")
+   *
+   * print "Hit menu to see extra options."
+   * print "Will timeout in 10 seconds if you hit nothing."
+   *
+   * while True: # Wait for events from the menu.
+   *   response=droid.eventWait(10000).result
+   *   if response==None:
+   *     break
+   *   print response
+   *   if response["name"]=="off":
+   *     break
+   * print "And done."
+   *
+   * </pre>
+   */
+  @Rpc(description = "Adds a new item to options menu.")
+  public void addOptionsMenuItem(
+      @RpcParameter(name = "label", description = "label for this menu item") String label,
+      @RpcParameter(name = "event", description = "event that will be generated on menu item click") String event,
+      @RpcParameter(name = "eventData") @RpcOptional Object data,
+      @RpcParameter(name = "iconName", description = "Android system menu icon, see http://developer.android.com/reference/android/R.drawable.html") @RpcOptional String iconName) {
+    mOptionsMenuItems.add(new UiMenuItem(label, event, data, iconName));
+    mMenuUpdated.set(true);
+  }
+
+  @Rpc(description = "Removes all items previously added to context menu.")
+  public void clearContextMenu() {
+    mContextMenuItems.clear();
+  }
+
+  @Rpc(description = "Removes all items previously added to options menu.")
+  public void clearOptionsMenu() {
+    mOptionsMenuItems.clear();
+    mMenuUpdated.set(true);
+  }
+
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    for (UiMenuItem item : mContextMenuItems) {
+      MenuItem menuItem = menu.add(item.mmTitle);
+      menuItem.setOnMenuItemClickListener(item.mmListener);
+    }
+  }
+
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    if (mMenuUpdated.getAndSet(false)) {
+      menu.removeGroup(MENU_GROUP_ID);
+      for (UiMenuItem item : mOptionsMenuItems) {
+        MenuItem menuItem = menu.add(MENU_GROUP_ID, Menu.NONE, Menu.NONE, item.mmTitle);
+        if (item.mmIcon != null) {
+          menuItem.setIcon(mService.getResources()
+              .getIdentifier(item.mmIcon, "drawable", "android"));
+        }
+        menuItem.setOnMenuItemClickListener(item.mmListener);
+      }
+      return true;
+    }
+    return true;
+  }
+
+  /**
+   * See <a href=http://code.google.com/p/android-scripting/wiki/FullScreenUI>wiki page</a> for more
+   * detail.
+   */
+  @Rpc(description = "Show Full Screen.")
+  public List<String> fullShow(
+      @RpcParameter(name = "layout", description = "String containing View layout") String layout,
+      @RpcParameter(name = "title", description = "Activity Title") @RpcOptional String title)
+      throws InterruptedException {
+    if (mFullScreenTask != null) {
+      // fullDismiss();
+      mFullScreenTask.setLayout(layout);
+      if (title != null) {
+        mFullScreenTask.setTitle(title);
+      }
+    } else {
+      mFullScreenTask = new FullScreenTask(layout, title);
+      mFullScreenTask.setEventFacade(mEventFacade);
+      mFullScreenTask.setUiFacade(this);
+      mFullScreenTask.setOverrideKeys(mOverrideKeys);
+      mTaskQueue.execute(mFullScreenTask);
+      mFullScreenTask.getShowLatch().await();
+    }
+    return mFullScreenTask.mInflater.getErrors();
+  }
+
+  @Rpc(description = "Dismiss Full Screen.")
+  public void fullDismiss() {
+    if (mFullScreenTask != null) {
+      mFullScreenTask.finish();
+      mFullScreenTask = null;
+    }
+  }
+
+  class MouseMotionListener implements View.OnGenericMotionListener {
+
+      @Override
+      public boolean onGenericMotion(View v, MotionEvent event) {
+          Log.d("Generic motion triggered.");
+          if (event.getToolType(0) == MotionEvent.TOOL_TYPE_MOUSE) {
+              mLastXPosition = event.getAxisValue(MotionEvent.AXIS_X);
+              Log.d("New mouse x coord: " + mLastXPosition);
+//              Bundle msg = new Bundle();
+//              msg.putFloat("value", mLastXPosition);
+//              mEventFacade.postEvent("MouseXPositionUpdate", msg);
+              return true;
+          }
+          return false;
+      }
+  }
+
+  @Rpc(description = "Get Fullscreen Properties")
+  public Map<String, Map<String, String>> fullQuery() {
+    if (mFullScreenTask == null) {
+      throw new RuntimeException("No screen displayed.");
+    }
+    return mFullScreenTask.getViewAsMap();
+  }
+
+  @Rpc(description = "Get fullscreen properties for a specific widget")
+  public Map<String, String> fullQueryDetail(
+      @RpcParameter(name = "id", description = "id of layout widget") String id) {
+    if (mFullScreenTask == null) {
+      throw new RuntimeException("No screen displayed.");
+    }
+    return mFullScreenTask.getViewDetail(id);
+  }
+
+  @Rpc(description = "Set fullscreen widget property")
+  public String fullSetProperty(
+      @RpcParameter(name = "id", description = "id of layout widget") String id,
+      @RpcParameter(name = "property", description = "name of property to set") String property,
+      @RpcParameter(name = "value", description = "value to set property to") String value) {
+    if (mFullScreenTask == null) {
+      throw new RuntimeException("No screen displayed.");
+    }
+    return mFullScreenTask.setViewProperty(id, property, value);
+  }
+
+  @Rpc(description = "Attach a list to a fullscreen widget")
+  public String fullSetList(
+      @RpcParameter(name = "id", description = "id of layout widget") String id,
+      @RpcParameter(name = "list", description = "List to set") JSONArray items) {
+    if (mFullScreenTask == null) {
+      throw new RuntimeException("No screen displayed.");
+    }
+    return mFullScreenTask.setList(id, items);
+  }
+
+  @Rpc(description = "Set the Full Screen Activity Title")
+  public void fullSetTitle(
+      @RpcParameter(name = "title", description = "Activity Title") String title) {
+    if (mFullScreenTask == null) {
+      throw new RuntimeException("No screen displayed.");
+    }
+    mFullScreenTask.setTitle(title);
+  }
+
+  /**
+   * This will override the default behaviour of keys while in the fullscreen mode. ie:
+   *
+   * <pre>
+   *   droid.fullKeyOverride([24,25],True)
+   * </pre>
+   *
+   * This will override the default behaviour of the volume keys (codes 24 and 25) so that they do
+   * not actually adjust the volume. <br>
+   * Returns a list of currently overridden keycodes.
+   */
+  @Rpc(description = "Override default key actions")
+  public JSONArray fullKeyOverride(
+      @RpcParameter(name = "keycodes", description = "List of keycodes to override") JSONArray keycodes,
+      @RpcParameter(name = "enable", description = "Turn overriding or off") @RpcDefault(value = "true") Boolean enable)
+      throws JSONException {
+    for (int i = 0; i < keycodes.length(); i++) {
+      int value = (int) keycodes.getLong(i);
+      if (value > 0) {
+        if (enable) {
+          if (!mOverrideKeys.contains(value)) {
+            mOverrideKeys.add(value);
+          }
+        } else {
+          int index = mOverrideKeys.indexOf(value);
+          if (index >= 0) {
+            mOverrideKeys.remove(index);
+          }
+        }
+      }
+    }
+    if (mFullScreenTask != null) {
+      mFullScreenTask.setOverrideKeys(mOverrideKeys);
+    }
+    return new JSONArray(mOverrideKeys);
+  }
+
+  @Rpc(description = "Start tracking mouse cursor x coordinate.")
+  public void startTrackingMouseXCoord() throws InterruptedException {
+    View.OnGenericMotionListener l = new MouseMotionListener();
+    fullShow(blankLayout, "Blank");
+    mFullScreenTask.mView.setOnGenericMotionListener(l);
+  }
+
+  @Rpc(description = "Stop tracking mouse cursor x coordinate.")
+  public void stopTrackingMouseXCoord() throws InterruptedException {
+    fullDismiss();
+  }
+
+  @Rpc(description = "Return the latest X position of mouse cursor.")
+  public float getLatestMouseXCoord() {
+      return mLastXPosition;
+  }
+
+@Override
+  public void shutdown() {
+    fullDismiss();
+    HtmlActivityTask.shutdown();
+  }
+
+  private class UiMenuItem {
+
+    private final String mmTitle;
+    private final String mmEvent;
+    private final Object mmEventData;
+    private final String mmIcon;
+    private final MenuItem.OnMenuItemClickListener mmListener;
+
+    public UiMenuItem(String title, String event, Object data, String icon) {
+      mmTitle = title;
+      mmEvent = event;
+      mmEventData = data;
+      mmIcon = icon;
+      mmListener = new MenuItem.OnMenuItemClickListener() {
+        @Override
+        public boolean onMenuItemClick(MenuItem item) {
+          // TODO(damonkohler): Does mmEventData need to be cloned somehow?
+          mEventFacade.postEvent(mmEvent, mmEventData);
+          return true;
+        }
+      };
+    }
+  }
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/facade/ui/ViewInflater.java b/Common/src/com/googlecode/android_scripting/facade/ui/ViewInflater.java
new file mode 100644
index 0000000..871c562
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/ui/ViewInflater.java
@@ -0,0 +1,1023 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.ui;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Typeface;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.text.InputType;
+import android.text.method.DigitsKeyListener;
+import android.util.DisplayMetrics;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewGroup.LayoutParams;
+import android.view.ViewGroup.MarginLayoutParams;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ArrayAdapter;
+import android.widget.ListAdapter;
+import android.widget.RelativeLayout;
+import android.widget.Spinner;
+import android.widget.SpinnerAdapter;
+import android.widget.TableLayout;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.Log;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.json.JSONArray;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+
+public class ViewInflater {
+  private static XmlPullParserFactory mFactory;
+  public static final String ANDROID = "http://schemas.android.com/apk/res/android";
+  public static final int BASESEQ = 0x7f0f0000;
+  private int mNextSeq = BASESEQ;
+  private final Map<String, Integer> mIdList = new HashMap<String, Integer>();
+  private final List<String> mErrors = new ArrayList<String>();
+  private Context mContext;
+  private DisplayMetrics mMetrics;
+  private static final Map<String, Integer> mInputTypes = new HashMap<String, Integer>();
+  public static final Map<String, String> mColorNames = new HashMap<String, String>();
+  public static final Map<String, Integer> mRelative = new HashMap<String, Integer>();
+  static {
+    mColorNames.put("aliceblue", "#f0f8ff");
+    mColorNames.put("antiquewhite", "#faebd7");
+    mColorNames.put("aqua", "#00ffff");
+    mColorNames.put("aquamarine", "#7fffd4");
+    mColorNames.put("azure", "#f0ffff");
+    mColorNames.put("beige", "#f5f5dc");
+    mColorNames.put("bisque", "#ffe4c4");
+    mColorNames.put("black", "#000000");
+    mColorNames.put("blanchedalmond", "#ffebcd");
+    mColorNames.put("blue", "#0000ff");
+    mColorNames.put("blueviolet", "#8a2be2");
+    mColorNames.put("brown", "#a52a2a");
+    mColorNames.put("burlywood", "#deb887");
+    mColorNames.put("cadetblue", "#5f9ea0");
+    mColorNames.put("chartreuse", "#7fff00");
+    mColorNames.put("chocolate", "#d2691e");
+    mColorNames.put("coral", "#ff7f50");
+    mColorNames.put("cornflowerblue", "#6495ed");
+    mColorNames.put("cornsilk", "#fff8dc");
+    mColorNames.put("crimson", "#dc143c");
+    mColorNames.put("cyan", "#00ffff");
+    mColorNames.put("darkblue", "#00008b");
+    mColorNames.put("darkcyan", "#008b8b");
+    mColorNames.put("darkgoldenrod", "#b8860b");
+    mColorNames.put("darkgray", "#a9a9a9");
+    mColorNames.put("darkgrey", "#a9a9a9");
+    mColorNames.put("darkgreen", "#006400");
+    mColorNames.put("darkkhaki", "#bdb76b");
+    mColorNames.put("darkmagenta", "#8b008b");
+    mColorNames.put("darkolivegreen", "#556b2f");
+    mColorNames.put("darkorange", "#ff8c00");
+    mColorNames.put("darkorchid", "#9932cc");
+    mColorNames.put("darkred", "#8b0000");
+    mColorNames.put("darksalmon", "#e9967a");
+    mColorNames.put("darkseagreen", "#8fbc8f");
+    mColorNames.put("darkslateblue", "#483d8b");
+    mColorNames.put("darkslategray", "#2f4f4f");
+    mColorNames.put("darkslategrey", "#2f4f4f");
+    mColorNames.put("darkturquoise", "#00ced1");
+    mColorNames.put("darkviolet", "#9400d3");
+    mColorNames.put("deeppink", "#ff1493");
+    mColorNames.put("deepskyblue", "#00bfff");
+    mColorNames.put("dimgray", "#696969");
+    mColorNames.put("dimgrey", "#696969");
+    mColorNames.put("dodgerblue", "#1e90ff");
+    mColorNames.put("firebrick", "#b22222");
+    mColorNames.put("floralwhite", "#fffaf0");
+    mColorNames.put("forestgreen", "#228b22");
+    mColorNames.put("fuchsia", "#ff00ff");
+    mColorNames.put("gainsboro", "#dcdcdc");
+    mColorNames.put("ghostwhite", "#f8f8ff");
+    mColorNames.put("gold", "#ffd700");
+    mColorNames.put("goldenrod", "#daa520");
+    mColorNames.put("gray", "#808080");
+    mColorNames.put("grey", "#808080");
+    mColorNames.put("green", "#008000");
+    mColorNames.put("greenyellow", "#adff2f");
+    mColorNames.put("honeydew", "#f0fff0");
+    mColorNames.put("hotpink", "#ff69b4");
+    mColorNames.put("indianred ", "#cd5c5c");
+    mColorNames.put("indigo ", "#4b0082");
+    mColorNames.put("ivory", "#fffff0");
+    mColorNames.put("khaki", "#f0e68c");
+    mColorNames.put("lavender", "#e6e6fa");
+    mColorNames.put("lavenderblush", "#fff0f5");
+    mColorNames.put("lawngreen", "#7cfc00");
+    mColorNames.put("lemonchiffon", "#fffacd");
+    mColorNames.put("lightblue", "#add8e6");
+    mColorNames.put("lightcoral", "#f08080");
+    mColorNames.put("lightcyan", "#e0ffff");
+    mColorNames.put("lightgoldenrodyellow", "#fafad2");
+    mColorNames.put("lightgray", "#d3d3d3");
+    mColorNames.put("lightgrey", "#d3d3d3");
+    mColorNames.put("lightgreen", "#90ee90");
+    mColorNames.put("lightpink", "#ffb6c1");
+    mColorNames.put("lightsalmon", "#ffa07a");
+    mColorNames.put("lightseagreen", "#20b2aa");
+    mColorNames.put("lightskyblue", "#87cefa");
+    mColorNames.put("lightslategray", "#778899");
+    mColorNames.put("lightslategrey", "#778899");
+    mColorNames.put("lightsteelblue", "#b0c4de");
+    mColorNames.put("lightyellow", "#ffffe0");
+    mColorNames.put("lime", "#00ff00");
+    mColorNames.put("limegreen", "#32cd32");
+    mColorNames.put("linen", "#faf0e6");
+    mColorNames.put("magenta", "#ff00ff");
+    mColorNames.put("maroon", "#800000");
+    mColorNames.put("mediumaquamarine", "#66cdaa");
+    mColorNames.put("mediumblue", "#0000cd");
+    mColorNames.put("mediumorchid", "#ba55d3");
+    mColorNames.put("mediumpurple", "#9370d8");
+    mColorNames.put("mediumseagreen", "#3cb371");
+    mColorNames.put("mediumslateblue", "#7b68ee");
+    mColorNames.put("mediumspringgreen", "#00fa9a");
+    mColorNames.put("mediumturquoise", "#48d1cc");
+    mColorNames.put("mediumvioletred", "#c71585");
+    mColorNames.put("midnightblue", "#191970");
+    mColorNames.put("mintcream", "#f5fffa");
+    mColorNames.put("mistyrose", "#ffe4e1");
+    mColorNames.put("moccasin", "#ffe4b5");
+    mColorNames.put("navajowhite", "#ffdead");
+    mColorNames.put("navy", "#000080");
+    mColorNames.put("oldlace", "#fdf5e6");
+    mColorNames.put("olive", "#808000");
+    mColorNames.put("olivedrab", "#6b8e23");
+    mColorNames.put("orange", "#ffa500");
+    mColorNames.put("orangered", "#ff4500");
+    mColorNames.put("orchid", "#da70d6");
+    mColorNames.put("palegoldenrod", "#eee8aa");
+    mColorNames.put("palegreen", "#98fb98");
+    mColorNames.put("paleturquoise", "#afeeee");
+    mColorNames.put("palevioletred", "#d87093");
+    mColorNames.put("papayawhip", "#ffefd5");
+    mColorNames.put("peachpuff", "#ffdab9");
+    mColorNames.put("peru", "#cd853f");
+    mColorNames.put("pink", "#ffc0cb");
+    mColorNames.put("plum", "#dda0dd");
+    mColorNames.put("powderblue", "#b0e0e6");
+    mColorNames.put("purple", "#800080");
+    mColorNames.put("red", "#ff0000");
+    mColorNames.put("rosybrown", "#bc8f8f");
+    mColorNames.put("royalblue", "#4169e1");
+    mColorNames.put("saddlebrown", "#8b4513");
+    mColorNames.put("salmon", "#fa8072");
+    mColorNames.put("sandybrown", "#f4a460");
+    mColorNames.put("seagreen", "#2e8b57");
+    mColorNames.put("seashell", "#fff5ee");
+    mColorNames.put("sienna", "#a0522d");
+    mColorNames.put("silver", "#c0c0c0");
+    mColorNames.put("skyblue", "#87ceeb");
+    mColorNames.put("slateblue", "#6a5acd");
+    mColorNames.put("slategray", "#708090");
+    mColorNames.put("slategrey", "#708090");
+    mColorNames.put("snow", "#fffafa");
+    mColorNames.put("springgreen", "#00ff7f");
+    mColorNames.put("steelblue", "#4682b4");
+    mColorNames.put("tan", "#d2b48c");
+    mColorNames.put("teal", "#008080");
+    mColorNames.put("thistle", "#d8bfd8");
+    mColorNames.put("tomato", "#ff6347");
+    mColorNames.put("turquoise", "#40e0d0");
+    mColorNames.put("violet", "#ee82ee");
+    mColorNames.put("wheat", "#f5deb3");
+    mColorNames.put("white", "#ffffff");
+    mColorNames.put("whitesmoke", "#f5f5f5");
+    mColorNames.put("yellow", "#ffff00");
+    mColorNames.put("yellowgreen", "#9acd32");
+
+    mRelative.put("above", RelativeLayout.ABOVE);
+    mRelative.put("alignBaseline", RelativeLayout.ALIGN_BASELINE);
+    mRelative.put("alignBottom", RelativeLayout.ALIGN_BOTTOM);
+    mRelative.put("alignLeft", RelativeLayout.ALIGN_LEFT);
+    mRelative.put("alignParentBottom", RelativeLayout.ALIGN_PARENT_BOTTOM);
+    mRelative.put("alignParentLeft", RelativeLayout.ALIGN_PARENT_LEFT);
+    mRelative.put("alignParentRight", RelativeLayout.ALIGN_PARENT_RIGHT);
+    mRelative.put("alignParentTop", RelativeLayout.ALIGN_PARENT_TOP);
+    mRelative.put("alignRight", RelativeLayout.ALIGN_PARENT_RIGHT);
+    mRelative.put("alignTop", RelativeLayout.ALIGN_TOP);
+    // mRelative.put("alignWithParentIfMissing",RelativeLayout.); // No idea what this translates
+    // to.
+    mRelative.put("below", RelativeLayout.BELOW);
+    mRelative.put("centerHorizontal", RelativeLayout.CENTER_HORIZONTAL);
+    mRelative.put("centerInParent", RelativeLayout.CENTER_IN_PARENT);
+    mRelative.put("centerVertical", RelativeLayout.CENTER_VERTICAL);
+    mRelative.put("toLeftOf", RelativeLayout.LEFT_OF);
+    mRelative.put("toRightOf", RelativeLayout.RIGHT_OF);
+  }
+
+  public static XmlPullParserFactory getFactory() throws XmlPullParserException {
+    if (mFactory == null) {
+      mFactory = XmlPullParserFactory.newInstance();
+      mFactory.setNamespaceAware(true);
+    }
+    return mFactory;
+  }
+
+  public static XmlPullParser getXml() throws XmlPullParserException {
+    return getFactory().newPullParser();
+  }
+
+  public static XmlPullParser getXml(InputStream is) throws XmlPullParserException {
+    XmlPullParser xml = getXml();
+    xml.setInput(is, null);
+    return xml;
+  }
+
+  public static XmlPullParser getXml(Reader ir) throws XmlPullParserException {
+    XmlPullParser xml = getXml();
+    xml.setInput(ir);
+    return xml;
+  }
+
+  public View inflate(Activity context, XmlPullParser xml) throws XmlPullParserException,
+      IOException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+    int event;
+    mContext = context;
+    mErrors.clear();
+    mMetrics = new DisplayMetrics();
+    context.getWindowManager().getDefaultDisplay().getMetrics(mMetrics);
+    do {
+      event = xml.next();
+      if (event == XmlPullParser.END_DOCUMENT) {
+        return null;
+      }
+    } while (event != XmlPullParser.START_TAG);
+    View view = inflateView(context, xml, null);
+    return view;
+  }
+
+  private void addln(Object msg) {
+    Log.d(msg.toString());
+  }
+
+  @SuppressWarnings("rawtypes")
+  public void setClickListener(View v, android.view.View.OnClickListener listener,
+      OnItemClickListener itemListener) {
+    if (v.isClickable()) {
+
+      if (v instanceof AdapterView) {
+        try {
+          ((AdapterView) v).setOnItemClickListener(itemListener);
+        } catch (RuntimeException e) {
+          // Ignore this, not all controls support OnItemClickListener
+        }
+      }
+      try {
+        v.setOnClickListener(listener);
+      } catch (RuntimeException e) {
+        // And not all controls support OnClickListener.
+      }
+    }
+    if (v instanceof ViewGroup) {
+      ViewGroup vg = (ViewGroup) v;
+      for (int i = 0; i < vg.getChildCount(); i++) {
+        setClickListener(vg.getChildAt(i), listener, itemListener);
+      }
+    }
+  }
+
+  private View inflateView(Context context, XmlPullParser xml, ViewGroup root)
+      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException,
+      XmlPullParserException, IOException {
+    View view = buildView(context, xml, root);
+    if (view == null) {
+      return view;
+    }
+    int event;
+    while ((event = xml.next()) != XmlPullParser.END_DOCUMENT) {
+      switch (event) {
+      case XmlPullParser.START_TAG:
+        if (view == null || view instanceof ViewGroup) {
+          inflateView(context, xml, (ViewGroup) view);
+        } else {
+          skipTag(xml); // Not really a view, probably, skip it.
+        }
+        break;
+      case XmlPullParser.END_TAG:
+        return view;
+      }
+    }
+    return view;
+  }
+
+  private void skipTag(XmlPullParser xml) throws XmlPullParserException, IOException {
+    int depth = xml.getDepth();
+    int event;
+    while ((event = xml.next()) != XmlPullParser.END_DOCUMENT) {
+      if (event == XmlPullParser.END_TAG && xml.getDepth() <= depth) {
+        break;
+      }
+    }
+  }
+
+  private View buildView(Context context, XmlPullParser xml, ViewGroup root)
+      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+    View view = viewClass(context, xml.getName());
+    if (view != null) {
+      getLayoutParams(view, root); // Make quite sure every view has a layout param.
+      for (int i = 0; i < xml.getAttributeCount(); i++) {
+        String ns = xml.getAttributeNamespace(i);
+        String attr = xml.getAttributeName(i);
+        if (ANDROID.equals(ns)) {
+          setProperty(view, root, attr, xml.getAttributeValue(i));
+        }
+      }
+      if (root != null) {
+        root.addView(view);
+      }
+    }
+
+    return view;
+  }
+
+  private int getLayoutValue(String value) {
+    if (value == null) {
+      return 0;
+    }
+    if (value.equals("match_parent")) {
+      return LayoutParams.MATCH_PARENT;
+    }
+    if (value.equals("wrap_content")) {
+      return LayoutParams.WRAP_CONTENT;
+    }
+    if (value.equals("fill_parent")) {
+      return LayoutParams.MATCH_PARENT;
+    }
+    return (int) getFontSize(value);
+  }
+
+  private float getFontSize(String value) {
+    int i;
+    float size;
+    String unit = "px";
+    for (i = 0; i < value.length(); i++) {
+      char c = value.charAt(i);
+      if (!(Character.isDigit(c) || c == '.')) {
+        break;
+      }
+    }
+    size = Float.parseFloat(value.substring(0, i));
+    if (i < value.length()) {
+      unit = value.substring(i).trim();
+    }
+    if (unit.equals("px")) {
+      return size;
+    }
+    if (unit.equals("sp")) {
+      return mMetrics.scaledDensity * size;
+    }
+    if (unit.equals("dp") || unit.equals("dip")) {
+      return mMetrics.density * size;
+    }
+    float inches = mMetrics.ydpi * size;
+    if (unit.equals("in")) {
+      return inches;
+    }
+    if (unit.equals("pt")) {
+      return inches / 72;
+    }
+    if (unit.equals("mm")) {
+      return (float) (inches / 2.54);
+    }
+    return 0;
+  }
+
+  private int calcId(String value) {
+    if (value == null) {
+      return 0;
+    }
+    if (value.startsWith("@+id/")) {
+      return tryGetId(value.substring(5));
+    }
+    if (value.startsWith("@id/")) {
+      return tryGetId(value.substring(4));
+    }
+    try {
+      return Integer.parseInt(value);
+    } catch (NumberFormatException e) {
+      return 0;
+    }
+  }
+
+  private int tryGetId(String value) {
+    Integer id = mIdList.get(value);
+    if (id == null) {
+      id = new Integer(mNextSeq++);
+      mIdList.put(value, id);
+    }
+    return id;
+  }
+
+  private LayoutParams getLayoutParams(View view, ViewGroup root) {
+    LayoutParams result = view.getLayoutParams();
+    if (result == null) {
+      result = createLayoutParams(root);
+      view.setLayoutParams(result);
+    }
+    return result;
+  }
+
+  private LayoutParams createLayoutParams(ViewGroup root) {
+    LayoutParams result = null;
+    if (root != null) {
+      try {
+        String lookfor = root.getClass().getName() + "$LayoutParams";
+        addln(lookfor);
+        Class<? extends LayoutParams> clazz = Class.forName(lookfor).asSubclass(LayoutParams.class);
+        if (clazz != null) {
+          Constructor<? extends LayoutParams> ct = clazz.getConstructor(int.class, int.class);
+          result = ct.newInstance(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
+        }
+      } catch (Exception e) {
+        result = null;
+      }
+    }
+    if (result == null) {
+      result = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
+    }
+    return result;
+  }
+
+  public void setProperty(View view, String attr, String value) {
+    try {
+      setProperty(view, (ViewGroup) view.getParent(), attr, value);
+    } catch (Exception e) {
+      mErrors.add(e.toString());
+    }
+  }
+
+  private void setProperty(View view, ViewGroup root, String attr, String value)
+      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+    addln(attr + ":" + value);
+    if (attr.startsWith("layout_")) {
+      setLayoutProperty(view, root, attr, value);
+    } else if (attr.equals("id")) {
+      view.setId(calcId(value));
+    } else if (attr.equals("gravity")) {
+      setInteger(view, attr, getInteger(Gravity.class, value));
+    } else if (attr.equals("width") || attr.equals("height")) {
+      setInteger(view, attr, (int) getFontSize(value));
+    } else if (attr.equals("inputType")) {
+      setInteger(view, attr, getInteger(InputType.class, value));
+    } else if (attr.equals("background")) {
+      setBackground(view, value);
+    } else if (attr.equals("digits") && view instanceof TextView) {
+      ((TextView) view).setKeyListener(DigitsKeyListener.getInstance(value));
+    } else if (attr.startsWith("nextFocus")) {
+      setInteger(view, attr + "Id", calcId(value));
+    } else if (attr.equals("padding")) {
+      int size = (int) getFontSize(value);
+      view.setPadding(size, size, size, size);
+    } else if (attr.equals("stretchColumns")) {
+      setStretchColumns(view, value);
+    } else if (attr.equals("textSize")) {
+      setFloat(view, attr, getFontSize(value));
+    } else if (attr.equals("textColor")) {
+      setInteger(view, attr, getColor(value));
+    } else if (attr.equals("textHighlightColor")) {
+      setInteger(view, "HighlightColor", getColor(value));
+    } else if (attr.equals("textColorHint")) {
+      setInteger(view, "LinkTextColor", getColor(value));
+    } else if (attr.equals("textStyle")) {
+      TextView textview = (TextView) view;
+      int style = getInteger(Typeface.class, value);
+      if (style == 0) {
+        textview.setTypeface(Typeface.DEFAULT);
+      } else {
+        textview.setTypeface(textview.getTypeface(), style);
+      }
+    } else if (attr.equals("typeface")) {
+      TextView textview = (TextView) view;
+      Typeface typeface = textview.getTypeface();
+      int style = typeface == null ? 0 : typeface.getStyle();
+      textview.setTypeface(Typeface.create(value, style));
+    } else if (attr.equals("src")) {
+      setImage(view, value);
+    } else {
+      setDynamicProperty(view, attr, value);
+    }
+  }
+
+  private void setStretchColumns(View view, String value) {
+    TableLayout table = (TableLayout) view;
+    String[] values = value.split(",");
+    for (String column : values) {
+      table.setColumnStretchable(Integer.parseInt(column), true);
+    }
+  }
+
+  private void setLayoutProperty(View view, ViewGroup root, String attr, String value) {
+    LayoutParams layout = getLayoutParams(view, root);
+    String layoutAttr = attr.substring(7);
+    if (layoutAttr.equals("width")) {
+      layout.width = getLayoutValue(value);
+    } else if (layoutAttr.equals("height")) {
+      layout.height = getLayoutValue(value);
+    } else if (layoutAttr.equals("gravity")) {
+      setIntegerField(layout, "gravity", getInteger(Gravity.class, value));
+    } else {
+      if (layoutAttr.startsWith("margin") && layout instanceof MarginLayoutParams) {
+        int size = (int) getFontSize(value);
+        MarginLayoutParams margins = (MarginLayoutParams) layout;
+        if (layoutAttr.equals("marginBottom")) {
+          margins.bottomMargin = size;
+        } else if (layoutAttr.equals("marginTop")) {
+          margins.topMargin = size;
+        } else if (layoutAttr.equals("marginLeft")) {
+          margins.leftMargin = size;
+        } else if (layoutAttr.equals("marginRight")) {
+          margins.rightMargin = size;
+        }
+      } else if (layout instanceof RelativeLayout.LayoutParams) {
+        int anchor = calcId(value);
+        if (anchor == 0) {
+          anchor = getInteger(RelativeLayout.class, value);
+        }
+        int rule = mRelative.get(layoutAttr);
+        ((RelativeLayout.LayoutParams) layout).addRule(rule, anchor);
+      } else {
+        setIntegerField(layout, layoutAttr, getInteger(layout.getClass(), value));
+      }
+    }
+  }
+
+  private void setBackground(View view, String value) {
+    if (value.startsWith("#")) {
+      view.setBackgroundColor(getColor(value));
+    } else if (value.startsWith("@")) {
+      setInteger(view, "backgroundResource", getInteger(view, value));
+    } else {
+      view.setBackground(getDrawable(value));
+    }
+  }
+
+  private Drawable getDrawable(String value) {
+    try {
+      Uri uri = Uri.parse(value);
+      if ("file".equals(uri.getScheme())) {
+        BitmapDrawable bd = new BitmapDrawable(mContext.getResources(), uri.getPath());
+        return bd;
+      }
+    } catch (Exception e) {
+      mErrors.add("failed to load drawable " + value);
+    }
+    return null;
+  }
+
+  private void setImage(View view, String value) {
+    if (value.startsWith("@")) {
+      setInteger(view, "imageResource", getInteger(view, value));
+    } else {
+      try {
+        Uri uri = Uri.parse(value);
+        if ("file".equals(uri.getScheme())) {
+          Bitmap bm = BitmapFactory.decodeFile(uri.getPath());
+          Method method = view.getClass().getMethod("setImageBitmap", Bitmap.class);
+          method.invoke(view, bm);
+        } else {
+          mErrors.add("Only 'file' currently supported for images");
+        }
+      } catch (Exception e) {
+        mErrors.add("failed to set image " + value);
+      }
+    }
+  }
+
+  private void setIntegerField(Object target, String fieldName, int value) {
+    try {
+      Field f = target.getClass().getField(fieldName);
+      f.setInt(target, value);
+    } catch (Exception e) {
+      mErrors.add("set field)" + fieldName + " failed. " + e.toString());
+    }
+  }
+
+  /** Expand single digit color to 2 digits. */
+  private int expandColor(String colorValue) {
+    return Integer.parseInt(colorValue + colorValue, 16);
+  }
+
+  private int getColor(String value) {
+    int a = 0xff, r = 0, g = 0, b = 0;
+    if (value.startsWith("#")) {
+      try {
+        value = value.substring(1);
+        if (value.length() == 4) {
+          a = expandColor(value.substring(0, 1));
+          value = value.substring(1);
+        }
+        if (value.length() == 3) {
+          r = expandColor(value.substring(0, 1));
+          g = expandColor(value.substring(1, 2));
+          b = expandColor(value.substring(2, 3));
+        } else {
+          if (value.length() == 8) {
+            a = Integer.parseInt(value.substring(0, 2), 16);
+            value = value.substring(2);
+          }
+          if (value.length() == 6) {
+            r = Integer.parseInt(value.substring(0, 2), 16);
+            g = Integer.parseInt(value.substring(2, 4), 16);
+            b = Integer.parseInt(value.substring(4, 6), 16);
+          }
+        }
+        long result = (a << 24) | (r << 16) | (g << 8) | b;
+        return (int) result;
+      } catch (Exception e) {
+      }
+    } else if (mColorNames.containsKey(value.toLowerCase())) {
+      return getColor(mColorNames.get(value.toLowerCase()));
+    }
+    mErrors.add("Unknown color " + value);
+    return 0;
+  }
+
+  private int getInputType(String value) {
+    int result = 0;
+    Integer v = getInputTypes().get(value);
+    if (v == null) {
+      mErrors.add("Unkown input type " + value);
+    } else {
+      result = v;
+    }
+    return result;
+  }
+
+  private void setInteger(View view, String attr, int value) {
+    String name = "set" + PCase(attr);
+    Method m;
+    try {
+      if ((m = tryMethod(view, name, Context.class, int.class)) != null) {
+        m.invoke(view, mContext, value);
+      } else if ((m = tryMethod(view, name, int.class)) != null) {
+        m.invoke(view, value);
+      }
+    } catch (Exception e) {
+      addln(name + ":" + value + ":" + e.toString());
+    }
+
+  }
+
+  private void setFloat(View view, String attr, float value) {
+    String name = "set" + PCase(attr);
+    Method m;
+    try {
+      if ((m = tryMethod(view, name, Context.class, float.class)) != null) {
+        m.invoke(view, mContext, value);
+      } else if ((m = tryMethod(view, name, float.class)) != null) {
+        m.invoke(view, value);
+      }
+    } catch (Exception e) {
+      addln(name + ":" + value + ":" + e.toString());
+    }
+
+  }
+
+  private void setDynamicProperty(View view, String attr, String value)
+      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+    String name = "set" + PCase(attr);
+    try {
+      Method m = tryMethod(view, name, CharSequence.class);
+      if (m != null) {
+        m.invoke(view, value);
+      } else if ((m = tryMethod(view, name, Context.class, int.class)) != null) {
+        m.invoke(view, mContext, getInteger(view, value));
+      } else if ((m = tryMethod(view, name, int.class)) != null) {
+        m.invoke(view, getInteger(view, value));
+      } else if ((m = tryMethod(view, name, float.class)) != null) {
+        m.invoke(view, Float.parseFloat(value));
+      } else if ((m = tryMethod(view, name, boolean.class)) != null) {
+        m.invoke(view, Boolean.parseBoolean(value));
+      } else if ((m = tryMethod(view, name, Object.class)) != null) {
+        m.invoke(view, value);
+      } else {
+        mErrors.add(view.getClass().getSimpleName() + ":" + attr + " Property not found.");
+      }
+    } catch (Exception e) {
+      addln(name + ":" + value + ":" + e.toString());
+      mErrors.add(name + ":" + value + ":" + e.toString());
+    }
+  }
+
+  private String PCase(String s) {
+    if (s == null) {
+      return null;
+    }
+    if (s.length() > 0) {
+      return s.substring(0, 1).toUpperCase() + s.substring(1);
+    }
+    return "";
+  }
+
+  private Method tryMethod(Object o, String name, Class<?>... parameters) {
+    Method result;
+    try {
+      result = o.getClass().getMethod(name, parameters);
+    } catch (Exception e) {
+      result = null;
+    }
+    return result;
+  }
+
+  public String camelCase(String s) {
+    if (s == null) {
+      return "";
+    } else if (s.length() < 2) {
+      return s.toUpperCase();
+    } else {
+      return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
+    }
+  }
+
+  private Integer getInteger(Class<?> clazz, String value) {
+    Integer result = null;
+    if (value.contains("|")) {
+      int work = 0;
+      for (String s : value.split("\\|")) {
+        work |= getInteger(clazz, s);
+      }
+      result = work;
+    } else {
+      if (value.startsWith("?")) {
+        result = parseTheme(value);
+      } else if (value.startsWith("@")) {
+        result = parseTheme(value);
+      } else if (value.startsWith("0x")) {
+        try {
+          result = (int) Long.parseLong(value.substring(2), 16);
+        } catch (NumberFormatException e) {
+          result = 0;
+        }
+      } else {
+        try {
+          result = Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+          if (clazz == InputType.class) {
+            return getInputType(value);
+          }
+          try {
+            Field f = clazz.getField(value.toUpperCase());
+            result = f.getInt(null);
+          } catch (Exception ex) {
+            mErrors.add("Unknown value: " + value);
+            result = 0;
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  private Integer getInteger(View view, String value) {
+    return getInteger(view.getClass(), value);
+  }
+
+  private Integer parseTheme(String value) {
+    int result;
+    try {
+      String query = "";
+      int i;
+      value = value.substring(1); // skip past "?"
+      i = value.indexOf(":");
+      if (i >= 0) {
+        query = value.substring(0, i) + ".";
+        value = value.substring(i + 1);
+      }
+      query += "R";
+      i = value.indexOf("/");
+      if (i >= 0) {
+        query += "$" + value.substring(0, i);
+        value = value.substring(i + 1);
+      }
+      Class<?> clazz = Class.forName(query);
+      Field f = clazz.getField(value);
+      result = f.getInt(null);
+    } catch (Exception e) {
+      result = 0;
+    }
+    return result;
+  }
+
+  private View viewClass(Context context, String name) {
+    View result = null;
+    result = viewClassTry(context, "android.view." + name);
+    if (result == null) {
+      result = viewClassTry(context, "android.widget." + name);
+    }
+    if (result == null) {
+      result = viewClassTry(context, name);
+    }
+    return result;
+  }
+
+  private View viewClassTry(Context context, String name) {
+    View result = null;
+    try {
+      Class<? extends View> viewclass = Class.forName(name).asSubclass(View.class);
+      if (viewclass != null) {
+        Constructor<? extends View> ct = viewclass.getConstructor(Context.class);
+        result = ct.newInstance(context);
+      }
+    } catch (Exception e) {
+    }
+    return result;
+
+  }
+
+  public Map<String, Integer> getIdList() {
+    return mIdList;
+  }
+
+  public List<String> getErrors() {
+    return mErrors;
+  }
+
+  public String getIdName(int id) {
+    for (String key : mIdList.keySet()) {
+      if (mIdList.get(key) == id) {
+        return key;
+      }
+    }
+    return null;
+  }
+
+  public int getId(String name) {
+    return mIdList.get(name);
+  }
+
+  public Map<String, Map<String, String>> getViewAsMap(View v) {
+    Map<String, Map<String, String>> result = new HashMap<String, Map<String, String>>();
+    for (Entry<String, Integer> entry : mIdList.entrySet()) {
+      View tmp = v.findViewById(entry.getValue());
+      if (tmp != null) {
+        result.put(entry.getKey(), getViewInfo(tmp));
+      }
+    }
+    return result;
+  }
+
+  public Map<String, String> getViewInfo(View v) {
+    Map<String, String> result = new HashMap<String, String>();
+    if (v.getId() != 0) {
+      result.put("id", getIdName(v.getId()));
+    }
+    result.put("type", v.getClass().getSimpleName());
+    addProperty(v, "text", result);
+    addProperty(v, "visibility", result);
+    addProperty(v, "checked", result);
+    addProperty(v, "tag", result);
+    addProperty(v, "selectedItemPosition", result);
+    addProperty(v, "progress", result);
+    return result;
+  }
+
+  private void addProperty(View v, String attr, Map<String, String> dest) {
+    String result = getProperty(v, attr);
+    if (result != null) {
+      dest.put(attr, result);
+    }
+  }
+
+  private String getProperty(View v, String attr) {
+    String name = PCase(attr);
+    Method m = tryMethod(v, "get" + name);
+    if (m == null) {
+      m = tryMethod(v, "is" + name);
+    }
+    String result = null;
+    if (m != null) {
+      try {
+        Object o = m.invoke(v);
+        if (o != null) {
+          result = o.toString();
+        }
+      } catch (Exception e) {
+        result = null;
+      }
+    }
+    return result;
+  }
+
+  public static Map<String, Integer> getInputTypes() {
+    if (mInputTypes.size() == 0) {
+      mInputTypes.put("none", 0x00000000);
+      mInputTypes.put("text", 0x00000001);
+      mInputTypes.put("textCapCharacters", 0x00001001);
+      mInputTypes.put("textCapWords", 0x00002001);
+      mInputTypes.put("textCapSentences", 0x00004001);
+      mInputTypes.put("textAutoCorrect", 0x00008001);
+      mInputTypes.put("textAutoComplete", 0x00010001);
+      mInputTypes.put("textMultiLine", 0x00020001);
+      mInputTypes.put("textImeMultiLine", 0x00040001);
+      mInputTypes.put("textNoSuggestions", 0x00080001);
+      mInputTypes.put("textUri", 0x00000011);
+      mInputTypes.put("textEmailAddress", 0x00000021);
+      mInputTypes.put("textEmailSubject", 0x00000031);
+      mInputTypes.put("textShortMessage", 0x00000041);
+      mInputTypes.put("textLongMessage", 0x00000051);
+      mInputTypes.put("textPersonName", 0x00000061);
+      mInputTypes.put("textPostalAddress", 0x00000071);
+      mInputTypes.put("textPassword", 0x00000081);
+      mInputTypes.put("textVisiblePassword", 0x00000091);
+      mInputTypes.put("textWebEditText", 0x000000a1);
+      mInputTypes.put("textFilter", 0x000000b1);
+      mInputTypes.put("textPhonetic", 0x000000c1);
+      mInputTypes.put("textWebEmailAddress", 0x000000d1);
+      mInputTypes.put("textWebPassword", 0x000000e1);
+      mInputTypes.put("number", 0x00000002);
+      mInputTypes.put("numberSigned", 0x00001002);
+      mInputTypes.put("numberDecimal", 0x00002002);
+      mInputTypes.put("numberPassword", 0x00000012);
+      mInputTypes.put("phone", 0x00000003);
+      mInputTypes.put("datetime", 0x00000004);
+      mInputTypes.put("date", 0x00000014);
+      mInputTypes.put("time", 0x00000024);
+    }
+    return mInputTypes;
+  }
+
+  /** Query class (typically R.id) to extract id names */
+  public void setIdList(Class<?> idClass) {
+    mIdList.clear();
+    for (Field f : idClass.getDeclaredFields()) {
+      try {
+        String name = f.getName();
+        int value = f.getInt(null);
+        mIdList.put(name, value);
+      } catch (Exception e) {
+        // Ignore
+      }
+    }
+  }
+
+  public void setListAdapter(View view, JSONArray items) {
+    List<String> list = new ArrayList<String>();
+    try {
+      for (int i = 0; i < items.length(); i++) {
+        list.add(items.get(i).toString());
+      }
+      ArrayAdapter<String> adapter;
+      if (view instanceof Spinner) {
+        adapter =
+            new ArrayAdapter<String>(mContext, android.R.layout.simple_spinner_item,
+                android.R.id.text1, list);
+      } else {
+        adapter =
+            new ArrayAdapter<String>(mContext, android.R.layout.simple_list_item_1,
+                android.R.id.text1, list);
+      }
+      adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+      Method m = tryMethod(view, "setAdapter", SpinnerAdapter.class);
+      if (m == null) {
+        m = view.getClass().getMethod("setAdapter", ListAdapter.class);
+      }
+      m.invoke(view, adapter);
+    } catch (Exception e) {
+      mErrors.add("failed to load list " + e.getMessage());
+    }
+  }
+
+  public void clearAll() {
+    getErrors().clear();
+    mIdList.clear();
+    mNextSeq = BASESEQ;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/wifi/HttpFacade.java b/Common/src/com/googlecode/android_scripting/facade/wifi/HttpFacade.java
new file mode 100644
index 0000000..75bf888
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/wifi/HttpFacade.java
@@ -0,0 +1,216 @@
+
+package com.googlecode.android_scripting.facade.wifi;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+
+/**
+ * Basic http operations.
+ */
+public class HttpFacade extends RpcReceiver {
+
+    private ServerSocket mServerSocket = null;
+    private int mServerTimeout = -1;
+    private HashMap<Integer, Socket> mSockets = null;
+    private int socketCnt = 0;
+
+    public HttpFacade(FacadeManager manager) throws IOException {
+        super(manager);
+        mSockets = new HashMap<Integer, Socket>();
+    }
+
+    private void inputStreamToOutputStream(InputStream in, OutputStream out) throws IOException {
+        if (in == null) {
+            Log.e("InputStream is null.");
+            return;
+        }
+        if (out == null) {
+            Log.e("OutputStream is null.");
+            return;
+        }
+        try {
+            int read = 0;
+            byte[] bytes = new byte[1024];
+            while ((read = in.read(bytes)) != -1) {
+                out.write(bytes, 0, read);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            in.close();
+            out.close();
+        }
+
+    }
+
+    private String inputStreamToString(InputStream in) throws IOException {
+        BufferedReader r = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
+        StringBuilder sb = new StringBuilder();
+        String str = null;
+        while ((str = r.readLine()) != null) {
+            sb.append(str);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Send an http request and get the response.
+     *
+     * @param url The url to send request to.
+     * @return The HttpURLConnection object.
+     */
+    private HttpURLConnection httpRequest(String url) throws IOException {
+        URL targetURL = new URL(url);
+        HttpURLConnection urlConnection = null;
+        try {
+            urlConnection = (HttpURLConnection) targetURL.openConnection();
+            urlConnection.connect();
+            int respCode = urlConnection.getResponseCode();
+            String respMsg = urlConnection.getResponseMessage();
+            Log.d("Got response code: " + respCode + " and response msg: " + respMsg);
+        } catch (IOException e) {
+            Log.e("Failed to open a connection to " + url);
+            Log.e(e.toString());
+        } finally {
+            if (urlConnection != null) {
+                urlConnection.disconnect();
+            }
+        }
+        return urlConnection;
+    }
+
+    @Rpc(description = "Start waiting for a connection request on a specified port.",
+            returns = "The index of the connection.")
+    public Integer httpAcceptConnection(Integer port) throws IOException {
+        mServerSocket = new ServerSocket(port);
+        if (mServerTimeout > 0) {
+            mServerSocket.setSoTimeout(mServerTimeout);
+        }
+        Socket sock = mServerSocket.accept();
+        socketCnt += 1;
+        mSockets.put(socketCnt, sock);
+        return socketCnt;
+    }
+
+    @Rpc(description = "Download a file from specified url.")
+    public void httpDownloadFile(String url) throws IOException {
+        HttpURLConnection urlConnection = httpRequest(url);
+        String filename = null;
+        String contentDisposition = urlConnection.getHeaderField("Content-Disposition");
+        // Try to figure out the name of the file being downloaded.
+        // If the server returned a filename, use it.
+        if (contentDisposition != null) {
+            int idx = contentDisposition.toLowerCase().indexOf("filename");
+            if (idx != -1) {
+                filename = contentDisposition.substring(idx + 9);
+                Log.d("Using name returned by server: " + filename);
+            }
+        }
+        // If the server did not provide a filename to us, use the last part of url.
+        if (filename == null) {
+            int lastIdx = url.lastIndexOf('/');
+            filename = url.substring(lastIdx + 1);
+            Log.d("Using name from url: " + filename);
+        }
+        InputStream in = new BufferedInputStream(urlConnection.getInputStream());
+        String outPath = "/sdcard/Download/" + filename;
+        OutputStream output = new FileOutputStream(new File(outPath));
+        inputStreamToOutputStream(in, output);
+        Log.d("Downloaded file at " + outPath);
+    }
+
+    @Rpc(description = "Make an http request and return the response message.")
+    public HttpURLConnection httpPing(@RpcParameter(name = "url") String url) throws IOException {
+        try {
+            HttpURLConnection urlConnection = null;
+            urlConnection = httpRequest(url);
+            return urlConnection;
+        } catch (UnknownHostException e) {
+            return null;
+        }
+    }
+
+    @Rpc(description = "Make an http request and return the response content as a string.")
+    public String httpRequestString(@RpcParameter(name = "url") String url) throws IOException {
+        HttpURLConnection urlConnection = httpRequest(url);
+        InputStream in = new BufferedInputStream(urlConnection.getInputStream());
+        String result = inputStreamToString(in);
+        Log.d("Fetched: " + result);
+        return result;
+    }
+
+    @Rpc(description = "Set how many milliseconds to wait for an incoming connection.")
+    public void httpSetServerTimeout(@RpcParameter(name = "timeout") Integer timeout)
+            throws SocketException {
+        mServerSocket.setSoTimeout(timeout);
+        mServerTimeout = timeout;
+    }
+
+    @Rpc(description = "Ping to host(URL or IP), return success (true) or fail (false).")
+    // The optional timeout parameter is in unit of second.
+    public Boolean pingHost(@RpcParameter(name = "host") String hostString,
+            @RpcParameter(name = "timeout") @RpcOptional Integer timeout) {
+        try {
+            String host;
+            try {
+                URL url = new URL(hostString);
+                host = url.getHost();
+            } catch (java.net.MalformedURLException e) {
+                Log.d("hostString is not URL, it may be IP address.");
+                host = hostString;
+            }
+
+            Log.d("Host:" + host);
+            String pingCmdString = "ping -c 1 ";
+            if (timeout != null) {
+                pingCmdString = pingCmdString + "-W " + timeout + " ";
+            }
+            pingCmdString = pingCmdString + host;
+            Log.d("Execute command: " + pingCmdString);
+            Process p1 = java.lang.Runtime.getRuntime().exec(pingCmdString);
+            int returnVal = p1.waitFor();
+            boolean reachable = (returnVal == 0);
+            Log.d("Ping return Value:" + returnVal);
+            return reachable;
+        } catch (Exception e){
+            e.printStackTrace();
+            return false;
+        }
+        /*TODO see b/18899134 for more information.
+        */
+    }
+
+    @Override
+    public void shutdown() {
+        for (int key : mSockets.keySet()) {
+            Socket sock = mSockets.get(key);
+            try {
+                sock.close();
+            } catch (IOException e) {
+                Log.e("Failed to close socket " + key + " on port " + sock.getLocalPort());
+                e.printStackTrace();
+            }
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/wifi/WifiManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiManagerFacade.java
new file mode 100755
index 0000000..c0efe0f
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiManagerFacade.java
@@ -0,0 +1,887 @@
+
+package com.googlecode.android_scripting.facade.wifi;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectOutput;
+import java.io.ObjectOutputStream;
+import java.net.ConnectException;
+import java.security.GeneralSecurityException;
+import java.security.KeyFactory;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.DhcpInfo;
+import android.net.Network;
+import android.net.NetworkInfo;
+import android.net.NetworkInfo.DetailedState;
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiActivityEnergyInfo;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiConfiguration.AuthAlgorithm;
+import android.net.wifi.WifiConfiguration.KeyMgmt;
+import android.net.wifi.WifiEnterpriseConfig;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.net.wifi.WifiManager.WifiLock;
+import android.net.wifi.WpsInfo;
+import android.os.Bundle;
+import android.provider.Settings.Global;
+import android.provider.Settings.SettingNotFoundException;
+import android.util.Base64;
+
+/**
+ * WifiManager functions.
+ */
+// TODO: make methods handle various wifi states properly
+// e.g. wifi connection result will be null when flight mode is on
+public class WifiManagerFacade extends RpcReceiver {
+    private final static String mEventType = "WifiManager";
+    private final Service mService;
+    private final WifiManager mWifi;
+    private final EventFacade mEventFacade;
+
+    private final IntentFilter mScanFilter;
+    private final IntentFilter mStateChangeFilter;
+    private final IntentFilter mTetherFilter;
+    private final WifiScanReceiver mScanResultsAvailableReceiver;
+    private final WifiStateChangeReceiver mStateChangeReceiver;
+    private boolean mTrackingWifiStateChange;
+
+    private final BroadcastReceiver mTetherStateReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (WifiManager.WIFI_AP_STATE_CHANGED_ACTION.equals(action)) {
+                Log.d("Wifi AP state changed.");
+                int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_AP_STATE,
+                        WifiManager.WIFI_AP_STATE_FAILED);
+                if (state == WifiManager.WIFI_AP_STATE_ENABLED) {
+                    mEventFacade.postEvent("WifiManagerApEnabled", null);
+                } else if (state == WifiManager.WIFI_AP_STATE_DISABLED) {
+                    mEventFacade.postEvent("WifiManagerApDisabled", null);
+                }
+            } else if (ConnectivityManager.ACTION_TETHER_STATE_CHANGED.equals(action)) {
+                Log.d("Tether state changed.");
+                ArrayList<String> available = intent.getStringArrayListExtra(
+                        ConnectivityManager.EXTRA_AVAILABLE_TETHER);
+                ArrayList<String> active = intent.getStringArrayListExtra(
+                        ConnectivityManager.EXTRA_ACTIVE_TETHER);
+                ArrayList<String> errored = intent.getStringArrayListExtra(
+                        ConnectivityManager.EXTRA_ERRORED_TETHER);
+                Bundle msg = new Bundle();
+                msg.putStringArrayList("AVAILABLE_TETHER", available);
+                msg.putStringArrayList("ACTIVE_TETHER", active);
+                msg.putStringArrayList("ERRORED_TETHER", errored);
+                mEventFacade.postEvent("TetherStateChanged", msg);
+            }
+        }
+    };
+
+    private WifiLock mLock = null;
+    private boolean mIsConnected = false;
+
+    public WifiManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mWifi = (WifiManager) mService.getSystemService(Context.WIFI_SERVICE);
+        mEventFacade = manager.getReceiver(EventFacade.class);
+
+        mScanFilter = new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
+        mStateChangeFilter = new IntentFilter(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+        mStateChangeFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
+        mStateChangeFilter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
+        mStateChangeFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY - 1);
+
+        mTetherFilter = new IntentFilter(WifiManager.WIFI_AP_STATE_CHANGED_ACTION);
+        mTetherFilter.addAction(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
+
+        mScanResultsAvailableReceiver = new WifiScanReceiver(mEventFacade);
+        mStateChangeReceiver = new WifiStateChangeReceiver();
+        mTrackingWifiStateChange = false;
+    }
+
+    private void makeLock(int wifiMode) {
+        if (mLock == null) {
+            mLock = mWifi.createWifiLock(wifiMode, "sl4a");
+            mLock.acquire();
+        }
+    }
+
+    /**
+     * Handle Broadcast receiver for Scan Result
+     *
+     * @parm eventFacade Object of EventFacade
+     */
+    class WifiScanReceiver extends BroadcastReceiver {
+        private final EventFacade mEventFacade;
+
+        WifiScanReceiver(EventFacade eventFacade) {
+            mEventFacade = eventFacade;
+        }
+
+        @Override
+        public void onReceive(Context c, Intent intent) {
+            String action = intent.getAction();
+            if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
+                Bundle mResults = new Bundle();
+                Log.d("Wifi connection scan finished, results available.");
+                mResults.putLong("Timestamp", System.currentTimeMillis() / 1000);
+                mEventFacade.postEvent(mEventType + "ScanResultsAvailable", mResults);
+                mService.unregisterReceiver(mScanResultsAvailableReceiver);
+            }
+        }
+    }
+
+    class WifiActionListener implements WifiManager.ActionListener {
+        private final EventFacade mEventFacade;
+        private final String TAG;
+
+        public WifiActionListener(EventFacade eventFacade, String tag) {
+            mEventFacade = eventFacade;
+            this.TAG = tag;
+        }
+
+        @Override
+        public void onSuccess() {
+            Log.d("WifiActionListener  onSuccess called for " + mEventType + TAG + "OnSuccess");
+            mEventFacade.postEvent(mEventType + TAG + "OnSuccess", null);
+        }
+
+        @Override
+        public void onFailure(int reason) {
+            Log.d("WifiActionListener  onFailure called for" + mEventType);
+            Bundle msg = new Bundle();
+            msg.putInt("reason", reason);
+            mEventFacade.postEvent(mEventType + TAG + "OnFailure", msg);
+        }
+    }
+
+    public class WifiStateChangeReceiver extends BroadcastReceiver {
+        String mCachedWifiInfo = "";
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
+                Log.d("Wifi network state changed.");
+                NetworkInfo nInfo = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
+                WifiInfo wInfo = intent.getParcelableExtra(WifiManager.EXTRA_WIFI_INFO);
+                Log.d("NetworkInfo " + nInfo);
+                Log.d("WifiInfo " + wInfo);
+                // If network info is of type wifi, send wifi events.
+                if (nInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+                    if (wInfo != null && nInfo.getDetailedState().equals(DetailedState.CONNECTED)) {
+                        String bssid = wInfo.getBSSID();
+                        if (bssid != null && !mCachedWifiInfo.equals(wInfo.toString())) {
+                            Log.d("WifiNetworkConnected");
+                            mEventFacade.postEvent("WifiNetworkConnected", wInfo);
+                        }
+                        mCachedWifiInfo = wInfo.toString();
+                    } else {
+                        if (nInfo.getDetailedState().equals(DetailedState.DISCONNECTED)) {
+                            if (!mCachedWifiInfo.equals("")) {
+                                mCachedWifiInfo = "";
+                                mEventFacade.postEvent("WifiNetworkDisconnected", null);
+                            }
+                        }
+                    }
+                }
+            } else if (action.equals(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION)) {
+                Log.d("Supplicant connection state changed.");
+                mIsConnected = intent
+                        .getBooleanExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, false);
+                Bundle msg = new Bundle();
+                msg.putBoolean("Connected", mIsConnected);
+                mEventFacade.postEvent("SupplicantConnectionChanged", msg);
+            }
+        }
+    }
+
+    public class WifiWpsCallback extends WifiManager.WpsCallback {
+        private static final String tag = "WifiWps";
+
+        @Override
+        public void onStarted(String pin) {
+            Bundle msg = new Bundle();
+            msg.putString("pin", pin);
+            mEventFacade.postEvent(tag + "OnStarted", msg);
+        }
+
+        @Override
+        public void onSucceeded() {
+            Log.d("Wps op succeeded");
+            mEventFacade.postEvent(tag + "OnSucceeded", null);
+        }
+
+        @Override
+        public void onFailed(int reason) {
+            Bundle msg = new Bundle();
+            msg.putInt("reason", reason);
+            mEventFacade.postEvent(tag + "OnFailed", msg);
+        }
+    }
+
+    private void applyingkeyMgmt(WifiConfiguration config, ScanResult result) {
+        if (result.capabilities.contains("WEP")) {
+            config.allowedKeyManagement.set(KeyMgmt.NONE);
+            config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
+            config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
+        } else if (result.capabilities.contains("PSK")) {
+            config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
+        } else if (result.capabilities.contains("EAP")) {
+            // this is probably wrong, as we don't have a way to enter the enterprise config
+            config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
+            config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
+        } else {
+            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
+        }
+    }
+
+    private WifiConfiguration genWifiConfig(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+        WifiConfiguration config = new WifiConfiguration();
+        if (j.has("SSID")) {
+            config.SSID = "\"" + j.getString("SSID") + "\"";
+        } else if (j.has("ssid")) {
+            config.SSID = "\"" + j.getString("ssid") + "\"";
+        }
+        if (j.has("password")) {
+            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
+            config.preSharedKey = "\"" + j.getString("password") + "\"";
+        } else {
+            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
+        }
+        if (j.has("BSSID")) {
+            config.BSSID = j.getString("BSSID");
+        }
+        if (j.has("hiddenSSID")) {
+            config.hiddenSSID = j.getBoolean("hiddenSSID");
+        }
+        if (j.has("priority")) {
+            config.priority = j.getInt("priority");
+        }
+        if (j.has("apBand")) {
+            config.apBand = j.getInt("apBand");
+        }
+        if (j.has("preSharedKey")) {
+            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
+            config.preSharedKey = j.getString("preSharedKey");
+        }
+        if (j.has("wepKeys")) {
+            // Looks like we only support static WEP.
+            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
+            config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
+            config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
+            JSONArray keys = j.getJSONArray("wepKeys");
+            String[] wepKeys = new String[keys.length()];
+            for (int i = 0; i < keys.length(); i++) {
+                wepKeys[i] = keys.getString(i);
+            }
+            config.wepKeys = wepKeys;
+        }
+        if (j.has("wepTxKeyIndex")) {
+            config.wepTxKeyIndex = j.getInt("wepTxKeyIndex");
+        }
+        return config;
+    }
+
+    private WifiConfiguration genWifiEnterpriseConfig(JSONObject j) throws JSONException,
+            GeneralSecurityException {
+        if (j == null) {
+            return null;
+        }
+        WifiConfiguration config = new WifiConfiguration();
+        config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
+        config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
+        if (j.has("SSID")) {
+            config.SSID = j.getString("SSID");
+        }
+        if (j.has("FQDN")) {
+            config.FQDN = j.getString("FQDN");
+        }
+        if (j.has("providerFriendlyName")) {
+            config.providerFriendlyName = j.getString("providerFriendlyName");
+        }
+        if (j.has("roamingConsortiumIds")) {
+            JSONArray ids = j.getJSONArray("roamingConsortiumIds");
+            long[] rIds = new long[ids.length()];
+            for (int i = 0; i < ids.length(); i++) {
+                rIds[i] = ids.getLong(i);
+            }
+            config.roamingConsortiumIds = rIds;
+        }
+        WifiEnterpriseConfig eConfig = new WifiEnterpriseConfig();
+        if (j.has(WifiEnterpriseConfig.EAP_KEY)) {
+            int eap = j.getInt(WifiEnterpriseConfig.EAP_KEY);
+            eConfig.setEapMethod(eap);
+        }
+        if (j.has(WifiEnterpriseConfig.PHASE2_KEY)) {
+            int p2Method = j.getInt(WifiEnterpriseConfig.PHASE2_KEY);
+            eConfig.setPhase2Method(p2Method);
+        }
+        if (j.has(WifiEnterpriseConfig.CA_CERT_KEY)) {
+            String certStr = j.getString(WifiEnterpriseConfig.CA_CERT_KEY);
+            Log.v("CA Cert String is " + certStr);
+            eConfig.setCaCertificate(strToX509Cert(certStr));
+        }
+        if (j.has(WifiEnterpriseConfig.CLIENT_CERT_KEY)
+                && j.has(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY)) {
+            String certStr = j.getString(WifiEnterpriseConfig.CLIENT_CERT_KEY);
+            String keyStr = j.getString(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY);
+            Log.v("Client Cert String is " + certStr);
+            Log.v("Client Key String is " + keyStr);
+            X509Certificate cert = strToX509Cert(certStr);
+            PrivateKey privKey = strToPrivateKey(keyStr);
+            Log.v("Cert is " + cert);
+            Log.v("Private Key is " + privKey);
+            eConfig.setClientKeyEntry(privKey, cert);
+        }
+        if (j.has(WifiEnterpriseConfig.IDENTITY_KEY)) {
+            String identity = j.getString(WifiEnterpriseConfig.IDENTITY_KEY);
+            Log.v("Setting identity to " + identity);
+            eConfig.setIdentity(identity);
+        }
+        if (j.has(WifiEnterpriseConfig.PASSWORD_KEY)) {
+            String pwd = j.getString(WifiEnterpriseConfig.PASSWORD_KEY);
+            Log.v("Setting password to " + pwd);
+            eConfig.setPassword(pwd);
+        }
+        if (j.has(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY)) {
+            String altSub = j.getString(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY);
+            Log.v("Setting Alt Subject to " + altSub);
+            eConfig.setAltSubjectMatch(altSub);
+        }
+        if (j.has(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY)) {
+            String domSuffix = j.getString(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY);
+            Log.v("Setting Domain Suffix Match to " + domSuffix);
+            eConfig.setDomainSuffixMatch(domSuffix);
+        }
+        if (j.has(WifiEnterpriseConfig.REALM_KEY)) {
+            String realm = j.getString(WifiEnterpriseConfig.REALM_KEY);
+            Log.v("Setting Domain Suffix Match to " + realm);
+            eConfig.setRealm(realm);
+        }
+        config.enterpriseConfig = eConfig;
+        return config;
+    }
+
+    private boolean matchScanResult(ScanResult result, String id) {
+        if (result.BSSID.equals(id) || result.SSID.equals(id)) {
+            return true;
+        }
+        return false;
+    }
+
+    private WpsInfo parseWpsInfo(String infoStr) throws JSONException {
+        if (infoStr == null) {
+            return null;
+        }
+        JSONObject j = new JSONObject(infoStr);
+        WpsInfo info = new WpsInfo();
+        if (j.has("setup")) {
+            info.setup = j.getInt("setup");
+        }
+        if (j.has("BSSID")) {
+            info.BSSID = j.getString("BSSID");
+        }
+        if (j.has("pin")) {
+            info.pin = j.getString("pin");
+        }
+        return info;
+    }
+
+    private byte[] base64StrToBytes(String input) {
+        return Base64.decode(input, Base64.DEFAULT);
+    }
+
+    private X509Certificate strToX509Cert(String certStr) throws CertificateException {
+        byte[] certBytes = base64StrToBytes(certStr);
+        InputStream certStream = new ByteArrayInputStream(certBytes);
+        CertificateFactory cf = CertificateFactory.getInstance("X509");
+        return (X509Certificate) cf.generateCertificate(certStream);
+    }
+
+    private PrivateKey strToPrivateKey(String key) throws NoSuchAlgorithmException,
+            InvalidKeySpecException {
+        byte[] keyBytes = base64StrToBytes(key);
+        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
+        KeyFactory fact = KeyFactory.getInstance("RSA");
+        PrivateKey priv = fact.generatePrivate(keySpec);
+        return priv;
+    }
+
+    private PublicKey strToPublicKey(String key) throws NoSuchAlgorithmException,
+            InvalidKeySpecException {
+        byte[] keyBytes = base64StrToBytes(key);
+        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
+        KeyFactory fact = KeyFactory.getInstance("RSA");
+        PublicKey pub = fact.generatePublic(keySpec);
+        return pub;
+    }
+
+    private WifiConfiguration wifiConfigurationFromScanResult(ScanResult result) {
+        if (result == null)
+            return null;
+        WifiConfiguration config = new WifiConfiguration();
+        config.SSID = "\"" + result.SSID + "\"";
+        applyingkeyMgmt(config, result);
+        config.BSSID = result.BSSID;
+        return config;
+    }
+
+    @Rpc(description = "test.")
+    public String wifiTest(String certString) throws CertificateException, IOException {
+        // TODO(angli): Make this work. Convert a X509Certificate back to a string.
+        X509Certificate caCert = strToX509Cert(certString);
+        caCert.getEncoded();
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        ObjectOutput out = new ObjectOutputStream(bos);
+        out.writeObject(caCert);
+        byte[] data = bos.toByteArray();
+        bos.close();
+        return Base64.encodeToString(data, Base64.DEFAULT);
+    }
+
+    @Rpc(description = "Add a network.")
+    public Integer wifiAddNetwork(@RpcParameter(name = "wifiConfig") JSONObject wifiConfig)
+            throws JSONException {
+        return mWifi.addNetwork(genWifiConfig(wifiConfig));
+    }
+
+    @Rpc(description = "Builds a WifiConfiguration from Hotspot 2.0 MIME file.")
+    public WifiConfiguration wifiBuildConfig(
+            @RpcParameter(name = "uriString") String uriString,
+            @RpcParameter(name = "mimeType") String mimeType,
+            String dataString)
+                    throws JSONException {
+        byte[] data = base64StrToBytes(dataString);
+        return mWifi.buildWifiConfig(uriString, mimeType, data);
+    }
+
+    @Rpc(description = "Cancel Wi-fi Protected Setup.")
+    public void wifiCancelWps() throws JSONException {
+        WifiWpsCallback listener = new WifiWpsCallback();
+        mWifi.cancelWps(listener);
+    }
+
+    @Rpc(description = "Checks Wifi state.", returns = "True if Wifi is enabled.")
+    public Boolean wifiCheckState() {
+        return mWifi.getWifiState() == WifiManager.WIFI_STATE_ENABLED;
+    }
+
+    /**
+     * Connects to a WPA protected wifi network
+     *
+     * @param wifiSSID SSID of the wifi network
+     * @param wifiPassword password for the wifi network
+     * @return true on success
+     * @throws ConnectException
+     * @throws JSONException
+     */
+    @Rpc(description = "Connects a wifi network by ssid", returns = "True if the operation succeeded.")
+    public Boolean wifiConnect(@RpcParameter(name = "config") JSONObject config)
+            throws ConnectException, JSONException {
+        WifiConfiguration wifiConfig = genWifiConfig(config);
+        int nId = mWifi.addNetwork(wifiConfig);
+        if (nId < 0) {
+            Log.e("Got negative network Id.");
+            return false;
+        }
+        mWifi.disconnect();
+        mWifi.enableNetwork(nId, true);
+        return mWifi.reconnect();
+    }
+
+    @Rpc(description = "Disconnects from the currently active access point.", returns = "True if the operation succeeded.")
+    public Boolean wifiDisconnect() {
+        return mWifi.disconnect();
+    }
+
+    @Rpc(description = "Enable/disable autojoin scan and switch network when connected.")
+    public Boolean wifiEnableAutoJoinWhenAssociated(@RpcParameter(name = "enable") Boolean enable) {
+        return mWifi.enableAutoJoinWhenAssociated(enable);
+    }
+
+    @Rpc(description = "Enable a configured network. Initiate a connection if disableOthers is true", returns = "True if the operation succeeded.")
+    public Boolean wifiEnableNetwork(@RpcParameter(name = "netId") Integer netId,
+            @RpcParameter(name = "disableOthers") Boolean disableOthers) {
+        return mWifi.enableNetwork(netId, disableOthers);
+    }
+
+    @Rpc(description = "Enable WiFi verbose logging.")
+    public void wifiEnableVerboseLogging(@RpcParameter(name = "level") Integer level) {
+        mWifi.enableVerboseLogging(level);
+    }
+
+    @Rpc(description = "Connect to a wifi network that uses Enterprise authentication methods.")
+    public void wifiEnterpriseConnect(@RpcParameter(name = "config") JSONObject config)
+            throws JSONException, GeneralSecurityException {
+        // Create Certificate
+        WifiActionListener listener = new WifiActionListener(mEventFacade, "EnterpriseConnect");
+        WifiConfiguration wifiConfig = genWifiEnterpriseConfig(config);
+        if (wifiConfig.isPasspoint()) {
+            Log.d("Got a passpoint config, add it and save config.");
+            mWifi.addNetwork(wifiConfig);
+            mWifi.saveConfiguration();
+        } else {
+            Log.d("Got a non-passpoint enterprise config, connect directly.");
+            mWifi.connect(wifiConfig, listener);
+        }
+    }
+
+    @Rpc(description = "Resets all WifiManager settings.")
+    public void wifiFactoryReset() {
+        mWifi.factoryReset();
+    }
+
+    /**
+     * Forget a wifi network with priority
+     *
+     * @param networkID Id of wifi network
+     */
+    @Rpc(description = "Forget a wifi network with priority")
+    public void wifiForgetNetwork(@RpcParameter(name = "wifiSSID") Integer newtorkId) {
+        WifiActionListener listener = new WifiActionListener(mEventFacade, "ForgetNetwork");
+        mWifi.forget(newtorkId, listener);
+    }
+
+    @Rpc(description = "Gets the Wi-Fi AP Configuration.")
+    public WifiConfiguration wifiGetApConfiguration() {
+        return mWifi.getWifiApConfiguration();
+    }
+
+    @Rpc(description = "Returns the file in which IP and proxy configuration data is stored.")
+    public String wifiGetConfigFile() {
+        return mWifi.getConfigFile();
+    }
+
+    @Rpc(description = "Return a list of all the configured wifi networks.")
+    public List<WifiConfiguration> wifiGetConfiguredNetworks() {
+        return mWifi.getConfiguredNetworks();
+    }
+
+    @Rpc(description = "Returns information about the currently active access point.")
+    public WifiInfo wifiGetConnectionInfo() {
+        return mWifi.getConnectionInfo();
+    }
+
+    @Rpc(description = "Returns wifi activity and energy usage info.")
+    public WifiActivityEnergyInfo wifiGetControllerActivityEnergyInfo() {
+        return mWifi.getControllerActivityEnergyInfo(0);
+    }
+
+    @Rpc(description = "Get the country code used by WiFi.")
+    public String wifiGetCountryCode() {
+        return mWifi.getCountryCode();
+    }
+
+    @Rpc(description = "Get the current network.")
+    public Network wifiGetCurrentNetwork() {
+        return mWifi.getCurrentNetwork();
+    }
+
+    @Rpc(description = "Get the info from last successful DHCP request.")
+    public DhcpInfo wifiGetDhcpInfo() {
+        return mWifi.getDhcpInfo();
+    }
+
+    @Rpc(description = "Get setting for Framework layer autojoin enable status.")
+    public Boolean wifiGetEnableAutoJoinWhenAssociated() {
+        return mWifi.getEnableAutoJoinWhenAssociated();
+    }
+
+    @Rpc(description = "Returns 1 if autojoin offload thru Wifi HAL layer is enabled, 0 otherwise.")
+    public Integer wifiGetHalBasedAutojoinOffload() {
+        return mWifi.getHalBasedAutojoinOffload();
+    }
+
+    @Rpc(description = "Get privileged configured networks.")
+    public List<WifiConfiguration> wifiGetPrivilegedConfiguredNetworks() {
+        return mWifi.getPrivilegedConfiguredNetworks();
+    }
+
+    @Rpc(description = "Returns the list of access points found during the most recent Wifi scan.")
+    public List<ScanResult> wifiGetScanResults() {
+        return mWifi.getScanResults();
+    }
+
+    @Rpc(description = "Get the current level of WiFi verbose logging.")
+    public Integer wifiGetVerboseLoggingLevel() {
+        return mWifi.getVerboseLoggingLevel();
+    }
+
+    @Rpc(description = "true if this adapter supports 5 GHz band.")
+    public Boolean wifiIs5GHzBandSupported() {
+        return mWifi.is5GHzBandSupported();
+    }
+
+    @Rpc(description = "true if this adapter supports multiple simultaneous connections.")
+    public Boolean wifiIsAdditionalStaSupported() {
+        return mWifi.isAdditionalStaSupported();
+    }
+
+    @Rpc(description = "Return whether Wi-Fi AP is enabled or disabled.")
+    public Boolean wifiIsApEnabled() {
+        return mWifi.isWifiApEnabled();
+    }
+
+    @Rpc(description = "Check if Device-to-AP RTT is supported.")
+    public Boolean wifiIsDeviceToApRttSupported() {
+        return mWifi.isDeviceToApRttSupported();
+    }
+
+    @Rpc(description = "Check if Device-to-device RTT is supported.")
+    public Boolean wifiIsDeviceToDeviceRttSupported() {
+        return mWifi.isDeviceToDeviceRttSupported();
+    }
+
+    @Rpc(description = "Check if the chipset supports dual frequency band (2.4 GHz and 5 GHz).")
+    public Boolean wifiIsDualBandSupported() {
+        return mWifi.isDualBandSupported();
+    }
+
+    @Rpc(description = "Check if this adapter supports advanced power/performance counters.")
+    public Boolean wifiIsEnhancedPowerReportingSupported() {
+        return mWifi.isEnhancedPowerReportingSupported();
+    }
+
+    @Rpc(description = "Check if multicast is enabled.")
+    public Boolean wifiIsMulticastEnabled() {
+        return mWifi.isMulticastEnabled();
+    }
+
+    @Rpc(description = "true if this adapter supports Neighbour Awareness Network APIs.")
+    public Boolean wifiIsNanSupported() {
+        return mWifi.isNanSupported();
+    }
+
+    @Rpc(description = "true if this adapter supports Off Channel Tunnel Directed Link Setup.")
+    public Boolean wifiIsOffChannelTdlsSupported() {
+        return mWifi.isOffChannelTdlsSupported();
+    }
+
+    @Rpc(description = "true if this adapter supports WifiP2pManager (Wi-Fi Direct).")
+    public Boolean wifiIsP2pSupported() {
+        return mWifi.isP2pSupported();
+    }
+
+    @Rpc(description = "true if this adapter supports passpoint.")
+    public Boolean wifiIsPasspointSupported() {
+        return mWifi.isPasspointSupported();
+    }
+
+    @Rpc(description = "true if this adapter supports portable Wi-Fi hotspot.")
+    public Boolean wifiIsPortableHotspotSupported() {
+        return mWifi.isPortableHotspotSupported();
+    }
+
+    @Rpc(description = "true if this adapter supports offloaded connectivity scan.")
+    public Boolean wifiIsPreferredNetworkOffloadSupported() {
+        return mWifi.isPreferredNetworkOffloadSupported();
+    }
+
+    @Rpc(description = "Check if wifi scanner is supported on this device.")
+    public Boolean wifiIsScannerSupported() {
+        return mWifi.isWifiScannerSupported();
+    }
+
+    @Rpc(description = "Check if tdls is supported on this device.")
+    public Boolean wifiIsTdlsSupported() {
+        return mWifi.isTdlsSupported();
+    }
+
+    @Rpc(description = "Acquires a full Wifi lock.")
+    public void wifiLockAcquireFull() {
+        makeLock(WifiManager.WIFI_MODE_FULL);
+    }
+
+    @Rpc(description = "Acquires a scan only Wifi lock.")
+    public void wifiLockAcquireScanOnly() {
+        makeLock(WifiManager.WIFI_MODE_SCAN_ONLY);
+    }
+
+    @Rpc(description = "Releases a previously acquired Wifi lock.")
+    public void wifiLockRelease() {
+        if (mLock != null) {
+            mLock.release();
+            mLock = null;
+        }
+    }
+
+    /**
+     * Connects to a wifi network with priority
+     *
+     * @param wifiSSID SSID of the wifi network
+     * @param wifiPassword password for the wifi network
+     * @throws JSONException
+     */
+    @Rpc(description = "Connects a wifi network as priority by pasing ssid")
+    public void wifiPriorityConnect(@RpcParameter(name = "config") JSONObject config)
+            throws JSONException {
+        WifiConfiguration wifiConfig = genWifiConfig(config);
+        WifiActionListener listener = new WifiActionListener(mEventFacade, "PriorityConnect");
+        mWifi.connect(wifiConfig, listener);
+    }
+
+    @Rpc(description = "Reassociates with the currently active access point.", returns = "True if the operation succeeded.")
+    public Boolean wifiReassociate() {
+        return mWifi.reassociate();
+    }
+
+    @Rpc(description = "Reconnects to the currently active access point.", returns = "True if the operation succeeded.")
+    public Boolean wifiReconnect() {
+        return mWifi.reconnect();
+    }
+
+    @Rpc(description = "Remove a configured network.", returns = "True if the operation succeeded.")
+    public Boolean wifiRemoveNetwork(@RpcParameter(name = "netId") Integer netId) {
+        return mWifi.removeNetwork(netId);
+    }
+
+    @Rpc(description = "Start/stop wifi soft AP.")
+    public Boolean wifiSetApEnabled(
+            @RpcParameter(name = "enable") Boolean enable,
+            @RpcParameter(name = "configJson") JSONObject configJson) throws JSONException {
+        int wifiState = mWifi.getWifiState();
+        if (enable) {
+            if ((wifiState == WifiManager.WIFI_STATE_ENABLING) ||
+                    (wifiState == WifiManager.WIFI_STATE_ENABLED)) {
+                mWifi.setWifiEnabled(false);
+            }
+            WifiConfiguration config = genWifiConfig(configJson);
+            // Need to strip of extra quotation marks for SSID and password.
+            String ssid = config.SSID;
+            if (ssid != null) {
+                config.SSID = ssid.substring(1, ssid.length() - 1);
+            }
+            String pwd = config.preSharedKey;
+            if (pwd != null) {
+                config.preSharedKey = pwd.substring(1, pwd.length() - 1);
+            }
+            return mWifi.setWifiApEnabled(config, enable);
+        } else {
+            return mWifi.setWifiApEnabled(null, false);
+        }
+    }
+
+    @Rpc(description = "Set the country code used by WiFi.")
+    public void wifiSetCountryCode(
+            @RpcParameter(name = "country") String country,
+            @RpcParameter(name = "persist") Boolean persist) {
+        mWifi.setCountryCode(country, persist);
+    }
+
+    @Rpc(description = "Enable/disable autojoin offload through Wifi HAL layer.")
+    public void wifiSetHalBasedAutojoinOffload(
+            @RpcParameter(name = "enable") Integer enable) {
+        mWifi.setHalBasedAutojoinOffload(enable);
+    }
+
+    @Rpc(description = "Enable/disable tdls with a mac address.")
+    public void wifiSetTdlsEnabledWithMacAddress(
+            @RpcParameter(name = "remoteMacAddress") String remoteMacAddress,
+            @RpcParameter(name = "enable") Boolean enable) {
+        mWifi.setTdlsEnabledWithMacAddress(remoteMacAddress, enable);
+    }
+
+    @Rpc(description = "Starts a scan for Wifi access points.", returns = "True if the scan was initiated successfully.")
+    public Boolean wifiStartScan() {
+        mService.registerReceiver(mScanResultsAvailableReceiver, mScanFilter);
+        return mWifi.startScan();
+    }
+
+    @Rpc(description = "Start Wi-fi Protected Setup.")
+    public void wifiStartWps(
+            @RpcParameter(name = "config", description = "A json string with fields \"setup\", \"BSSID\", and \"pin\"") String config)
+                    throws JSONException {
+        WpsInfo info = parseWpsInfo(config);
+        WifiWpsCallback listener = new WifiWpsCallback();
+        Log.d("Starting wps with: " + info);
+        mWifi.startWps(info, listener);
+    }
+
+    @Rpc(description = "Start listening for wifi state change related broadcasts.")
+    public void wifiStartTrackingStateChange() {
+        mService.registerReceiver(mStateChangeReceiver, mStateChangeFilter);
+        mService.registerReceiver(mTetherStateReceiver, mTetherFilter);
+        mTrackingWifiStateChange = true;
+    }
+
+    @Rpc(description = "Stop listening for wifi state change related broadcasts.")
+    public void wifiStopTrackingStateChange() {
+        if (mTrackingWifiStateChange == true) {
+            mService.unregisterReceiver(mTetherStateReceiver);
+            mService.unregisterReceiver(mStateChangeReceiver);
+            mTrackingWifiStateChange = false;
+        }
+    }
+
+    @Rpc(description = "Toggle Wifi on and off.", returns = "True if Wifi is enabled.")
+    public Boolean wifiToggleState(@RpcParameter(name = "enabled") @RpcOptional Boolean enabled) {
+        if (enabled == null) {
+            enabled = !wifiCheckState();
+        }
+        mWifi.setWifiEnabled(enabled);
+        return enabled;
+    }
+
+    @Rpc(description = "Toggle Wifi scan always available on and off.", returns = "True if Wifi scan is always available.")
+    public Boolean wifiToggleScanAlwaysAvailable(
+            @RpcParameter(name = "enabled") @RpcOptional Boolean enabled)
+                    throws SettingNotFoundException {
+        ContentResolver cr = mService.getContentResolver();
+        int isSet = 0;
+        if (enabled == null) {
+            isSet = Global.getInt(cr, Global.WIFI_SCAN_ALWAYS_AVAILABLE);
+            isSet ^= 1;
+        } else if (enabled == true) {
+            isSet = 1;
+        }
+        Global.putInt(cr, Global.WIFI_SCAN_ALWAYS_AVAILABLE, isSet);
+        if (isSet == 1) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void shutdown() {
+        wifiLockRelease();
+        if (mTrackingWifiStateChange == true) {
+            wifiStopTrackingStateChange();
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/wifi/WifiNanManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiNanManagerFacade.java
new file mode 100644
index 0000000..5863e8d
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiNanManagerFacade.java
@@ -0,0 +1,403 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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 com.googlecode.android_scripting.facade.wifi;
+
+import android.app.Service;
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.wifi.nan.ConfigRequest;
+import android.net.wifi.nan.PublishData;
+import android.net.wifi.nan.PublishSettings;
+import android.net.wifi.nan.SubscribeData;
+import android.net.wifi.nan.SubscribeSettings;
+import android.net.wifi.nan.TlvBufferUtils;
+import android.net.wifi.nan.WifiNanEventListener;
+import android.net.wifi.nan.WifiNanManager;
+import android.net.wifi.nan.WifiNanSession;
+import android.net.wifi.nan.WifiNanSessionListener;
+import android.os.Bundle;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.RemoteException;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * WifiNanManager functions.
+ */
+public class WifiNanManagerFacade extends RpcReceiver {
+    private final Service mService;
+    private final EventFacade mEventFacade;
+
+    private WifiNanManager mMgr;
+    private WifiNanSession mSession;
+    private HandlerThread mNanFacadeThread;
+    private ConnectivityManager mConnMgr;
+
+    private static TlvBufferUtils.TlvConstructor getFilterData(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+
+        TlvBufferUtils.TlvConstructor constructor = new TlvBufferUtils.TlvConstructor(0, 1);
+        constructor.allocate(255);
+
+        if (j.has("int0")) {
+            constructor.putShort(0, (short) j.getInt("int0"));
+        }
+
+        if (j.has("int1")) {
+            constructor.putShort(0, (short) j.getInt("int1"));
+        }
+
+        if (j.has("data0")) {
+            constructor.putString(0, j.getString("data0"));
+        }
+
+        if (j.has("data1")) {
+            constructor.putString(0, j.getString("data1"));
+        }
+
+        return constructor;
+    }
+
+    private static ConfigRequest getConfigRequest(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+
+        ConfigRequest.Builder builder = new ConfigRequest.Builder();
+
+        if (j.has("Support5gBand")) {
+            builder.setSupport5gBand(j.getBoolean("Support5gBand"));
+        }
+        if (j.has("MasterPreference")) {
+            builder.setMasterPreference(j.getInt("MasterPreference"));
+        }
+        if (j.has("ClusterLow")) {
+            builder.setClusterLow(j.getInt("ClusterLow"));
+        }
+        if (j.has("ClusterHigh")) {
+            builder.setClusterHigh(j.getInt("ClusterHigh"));
+        }
+
+        return builder.build();
+    }
+
+    private static PublishData getPublishData(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+
+        PublishData.Builder builder = new PublishData.Builder();
+
+        if (j.has("ServiceName")) {
+            builder.setServiceName(j.getString("ServiceName"));
+        }
+
+        if (j.has("ServiceSpecificInfo")) {
+            String ssi = j.getString("ServiceSpecificInfo");
+            builder.setServiceSpecificInfo(ssi.getBytes(), ssi.length());
+        }
+
+        if (j.has("TxFilter")) {
+            TlvBufferUtils.TlvConstructor constructor = getFilterData(j.getJSONObject("TxFilter"));
+            builder.setTxFilter(constructor.getArray(), constructor.getActualLength());
+        }
+
+        if (j.has("RxFilter")) {
+            TlvBufferUtils.TlvConstructor constructor = getFilterData(j.getJSONObject("RxFilter"));
+            builder.setRxFilter(constructor.getArray(), constructor.getActualLength());
+        }
+
+        return builder.build();
+    }
+
+    private static PublishSettings getPublishSettings(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+
+        PublishSettings.Builder builder = new PublishSettings.Builder();
+
+        if (j.has("PublishType")) {
+            builder.setPublishType(j.getInt("PublishType"));
+        }
+        if (j.has("PublishCount")) {
+            builder.setPublishCount(j.getInt("PublishCount"));
+        }
+        if (j.has("TtlSec")) {
+            builder.setTtlSec(j.getInt("TtlSec"));
+        }
+
+        return builder.build();
+    }
+
+    private static SubscribeData getSubscribeData(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+
+        SubscribeData.Builder builder = new SubscribeData.Builder();
+
+        if (j.has("ServiceName")) {
+            builder.setServiceName(j.getString("ServiceName"));
+        }
+
+        if (j.has("ServiceSpecificInfo")) {
+            String ssi = j.getString("ServiceSpecificInfo");
+            builder.setServiceSpecificInfo(ssi);
+        }
+
+        if (j.has("TxFilter")) {
+            TlvBufferUtils.TlvConstructor constructor = getFilterData(j.getJSONObject("TxFilter"));
+            builder.setTxFilter(constructor.getArray(), constructor.getActualLength());
+        }
+
+        if (j.has("RxFilter")) {
+            TlvBufferUtils.TlvConstructor constructor = getFilterData(j.getJSONObject("RxFilter"));
+            builder.setRxFilter(constructor.getArray(), constructor.getActualLength());
+        }
+
+        return builder.build();
+    }
+
+    private static SubscribeSettings getSubscribeSettings(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+
+        SubscribeSettings.Builder builder = new SubscribeSettings.Builder();
+
+        if (j.has("SubscribeType")) {
+            builder.setSubscribeType(j.getInt("SubscribeType"));
+        }
+        if (j.has("SubscribeCount")) {
+            builder.setSubscribeCount(j.getInt("SubscribeCount"));
+        }
+        if (j.has("TtlSec")) {
+            builder.setTtlSec(j.getInt("TtlSec"));
+        }
+
+        return builder.build();
+    }
+
+    public WifiNanManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+
+        mNanFacadeThread = new HandlerThread("nanFacadeThread");
+        mNanFacadeThread.start();
+
+        mMgr = (WifiNanManager) mService.getSystemService(Context.WIFI_NAN_SERVICE);
+        mMgr.connect(new NanEventListenerPostsEvents(mNanFacadeThread.getLooper()),
+                WifiNanEventListener.LISTEN_CONFIG_COMPLETED
+                        | WifiNanEventListener.LISTEN_CONFIG_FAILED
+                        | WifiNanEventListener.LISTEN_NAN_DOWN
+                        | WifiNanEventListener.LISTEN_IDENTITY_CHANGED);
+
+        mConnMgr = (ConnectivityManager) mService.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+        mEventFacade = manager.getReceiver(EventFacade.class);
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Rpc(description = "Start NAN.")
+    public void wifiNanEnable(@RpcParameter(name = "nanConfig") JSONObject nanConfig)
+            throws RemoteException, JSONException {
+        mMgr.requestConfig(getConfigRequest(nanConfig));
+    }
+
+    @Rpc(description = "Stop NAN.")
+    public void wifiNanDisable() throws RemoteException, JSONException {
+        mMgr.disconnect();
+    }
+
+    @Rpc(description = "Publish.")
+    public void wifiNanPublish(@RpcParameter(name = "publishData") JSONObject publishData,
+            @RpcParameter(name = "publishSettings") JSONObject publishSettings,
+            @RpcParameter(name = "listenerId") Integer listenerId)
+                    throws RemoteException, JSONException {
+        mSession = mMgr.publish(getPublishData(publishData), getPublishSettings(publishSettings),
+                new NanSessionListenerPostsEvents(mNanFacadeThread.getLooper(), listenerId),
+                WifiNanSessionListener.LISTEN_PUBLISH_FAIL
+                        | WifiNanSessionListener.LISTEN_PUBLISH_TERMINATED
+                        | WifiNanSessionListener.LISTEN_SUBSCRIBE_FAIL
+                        | WifiNanSessionListener.LISTEN_SUBSCRIBE_TERMINATED
+                        | WifiNanSessionListener.LISTEN_MATCH
+                        | WifiNanSessionListener.LISTEN_MESSAGE_SEND_SUCCESS
+                        | WifiNanSessionListener.LISTEN_MESSAGE_SEND_FAIL
+                        | WifiNanSessionListener.LISTEN_MESSAGE_RECEIVED);
+    }
+
+    @Rpc(description = "Subscribe.")
+    public void wifiNanSubscribe(@RpcParameter(name = "subscribeData") JSONObject subscribeData,
+            @RpcParameter(name = "subscribeSettings") JSONObject subscribeSettings,
+            @RpcParameter(name = "listenerId") Integer listenerId)
+                    throws RemoteException, JSONException {
+
+        mSession = mMgr.subscribe(getSubscribeData(subscribeData),
+                getSubscribeSettings(subscribeSettings),
+                new NanSessionListenerPostsEvents(mNanFacadeThread.getLooper(), listenerId),
+                WifiNanSessionListener.LISTEN_PUBLISH_FAIL
+                        | WifiNanSessionListener.LISTEN_PUBLISH_TERMINATED
+                        | WifiNanSessionListener.LISTEN_SUBSCRIBE_FAIL
+                        | WifiNanSessionListener.LISTEN_SUBSCRIBE_TERMINATED
+                        | WifiNanSessionListener.LISTEN_MATCH
+                        | WifiNanSessionListener.LISTEN_MESSAGE_SEND_SUCCESS
+                        | WifiNanSessionListener.LISTEN_MESSAGE_SEND_FAIL
+                        | WifiNanSessionListener.LISTEN_MESSAGE_RECEIVED);
+    }
+
+    @Rpc(description = "Send peer-to-peer NAN message")
+    public void wifiNanSendMessage(
+            @RpcParameter(name = "peerId", description = "The ID of the peer being communicated "
+                    + "with. Obtained from a previous message or match session.") Integer peerId,
+            @RpcParameter(name = "message") String message,
+            @RpcParameter(name = "messageId", description = "Arbitrary handle used for "
+                    + "identification of the message in the message status callbacks")
+            Integer messageId)
+                    throws RemoteException {
+        mSession.sendMessage(peerId, message.getBytes(), message.length(), messageId);
+    }
+
+    private class NanEventListenerPostsEvents extends WifiNanEventListener {
+        public NanEventListenerPostsEvents(Looper looper) {
+            super(looper);
+        }
+
+        @Override
+        public void onConfigCompleted(ConfigRequest configRequest) {
+            Bundle mResults = new Bundle();
+            mResults.putParcelable("configRequest", configRequest);
+            mEventFacade.postEvent("WifiNanOnConfigCompleted", mResults);
+        }
+
+        @Override
+        public void onConfigFailed(ConfigRequest failedConfig, int reason) {
+            Bundle mResults = new Bundle();
+            mResults.putParcelable("failedConfig", failedConfig);
+            mResults.putInt("reason", reason);
+            mEventFacade.postEvent("WifiNanOnConfigFailed", mResults);
+        }
+
+        @Override
+        public void onNanDown(int reason) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("reason", reason);
+            mEventFacade.postEvent("WifiNanOnNanDown", mResults);
+        }
+
+        @Override
+        public void onIdentityChanged() {
+            Bundle mResults = new Bundle();
+            mEventFacade.postEvent("WifiNanOnIdentityChanged", mResults);
+        }
+    }
+
+    private class NanSessionListenerPostsEvents extends WifiNanSessionListener {
+        private int mListenerId;
+
+        public NanSessionListenerPostsEvents(Looper looper, int listenerId) {
+            super(looper);
+            mListenerId = listenerId;
+        }
+
+        @Override
+        public void onPublishFail(int reason) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("reason", reason);
+            mEventFacade.postEvent("WifiNanSessionOnPublishFail", mResults);
+        }
+
+        @Override
+        public void onPublishTerminated(int reason) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("reason", reason);
+            mEventFacade.postEvent("WifiNanSessionOnPublishTerminated", mResults);
+        }
+
+        @Override
+        public void onSubscribeFail(int reason) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("reason", reason);
+            mEventFacade.postEvent("WifiNanSessionOnSubscribeFail", mResults);
+        }
+
+        @Override
+        public void onSubscribeTerminated(int reason) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("reason", reason);
+            mEventFacade.postEvent("WifiNanSessionOnSubscribeTerminated", mResults);
+        }
+
+        @Override
+        public void onMatch(int peerId, byte[] serviceSpecificInfo,
+                int serviceSpecificInfoLength, byte[] matchFilter, int matchFilterLength) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("peerId", peerId);
+            mResults.putInt("serviceSpecificInfoLength", serviceSpecificInfoLength);
+            mResults.putByteArray("serviceSpecificInfo", serviceSpecificInfo); // TODO: base64
+            mResults.putInt("matchFilterLength", matchFilterLength);
+            mResults.putByteArray("matchFilter", matchFilter); // TODO: base64
+            mEventFacade.postEvent("WifiNanSessionOnMatch", mResults);
+        }
+
+        @Override
+        public void onMessageSendSuccess(int messageId) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("messageId", messageId);
+            mEventFacade.postEvent("WifiNanSessionOnMessageSendSuccess", mResults);
+        }
+
+        @Override
+        public void onMessageSendFail(int messageId, int reason) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("messageId", messageId);
+            mResults.putInt("reason", reason);
+            mEventFacade.postEvent("WifiNanSessionOnMessageSendFail", mResults);
+        }
+
+        @Override
+        public void onMessageReceived(int peerId, byte[] message, int messageLength) {
+            Bundle mResults = new Bundle();
+            mResults.putInt("listenerId", mListenerId);
+            mResults.putInt("peerId", peerId);
+            mResults.putInt("messageLength", messageLength);
+            mResults.putByteArray("message", message); // TODO: base64
+            mResults.putString("messageAsString", new String(message, 0, messageLength));
+            mEventFacade.postEvent("WifiNanSessionOnMessageReceived", mResults);
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/wifi/WifiP2pManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiP2pManagerFacade.java
new file mode 100644
index 0000000..d0514b9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiP2pManagerFacade.java
@@ -0,0 +1,506 @@
+
+package com.googlecode.android_scripting.facade.wifi;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.NetworkInfo;
+import android.net.wifi.WpsInfo;
+import android.net.wifi.p2p.WifiP2pConfig;
+import android.net.wifi.p2p.WifiP2pDevice;
+import android.net.wifi.p2p.WifiP2pDeviceList;
+import android.net.wifi.p2p.WifiP2pGroup;
+import android.net.wifi.p2p.WifiP2pGroupList;
+import android.net.wifi.p2p.WifiP2pInfo;
+import android.net.wifi.p2p.WifiP2pManager;
+import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceInfo;
+import android.net.wifi.p2p.nsd.WifiP2pServiceInfo;
+import android.net.wifi.p2p.nsd.WifiP2pServiceRequest;
+import android.net.wifi.p2p.nsd.WifiP2pUpnpServiceInfo;
+import android.os.Bundle;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+
+import com.android.internal.util.Protocol;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * WifiP2pManager functions.
+ */
+public class WifiP2pManagerFacade extends RpcReceiver {
+
+    class WifiP2pActionListener implements WifiP2pManager.ActionListener {
+        private final EventFacade mEventFacade;
+        private final String mEventType;
+        private final String TAG;
+
+        public WifiP2pActionListener(EventFacade eventFacade, String tag) {
+            mEventType = "WifiP2p";
+            mEventFacade = eventFacade;
+            TAG = tag;
+        }
+
+        @Override
+        public void onSuccess() {
+            mEventFacade.postEvent(mEventType + TAG + "OnSuccess", null);
+        }
+
+        @Override
+        public void onFailure(int reason) {
+            Log.d("WifiActionListener  " + mEventType);
+            Bundle msg = new Bundle();
+            if (reason == WifiP2pManager.P2P_UNSUPPORTED) {
+                msg.putString("reason", "P2P_UNSUPPORTED");
+            } else if (reason == WifiP2pManager.ERROR) {
+                msg.putString("reason", "ERROR");
+            } else if (reason == WifiP2pManager.BUSY) {
+                msg.putString("reason", "BUSY");
+            } else if (reason == WifiP2pManager.NO_SERVICE_REQUESTS) {
+                msg.putString("reason", "NO_SERVICE_REQUESTS");
+            } else {
+                msg.putInt("reason", reason);
+            }
+            mEventFacade.postEvent(mEventType + TAG + "OnFailure", msg);
+        }
+    }
+
+    class WifiP2pConnectionInfoListener implements WifiP2pManager.ConnectionInfoListener {
+        private final EventFacade mEventFacade;
+        private final String mEventType;
+
+        public WifiP2pConnectionInfoListener(EventFacade eventFacade) {
+            mEventType = "WifiP2p";
+            mEventFacade = eventFacade;
+        }
+
+        @Override
+        public void onConnectionInfoAvailable(WifiP2pInfo info) {
+            Bundle msg = new Bundle();
+            msg.putBoolean("groupFormed", info.groupFormed);
+            msg.putBoolean("isGroupOwner", info.isGroupOwner);
+            InetAddress addr = info.groupOwnerAddress;
+            String hostName = null;
+            String hostAddress = null;
+            if (addr != null) {
+                hostName = addr.getHostName();
+                hostAddress = addr.getHostAddress();
+            }
+            msg.putString("groupOwnerHostName", hostName);
+            msg.putString("groupOwnerHostAddress", hostAddress);
+            mEventFacade.postEvent(mEventType + "OnConnectionInfoAvailable", msg);
+        }
+    }
+
+    class WifiP2pDnsSdServiceResponseListener implements
+            WifiP2pManager.DnsSdServiceResponseListener {
+        private final EventFacade mEventFacade;
+        private final String mEventType;
+
+        public WifiP2pDnsSdServiceResponseListener(EventFacade eventFacade) {
+            mEventType = "WifiP2p";
+            mEventFacade = eventFacade;
+        }
+
+        @Override
+        public void onDnsSdServiceAvailable(String instanceName, String registrationType,
+                WifiP2pDevice srcDevice) {
+            Bundle msg = new Bundle();
+            msg.putString("InstanceName", instanceName);
+            msg.putString("RegistrationType", registrationType);
+            msg.putString("SourceDeviceName", srcDevice.deviceName);
+            msg.putString("SourceDeviceAddress", srcDevice.deviceAddress);
+            mEventFacade.postEvent(mEventType + "OnDnsSdServiceAvailable", msg);
+        }
+    }
+
+    class WifiP2pDnsSdTxtRecordListener implements WifiP2pManager.DnsSdTxtRecordListener {
+        private final EventFacade mEventFacade;
+        private final String mEventType;
+
+        public WifiP2pDnsSdTxtRecordListener(EventFacade eventFacade) {
+            mEventType = "WifiP2p";
+            mEventFacade = eventFacade;
+        }
+
+        @Override
+        public void onDnsSdTxtRecordAvailable(String fullDomainName,
+                Map<String, String> txtRecordMap, WifiP2pDevice srcDevice) {
+            Bundle msg = new Bundle();
+            msg.putString("FullDomainName", fullDomainName);
+            Bundle txtMap = new Bundle();
+            for (String key : txtRecordMap.keySet()) {
+                txtMap.putString(key, txtRecordMap.get(key));
+            }
+            msg.putBundle("TxtRecordMap", txtMap);
+            msg.putString("SourceDeviceName", srcDevice.deviceName);
+            msg.putString("SourceDeviceAddress", srcDevice.deviceAddress);
+            mEventFacade.postEvent(mEventType + "OnDnsSdTxtRecordAvailable", msg);
+        }
+
+    }
+
+    class WifiP2pGroupInfoListener implements WifiP2pManager.GroupInfoListener {
+        private final EventFacade mEventFacade;
+        private final String mEventType;
+
+        public WifiP2pGroupInfoListener(EventFacade eventFacade) {
+            mEventType = "WifiP2p";
+            mEventFacade = eventFacade;
+        }
+
+        @Override
+        public void onGroupInfoAvailable(WifiP2pGroup group) {
+            mEventFacade.postEvent(mEventType + "OnGroupInfoAvailable", parseGroupInfo(group));
+        }
+    }
+
+    class WifiP2pPeerListListener implements WifiP2pManager.PeerListListener {
+        private final EventFacade mEventFacade;
+
+        public WifiP2pPeerListListener(EventFacade eventFacade) {
+            mEventFacade = eventFacade;
+        }
+
+        @Override
+        public void onPeersAvailable(WifiP2pDeviceList newPeers) {
+            Collection<WifiP2pDevice> devices = newPeers.getDeviceList();
+            Log.d(devices.toString());
+            if (devices.size() > 0) {
+                mP2pPeers.clear();
+                mP2pPeers.addAll(devices);
+                Bundle msg = new Bundle();
+                msg.putParcelableList("Peers", mP2pPeers);
+                mEventFacade.postEvent(mEventType + "OnPeersAvailable", msg);
+            }
+        }
+    }
+
+    class WifiP2pPersistentGroupInfoListener implements WifiP2pManager.PersistentGroupInfoListener {
+        private final EventFacade mEventFacade;
+        private final String mEventType;
+
+        public WifiP2pPersistentGroupInfoListener(EventFacade eventFacade) {
+            mEventType = "WifiP2p";
+            mEventFacade = eventFacade;
+        }
+
+        @Override
+        public void onPersistentGroupInfoAvailable(WifiP2pGroupList groups) {
+            ArrayList<Bundle> gs = new ArrayList<Bundle>();
+            for (WifiP2pGroup g : groups.getGroupList()) {
+                gs.add(parseGroupInfo(g));
+            }
+            mEventFacade.postEvent(mEventType + "OnPersistentGroupInfoAvailable", gs);
+        }
+
+    }
+
+    class WifiP2pStateChangedReceiver extends BroadcastReceiver {
+        private final EventFacade mEventFacade;
+        private final Bundle mResults;
+
+        WifiP2pStateChangedReceiver(EventFacade eventFacade) {
+            mEventFacade = eventFacade;
+            mResults = new Bundle();
+        }
+
+        @Override
+        public void onReceive(Context c, Intent intent) {
+            String action = intent.getAction();
+            if (action.equals(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)) {
+                Log.d("Wifi P2p State Changed.");
+                int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, 0);
+                if (state == WifiP2pManager.WIFI_P2P_STATE_DISABLED) {
+                    Log.d("Disabled");
+                    isP2pEnabled = false;
+                } else if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
+                    Log.d("Enabled");
+                    isP2pEnabled = true;
+                }
+            } else if (action.equals(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)) {
+                Log.d("Wifi P2p Peers Changed. Requesting peers.");
+                WifiP2pDeviceList peers = intent
+                        .getParcelableExtra(WifiP2pManager.EXTRA_P2P_DEVICE_LIST);
+                Log.d(peers.toString());
+                wifiP2pRequestPeers();
+            } else if (action.equals(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)) {
+                Log.d("Wifi P2p Connection Changed.");
+                WifiP2pInfo p2pInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_INFO);
+                NetworkInfo networkInfo = intent
+                        .getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
+                WifiP2pGroup group = intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_GROUP);
+                if (networkInfo.isConnected()) {
+                    Log.d("Wifi P2p Connected.");
+                    mResults.putParcelable("P2pInfo", p2pInfo);
+                    mResults.putParcelable("Group", group);
+                    mEventFacade.postEvent(mEventType + "Connected", mResults);
+                    mResults.clear();
+                } else {
+                    mEventFacade.postEvent(mEventType + "Disconnected", null);
+                }
+            } else if (action.equals(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)) {
+                Log.d("Wifi P2p This Device Changed.");
+                WifiP2pDevice device = intent
+                        .getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE);
+                mResults.putParcelable("Device", device);
+                mEventFacade.postEvent(mEventType + "ThisDeviceChanged", mResults);
+                mResults.clear();
+            } else if (action.equals(WifiP2pManager.WIFI_P2P_DISCOVERY_CHANGED_ACTION)) {
+                Log.d("Wifi P2p Discovery Changed.");
+                int state = intent.getIntExtra(WifiP2pManager.EXTRA_DISCOVERY_STATE, 0);
+                if (state == WifiP2pManager.WIFI_P2P_DISCOVERY_STARTED) {
+                    Log.d("discovery started.");
+                } else if (state == WifiP2pManager.WIFI_P2P_DISCOVERY_STOPPED) {
+                    Log.d("discovery stoped.");
+                }
+            }
+        }
+    }
+
+    private final static String mEventType = "WifiP2p";
+
+    private WifiP2pManager.Channel mChannel;
+    private final EventFacade mEventFacade;
+    private final WifiP2pManager mP2p;
+    private final WifiP2pStateChangedReceiver mP2pStateChangedReceiver;
+    private final Service mService;
+    private final IntentFilter mStateChangeFilter;
+    private final Map<Integer, WifiP2pServiceRequest> mServiceRequests;
+
+    private boolean isP2pEnabled;
+    private int mServiceRequestCnt = 0;
+    private WifiP2pServiceInfo mServiceInfo = null;
+    private List<WifiP2pDevice> mP2pPeers = new ArrayList<WifiP2pDevice>();
+
+    public WifiP2pManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mP2p = (WifiP2pManager) mService.getSystemService(Context.WIFI_P2P_SERVICE);
+        mEventFacade = manager.getReceiver(EventFacade.class);
+
+        mStateChangeFilter = new IntentFilter(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
+        mStateChangeFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
+        mStateChangeFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
+        mStateChangeFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
+        mStateChangeFilter.setPriority(999);
+
+        mP2pStateChangedReceiver = new WifiP2pStateChangedReceiver(mEventFacade);
+        mServiceRequests = new HashMap<Integer, WifiP2pServiceRequest>();
+    }
+
+    public Bundle parseGroupInfo(WifiP2pGroup group) {
+        Bundle msg = new Bundle();
+        msg.putString("Interface", group.getInterface());
+        msg.putString("NetworkName", group.getNetworkName());
+        msg.putString("Passphrase", group.getPassphrase());
+        msg.putInt("NetworkId", group.getNetworkId());
+        msg.putString("OwnerName", group.getOwner().deviceName);
+        msg.putString("OwnerAddress", group.getOwner().deviceAddress);
+        return msg;
+    }
+
+    @Override
+    public void shutdown() {
+        mService.unregisterReceiver(mP2pStateChangedReceiver);
+    }
+
+    @Rpc(description = "Accept p2p connection invitation.")
+    public void wifiP2pAcceptConnection() throws RemoteException {
+        Log.d("Accepting p2p connection.");
+        Messenger m = mP2p.getP2pStateMachineMessenger();
+        int user_accept = Protocol.BASE_WIFI_P2P_SERVICE + 2;
+        Message msg = Message.obtain();
+        msg.what = user_accept;
+        m.send(msg);
+    }
+
+    @Rpc(description = "Reject p2p connection invitation.")
+    public void wifiP2pRejectConnection() throws RemoteException {
+        Log.d("Rejecting p2p connection.");
+        Messenger m = mP2p.getP2pStateMachineMessenger();
+        int user_accept = Protocol.BASE_WIFI_P2P_SERVICE + 3;
+        Message msg = Message.obtain();
+        msg.what = user_accept;
+        m.send(msg);
+    }
+
+    @Rpc(description = "Register a local service for service discovery. One of the \"CreateXxxServiceInfo functions needs to be called first.\"")
+    public void wifiP2pAddLocalService() {
+        mP2p.addLocalService(mChannel, mServiceInfo,
+                new WifiP2pActionListener(mEventFacade, "AddLocalService"));
+    }
+
+    @Rpc(description = "Add a service discovery request.")
+    public Integer wifiP2pAddServiceRequest(
+            @RpcParameter(name = "protocolType") Integer protocolType) {
+        WifiP2pServiceRequest request = WifiP2pServiceRequest.newInstance(protocolType);
+        mServiceRequestCnt += 1;
+        mServiceRequests.put(mServiceRequestCnt, request);
+        mP2p.addServiceRequest(mChannel, request, new WifiP2pActionListener(mEventFacade,
+                "AddServiceRequest"));
+        return mServiceRequestCnt;
+    }
+
+    @Rpc(description = "Cancel any ongoing connect negotiation.")
+    public void wifiP2pCancelConnect() {
+        mP2p.cancelConnect(mChannel, new WifiP2pActionListener(mEventFacade, "CancelConnect"));
+    }
+
+    @Rpc(description = "Clear all registered local services of service discovery.")
+    public void wifiP2pClearLocalServices() {
+        mP2p.clearLocalServices(mChannel,
+                new WifiP2pActionListener(mEventFacade, "ClearLocalServices"));
+    }
+
+    @Rpc(description = "Clear all registered service discovery requests.")
+    public void wifiP2pClearServiceRequests() {
+        mP2p.clearServiceRequests(mChannel,
+                new WifiP2pActionListener(mEventFacade, "ClearServiceRequests"));
+    }
+
+    @Rpc(description = "Connects to a discovered wifi p2p device.")
+    public void wifiP2pConnect(@RpcParameter(name = "deviceId") String deviceId) {
+        for (WifiP2pDevice d : mP2pPeers) {
+            if (wifiP2pDeviceMatches(d, deviceId)) {
+                WifiP2pConfig config = new WifiP2pConfig();
+                config.deviceAddress = d.deviceAddress;
+                config.wps.setup = WpsInfo.PBC;
+                mP2p.connect(mChannel, config,
+                        new WifiP2pActionListener(mEventFacade, "Connect"));
+            }
+        }
+    }
+
+    @Rpc(description = "Create a Bonjour service info object to be used for wifiP2pAddLocalService.")
+    public void wifiP2pCreateBonjourServiceInfo(
+            @RpcParameter(name = "instanceName") String instanceName,
+            @RpcParameter(name = "serviceType") String serviceType,
+            @RpcParameter(name = "txtMap") JSONObject txtMap) throws JSONException {
+        Map<String, String> map = new HashMap<String, String>();
+        for (String key : txtMap.keySet()) {
+            map.put(key, txtMap.getString(key));
+        }
+        mServiceInfo = WifiP2pDnsSdServiceInfo.newInstance(instanceName, serviceType, map);
+    }
+
+    @Rpc(description = "Create a wifi p2p group.")
+    public void wifiP2pCreateGroup() {
+        mP2p.createGroup(mChannel, new WifiP2pActionListener(mEventFacade, "CreatGroup"));
+    }
+
+    @Rpc(description = "Create a Upnp service info object to be used for wifiP2pAddLocalService.")
+    public void wifiP2pCreateUpnpServiceInfo(
+            @RpcParameter(name = "uuid") String uuid,
+            @RpcParameter(name = "device") String device,
+            @RpcParameter(name = "services") List<String> services) {
+        mServiceInfo = WifiP2pUpnpServiceInfo.newInstance(uuid, device, services);
+    }
+
+    @Rpc(description = "Delete a stored persistent group from the system settings.")
+    public void wifiP2pDeletePersistentGroup(@RpcParameter(name = "netId") Integer netId) {
+        mP2p.deletePersistentGroup(mChannel, netId,
+                new WifiP2pActionListener(mEventFacade, "DeletePersistentGroup"));
+    }
+
+    private boolean wifiP2pDeviceMatches(WifiP2pDevice d, String deviceId) {
+        return d.deviceName.equals(deviceId) || d.deviceAddress.equals(deviceId);
+    }
+
+    @Rpc(description = "Start peers discovery for wifi p2p.")
+    public void wifiP2pDiscoverPeers() {
+        mP2p.discoverPeers(mChannel, new WifiP2pActionListener(mEventFacade, "DiscoverPeers"));
+    }
+
+    @Rpc(description = "Initiate service discovery.")
+    public void wifiP2pDiscoverServices() {
+        mP2p.discoverServices(mChannel,
+                new WifiP2pActionListener(mEventFacade, "DiscoverServices"));
+    }
+
+    @Rpc(description = "Initialize wifi p2p. Must be called before any other p2p functions.")
+    public void wifiP2pInitialize() {
+        mService.registerReceiver(mP2pStateChangedReceiver, mStateChangeFilter);
+        mChannel = mP2p.initialize(mService, mService.getMainLooper(), null);
+    }
+
+    @Rpc(description = "Returns true if wifi p2p is enabled, false otherwise.")
+    public Boolean wifiP2pIsEnabled() {
+        return isP2pEnabled;
+    }
+
+    @Rpc(description = "Remove the current p2p group.")
+    public void wifiP2pRemoveGroup() {
+        mP2p.removeGroup(mChannel, new WifiP2pActionListener(mEventFacade, "RemoveGroup"));
+    }
+
+    @Rpc(description = "Remove a registered local service added with wifiP2pAddLocalService.")
+    public void wifiP2pRemoveLocalService() {
+        mP2p.removeLocalService(mChannel, mServiceInfo,
+                new WifiP2pActionListener(mEventFacade, "RemoveLocalService"));
+    }
+
+    @Rpc(description = "Remove a service discovery request.")
+    public void wifiP2pRemoveServiceRequest(@RpcParameter(name = "index") Integer index) {
+        mP2p.removeServiceRequest(mChannel, mServiceRequests.remove(index),
+                new WifiP2pActionListener(mEventFacade, "RemoveServiceRequest"));
+    }
+
+    @Rpc(description = "Request device connection info.")
+    public void wifiP2pRequestConnectionInfo() {
+        mP2p.requestConnectionInfo(mChannel, new WifiP2pConnectionInfoListener(mEventFacade));
+    }
+
+    @Rpc(description = "Create a wifi p2p group.")
+    public void wifiP2pRequestGroupInfo() {
+        mP2p.requestGroupInfo(mChannel, new WifiP2pGroupInfoListener(mEventFacade));
+    }
+
+    @Rpc(description = "Request peers that are discovered for wifi p2p.")
+    public void wifiP2pRequestPeers() {
+        mP2p.requestPeers(mChannel, new WifiP2pPeerListListener(mEventFacade));
+    }
+
+    @Rpc(description = "Request a list of all the persistent p2p groups stored in system.")
+    public void wifiP2pRequestPersistentGroupInfo() {
+        mP2p.requestPersistentGroupInfo(mChannel,
+                new WifiP2pPersistentGroupInfoListener(mEventFacade));
+    }
+
+    @Rpc(description = "Set p2p device name.")
+    public void wifiP2pSetDeviceName(@RpcParameter(name = "devName") String devName) {
+        mP2p.setDeviceName(mChannel, devName,
+                new WifiP2pActionListener(mEventFacade, "SetDeviceName"));
+    }
+
+    @Rpc(description = "Register a callback to be invoked on receiving Bonjour service discovery response.")
+    public void wifiP2pSetDnsSdResponseListeners() {
+        mP2p.setDnsSdResponseListeners(mChannel,
+                new WifiP2pDnsSdServiceResponseListener(mEventFacade),
+                new WifiP2pDnsSdTxtRecordListener(mEventFacade));
+    }
+
+    @Rpc(description = "Stop an ongoing peer discovery.")
+    public void wifiP2pStopPeerDiscovery() {
+        mP2p.stopPeerDiscovery(mChannel,
+                new WifiP2pActionListener(mEventFacade, "StopPeerDiscovery"));
+    }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/wifi/WifiRttManagerFacade.java b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiRttManagerFacade.java
new file mode 100644
index 0000000..b4bf1e1
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiRttManagerFacade.java
@@ -0,0 +1,210 @@
+
+package com.googlecode.android_scripting.facade.wifi;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.app.Service;
+import android.content.Context;
+import android.net.wifi.RttManager;
+import android.net.wifi.RttManager.RttCapabilities;
+import android.net.wifi.RttManager.RttListener;
+import android.net.wifi.RttManager.RttParams;
+import android.net.wifi.RttManager.RttResult;
+import android.os.Bundle;
+import android.os.Parcelable;
+
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * WifiRttManager functions.
+ */
+public class WifiRttManagerFacade extends RpcReceiver {
+    private final Service mService;
+    private final RttManager mRtt;
+    private final EventFacade mEventFacade;
+    private final Map<Integer, RttListener> mRangingListeners;
+
+    public WifiRttManagerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mRtt = (RttManager) mService.getSystemService(Context.WIFI_RTT_SERVICE);
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        mRangingListeners = new Hashtable<Integer, RttListener>();
+    }
+
+    public static class RangingListener implements RttListener {
+        private static final String TAG = "WifiRttRanging";
+        private static int sCount = 0;
+        private final EventFacade mEventFacade;
+        public final int mId;
+
+        public RangingListener(EventFacade eventFacade) {
+            sCount += 1;
+            mId = sCount;
+            mEventFacade = eventFacade;
+        }
+
+        private Bundle packRttResult(RttResult result) {
+            Bundle rttResult = new Bundle();
+            rttResult.putString("BSSID", result.bssid);
+            rttResult.putInt("txRate", result.txRate);
+            rttResult.putInt("rxRate", result.rxRate);
+            rttResult.putInt("distance", result.distance);
+            rttResult.putInt("distanceStandardDeviation",
+                    result.distanceStandardDeviation);
+            rttResult.putInt("distanceSpread", result.distanceSpread);
+            rttResult.putInt("burstDuration", result.burstDuration);
+            rttResult.putLong("rtt", result.rtt);
+            rttResult.putLong("rttStandardDeviation",
+                    result.rttStandardDeviation);
+            rttResult.putLong("rttSpread", result.rttSpread);
+            rttResult.putLong("ts", result.ts);
+            rttResult.putInt("rssi", result.rssi);
+            rttResult.putInt("rssiSpread", result.rssiSpread);
+            rttResult.putInt("retryAfterDuration", result.retryAfterDuration);
+            rttResult.putInt("measurementType", result.measurementType);
+            rttResult.putInt("status", result.status);
+            rttResult.putInt("frameNumberPerBurstPeer",
+                    result.frameNumberPerBurstPeer);
+            rttResult.putInt("successMeasurementFrameNumber",
+                    result.successMeasurementFrameNumber);
+            rttResult.putInt("measurementFrameNumber",
+                    result.measurementFrameNumber);
+            rttResult.putInt("burstNumber", result.burstNumber);
+            rttResult.putInt("status", result.status);
+            return rttResult;
+        }
+
+        @Override
+        public void onSuccess(RttResult[] results) {
+            if (results == null) {
+                mEventFacade
+                        .postEvent(RangingListener.TAG + mId + "onSuccess", null);
+                return;
+            }
+            Bundle msg = new Bundle();
+            Parcelable[] resultBundles = new Parcelable[results.length];
+            for (int i = 0; i < results.length; i++) {
+                resultBundles[i] = packRttResult(results[i]);
+            }
+            msg.putParcelableArray("Results", resultBundles);
+            mEventFacade
+                    .postEvent(RangingListener.TAG + mId + "onSuccess", msg);
+        }
+
+        @Override
+        public void onFailure(int reason, String description) {
+            Bundle msg = new Bundle();
+            msg.putInt("Reason", reason);
+            msg.putString("Description", description);
+            mEventFacade
+                    .postEvent(RangingListener.TAG + mId + "onFailure", msg);
+        }
+
+        @Override
+        public void onAborted() {
+            mEventFacade.postEvent(RangingListener.TAG + mId + "onAborted",
+                    new Bundle());
+        }
+    }
+
+    @Rpc(description = "Get wifi Rtt capabilities.")
+    public RttCapabilities wifiRttGetCapabilities() {
+        return mRtt.getRttCapabilities();
+    }
+
+    private RttParams parseRttParam(JSONObject j) throws JSONException {
+        RttParams result = new RttParams();
+        if (j.has("deviceType")) {
+            result.deviceType = j.getInt("deviceType");
+        }
+        if (j.has("requestType")) {
+            result.requestType = j.getInt("requestType");
+        }
+        if (j.has("bssid")) {
+            result.bssid = j.getString("bssid");
+        }
+        if (j.has("frequency")) {
+            result.frequency = j.getInt("frequency");
+        }
+        if (j.has("channelWidth")) {
+            result.channelWidth = j.getInt("channelWidth");
+        }
+        if (j.has("centerFreq0")) {
+            result.centerFreq0 = j.getInt("centerFreq0");
+        }
+        if (j.has("centerFreq1")) {
+            result.centerFreq1 = j.getInt("centerFreq1");
+        }
+        if (j.has("numberBurst")) {
+            result.numberBurst = j.getInt("numberBurst");
+        }
+        if (j.has("burstTimeout")) {
+            result.burstTimeout = j.getInt("burstTimeout");
+        }
+        if (j.has("interval")) {
+            result.interval = j.getInt("interval");
+        }
+        if (j.has("numSamplesPerBurst")) {
+            result.numSamplesPerBurst = j.getInt("numSamplesPerBurst");
+        }
+        if (j.has("numRetriesPerMeasurementFrame")) {
+            result.numRetriesPerMeasurementFrame = j
+                    .getInt("numRetriesPerMeasurementFrame");
+        }
+        if (j.has("numRetriesPerFTMR")) {
+            result.numRetriesPerFTMR = j.getInt("numRetriesPerFTMR");
+        }
+        if (j.has("LCIRequest")) {
+            result.LCIRequest = j.getBoolean("LCIRequest");
+        }
+        if (j.has("LCRRequest")) {
+            result.LCRRequest = j.getBoolean("LCRRequest");
+        }
+        if (j.has("preamble")) {
+            result.preamble = j.getInt("preamble");
+        }
+        if (j.has("bandwidth")) {
+            result.bandwidth = j.getInt("bandwidth");
+        }
+        return result;
+    }
+
+    @Rpc(description = "Start ranging.", returns = "Id of the listener associated with the started ranging.")
+    public Integer wifiRttStartRanging(
+            @RpcParameter(name = "params") JSONArray params)
+            throws JSONException {
+        RttParams[] rParams = new RttParams[params.length()];
+        for (int i = 0; i < params.length(); i++) {
+            rParams[i] = parseRttParam(params.getJSONObject(i));
+        }
+        RangingListener listener = new RangingListener(mEventFacade);
+        mRangingListeners.put(listener.mId, listener);
+        mRtt.startRanging(rParams, listener);
+        return listener.mId;
+    }
+
+    @Rpc(description = "Stop ranging.")
+    public void wifiRttStopRanging(@RpcParameter(name = "index") Integer index) {
+        mRtt.stopRanging(mRangingListeners.remove(index));
+    }
+
+    @Override
+    public void shutdown() {
+        ArrayList<Integer> keys = new ArrayList<Integer>(
+                mRangingListeners.keySet());
+        for (int k : keys) {
+            wifiRttStopRanging(k);
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/facade/wifi/WifiScannerFacade.java b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiScannerFacade.java
new file mode 100644
index 0000000..f718b90
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/facade/wifi/WifiScannerFacade.java
@@ -0,0 +1,649 @@
+/*
+ * Copyright (C) 2014 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade.wifi;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.MainThread;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+import android.app.Service;
+import android.content.Context;
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiScanner;
+import android.net.wifi.WifiScanner.BssidInfo;
+import android.net.wifi.WifiScanner.ChannelSpec;
+import android.net.wifi.WifiScanner.ScanData;
+import android.net.wifi.WifiScanner.ScanSettings;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.provider.Settings.Global;
+import android.provider.Settings.SettingNotFoundException;
+
+/**
+ * WifiScanner functions.
+ */
+public class WifiScannerFacade extends RpcReceiver {
+    private final Service mService;
+    private final EventFacade mEventFacade;
+    private final WifiScanner mScan;
+    // These counters are just for indexing;
+    // they do not represent the total number of listeners
+    private static int WifiScanListenerCnt;
+    private static int WifiChangeListenerCnt;
+    private static int WifiBssidListenerCnt;
+    private final ConcurrentHashMap<Integer, WifiScanListener> scanListeners;
+    private final ConcurrentHashMap<Integer, WifiScanListener> scanBackgroundListeners;
+    private final ConcurrentHashMap<Integer, ChangeListener> trackChangeListeners;
+    private final ConcurrentHashMap<Integer, WifiBssidListener> trackBssidListeners;
+    private static ConcurrentHashMap<Integer, ScanResult[]> wifiScannerResultList;
+    private static ConcurrentHashMap<Integer, ScanData[]> wifiScannerDataList;
+
+    public WifiScannerFacade(FacadeManager manager) {
+        super(manager);
+        mService = manager.getService();
+        mScan = (WifiScanner) mService.getSystemService(Context.WIFI_SCANNING_SERVICE);
+        mEventFacade = manager.getReceiver(EventFacade.class);
+        scanListeners = new ConcurrentHashMap<Integer, WifiScanListener>();
+        scanBackgroundListeners = new ConcurrentHashMap<Integer, WifiScanListener>();
+        trackChangeListeners = new ConcurrentHashMap<Integer, ChangeListener>();
+        trackBssidListeners = new ConcurrentHashMap<Integer, WifiBssidListener>();
+        wifiScannerResultList = new ConcurrentHashMap<Integer, ScanResult[]>();
+        wifiScannerDataList = new ConcurrentHashMap<Integer, ScanData[]>();
+    }
+
+    public static List<ScanResult> getWifiScanResult(Integer listenerIndex) {
+        ScanResult[] sr = wifiScannerResultList.get(listenerIndex);
+        return Arrays.asList(sr);
+    }
+
+    private class WifiActionListener implements WifiScanner.ActionListener {
+        private final Bundle mResults;
+        public int mIndex;
+        protected String mEventType;
+        private long startScanElapsedRealTime;
+
+        public WifiActionListener(String type, int idx, Bundle resultBundle, long startScanERT) {
+            this.mIndex = idx;
+            this.mEventType = type;
+            this.mResults = resultBundle;
+            this.startScanElapsedRealTime = startScanERT;
+        }
+
+        @Override
+        public void onSuccess() {
+            Log.d("onSuccess " + mEventType + " " + mIndex);
+            mResults.putString("Type", "onSuccess");
+            mResults.putInt("Index", mIndex);
+            mResults.putLong("ScanElapsedRealtime", startScanElapsedRealTime);
+            mEventFacade.postEvent(mEventType + mIndex + "onSuccess", mResults.clone());
+            mResults.clear();
+        }
+
+        @Override
+        public void onFailure(int reason, String description) {
+            Log.d("onFailure " + mEventType + " " + mIndex);
+            mResults.putString("Type", "onFailure");
+            mResults.putInt("Index", mIndex);
+            mResults.putInt("Reason", reason);
+            mResults.putString("Description", description);
+            mEventFacade.postEvent(mEventType + mIndex + "onFailure", mResults.clone());
+            mResults.clear();
+        }
+
+        public void reportResult(ScanResult[] results, String type) {
+            Log.d("reportResult " + mEventType + " " + mIndex);
+            mResults.putInt("Index", mIndex);
+            mResults.putLong("ResultElapsedRealtime", SystemClock.elapsedRealtime());
+            mResults.putString("Type", type);
+            mResults.putParcelableArray("Results", results);
+            mEventFacade.postEvent(mEventType + mIndex + type, mResults.clone());
+            mResults.clear();
+        }
+    }
+
+    /**
+     * Constructs a wifiScanListener obj and returns it
+     *
+     * @return WifiScanListener
+     */
+    private WifiScanListener genWifiScanListener() {
+        WifiScanListener mWifiScannerListener = MainThread.run(mService,
+                new Callable<WifiScanListener>() {
+                    @Override
+                    public WifiScanListener call() throws Exception {
+                        return new WifiScanListener();
+                    }
+                });
+        scanListeners.put(mWifiScannerListener.mIndex, mWifiScannerListener);
+        return mWifiScannerListener;
+    }
+
+    /**
+     * Constructs a wifiScanListener obj for background scan and returns it
+     *
+     * @return WifiScanListener
+     */
+    private WifiScanListener genBackgroundWifiScanListener() {
+        WifiScanListener mWifiScannerListener = MainThread.run(mService,
+                new Callable<WifiScanListener>() {
+                    @Override
+                    public WifiScanListener call() throws Exception {
+                        return new WifiScanListener();
+                    }
+                });
+        scanBackgroundListeners.put(mWifiScannerListener.mIndex, mWifiScannerListener);
+        return mWifiScannerListener;
+    }
+
+    private class WifiScanListener implements WifiScanner.ScanListener {
+        private static final String mEventType = "WifiScannerScan";
+        protected final Bundle mScanResults;
+        protected final Bundle mScanData;
+        private final WifiActionListener mWAL;
+        public int mIndex;
+
+        public WifiScanListener() {
+            mScanResults = new Bundle();
+            mScanData = new Bundle();
+            WifiScanListenerCnt += 1;
+            mIndex = WifiScanListenerCnt;
+            mWAL = new WifiActionListener(mEventType, mIndex, mScanResults,
+                    SystemClock.elapsedRealtime());
+        }
+
+        @Override
+        public void onSuccess() {
+            mWAL.onSuccess();
+        }
+
+        @Override
+        public void onFailure(int reason, String description) {
+            scanListeners.remove(mIndex);
+            mWAL.onFailure(reason, description);
+        }
+
+        @Override
+        public void onPeriodChanged(int periodInMs) {
+            Log.d("onPeriodChanged " + mEventType + " " + mIndex);
+            mScanResults.putString("Type", "onPeriodChanged");
+            mScanResults.putInt("NewPeriod", periodInMs);
+            mEventFacade.postEvent(mEventType + mIndex, mScanResults.clone());
+            mScanResults.clear();
+        }
+
+        @Override
+        public void onFullResult(ScanResult fullScanResult) {
+            Log.d("onFullResult WifiScanListener " + mIndex);
+            mWAL.reportResult(new ScanResult[] {
+                    fullScanResult
+            }, "onFullResult");
+        }
+
+        public void onResults(ScanData[] results) {
+            Log.d("onResult WifiScanListener " + mIndex);
+            wifiScannerDataList.put(mIndex, results);
+            mScanData.putInt("Index", mIndex);
+            mScanData.putLong("ResultElapsedRealtime", SystemClock.elapsedRealtime());
+            mScanData.putString("Type", "onResults");
+            mScanData.putParcelableArray("Results", results);
+            mEventFacade.postEvent(mEventType + mIndex + "onResults", mScanData.clone());
+            mScanData.clear();
+        }
+    }
+
+    /**
+     * Constructs a ChangeListener obj and returns it
+     *
+     * @return ChangeListener
+     */
+    private ChangeListener genWifiChangeListener() {
+        ChangeListener mWifiChangeListener = MainThread.run(mService,
+                new Callable<ChangeListener>() {
+                    @Override
+                    public ChangeListener call() throws Exception {
+                        return new ChangeListener();
+                    }
+                });
+        trackChangeListeners.put(mWifiChangeListener.mIndex, mWifiChangeListener);
+        return mWifiChangeListener;
+    }
+
+    private class ChangeListener implements WifiScanner.WifiChangeListener {
+        private static final String mEventType = "WifiScannerChange";
+        protected final Bundle mResults;
+        private final WifiActionListener mWAL;
+        public int mIndex;
+
+        public ChangeListener() {
+            mResults = new Bundle();
+            WifiChangeListenerCnt += 1;
+            mIndex = WifiChangeListenerCnt;
+            mWAL = new WifiActionListener(mEventType, mIndex, mResults,
+                    SystemClock.elapsedRealtime());
+        }
+
+        @Override
+        public void onSuccess() {
+            mWAL.onSuccess();
+        }
+
+        @Override
+        public void onFailure(int reason, String description) {
+            trackChangeListeners.remove(mIndex);
+            mWAL.onFailure(reason, description);
+        }
+
+        /**
+         * indicates that changes were detected in wifi environment
+         *
+         * @param results indicate the access points that exhibited change
+         */
+        @Override
+        public void onChanging(ScanResult[] results) { /* changes are found */
+            mWAL.reportResult(results, "onChanging");
+        }
+
+        /**
+         * indicates that no wifi changes are being detected for a while
+         *
+         * @param results indicate the access points that are bing monitored for change
+         */
+        @Override
+        public void onQuiescence(ScanResult[] results) { /* changes settled down */
+            mWAL.reportResult(results, "onQuiescence");
+        }
+    }
+
+    private WifiBssidListener genWifiBssidListener() {
+        WifiBssidListener mWifiBssidListener = MainThread.run(mService,
+                new Callable<WifiBssidListener>() {
+                    @Override
+                    public WifiBssidListener call() throws Exception {
+                        return new WifiBssidListener();
+                    }
+                });
+        trackBssidListeners.put(mWifiBssidListener.mIndex, mWifiBssidListener);
+        return mWifiBssidListener;
+    }
+
+    private class WifiBssidListener implements WifiScanner.BssidListener {
+        private static final String mEventType = "WifiScannerBssid";
+        protected final Bundle mResults;
+        private final WifiActionListener mWAL;
+        public int mIndex;
+
+        public WifiBssidListener() {
+            mResults = new Bundle();
+            WifiBssidListenerCnt += 1;
+            mIndex = WifiBssidListenerCnt;
+            mWAL = new WifiActionListener(mEventType, mIndex, mResults,
+                    SystemClock.elapsedRealtime());
+        }
+
+        @Override
+        public void onSuccess() {
+            mWAL.onSuccess();
+        }
+
+        @Override
+        public void onFailure(int reason, String description) {
+            trackBssidListeners.remove(mIndex);
+            mWAL.onFailure(reason, description);
+        }
+
+        @Override
+        public void onFound(ScanResult[] results) {
+            mWAL.reportResult(results, "onFound");
+        }
+
+        @Override
+        public void onLost(ScanResult[] results) {
+            mWAL.reportResult(results, "onLost");
+        }
+    }
+
+    private ScanSettings parseScanSettings(JSONObject j) throws JSONException {
+        if (j == null) {
+            return null;
+        }
+        ScanSettings result = new ScanSettings();
+        if (j.has("band")) {
+            result.band = j.optInt("band");
+        }
+        if (j.has("channels")) {
+            JSONArray chs = j.getJSONArray("channels");
+            ChannelSpec[] channels = new ChannelSpec[chs.length()];
+            for (int i = 0; i < channels.length; i++) {
+                channels[i] = new ChannelSpec(chs.getInt(i));
+            }
+            result.channels = channels;
+        }
+        if (j.has("maxScansToCache")) {
+            result.maxScansToCache = j.getInt("maxScansToCache");
+        }
+        /* periodInMs and reportEvents are required */
+        result.periodInMs = j.getInt("periodInMs");
+        if (j.has("maxPeriodInMs")) {
+            result.maxPeriodInMs = j.getInt("maxPeriodInMs");
+        }
+        if (j.has("stepCount")) {
+            result.stepCount = j.getInt("stepCount");
+        }
+        result.reportEvents = j.getInt("reportEvents");
+        if (j.has("numBssidsPerScan")) {
+            result.numBssidsPerScan = j.getInt("numBssidsPerScan");
+        }
+        return result;
+    }
+
+    private BssidInfo[] parseBssidInfo(JSONArray jBssids) throws JSONException {
+        BssidInfo[] bssids = new BssidInfo[jBssids.length()];
+        for (int i = 0; i < bssids.length; i++) {
+            JSONObject bi = (JSONObject) jBssids.get(i);
+            BssidInfo bssidInfo = new BssidInfo();
+            bssidInfo.bssid = bi.getString("BSSID");
+            bssidInfo.high = bi.getInt("high");
+            bssidInfo.low = bi.getInt("low");
+            if (bi.has("frequencyHint")) {
+                bssidInfo.frequencyHint = bi.getInt("frequencyHint");
+            }
+            bssids[i] = bssidInfo;
+        }
+        return bssids;
+    }
+
+    /**
+     * Starts periodic WifiScanner scan
+     *
+     * @param scanSettings
+     * @return the id of the scan listener associated with this scan
+     * @throws JSONException
+     */
+    @Rpc(description = "Starts a WifiScanner Background scan")
+    public Integer wifiScannerStartBackgroundScan(
+            @RpcParameter(name = "scanSettings") JSONObject scanSettings)
+                    throws JSONException {
+        ScanSettings ss = parseScanSettings(scanSettings);
+        Log.d("startWifiScannerScan with " + ss.channels);
+        WifiScanListener listener = genBackgroundWifiScanListener();
+        mScan.startBackgroundScan(ss, listener);
+        return listener.mIndex;
+    }
+
+    /**
+     * Get currently available scan results on appropriate listeners
+     *
+     * @return true if all scan results were reported correctly
+     * @throws JSONException
+     */
+    @Rpc(description = "Get currently available scan results on appropriate listeners")
+    public Boolean wifiScannerGetScanResults() throws JSONException {
+        mScan.getScanResults();
+        return true;
+    }
+
+    /**
+     * Stops a WifiScanner scan
+     *
+     * @param listenerIndex the id of the scan listener whose scan to stop
+     * @throws Exception
+     */
+    @Rpc(description = "Stops an ongoing  WifiScanner Background scan")
+    public void wifiScannerStopBackgroundScan(
+            @RpcParameter(name = "listener") Integer listenerIndex)
+                    throws Exception {
+        if (!scanBackgroundListeners.containsKey(listenerIndex)) {
+            throw new Exception("Background scan session " + listenerIndex + " does not exist");
+        }
+        WifiScanListener listener = scanBackgroundListeners.get(listenerIndex);
+        Log.d("stopWifiScannerScan listener " + listener.mIndex);
+        mScan.stopBackgroundScan(listener);
+        wifiScannerResultList.remove(listenerIndex);
+        scanBackgroundListeners.remove(listenerIndex);
+    }
+
+    /**
+     * Starts periodic WifiScanner scan
+     *
+     * @param scanSettings
+     * @return the id of the scan listener associated with this scan
+     * @throws JSONException
+     */
+    @Rpc(description = "Starts a WifiScanner single scan")
+    public Integer wifiScannerStartScan(
+            @RpcParameter(name = "scanSettings") JSONObject scanSettings)
+                    throws JSONException {
+        ScanSettings ss = parseScanSettings(scanSettings);
+        Log.d("startWifiScannerScan with " + ss.channels);
+        WifiScanListener listener = genWifiScanListener();
+        mScan.startScan(ss, listener);
+        return listener.mIndex;
+    }
+
+    /**
+     * Stops a WifiScanner scan
+     *
+     * @param listenerIndex the id of the scan listener whose scan to stop
+     * @throws Exception
+     */
+    @Rpc(description = "Stops an ongoing  WifiScanner Single scan")
+    public void wifiScannerStopScan(@RpcParameter(name = "listener") Integer listenerIndex)
+            throws Exception {
+        if (!scanListeners.containsKey(listenerIndex)) {
+            throw new Exception("Single scan session " + listenerIndex + " does not exist");
+        }
+        WifiScanListener listener = scanListeners.get(listenerIndex);
+        Log.d("stopWifiScannerScan listener " + listener.mIndex);
+        mScan.stopScan(listener);
+        wifiScannerResultList.remove(listener.mIndex);
+        scanListeners.remove(listenerIndex);
+    }
+
+    /** RPC Methods */
+    @Rpc(description = "Returns the channels covered by the specified band number.")
+    public List<Integer> wifiScannerGetAvailableChannels(
+            @RpcParameter(name = "band") Integer band) {
+        return mScan.getAvailableChannels(band);
+    }
+
+    /**
+     * Starts tracking wifi changes
+     *
+     * @return the id of the change listener associated with this track
+     * @throws Exception
+     */
+    @Rpc(description = "Starts tracking wifi changes")
+    public Integer wifiScannerStartTrackingChange() throws Exception {
+        ChangeListener listener = genWifiChangeListener();
+        mScan.startTrackingWifiChange(listener);
+        return listener.mIndex;
+    }
+
+    /**
+     * Stops tracking wifi changes
+     *
+     * @param listenerIndex the id of the change listener whose track to stop
+     * @throws Exception
+     */
+    @Rpc(description = "Stops tracking wifi changes")
+    public void wifiScannerStopTrackingChange(
+            @RpcParameter(name = "listener") Integer listenerIndex) throws Exception {
+        if (!trackChangeListeners.containsKey(listenerIndex)) {
+            throw new Exception("Wifi change tracking session " + listenerIndex
+                    + " does not exist");
+        }
+        ChangeListener listener = trackChangeListeners.get(listenerIndex);
+        mScan.stopTrackingWifiChange(listener);
+        trackChangeListeners.remove(listenerIndex);
+    }
+
+    /**
+     * Starts tracking changes of the specified bssids.
+     *
+     * @param bssidInfos An array of json strings, each representing a BssidInfo object.
+     * @param apLostThreshold
+     * @return The index of the listener used to start the tracking.
+     * @throws JSONException
+     */
+    @Rpc(description = "Starts tracking changes of the specified bssids.")
+    public Integer wifiScannerStartTrackingBssids(
+            @RpcParameter(name = "bssidInfos") JSONArray bssidInfos,
+            @RpcParameter(name = "apLostThreshold") Integer apLostThreshold) throws JSONException {
+        BssidInfo[] bssids = parseBssidInfo(bssidInfos);
+        WifiBssidListener listener = genWifiBssidListener();
+        mScan.startTrackingBssids(bssids, apLostThreshold, listener);
+        return listener.mIndex;
+    }
+
+    /**
+     * Stops tracking the list of APs associated with the input listener
+     *
+     * @param listenerIndex the id of the bssid listener whose track to stop
+     * @throws Exception
+     */
+    @Rpc(description = "Stops tracking changes in the APs on the list")
+    public void wifiScannerStopTrackingBssids(
+            @RpcParameter(name = "listener") Integer listenerIndex) throws Exception {
+        if (!trackBssidListeners.containsKey(listenerIndex)) {
+            throw new Exception("Bssid tracking session " + listenerIndex + " does not exist");
+        }
+        WifiBssidListener listener = trackBssidListeners.get(listenerIndex);
+        mScan.stopTrackingBssids(listener);
+        trackBssidListeners.remove(listenerIndex);
+    }
+
+    @Rpc(description = "Toggle the 'WiFi scan always available' option. If an input is given, the "
+            + "option is set to what the input boolean indicates.")
+    public void wifiScannerToggleAlwaysAvailable(
+            @RpcParameter(name = "alwaysAvailable") @RpcOptional Boolean alwaysAvailable)
+                    throws SettingNotFoundException {
+        int new_state = 0;
+        if (alwaysAvailable == null) {
+            int current_state = Global.getInt(mService.getContentResolver(),
+                    Global.WIFI_SCAN_ALWAYS_AVAILABLE);
+            new_state = current_state ^ 0x1;
+        } else {
+            new_state = alwaysAvailable ? 1 : 0;
+        }
+        Global.putInt(mService.getContentResolver(), Global.WIFI_SCAN_ALWAYS_AVAILABLE, new_state);
+    }
+
+    @Rpc(description = "Returns true if WiFi scan is always available, false otherwise.")
+    public Boolean wifiScannerIsAlwaysAvailable() throws SettingNotFoundException {
+        int current_state = Global.getInt(mService.getContentResolver(),
+                Global.WIFI_SCAN_ALWAYS_AVAILABLE);
+        if (current_state == 1) {
+            return true;
+        }
+        return false;
+    }
+
+    @Rpc(description = "Returns a list of mIndexes of existing listeners")
+    public Set<Integer> wifiGetCurrentScanIndexes() {
+        return scanListeners.keySet();
+    }
+
+    /**
+     * Starts tracking wifi changes
+     *
+     * @return the id of the change listener associated with this track
+     * @throws Exception
+     */
+    @Rpc(description = "Starts tracking wifi changes with track settings")
+    public Integer wifiScannerStartTrackingChangeWithSetting(
+            @RpcParameter(name = "trackSettings") JSONArray bssidSettings,
+            @RpcParameter(name = "rssiSS") Integer rssiSS,
+            @RpcParameter(name = "lostApSS") Integer lostApSS,
+            @RpcParameter(name = "unchangedSS") Integer unchangedSS,
+            @RpcParameter(name = "minApsBreachingThreshold") Integer minApsBreachingThreshold,
+            @RpcParameter(name = "periodInMs") Integer periodInMs) throws Exception {
+        Log.d("starting change track with track settings");
+        BssidInfo[] bssids = parseBssidInfo(bssidSettings);
+        mScan.configureWifiChange(rssiSS, lostApSS, unchangedSS, minApsBreachingThreshold,
+              periodInMs, bssids);
+        ChangeListener listener = genWifiChangeListener();
+        mScan.startTrackingWifiChange(listener);
+        return listener.mIndex;
+    }
+
+    /**
+     * Shuts down all activities associated with WifiScanner
+     */
+    @Rpc(description = "Shuts down all WifiScanner activities and remove listeners.")
+    public void wifiScannerShutdown() {
+        this.shutdown();
+    }
+
+    /**
+     * Stops all activity
+     */
+    @Override
+    public void shutdown() {
+        try {
+            if (!scanListeners.isEmpty()) {
+                Iterator<ConcurrentHashMap.Entry<Integer, WifiScanListener>> iter = scanListeners
+                        .entrySet().iterator();
+                while (iter.hasNext()) {
+                    ConcurrentHashMap.Entry<Integer, WifiScanListener> entry = iter.next();
+                    this.wifiScannerStopScan(entry.getKey());
+                }
+            }
+            if (!scanBackgroundListeners.isEmpty()) {
+                Iterator<ConcurrentHashMap.Entry<Integer, WifiScanListener>> iter = scanBackgroundListeners
+                        .entrySet().iterator();
+                while (iter.hasNext()) {
+                    ConcurrentHashMap.Entry<Integer, WifiScanListener> entry = iter.next();
+                    this.wifiScannerStopBackgroundScan(entry.getKey());
+                }
+            }
+            if (!trackChangeListeners.isEmpty()) {
+                Iterator<ConcurrentHashMap.Entry<Integer, ChangeListener>> iter = trackChangeListeners
+                        .entrySet().iterator();
+                while (iter.hasNext()) {
+                    ConcurrentHashMap.Entry<Integer, ChangeListener> entry = iter.next();
+                    this.wifiScannerStopTrackingChange(entry.getKey());
+                }
+            }
+            if (!trackBssidListeners.isEmpty()) {
+                Iterator<ConcurrentHashMap.Entry<Integer, WifiBssidListener>> iter = trackBssidListeners
+                        .entrySet().iterator();
+                while (iter.hasNext()) {
+                    ConcurrentHashMap.Entry<Integer, WifiBssidListener> entry = iter.next();
+                    this.wifiScannerStopTrackingBssids(entry.getKey());
+                }
+            }
+        } catch (Exception e) {
+            Log.e("Shutdown failed: " + e.toString());
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/future/FutureActivityTask.java b/Common/src/com/googlecode/android_scripting/future/FutureActivityTask.java
new file mode 100644
index 0000000..b474736
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/future/FutureActivityTask.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.future;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.View;
+import android.view.Window;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Encapsulates an {@link Activity} and a {@link FutureObject}.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public abstract class FutureActivityTask<T> {
+
+  private final FutureResult<T> mResult = new FutureResult<T>();
+  private Activity mActivity;
+
+  public void setActivity(Activity activity) {
+    mActivity = activity;
+  }
+
+  public Activity getActivity() {
+    return mActivity;
+  }
+
+  public void onCreate() {
+    mActivity.getWindow().requestFeature(Window.FEATURE_NO_TITLE);
+  }
+
+  public void onStart() {
+  }
+
+  public void onResume() {
+  }
+
+  public void onPause() {
+  }
+
+  public void onStop() {
+  }
+
+  public void onDestroy() {
+  }
+
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+  }
+
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    return false;
+  }
+
+  public void onActivityResult(int requestCode, int resultCode, Intent data) {
+  }
+
+  protected void setResult(T result) {
+    mResult.set(result);
+  }
+
+  public T getResult() throws InterruptedException {
+    return mResult.get();
+  }
+
+  public T getResult(long timeout, TimeUnit unit) throws InterruptedException {
+    return mResult.get(timeout, unit);
+  }
+
+  public void finish() {
+    mActivity.finish();
+  }
+
+  public void startActivity(Intent intent) {
+    mActivity.startActivity(intent);
+  }
+
+  public void startActivityForResult(Intent intent, int requestCode) {
+    mActivity.startActivityForResult(intent, requestCode);
+  }
+
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    // Placeholder.
+    return false;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/interpreter/InProcessInterpreter.java b/Common/src/com/googlecode/android_scripting/interpreter/InProcessInterpreter.java
new file mode 100644
index 0000000..48de556
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/interpreter/InProcessInterpreter.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import java.io.FileDescriptor;
+
+public interface InProcessInterpreter {
+  public FileDescriptor getStdOut();
+
+  public FileDescriptor getStdIn();
+
+  public boolean runInteractive();
+
+  public void runScript(String filename);
+}
diff --git a/Common/src/com/googlecode/android_scripting/interpreter/Interpreter.java b/Common/src/com/googlecode/android_scripting/interpreter/Interpreter.java
new file mode 100644
index 0000000..7a69032
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/interpreter/Interpreter.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import com.googlecode.android_scripting.language.Language;
+import com.googlecode.android_scripting.language.SupportedLanguages;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Combines all the execution-related specs of a particular interpreter installed in the system.
+ * This class is instantiated through a map received from a concrete InterpreterProfider.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public class Interpreter implements InterpreterPropertyNames {
+
+  private String mExtension;
+  private String mName;
+  private String mNiceName;
+  private String mInteractiveCommand;
+  private String mScriptExecutionCommand;
+  private File mBinary;
+  private boolean mHasInteractiveMode;
+  private final List<String> mArguments;
+  private final Map<String, String> mEnvironment;
+  private Language mLanguage;
+
+  public Interpreter() {
+    mArguments = new ArrayList<String>();
+    mEnvironment = new HashMap<String, String>();
+  }
+
+  public static Interpreter buildFromMaps(Map<String, String> data,
+      Map<String, String> environment_variables, Map<String, String> arguments) {
+    String extension = data.get(EXTENSION);
+    String name = data.get(NAME);
+    String niceName = data.get(NICE_NAME);
+    String binary = data.get(BINARY);
+    String interactiveCommand = data.get(INTERACTIVE_COMMAND);
+    String scriptCommand = data.get(SCRIPT_COMMAND);
+    Boolean hasInteractiveMode;
+    if (data.containsKey(HAS_INTERACTIVE_MODE)) {
+      hasInteractiveMode = Boolean.parseBoolean(data.get(HAS_INTERACTIVE_MODE));
+    } else {
+      // Default to true so that older interpreter APKs that don't have this value define still
+      // work.
+      hasInteractiveMode = true;
+    }
+    Interpreter interpreter = new Interpreter();
+    interpreter.setName(name);
+    interpreter.setNiceName(niceName);
+    interpreter.setExtension(extension);
+    interpreter.setBinary(new File(binary));
+    interpreter.setInteractiveCommand(interactiveCommand);
+    interpreter.setScriptCommand(scriptCommand);
+    interpreter.setHasInteractiveMode(hasInteractiveMode);
+    interpreter.setLanguage(SupportedLanguages.getLanguageByExtension(extension));
+    interpreter.putAllEnvironmentVariables(environment_variables);
+    interpreter.addAllArguments(arguments.values());
+    return interpreter;
+  }
+
+  // TODO(damonkohler): This should take a List<String> since order is important.
+  private void addAllArguments(Collection<String> arguments) {
+    mArguments.addAll(arguments);
+  }
+
+  List<String> getArguments() {
+    return mArguments;
+  }
+
+  private void putAllEnvironmentVariables(Map<String, String> environmentVariables) {
+    mEnvironment.putAll(environmentVariables);
+  }
+
+  public Map<String, String> getEnvironmentVariables() {
+    return mEnvironment;
+  }
+
+  protected void setScriptCommand(String executeParameters) {
+    mScriptExecutionCommand = executeParameters;
+  }
+
+  public String getScriptCommand() {
+    return mScriptExecutionCommand;
+  }
+
+  protected void setInteractiveCommand(String interactiveCommand) {
+    mInteractiveCommand = interactiveCommand;
+  }
+
+  public String getInteractiveCommand() {
+    return mInteractiveCommand;
+  }
+
+  protected void setBinary(File binary) {
+    if (!binary.exists()) {
+      throw new RuntimeException("Binary " + binary + " does not exist!");
+    }
+    mBinary = binary;
+  }
+
+  public File getBinary() {
+    return mBinary;
+  }
+
+  protected void setExtension(String extension) {
+    mExtension = extension;
+  }
+
+  protected void setHasInteractiveMode(boolean hasInteractiveMode) {
+    mHasInteractiveMode = hasInteractiveMode;
+  }
+
+  public boolean hasInteractiveMode() {
+    return mHasInteractiveMode;
+  }
+
+  public String getExtension() {
+    return mExtension;
+  }
+
+  protected void setName(String name) {
+    mName = name;
+  }
+
+  public String getName() {
+    return mName;
+  }
+
+  protected void setNiceName(String niceName) {
+    mNiceName = niceName;
+  }
+
+  public String getNiceName() {
+    return mNiceName;
+  }
+
+  public String getContentTemplate() {
+    return mLanguage.getContentTemplate();
+  }
+
+  protected void setLanguage(Language language) {
+    mLanguage = language;
+  }
+
+  public Language getLanguage() {
+    return mLanguage;
+  }
+
+  public String getRpcText(String content, MethodDescriptor rpc, String[] values) {
+    return mLanguage.getRpcText(content, rpc, values);
+  }
+
+  public boolean isInstalled() {
+    return mBinary.exists();
+  }
+
+  public boolean isUninstallable() {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/interpreter/InterpreterConfiguration.java b/Common/src/com/googlecode/android_scripting/interpreter/InterpreterConfiguration.java
new file mode 100644
index 0000000..02bd654
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/interpreter/InterpreterConfiguration.java
@@ -0,0 +1,322 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ProviderInfo;
+import android.content.pm.ResolveInfo;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.database.Cursor;
+import android.net.Uri;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.SingleThreadExecutor;
+import com.googlecode.android_scripting.interpreter.html.HtmlInterpreter;
+import com.googlecode.android_scripting.interpreter.shell.ShellInterpreter;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.ExecutorService;
+
+/**
+ * Manages and provides access to the set of available interpreters.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class InterpreterConfiguration {
+
+  private final InterpreterListener mListener;
+  private final Set<Interpreter> mInterpreterSet;
+  private final Set<ConfigurationObserver> mObserverSet;
+  private final Context mContext;
+  private volatile boolean mIsDiscoveryComplete = false;
+
+  public interface ConfigurationObserver {
+    public void onConfigurationChanged();
+  }
+
+  private class InterpreterListener extends BroadcastReceiver {
+    private final PackageManager mmPackageManager;
+    private final ContentResolver mmResolver;
+    private final ExecutorService mmExecutor;
+    private final Map<String, Interpreter> mmDiscoveredInterpreters;
+
+    private InterpreterListener(Context context) {
+      mmPackageManager = context.getPackageManager();
+      mmResolver = context.getContentResolver();
+      mmExecutor = new SingleThreadExecutor();
+      mmDiscoveredInterpreters = new HashMap<String, Interpreter>();
+    }
+
+    private void discoverForType(final String mime) {
+      mmExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          Intent intent = new Intent(InterpreterConstants.ACTION_DISCOVER_INTERPRETERS);
+          intent.addCategory(Intent.CATEGORY_LAUNCHER);
+          intent.setType(mime);
+          List<ResolveInfo> resolveInfos = mmPackageManager.queryIntentActivities(intent, 0);
+          for (ResolveInfo info : resolveInfos) {
+            addInterpreter(info.activityInfo.packageName);
+          }
+          mIsDiscoveryComplete = true;
+          notifyConfigurationObservers();
+        }
+      });
+    }
+
+    private void discoverAll() {
+      mmExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          Intent intent = new Intent(InterpreterConstants.ACTION_DISCOVER_INTERPRETERS);
+          intent.addCategory(Intent.CATEGORY_LAUNCHER);
+          intent.setType(InterpreterConstants.MIME + "*");
+          List<ResolveInfo> resolveInfos = mmPackageManager.queryIntentActivities(intent, 0);
+          for (ResolveInfo info : resolveInfos) {
+            addInterpreter(info.activityInfo.packageName);
+          }
+          mIsDiscoveryComplete = true;
+          notifyConfigurationObservers();
+        }
+      });
+    }
+
+    private void notifyConfigurationObservers() {
+      for (ConfigurationObserver observer : mObserverSet) {
+        observer.onConfigurationChanged();
+      }
+    }
+
+    private void addInterpreter(final String packageName) {
+      if (mmDiscoveredInterpreters.containsKey(packageName)) {
+        return;
+      }
+      Interpreter discoveredInterpreter = buildInterpreter(packageName);
+      if (discoveredInterpreter == null) {
+        return;
+      }
+      mmDiscoveredInterpreters.put(packageName, discoveredInterpreter);
+      mInterpreterSet.add(discoveredInterpreter);
+      Log.v("Interpreter discovered: " + packageName + "\nBinary: "
+          + discoveredInterpreter.getBinary());
+    }
+
+    private void remove(final String packageName) {
+      if (!mmDiscoveredInterpreters.containsKey(packageName)) {
+        return;
+      }
+      mmExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          Interpreter interpreter = mmDiscoveredInterpreters.get(packageName);
+          if (interpreter == null) {
+            Log.v("Interpreter for " + packageName + " not installed.");
+            return;
+          }
+          mInterpreterSet.remove(interpreter);
+          mmDiscoveredInterpreters.remove(packageName);
+          notifyConfigurationObservers();
+        }
+      });
+    }
+
+    // We require that there's only one interpreter provider per APK.
+    private Interpreter buildInterpreter(String packageName) {
+      PackageInfo packInfo;
+      try {
+        packInfo = mmPackageManager.getPackageInfo(packageName, PackageManager.GET_PROVIDERS);
+      } catch (NameNotFoundException e) {
+        throw new RuntimeException("Package '" + packageName + "' not found.");
+      }
+      ProviderInfo provider = packInfo.providers[0];
+
+      Map<String, String> interpreterMap =
+          getMap(provider, InterpreterConstants.PROVIDER_PROPERTIES);
+      if (interpreterMap == null) {
+        Log.e("Null interpreter map for: " + packageName);
+        return null;
+      }
+      Map<String, String> environmentMap =
+          getMap(provider, InterpreterConstants.PROVIDER_ENVIRONMENT_VARIABLES);
+      if (environmentMap == null) {
+        throw new RuntimeException("Null environment map for: " + packageName);
+      }
+      Map<String, String> argumentsMap = getMap(provider, InterpreterConstants.PROVIDER_ARGUMENTS);
+      if (argumentsMap == null) {
+        throw new RuntimeException("Null arguments map for: " + packageName);
+      }
+      return Interpreter.buildFromMaps(interpreterMap, environmentMap, argumentsMap);
+    }
+
+    private Map<String, String> getMap(ProviderInfo provider, String name) {
+      Uri uri = Uri.parse("content://" + provider.authority + "/" + name);
+      Cursor cursor = mmResolver.query(uri, null, null, null, null);
+      if (cursor == null) {
+        return null;
+      }
+      cursor.moveToFirst();
+      // Use LinkedHashMap so that order is maintained (important for position CLI arguments).
+      Map<String, String> map = new LinkedHashMap<String, String>();
+      for (int i = 0; i < cursor.getColumnCount(); i++) {
+        map.put(cursor.getColumnName(i), cursor.getString(i));
+      }
+      return map;
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      final String action = intent.getAction();
+      final String packageName = intent.getData().getSchemeSpecificPart();
+      if (action.equals(InterpreterConstants.ACTION_INTERPRETER_ADDED)) {
+        mmExecutor.execute(new Runnable() {
+          @Override
+          public void run() {
+            addInterpreter(packageName);
+            notifyConfigurationObservers();
+          }
+        });
+      } else if (action.equals(InterpreterConstants.ACTION_INTERPRETER_REMOVED)
+          || action.equals(Intent.ACTION_PACKAGE_REMOVED)
+          || action.equals(Intent.ACTION_PACKAGE_REPLACED)
+          || action.equals(Intent.ACTION_PACKAGE_DATA_CLEARED)) {
+        remove(packageName);
+      }
+    }
+
+  }
+
+  public InterpreterConfiguration(Context context) {
+    mContext = context;
+    mInterpreterSet = new CopyOnWriteArraySet<Interpreter>();
+    mInterpreterSet.add(new ShellInterpreter());
+    try {
+      mInterpreterSet.add(new HtmlInterpreter(mContext));
+    } catch (IOException e) {
+      Log.e("Failed to instantiate HtmlInterpreter.", e);
+    }
+    mObserverSet = new CopyOnWriteArraySet<ConfigurationObserver>();
+    IntentFilter filter = new IntentFilter();
+    filter.addAction(InterpreterConstants.ACTION_INTERPRETER_ADDED);
+    filter.addAction(InterpreterConstants.ACTION_INTERPRETER_REMOVED);
+    filter.addAction(Intent.ACTION_PACKAGE_DATA_CLEARED);
+    filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+    filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
+    filter.addDataScheme("package");
+    mListener = new InterpreterListener(mContext);
+    mContext.registerReceiver(mListener, filter);
+  }
+
+  public void startDiscovering() {
+    mListener.discoverAll();
+  }
+
+  public void startDiscovering(String mime) {
+    mListener.discoverForType(mime);
+  }
+
+  public boolean isDiscoveryComplete() {
+    return mIsDiscoveryComplete;
+  }
+
+  public void registerObserver(ConfigurationObserver observer) {
+    if (observer != null) {
+      mObserverSet.add(observer);
+    }
+  }
+
+  public void unregisterObserver(ConfigurationObserver observer) {
+    if (observer != null) {
+      mObserverSet.remove(observer);
+    }
+  }
+
+  /**
+   * Returns the list of all known interpreters.
+   */
+  public List<? extends Interpreter> getSupportedInterpreters() {
+    return new ArrayList<Interpreter>(mInterpreterSet);
+  }
+
+  /**
+   * Returns the list of all installed interpreters.
+   */
+  public List<Interpreter> getInstalledInterpreters() {
+    List<Interpreter> interpreters = new ArrayList<Interpreter>();
+    for (Interpreter i : mInterpreterSet) {
+      if (i.isInstalled()) {
+        interpreters.add(i);
+      }
+    }
+    return interpreters;
+  }
+
+  /**
+   * Returns the list of interpreters that support interactive mode execution.
+   */
+  public List<Interpreter> getInteractiveInterpreters() {
+    List<Interpreter> interpreters = new ArrayList<Interpreter>();
+    for (Interpreter i : mInterpreterSet) {
+      if (i.isInstalled() && i.hasInteractiveMode()) {
+        interpreters.add(i);
+      }
+    }
+    return interpreters;
+  }
+
+  /**
+   * Returns the interpreter matching the provided name or null if no interpreter was found.
+   */
+  public Interpreter getInterpreterByName(String interpreterName) {
+    for (Interpreter i : mInterpreterSet) {
+      if (i.getName().equals(interpreterName)) {
+        return i;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns the correct interpreter for the provided script name based on the script's extension or
+   * null if no interpreter was found.
+   */
+  public Interpreter getInterpreterForScript(String scriptName) {
+    int dotIndex = scriptName.lastIndexOf('.');
+    if (dotIndex == -1) {
+      return null;
+    }
+    String ext = scriptName.substring(dotIndex);
+    for (Interpreter i : mInterpreterSet) {
+      if (i.getExtension().equals(ext)) {
+        return i;
+      }
+    }
+    return null;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/interpreter/html/HtmlActivityTask.java b/Common/src/com/googlecode/android_scripting/interpreter/html/HtmlActivityTask.java
new file mode 100644
index 0000000..fa5d768
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/interpreter/html/HtmlActivityTask.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter.html;
+
+import android.app.Activity;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.net.Uri;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Menu;
+import android.view.View;
+import android.view.Window;
+import android.webkit.JsPromptResult;
+import android.webkit.JsResult;
+import android.webkit.WebChromeClient;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+import com.googlecode.android_scripting.FileUtils;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.SingleThreadExecutor;
+import com.googlecode.android_scripting.event.Event;
+import com.googlecode.android_scripting.event.EventObserver;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.ui.UiFacade;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+import com.googlecode.android_scripting.jsonrpc.JsonBuilder;
+import com.googlecode.android_scripting.jsonrpc.JsonRpcResult;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.rpc.RpcError;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public class HtmlActivityTask extends FutureActivityTask<Void> {
+
+  private static final String HTTP = "http";
+  private static final String ANDROID_PROTOTYPE_JS =
+      "Android.prototype.%1$s = function(var_args) { "
+          + "return this._call(\"%1$s\", Array.prototype.slice.call(arguments)); };";
+
+  private static final String PREFIX = "file://";
+  private static final String BASE_URL = PREFIX + InterpreterConstants.SCRIPTS_ROOT;
+
+  private final RpcReceiverManager mReceiverManager;
+  private final String mJsonSource;
+  private final String mAndroidJsSource;
+  private final String mAPIWrapperSource;
+  private final String mUrl;
+  private final JavaScriptWrapper mWrapper;
+  private final HtmlEventObserver mObserver;
+  private final UiFacade mUiFacade;
+  private ChromeClient mChromeClient;
+  private WebView mView;
+  private MyWebViewClient mWebViewClient;
+  private static HtmlActivityTask reference;
+  private boolean mDestroyManager;
+
+  public HtmlActivityTask(RpcReceiverManager manager, String androidJsSource, String jsonSource,
+      String url, boolean destroyManager) {
+    reference = this;
+    mReceiverManager = manager;
+    mJsonSource = jsonSource;
+    mAndroidJsSource = androidJsSource;
+    mAPIWrapperSource = generateAPIWrapper();
+    mWrapper = new JavaScriptWrapper();
+    mObserver = new HtmlEventObserver();
+    mReceiverManager.getReceiver(EventFacade.class).addGlobalEventObserver(mObserver);
+    mUiFacade = mReceiverManager.getReceiver(UiFacade.class);
+    mUrl = url;
+    mDestroyManager = destroyManager;
+  }
+
+  public RpcReceiverManager getRpcReceiverManager() {
+    return mReceiverManager;
+  }
+
+  /*
+   * New WebviewClient
+   */
+  private class MyWebViewClient extends WebViewClient {
+    @Override
+    public boolean shouldOverrideUrlLoading(WebView view, String url) {
+      /*
+       * if (Uri.parse(url).getHost().equals("www.example.com")) {
+       * // This is my web site, so do not
+       * override; let my WebView load the page return false; }
+       * // Otherwise, the link is not for a
+       * page on my site, so launch another Activity that handles URLs Intent intent = new
+       * Intent(Intent.ACTION_VIEW, Uri.parse(url)); startActivity(intent);
+       */
+      if (!HTTP.equals(Uri.parse(url).getScheme())) {
+        String source = null;
+        try {
+          source = FileUtils.readToString(new File(Uri.parse(url).getPath()));
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+        source =
+            "<script>" + mJsonSource + "</script>" + "<script>" + mAndroidJsSource + "</script>"
+                + "<script>" + mAPIWrapperSource + "</script>" + source;
+        mView.loadDataWithBaseURL(BASE_URL, source, "text/html", "utf-8", null);
+      } else {
+        mView.loadUrl(url);
+      }
+      return true;
+    }
+  }
+
+  @Override
+  public void onCreate() {
+    mView = new WebView(getActivity());
+    mView.setId(1);
+    mView.getSettings().setJavaScriptEnabled(true);
+    mView.addJavascriptInterface(mWrapper, "_rpc_wrapper");
+    mView.addJavascriptInterface(new Object() {
+
+      @SuppressWarnings("unused")
+      public void register(String event, int id) {
+        mObserver.register(event, id);
+      }
+    }, "_callback_wrapper");
+
+    getActivity().setContentView(mView);
+    mView.setOnCreateContextMenuListener(getActivity());
+    mChromeClient = new ChromeClient(getActivity());
+    mWebViewClient = new MyWebViewClient();
+    mView.setWebChromeClient(mChromeClient);
+    mView.setWebViewClient(mWebViewClient);
+    mView.loadUrl("javascript:" + mJsonSource);
+    mView.loadUrl("javascript:" + mAndroidJsSource);
+    mView.loadUrl("javascript:" + mAPIWrapperSource);
+    load();
+  }
+
+  private void load() {
+    if (!HTTP.equals(Uri.parse(mUrl).getScheme())) {
+      String source = null;
+      try {
+        source = FileUtils.readToString(new File(Uri.parse(mUrl).getPath()));
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+      mView.loadDataWithBaseURL(BASE_URL, source, "text/html", "utf-8", null);
+    } else {
+      mView.loadUrl(mUrl);
+    }
+  }
+
+  @Override
+  public void onDestroy() {
+    mReceiverManager.getReceiver(EventFacade.class).removeEventObserver(mObserver);
+    if (mDestroyManager) {
+      mReceiverManager.shutdown();
+    }
+    mView.destroy();
+    mView = null;
+    reference = null;
+    setResult(null);
+  }
+
+  public static void shutdown() {
+    if (HtmlActivityTask.reference != null) {
+      HtmlActivityTask.reference.finish();
+    }
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    mUiFacade.onCreateContextMenu(menu, v, menuInfo);
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    return mUiFacade.onPrepareOptionsMenu(menu);
+  }
+
+  private String generateAPIWrapper() {
+    StringBuilder wrapper = new StringBuilder();
+    for (Class<? extends RpcReceiver> clazz : mReceiverManager.getRpcReceiverClasses()) {
+      for (MethodDescriptor rpc : MethodDescriptor.collectFrom(clazz)) {
+        wrapper.append(String.format(ANDROID_PROTOTYPE_JS, rpc.getName()));
+      }
+    }
+    return wrapper.toString();
+  }
+
+  private class JavaScriptWrapper {
+    @SuppressWarnings("unused")
+    public String call(String data) throws JSONException {
+      Log.v("Received: " + data);
+      JSONObject request = new JSONObject(data);
+      int id = request.getInt("id");
+      String method = request.getString("method");
+      JSONArray params = request.getJSONArray("params");
+      MethodDescriptor rpc = mReceiverManager.getMethodDescriptor(method);
+      if (rpc == null) {
+        return JsonRpcResult.error(id, new RpcError("Unknown RPC.")).toString();
+      }
+      try {
+        return JsonRpcResult.result(id, rpc.invoke(mReceiverManager, params)).toString();
+      } catch (Throwable t) {
+        Log.e("Invocation error.", t);
+        return JsonRpcResult.error(id, t).toString();
+      }
+    }
+
+    @SuppressWarnings("unused")
+    public void dismiss() {
+      Activity parent = getActivity();
+      parent.finish();
+    }
+  }
+
+  private class HtmlEventObserver implements EventObserver {
+    private Map<String, Set<Integer>> mEventMap = new HashMap<String, Set<Integer>>();
+
+    public void register(String eventName, Integer id) {
+      if (mEventMap.containsKey(eventName)) {
+        mEventMap.get(eventName).add(id);
+      } else {
+        Set<Integer> idSet = new HashSet<Integer>();
+        idSet.add(id);
+        mEventMap.put(eventName, idSet);
+      }
+    }
+
+    @Override
+    public void onEventReceived(Event event) {
+      final JSONObject json = new JSONObject();
+      try {
+        json.put("data", JsonBuilder.build(event.getData()));
+      } catch (JSONException e) {
+        Log.e(e);
+      }
+      if (mEventMap.containsKey(event.getName())) {
+        for (final Integer id : mEventMap.get(event.getName())) {
+          getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+              mView.loadUrl(String.format("javascript:droid._callback(%d, %s);", id, json));
+            }
+          });
+        }
+      }
+    }
+
+    @SuppressWarnings("unused")
+    public void dismiss() {
+      Activity parent = getActivity();
+      parent.finish();
+    }
+  }
+
+  private class ChromeClient extends WebChromeClient {
+    private final static String JS_TITLE = "JavaScript Dialog";
+
+    private final Activity mActivity;
+    private final Resources mResources;
+    private final ExecutorService mmExecutor;
+
+    public ChromeClient(Activity activity) {
+      mActivity = activity;
+      mResources = mActivity.getResources();
+      mmExecutor = new SingleThreadExecutor();
+    }
+
+    @Override
+    public void onReceivedTitle(WebView view, String title) {
+      mActivity.setTitle(title);
+    }
+
+    @Override
+    public void onReceivedIcon(WebView view, Bitmap icon) {
+      mActivity.getWindow().requestFeature(Window.FEATURE_RIGHT_ICON);
+      mActivity.getWindow().setFeatureDrawable(Window.FEATURE_RIGHT_ICON,
+                                               new BitmapDrawable(mActivity.getResources(), icon));
+    }
+
+    @Override
+    public boolean onJsAlert(WebView view, String url, String message, final JsResult result) {
+      final UiFacade uiFacade = mReceiverManager.getReceiver(UiFacade.class);
+      uiFacade.dialogCreateAlert(JS_TITLE, message);
+      uiFacade.dialogSetPositiveButtonText(mResources.getString(android.R.string.ok));
+
+      mmExecutor.execute(new Runnable() {
+
+        @Override
+        public void run() {
+          try {
+            uiFacade.dialogShow();
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+          uiFacade.dialogGetResponse();
+          result.confirm();
+        }
+      });
+      return true;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean onJsConfirm(WebView view, String url, String message, final JsResult result) {
+      final UiFacade uiFacade = mReceiverManager.getReceiver(UiFacade.class);
+      uiFacade.dialogCreateAlert(JS_TITLE, message);
+      uiFacade.dialogSetPositiveButtonText(mResources.getString(android.R.string.ok));
+      uiFacade.dialogSetNegativeButtonText(mResources.getString(android.R.string.cancel));
+
+      mmExecutor.execute(new Runnable() {
+
+        @Override
+        public void run() {
+          try {
+            uiFacade.dialogShow();
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+          Map<String, Object> mResultMap = (Map<String, Object>) uiFacade.dialogGetResponse();
+          if ("positive".equals(mResultMap.get("which"))) {
+            result.confirm();
+          } else {
+            result.cancel();
+          }
+        }
+      });
+
+      return true;
+    }
+
+    @Override
+    public boolean onJsPrompt(WebView view, String url, final String message,
+        final String defaultValue, final JsPromptResult result) {
+      final UiFacade uiFacade = mReceiverManager.getReceiver(UiFacade.class);
+      mmExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          String value = null;
+          try {
+            value = uiFacade.dialogGetInput(JS_TITLE, message, defaultValue);
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+          if (value != null) {
+            result.confirm(value);
+          } else {
+            result.cancel();
+          }
+        }
+      });
+      return true;
+    }
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/interpreter/html/HtmlInterpreter.java b/Common/src/com/googlecode/android_scripting/interpreter/html/HtmlInterpreter.java
new file mode 100644
index 0000000..3f86ff0
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/interpreter/html/HtmlInterpreter.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter.html;
+
+import android.content.Context;
+
+import com.googlecode.android_scripting.FileUtils;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.language.HtmlLanguage;
+
+import java.io.IOException;
+
+public class HtmlInterpreter extends Interpreter {
+
+  public static final String HTML = "html";
+  public static final String HTML_EXTENSION = ".html";
+
+  public static final String JSON_FILE = "json2.js";
+  public static final String ANDROID_JS_FILE = "android.js";
+  public static final String HTML_NICE_NAME = "HTML and JavaScript";
+
+  private final String mJson;
+  private final String mAndroidJs;
+
+  public HtmlInterpreter(Context context) throws IOException {
+    setExtension(HTML_EXTENSION);
+    setName(HTML);
+    setNiceName(HTML_NICE_NAME);
+    setInteractiveCommand("");
+    setScriptCommand("%s");
+    setLanguage(new HtmlLanguage());
+    setHasInteractiveMode(false);
+    mJson = FileUtils.readFromAssetsFile(context, JSON_FILE);
+    mAndroidJs = FileUtils.readFromAssetsFile(context, ANDROID_JS_FILE);
+  }
+
+  public boolean hasInterpreterArchive() {
+    return false;
+  }
+
+  public boolean hasExtrasArchive() {
+    return false;
+  }
+
+  public boolean hasScriptsArchive() {
+    return false;
+  }
+
+  public int getVersion() {
+    return 0;
+  }
+
+  @Override
+  public boolean isUninstallable() {
+    return false;
+  }
+
+  @Override
+  public boolean isInstalled() {
+    return true;
+  }
+
+  public String getJsonSource() {
+    return mJson;
+  }
+
+  public String getAndroidJsSource() {
+    return mAndroidJs;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/interpreter/shell/ShellInterpreter.java b/Common/src/com/googlecode/android_scripting/interpreter/shell/ShellInterpreter.java
new file mode 100644
index 0000000..a1f11ff
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/interpreter/shell/ShellInterpreter.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter.shell;
+
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.language.ShellLanguage;
+
+import java.io.File;
+
+/**
+ * Represents the shell.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class ShellInterpreter extends Interpreter {
+  private final static String SHELL_BIN = "/system/bin/sh";
+
+  public ShellInterpreter() {
+    setExtension(".sh");
+    setName("sh");
+    setNiceName("Shell");
+    setBinary(new File(SHELL_BIN));
+    setInteractiveCommand("");
+    setScriptCommand("%s");
+    setLanguage(new ShellLanguage());
+    setHasInteractiveMode(true);
+  }
+
+  public boolean hasInterpreterArchive() {
+    return false;
+  }
+
+  public boolean hasExtrasArchive() {
+    return false;
+  }
+
+  public boolean hasScriptsArchive() {
+    return false;
+  }
+
+  public int getVersion() {
+    return 0;
+  }
+
+  @Override
+  public boolean isUninstallable() {
+    return false;
+  }
+
+  @Override
+  public boolean isInstalled() {
+    return true;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/JsonBuilder.java b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonBuilder.java
new file mode 100644
index 0000000..24428a4
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonBuilder.java
@@ -0,0 +1,1188 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.URL;
+import java.security.PrivateKey;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.apache.commons.codec.binary.Base64Codec;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.le.AdvertiseSettings;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.graphics.Point;
+import android.location.Address;
+import android.location.Location;
+import android.net.DhcpInfo;
+import android.net.Network;
+import android.net.NetworkInfo;
+import android.net.Uri;
+import android.net.wifi.RttManager.RttCapabilities;
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiActivityEnergyInfo;
+import android.net.wifi.WifiChannel;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiEnterpriseConfig;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiScanner.ScanData;
+import android.net.wifi.p2p.WifiP2pDevice;
+import android.net.wifi.p2p.WifiP2pGroup;
+import android.net.wifi.p2p.WifiP2pInfo;
+import android.os.Bundle;
+import android.os.ParcelUuid;
+import android.telecom.Call;
+import android.telecom.CallAudioState;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.VideoProfile;
+import android.telecom.VideoProfile.CameraCapabilities;
+import android.telephony.CellIdentityCdma;
+import android.telephony.CellIdentityGsm;
+import android.telephony.CellIdentityLte;
+import android.telephony.CellIdentityWcdma;
+import android.telephony.CellInfoCdma;
+import android.telephony.CellInfoGsm;
+import android.telephony.CellInfoLte;
+import android.telephony.CellInfoWcdma;
+import android.telephony.CellLocation;
+import android.telephony.CellSignalStrengthCdma;
+import android.telephony.CellSignalStrengthGsm;
+import android.telephony.CellSignalStrengthLte;
+import android.telephony.CellSignalStrengthWcdma;
+import android.telephony.ModemActivityInfo;
+import android.telephony.NeighboringCellInfo;
+import android.telephony.SmsMessage;
+import android.telephony.SignalStrength;
+import android.telephony.SubscriptionInfo;
+import android.telephony.gsm.GsmCellLocation;
+import android.telephony.VoLteServiceState;
+import android.util.Base64;
+import android.util.DisplayMetrics;
+import android.util.SparseArray;
+
+import com.googlecode.android_scripting.ConvertUtils;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.event.Event;
+//FIXME: Refactor classes, constants and conversions out of here
+import com.googlecode.android_scripting.facade.telephony.InCallServiceImpl;
+import com.googlecode.android_scripting.facade.telephony.TelephonyUtils;
+import com.googlecode.android_scripting.facade.telephony.TelephonyConstants;
+
+public class JsonBuilder {
+
+    @SuppressWarnings("unchecked")
+    public static Object build(Object data) throws JSONException {
+        if (data == null) {
+            return JSONObject.NULL;
+        }
+        if (data instanceof Integer) {
+            return data;
+        }
+        if (data instanceof Float) {
+            return data;
+        }
+        if (data instanceof Double) {
+            return data;
+        }
+        if (data instanceof Long) {
+            return data;
+        }
+        if (data instanceof String) {
+            return data;
+        }
+        if (data instanceof Boolean) {
+            return data;
+        }
+        if (data instanceof JsonSerializable) {
+            return ((JsonSerializable)data).toJSON();
+        }
+        if (data instanceof JSONObject) {
+            return data;
+        }
+        if (data instanceof JSONArray) {
+            return data;
+        }
+        if (data instanceof Set<?>) {
+            List<Object> items = new ArrayList<Object>((Set<?>) data);
+            return buildJsonList(items);
+        }
+        if (data instanceof Collection<?>) {
+            List<Object> items = new ArrayList<Object>((Collection<?>) data);
+            return buildJsonList(items);
+        }
+        if (data instanceof List<?>) {
+            return buildJsonList((List<?>) data);
+        }
+        if (data instanceof Address) {
+            return buildJsonAddress((Address) data);
+        }
+        if (data instanceof CallAudioState) {
+            return buildJsonAudioState((CallAudioState) data);
+        }
+        if (data instanceof Location) {
+            return buildJsonLocation((Location) data);
+        }
+        if (data instanceof Bundle) {
+            return buildJsonBundle((Bundle) data);
+        }
+        if (data instanceof Intent) {
+            return buildJsonIntent((Intent) data);
+        }
+        if (data instanceof Event) {
+            return buildJsonEvent((Event) data);
+        }
+        if (data instanceof Map<?, ?>) {
+            // TODO(damonkohler): I would like to make this a checked cast if
+            // possible.
+            return buildJsonMap((Map<String, ?>) data);
+        }
+        if (data instanceof ParcelUuid) {
+            return data.toString();
+        }
+        if (data instanceof ScanResult) {
+            return buildJsonScanResult((ScanResult) data);
+        }
+        if (data instanceof ScanData) {
+            return buildJsonScanData((ScanData) data);
+        }
+        if (data instanceof android.bluetooth.le.ScanResult) {
+            return buildJsonBleScanResult((android.bluetooth.le.ScanResult) data);
+        }
+        if (data instanceof AdvertiseSettings) {
+            return buildJsonBleAdvertiseSettings((AdvertiseSettings) data);
+        }
+        if (data instanceof BluetoothGattService) {
+            return buildJsonBluetoothGattService((BluetoothGattService) data);
+        }
+        if (data instanceof BluetoothGattCharacteristic) {
+            return buildJsonBluetoothGattCharacteristic((BluetoothGattCharacteristic) data);
+        }
+        if (data instanceof BluetoothGattDescriptor) {
+            return buildJsonBluetoothGattDescriptor((BluetoothGattDescriptor) data);
+        }
+        if (data instanceof BluetoothDevice) {
+            return buildJsonBluetoothDevice((BluetoothDevice) data);
+        }
+        if (data instanceof CellLocation) {
+            return buildJsonCellLocation((CellLocation) data);
+        }
+        if (data instanceof WifiInfo) {
+            return buildJsonWifiInfo((WifiInfo) data);
+        }
+        if (data instanceof NeighboringCellInfo) {
+            return buildNeighboringCellInfo((NeighboringCellInfo) data);
+        }
+        if (data instanceof Network) {
+            return buildNetwork((Network) data);
+        }
+        if (data instanceof NetworkInfo) {
+            return buildNetworkInfo((NetworkInfo) data);
+        }
+        if (data instanceof HttpURLConnection) {
+            return buildHttpURLConnection((HttpURLConnection) data);
+        }
+        if (data instanceof InetSocketAddress) {
+            return buildInetSocketAddress((InetSocketAddress) data);
+        }
+        if (data instanceof InetAddress) {
+            return buildInetAddress((InetAddress) data);
+        }
+        if (data instanceof URL) {
+            return buildURL((URL) data);
+        }
+        if (data instanceof Point) {
+            return buildPoint((Point) data);
+        }
+        if (data instanceof SmsMessage) {
+            return buildSmsMessage((SmsMessage) data);
+        }
+        if (data instanceof PhoneAccount) {
+            return buildPhoneAccount((PhoneAccount) data);
+        }
+        if (data instanceof PhoneAccountHandle) {
+            return buildPhoneAccountHandle((PhoneAccountHandle) data);
+        }
+        if (data instanceof SubscriptionInfo) {
+            return buildSubscriptionInfoRecord((SubscriptionInfo) data);
+        }
+        if (data instanceof DhcpInfo) {
+            return buildDhcpInfo((DhcpInfo) data);
+        }
+        if (data instanceof DisplayMetrics) {
+            return buildDisplayMetrics((DisplayMetrics) data);
+        }
+        if (data instanceof RttCapabilities) {
+            return buildRttCapabilities((RttCapabilities) data);
+        }
+        if (data instanceof WifiActivityEnergyInfo) {
+            return buildWifiActivityEnergyInfo((WifiActivityEnergyInfo) data);
+        }
+        if (data instanceof WifiChannel) {
+            return buildWifiChannel((WifiChannel) data);
+        }
+        if (data instanceof WifiConfiguration) {
+            return buildWifiConfiguration((WifiConfiguration) data);
+        }
+        if (data instanceof WifiP2pDevice) {
+            return buildWifiP2pDevice((WifiP2pDevice) data);
+        }
+        if (data instanceof WifiP2pInfo) {
+            return buildWifiP2pInfo((WifiP2pInfo) data);
+        }
+        if (data instanceof WifiP2pGroup) {
+            return buildWifiP2pGroup((WifiP2pGroup) data);
+        }
+        if (data instanceof byte[]) {
+            return Base64Codec.encodeBase64((byte[]) data);
+        }
+        if (data instanceof Object[]) {
+            return buildJSONArray((Object[]) data);
+        }
+        if (data instanceof CellInfoLte) {
+            return buildCellInfoLte((CellInfoLte) data);
+        }
+        if (data instanceof CellInfoWcdma) {
+            return buildCellInfoWcdma((CellInfoWcdma) data);
+        }
+        if (data instanceof CellInfoGsm) {
+            return buildCellInfoGsm((CellInfoGsm) data);
+        }
+        if (data instanceof CellInfoCdma) {
+            return buildCellInfoCdma((CellInfoCdma) data);
+        }
+        if (data instanceof Call) {
+            return buildCall((Call) data);
+        }
+        if (data instanceof Call.Details) {
+            return buildCallDetails((Call.Details) data);
+        }
+        if (data instanceof InCallServiceImpl.CallEvent<?>) {
+            return buildCallEvent((InCallServiceImpl.CallEvent<?>) data);
+        }
+        if (data instanceof VideoProfile) {
+            return buildVideoProfile((VideoProfile) data);
+        }
+        if (data instanceof CameraCapabilities) {
+            return buildCameraCapabilities((CameraCapabilities) data);
+        }
+        if (data instanceof VoLteServiceState) {
+            return buildVoLteServiceStateEvent((VoLteServiceState) data);
+        }
+        if (data instanceof ModemActivityInfo) {
+            return buildModemActivityInfo((ModemActivityInfo) data);
+        }
+        if (data instanceof SignalStrength) {
+            return buildSignalStrength((SignalStrength) data);
+        }
+
+
+        return data.toString();
+        // throw new JSONException("Failed to build JSON result. " +
+        // data.getClass().getName());
+    }
+
+    private static JSONObject buildJsonAudioState(CallAudioState data)
+            throws JSONException {
+        JSONObject state = new JSONObject();
+        state.put("isMuted", data.isMuted());
+        state.put("AudioRoute", InCallServiceImpl.getAudioRouteString(data.getRoute()));
+        return state;
+    }
+
+    private static Object buildDisplayMetrics(DisplayMetrics data)
+            throws JSONException {
+        JSONObject dm = new JSONObject();
+        dm.put("widthPixels", data.widthPixels);
+        dm.put("heightPixels", data.heightPixels);
+        dm.put("noncompatHeightPixels", data.noncompatHeightPixels);
+        dm.put("noncompatWidthPixels", data.noncompatWidthPixels);
+        return dm;
+    }
+
+    private static Object buildInetAddress(InetAddress data) {
+        JSONArray address = new JSONArray();
+        address.put(data.getHostName());
+        address.put(data.getHostAddress());
+        return address;
+    }
+
+    private static Object buildInetSocketAddress(InetSocketAddress data) {
+        JSONArray address = new JSONArray();
+        address.put(data.getHostName());
+        address.put(data.getPort());
+        return address;
+    }
+
+    private static JSONObject buildJsonAddress(Address address)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("admin_area", address.getAdminArea());
+        result.put("country_code", address.getCountryCode());
+        result.put("country_name", address.getCountryName());
+        result.put("feature_name", address.getFeatureName());
+        result.put("phone", address.getPhone());
+        result.put("locality", address.getLocality());
+        result.put("postal_code", address.getPostalCode());
+        result.put("sub_admin_area", address.getSubAdminArea());
+        result.put("thoroughfare", address.getThoroughfare());
+        result.put("url", address.getUrl());
+        return result;
+    }
+
+    private static JSONArray buildJSONArray(Object[] data) throws JSONException {
+        JSONArray result = new JSONArray();
+        for (Object o : data) {
+            result.put(build(o));
+        }
+        return result;
+    }
+
+    private static JSONObject buildJsonBleAdvertiseSettings(
+            AdvertiseSettings advertiseSettings) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("mode", advertiseSettings.getMode());
+        result.put("txPowerLevel", advertiseSettings.getTxPowerLevel());
+        result.put("isConnectable", advertiseSettings.isConnectable());
+        return result;
+    }
+
+    private static JSONObject buildJsonBleScanResult(
+            android.bluetooth.le.ScanResult scanResult) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("rssi", scanResult.getRssi());
+        result.put("timestampNanos", scanResult.getTimestampNanos());
+        result.put("deviceName", scanResult.getScanRecord().getDeviceName());
+        result.put("txPowerLevel", scanResult.getScanRecord().getTxPowerLevel());
+        result.put("advertiseFlags", scanResult.getScanRecord()
+                .getAdvertiseFlags());
+        ArrayList<String> manufacturerDataList = new ArrayList<String>();
+        ArrayList<Integer> idList = new ArrayList<Integer>();
+        if (scanResult.getScanRecord().getManufacturerSpecificData() != null) {
+            SparseArray<byte[]> manufacturerSpecificData = scanResult
+                    .getScanRecord().getManufacturerSpecificData();
+            for (int i = 0; i < manufacturerSpecificData.size(); i++) {
+                manufacturerDataList.add(ConvertUtils
+                        .convertByteArrayToString(manufacturerSpecificData
+                                .valueAt(i)));
+                idList.add(manufacturerSpecificData.keyAt(i));
+            }
+        }
+        result.put("manufacturerSpecificDataList", manufacturerDataList);
+        result.put("manufacturereIdList", idList);
+        ArrayList<String> serviceUuidList = new ArrayList<String>();
+        ArrayList<String> serviceDataList = new ArrayList<String>();
+        if (scanResult.getScanRecord().getServiceData() != null) {
+            Map<ParcelUuid, byte[]> serviceDataMap = scanResult.getScanRecord()
+                    .getServiceData();
+            for (ParcelUuid serviceUuid : serviceDataMap.keySet()) {
+                serviceUuidList.add(serviceUuid.toString());
+                serviceDataList.add(ConvertUtils
+                        .convertByteArrayToString(serviceDataMap
+                                .get(serviceUuid)));
+            }
+        }
+        result.put("serviceUuidList", serviceUuidList);
+        result.put("serviceDataList", serviceDataList);
+        List<ParcelUuid> serviceUuids = scanResult.getScanRecord()
+                .getServiceUuids();
+        String serviceUuidsString = "";
+        if (serviceUuids != null && serviceUuids.size() > 0) {
+            for (ParcelUuid uuid : serviceUuids) {
+                serviceUuidsString = serviceUuidsString + "," + uuid;
+            }
+        }
+        result.put("serviceUuids", serviceUuidsString);
+        result.put("scanRecord",
+                build(ConvertUtils.convertByteArrayToString(scanResult
+                        .getScanRecord().getBytes())));
+        result.put("deviceInfo", build(scanResult.getDevice()));
+        return result;
+    }
+
+    private static JSONObject buildJsonBluetoothDevice(BluetoothDevice data)
+            throws JSONException {
+        JSONObject deviceInfo = new JSONObject();
+        deviceInfo.put("address", data.getAddress());
+        deviceInfo.put("state", data.getBondState());
+        deviceInfo.put("name", data.getName());
+        deviceInfo.put("type", data.getType());
+        return deviceInfo;
+    }
+
+    private static Object buildJsonBluetoothGattCharacteristic(
+            BluetoothGattCharacteristic data) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("instanceId", data.getInstanceId());
+        result.put("permissions", data.getPermissions());
+        result.put("properties", data.getProperties());
+        result.put("writeType", data.getWriteType());
+        result.put("descriptorsList", build(data.getDescriptors()));
+        result.put("uuid", data.getUuid().toString());
+        result.put("value", build(data.getValue()));
+
+        return result;
+    }
+
+    private static Object buildJsonBluetoothGattDescriptor(
+            BluetoothGattDescriptor data) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("instanceId", data.getInstanceId());
+        result.put("permissions", data.getPermissions());
+        result.put("characteristic", data.getCharacteristic());
+        result.put("uuid", data.getUuid().toString());
+        result.put("value", build(data.getValue()));
+        return result;
+    }
+
+    private static Object buildJsonBluetoothGattService(
+            BluetoothGattService data) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("instanceId", data.getInstanceId());
+        result.put("type", data.getType());
+        result.put("gattCharacteristicList", build(data.getCharacteristics()));
+        result.put("includedServices", build(data.getIncludedServices()));
+        result.put("uuid", data.getUuid().toString());
+        return result;
+    }
+
+    private static JSONObject buildJsonBundle(Bundle bundle)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        for (String key : bundle.keySet()) {
+            result.put(key, build(bundle.get(key)));
+        }
+        return result;
+    }
+
+    private static JSONObject buildJsonCellLocation(CellLocation cellLocation)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        if (cellLocation instanceof GsmCellLocation) {
+            GsmCellLocation location = (GsmCellLocation) cellLocation;
+            result.put("lac", location.getLac());
+            result.put("cid", location.getCid());
+        }
+        // TODO(damonkohler): Add support for CdmaCellLocation. Not supported
+        // until API level 5.
+        return result;
+    }
+
+    private static JSONObject buildDhcpInfo(DhcpInfo data) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("ipAddress", data.ipAddress);
+        result.put("dns1", data.dns1);
+        result.put("dns2", data.dns2);
+        result.put("gateway", data.gateway);
+        result.put("serverAddress", data.serverAddress);
+        result.put("leaseDuration", data.leaseDuration);
+        return result;
+    }
+
+    private static JSONObject buildJsonEvent(Event event) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("name", event.getName());
+        result.put("data", build(event.getData()));
+        result.put("time", event.getCreationTime());
+        return result;
+    }
+
+    private static JSONObject buildJsonIntent(Intent data) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("data", data.getDataString());
+        result.put("type", data.getType());
+        result.put("extras", build(data.getExtras()));
+        result.put("categories", build(data.getCategories()));
+        result.put("action", data.getAction());
+        ComponentName component = data.getComponent();
+        if (component != null) {
+            result.put("packagename", component.getPackageName());
+            result.put("classname", component.getClassName());
+        }
+        result.put("flags", data.getFlags());
+        return result;
+    }
+
+    private static <T> JSONArray buildJsonList(final List<T> list)
+            throws JSONException {
+        JSONArray result = new JSONArray();
+        for (T item : list) {
+            result.put(build(item));
+        }
+        return result;
+    }
+
+    private static JSONObject buildJsonLocation(Location location)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("altitude", location.getAltitude());
+        result.put("latitude", location.getLatitude());
+        result.put("longitude", location.getLongitude());
+        result.put("time", location.getTime());
+        result.put("accuracy", location.getAccuracy());
+        result.put("speed", location.getSpeed());
+        result.put("provider", location.getProvider());
+        result.put("bearing", location.getBearing());
+        return result;
+    }
+
+    private static JSONObject buildJsonMap(Map<String, ?> map)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        for (Entry<String, ?> entry : map.entrySet()) {
+            String key = entry.getKey();
+            if (key == null) {
+                key = "";
+            }
+            result.put(key, build(entry.getValue()));
+        }
+        return result;
+    }
+
+    private static JSONObject buildJsonScanResult(ScanResult scanResult)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("BSSID", scanResult.BSSID);
+        result.put("SSID", scanResult.SSID);
+        result.put("frequency", scanResult.frequency);
+        result.put("level", scanResult.level);
+        result.put("capabilities", scanResult.capabilities);
+        result.put("timestamp", scanResult.timestamp);
+        result.put("autoJoinStatus", scanResult.autoJoinStatus);
+        result.put("blackListTimestamp", scanResult.blackListTimestamp);
+        result.put("centerFreq0", scanResult.centerFreq0);
+        result.put("centerFreq1", scanResult.centerFreq1);
+        result.put("channelWidth", scanResult.channelWidth);
+        result.put("distanceCm", scanResult.distanceCm);
+        result.put("distanceSdCm", scanResult.distanceSdCm);
+        result.put("is80211McRTTResponder", scanResult.is80211mcResponder());
+        result.put("isAutoJoinCandidate", scanResult.isAutoJoinCandidate);
+        result.put("numConnection", scanResult.numConnection);
+        result.put("passpointNetwork", scanResult.isPasspointNetwork());
+        result.put("numIpConfigFailures", scanResult.numIpConfigFailures);
+        result.put("numUsage", scanResult.numUsage);
+        result.put("seen", scanResult.seen);
+        result.put("untrusted", scanResult.untrusted);
+        result.put("operatorFriendlyName", scanResult.operatorFriendlyName);
+        result.put("venueName", scanResult.venueName);
+        if (scanResult.informationElements != null) {
+            JSONArray infoEles = new JSONArray();
+            for (ScanResult.InformationElement ie : scanResult.informationElements) {
+                JSONObject infoEle = new JSONObject();
+                infoEle.put("id", ie.id);
+                infoEle.put("bytes", Base64Codec.encodeBase64(ie.bytes).toString());
+                infoEles.put(infoEle);
+            }
+            result.put("InfomationElements", infoEles);
+        } else {
+            result.put("InfomationElements", null);
+        }
+        return result;
+    }
+
+    private static JSONObject buildJsonScanData(ScanData scanData)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("Id", scanData.getId());
+        result.put("Flags", scanData.getFlags());
+        JSONArray scanResults = new JSONArray();
+        for (ScanResult sr : scanData.getResults()) {
+            scanResults.put(buildJsonScanResult(sr));
+        }
+        result.put("ScanResults", scanResults);
+        return result;
+    }
+
+    private static JSONObject buildJsonWifiInfo(WifiInfo data)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("hidden_ssid", data.getHiddenSSID());
+        result.put("ip_address", data.getIpAddress());
+        result.put("link_speed", data.getLinkSpeed());
+        result.put("network_id", data.getNetworkId());
+        result.put("rssi", data.getRssi());
+        result.put("BSSID", data.getBSSID());
+        result.put("mac_address", data.getMacAddress());
+        // Trim the double quotes if exist
+        String ssid = data.getSSID();
+        if (ssid.charAt(0) == '"'
+                && ssid.charAt(ssid.length() - 1) == '"') {
+            result.put("SSID", ssid.substring(1, ssid.length() - 1));
+        } else {
+            result.put("SSID", ssid);
+        }
+        String supplicantState = "";
+        switch (data.getSupplicantState()) {
+            case ASSOCIATED:
+                supplicantState = "associated";
+                break;
+            case ASSOCIATING:
+                supplicantState = "associating";
+                break;
+            case COMPLETED:
+                supplicantState = "completed";
+                break;
+            case DISCONNECTED:
+                supplicantState = "disconnected";
+                break;
+            case DORMANT:
+                supplicantState = "dormant";
+                break;
+            case FOUR_WAY_HANDSHAKE:
+                supplicantState = "four_way_handshake";
+                break;
+            case GROUP_HANDSHAKE:
+                supplicantState = "group_handshake";
+                break;
+            case INACTIVE:
+                supplicantState = "inactive";
+                break;
+            case INVALID:
+                supplicantState = "invalid";
+                break;
+            case SCANNING:
+                supplicantState = "scanning";
+                break;
+            case UNINITIALIZED:
+                supplicantState = "uninitialized";
+                break;
+            default:
+                supplicantState = null;
+        }
+        result.put("supplicant_state", build(supplicantState));
+        result.put("is_5ghz", data.is5GHz());
+        result.put("is_24ghz", data.is24GHz());
+        return result;
+    }
+
+    private static JSONObject buildNeighboringCellInfo(NeighboringCellInfo data)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("cid", data.getCid());
+        result.put("rssi", data.getRssi());
+        result.put("lac", data.getLac());
+        result.put("psc", data.getPsc());
+        String networkType =
+                TelephonyUtils.getNetworkTypeString(data.getNetworkType());
+        result.put("network_type", build(networkType));
+        return result;
+    }
+
+    private static JSONObject buildCellInfoLte(CellInfoLte data)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("rat", "lte");
+        result.put("registered", data.isRegistered());
+        CellIdentityLte cellidentity =
+                ((CellInfoLte) data).getCellIdentity();
+        CellSignalStrengthLte signalstrength =
+                ((CellInfoLte) data).getCellSignalStrength();
+        result.put("mcc", cellidentity.getMcc());
+        result.put("mnc", cellidentity.getMnc());
+        result.put("cid", cellidentity.getCi());
+        result.put("pcid", cellidentity.getPci());
+        result.put("tac", cellidentity.getTac());
+        result.put("rsrp", signalstrength.getDbm());
+        result.put("asulevel", signalstrength.getAsuLevel());
+        result.put("timing_advance", signalstrength.getTimingAdvance());
+        return result;
+    }
+
+    private static JSONObject buildCellInfoGsm(CellInfoGsm data)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("rat", "gsm");
+        result.put("registered", data.isRegistered());
+        CellIdentityGsm cellidentity =
+                ((CellInfoGsm) data).getCellIdentity();
+        CellSignalStrengthGsm signalstrength =
+                ((CellInfoGsm) data).getCellSignalStrength();
+        result.put("mcc", cellidentity.getMcc());
+        result.put("mnc", cellidentity.getMnc());
+        result.put("cid", cellidentity.getCid());
+        result.put("lac", cellidentity.getLac());
+        result.put("signal_strength", signalstrength.getDbm());
+        result.put("asulevel", signalstrength.getAsuLevel());
+        return result;
+    }
+
+    private static JSONObject buildCellInfoWcdma(CellInfoWcdma data)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("rat", "wcdma");
+        result.put("registered", data.isRegistered());
+        CellIdentityWcdma cellidentity =
+                ((CellInfoWcdma) data).getCellIdentity();
+        CellSignalStrengthWcdma signalstrength =
+                ((CellInfoWcdma) data).getCellSignalStrength();
+        result.put("mcc", cellidentity.getMcc());
+        result.put("mnc", cellidentity.getMnc());
+        result.put("cid", cellidentity.getCid());
+        result.put("lac", cellidentity.getLac());
+        result.put("psc", cellidentity.getPsc());
+        result.put("signal_strength", signalstrength.getDbm());
+        result.put("asulevel", signalstrength.getAsuLevel());
+        return result;
+    }
+
+    private static JSONObject buildCellInfoCdma(CellInfoCdma data)
+            throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("rat", "cdma");
+        result.put("registered", data.isRegistered());
+        CellIdentityCdma cellidentity =
+                ((CellInfoCdma) data).getCellIdentity();
+        CellSignalStrengthCdma signalstrength =
+                ((CellInfoCdma) data).getCellSignalStrength();
+        result.put("network_id", cellidentity.getNetworkId());
+        result.put("system_id", cellidentity.getSystemId());
+        result.put("basestation_id", cellidentity.getBasestationId());
+        result.put("longitude", cellidentity.getLongitude());
+        result.put("latitude", cellidentity.getLatitude());
+        result.put("cdma_dbm", signalstrength.getCdmaDbm());
+        result.put("cdma_ecio", signalstrength.getCdmaEcio());
+        result.put("evdo_dbm", signalstrength.getEvdoDbm());
+        result.put("evdo_ecio", signalstrength.getEvdoEcio());
+        result.put("evdo_snr", signalstrength.getEvdoSnr());
+        return result;
+    }
+
+    private static Object buildHttpURLConnection(HttpURLConnection data)
+            throws JSONException {
+        JSONObject con = new JSONObject();
+        try {
+            con.put("ResponseCode", data.getResponseCode());
+            con.put("ResponseMessage", data.getResponseMessage());
+        } catch (IOException e) {
+            e.printStackTrace();
+            return con;
+        }
+        con.put("ContentLength", data.getContentLength());
+        con.put("ContentEncoding", data.getContentEncoding());
+        con.put("ContentType", data.getContentType());
+        con.put("Date", data.getDate());
+        con.put("ReadTimeout", data.getReadTimeout());
+        con.put("HeaderFields", buildJsonMap(data.getHeaderFields()));
+        con.put("URL", buildURL(data.getURL()));
+        return con;
+    }
+
+    private static Object buildNetwork(Network data) throws JSONException {
+        JSONObject nw = new JSONObject();
+        nw.put("netId", data.netId);
+        return nw;
+    }
+
+    private static Object buildNetworkInfo(NetworkInfo data)
+            throws JSONException {
+        JSONObject info = new JSONObject();
+        info.put("isAvailable", data.isAvailable());
+        info.put("isConnected", data.isConnected());
+        info.put("isFailover", data.isFailover());
+        info.put("isRoaming", data.isRoaming());
+        info.put("ExtraInfo", data.getExtraInfo());
+        info.put("FailedReason", data.getReason());
+        info.put("TypeName", data.getTypeName());
+        info.put("SubtypeName", data.getSubtypeName());
+        info.put("State", data.getState().name().toString());
+        return info;
+    }
+
+    private static Object buildURL(URL data) throws JSONException {
+        JSONObject url = new JSONObject();
+        url.put("Authority", data.getAuthority());
+        url.put("Host", data.getHost());
+        url.put("Path", data.getPath());
+        url.put("Port", data.getPort());
+        url.put("Protocol", data.getProtocol());
+        return url;
+    }
+
+    private static JSONObject buildPhoneAccount(PhoneAccount data)
+            throws JSONException {
+        JSONObject acct = new JSONObject();
+        acct.put("Address", data.getAddress().toSafeString());
+        acct.put("SubscriptionAddress", data.getSubscriptionAddress()
+                .toSafeString());
+        acct.put("Label", ((data.getLabel() != null) ? data.getLabel().toString() : ""));
+        acct.put("ShortDescription", ((data.getShortDescription() != null) ? data
+                .getShortDescription().toString() : ""));
+        return acct;
+    }
+
+    private static Object buildPhoneAccountHandle(PhoneAccountHandle data)
+            throws JSONException {
+        JSONObject msg = new JSONObject();
+        msg.put("id", data.getId());
+        msg.put("ComponentName", data.getComponentName().flattenToString());
+        return msg;
+    }
+
+    private static Object buildSubscriptionInfoRecord(SubscriptionInfo data)
+            throws JSONException {
+        JSONObject msg = new JSONObject();
+        msg.put("subscriptionId", data.getSubscriptionId());
+        msg.put("iccId", data.getIccId());
+        msg.put("simSlotIndex", data.getSimSlotIndex());
+        msg.put("displayName", data.getDisplayName());
+        msg.put("nameSource", data.getNameSource());
+        msg.put("iconTint", data.getIconTint());
+        msg.put("number", data.getNumber());
+        msg.put("dataRoaming", data.getDataRoaming());
+        msg.put("mcc", data.getMcc());
+        msg.put("mnc", data.getMnc());
+        return msg;
+    }
+
+    private static Object buildPoint(Point data) throws JSONException {
+        JSONObject point = new JSONObject();
+        point.put("x", data.x);
+        point.put("y", data.y);
+        return point;
+    }
+
+    private static Object buildRttCapabilities(RttCapabilities data)
+            throws JSONException {
+        JSONObject cap = new JSONObject();
+        cap.put("bwSupported", data.bwSupported);
+        cap.put("lciSupported", data.lciSupported);
+        cap.put("lcrSupported", data.lcrSupported);
+        cap.put("oneSidedRttSupported", data.oneSidedRttSupported);
+        cap.put("preambleSupported", data.preambleSupported);
+        cap.put("twoSided11McRttSupported", data.twoSided11McRttSupported);
+        return cap;
+    }
+
+    private static Object buildSmsMessage(SmsMessage data) throws JSONException {
+        JSONObject msg = new JSONObject();
+        msg.put("originatingAddress", data.getOriginatingAddress());
+        msg.put("messageBody", data.getMessageBody());
+        return msg;
+    }
+
+    private static JSONObject buildWifiActivityEnergyInfo(
+            WifiActivityEnergyInfo data) throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("ControllerEnergyUsed", data.getControllerEnergyUsed());
+        result.put("ControllerIdleTimeMillis",
+                data.getControllerIdleTimeMillis());
+        result.put("ControllerRxTimeMillis", data.getControllerRxTimeMillis());
+        result.put("ControllerTxTimeMillis", data.getControllerTxTimeMillis());
+        result.put("StackState", data.getStackState());
+        result.put("TimeStamp", data.getTimeStamp());
+        return result;
+    }
+
+    private static Object buildWifiChannel(WifiChannel data) throws JSONException {
+        JSONObject channel = new JSONObject();
+        channel.put("channelNum", data.channelNum);
+        channel.put("freqMHz", data.freqMHz);
+        channel.put("isDFS", data.isDFS);
+        channel.put("isValid", data.isValid());
+        return channel;
+    }
+
+    private static Object buildWifiConfiguration(WifiConfiguration data)
+            throws JSONException {
+        JSONObject config = new JSONObject();
+        config.put("networkId", data.networkId);
+        // Trim the double quotes if exist
+        if (data.SSID.charAt(0) == '"'
+                && data.SSID.charAt(data.SSID.length() - 1) == '"') {
+            config.put("SSID", data.SSID.substring(1, data.SSID.length() - 1));
+        } else {
+            config.put("SSID", data.SSID);
+        }
+        config.put("BSSID", data.BSSID);
+        config.put("priority", data.priority);
+        config.put("hiddenSSID", data.hiddenSSID);
+        config.put("FQDN", data.FQDN);
+        config.put("providerFriendlyName", data.providerFriendlyName);
+        config.put("isPasspoint", data.isPasspoint());
+        config.put("hiddenSSID", data.hiddenSSID);
+        if (data.status == WifiConfiguration.Status.CURRENT) {
+            config.put("status", "CURRENT");
+        } else if (data.status == WifiConfiguration.Status.DISABLED) {
+            config.put("status", "DISABLED");
+        } else if (data.status == WifiConfiguration.Status.ENABLED) {
+            config.put("status", "ENABLED");
+        } else {
+            config.put("status", "UNKNOWN");
+        }
+        // config.put("enterpriseConfig", buildWifiEnterpriseConfig(data.enterpriseConfig));
+        return config;
+    }
+
+    private static Object buildWifiEnterpriseConfig(WifiEnterpriseConfig data)
+            throws JSONException, CertificateEncodingException {
+        JSONObject config = new JSONObject();
+        config.put(WifiEnterpriseConfig.PLMN_KEY, data.getPlmn());
+        config.put(WifiEnterpriseConfig.REALM_KEY, data.getRealm());
+        config.put(WifiEnterpriseConfig.EAP_KEY, data.getEapMethod());
+        config.put(WifiEnterpriseConfig.PHASE2_KEY, data.getPhase2Method());
+        config.put(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY, data.getAltSubjectMatch());
+        X509Certificate caCert = data.getCaCertificate();
+        String caCertString = Base64.encodeToString(caCert.getEncoded(), Base64.DEFAULT);
+        config.put(WifiEnterpriseConfig.CA_CERT_KEY, caCertString);
+        X509Certificate clientCert = data.getClientCertificate();
+        String clientCertString = Base64.encodeToString(clientCert.getEncoded(), Base64.DEFAULT);
+        config.put(WifiEnterpriseConfig.CLIENT_CERT_KEY, clientCertString);
+        PrivateKey pk = data.getClientPrivateKey();
+        String privateKeyString = Base64.encodeToString(pk.getEncoded(), Base64.DEFAULT);
+        config.put(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY, privateKeyString);
+        config.put(WifiEnterpriseConfig.PASSWORD_KEY, data.getPassword());
+        return config;
+    }
+
+    private static JSONObject buildWifiP2pDevice(WifiP2pDevice data)
+            throws JSONException {
+        JSONObject deviceInfo = new JSONObject();
+        deviceInfo.put("Name", data.deviceName);
+        deviceInfo.put("Address", data.deviceAddress);
+        return deviceInfo;
+    }
+
+    private static JSONObject buildWifiP2pGroup(WifiP2pGroup data)
+            throws JSONException {
+        JSONObject group = new JSONObject();
+        Log.d("build p2p group.");
+        group.put("ClientList", build(data.getClientList()));
+        group.put("Interface", data.getInterface());
+        group.put("Networkname", data.getNetworkName());
+        group.put("Owner", data.getOwner());
+        group.put("Passphrase", data.getPassphrase());
+        group.put("NetworkId", data.getNetworkId());
+        return group;
+    }
+
+    private static JSONObject buildWifiP2pInfo(WifiP2pInfo data)
+            throws JSONException {
+        JSONObject info = new JSONObject();
+        Log.d("build p2p info.");
+        info.put("groupFormed", data.groupFormed);
+        info.put("isGroupOwner", data.isGroupOwner);
+        info.put("groupOwnerAddress", data.groupOwnerAddress);
+        return info;
+    }
+
+    private static <T> JSONObject buildCallEvent(InCallServiceImpl.CallEvent<T> callEvent)
+            throws JSONException {
+        JSONObject jsonEvent = new JSONObject();
+        jsonEvent.put("CallId", callEvent.getCallId());
+        jsonEvent.put("Event", build(callEvent.getEvent()));
+        return jsonEvent;
+    }
+
+    private static JSONObject buildUri(Uri uri) throws JSONException {
+        return new JSONObject().put("Uri", build((uri != null) ? uri.toString() : ""));
+    }
+
+    private static JSONObject buildCallDetails(Call.Details details) throws JSONException {
+
+        JSONObject callDetails = new JSONObject();
+
+        callDetails.put("Handle", buildUri(details.getHandle()));
+        callDetails.put("HandlePresentation",
+                build(InCallServiceImpl.getCallPresentationInfoString(
+                        details.getHandlePresentation())));
+        callDetails.put("CallerDisplayName", build(details.getCallerDisplayName()));
+
+        // TODO AccountHandle
+        // callDetails.put("AccountHandle", build(""));
+
+        callDetails.put("Capabilities",
+                build(InCallServiceImpl.getCallCapabilitiesString(details.getCallCapabilities())));
+
+        callDetails.put("Properties",
+                build(InCallServiceImpl.getCallPropertiesString(details.getCallProperties())));
+
+        // TODO Parse fields in Disconnect Cause
+        callDetails.put("DisconnectCause", build((details.getDisconnectCause() != null) ? details
+                .getDisconnectCause().toString() : ""));
+        callDetails.put("ConnectTimeMillis", build(details.getConnectTimeMillis()));
+
+        // TODO: GatewayInfo
+        // callDetails.put("GatewayInfo", build(""));
+
+        callDetails.put("VideoState",
+                build(InCallServiceImpl.getVideoCallStateString(details.getVideoState())));
+
+        // TODO: StatusHints
+        // callDetails.put("StatusHints", build(""));
+
+        callDetails.put("Extras", build(details.getExtras()));
+
+        return callDetails;
+    }
+
+    private static JSONObject buildCall(Call call) throws JSONException {
+
+        JSONObject callInfo = new JSONObject();
+
+        callInfo.put("Parent", build(InCallServiceImpl.getCallId(call)));
+
+        // TODO:Make a function out of this for consistency
+        ArrayList<String> children = new ArrayList<String>();
+        for (Call child : call.getChildren()) {
+            children.add(InCallServiceImpl.getCallId(child));
+        }
+        callInfo.put("Children", build(children));
+
+        // TODO:Make a function out of this for consistency
+        ArrayList<String> conferenceables = new ArrayList<String>();
+        for (Call conferenceable : call.getChildren()) {
+            children.add(InCallServiceImpl.getCallId(conferenceable));
+        }
+        callInfo.put("ConferenceableCalls", build(conferenceables));
+
+        callInfo.put("State", build(InCallServiceImpl.getCallStateString(call.getState())));
+        callInfo.put("CannedTextResponses", build(call.getCannedTextResponses()));
+        callInfo.put("VideoCall", InCallServiceImpl.getVideoCallId(call.getVideoCall()));
+        callInfo.put("Details", build(call.getDetails()));
+
+        return callInfo;
+    }
+
+    private static JSONObject buildVideoProfile(VideoProfile videoProfile) throws JSONException {
+        JSONObject profile = new JSONObject();
+
+        profile.put("VideoState",
+                InCallServiceImpl.getVideoCallStateString(videoProfile.getVideoState()));
+        profile.put("VideoQuality",
+                InCallServiceImpl.getVideoCallQualityString(videoProfile.getQuality()));
+
+        return profile;
+    }
+
+    private static JSONObject buildCameraCapabilities(CameraCapabilities cameraCapabilities)
+            throws JSONException {
+        JSONObject capabilities = new JSONObject();
+
+        capabilities.put("Height", build(cameraCapabilities.getHeight()));
+        capabilities.put("Width", build(cameraCapabilities.getWidth()));
+        capabilities.put("ZoomSupported", build(cameraCapabilities.isZoomSupported()));
+        capabilities.put("MaxZoom", build(cameraCapabilities.getMaxZoom()));
+
+        return capabilities;
+    }
+
+    private static JSONObject buildVoLteServiceStateEvent(
+        VoLteServiceState volteInfo)
+            throws JSONException {
+        JSONObject info = new JSONObject();
+        info.put(TelephonyConstants.VoLteServiceStateContainer.SRVCC_STATE,
+            TelephonyUtils.getSrvccStateString(volteInfo.getSrvccState()));
+        return info;
+    }
+
+    private static JSONObject buildModemActivityInfo(ModemActivityInfo modemInfo)
+            throws JSONException {
+        JSONObject info = new JSONObject();
+
+        info.put("Timestamp", modemInfo.getTimestamp());
+        info.put("SleepTimeMs", modemInfo.getSleepTimeMillis());
+        info.put("IdleTimeMs", modemInfo.getIdleTimeMillis());
+        //convert from int[] to List<Integer> for proper JSON translation
+        int[] txTimes = modemInfo.getTxTimeMillis();
+        List<Integer> tmp = new ArrayList<Integer>(txTimes.length);
+        for(int val : txTimes) {
+            tmp.add(val);
+        }
+        info.put("TxTimeMs", build(tmp));
+        info.put("RxTimeMs", modemInfo.getRxTimeMillis());
+        info.put("EnergyUsedMw", modemInfo.getEnergyUsed());
+        return info;
+    }
+    private static JSONObject buildSignalStrength(SignalStrength signalStrength)
+            throws JSONException {
+        JSONObject info = new JSONObject();
+        info.put(TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_GSM,
+            signalStrength.getGsmSignalStrength());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_GSM_DBM,
+            signalStrength.getGsmDbm());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_GSM_LEVEL,
+            signalStrength.getGsmLevel());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_GSM_ASU_LEVEL,
+            signalStrength.getGsmAsuLevel());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_GSM_BIT_ERROR_RATE,
+            signalStrength.getGsmBitErrorRate());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_CDMA_DBM,
+            signalStrength.getCdmaDbm());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_CDMA_LEVEL,
+            signalStrength.getCdmaLevel());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_CDMA_ASU_LEVEL,
+            signalStrength.getCdmaAsuLevel());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_CDMA_ECIO,
+            signalStrength.getCdmaEcio());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_EVDO_DBM,
+            signalStrength.getEvdoDbm());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_EVDO_ECIO,
+            signalStrength.getEvdoEcio());
+        info.put(TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_LTE,
+            signalStrength.getLteSignalStrength());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_LTE_DBM,
+            signalStrength.getLteDbm());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_LTE_LEVEL,
+            signalStrength.getLteLevel());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_LTE_ASU_LEVEL,
+            signalStrength.getLteAsuLevel());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_LEVEL,
+            signalStrength.getLevel());
+        info.put(
+            TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_ASU_LEVEL,
+            signalStrength.getAsuLevel());
+        info.put(TelephonyConstants.SignalStrengthContainer.SIGNAL_STRENGTH_DBM,
+            signalStrength.getDbm());
+        return info;
+    }
+
+    private JsonBuilder() {
+        // This is a utility class.
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/JsonDeserializable.java b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonDeserializable.java
new file mode 100644
index 0000000..a577fdc
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonDeserializable.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public interface JsonDeserializable {
+    public JSONObject fromJSON() throws JSONException;
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/JsonRpcResult.java b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonRpcResult.java
new file mode 100644
index 0000000..b9f3d67
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonRpcResult.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Represents a JSON RPC result.
+ *
+ * @see http://json-rpc.org/wiki/specification
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class JsonRpcResult {
+
+  private JsonRpcResult() {
+    // Utility class.
+  }
+
+  public static JSONObject empty(int id) throws JSONException {
+    JSONObject json = new JSONObject();
+    json.put("id", id);
+    json.put("result", JSONObject.NULL);
+    json.put("error", JSONObject.NULL);
+    return json;
+  }
+
+  public static JSONObject result(int id, Object data) throws JSONException {
+    JSONObject json = new JSONObject();
+    json.put("id", id);
+    json.put("result", JsonBuilder.build(data));
+    json.put("error", JSONObject.NULL);
+    return json;
+  }
+
+  public static JSONObject error(int id, Throwable t) throws JSONException {
+    JSONObject json = new JSONObject();
+    json.put("id", id);
+    json.put("result", JSONObject.NULL);
+    json.put("error", t.toString());
+    return json;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/JsonRpcServer.java b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonRpcServer.java
new file mode 100644
index 0000000..5bdd99a
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonRpcServer.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.SimpleServer;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.rpc.RpcError;
+
+/**
+ * A JSON RPC server that forwards RPC calls to a specified receiver object.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class JsonRpcServer extends SimpleServer {
+
+    private static final String CMD_CLOSE_SESSION = "closeSl4aSession";
+
+    private final RpcReceiverManagerFactory mRpcReceiverManagerFactory;
+
+    // private final String mHandshake;
+
+    /**
+     * Construct a {@link JsonRpcServer} connected to the provided {@link RpcReceiverManager}.
+     *
+     * @param managerFactory the {@link RpcReceiverManager} to register with the server
+     * @param handshake the secret handshake required for authorization to use this server
+     */
+    public JsonRpcServer(RpcReceiverManagerFactory managerFactory, String handshake) {
+        // mHandshake = handshake;
+        mRpcReceiverManagerFactory = managerFactory;
+    }
+
+    @Override
+    public void shutdown() {
+        super.shutdown();
+        // Notify all RPC receiving objects. They may have to clean up some of their state.
+        for (RpcReceiverManager manager : mRpcReceiverManagerFactory.getRpcReceiverManagers()
+                .values()) {
+            manager.shutdown();
+        }
+    }
+
+    @Override
+    protected void handleRPCConnection(Socket sock, Integer UID, BufferedReader reader,
+            PrintWriter writer) throws Exception {
+        RpcReceiverManager receiverManager = null;
+        Map<Integer, RpcReceiverManager> mgrs = mRpcReceiverManagerFactory.getRpcReceiverManagers();
+        synchronized (mgrs) {
+            Log.d("UID " + UID);
+            Log.d("manager map keys: "
+                    + mRpcReceiverManagerFactory.getRpcReceiverManagers().keySet());
+            if (mgrs.containsKey(UID)) {
+                Log.d("Look up existing session");
+                receiverManager = mgrs.get(UID);
+            } else {
+                Log.d("Create a new session");
+                receiverManager = mRpcReceiverManagerFactory.create(UID);
+            }
+        }
+        // boolean passedAuthentication = false;
+        String data;
+        while ((data = reader.readLine()) != null) {
+            Log.v("Session " + UID + " Received: " + data);
+            JSONObject request = new JSONObject(data);
+            int id = request.getInt("id");
+            String method = request.getString("method");
+            JSONArray params = request.getJSONArray("params");
+
+            MethodDescriptor rpc = receiverManager.getMethodDescriptor(method);
+            if (rpc == null) {
+                send(writer, JsonRpcResult.error(id, new RpcError("Unknown RPC: " + method)), UID);
+                continue;
+            }
+            try {
+                send(writer, JsonRpcResult.result(id, rpc.invoke(receiverManager, params)), UID);
+            } catch (Throwable t) {
+                Log.e("Invocation error.", t);
+                send(writer, JsonRpcResult.error(id, t), UID);
+            }
+            if (method.equals(CMD_CLOSE_SESSION)) {
+                Log.d("Got shutdown signal");
+                synchronized (writer) {
+                    receiverManager.shutdown();
+                    reader.close();
+                    writer.close();
+                    sock.close();
+                    shutdown();
+                    mgrs.remove(UID);
+                }
+                return;
+            }
+        }
+    }
+
+    private void send(PrintWriter writer, JSONObject result, int UID) {
+        writer.write(result + "\n");
+        writer.flush();
+        Log.v("Session " + UID + " Sent: " + result);
+    }
+
+    @Override
+    protected void handleConnection(Socket socket) throws Exception {
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/JsonSerializable.java b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonSerializable.java
new file mode 100644
index 0000000..5f05d40
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/JsonSerializable.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public interface JsonSerializable {
+    public JSONObject toJSON() throws JSONException;
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiver.java b/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiver.java
new file mode 100644
index 0000000..e885422
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiver.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+public abstract class RpcReceiver {
+
+  protected final RpcReceiverManager mManager;
+
+  public RpcReceiver(RpcReceiverManager manager) {
+    // To make reflection easier, we ensures that all the subclasses agree on this common
+    // constructor.
+    mManager = manager;
+  }
+
+  /** Invoked when the receiver is shut down. */
+  public abstract void shutdown();
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiverManager.java b/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiverManager.java
new file mode 100644
index 0000000..3f6b105
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiverManager.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+
+public abstract class RpcReceiverManager {
+
+    private final Map<Class<? extends RpcReceiver>, RpcReceiver> mReceivers;
+
+    /**
+     * A map of strings to known RPCs.
+     */
+    private final Map<String, MethodDescriptor> mKnownRpcs = new HashMap<String, MethodDescriptor>();
+
+    public RpcReceiverManager(Collection<Class<? extends RpcReceiver>> classList) {
+        mReceivers = new HashMap<Class<? extends RpcReceiver>, RpcReceiver>();
+        for (Class<? extends RpcReceiver> receiverClass : classList) {
+            mReceivers.put(receiverClass, null);
+            Collection<MethodDescriptor> methodList = MethodDescriptor.collectFrom(receiverClass);
+            for (MethodDescriptor m : methodList) {
+                if (mKnownRpcs.containsKey(m.getName())) {
+                    // We already know an RPC of the same name. We don't catch this anywhere because
+                    // this is a programming error.
+                    throw new RuntimeException("An RPC with the name " + m.getName()
+                            + " is already known.");
+                }
+                mKnownRpcs.put(m.getName(), m);
+            }
+        }
+    }
+
+    public Collection<Class<? extends RpcReceiver>> getRpcReceiverClasses() {
+        return mReceivers.keySet();
+    }
+
+    private RpcReceiver get(Class<? extends RpcReceiver> clazz) {
+        RpcReceiver object = mReceivers.get(clazz);
+        if (object != null) {
+            return object;
+        }
+
+        Constructor<? extends RpcReceiver> constructor;
+        try {
+            constructor = clazz.getConstructor(FacadeManager.class);
+            object = constructor.newInstance(this);
+            mReceivers.put(clazz, object);
+        } catch (Exception e) {
+            Log.e(e);
+        }
+
+        return object;
+    }
+
+    public <T extends RpcReceiver> T getReceiver(Class<T> clazz) {
+        RpcReceiver receiver = get(clazz);
+        return clazz.cast(receiver);
+    }
+
+    public MethodDescriptor getMethodDescriptor(String methodName) {
+        return mKnownRpcs.get(methodName);
+    }
+
+    public Object invoke(Class<? extends RpcReceiver> clazz, Method method, Object[] args)
+            throws Exception {
+        RpcReceiver object = get(clazz);
+        return method.invoke(object, args);
+    }
+
+    public void shutdown() {
+        for (RpcReceiver receiver : mReceivers.values()) {
+            try {
+                if (receiver != null) {
+                    receiver.shutdown();
+                }
+            } catch (Exception e) {
+                Log.e("Failed to shut down an RpcReceiver", e);
+            }
+        }
+    }
+}
diff --git a/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiverManagerFactory.java b/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiverManagerFactory.java
new file mode 100644
index 0000000..defec5f
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/jsonrpc/RpcReceiverManagerFactory.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.jsonrpc;
+
+import java.util.Map;
+
+public interface RpcReceiverManagerFactory {
+  public RpcReceiverManager create(Integer UID);
+
+  public Map<Integer, RpcReceiverManager> getRpcReceiverManagers();
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/BeanShellLanguage.java b/Common/src/com/googlecode/android_scripting/language/BeanShellLanguage.java
new file mode 100644
index 0000000..b92d502
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/BeanShellLanguage.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+import com.googlecode.android_scripting.rpc.ParameterDescriptor;
+
+/**
+ * Represents the BeanShell programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class BeanShellLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    // FIXME(igor.v.karp): this is interpreter specific
+    return "source(\"/sdcard/com.googlecode.bshforandroid/extras/bsh/android.bsh\");\n";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return rpcReceiver + " = Android();\n";
+  }
+
+  @Override
+  protected String getMethodCallText(String receiver, String method,
+      ParameterDescriptor[] parameters) {
+    StringBuilder result =
+        new StringBuilder().append(getApplyReceiverText(receiver)).append(getApplyOperatorText())
+            .append(method);
+    if (parameters.length > 0) {
+      result.append(getLeftParametersText());
+    } else {
+      result.append(getQuote());
+    }
+    String separator = "";
+    for (ParameterDescriptor parameter : parameters) {
+      result.append(separator).append(getValueText(parameter));
+      separator = getParameterSeparator();
+    }
+    result.append(getRightParametersText());
+
+    return result.toString();
+  }
+
+  @Override
+  protected String getApplyOperatorText() {
+    return ".call(\"";
+  }
+
+  @Override
+  protected String getLeftParametersText() {
+    return "\", ";
+  }
+
+  @Override
+  protected String getRightParametersText() {
+    return ")";
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/HtmlLanguage.java b/Common/src/com/googlecode/android_scripting/language/HtmlLanguage.java
new file mode 100644
index 0000000..e7abf33
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/HtmlLanguage.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+import com.googlecode.android_scripting.rpc.ParameterDescriptor;
+
+public class HtmlLanguage extends Language {
+
+  /** Returns the Android package import statement. */
+  @Override
+  protected String getImportStatement() {
+    return "<html>\n<head>\n<script>";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return String.format("var %s = new Android();\n</script>\n</head>\n<body>\n\n</body>\n</html>",
+        rpcReceiver);
+  }
+
+  @Override
+  protected String getMethodCallText(String receiver, String method,
+      ParameterDescriptor[] parameters) {
+    StringBuilder result =
+        new StringBuilder().append(getApplyReceiverText(receiver)).append(getApplyOperatorText())
+            .append(method);
+    if (parameters.length > 0) {
+      result.append(getLeftParametersText());
+    } else {
+      result.append(getQuote());
+    }
+    String separator = "";
+    for (ParameterDescriptor parameter : parameters) {
+      result.append(separator).append(getValueText(parameter));
+      separator = getParameterSeparator();
+    }
+    result.append(getRightParametersText());
+
+    return result.toString();
+  }
+
+  @Override
+  protected String getApplyOperatorText() {
+    return ".call('";
+  }
+
+  @Override
+  protected String getLeftParametersText() {
+    return "', ";
+  }
+
+  @Override
+  protected String getRightParametersText() {
+    return ")";
+  }
+
+  @Override
+  protected String getQuote() {
+    return "'";
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/JavaScriptLanguage.java b/Common/src/com/googlecode/android_scripting/language/JavaScriptLanguage.java
new file mode 100644
index 0000000..7e88d3c
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/JavaScriptLanguage.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the JavaScript programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class JavaScriptLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    // FIXME(igor.v.karp): this is interpreter specific
+    return "load(\"/sdcard/com.googlecode.rhinoforandroid/extras/rhino/android.js\");\n";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return "var " + rpcReceiver + " = Android();\n";
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/Language.java b/Common/src/com/googlecode/android_scripting/language/Language.java
new file mode 100644
index 0000000..0a8d487
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/Language.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.rpc.ParameterDescriptor;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Represents the programming language supported by the SL4A.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class Language {
+
+  private final static Map<Character, String> AUTO_CLOSE_MAP = buildAutoCloseMap('[', "[]", '{',
+      "{}", '(', "()", '\'', "''", '"', "\"\"");
+
+  /** Returns the initial template for newly created script. */
+  public String getContentTemplate() {
+    StringBuilder content = new StringBuilder(getImportStatement());
+    if (content.length() != 0) {
+      content.append('\n');
+    }
+    content.append(getRpcReceiverDeclaration(getDefaultRpcReceiver()));
+    return content.toString();
+  }
+
+  /** Returns the Android package import statement. */
+  protected String getImportStatement() {
+    return "";
+  }
+
+  /** Returns the RPC receiver declaration. */
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return "";
+  }
+
+  /** Returns the default RPC receiver name. */
+  protected String getDefaultRpcReceiver() {
+    return "droid";
+  }
+
+  /**
+   * Returns the string containing opening and closing tokens if the input is an opening token.
+   * Returns {@code null} otherwise.
+   */
+  public String autoClose(char token) {
+    return AUTO_CLOSE_MAP.get(token);
+  }
+
+  /** Returns the RPC call text with given parameter values. */
+  public final String getRpcText(String content, MethodDescriptor rpc, String[] values) {
+    return getMethodCallText(getRpcReceiverName(content), rpc.getName(),
+        rpc.getParameterValues(values));
+  }
+
+  /** Returns the RPC receiver found in the given script. */
+  protected String getRpcReceiverName(String content) {
+    return getDefaultRpcReceiver();
+  }
+
+  /** Returns the method call text in the language. */
+  protected String getMethodCallText(String receiver, String method,
+      ParameterDescriptor[] parameters) {
+    StringBuilder result =
+        new StringBuilder().append(getApplyReceiverText(receiver)).append(getApplyOperatorText())
+            .append(method).append(getLeftParametersText());
+    String separator = "";
+    for (ParameterDescriptor parameter : parameters) {
+      result.append(separator).append(getValueText(parameter));
+      separator = getParameterSeparator();
+    }
+    result.append(getRightParametersText());
+
+    return result.toString();
+  }
+
+  /** Returns the apply receiver text. */
+  protected String getApplyReceiverText(String receiver) {
+    return receiver;
+  }
+
+  /** Returns the apply operator text. */
+  protected String getApplyOperatorText() {
+    return ".";
+  }
+
+  /** Returns the text to the left of the parameters. */
+  protected String getLeftParametersText() {
+    return "(";
+  }
+
+  /** Returns the text to the right of the parameters. */
+  protected String getRightParametersText() {
+    return ")";
+  }
+
+  /** Returns the parameter separator text. */
+  protected String getParameterSeparator() {
+    return ", ";
+  }
+
+  /** Returns the text of the quotation. */
+  protected String getQuote() {
+    return "\"";
+  }
+
+  /** Returns the text of the {@code null} value. */
+  protected String getNull() {
+    return "null";
+  }
+
+  /** Returns the text of the {{@code true} value. */
+  protected String getTrue() {
+    return "true";
+  }
+
+  /** Returns the text of the false value. */
+  protected String getFalse() {
+    return "false";
+  }
+
+  /** Returns the parameter value suitable for code generation. */
+  protected String getValueText(ParameterDescriptor parameter) {
+    if (parameter.getValue() == null) {
+      return getNullValueText();
+    } else if (parameter.getType().equals(String.class)) {
+      return getStringValueText(parameter.getValue());
+    } else if (parameter.getType().equals(Boolean.class)) {
+      return getBooleanValueText(parameter.getValue());
+    } else {
+      return parameter.getValue();
+    }
+  }
+
+  /** Returns the null value suitable for code generation. */
+  private String getNullValueText() {
+    return getNull();
+  }
+
+  /** Returns the string parameter value suitable for code generation. */
+  protected String getStringValueText(String value) {
+    // TODO(igorkarp): do not quote expressions once they could be detected.
+    return getQuote() + value + getQuote();
+  }
+
+  /** Returns the boolean parameter value suitable for code generation. */
+  protected String getBooleanValueText(String value) {
+    if (value.equals(Boolean.TRUE.toString())) {
+      return getTrue();
+    } else if (value.equals(Boolean.FALSE.toString())) {
+      return getFalse();
+    } else {
+      // If it is neither true nor false it is must be an expression.
+      return value;
+    }
+  }
+
+  private static Map<Character, String> buildAutoCloseMap(char c1, String s1, char c2, String s2,
+      char c3, String s3, char c4, String s4, char c5, String s5) {
+    Map<Character, String> map = new HashMap<Character, String>(5);
+    map.put(c1, s1);
+    map.put(c2, s2);
+    map.put(c3, s3);
+    map.put(c4, s4);
+    map.put(c5, s5);
+    return map;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/LuaLanguage.java b/Common/src/com/googlecode/android_scripting/language/LuaLanguage.java
new file mode 100644
index 0000000..a279434
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/LuaLanguage.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Lua programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class LuaLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    return "require \"android\"\n";
+  }
+
+  @Override
+  protected String getDefaultRpcReceiver() {
+    return "android";
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/PerlLanguage.java b/Common/src/com/googlecode/android_scripting/language/PerlLanguage.java
new file mode 100644
index 0000000..c5cca0b
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/PerlLanguage.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Perl programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class PerlLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    return "use Android;\n";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return "my " + rpcReceiver + " = Android->new();\n";
+  }
+
+  @Override
+  protected String getDefaultRpcReceiver() {
+    return "$droid";
+  }
+
+  @Override
+  protected String getApplyOperatorText() {
+    return "->";
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/PhpLanguage.java b/Common/src/com/googlecode/android_scripting/language/PhpLanguage.java
new file mode 100644
index 0000000..a141a3c
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/PhpLanguage.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the PHP programming language.
+ *
+ * @author ivan@irontec.com (Ivan Mosquera Paulo)
+ */
+public class PhpLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    return "<?php\n\nrequire_once(\"Android.php\");";
+
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return rpcReceiver + " = new Android();\n";
+  }
+
+  @Override
+  protected String getDefaultRpcReceiver() {
+    return "$droid";
+  }
+
+  @Override
+  protected String getApplyOperatorText() {
+    return "->";
+  }
+
+  @Override
+  protected String getQuote() {
+    return "'";
+  }
+
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/language/PythonLanguage.java b/Common/src/com/googlecode/android_scripting/language/PythonLanguage.java
new file mode 100644
index 0000000..beb59ae
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/PythonLanguage.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Python programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class PythonLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    return "import android\n";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return rpcReceiver + " = android.Android()\n";
+  }
+
+  @Override
+  protected String getQuote() {
+    return "'";
+  }
+
+  @Override
+  protected String getNull() {
+    return "None";
+  }
+
+  @Override
+  protected String getTrue() {
+    return "True";
+  }
+
+  @Override
+  protected String getFalse() {
+    return "False";
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/RubyLanguage.java b/Common/src/com/googlecode/android_scripting/language/RubyLanguage.java
new file mode 100644
index 0000000..d6cd189
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/RubyLanguage.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Ruby programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class RubyLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    return "require \"android\";\n";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return rpcReceiver + " = Droid.new\n";
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/ShellLanguage.java b/Common/src/com/googlecode/android_scripting/language/ShellLanguage.java
new file mode 100644
index 0000000..d7bc5a2
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/ShellLanguage.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Shell programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class ShellLanguage extends Language {
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/SleepLanguage.java b/Common/src/com/googlecode/android_scripting/language/SleepLanguage.java
new file mode 100644
index 0000000..1b623ab
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/SleepLanguage.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Sleep programming language.
+ *
+ * @author tomcatalbino@gmail.com
+ */
+public class SleepLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    return "import com.googlecode.rpc.*;\n";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return rpcReceiver + " = [new Android];\n";
+  }
+
+  @Override
+  protected String getDefaultRpcReceiver() {
+    return "$droid";
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/SquirrelLanguage.java b/Common/src/com/googlecode/android_scripting/language/SquirrelLanguage.java
new file mode 100644
index 0000000..f9b25bf
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/SquirrelLanguage.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Squirrel programming language, by Alberto Demichelis
+ * this file adapted by Andy Tai, atai@atai.org
+ * based on the Python version by
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class SquirrelLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    /* initialization code */
+    return "";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return rpcReceiver + " <- Android();\n";
+  }
+
+  @Override
+  protected String getQuote() {
+    return "\"";
+  }
+
+  @Override
+  protected String getNull() {
+    return "null";
+  }
+
+  @Override
+  protected String getTrue() {
+    return "true";
+  }
+
+  @Override
+  protected String getFalse() {
+    return "false";
+  }
+}
+
diff --git a/Common/src/com/googlecode/android_scripting/language/SupportedLanguages.java b/Common/src/com/googlecode/android_scripting/language/SupportedLanguages.java
new file mode 100644
index 0000000..e496378
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/SupportedLanguages.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+import com.googlecode.android_scripting.Log;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SupportedLanguages {
+
+  private static enum KnownLanguage {
+    // SHELL(".sh", ShellLanguage.class), // We don't really support Shell language
+    HTML(".html", HtmlLanguage.class), BEANSHELL(".bsh", BeanShellLanguage.class), JAVASCRIPT(
+        ".js", JavaScriptLanguage.class), LUA(".lua", LuaLanguage.class), PERL(".pl",
+        PerlLanguage.class), PYTHON(".py", PythonLanguage.class), RUBY(".rb", RubyLanguage.class),
+    TCL(".tcl", TclLanguage.class), PHP(".php", PhpLanguage.class), SLEEP(".sl",
+        SleepLanguage.class), SQUIRREL(".nut", SquirrelLanguage.class);
+
+    private final String mmExtension;
+    private final Class<? extends Language> mmClass;
+
+    private KnownLanguage(String ext, Class<? extends Language> clazz) {
+      mmExtension = ext;
+      mmClass = clazz;
+    }
+
+    private String getExtension() {
+      return mmExtension;
+    }
+
+    private Class<? extends Language> getLanguageClass() {
+      return mmClass;
+    }
+  }
+
+  private static Map<String, Class<? extends Language>> sSupportedLanguages;
+
+  static {
+    sSupportedLanguages = new HashMap<String, Class<? extends Language>>();
+    for (KnownLanguage language : KnownLanguage.values()) {
+      sSupportedLanguages.put(language.getExtension(), language.getLanguageClass());
+    }
+  }
+
+  public static Language getLanguageByExtension(String extension) {
+    extension = extension.toLowerCase();
+    if (!extension.startsWith(".")) {
+      throw new RuntimeException("Extension does not start with a dot: " + extension);
+    }
+    Language lang = null;
+
+    Class<? extends Language> clazz = sSupportedLanguages.get(extension);
+    if (clazz == null) {
+      clazz = Language.class; // revert to default language.
+    }
+    if (clazz != null) {
+      try {
+        lang = clazz.newInstance();
+      } catch (IllegalAccessException e) {
+        Log.e(e);
+      } catch (InstantiationException e) {
+        Log.e(e);
+      }
+    }
+    return lang;
+  }
+
+  public static boolean checkLanguageSupported(String name) {
+    String extension = name.toLowerCase();
+    int index = extension.lastIndexOf('.');
+    if (index < 0) {
+      extension = "." + extension;
+    } else if (index > 0) {
+      extension = extension.substring(index);
+    }
+    return sSupportedLanguages.containsKey(extension);
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/language/TclLanguage.java b/Common/src/com/googlecode/android_scripting/language/TclLanguage.java
new file mode 100644
index 0000000..52b8532
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/language/TclLanguage.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.language;
+
+/**
+ * Represents the Tcl programming language.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class TclLanguage extends Language {
+
+  @Override
+  protected String getImportStatement() {
+    return "package require android\n";
+  }
+
+  @Override
+  protected String getRpcReceiverDeclaration(String rpcReceiver) {
+    return "set " + rpcReceiver + " [android new]\n";
+  }
+
+  @Override
+  protected String getApplyReceiverText(String receiver) {
+    return "$" + receiver;
+  }
+
+  @Override
+  protected String getApplyOperatorText() {
+    return " ";
+  }
+
+  @Override
+  protected String getLeftParametersText() {
+    return " ";
+  }
+
+  @Override
+  protected String getRightParametersText() {
+    return "";
+  }
+
+  @Override
+  protected String getParameterSeparator() {
+    return " ";
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/Converter.java b/Common/src/com/googlecode/android_scripting/rpc/Converter.java
new file mode 100644
index 0000000..274d838
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/Converter.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+/**
+ * A converter can take a String and turn it into an instance of type T (the type parameter to the
+ * converter).
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public interface Converter<T> {
+
+  /** Convert a string into type T. */
+  T convert(String value);
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/MethodDescriptor.java b/Common/src/com/googlecode/android_scripting/rpc/MethodDescriptor.java
new file mode 100644
index 0000000..5c31c34
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/MethodDescriptor.java
@@ -0,0 +1,593 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Parcelable;
+
+import com.googlecode.android_scripting.facade.AndroidFacade;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
+import com.googlecode.android_scripting.util.VisibleForTesting;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * An adapter that wraps {@code Method}.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public final class MethodDescriptor {
+  private static final Map<Class<?>, Converter<?>> sConverters = populateConverters();
+
+  private final Method mMethod;
+  private final Class<? extends RpcReceiver> mClass;
+
+  public MethodDescriptor(Class<? extends RpcReceiver> clazz, Method method) {
+    mClass = clazz;
+    mMethod = method;
+  }
+
+  @Override
+  public String toString() {
+    return mMethod.getDeclaringClass().getCanonicalName() + "." + mMethod.getName();
+  }
+
+  /** Collects all methods with {@code RPC} annotation from given class. */
+  public static Collection<MethodDescriptor> collectFrom(Class<? extends RpcReceiver> clazz) {
+    List<MethodDescriptor> descriptors = new ArrayList<MethodDescriptor>();
+    for (Method method : clazz.getMethods()) {
+      if (method.isAnnotationPresent(Rpc.class)) {
+        descriptors.add(new MethodDescriptor(clazz, method));
+      }
+    }
+    return descriptors;
+  }
+
+  /**
+   * Invokes the call that belongs to this object with the given parameters. Wraps the response
+   * (possibly an exception) in a JSONObject.
+   *
+   * @param parameters
+   *          {@code JSONArray} containing the parameters
+   * @return result
+   * @throws Throwable
+   */
+  public Object invoke(RpcReceiverManager manager, final JSONArray parameters) throws Throwable {
+
+    final Type[] parameterTypes = getGenericParameterTypes();
+    final Object[] args = new Object[parameterTypes.length];
+    final Annotation annotations[][] = getParameterAnnotations();
+
+    if (parameters.length() > args.length) {
+      throw new RpcError("Too many parameters specified.");
+    }
+
+    for (int i = 0; i < args.length; i++) {
+      final Type parameterType = parameterTypes[i];
+      if (i < parameters.length()) {
+        args[i] = convertParameter(parameters, i, parameterType);
+      } else if (MethodDescriptor.hasDefaultValue(annotations[i])) {
+        args[i] = MethodDescriptor.getDefaultValue(parameterType, annotations[i]);
+      } else {
+        throw new RpcError("Argument " + (i + 1) + " is not present");
+      }
+    }
+
+    return invoke(manager, args);
+  }
+
+  /**
+   * Invokes the call that belongs to this object with the given parameters. Wraps the response
+   * (possibly an exception) in a JSONObject.
+   *
+   * @param parameters {@code Bundle} containing the parameters
+   * @return result
+   * @throws Throwable
+   */
+  public Object invoke(RpcReceiverManager manager, final Bundle parameters) throws Throwable {
+    final Annotation annotations[][] = getParameterAnnotations();
+    final Class<?>[] parameterTypes = getMethod().getParameterTypes();
+    final Object[] args = new Object[parameterTypes.length];
+
+    for (int i = 0; i < parameterTypes.length; i++) {
+      Class<?> parameterType = parameterTypes[i];
+      String parameterName = getName(annotations[i]);
+      if (i < parameterTypes.length) {
+        args[i] = convertParameter(parameters, parameterType, parameterName);
+      } else if (MethodDescriptor.hasDefaultValue(annotations[i])) {
+        args[i] = MethodDescriptor.getDefaultValue(parameterType, annotations[i]);
+      } else {
+        throw new RpcError("Argument " + (i + 1) + " is not present");
+      }
+    }
+    return invoke(manager, args);
+  }
+
+  private Object invoke(RpcReceiverManager manager, Object[] args) throws Throwable{
+    Object result = null;
+    try {
+      result = manager.invoke(mClass, mMethod, args);
+    } catch (Throwable t) {
+      throw t.getCause();
+    }
+    return result;
+  }
+
+  /**
+   * Converts a parameter from JSON into a Java Object.
+   *
+   * @return TODO
+   */
+  // TODO(damonkohler): This signature is a bit weird (auto-refactored). The obvious alternative
+  // would be to work on one supplied parameter and return the converted parameter. However, that's
+  // problematic because you lose the ability to call the getXXX methods on the JSON array.
+  @VisibleForTesting
+  static Object convertParameter(final JSONArray parameters, int index, Type type)
+      throws JSONException, RpcError {
+    try {
+      // Log.d("sl4a", parameters.toString());
+      // Log.d("sl4a", type.toString());
+      // We must handle null and numbers explicitly because we cannot magically cast them. We
+      // also need to convert implicitly from numbers to bools.
+      if (parameters.isNull(index)) {
+        return null;
+      } else if (type == Boolean.class) {
+        try {
+          return parameters.getBoolean(index);
+        } catch (JSONException e) {
+          return new Boolean(parameters.getInt(index) != 0);
+        }
+      } else if (type == Long.class) {
+        return parameters.getLong(index);
+      } else if (type == Double.class) {
+        return parameters.getDouble(index);
+      } else if (type == Integer.class) {
+        return parameters.getInt(index);
+      } else if (type == Intent.class) {
+        return buildIntent(parameters.getJSONObject(index));
+      } else if (type == Integer[].class) {
+        JSONArray list = parameters.getJSONArray(index);
+        Integer[] result = new Integer[list.length()];
+        for (int i = 0; i < list.length(); i++) {
+          result[i] = list.getInt(i);
+        }
+        return result;
+      } else if (type == String[].class) {
+        JSONArray list = parameters.getJSONArray(index);
+        String[] result = new String[list.length()];
+        for (int i = 0; i < list.length(); i++) {
+          result[i] = list.getString(i);
+        }
+        return result;
+      } else if (type == JSONObject.class) {
+          return parameters.getJSONObject(index);
+      } else {
+        // Magically cast the parameter to the right Java type.
+        return ((Class<?>) type).cast(parameters.get(index));
+      }
+    } catch (ClassCastException e) {
+      throw new RpcError("Argument " + (index + 1) + " should be of type "
+          + ((Class<?>) type).getSimpleName() + ".");
+    }
+  }
+
+  private Object convertParameter(Bundle bundle, Class<?> type, String name) {
+    Object param = null;
+    if (type.isAssignableFrom(Boolean.class)) {
+      param = bundle.getBoolean(name, false);
+    }
+    if (type.isAssignableFrom(Boolean[].class)) {
+      param = bundle.getBooleanArray(name);
+    }
+    if (type.isAssignableFrom(String.class)) {
+      param = bundle.getString(name);
+    }
+    if (type.isAssignableFrom(String[].class)) {
+      param = bundle.getStringArray(name);
+    }
+    if (type.isAssignableFrom(Integer.class)) {
+      param = bundle.getInt(name, 0);
+    }
+    if (type.isAssignableFrom(Integer[].class)) {
+      param = bundle.getIntArray(name);
+    }
+    if (type.isAssignableFrom(Bundle.class)) {
+      param = bundle.getBundle(name);
+    }
+    if (type.isAssignableFrom(Parcelable.class)) {
+      param = bundle.getParcelable(name);
+    }
+    if (type.isAssignableFrom(Parcelable[].class)) {
+      param = bundle.getParcelableArray(name);
+    }
+    if (type.isAssignableFrom(Intent.class)) {
+      param = bundle.getParcelable(name);
+    }
+    return param;
+  }
+
+  public static Object buildIntent(JSONObject jsonObject) throws JSONException {
+    Intent intent = new Intent();
+    if (jsonObject.has("action")) {
+      intent.setAction(jsonObject.getString("action"));
+    }
+    if (jsonObject.has("data") && jsonObject.has("type")) {
+      intent.setDataAndType(Uri.parse(jsonObject.optString("data", null)),
+          jsonObject.optString("type", null));
+    } else if (jsonObject.has("data")) {
+      intent.setData(Uri.parse(jsonObject.optString("data", null)));
+    } else if (jsonObject.has("type")) {
+      intent.setType(jsonObject.optString("type", null));
+    }
+    if (jsonObject.has("packagename") && jsonObject.has("classname")) {
+      intent.setClassName(jsonObject.getString("packagename"), jsonObject.getString("classname"));
+    }
+    if (jsonObject.has("flags")) {
+      intent.setFlags(jsonObject.getInt("flags"));
+    }
+    if (!jsonObject.isNull("extras")) {
+      AndroidFacade.putExtrasFromJsonObject(jsonObject.getJSONObject("extras"), intent);
+    }
+    if (!jsonObject.isNull("categories")) {
+      JSONArray categories = jsonObject.getJSONArray("categories");
+      for (int i = 0; i < categories.length(); i++) {
+        intent.addCategory(categories.getString(i));
+      }
+    }
+    return intent;
+  }
+
+  public Method getMethod() {
+    return mMethod;
+  }
+
+  public Class<? extends RpcReceiver> getDeclaringClass() {
+    return mClass;
+  }
+
+  public String getName() {
+    if (mMethod.isAnnotationPresent(RpcName.class)) {
+      return mMethod.getAnnotation(RpcName.class).name();
+    }
+    return mMethod.getName();
+  }
+
+  public Type[] getGenericParameterTypes() {
+    return mMethod.getGenericParameterTypes();
+  }
+
+  public Annotation[][] getParameterAnnotations() {
+    return mMethod.getParameterAnnotations();
+  }
+
+  /**
+   * Returns a human-readable help text for this RPC, based on annotations in the source code.
+   *
+   * @return derived help string
+   */
+  public String getHelp() {
+    StringBuilder helpBuilder = new StringBuilder();
+    Rpc rpcAnnotation = mMethod.getAnnotation(Rpc.class);
+
+    helpBuilder.append(mMethod.getName());
+    helpBuilder.append("(");
+    final Class<?>[] parameterTypes = mMethod.getParameterTypes();
+    final Type[] genericParameterTypes = mMethod.getGenericParameterTypes();
+    final Annotation[][] annotations = mMethod.getParameterAnnotations();
+    for (int i = 0; i < parameterTypes.length; i++) {
+      if (i == 0) {
+        helpBuilder.append("\n  ");
+      } else {
+        helpBuilder.append(",\n  ");
+      }
+
+      helpBuilder.append(getHelpForParameter(genericParameterTypes[i], annotations[i]));
+    }
+    helpBuilder.append(")\n\n");
+    helpBuilder.append(rpcAnnotation.description());
+    if (!rpcAnnotation.returns().equals("")) {
+      helpBuilder.append("\n");
+      helpBuilder.append("\nReturns:\n  ");
+      helpBuilder.append(rpcAnnotation.returns());
+    }
+
+    if (mMethod.isAnnotationPresent(RpcStartEvent.class)) {
+      String eventName = mMethod.getAnnotation(RpcStartEvent.class).value();
+      helpBuilder.append(String.format("\n\nGenerates \"%s\" events.", eventName));
+    }
+
+    if (mMethod.isAnnotationPresent(RpcDeprecated.class)) {
+      String replacedBy = mMethod.getAnnotation(RpcDeprecated.class).value();
+      String release = mMethod.getAnnotation(RpcDeprecated.class).release();
+      helpBuilder.append(String.format("\n\nDeprecated in %s! Please use %s instead.", release,
+          replacedBy));
+    }
+
+    return helpBuilder.toString();
+  }
+
+  /**
+   * Returns the help string for one particular parameter. This respects optional parameters.
+   *
+   * @param parameterType
+   *          (generic) type of the parameter
+   * @param annotations
+   *          annotations of the parameter, may be null
+   * @return string describing the parameter based on source code annotations
+   */
+  private static String getHelpForParameter(Type parameterType, Annotation[] annotations) {
+    StringBuilder result = new StringBuilder();
+
+    appendTypeName(result, parameterType);
+    result.append(" ");
+    result.append(getName(annotations));
+    if (hasDefaultValue(annotations)) {
+      result.append("[optional");
+      if (hasExplicitDefaultValue(annotations)) {
+        result.append(", default " + getDefaultValue(parameterType, annotations));
+      }
+      result.append("]");
+    }
+
+    String description = getDescription(annotations);
+    if (description.length() > 0) {
+      result.append(": ");
+      result.append(description);
+    }
+
+    return result.toString();
+  }
+
+  /**
+   * Appends the name of the given type to the {@link StringBuilder}.
+   *
+   * @param builder
+   *          string builder to append to
+   * @param type
+   *          type whose name to append
+   */
+  private static void appendTypeName(final StringBuilder builder, final Type type) {
+    if (type instanceof Class<?>) {
+      builder.append(((Class<?>) type).getSimpleName());
+    } else {
+      ParameterizedType parametrizedType = (ParameterizedType) type;
+      builder.append(((Class<?>) parametrizedType.getRawType()).getSimpleName());
+      builder.append("<");
+
+      Type[] arguments = parametrizedType.getActualTypeArguments();
+      for (int i = 0; i < arguments.length; i++) {
+        if (i > 0) {
+          builder.append(", ");
+        }
+        appendTypeName(builder, arguments[i]);
+      }
+      builder.append(">");
+    }
+  }
+
+  /**
+   * Returns parameter descriptors suitable for the RPC call text representation.
+   *
+   * <p>
+   * Uses parameter value, default value or name, whatever is available first.
+   *
+   * @return an array of parameter descriptors
+   */
+  public ParameterDescriptor[] getParameterValues(String[] values) {
+    Type[] parameterTypes = mMethod.getGenericParameterTypes();
+    Annotation[][] parametersAnnotations = mMethod.getParameterAnnotations();
+    ParameterDescriptor[] parameters = new ParameterDescriptor[parametersAnnotations.length];
+    for (int index = 0; index < parameters.length; index++) {
+      String value;
+      if (index < values.length) {
+        value = values[index];
+      } else if (hasDefaultValue(parametersAnnotations[index])) {
+        Object defaultValue = getDefaultValue(parameterTypes[index], parametersAnnotations[index]);
+        if (defaultValue == null) {
+          value = null;
+        } else {
+          value = String.valueOf(defaultValue);
+        }
+      } else {
+        value = getName(parametersAnnotations[index]);
+      }
+      parameters[index] = new ParameterDescriptor(value, parameterTypes[index]);
+    }
+    return parameters;
+  }
+
+  /**
+   * Returns parameter hints.
+   *
+   * @return an array of parameter hints
+   */
+  public String[] getParameterHints() {
+    Annotation[][] parametersAnnotations = mMethod.getParameterAnnotations();
+    String[] hints = new String[parametersAnnotations.length];
+    for (int index = 0; index < hints.length; index++) {
+      String name = getName(parametersAnnotations[index]);
+      String description = getDescription(parametersAnnotations[index]);
+      String hint = "No paramenter description.";
+      if (!name.equals("") && !description.equals("")) {
+        hint = name + ": " + description;
+      } else if (!name.equals("")) {
+        hint = name;
+      } else if (!description.equals("")) {
+        hint = description;
+      }
+      hints[index] = hint;
+    }
+    return hints;
+  }
+
+  /**
+   * Extracts the formal parameter name from an annotation.
+   *
+   * @param annotations
+   *          the annotations of the parameter
+   * @return the formal name of the parameter
+   */
+  private static String getName(Annotation[] annotations) {
+    for (Annotation a : annotations) {
+      if (a instanceof RpcParameter) {
+        return ((RpcParameter) a).name();
+      }
+    }
+    throw new IllegalStateException("No parameter name");
+  }
+
+  /**
+   * Extracts the parameter description from its annotations.
+   *
+   * @param annotations
+   *          the annotations of the parameter
+   * @return the description of the parameter
+   */
+  private static String getDescription(Annotation[] annotations) {
+    for (Annotation a : annotations) {
+      if (a instanceof RpcParameter) {
+        return ((RpcParameter) a).description();
+      }
+    }
+    throw new IllegalStateException("No parameter description");
+  }
+
+  /**
+   * Returns the default value for a specific parameter.
+   *
+   * @param parameterType
+   *          parameterType
+   * @param annotations
+   *          annotations of the parameter
+   */
+  public static Object getDefaultValue(Type parameterType, Annotation[] annotations) {
+    for (Annotation a : annotations) {
+      if (a instanceof RpcDefault) {
+        RpcDefault defaultAnnotation = (RpcDefault) a;
+        Converter<?> converter = converterFor(parameterType, defaultAnnotation.converter());
+        return converter.convert(defaultAnnotation.value());
+      } else if (a instanceof RpcOptional) {
+        return null;
+      }
+    }
+    throw new IllegalStateException("No default value for " + parameterType);
+  }
+
+  @SuppressWarnings("rawtypes")
+  private static Converter<?> converterFor(Type parameterType,
+      Class<? extends Converter> converterClass) {
+    if (converterClass == Converter.class) {
+      Converter<?> converter = sConverters.get(parameterType);
+      if (converter == null) {
+        throw new IllegalArgumentException("No predefined converter found for " + parameterType);
+      }
+      return converter;
+    }
+    try {
+      Constructor<?> constructor = converterClass.getConstructor(new Class<?>[0]);
+      return (Converter<?>) constructor.newInstance(new Object[0]);
+    } catch (Exception e) {
+      throw new IllegalArgumentException("Cannot create converter from "
+          + converterClass.getCanonicalName());
+    }
+  }
+
+  /**
+   * Determines whether or not this parameter has default value.
+   *
+   * @param annotations
+   *          annotations of the parameter
+   */
+  public static boolean hasDefaultValue(Annotation[] annotations) {
+    for (Annotation a : annotations) {
+      if (a instanceof RpcDefault || a instanceof RpcOptional) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns whether the default value is specified for a specific parameter.
+   *
+   * @param annotations
+   *          annotations of the parameter
+   */
+  @VisibleForTesting
+  static boolean hasExplicitDefaultValue(Annotation[] annotations) {
+    for (Annotation a : annotations) {
+      if (a instanceof RpcDefault) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /** Returns the converters for {@code String}, {@code Integer} and {@code Boolean}. */
+  private static Map<Class<?>, Converter<?>> populateConverters() {
+    Map<Class<?>, Converter<?>> converters = new HashMap<Class<?>, Converter<?>>();
+    converters.put(String.class, new Converter<String>() {
+      @Override
+      public String convert(String value) {
+        return value;
+      }
+    });
+    converters.put(Integer.class, new Converter<Integer>() {
+      @Override
+      public Integer convert(String input) {
+        try {
+          return Integer.decode(input);
+        } catch (NumberFormatException e) {
+          throw new IllegalArgumentException("'" + input + "' is not an integer");
+        }
+      }
+    });
+    converters.put(Boolean.class, new Converter<Boolean>() {
+      @Override
+      public Boolean convert(String input) {
+        if (input == null) {
+          return null;
+        }
+        input = input.toLowerCase();
+        if (input.equals("true")) {
+          return Boolean.TRUE;
+        }
+        if (input.equals("false")) {
+          return Boolean.FALSE;
+        }
+        throw new IllegalArgumentException("'" + input + "' is not a boolean");
+      }
+    });
+    return converters;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/ParameterDescriptor.java b/Common/src/com/googlecode/android_scripting/rpc/ParameterDescriptor.java
new file mode 100644
index 0000000..021373c
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/ParameterDescriptor.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.reflect.Type;
+
+/**
+ * RPC parameter description.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public final class ParameterDescriptor {
+  private final String value;
+  private final Type type;
+
+  public ParameterDescriptor(String value, Type type) {
+    this.value = value;
+    this.type = type;
+  }
+
+  public String getValue() {
+    return value;
+  }
+
+  public Type getType() {
+    return type;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/Rpc.java b/Common/src/com/googlecode/android_scripting/rpc/Rpc.java
new file mode 100644
index 0000000..8fc932e
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/Rpc.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * The {@link Rpc} annotation is used to annotate server-side implementations of RPCs. It describes
+ * meta-information (currently a brief documentation of the function), and marks a function as the
+ * implementation of an RPC.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@Documented
+public @interface Rpc {
+  /**
+   * Returns brief description of the function. Should be limited to one or two sentences.
+   */
+  String description();
+
+  /**
+   * Gives a brief description of the functions return value (and the underlying data structure).
+   */
+  String returns() default "";
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcDefault.java b/Common/src/com/googlecode/android_scripting/rpc/RpcDefault.java
new file mode 100644
index 0000000..b27bccc
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcDefault.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Use this annotation to mark an RPC parameter that have a default value.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+@Documented
+public @interface RpcDefault {
+  /** The default value of the RPC parameter. */
+  public String value();
+
+  @SuppressWarnings("rawtypes")
+  public Class<? extends Converter> converter() default Converter.class;
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcDeprecated.java b/Common/src/com/googlecode/android_scripting/rpc/RpcDeprecated.java
new file mode 100644
index 0000000..c717e5d
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcDeprecated.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Use this annotation to mark RPC method as deprecated.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@Documented
+public @interface RpcDeprecated {
+  /** The method that replaced this one. */
+  public String value();
+
+  /** Release of SL4A when deprecation occurred. */
+  public String release() default "r4";
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcError.java b/Common/src/com/googlecode/android_scripting/rpc/RpcError.java
new file mode 100644
index 0000000..c4591c7
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcError.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+@SuppressWarnings("serial")
+public class RpcError extends Exception {
+
+  public RpcError(String message) {
+    super(message);
+  }
+
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcMinSdk.java b/Common/src/com/googlecode/android_scripting/rpc/RpcMinSdk.java
new file mode 100644
index 0000000..00b49ec
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcMinSdk.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Use this annotation to specify minimum SDK level (if higher than 3).
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface RpcMinSdk {
+  /** Minimum SDK Level. */
+  public int value();
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcName.java b/Common/src/com/googlecode/android_scripting/rpc/RpcName.java
new file mode 100644
index 0000000..b0992e6
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcName.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Use this annotation to mark an RPC parameter that have a default value.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@Documented
+public @interface RpcName {
+  /** The default value of the RPC parameter. */
+  public String name();
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcOptional.java b/Common/src/com/googlecode/android_scripting/rpc/RpcOptional.java
new file mode 100644
index 0000000..53ac650
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcOptional.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Use this annotation to mark RPC parameter as optional.
+ *
+ * <p>
+ * The parameter marked as optional has no explicit default value. {@code null} is used as default
+ * value.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+@Documented
+public @interface RpcOptional {
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcParameter.java b/Common/src/com/googlecode/android_scripting/rpc/RpcParameter.java
new file mode 100644
index 0000000..eb84879
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcParameter.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that is used to document the parameters of an RPC.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+@Documented
+public @interface RpcParameter {
+  /**
+   * The name of the formal parameter. This should be in agreement with the java code.
+   */
+  public String name();
+
+  /**
+   * Description of the RPC. This should be a short descriptive statement without a full stop, such
+   * as 'disables the WiFi mode'.
+   */
+  public String description() default "";
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcStartEvent.java b/Common/src/com/googlecode/android_scripting/rpc/RpcStartEvent.java
new file mode 100644
index 0000000..68a5af3
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcStartEvent.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Use this annotation to mark an RPC as one that starts generating events.
+ *
+ * @author damonkohler@gmail.com (Damon Kohler)
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@Documented
+public @interface RpcStartEvent {
+  /** The name of the event that is generated. */
+  public String value();
+}
diff --git a/Common/src/com/googlecode/android_scripting/rpc/RpcStopEvent.java b/Common/src/com/googlecode/android_scripting/rpc/RpcStopEvent.java
new file mode 100644
index 0000000..fce25f9
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/rpc/RpcStopEvent.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.rpc;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Use this annotation to mark an RPC as one that stops generating events.
+ *
+ * @author damonkohler@gmail.com (Damon Kohler)
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@Documented
+public @interface RpcStopEvent {
+  /** The name of the event that stops being generated. */
+  public String value();
+}
diff --git a/Common/src/com/googlecode/android_scripting/trigger/ScriptTrigger.java b/Common/src/com/googlecode/android_scripting/trigger/ScriptTrigger.java
new file mode 100644
index 0000000..76640fe
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/trigger/ScriptTrigger.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.trigger;
+
+import android.content.Context;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.IntentBuilders;
+import com.googlecode.android_scripting.event.Event;
+
+import java.io.File;
+
+/**
+ * A trigger implementation that launches a given script when the event occurs.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ */
+public class ScriptTrigger implements Trigger {
+  private static final long serialVersionUID = 1804599219214041409L;
+  private final File mScript;
+  private final String mEventName;
+
+  public ScriptTrigger(String eventName, File script) {
+    mEventName = eventName;
+    mScript = script;
+  }
+
+  @Override
+  public void handleEvent(Event event, Context context) {
+    Intent intent = IntentBuilders.buildStartInBackgroundIntent(mScript);
+    // This is required since the script is being started from the TriggerService.
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    context.startActivity(intent);
+  }
+
+  @Override
+  public String getEventName() {
+    return mEventName;
+  }
+
+  public File getScript() {
+    return mScript;
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/trigger/Trigger.java b/Common/src/com/googlecode/android_scripting/trigger/Trigger.java
new file mode 100644
index 0000000..e06a973
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/trigger/Trigger.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.trigger;
+
+import android.content.Context;
+
+import com.googlecode.android_scripting.event.Event;
+
+import java.io.Serializable;
+
+/**
+ * Interface implemented by objects listening to events on the event queue inside of the
+ * {@link SerivceManager}.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ */
+public interface Trigger extends Serializable {
+  /**
+   * Handles an event from the event queue.
+   *
+   * @param event
+   *          Event to handle
+   * @param context
+   *          TODO
+   */
+  void handleEvent(Event event, Context context);
+
+  /**
+   * Returns the event name that this {@link Trigger} is interested in.
+   */
+  // TODO(damonkohler): This could be removed by maintaining a reverse mapping from Trigger to event
+  // name in the TriggerRespository.
+  String getEventName();
+}
diff --git a/Common/src/com/googlecode/android_scripting/trigger/TriggerRepository.java b/Common/src/com/googlecode/android_scripting/trigger/TriggerRepository.java
new file mode 100644
index 0000000..4e42bfc
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/trigger/TriggerRepository.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.trigger;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+import com.googlecode.android_scripting.IntentBuilders;
+import com.googlecode.android_scripting.Log;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Map.Entry;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.apache.commons.codec.binary.Base64Codec;
+
+/**
+ * A repository maintaining all currently scheduled triggers. This includes, for example, alarms or
+ * observers of arriving text messages etc. This class is responsible for serializing the list of
+ * triggers to the shared preferences store, and retrieving it from there.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class TriggerRepository {
+  /**
+   * The list of triggers is serialized to the shared preferences entry with this name.
+   */
+  private static final String TRIGGERS_PREF_KEY = "TRIGGERS";
+
+  private final SharedPreferences mPreferences;
+  private final Context mContext;
+
+  /**
+   * An interface for objects that are notified when a trigger is added to the repository.
+   */
+  public interface TriggerRepositoryObserver {
+    /**
+     * Invoked just before the trigger is added to the repository.
+     *
+     * @param trigger
+     *          The trigger about to be added to the repository.
+     */
+    void onPut(Trigger trigger);
+
+    /**
+     * Invoked just after the trigger has been removed from the repository.
+     *
+     * @param trigger
+     *          The trigger that has just been removed from the repository.
+     */
+    void onRemove(Trigger trigger);
+  }
+
+  private final Multimap<String, Trigger> mTriggers;
+  private final CopyOnWriteArrayList<TriggerRepositoryObserver> mTriggerObservers =
+      new CopyOnWriteArrayList<TriggerRepositoryObserver>();
+
+  public TriggerRepository(Context context) {
+    mContext = context;
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(context);
+    String triggers = mPreferences.getString(TRIGGERS_PREF_KEY, null);
+    mTriggers = deserializeTriggersFromString(triggers);
+  }
+
+  /** Returns a list of all triggers. The list is unmodifiable. */
+  public synchronized Multimap<String, Trigger> getAllTriggers() {
+    return Multimaps.unmodifiableMultimap(mTriggers);
+  }
+
+  /**
+   * Adds a new trigger to the repository.
+   *
+   * @param trigger
+   *          the {@link Trigger} to add
+   */
+  public synchronized void put(Trigger trigger) {
+    notifyOnAdd(trigger);
+    mTriggers.put(trigger.getEventName(), trigger);
+    storeTriggers();
+    ensureTriggerServiceRunning();
+  }
+
+  /** Removes a specific {@link Trigger}. */
+  public synchronized void remove(final Trigger trigger) {
+    mTriggers.get(trigger.getEventName()).remove(trigger);
+    storeTriggers();
+    notifyOnRemove(trigger);
+  }
+
+  /** Ensures that the {@link TriggerService} is running */
+  private void ensureTriggerServiceRunning() {
+    Intent startTriggerServiceIntent = IntentBuilders.buildTriggerServiceIntent();
+    mContext.startService(startTriggerServiceIntent);
+  }
+
+  /** Notify all {@link TriggerRepositoryObserver}s that a {@link Trigger} was added. */
+  private void notifyOnAdd(Trigger trigger) {
+    for (TriggerRepositoryObserver observer : mTriggerObservers) {
+      observer.onPut(trigger);
+    }
+  }
+
+  /** Notify all {@link TriggerRepositoryObserver}s that a {@link Trigger} was removed. */
+  private void notifyOnRemove(Trigger trigger) {
+    for (TriggerRepositoryObserver observer : mTriggerObservers) {
+      observer.onRemove(trigger);
+    }
+  }
+
+  /** Writes the list of triggers to the shared preferences. */
+  private synchronized void storeTriggers() {
+    SharedPreferences.Editor editor = mPreferences.edit();
+    final String triggerValue = serializeTriggersToString(mTriggers);
+    if (triggerValue != null) {
+      editor.putString(TRIGGERS_PREF_KEY, triggerValue);
+    }
+    editor.commit();
+  }
+
+  /** Deserializes the {@link Multimap} of {@link Trigger}s from a base 64 encoded string. */
+  @SuppressWarnings("unchecked")
+  private Multimap<String, Trigger> deserializeTriggersFromString(String triggers) {
+    if (triggers == null) {
+      return ArrayListMultimap.<String, Trigger> create();
+    }
+    try {
+      final ByteArrayInputStream inputStream =
+          new ByteArrayInputStream(Base64Codec.decodeBase64(triggers.getBytes()));
+      final ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
+      return (Multimap<String, Trigger>) objectInputStream.readObject();
+    } catch (Exception e) {
+      Log.e(e);
+    }
+    return ArrayListMultimap.<String, Trigger> create();
+  }
+
+  /** Serializes the list of triggers to a Base64 encoded string. */
+  private String serializeTriggersToString(Multimap<String, Trigger> triggers) {
+    try {
+      final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+      final ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
+      objectOutputStream.writeObject(triggers);
+      return new String(Base64Codec.encodeBase64(outputStream.toByteArray()));
+    } catch (IOException e) {
+      Log.e(e);
+      return null;
+    }
+  }
+
+  /** Returns {@code true} iff the list of triggers is empty. */
+  public synchronized boolean isEmpty() {
+    return mTriggers.isEmpty();
+  }
+
+  /** Adds a {@link TriggerRepositoryObserver}. */
+  public void addObserver(TriggerRepositoryObserver observer) {
+    mTriggerObservers.add(observer);
+  }
+
+  /**
+   * Adds the given {@link TriggerRepositoryObserver} and invokes
+   * {@link TriggerRepositoryObserver#onPut} for all existing triggers.
+   *
+   * @param observer
+   *          The observer to add.
+   */
+  public synchronized void bootstrapObserver(TriggerRepositoryObserver observer) {
+    addObserver(observer);
+    for (Entry<String, Trigger> trigger : mTriggers.entries()) {
+      observer.onPut(trigger.getValue());
+    }
+  }
+
+  /**
+   * Removes a {@link TriggerRepositoryObserver}.
+   */
+  public void removeObserver(TriggerRepositoryObserver observer) {
+    mTriggerObservers.remove(observer);
+  }
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/util/VisibleForTesting.java b/Common/src/com/googlecode/android_scripting/util/VisibleForTesting.java
new file mode 100644
index 0000000..cc8f92a
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/util/VisibleForTesting.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.util;
+
+/**
+ * An annotation that indicates that the visibility of a type or member has been relaxed from
+ * private to package to make the code testable.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+// TODO(igor.v.karp): Consider replacing this annotation by one from Guava or GCL
+public @interface VisibleForTesting {
+}
diff --git a/Common/src/com/googlecode/android_scripting/webcam/JpegProvider.java b/Common/src/com/googlecode/android_scripting/webcam/JpegProvider.java
new file mode 100644
index 0000000..d258882
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/webcam/JpegProvider.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.webcam;
+
+interface JpegProvider {
+  public byte[] getJpeg();
+}
\ No newline at end of file
diff --git a/Common/src/com/googlecode/android_scripting/webcam/MjpegServer.java b/Common/src/com/googlecode/android_scripting/webcam/MjpegServer.java
new file mode 100644
index 0000000..c2b3ac5
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/webcam/MjpegServer.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.webcam;
+
+import java.io.BufferedReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.net.Socket;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.SimpleServer;
+
+class MjpegServer extends SimpleServer {
+
+  private final JpegProvider mProvider;
+
+  public MjpegServer(JpegProvider provider) {
+    mProvider = provider;
+  }
+
+  @Override
+  protected void handleConnection(Socket socket) throws Exception {
+    Log.d("handle Mjpeg connection");
+    byte[] data = mProvider.getJpeg();
+    if (data == null) {
+      return;
+    }
+    OutputStream outputStream = socket.getOutputStream();
+    outputStream.write((
+        "HTTP/1.0 200 OK\r\n" +
+        "Server: SL4A\r\n" +
+        "Connection: close\r\n" +
+        "Max-Age: 0\r\n" +
+        "Expires: 0\r\n" +
+        "Cache-Control: no-cache, private\r\n" +
+        "Pragma: no-cache\r\n" +
+        "Content-Type: multipart/x-mixed-replace; boundary=--BoundaryString\r\n\r\n").getBytes());
+    while (true) {
+      data = mProvider.getJpeg();
+      if (data == null) {
+        return;
+      }
+      outputStream.write("--BoundaryString\r\n".getBytes());
+      outputStream.write("Content-type: image/jpg\r\n".getBytes());
+      outputStream.write(("Content-Length: " + data.length + "\r\n\r\n").getBytes());
+      outputStream.write(data);
+      outputStream.write("\r\n\r\n".getBytes());
+      outputStream.flush();
+    }
+  }
+
+  @Override
+  protected void handleRPCConnection(Socket sock, Integer UID, BufferedReader reader, PrintWriter writer)
+      throws Exception {
+  }
+}
diff --git a/Common/src/com/googlecode/android_scripting/webcam/WebCamFacade.java b/Common/src/com/googlecode/android_scripting/webcam/WebCamFacade.java
new file mode 100644
index 0000000..b984828
--- /dev/null
+++ b/Common/src/com/googlecode/android_scripting/webcam/WebCamFacade.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.webcam;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
+
+import android.app.Service;
+import android.graphics.ImageFormat;
+import android.graphics.Rect;
+import android.graphics.YuvImage;
+import android.hardware.Camera;
+import android.hardware.Camera.Parameters;
+import android.hardware.Camera.PreviewCallback;
+import android.hardware.Camera.Size;
+import android.util.Base64;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.WindowManager;
+import android.view.SurfaceHolder.Callback;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.FutureActivityTaskExecutor;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.SingleThreadExecutor;
+import com.googlecode.android_scripting.SimpleServer.SimpleServerObserver;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.future.FutureActivityTask;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDefault;
+import com.googlecode.android_scripting.rpc.RpcOptional;
+import com.googlecode.android_scripting.rpc.RpcParameter;
+
+/**
+ * Manages access to camera streaming.
+ * <br>
+ * <h3>Usage Notes</h3>
+ * <br><b>webCamStart</b> and <b>webCamStop</b> are used to start and stop an Mpeg stream on a given port. <b>webcamAdjustQuality</b> is used to ajust the quality of the streaming video.
+ * <br><b>cameraStartPreview</b> is used to get access to the camera preview screen. It will generate "preview" events as images become available.
+ * <br>The preview has two modes: data or file. If you pass a non-blank, writable file path to the <b>cameraStartPreview</b> it will store jpg images in that folder.
+ * It is up to the caller to clean up these files after the fact. If no file element is provided,
+ * the event will include the image data as a base64 encoded string.
+ * <h3>Event details</h3>
+ * <br>The data element of the preview event will be a map, with the following elements defined.
+ * <ul>
+ * <li><b>format</b> - currently always "jpeg"
+ * <li><b>width</b> - image width (in pixels)
+ * <li><b>height</b> - image height (in pixels)
+ * <li><b>quality</b> - JPEG quality. Number from 1-100
+ * <li><b>filename</b> - Name of file where image was saved. Only relevant if filepath defined.
+ * <li><b>error</b> - included if there was an IOException saving file, ie, disk full or path write protected.
+ * <li><b>encoding</b> - Data encoding. If filepath defined, will be "file" otherwise "base64"
+ * <li><b>data</b> - Base64 encoded image data.
+ * </ul>
+ *<br>Note that "filename", "error" and "data" are mutual exclusive.
+ *<br>
+ *<br>The webcam and preview modes use the same resources, so you can't use them both at the same time. Stop one mode before starting the other.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com) (probably)
+ * @author Robbie Matthews (rjmatthews62@gmail.com)
+ *
+ */
+public class WebCamFacade extends RpcReceiver {
+
+  private final Service mService;
+  private final Executor mJpegCompressionExecutor = new SingleThreadExecutor();
+  private final ByteArrayOutputStream mJpegCompressionBuffer = new ByteArrayOutputStream();
+
+  private volatile byte[] mJpegData;
+
+  private CountDownLatch mJpegDataReady;
+  private boolean mStreaming;
+  private int mPreviewHeight;
+  private int mPreviewWidth;
+  private int mJpegQuality;
+
+  private MjpegServer mJpegServer;
+  private FutureActivityTask<SurfaceHolder> mPreviewTask;
+  private Camera mCamera;
+  private Parameters mParameters;
+  private final EventFacade mEventFacade;
+  private boolean mPreview;
+  private File mDest;
+
+  private final PreviewCallback mPreviewCallback = new PreviewCallback() {
+    @Override
+    public void onPreviewFrame(final byte[] data, final Camera camera) {
+      mJpegCompressionExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          mJpegData = compressYuvToJpeg(data);
+          mJpegDataReady.countDown();
+          if (mStreaming) {
+            camera.setOneShotPreviewCallback(mPreviewCallback);
+          }
+        }
+      });
+    }
+  };
+
+  private final PreviewCallback mPreviewEvent = new PreviewCallback() {
+    @Override
+    public void onPreviewFrame(final byte[] data, final Camera camera) {
+      mJpegCompressionExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          mJpegData = compressYuvToJpeg(data);
+          Map<String,Object> map = new HashMap<String, Object>();
+          map.put("format", "jpeg");
+          map.put("width", mPreviewWidth);
+          map.put("height", mPreviewHeight);
+          map.put("quality", mJpegQuality);
+          if (mDest!=null) {
+            try {
+              File dest=File.createTempFile("prv",".jpg",mDest);
+              OutputStream output = new FileOutputStream(dest);
+              output.write(mJpegData);
+              output.close();
+              map.put("encoding","file");
+              map.put("filename",dest.toString());
+            } catch (IOException e) {
+              map.put("error", e.toString());
+            }
+          }
+          else {
+            map.put("encoding","Base64");
+            map.put("data", Base64.encodeToString(mJpegData, Base64.DEFAULT));
+          }
+          mEventFacade.postEvent("preview", map);
+          if (mPreview) {
+            camera.setOneShotPreviewCallback(mPreviewEvent);
+          }
+        }
+      });
+    }
+  };
+
+  public WebCamFacade(FacadeManager manager) {
+    super(manager);
+    mService = manager.getService();
+    mJpegDataReady = new CountDownLatch(1);
+    mEventFacade = manager.getReceiver(EventFacade.class);
+  }
+
+  private byte[] compressYuvToJpeg(final byte[] yuvData) {
+    mJpegCompressionBuffer.reset();
+    YuvImage yuvImage =
+        new YuvImage(yuvData, ImageFormat.NV21, mPreviewWidth, mPreviewHeight, null);
+    yuvImage.compressToJpeg(new Rect(0, 0, mPreviewWidth, mPreviewHeight), mJpegQuality,
+        mJpegCompressionBuffer);
+    return mJpegCompressionBuffer.toByteArray();
+  }
+
+  @Rpc(description = "Starts an MJPEG stream and returns a Tuple of address and port for the stream.")
+  public InetSocketAddress webcamStart(
+      @RpcParameter(name = "resolutionLevel", description = "increasing this number provides higher resolution") @RpcDefault("0") Integer resolutionLevel,
+      @RpcParameter(name = "jpegQuality", description = "a number from 0-100") @RpcDefault("20") Integer jpegQuality,
+      @RpcParameter(name = "port", description = "If port is specified, the webcam service will bind to port, otherwise it will pick any available port.") @RpcDefault("0") Integer port)
+      throws Exception {
+    try {
+      openCamera(resolutionLevel, jpegQuality);
+      return startServer(port);
+    } catch (Exception e) {
+      webcamStop();
+      throw e;
+    }
+  }
+
+  private InetSocketAddress startServer(Integer port) {
+    mJpegServer = new MjpegServer(new JpegProvider() {
+      @Override
+      public byte[] getJpeg() {
+        try {
+          mJpegDataReady.await();
+        } catch (InterruptedException e) {
+          Log.e(e);
+        }
+        return mJpegData;
+      }
+    });
+    mJpegServer.addObserver(new SimpleServerObserver() {
+      @Override
+      public void onDisconnect() {
+        if (mJpegServer.getNumberOfConnections() == 0 && mStreaming) {
+          stopStream();
+        }
+      }
+
+      @Override
+      public void onConnect() {
+        if (!mStreaming) {
+          startStream();
+        }
+      }
+    });
+    return mJpegServer.startPublic(port);
+  }
+
+  private void stopServer() {
+    if (mJpegServer != null) {
+      mJpegServer.shutdown();
+      mJpegServer = null;
+    }
+  }
+
+  @Rpc(description = "Adjusts the quality of the webcam stream while it is running.")
+  public void webcamAdjustQuality(
+      @RpcParameter(name = "resolutionLevel", description = "increasing this number provides higher resolution") @RpcDefault("0") Integer resolutionLevel,
+      @RpcParameter(name = "jpegQuality", description = "a number from 0-100") @RpcDefault("20") Integer jpegQuality)
+      throws Exception {
+    if (mStreaming == false) {
+      throw new IllegalStateException("Webcam not streaming.");
+    }
+    stopStream();
+    releaseCamera();
+    openCamera(resolutionLevel, jpegQuality);
+    startStream();
+  }
+
+  private void openCamera(Integer resolutionLevel, Integer jpegQuality) throws IOException,
+      InterruptedException {
+    mCamera = Camera.open();
+    mParameters = mCamera.getParameters();
+    mParameters.setPictureFormat(ImageFormat.JPEG);
+    mParameters.setPreviewFormat(ImageFormat.JPEG);
+    List<Size> supportedPreviewSizes = mParameters.getSupportedPreviewSizes();
+    Collections.sort(supportedPreviewSizes, new Comparator<Size>() {
+      @Override
+      public int compare(Size o1, Size o2) {
+        return o1.width - o2.width;
+      }
+    });
+    Size previewSize =
+        supportedPreviewSizes.get(Math.min(resolutionLevel, supportedPreviewSizes.size() - 1));
+    mPreviewHeight = previewSize.height;
+    mPreviewWidth = previewSize.width;
+    mParameters.setPreviewSize(mPreviewWidth, mPreviewHeight);
+    mJpegQuality = Math.min(Math.max(jpegQuality, 0), 100);
+    mCamera.setParameters(mParameters);
+    // TODO(damonkohler): Rotate image based on orientation.
+    mPreviewTask = createPreviewTask();
+    mCamera.startPreview();
+  }
+
+  private void startStream() {
+    mStreaming = true;
+    mCamera.setOneShotPreviewCallback(mPreviewCallback);
+  }
+
+  private void stopStream() {
+    mJpegDataReady = new CountDownLatch(1);
+    mStreaming = false;
+    if (mPreviewTask != null) {
+      mPreviewTask.finish();
+      mPreviewTask = null;
+    }
+  }
+
+  private void releaseCamera() {
+    if (mCamera != null) {
+      mCamera.release();
+      mCamera = null;
+    }
+    mParameters = null;
+  }
+
+  @Rpc(description = "Stops the webcam stream.")
+  public void webcamStop() {
+    stopServer();
+    stopStream();
+    releaseCamera();
+  }
+
+  private FutureActivityTask<SurfaceHolder> createPreviewTask() throws IOException,
+      InterruptedException {
+    FutureActivityTask<SurfaceHolder> task = new FutureActivityTask<SurfaceHolder>() {
+      @Override
+      public void onCreate() {
+        super.onCreate();
+        final SurfaceView view = new SurfaceView(getActivity());
+        getActivity().setContentView(view);
+        getActivity().getWindow().setSoftInputMode(
+            WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
+        //view.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
+        view.getHolder().addCallback(new Callback() {
+          @Override
+          public void surfaceDestroyed(SurfaceHolder holder) {
+          }
+
+          @Override
+          public void surfaceCreated(SurfaceHolder holder) {
+            setResult(view.getHolder());
+          }
+
+          @Override
+          public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+          }
+        });
+      }
+    };
+    FutureActivityTaskExecutor taskExecutor =
+        ((BaseApplication) mService.getApplication()).getTaskExecutor();
+    taskExecutor.execute(task);
+    mCamera.setPreviewDisplay(task.getResult());
+    return task;
+  }
+
+  @Rpc(description = "Start Preview Mode. Throws 'preview' events.",returns="True if successful")
+  public boolean cameraStartPreview(
+          @RpcParameter(name = "resolutionLevel", description = "increasing this number provides higher resolution") @RpcDefault("0") Integer resolutionLevel,
+          @RpcParameter(name = "jpegQuality", description = "a number from 0-100") @RpcDefault("20") Integer jpegQuality,
+          @RpcParameter(name = "filepath", description = "Path to store jpeg files.") @RpcOptional String filepath)
+      throws InterruptedException {
+    mDest=null;
+    if (filepath!=null && (filepath.length()>0)) {
+      mDest = new File(filepath);
+      if (!mDest.exists()) mDest.mkdirs();
+      if (!(mDest.isDirectory() && mDest.canWrite())) {
+        return false;
+      }
+    }
+
+    try {
+      openCamera(resolutionLevel, jpegQuality);
+    } catch (IOException e) {
+      Log.e(e);
+      return false;
+    }
+    startPreview();
+    return true;
+  }
+
+  @Rpc(description = "Stop the preview mode.")
+  public void cameraStopPreview() {
+    stopPreview();
+  }
+
+  private void startPreview() {
+    mPreview = true;
+    mCamera.setOneShotPreviewCallback(mPreviewEvent);
+  }
+
+  private void stopPreview() {
+    mPreview = false;
+    if (mPreviewTask!=null)
+    {
+      mPreviewTask.finish();
+      mPreviewTask=null;
+    }
+    releaseCamera();
+  }
+
+  @Override
+  public void shutdown() {
+    mPreview=false;
+    webcamStop();
+  }
+}
diff --git a/Common/src/org/apache/commons/codec/BinaryDecoder.java b/Common/src/org/apache/commons/codec/BinaryDecoder.java
new file mode 100644
index 0000000..07d93fa
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/BinaryDecoder.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec;
+
+/**
+ * Defines common decoding methods for byte array decoders.
+ *
+ * @author Apache Software Foundation
+ * @version $Id: BinaryDecoder.java 651573 2008-04-25 11:11:21Z niallp $
+ */
+public interface BinaryDecoder extends Decoder {
+
+    /**
+     * Decodes a byte array and returns the results as a byte array.
+     *
+     * @param pArray A byte array which has been encoded with the
+     *      appropriate encoder
+     *
+     * @return a byte array that contains decoded content
+     *
+     * @throws DecoderException A decoder exception is thrown
+     *          if a Decoder encounters a failure condition during
+     *          the decode process.
+     */
+    byte[] decode(byte[] pArray) throws DecoderException;
+}
+
diff --git a/Common/src/org/apache/commons/codec/BinaryEncoder.java b/Common/src/org/apache/commons/codec/BinaryEncoder.java
new file mode 100644
index 0000000..40bd797
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/BinaryEncoder.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec;
+
+/**
+ * Defines common encoding methods for byte array encoders.
+ *
+ * @author Apache Software Foundation
+ * @version $Id: BinaryEncoder.java 651573 2008-04-25 11:11:21Z niallp $
+ */
+public interface BinaryEncoder extends Encoder {
+
+    /**
+     * Encodes a byte array and return the encoded data
+     * as a byte array.
+     *
+     * @param pArray Data to be encoded
+     *
+     * @return A byte array containing the encoded data
+     *
+     * @throws EncoderException thrown if the Encoder
+     *      encounters a failure condition during the
+     *      encoding process.
+     */
+    byte[] encode(byte[] pArray) throws EncoderException;
+}
+
diff --git a/Common/src/org/apache/commons/codec/CharEncoding.java b/Common/src/org/apache/commons/codec/CharEncoding.java
new file mode 100644
index 0000000..01af749
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/CharEncoding.java
@@ -0,0 +1,126 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec;
+
+/**
+ * Character encoding names required of every implementation of the Java platform.
+ *
+ * From the Java documentation <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard
+ * charsets</a>:
+ * <p>
+ * <cite>Every implementation of the Java platform is required to support the following character encodings. Consult the
+ * release documentation for your implementation to see if any other encodings are supported. Consult the release
+ * documentation for your implementation to see if any other encodings are supported. </cite>
+ * </p>
+ *
+ * <ul>
+ * <li><code>US-ASCII</code><br/>
+ * Seven-bit ASCII, a.k.a. ISO646-US, a.k.a. the Basic Latin block of the Unicode character set.</li>
+ * <li><code>ISO-8859-1</code><br/>
+ * ISO Latin Alphabet No. 1, a.k.a. ISO-LATIN-1.</li>
+ * <li><code>UTF-8</code><br/>
+ * Eight-bit Unicode Transformation Format.</li>
+ * <li><code>UTF-16BE</code><br/>
+ * Sixteen-bit Unicode Transformation Format, big-endian byte order.</li>
+ * <li><code>UTF-16LE</code><br/>
+ * Sixteen-bit Unicode Transformation Format, little-endian byte order.</li>
+ * <li><code>UTF-16</code><br/>
+ * Sixteen-bit Unicode Transformation Format, byte order specified by a mandatory initial byte-order mark (either order
+ * accepted on input, big-endian used on output.)</li>
+ * </ul>
+ *
+ * This perhaps would best belong in the [lang] project. Even if a similar interface is defined in [lang], it is not
+ * forseen that [codec] would be made to depend on [lang].
+ *
+ * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+ * @author Apache Software Foundation
+ * @since 1.4
+ * @version $Id: CharEncoding.java 797857 2009-07-25 23:43:33Z ggregory $
+ */
+public class CharEncoding {
+    /**
+     * CharEncodingISO Latin Alphabet No. 1, a.k.a. ISO-LATIN-1. </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final String ISO_8859_1 = "ISO-8859-1";
+
+    /**
+     * <p>
+     * Seven-bit ASCII, also known as ISO646-US, also known as the Basic Latin block of the Unicode character set.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final String US_ASCII = "US-ASCII";
+
+    /**
+     * <p>
+     * Sixteen-bit Unicode Transformation Format, The byte order specified by a mandatory initial byte-order mark
+     * (either order accepted on input, big-endian used on output)
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final String UTF_16 = "UTF-16";
+
+    /**
+     * <p>
+     * Sixteen-bit Unicode Transformation Format, big-endian byte order.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final String UTF_16BE = "UTF-16BE";
+
+    /**
+     * <p>
+     * Sixteen-bit Unicode Transformation Format, little-endian byte order.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final String UTF_16LE = "UTF-16LE";
+
+    /**
+     * <p>
+     * Eight-bit Unicode Transformation Format.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final String UTF_8 = "UTF-8";
+}
\ No newline at end of file
diff --git a/Common/src/org/apache/commons/codec/Decoder.java b/Common/src/org/apache/commons/codec/Decoder.java
new file mode 100644
index 0000000..c4de37a
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/Decoder.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec;
+
+/**
+ * <p>Provides the highest level of abstraction for Decoders.
+ * This is the sister interface of {@link Encoder}.  All
+ * Decoders implement this common generic interface.</p>
+ *
+ * <p>Allows a user to pass a generic Object to any Decoder
+ * implementation in the codec package.</p>
+ *
+ * <p>One of the two interfaces at the center of the codec package.</p>
+ *
+ * @author Apache Software Foundation
+ * @version $Id: Decoder.java 797690 2009-07-24 23:28:35Z ggregory $
+ */
+public interface Decoder {
+
+    /**
+     * Decodes an "encoded" Object and returns a "decoded"
+     * Object.  Note that the implementation of this
+     * interface will try to cast the Object parameter
+     * to the specific type expected by a particular Decoder
+     * implementation.  If a {@link ClassCastException} occurs
+     * this decode method will throw a DecoderException.
+     *
+     * @param pObject an object to "decode"
+     *
+     * @return a 'decoded" object
+     *
+     * @throws DecoderException a decoder exception can
+     * be thrown for any number of reasons.  Some good
+     * candidates are that the parameter passed to this
+     * method is null, a param cannot be cast to the
+     * appropriate type for a specific encoder.
+     */
+    Object decode(Object pObject) throws DecoderException;
+}
+
diff --git a/Common/src/org/apache/commons/codec/DecoderException.java b/Common/src/org/apache/commons/codec/DecoderException.java
new file mode 100644
index 0000000..c928086
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/DecoderException.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec;
+
+/**
+ * Thrown when a Decoder has encountered a failure condition during a decode.
+ *
+ * @author Apache Software Foundation
+ * @version $Id: DecoderException.java 797804 2009-07-25 17:27:04Z ggregory $
+ */
+public class DecoderException extends Exception {
+
+    /**
+     * Declares the Serial Version Uid.
+     *
+     * @see <a href="http://c2.com/cgi/wiki?AlwaysDeclareSerialVersionUid">Always Declare Serial Version Uid</a>
+     */
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Constructs a new exception with <code>null</code> as its detail message. The cause is not initialized, and may
+     * subsequently be initialized by a call to {@link #initCause}.
+     *
+     * @since 1.4
+     */
+    public DecoderException() {
+        super();
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message. The cause is not initialized, and may subsequently
+     * be initialized by a call to {@link #initCause}.
+     *
+     * @param message
+     *            The detail message which is saved for later retrieval by the {@link #getMessage()} method.
+     */
+    public DecoderException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructsa new exception with the specified detail message and cause.
+     *
+     * <p>
+     * Note that the detail message associated with <code>cause</code> is not automatically incorporated into this
+     * exception's detail message.
+     * </p>
+     *
+     * @param message
+     *            The detail message which is saved for later retrieval by the {@link #getMessage()} method.
+     * @param cause
+     *            The cause which is saved for later retrieval by the {@link #getCause()} method. A <code>null</code>
+     *            value is permitted, and indicates that the cause is nonexistent or unknown.
+     * @since 1.4
+     */
+    public DecoderException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause and a detail message of <code>(cause==null ?
+     * null : cause.toString())</code> (which typically contains the class and detail message of <code>cause</code>).
+     * This constructor is useful for exceptions that are little more than wrappers for other throwables.
+     *
+     * @param cause
+     *            The cause which is saved for later retrieval by the {@link #getCause()} method. A <code>null</code>
+     *            value is permitted, and indicates that the cause is nonexistent or unknown.
+     * @since 1.4
+     */
+    public DecoderException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/Common/src/org/apache/commons/codec/Encoder.java b/Common/src/org/apache/commons/codec/Encoder.java
new file mode 100644
index 0000000..a137e39
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/Encoder.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec;
+
+/**
+ * <p>Provides the highest level of abstraction for Encoders.
+ * This is the sister interface of {@link Decoder}.  Every implementation of
+ * Encoder provides this common generic interface whic allows a user to pass a
+ * generic Object to any Encoder implementation in the codec package.</p>
+ *
+ * @author Apache Software Foundation
+ * @version $Id: Encoder.java 634915 2008-03-08 09:30:25Z bayard $
+ */
+public interface Encoder {
+
+    /**
+     * Encodes an "Object" and returns the encoded content
+     * as an Object.  The Objects here may just be <code>byte[]</code>
+     * or <code>String</code>s depending on the implementation used.
+     *
+     * @param pObject An object ot encode
+     *
+     * @return An "encoded" Object
+     *
+     * @throws EncoderException an encoder exception is
+     *  thrown if the encoder experiences a failure
+     *  condition during the encoding process.
+     */
+    Object encode(Object pObject) throws EncoderException;
+}
+
diff --git a/Common/src/org/apache/commons/codec/EncoderException.java b/Common/src/org/apache/commons/codec/EncoderException.java
new file mode 100644
index 0000000..975bb77
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/EncoderException.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec;
+
+/**
+ * Thrown when there is a failure condition during the encoding process. This exception is thrown when an Encoder
+ * encounters a encoding specific exception such as invalid data, inability to calculate a checksum, characters outside
+ * of the expected range.
+ *
+ * @author Apache Software Foundation
+ * @version $Id: EncoderException.java 797804 2009-07-25 17:27:04Z ggregory $
+ */
+public class EncoderException extends Exception {
+
+    /**
+     * Declares the Serial Version Uid.
+     *
+     * @see <a href="http://c2.com/cgi/wiki?AlwaysDeclareSerialVersionUid">Always Declare Serial Version Uid</a>
+     */
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Constructs a new exception with <code>null</code> as its detail message. The cause is not initialized, and may
+     * subsequently be initialized by a call to {@link #initCause}.
+     *
+     * @since 1.4
+     */
+    public EncoderException() {
+        super();
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message. The cause is not initialized, and may subsequently
+     * be initialized by a call to {@link #initCause}.
+     *
+     * @param message
+     *            a useful message relating to the encoder specific error.
+     */
+    public EncoderException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message and cause.
+     *
+     * <p>
+     * Note that the detail message associated with <code>cause</code> is not automatically incorporated into this
+     * exception's detail message.
+     * </p>
+     *
+     * @param message
+     *            The detail message which is saved for later retrieval by the {@link #getMessage()} method.
+     * @param cause
+     *            The cause which is saved for later retrieval by the {@link #getCause()} method. A <code>null</code>
+     *            value is permitted, and indicates that the cause is nonexistent or unknown.
+     * @since 1.4
+     */
+    public EncoderException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause and a detail message of <code>(cause==null ?
+     * null : cause.toString())</code> (which typically contains the class and detail message of <code>cause</code>).
+     * This constructor is useful for exceptions that are little more than wrappers for other throwables.
+     *
+     * @param cause
+     *            The cause which is saved for later retrieval by the {@link #getCause()} method. A <code>null</code>
+     *            value is permitted, and indicates that the cause is nonexistent or unknown.
+     * @since 1.4
+     */
+    public EncoderException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/Common/src/org/apache/commons/codec/binary/Base64Codec.java b/Common/src/org/apache/commons/codec/binary/Base64Codec.java
new file mode 100644
index 0000000..20239e2
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/binary/Base64Codec.java
@@ -0,0 +1,1055 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec.binary;
+
+import java.math.BigInteger;
+
+import org.apache.commons.codec.BinaryDecoder;
+import org.apache.commons.codec.BinaryEncoder;
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.EncoderException;
+
+/**
+ * Provides Base64 encoding and decoding as defined by RFC 2045.
+ *
+ * <p>
+ * This class implements section <cite>6.8. Base64 Content-Transfer-Encoding</cite> from RFC 2045 <cite>Multipurpose
+ * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies</cite> by Freed and Borenstein.
+ * </p>
+ * <p>
+ * The class can be parameterized in the following manner with various constructors:
+ * <ul>
+ * <li>URL-safe mode: Default off.</li>
+ * <li>Line length: Default 76. Line length that aren't multiples of 4 will still essentially end up being multiples of
+ * 4 in the encoded data.
+ * <li>Line separator: Default is CRLF ("\r\n")</li>
+ * </ul>
+ * </p>
+ * <p>
+ * Since this class operates directly on byte streams, and not character streams, it is hard-coded to only encode/decode
+ * character encodings which are compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252, UTF-8, etc).
+ * </p>
+ *
+ * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>
+ * @author Apache Software Foundation
+ * @since 1.0
+ * @version $Id: Base64.java 801706 2009-08-06 16:27:06Z niallp $
+ */
+public class Base64Codec implements BinaryEncoder, BinaryDecoder {
+    private static final int DEFAULT_BUFFER_RESIZE_FACTOR = 2;
+
+    private static final int DEFAULT_BUFFER_SIZE = 8192;
+
+    /**
+     * Chunk size per RFC 2045 section 6.8.
+     *
+     * <p>
+     * The {@value} character limit does not count the trailing CRLF, but counts all other characters, including any
+     * equal signs.
+     * </p>
+     *
+     * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 6.8</a>
+     */
+    static final int CHUNK_SIZE = 76;
+
+    /**
+     * Chunk separator per RFC 2045 section 2.1.
+     *
+     * <p>
+     * N.B. The next major release may break compatibility and make this field private.
+     * </p>
+     *
+     * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a>
+     */
+    static final byte[] CHUNK_SEPARATOR = {'\r', '\n'};
+
+    /**
+     * This array is a lookup table that translates 6-bit positive integer index values into their "Base64 Alphabet"
+     * equivalents as specified in Table 1 of RFC 2045.
+     *
+     * Thanks to "commons" project in ws.apache.org for this code.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     */
+    private static final byte[] STANDARD_ENCODE_TABLE = {
+            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
+    };
+
+    /**
+     * This is a copy of the STANDARD_ENCODE_TABLE above, but with + and /
+     * changed to - and _ to make the encoded Base64 results more URL-SAFE.
+     * This table is only used when the Base64's mode is set to URL-SAFE.
+     */
+    private static final byte[] URL_SAFE_ENCODE_TABLE = {
+            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'
+    };
+
+    /**
+     * Byte used to pad output.
+     */
+    private static final byte PAD = '=';
+
+    /**
+     * This array is a lookup table that translates Unicode characters drawn from the "Base64 Alphabet" (as specified in
+     * Table 1 of RFC 2045) into their 6-bit positive integer equivalents. Characters that are not in the Base64
+     * alphabet but fall within the bounds of the array are translated to -1.
+     *
+     * Note: '+' and '-' both decode to 62. '/' and '_' both decode to 63. This means decoder seamlessly handles both
+     * URL_SAFE and STANDARD base64. (The encoder, on the other hand, needs to know ahead of time what to emit).
+     *
+     * Thanks to "commons" project in ws.apache.org for this code.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     */
+    private static final byte[] DECODE_TABLE = {
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54,
+            55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4,
+            5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+            24, 25, -1, -1, -1, -1, 63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+            35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
+    };
+
+    /** Mask used to extract 6 bits, used when encoding */
+    private static final int MASK_6BITS = 0x3f;
+
+    /** Mask used to extract 8 bits, used in decoding base64 bytes */
+    private static final int MASK_8BITS = 0xff;
+
+    // The static final fields above are used for the original static byte[] methods on Base64.
+    // The private member fields below are used with the new streaming approach, which requires
+    // some state be preserved between calls of encode() and decode().
+
+    /**
+     * Encode table to use: either STANDARD or URL_SAFE. Note: the DECODE_TABLE above remains static because it is able
+     * to decode both STANDARD and URL_SAFE streams, but the encodeTable must be a member variable so we can switch
+     * between the two modes.
+     */
+    private final byte[] encodeTable;
+
+    /**
+     * Line length for encoding. Not used when decoding. A value of zero or less implies no chunking of the base64
+     * encoded data.
+     */
+    private final int lineLength;
+
+    /**
+     * Line separator for encoding. Not used when decoding. Only used if lineLength > 0.
+     */
+    private final byte[] lineSeparator;
+
+    /**
+     * Convenience variable to help us determine when our buffer is going to run out of room and needs resizing.
+     * <code>decodeSize = 3 + lineSeparator.length;</code>
+     */
+    private final int decodeSize;
+
+    /**
+     * Convenience variable to help us determine when our buffer is going to run out of room and needs resizing.
+     * <code>encodeSize = 4 + lineSeparator.length;</code>
+     */
+    private final int encodeSize;
+
+    /**
+     * Buffer for streaming.
+     */
+    private byte[] buffer;
+
+    /**
+     * Position where next character should be written in the buffer.
+     */
+    private int pos;
+
+    /**
+     * Position where next character should be read from the buffer.
+     */
+    private int readPos;
+
+    /**
+     * Variable tracks how many characters have been written to the current line. Only used when encoding. We use it to
+     * make sure each encoded line never goes beyond lineLength (if lineLength > 0).
+     */
+    private int currentLinePos;
+
+    /**
+     * Writes to the buffer only occur after every 3 reads when encoding, an every 4 reads when decoding. This variable
+     * helps track that.
+     */
+    private int modulus;
+
+    /**
+     * Boolean flag to indicate the EOF has been reached. Once EOF has been reached, this Base64 object becomes useless,
+     * and must be thrown away.
+     */
+    private boolean eof;
+
+    /**
+     * Place holder for the 3 bytes we're dealing with for our base64 logic. Bitwise operations store and extract the
+     * base64 encoding or decoding from this variable.
+     */
+    private int x;
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length is 76, the line separator is CRLF, and the encoding table is STANDARD_ENCODE_TABLE.
+     * </p>
+     *
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     */
+    public Base64Codec() {
+        this(false);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in the given URL-safe mode.
+     * <p>
+     * When encoding the line length is 76, the line separator is CRLF, and the encoding table is STANDARD_ENCODE_TABLE.
+     * </p>
+     *
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param urlSafe
+     *            if <code>true</code>, URL-safe encoding is used. In most cases this should be set to
+     *            <code>false</code>.
+     * @since 1.4
+     */
+    public Base64Codec(boolean urlSafe) {
+        this(CHUNK_SIZE, CHUNK_SEPARATOR, urlSafe);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length is given in the constructor, the line separator is CRLF, and the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
+     * <p>
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param lineLength
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of 4).
+     *            If lineLength <= 0, then the output will not be divided into lines (chunks). Ignored when decoding.
+     * @since 1.4
+     */
+    public Base64Codec(int lineLength) {
+        this(lineLength, CHUNK_SEPARATOR);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length and line separator are given in the constructor, and the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
+     * <p>
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param lineLength
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of 4).
+     *            If lineLength <= 0, then the output will not be divided into lines (chunks). Ignored when decoding.
+     * @param lineSeparator
+     *            Each line of encoded data will end with this sequence of bytes.
+     * @throws IllegalArgumentException
+     *             Thrown when the provided lineSeparator included some base64 characters.
+     * @since 1.4
+     */
+    public Base64Codec(int lineLength, byte[] lineSeparator) {
+        this(lineLength, lineSeparator, false);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length and line separator are given in the constructor, and the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
+     * <p>
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param lineLength
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of 4).
+     *            If lineLength <= 0, then the output will not be divided into lines (chunks). Ignored when decoding.
+     * @param lineSeparator
+     *            Each line of encoded data will end with this sequence of bytes.
+     * @param urlSafe
+     *            Instead of emitting '+' and '/' we emit '-' and '_' respectively. urlSafe is only applied to encode
+     *            operations. Decoding seamlessly handles both modes.
+     * @throws IllegalArgumentException
+     *             The provided lineSeparator included some base64 characters. That's not going to work!
+     * @since 1.4
+     */
+    public Base64Codec(int lineLength, byte[] lineSeparator, boolean urlSafe) {
+        if (lineSeparator == null) {
+            lineLength = 0;  // disable chunk-separating
+            lineSeparator = CHUNK_SEPARATOR;  // this just gets ignored
+        }
+        this.lineLength = lineLength > 0 ? (lineLength / 4) * 4 : 0;
+        this.lineSeparator = new byte[lineSeparator.length];
+        System.arraycopy(lineSeparator, 0, this.lineSeparator, 0, lineSeparator.length);
+        if (lineLength > 0) {
+            this.encodeSize = 4 + lineSeparator.length;
+        } else {
+            this.encodeSize = 4;
+        }
+        this.decodeSize = this.encodeSize - 1;
+        if (containsBase64Byte(lineSeparator)) {
+            String sep = StringUtils.newStringUtf8(lineSeparator);
+            throw new IllegalArgumentException("lineSeperator must not contain base64 characters: [" + sep + "]");
+        }
+        this.encodeTable = urlSafe ? URL_SAFE_ENCODE_TABLE : STANDARD_ENCODE_TABLE;
+    }
+
+    /**
+     * Returns our current encode mode. True if we're URL-SAFE, false otherwise.
+     *
+     * @return true if we're in URL-SAFE mode, false otherwise.
+     * @since 1.4
+     */
+    public boolean isUrlSafe() {
+        return this.encodeTable == URL_SAFE_ENCODE_TABLE;
+    }
+
+    /**
+     * Returns true if this Base64 object has buffered data for reading.
+     *
+     * @return true if there is Base64 object still available for reading.
+     */
+    boolean hasData() {
+        return this.buffer != null;
+    }
+
+    /**
+     * Returns the amount of buffered data available for reading.
+     *
+     * @return The amount of buffered data available for reading.
+     */
+    int avail() {
+        return buffer != null ? pos - readPos : 0;
+    }
+
+    /** Doubles our buffer. */
+    private void resizeBuffer() {
+        if (buffer == null) {
+            buffer = new byte[DEFAULT_BUFFER_SIZE];
+            pos = 0;
+            readPos = 0;
+        } else {
+            byte[] b = new byte[buffer.length * DEFAULT_BUFFER_RESIZE_FACTOR];
+            System.arraycopy(buffer, 0, b, 0, buffer.length);
+            buffer = b;
+        }
+    }
+
+    /**
+     * Extracts buffered data into the provided byte[] array, starting at position bPos, up to a maximum of bAvail
+     * bytes. Returns how many bytes were actually extracted.
+     *
+     * @param b
+     *            byte[] array to extract the buffered data into.
+     * @param bPos
+     *            position in byte[] array to start extraction at.
+     * @param bAvail
+     *            amount of bytes we're allowed to extract. We may extract fewer (if fewer are available).
+     * @return The number of bytes successfully extracted into the provided byte[] array.
+     */
+    int readResults(byte[] b, int bPos, int bAvail) {
+        if (buffer != null) {
+            int len = Math.min(avail(), bAvail);
+            if (buffer != b) {
+                System.arraycopy(buffer, readPos, b, bPos, len);
+                readPos += len;
+                if (readPos >= pos) {
+                    buffer = null;
+                }
+            } else {
+                // Re-using the original consumer's output array is only
+                // allowed for one round.
+                buffer = null;
+            }
+            return len;
+        }
+        return eof ? -1 : 0;
+    }
+
+    /**
+     * Sets the streaming buffer. This is a small optimization where we try to buffer directly to the consumer's output
+     * array for one round (if the consumer calls this method first) instead of starting our own buffer.
+     *
+     * @param out
+     *            byte[] array to buffer directly to.
+     * @param outPos
+     *            Position to start buffering into.
+     * @param outAvail
+     *            Amount of bytes available for direct buffering.
+     */
+    void setInitialBuffer(byte[] out, int outPos, int outAvail) {
+        // We can re-use consumer's original output array under
+        // special circumstances, saving on some System.arraycopy().
+        if (out != null && out.length == outAvail) {
+            buffer = out;
+            pos = outPos;
+            readPos = outPos;
+        }
+    }
+
+    /**
+     * <p>
+     * Encodes all of the provided data, starting at inPos, for inAvail bytes. Must be called at least twice: once with
+     * the data to encode, and once with inAvail set to "-1" to alert encoder that EOF has been reached, so flush last
+     * remaining bytes (if not multiple of 3).
+     * </p>
+     * <p>
+     * Thanks to "commons" project in ws.apache.org for the bitwise operations, and general approach.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     * </p>
+     *
+     * @param in
+     *            byte[] array of binary data to base64 encode.
+     * @param inPos
+     *            Position to start reading data from.
+     * @param inAvail
+     *            Amount of bytes available from input for encoding.
+     */
+    void encode(byte[] in, int inPos, int inAvail) {
+        if (eof) {
+            return;
+        }
+        // inAvail < 0 is how we're informed of EOF in the underlying data we're
+        // encoding.
+        if (inAvail < 0) {
+            eof = true;
+            if (buffer == null || buffer.length - pos < encodeSize) {
+                resizeBuffer();
+            }
+            switch (modulus) {
+                case 1 :
+                    buffer[pos++] = encodeTable[(x >> 2) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x << 4) & MASK_6BITS];
+                    // URL-SAFE skips the padding to further reduce size.
+                    if (encodeTable == STANDARD_ENCODE_TABLE) {
+                        buffer[pos++] = PAD;
+                        buffer[pos++] = PAD;
+                    }
+                    break;
+
+                case 2 :
+                    buffer[pos++] = encodeTable[(x >> 10) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x >> 4) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x << 2) & MASK_6BITS];
+                    // URL-SAFE skips the padding to further reduce size.
+                    if (encodeTable == STANDARD_ENCODE_TABLE) {
+                        buffer[pos++] = PAD;
+                    }
+                    break;
+            }
+            if (lineLength > 0 && pos > 0) {
+                System.arraycopy(lineSeparator, 0, buffer, pos, lineSeparator.length);
+                pos += lineSeparator.length;
+            }
+        } else {
+            for (int i = 0; i < inAvail; i++) {
+                if (buffer == null || buffer.length - pos < encodeSize) {
+                    resizeBuffer();
+                }
+                modulus = (++modulus) % 3;
+                int b = in[inPos++];
+                if (b < 0) {
+                    b += 256;
+                }
+                x = (x << 8) + b;
+                if (0 == modulus) {
+                    buffer[pos++] = encodeTable[(x >> 18) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x >> 12) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x >> 6) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[x & MASK_6BITS];
+                    currentLinePos += 4;
+                    if (lineLength > 0 && lineLength <= currentLinePos) {
+                        System.arraycopy(lineSeparator, 0, buffer, pos, lineSeparator.length);
+                        pos += lineSeparator.length;
+                        currentLinePos = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * <p>
+     * Decodes all of the provided data, starting at inPos, for inAvail bytes. Should be called at least twice: once
+     * with the data to decode, and once with inAvail set to "-1" to alert decoder that EOF has been reached. The "-1"
+     * call is not necessary when decoding, but it doesn't hurt, either.
+     * </p>
+     * <p>
+     * Ignores all non-base64 characters. This is how chunked (e.g. 76 character) data is handled, since CR and LF are
+     * silently ignored, but has implications for other bytes, too. This method subscribes to the garbage-in,
+     * garbage-out philosophy: it will not check the provided data for validity.
+     * </p>
+     * <p>
+     * Thanks to "commons" project in ws.apache.org for the bitwise operations, and general approach.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     * </p>
+     *
+     * @param in
+     *            byte[] array of ascii data to base64 decode.
+     * @param inPos
+     *            Position to start reading data from.
+     * @param inAvail
+     *            Amount of bytes available from input for encoding.
+     */
+    void decode(byte[] in, int inPos, int inAvail) {
+        if (eof) {
+            return;
+        }
+        if (inAvail < 0) {
+            eof = true;
+        }
+        for (int i = 0; i < inAvail; i++) {
+            if (buffer == null || buffer.length - pos < decodeSize) {
+                resizeBuffer();
+            }
+            byte b = in[inPos++];
+            if (b == PAD) {
+                // We're done.
+                eof = true;
+                break;
+            } else {
+                if (b >= 0 && b < DECODE_TABLE.length) {
+                    int result = DECODE_TABLE[b];
+                    if (result >= 0) {
+                        modulus = (++modulus) % 4;
+                        x = (x << 6) + result;
+                        if (modulus == 0) {
+                            buffer[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+                            buffer[pos++] = (byte) ((x >> 8) & MASK_8BITS);
+                            buffer[pos++] = (byte) (x & MASK_8BITS);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Two forms of EOF as far as base64 decoder is concerned: actual
+        // EOF (-1) and first time '=' character is encountered in stream.
+        // This approach makes the '=' padding characters completely optional.
+        if (eof && modulus != 0) {
+            x = x << 6;
+            switch (modulus) {
+                case 2 :
+                    x = x << 6;
+                    buffer[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+                    break;
+                case 3 :
+                    buffer[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+                    buffer[pos++] = (byte) ((x >> 8) & MASK_8BITS);
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Returns whether or not the <code>octet</code> is in the base 64 alphabet.
+     *
+     * @param octet
+     *            The value to test
+     * @return <code>true</code> if the value is defined in the the base 64 alphabet, <code>false</code> otherwise.
+     * @since 1.4
+     */
+    public static boolean isBase64(byte octet) {
+        return octet == PAD || (octet >= 0 && octet < DECODE_TABLE.length && DECODE_TABLE[octet] != -1);
+    }
+
+    /**
+     * Tests a given byte array to see if it contains only valid characters within the Base64 alphabet. Currently the
+     * method treats whitespace as valid.
+     *
+     * @param arrayOctet
+     *            byte array to test
+     * @return <code>true</code> if all bytes are valid characters in the Base64 alphabet or if the byte array is empty;
+     *         false, otherwise
+     */
+    public static boolean isArrayByteBase64(byte[] arrayOctet) {
+        for (int i = 0; i < arrayOctet.length; i++) {
+            if (!isBase64(arrayOctet[i]) && !isWhiteSpace(arrayOctet[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Tests a given byte array to see if it contains only valid characters within the Base64 alphabet.
+     *
+     * @param arrayOctet
+     *            byte array to test
+     * @return <code>true</code> if any byte is a valid character in the Base64 alphabet; false herwise
+     */
+    private static boolean containsBase64Byte(byte[] arrayOctet) {
+        for (int i = 0; i < arrayOctet.length; i++) {
+            if (isBase64(arrayOctet[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm but does not chunk the output.
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return byte[] containing Base64 characters in their UTF-8 representation.
+     */
+    public static byte[] encodeBase64(byte[] binaryData) {
+        return encodeBase64(binaryData, false);
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm into 76 character blocks separated by CRLF.
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return String containing Base64 characters.
+     * @since 1.4
+     */
+    public static String encodeBase64String(byte[] binaryData) {
+        return StringUtils.newStringUtf8(encodeBase64(binaryData, true));
+    }
+
+    /**
+     * Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The
+     * url-safe variation emits - and _ instead of + and / characters.
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return byte[] containing Base64 characters in their UTF-8 representation.
+     * @since 1.4
+     */
+    public static byte[] encodeBase64URLSafe(byte[] binaryData) {
+        return encodeBase64(binaryData, false, true);
+    }
+
+    /**
+     * Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The
+     * url-safe variation emits - and _ instead of + and / characters.
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return String containing Base64 characters
+     * @since 1.4
+     */
+    public static String encodeBase64URLSafeString(byte[] binaryData) {
+        return StringUtils.newStringUtf8(encodeBase64(binaryData, false, true));
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm and chunks the encoded output into 76 character blocks
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return Base64 characters chunked in 76 character blocks
+     */
+    public static byte[] encodeBase64Chunked(byte[] binaryData) {
+        return encodeBase64(binaryData, true);
+    }
+
+    /**
+     * Decodes an Object using the base64 algorithm. This method is provided in order to satisfy the requirements of the
+     * Decoder interface, and will throw a DecoderException if the supplied object is not of type byte[] or String.
+     *
+     * @param pObject
+     *            Object to decode
+     * @return An object (of type byte[]) containing the binary data which corresponds to the byte[] or String supplied.
+     * @throws DecoderException
+     *             if the parameter supplied is not of type byte[]
+     */
+    public Object decode(Object pObject) throws DecoderException {
+        if (pObject instanceof byte[]) {
+            return decode((byte[]) pObject);
+        } else if (pObject instanceof String) {
+            return decode((String) pObject);
+        } else {
+            throw new DecoderException("Parameter supplied to Base64 decode is not a byte[] or a String");
+        }
+    }
+
+    /**
+     * Decodes a String containing containing characters in the Base64 alphabet.
+     *
+     * @param pArray
+     *            A String containing Base64 character data
+     * @return a byte array containing binary data
+     * @since 1.4
+     */
+    public byte[] decode(String pArray) {
+        return decode(StringUtils.getBytesUtf8(pArray));
+    }
+
+    /**
+     * Decodes a byte[] containing containing characters in the Base64 alphabet.
+     *
+     * @param pArray
+     *            A byte array containing Base64 character data
+     * @return a byte array containing binary data
+     */
+    public byte[] decode(byte[] pArray) {
+        reset();
+        if (pArray == null || pArray.length == 0) {
+            return pArray;
+        }
+        long len = (pArray.length * 3) / 4;
+        byte[] buf = new byte[(int) len];
+        setInitialBuffer(buf, 0, buf.length);
+        decode(pArray, 0, pArray.length);
+        decode(pArray, 0, -1); // Notify decoder of EOF.
+
+        // Would be nice to just return buf (like we sometimes do in the encode
+        // logic), but we have no idea what the line-length was (could even be
+        // variable).  So we cannot determine ahead of time exactly how big an
+        // array is necessary.  Hence the need to construct a 2nd byte array to
+        // hold the final result:
+
+        byte[] result = new byte[pos];
+        readResults(result, 0, result.length);
+        return result;
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
+     *
+     * @param binaryData
+     *            Array containing binary data to encode.
+     * @param isChunked
+     *            if <code>true</code> this encoder will chunk the base64 output into 76 character blocks
+     * @return Base64-encoded data.
+     * @throws IllegalArgumentException
+     *             Thrown when the input array needs an output array bigger than {@link Integer#MAX_VALUE}
+     */
+    public static byte[] encodeBase64(byte[] binaryData, boolean isChunked) {
+        return encodeBase64(binaryData, isChunked, false);
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
+     *
+     * @param binaryData
+     *            Array containing binary data to encode.
+     * @param isChunked
+     *            if <code>true</code> this encoder will chunk the base64 output into 76 character blocks
+     * @param urlSafe
+     *            if <code>true</code> this encoder will emit - and _ instead of the usual + and / characters.
+     * @return Base64-encoded data.
+     * @throws IllegalArgumentException
+     *             Thrown when the input array needs an output array bigger than {@link Integer#MAX_VALUE}
+     * @since 1.4
+     */
+    public static byte[] encodeBase64(byte[] binaryData, boolean isChunked, boolean urlSafe) {
+        return encodeBase64(binaryData, isChunked, urlSafe, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
+     *
+     * @param binaryData
+     *            Array containing binary data to encode.
+     * @param isChunked
+     *            if <code>true</code> this encoder will chunk the base64 output into 76 character blocks
+     * @param urlSafe
+     *            if <code>true</code> this encoder will emit - and _ instead of the usual + and / characters.
+     * @param maxResultSize
+     *            The maximum result size to accept.
+     * @return Base64-encoded data.
+     * @throws IllegalArgumentException
+     *             Thrown when the input array needs an output array bigger than maxResultSize
+     * @since 1.4
+     */
+    public static byte[] encodeBase64(byte[] binaryData, boolean isChunked, boolean urlSafe, int maxResultSize) {
+        if (binaryData == null || binaryData.length == 0) {
+            return binaryData;
+        }
+
+        long len = getEncodeLength(binaryData, CHUNK_SIZE, CHUNK_SEPARATOR);
+        if (len > maxResultSize) {
+            throw new IllegalArgumentException("Input array too big, the output array would be bigger (" +
+                len +
+                ") than the specified maxium size of " +
+                maxResultSize);
+        }
+
+        Base64Codec b64 = isChunked ? new Base64Codec(urlSafe) : new Base64Codec(0, CHUNK_SEPARATOR, urlSafe);
+        return b64.encode(binaryData);
+    }
+
+    /**
+     * Decodes a Base64 String into octets
+     *
+     * @param base64String
+     *            String containing Base64 data
+     * @return Array containing decoded data.
+     * @since 1.4
+     */
+    public static byte[] decodeBase64(String base64String) {
+        return new Base64Codec().decode(base64String);
+    }
+
+    /**
+     * Decodes Base64 data into octets
+     *
+     * @param base64Data
+     *            Byte array containing Base64 data
+     * @return Array containing decoded data.
+     */
+    public static byte[] decodeBase64(byte[] base64Data) {
+        return new Base64Codec().decode(base64Data);
+    }
+
+    /**
+     * Discards any whitespace from a base-64 encoded block.
+     *
+     * @param data
+     *            The base-64 encoded data to discard the whitespace from.
+     * @return The data, less whitespace (see RFC 2045).
+     * @deprecated This method is no longer needed
+     */
+    static byte[] discardWhitespace(byte[] data) {
+        byte groomedData[] = new byte[data.length];
+        int bytesCopied = 0;
+        for (int i = 0; i < data.length; i++) {
+            switch (data[i]) {
+                case ' ' :
+                case '\n' :
+                case '\r' :
+                case '\t' :
+                    break;
+                default :
+                    groomedData[bytesCopied++] = data[i];
+            }
+        }
+        byte packedData[] = new byte[bytesCopied];
+        System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
+        return packedData;
+    }
+
+    /**
+     * Checks if a byte value is whitespace or not.
+     *
+     * @param byteToCheck
+     *            the byte to check
+     * @return true if byte is whitespace, false otherwise
+     */
+    private static boolean isWhiteSpace(byte byteToCheck) {
+        switch (byteToCheck) {
+            case ' ' :
+            case '\n' :
+            case '\r' :
+            case '\t' :
+                return true;
+            default :
+                return false;
+        }
+    }
+
+    // Implementation of the Encoder Interface
+
+    /**
+     * Encodes an Object using the base64 algorithm. This method is provided in order to satisfy the requirements of the
+     * Encoder interface, and will throw an EncoderException if the supplied object is not of type byte[].
+     *
+     * @param pObject
+     *            Object to encode
+     * @return An object (of type byte[]) containing the base64 encoded data which corresponds to the byte[] supplied.
+     * @throws EncoderException
+     *             if the parameter supplied is not of type byte[]
+     */
+    public Object encode(Object pObject) throws EncoderException {
+        if (!(pObject instanceof byte[])) {
+            throw new EncoderException("Parameter supplied to Base64 encode is not a byte[]");
+        }
+        return encode((byte[]) pObject);
+    }
+
+    /**
+     * Encodes a byte[] containing binary data, into a String containing characters in the Base64 alphabet.
+     *
+     * @param pArray
+     *            a byte array containing binary data
+     * @return A String containing only Base64 character data
+     * @since 1.4
+     */
+    public String encodeToString(byte[] pArray) {
+        return StringUtils.newStringUtf8(encode(pArray));
+    }
+
+    /**
+     * Encodes a byte[] containing binary data, into a byte[] containing characters in the Base64 alphabet.
+     *
+     * @param pArray
+     *            a byte array containing binary data
+     * @return A byte array containing only Base64 character data
+     */
+    public byte[] encode(byte[] pArray) {
+        reset();
+        if (pArray == null || pArray.length == 0) {
+            return pArray;
+        }
+        long len = getEncodeLength(pArray, lineLength, lineSeparator);
+        byte[] buf = new byte[(int) len];
+        setInitialBuffer(buf, 0, buf.length);
+        encode(pArray, 0, pArray.length);
+        encode(pArray, 0, -1); // Notify encoder of EOF.
+        // Encoder might have resized, even though it was unnecessary.
+        if (buffer != buf) {
+            readResults(buf, 0, buf.length);
+        }
+        // In URL-SAFE mode we skip the padding characters, so sometimes our
+        // final length is a bit smaller.
+        if (isUrlSafe() && pos < buf.length) {
+            byte[] smallerBuf = new byte[pos];
+            System.arraycopy(buf, 0, smallerBuf, 0, pos);
+            buf = smallerBuf;
+        }
+        return buf;
+    }
+
+    /**
+     * Pre-calculates the amount of space needed to base64-encode the supplied array.
+     *
+     * @param pArray byte[] array which will later be encoded
+     * @param chunkSize line-length of the output (<= 0 means no chunking) between each
+     *        chunkSeparator (e.g. CRLF).
+     * @param chunkSeparator the sequence of bytes used to separate chunks of output (e.g. CRLF).
+     *
+     * @return amount of space needed to encoded the supplied array.  Returns
+     *         a long since a max-len array will require Integer.MAX_VALUE + 33%.
+     */
+    private static long getEncodeLength(byte[] pArray, int chunkSize, byte[] chunkSeparator) {
+        // base64 always encodes to multiples of 4.
+        chunkSize = (chunkSize / 4) * 4;
+
+        long len = (pArray.length * 4) / 3;
+        long mod = len % 4;
+        if (mod != 0) {
+            len += 4 - mod;
+        }
+        if (chunkSize > 0) {
+            boolean lenChunksPerfectly = len % chunkSize == 0;
+            len += (len / chunkSize) * chunkSeparator.length;
+            if (!lenChunksPerfectly) {
+                len += chunkSeparator.length;
+            }
+        }
+        return len;
+    }
+
+    // Implementation of integer encoding used for crypto
+    /**
+     * Decodes a byte64-encoded integer according to crypto standards such as W3C's XML-Signature
+     *
+     * @param pArray
+     *            a byte array containing base64 character data
+     * @return A BigInteger
+     * @since 1.4
+     */
+    public static BigInteger decodeInteger(byte[] pArray) {
+        return new BigInteger(1, decodeBase64(pArray));
+    }
+
+    /**
+     * Encodes to a byte64-encoded integer according to crypto standards such as W3C's XML-Signature
+     *
+     * @param bigInt
+     *            a BigInteger
+     * @return A byte array containing base64 character data
+     * @throws NullPointerException
+     *             if null is passed in
+     * @since 1.4
+     */
+    public static byte[] encodeInteger(BigInteger bigInt) {
+        if (bigInt == null) {
+            throw new NullPointerException("encodeInteger called with null parameter");
+        }
+        return encodeBase64(toIntegerBytes(bigInt), false);
+    }
+
+    /**
+     * Returns a byte-array representation of a <code>BigInteger</code> without sign bit.
+     *
+     * @param bigInt
+     *            <code>BigInteger</code> to be converted
+     * @return a byte array representation of the BigInteger parameter
+     */
+    static byte[] toIntegerBytes(BigInteger bigInt) {
+        int bitlen = bigInt.bitLength();
+        // round bitlen
+        bitlen = ((bitlen + 7) >> 3) << 3;
+        byte[] bigBytes = bigInt.toByteArray();
+
+        if (((bigInt.bitLength() % 8) != 0) && (((bigInt.bitLength() / 8) + 1) == (bitlen / 8))) {
+            return bigBytes;
+        }
+        // set up params for copying everything but sign bit
+        int startSrc = 0;
+        int len = bigBytes.length;
+
+        // if bigInt is exactly byte-aligned, just skip signbit in copy
+        if ((bigInt.bitLength() % 8) == 0) {
+            startSrc = 1;
+            len--;
+        }
+        int startDst = bitlen / 8 - len; // to pad w/ nulls as per spec
+        byte[] resizedBytes = new byte[bitlen / 8];
+        System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
+        return resizedBytes;
+    }
+
+    /**
+     * Resets this Base64 object to its initial newly constructed state.
+     */
+    private void reset() {
+        buffer = null;
+        pos = 0;
+        readPos = 0;
+        currentLinePos = 0;
+        modulus = 0;
+        eof = false;
+    }
+
+}
diff --git a/Common/src/org/apache/commons/codec/binary/StringUtils.java b/Common/src/org/apache/commons/codec/binary/StringUtils.java
new file mode 100644
index 0000000..e3af657
--- /dev/null
+++ b/Common/src/org/apache/commons/codec/binary/StringUtils.java
@@ -0,0 +1,279 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.commons.codec.binary;
+
+import java.io.UnsupportedEncodingException;
+
+import org.apache.commons.codec.CharEncoding;
+
+/**
+ * Converts String to and from bytes using the encodings required by the Java specification. These encodings are specified in <a
+ * href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+ *
+ * @see CharEncoding
+ * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+ * @author <a href="mailto:ggregory@seagullsw.com">Gary Gregory</a>
+ * @version $Id: StringUtils.java 801391 2009-08-05 19:55:54Z ggregory $
+ * @since 1.4
+ */
+public class StringUtils {
+
+    /**
+     * Encodes the given string into a sequence of bytes using the ISO-8859-1 charset, storing the result into a new
+     * byte array.
+     *
+     * @param string
+     *            the String to encode
+     * @return encoded bytes
+     * @throws IllegalStateException
+     *             Thrown when the charset is missing, which should be never according the the Java specification.
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     * @see #getBytesUnchecked(String, String)
+     */
+    public static byte[] getBytesIso8859_1(String string) {
+        return StringUtils.getBytesUnchecked(string, CharEncoding.ISO_8859_1);
+    }
+
+    /**
+     * Encodes the given string into a sequence of bytes using the US-ASCII charset, storing the result into a new byte
+     * array.
+     *
+     * @param string
+     *            the String to encode
+     * @return encoded bytes
+     * @throws IllegalStateException
+     *             Thrown when the charset is missing, which should be never according the the Java specification.
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     * @see #getBytesUnchecked(String, String)
+     */
+    public static byte[] getBytesUsAscii(String string) {
+        return StringUtils.getBytesUnchecked(string, CharEncoding.US_ASCII);
+    }
+
+    /**
+     * Encodes the given string into a sequence of bytes using the UTF-16 charset, storing the result into a new byte
+     * array.
+     *
+     * @param string
+     *            the String to encode
+     * @return encoded bytes
+     * @throws IllegalStateException
+     *             Thrown when the charset is missing, which should be never according the the Java specification.
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     * @see #getBytesUnchecked(String, String)
+     */
+    public static byte[] getBytesUtf16(String string) {
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_16);
+    }
+
+    /**
+     * Encodes the given string into a sequence of bytes using the UTF-16BE charset, storing the result into a new byte
+     * array.
+     *
+     * @param string
+     *            the String to encode
+     * @return encoded bytes
+     * @throws IllegalStateException
+     *             Thrown when the charset is missing, which should be never according the the Java specification.
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     * @see #getBytesUnchecked(String, String)
+     */
+    public static byte[] getBytesUtf16Be(String string) {
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_16BE);
+    }
+
+    /**
+     * Encodes the given string into a sequence of bytes using the UTF-16LE charset, storing the result into a new byte
+     * array.
+     *
+     * @param string
+     *            the String to encode
+     * @return encoded bytes
+     * @throws IllegalStateException
+     *             Thrown when the charset is missing, which should be never according the the Java specification.
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     * @see #getBytesUnchecked(String, String)
+     */
+    public static byte[] getBytesUtf16Le(String string) {
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_16LE);
+    }
+
+    /**
+     * Encodes the given string into a sequence of bytes using the UTF-8 charset, storing the result into a new byte
+     * array.
+     *
+     * @param string
+     *            the String to encode
+     * @return encoded bytes
+     * @throws IllegalStateException
+     *             Thrown when the charset is missing, which should be never according the the Java specification.
+     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     * @see #getBytesUnchecked(String, String)
+     */
+    public static byte[] getBytesUtf8(String string) {
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_8);
+    }
+
+    /**
+     * Encodes the given string into a sequence of bytes using the named charset, storing the result into a new byte
+     * array.
+     * <p>
+     * This method catches {@link UnsupportedEncodingException} and rethrows it as {@link IllegalStateException}, which
+     * should never happen for a required charset name. Use this method when the encoding is required to be in the JRE.
+     * </p>
+     *
+     * @param string
+     *            the String to encode
+     * @param charsetName
+     *            The name of a required {@link java.nio.charset.Charset}
+     * @return encoded bytes
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen for a
+     *             required charset name.
+     * @see CharEncoding
+     * @see String#getBytes(String)
+     */
+    public static byte[] getBytesUnchecked(String string, String charsetName) {
+        if (string == null) {
+            return null;
+        }
+        try {
+            return string.getBytes(charsetName);
+        } catch (UnsupportedEncodingException e) {
+            throw StringUtils.newIllegalStateException(charsetName, e);
+        }
+    }
+
+    private static IllegalStateException newIllegalStateException(String charsetName, UnsupportedEncodingException e) {
+        return new IllegalStateException(charsetName + ": " + e);
+    }
+
+    /**
+     * Constructs a new <code>String</code> by decoding the specified array of bytes using the given charset.
+     * <p>
+     * This method catches {@link UnsupportedEncodingException} and re-throws it as {@link IllegalStateException}, which
+     * should never happen for a required charset name. Use this method when the encoding is required to be in the JRE.
+     * </p>
+     *
+     * @param bytes
+     *            The bytes to be decoded into characters
+     * @param charsetName
+     *            The name of a required {@link java.nio.charset.Charset}
+     * @return A new <code>String</code> decoded from the specified array of bytes using the given charset.
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen for a
+     *             required charset name.
+     * @see CharEncoding
+     * @see String#String(byte[], String)
+     */
+    public static String newString(byte[] bytes, String charsetName) {
+        if (bytes == null) {
+            return null;
+        }
+        try {
+            return new String(bytes, charsetName);
+        } catch (UnsupportedEncodingException e) {
+            throw StringUtils.newIllegalStateException(charsetName, e);
+        }
+    }
+
+    /**
+     * Constructs a new <code>String</code> by decoding the specified array of bytes using the ISO-8859-1 charset.
+     *
+     * @param bytes
+     *            The bytes to be decoded into characters
+     * @return A new <code>String</code> decoded from the specified array of bytes using the given charset.
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen since the
+     *             charset is required.
+     */
+    public static String newStringIso8859_1(byte[] bytes) {
+        return StringUtils.newString(bytes, CharEncoding.ISO_8859_1);
+    }
+
+    /**
+     * Constructs a new <code>String</code> by decoding the specified array of bytes using the US-ASCII charset.
+     *
+     * @param bytes
+     *            The bytes to be decoded into characters
+     * @return A new <code>String</code> decoded from the specified array of bytes using the given charset.
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen since the
+     *             charset is required.
+     */
+    public static String newStringUsAscii(byte[] bytes) {
+        return StringUtils.newString(bytes, CharEncoding.US_ASCII);
+    }
+
+    /**
+     * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-16 charset.
+     *
+     * @param bytes
+     *            The bytes to be decoded into characters
+     * @return A new <code>String</code> decoded from the specified array of bytes using the given charset.
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen since the
+     *             charset is required.
+     */
+    public static String newStringUtf16(byte[] bytes) {
+        return StringUtils.newString(bytes, CharEncoding.UTF_16);
+    }
+
+    /**
+     * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-16BE charset.
+     *
+     * @param bytes
+     *            The bytes to be decoded into characters
+     * @return A new <code>String</code> decoded from the specified array of bytes using the given charset.
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen since the
+     *             charset is required.
+     */
+    public static String newStringUtf16Be(byte[] bytes) {
+        return StringUtils.newString(bytes, CharEncoding.UTF_16BE);
+    }
+
+    /**
+     * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-16LE charset.
+     *
+     * @param bytes
+     *            The bytes to be decoded into characters
+     * @return A new <code>String</code> decoded from the specified array of bytes using the given charset.
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen since the
+     *             charset is required.
+     */
+    public static String newStringUtf16Le(byte[] bytes) {
+        return StringUtils.newString(bytes, CharEncoding.UTF_16LE);
+    }
+
+    /**
+     * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-8 charset.
+     *
+     * @param bytes
+     *            The bytes to be decoded into characters
+     * @return A new <code>String</code> decoded from the specified array of bytes using the given charset.
+     * @throws IllegalStateException
+     *             Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen since the
+     *             charset is required.
+     */
+    public static String newStringUtf8(byte[] bytes) {
+        return StringUtils.newString(bytes, CharEncoding.UTF_8);
+    }
+
+}
diff --git a/Docs/generate_api_reference_md.pl b/Docs/generate_api_reference_md.pl
new file mode 100755
index 0000000..546fe28
--- /dev/null
+++ b/Docs/generate_api_reference_md.pl
@@ -0,0 +1,163 @@
+#!/usr/bin/perl
+#
+#  Copyright (C) 2015 Google, Inc.
+#
+#  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.
+#
+
+use strict;
+use warnings;
+use Cwd 'abs_path';
+use JSON;
+use File::Find;
+
+my $sl4a_path = $ARGV[0];
+my $md = "";
+my $md_end = "";
+
+if (not defined $sl4a_path) {
+    $sl4a_path = abs_path($0);
+    $sl4a_path =~ s/\/Docs\/generate_api_reference_md\.pl//g;
+}
+
+sub eachFile {
+    my $filename = $_;
+    my $fullpath = $File::Find::name;
+    if (-e $filename && $filename =~ m/Facade\.java/) {
+        open(FILE, $filename);
+        my @lines = <FILE>;
+        close(FILE);
+
+        my $title = $filename;
+        $title =~ s/\.java//;
+        $title = '**' . $title . '**' . "\n";
+        $md = $md . "\n$title";
+        my $description = "";
+        for (my $i = 0; $i < scalar(@lines); $i++) {
+            my $line = $lines[$i];
+            $line =~ s/\n//;
+            $line =~ s/^\s+|\s+$//g;
+
+            if ($line =~ m /^\@Rpc\(description/) {
+                $description = "";
+                for (my $j = $i; $j < scalar(@lines); $j++) {
+                    my $l = $lines[$j];
+                    $l =~ s/^\s+|\s+$//g;
+                    $description = $description . $l;
+                    if ($l =~ m/\)$/) {
+                        $i = $j;
+                        last;
+                    }
+                }
+                $description = _format_description($description);
+
+            }
+            if ($line =~ m /^public/ && $description ne "") {
+                my @words = split(/\s/, $line);
+                my $func_name = $words[2];
+                my $func_names_and_params = "";
+                if ($func_name =~ /void/) {
+                    $func_name = $words[3];
+                    if ($func_name =~ /void/) {
+                        $description = "";
+                        $func_names_and_params = "";
+                        next;
+                    }
+                }
+                if ($func_name =~ /\(/) {
+                    $func_name =~ s/\(.*//;
+                }
+                $func_name =~ s/\(//g;
+                $func_name =~ s/\)//g;
+                for (my $j = $i; $j < scalar(@lines); $j++) {
+                    $func_names_and_params = $func_names_and_params . $lines[$j];
+                    if ($lines[$j] =~ m/{$/) {
+                        last;
+                    }
+                }
+                $func_names_and_params = _format_func_names_and_params($func_names_and_params);
+                if ($func_names_and_params eq "") {
+                    $func_names_and_params = ")\n";
+                } else {
+                    $func_names_and_params = "\n" . $func_names_and_params;
+                }
+                $md_end = $md_end . "# $func_name\n```\n" .
+                    "$func_name(" . $func_names_and_params . "\n$description\n```\n\n" ;
+                $description = "";
+                $func_names_and_params = "";
+                my $lc_name = lc $func_name;
+                $md = $md . "  * [$func_name](\#$lc_name)\n";
+            }
+        }
+
+    }
+}
+
+sub _format_func_names_and_params {
+    my $fn = shift;
+    $fn =~ s/^\s+|\s+$//g;
+    my @words = split(/\n/,$fn);
+    my $format = "";
+    my $description = "";
+    my $name = "";
+    my $params = "";
+    for my $w (@words) {
+        if ($w =~ /\@RpcParameter\(name = "(.+?)", description = "(.+?)"/) {
+           $name = $1;
+           $description = $2;
+        }
+        elsif ($w =~ /\@RpcParameter\(name = "(.+?)"/) {
+           $name = $1;
+        }
+        if ($w =~ m/,$/) {
+            my @split = split(/\s/, $w);
+            $params = "$split[$#split-1] $split[$#split]";
+            if ($description eq "") {
+                $format = $params;
+            } elsif ($description ne "") {
+                $params =~ s/,//;
+                $format = $format . "  $params: $description,\n"
+            }
+            $description = "";
+            $name = "";
+            $params = "";
+        }
+    }
+    $format =~ s/,$/)/;
+    return $format;
+}
+
+sub _format_description {
+    my $description = shift;
+    $description =~ s/\@Rpc\(//;
+    $description =~ s/^\s+|\s+$//g;
+    $description =~ s/\n//g;
+    $description =~ s/description = \"//g;
+    $description =~ s/\"\)//g;
+    if ($description =~ m/returns(\s*)=/) {
+        $description =~ s/\",//;
+        my @words = split(/returns(\s*)=/, $description);
+        my $des = $words[0];
+        my $ret = $words[1];
+        $ret =~ s/^\s+|\s+$//g;
+        $ret =~ s/^"//;
+        $description = $des . "\n\n" . "Returns:\n" . "  $ret";
+    }
+    return $description;
+}
+
+find (\&eachFile, $sl4a_path);
+open(FILE, ">$sl4a_path/Docs/ApiReference.md");
+print FILE $md . "\n";
+print FILE $md_end . "\n";
+close(FILE);
diff --git a/InterpreterForAndroid/Android.mk b/InterpreterForAndroid/Android.mk
new file mode 100644
index 0000000..7f222f6
--- /dev/null
+++ b/InterpreterForAndroid/Android.mk
@@ -0,0 +1,28 @@
+#
+#  Copyright (C) 2016 Google, Inc.
+#
+#  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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+
+LOCAL_MODULE := sl4a.InterpreterForAndroid
+LOCAL_MODULE_OWNER := google
+LOCAL_STATIC_JAVA_LIBRARIES := guava android-common sl4a.Utils
+#LOCAL_STATIC_JAVA_LIBRARIES += android-support-v4
+LOCAL_SRC_FILES := $(call all-java-files-under, src/com/googlecode/android_scripting)
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/AsyncTaskListener.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/AsyncTaskListener.java
new file mode 100644
index 0000000..38bb34b
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/AsyncTaskListener.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+/**
+ * This listener asynchronously receives a task result whenever it finishes. Should be implemented
+ * to avoid blocking on task's get() method.
+ *
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public interface AsyncTaskListener<T> {
+  public void onTaskFinished(T result, String message);
+}
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/InterpreterInstaller.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/InterpreterInstaller.java
new file mode 100644
index 0000000..53a1d6c
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/InterpreterInstaller.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.Looper;
+import android.preference.PreferenceManager;
+
+import com.googlecode.android_scripting.exception.Sl4aException;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+import com.googlecode.android_scripting.interpreter.InterpreterDescriptor;
+import com.googlecode.android_scripting.interpreter.InterpreterUtils;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * AsyncTask for installing interpreters.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public abstract class InterpreterInstaller extends AsyncTask<Void, Void, Boolean> {
+
+  protected final InterpreterDescriptor mDescriptor;
+  protected final AsyncTaskListener<Boolean> mTaskListener;
+  protected final Queue<RequestCode> mTaskQueue;
+  protected final Context mContext;
+
+  protected final Handler mainThreadHandler;
+  protected Handler mBackgroundHandler;
+
+  protected volatile AsyncTask<Void, Integer, Long> mTaskHolder;
+
+  protected final String mInterpreterRoot;
+
+  protected static enum RequestCode {
+    DOWNLOAD_INTERPRETER, DOWNLOAD_INTERPRETER_EXTRAS, DOWNLOAD_SCRIPTS, EXTRACT_INTERPRETER,
+    EXTRACT_INTERPRETER_EXTRAS, EXTRACT_SCRIPTS
+  }
+
+  // Executed in the UI thread.
+  private final Runnable mTaskStarter = new Runnable() {
+    @Override
+    public void run() {
+      RequestCode task = mTaskQueue.peek();
+      try {
+        AsyncTask<Void, Integer, Long> newTask = null;
+        switch (task) {
+        case DOWNLOAD_INTERPRETER:
+          newTask = downloadInterpreter();
+          break;
+        case DOWNLOAD_INTERPRETER_EXTRAS:
+          newTask = downloadInterpreterExtras();
+          break;
+        case DOWNLOAD_SCRIPTS:
+          newTask = downloadScripts();
+          break;
+        case EXTRACT_INTERPRETER:
+          newTask = extractInterpreter();
+          break;
+        case EXTRACT_INTERPRETER_EXTRAS:
+          newTask = extractInterpreterExtras();
+          break;
+        case EXTRACT_SCRIPTS:
+          newTask = extractScripts();
+          break;
+        }
+        mTaskHolder = newTask.execute();
+      } catch (Exception e) {
+        Log.v(e.getMessage(), e);
+      }
+
+      if (mBackgroundHandler != null) {
+        mBackgroundHandler.post(mTaskWorker);
+      }
+    }
+  };
+
+  // Executed in the background.
+  private final Runnable mTaskWorker = new Runnable() {
+    @Override
+    public void run() {
+      RequestCode request = mTaskQueue.peek();
+      try {
+        if (mTaskHolder != null && mTaskHolder.get() != null) {
+          mTaskQueue.remove();
+          mTaskHolder = null;
+          // Post processing.
+          if (request == RequestCode.EXTRACT_INTERPRETER && !chmodIntepreter()) {
+            // Chmod returned false.
+            Looper.myLooper().quit();
+          } else if (mTaskQueue.size() == 0) {
+            // We're done here.
+            Looper.myLooper().quit();
+            return;
+          } else if (mainThreadHandler != null) {
+            // There's still some work to do.
+            mainThreadHandler.post(mTaskStarter);
+            return;
+          }
+        }
+      } catch (Exception e) {
+        Log.e(e);
+      }
+      // Something went wrong...
+      switch (request) {
+      case DOWNLOAD_INTERPRETER:
+        Log.e("Downloading interpreter failed.");
+        break;
+      case DOWNLOAD_INTERPRETER_EXTRAS:
+        Log.e("Downloading interpreter extras failed.");
+        break;
+      case DOWNLOAD_SCRIPTS:
+        Log.e("Downloading scripts failed.");
+        break;
+      case EXTRACT_INTERPRETER:
+        Log.e("Extracting interpreter failed.");
+        break;
+      case EXTRACT_INTERPRETER_EXTRAS:
+        Log.e("Extracting interpreter extras failed.");
+        break;
+      case EXTRACT_SCRIPTS:
+        Log.e("Extracting scripts failed.");
+        break;
+      }
+      Looper.myLooper().quit();
+    }
+  };
+
+  // TODO(Alexey): Add Javadoc.
+  public InterpreterInstaller(InterpreterDescriptor descriptor, Context context,
+      AsyncTaskListener<Boolean> taskListener) throws Sl4aException {
+    super();
+    mDescriptor = descriptor;
+    mContext = context;
+    mTaskListener = taskListener;
+    mainThreadHandler = new Handler();
+    mTaskQueue = new LinkedList<RequestCode>();
+
+    String packageName = mDescriptor.getClass().getPackage().getName();
+
+    if (packageName.length() == 0) {
+      throw new Sl4aException("Interpreter package name is empty.");
+    }
+
+    mInterpreterRoot = InterpreterConstants.SDCARD_ROOT + packageName;
+
+    if (mDescriptor == null) {
+      throw new Sl4aException("Interpreter description not provided.");
+    }
+    if (mDescriptor.getName() == null) {
+      throw new Sl4aException("Interpreter not specified.");
+    }
+    if (isInstalled()) {
+      throw new Sl4aException("Interpreter is installed.");
+    }
+
+    if (mDescriptor.hasInterpreterArchive()) {
+      mTaskQueue.offer(RequestCode.DOWNLOAD_INTERPRETER);
+      mTaskQueue.offer(RequestCode.EXTRACT_INTERPRETER);
+    }
+    if (mDescriptor.hasExtrasArchive()) {
+      mTaskQueue.offer(RequestCode.DOWNLOAD_INTERPRETER_EXTRAS);
+      mTaskQueue.offer(RequestCode.EXTRACT_INTERPRETER_EXTRAS);
+    }
+    if (mDescriptor.hasScriptsArchive()) {
+      mTaskQueue.offer(RequestCode.DOWNLOAD_SCRIPTS);
+      mTaskQueue.offer(RequestCode.EXTRACT_SCRIPTS);
+    }
+  }
+
+  @Override
+  protected Boolean doInBackground(Void... params) {
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        executeInBackground();
+        final boolean result = (mTaskQueue.size() == 0);
+        mainThreadHandler.post(new Runnable() {
+          @Override
+          public void run() {
+            finish(result);
+          }
+        });
+      }
+    }).start();
+    return true;
+  }
+
+  private boolean executeInBackground() {
+
+    File root = new File(mInterpreterRoot);
+    if (root.exists()) {
+      FileUtils.delete(root);
+    }
+    if (!root.mkdirs()) {
+      Log.e("Failed to make directories: " + root.getAbsolutePath());
+      return false;
+    }
+
+    if (Looper.myLooper() == null) {
+      Looper.prepare();
+    }
+    mBackgroundHandler = new Handler(Looper.myLooper());
+    mainThreadHandler.post(mTaskStarter);
+    Looper.loop();
+    // Have we executed all the tasks?
+    return (mTaskQueue.size() == 0);
+  }
+
+  protected void finish(boolean result) {
+    if (result && setup()) {
+      mTaskListener.onTaskFinished(true, "Installation successful.");
+    } else {
+      if (mTaskHolder != null) {
+        mTaskHolder.cancel(true);
+      }
+      cleanup();
+      mTaskListener.onTaskFinished(false, "Installation failed.");
+    }
+  }
+
+  protected AsyncTask<Void, Integer, Long> download(String in) throws MalformedURLException {
+    String out = mInterpreterRoot;
+    return new UrlDownloaderTask(in, out, mContext);
+  }
+
+  protected AsyncTask<Void, Integer, Long> downloadInterpreter() throws MalformedURLException {
+    return download(mDescriptor.getInterpreterArchiveUrl());
+  }
+
+  protected AsyncTask<Void, Integer, Long> downloadInterpreterExtras() throws MalformedURLException {
+    return download(mDescriptor.getExtrasArchiveUrl());
+  }
+
+  protected AsyncTask<Void, Integer, Long> downloadScripts() throws MalformedURLException {
+    return download(mDescriptor.getScriptsArchiveUrl());
+  }
+
+  protected AsyncTask<Void, Integer, Long> extract(String in, String out, boolean replaceAll)
+      throws Sl4aException {
+    return new ZipExtractorTask(in, out, mContext, replaceAll);
+  }
+
+  protected AsyncTask<Void, Integer, Long> extractInterpreter() throws Sl4aException {
+    String in =
+        new File(mInterpreterRoot, mDescriptor.getInterpreterArchiveName()).getAbsolutePath();
+    String out = InterpreterUtils.getInterpreterRoot(mContext).getAbsolutePath();
+    return extract(in, out, true);
+  }
+
+  protected AsyncTask<Void, Integer, Long> extractInterpreterExtras() throws Sl4aException {
+    String in = new File(mInterpreterRoot, mDescriptor.getExtrasArchiveName()).getAbsolutePath();
+    String out = mInterpreterRoot + InterpreterConstants.INTERPRETER_EXTRAS_ROOT;
+    return extract(in, out, true);
+  }
+
+  protected AsyncTask<Void, Integer, Long> extractScripts() throws Sl4aException {
+    String in = new File(mInterpreterRoot, mDescriptor.getScriptsArchiveName()).getAbsolutePath();
+    String out = InterpreterConstants.SCRIPTS_ROOT;
+    return extract(in, out, false);
+  }
+
+  protected boolean chmodIntepreter() {
+    int dataChmodErrno;
+    boolean interpreterChmodSuccess;
+    try {
+      dataChmodErrno = FileUtils.chmod(InterpreterUtils.getInterpreterRoot(mContext), 0755);
+      interpreterChmodSuccess =
+          FileUtils.recursiveChmod(InterpreterUtils.getInterpreterRoot(mContext, mDescriptor
+              .getName()), 0755);
+    } catch (Exception e) {
+      Log.e(e);
+      return false;
+    }
+    return dataChmodErrno == 0 && interpreterChmodSuccess;
+  }
+
+  protected boolean isInstalled() {
+    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(mContext);
+    return preferences.getBoolean(InterpreterConstants.INSTALLED_PREFERENCE_KEY, false);
+  }
+
+  private void cleanup() {
+    List<File> directories = new ArrayList<File>();
+
+    directories.add(new File(mInterpreterRoot));
+
+    if (mDescriptor.hasInterpreterArchive()) {
+      if (!mTaskQueue.contains(RequestCode.EXTRACT_INTERPRETER)) {
+        directories.add(InterpreterUtils.getInterpreterRoot(mContext, mDescriptor.getName()));
+      }
+    }
+
+    for (File directory : directories) {
+      FileUtils.delete(directory);
+    }
+  }
+
+  protected abstract boolean setup();
+}
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/InterpreterUninstaller.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/InterpreterUninstaller.java
new file mode 100644
index 0000000..5d0c17f
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/InterpreterUninstaller.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.SharedPreferences;
+import android.content.DialogInterface.OnCancelListener;
+import android.os.AsyncTask;
+import android.preference.PreferenceManager;
+
+import com.googlecode.android_scripting.exception.Sl4aException;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+import com.googlecode.android_scripting.interpreter.InterpreterDescriptor;
+import com.googlecode.android_scripting.interpreter.InterpreterUtils;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * AsyncTask for uninstalling interpreters.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public abstract class InterpreterUninstaller extends AsyncTask<Void, Void, Boolean> {
+
+  protected final InterpreterDescriptor mDescriptor;
+  protected final Context mContext;
+  protected final ProgressDialog mDialog;
+  protected final AsyncTaskListener<Boolean> mListener;
+
+  protected final String mInterpreterRoot;
+
+  public InterpreterUninstaller(InterpreterDescriptor descriptor, Context context,
+      AsyncTaskListener<Boolean> listener) throws Sl4aException {
+
+    super();
+
+    mDescriptor = descriptor;
+    mContext = context;
+    mListener = listener;
+
+    String packageName = mDescriptor.getClass().getPackage().getName();
+
+    if (packageName.length() == 0) {
+      throw new Sl4aException("Interpreter package name is empty.");
+    }
+
+    mInterpreterRoot = InterpreterConstants.SDCARD_ROOT + packageName;
+
+    if (mDescriptor == null) {
+      throw new Sl4aException("Interpreter description not provided.");
+    }
+    if (mDescriptor.getName() == null) {
+      throw new Sl4aException("Interpreter not specified.");
+    }
+    if (!isInstalled()) {
+      throw new Sl4aException("Interpreter not installed.");
+    }
+
+    if (context != null) {
+      mDialog = new ProgressDialog(context);
+    } else {
+      mDialog = null;
+    }
+  }
+
+  public final void execute() {
+    execute(null, null, null);
+  }
+
+  @Override
+  protected void onPreExecute() {
+    if (mDialog != null) {
+      mDialog.setMessage("Uninstalling " + mDescriptor.getNiceName());
+      mDialog.setIndeterminate(true);
+      mDialog.setOnCancelListener(new OnCancelListener() {
+        @Override
+        public void onCancel(DialogInterface dialog) {
+          cancel(true);
+        }
+      });
+      mDialog.show();
+    }
+  }
+
+  @Override
+  protected void onPostExecute(Boolean result) {
+    if (mDialog != null && mDialog.isShowing()) {
+      mDialog.dismiss();
+    }
+    if (result) {
+      mListener.onTaskFinished(result, "Uninstallation successful.");
+    } else {
+      mListener.onTaskFinished(result, "Uninstallation failed.");
+    }
+  }
+
+  @Override
+  protected Boolean doInBackground(Void... params) {
+    List<File> directories = new ArrayList<File>();
+
+    directories.add(new File(mInterpreterRoot));
+
+    if (mDescriptor.hasInterpreterArchive()) {
+      directories.add(InterpreterUtils.getInterpreterRoot(mContext, mDescriptor.getName()));
+    }
+
+    for (File directory : directories) {
+      FileUtils.delete(directory);
+    }
+
+    return cleanup();
+  }
+
+  protected boolean isInstalled() {
+    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(mContext);
+    return preferences.getBoolean(InterpreterConstants.INSTALLED_PREFERENCE_KEY, false);
+  }
+
+  protected abstract boolean cleanup();
+}
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/UrlDownloaderTask.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/UrlDownloaderTask.java
new file mode 100644
index 0000000..f9ba053
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/UrlDownloaderTask.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.AsyncTask;
+
+
+import com.googlecode.android_scripting.IoUtils;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.exception.Sl4aException;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+
+/**
+ * AsyncTask for extracting ZIP files.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public class UrlDownloaderTask extends AsyncTask<Void, Integer, Long> {
+
+  private final URL mUrl;
+  private final File mFile;
+  private final ProgressDialog mDialog;
+
+  private Throwable mException;
+  private OutputStream mProgressReportingOutputStream;
+
+  private final class ProgressReportingOutputStream extends FileOutputStream {
+    private int mProgress = 0;
+
+    private ProgressReportingOutputStream(File f) throws FileNotFoundException {
+      super(f);
+    }
+
+    @Override
+    public void write(byte[] buffer, int offset, int count) throws IOException {
+      super.write(buffer, offset, count);
+      mProgress += count;
+      publishProgress(mProgress);
+    }
+  }
+
+  public UrlDownloaderTask(String url, String out, Context context) throws MalformedURLException {
+    super();
+    if (context != null) {
+      mDialog = new ProgressDialog(context);
+    } else {
+      mDialog = null;
+    }
+    mUrl = new URL(url);
+    String fileName = new File(mUrl.getFile()).getName();
+    mFile = new File(out, fileName);
+  }
+
+  @Override
+  protected void onPreExecute() {
+    Log.v("Downloading " + mUrl);
+    if (mDialog != null) {
+      mDialog.setTitle("Downloading");
+      mDialog.setMessage(mFile.getName());
+      // mDialog.setIndeterminate(true);
+      mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
+      mDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+        @Override
+        public void onCancel(DialogInterface dialog) {
+          cancel(true);
+        }
+      });
+      mDialog.show();
+    }
+  }
+
+  @Override
+  protected Long doInBackground(Void... params) {
+    try {
+      return download();
+    } catch (Exception e) {
+      if (mFile.exists()) {
+        // Clean up bad downloads.
+        mFile.delete();
+      }
+      mException = e;
+      return null;
+    }
+  }
+
+  @Override
+  protected void onProgressUpdate(Integer... progress) {
+    if (mDialog == null) {
+      return;
+    }
+    if (progress.length > 1) {
+      int contentLength = progress[1];
+      if (contentLength == -1) {
+        mDialog.setIndeterminate(true);
+      } else {
+        mDialog.setMax(contentLength);
+      }
+    } else {
+      mDialog.setProgress(progress[0].intValue());
+    }
+  }
+
+  @Override
+  protected void onPostExecute(Long result) {
+    if (mDialog != null && mDialog.isShowing()) {
+      mDialog.dismiss();
+    }
+    if (isCancelled()) {
+      return;
+    }
+    if (mException != null) {
+      Log.e("Download failed.", mException);
+    }
+  }
+
+  @Override
+  protected void onCancelled() {
+    if (mDialog != null) {
+      mDialog.setTitle("Download cancelled.");
+    }
+  }
+
+  private long download() throws Exception {
+    URLConnection connection = null;
+    try {
+      connection = mUrl.openConnection();
+    } catch (IOException e) {
+      throw new Sl4aException("Cannot open URL: " + mUrl, e);
+    }
+
+    int contentLength = connection.getContentLength();
+
+    if (mFile.exists() && contentLength == mFile.length()) {
+      Log.v("Output file already exists. Skipping download.");
+      return 0l;
+    }
+
+    try {
+      mProgressReportingOutputStream = new ProgressReportingOutputStream(mFile);
+    } catch (FileNotFoundException e) {
+      throw new Sl4aException(e);
+    }
+
+    publishProgress(0, contentLength);
+
+    int bytesCopied = IoUtils.copy(connection.getInputStream(), mProgressReportingOutputStream);
+    if (bytesCopied != contentLength && contentLength != -1) {
+      throw new IOException("Download incomplete: " + bytesCopied + " != " + contentLength);
+    }
+    mProgressReportingOutputStream.close();
+    Log.v("Download completed successfully.");
+    return bytesCopied;
+  }
+}
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/ZipExtractorTask.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/ZipExtractorTask.java
new file mode 100644
index 0000000..3d7eb01
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/ZipExtractorTask.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnCancelListener;
+import android.os.AsyncTask;
+
+import com.googlecode.android_scripting.exception.Sl4aException;
+import com.googlecode.android_scripting.future.FutureResult;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/**
+ * AsyncTask for extracting ZIP files.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public class ZipExtractorTask extends AsyncTask<Void, Integer, Long> {
+
+  private static enum Replace {
+    YES, NO, YESTOALL, SKIPALL
+  }
+
+  private final File mInput;
+  private final File mOutput;
+  private final ProgressDialog mDialog;
+  private Throwable mException;
+  private int mProgress = 0;
+  private final Context mContext;
+  private boolean mReplaceAll;
+
+  private final class ProgressReportingOutputStream extends FileOutputStream {
+    private ProgressReportingOutputStream(File f) throws FileNotFoundException {
+      super(f);
+    }
+
+    @Override
+    public void write(byte[] buffer, int offset, int count) throws IOException {
+      super.write(buffer, offset, count);
+      mProgress += count;
+      publishProgress(mProgress);
+    }
+  }
+
+  public ZipExtractorTask(String in, String out, Context context, boolean replaceAll)
+      throws Sl4aException {
+    super();
+    mInput = new File(in);
+    mOutput = new File(out);
+    if (!mOutput.exists()) {
+      if (!mOutput.mkdirs()) {
+        throw new Sl4aException("Failed to make directories: " + mOutput.getAbsolutePath());
+      }
+    }
+    if (context != null) {
+      mDialog = new ProgressDialog(context);
+    } else {
+      mDialog = null;
+    }
+
+    mContext = context;
+    mReplaceAll = replaceAll;
+
+  }
+
+  @Override
+  protected void onPreExecute() {
+    Log.v("Extracting " + mInput.getAbsolutePath() + " to " + mOutput.getAbsolutePath());
+    if (mDialog != null) {
+      mDialog.setTitle("Extracting");
+      mDialog.setMessage(mInput.getName());
+      mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
+      mDialog.setOnCancelListener(new OnCancelListener() {
+        @Override
+        public void onCancel(DialogInterface dialog) {
+          cancel(true);
+        }
+      });
+      mDialog.show();
+    }
+  }
+
+  @Override
+  protected Long doInBackground(Void... params) {
+    try {
+      return unzip();
+    } catch (Exception e) {
+      if (mInput.exists()) {
+        // Clean up bad zip file.
+        mInput.delete();
+      }
+      mException = e;
+      return null;
+    }
+  }
+
+  @Override
+  protected void onProgressUpdate(Integer... progress) {
+    if (mDialog == null) {
+      return;
+    }
+    if (progress.length > 1) {
+      int max = progress[1];
+      mDialog.setMax(max);
+    } else {
+      mDialog.setProgress(progress[0].intValue());
+    }
+  }
+
+  @Override
+  protected void onPostExecute(Long result) {
+    if (mDialog != null && mDialog.isShowing()) {
+      mDialog.dismiss();
+    }
+    if (isCancelled()) {
+      return;
+    }
+    if (mException != null) {
+      Log.e("Zip extraction failed.", mException);
+    }
+  }
+
+  @Override
+  protected void onCancelled() {
+    if (mDialog != null) {
+      mDialog.setTitle("Extraction cancelled.");
+    }
+  }
+
+  private long unzip() throws Exception {
+    long extractedSize = 0l;
+    Enumeration<? extends ZipEntry> entries;
+    ZipFile zip = new ZipFile(mInput);
+    long uncompressedSize = getOriginalSize(zip);
+
+    publishProgress(0, (int) uncompressedSize);
+
+    entries = zip.entries();
+
+    try {
+      while (entries.hasMoreElements()) {
+        ZipEntry entry = entries.nextElement();
+        if (entry.isDirectory()) {
+          // Not all zip files actually include separate directory entries.
+          // We'll just ignore them
+          // and create them as necessary for each actual entry.
+          continue;
+        }
+        File destination = new File(mOutput, entry.getName());
+        if (!destination.getParentFile().exists()) {
+          destination.getParentFile().mkdirs();
+        }
+        if (destination.exists() && mContext != null && !mReplaceAll) {
+          Replace answer = showDialog(entry.getName());
+          switch (answer) {
+          case YES:
+            break;
+          case NO:
+            continue;
+          case YESTOALL:
+            mReplaceAll = true;
+            break;
+          default:
+            return extractedSize;
+          }
+        }
+        ProgressReportingOutputStream outStream = new ProgressReportingOutputStream(destination);
+        extractedSize += IoUtils.copy(zip.getInputStream(entry), outStream);
+        outStream.close();
+      }
+    } finally {
+      try {
+        zip.close();
+      } catch (Exception e) {
+        // swallow this exception, we are only interested in the original one
+      }
+    }
+    Log.v("Extraction is complete.");
+    return extractedSize;
+  }
+
+  private long getOriginalSize(ZipFile file) {
+    Enumeration<? extends ZipEntry> entries = file.entries();
+    long originalSize = 0l;
+    while (entries.hasMoreElements()) {
+      ZipEntry entry = entries.nextElement();
+      if (entry.getSize() >= 0) {
+        originalSize += entry.getSize();
+      }
+    }
+    return originalSize;
+  }
+
+  private Replace showDialog(final String name) {
+    final FutureResult<Replace> mResult = new FutureResult<Replace>();
+
+    MainThread.run(mContext, new Runnable() {
+      @Override
+      public void run() {
+        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
+        builder.setTitle(String.format("Script \"%s\" already exist.", name));
+        builder.setMessage(String.format("Do you want to replace script \"%s\" ?", name));
+
+        DialogInterface.OnClickListener buttonListener = new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int which) {
+            Replace result = Replace.SKIPALL;
+            switch (which) {
+            case DialogInterface.BUTTON_POSITIVE:
+              result = Replace.YES;
+              break;
+            case DialogInterface.BUTTON_NEGATIVE:
+              result = Replace.NO;
+              break;
+            case DialogInterface.BUTTON_NEUTRAL:
+              result = Replace.YESTOALL;
+              break;
+            }
+            mResult.set(result);
+            dialog.dismiss();
+          }
+        };
+        builder.setNegativeButton("Skip", buttonListener);
+        builder.setPositiveButton("Replace", buttonListener);
+        builder.setNeutralButton("Replace All", buttonListener);
+
+        builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
+          @Override
+          public void onCancel(DialogInterface dialog) {
+            mResult.set(Replace.SKIPALL);
+            dialog.dismiss();
+          }
+        });
+        builder.show();
+      }
+    });
+
+    try {
+      return mResult.get();
+    } catch (InterruptedException e) {
+      Log.e(e);
+    }
+    return null;
+  }
+}
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/activity/Main.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/activity/Main.java
new file mode 100644
index 0000000..2af4d17
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/activity/Main.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.net.Uri;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.view.Gravity;
+import android.view.View;
+import android.view.Window;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup.LayoutParams;
+import android.view.ViewGroup.MarginLayoutParams;
+import android.widget.Button;
+import android.widget.LinearLayout;
+
+import com.googlecode.android_scripting.AsyncTaskListener;
+import com.googlecode.android_scripting.InterpreterInstaller;
+import com.googlecode.android_scripting.InterpreterUninstaller;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.exception.Sl4aException;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+import com.googlecode.android_scripting.interpreter.InterpreterDescriptor;
+
+/**
+ * Base activity for distributing interpreters as APK's.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public abstract class Main extends Activity {
+
+  protected final static float MARGIN_DIP = 3.0f;
+
+  protected final String mId = getClass().getPackage().getName();
+
+  protected SharedPreferences mPreferences;
+  protected InterpreterDescriptor mDescriptor;
+  protected Button mButton;
+  protected LinearLayout mLayout;
+
+  protected abstract InterpreterDescriptor getDescriptor();
+
+  protected abstract InterpreterInstaller getInterpreterInstaller(InterpreterDescriptor descriptor,
+      Context context, AsyncTaskListener<Boolean> listener) throws Sl4aException;
+
+  protected abstract InterpreterUninstaller getInterpreterUninstaller(
+      InterpreterDescriptor descriptor, Context context, AsyncTaskListener<Boolean> listener)
+      throws Sl4aException;
+
+  protected enum RunningTask {
+    INSTALL, UNINSTALL
+  }
+
+  protected volatile RunningTask mCurrentTask = null;
+
+  protected final AsyncTaskListener<Boolean> mTaskListener = new AsyncTaskListener<Boolean>() {
+    @Override
+    public void onTaskFinished(Boolean result, String message) {
+      getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS,
+          Window.PROGRESS_VISIBILITY_OFF);
+      if (result) {
+        switch (mCurrentTask) {
+        case INSTALL:
+          setInstalled(true);
+          prepareUninstallButton();
+          break;
+        case UNINSTALL:
+          setInstalled(false);
+          prepareInstallButton();
+          break;
+        }
+      }
+      Log.v(Main.this, message);
+      mCurrentTask = null;
+    }
+  };
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+    mDescriptor = getDescriptor();
+
+    requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+    initializeViews();
+    if (checkInstalled()) {
+      prepareUninstallButton();
+    } else {
+      prepareInstallButton();
+    }
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    finish();
+  }
+
+  // TODO(alexey): Pull out to a layout XML?
+  protected void initializeViews() {
+    mLayout = new LinearLayout(this);
+    mLayout.setOrientation(LinearLayout.VERTICAL);
+    mLayout.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+    mLayout.setGravity(Gravity.CENTER_HORIZONTAL);
+
+    mButton = new Button(this);
+    MarginLayoutParams marginParams =
+        new MarginLayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+    final float scale = getResources().getDisplayMetrics().density;
+    int marginPixels = (int) (MARGIN_DIP * scale + 0.5f);
+    marginParams.setMargins(marginPixels, marginPixels, marginPixels, marginPixels);
+    mButton.setLayoutParams(marginParams);
+    mLayout.addView(mButton);
+    setContentView(mLayout);
+  }
+
+  protected void prepareInstallButton() {
+    mButton.setText("Install");
+    mButton.setOnClickListener(new OnClickListener() {
+      @Override
+      public void onClick(View v) {
+        install();
+      }
+    });
+  }
+
+  protected void prepareUninstallButton() {
+    mButton.setText("Uninstall");
+    mButton.setOnClickListener(new OnClickListener() {
+      @Override
+      public void onClick(View v) {
+        uninstall();
+      }
+    });
+  }
+
+  protected void broadcastInstallationStateChange(boolean isInterpreterInstalled) {
+    Intent intent = new Intent();
+    intent.setData(Uri.parse("package:" + mId));
+    if (isInterpreterInstalled) {
+      intent.setAction(InterpreterConstants.ACTION_INTERPRETER_ADDED);
+    } else {
+      intent.setAction(InterpreterConstants.ACTION_INTERPRETER_REMOVED);
+    }
+    sendBroadcast(intent);
+  }
+
+  protected synchronized void install() {
+    if (mCurrentTask != null) {
+      return;
+    }
+    getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS, Window.PROGRESS_VISIBILITY_ON);
+    mCurrentTask = RunningTask.INSTALL;
+    InterpreterInstaller installTask;
+    try {
+      installTask = getInterpreterInstaller(mDescriptor, Main.this, mTaskListener);
+    } catch (Sl4aException e) {
+      Log.e(this, e.getMessage(), e);
+      return;
+    }
+    installTask.execute();
+  }
+
+  protected synchronized void uninstall() {
+    if (mCurrentTask != null) {
+      return;
+    }
+    getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS, Window.PROGRESS_VISIBILITY_ON);
+    mCurrentTask = RunningTask.UNINSTALL;
+    InterpreterUninstaller uninstallTask;
+    try {
+      uninstallTask = getInterpreterUninstaller(mDescriptor, Main.this, mTaskListener);
+    } catch (Sl4aException e) {
+      Log.e(this, e.getMessage(), e);
+      return;
+    }
+    uninstallTask.execute();
+  }
+
+  protected void setInstalled(boolean isInstalled) {
+    SharedPreferences.Editor editor = mPreferences.edit();
+    editor.putBoolean(InterpreterConstants.INSTALLED_PREFERENCE_KEY, isInstalled);
+    editor.commit();
+    broadcastInstallationStateChange(isInstalled);
+  }
+
+  protected boolean checkInstalled() {
+    boolean isInstalled =
+        mPreferences.getBoolean(InterpreterConstants.INSTALLED_PREFERENCE_KEY, false);
+    broadcastInstallationStateChange(isInstalled);
+    return isInstalled;
+  }
+
+  public LinearLayout getLayout() {
+    return mLayout;
+  }
+
+}
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/interpreter/InterpreterProvider.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/interpreter/InterpreterProvider.java
new file mode 100644
index 0000000..500c5d4
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/interpreter/InterpreterProvider.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.preference.PreferenceManager;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * A provider that can be queried to obtain execution-related interpreter info.
+ *
+ * <p>
+ * To create an interpreter APK, please extend this content provider and implement getDescriptor()
+ * and getEnvironmentSettings().<br>
+ * Please declare the provider in the android manifest xml (the authority values has to be set to
+ * your_package_name.provider_name).
+ *
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public abstract class InterpreterProvider extends ContentProvider {
+
+  private static final int PROPERTIES = 1;
+  private static final int ENVIRONMENT_VARIABLES = 2;
+  private static final int ARGUMENTS = 3;
+
+  private UriMatcher mUriMatcher;
+  private SharedPreferences mPreferences;
+
+  private InterpreterDescriptor mDescriptor;
+  private Context mContext;
+
+  public static final String MIME = "vnd.android.cursor.item/vnd.googlecode.interpreter";
+
+  public InterpreterProvider() {
+    mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+    String auth = this.getClass().getName().toLowerCase();
+    mUriMatcher.addURI(auth, InterpreterConstants.PROVIDER_PROPERTIES, PROPERTIES);
+    mUriMatcher.addURI(auth, InterpreterConstants.PROVIDER_ENVIRONMENT_VARIABLES,
+        ENVIRONMENT_VARIABLES);
+    mUriMatcher.addURI(auth, InterpreterConstants.PROVIDER_ARGUMENTS, ARGUMENTS);
+  }
+
+  /**
+   * Returns an instance of the class that implements the desired {@link InterpreterDescriptor}.
+   */
+  protected abstract InterpreterDescriptor getDescriptor();
+
+  @Override
+  public int delete(Uri uri, String selection, String[] selectionArgs) {
+    return 0;
+  }
+
+  @Override
+  public String getType(Uri uri) {
+    return MIME;
+  }
+
+  @Override
+  public Uri insert(Uri uri, ContentValues values) {
+    return null;
+  }
+
+  @Override
+  public boolean onCreate() {
+    mDescriptor = getDescriptor();
+    mContext = getContext();
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(mContext);
+    return false;
+  }
+
+  @Override
+  public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+      String sortOrder) {
+    if (!isInterpreterInstalled()) {
+      return null;
+    }
+    Map<String, String> map;
+    switch (mUriMatcher.match(uri)) {
+    case PROPERTIES:
+      map = getProperties();
+      break;
+    case ENVIRONMENT_VARIABLES:
+      map = getEnvironmentVariables();
+      break;
+    case ARGUMENTS:
+      map = getArguments();
+      break;
+    default:
+      map = null;
+    }
+    return buildCursorFromMap(map);
+  }
+
+  @Override
+  public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+    return 0;
+  }
+
+  private boolean isInterpreterInstalled() {
+    return mPreferences.getBoolean(InterpreterConstants.INSTALLED_PREFERENCE_KEY, false);
+  }
+
+  private Cursor buildCursorFromMap(Map<String, String> map) {
+    if (map == null) {
+      return null;
+    }
+    MatrixCursor cursor = new MatrixCursor(map.keySet().toArray(new String[map.size()]));
+    cursor.addRow(map.values());
+    return cursor;
+  }
+
+  private Map<String, String> getProperties() {
+    Map<String, String> values = new HashMap<String, String>();
+    values.put(InterpreterPropertyNames.NAME, mDescriptor.getName());
+    values.put(InterpreterPropertyNames.NICE_NAME, mDescriptor.getNiceName());
+    values.put(InterpreterPropertyNames.EXTENSION, mDescriptor.getExtension());
+    values.put(InterpreterPropertyNames.BINARY, mDescriptor.getBinary(mContext).getAbsolutePath());
+    values.put(InterpreterPropertyNames.INTERACTIVE_COMMAND, mDescriptor
+        .getInteractiveCommand(mContext));
+    values.put(InterpreterPropertyNames.SCRIPT_COMMAND, mDescriptor.getScriptCommand(mContext));
+    values.put(InterpreterPropertyNames.HAS_INTERACTIVE_MODE, Boolean.toString(mDescriptor
+        .hasInteractiveMode()));
+    return values;
+  }
+
+  private Map<String, String> getEnvironmentVariables() {
+    Map<String, String> values = new HashMap<String, String>();
+    values.putAll(mDescriptor.getEnvironmentVariables(mContext));
+    return values;
+  }
+
+  private Map<String, String> getArguments() {
+    Map<String, String> values = new LinkedHashMap<String, String>();
+    int column = 0;
+    for (String argument : mDescriptor.getArguments(mContext)) {
+      values.put(Integer.toString(column), argument);
+      column++;
+    }
+    return values;
+  }
+}
diff --git a/InterpreterForAndroid/src/com/googlecode/android_scripting/interpreter/Sl4aHostedInterpreter.java b/InterpreterForAndroid/src/com/googlecode/android_scripting/interpreter/Sl4aHostedInterpreter.java
new file mode 100644
index 0000000..e6ca41c
--- /dev/null
+++ b/InterpreterForAndroid/src/com/googlecode/android_scripting/interpreter/Sl4aHostedInterpreter.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import android.content.Context;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A description of the interpreters hosted by the SL4A project.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public abstract class Sl4aHostedInterpreter implements InterpreterDescriptor {
+
+  public static final String BASE_INSTALL_URL = "http://android-scripting.googlecode.com/files/";
+  public static final String DALVIKVM = "/system/bin/dalvikvm";
+
+  // TODO(damonkohler): Remove getVersion() and pull these three version methods up in to the base
+  // class.
+
+  public String getBaseInstallUrl() {
+    return BASE_INSTALL_URL;
+  }
+
+  public int getInterpreterVersion() {
+    return getVersion();
+  }
+
+  public int getExtrasVersion() {
+    return getVersion();
+  }
+
+  public int getScriptsVersion() {
+    return getVersion();
+  }
+
+  @Override
+  public String getInterpreterArchiveName() {
+    return String.format("%s_r%s.zip", getName(), getInterpreterVersion());
+  }
+
+  @Override
+  public String getExtrasArchiveName() {
+    return String.format("%s_extras_r%s.zip", getName(), getExtrasVersion());
+  }
+
+  @Override
+  public String getScriptsArchiveName() {
+    return String.format("%s_scripts_r%s.zip", getName(), getScriptsVersion());
+  }
+
+  @Override
+  public String getInterpreterArchiveUrl() {
+    return getBaseInstallUrl() + getInterpreterArchiveName();
+  }
+
+  @Override
+  public String getExtrasArchiveUrl() {
+    return getBaseInstallUrl() + getExtrasArchiveName();
+  }
+
+  @Override
+  public String getScriptsArchiveUrl() {
+    return getBaseInstallUrl() + getScriptsArchiveName();
+  }
+
+  @Override
+  public String getInteractiveCommand(Context context) {
+    return "";
+  }
+
+  @Override
+  public boolean hasInteractiveMode() {
+    return true;
+  }
+
+  @Override
+  public String getScriptCommand(Context context) {
+    return "%s";
+  }
+
+  @Override
+  public List<String> getArguments(Context context) {
+    return new ArrayList<String>();
+  }
+
+  @Override
+  public Map<String, String> getEnvironmentVariables(Context context) {
+    return new HashMap<String, String>();
+  }
+
+  // TODO(damonkohler): This shouldn't be public.
+  public File getExtrasPath(Context context) {
+    if (!hasInterpreterArchive() && hasExtrasArchive()) {
+      return new File(InterpreterConstants.SDCARD_ROOT + this.getClass().getPackage().getName()
+          + InterpreterConstants.INTERPRETER_EXTRAS_ROOT, getName());
+    }
+    return InterpreterUtils.getInterpreterRoot(context, getName());
+  }
+}
diff --git a/README b/README
new file mode 100644
index 0000000..cf7b58b
--- /dev/null
+++ b/README
@@ -0,0 +1,61 @@
+=============================
+Project Info
+=============================
+Scripting Layer For Android
+
+Originally authored by Damon Kohler, Scripting Layer for Android, SL4A, is an automation toolset
+for calling Android APIs in a platform-independent manner. It supports both remote automation via
+ADB as well as execution of scripts from on-device via a series of lightweight translation layers.
+
+=============================
+Build Instructions
+=============================
+
+Due to its inclusion in AOSP as a privileged app, building SL4A requires a system build.
+
+For the initial build of Android:
+
+1) cd <ANDROID_SOURCE_ROOT>
+2) source build/envsetup.sh
+3) lunch <TARGET>
+4) make [-j15]
+
+Then Build SL4A:
+
+1) cd <ANDROID_SOURCE_ROOT>/packages/apps/Test/connectivity/sl4a
+2) mm [-j15]
+
+===========================
+Install Instructions
+===========================
+
+1) adb install -r <ANDROID_SOURCE_ROOT>/out/target/product/<TARGET>/data/app/sl4a/sl4a.apk
+
+===========================
+Run Instructions
+===========================
+
+1) SL4A may be launched from Android as a normal App.
+
+or;
+
+2) To enable RPC access from the command prompt:
+
+    1) adb forward tcp:<HOST_PORT_NUM> tcp:<DEVICE_PORT_NUM>
+    2) adb shell "am start -a com.googlecode.android_scripting.action.LAUNCH_SERVER \
+               --ei com.googlecode.android_scripting.extra.USE_SERVICE_PORT <DEVICE_PORT_NUM> \
+               com.googlecode.android_scripting/.activity.ScriptingLayerServiceLauncher"
+
+    where <HOST_PORT_NUM> and <DEVICE_PORT_NUM> are the tcp ports on the host computer and device.
+
+
+===========================
+Doc Generation Instructions
+===========================
+
+From SL4A source directory run this command:
+    1)"perl Docs/generate_api_reference_md.pl"
+
+In the Docs direcotry there should now be an ApiReference.md file that
+contains which RPC functions are available in SL4A as well as documentation
+for the RPC functions.
diff --git a/ScriptingLayer/Android.mk b/ScriptingLayer/Android.mk
new file mode 100644
index 0000000..2871eff
--- /dev/null
+++ b/ScriptingLayer/Android.mk
@@ -0,0 +1,31 @@
+#
+#  Copyright (C) 2016 Google, Inc.
+#
+#  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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+
+LOCAL_MODULE := sl4a.ScriptingLayer
+LOCAL_MODULE_OWNER := google
+
+LOCAL_STATIC_JAVA_LIBRARIES := guava android-common
+LOCAL_STATIC_JAVA_LIBRARIES += sl4a.Utils sl4a.Common
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src/com/googlecode/android_scripting)
+
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
diff --git a/ScriptingLayer/src/com/googlecode/android_scripting/AndroidProxy.java b/ScriptingLayer/src/com/googlecode/android_scripting/AndroidProxy.java
new file mode 100644
index 0000000..997582c
--- /dev/null
+++ b/ScriptingLayer/src/com/googlecode/android_scripting/AndroidProxy.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.Service;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.facade.FacadeManagerFactory;
+import com.googlecode.android_scripting.jsonrpc.JsonRpcServer;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManagerFactory;
+
+import java.net.InetSocketAddress;
+import java.util.UUID;
+
+public class AndroidProxy {
+
+  private InetSocketAddress mAddress;
+  private final JsonRpcServer mJsonRpcServer;
+  private final UUID mSecret;
+  private final RpcReceiverManagerFactory mFacadeManagerFactory;
+
+  /**
+   *
+   * @param service
+   *          Android service (required to build facades).
+   * @param intent
+   *          the intent that launched the proxy/script.
+   * @param requiresHandshake
+   *          indicates whether RPC security protocol should be enabled.
+   */
+  public AndroidProxy(Service service, Intent intent, boolean requiresHandshake) {
+    if (requiresHandshake) {
+      mSecret = UUID.randomUUID();
+    } else {
+      mSecret = null;
+    }
+    mFacadeManagerFactory =
+        new FacadeManagerFactory(FacadeConfiguration.getSdkLevel(), service, intent,
+            FacadeConfiguration.getFacadeClasses());
+    mJsonRpcServer = new JsonRpcServer(mFacadeManagerFactory, getSecret());
+  }
+
+  public InetSocketAddress getAddress() {
+    return mAddress;
+  }
+
+  public InetSocketAddress startLocal() {
+    return startLocal(0);
+  }
+
+  public InetSocketAddress startLocal(int port) {
+    mAddress = mJsonRpcServer.startLocal(port);
+    return mAddress;
+  }
+
+  public InetSocketAddress startPublic() {
+    return startPublic(0);
+  }
+
+  public InetSocketAddress startPublic(int port) {
+    mAddress = mJsonRpcServer.startPublic(port);
+    return mAddress;
+  }
+
+  public void shutdown() {
+    mJsonRpcServer.shutdown();
+  }
+
+  public String getSecret() {
+    if (mSecret == null) {
+      return null;
+    }
+    return mSecret.toString();
+  }
+
+  public RpcReceiverManagerFactory getRpcReceiverManagerFactory() {
+    return mFacadeManagerFactory;
+  }
+}
diff --git a/ScriptingLayer/src/com/googlecode/android_scripting/ScriptLauncher.java b/ScriptingLayer/src/com/googlecode/android_scripting/ScriptLauncher.java
new file mode 100644
index 0000000..865f077
--- /dev/null
+++ b/ScriptingLayer/src/com/googlecode/android_scripting/ScriptLauncher.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.Service;
+import android.content.Intent;
+
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterProcess;
+import com.googlecode.android_scripting.interpreter.html.HtmlActivityTask;
+import com.googlecode.android_scripting.interpreter.html.HtmlInterpreter;
+
+import java.io.File;
+
+public class ScriptLauncher {
+
+  private ScriptLauncher() {
+    // Utility class.
+  }
+
+  public static HtmlActivityTask launchHtmlScript(File script, Service service, Intent intent,
+      InterpreterConfiguration config) {
+    if (!script.exists()) {
+      throw new RuntimeException("No such script to launch.");
+    }
+    HtmlInterpreter interpreter =
+        (HtmlInterpreter) config.getInterpreterByName(HtmlInterpreter.HTML);
+    if (interpreter == null) {
+      throw new RuntimeException("HtmlInterpreter is not available.");
+    }
+    final FacadeManager manager =
+        new FacadeManager(FacadeConfiguration.getSdkLevel(), service, intent,
+            FacadeConfiguration.getFacadeClasses());
+    FutureActivityTaskExecutor executor =
+        ((BaseApplication) service.getApplication()).getTaskExecutor();
+    final HtmlActivityTask task =
+        new HtmlActivityTask(manager, interpreter.getAndroidJsSource(),
+            interpreter.getJsonSource(), script.getAbsolutePath(), true);
+    executor.execute(task);
+    return task;
+  }
+
+  public static InterpreterProcess launchInterpreter(final AndroidProxy proxy, Intent intent,
+      InterpreterConfiguration config, Runnable shutdownHook) {
+    Interpreter interpreter;
+    String interpreterName;
+    interpreterName = intent.getStringExtra(Constants.EXTRA_INTERPRETER_NAME);
+    interpreter = config.getInterpreterByName(interpreterName);
+    InterpreterProcess process = new InterpreterProcess(interpreter, proxy);
+    if (shutdownHook == null) {
+      process.start(new Runnable() {
+        @Override
+        public void run() {
+          proxy.shutdown();
+        }
+      });
+    } else {
+      process.start(shutdownHook);
+    }
+    return process;
+  }
+
+  public static ScriptProcess launchScript(File script, InterpreterConfiguration configuration,
+      final AndroidProxy proxy, Runnable shutdownHook) {
+    if (!script.exists()) {
+      throw new RuntimeException("No such script to launch.");
+    }
+    ScriptProcess process = new ScriptProcess(script, configuration, proxy);
+    if (shutdownHook == null) {
+      process.start(new Runnable() {
+        @Override
+        public void run() {
+          proxy.shutdown();
+        }
+      });
+    } else {
+      process.start(shutdownHook);
+    }
+    return process;
+  }
+}
\ No newline at end of file
diff --git a/ScriptingLayer/src/com/googlecode/android_scripting/ScriptProcess.java b/ScriptingLayer/src/com/googlecode/android_scripting/ScriptProcess.java
new file mode 100644
index 0000000..607bb64
--- /dev/null
+++ b/ScriptingLayer/src/com/googlecode/android_scripting/ScriptProcess.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterProcess;
+
+import java.io.File;
+
+public class ScriptProcess extends InterpreterProcess {
+
+  private final File mScript;
+
+  public ScriptProcess(File script, InterpreterConfiguration configuration, AndroidProxy proxy) {
+    super(configuration.getInterpreterForScript(script.getName()), proxy);
+    mScript = script;
+    String scriptName = script.getName();
+    setName(scriptName);
+    Interpreter interpreter = configuration.getInterpreterForScript(scriptName);
+    setCommand(String.format(interpreter.getScriptCommand(), script.getAbsolutePath()));
+  }
+
+  public String getPath() {
+    return mScript.getPath();
+  }
+
+}
diff --git a/ScriptingLayer/src/com/googlecode/android_scripting/ScriptStorageAdapter.java b/ScriptingLayer/src/com/googlecode/android_scripting/ScriptStorageAdapter.java
new file mode 100644
index 0000000..96608c1
--- /dev/null
+++ b/ScriptingLayer/src/com/googlecode/android_scripting/ScriptStorageAdapter.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Manages storage and retrieval of scripts on the file system.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class ScriptStorageAdapter {
+
+  private ScriptStorageAdapter() {
+    // Utility class.
+  }
+
+  /**
+   * Writes data to the script by name and overwrites any existing data.
+   */
+  public static void writeScript(File script, String data) {
+    if (script.getParent() == null) {
+      script = new File(InterpreterConstants.SCRIPTS_ROOT, script.getPath());
+    }
+    try {
+      FileWriter stream = new FileWriter(script, false /* overwrite */);
+      BufferedWriter out = new BufferedWriter(stream);
+      out.write(data);
+      out.close();
+    } catch (IOException e) {
+      Log.e("Failed to write script.", e);
+    }
+  }
+
+  /**
+   * Returns a list of all available script {@link File}s.
+   */
+  public static List<File> listAllScripts(File dir) {
+    if (dir == null) {
+      dir = new File(InterpreterConstants.SCRIPTS_ROOT);
+    }
+    if (dir.exists()) {
+      List<File> scripts = Arrays.asList(dir.listFiles());
+      Collections.sort(scripts, new Comparator<File>() {
+        @Override
+        public int compare(File file1, File file2) {
+          if (file1.isDirectory() && !file2.isDirectory()) {
+            return -1;
+          } else if (!file1.isDirectory() && file2.isDirectory()) {
+            return 1;
+          }
+          return file1.compareTo(file2);
+        }
+      });
+      return scripts;
+    }
+    return new ArrayList<File>();
+  }
+
+  /**
+   * Returns a list of script {@link File}s from the given folder for which there is an interpreter
+   * installed.
+   */
+  public static List<File> listExecutableScripts(File directory, InterpreterConfiguration config) {
+    // NOTE(damonkohler): Creating a LinkedList here is necessary in order to be able to filter it
+    // later.
+    List<File> scripts = new LinkedList<File>(listAllScripts(directory));
+    // Filter out any files that don't have interpreters installed.
+    for (Iterator<File> it = scripts.iterator(); it.hasNext();) {
+      File script = it.next();
+      if (script.isDirectory()) {
+        continue;
+      }
+      Interpreter interpreter = config.getInterpreterForScript(script.getName());
+      if (interpreter == null || !interpreter.isInstalled()) {
+        it.remove();
+      }
+    }
+    return scripts;
+  }
+
+  /**
+   * Returns a list of all (including subfolders) script {@link File}s for which there is an
+   * interpreter installed.
+   */
+  public static List<File> listExecutableScriptsRecursively(File directory,
+      InterpreterConfiguration config) {
+    // NOTE(damonkohler): Creating a LinkedList here is necessary in order to be able to filter it
+    // later.
+    List<File> scripts = new LinkedList<File>();
+    List<File> files = listAllScripts(directory);
+
+    // Filter out any files that don't have interpreters installed.
+    for (Iterator<File> it = files.iterator(); it.hasNext();) {
+      File file = it.next();
+      if (file.isDirectory()) {
+        scripts.addAll(listExecutableScriptsRecursively(file, config));
+      }
+      Interpreter interpreter = config.getInterpreterForScript(file.getName());
+      if (interpreter != null && interpreter.isInstalled()) {
+        scripts.add(file);
+      }
+    }
+    Collections.sort(scripts);
+    return scripts;
+  }
+}
\ No newline at end of file
diff --git a/ScriptingLayer/src/com/googlecode/android_scripting/facade/FacadeConfiguration.java b/ScriptingLayer/src/com/googlecode/android_scripting/facade/FacadeConfiguration.java
new file mode 100644
index 0000000..b297580
--- /dev/null
+++ b/ScriptingLayer/src/com/googlecode/android_scripting/facade/FacadeConfiguration.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.facade;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+import com.google.common.collect.Maps;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothA2dpFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothAvrcpFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothConnectionFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothHidFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothHspFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothLeAdvertiseFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothLeScanFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothMapFacade;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothRfcommFacade;
+import com.googlecode.android_scripting.facade.bluetooth.GattClientFacade;
+import com.googlecode.android_scripting.facade.bluetooth.GattServerFacade;
+import com.googlecode.android_scripting.facade.media.AudioManagerFacade;
+import com.googlecode.android_scripting.facade.media.MediaPlayerFacade;
+import com.googlecode.android_scripting.facade.media.MediaRecorderFacade;
+import com.googlecode.android_scripting.facade.media.MediaScannerFacade;
+import com.googlecode.android_scripting.facade.media.MediaSessionFacade;
+import com.googlecode.android_scripting.facade.telephony.CarrierConfigFacade;
+import com.googlecode.android_scripting.facade.telephony.ImsManagerFacade;
+import com.googlecode.android_scripting.facade.telephony.SmsFacade;
+import com.googlecode.android_scripting.facade.telephony.SubscriptionManagerFacade;
+import com.googlecode.android_scripting.facade.telephony.TelecomCallFacade;
+import com.googlecode.android_scripting.facade.telephony.TelecomManagerFacade;
+import com.googlecode.android_scripting.facade.telephony.TelephonyManagerFacade;
+import com.googlecode.android_scripting.facade.ui.UiFacade;
+import com.googlecode.android_scripting.facade.wifi.HttpFacade;
+import com.googlecode.android_scripting.facade.wifi.WifiManagerFacade;
+import com.googlecode.android_scripting.facade.wifi.WifiNanManagerFacade;
+import com.googlecode.android_scripting.facade.wifi.WifiP2pManagerFacade;
+import com.googlecode.android_scripting.facade.wifi.WifiRttManagerFacade;
+import com.googlecode.android_scripting.facade.wifi.WifiScannerFacade;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.rpc.RpcDeprecated;
+import com.googlecode.android_scripting.rpc.RpcMinSdk;
+import com.googlecode.android_scripting.rpc.RpcStartEvent;
+import com.googlecode.android_scripting.rpc.RpcStopEvent;
+import com.googlecode.android_scripting.webcam.WebCamFacade;
+
+/**
+ * Encapsulates the list of supported facades and their construction.
+ */
+public class FacadeConfiguration {
+    private final static Set<Class<? extends RpcReceiver>> sFacadeClassList;
+    private final static SortedMap<String, MethodDescriptor> sRpcs =
+            new TreeMap<String, MethodDescriptor>();
+
+    private static int sSdkLevel;
+
+    static {
+        sSdkLevel = android.os.Build.VERSION.SDK_INT;
+
+        sFacadeClassList = new HashSet<Class<? extends RpcReceiver>>();
+        sFacadeClassList.add(ActivityResultFacade.class);
+        sFacadeClassList.add(AndroidFacade.class);
+        sFacadeClassList.add(ApplicationManagerFacade.class);
+        sFacadeClassList.add(AudioManagerFacade.class);
+        sFacadeClassList.add(BatteryManagerFacade.class);
+        sFacadeClassList.add(CameraFacade.class);
+        sFacadeClassList.add(CommonIntentsFacade.class);
+        sFacadeClassList.add(ContactsFacade.class);
+        sFacadeClassList.add(EventFacade.class);
+        sFacadeClassList.add(ImsManagerFacade.class);
+        sFacadeClassList.add(LocationFacade.class);
+        sFacadeClassList.add(TelephonyManagerFacade.class);
+        sFacadeClassList.add(PreferencesFacade.class);
+        sFacadeClassList.add(MediaPlayerFacade.class);
+        sFacadeClassList.add(MediaRecorderFacade.class);
+        sFacadeClassList.add(MediaScannerFacade.class);
+        sFacadeClassList.add(MediaSessionFacade.class);
+        sFacadeClassList.add(SensorManagerFacade.class);
+        sFacadeClassList.add(SettingsFacade.class);
+        sFacadeClassList.add(SmsFacade.class);
+        sFacadeClassList.add(SpeechRecognitionFacade.class);
+        sFacadeClassList.add(ToneGeneratorFacade.class);
+        sFacadeClassList.add(WakeLockFacade.class);
+        sFacadeClassList.add(HttpFacade.class);
+        sFacadeClassList.add(WifiManagerFacade.class);
+        sFacadeClassList.add(UiFacade.class);
+        sFacadeClassList.add(TextToSpeechFacade.class);
+        sFacadeClassList.add(BluetoothFacade.class);
+        sFacadeClassList.add(BluetoothA2dpFacade.class);
+        sFacadeClassList.add(BluetoothAvrcpFacade.class);
+        sFacadeClassList.add(BluetoothConnectionFacade.class);
+        sFacadeClassList.add(BluetoothHspFacade.class);
+        sFacadeClassList.add(BluetoothHidFacade.class);
+        sFacadeClassList.add(BluetoothMapFacade.class);
+        sFacadeClassList.add(BluetoothRfcommFacade.class);
+        sFacadeClassList.add(WebCamFacade.class);
+        sFacadeClassList.add(WifiP2pManagerFacade.class);
+        sFacadeClassList.add(BluetoothLeScanFacade.class);
+        sFacadeClassList.add(BluetoothLeAdvertiseFacade.class);
+        sFacadeClassList.add(GattClientFacade.class);
+        sFacadeClassList.add(GattServerFacade.class);
+        sFacadeClassList.add(ConnectivityManagerFacade.class);
+        sFacadeClassList.add(DisplayFacade.class);
+        sFacadeClassList.add(TelecomManagerFacade.class);
+        sFacadeClassList.add(WifiRttManagerFacade.class);
+        sFacadeClassList.add(WifiScannerFacade.class);
+        sFacadeClassList.add(SubscriptionManagerFacade.class);
+        sFacadeClassList.add(TelecomCallFacade.class);
+        sFacadeClassList.add(CarrierConfigFacade.class);
+
+        /*Compatibility reset to >= Marshmallow */
+        if( sSdkLevel >= 23 ) {
+            //add new facades here
+            sFacadeClassList.add(WifiNanManagerFacade.class);
+        }
+
+        for (Class<? extends RpcReceiver> recieverClass : sFacadeClassList) {
+            for (MethodDescriptor rpcMethod : MethodDescriptor.collectFrom(recieverClass)) {
+                sRpcs.put(rpcMethod.getName(), rpcMethod);
+            }
+        }
+    }
+
+    private FacadeConfiguration() {
+        // Utility class.
+    }
+
+    public static int getSdkLevel() {
+        return sSdkLevel;
+    }
+
+    /** Returns a list of {@link MethodDescriptor} objects for all facades. */
+    public static List<MethodDescriptor> collectMethodDescriptors() {
+        return new ArrayList<MethodDescriptor>(sRpcs.values());
+    }
+
+    /**
+     * Returns a list of not deprecated {@link MethodDescriptor} objects for facades supported by
+     * the current SDK version.
+     */
+    public static List<MethodDescriptor> collectSupportedMethodDescriptors() {
+        List<MethodDescriptor> list = new ArrayList<MethodDescriptor>();
+        for (MethodDescriptor descriptor : sRpcs.values()) {
+            Method method = descriptor.getMethod();
+            if (method.isAnnotationPresent(RpcDeprecated.class)) {
+                continue;
+            } else if (method.isAnnotationPresent(RpcMinSdk.class)) {
+                int requiredSdkLevel = method.getAnnotation(RpcMinSdk.class).value();
+                if (sSdkLevel < requiredSdkLevel) {
+                    continue;
+                }
+            }
+            list.add(descriptor);
+        }
+        return list;
+    }
+
+    public static Map<String, MethodDescriptor> collectStartEventMethodDescriptors() {
+        Map<String, MethodDescriptor> map = Maps.newHashMap();
+        for (MethodDescriptor descriptor : sRpcs.values()) {
+            Method method = descriptor.getMethod();
+            if (method.isAnnotationPresent(RpcStartEvent.class)) {
+                String eventName = method.getAnnotation(RpcStartEvent.class).value();
+                if (map.containsKey(eventName)) {
+                    Log.d("Duplicate eventName " + eventName);
+                    throw new RuntimeException("Duplicate start event method descriptor found.");
+                }
+                map.put(eventName, descriptor);
+            }
+        }
+        return map;
+    }
+
+    public static Map<String, MethodDescriptor> collectStopEventMethodDescriptors() {
+        Map<String, MethodDescriptor> map = Maps.newHashMap();
+        for (MethodDescriptor descriptor : sRpcs.values()) {
+            Method method = descriptor.getMethod();
+            if (method.isAnnotationPresent(RpcStopEvent.class)) {
+                String eventName = method.getAnnotation(RpcStopEvent.class).value();
+                if (map.containsKey(eventName)) {
+                    throw new RuntimeException("Duplicate stop event method descriptor found.");
+                }
+                map.put(eventName, descriptor);
+            }
+        }
+        return map;
+    }
+
+    /** Returns a method by name. */
+    public static MethodDescriptor getMethodDescriptor(String name) {
+        return sRpcs.get(name);
+    }
+
+    public static Collection<Class<? extends RpcReceiver>> getFacadeClasses() {
+        return sFacadeClassList;
+    }
+}
diff --git a/ScriptingLayer/src/com/googlecode/android_scripting/interpreter/InterpreterProcess.java b/ScriptingLayer/src/com/googlecode/android_scripting/interpreter/InterpreterProcess.java
new file mode 100644
index 0000000..52a12c0
--- /dev/null
+++ b/ScriptingLayer/src/com/googlecode/android_scripting/interpreter/InterpreterProcess.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import com.googlecode.android_scripting.AndroidProxy;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.Process;
+import com.googlecode.android_scripting.SimpleServer;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManagerFactory;
+
+import java.net.InetSocketAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+
+/**
+ * This is a skeletal implementation of an interpreter process.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class InterpreterProcess extends Process {
+
+  private final AndroidProxy mProxy;
+  private final Interpreter mInterpreter;
+  private String mCommand;
+
+  /**
+   * Creates a new {@link InterpreterProcess}.
+   *
+   * @param launchScript
+   *          the absolute path to a script that should be launched with the interpreter
+   * @param port
+   *          the port that the AndroidProxy is listening on
+   */
+  public InterpreterProcess(Interpreter interpreter, AndroidProxy proxy) {
+    mProxy = proxy;
+    mInterpreter = interpreter;
+
+    setBinary(interpreter.getBinary());
+    setName(interpreter.getNiceName());
+    setCommand(interpreter.getInteractiveCommand());
+    addAllArguments(interpreter.getArguments());
+    putAllEnvironmentVariables(System.getenv());
+    putEnvironmentVariable("AP_HOST", getHost());
+    putEnvironmentVariable("AP_PORT", Integer.toString(getPort()));
+    if (proxy.getSecret() != null) {
+      putEnvironmentVariable("AP_HANDSHAKE", getSecret());
+    }
+    putAllEnvironmentVariables(interpreter.getEnvironmentVariables());
+  }
+
+  protected void setCommand(String command) {
+    mCommand = command;
+  }
+
+  public Interpreter getInterpreter() {
+    return mInterpreter;
+  }
+
+  public String getHost() {
+    String result = mProxy.getAddress().getHostName();
+    if (result.equals("0.0.0.0")) { // Wildcard.
+      try {
+        return SimpleServer.getPublicInetAddress().getHostName();
+      } catch (UnknownHostException e) {
+        Log.i("public address", e);
+        e.printStackTrace();
+      } catch (SocketException e) {
+        Log.i("public address", e);
+      }
+    }
+    return result;
+  }
+
+  public int getPort() {
+    return mProxy.getAddress().getPort();
+  }
+
+  public InetSocketAddress getAddress() {
+    return mProxy.getAddress();
+  }
+
+  public String getSecret() {
+    return mProxy.getSecret();
+  }
+
+  public RpcReceiverManagerFactory getRpcReceiverManagerFactory() {
+    return mProxy.getRpcReceiverManagerFactory();
+  }
+
+  @Override
+  public void start(final Runnable shutdownHook) {
+    if (!mCommand.isEmpty()) {
+      addArgument(mCommand);
+    }
+    super.start(shutdownHook);
+  }
+
+  @Override
+  public void kill() {
+    super.kill();
+    mProxy.shutdown();
+  }
+
+  @Override
+  public String getWorkingDirectory() {
+    return InterpreterConstants.SDCARD_SL4A_ROOT;
+  }
+}
diff --git a/ScriptingLayer/src/com/googlecode/android_scripting/trigger/EventGenerationControllingObserver.java b/ScriptingLayer/src/com/googlecode/android_scripting/trigger/EventGenerationControllingObserver.java
new file mode 100644
index 0000000..0c38a0f
--- /dev/null
+++ b/ScriptingLayer/src/com/googlecode/android_scripting/trigger/EventGenerationControllingObserver.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.trigger;
+
+import com.google.common.collect.Maps;
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.trigger.TriggerRepository.TriggerRepositoryObserver;
+
+import java.util.Map;
+
+import org.json.JSONArray;
+
+/**
+ * A {@link TriggerRepositoryObserver} that starts and stops the monitoring of events depending on
+ * whether or not triggers for the event exist.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ */
+public class EventGenerationControllingObserver implements TriggerRepositoryObserver {
+  private final FacadeManager mFacadeManager;
+  private final Map<String, MethodDescriptor> mStartEventGeneratingMethodDescriptors;
+  private final Map<String, MethodDescriptor> mStopEventGeneratingMethodDescriptors;
+  private final Map<String, Integer> mEventTriggerRefCounts = Maps.newHashMap();
+
+  /**
+   * Creates a new StartEventMonitoringObserver for the given trigger repository.
+   *
+   * @param facadeManager
+   * @param triggerRepository
+   */
+  public EventGenerationControllingObserver(FacadeManager facadeManager) {
+    mFacadeManager = facadeManager;
+    mStartEventGeneratingMethodDescriptors =
+        FacadeConfiguration.collectStartEventMethodDescriptors();
+    mStopEventGeneratingMethodDescriptors = FacadeConfiguration.collectStopEventMethodDescriptors();
+  }
+
+  private synchronized int incrementAndGetRefCount(String eventName) {
+    int refCount =
+        (mEventTriggerRefCounts.containsKey(eventName)) ? mEventTriggerRefCounts.get(eventName) : 0;
+    refCount++;
+    mEventTriggerRefCounts.put(eventName, refCount);
+    return refCount;
+  }
+
+  private synchronized int decrementAndGetRefCount(String eventName) {
+    int refCount =
+        (mEventTriggerRefCounts.containsKey(eventName)) ? mEventTriggerRefCounts.get(eventName) : 0;
+    refCount--;
+    mEventTriggerRefCounts.put(eventName, refCount);
+    return refCount;
+  }
+
+  @Override
+  public synchronized void onPut(Trigger trigger) {
+    // If we're not already monitoring the events corresponding to this trigger, do so.
+    if (incrementAndGetRefCount(trigger.getEventName()) == 1) {
+      startMonitoring(trigger.getEventName());
+    }
+  }
+
+  @Override
+  public synchronized void onRemove(Trigger trigger) {
+    // If there are no more triggers listening to this event, then we need to stop monitoring.
+    if (decrementAndGetRefCount(trigger.getEventName()) == 1) {
+      stopMonitoring(trigger.getEventName());
+    }
+  }
+
+  private void startMonitoring(String eventName) {
+    MethodDescriptor startEventGeneratingMethod =
+        mStartEventGeneratingMethodDescriptors.get(eventName);
+    try {
+      startEventGeneratingMethod.invoke(mFacadeManager, new JSONArray());
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+  }
+
+  private void stopMonitoring(String eventName) {
+    MethodDescriptor stopEventGeneratingMethod =
+        mStopEventGeneratingMethodDescriptors.get(eventName);
+    try {
+      stopEventGeneratingMethod.invoke(mFacadeManager, new JSONArray());
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/Android.mk b/ScriptingLayerForAndroid/Android.mk
new file mode 100644
index 0000000..79f66c3
--- /dev/null
+++ b/ScriptingLayerForAndroid/Android.mk
@@ -0,0 +1,59 @@
+#
+#  Copyright (C) 2016 Google, Inc.
+#
+#  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.
+#
+
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_PACKAGE_NAME := sl4a
+LOCAL_MODULE_OWNER := google
+LOCAL_DEX_PREOPT := false
+
+LOCAL_CERTIFICATE := platform
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res
+
+LOCAL_AAPT_FLAGS := --auto-add-overlay
+
+LOCAL_MULTILIB := both
+
+# Builds on the Data Partition
+LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_APPS)
+
+LOCAL_STATIC_JAVA_LIBRARIES := guava android-common locale_platform android-support-v4
+LOCAL_STATIC_JAVA_LIBRARIES += sl4a.Utils sl4a.Common
+LOCAL_STATIC_JAVA_LIBRARIES += sl4a.InterpreterForAndroid sl4a.ScriptingLayer
+
+LOCAL_PRIVILEGED_MODULE := true
+LOCAL_PROGUARD_ENABLED := disabled
+
+
+LOCAL_JNI_SHARED_LIBRARIES := libcom_googlecode_android_scripting_Exec
+
+include $(PREBUILT_SHARED_LIBRARY)
+
+include $(BUILD_PACKAGE)
+
+include $(CLEAR_VARS)
+LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES := locale_platform:libs/locale_platform.jar
+include $(BUILD_MULTI_PREBUILT)
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
+
diff --git a/ScriptingLayerForAndroid/AndroidManifest.xml b/ScriptingLayerForAndroid/AndroidManifest.xml
new file mode 100644
index 0000000..cc9f2b8
--- /dev/null
+++ b/ScriptingLayerForAndroid/AndroidManifest.xml
@@ -0,0 +1,220 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+/*
+** Copyright 2016, The Android Open Source Project
+**
+** 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.
+*/
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.googlecode.android_scripting"
+    android:sharedUserId="android.uid.system">
+
+    <uses-permission android:name="com.android.permission.WHITELIST_BLUETOOTH_DEVICE"
+        android:protectionLevel="signature" />
+    <uses-permission android:name="android.permission.ACCESS_BLUETOOTH_SHARE"
+        android:protectionLevel="signature" />
+    <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.BIND_INCALL_SERVICE" />
+    <uses-permission android:name="android.permission.CALL_PHONE" />
+    <uses-permission android:name="android.permission.CALL_PRIVILEGED" />
+    <uses-permission android:name="android.permission.CONTROL_INCALL_EXPERIENCE" />
+    <uses-permission android:name="android.permission.CONNECTIVITY_INTERNAL" />
+    <uses-permission android:name="android.permission.LOCATION_HARDWARE" />
+    <uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.RECEIVE_SMS" />
+    <uses-permission android:name="android.permission.SEND_SMS" />
+    <uses-permission android:name="android.permission.READ_SMS" />
+    <uses-permission android:name="android.permission.WRITE_SMS" />
+    <uses-permission android:name="android.permission.RECEIVE_MMS" />
+    <uses-permission android:name="android.permission.BROADCAST_WAP_PUSH" />
+    <uses-permission android:name="android.permission.RECEIVE_WAP_PUSH" />
+    <uses-permission android:name="android.permission.WRITE_APN_SETTINGS" />
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>
+    <uses-permission android:name="android.permission.PERSISTENT_ACTIVITY" />
+    <uses-permission android:name="android.permission.RESTART_PACKAGES" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.READ_LOGS" />
+    <uses-permission android:name="android.permission.REAL_GET_TASKS" />
+    <uses-permission android:name="android.permission.WRITE_SETTINGS" />
+    <uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED" />
+    <uses-permission android:name="android.permission.BLUETOOTH_MAP" />
+    <uses-permission android:name="android.permission.BLUETOOTH_STACK" />
+    <uses-permission android:name="android.permission.NET_ADMIN" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.DEVICE_POWER" />
+    <uses-permission android:name="android.permission.CHANGE_CONFIGURATION" />
+    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
+    <uses-permission android:name="android.permission.NFC" />
+    <uses-permission android:name="android.permission.HARDWARE_TEST" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.MASTER_CLEAR" />
+    <uses-permission android:name="android.permission.USE_CREDENTIALS" />
+    <uses-permission android:name="android.permission.ACCESS_DOWNLOAD_MANAGER" />
+    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
+    <uses-permission android:name="android.permission.ACCESS_WIMAX_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIMAX_STATE" />
+    <uses-permission android:name="com.android.certinstaller.INSTALL_AS_USER" />
+    <uses-permission android:name="android.permission.CLEAR_APP_USER_DATA" />
+    <uses-permission android:name="android.permission.MODIFY_PHONE_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" />
+    <uses-permission android:name="android.permission.READ_USER_DICTIONARY" />
+    <uses-permission android:name="android.permission.WRITE_USER_DICTIONARY" />
+    <uses-permission android:name="android.permission.FORCE_STOP_PACKAGES" />
+    <uses-permission android:name="android.permission.PACKAGE_USAGE_STATS" />
+    <uses-permission android:name="android.permission.BATTERY_STATS" />
+    <uses-permission android:name="android.permission.MOVE_PACKAGE" />
+    <uses-permission android:name="android.permission.BACKUP" />
+    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS" />
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
+    <uses-permission android:name="android.permission.READ_SYNC_STATS" />
+    <uses-permission android:name="android.permission.STATUS_BAR" />
+    <uses-permission android:name="android.permission.MANAGE_USB" />
+    <uses-permission android:name="android.permission.SET_POINTER_SPEED" />
+    <uses-permission android:name="android.permission.SET_KEYBOARD_LAYOUT" />
+    <uses-permission android:name="android.permission.INTERACT_ACROSS_USERS_FULL" />
+    <uses-permission android:name="android.permission.COPY_PROTECTED_DATA" />
+    <uses-permission android:name="android.permission.MANAGE_USERS" />
+    <uses-permission android:name="android.permission.READ_PROFILE" />
+    <uses-permission android:name="android.permission.CONFIGURE_WIFI_DISPLAY" />
+    <uses-permission android:name="android.permission.SET_TIME" />
+    <uses-permission android:name="android.permission.SET_TIME_ZONE" />
+    <uses-permission android:name="android.permission.ACCESS_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.REBOOT" />
+    <uses-permission android:name="android.permission.MANAGE_DEVICE_ADMINS" />
+    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.READ_PRECISE_PHONE_STATE" />
+    <uses-permission android:name="android.permission.READ_PRIVILEGED_PHONE_STATE" />
+    <uses-permission android:name="android.permission.MEDIA_CONTENT_CONTROL" />
+    <uses-permission android:name="android.permission.RECEIVE_EMERGENCY_BROADCAST"/>
+    <application android:icon="@drawable/sl4a_logo_48" android:label="@string/application_title" android:name=".Sl4aApplication"
+        android:theme="@android:style/Theme.DeviceDefault">
+        <activity android:name=".activity.ScriptManager" android:configChanges="keyboardHidden|orientation" android:windowSoftInputMode="adjustResize" android:launchMode="singleTop">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.SEARCH" />
+            </intent-filter>
+            <meta-data android:name="android.app.searchable" android:resource="@xml/searchable_scripts" />
+        </activity>
+        <activity android:name=".activity.ScriptPicker" android:configChanges="keyboardHidden|orientation" android:label="Scripts">
+            <intent-filter>
+                <action android:name="android.intent.action.CREATE_SHORTCUT" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.PICK" />
+                <data android:scheme="content" android:path="sl4a/scripts" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity android:name=".activity.InterpreterPicker" android:configChanges="keyboardHidden|orientation" android:label="Interpreters">
+            <intent-filter>
+                <action android:name="android.intent.action.CREATE_SHORTCUT" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity-alias android:name="LocalePlugin" android:targetActivity=".activity.ScriptPicker" android:label="@string/application_title" android:icon="@drawable/sl4a_logo_32">
+            <intent-filter>
+                <action android:name="com.twofortyfouram.locale.intent.action.EDIT_SETTING" />
+            </intent-filter>
+        </activity-alias>
+        <receiver android:name=".locale.LocaleReceiver">
+            <intent-filter>
+                <action android:name="com.twofortyfouram.locale.intent.action.FIRE_SETTING" />
+            </intent-filter>
+        </receiver>
+        <activity android:name=".activity.Preferences" android:theme="@android:style/Theme.DeviceDefault.Settings" />
+        <activity android:name="org.connectbot.ConsoleActivity" android:theme="@android:style/Theme.DeviceDefault.NoActionBar" android:configChanges="keyboardHidden|orientation" android:windowSoftInputMode="stateAlwaysVisible|adjustResize" android:finishOnTaskLaunch="true" android:launchMode="singleTask" />
+        <activity android:name=".activity.ScriptEditor" android:theme="@android:style/Theme.DeviceDefault.NoActionBar" android:configChanges="keyboardHidden|orientation" android:windowSoftInputMode="stateAlwaysVisible|adjustResize">
+            <intent-filter>
+                <action android:name="com.googlecode.android_scripting.action.EDIT_SCRIPT" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity android:name=".activity.ApiBrowser" android:configChanges="keyboardHidden|orientation" android:launchMode="singleTop" android:windowSoftInputMode="adjustResize">
+            <intent-filter>
+                <action android:name="android.intent.action.SEARCH" />
+            </intent-filter>
+            <meta-data android:name="android.app.searchable" android:resource="@xml/searchable_apis" />
+        </activity>
+        <activity android:name=".activity.ApiPrompt" android:theme="@android:style/Theme.DeviceDefault.NoActionBar" android:configChanges="keyboardHidden|orientation" />
+        <activity android:name=".activity.TriggerManager" android:launchMode="singleTask" android:configChanges="keyboardHidden|orientation" />
+        <activity android:name=".activity.BluetoothDeviceList" android:configChanges="keyboardHidden|orientation" />
+        <activity android:name=".activity.ScriptingLayerServiceLauncher" android:taskAffinity="" android:theme="@android:style/Theme.DeviceDefault.NoActionBar.TranslucentDecor">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity android:name=".activity.FutureActivity" android:configChanges="keyboardHidden|orientation" android:theme="@android:style/Theme.DeviceDefault.NoActionBar.TranslucentDecor" />
+        <activity android:name="org.connectbot.HelpActivity" android:configChanges="keyboardHidden|orientation" />
+        <activity android:name="org.connectbot.HelpTopicActivity" android:configChanges="keyboardHidden|orientation" />
+        <service android:name=".activity.ScriptingLayerService" />
+        <service android:name=".activity.TriggerService" />
+        <service android:name="com.googlecode.android_scripting.facade.telephony.InCallServiceImpl"
+                 android:permission="android.permission.BIND_INCALL_SERVICE" >
+            <intent-filter>
+                <action android:name="android.telecom.InCallService"/>
+            </intent-filter>
+        </service>
+        <service android:name=".service.FacadeService" android:enabled="true" android:exported="true" >
+            <intent-filter>
+                <action android:name="com.googlecode.android_scripting.service.FacadeService.ACTION_BIND" />
+            </intent-filter>
+        </service>
+        <activity android:name=".activity.InterpreterManager" android:launchMode="singleTask" android:configChanges="keyboardHidden|orientation" />
+        <activity android:name=".activity.LogcatViewer" android:launchMode="singleTask" android:configChanges="keyboardHidden|orientation" />
+        <activity android:name=".activity.ScriptsLiveFolder" android:label="Scripts" android:icon="@drawable/live_folder" android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.CREATE_LIVE_FOLDER" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <provider android:name=".provider.ScriptProvider" android:authorities="com.googlecode.android_scripting.provider.scriptprovider" />
+        <provider android:name=".provider.ApiProvider" android:authorities="com.googlecode.android_scripting.provider.apiprovider" />
+        <provider
+            android:name="android.support.v4.content.FileProvider"
+            android:authorities="com.googlecode.android_scripting.provider.telephonytestprovider"
+            android:grantUriPermissions="true"
+            android:exported="false">
+            <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/paths" />
+        </provider>
+        <uses-library android:name="android.test.runner" />
+        <activity android:name=".activity.ScriptProcessMonitor" android:launchMode="singleTask" android:finishOnTaskLaunch="true" />
+        <activity android:configChanges="keyboardHidden|orientation" android:name="org.connectbot.util.ColorsActivity" android:theme="@android:style/Theme.DeviceDefault.Dialog">
+            <intent-filter>
+                <action android:name="com.googlecode.android_scripting.PICK_TERMINAL_COLORS" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
diff --git a/ScriptingLayerForAndroid/jni/Android.mk b/ScriptingLayerForAndroid/jni/Android.mk
new file mode 100644
index 0000000..541aafb
--- /dev/null
+++ b/ScriptingLayerForAndroid/jni/Android.mk
@@ -0,0 +1,37 @@
+#
+#  Copyright (C) 2016 Google, Inc.
+#
+#  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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := com_googlecode_android_scripting_Exec.cpp
+
+LOCAL_CFLAGS += -Wno-unused-parameter
+
+LOCAL_C_INCLUDES += \
+    $(JNI_H_INCLUDE) \
+
+LOCAL_SHARED_LIBRARIES := \
+    libandroid_runtime \
+    libnativehelper \
+    libcutils \
+    libutils \
+    liblog
+
+LOCAL_MODULE    := libcom_googlecode_android_scripting_Exec
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/ScriptingLayerForAndroid/jni/com_googlecode_android_scripting_Exec.cpp b/ScriptingLayerForAndroid/jni/com_googlecode_android_scripting_Exec.cpp
new file mode 100644
index 0000000..495f27a
--- /dev/null
+++ b/ScriptingLayerForAndroid/jni/com_googlecode_android_scripting_Exec.cpp
@@ -0,0 +1,202 @@
+//
+//  Copyright (C) 2016 Google, Inc.
+//
+//  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.
+//
+
+#include "com_googlecode_android_scripting_Exec.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <termios.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+ 
+#include "android/log.h"
+
+#define LOG_TAG "Exec"
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+int CreateSubprocess(const char* cmd, char* args[], char* vars[], char *wkdir, pid_t* pid) {
+  char* devname;
+  int ptm = open("/dev/ptmx", O_RDWR);
+  if(ptm < 0){
+    LOGE("Cannot open /dev/ptmx: %s\n", strerror(errno));
+    return -1;
+  }
+  fcntl(ptm, F_SETFD, FD_CLOEXEC);
+
+  if (grantpt(ptm) || unlockpt(ptm) ||
+      ((devname = (char*) ptsname(ptm)) == 0)) {
+    LOGE("Trouble with /dev/ptmx: %s\n", strerror(errno));
+    return -1;
+  }
+
+  *pid = fork();
+  if(*pid < 0) {
+    LOGE("Fork failed: %s\n", strerror(errno));
+    return -1;
+  }
+
+  if(*pid == 0){
+    int pts;
+    setsid();
+    pts = open(devname, O_RDWR);
+    if(pts < 0) {
+      exit(-1);
+    }
+    dup2(pts, 0);
+    dup2(pts, 1);
+    dup2(pts, 2);
+    close(ptm);
+    if (wkdir) chdir(wkdir);
+    execve(cmd, args, vars);
+    exit(-1);
+  } else {
+    return ptm;
+  }
+}
+
+void JNU_ThrowByName(JNIEnv* env, const char* name, const char* msg) {
+  jclass clazz = env->FindClass(name);
+  if (clazz != NULL) {
+    env->ThrowNew(clazz, msg);
+  }
+  env->DeleteLocalRef(clazz);
+}
+
+char* JNU_GetStringNativeChars(JNIEnv* env, jstring jstr) {
+  if (jstr == NULL) {
+    return NULL;
+  }
+  jbyteArray bytes = 0;
+  jthrowable exc;
+  char* result = 0;
+  if (env->EnsureLocalCapacity(2) < 0) {
+    return 0; /* out of memory error */
+  }
+  jclass Class_java_lang_String = env->FindClass("java/lang/String");
+  jmethodID MID_String_getBytes = env->GetMethodID(
+      Class_java_lang_String, "getBytes", "()[B");
+  bytes = (jbyteArray) env->CallObjectMethod(jstr, MID_String_getBytes);
+  exc = env->ExceptionOccurred();
+  if (!exc) {
+    jint len = env->GetArrayLength(bytes);
+    result = (char*) malloc(len + 1);
+    if (result == 0) {
+      JNU_ThrowByName(env, "java/lang/OutOfMemoryError", 0);
+      env->DeleteLocalRef(bytes);
+      return 0;
+    }
+    env->GetByteArrayRegion(bytes, 0, len, (jbyte*) result);
+    result[len] = 0; /* NULL-terminate */
+  } else {
+    env->DeleteLocalRef(exc);
+  }
+  env->DeleteLocalRef(bytes);
+  return result;
+}
+
+int JNU_GetFdFromFileDescriptor(JNIEnv* env, jobject fileDescriptor) {
+  jclass Class_java_io_FileDescriptor = env->FindClass("java/io/FileDescriptor");
+  jfieldID descriptor = env->GetFieldID(Class_java_io_FileDescriptor, "descriptor", "I");
+  return env->GetIntField(fileDescriptor, descriptor);
+}
+
+JNIEXPORT jobject JNICALL Java_com_googlecode_android_1scripting_Exec_createSubprocess(
+    JNIEnv* env, jclass clazz, jstring cmd, jobjectArray argArray, jobjectArray varArray,
+    jstring workingDirectory,
+    jintArray processIdArray) {
+  char* cmd_native = JNU_GetStringNativeChars(env, cmd);
+  char* wkdir_native = JNU_GetStringNativeChars(env, workingDirectory);
+  pid_t pid;
+  jsize len = 0;
+  if (argArray) {
+    len = env->GetArrayLength(argArray);
+  }
+  char* args[len + 2];
+  args[0] = cmd_native;
+  for (int i = 0; i < len; i++) {
+    jstring arg = (jstring) env->GetObjectArrayElement(argArray, i);
+    char* arg_native = JNU_GetStringNativeChars(env, arg);
+    args[i + 1] = arg_native;
+  }
+  args[len + 1] = NULL;
+
+  len = 0;
+  if (varArray) {
+    len = env->GetArrayLength(varArray);
+  }
+  char* vars[len + 1];
+  for (int i = 0; i < len; i++) {
+    jstring var = (jstring) env->GetObjectArrayElement(varArray, i);
+    char* var_native = JNU_GetStringNativeChars(env, var);
+    vars[i] = var_native;
+  }
+  vars[len] = NULL;
+
+  int ptm = CreateSubprocess(cmd_native, args, vars, wkdir_native, &pid);
+  if (processIdArray) {
+    if (env->GetArrayLength(processIdArray) > 0) {
+      jboolean isCopy;
+      int* proccessId = (int*) env->GetPrimitiveArrayCritical(processIdArray, &isCopy);
+      if (proccessId) {
+        *proccessId = (int) pid;
+        env->ReleasePrimitiveArrayCritical(processIdArray, proccessId, 0);
+      }
+    }
+  }
+
+  jclass Class_java_io_FileDescriptor =
+      env->FindClass("java/io/FileDescriptor");
+  jmethodID init = env->GetMethodID(Class_java_io_FileDescriptor, "<init>", "()V");
+  jobject result = env->NewObject(Class_java_io_FileDescriptor, init);
+
+  if (!result) {
+    LOGE("Couldn't create a FileDescriptor.");
+  } else {
+    jfieldID descriptor = env->GetFieldID(Class_java_io_FileDescriptor, "descriptor", "I");
+    env->SetIntField(result, descriptor, ptm);
+  }
+  return result;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_android_1scripting_Exec_setPtyWindowSize(
+    JNIEnv* env, jclass clazz, jobject fileDescriptor, jint row, jint col, jint xpixel,
+    jint ypixel) {
+  struct winsize sz;
+  int fd = JNU_GetFdFromFileDescriptor(env, fileDescriptor);
+  if (env->ExceptionOccurred() != NULL) {
+    return;
+  }
+  sz.ws_row = row;
+  sz.ws_col = col;
+  sz.ws_xpixel = xpixel;
+  sz.ws_ypixel = ypixel;
+  ioctl(fd, TIOCSWINSZ, &sz);
+}
+
+JNIEXPORT jint JNICALL Java_com_googlecode_android_1scripting_Exec_waitFor(JNIEnv* env, jclass clazz, jint procId) {
+  int status;
+  waitpid(procId, &status, 0);
+  int result = 0;
+  if (WIFEXITED(status)) {
+    result = WEXITSTATUS(status);
+  }
+  return result;
+}
diff --git a/ScriptingLayerForAndroid/jni/com_googlecode_android_scripting_Exec.h b/ScriptingLayerForAndroid/jni/com_googlecode_android_scripting_Exec.h
new file mode 100644
index 0000000..6f6d422
--- /dev/null
+++ b/ScriptingLayerForAndroid/jni/com_googlecode_android_scripting_Exec.h
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_googlecode_android_scripting_Exec */
+
+#ifndef _Included_com_googlecode_android_scripting_Exec
+#define _Included_com_googlecode_android_scripting_Exec
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_googlecode_android_scripting_Exec
+ * Method:    createSubprocess
+ * Signature: (Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;[I)Ljava/io/FileDescriptor;
+ */
+JNIEXPORT jobject JNICALL Java_com_googlecode_android_1scripting_Exec_createSubprocess
+  (JNIEnv *, jclass, jstring, jobjectArray, jobjectArray, jstring, jintArray);
+
+/*
+ * Class:     com_googlecode_android_scripting_Exec
+ * Method:    setPtyWindowSize
+ * Signature: (Ljava/io/FileDescriptor;IIII)V
+ */
+JNIEXPORT void JNICALL Java_com_googlecode_android_1scripting_Exec_setPtyWindowSize
+  (JNIEnv *, jclass, jobject, jint, jint, jint, jint);
+
+/*
+ * Class:     com_googlecode_android_scripting_Exec
+ * Method:    waitFor
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_com_googlecode_android_1scripting_Exec_waitFor
+  (JNIEnv *, jclass, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/ScriptingLayerForAndroid/libs/locale_platform.jar b/ScriptingLayerForAndroid/libs/locale_platform.jar
new file mode 100644
index 0000000..4697825
--- /dev/null
+++ b/ScriptingLayerForAndroid/libs/locale_platform.jar
Binary files differ
diff --git a/ScriptingLayerForAndroid/proguard.flags b/ScriptingLayerForAndroid/proguard.flags
new file mode 100644
index 0000000..93a2728
--- /dev/null
+++ b/ScriptingLayerForAndroid/proguard.flags
@@ -0,0 +1,5 @@
+
+-libraryjars libs
+
+-keep class net.londatiga.android.**{*;}
+
diff --git a/ScriptingLayerForAndroid/res/anim/fade_out_delayed.xml b/ScriptingLayerForAndroid/res/anim/fade_out_delayed.xml
new file mode 100644
index 0000000..20ca839
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/fade_out_delayed.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<alpha xmlns:android="http://schemas.android.com/apk/res/android"
+	android:fromAlpha="1.0"
+	android:toAlpha="0.0"
+	android:duration="500"
+	android:startOffset="1000"
+	android:fillAfter="true"
+	/>
diff --git a/ScriptingLayerForAndroid/res/anim/fade_stay_hidden.xml b/ScriptingLayerForAndroid/res/anim/fade_stay_hidden.xml
new file mode 100644
index 0000000..e62ca8b
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/fade_stay_hidden.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<alpha xmlns:android="http://schemas.android.com/apk/res/android"
+	android:fromAlpha="0.0"
+	android:toAlpha="0.0"
+	android:duration="500"
+	android:fillAfter="true"
+	/>
diff --git a/ScriptingLayerForAndroid/res/anim/keyboard_fade_in.xml b/ScriptingLayerForAndroid/res/anim/keyboard_fade_in.xml
new file mode 100644
index 0000000..edd5b94
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/keyboard_fade_in.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<alpha xmlns:android="http://schemas.android.com/apk/res/android"
+	android:interpolator="@android:anim/accelerate_interpolator"
+	android:fromAlpha="0.0"
+	android:toAlpha="1.0"
+	android:duration="100" />
diff --git a/ScriptingLayerForAndroid/res/anim/keyboard_fade_out.xml b/ScriptingLayerForAndroid/res/anim/keyboard_fade_out.xml
new file mode 100644
index 0000000..1f37d32
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/keyboard_fade_out.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<alpha xmlns:android="http://schemas.android.com/apk/res/android"
+	android:interpolator="@android:anim/accelerate_interpolator"
+	android:fromAlpha="1.0"
+	android:toAlpha="0.0"
+	android:duration="100" />
diff --git a/ScriptingLayerForAndroid/res/anim/slide_left_in.xml b/ScriptingLayerForAndroid/res/anim/slide_left_in.xml
new file mode 100644
index 0000000..29a0048
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/slide_left_in.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+	<translate android:fromXDelta="100%p" android:toXDelta="0" android:duration="300"/>
+	<!--  <alpha android:fromAlpha="0.0" android:toAlpha="1.0" android:duration="300" />  -->
+</set>
diff --git a/ScriptingLayerForAndroid/res/anim/slide_left_out.xml b/ScriptingLayerForAndroid/res/anim/slide_left_out.xml
new file mode 100644
index 0000000..9c46442
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/slide_left_out.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+	<translate android:fromXDelta="0" android:toXDelta="-100%p" android:duration="300"/>
+	<!--  <alpha android:fromAlpha="0.0" android:toAlpha="1.0" android:duration="300" />  -->
+</set>
diff --git a/ScriptingLayerForAndroid/res/anim/slide_right_in.xml b/ScriptingLayerForAndroid/res/anim/slide_right_in.xml
new file mode 100644
index 0000000..0d52c9f
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/slide_right_in.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+	<translate android:fromXDelta="-100%p" android:toXDelta="0" android:duration="300"/>
+	<!--  <alpha android:fromAlpha="0.0" android:toAlpha="1.0" android:duration="300" />  -->
+</set>
diff --git a/ScriptingLayerForAndroid/res/anim/slide_right_out.xml b/ScriptingLayerForAndroid/res/anim/slide_right_out.xml
new file mode 100644
index 0000000..ace4e9d
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/anim/slide_right_out.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+	<translate android:fromXDelta="0" android:toXDelta="100%p" android:duration="300"/>
+	<!--  <alpha android:fromAlpha="0.0" android:toAlpha="1.0" android:duration="300" />  -->
+</set>
diff --git a/ScriptingLayerForAndroid/res/drawable/atari_small.png b/ScriptingLayerForAndroid/res/drawable/atari_small.png
new file mode 100644
index 0000000..535e295
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/atari_small.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/atari_small_notice.txt b/ScriptingLayerForAndroid/res/drawable/atari_small_notice.txt
new file mode 100644
index 0000000..afa8539
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/atari_small_notice.txt
@@ -0,0 +1,11 @@
+COMMENT  Copyright (c) 1999, Thomas A. Fine
+COMMENT
+COMMENT  License to copy, modify, and distribute for both commercial and
+COMMENT  non-commercial use is herby granted, provided this notice
+COMMENT  is preserved.
+COMMENT
+COMMENT  Email to my last name at head.cfa.harvard.edu
+COMMENT  http://hea-www.harvard.edu/~fine/
+COMMENT
+COMMENT  Produced with bdfedit, a tcl/tk font editing program
+COMMENT  written by Thomas A. Fine
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/drawable/background.png b/ScriptingLayerForAndroid/res/drawable/background.png
new file mode 100644
index 0000000..d0fc14f
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/background.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/bsh_icon.png b/ScriptingLayerForAndroid/res/drawable/bsh_icon.png
new file mode 100644
index 0000000..1d73eb5
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/bsh_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/file_bg.png b/ScriptingLayerForAndroid/res/drawable/file_bg.png
new file mode 100644
index 0000000..949613c
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/file_bg.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/folder.png b/ScriptingLayerForAndroid/res/drawable/folder.png
new file mode 100644
index 0000000..6333914
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/folder.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/html_icon.png b/ScriptingLayerForAndroid/res/drawable/html_icon.png
new file mode 100644
index 0000000..c86bee0
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/html_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/ic_dialog_time.png b/ScriptingLayerForAndroid/res/drawable/ic_dialog_time.png
new file mode 100644
index 0000000..3ce2751
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/ic_dialog_time.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/ic_menu_close_clear_cancel.png b/ScriptingLayerForAndroid/res/drawable/ic_menu_close_clear_cancel.png
new file mode 100644
index 0000000..619858c
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/ic_menu_close_clear_cancel.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/ic_menu_refresh.png b/ScriptingLayerForAndroid/res/drawable/ic_menu_refresh.png
new file mode 100644
index 0000000..77d70dd
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/ic_menu_refresh.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/ic_menu_search.png b/ScriptingLayerForAndroid/res/drawable/ic_menu_search.png
new file mode 100644
index 0000000..94446db
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/ic_menu_search.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/js_icon.png b/ScriptingLayerForAndroid/res/drawable/js_icon.png
new file mode 100644
index 0000000..86d2504
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/js_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/keyboard_icon.png b/ScriptingLayerForAndroid/res/drawable/keyboard_icon.png
new file mode 100644
index 0000000..9205d8b
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/keyboard_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/live_folder.png b/ScriptingLayerForAndroid/res/drawable/live_folder.png
new file mode 100644
index 0000000..3dac86a
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/live_folder.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/lua_icon.png b/ScriptingLayerForAndroid/res/drawable/lua_icon.png
new file mode 100644
index 0000000..0a7a2f3
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/lua_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/nut_icon.png b/ScriptingLayerForAndroid/res/drawable/nut_icon.png
new file mode 100644
index 0000000..06ef267
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/nut_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/pl_icon.png b/ScriptingLayerForAndroid/res/drawable/pl_icon.png
new file mode 100644
index 0000000..7265f46
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/pl_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/py_icon.png b/ScriptingLayerForAndroid/res/drawable/py_icon.png
new file mode 100644
index 0000000..0dcbc64
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/py_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/rb_icon.png b/ScriptingLayerForAndroid/res/drawable/rb_icon.png
new file mode 100644
index 0000000..8c33c29
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/rb_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/script_logo_48.png b/ScriptingLayerForAndroid/res/drawable/script_logo_48.png
new file mode 100644
index 0000000..488ed82
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/script_logo_48.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sh_icon.png b/ScriptingLayerForAndroid/res/drawable/sh_icon.png
new file mode 100644
index 0000000..6469c34
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sh_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_32.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_32.png
new file mode 100644
index 0000000..8fb9e6d
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_32.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48.png
new file mode 100644
index 0000000..488ed82
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_10.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_10.png
new file mode 100644
index 0000000..feac584
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_10.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_2.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_2.png
new file mode 100644
index 0000000..400d3b4
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_2.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_3.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_3.png
new file mode 100644
index 0000000..f666771
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_3.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_4.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_4.png
new file mode 100644
index 0000000..9021173
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_4.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_5.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_5.png
new file mode 100644
index 0000000..c40a9ae
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_5.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_6.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_6.png
new file mode 100644
index 0000000..a428da4
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_6.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_7.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_7.png
new file mode 100644
index 0000000..b515c3a
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_7.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_8.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_8.png
new file mode 100644
index 0000000..6474542
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_8.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_9.png b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_9.png
new file mode 100644
index 0000000..6c6ffd5
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_logo_48_9.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/sl4a_notification_logo.xml b/ScriptingLayerForAndroid/res/drawable/sl4a_notification_logo.xml
new file mode 100644
index 0000000..cea5465
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl4a_notification_logo.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<level-list xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:maxLevel="1" android:drawable="@drawable/sl4a_logo_48" />
+  <item android:maxLevel="2" android:drawable="@drawable/sl4a_logo_48_2" />
+  <item android:maxLevel="3" android:drawable="@drawable/sl4a_logo_48_3" />
+  <item android:maxLevel="4" android:drawable="@drawable/sl4a_logo_48_4" />
+  <item android:maxLevel="5" android:drawable="@drawable/sl4a_logo_48_5" />
+  <item android:maxLevel="6" android:drawable="@drawable/sl4a_logo_48_6" />
+  <item android:maxLevel="7" android:drawable="@drawable/sl4a_logo_48_7" />
+  <item android:maxLevel="8" android:drawable="@drawable/sl4a_logo_48_8" />
+  <item android:maxLevel="9" android:drawable="@drawable/sl4a_logo_48_9" />
+  <item android:maxLevel="2147483647" android:drawable="@drawable/sl4a_logo_48_10" />
+</level-list>
diff --git a/ScriptingLayerForAndroid/res/drawable/sl_icon.png b/ScriptingLayerForAndroid/res/drawable/sl_icon.png
new file mode 100644
index 0000000..a85ef87
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/sl_icon.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/stat_sys_warning.png b/ScriptingLayerForAndroid/res/drawable/stat_sys_warning.png
new file mode 100644
index 0000000..be00f47
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/stat_sys_warning.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/terminal.png b/ScriptingLayerForAndroid/res/drawable/terminal.png
new file mode 100644
index 0000000..9e25569
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/terminal.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_down_btn.xml b/ScriptingLayerForAndroid/res/drawable/timepicker_down_btn.xml
new file mode 100644
index 0000000..a0a566b
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_down_btn.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 The Android Open Source Project
+
+     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.
+-->
+<selector
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <item
+    android:state_pressed="false"
+    android:state_enabled="true"
+    android:state_focused="false"
+    android:drawable="@drawable/timepicker_down_normal" />
+  <item
+    android:state_pressed="true"
+    android:state_enabled="true"
+    android:drawable="@drawable/timepicker_down_pressed" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="true"
+    android:state_focused="true"
+    android:drawable="@drawable/timepicker_down_selected" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="false"
+    android:state_focused="false"
+    android:drawable="@drawable/timepicker_down_disabled" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="false"
+    android:state_focused="true"
+    android:drawable="@drawable/timepicker_down_disabled_focused" />
+</selector>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_down_disabled.png b/ScriptingLayerForAndroid/res/drawable/timepicker_down_disabled.png
new file mode 100644
index 0000000..af72d22
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_down_disabled.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_down_disabled_focused.png b/ScriptingLayerForAndroid/res/drawable/timepicker_down_disabled_focused.png
new file mode 100644
index 0000000..2d80424
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_down_disabled_focused.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_down_normal.png b/ScriptingLayerForAndroid/res/drawable/timepicker_down_normal.png
new file mode 100644
index 0000000..c427fc3
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_down_normal.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_down_pressed.png b/ScriptingLayerForAndroid/res/drawable/timepicker_down_pressed.png
new file mode 100644
index 0000000..ac6ac53
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_down_pressed.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_down_selected.png b/ScriptingLayerForAndroid/res/drawable/timepicker_down_selected.png
new file mode 100644
index 0000000..f710b57
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_down_selected.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_input.xml b/ScriptingLayerForAndroid/res/drawable/timepicker_input.xml
new file mode 100644
index 0000000..df73ab2
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_input.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 The Android Open Source Project
+
+     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.
+-->
+<selector
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <item
+    android:state_pressed="false"
+    android:state_enabled="true"
+    android:state_focused="false"
+    android:drawable="@drawable/timepicker_input_normal" />
+  <item
+    android:state_pressed="true"
+    android:state_enabled="true"
+    android:drawable="@drawable/timepicker_input_pressed" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="true"
+    android:state_focused="true"
+    android:drawable="@drawable/timepicker_input_selected" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="false"
+    android:state_focused="false"
+    android:drawable="@drawable/timepicker_input_disabled" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="false"
+    android:state_focused="true"
+    android:drawable="@drawable/timepicker_input_normal" />
+</selector>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_input_disabled.png b/ScriptingLayerForAndroid/res/drawable/timepicker_input_disabled.png
new file mode 100644
index 0000000..97da87a
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_input_disabled.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_input_normal.png b/ScriptingLayerForAndroid/res/drawable/timepicker_input_normal.png
new file mode 100644
index 0000000..eb101c5
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_input_normal.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_input_pressed.png b/ScriptingLayerForAndroid/res/drawable/timepicker_input_pressed.png
new file mode 100644
index 0000000..c83b1eb
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_input_pressed.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_input_selected.png b/ScriptingLayerForAndroid/res/drawable/timepicker_input_selected.png
new file mode 100644
index 0000000..e152848
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_input_selected.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_up_btn.xml b/ScriptingLayerForAndroid/res/drawable/timepicker_up_btn.xml
new file mode 100644
index 0000000..5be8d82
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_up_btn.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 The Android Open Source Project
+
+     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.
+-->
+<selector
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <item
+    android:state_pressed="false"
+    android:state_enabled="true"
+    android:state_focused="false"
+    android:drawable="@drawable/timepicker_up_normal" />
+  <item
+    android:state_pressed="true"
+    android:state_enabled="true"
+    android:drawable="@drawable/timepicker_up_pressed" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="true"
+    android:state_focused="true"
+    android:drawable="@drawable/timepicker_up_selected" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="false"
+    android:state_focused="false"
+    android:drawable="@drawable/timepicker_up_disabled" />
+  <item
+    android:state_pressed="false"
+    android:state_enabled="false"
+    android:state_focused="true"
+    android:drawable="@drawable/timepicker_up_disabled_focused" />
+</selector>
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_up_disabled.png b/ScriptingLayerForAndroid/res/drawable/timepicker_up_disabled.png
new file mode 100644
index 0000000..1814bb4
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_up_disabled.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_up_disabled_focused.png b/ScriptingLayerForAndroid/res/drawable/timepicker_up_disabled_focused.png
new file mode 100644
index 0000000..9ad5b85
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_up_disabled_focused.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_up_normal.png b/ScriptingLayerForAndroid/res/drawable/timepicker_up_normal.png
new file mode 100644
index 0000000..35fc221
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_up_normal.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_up_pressed.png b/ScriptingLayerForAndroid/res/drawable/timepicker_up_pressed.png
new file mode 100644
index 0000000..c910777
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_up_pressed.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/drawable/timepicker_up_selected.png b/ScriptingLayerForAndroid/res/drawable/timepicker_up_selected.png
new file mode 100644
index 0000000..549a7e5
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/drawable/timepicker_up_selected.png
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/layout/act_colors.xml b/ScriptingLayerForAndroid/res/layout/act_colors.xml
new file mode 100644
index 0000000..b40c2f1
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/act_colors.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<RelativeLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="fill_parent"
+	android:layout_height="fill_parent">
+  
+  <LinearLayout
+    android:id="@+id/color_layout"
+    android:layout_height="wrap_content"
+    android:layout_width="210dp"
+    android:layout_centerInParent="true"
+    android:gravity="center">
+    
+    <GridView
+    android:id="@+id/color_grid"
+    android:layout_height="wrap_content"
+    android:layout_width="wrap_content"
+    android:gravity="center"
+    android:padding="20dp"
+    android:verticalSpacing="20dp"
+    android:horizontalSpacing="20dp"
+    android:columnWidth="160dp"
+    android:numColumns="1"
+    android:stretchMode="none"/>
+  
+  </LinearLayout>	
+</RelativeLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/act_console.xml b/ScriptingLayerForAndroid/res/layout/act_console.xml
new file mode 100644
index 0000000..8993db3
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/act_console.xml
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="fill_parent"
+	android:layout_height="fill_parent"
+	android:background="#ff000000"
+	>
+
+	<ViewFlipper
+		android:id="@+id/console_flip"
+		android:layout_width="fill_parent"
+		android:layout_height="fill_parent"
+		/>
+
+	<RelativeLayout
+		android:id="@+id/console_boolean_group"
+		android:layout_width="fill_parent"
+		android:layout_height="wrap_content"
+		android:layout_alignParentBottom="true"
+		android:padding="5dip"
+		android:background="#80000000"
+		android:fadingEdge="horizontal"
+		android:fadingEdgeLength="25dip"
+		android:visibility="gone"
+		>
+
+		<TextView
+			android:id="@+id/console_prompt"
+			android:layout_height="wrap_content"
+			android:layout_width="fill_parent"
+			android:textAppearance="?android:attr/textAppearanceMedium"
+			/>
+
+		<Button
+			android:id="@+id/console_prompt_no"
+			android:text="@string/prompt_no"
+			android:paddingTop="5dip"
+			android:paddingBottom="10dip"
+			android:paddingLeft="40dip"
+			android:paddingRight="40dip"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:layout_alignParentRight="true"
+			android:layout_below="@+id/console_prompt"
+			android:clickable="false"
+			/>
+
+		<Button
+			android:id="@+id/console_prompt_yes"
+			android:text="@string/prompt_yes"
+			android:paddingTop="5dip"
+			android:paddingBottom="10dip"
+			android:paddingLeft="40dip"
+			android:paddingRight="40dip"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:layout_toLeftOf="@+id/console_prompt_no"
+			android:layout_below="@+id/console_prompt"
+			/>
+
+	</RelativeLayout>
+
+	<ImageView
+		android:id="@+id/keyboard_button"
+		android:paddingRight="15dip"
+		android:paddingBottom="15dip"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:layout_alignParentBottom="true"
+		android:layout_alignParentRight="true"
+		android:visibility="gone"
+		android:src="@+drawable/keyboard_icon"
+		/>
+
+</RelativeLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/act_help.xml b/ScriptingLayerForAndroid/res/layout/act_help.xml
new file mode 100644
index 0000000..2afe9e4
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/act_help.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<ScrollView
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="fill_parent"
+	android:layout_height="wrap_content"
+	android:layout_weight="1"
+	>
+
+	<LinearLayout
+		android:id="@+id/topics"
+		android:orientation="vertical"
+		android:layout_width="fill_parent"
+		android:layout_height="wrap_content"
+		android:gravity="center_horizontal"
+		>
+
+		<TextView
+      android:id="@+id/version"
+			android:layout_width="fill_parent"
+			android:layout_height="wrap_content"
+			android:paddingTop="2dip"
+			android:textAppearance="?android:attr/textAppearanceSmall"
+			android:gravity="right"
+			android:paddingRight="2dip"
+			/>
+    
+    <TextView
+      android:id="@+id/help_acks_text"
+      android:layout_width="fill_parent"
+      android:layout_height="wrap_content"
+      android:text="@string/help_acks"
+      android:paddingTop="2dip"
+      android:linksClickable="true"
+      android:textAppearance="?android:attr/textAppearanceMedium"
+      android:gravity="center_horizontal"
+      />
+      
+		<TextView
+			android:layout_width="fill_parent"
+			android:layout_height="wrap_content"
+			android:text="@string/help_intro"
+			android:paddingTop="2dip"
+			android:textAppearance="?android:attr/textAppearanceMedium"
+			android:gravity="center_horizontal"
+			/>
+
+	</LinearLayout>
+</ScrollView>
diff --git a/ScriptingLayerForAndroid/res/layout/act_help_topic.xml b/ScriptingLayerForAndroid/res/layout/act_help_topic.xml
new file mode 100644
index 0000000..7123d63
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/act_help_topic.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	android:orientation="vertical"
+	android:layout_width="fill_parent"
+	android:layout_height="fill_parent"
+	>
+
+	<org.connectbot.util.HelpTopicView
+		android:id="@+id/topic_text"
+		android:layout_width="fill_parent"
+		android:layout_height="fill_parent"
+		/>
+
+</LinearLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/api_browser.xml b/ScriptingLayerForAndroid/res/layout/api_browser.xml
new file mode 100644
index 0000000..4c4f8a4
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/api_browser.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+  <ListView
+    android:id="@+id/android:list"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+  <TextView
+    android:id="@+id/android:empty"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/no_apis_message" />
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/api_prompt.xml b/ScriptingLayerForAndroid/res/layout/api_prompt.xml
new file mode 100644
index 0000000..7a65663
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/api_prompt.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent"
+  android:padding="2dip">
+  <ListView
+    android:id="@+id/list"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:divider="#00000000" />
+  <Button
+    android:id="@+id/done"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:text="@string/prompt_finish"
+    android:layout_alignParentBottom="true" />
+</RelativeLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/api_prompt_item.xml b/ScriptingLayerForAndroid/res/layout/api_prompt_item.xml
new file mode 100644
index 0000000..a529139
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/api_prompt_item.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+  <TextView
+    android:id="@+id/api_prompt_item_description"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content" />
+  <EditText
+    android:id="@+id/api_prompt_item_value"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/bluetooth_device_list.xml b/ScriptingLayerForAndroid/res/layout/bluetooth_device_list.xml
new file mode 100644
index 0000000..bec4c53
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/bluetooth_device_list.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+  <ListView
+    android:id="@+id/android:list"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+  <TextView
+    android:id="@+id/android:empty"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/no_bluetooth_devices_message" />
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/dia_resize.xml b/ScriptingLayerForAndroid/res/layout/dia_resize.xml
new file mode 100644
index 0000000..32253fb
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/dia_resize.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	android:orientation="horizontal"
+	android:layout_width="wrap_content"
+	android:layout_height="wrap_content"
+	android:paddingLeft="10dip"
+	android:paddingRight="10dip"
+	>
+
+	<EditText
+		android:id="@+id/width"
+		android:layout_width="100dip"
+		android:layout_height="wrap_content"
+		android:singleLine="true"
+		android:numeric="integer"
+		android:text="@string/default_width"/>
+
+	<TextView
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:paddingLeft="10dip"
+		android:paddingRight="10dip"
+		android:gravity="right|bottom"
+		android:textAppearance="?android:attr/textAppearanceLarge"
+		/>
+
+
+	<EditText
+		android:id="@+id/height"
+		android:layout_width="100dip"
+		android:layout_height="wrap_content"
+		android:singleLine="true"
+		android:numeric="integer"
+		android:text="@string/default_height"/>
+</LinearLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/duration_picker.xml b/ScriptingLayerForAndroid/res/layout/duration_picker.xml
new file mode 100644
index 0000000..29e524d
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/duration_picker.xml
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * Copyright (C) 2008 OpenIntents.org
+ *
+ * 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.
+ -->
+<RelativeLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="wrap_content"
+  android:layout_height="wrap_content">
+  <com.googlecode.android_scripting.widget.NumberPicker
+    android:id="@+id/day"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:focusable="true"
+    android:focusableInTouchMode="true" />
+  <TextView
+    android:text="@string/display_days"
+    android:gravity="center_horizontal"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:layout_below="@+id/day"
+    android:layout_alignLeft="@+id/day" />
+  <com.googlecode.android_scripting.widget.NumberPicker
+    android:id="@+id/hour"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:layout_marginLeft="2dip"
+    android:focusable="true"
+    android:focusableInTouchMode="true"
+    android:layout_toRightOf="@+id/day" />
+  <TextView
+    android:text="@string/display_hours"
+    android:gravity="center_horizontal"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:layout_below="@+id/hour"
+    android:layout_alignLeft="@+id/hour" />
+   <com.googlecode.android_scripting.widget.NumberPicker
+    android:id="@+id/minute"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:layout_marginLeft="2dip"
+    android:focusable="true"
+    android:focusableInTouchMode="true"
+    android:layout_toRightOf="@+id/hour" />
+  <TextView
+    android:text="@string/display_minutes"
+    android:gravity="center_horizontal"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:layout_below="@+id/minute"
+    android:layout_alignLeft="@+id/minute" />
+  <com.googlecode.android_scripting.widget.NumberPicker
+    android:id="@+id/second"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:layout_marginLeft="2dip"
+    android:focusable="true"
+    android:focusableInTouchMode="true"
+    android:layout_toRightOf="@+id/minute" />
+  <TextView
+    android:text="@string/display_seconds"
+    android:gravity="center_horizontal"
+    android:layout_width="70dip"
+    android:layout_height="wrap_content"
+    android:layout_below="@+id/second"
+    android:layout_alignLeft="@+id/second" />
+</RelativeLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/findreplace.xml b/ScriptingLayerForAndroid/res/layout/findreplace.xml
new file mode 100644
index 0000000..64ec004
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/findreplace.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+    <TextView android:id="@+id/textView1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/display_find"></TextView>
+    <EditText android:layout_width="match_parent" android:layout_height="wrap_content" android:id="@+id/searchFind">
+        <requestFocus></requestFocus>
+    </EditText>
+    <TextView android:id="@+id/textView2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/display_replace"></TextView>
+    <EditText android:layout_width="match_parent" android:layout_height="wrap_content" android:id="@+id/searchReplace"></EditText>
+    <LinearLayout android:id="@+id/linearLayout1" android:layout_width="match_parent" android:layout_height="wrap_content">
+    </LinearLayout>
+    <LinearLayout android:id="@+id/linearLayout2" android:layout_width="match_parent" android:layout_height="wrap_content">
+    </LinearLayout>
+    <TableLayout android:id="@+id/tableLayout1" android:layout_width="match_parent" android:layout_height="wrap_content">
+        <TableRow android:id="@+id/tableRow1" android:layout_width="wrap_content" android:layout_height="wrap_content">
+            <CheckBox android:text="@string/display_whole_words" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/searchWord"></CheckBox>
+            <CheckBox android:text="@string/display_case_sensitive" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/searchCase"></CheckBox>
+        </TableRow>
+        <TableRow android:id="@+id/tableRow2" android:layout_width="wrap_content" android:layout_height="wrap_content">
+            <CheckBox android:text="@string/display_replace_all" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/searchAll"></CheckBox>
+            <CheckBox android:text="@string/display_from_start" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/searchStart"></CheckBox>
+        </TableRow>
+    </TableLayout>
+    <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/textView3" android:typeface="normal" android:text="@string/findreplace_undo_reminder"></TextView>
+</LinearLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/interpreter_manager.xml b/ScriptingLayerForAndroid/res/layout/interpreter_manager.xml
new file mode 100644
index 0000000..6b2afb9
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/interpreter_manager.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+  <ListView
+    android:id="@+id/android:list"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+  <TextView
+    android:id="@+id/android:empty"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/no_interpreters" />
+</LinearLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/item_terminal.xml b/ScriptingLayerForAndroid/res/layout/item_terminal.xml
new file mode 100644
index 0000000..9a8ff19
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/item_terminal.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+-->
+
+<RelativeLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="fill_parent"
+	android:layout_height="fill_parent"
+	>
+
+	<TextView
+		android:id="@+id/terminal_overlay"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:textAppearance="?android:attr/textAppearanceLarge"
+		android:background="#aa000000"
+		android:padding="10dip"
+		android:layout_centerInParent="true"
+		/>
+
+</RelativeLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/list_item.xml b/ScriptingLayerForAndroid/res/layout/list_item.xml
new file mode 100644
index 0000000..e9f2814
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/list_item.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="horizontal"
+  android:layout_width="wrap_content"
+  android:layout_height="wrap_content"
+  android:padding="4dip"
+  android:gravity="center_vertical">
+  <ImageView
+    android:id="@+id/list_item_icon"
+    android:layout_width="32dip"
+    android:layout_height="32dip"
+    android:fadingEdgeLength="0dip" />
+  <TextView
+    android:id="@+id/list_item_title"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:paddingLeft="5dip"
+    android:textSize="22dip" />
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/logcat_viewer.xml b/ScriptingLayerForAndroid/res/layout/logcat_viewer.xml
new file mode 100644
index 0000000..2517432
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/logcat_viewer.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+  <ListView
+    android:id="@+id/android:list"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+  <TextView
+    android:id="@+id/android:empty"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/no_logcat_msg" />
+</LinearLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/notification.xml b/ScriptingLayerForAndroid/res/layout/notification.xml
new file mode 100644
index 0000000..a450fbe
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/notification.xml
@@ -0,0 +1,33 @@
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent"
+  android:padding="3dip">
+  <RelativeLayout
+    android:orientation="horizontal"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content" >
+    <TextView
+      android:id="@+id/notification_title"
+      android:layout_width="fill_parent"
+      android:layout_height="wrap_content"
+      android:textColor="#000"
+      android:textStyle="bold"
+      android:textSize="12dip"
+      android:layout_alignParentLeft="true" />
+    <TextView
+      android:id="@+id/notification_action"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:textColor="#000"
+      android:textSize="12dip"
+      android:layout_alignParentRight="true" />
+  </RelativeLayout>
+  <TextView
+    android:id="@+id/notification_message"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:textColor="#000"
+    android:textSize="12dip" />
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/number_picker.xml b/ScriptingLayerForAndroid/res/layout/number_picker.xml
new file mode 100644
index 0000000..8b1a433
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/number_picker.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+**
+** Copyright 2008, The Android Open Source Project
+**
+** 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.
+*/
+-->
+<merge
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <com.googlecode.android_scripting.widget.NumberPickerButton
+    android:id="@+id/increment"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:background="@drawable/timepicker_up_btn" />
+  <EditText
+    android:id="@+id/timepicker_input"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:gravity="center"
+    android:singleLine="true"
+    style="?android:attr/textAppearanceLargeInverse"
+    android:textSize="30sp"
+    android:background="@drawable/timepicker_input"
+    android:numeric="integer" />
+  <com.googlecode.android_scripting.widget.NumberPickerButton
+    android:id="@+id/decrement"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:background="@drawable/timepicker_down_btn" />
+</merge>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/number_picker_edit.xml b/ScriptingLayerForAndroid/res/layout/number_picker_edit.xml
new file mode 100644
index 0000000..ebf34da
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/number_picker_edit.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+**
+** Copyright 2008, The Android Open Source Project
+**
+** 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.
+*/
+-->
+<EditText
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent"
+  android:layout_height="wrap_content"
+  android:gravity="center_horizontal"
+  android:singleLine="true"
+  style="?android:attr/textAppearanceLargeInverse"
+  android:textSize="30sp"
+  android:background="@drawable/timepicker_input" />
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/script_editor.xml b/ScriptingLayerForAndroid/res/layout/script_editor.xml
new file mode 100644
index 0000000..be9c22e
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/script_editor.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent"
+  android:paddingTop="4dip">
+  <EditText
+    android:id="@+id/script_editor_title"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:hint="Script Name"
+    android:singleLine="true" />
+  <EditText
+    android:id="@+id/script_editor_body"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:hint="Script Content"
+    android:typeface="monospace"
+    android:gravity="top"
+    android:inputType="textMultiLine" android:scrollHorizontally="true" android:scrollbars="horizontal|vertical"/>
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/script_manager.xml b/ScriptingLayerForAndroid/res/layout/script_manager.xml
new file mode 100644
index 0000000..e8ce08e
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/script_manager.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+  <ListView
+    android:id="@+id/android:list"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+  <TextView
+    android:id="@+id/android:empty"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/no_scripts_message" />
+</RelativeLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/script_monitor.xml b/ScriptingLayerForAndroid/res/layout/script_monitor.xml
new file mode 100644
index 0000000..7c57f3b
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/script_monitor.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+   <ListView
+    android:id="@+id/android:list"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+  <TextView
+    android:id="@+id/android:empty"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/no_running_scripts_message" />
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/script_monitor_list_item.xml b/ScriptingLayerForAndroid/res/layout/script_monitor_list_item.xml
new file mode 100644
index 0000000..df3c339
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/script_monitor_list_item.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent">
+    <RelativeLayout
+      android:layout_width="fill_parent" 
+      android:layout_height="wrap_content">
+      
+      <TextView
+      android:id="@+id/process_title"
+      android:textSize="16sp"
+      android:textStyle="bold"
+      android:textColor="#FFF"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"/>
+      <TextView
+      android:id="@+id/process_age"
+      android:layout_alignParentRight="true"
+      android:gravity="right"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"/>
+    </RelativeLayout>
+    <RelativeLayout
+      android:layout_width="fill_parent" 
+      android:layout_height="wrap_content">
+       <TextView
+      android:id="@+id/process_details"
+      android:gravity="left"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"/>
+      <TextView
+      android:id="@+id/process_status"
+      android:layout_alignParentRight="true"
+      android:gravity="right"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"/>
+    </RelativeLayout>  
+</LinearLayout>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/layout/title.xml b/ScriptingLayerForAndroid/res/layout/title.xml
new file mode 100644
index 0000000..54df631
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/title.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 The Android Open Source Project
+
+     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.
+-->
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/screen"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:orientation="vertical">
+    <TextView android:id="@+id/left_text"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:ellipsize="end" 
+        android:maxLines="1"
+        android:scrollHorizontally="true"
+        android:layout_centerVertical="true"
+        android:fadingEdge="horizontal"
+        android:layout_alignParentLeft="true" 
+        android:textStyle="bold" 
+        android:textColor="#ffffff" 
+        android:shadowColor="#000000" 
+        android:shadowRadius="1"
+        android:layout_toLeftOf="@+id/right_text"/>
+    <TextView android:id="@+id/right_text"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_centerVertical="true"
+        android:layout_toLeftOf="@+id/progress_bar"
+        android:layout_alignWithParentIfMissing="true"/>
+     <ProgressBar android:id="@+id/progress_bar"
+      android:layout_height="18sp"
+      android:layout_width="18sp"
+      android:layout_marginLeft="5sp"
+      android:visibility="gone"
+      style="android:attr/ProgressBar_indeterminate"
+      android:layout_centerVertical="true"
+      android:layout_alignParentRight="true"
+     />
+</RelativeLayout>
diff --git a/ScriptingLayerForAndroid/res/layout/trigger_manager.xml b/ScriptingLayerForAndroid/res/layout/trigger_manager.xml
new file mode 100644
index 0000000..926da9d
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/layout/trigger_manager.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent"
+  android:layout_height="fill_parent" android:orientation="vertical">
+  <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/btnTriggerCancel" android:onClick="clickCancel" android:text="@string/cancel_all"></Button><ListView
+    android:id="@+id/android:list"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" />
+  <TextView
+    android:id="@+id/android:empty"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/no_triggers_message" />
+
+</LinearLayout>
diff --git a/ScriptingLayerForAndroid/res/menu/terminal.xml b/ScriptingLayerForAndroid/res/menu/terminal.xml
new file mode 100644
index 0000000..136dcaf
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/menu/terminal.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2016, The Android Open Source Project
+**
+** 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.
+*/
+-->
+
+<menu
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <item
+    android:id="@+id/terminal_menu_resize"
+    android:title="@string/terminal_menu_resize"
+    android:alphabeticShortcut="s"
+    android:icon="@android:drawable/ic_menu_crop" />
+  <item
+    android:id="@+id/terminal_menu_send_email"
+    android:title="Email"
+    android:alphabeticShortcut="e"
+    android:icon="@android:drawable/ic_menu_send" />
+  <item
+    android:id="@+id/terminal_menu_preferences"
+    android:title="Preferences"
+    android:alphabeticShortcut="p"
+    android:icon="@android:drawable/ic_menu_preferences" />
+  <item
+    android:id="@+id/terminal_menu_exit_and_edit"
+    android:title="Exit &amp; Edit"
+    android:alphabeticShortcut="q"
+    android:enabled="false"
+    android:icon="@android:drawable/ic_menu_edit" />
+</menu>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/raw/bell.ogg b/ScriptingLayerForAndroid/res/raw/bell.ogg
new file mode 100644
index 0000000..674f25d
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/raw/bell.ogg
Binary files differ
diff --git a/ScriptingLayerForAndroid/res/values/arrays.xml b/ScriptingLayerForAndroid/res/values/arrays.xml
new file mode 100644
index 0000000..a4e3851
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/values/arrays.xml
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2016, The Android Open Source Project
+**
+** 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.
+*/
+-->
+
+<resources>
+  <string-array
+    name="entries_fontsize_preference">
+    <item>4 x 8 pixels</item>
+    <item>6 pt</item>
+    <item>7 pt</item>
+    <item>8 pt</item>
+    <item>9 pt</item>
+    <item>10 pt</item>
+    <item>12 pt</item>
+    <item>14 pt</item>
+    <item>16 pt</item>
+    <item>18 pt</item>
+    <item>20 pt</item>
+    <item>22 pt</item>
+    <item>24 pt</item>
+    <item>26 pt</item>
+    <item>28 pt</item>
+    <item>30 pt</item>
+  </string-array>
+  <string-array
+    name="list_rotation">
+    <item>@string/list_rotation_default</item>
+    <item>@string/list_rotation_land</item>
+    <item>@string/list_rotation_port</item>
+    <item>@string/list_rotation_auto</item>
+  </string-array>
+  <string-array
+    name="list_rotation_values">
+    <item>Default</item>
+    <item>Force landscape</item>
+    <item>Force portrait</item>
+    <item>Automatic</item>
+  </string-array>
+  
+    <string-array name="list_keymode">
+    <item>@string/list_keymode_right</item>
+    <item>@string/list_keymode_left</item>
+    <item>@string/list_keymode_none</item>
+  </string-array>
+
+  <string-array name="list_keymode_values">
+    <item>Use right-side keys</item>
+    <item>Use left-side keys</item>
+    <item>none</item>
+  </string-array>
+  
+    <string-array name="list_camera">
+    <item>@string/list_camera_ctrlaspace</item>
+    <item>@string/list_camera_ctrla</item>
+    <item>@string/list_camera_esc</item>
+    <item>@string/list_camera_esc_a</item>
+    <item>@string/list_camera_none</item>
+  </string-array>
+
+  <string-array name="list_camera_values">
+    <item>Ctrl+A then Space</item>
+    <item>Ctrl+A</item>
+    <item>Esc</item>
+    <item>Esc+A</item>
+    <item>None</item>
+  </string-array>
+  
+    <string-array name="list_delkey">
+    <item>@string/list_delkey_del</item>
+    <item>@string/list_delkey_backspace</item>
+  </string-array>
+
+  <string-array name="list_delkey_values">
+    <item>del</item>
+    <item>backspace</item>
+  </string-array>
+  
+  <string-array
+    name="entryvalues_fontsize_preference">
+    <item>0</item>
+    <item>6</item>
+    <item>7</item>
+    <item>8</item>
+    <item>9</item>
+    <item>10</item>
+    <item>12</item>
+    <item>14</item>
+    <item>16</item>
+    <item>18</item>
+    <item>20</item>
+    <item>22</item>
+    <item>24</item>
+    <item>26</item>
+    <item>28</item>
+    <item>30</item>
+  </string-array>
+  <string-array
+    name="entries_color_preference">
+    <item>Black text on white</item>
+    <item>White text on black</item>
+    <item>White text on blue</item>
+  </string-array>
+  <string-array
+    name="entryvalues_color_preference">
+    <item>0</item>
+    <item>1</item>
+    <item>2</item>
+  </string-array>
+  <string-array
+    name="entries_controlkey_preference">
+    <item>Jog ball</item>
+    <item>\@ key</item>
+    <item>Left Alt key</item>
+    <item>Right Alt key</item>
+  </string-array>
+  <string-array
+    name="entryvalues_controlkey_preference">
+    <item>0</item>
+    <item>1</item>
+    <item>2</item>
+    <item>3</item>
+  </string-array>
+</resources>
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/res/values/strings.xml b/ScriptingLayerForAndroid/res/values/strings.xml
new file mode 100644
index 0000000..b95427e
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/values/strings.xml
@@ -0,0 +1,213 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2016, The Android Open Source Project
+**
+** 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.
+*/
+-->
+
+<resources>
+    <string name="help_force_browser">Force API Browser</string>
+   <string
+    name="stop_all">Stop All</string>
+  <string
+    name="application_title">SL4A</string>
+  <string
+    name="application_nice_title">Scripting Layer for Android</string>
+  <string
+    name="text_preferences">Text</string>
+  <string
+    name="title_fontsize_preference">Font size</string>
+  <string
+    name="summary_fontsize_preference">Choose character height in pixels.</string>
+  <string
+    name="dialog_title_fontsize_preference">Font size</string>
+  <string
+    name="title_color_preference">Colors</string>
+  <string
+    name="summary_color_preference">Choose text color.</string>
+  <string
+    name="dialog_title_color_preference">Text color</string>
+  <string
+    name="keyboard_preferences">Keyboard</string>
+  <string
+    name="title_controlkey_preference">Control key</string>
+  <string
+    name="summary_controlkey_preference">Choose control key.</string>
+  <string
+    name="dialog_title_controlkey_preference">Control key</string>
+  <string
+    name="shell_preferences">Shell</string>
+  <string
+    name="title_shell_preference">Command line</string>
+  <string
+    name="summary_shell_preference">Specify the shell command line.</string>
+  <string
+    name="dialog_title_shell_preference">Shell</string>
+  <string
+    name="title_initialcommand_preference">Initial command</string>
+  <string
+    name="summary_initialcommand_preference">Sent to the shell when it starts.</string>
+  <string
+    name="dialog_title_initialcommand_preference">Initial Command</string>
+  <string
+    name="default_value_fontsize_preference">10</string>
+  <string
+    name="default_value_color_preference">1</string>
+  <string
+    name="default_value_controlkey_preference">0</string>
+  <string
+    name="no_scripts_message">Start adding scripts and interpreters by pressing the menu
+    button.</string>
+  <string
+    name="no_apis_message">No matching APIs found.</string>  
+  <string
+    name="notification_action_message">Tap to open Script Monitor.</string>
+  <string
+    name="no_running_scripts_message">There are no currently running scripts.</string>
+  <string
+    name="script_number_message">Number of running scripts:\t</string>
+  <string
+    name="no_triggers_message">No triggers.</string>
+  <string
+    name="no_bluetooth_devices_message">No Bluetooth devices found.</string>
+  <string
+    name="search_description_scripts">Search scripts</string>
+  <string
+    name="search_description_apis">Search APIs</string>
+    
+  <string name="prompt_process_exited">Process has exited.\nClose terminal?</string>
+  <string name="prompt_confirm_exit">Confirm exit.\nKill process?</string>
+  
+  <string name="terminal_copy_done">Copied %1$d bytes to clipboard</string>
+  <string name="terminal_copy_start">Touch and drag\nor use directional pad\nto select area to copy</string>
+  
+  
+  <string name="terminal_menu_close">Close</string>
+  <string name="terminal_menu_copy">Copy</string>
+  <string name="terminal_menu_paste">Paste</string>
+  <string name="terminal_menu_resize">Force Size</string>
+  
+  <string name="button_resize">Resize</string>
+  
+  <!-- Name for the scrollback size preference -->
+  <string name="pref_scrollback_title">Scrollback size</string>
+  <!-- Description of the scrollback size preference -->
+  <string name="pref_scrollback_summary">Size of scrollback buffer to keep in memory for each console</string>
+  <!-- Name for the rotation mode preference -->
+  <string name="pref_rotation_title">Rotation mode</string>
+  <!-- Summary for the rotation mode preference -->
+  <string name="pref_rotation_summary">How to change rotation when keyboard popped in/out</string>
+    <!-- Name for the full screen preference -->
+  <string name="pref_fullscreen_title">Full screen</string>
+  <!-- Summary for the full screen preference -->
+  <string name="pref_fullscreen_summary">Hide status bar while in console</string>
+    <!-- Name for the keyboard shortcuts preference -->
+  <string name="pref_keymode_title">Directory shortcuts</string>
+  <!-- Summary for the keyboard shortcuts preference -->
+  <string name="pref_keymode_summary">Select how to use Alt for \'/\' and Shift for Tab</string>
+  <!-- Name for the camera shortcut usage preference -->
+  <string name="pref_camera_title">Camera shortcut</string>
+  <!-- Summary for the camera shortcut usage preference -->
+  <string name="pref_camera_summary">Select which shortcut to trigger when the camera button is pushed</string>
+  <!-- Name for the keep screen on preference -->
+  <string name="pref_keepalive_title">Keep screen awake</string>
+  <!-- Summary for the camera shortcut usage preference -->
+  <string name="pref_keepalive_summary">Prevent the screen from turning off when working in a console</string>
+  <!-- Name for the haptic feedback (bumpy arrow) preference -->
+  <string name="pref_bumpyarrows_title">Bumpy arrows</string>
+  <!-- Summary for the haptic feedback (bumpy arrow) preference -->
+  <string name="pref_bumpyarrows_summary">Vibrate when sending arrow keys from trackball</string>
+  <string name="pref_hidekeyboard_title">Hide Keyboard</string>
+  <string name="pref_hidekeyboard_summary">Hide soft keyboard in terminal on startup</string>
+  <!-- Category title for the Terminal Bell preferences -->
+  <string name="pref_bell_category">Terminal bell</string>
+  <!-- Checkbox preference title for the audible terminal bell feature -->
+  <string name="pref_bell_title">Audible bell</string>
+  <!-- Title for the slider preference to set the volume -->
+  <string name="pref_bell_volume_title">Bell volume</string>
+  <!-- Checkbox preference title for the vibrate on terminal bell feature -->
+  <string name="pref_bell_vibrate_title">Vibrate on bell</string>
+  <string name="pref_fontsize_title">Font size (pt)</string>
+      <!-- Setting for what key code is sent to the server when DEL key is pressed. -->
+  <string name="pref_delkey_title">DEL Key</string>
+  <!-- Summary for field asking what key code is sent to the server when DEL key is pressed. -->
+  <string name="pref_delkey_summary">The key code sent when DEL key is pressed</string>
+  <!-- Host character encoding preference title -->
+  <string name="pref_encoding_title">Encoding</string>
+  <!-- Host character encoding preference summary -->
+  <string name="pref_encoding_summary">Character encoding for the host</string>
+  <string name="pref_hide_notifications">Hide Notifications</string>
+      <!-- Default screen rotation preference selection -->
+  <string name="list_rotation_default">Default</string>
+  <string name="list_rotation_land">Force landscape</string>
+  <string name="list_rotation_port">Force portrait</string>
+  <!-- Selection to indicate the rotation should be selected automatically based on the tilt sensor. -->
+  <string name="list_rotation_auto">Automatic</string>
+    <!-- Preference selection to indicate use of right side of keyboard for special shortcuts. -->
+  <string name="list_keymode_right">Use right-side keys</string>
+  <!-- Preference selection to indicate use of left side of keyboard for special shortcuts. -->
+  <string name="list_keymode_left">Use left-side keys</string>
+  <!-- Preference selection to indicate never to use special shortcut keys. -->
+  <string name="list_keymode_none">Disable</string>
+    <!-- Selection to indicate pressing the Camera button should send "Ctrl+A then Space". -->
+  <string name="list_camera_ctrlaspace">Ctrl+A then Space</string>
+  <!-- Selection to indicate pressing the Camera button should send "Ctrl+A". -->
+  <string name="list_camera_ctrla">Ctrl+A</string>
+  <!-- Selection to indicate pressing the Camera button should send the "Esc" key. -->
+  <string name="list_camera_esc">Esc</string>
+  <!-- Selection to indicate pressing the Camera button should send "Esc+A". -->
+  <string name="list_camera_esc_a">Esc+A</string>
+  <!-- Selection to indicate pressing the Camera button should send nothing at all. -->
+  <string name="list_camera_none">None</string>
+    <!-- Name for the backspace character -->
+  <string name="list_delkey_backspace">Backspace</string>
+  <!-- Name for the ASCII DEL character -->
+  <string name="list_delkey_del">Delete</string>
+  
+  <!-- Window title for Help index -->
+  <string name="title_help">Help</string>
+  
+  <string name="help_acks">SL4A uses <a href="http://code.google.com/p/connectbot/">ConnectBot</a> terminal.</string>
+  <string name="help_intro">Please select a topic below for more information on a particular subject.</string>
+  <string name="enable_auto_close">Enable Auto Close</string>
+  <string name="prompt_no">No</string>
+  <string name="prompt_yes">Yes</string>
+  <string name="prompt_finish">Finish</string>
+  <string name="default_width">80</string>
+  <string name="default_height">25</string>
+  <string name="display_days">Days</string>
+  <string name="display_hours">Hours</string>
+  <string name="display_minutes">Minutes</string>
+  <string name="display_seconds">Seconds</string>
+  <string name="display_find">Find</string>
+  <string name="display_replace">Replace</string>
+  <string name="display_whole_words">Whole Words</string>
+  <string name="display_case_sensitive">Case Sensitive</string>
+  <string name="display_replace_all">Replace All</string>
+  <string name="display_from_start">From Start</string>
+  <string name="findreplace_undo_reminder">Remember you can use the volume keys to undo mistakes.</string>
+  <string name="no_interpreters">No interpreters.</string>
+  <string name="no_logcat_msg">No logcat messages.</string>
+  <string name="cancel_all">Cancel All</string>
+
+  <string name="title_triggers">Triggers</string>
+  <string name="title_scripts">Scripts</string>
+  <string name="title_api_browser">API Browser</string>
+  <string name="title_logcat">Logcat</string>
+  <string name="title_interpreters">Interpreters</string>
+  <string name="title_script_monitor">Script Monitor</string>
+  <string name="title_bluetooth_devices">Bluetooth Devices</string>
+
+</resources>
diff --git a/ScriptingLayerForAndroid/res/xml/paths.xml b/ScriptingLayerForAndroid/res/xml/paths.xml
new file mode 100644
index 0000000..ca3b85a
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/xml/paths.xml
@@ -0,0 +1,3 @@
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <cache-path name="mms" path="." />
+</paths>
diff --git a/ScriptingLayerForAndroid/res/xml/preferences.xml b/ScriptingLayerForAndroid/res/xml/preferences.xml
new file mode 100644
index 0000000..e0e6d35
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/xml/preferences.xml
@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2016, The Android Open Source Project
+**
+** 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.
+*/
+-->
+
+<PreferenceScreen
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <PreferenceCategory
+    android:title="General">
+    <EditTextPreference android:summary="Port to use for running server. Leave at 0 for random selection." android:key="use_service_port" android:title="Server Port" android:defaultValue="0" android:numeric="integer"></EditTextPreference>
+  </PreferenceCategory>
+  <PreferenceCategory
+    android:title="Script Manager">
+    <CheckBoxPreference
+      android:key="show_all_files"
+      android:title="Show all files"
+      android:defaultValue="false" />
+  </PreferenceCategory>
+  <PreferenceCategory
+    android:title="Script Editor">
+    <ListPreference
+      android:key="editor_fontsize"
+      android:defaultValue="@string/default_value_fontsize_preference"
+      android:title="@string/title_fontsize_preference"
+      android:summary="@string/summary_fontsize_preference"
+      android:entries="@array/entries_fontsize_preference"
+      android:entryValues="@array/entryvalues_fontsize_preference"
+      android:dialogTitle="@string/dialog_title_fontsize_preference" />
+  <CheckBoxPreference android:title="@string/help_force_browser" android:key="helpForceBrowser" android:defaultValue="true" android:summary="Force API Help to use default Android Browser"></CheckBoxPreference>
+  <CheckBoxPreference android:summary="When enabled, quotes and brackets are automatically completed." android:key="enableAutoClose" android:title="@string/enable_auto_close" android:defaultValue="true"></CheckBoxPreference>
+  <CheckBoxPreference android:title="No Wrap" android:summary="Don't wrap text in editor" android:key="editor_no_wrap"></CheckBoxPreference>
+  <CheckBoxPreference android:key="editor_auto_indent" android:defaultValue="false" android:summaryOff="Auto Indent Disabled" android:summaryOn="Auto Indent Enabled" android:title="Auto Indent"></CheckBoxPreference>
+</PreferenceCategory>
+  <PreferenceCategory
+    android:title="Terminal">
+    <EditTextPreference
+      android:key="scrollback"
+      android:title="@string/pref_scrollback_title"
+      android:summary="@string/pref_scrollback_summary"
+      android:defaultValue="140" />
+    <EditTextPreference
+      android:key="fontsize"
+      android:title="@string/pref_fontsize_title"
+      android:defaultValue="10" />
+    <org.connectbot.util.EncodingPreference
+      android:key="encoding"
+      android:title="@string/pref_encoding_title"
+      android:summary="@string/pref_encoding_summary" />
+    <ListPreference
+      android:key="rotation"
+      android:title="@string/pref_rotation_title"
+      android:summary="@string/pref_rotation_summary"
+      android:entries="@array/list_rotation"
+      android:entryValues="@array/list_rotation_values"
+      android:defaultValue="Default" />
+    <Preference
+      android:key="color"
+      android:title="@string/title_color_preference"
+      android:summary="@string/summary_color_preference">
+      <intent
+        android:action="com.googlecode.android_scripting.PICK_TERMINAL_COLORS" />
+    </Preference>
+    <CheckBoxPreference
+      android:key="fullscreen"
+      android:title="@string/pref_fullscreen_title"
+      android:summary="@string/pref_fullscreen_summary"
+      android:defaultValue="false" />
+    <ListPreference
+      android:key="delkey"
+      android:title="@string/pref_delkey_title"
+      android:summary="@string/pref_delkey_summary"
+      android:entries="@array/list_delkey"
+      android:entryValues="@array/list_delkey_values" />
+    <ListPreference
+      android:key="keymode"
+      android:title="@string/pref_keymode_title"
+      android:summary="@string/pref_keymode_summary"
+      android:entries="@array/list_keymode"
+      android:entryValues="@array/list_keymode_values"
+      android:defaultValue="Use right-side keys" />
+    <ListPreference
+      android:key="camera"
+      android:title="@string/pref_camera_title"
+      android:summary="@string/pref_camera_summary"
+      android:entries="@array/list_camera"
+      android:entryValues="@array/list_camera_values"
+      android:defaultValue="Ctrl+A then Space" ></ListPreference>
+    <CheckBoxPreference
+      android:key="keepalive"
+      android:title="@string/pref_keepalive_title"
+      android:summary="@string/pref_keepalive_summary"
+      android:defaultValue="true" />
+    <CheckBoxPreference
+      android:key="bumpyarrows"
+      android:title="@string/pref_bumpyarrows_title"
+      android:summary="@string/pref_bumpyarrows_summary"
+      android:defaultValue="true" />
+    <CheckBoxPreference
+      android:key="hidekeyboard"
+      android:title="@string/pref_hidekeyboard_title"
+      android:summary="@string/pref_hidekeyboard_summary"
+      android:defaultValue="false" />
+  </PreferenceCategory>
+  <PreferenceCategory
+    android:title="Terminal bell">
+    <CheckBoxPreference
+      android:key="bell"
+      android:title="@string/pref_bell_title"
+      android:defaultValue="true" />
+    <org.connectbot.util.VolumePreference
+      android:key="bellVolume"
+      android:title="@string/pref_bell_volume_title" />
+    <CheckBoxPreference
+      android:key="bellVibrate"
+      android:title="@string/pref_bell_vibrate_title"
+      android:defaultValue="true" />
+  </PreferenceCategory>
+  <PreferenceCategory
+	  android:title="Trigger Behaviour">
+	  <CheckBoxPreference 
+	    android:key="hideServiceNotifications"
+		android:title="@string/pref_hide_notifications" 
+		android:defaultValue="false" />
+	</PreferenceCategory>
+</PreferenceScreen>
diff --git a/ScriptingLayerForAndroid/res/xml/searchable_apis.xml b/ScriptingLayerForAndroid/res/xml/searchable_apis.xml
new file mode 100644
index 0000000..bab5acc
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/xml/searchable_apis.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2016, The Android Open Source Project
+**
+** 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.
+*/
+-->
+
+  <searchable xmlns:android="http://schemas.android.com/apk/res/android"
+        android:label="@string/application_title"
+        android:hint="@string/search_description_apis"
+        android:searchSettingsDescription="@string/search_description_apis"
+        android:voiceSearchMode="showVoiceSearchButton|launchRecognizer"
+        android:searchSuggestAuthority="com.googlecode.android_scripting.provider.apiprovider"
+        android:searchSuggestPath="searchSuggestions">
+</searchable>
+
diff --git a/ScriptingLayerForAndroid/res/xml/searchable_scripts.xml b/ScriptingLayerForAndroid/res/xml/searchable_scripts.xml
new file mode 100644
index 0000000..b0773cc
--- /dev/null
+++ b/ScriptingLayerForAndroid/res/xml/searchable_scripts.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2016, The Android Open Source Project
+**
+** 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.
+*/
+-->
+
+  <searchable xmlns:android="http://schemas.android.com/apk/res/android"
+        android:label="@string/application_title"
+        android:hint="@string/search_description_scripts"
+        android:searchSettingsDescription="@string/search_description_scripts"
+        android:includeInGlobalSearch="true"
+        android:voiceSearchMode="showVoiceSearchButton|launchRecognizer"
+        android:searchSuggestAuthority="com.googlecode.android_scripting.provider.scriptprovider"
+        android:searchSuggestPath="searchSuggestions"
+        android:searchSuggestIntentAction="android.intent.action.SEARCH">
+</searchable>
+
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/ActivityFlinger.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/ActivityFlinger.java
new file mode 100644
index 0000000..91216ac
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/ActivityFlinger.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.GestureDetector.SimpleOnGestureListener;
+import android.view.View.OnTouchListener;
+
+import com.googlecode.android_scripting.activity.InterpreterManager;
+import com.googlecode.android_scripting.activity.LogcatViewer;
+import com.googlecode.android_scripting.activity.ScriptManager;
+import com.googlecode.android_scripting.activity.TriggerManager;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class ActivityFlinger {
+
+  private static final int SWIPE_MIN_DISTANCE = 120;
+  private static final int SWIPE_MAX_OFF_PATH = 100;
+  private static final int SWIPE_THRESHOLD_VELOCITY = 200;
+
+  private static class ActivityTransition {
+    Class<? extends Activity> mLeft;
+    Class<? extends Activity> mRight;
+
+    public ActivityTransition(Class<? extends Activity> left, Class<? extends Activity> right) {
+      mLeft = left;
+      mRight = right;
+    }
+  }
+
+  private static Map<Class<?>, ActivityTransition> mActivityTransitions =
+      new HashMap<Class<?>, ActivityTransition>();
+
+  private ActivityFlinger() {
+    // Utility class.
+  }
+
+  static {
+    List<Class<? extends Activity>> entries = new ArrayList<Class<? extends Activity>>();
+    entries.add(ScriptManager.class);
+    entries.add(InterpreterManager.class);
+    entries.add(TriggerManager.class);
+    entries.add(LogcatViewer.class);
+
+    Class<? extends Activity> left = null;
+    Class<? extends Activity> current = null;
+    Class<? extends Activity> right = null;
+
+    for (Iterator<Class<? extends Activity>> it = entries.iterator(); it.hasNext()
+        || current != null;) {
+      if (current == null) {
+        current = it.next();
+      }
+      if (it.hasNext()) {
+        right = it.next();
+      } else {
+        right = null;
+      }
+      mActivityTransitions.put(current, new ActivityTransition(left, right));
+      left = current;
+      current = right;
+    }
+  }
+
+  public static void attachView(View view, Context context) {
+    final LeftRightFlingListener mListener = new LeftRightFlingListener();
+    final GestureDetector mGestureDetector = new GestureDetector(mListener);
+    ActivityTransition transition = mActivityTransitions.get(context.getClass());
+    if (transition.mLeft != null) {
+      mListener.mLeftRunnable = new StartActivityRunnable(context, transition.mLeft);
+    }
+    if (transition.mRight != null) {
+      mListener.mRightRunnable = new StartActivityRunnable(context, transition.mRight);
+    }
+    view.setOnTouchListener(new OnTouchListener() {
+      @Override
+      public boolean onTouch(View v, MotionEvent event) {
+        return mGestureDetector.onTouchEvent(event);
+      }
+    });
+  }
+
+  private static class StartActivityRunnable implements Runnable {
+
+    private final Context mContext;
+    private final Class<?> mActivityClass;
+
+    private StartActivityRunnable(Context context, Class<?> activity) {
+      mContext = context;
+      mActivityClass = activity;
+    }
+
+    @Override
+    public void run() {
+      Intent intent = new Intent(mContext, mActivityClass);
+      mContext.startActivity(intent);
+    }
+  }
+
+  private static class LeftRightFlingListener extends SimpleOnGestureListener {
+    Runnable mLeftRunnable;
+    Runnable mRightRunnable;
+
+    @Override
+    public boolean onFling(MotionEvent event1, MotionEvent event2, float velocityX, float velocityY) {
+      if (Math.abs(event1.getY() - event2.getY()) > SWIPE_MAX_OFF_PATH) {
+        return false;
+      }
+      if (event1.getX() - event2.getX() > SWIPE_MIN_DISTANCE
+          && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
+        if (mRightRunnable != null) {
+          mRightRunnable.run();
+        }
+      } else if (event2.getX() - event1.getX() > SWIPE_MIN_DISTANCE
+          && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
+        if (mLeftRunnable != null) {
+          mLeftRunnable.run();
+        }
+      } else {
+        return super.onFling(event1, event2, velocityX, velocityY);
+      }
+      return true;
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/ScriptListAdapter.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/ScriptListAdapter.java
new file mode 100644
index 0000000..d1e6f65
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/ScriptListAdapter.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import java.io.File;
+import java.util.List;
+
+public abstract class ScriptListAdapter extends BaseAdapter {
+
+  protected final Context mContext;
+  protected final LayoutInflater mInflater;
+
+  public ScriptListAdapter(Context context) {
+    mContext = context;
+    mInflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+  }
+
+  @Override
+  public int getCount() {
+    return getScriptList().size();
+  }
+
+  @Override
+  public Object getItem(int position) {
+    return getScriptList().get(position);
+  }
+
+  @Override
+  public long getItemId(int position) {
+    return position;
+  }
+
+  @Override
+  public View getView(int position, View convertView, ViewGroup parent) {
+    LinearLayout container;
+    File script = getScriptList().get(position);
+
+    if (convertView == null) {
+      container = (LinearLayout) mInflater.inflate(R.layout.list_item, null);
+    } else {
+      container = (LinearLayout) convertView;
+    }
+
+    ImageView icon = (ImageView) container.findViewById(R.id.list_item_icon);
+    int resourceId;
+    if (script.isDirectory()) {
+      resourceId = R.drawable.folder;
+    } else {
+      resourceId = FeaturedInterpreters.getInterpreterIcon(mContext, script.getName());
+      if (resourceId == 0) {
+        resourceId = R.drawable.sl4a_logo_32;
+      }
+    }
+    icon.setImageResource(resourceId);
+
+    TextView text = (TextView) container.findViewById(R.id.list_item_title);
+    text.setText(getScriptList().get(position).getName());
+    return container;
+  }
+
+  protected abstract List<File> getScriptList();
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/Sl4aApplication.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/Sl4aApplication.java
new file mode 100644
index 0000000..953c6aa
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/Sl4aApplication.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+public class Sl4aApplication extends BaseApplication {
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+  }
+
+  @Override
+  public void onTerminate() {
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ApiBrowser.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ApiBrowser.java
new file mode 100644
index 0000000..8255313
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ApiBrowser.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.ListActivity;
+import android.app.SearchManager;
+import android.content.Intent;
+import android.database.MatrixCursor;
+import android.os.Bundle;
+import android.util.TypedValue;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.widget.AdapterView;
+import android.widget.AlphabetIndexer;
+import android.widget.BaseAdapter;
+import android.widget.ListView;
+import android.widget.SectionIndexer;
+import android.widget.TextView;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.Lists;
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.language.SupportedLanguages;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.rpc.ParameterDescriptor;
+import com.googlecode.android_scripting.rpc.RpcDeprecated;
+import com.googlecode.android_scripting.rpc.RpcMinSdk;
+
+import java.lang.reflect.Method;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ApiBrowser extends ListActivity {
+
+  private boolean searchResultMode = false;
+
+  private static enum RequestCode {
+    RPC_PROMPT
+  }
+
+  private static enum MenuId {
+    EXPAND_ALL, COLLAPSE_ALL, SEARCH;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  private static enum ContextMenuId {
+    INSERT_TEXT, PROMPT_PARAMETERS, HELP;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  private List<MethodDescriptor> mMethodDescriptors;
+  private Set<Integer> mExpandedPositions;
+  private ApiBrowserAdapter mAdapter;
+  private boolean mIsLanguageSupported;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "API Browser", R.layout.api_browser);
+    getListView().setFastScrollEnabled(true);
+    mExpandedPositions = new HashSet<Integer>();
+    updateAndFilterMethodDescriptors(null);
+    String scriptName = getIntent().getStringExtra(Constants.EXTRA_SCRIPT_PATH);
+    mIsLanguageSupported = SupportedLanguages.checkLanguageSupported(scriptName);
+    mAdapter = new ApiBrowserAdapter();
+    setListAdapter(mAdapter);
+    registerForContextMenu(getListView());
+    setResult(RESULT_CANCELED);
+  }
+
+  private void updateAndFilterMethodDescriptors(final String query) {
+    mMethodDescriptors =
+        Lists.newArrayList(Collections2.filter(FacadeConfiguration.collectMethodDescriptors(),
+            new Predicate<MethodDescriptor>() {
+              @Override
+              public boolean apply(MethodDescriptor descriptor) {
+                Method method = descriptor.getMethod();
+                if (method.isAnnotationPresent(RpcDeprecated.class)) {
+                  return false;
+                } else if (method.isAnnotationPresent(RpcMinSdk.class)) {
+                  int requiredSdkLevel = method.getAnnotation(RpcMinSdk.class).value();
+                  if (FacadeConfiguration.getSdkLevel() < requiredSdkLevel) {
+                    return false;
+                  }
+                }
+                if (query == null) {
+                  return true;
+                }
+                return descriptor.getName().toLowerCase().contains(query.toLowerCase());
+              }
+            }));
+  }
+
+  @Override
+  protected void onNewIntent(Intent intent) {
+    if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
+      searchResultMode = true;
+      final String query = intent.getStringExtra(SearchManager.QUERY);
+      ((TextView) findViewById(R.id.left_text)).setText(query);
+      updateAndFilterMethodDescriptors(query);
+      if (mMethodDescriptors.size() == 1) {
+        mExpandedPositions.add(0);
+      } else {
+        mExpandedPositions.clear();
+      }
+      mAdapter.notifyDataSetChanged();
+    }
+  }
+
+  @Override
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_BACK && searchResultMode) {
+      searchResultMode = false;
+      mExpandedPositions.clear();
+      ((TextView) findViewById(R.id.left_text)).setText("API Browser");
+      updateAndFilterMethodDescriptors("");
+      mAdapter.notifyDataSetChanged();
+      return true;
+    }
+    return super.onKeyDown(keyCode, event);
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    super.onPrepareOptionsMenu(menu);
+    menu.clear();
+    menu.add(Menu.NONE, MenuId.EXPAND_ALL.getId(), Menu.NONE, "Expand All").setIcon(
+        android.R.drawable.ic_menu_add);
+    menu.add(Menu.NONE, MenuId.COLLAPSE_ALL.getId(), Menu.NONE, "Collapse All").setIcon(
+        android.R.drawable.ic_menu_close_clear_cancel);
+    menu.add(Menu.NONE, MenuId.SEARCH.getId(), Menu.NONE, "Search").setIcon(
+        R.drawable.ic_menu_search);
+    return true;
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    super.onOptionsItemSelected(item);
+    int itemId = item.getItemId();
+    if (itemId == MenuId.EXPAND_ALL.getId()) {
+      for (int i = 0; i < mMethodDescriptors.size(); i++) {
+        mExpandedPositions.add(i);
+      }
+    } else if (itemId == MenuId.COLLAPSE_ALL.getId()) {
+      mExpandedPositions.clear();
+    } else if (itemId == MenuId.SEARCH.getId()) {
+      onSearchRequested();
+    }
+
+    mAdapter.notifyDataSetInvalidated();
+    return true;
+  }
+
+  @Override
+  protected void onListItemClick(ListView l, View v, int position, long id) {
+    if (mExpandedPositions.contains(position)) {
+      mExpandedPositions.remove(position);
+    } else {
+      mExpandedPositions.add(position);
+    }
+    mAdapter.notifyDataSetInvalidated();
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfo) {
+    if (!mIsLanguageSupported) {
+      return;
+    }
+    menu.add(Menu.NONE, ContextMenuId.INSERT_TEXT.getId(), Menu.NONE, "Insert");
+    menu.add(Menu.NONE, ContextMenuId.PROMPT_PARAMETERS.getId(), Menu.NONE, "Prompt");
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    AdapterView.AdapterContextMenuInfo info;
+    try {
+      info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
+    } catch (ClassCastException e) {
+      Log.e("Bad menuInfo", e);
+      return false;
+    }
+
+    MethodDescriptor rpc = (MethodDescriptor) getListAdapter().getItem(info.position);
+    if (rpc == null) {
+      Log.v("No RPC selected.");
+      return false;
+    }
+
+    if (item.getItemId() == ContextMenuId.INSERT_TEXT.getId()) {
+      // There's no activity to track calls to insert (like there is for prompt) so we track it
+      // here instead.
+      insertText(rpc, new String[0]);
+    } else if (item.getItemId() == ContextMenuId.PROMPT_PARAMETERS.getId()) {
+      Intent intent = new Intent(this, ApiPrompt.class);
+      intent.putExtra(Constants.EXTRA_API_PROMPT_RPC_NAME, rpc.getName());
+      ParameterDescriptor[] parameters = rpc.getParameterValues(new String[0]);
+      String[] values = new String[parameters.length];
+      int index = 0;
+      for (ParameterDescriptor parameter : parameters) {
+        values[index++] = parameter.getValue();
+      }
+      intent.putExtra(Constants.EXTRA_API_PROMPT_VALUES, values);
+      startActivityForResult(intent, RequestCode.RPC_PROMPT.ordinal());
+    } else if (item.getItemId() == ContextMenuId.HELP.getId()) {
+      String help = rpc.getDeclaringClass().getSimpleName() + ".html#" + rpc.getName();
+
+    }
+    return true;
+  }
+
+  @Override
+  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    super.onActivityResult(requestCode, resultCode, data);
+    RequestCode request = RequestCode.values()[requestCode];
+    if (resultCode == RESULT_OK) {
+      switch (request) {
+      case RPC_PROMPT:
+        MethodDescriptor rpc =
+            FacadeConfiguration.getMethodDescriptor(data
+                .getStringExtra(Constants.EXTRA_API_PROMPT_RPC_NAME));
+        String[] values = data.getStringArrayExtra(Constants.EXTRA_API_PROMPT_VALUES);
+        insertText(rpc, values);
+        break;
+      default:
+        break;
+      }
+    } else {
+      switch (request) {
+      case RPC_PROMPT:
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  private void insertText(MethodDescriptor rpc, String[] values) {
+    String scriptText = getIntent().getStringExtra(Constants.EXTRA_SCRIPT_TEXT);
+    InterpreterConfiguration config =
+        ((BaseApplication) getApplication()).getInterpreterConfiguration();
+
+    Interpreter interpreter =
+        config.getInterpreterByName(getIntent().getStringExtra(Constants.EXTRA_INTERPRETER_NAME));
+    String rpcHelpText = interpreter.getRpcText(scriptText, rpc, values);
+
+    Intent intent = new Intent();
+    intent.putExtra(Constants.EXTRA_RPC_HELP_TEXT, rpcHelpText);
+    setResult(RESULT_OK, intent);
+    finish();
+  }
+
+  private class ApiBrowserAdapter extends BaseAdapter implements SectionIndexer {
+
+    private final AlphabetIndexer mIndexer;
+    private final MatrixCursor mCursor;
+
+    public ApiBrowserAdapter() {
+      mCursor = new MatrixCursor(new String[] { "NAME" });
+      for (MethodDescriptor info : mMethodDescriptors) {
+        mCursor.addRow(new String[] { info.getName() });
+      }
+      mIndexer = new AlphabetIndexer(mCursor, 0, " ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+    }
+
+    @Override
+    public int getCount() {
+      return mMethodDescriptors.size();
+    }
+
+    @Override
+    public Object getItem(int position) {
+      return mMethodDescriptors.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(final int position, View convertView, ViewGroup parent) {
+      TextView view;
+      if (convertView == null) {
+        view = new TextView(ApiBrowser.this);
+      } else {
+        view = (TextView) convertView;
+      }
+      view.setPadding(4, 4, 4, 4);
+      view.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
+      if (mExpandedPositions.contains(position)) {
+        view.setText(mMethodDescriptors.get(position).getHelp());
+      } else {
+        view.setText(mMethodDescriptors.get(position).getName());
+      }
+      return view;
+    }
+
+    @Override
+    public int getPositionForSection(int section) {
+      return mIndexer.getPositionForSection(section);
+    }
+
+    @Override
+    public int getSectionForPosition(int position) {
+      return mIndexer.getSectionForPosition(position);
+    }
+
+    @Override
+    public Object[] getSections() {
+      return mIndexer.getSections();
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ApiPrompt.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ApiPrompt.java
new file mode 100644
index 0000000..e9655a2
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ApiPrompt.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.View.OnClickListener;
+import android.widget.BaseAdapter;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+
+/**
+ * Prompts for API parameters.
+ *
+ * <p>
+ * This activity is started by {@link ApiBrowser} to prompt user for RPC call parameters.
+ * Input/output interface is RPC name and explicit parameter values.
+ *
+ * @author igor.v.karp@gmail.com (Igor Karp)
+ */
+public class ApiPrompt extends Activity {
+  private MethodDescriptor mRpc;
+  private String[] mHints;
+  private String[] mValues;
+  private ApiPromptAdapter mAdapter;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.api_prompt);
+    mRpc =
+        FacadeConfiguration.getMethodDescriptor(getIntent().getStringExtra(
+            Constants.EXTRA_API_PROMPT_RPC_NAME));
+    mHints = mRpc.getParameterHints();
+    mValues = getIntent().getStringArrayExtra(Constants.EXTRA_API_PROMPT_VALUES);
+    mAdapter = new ApiPromptAdapter();
+    ((ListView) findViewById(R.id.list)).setAdapter(mAdapter);
+    ((Button) findViewById(R.id.done)).setOnClickListener(new OnClickListener() {
+      @Override
+      public void onClick(View v) {
+        Intent intent = new Intent();
+        intent.putExtra(Constants.EXTRA_API_PROMPT_RPC_NAME, mRpc.getName());
+        intent.putExtra(Constants.EXTRA_API_PROMPT_VALUES, mValues);
+        setResult(RESULT_OK, intent);
+        finish();
+      }
+    });
+    setResult(RESULT_CANCELED);
+  }
+
+  private class ApiPromptAdapter extends BaseAdapter {
+    @Override
+    public int getCount() {
+      return mHints.length;
+    }
+
+    @Override
+    public Object getItem(int position) {
+      return mValues[position];
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+      View item;
+      if (convertView == null) {
+        LayoutInflater inflater =
+            (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        item =
+            inflater.inflate(R.layout.api_prompt_item, parent, false /* do not attach to root */);
+      } else {
+        item = convertView;
+      }
+      TextView description = (TextView) item.findViewById(R.id.api_prompt_item_description);
+      EditText value = (EditText) item.findViewById(R.id.api_prompt_item_value);
+      description.setText(mHints[position]);
+      value.setText(mValues[position]);
+      value.addTextChangedListener(new ValueWatcher(position));
+      return item;
+    }
+  }
+
+  private class ValueWatcher implements TextWatcher {
+    private final int mPosition;
+
+    public ValueWatcher(int position) {
+      mPosition = position;
+    }
+
+    @Override
+    public void afterTextChanged(Editable e) {
+    }
+
+    @Override
+    public void beforeTextChanged(CharSequence s, int start, int before, int count) {
+    }
+
+    @Override
+    public void onTextChanged(CharSequence s, int start, int before, int count) {
+      mValues[mPosition] = s.toString();
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/BluetoothDeviceList.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/BluetoothDeviceList.java
new file mode 100644
index 0000000..962f69f
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/BluetoothDeviceList.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.ListActivity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.TypedValue;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothDiscoveryHelper;
+import com.googlecode.android_scripting.facade.bluetooth.BluetoothDiscoveryHelper.BluetoothDiscoveryListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BluetoothDeviceList extends ListActivity {
+
+  private static class DeviceInfo {
+    public final String mmName;
+    public final String mmAddress;
+
+    public DeviceInfo(String name, String address) {
+      mmName = name;
+      mmAddress = address;
+    }
+  }
+
+  private final DeviceListAdapter mAdapter = new DeviceListAdapter();
+  private final BluetoothDiscoveryHelper mBluetoothHelper =
+      new BluetoothDiscoveryHelper(this, mAdapter);
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "Bluetooth Devices", R.layout.bluetooth_device_list);
+    setListAdapter(mAdapter);
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    CustomizeWindow.toggleProgressBarVisibility(this, true);
+    mBluetoothHelper.startDiscovery();
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    mBluetoothHelper.cancel();
+  }
+
+  @Override
+  protected void onListItemClick(android.widget.ListView l, View v, int position, long id) {
+    DeviceInfo device = (DeviceInfo) mAdapter.getItem(position);
+    final Intent result = new Intent();
+    result.putExtra(Constants.EXTRA_DEVICE_ADDRESS, device.mmAddress);
+    setResult(RESULT_OK, result);
+    finish();
+  };
+
+  private class DeviceListAdapter extends BaseAdapter implements BluetoothDiscoveryListener {
+    List<DeviceInfo> mmDeviceList;
+
+    public DeviceListAdapter() {
+      mmDeviceList = new ArrayList<DeviceInfo>();
+    }
+
+    @Override
+    public void addDevice(String name, String address) {
+      mmDeviceList.add(new DeviceInfo(name, address));
+      notifyDataSetChanged();
+    }
+
+    @Override
+    public int getCount() {
+      return mmDeviceList.size();
+    }
+
+    @Override
+    public Object getItem(int position) {
+      return mmDeviceList.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup viewGroup) {
+      final DeviceInfo device = mmDeviceList.get(position);
+      final TextView view = new TextView(BluetoothDeviceList.this);
+      view.setPadding(2, 2, 2, 2);
+      view.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 20);
+      view.setText(device.mmName + " (" + device.mmAddress + ")");
+      return view;
+    }
+
+    @Override
+    public void addBondedDevice(String name, String address) {
+      addDevice(name, address);
+    }
+
+    @Override
+    public void scanDone() {
+      CustomizeWindow.toggleProgressBarVisibility(BluetoothDeviceList.this, false);
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/CustomizeWindow.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/CustomizeWindow.java
new file mode 100644
index 0000000..897748f
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/CustomizeWindow.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.Window;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.Version;
+
+public class CustomizeWindow {
+  private CustomizeWindow() {
+    // Utility class.
+  }
+
+  public static void requestCustomTitle(Activity activity, String title, int contentViewLayoutResId) {
+    //b/26218264
+    //activity.requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
+    //activity.setContentView(contentViewLayoutResId);
+    //activity.getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.title);
+    //((TextView) activity.findViewById(R.id.left_text)).setText(title);
+    //((TextView) activity.findViewById(R.id.right_text)).setText("SL4A r"
+    //    + Version.getVersion(activity));
+  }
+
+  public static void toggleProgressBarVisibility(Activity activity, boolean on) {
+    ((ProgressBar) activity.findViewById(R.id.progress_bar)).setVisibility(on ? View.VISIBLE
+        : View.GONE);
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/InterpreterManager.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/InterpreterManager.java
new file mode 100644
index 0000000..dcba601
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/InterpreterManager.java
@@ -0,0 +1,265 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.AlertDialog;
+import android.app.ListActivity;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.DataSetObserver;
+import android.net.Uri;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.SubMenu;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.ActivityFlinger;
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.FeaturedInterpreters;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration.ConfigurationObserver;
+import com.googlecode.android_scripting.interpreter.html.HtmlInterpreter;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
+public class InterpreterManager extends ListActivity {
+
+  private InterpreterManagerAdapter mAdapter;
+  private InterpreterListObserver mObserver;
+  private List<Interpreter> mInterpreters;
+  private List<String> mFeaturedInterpreters;
+  private InterpreterConfiguration mConfiguration;
+  private SharedPreferences mPreferences;
+
+  private static enum MenuId {
+    HELP, ADD, NETWORK, PREFERENCES;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "Interpreters", R.layout.interpreter_manager);
+    mConfiguration = ((BaseApplication) getApplication()).getInterpreterConfiguration();
+    mInterpreters = new ArrayList<Interpreter>();
+    mAdapter = new InterpreterManagerAdapter();
+    mObserver = new InterpreterListObserver();
+    mAdapter.registerDataSetObserver(mObserver);
+    setListAdapter(mAdapter);
+    ActivityFlinger.attachView(getListView(), this);
+    ActivityFlinger.attachView(getWindow().getDecorView(), this);
+    mFeaturedInterpreters = FeaturedInterpreters.getList();
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    mConfiguration.registerObserver(mObserver);
+    mAdapter.notifyDataSetInvalidated();
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    mAdapter.notifyDataSetInvalidated();
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    mConfiguration.unregisterObserver(mObserver);
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    menu.clear();
+    buildInstallLanguagesMenu(menu);
+    menu.add(Menu.NONE, MenuId.NETWORK.getId(), Menu.NONE, "Start Server").setIcon(
+        android.R.drawable.ic_menu_share);
+    menu.add(Menu.NONE, MenuId.PREFERENCES.getId(), Menu.NONE, "Preferences").setIcon(
+        android.R.drawable.ic_menu_preferences);
+    return super.onPrepareOptionsMenu(menu);
+  }
+
+  private void buildInstallLanguagesMenu(Menu menu) {
+    SubMenu installMenu =
+        menu.addSubMenu(Menu.NONE, MenuId.ADD.getId(), Menu.NONE, "Add").setIcon(
+            android.R.drawable.ic_menu_add);
+    int i = MenuId.values().length + Menu.FIRST;
+    for (String interpreterName : mFeaturedInterpreters) {
+      installMenu.add(Menu.NONE, i++, Menu.NONE, interpreterName);
+    }
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    int itemId = item.getItemId();
+    if (itemId == MenuId.NETWORK.getId()) {
+      AlertDialog.Builder dialog = new AlertDialog.Builder(this);
+      dialog.setItems(new CharSequence[] { "Public", "Private" }, new OnClickListener() {
+        @Override
+        public void onClick(DialogInterface dialog, int which) {
+          launchService(which == 0 /* usePublicIp */);
+        }
+      });
+      dialog.show();
+    } else if (itemId == MenuId.PREFERENCES.getId()) {
+      startActivity(new Intent(this, Preferences.class));
+    } else if (itemId >= MenuId.values().length + Menu.FIRST) {
+      int i = itemId - MenuId.values().length - Menu.FIRST;
+      if (i < mFeaturedInterpreters.size()) {
+        URL url = FeaturedInterpreters.getUrlForName(mFeaturedInterpreters.get(i));
+        Intent viewIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url.toString()));
+        startActivity(viewIntent);
+      }
+    }
+    return true;
+  }
+
+  private int getPrefInt(String key, int defaultValue) {
+    int result = defaultValue;
+    String value = mPreferences.getString(key, null);
+    if (value != null) {
+      try {
+        result = Integer.parseInt(value);
+      } catch (NumberFormatException e) {
+        result = defaultValue;
+      }
+    }
+    return result;
+  }
+
+  private void launchService(boolean usePublicIp) {
+    Intent intent = new Intent(this, ScriptingLayerService.class);
+    intent.setAction(Constants.ACTION_LAUNCH_SERVER);
+    intent.putExtra(Constants.EXTRA_USE_EXTERNAL_IP, usePublicIp);
+    intent.putExtra(Constants.EXTRA_USE_SERVICE_PORT, getPrefInt("use_service_port", 0));
+    startService(intent);
+  }
+
+  private void launchTerminal(Interpreter interpreter) {
+    if (interpreter instanceof HtmlInterpreter) {
+      return;
+    }
+    Intent intent = new Intent(this, ScriptingLayerService.class);
+    intent.setAction(Constants.ACTION_LAUNCH_INTERPRETER);
+    intent.putExtra(Constants.EXTRA_INTERPRETER_NAME, interpreter.getName());
+    startService(intent);
+  }
+
+  @Override
+  protected void onListItemClick(ListView list, View view, int position, long id) {
+    Interpreter interpreter = (Interpreter) list.getItemAtPosition(position);
+    launchTerminal(interpreter);
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    mConfiguration.unregisterObserver(mObserver);
+  }
+
+  private class InterpreterListObserver extends DataSetObserver implements ConfigurationObserver {
+    @Override
+    public void onInvalidated() {
+      mInterpreters = mConfiguration.getInteractiveInterpreters();
+    }
+
+    @Override
+    public void onChanged() {
+      mInterpreters = mConfiguration.getInteractiveInterpreters();
+    }
+
+    @Override
+    public void onConfigurationChanged() {
+      runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          mAdapter.notifyDataSetChanged();
+        }
+      });
+    }
+  }
+
+  private class InterpreterManagerAdapter extends BaseAdapter {
+
+    @Override
+    public int getCount() {
+      return mInterpreters.size();
+    }
+
+    @Override
+    public Object getItem(int position) {
+      return mInterpreters.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+      LinearLayout container;
+
+      Interpreter interpreter = mInterpreters.get(position);
+
+      if (convertView == null) {
+        LayoutInflater inflater =
+            (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        container = (LinearLayout) inflater.inflate(R.layout.list_item, null);
+      } else {
+        container = (LinearLayout) convertView;
+      }
+      ImageView img = (ImageView) container.findViewById(R.id.list_item_icon);
+
+      int imgId =
+          FeaturedInterpreters.getInterpreterIcon(InterpreterManager.this,
+              interpreter.getExtension());
+      if (imgId == 0) {
+        imgId = R.drawable.sl4a_logo_32;
+      }
+
+      img.setImageResource(imgId);
+
+      TextView text = (TextView) container.findViewById(R.id.list_item_title);
+
+      text.setText(interpreter.getNiceName());
+      return container;
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/InterpreterPicker.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/InterpreterPicker.java
new file mode 100644
index 0000000..79145d5
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/InterpreterPicker.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.ListActivity;
+import android.content.Context;
+import android.content.Intent;
+import android.database.DataSetObserver;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.FeaturedInterpreters;
+import com.googlecode.android_scripting.IntentBuilders;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration.ConfigurationObserver;
+
+import java.util.List;
+
+/**
+ * Presents available scripts and returns the selected one.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class InterpreterPicker extends ListActivity {
+
+  private List<Interpreter> mInterpreters;
+  private InterpreterPickerAdapter mAdapter;
+  private InterpreterConfiguration mConfiguration;
+  private ScriptListObserver mObserver;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "Interpreters", R.layout.script_manager);
+    mObserver = new ScriptListObserver();
+    mConfiguration = ((BaseApplication) getApplication()).getInterpreterConfiguration();
+    mInterpreters = mConfiguration.getInteractiveInterpreters();
+    mConfiguration.registerObserver(mObserver);
+    mAdapter = new InterpreterPickerAdapter();
+    mAdapter.registerDataSetObserver(mObserver);
+    setListAdapter(mAdapter);
+  }
+
+  @Override
+  protected void onListItemClick(ListView list, View view, int position, long id) {
+    final Interpreter interpreter = (Interpreter) list.getItemAtPosition(position);
+    if (Intent.ACTION_CREATE_SHORTCUT.equals(getIntent().getAction())) {
+      int icon =
+          FeaturedInterpreters.getInterpreterIcon(InterpreterPicker.this, interpreter
+              .getExtension());
+      if (icon == 0) {
+        icon = R.drawable.sl4a_logo_48;
+      }
+      Parcelable iconResource =
+          Intent.ShortcutIconResource.fromContext(InterpreterPicker.this, icon);
+      Intent intent = IntentBuilders.buildInterpreterShortcutIntent(interpreter, iconResource);
+      setResult(RESULT_OK, intent);
+    }
+    finish();
+  }
+
+  @Override
+  protected void onDestroy() {
+    super.onDestroy();
+    mConfiguration.unregisterObserver(mObserver);
+  }
+
+  private class ScriptListObserver extends DataSetObserver implements ConfigurationObserver {
+    @Override
+    public void onInvalidated() {
+      mInterpreters = mConfiguration.getInteractiveInterpreters();
+    }
+
+    @Override
+    public void onConfigurationChanged() {
+      mAdapter.notifyDataSetInvalidated();
+    }
+  }
+
+  private class InterpreterPickerAdapter extends BaseAdapter {
+
+    @Override
+    public int getCount() {
+      return mInterpreters.size();
+    }
+
+    @Override
+    public Object getItem(int position) {
+      return mInterpreters.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+      LinearLayout container;
+
+      Interpreter interpreter = mInterpreters.get(position);
+
+      if (convertView == null) {
+        LayoutInflater inflater =
+            (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        container = (LinearLayout) inflater.inflate(R.layout.list_item, null);
+      } else {
+        container = (LinearLayout) convertView;
+      }
+      ImageView img = (ImageView) container.findViewById(R.id.list_item_icon);
+
+      int imgId =
+          FeaturedInterpreters.getInterpreterIcon(InterpreterPicker.this, interpreter
+              .getExtension());
+      if (imgId == 0) {
+        imgId = R.drawable.sl4a_logo_32;
+      }
+
+      img.setImageResource(imgId);
+
+      TextView text = (TextView) container.findViewById(R.id.list_item_title);
+
+      text.setText(interpreter.getNiceName());
+      return container;
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/LogcatViewer.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/LogcatViewer.java
new file mode 100644
index 0000000..7025c23
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/LogcatViewer.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.ListActivity;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.text.ClipboardManager;
+import android.util.TypedValue;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.googlecode.android_scripting.ActivityFlinger;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.Process;
+import com.googlecode.android_scripting.R;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.LinkedList;
+import java.util.List;
+
+public class LogcatViewer extends ListActivity {
+
+  private List<String> mLogcatMessages;
+  private int mOldLastPosition;
+  private LogcatViewerAdapter mAdapter;
+  private Process mLogcatProcess;
+
+  private static enum MenuId {
+    HELP, PREFERENCES, JUMP_TO_BOTTOM, SHARE, COPY;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  private class LogcatWatcher implements Runnable {
+    @Override
+    public void run() {
+      mLogcatProcess = new Process();
+      mLogcatProcess.setBinary(new File("/system/bin/logcat"));
+      mLogcatProcess.start(null);
+      try {
+        BufferedReader br = new BufferedReader(new InputStreamReader(mLogcatProcess.getIn()));
+        while (true) {
+          final String line = br.readLine();
+          if (line == null) {
+            break;
+          }
+          runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+              mLogcatMessages.add(line);
+              mAdapter.notifyDataSetInvalidated();
+              // This logic performs what transcriptMode="normal" should do. Since that doesn't seem
+              // to work, we do it this way.
+              int lastVisiblePosition = getListView().getLastVisiblePosition();
+              int lastPosition = mLogcatMessages.size() - 1;
+              if (lastVisiblePosition == mOldLastPosition || lastVisiblePosition == -1) {
+                getListView().setSelection(lastPosition);
+              }
+              mOldLastPosition = lastPosition;
+            }
+          });
+        }
+      } catch (IOException e) {
+        Log.e("Failed to read from logcat process.", e);
+      } finally {
+        mLogcatProcess.kill();
+      }
+    }
+  }
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "Logcat", R.layout.logcat_viewer);
+    mLogcatMessages = new LinkedList<String>();
+    mOldLastPosition = 0;
+    mAdapter = new LogcatViewerAdapter();
+    setListAdapter(mAdapter);
+    ActivityFlinger.attachView(getListView(), this);
+    ActivityFlinger.attachView(getWindow().getDecorView(), this);
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    menu.add(Menu.NONE, MenuId.PREFERENCES.getId(), Menu.NONE, "Preferences").setIcon(
+        android.R.drawable.ic_menu_preferences);
+    menu.add(Menu.NONE, MenuId.JUMP_TO_BOTTOM.getId(), Menu.NONE, "Jump to Bottom").setIcon(
+        android.R.drawable.ic_menu_revert);
+    menu.add(Menu.NONE, MenuId.SHARE.getId(), Menu.NONE, "Share").setIcon(
+        android.R.drawable.ic_menu_share);
+    menu.add(Menu.NONE, MenuId.COPY.getId(), Menu.NONE, "Copy").setIcon(
+        android.R.drawable.ic_menu_edit);
+    return super.onCreateOptionsMenu(menu);
+  }
+
+  private String getAsString() {
+    StringBuilder builder = new StringBuilder();
+    for (String message : mLogcatMessages) {
+      builder.append(message + "\n");
+    }
+    return builder.toString();
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    int itemId = item.getItemId();
+    if (itemId == MenuId.JUMP_TO_BOTTOM.getId()) {
+      getListView().setSelection(mLogcatMessages.size() - 1);
+    } else if (itemId == MenuId.PREFERENCES.getId()) {
+      startActivity(new Intent(this, Preferences.class));
+    } else if (itemId == MenuId.SHARE.getId()) {
+      Intent intent = new Intent(Intent.ACTION_SEND);
+      intent.putExtra(Intent.EXTRA_TEXT, getAsString().toString());
+      intent.putExtra(Intent.EXTRA_SUBJECT, "Logcat Dump");
+      intent.setType("text/plain");
+      startActivity(Intent.createChooser(intent, "Send Logcat to:"));
+    } else if (itemId == MenuId.COPY.getId()) {
+      ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
+      clipboard.setText(getAsString());
+      Toast.makeText(this, "Copied to clipboard", Toast.LENGTH_SHORT).show();
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  @Override
+  protected void onStart() {
+    mLogcatMessages.clear();
+    Thread logcatWatcher = new Thread(new LogcatWatcher());
+    logcatWatcher.setPriority(Thread.NORM_PRIORITY - 1);
+    logcatWatcher.start();
+    mAdapter.notifyDataSetInvalidated();
+    super.onStart();
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    mLogcatProcess.kill();
+  }
+
+  private class LogcatViewerAdapter extends BaseAdapter {
+
+    @Override
+    public int getCount() {
+      return mLogcatMessages.size();
+    }
+
+    @Override
+    public Object getItem(int position) {
+      return mLogcatMessages.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(final int position, View convertView, ViewGroup parent) {
+      TextView view = new TextView(LogcatViewer.this);
+      view.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
+      view.setText(mLogcatMessages.get(position));
+      return view;
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/Preferences.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/Preferences.java
new file mode 100644
index 0000000..5197d9e
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/Preferences.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+
+import com.googlecode.android_scripting.R;
+
+public class Preferences extends PreferenceActivity {
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    // Load the preferences from an XML resource
+    addPreferencesFromResource(R.xml.preferences);
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptEditor.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptEditor.java
new file mode 100644
index 0000000..b83720e
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptEditor.java
@@ -0,0 +1,621 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.media.AudioManager;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Editable;
+import android.text.InputFilter;
+import android.text.InputType;
+import android.text.Selection;
+import android.text.Spanned;
+import android.text.TextWatcher;
+import android.text.style.UnderlineSpan;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.EditText;
+import android.widget.Toast;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.FileUtils;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.ScriptStorageAdapter;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Vector;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * A text editor for scripts.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class ScriptEditor extends Activity implements OnClickListener {
+  private static final int DIALOG_FIND_REPLACE = 2;
+  private static final int DIALOG_LINE = 1;
+  private EditText mNameText;
+  private EditText mContentText;
+  private boolean mScheduleMoveLeft;
+  private String mLastSavedContent;
+  private SharedPreferences mPreferences;
+  private InterpreterConfiguration mConfiguration;
+  private ContentTextWatcher mWatcher;
+  private EditHistory mHistory;
+  private File mScript;
+  private EditText mLineNo;
+
+  private boolean mIsUndoOrRedo = false;
+  private boolean mEnableAutoClose;
+  private boolean mAutoIndent;
+
+  private EditText mSearchFind;
+  private EditText mSearchReplace;
+  private CheckBox mSearchCase;
+  private CheckBox mSearchWord;
+  private CheckBox mSearchAll;
+  private CheckBox mSearchStart;
+
+  private static enum MenuId {
+    SAVE, SAVE_AND_RUN, PREFERENCES, API_BROWSER, HELP, SHARE, GOTO, SEARCH;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  private static enum RequestCode {
+    RPC_HELP
+  }
+
+  private int readIntPref(String key, int defaultValue, int maxValue) {
+    int val;
+    try {
+      val = Integer.parseInt(mPreferences.getString(key, Integer.toString(defaultValue)));
+    } catch (NumberFormatException e) {
+      val = defaultValue;
+    }
+    val = Math.max(0, Math.min(val, maxValue));
+    return val;
+  }
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.script_editor);
+    mNameText = (EditText) findViewById(R.id.script_editor_title);
+    mContentText = (EditText) findViewById(R.id.script_editor_body);
+    mHistory = new EditHistory();
+    mWatcher = new ContentTextWatcher(mHistory);
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+    updatePreferences();
+
+    mScript = new File(getIntent().getStringExtra(Constants.EXTRA_SCRIPT_PATH));
+    mNameText.setText(mScript.getName());
+    mNameText.setSelected(true);
+    // NOTE: This appears to be the only way to get Android to put the cursor to the beginning of
+    // the EditText field.
+    mNameText.setSelection(1);
+    mNameText.extendSelection(0);
+    mNameText.setSelection(0);
+    mLastSavedContent = getIntent().getStringExtra(Constants.EXTRA_SCRIPT_CONTENT);
+    if (mLastSavedContent == null) {
+      try {
+        mLastSavedContent = FileUtils.readToString(mScript);
+      } catch (IOException e) {
+        Log.e("Failed to read script.", e);
+        mLastSavedContent = "";
+      } finally {
+      }
+    }
+
+    mContentText.setText(mLastSavedContent);
+    InputFilter[] oldFilters = mContentText.getFilters();
+    List<InputFilter> filters = new ArrayList<InputFilter>(oldFilters.length + 1);
+    filters.addAll(Arrays.asList(oldFilters));
+    filters.add(new ContentInputFilter());
+    mContentText.setFilters(filters.toArray(oldFilters));
+    mContentText.addTextChangedListener(mWatcher);
+    mConfiguration = ((BaseApplication) getApplication()).getInterpreterConfiguration();
+    // Disables volume key beep.
+    setVolumeControlStream(AudioManager.STREAM_MUSIC);
+    mLineNo = new EditText(this);
+    mLineNo.setInputType(InputType.TYPE_CLASS_NUMBER);
+    int lastLocation = mPreferences.getInt("lasteditpos." + mScript, -1);
+    if (lastLocation >= 0) {
+      mContentText.requestFocus();
+      mContentText.setSelection(lastLocation);
+    }
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    updatePreferences();
+  }
+
+  private void updatePreferences() {
+    mContentText.setTextSize(readIntPref("editor_fontsize", 10, 30));
+    mEnableAutoClose = mPreferences.getBoolean("enableAutoClose", true);
+    mAutoIndent = mPreferences.getBoolean("editor_auto_indent", false);
+    mContentText.setHorizontallyScrolling(mPreferences.getBoolean("editor_no_wrap", false));
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    super.onCreateOptionsMenu(menu);
+    menu.add(0, MenuId.SAVE.getId(), 0, "Save & Exit").setIcon(android.R.drawable.ic_menu_save);
+    menu.add(0, MenuId.SAVE_AND_RUN.getId(), 0, "Save & Run").setIcon(
+        android.R.drawable.ic_media_play);
+    menu.add(0, MenuId.PREFERENCES.getId(), 0, "Preferences").setIcon(
+        android.R.drawable.ic_menu_preferences);
+    menu.add(0, MenuId.API_BROWSER.getId(), 0, "API Browser").setIcon(
+        android.R.drawable.ic_menu_info_details);
+    menu.add(0, MenuId.SHARE.getId(), 0, "Share").setIcon(android.R.drawable.ic_menu_share);
+    menu.add(0, MenuId.GOTO.getId(), 0, "GoTo").setIcon(android.R.drawable.ic_menu_directions);
+    menu.add(0, MenuId.SEARCH.getId(), 0, "Find").setIcon(android.R.drawable.ic_menu_search);
+    return true;
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    if (item.getItemId() == MenuId.SAVE.getId()) {
+      save();
+      finish();
+    } else if (item.getItemId() == MenuId.SAVE_AND_RUN.getId()) {
+      save();
+      Interpreter interpreter =
+          mConfiguration.getInterpreterForScript(mNameText.getText().toString());
+      if (interpreter != null) { // We may be editing an unknown type.
+        Intent intent = new Intent(this, ScriptingLayerService.class);
+        intent.setAction(Constants.ACTION_LAUNCH_FOREGROUND_SCRIPT);
+        intent.putExtra(Constants.EXTRA_SCRIPT_PATH, mScript.getAbsolutePath());
+        startService(intent);
+      } else {
+        // TODO(damonkohler): Should remove menu option.
+        Toast.makeText(this, "Can't run this type.", Toast.LENGTH_SHORT).show();
+      }
+      finish();
+    } else if (item.getItemId() == MenuId.PREFERENCES.getId()) {
+      startActivity(new Intent(this, Preferences.class));
+    } else if (item.getItemId() == MenuId.API_BROWSER.getId()) {
+      Intent intent = new Intent(this, ApiBrowser.class);
+      intent.putExtra(Constants.EXTRA_SCRIPT_PATH, mNameText.getText().toString());
+      intent.putExtra(Constants.EXTRA_INTERPRETER_NAME,
+          mConfiguration.getInterpreterForScript(mNameText.getText().toString()).getName());
+      intent.putExtra(Constants.EXTRA_SCRIPT_TEXT, mContentText.getText().toString());
+      startActivityForResult(intent, RequestCode.RPC_HELP.ordinal());
+    } else if (item.getItemId() == MenuId.SHARE.getId()) {
+      Intent intent = new Intent(Intent.ACTION_SEND);
+      intent.putExtra(Intent.EXTRA_TEXT, mContentText.getText().toString());
+      intent.putExtra(Intent.EXTRA_SUBJECT, "Share " + mNameText.getText().toString());
+      intent.setType("text/plain");
+      startActivity(Intent.createChooser(intent, "Send Script to:"));
+    } else if (item.getItemId() == MenuId.GOTO.getId()) {
+      showDialog(DIALOG_LINE);
+    } else if (item.getItemId() == MenuId.SEARCH.getId()) {
+      showDialog(DIALOG_FIND_REPLACE);
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  @Override
+  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    super.onActivityResult(requestCode, resultCode, data);
+    RequestCode request = RequestCode.values()[requestCode];
+
+    if (resultCode == RESULT_OK) {
+      switch (request) {
+      case RPC_HELP:
+        String rpcText = data.getStringExtra(Constants.EXTRA_RPC_HELP_TEXT);
+        insertContent(rpcText);
+        break;
+      default:
+        break;
+      }
+    } else {
+      switch (request) {
+      case RPC_HELP:
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  private void save() {
+    int start = mContentText.getSelectionStart();
+    mLastSavedContent = mContentText.getText().toString();
+    mScript = new File(mScript.getParent(), mNameText.getText().toString());
+    ScriptStorageAdapter.writeScript(mScript, mLastSavedContent);
+    Toast.makeText(this, "Saved " + mNameText.getText().toString(), Toast.LENGTH_SHORT).show();
+    Editor e = mPreferences.edit();
+    e.putInt("lasteditpos." + mScript, start);
+    e.commit();
+  }
+
+  private void insertContent(String text) {
+    int selectionStart = Math.min(mContentText.getSelectionStart(), mContentText.getSelectionEnd());
+    int selectionEnd = Math.max(mContentText.getSelectionStart(), mContentText.getSelectionEnd());
+    mContentText.getEditableText().replace(selectionStart, selectionEnd, text);
+  }
+
+  @Override
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_BACK && hasContentChanged()) {
+      AlertDialog.Builder alert = new AlertDialog.Builder(this);
+      setVolumeControlStream(AudioManager.STREAM_MUSIC);
+      alert.setCancelable(false);
+      alert.setTitle("Confirm exit");
+      alert.setMessage("Would you like to save?");
+      alert.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
+        public void onClick(DialogInterface dialog, int whichButton) {
+          save();
+          finish();
+        }
+      });
+      alert.setNegativeButton("No", new DialogInterface.OnClickListener() {
+        public void onClick(DialogInterface dialog, int whichButton) {
+          finish();
+        }
+      });
+      alert.setNeutralButton("Cancel", new DialogInterface.OnClickListener() {
+        public void onClick(DialogInterface dialog, int whichButton) {
+        }
+      });
+      alert.show();
+      return true;
+    } else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
+      redo();
+      return true;
+    } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
+      undo();
+      return true;
+    } else if (keyCode == KeyEvent.KEYCODE_SEARCH) {
+      showDialog(DIALOG_FIND_REPLACE);
+      return true;
+    } else {
+      return super.onKeyDown(keyCode, event);
+    }
+  }
+
+  @Override
+  protected Dialog onCreateDialog(int id, Bundle args) {
+    AlertDialog.Builder b = new AlertDialog.Builder(this);
+    if (id == DIALOG_LINE) {
+      b.setTitle("Goto Line");
+      b.setView(mLineNo);
+      b.setPositiveButton("Ok", new OnClickListener() {
+
+        @Override
+        public void onClick(DialogInterface dialog, int which) {
+          gotoLine(Integer.parseInt(mLineNo.getText().toString()));
+        }
+      });
+      b.setNegativeButton("Cancel", null);
+      return b.create();
+    } else if (id == DIALOG_FIND_REPLACE) {
+      View v = getLayoutInflater().inflate(R.layout.findreplace, null);
+      mSearchFind = (EditText) v.findViewById(R.id.searchFind);
+      mSearchReplace = (EditText) v.findViewById(R.id.searchReplace);
+      mSearchAll = (CheckBox) v.findViewById(R.id.searchAll);
+      mSearchCase = (CheckBox) v.findViewById(R.id.searchCase);
+      mSearchStart = (CheckBox) v.findViewById(R.id.searchStart);
+      mSearchWord = (CheckBox) v.findViewById(R.id.searchWord);
+      b.setTitle("Search and Replace");
+      b.setView(v);
+      b.setPositiveButton("Find", this);
+      b.setNeutralButton("Next", this);
+      b.setNegativeButton("Replace", this);
+      return b.create();
+    }
+
+    return super.onCreateDialog(id, args);
+  }
+
+  @Override
+  protected void onPrepareDialog(int id, Dialog dialog, Bundle args) {
+    if (id == DIALOG_LINE) {
+      mLineNo.setText(String.valueOf(getLineNo()));
+    } else if (id == DIALOG_FIND_REPLACE) {
+      mSearchStart.setChecked(false);
+    }
+    super.onPrepareDialog(id, dialog, args);
+  }
+
+  protected int getLineNo() {
+    int pos = mContentText.getSelectionStart();
+    String text = mContentText.getText().toString();
+    int i = 0;
+    int n = 1;
+    while (i < pos) {
+      int j = text.indexOf("\n", i);
+      if (j < 0) {
+        break;
+      }
+      i = j + 1;
+      if (i < pos) {
+        n += 1;
+      }
+    }
+    return n;
+  }
+
+  protected void gotoLine(int line) {
+    String text = mContentText.getText().toString();
+    if (text.length() < 1) {
+      return;
+    }
+    int i = 0;
+    int n = 1;
+    while (i < text.length() && n < line) {
+      int j = text.indexOf("\n", i);
+      if (j < 0) {
+        break;
+      }
+      i = j + 1;
+      n += 1;
+    }
+    mContentText.setSelection(Math.min(text.length() - 1, i));
+  }
+
+  @Override
+  protected void onUserLeaveHint() {
+    if (hasContentChanged()) {
+      save();
+    }
+  }
+
+  private boolean hasContentChanged() {
+    return !mLastSavedContent.equals(mContentText.getText().toString());
+  }
+
+  private final class ContentInputFilter implements InputFilter {
+    @Override
+    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart,
+        int dend) {
+      if (end - start == 1) {
+        Interpreter ip = mConfiguration.getInterpreterForScript(mNameText.getText().toString());
+        String auto = null;
+        if (ip != null && mEnableAutoClose) {
+          auto = ip.getLanguage().autoClose(source.charAt(start));
+        }
+        // Auto indent code?
+        if (auto == null && source.charAt(start) == '\n' && mAutoIndent) {
+          int i = dstart - 1;
+          int spaces = 0;
+          while ((i >= 0) && dest.charAt(i) != '\n') {
+            i -= 1; // Find start of line.
+          }
+          i += 1;
+          while (i < dest.length() && dest.charAt(i++) == ' ') {
+            spaces += 1;
+          }
+          if (spaces > 0) {
+            return String.format("\n%" + spaces + "s", " ");
+          }
+        }
+        if (auto != null) {
+          mScheduleMoveLeft = true;
+          return auto;
+        }
+      }
+      return null;
+    }
+  }
+
+  private final class ContentTextWatcher implements TextWatcher {
+    private final EditHistory mmEditHistory;
+    private CharSequence mmBeforeChange;
+    private CharSequence mmAfterChange;
+
+    private ContentTextWatcher(EditHistory history) {
+      mmEditHistory = history;
+    }
+
+    @Override
+    public void onTextChanged(CharSequence s, int start, int before, int count) {
+      if (!mIsUndoOrRedo) {
+        mmAfterChange = s.subSequence(start, start + count);
+        mmEditHistory.add(new EditItem(start, mmBeforeChange, mmAfterChange));
+      }
+    }
+
+    @Override
+    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+      if (!mIsUndoOrRedo) {
+        mmBeforeChange = s.subSequence(start, start + count);
+      }
+    }
+
+    @Override
+    public void afterTextChanged(Editable s) {
+      if (mScheduleMoveLeft) {
+        mScheduleMoveLeft = false;
+        Selection.moveLeft(mContentText.getText(), mContentText.getLayout());
+      }
+    }
+  }
+
+  /**
+   * Keeps track of all the edit history of a text.
+   */
+  private final class EditHistory {
+    int mmPosition = 0;
+    private final Vector<EditItem> mmHistory = new Vector<EditItem>();
+
+    /**
+     * Adds a new edit operation to the history at the current position. If executed after a call to
+     * getPrevious() removes all the future history (elements with positions >= current history
+     * position).
+     *
+     */
+    private void add(EditItem item) {
+      mmHistory.setSize(mmPosition);
+      mmHistory.add(item);
+      mmPosition++;
+    }
+
+    /**
+     * Traverses the history backward by one position, returns and item at that position.
+     */
+    private EditItem getPrevious() {
+      if (mmPosition == 0) {
+        return null;
+      }
+      mmPosition--;
+      return mmHistory.get(mmPosition);
+    }
+
+    /**
+     * Traverses the history forward by one position, returns and item at that position.
+     */
+    private EditItem getNext() {
+      if (mmPosition == mmHistory.size()) {
+        return null;
+      }
+      EditItem item = mmHistory.get(mmPosition);
+      mmPosition++;
+      return item;
+    }
+  }
+
+  /**
+   * Represents a single edit operation.
+   */
+  private final class EditItem {
+    private final int mmIndex;
+    private final CharSequence mmBefore;
+    private final CharSequence mmAfter;
+
+    /**
+     * Constructs EditItem of a modification that was applied at position start and replaced
+     * CharSequence before with CharSequence after.
+     */
+    public EditItem(int start, CharSequence before, CharSequence after) {
+      mmIndex = start;
+      mmBefore = before;
+      mmAfter = after;
+    }
+  }
+
+  private void undo() {
+    EditItem edit = mHistory.getPrevious();
+    if (edit == null) {
+      return;
+    }
+    Editable text = mContentText.getText();
+    int start = edit.mmIndex;
+    int end = start + (edit.mmAfter != null ? edit.mmAfter.length() : 0);
+    mIsUndoOrRedo = true;
+    text.replace(start, end, edit.mmBefore);
+    mIsUndoOrRedo = false;
+    // This will get rid of underlines inserted when editor tries to come up with a suggestion.
+    for (Object o : text.getSpans(0, text.length(), UnderlineSpan.class)) {
+      text.removeSpan(o);
+    }
+    Selection.setSelection(text, edit.mmBefore == null ? start : (start + edit.mmBefore.length()));
+  }
+
+  private void redo() {
+    EditItem edit = mHistory.getNext();
+    if (edit == null) {
+      return;
+    }
+    Editable text = mContentText.getText();
+    int start = edit.mmIndex;
+    int end = start + (edit.mmBefore != null ? edit.mmBefore.length() : 0);
+    mIsUndoOrRedo = true;
+    text.replace(start, end, edit.mmAfter);
+    mIsUndoOrRedo = false;
+    for (Object o : text.getSpans(0, text.length(), UnderlineSpan.class)) {
+      text.removeSpan(o);
+    }
+    Selection.setSelection(text, edit.mmAfter == null ? start : (start + edit.mmAfter.length()));
+  }
+
+  @Override
+  public void onClick(DialogInterface dialog, int which) {
+    int start = mContentText.getSelectionStart();
+    int end = mContentText.getSelectionEnd();
+    String original = mContentText.getText().toString();
+    if (start == end || which != AlertDialog.BUTTON_NEGATIVE) {
+      end = original.length();
+    }
+    if (which == AlertDialog.BUTTON_NEUTRAL) {
+      start += 1;
+    }
+    if (mSearchStart.isChecked()) {
+      start = 0;
+      end = original.length();
+    }
+    String findText = mSearchFind.getText().toString();
+    String replaceText = mSearchReplace.getText().toString();
+    String search = Pattern.quote(findText);
+    int flags = 0;
+    if (!mSearchCase.isChecked()) {
+      flags |= Pattern.CASE_INSENSITIVE;
+    }
+    if (mSearchWord.isChecked()) {
+      search = "\\b" + search + "\\b";
+    }
+    Pattern p = Pattern.compile(search, flags);
+    Matcher m = p.matcher(original);
+    m.region(start, end);
+    if (!m.find()) {
+      Toast.makeText(this, "Search not found.", Toast.LENGTH_SHORT).show();
+      return;
+    }
+    int foundpos = m.start();
+    if (which != AlertDialog.BUTTON_NEGATIVE) { // Find
+      mContentText.setSelection(foundpos, foundpos + findText.length());
+    } else { // Replace
+      String s;
+      // Seems to be a bug in the android 2.2 implementation of replace... regions not returning
+      // whole string.
+      m = p.matcher(original.substring(start, end));
+      String replace = Matcher.quoteReplacement(replaceText);
+      if (mSearchAll.isChecked()) {
+        s = m.replaceAll(replace);
+      } else {
+        s = m.replaceFirst(replace);
+      }
+      mContentText.setText(original.substring(0, start) + s + original.substring(end));
+      mContentText.setSelection(foundpos, foundpos + replaceText.length());
+    }
+    mContentText.requestFocus();
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptManager.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptManager.java
new file mode 100644
index 0000000..9cc7c97
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptManager.java
@@ -0,0 +1,579 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.AlertDialog;
+import android.app.ListActivity;
+import android.app.SearchManager;
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.DataSetObserver;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.preference.PreferenceManager;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.Lists;
+import com.googlecode.android_scripting.ActivityFlinger;
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.FileUtils;
+import com.googlecode.android_scripting.IntentBuilders;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.ScriptListAdapter;
+import com.googlecode.android_scripting.ScriptStorageAdapter;
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration.ConfigurationObserver;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+
+import java.io.File;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map.Entry;
+
+/**
+ * Manages creation, deletion, and execution of stored scripts.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class ScriptManager extends ListActivity {
+
+  private final static String EMPTY = "";
+
+  private List<File> mScripts;
+  private ScriptManagerAdapter mAdapter;
+  private SharedPreferences mPreferences;
+  private HashMap<Integer, Interpreter> mAddMenuIds;
+  private ScriptListObserver mObserver;
+  private InterpreterConfiguration mConfiguration;
+  private SearchManager mManager;
+  private boolean mInSearchResultMode = false;
+  private String mQuery = EMPTY;
+  private File mCurrentDir;
+  private final File mBaseDir = new File(InterpreterConstants.SCRIPTS_ROOT);
+  private final Handler mHandler = new Handler();
+  private File mCurrent;
+
+  private static enum RequestCode {
+    INSTALL_INTERPETER, QRCODE_ADD
+  }
+
+  private static enum MenuId {
+    DELETE, HELP, FOLDER_ADD, QRCODE_ADD, INTERPRETER_MANAGER, PREFERENCES, LOGCAT_VIEWER,
+    TRIGGER_MANAGER, REFRESH, SEARCH, RENAME, EXTERNAL;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "Scripts", R.layout.script_manager);
+    if (FileUtils.externalStorageMounted()) {
+      File sl4a = mBaseDir.getParentFile();
+      if (!sl4a.exists()) {
+        sl4a.mkdir();
+        try {
+          FileUtils.chmod(sl4a, 0755); // Handle the sl4a parent folder first.
+        } catch (Exception e) {
+          // Not much we can do here if it doesn't work.
+        }
+      }
+      if (!FileUtils.makeDirectories(mBaseDir, 0755)) {
+        new AlertDialog.Builder(this)
+            .setTitle("Error")
+            .setMessage(
+                "Failed to create scripts directory.\n" + mBaseDir + "\n"
+                    + "Please check the permissions of your external storage media.")
+            .setIcon(android.R.drawable.ic_dialog_alert).setPositiveButton("Ok", null).show();
+      }
+    } else {
+      new AlertDialog.Builder(this).setTitle("External Storage Unavilable")
+          .setMessage("Scripts will be unavailable as long as external storage is unavailable.")
+          .setIcon(android.R.drawable.ic_dialog_alert).setPositiveButton("Ok", null).show();
+    }
+
+    mCurrentDir = mBaseDir;
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+    mAdapter = new ScriptManagerAdapter(this);
+    mObserver = new ScriptListObserver();
+    mAdapter.registerDataSetObserver(mObserver);
+    mConfiguration = ((BaseApplication) getApplication()).getInterpreterConfiguration();
+    mManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
+
+    registerForContextMenu(getListView());
+    updateAndFilterScriptList(mQuery);
+    setListAdapter(mAdapter);
+    ActivityFlinger.attachView(getListView(), this);
+    ActivityFlinger.attachView(getWindow().getDecorView(), this);
+    startService(IntentBuilders.buildTriggerServiceIntent());
+    handleIntent(getIntent());
+  }
+
+  @Override
+  protected void onNewIntent(Intent intent) {
+    handleIntent(intent);
+  }
+
+  @SuppressWarnings("serial")
+  private void updateAndFilterScriptList(final String query) {
+    List<File> scripts;
+    if (mPreferences.getBoolean("show_all_files", false)) {
+      scripts = ScriptStorageAdapter.listAllScripts(mCurrentDir);
+    } else {
+      scripts = ScriptStorageAdapter.listExecutableScripts(mCurrentDir, mConfiguration);
+    }
+    mScripts = Lists.newArrayList(Collections2.filter(scripts, new Predicate<File>() {
+      @Override
+      public boolean apply(File file) {
+        return file.getName().toLowerCase().contains(query.toLowerCase());
+      }
+    }));
+
+    // TODO(tturney): Add a text view that shows the queried text.
+    synchronized (mQuery) {
+      if (!mQuery.equals(query)) {
+        if (query != null || !query.equals(EMPTY)) {
+          mQuery = query;
+        }
+      }
+    }
+
+    if ((mScripts.size() == 0) && findViewById(android.R.id.empty) != null) {
+      ((TextView) findViewById(android.R.id.empty)).setText("No matches found.");
+    }
+
+    // TODO(damonkohler): Extending the File class here seems odd.
+    if (!mCurrentDir.equals(mBaseDir)) {
+      mScripts.add(0, new File(mCurrentDir.getParent()) {
+        @Override
+        public boolean isDirectory() {
+          return true;
+        }
+
+        @Override
+        public String getName() {
+          return "..";
+        }
+      });
+    }
+  }
+
+  private void handleIntent(Intent intent) {
+    if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
+      mInSearchResultMode = true;
+      String query = intent.getStringExtra(SearchManager.QUERY);
+      updateAndFilterScriptList(query);
+      mAdapter.notifyDataSetChanged();
+    }
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    menu.add(Menu.NONE, MenuId.RENAME.getId(), Menu.NONE, "Rename");
+    menu.add(Menu.NONE, MenuId.DELETE.getId(), Menu.NONE, "Delete");
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    AdapterView.AdapterContextMenuInfo info;
+    try {
+      info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
+    } catch (ClassCastException e) {
+      Log.e("Bad menuInfo", e);
+      return false;
+    }
+    File file = (File) mAdapter.getItem(info.position);
+    int itemId = item.getItemId();
+    if (itemId == MenuId.DELETE.getId()) {
+      delete(file);
+      return true;
+    } else if (itemId == MenuId.RENAME.getId()) {
+      rename(file);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_BACK && mInSearchResultMode) {
+      mInSearchResultMode = false;
+      mAdapter.notifyDataSetInvalidated();
+      return true;
+    }
+    return super.onKeyDown(keyCode, event);
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    mConfiguration.unregisterObserver(mObserver);
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    mConfiguration.registerObserver(mObserver);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    if (!mInSearchResultMode && findViewById(android.R.id.empty) != null) {
+      ((TextView) findViewById(android.R.id.empty)).setText(R.string.no_scripts_message);
+    }
+    updateAndFilterScriptList(mQuery);
+    mAdapter.notifyDataSetChanged();
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    super.onPrepareOptionsMenu(menu);
+    menu.clear();
+    buildMenuIdMaps();
+    buildAddMenu(menu);
+    buildSwitchActivityMenu(menu);
+    menu.add(Menu.NONE, MenuId.SEARCH.getId(), Menu.NONE, "Search").setIcon(
+        R.drawable.ic_menu_search);
+    menu.add(Menu.NONE, MenuId.PREFERENCES.getId(), Menu.NONE, "Preferences").setIcon(
+        android.R.drawable.ic_menu_preferences);
+    menu.add(Menu.NONE, MenuId.REFRESH.getId(), Menu.NONE, "Refresh").setIcon(
+        R.drawable.ic_menu_refresh);
+    return true;
+  }
+
+  private void buildSwitchActivityMenu(Menu menu) {
+    Menu subMenu =
+        menu.addSubMenu(Menu.NONE, Menu.NONE, Menu.NONE, "View").setIcon(
+            android.R.drawable.ic_menu_more);
+    subMenu.add(Menu.NONE, MenuId.INTERPRETER_MANAGER.getId(), Menu.NONE, "Interpreters");
+    subMenu.add(Menu.NONE, MenuId.TRIGGER_MANAGER.getId(), Menu.NONE, "Triggers");
+    subMenu.add(Menu.NONE, MenuId.LOGCAT_VIEWER.getId(), Menu.NONE, "Logcat");
+  }
+
+  private void buildMenuIdMaps() {
+    mAddMenuIds = new LinkedHashMap<Integer, Interpreter>();
+    int i = MenuId.values().length + Menu.FIRST;
+    List<Interpreter> installed = mConfiguration.getInstalledInterpreters();
+    Collections.sort(installed, new Comparator<Interpreter>() {
+      @Override
+      public int compare(Interpreter interpreterA, Interpreter interpreterB) {
+        return interpreterA.getNiceName().compareTo(interpreterB.getNiceName());
+      }
+    });
+    for (Interpreter interpreter : installed) {
+      mAddMenuIds.put(i, interpreter);
+      ++i;
+    }
+  }
+
+  private void buildAddMenu(Menu menu) {
+    Menu addMenu =
+        menu.addSubMenu(Menu.NONE, Menu.NONE, Menu.NONE, "Add").setIcon(
+            android.R.drawable.ic_menu_add);
+    addMenu.add(Menu.NONE, MenuId.FOLDER_ADD.getId(), Menu.NONE, "Folder");
+    for (Entry<Integer, Interpreter> entry : mAddMenuIds.entrySet()) {
+      addMenu.add(Menu.NONE, entry.getKey(), Menu.NONE, entry.getValue().getNiceName());
+    }
+    addMenu.add(Menu.NONE, MenuId.QRCODE_ADD.getId(), Menu.NONE, "Scan Barcode");
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    int itemId = item.getItemId();
+    if (itemId == MenuId.INTERPRETER_MANAGER.getId()) {
+      // Show interpreter manger.
+      Intent i = new Intent(this, InterpreterManager.class);
+      startActivity(i);
+    } else if (mAddMenuIds.containsKey(itemId)) {
+      // Add a new script.
+      Intent intent = new Intent(Constants.ACTION_EDIT_SCRIPT);
+      Interpreter interpreter = mAddMenuIds.get(itemId);
+      intent.putExtra(Constants.EXTRA_SCRIPT_PATH,
+          new File(mCurrentDir.getPath(), interpreter.getExtension()).getPath());
+      intent.putExtra(Constants.EXTRA_SCRIPT_CONTENT, interpreter.getContentTemplate());
+      intent.putExtra(Constants.EXTRA_IS_NEW_SCRIPT, true);
+      startActivity(intent);
+      synchronized (mQuery) {
+        mQuery = EMPTY;
+      }
+    } else if (itemId == MenuId.QRCODE_ADD.getId()) {
+      try {
+        Intent intent = new Intent("com.google.zxing.client.android.SCAN");
+        startActivityForResult(intent, RequestCode.QRCODE_ADD.ordinal());
+      }catch(ActivityNotFoundException e) {
+        Log.e("No handler found to Scan a QR Code!", e);
+      }
+    } else if (itemId == MenuId.FOLDER_ADD.getId()) {
+      addFolder();
+    } else if (itemId == MenuId.PREFERENCES.getId()) {
+      startActivity(new Intent(this, Preferences.class));
+    } else if (itemId == MenuId.TRIGGER_MANAGER.getId()) {
+      startActivity(new Intent(this, TriggerManager.class));
+    } else if (itemId == MenuId.LOGCAT_VIEWER.getId()) {
+      startActivity(new Intent(this, LogcatViewer.class));
+    } else if (itemId == MenuId.REFRESH.getId()) {
+      updateAndFilterScriptList(mQuery);
+      mAdapter.notifyDataSetChanged();
+    } else if (itemId == MenuId.SEARCH.getId()) {
+      onSearchRequested();
+    }
+    return true;
+  }
+
+  @Override
+  protected void onListItemClick(ListView list, View view, int position, long id) {
+    final File file = (File) list.getItemAtPosition(position);
+    mCurrent = file;
+    if (file.isDirectory()) {
+      mCurrentDir = file;
+      mAdapter.notifyDataSetInvalidated();
+      return;
+    }
+    doDialogMenu();
+    return;
+  }
+
+  // Quickedit chokes on sdk 3 or below, and some Android builds. Provides alternative menu.
+  private void doDialogMenu() {
+    AlertDialog.Builder builder = new AlertDialog.Builder(this);
+    final CharSequence[] menuList =
+        { "Run Foreground", "Run Background", "Edit", "Delete", "Rename" };
+    builder.setTitle(mCurrent.getName());
+    builder.setItems(menuList, new DialogInterface.OnClickListener() {
+
+      @Override
+      public void onClick(DialogInterface dialog, int which) {
+        Intent intent;
+        switch (which) {
+        case 0:
+          intent = new Intent(ScriptManager.this, ScriptingLayerService.class);
+          intent.setAction(Constants.ACTION_LAUNCH_FOREGROUND_SCRIPT);
+          intent.putExtra(Constants.EXTRA_SCRIPT_PATH, mCurrent.getPath());
+          startService(intent);
+          break;
+        case 1:
+          intent = new Intent(ScriptManager.this, ScriptingLayerService.class);
+          intent.setAction(Constants.ACTION_LAUNCH_BACKGROUND_SCRIPT);
+          intent.putExtra(Constants.EXTRA_SCRIPT_PATH, mCurrent.getPath());
+          startService(intent);
+          break;
+        case 2:
+          editScript(mCurrent);
+          break;
+        case 3:
+          delete(mCurrent);
+          break;
+        case 4:
+          rename(mCurrent);
+          break;
+        }
+      }
+    });
+    builder.show();
+  }
+
+  /**
+   * Opens the script for editing.
+   *
+   * @param script
+   *          the name of the script to edit
+   */
+  private void editScript(File script) {
+    Intent i = new Intent(Constants.ACTION_EDIT_SCRIPT);
+    i.putExtra(Constants.EXTRA_SCRIPT_PATH, script.getAbsolutePath());
+    startActivity(i);
+  }
+
+  private void delete(final File file) {
+    AlertDialog.Builder alert = new AlertDialog.Builder(this);
+    alert.setTitle("Delete");
+    alert.setMessage("Would you like to delete " + file.getName() + "?");
+    alert.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
+      public void onClick(DialogInterface dialog, int whichButton) {
+        FileUtils.delete(file);
+        mScripts.remove(file);
+        mAdapter.notifyDataSetChanged();
+      }
+    });
+    alert.setNegativeButton("No", new DialogInterface.OnClickListener() {
+      public void onClick(DialogInterface dialog, int whichButton) {
+        // Ignore.
+      }
+    });
+    alert.show();
+  }
+
+  private void addFolder() {
+    final EditText folderName = new EditText(this);
+    folderName.setHint("Folder Name");
+    AlertDialog.Builder alert = new AlertDialog.Builder(this);
+    alert.setTitle("Add Folder");
+    alert.setView(folderName);
+    alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
+      public void onClick(DialogInterface dialog, int whichButton) {
+        String name = folderName.getText().toString();
+        if (name.length() == 0) {
+          Log.e(ScriptManager.this, "Folder name is empty.");
+          return;
+        } else {
+          for (File f : mScripts) {
+            if (f.getName().equals(name)) {
+              Log.e(ScriptManager.this, String.format("Folder \"%s\" already exists.", name));
+              return;
+            }
+          }
+        }
+        File dir = new File(mCurrentDir, name);
+        if (!FileUtils.makeDirectories(dir, 0755)) {
+          Log.e(ScriptManager.this, String.format("Cannot create folder \"%s\".", name));
+        }
+        mAdapter.notifyDataSetInvalidated();
+      }
+    });
+    alert.show();
+  }
+
+  private void rename(final File file) {
+    final EditText newName = new EditText(this);
+    newName.setText(file.getName());
+    AlertDialog.Builder alert = new AlertDialog.Builder(this);
+    alert.setTitle("Rename");
+    alert.setView(newName);
+    alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
+      public void onClick(DialogInterface dialog, int whichButton) {
+        String name = newName.getText().toString();
+        if (name.length() == 0) {
+          Log.e(ScriptManager.this, "Name is empty.");
+          return;
+        } else {
+          for (File f : mScripts) {
+            if (f.getName().equals(name)) {
+              Log.e(ScriptManager.this, String.format("\"%s\" already exists.", name));
+              return;
+            }
+          }
+        }
+        if (!FileUtils.rename(file, name)) {
+          throw new RuntimeException(String.format("Cannot rename \"%s\".", file.getPath()));
+        }
+        mAdapter.notifyDataSetInvalidated();
+      }
+    });
+    alert.show();
+  }
+
+  @Override
+  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    RequestCode request = RequestCode.values()[requestCode];
+    if (resultCode == RESULT_OK) {
+      switch (request) {
+      case QRCODE_ADD:
+        writeScriptFromBarcode(data);
+        break;
+      default:
+        break;
+      }
+    } else {
+      switch (request) {
+      case QRCODE_ADD:
+        break;
+      default:
+        break;
+      }
+    }
+    mAdapter.notifyDataSetInvalidated();
+  }
+
+  private void writeScriptFromBarcode(Intent data) {
+    String result = data.getStringExtra("SCAN_RESULT");
+    if (result == null) {
+      Log.e(this, "Invalid QR code content.");
+      return;
+    }
+    String contents[] = result.split("\n", 2);
+    if (contents.length != 2) {
+      Log.e(this, "Invalid QR code content.");
+      return;
+    }
+    String title = contents[0];
+    String body = contents[1];
+    File script = new File(mCurrentDir, title);
+    ScriptStorageAdapter.writeScript(script, body);
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    mConfiguration.unregisterObserver(mObserver);
+    mManager.setOnCancelListener(null);
+  }
+
+  private class ScriptListObserver extends DataSetObserver implements ConfigurationObserver {
+    @Override
+    public void onInvalidated() {
+      updateAndFilterScriptList(EMPTY);
+    }
+
+    @Override
+    public void onConfigurationChanged() {
+      runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          updateAndFilterScriptList(mQuery);
+          mAdapter.notifyDataSetChanged();
+        }
+      });
+    }
+  }
+
+  private class ScriptManagerAdapter extends ScriptListAdapter {
+    public ScriptManagerAdapter(Context context) {
+      super(context);
+    }
+
+    @Override
+    protected List<File> getScriptList() {
+      return mScripts;
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptPicker.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptPicker.java
new file mode 100644
index 0000000..9385382
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptPicker.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.ListActivity;
+import android.content.Context;
+import android.content.Intent;
+import android.database.DataSetObserver;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.ListView;
+
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.FeaturedInterpreters;
+import com.googlecode.android_scripting.IntentBuilders;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.ScriptListAdapter;
+import com.googlecode.android_scripting.ScriptStorageAdapter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+
+import java.io.File;
+import java.util.List;
+
+
+/**
+ * Presents available scripts and returns the selected one.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class ScriptPicker extends ListActivity {
+
+  private List<File> mScripts;
+  private ScriptPickerAdapter mAdapter;
+  private InterpreterConfiguration mConfiguration;
+  private File mCurrentDir;
+  private final File mBaseDir = new File(InterpreterConstants.SCRIPTS_ROOT);
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "Scripts", R.layout.script_manager);
+    mCurrentDir = mBaseDir;
+    mConfiguration = ((BaseApplication) getApplication()).getInterpreterConfiguration();
+    mScripts = ScriptStorageAdapter.listExecutableScripts(null, mConfiguration);
+    mAdapter = new ScriptPickerAdapter(this);
+    mAdapter.registerDataSetObserver(new ScriptListObserver());
+    setListAdapter(mAdapter);
+  }
+
+  @Override
+  protected void onListItemClick(ListView list, View view, int position, long id) {
+    final File script = (File) list.getItemAtPosition(position);
+
+    if (script.isDirectory()) {
+      mCurrentDir = script;
+      mAdapter.notifyDataSetInvalidated();
+      return;
+    }
+
+    //TODO: Take action here based on item click
+  }
+
+  private class ScriptListObserver extends DataSetObserver {
+    @SuppressWarnings("serial")
+    @Override
+    public void onInvalidated() {
+      mScripts = ScriptStorageAdapter.listExecutableScripts(mCurrentDir, mConfiguration);
+      // TODO(damonkohler): Extending the File class here seems odd.
+      if (!mCurrentDir.equals(mBaseDir)) {
+        mScripts.add(0, new File(mCurrentDir.getParent()) {
+          @Override
+          public boolean isDirectory() {
+            return true;
+          }
+
+          @Override
+          public String getName() {
+            return "..";
+          }
+        });
+      }
+    }
+  }
+
+  private class ScriptPickerAdapter extends ScriptListAdapter {
+
+    public ScriptPickerAdapter(Context context) {
+      super(context);
+    }
+
+    @Override
+    protected List<File> getScriptList() {
+      return mScripts;
+    }
+
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptProcessMonitor.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptProcessMonitor.java
new file mode 100644
index 0000000..614890a
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptProcessMonitor.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.ListActivity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.BaseAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.interpreter.InterpreterProcess;
+
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.connectbot.ConsoleActivity;
+
+/**
+ * An activity that allows to monitor running scripts.
+ *
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public class ScriptProcessMonitor extends ListActivity {
+
+  private final static int UPDATE_INTERVAL_SECS = 1;
+
+  private final Timer mTimer = new Timer();
+
+  private volatile ScriptingLayerService mService;
+
+  private ScriptListAdapter mUpdater;
+  private List<InterpreterProcess> mProcessList;
+  private ScriptMonitorAdapter mAdapter;
+  private boolean mIsConnected = false;
+
+  private ServiceConnection mConnection = new ServiceConnection() {
+    @Override
+    public void onServiceConnected(ComponentName name, IBinder service) {
+      mService = ((ScriptingLayerService.LocalBinder) service).getService();
+      mUpdater = new ScriptListAdapter();
+      mTimer.scheduleAtFixedRate(mUpdater, 0, UPDATE_INTERVAL_SECS * 1000);
+      mIsConnected = true;
+    }
+
+    @Override
+    public void onServiceDisconnected(ComponentName name) {
+      mService = null;
+      mIsConnected = false;
+      mProcessList = null;
+      mAdapter.notifyDataSetChanged();
+    }
+  };
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    bindService(new Intent(this, ScriptingLayerService.class), mConnection, 0);
+    CustomizeWindow.requestCustomTitle(this, "Script Monitor", R.layout.script_monitor);
+    mAdapter = new ScriptMonitorAdapter();
+    setListAdapter(mAdapter);
+    registerForContextMenu(getListView());
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    if (mUpdater != null) {
+      mUpdater.cancel();
+    }
+    mTimer.purge();
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    if (mIsConnected) {
+      try {
+        mUpdater = new ScriptListAdapter();
+        mTimer.scheduleAtFixedRate(mUpdater, 0, UPDATE_INTERVAL_SECS * 1000);
+      } catch (IllegalStateException e) {
+        Log.e(e.getMessage(), e);
+      }
+    }
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    mTimer.cancel();
+    unbindService(mConnection);
+  }
+
+  @Override
+  protected void onListItemClick(ListView list, View view, int position, long id) {
+    final InterpreterProcess script = (InterpreterProcess) list.getItemAtPosition(position);
+    Intent intent = new Intent(this, ConsoleActivity.class);
+    intent.putExtra(Constants.EXTRA_PROXY_PORT, script.getPort());
+    startActivity(intent);
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfo) {
+    menu.add(Menu.NONE, 0, Menu.NONE, "Stop");
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    AdapterView.AdapterContextMenuInfo info;
+    try {
+      info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
+    } catch (ClassCastException e) {
+      Log.e("Bad menuInfo", e);
+      return false;
+    }
+
+    InterpreterProcess script = mAdapter.getItem(info.position);
+    if (script == null) {
+      Log.v("No script selected.");
+      return false;
+    }
+
+    Intent intent = new Intent(ScriptProcessMonitor.this, ScriptingLayerService.class);
+    intent.setAction(Constants.ACTION_KILL_PROCESS);
+    intent.putExtra(Constants.EXTRA_PROXY_PORT, script.getPort());
+    startService(intent);
+
+    return true;
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    menu.clear();
+    // TODO(damonkohler): How could mProcessList ever be null?
+    if (mProcessList != null && !mProcessList.isEmpty()) {
+      menu.add(Menu.NONE, 0, Menu.NONE, R.string.stop_all).setIcon(
+          android.R.drawable.ic_menu_close_clear_cancel);
+    }
+    return super.onPrepareOptionsMenu(menu);
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    Intent intent = new Intent(this, ScriptingLayerService.class);
+    intent.setAction(Constants.ACTION_KILL_ALL);
+    startService(intent);
+    return true;
+  }
+
+  private class ScriptListAdapter extends TimerTask {
+    private int mmExpectedModCount = 0;
+    private volatile List<InterpreterProcess> mmList;
+
+    @Override
+    public void run() {
+      if (mService == null) {
+        mmList.clear();
+        mTimer.cancel();
+      } else {
+        int freshModCount = mService.getModCount();
+        if (freshModCount != mmExpectedModCount) {
+          mmExpectedModCount = freshModCount;
+          mmList = mService.getScriptProcessesList();
+        }
+      }
+      runOnUiThread(new Runnable() {
+        public void run() {
+          mProcessList = mUpdater.getFreshProcessList();
+          mAdapter.notifyDataSetChanged();
+        }
+      });
+    }
+
+    private List<InterpreterProcess> getFreshProcessList() {
+      return mmList;
+    }
+  }
+
+  private class ScriptMonitorAdapter extends BaseAdapter {
+
+    @Override
+    public int getCount() {
+      if (mProcessList == null) {
+        return 0;
+      }
+      return mProcessList.size();
+    }
+
+    @Override
+    public InterpreterProcess getItem(int position) {
+      return mProcessList.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+      View itemView;
+      if (convertView == null) {
+        LayoutInflater inflater =
+            (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        itemView = inflater.inflate(R.layout.script_monitor_list_item, parent, false);
+      } else {
+        itemView = convertView;
+      }
+      InterpreterProcess process = mProcessList.get(position);
+      ((TextView) itemView.findViewById(R.id.process_title)).setText(process.getName());
+      ((TextView) itemView.findViewById(R.id.process_age)).setText(process.getUptime());
+      ((TextView) itemView.findViewById(R.id.process_details)).setText(process.getHost() + ":"
+          + process.getPort());
+      ((TextView) itemView.findViewById(R.id.process_status)).setText("PID " + process.getPid());
+      return itemView;
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptingLayerService.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptingLayerService.java
new file mode 100644
index 0000000..b39c984
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptingLayerService.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Build;
+import android.os.StrictMode;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+import com.googlecode.android_scripting.AndroidProxy;
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.ForegroundService;
+import com.googlecode.android_scripting.NotificationIdFactory;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.ScriptLauncher;
+import com.googlecode.android_scripting.ScriptProcess;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterProcess;
+import com.googlecode.android_scripting.interpreter.html.HtmlInterpreter;
+import com.googlecode.android_scripting.interpreter.shell.ShellInterpreter;
+
+import org.connectbot.ConsoleActivity;
+import org.connectbot.service.TerminalManager;
+
+import java.io.File;
+import java.lang.ref.WeakReference;
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A service that allows scripts and the RPC server to run in the background.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class ScriptingLayerService extends ForegroundService {
+  private static final int NOTIFICATION_ID = NotificationIdFactory.create();
+
+  private final IBinder mBinder;
+  private final Map<Integer, InterpreterProcess> mProcessMap;
+  private final String LOG_TAG = "sl4a";
+  private volatile int mModCount = 0;
+  private NotificationManager mNotificationManager;
+  private Notification mNotification;
+  private PendingIntent mNotificationPendingIntent;
+  private InterpreterConfiguration mInterpreterConfiguration;
+
+  private volatile WeakReference<InterpreterProcess> mRecentlyKilledProcess;
+
+  private TerminalManager mTerminalManager;
+
+  private SharedPreferences mPreferences = null;
+  private boolean mHide;
+
+  public class LocalBinder extends Binder {
+    public ScriptingLayerService getService() {
+      return ScriptingLayerService.this;
+    }
+  }
+
+  @Override
+  public IBinder onBind(Intent intent) {
+    return mBinder;
+  }
+
+  public ScriptingLayerService() {
+    super(NOTIFICATION_ID);
+    mProcessMap = new ConcurrentHashMap<Integer, InterpreterProcess>();
+    mBinder = new LocalBinder();
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    mInterpreterConfiguration = ((BaseApplication) getApplication()).getInterpreterConfiguration();
+    mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+    mRecentlyKilledProcess = new WeakReference<InterpreterProcess>(null);
+    mTerminalManager = new TerminalManager(this);
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+    mHide = mPreferences.getBoolean(Constants.HIDE_NOTIFY, false);
+  }
+
+  @Override
+  protected Notification createNotification() {
+    Intent notificationIntent = new Intent(this, ScriptingLayerService.class);
+    notificationIntent.setAction(Constants.ACTION_SHOW_RUNNING_SCRIPTS);
+    mNotificationPendingIntent = PendingIntent.getService(this, 0, notificationIntent, 0);
+
+    Notification.Builder builder = new Notification.Builder(this);
+    builder.setSmallIcon(R.drawable.sl4a_notification_logo)
+           .setTicker(null)
+           .setWhen(System.currentTimeMillis())
+           .setContentTitle("SL4A Service")
+           .setContentText("Tap to view running scripts")
+           .setContentIntent(mNotificationPendingIntent);
+    mNotification = builder.build();
+    mNotification.flags = Notification.FLAG_NO_CLEAR | Notification.FLAG_ONGOING_EVENT;
+    return mNotification;
+  }
+
+  private void updateNotification(String tickerText) {
+    if (tickerText.equals(mNotification.tickerText)) {
+      // Consequent notifications with the same ticker-text are displayed without any ticker-text.
+      // This is a way around. Alternatively, we can display process name and port.
+      tickerText = tickerText + " ";
+    }
+    String msg;
+    if (mProcessMap.size() <= 1) {
+      msg = "Tap to view " + Integer.toString(mProcessMap.size()) + " running script";
+    } else {
+      msg = "Tap to view " + Integer.toString(mProcessMap.size()) + " running scripts";
+    }
+    Notification.Builder builder = new Notification.Builder(this);
+    builder.setContentTitle("SL4A Service")
+           .setContentText(msg)
+           .setContentIntent(mNotificationPendingIntent)
+           .setSmallIcon(mNotification.icon, mProcessMap.size())
+           .setWhen(mNotification.when)
+           .setTicker(tickerText);
+
+    mNotification = builder.build();
+    mNotificationManager.notify(NOTIFICATION_ID, mNotification);
+  }
+
+  @Override
+  public int onStartCommand(Intent intent, int flags, int startId) {
+    super.onStartCommand(intent, flags, startId);
+    String errmsg = null;
+    if (intent == null) {
+      return START_REDELIVER_INTENT;
+    }
+    if (intent.getAction().equals(Constants.ACTION_KILL_ALL)) {
+      killAll();
+      stopSelf(startId);
+      return START_REDELIVER_INTENT;
+    }
+
+    if (intent.getAction().equals(Constants.ACTION_KILL_PROCESS)) {
+      killProcess(intent);
+      if (mProcessMap.isEmpty()) {
+        stopSelf(startId);
+      }
+      return START_REDELIVER_INTENT;
+    }
+
+    if (intent.getAction().equals(Constants.ACTION_SHOW_RUNNING_SCRIPTS)) {
+      showRunningScripts();
+      return START_REDELIVER_INTENT;
+    }
+
+    String name = intent.getStringExtra(Constants.EXTRA_SCRIPT_PATH);
+    if (name != null && name.endsWith(HtmlInterpreter.HTML_EXTENSION)) {
+      if (Integer.valueOf(android.os.Build.VERSION.SDK) > 21) {
+          Log.e(LOG_TAG, "Starting a WebViewClient not permitted for your SDK Version.");
+      } else {
+          launchHtmlScript(intent);
+      }
+      if (mProcessMap.isEmpty()) {
+        stopSelf(startId);
+      }
+      return START_REDELIVER_INTENT;
+    }
+
+    //TODO: b/26538940 We need to go back to a strict policy and fix the problems
+    StrictMode.ThreadPolicy sl4aPolicy = new StrictMode.ThreadPolicy.Builder()
+        .detectAll()
+        .penaltyLog()
+        .build();
+
+    StrictMode.setThreadPolicy(sl4aPolicy);
+
+    AndroidProxy proxy = null;
+    InterpreterProcess interpreterProcess = null;
+    if (intent.getAction().equals(Constants.ACTION_LAUNCH_SERVER)) {
+      proxy = launchServer(intent, false);
+      // TODO(damonkohler): This is just to make things easier. Really, we shouldn't need to start
+      // an interpreter when all we want is a server.
+      interpreterProcess = new InterpreterProcess(new ShellInterpreter(), proxy);
+      interpreterProcess.setName("Server");
+    } else {
+      proxy = launchServer(intent, true);
+      if (intent.getAction().equals(Constants.ACTION_LAUNCH_FOREGROUND_SCRIPT)) {
+        launchTerminal(proxy.getAddress());
+        try {
+          interpreterProcess = launchScript(intent, proxy);
+        } catch (RuntimeException e) {
+          errmsg =
+              "Unable to run " + intent.getStringExtra(Constants.EXTRA_SCRIPT_PATH) + "\n"
+                  + e.getMessage();
+          interpreterProcess = null;
+        }
+      } else if (intent.getAction().equals(Constants.ACTION_LAUNCH_BACKGROUND_SCRIPT)) {
+        interpreterProcess = launchScript(intent, proxy);
+      } else if (intent.getAction().equals(Constants.ACTION_LAUNCH_INTERPRETER)) {
+        launchTerminal(proxy.getAddress());
+        interpreterProcess = launchInterpreter(intent, proxy);
+      }
+    }
+    if (errmsg != null) {
+      updateNotification(errmsg);
+    } else if (interpreterProcess == null) {
+      updateNotification("Action not implemented: " + intent.getAction());
+    } else {
+      addProcess(interpreterProcess);
+    }
+    return START_REDELIVER_INTENT;
+  }
+
+  private boolean tryPort(AndroidProxy androidProxy, boolean usePublicIp, int usePort) {
+    if (usePublicIp) {
+      return (androidProxy.startPublic(usePort) != null);
+    } else {
+      return (androidProxy.startLocal(usePort) != null);
+    }
+  }
+
+  private AndroidProxy launchServer(Intent intent, boolean requiresHandshake) {
+    AndroidProxy androidProxy = new AndroidProxy(this, intent, requiresHandshake);
+    boolean usePublicIp = intent.getBooleanExtra(Constants.EXTRA_USE_EXTERNAL_IP, false);
+    int usePort = intent.getIntExtra(Constants.EXTRA_USE_SERVICE_PORT, 0);
+    // If port is in use, fall back to default behaviour
+    if (!tryPort(androidProxy, usePublicIp, usePort)) {
+      if (usePort != 0) {
+        tryPort(androidProxy, usePublicIp, 0);
+      }
+    }
+    return androidProxy;
+  }
+
+  private void launchHtmlScript(Intent intent) {
+    File script = new File(intent.getStringExtra(Constants.EXTRA_SCRIPT_PATH));
+    ScriptLauncher.launchHtmlScript(script, this, intent, mInterpreterConfiguration);
+  }
+
+  private ScriptProcess launchScript(Intent intent, AndroidProxy proxy) {
+    final int port = proxy.getAddress().getPort();
+    File script = new File(intent.getStringExtra(Constants.EXTRA_SCRIPT_PATH));
+    return ScriptLauncher.launchScript(script, mInterpreterConfiguration, proxy, new Runnable() {
+      @Override
+      public void run() {
+        // TODO(damonkohler): This action actually kills the script rather than notifying the
+        // service that script exited on its own. We should distinguish between these two cases.
+        Intent intent = new Intent(ScriptingLayerService.this, ScriptingLayerService.class);
+        intent.setAction(Constants.ACTION_KILL_PROCESS);
+        intent.putExtra(Constants.EXTRA_PROXY_PORT, port);
+        startService(intent);
+      }
+    });
+  }
+
+  private InterpreterProcess launchInterpreter(Intent intent, AndroidProxy proxy) {
+    InterpreterConfiguration config =
+        ((BaseApplication) getApplication()).getInterpreterConfiguration();
+    final int port = proxy.getAddress().getPort();
+    return ScriptLauncher.launchInterpreter(proxy, intent, config, new Runnable() {
+      @Override
+      public void run() {
+        // TODO(damonkohler): This action actually kills the script rather than notifying the
+        // service that script exited on its own. We should distinguish between these two cases.
+        Intent intent = new Intent(ScriptingLayerService.this, ScriptingLayerService.class);
+        intent.setAction(Constants.ACTION_KILL_PROCESS);
+        intent.putExtra(Constants.EXTRA_PROXY_PORT, port);
+        startService(intent);
+      }
+    });
+  }
+
+  private void launchTerminal(InetSocketAddress address) {
+    Intent i = new Intent(this, ConsoleActivity.class);
+    i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    i.putExtra(Constants.EXTRA_PROXY_PORT, address.getPort());
+    startActivity(i);
+  }
+
+  private void showRunningScripts() {
+    Intent i = new Intent(this, ScriptProcessMonitor.class);
+    i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    startActivity(i);
+  }
+
+  private void addProcess(InterpreterProcess process) {
+    mProcessMap.put(process.getPort(), process);
+    mModCount++;
+    if (!mHide) {
+      updateNotification(process.getName() + " started.");
+    }
+  }
+
+  private InterpreterProcess removeProcess(int port) {
+    InterpreterProcess process = mProcessMap.remove(port);
+    if (process == null) {
+      return null;
+    }
+    mModCount++;
+    if (!mHide) {
+      updateNotification(process.getName() + " exited.");
+    }
+    return process;
+  }
+
+  private void killProcess(Intent intent) {
+    int processId = intent.getIntExtra(Constants.EXTRA_PROXY_PORT, 0);
+    InterpreterProcess process = removeProcess(processId);
+    if (process != null) {
+      process.kill();
+      mRecentlyKilledProcess = new WeakReference<InterpreterProcess>(process);
+    }
+  }
+
+  public int getModCount() {
+    return mModCount;
+  }
+
+  private void killAll() {
+    for (InterpreterProcess process : getScriptProcessesList()) {
+      process = removeProcess(process.getPort());
+      if (process != null) {
+        process.kill();
+      }
+    }
+  }
+
+  public List<InterpreterProcess> getScriptProcessesList() {
+    ArrayList<InterpreterProcess> result = new ArrayList<InterpreterProcess>();
+    result.addAll(mProcessMap.values());
+    return result;
+  }
+
+  public InterpreterProcess getProcess(int port) {
+    InterpreterProcess p = mProcessMap.get(port);
+    if (p == null) {
+      return mRecentlyKilledProcess.get();
+    }
+    return p;
+  }
+
+  public TerminalManager getTerminalManager() {
+    return mTerminalManager;
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptingLayerServiceLauncher.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptingLayerServiceLauncher.java
new file mode 100644
index 0000000..e373670
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptingLayerServiceLauncher.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.SystemProperties;
+
+import android.util.Log;
+
+import com.googlecode.android_scripting.Constants;
+
+public class ScriptingLayerServiceLauncher extends Activity {
+
+    private static final int DEBUGGABLE_BUILD = 1;
+
+    private static final String LOG_TAG = "sl4a";
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    // Forward the intent that launched us to start the service.
+
+    if(SystemProperties.getInt("ro.debuggable", 0) == DEBUGGABLE_BUILD) {
+        Intent intent = getIntent();
+        intent.setComponent(Constants.SL4A_SERVICE_COMPONENT_NAME);
+        startService(intent);
+        finish();
+    }
+    else {
+        Log.e(LOG_TAG, "ERROR: Cannot to start SL4A on non-debuggable build!");
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptsLiveFolder.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptsLiveFolder.java
new file mode 100644
index 0000000..191c641
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ScriptsLiveFolder.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.Intent.ShortcutIconResource;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.LiveFolders;
+
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.provider.ScriptProvider;
+
+public class ScriptsLiveFolder extends Activity {
+
+  public static final Uri CONTENT_URI =
+      Uri.parse("content://" + ScriptProvider.AUTHORITY + "/" + ScriptProvider.LIVEFOLDER);
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    final Intent intent = getIntent();
+    final String action = intent.getAction();
+    if (LiveFolders.ACTION_CREATE_LIVE_FOLDER.equals(action)) {
+      setResult(RESULT_OK, createLiveFolder(this, CONTENT_URI, "Scripts", R.drawable.live_folder));
+    } else {
+      setResult(RESULT_CANCELED);
+    }
+    finish();
+  }
+
+  private Intent createLiveFolder(Context context, Uri uri, String name, int icon) {
+    final Intent intent = new Intent();
+    intent.setData(uri);
+    intent.putExtra(LiveFolders.EXTRA_LIVE_FOLDER_NAME, name);
+    intent.putExtra(LiveFolders.EXTRA_LIVE_FOLDER_ICON, ShortcutIconResource
+        .fromContext(this, icon));
+    intent.putExtra(LiveFolders.EXTRA_LIVE_FOLDER_DISPLAY_MODE, LiveFolders.DISPLAY_MODE_LIST);
+    return intent;
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ServiceUtils.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ServiceUtils.java
new file mode 100644
index 0000000..ddb5937
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/ServiceUtils.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.Context;
+
+import com.googlecode.android_scripting.Log;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * A utility class supplying helper methods for {@link Service} objects.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ */
+public class ServiceUtils {
+  private ServiceUtils() {
+  }
+
+  /**
+   * Marks the service as a foreground service. This uses reflection to figure out whether the new
+   * APIs for marking a service as a foreground service are available. If not, it falls back to the
+   * old {@link #setForeground(boolean)} call.
+   *
+   * @param service
+   *          the service to put in foreground mode
+   * @param notificationId
+   *          id of the notification to show
+   * @param notification
+   *          the notification to show
+   */
+  public static void setForeground(Service service, Integer notificationId,
+      Notification notification) {
+    final Class<?>[] startForegroundSignature = new Class[] { int.class, Notification.class };
+    Method startForeground = null;
+    try {
+      startForeground = service.getClass().getMethod("startForeground", startForegroundSignature);
+
+      try {
+        startForeground.invoke(service, new Object[] { notificationId, notification });
+      } catch (IllegalArgumentException e) {
+        // Should not happen!
+        Log.e("Could not set TriggerService to foreground mode.", e);
+      } catch (IllegalAccessException e) {
+        // Should not happen!
+        Log.e("Could not set TriggerService to foreground mode.", e);
+      } catch (InvocationTargetException e) {
+        // Should not happen!
+        Log.e("Could not set TriggerService to foreground mode.", e);
+      }
+
+    } catch (NoSuchMethodException e) {
+      // Fall back on old API.
+      // service.setForeground(true); //too old to be supported
+
+      NotificationManager manager =
+          (NotificationManager) service.getSystemService(Context.NOTIFICATION_SERVICE);
+      manager.notify(notificationId, notification);
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/TriggerManager.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/TriggerManager.java
new file mode 100644
index 0000000..fc37796
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/TriggerManager.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.AlertDialog;
+import android.app.ListActivity;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.DialogInterface.OnClickListener;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.widget.AdapterView;
+import android.widget.BaseAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.google.common.collect.Lists;
+import com.googlecode.android_scripting.ActivityFlinger;
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.trigger.ScriptTrigger;
+import com.googlecode.android_scripting.trigger.Trigger;
+import com.googlecode.android_scripting.trigger.TriggerRepository;
+import com.googlecode.android_scripting.trigger.TriggerRepository.TriggerRepositoryObserver;
+
+import java.io.File;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class TriggerManager extends ListActivity {
+  private final List<ScriptTrigger> mTriggers = Lists.newArrayList();
+
+  private ScriptTriggerAdapter mAdapter;
+  private TriggerRepository mTriggerRepository;
+
+  private static enum ContextMenuId {
+    REMOVE;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  private static enum MenuId {
+    ADD, PREFERENCES, HELP;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CustomizeWindow.requestCustomTitle(this, "Triggers", R.layout.trigger_manager);
+    ScriptTriggerListObserver observer = new ScriptTriggerListObserver();
+    mAdapter = new ScriptTriggerAdapter();
+    setListAdapter(mAdapter);
+    registerForContextMenu(getListView());
+    mTriggerRepository = ((BaseApplication) getApplication()).getTriggerRepository();
+    mTriggerRepository.bootstrapObserver(observer);
+    ActivityFlinger.attachView(getListView(), this);
+    ActivityFlinger.attachView(getWindow().getDecorView(), this);
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    menu.add(Menu.NONE, MenuId.ADD.getId(), Menu.NONE, "Add").setIcon(
+        android.R.drawable.ic_menu_add);
+    menu.add(Menu.NONE, MenuId.PREFERENCES.getId(), Menu.NONE, "Preferences").setIcon(
+        android.R.drawable.ic_menu_preferences);
+    return true;
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    int itemId = item.getItemId();
+    if (itemId == MenuId.PREFERENCES.getId()) {
+      startActivity(new Intent(this, Preferences.class));
+    } else if (itemId != Menu.NONE) {
+      Intent intent = new Intent(this, ScriptPicker.class);
+      intent.setAction(Intent.ACTION_PICK);
+      startActivityForResult(intent, itemId);
+    }
+    return true;
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    menu.add(Menu.NONE, ContextMenuId.REMOVE.getId(), Menu.NONE, "Remove");
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    AdapterView.AdapterContextMenuInfo info;
+    try {
+      info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
+    } catch (ClassCastException e) {
+      Log.e("Bad menuInfo", e);
+      return false;
+    }
+
+    Trigger trigger = mAdapter.getItem(info.position);
+    if (trigger == null) {
+      Log.v("No trigger selected.");
+      return false;
+    }
+
+    if (item.getItemId() == ContextMenuId.REMOVE.getId()) {
+      mTriggerRepository.remove(trigger);
+    }
+    return true;
+  }
+
+  @Override
+  public void onListItemClick(ListView l, View v, int position, long id) {
+    mAdapter.notifyDataSetInvalidated();
+  }
+
+  private class ScriptTriggerListObserver implements TriggerRepositoryObserver {
+
+    @Override
+    public void onPut(Trigger trigger) {
+      mTriggers.add((ScriptTrigger) trigger);
+      mAdapter.notifyDataSetInvalidated();
+    }
+
+    @Override
+    public void onRemove(Trigger trigger) {
+      mTriggers.remove(trigger);
+      mAdapter.notifyDataSetInvalidated();
+    }
+  }
+
+  private class ScriptTriggerAdapter extends BaseAdapter {
+
+    @Override
+    public int getCount() {
+      return mTriggers.size();
+    }
+
+    @Override
+    public Trigger getItem(int position) {
+      return mTriggers.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+      return position;
+    }
+
+    @Override
+    public View getView(final int position, View convertView, ViewGroup parent) {
+      ScriptTrigger trigger = mTriggers.get(position);
+      TextView textView = new TextView(TriggerManager.this);
+      textView.setText(trigger.getEventName() + " " + trigger.getScript().getName());
+      return textView;
+    }
+  }
+
+  @Override
+  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (resultCode == RESULT_OK) {
+      final File script = new File(data.getStringExtra(Constants.EXTRA_SCRIPT_PATH));
+      if (requestCode == MenuId.ADD.getId()) {
+        Map<String, MethodDescriptor> eventMethodDescriptors =
+            FacadeConfiguration.collectStartEventMethodDescriptors();
+        final List<String> eventNames = Lists.newArrayList(eventMethodDescriptors.keySet());
+        Collections.sort(eventNames);
+        AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        builder.setItems(eventNames.toArray(new CharSequence[eventNames.size()]),
+            new OnClickListener() {
+              @Override
+              public void onClick(DialogInterface dialog, int position) {
+                mTriggerRepository.put(new ScriptTrigger(eventNames.get(position), script));
+              }
+            });
+        builder.show();
+      }
+    }
+  }
+
+  public void clickCancel(View v) {
+    for (Trigger t : mTriggerRepository.getAllTriggers().values()) {
+      mTriggerRepository.remove(t);
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/TriggerService.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/TriggerService.java
new file mode 100644
index 0000000..8024533
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/activity/TriggerService.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.activity;
+
+import android.app.AlarmManager;
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.IBinder;
+
+import com.google.common.base.Preconditions;
+import com.googlecode.android_scripting.BaseApplication;
+import com.googlecode.android_scripting.ForegroundService;
+import com.googlecode.android_scripting.IntentBuilders;
+import com.googlecode.android_scripting.NotificationIdFactory;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.event.Event;
+import com.googlecode.android_scripting.event.EventObserver;
+import com.googlecode.android_scripting.facade.EventFacade;
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.facade.FacadeManager;
+import com.googlecode.android_scripting.trigger.EventGenerationControllingObserver;
+import com.googlecode.android_scripting.trigger.Trigger;
+import com.googlecode.android_scripting.trigger.TriggerRepository;
+import com.googlecode.android_scripting.trigger.TriggerRepository.TriggerRepositoryObserver;
+
+/**
+ * The trigger service takes care of installing triggers serialized to the preference storage.
+ *
+ * <p>
+ * The service also installs an alarm that keeps it running, unless the user force-quits the
+ * service.
+ *
+ * <p>
+ * When no triggers are installed the service shuts down silently as to not consume resources
+ * unnecessarily.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class TriggerService extends ForegroundService {
+  private static final int NOTIFICATION_ID = NotificationIdFactory.create();
+  private static final long PING_MILLIS = 10 * 1000 * 60;
+
+  private final IBinder mBinder;
+  private TriggerRepository mTriggerRepository;
+  private FacadeManager mFacadeManager;
+  private EventFacade mEventFacade;
+
+  public class LocalBinder extends Binder {
+    public TriggerService getService() {
+      return TriggerService.this;
+    }
+  }
+
+  public TriggerService() {
+    super(NOTIFICATION_ID);
+    mBinder = new LocalBinder();
+  }
+
+  @Override
+  public IBinder onBind(Intent intent) {
+    return mBinder;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+
+    mFacadeManager =
+        new FacadeManager(FacadeConfiguration.getSdkLevel(), this, null,
+            FacadeConfiguration.getFacadeClasses());
+    mEventFacade = mFacadeManager.getReceiver(EventFacade.class);
+
+    mTriggerRepository = ((BaseApplication) getApplication()).getTriggerRepository();
+    mTriggerRepository.bootstrapObserver(new RepositoryObserver());
+    mTriggerRepository.bootstrapObserver(new EventGenerationControllingObserver(mFacadeManager));
+    installAlarm();
+  }
+
+  @Override
+  public void onStart(Intent intent, int startId) {
+    if (mTriggerRepository.isEmpty()) {
+      stopSelfResult(startId);
+      return;
+    }
+  }
+
+  /** Returns the notification to display whenever the service is running. */
+  @Override
+  protected Notification createNotification() {
+    Intent notificationIntent = new Intent(this, TriggerManager.class);
+    Notification.Builder builder = new Notification.Builder(this);
+    builder.setSmallIcon(R.drawable.sl4a_logo_48)
+           .setTicker("SL4A Trigger Service started.")
+           .setWhen(System.currentTimeMillis())
+           .setContentTitle("SL4A Trigger Service")
+           .setContentText("Tap to view triggers")
+           .setContentIntent(PendingIntent.getActivity(this, 0, notificationIntent, 0));
+    Notification notification = builder.build();
+    notification.flags = Notification.FLAG_NO_CLEAR | Notification.FLAG_ONGOING_EVENT;
+    return notification;
+  }
+
+  private class TriggerEventObserver implements EventObserver {
+    private final Trigger mTrigger;
+
+    public TriggerEventObserver(Trigger trigger) {
+      mTrigger = trigger;
+    }
+
+    @Override
+    public void onEventReceived(Event event) {
+      mTrigger.handleEvent(event, TriggerService.this);
+    }
+  }
+
+  private class RepositoryObserver implements TriggerRepositoryObserver {
+    int mTriggerCount = 0;
+
+    @Override
+    public void onPut(Trigger trigger) {
+      mTriggerCount++;
+      mEventFacade.addNamedEventObserver(trigger.getEventName(), new TriggerEventObserver(trigger));
+    }
+
+    @Override
+    public void onRemove(Trigger trigger) {
+      Preconditions.checkArgument(mTriggerCount > 0);
+      // TODO(damonkohler): Tear down EventObserver associated with trigger.
+      if (--mTriggerCount == 0) {
+        // TODO(damonkohler): Use stopSelfResult() which would require tracking startId.
+        stopSelf();
+      }
+    }
+  }
+
+  private void installAlarm() {
+    AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
+    alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + PING_MILLIS,
+        PING_MILLIS, IntentBuilders.buildTriggerServicePendingIntent(this));
+  }
+
+  private void uninstallAlarm() {
+    AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
+    alarmManager.cancel(IntentBuilders.buildTriggerServicePendingIntent(this));
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    uninstallAlarm();
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/dialog/DurationPickerDialog.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/dialog/DurationPickerDialog.java
new file mode 100644
index 0000000..6a53fac
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/dialog/DurationPickerDialog.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.dialog;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.widget.DurationPicker;
+
+public class DurationPickerDialog {
+
+  private DurationPickerDialog() {
+    // Utility class.
+  }
+
+  public interface DurationPickedListener {
+    public void onSet(double duration);
+
+    public void onCancel();
+  }
+
+  public static void getDurationFromDialog(Activity activity, String title,
+      final DurationPickedListener done) {
+    final DurationPicker picker = new DurationPicker(activity);
+    AlertDialog.Builder alert = new AlertDialog.Builder(activity);
+    alert.setIcon(R.drawable.ic_dialog_time);
+    alert.setTitle(title);
+    alert.setView(picker);
+    alert.setPositiveButton("Set", new DialogInterface.OnClickListener() {
+      @Override
+      public void onClick(DialogInterface dialog, int whichButton) {
+        done.onSet(picker.getDuration());
+      }
+    });
+    alert.setOnCancelListener(new DialogInterface.OnCancelListener() {
+      @Override
+      public void onCancel(DialogInterface arg0) {
+        done.onCancel();
+      }
+    });
+    alert.show();
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/locale/LocaleReceiver.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/locale/LocaleReceiver.java
new file mode 100644
index 0000000..9c51720
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/locale/LocaleReceiver.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.locale;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.IntentBuilders;
+
+import java.io.File;
+
+public class LocaleReceiver extends BroadcastReceiver {
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+
+    final File script =
+        new File(intent.getBundleExtra(com.twofortyfouram.locale.platform.Intent.EXTRA_BUNDLE)
+            .getString(Constants.EXTRA_SCRIPT_PATH));
+    Log.v("LocaleReceiver", "Locale initiated launch of " + script);
+    Intent launchIntent;
+    if (intent.getBooleanExtra(Constants.EXTRA_LAUNCH_IN_BACKGROUND, false)) {
+      launchIntent = IntentBuilders.buildStartInBackgroundIntent(script);
+    } else {
+      launchIntent = IntentBuilders.buildStartInTerminalIntent(script);
+    }
+    launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    context.startActivity(launchIntent);
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/ApiProvider.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/ApiProvider.java
new file mode 100644
index 0000000..5bc1754
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/ApiProvider.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.provider;
+
+import android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.provider.BaseColumns;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+import com.googlecode.android_scripting.rpc.Rpc;
+import com.googlecode.android_scripting.rpc.RpcDeprecated;
+import com.googlecode.android_scripting.rpc.RpcMinSdk;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+
+public class ApiProvider extends ContentProvider {
+
+  public static final String SINGLE_MIME = "vnd.android.cursor.item/vnd.sl4a.api";
+
+  private static final int SUGGESTIONS_ID = 1;
+
+  public static final String AUTHORITY = ApiProvider.class.getName().toLowerCase();
+  public static final String SUGGESTIONS = "searchSuggestions/*/*";
+
+  private final UriMatcher mUriMatcher;
+  private final Collection<MethodDescriptor> mMethodDescriptors;
+
+  public ApiProvider() {
+    mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+    mUriMatcher.addURI(AUTHORITY, SUGGESTIONS, SUGGESTIONS_ID);
+    mMethodDescriptors =
+        Collections2.filter(FacadeConfiguration.collectMethodDescriptors(),
+            new Predicate<MethodDescriptor>() {
+              @Override
+              public boolean apply(MethodDescriptor descriptor) {
+                Method method = descriptor.getMethod();
+                if (method.isAnnotationPresent(RpcDeprecated.class)) {
+                  return false;
+                } else if (method.isAnnotationPresent(RpcMinSdk.class)) {
+                  int requiredSdkLevel = method.getAnnotation(RpcMinSdk.class).value();
+                  if (FacadeConfiguration.getSdkLevel() < requiredSdkLevel) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+            });
+  }
+
+  @Override
+  public int delete(Uri uri, String selection, String[] selectionArgs) {
+    return 0;
+  }
+
+  @Override
+  public String getType(Uri uri) {
+    return SINGLE_MIME;
+  }
+
+  @Override
+  public Uri insert(Uri uri, ContentValues values) {
+    return null;
+  }
+
+  @Override
+  public boolean onCreate() {
+    return true;
+  }
+
+  @Override
+  public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+      String sortOrder) {
+    switch (mUriMatcher.match(uri)) {
+    case SUGGESTIONS_ID:
+      String query = uri.getLastPathSegment().toLowerCase();
+      return querySearchSuggestions(query);
+    }
+    return null;
+  }
+
+  private Cursor querySearchSuggestions(String query) {
+    String[] columns =
+        { BaseColumns._ID, SearchManager.SUGGEST_COLUMN_TEXT_1,
+          SearchManager.SUGGEST_COLUMN_TEXT_2, SearchManager.SUGGEST_COLUMN_QUERY };
+    MatrixCursor cursor = new MatrixCursor(columns);
+    int index = 0;
+    for (MethodDescriptor descriptor : mMethodDescriptors) {
+      String name = descriptor.getMethod().getName();
+      if (!name.toLowerCase().contains(query)) {
+        continue;
+      }
+      String description = descriptor.getMethod().getAnnotation(Rpc.class).description();
+      description = description.replaceAll("\\s+", " ");
+      Object[] row = { index, name, description, name };
+      cursor.addRow(row);
+      ++index;
+    }
+    return cursor;
+  }
+
+  @Override
+  public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+    return 0;
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/ScriptProvider.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/ScriptProvider.java
new file mode 100644
index 0000000..0f16e0d
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/ScriptProvider.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.provider;
+
+import android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.content.Intent.ShortcutIconResource;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.provider.BaseColumns;
+import android.provider.LiveFolders;
+
+import com.googlecode.android_scripting.FeaturedInterpreters;
+import com.googlecode.android_scripting.IntentBuilders;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.ScriptStorageAdapter;
+import com.googlecode.android_scripting.interpreter.Interpreter;
+import com.googlecode.android_scripting.interpreter.InterpreterConfiguration;
+import com.googlecode.android_scripting.interpreter.InterpreterConstants;
+
+import java.io.File;
+
+public class ScriptProvider extends ContentProvider {
+
+  public static final String SINGLE_MIME = "vnd.android.cursor.item/vnd.sl4a.script";
+  public static final String MULTIPLE_MIME = "vnd.android.cursor.dir/vnd.sl4a.script";
+
+  private static final int LIVEFOLDER_ID = 1;
+  private static final int SUGGESTIONS_ID = 2;
+
+  public static final String AUTHORITY = ScriptProvider.class.getName().toLowerCase();
+  public static final String LIVEFOLDER = "liveFolder";
+  public static final String SUGGESTIONS = "searchSuggestions/*/*";
+
+  private final UriMatcher mUriMatcher;
+
+  private Context mContext;
+  private InterpreterConfiguration mConfiguration;
+
+  public ScriptProvider() {
+    mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+    mUriMatcher.addURI(AUTHORITY, LIVEFOLDER, LIVEFOLDER_ID);
+    mUriMatcher.addURI(AUTHORITY, SUGGESTIONS, SUGGESTIONS_ID);
+  }
+
+  @Override
+  public int delete(Uri uri, String selection, String[] selectionArgs) {
+    return 0;
+  }
+
+  @Override
+  public String getType(Uri uri) {
+    if (uri.getLastPathSegment().equals("scripts")) {
+      return MULTIPLE_MIME;
+    }
+    return SINGLE_MIME;
+  }
+
+  @Override
+  public Uri insert(Uri uri, ContentValues values) {
+    return null;
+  }
+
+  @Override
+  public boolean onCreate() {
+    mContext = getContext();
+    mConfiguration = new InterpreterConfiguration(mContext);
+    mConfiguration.startDiscovering();
+    return true;
+  }
+
+  @Override
+  public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+      String sortOrder) {
+    switch (mUriMatcher.match(uri)) {
+    case LIVEFOLDER_ID:
+      return queryLiveFolder();
+    case SUGGESTIONS_ID:
+      String query = uri.getLastPathSegment().toLowerCase();
+      return querySearchSuggestions(query);
+    default:
+      return null;
+    }
+  }
+
+  private Cursor querySearchSuggestions(String query) {
+    String[] columns =
+        { BaseColumns._ID, SearchManager.SUGGEST_COLUMN_TEXT_1,
+          SearchManager.SUGGEST_COLUMN_TEXT_2, SearchManager.SUGGEST_COLUMN_ICON_2,
+          SearchManager.SUGGEST_COLUMN_QUERY, SearchManager.SUGGEST_COLUMN_SHORTCUT_ID };
+    MatrixCursor cursor = new MatrixCursor(columns);
+    int index = 0;
+    for (File script : ScriptStorageAdapter.listExecutableScripts(null, mConfiguration)) {
+      String scriptName = script.getName().toLowerCase();
+      if (!scriptName.contains(query)) {
+        continue;
+      }
+      Interpreter interpreter = mConfiguration.getInterpreterForScript(scriptName);
+      String secondLine = interpreter.getNiceName();
+      int icon = FeaturedInterpreters.getInterpreterIcon(mContext, interpreter.getExtension());
+      Object[] row =
+          { index, scriptName, secondLine, icon, scriptName,
+            SearchManager.SUGGEST_NEVER_MAKE_SHORTCUT };
+      cursor.addRow(row);
+      ++index;
+    }
+    return cursor;
+  }
+
+  private Cursor queryLiveFolder() {
+    String[] columns =
+        { BaseColumns._ID, LiveFolders.NAME, LiveFolders.INTENT, LiveFolders.ICON_RESOURCE,
+          LiveFolders.ICON_PACKAGE, LiveFolders.DESCRIPTION };
+    MatrixCursor cursor = new MatrixCursor(columns);
+    int index = 0;
+    for (File script : ScriptStorageAdapter.listExecutableScriptsRecursively(null, mConfiguration)) {
+      int iconId = 0;
+      if (script.isDirectory()) {
+        iconId = R.drawable.folder;
+      } else {
+        iconId = FeaturedInterpreters.getInterpreterIcon(mContext, script.getName());
+        if (iconId == 0) {
+          iconId = R.drawable.sl4a_logo_32;
+        }
+      }
+      ShortcutIconResource icon = ShortcutIconResource.fromContext(mContext, iconId);
+      Intent intent = IntentBuilders.buildStartInBackgroundIntent(script);
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+      String description = script.getAbsolutePath();
+      if (description.startsWith(InterpreterConstants.SCRIPTS_ROOT)) {
+        description = description.replaceAll(InterpreterConstants.SCRIPTS_ROOT, "scripts/");
+      }
+      Object[] row =
+          { index, script.getName(), intent.toURI(), icon.resourceName, icon.packageName,
+            description };
+      cursor.addRow(row);
+      ++index;
+    }
+    return cursor;
+  }
+
+  @Override
+  public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+    return 0;
+  }
+
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/TelephonyTestProvider.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/TelephonyTestProvider.java
new file mode 100644
index 0000000..2ab7c24
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/provider/TelephonyTestProvider.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.provider;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import com.googlecode.android_scripting.Log;
+
+/**
+ * A simple provider to send MMS PDU to platform MMS service
+ */
+public class TelephonyTestProvider extends ContentProvider {
+
+    public static final String AUTHORITY = "telephonytestauthority";
+
+    private final boolean DBG = false;
+
+    @Override
+    public boolean onCreate() {
+        if(DBG) Log.d("TelephonTestProvider Successfully created!");
+        return true;
+    }
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+            String sortOrder) {
+        // Not supported
+        return null;
+    }
+
+    @Override
+    public String getType(Uri uri) {
+        // Not supported
+        return null;
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        // Not supported
+        return null;
+    }
+
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        // Not supported
+        return 0;
+    }
+
+    @Override
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        // Not supported
+        return 0;
+    }
+
+    @Override
+    public ParcelFileDescriptor openFile(Uri uri, String fileMode) throws FileNotFoundException {
+        Log.d(String.format("Entered ParcelFileDescriptor: Uri(%s), Mode(%s)", uri.toString(),
+                fileMode));
+        File file = new File(getContext().getCacheDir(), uri.getPath());
+        file.setReadable(true);
+
+        Log.d(String.format("Looking for file at %s", getContext().getCacheDir() + uri.getPath()));
+        int mode = (TextUtils.equals(fileMode, "r") ? ParcelFileDescriptor.MODE_READ_ONLY :
+                ParcelFileDescriptor.MODE_WRITE_ONLY
+                | ParcelFileDescriptor.MODE_TRUNCATE
+                | ParcelFileDescriptor.MODE_CREATE);
+
+        try {
+            ParcelFileDescriptor descriptor = ParcelFileDescriptor.open(file, mode);
+
+            if(DBG) {
+                try {
+                    BufferedReader br = new BufferedReader(new
+                            FileReader(descriptor.getFileDescriptor()));
+                    String line = null;
+                    while ((line = br.readLine()) != null) {
+                        Log.d("MMS:" + line);
+                    }
+                } catch (IOException e) {
+                }
+            }
+
+            return descriptor;
+        } catch (FileNotFoundException fnf) {
+            Log.e(fnf);
+            return null;
+        }
+    }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/service/FacadeService.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/service/FacadeService.java
new file mode 100644
index 0000000..7ca4e18
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/service/FacadeService.java
@@ -0,0 +1,55 @@
+package com.googlecode.android_scripting.service;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.HandlerThread;
+import android.os.IBinder;
+import android.os.Messenger;
+
+import com.googlecode.android_scripting.facade.FacadeConfiguration;
+import com.googlecode.android_scripting.facade.FacadeManagerFactory;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManagerFactory;
+
+/**
+ * FacadeService exposes SL4A's Facade methods through a {@link Service} so
+ * they can be invoked from third-party apps.
+ * <p>
+ * Example binding code:<br>
+ * {@code
+ *   Intent intent = new Intent();
+ *   intent.setPackage("com.googlecode.android_scripting");
+ *   intent.setAction("com.googlecode.android_scripting.service.FacadeService.ACTION_BIND");
+ *   sl4aService = bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
+ * }
+ * Example using the service:<br>
+ * {@code
+ *   Bundle sl4aBundle = new Bundle;
+ *   bundle.putString{"sl4aMethod", "makeToast"};
+ *   bundle.putString{"message", "Hello World!"};
+ *   Message msg = Message.obtain(null, SL4A_ACTION);
+ *   msg.setData(sl4aBundle);
+ *   msg.replyTo = myReplyHandler; // Set a Messenger if you need the response
+ *   mSl4aService.send(msg);
+ * }
+ * <p>
+ * For more info on binding a {@link Service} using a {@link Messenger} please
+ * refer to Android's public developer documentation.
+ */
+public class FacadeService extends Service {
+
+    private RpcReceiverManagerFactory rpcReceiverManagerFactory;
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        if (rpcReceiverManagerFactory == null) {
+            rpcReceiverManagerFactory =
+                    new FacadeManagerFactory(FacadeConfiguration.getSdkLevel(), this, null,
+                            FacadeConfiguration.getFacadeClasses());
+        }
+        HandlerThread handlerThread = new HandlerThread("MessageHandlerThread");
+        handlerThread.start();
+        Messenger aMessenger = new Messenger(new MessageHandler(handlerThread,
+                rpcReceiverManagerFactory));
+        return aMessenger.getBinder();
+    }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/service/MessageHandler.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/service/MessageHandler.java
new file mode 100644
index 0000000..8c6fb3f
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/service/MessageHandler.java
@@ -0,0 +1,116 @@
+package com.googlecode.android_scripting.service;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Message;
+import android.os.RemoteException;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.jsonrpc.JsonRpcResult;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManagerFactory;
+import com.googlecode.android_scripting.rpc.MethodDescriptor;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Class responsible for Handling messages that came through the FacadeService
+ * interface.
+ * <br>
+ * Please refer to {@link FacadeService} for details on how to use.
+ */
+@TargetApi(3)
+public class MessageHandler extends Handler {
+
+    private static final int SL4A_ACTION = 0;
+    private static final int DEFAULT_SENDING_ID = 0;
+
+    // Android sets this to -1 when the message is not sent by a Messenger.
+    // see http://developer.android.com/reference/android/os/Message.html#sendingUid
+    private static final int DEFAULT_UNSET_SENDING_ID = 1;
+
+    // Keys for the Bundles.
+    private static final String SL4A_METHOD = "sl4aMethod";
+    private static final String SL4A_RESULT = "sl4aResult";
+
+    private final RpcReceiverManagerFactory mRpcReceiverManagerFactory;
+
+    public MessageHandler(HandlerThread handlerThread,
+                          RpcReceiverManagerFactory rpcReceiverManagerFactory) {
+        super(handlerThread.getLooper());
+        this.mRpcReceiverManagerFactory = rpcReceiverManagerFactory;
+    }
+
+    /**
+     * Handles messages for the service. It does this via the same mechanism used
+     * for RPCs through RpcManagers.
+     *
+     * @param message The message that contains the method and parameters to
+     *     execute.
+     */
+    @Override
+    public void handleMessage(Message message) {
+        Log.d("Handling Remote request");
+        int senderId = message.sendingUid == DEFAULT_UNSET_SENDING_ID ?
+                DEFAULT_SENDING_ID : message.sendingUid;
+        if (message.what == SL4A_ACTION) {
+            RpcReceiverManager receiverManager;
+            if (mRpcReceiverManagerFactory.getRpcReceiverManagers().containsKey(senderId)) {
+                receiverManager = mRpcReceiverManagerFactory.getRpcReceiverManagers().get(senderId);
+            } else {
+                receiverManager = mRpcReceiverManagerFactory.create(senderId);
+            }
+            Bundle sl4aRequest = message.getData();
+            String method = sl4aRequest.getString(SL4A_METHOD);
+            if (method == null || "".equals(method)) {
+                Log.e("No SL4A method specified on the Bundle. Specify one with "
+                        + SL4A_METHOD);
+                return;
+            }
+            MethodDescriptor rpc = receiverManager.getMethodDescriptor(method);
+            if (rpc == null) {
+                Log.e("Unknown RPC: \"" + method + "\"");
+                return;
+            }
+            try {
+                Log.d("Invoking method " + rpc.getName());
+                Object result = rpc.invoke(receiverManager, sl4aRequest);
+                // Only return a result if we were passed a Messenger. Otherwise assume
+                // client did not care for the response.
+                if (message.replyTo != null) {
+                    Message reply = Message.obtain();
+                    Bundle sl4aResponse = new Bundle();
+                    putResult(senderId, result, sl4aResponse);
+                    reply.setData(sl4aResponse);
+                    message.replyTo.send(reply);
+                }
+            } catch (RemoteException e) {
+                Log.e("Could not send reply back to client", e);
+            } catch (Throwable t) {
+                Log.e("Exception while executing sl4a method", t);
+            }
+        }
+    }
+
+    private void putResult(int id, Object result, Bundle reply) {
+        JSONObject json;
+        try {
+            if (result instanceof Throwable) {
+                json = JsonRpcResult.error(id, (Throwable) result);
+            } else {
+                json = JsonRpcResult.result(id, result);
+            }
+        } catch (JSONException e) {
+            // There was an error converting the result to JSON. This shouldn't
+            // happen normally.
+            Log.e("Caught exception when filling JSON result.", e);
+            reply.putString(SL4A_RESULT, e.toString());
+            return;
+        }
+        Log.d("Returning result: " + json.toString());
+        reply.putString(SL4A_RESULT, json.toString());
+    }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/DurationPicker.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/DurationPicker.java
new file mode 100644
index 0000000..7652471
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/DurationPicker.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * 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 com.googlecode.android_scripting.widget;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.widget.FrameLayout;
+
+import com.googlecode.android_scripting.R;
+
+/**
+ * A view for selecting the a duration using days, hours, minutes, and seconds.
+ */
+public class DurationPicker extends FrameLayout {
+
+  private int mCurrentDay = 0; // 0-99
+  private int mCurrentHour = 0; // 0-23
+  private int mCurrentMinute = 0; // 0-59
+  private int mCurrentSecond = 0; // 0-59
+
+  private final NumberPicker mDayPicker;
+  private final NumberPicker mHourPicker;
+  private final NumberPicker mMinutePicker;
+  private final NumberPicker mSecondPicker;
+
+  public DurationPicker(Context context) {
+    this(context, null);
+  }
+
+  public DurationPicker(Context context, AttributeSet attrs) {
+    this(context, attrs, 0);
+  }
+
+  public DurationPicker(Context context, AttributeSet attrs, int defStyle) {
+    super(context, attrs, defStyle);
+    LayoutInflater inflater =
+        (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    inflater.inflate(R.layout.duration_picker, this, true);
+
+    mDayPicker = (NumberPicker) findViewById(R.id.day);
+    mDayPicker.setRange(0, 99);
+    mDayPicker.setSpeed(100);
+    // mHourPicker.setFormatter(NumberPicker.TWO_DIGIT_FORMATTER);
+    mDayPicker.setOnChangeListener(new NumberPicker.OnChangedListener() {
+      public void onChanged(NumberPicker spinner, int oldVal, int newVal) {
+        mCurrentDay = newVal;
+      }
+    });
+
+    mHourPicker = (NumberPicker) findViewById(R.id.hour);
+    mHourPicker.setRange(0, 23);
+    mHourPicker.setSpeed(100);
+    // mHourPicker.setFormatter(NumberPicker.TWO_DIGIT_FORMATTER);
+    mHourPicker.setOnChangeListener(new NumberPicker.OnChangedListener() {
+      public void onChanged(NumberPicker spinner, int oldVal, int newVal) {
+        mCurrentHour = newVal;
+      }
+    });
+
+    mMinutePicker = (NumberPicker) findViewById(R.id.minute);
+    mMinutePicker.setRange(0, 59);
+    mMinutePicker.setSpeed(100);
+    mMinutePicker.setFormatter(NumberPicker.TWO_DIGIT_FORMATTER);
+    mMinutePicker.setOnChangeListener(new NumberPicker.OnChangedListener() {
+      public void onChanged(NumberPicker spinner, int oldVal, int newVal) {
+        mCurrentMinute = newVal;
+      }
+    });
+
+    mSecondPicker = (NumberPicker) findViewById(R.id.second);
+    mSecondPicker.setRange(0, 59);
+    mSecondPicker.setSpeed(100);
+    mSecondPicker.setFormatter(NumberPicker.TWO_DIGIT_FORMATTER);
+    mSecondPicker.setOnChangeListener(new NumberPicker.OnChangedListener() {
+      public void onChanged(NumberPicker spinner, int oldVal, int newVal) {
+        mCurrentSecond = newVal;
+      }
+    });
+  }
+
+  @Override
+  public void setEnabled(boolean enabled) {
+    super.setEnabled(enabled);
+    mDayPicker.setEnabled(enabled);
+    mHourPicker.setEnabled(enabled);
+    mMinutePicker.setEnabled(enabled);
+    mSecondPicker.setEnabled(enabled);
+  }
+
+  /**
+   * Returns the current day.
+   */
+  public Integer getCurrentDay() {
+    return mCurrentDay;
+  }
+
+  /**
+   * Set the current hour.
+   */
+  public void setCurrentDay(Integer currentDay) {
+    mCurrentDay = currentDay;
+    updateDayDisplay();
+  }
+
+  /**
+   * Returns the current hour.
+   */
+  public Integer getCurrentHour() {
+    return mCurrentHour;
+  }
+
+  /**
+   * Set the current hour.
+   */
+  public void setCurrentHour(Integer currentHour) {
+    mCurrentHour = currentHour;
+    updateHourDisplay();
+  }
+
+  /**
+   * Returns the current minute.
+   */
+  public Integer getCurrentMinute() {
+    return mCurrentMinute;
+  }
+
+  /**
+   * Set the current minute.
+   */
+  public void setCurrentMinute(Integer currentMinute) {
+    mCurrentMinute = currentMinute;
+    updateMinuteDisplay();
+  }
+
+  /**
+   * Returns the current second.
+   */
+  public Integer getCurrentSecond() {
+    return mCurrentSecond;
+  }
+
+  /**
+   * Set the current minute.
+   */
+  public void setCurrentSecond(Integer currentSecond) {
+    mCurrentSecond = currentSecond;
+    updateSecondDisplay();
+  }
+
+  /**
+   * Set the state of the spinners appropriate to the current day.
+   */
+  private void updateDayDisplay() {
+    int currentDay = mCurrentDay;
+    mDayPicker.setCurrent(currentDay);
+  }
+
+  /**
+   * Set the state of the spinners appropriate to the current hour.
+   */
+  private void updateHourDisplay() {
+    int currentHour = mCurrentHour;
+    mHourPicker.setCurrent(currentHour);
+  }
+
+  /**
+   * Set the state of the spinners appropriate to the current minute.
+   */
+  private void updateMinuteDisplay() {
+    mMinutePicker.setCurrent(mCurrentMinute);
+  }
+
+  /**
+   * Set the state of the spinners appropriate to the current minute.
+   */
+  private void updateSecondDisplay() {
+    mSecondPicker.setCurrent(mCurrentSecond);
+  }
+
+  /**
+   * Returns the duration in seconds.
+   */
+  public double getDuration() {
+    // The text views may still have focus so clear theirs focus which will trigger the on focus
+    // changed and any typed values to be pulled.
+    mDayPicker.clearFocus();
+    mHourPicker.clearFocus();
+    mMinutePicker.clearFocus();
+    mSecondPicker.clearFocus();
+    return (((((mCurrentDay * 24l + mCurrentHour) * 60) + mCurrentMinute) * 60) + mCurrentSecond);
+  }
+
+  /**
+   * Sets the duration in milliseconds.
+   *
+   * @return
+   */
+  public void setDuration(long duration) {
+    double seconds = duration / 1000;
+    double minutes = seconds / 60;
+    seconds = seconds % 60;
+    double hours = minutes / 60;
+    minutes = minutes % 60;
+    double days = hours / 24;
+    hours = hours % 24;
+
+    setCurrentDay((int) days);
+    setCurrentHour((int) hours);
+    setCurrentMinute((int) minutes);
+    setCurrentSecond((int) seconds);
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/NumberPicker.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/NumberPicker.java
new file mode 100644
index 0000000..061eacd
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/NumberPicker.java
@@ -0,0 +1,412 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * 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 com.googlecode.android_scripting.widget;
+
+import android.content.Context;
+import android.os.Handler;
+import android.text.InputFilter;
+import android.text.InputType;
+import android.text.Spanned;
+import android.text.method.NumberKeyListener;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnFocusChangeListener;
+import android.view.View.OnLongClickListener;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.R;
+
+public class NumberPicker extends LinearLayout implements OnClickListener, OnFocusChangeListener,
+    OnLongClickListener {
+
+  public interface OnChangedListener {
+    void onChanged(NumberPicker picker, int oldVal, int newVal);
+  }
+
+  public interface Formatter {
+    String toString(int value);
+  }
+
+  /*
+   * Use a custom NumberPicker formatting callback to use two-digit minutes strings like "01".
+   * Keeping a static formatter etc. is the most efficient way to do this; it avoids creating
+   * temporary objects on every call to format().
+   */
+  public static final NumberPicker.Formatter TWO_DIGIT_FORMATTER = new NumberPicker.Formatter() {
+    final StringBuilder mBuilder = new StringBuilder();
+    final java.util.Formatter mFmt = new java.util.Formatter(mBuilder);
+    final Object[] mArgs = new Object[1];
+
+    public String toString(int value) {
+      mArgs[0] = value;
+      mBuilder.delete(0, mBuilder.length());
+      mFmt.format("%02d", mArgs);
+      return mFmt.toString();
+    }
+  };
+
+  private final Handler mHandler;
+  private final Runnable mRunnable = new Runnable() {
+    public void run() {
+      if (mIncrement) {
+        changeCurrent(mCurrent + 1);
+        mHandler.postDelayed(this, mSpeed);
+      } else if (mDecrement) {
+        changeCurrent(mCurrent - 1);
+        mHandler.postDelayed(this, mSpeed);
+      }
+    }
+  };
+
+  private final EditText mText;
+  private final InputFilter mNumberInputFilter;
+
+  private String[] mDisplayedValues;
+  private int mStart;
+  private int mEnd;
+  private int mCurrent;
+  private int mPrevious;
+  private OnChangedListener mListener;
+  private Formatter mFormatter;
+  private long mSpeed = 300;
+
+  private boolean mIncrement;
+  private boolean mDecrement;
+
+  public NumberPicker(Context context) {
+    this(context, null);
+  }
+
+  public NumberPicker(Context context, AttributeSet attrs) {
+    this(context, attrs, 0);
+  }
+
+  public NumberPicker(Context context, AttributeSet attrs, int defStyle) {
+    super(context, attrs);
+    setOrientation(VERTICAL);
+    LayoutInflater inflater =
+        (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    inflater.inflate(R.layout.number_picker, this, true);
+    mHandler = new Handler();
+    InputFilter inputFilter = new NumberPickerInputFilter();
+    mNumberInputFilter = new NumberRangeKeyListener();
+    mIncrementButton = (NumberPickerButton) findViewById(R.id.increment);
+    mIncrementButton.setOnClickListener(this);
+    mIncrementButton.setOnLongClickListener(this);
+    mIncrementButton.setNumberPicker(this);
+    mDecrementButton = (NumberPickerButton) findViewById(R.id.decrement);
+    mDecrementButton.setOnClickListener(this);
+    mDecrementButton.setOnLongClickListener(this);
+    mDecrementButton.setNumberPicker(this);
+
+    mText = (EditText) findViewById(R.id.timepicker_input);
+    mText.setOnFocusChangeListener(this);
+    mText.setFilters(new InputFilter[] { inputFilter });
+    mText.setRawInputType(InputType.TYPE_CLASS_NUMBER);
+
+    if (!isEnabled()) {
+      setEnabled(false);
+    }
+  }
+
+  @Override
+  public void setEnabled(boolean enabled) {
+    super.setEnabled(enabled);
+    mIncrementButton.setEnabled(enabled);
+    mDecrementButton.setEnabled(enabled);
+    mText.setEnabled(enabled);
+  }
+
+  public void setOnChangeListener(OnChangedListener listener) {
+    mListener = listener;
+  }
+
+  public void setFormatter(Formatter formatter) {
+    mFormatter = formatter;
+  }
+
+  /**
+   * Set the range of numbers allowed for the number picker. The current value will be automatically
+   * set to the start.
+   *
+   * @param start
+   *          the start of the range (inclusive)
+   * @param end
+   *          the end of the range (inclusive)
+   */
+  public void setRange(int start, int end) {
+    mStart = start;
+    mEnd = end;
+    mCurrent = start;
+    updateView();
+  }
+
+  /**
+   * Set the range of numbers allowed for the number picker. The current value will be automatically
+   * set to the start. Also provide a mapping for values used to display to the user.
+   *
+   * @param start
+   *          the start of the range (inclusive)
+   * @param end
+   *          the end of the range (inclusive)
+   * @param displayedValues
+   *          the values displayed to the user.
+   */
+  public void setRange(int start, int end, String[] displayedValues) {
+    mDisplayedValues = displayedValues;
+    mStart = start;
+    mEnd = end;
+    mCurrent = start;
+    updateView();
+  }
+
+  public void setCurrent(int current) {
+    mCurrent = current;
+    updateView();
+  }
+
+  /**
+   * The speed (in milliseconds) at which the numbers will scroll when the the +/- buttons are
+   * longpressed. Default is 300ms.
+   */
+  public void setSpeed(long speed) {
+    mSpeed = speed;
+  }
+
+  public void onClick(View v) {
+    validateInput(mText);
+    if (!mText.hasFocus()) {
+      mText.requestFocus();
+    }
+
+    // now perform the increment/decrement
+    if (R.id.increment == v.getId()) {
+      changeCurrent(mCurrent + 1);
+    } else if (R.id.decrement == v.getId()) {
+      changeCurrent(mCurrent - 1);
+    }
+  }
+
+  private String formatNumber(int value) {
+    return (mFormatter != null) ? mFormatter.toString(value) : String.valueOf(value);
+  }
+
+  private void changeCurrent(int current) {
+
+    // Wrap around the values if we go past the start or end
+    if (current > mEnd) {
+      current = mStart;
+    } else if (current < mStart) {
+      current = mEnd;
+    }
+    mPrevious = mCurrent;
+    mCurrent = current;
+    notifyChange();
+    updateView();
+  }
+
+  private void notifyChange() {
+    if (mListener != null) {
+      mListener.onChanged(this, mPrevious, mCurrent);
+    }
+  }
+
+  private void updateView() {
+
+    /*
+     * If we don't have displayed values then use the current number else find the correct value in
+     * the displayed values for the current number.
+     */
+    if (mDisplayedValues == null) {
+      mText.setText(formatNumber(mCurrent));
+    } else {
+      mText.setText(mDisplayedValues[mCurrent - mStart]);
+    }
+    mText.setSelection(mText.getText().length());
+  }
+
+  private void validateCurrentView(CharSequence str) {
+    int val = getSelectedPos(str.toString());
+    if ((val >= mStart) && (val <= mEnd)) {
+      mPrevious = mCurrent;
+      mCurrent = val;
+      notifyChange();
+    }
+    updateView();
+  }
+
+  public void onFocusChange(View v, boolean hasFocus) {
+
+    /*
+     * When focus is lost check that the text field has valid values.
+     */
+    if (!hasFocus) {
+      validateInput(v);
+    }
+  }
+
+  private void validateInput(View v) {
+    String str = String.valueOf(((TextView) v).getText());
+    if ("".equals(str)) {
+
+      // Restore to the old value as we don't allow empty values
+      updateView();
+    } else {
+
+      // Check the new value and ensure it's in range
+      validateCurrentView(str);
+    }
+  }
+
+  /**
+   * We start the long click here but rely on the {@link NumberPickerButton} to inform us when the
+   * long click has ended.
+   */
+  public boolean onLongClick(View v) {
+
+    /*
+     * The text view may still have focus so clear it's focus which will trigger the on focus
+     * changed and any typed values to be pulled.
+     */
+    mText.clearFocus();
+
+    if (R.id.increment == v.getId()) {
+      mIncrement = true;
+      mHandler.post(mRunnable);
+    } else if (R.id.decrement == v.getId()) {
+      mDecrement = true;
+      mHandler.post(mRunnable);
+    }
+    return true;
+  }
+
+  public void cancelIncrement() {
+    mIncrement = false;
+  }
+
+  public void cancelDecrement() {
+    mDecrement = false;
+  }
+
+  private static final char[] DIGIT_CHARACTERS =
+      new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
+
+  private final NumberPickerButton mIncrementButton;
+  private final NumberPickerButton mDecrementButton;
+
+  private class NumberPickerInputFilter implements InputFilter {
+    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart,
+        int dend) {
+      if (mDisplayedValues == null) {
+        return mNumberInputFilter.filter(source, start, end, dest, dstart, dend);
+      }
+      CharSequence filtered = String.valueOf(source.subSequence(start, end));
+      String result =
+          String.valueOf(dest.subSequence(0, dstart)) + filtered
+              + dest.subSequence(dend, dest.length());
+      String str = String.valueOf(result).toLowerCase();
+      for (String val : mDisplayedValues) {
+        val = val.toLowerCase();
+        if (val.startsWith(str)) {
+          return filtered;
+        }
+      }
+      return "";
+    }
+  }
+
+  private class NumberRangeKeyListener extends NumberKeyListener {
+
+    // XXX This doesn't allow for range limits when controlled by a
+    // soft input method!
+    public int getInputType() {
+      return InputType.TYPE_CLASS_NUMBER;
+    }
+
+    @Override
+    protected char[] getAcceptedChars() {
+      return DIGIT_CHARACTERS;
+    }
+
+    @Override
+    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart,
+        int dend) {
+
+      CharSequence filtered = super.filter(source, start, end, dest, dstart, dend);
+      if (filtered == null) {
+        filtered = source.subSequence(start, end);
+      }
+
+      String result =
+          String.valueOf(dest.subSequence(0, dstart)) + filtered
+              + dest.subSequence(dend, dest.length());
+
+      if ("".equals(result)) {
+        return result;
+      }
+      int val = getSelectedPos(result);
+
+      /*
+       * Ensure the user can't type in a value greater than the max allowed. We have to allow less
+       * than min as the user might want to delete some numbers and then type a new number.
+       */
+      if (val > mEnd) {
+        return "";
+      } else {
+        return filtered;
+      }
+    }
+  }
+
+  private int getSelectedPos(String str) {
+    if (mDisplayedValues == null) {
+      return Integer.parseInt(str);
+    } else {
+      for (int i = 0; i < mDisplayedValues.length; i++) {
+
+        /* Don't force the user to type in jan when ja will do */
+        str = str.toLowerCase();
+        if (mDisplayedValues[i].toLowerCase().startsWith(str)) {
+          return mStart + i;
+        }
+      }
+
+      /*
+       * The user might have typed in a number into the month field i.e. 10 instead of OCT so
+       * support that too.
+       */
+      try {
+        return Integer.parseInt(str);
+      } catch (NumberFormatException e) {
+
+        /* Ignore as if it's not a number we don't care */
+      }
+    }
+    return mStart;
+  }
+
+  /**
+   * @return the current value.
+   */
+  public int getCurrent() {
+    return mCurrent;
+  }
+}
\ No newline at end of file
diff --git a/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/NumberPickerButton.java b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/NumberPickerButton.java
new file mode 100644
index 0000000..cb8d184
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/com/googlecode/android_scripting/widget/NumberPickerButton.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * 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 com.googlecode.android_scripting.widget;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.widget.ImageButton;
+
+import com.googlecode.android_scripting.R;
+
+/**
+ * This class exists purely to cancel long click events.
+ */
+public class NumberPickerButton extends ImageButton {
+
+  private NumberPicker mNumberPicker;
+
+  public NumberPickerButton(Context context, AttributeSet attrs, int defStyle) {
+    super(context, attrs, defStyle);
+  }
+
+  public NumberPickerButton(Context context, AttributeSet attrs) {
+    super(context, attrs);
+  }
+
+  public NumberPickerButton(Context context) {
+    super(context);
+  }
+
+  public void setNumberPicker(NumberPicker picker) {
+    mNumberPicker = picker;
+  }
+
+  @Override
+  public boolean onTouchEvent(MotionEvent event) {
+    cancelLongpressIfRequired(event);
+    return super.onTouchEvent(event);
+  }
+
+  @Override
+  public boolean onTrackballEvent(MotionEvent event) {
+    cancelLongpressIfRequired(event);
+    return super.onTrackballEvent(event);
+  }
+
+  @Override
+  public boolean onKeyUp(int keyCode, KeyEvent event) {
+    if ((keyCode == KeyEvent.KEYCODE_DPAD_CENTER) || (keyCode == KeyEvent.KEYCODE_ENTER)) {
+      cancelLongpress();
+    }
+    return super.onKeyUp(keyCode, event);
+  }
+
+  private void cancelLongpressIfRequired(MotionEvent event) {
+    if ((event.getAction() == MotionEvent.ACTION_CANCEL)
+        || (event.getAction() == MotionEvent.ACTION_UP)) {
+      cancelLongpress();
+    }
+  }
+
+  private void cancelLongpress() {
+    if (R.id.increment == getId()) {
+      mNumberPicker.cancelIncrement();
+    } else if (R.id.decrement == getId()) {
+      mNumberPicker.cancelDecrement();
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/de/mud/terminal/Precomposer.java b/ScriptingLayerForAndroid/src/de/mud/terminal/Precomposer.java
new file mode 100644
index 0000000..edad64c
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/de/mud/terminal/Precomposer.java
@@ -0,0 +1,1052 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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 de.mud.terminal;
+
+/**
+ * @author Kenny Root
+ * This data was taken from xterm's precompose.c
+ */
+public class Precomposer {
+	public final static char precompositions[][] = {
+		{ 0x226E, 0x003C, 0x0338},
+		{ 0x2260, 0x003D, 0x0338},
+		{ 0x226F, 0x003E, 0x0338},
+		{ 0x00C0, 0x0041, 0x0300},
+		{ 0x00C1, 0x0041, 0x0301},
+		{ 0x00C2, 0x0041, 0x0302},
+		{ 0x00C3, 0x0041, 0x0303},
+		{ 0x0100, 0x0041, 0x0304},
+		{ 0x0102, 0x0041, 0x0306},
+		{ 0x0226, 0x0041, 0x0307},
+		{ 0x00C4, 0x0041, 0x0308},
+		{ 0x1EA2, 0x0041, 0x0309},
+		{ 0x00C5, 0x0041, 0x030A},
+		{ 0x01CD, 0x0041, 0x030C},
+		{ 0x0200, 0x0041, 0x030F},
+		{ 0x0202, 0x0041, 0x0311},
+		{ 0x1EA0, 0x0041, 0x0323},
+		{ 0x1E00, 0x0041, 0x0325},
+		{ 0x0104, 0x0041, 0x0328},
+		{ 0x1E02, 0x0042, 0x0307},
+		{ 0x1E04, 0x0042, 0x0323},
+		{ 0x1E06, 0x0042, 0x0331},
+		{ 0x0106, 0x0043, 0x0301},
+		{ 0x0108, 0x0043, 0x0302},
+		{ 0x010A, 0x0043, 0x0307},
+		{ 0x010C, 0x0043, 0x030C},
+		{ 0x00C7, 0x0043, 0x0327},
+		{ 0x1E0A, 0x0044, 0x0307},
+		{ 0x010E, 0x0044, 0x030C},
+		{ 0x1E0C, 0x0044, 0x0323},
+		{ 0x1E10, 0x0044, 0x0327},
+		{ 0x1E12, 0x0044, 0x032D},
+		{ 0x1E0E, 0x0044, 0x0331},
+		{ 0x00C8, 0x0045, 0x0300},
+		{ 0x00C9, 0x0045, 0x0301},
+		{ 0x00CA, 0x0045, 0x0302},
+		{ 0x1EBC, 0x0045, 0x0303},
+		{ 0x0112, 0x0045, 0x0304},
+		{ 0x0114, 0x0045, 0x0306},
+		{ 0x0116, 0x0045, 0x0307},
+		{ 0x00CB, 0x0045, 0x0308},
+		{ 0x1EBA, 0x0045, 0x0309},
+		{ 0x011A, 0x0045, 0x030C},
+		{ 0x0204, 0x0045, 0x030F},
+		{ 0x0206, 0x0045, 0x0311},
+		{ 0x1EB8, 0x0045, 0x0323},
+		{ 0x0228, 0x0045, 0x0327},
+		{ 0x0118, 0x0045, 0x0328},
+		{ 0x1E18, 0x0045, 0x032D},
+		{ 0x1E1A, 0x0045, 0x0330},
+		{ 0x1E1E, 0x0046, 0x0307},
+		{ 0x01F4, 0x0047, 0x0301},
+		{ 0x011C, 0x0047, 0x0302},
+		{ 0x1E20, 0x0047, 0x0304},
+		{ 0x011E, 0x0047, 0x0306},
+		{ 0x0120, 0x0047, 0x0307},
+		{ 0x01E6, 0x0047, 0x030C},
+		{ 0x0122, 0x0047, 0x0327},
+		{ 0x0124, 0x0048, 0x0302},
+		{ 0x1E22, 0x0048, 0x0307},
+		{ 0x1E26, 0x0048, 0x0308},
+		{ 0x021E, 0x0048, 0x030C},
+		{ 0x1E24, 0x0048, 0x0323},
+		{ 0x1E28, 0x0048, 0x0327},
+		{ 0x1E2A, 0x0048, 0x032E},
+		{ 0x00CC, 0x0049, 0x0300},
+		{ 0x00CD, 0x0049, 0x0301},
+		{ 0x00CE, 0x0049, 0x0302},
+		{ 0x0128, 0x0049, 0x0303},
+		{ 0x012A, 0x0049, 0x0304},
+		{ 0x012C, 0x0049, 0x0306},
+		{ 0x0130, 0x0049, 0x0307},
+		{ 0x00CF, 0x0049, 0x0308},
+		{ 0x1EC8, 0x0049, 0x0309},
+		{ 0x01CF, 0x0049, 0x030C},
+		{ 0x0208, 0x0049, 0x030F},
+		{ 0x020A, 0x0049, 0x0311},
+		{ 0x1ECA, 0x0049, 0x0323},
+		{ 0x012E, 0x0049, 0x0328},
+		{ 0x1E2C, 0x0049, 0x0330},
+		{ 0x0134, 0x004A, 0x0302},
+		{ 0x1E30, 0x004B, 0x0301},
+		{ 0x01E8, 0x004B, 0x030C},
+		{ 0x1E32, 0x004B, 0x0323},
+		{ 0x0136, 0x004B, 0x0327},
+		{ 0x1E34, 0x004B, 0x0331},
+		{ 0x0139, 0x004C, 0x0301},
+		{ 0x013D, 0x004C, 0x030C},
+		{ 0x1E36, 0x004C, 0x0323},
+		{ 0x013B, 0x004C, 0x0327},
+		{ 0x1E3C, 0x004C, 0x032D},
+		{ 0x1E3A, 0x004C, 0x0331},
+		{ 0x1E3E, 0x004D, 0x0301},
+		{ 0x1E40, 0x004D, 0x0307},
+		{ 0x1E42, 0x004D, 0x0323},
+		{ 0x01F8, 0x004E, 0x0300},
+		{ 0x0143, 0x004E, 0x0301},
+		{ 0x00D1, 0x004E, 0x0303},
+		{ 0x1E44, 0x004E, 0x0307},
+		{ 0x0147, 0x004E, 0x030C},
+		{ 0x1E46, 0x004E, 0x0323},
+		{ 0x0145, 0x004E, 0x0327},
+		{ 0x1E4A, 0x004E, 0x032D},
+		{ 0x1E48, 0x004E, 0x0331},
+		{ 0x00D2, 0x004F, 0x0300},
+		{ 0x00D3, 0x004F, 0x0301},
+		{ 0x00D4, 0x004F, 0x0302},
+		{ 0x00D5, 0x004F, 0x0303},
+		{ 0x014C, 0x004F, 0x0304},
+		{ 0x014E, 0x004F, 0x0306},
+		{ 0x022E, 0x004F, 0x0307},
+		{ 0x00D6, 0x004F, 0x0308},
+		{ 0x1ECE, 0x004F, 0x0309},
+		{ 0x0150, 0x004F, 0x030B},
+		{ 0x01D1, 0x004F, 0x030C},
+		{ 0x020C, 0x004F, 0x030F},
+		{ 0x020E, 0x004F, 0x0311},
+		{ 0x01A0, 0x004F, 0x031B},
+		{ 0x1ECC, 0x004F, 0x0323},
+		{ 0x01EA, 0x004F, 0x0328},
+		{ 0x1E54, 0x0050, 0x0301},
+		{ 0x1E56, 0x0050, 0x0307},
+		{ 0x0154, 0x0052, 0x0301},
+		{ 0x1E58, 0x0052, 0x0307},
+		{ 0x0158, 0x0052, 0x030C},
+		{ 0x0210, 0x0052, 0x030F},
+		{ 0x0212, 0x0052, 0x0311},
+		{ 0x1E5A, 0x0052, 0x0323},
+		{ 0x0156, 0x0052, 0x0327},
+		{ 0x1E5E, 0x0052, 0x0331},
+		{ 0x015A, 0x0053, 0x0301},
+		{ 0x015C, 0x0053, 0x0302},
+		{ 0x1E60, 0x0053, 0x0307},
+		{ 0x0160, 0x0053, 0x030C},
+		{ 0x1E62, 0x0053, 0x0323},
+		{ 0x0218, 0x0053, 0x0326},
+		{ 0x015E, 0x0053, 0x0327},
+		{ 0x1E6A, 0x0054, 0x0307},
+		{ 0x0164, 0x0054, 0x030C},
+		{ 0x1E6C, 0x0054, 0x0323},
+		{ 0x021A, 0x0054, 0x0326},
+		{ 0x0162, 0x0054, 0x0327},
+		{ 0x1E70, 0x0054, 0x032D},
+		{ 0x1E6E, 0x0054, 0x0331},
+		{ 0x00D9, 0x0055, 0x0300},
+		{ 0x00DA, 0x0055, 0x0301},
+		{ 0x00DB, 0x0055, 0x0302},
+		{ 0x0168, 0x0055, 0x0303},
+		{ 0x016A, 0x0055, 0x0304},
+		{ 0x016C, 0x0055, 0x0306},
+		{ 0x00DC, 0x0055, 0x0308},
+		{ 0x1EE6, 0x0055, 0x0309},
+		{ 0x016E, 0x0055, 0x030A},
+		{ 0x0170, 0x0055, 0x030B},
+		{ 0x01D3, 0x0055, 0x030C},
+		{ 0x0214, 0x0055, 0x030F},
+		{ 0x0216, 0x0055, 0x0311},
+		{ 0x01AF, 0x0055, 0x031B},
+		{ 0x1EE4, 0x0055, 0x0323},
+		{ 0x1E72, 0x0055, 0x0324},
+		{ 0x0172, 0x0055, 0x0328},
+		{ 0x1E76, 0x0055, 0x032D},
+		{ 0x1E74, 0x0055, 0x0330},
+		{ 0x1E7C, 0x0056, 0x0303},
+		{ 0x1E7E, 0x0056, 0x0323},
+		{ 0x1E80, 0x0057, 0x0300},
+		{ 0x1E82, 0x0057, 0x0301},
+		{ 0x0174, 0x0057, 0x0302},
+		{ 0x1E86, 0x0057, 0x0307},
+		{ 0x1E84, 0x0057, 0x0308},
+		{ 0x1E88, 0x0057, 0x0323},
+		{ 0x1E8A, 0x0058, 0x0307},
+		{ 0x1E8C, 0x0058, 0x0308},
+		{ 0x1EF2, 0x0059, 0x0300},
+		{ 0x00DD, 0x0059, 0x0301},
+		{ 0x0176, 0x0059, 0x0302},
+		{ 0x1EF8, 0x0059, 0x0303},
+		{ 0x0232, 0x0059, 0x0304},
+		{ 0x1E8E, 0x0059, 0x0307},
+		{ 0x0178, 0x0059, 0x0308},
+		{ 0x1EF6, 0x0059, 0x0309},
+		{ 0x1EF4, 0x0059, 0x0323},
+		{ 0x0179, 0x005A, 0x0301},
+		{ 0x1E90, 0x005A, 0x0302},
+		{ 0x017B, 0x005A, 0x0307},
+		{ 0x017D, 0x005A, 0x030C},
+		{ 0x1E92, 0x005A, 0x0323},
+		{ 0x1E94, 0x005A, 0x0331},
+		{ 0x00E0, 0x0061, 0x0300},
+		{ 0x00E1, 0x0061, 0x0301},
+		{ 0x00E2, 0x0061, 0x0302},
+		{ 0x00E3, 0x0061, 0x0303},
+		{ 0x0101, 0x0061, 0x0304},
+		{ 0x0103, 0x0061, 0x0306},
+		{ 0x0227, 0x0061, 0x0307},
+		{ 0x00E4, 0x0061, 0x0308},
+		{ 0x1EA3, 0x0061, 0x0309},
+		{ 0x00E5, 0x0061, 0x030A},
+		{ 0x01CE, 0x0061, 0x030C},
+		{ 0x0201, 0x0061, 0x030F},
+		{ 0x0203, 0x0061, 0x0311},
+		{ 0x1EA1, 0x0061, 0x0323},
+		{ 0x1E01, 0x0061, 0x0325},
+		{ 0x0105, 0x0061, 0x0328},
+		{ 0x1E03, 0x0062, 0x0307},
+		{ 0x1E05, 0x0062, 0x0323},
+		{ 0x1E07, 0x0062, 0x0331},
+		{ 0x0107, 0x0063, 0x0301},
+		{ 0x0109, 0x0063, 0x0302},
+		{ 0x010B, 0x0063, 0x0307},
+		{ 0x010D, 0x0063, 0x030C},
+		{ 0x00E7, 0x0063, 0x0327},
+		{ 0x1E0B, 0x0064, 0x0307},
+		{ 0x010F, 0x0064, 0x030C},
+		{ 0x1E0D, 0x0064, 0x0323},
+		{ 0x1E11, 0x0064, 0x0327},
+		{ 0x1E13, 0x0064, 0x032D},
+		{ 0x1E0F, 0x0064, 0x0331},
+		{ 0x00E8, 0x0065, 0x0300},
+		{ 0x00E9, 0x0065, 0x0301},
+		{ 0x00EA, 0x0065, 0x0302},
+		{ 0x1EBD, 0x0065, 0x0303},
+		{ 0x0113, 0x0065, 0x0304},
+		{ 0x0115, 0x0065, 0x0306},
+		{ 0x0117, 0x0065, 0x0307},
+		{ 0x00EB, 0x0065, 0x0308},
+		{ 0x1EBB, 0x0065, 0x0309},
+		{ 0x011B, 0x0065, 0x030C},
+		{ 0x0205, 0x0065, 0x030F},
+		{ 0x0207, 0x0065, 0x0311},
+		{ 0x1EB9, 0x0065, 0x0323},
+		{ 0x0229, 0x0065, 0x0327},
+		{ 0x0119, 0x0065, 0x0328},
+		{ 0x1E19, 0x0065, 0x032D},
+		{ 0x1E1B, 0x0065, 0x0330},
+		{ 0x1E1F, 0x0066, 0x0307},
+		{ 0x01F5, 0x0067, 0x0301},
+		{ 0x011D, 0x0067, 0x0302},
+		{ 0x1E21, 0x0067, 0x0304},
+		{ 0x011F, 0x0067, 0x0306},
+		{ 0x0121, 0x0067, 0x0307},
+		{ 0x01E7, 0x0067, 0x030C},
+		{ 0x0123, 0x0067, 0x0327},
+		{ 0x0125, 0x0068, 0x0302},
+		{ 0x1E23, 0x0068, 0x0307},
+		{ 0x1E27, 0x0068, 0x0308},
+		{ 0x021F, 0x0068, 0x030C},
+		{ 0x1E25, 0x0068, 0x0323},
+		{ 0x1E29, 0x0068, 0x0327},
+		{ 0x1E2B, 0x0068, 0x032E},
+		{ 0x1E96, 0x0068, 0x0331},
+		{ 0x00EC, 0x0069, 0x0300},
+		{ 0x00ED, 0x0069, 0x0301},
+		{ 0x00EE, 0x0069, 0x0302},
+		{ 0x0129, 0x0069, 0x0303},
+		{ 0x012B, 0x0069, 0x0304},
+		{ 0x012D, 0x0069, 0x0306},
+		{ 0x00EF, 0x0069, 0x0308},
+		{ 0x1EC9, 0x0069, 0x0309},
+		{ 0x01D0, 0x0069, 0x030C},
+		{ 0x0209, 0x0069, 0x030F},
+		{ 0x020B, 0x0069, 0x0311},
+		{ 0x1ECB, 0x0069, 0x0323},
+		{ 0x012F, 0x0069, 0x0328},
+		{ 0x1E2D, 0x0069, 0x0330},
+		{ 0x0135, 0x006A, 0x0302},
+		{ 0x01F0, 0x006A, 0x030C},
+		{ 0x1E31, 0x006B, 0x0301},
+		{ 0x01E9, 0x006B, 0x030C},
+		{ 0x1E33, 0x006B, 0x0323},
+		{ 0x0137, 0x006B, 0x0327},
+		{ 0x1E35, 0x006B, 0x0331},
+		{ 0x013A, 0x006C, 0x0301},
+		{ 0x013E, 0x006C, 0x030C},
+		{ 0x1E37, 0x006C, 0x0323},
+		{ 0x013C, 0x006C, 0x0327},
+		{ 0x1E3D, 0x006C, 0x032D},
+		{ 0x1E3B, 0x006C, 0x0331},
+		{ 0x1E3F, 0x006D, 0x0301},
+		{ 0x1E41, 0x006D, 0x0307},
+		{ 0x1E43, 0x006D, 0x0323},
+		{ 0x01F9, 0x006E, 0x0300},
+		{ 0x0144, 0x006E, 0x0301},
+		{ 0x00F1, 0x006E, 0x0303},
+		{ 0x1E45, 0x006E, 0x0307},
+		{ 0x0148, 0x006E, 0x030C},
+		{ 0x1E47, 0x006E, 0x0323},
+		{ 0x0146, 0x006E, 0x0327},
+		{ 0x1E4B, 0x006E, 0x032D},
+		{ 0x1E49, 0x006E, 0x0331},
+		{ 0x00F2, 0x006F, 0x0300},
+		{ 0x00F3, 0x006F, 0x0301},
+		{ 0x00F4, 0x006F, 0x0302},
+		{ 0x00F5, 0x006F, 0x0303},
+		{ 0x014D, 0x006F, 0x0304},
+		{ 0x014F, 0x006F, 0x0306},
+		{ 0x022F, 0x006F, 0x0307},
+		{ 0x00F6, 0x006F, 0x0308},
+		{ 0x1ECF, 0x006F, 0x0309},
+		{ 0x0151, 0x006F, 0x030B},
+		{ 0x01D2, 0x006F, 0x030C},
+		{ 0x020D, 0x006F, 0x030F},
+		{ 0x020F, 0x006F, 0x0311},
+		{ 0x01A1, 0x006F, 0x031B},
+		{ 0x1ECD, 0x006F, 0x0323},
+		{ 0x01EB, 0x006F, 0x0328},
+		{ 0x1E55, 0x0070, 0x0301},
+		{ 0x1E57, 0x0070, 0x0307},
+		{ 0x0155, 0x0072, 0x0301},
+		{ 0x1E59, 0x0072, 0x0307},
+		{ 0x0159, 0x0072, 0x030C},
+		{ 0x0211, 0x0072, 0x030F},
+		{ 0x0213, 0x0072, 0x0311},
+		{ 0x1E5B, 0x0072, 0x0323},
+		{ 0x0157, 0x0072, 0x0327},
+		{ 0x1E5F, 0x0072, 0x0331},
+		{ 0x015B, 0x0073, 0x0301},
+		{ 0x015D, 0x0073, 0x0302},
+		{ 0x1E61, 0x0073, 0x0307},
+		{ 0x0161, 0x0073, 0x030C},
+		{ 0x1E63, 0x0073, 0x0323},
+		{ 0x0219, 0x0073, 0x0326},
+		{ 0x015F, 0x0073, 0x0327},
+		{ 0x1E6B, 0x0074, 0x0307},
+		{ 0x1E97, 0x0074, 0x0308},
+		{ 0x0165, 0x0074, 0x030C},
+		{ 0x1E6D, 0x0074, 0x0323},
+		{ 0x021B, 0x0074, 0x0326},
+		{ 0x0163, 0x0074, 0x0327},
+		{ 0x1E71, 0x0074, 0x032D},
+		{ 0x1E6F, 0x0074, 0x0331},
+		{ 0x00F9, 0x0075, 0x0300},
+		{ 0x00FA, 0x0075, 0x0301},
+		{ 0x00FB, 0x0075, 0x0302},
+		{ 0x0169, 0x0075, 0x0303},
+		{ 0x016B, 0x0075, 0x0304},
+		{ 0x016D, 0x0075, 0x0306},
+		{ 0x00FC, 0x0075, 0x0308},
+		{ 0x1EE7, 0x0075, 0x0309},
+		{ 0x016F, 0x0075, 0x030A},
+		{ 0x0171, 0x0075, 0x030B},
+		{ 0x01D4, 0x0075, 0x030C},
+		{ 0x0215, 0x0075, 0x030F},
+		{ 0x0217, 0x0075, 0x0311},
+		{ 0x01B0, 0x0075, 0x031B},
+		{ 0x1EE5, 0x0075, 0x0323},
+		{ 0x1E73, 0x0075, 0x0324},
+		{ 0x0173, 0x0075, 0x0328},
+		{ 0x1E77, 0x0075, 0x032D},
+		{ 0x1E75, 0x0075, 0x0330},
+		{ 0x1E7D, 0x0076, 0x0303},
+		{ 0x1E7F, 0x0076, 0x0323},
+		{ 0x1E81, 0x0077, 0x0300},
+		{ 0x1E83, 0x0077, 0x0301},
+		{ 0x0175, 0x0077, 0x0302},
+		{ 0x1E87, 0x0077, 0x0307},
+		{ 0x1E85, 0x0077, 0x0308},
+		{ 0x1E98, 0x0077, 0x030A},
+		{ 0x1E89, 0x0077, 0x0323},
+		{ 0x1E8B, 0x0078, 0x0307},
+		{ 0x1E8D, 0x0078, 0x0308},
+		{ 0x1EF3, 0x0079, 0x0300},
+		{ 0x00FD, 0x0079, 0x0301},
+		{ 0x0177, 0x0079, 0x0302},
+		{ 0x1EF9, 0x0079, 0x0303},
+		{ 0x0233, 0x0079, 0x0304},
+		{ 0x1E8F, 0x0079, 0x0307},
+		{ 0x00FF, 0x0079, 0x0308},
+		{ 0x1EF7, 0x0079, 0x0309},
+		{ 0x1E99, 0x0079, 0x030A},
+		{ 0x1EF5, 0x0079, 0x0323},
+		{ 0x017A, 0x007A, 0x0301},
+		{ 0x1E91, 0x007A, 0x0302},
+		{ 0x017C, 0x007A, 0x0307},
+		{ 0x017E, 0x007A, 0x030C},
+		{ 0x1E93, 0x007A, 0x0323},
+		{ 0x1E95, 0x007A, 0x0331},
+		{ 0x1FED, 0x00A8, 0x0300},
+		{ 0x0385, 0x00A8, 0x0301},
+		{ 0x1FC1, 0x00A8, 0x0342},
+		{ 0x1EA6, 0x00C2, 0x0300},
+		{ 0x1EA4, 0x00C2, 0x0301},
+		{ 0x1EAA, 0x00C2, 0x0303},
+		{ 0x1EA8, 0x00C2, 0x0309},
+		{ 0x01DE, 0x00C4, 0x0304},
+		{ 0x01FA, 0x00C5, 0x0301},
+		{ 0x01FC, 0x00C6, 0x0301},
+		{ 0x01E2, 0x00C6, 0x0304},
+		{ 0x1E08, 0x00C7, 0x0301},
+		{ 0x1EC0, 0x00CA, 0x0300},
+		{ 0x1EBE, 0x00CA, 0x0301},
+		{ 0x1EC4, 0x00CA, 0x0303},
+		{ 0x1EC2, 0x00CA, 0x0309},
+		{ 0x1E2E, 0x00CF, 0x0301},
+		{ 0x1ED2, 0x00D4, 0x0300},
+		{ 0x1ED0, 0x00D4, 0x0301},
+		{ 0x1ED6, 0x00D4, 0x0303},
+		{ 0x1ED4, 0x00D4, 0x0309},
+		{ 0x1E4C, 0x00D5, 0x0301},
+		{ 0x022C, 0x00D5, 0x0304},
+		{ 0x1E4E, 0x00D5, 0x0308},
+		{ 0x022A, 0x00D6, 0x0304},
+		{ 0x01FE, 0x00D8, 0x0301},
+		{ 0x01DB, 0x00DC, 0x0300},
+		{ 0x01D7, 0x00DC, 0x0301},
+		{ 0x01D5, 0x00DC, 0x0304},
+		{ 0x01D9, 0x00DC, 0x030C},
+		{ 0x1EA7, 0x00E2, 0x0300},
+		{ 0x1EA5, 0x00E2, 0x0301},
+		{ 0x1EAB, 0x00E2, 0x0303},
+		{ 0x1EA9, 0x00E2, 0x0309},
+		{ 0x01DF, 0x00E4, 0x0304},
+		{ 0x01FB, 0x00E5, 0x0301},
+		{ 0x01FD, 0x00E6, 0x0301},
+		{ 0x01E3, 0x00E6, 0x0304},
+		{ 0x1E09, 0x00E7, 0x0301},
+		{ 0x1EC1, 0x00EA, 0x0300},
+		{ 0x1EBF, 0x00EA, 0x0301},
+		{ 0x1EC5, 0x00EA, 0x0303},
+		{ 0x1EC3, 0x00EA, 0x0309},
+		{ 0x1E2F, 0x00EF, 0x0301},
+		{ 0x1ED3, 0x00F4, 0x0300},
+		{ 0x1ED1, 0x00F4, 0x0301},
+		{ 0x1ED7, 0x00F4, 0x0303},
+		{ 0x1ED5, 0x00F4, 0x0309},
+		{ 0x1E4D, 0x00F5, 0x0301},
+		{ 0x022D, 0x00F5, 0x0304},
+		{ 0x1E4F, 0x00F5, 0x0308},
+		{ 0x022B, 0x00F6, 0x0304},
+		{ 0x01FF, 0x00F8, 0x0301},
+		{ 0x01DC, 0x00FC, 0x0300},
+		{ 0x01D8, 0x00FC, 0x0301},
+		{ 0x01D6, 0x00FC, 0x0304},
+		{ 0x01DA, 0x00FC, 0x030C},
+		{ 0x1EB0, 0x0102, 0x0300},
+		{ 0x1EAE, 0x0102, 0x0301},
+		{ 0x1EB4, 0x0102, 0x0303},
+		{ 0x1EB2, 0x0102, 0x0309},
+		{ 0x1EB1, 0x0103, 0x0300},
+		{ 0x1EAF, 0x0103, 0x0301},
+		{ 0x1EB5, 0x0103, 0x0303},
+		{ 0x1EB3, 0x0103, 0x0309},
+		{ 0x1E14, 0x0112, 0x0300},
+		{ 0x1E16, 0x0112, 0x0301},
+		{ 0x1E15, 0x0113, 0x0300},
+		{ 0x1E17, 0x0113, 0x0301},
+		{ 0x1E50, 0x014C, 0x0300},
+		{ 0x1E52, 0x014C, 0x0301},
+		{ 0x1E51, 0x014D, 0x0300},
+		{ 0x1E53, 0x014D, 0x0301},
+		{ 0x1E64, 0x015A, 0x0307},
+		{ 0x1E65, 0x015B, 0x0307},
+		{ 0x1E66, 0x0160, 0x0307},
+		{ 0x1E67, 0x0161, 0x0307},
+		{ 0x1E78, 0x0168, 0x0301},
+		{ 0x1E79, 0x0169, 0x0301},
+		{ 0x1E7A, 0x016A, 0x0308},
+		{ 0x1E7B, 0x016B, 0x0308},
+		{ 0x1E9B, 0x017F, 0x0307},
+		{ 0x1EDC, 0x01A0, 0x0300},
+		{ 0x1EDA, 0x01A0, 0x0301},
+		{ 0x1EE0, 0x01A0, 0x0303},
+		{ 0x1EDE, 0x01A0, 0x0309},
+		{ 0x1EE2, 0x01A0, 0x0323},
+		{ 0x1EDD, 0x01A1, 0x0300},
+		{ 0x1EDB, 0x01A1, 0x0301},
+		{ 0x1EE1, 0x01A1, 0x0303},
+		{ 0x1EDF, 0x01A1, 0x0309},
+		{ 0x1EE3, 0x01A1, 0x0323},
+		{ 0x1EEA, 0x01AF, 0x0300},
+		{ 0x1EE8, 0x01AF, 0x0301},
+		{ 0x1EEE, 0x01AF, 0x0303},
+		{ 0x1EEC, 0x01AF, 0x0309},
+		{ 0x1EF0, 0x01AF, 0x0323},
+		{ 0x1EEB, 0x01B0, 0x0300},
+		{ 0x1EE9, 0x01B0, 0x0301},
+		{ 0x1EEF, 0x01B0, 0x0303},
+		{ 0x1EED, 0x01B0, 0x0309},
+		{ 0x1EF1, 0x01B0, 0x0323},
+		{ 0x01EE, 0x01B7, 0x030C},
+		{ 0x01EC, 0x01EA, 0x0304},
+		{ 0x01ED, 0x01EB, 0x0304},
+		{ 0x01E0, 0x0226, 0x0304},
+		{ 0x01E1, 0x0227, 0x0304},
+		{ 0x1E1C, 0x0228, 0x0306},
+		{ 0x1E1D, 0x0229, 0x0306},
+		{ 0x0230, 0x022E, 0x0304},
+		{ 0x0231, 0x022F, 0x0304},
+		{ 0x01EF, 0x0292, 0x030C},
+		{ 0x0344, 0x0308, 0x0301},
+		{ 0x1FBA, 0x0391, 0x0300},
+		{ 0x0386, 0x0391, 0x0301},
+		{ 0x1FB9, 0x0391, 0x0304},
+		{ 0x1FB8, 0x0391, 0x0306},
+		{ 0x1F08, 0x0391, 0x0313},
+		{ 0x1F09, 0x0391, 0x0314},
+		{ 0x1FBC, 0x0391, 0x0345},
+		{ 0x1FC8, 0x0395, 0x0300},
+		{ 0x0388, 0x0395, 0x0301},
+		{ 0x1F18, 0x0395, 0x0313},
+		{ 0x1F19, 0x0395, 0x0314},
+		{ 0x1FCA, 0x0397, 0x0300},
+		{ 0x0389, 0x0397, 0x0301},
+		{ 0x1F28, 0x0397, 0x0313},
+		{ 0x1F29, 0x0397, 0x0314},
+		{ 0x1FCC, 0x0397, 0x0345},
+		{ 0x1FDA, 0x0399, 0x0300},
+		{ 0x038A, 0x0399, 0x0301},
+		{ 0x1FD9, 0x0399, 0x0304},
+		{ 0x1FD8, 0x0399, 0x0306},
+		{ 0x03AA, 0x0399, 0x0308},
+		{ 0x1F38, 0x0399, 0x0313},
+		{ 0x1F39, 0x0399, 0x0314},
+		{ 0x1FF8, 0x039F, 0x0300},
+		{ 0x038C, 0x039F, 0x0301},
+		{ 0x1F48, 0x039F, 0x0313},
+		{ 0x1F49, 0x039F, 0x0314},
+		{ 0x1FEC, 0x03A1, 0x0314},
+		{ 0x1FEA, 0x03A5, 0x0300},
+		{ 0x038E, 0x03A5, 0x0301},
+		{ 0x1FE9, 0x03A5, 0x0304},
+		{ 0x1FE8, 0x03A5, 0x0306},
+		{ 0x03AB, 0x03A5, 0x0308},
+		{ 0x1F59, 0x03A5, 0x0314},
+		{ 0x1FFA, 0x03A9, 0x0300},
+		{ 0x038F, 0x03A9, 0x0301},
+		{ 0x1F68, 0x03A9, 0x0313},
+		{ 0x1F69, 0x03A9, 0x0314},
+		{ 0x1FFC, 0x03A9, 0x0345},
+		{ 0x1FB4, 0x03AC, 0x0345},
+		{ 0x1FC4, 0x03AE, 0x0345},
+		{ 0x1F70, 0x03B1, 0x0300},
+		{ 0x03AC, 0x03B1, 0x0301},
+		{ 0x1FB1, 0x03B1, 0x0304},
+		{ 0x1FB0, 0x03B1, 0x0306},
+		{ 0x1F00, 0x03B1, 0x0313},
+		{ 0x1F01, 0x03B1, 0x0314},
+		{ 0x1FB6, 0x03B1, 0x0342},
+		{ 0x1FB3, 0x03B1, 0x0345},
+		{ 0x1F72, 0x03B5, 0x0300},
+		{ 0x03AD, 0x03B5, 0x0301},
+		{ 0x1F10, 0x03B5, 0x0313},
+		{ 0x1F11, 0x03B5, 0x0314},
+		{ 0x1F74, 0x03B7, 0x0300},
+		{ 0x03AE, 0x03B7, 0x0301},
+		{ 0x1F20, 0x03B7, 0x0313},
+		{ 0x1F21, 0x03B7, 0x0314},
+		{ 0x1FC6, 0x03B7, 0x0342},
+		{ 0x1FC3, 0x03B7, 0x0345},
+		{ 0x1F76, 0x03B9, 0x0300},
+		{ 0x03AF, 0x03B9, 0x0301},
+		{ 0x1FD1, 0x03B9, 0x0304},
+		{ 0x1FD0, 0x03B9, 0x0306},
+		{ 0x03CA, 0x03B9, 0x0308},
+		{ 0x1F30, 0x03B9, 0x0313},
+		{ 0x1F31, 0x03B9, 0x0314},
+		{ 0x1FD6, 0x03B9, 0x0342},
+		{ 0x1F78, 0x03BF, 0x0300},
+		{ 0x03CC, 0x03BF, 0x0301},
+		{ 0x1F40, 0x03BF, 0x0313},
+		{ 0x1F41, 0x03BF, 0x0314},
+		{ 0x1FE4, 0x03C1, 0x0313},
+		{ 0x1FE5, 0x03C1, 0x0314},
+		{ 0x1F7A, 0x03C5, 0x0300},
+		{ 0x03CD, 0x03C5, 0x0301},
+		{ 0x1FE1, 0x03C5, 0x0304},
+		{ 0x1FE0, 0x03C5, 0x0306},
+		{ 0x03CB, 0x03C5, 0x0308},
+		{ 0x1F50, 0x03C5, 0x0313},
+		{ 0x1F51, 0x03C5, 0x0314},
+		{ 0x1FE6, 0x03C5, 0x0342},
+		{ 0x1F7C, 0x03C9, 0x0300},
+		{ 0x03CE, 0x03C9, 0x0301},
+		{ 0x1F60, 0x03C9, 0x0313},
+		{ 0x1F61, 0x03C9, 0x0314},
+		{ 0x1FF6, 0x03C9, 0x0342},
+		{ 0x1FF3, 0x03C9, 0x0345},
+		{ 0x1FD2, 0x03CA, 0x0300},
+		{ 0x0390, 0x03CA, 0x0301},
+		{ 0x1FD7, 0x03CA, 0x0342},
+		{ 0x1FE2, 0x03CB, 0x0300},
+		{ 0x03B0, 0x03CB, 0x0301},
+		{ 0x1FE7, 0x03CB, 0x0342},
+		{ 0x1FF4, 0x03CE, 0x0345},
+		{ 0x03D3, 0x03D2, 0x0301},
+		{ 0x03D4, 0x03D2, 0x0308},
+		{ 0x0407, 0x0406, 0x0308},
+		{ 0x04D0, 0x0410, 0x0306},
+		{ 0x04D2, 0x0410, 0x0308},
+		{ 0x0403, 0x0413, 0x0301},
+		{ 0x0400, 0x0415, 0x0300},
+		{ 0x04D6, 0x0415, 0x0306},
+		{ 0x0401, 0x0415, 0x0308},
+		{ 0x04C1, 0x0416, 0x0306},
+		{ 0x04DC, 0x0416, 0x0308},
+		{ 0x04DE, 0x0417, 0x0308},
+		{ 0x040D, 0x0418, 0x0300},
+		{ 0x04E2, 0x0418, 0x0304},
+		{ 0x0419, 0x0418, 0x0306},
+		{ 0x04E4, 0x0418, 0x0308},
+		{ 0x040C, 0x041A, 0x0301},
+		{ 0x04E6, 0x041E, 0x0308},
+		{ 0x04EE, 0x0423, 0x0304},
+		{ 0x040E, 0x0423, 0x0306},
+		{ 0x04F0, 0x0423, 0x0308},
+		{ 0x04F2, 0x0423, 0x030B},
+		{ 0x04F4, 0x0427, 0x0308},
+		{ 0x04F8, 0x042B, 0x0308},
+		{ 0x04EC, 0x042D, 0x0308},
+		{ 0x04D1, 0x0430, 0x0306},
+		{ 0x04D3, 0x0430, 0x0308},
+		{ 0x0453, 0x0433, 0x0301},
+		{ 0x0450, 0x0435, 0x0300},
+		{ 0x04D7, 0x0435, 0x0306},
+		{ 0x0451, 0x0435, 0x0308},
+		{ 0x04C2, 0x0436, 0x0306},
+		{ 0x04DD, 0x0436, 0x0308},
+		{ 0x04DF, 0x0437, 0x0308},
+		{ 0x045D, 0x0438, 0x0300},
+		{ 0x04E3, 0x0438, 0x0304},
+		{ 0x0439, 0x0438, 0x0306},
+		{ 0x04E5, 0x0438, 0x0308},
+		{ 0x045C, 0x043A, 0x0301},
+		{ 0x04E7, 0x043E, 0x0308},
+		{ 0x04EF, 0x0443, 0x0304},
+		{ 0x045E, 0x0443, 0x0306},
+		{ 0x04F1, 0x0443, 0x0308},
+		{ 0x04F3, 0x0443, 0x030B},
+		{ 0x04F5, 0x0447, 0x0308},
+		{ 0x04F9, 0x044B, 0x0308},
+		{ 0x04ED, 0x044D, 0x0308},
+		{ 0x0457, 0x0456, 0x0308},
+		{ 0x0476, 0x0474, 0x030F},
+		{ 0x0477, 0x0475, 0x030F},
+		{ 0x04DA, 0x04D8, 0x0308},
+		{ 0x04DB, 0x04D9, 0x0308},
+		{ 0x04EA, 0x04E8, 0x0308},
+		{ 0x04EB, 0x04E9, 0x0308},
+		{ 0xFB2E, 0x05D0, 0x05B7},
+		{ 0xFB2F, 0x05D0, 0x05B8},
+		{ 0xFB30, 0x05D0, 0x05BC},
+		{ 0xFB31, 0x05D1, 0x05BC},
+		{ 0xFB4C, 0x05D1, 0x05BF},
+		{ 0xFB32, 0x05D2, 0x05BC},
+		{ 0xFB33, 0x05D3, 0x05BC},
+		{ 0xFB34, 0x05D4, 0x05BC},
+		{ 0xFB4B, 0x05D5, 0x05B9},
+		{ 0xFB35, 0x05D5, 0x05BC},
+		{ 0xFB36, 0x05D6, 0x05BC},
+		{ 0xFB38, 0x05D8, 0x05BC},
+		{ 0xFB1D, 0x05D9, 0x05B4},
+		{ 0xFB39, 0x05D9, 0x05BC},
+		{ 0xFB3A, 0x05DA, 0x05BC},
+		{ 0xFB3B, 0x05DB, 0x05BC},
+		{ 0xFB4D, 0x05DB, 0x05BF},
+		{ 0xFB3C, 0x05DC, 0x05BC},
+		{ 0xFB3E, 0x05DE, 0x05BC},
+		{ 0xFB40, 0x05E0, 0x05BC},
+		{ 0xFB41, 0x05E1, 0x05BC},
+		{ 0xFB43, 0x05E3, 0x05BC},
+		{ 0xFB44, 0x05E4, 0x05BC},
+		{ 0xFB4E, 0x05E4, 0x05BF},
+		{ 0xFB46, 0x05E6, 0x05BC},
+		{ 0xFB47, 0x05E7, 0x05BC},
+		{ 0xFB48, 0x05E8, 0x05BC},
+		{ 0xFB49, 0x05E9, 0x05BC},
+		{ 0xFB2A, 0x05E9, 0x05C1},
+		{ 0xFB2B, 0x05E9, 0x05C2},
+		{ 0xFB4A, 0x05EA, 0x05BC},
+		{ 0xFB1F, 0x05F2, 0x05B7},
+		{ 0x0622, 0x0627, 0x0653},
+		{ 0x0623, 0x0627, 0x0654},
+		{ 0x0625, 0x0627, 0x0655},
+		{ 0x0624, 0x0648, 0x0654},
+		{ 0x0626, 0x064A, 0x0654},
+		{ 0x06C2, 0x06C1, 0x0654},
+		{ 0x06D3, 0x06D2, 0x0654},
+		{ 0x06C0, 0x06D5, 0x0654},
+		{ 0x0958, 0x0915, 0x093C},
+		{ 0x0959, 0x0916, 0x093C},
+		{ 0x095A, 0x0917, 0x093C},
+		{ 0x095B, 0x091C, 0x093C},
+		{ 0x095C, 0x0921, 0x093C},
+		{ 0x095D, 0x0922, 0x093C},
+		{ 0x0929, 0x0928, 0x093C},
+		{ 0x095E, 0x092B, 0x093C},
+		{ 0x095F, 0x092F, 0x093C},
+		{ 0x0931, 0x0930, 0x093C},
+		{ 0x0934, 0x0933, 0x093C},
+		{ 0x09DC, 0x09A1, 0x09BC},
+		{ 0x09DD, 0x09A2, 0x09BC},
+		{ 0x09DF, 0x09AF, 0x09BC},
+		{ 0x09CB, 0x09C7, 0x09BE},
+		{ 0x09CC, 0x09C7, 0x09D7},
+		{ 0x0A59, 0x0A16, 0x0A3C},
+		{ 0x0A5A, 0x0A17, 0x0A3C},
+		{ 0x0A5B, 0x0A1C, 0x0A3C},
+		{ 0x0A5E, 0x0A2B, 0x0A3C},
+		{ 0x0A33, 0x0A32, 0x0A3C},
+		{ 0x0A36, 0x0A38, 0x0A3C},
+		{ 0x0B5C, 0x0B21, 0x0B3C},
+		{ 0x0B5D, 0x0B22, 0x0B3C},
+		{ 0x0B4B, 0x0B47, 0x0B3E},
+		{ 0x0B48, 0x0B47, 0x0B56},
+		{ 0x0B4C, 0x0B47, 0x0B57},
+		{ 0x0B94, 0x0B92, 0x0BD7},
+		{ 0x0BCA, 0x0BC6, 0x0BBE},
+		{ 0x0BCC, 0x0BC6, 0x0BD7},
+		{ 0x0BCB, 0x0BC7, 0x0BBE},
+		{ 0x0C48, 0x0C46, 0x0C56},
+		{ 0x0CC0, 0x0CBF, 0x0CD5},
+		{ 0x0CCA, 0x0CC6, 0x0CC2},
+		{ 0x0CC7, 0x0CC6, 0x0CD5},
+		{ 0x0CC8, 0x0CC6, 0x0CD6},
+		{ 0x0CCB, 0x0CCA, 0x0CD5},
+		{ 0x0D4A, 0x0D46, 0x0D3E},
+		{ 0x0D4C, 0x0D46, 0x0D57},
+		{ 0x0D4B, 0x0D47, 0x0D3E},
+		{ 0x0DDA, 0x0DD9, 0x0DCA},
+		{ 0x0DDC, 0x0DD9, 0x0DCF},
+		{ 0x0DDE, 0x0DD9, 0x0DDF},
+		{ 0x0DDD, 0x0DDC, 0x0DCA},
+		{ 0x0F69, 0x0F40, 0x0FB5},
+		{ 0x0F43, 0x0F42, 0x0FB7},
+		{ 0x0F4D, 0x0F4C, 0x0FB7},
+		{ 0x0F52, 0x0F51, 0x0FB7},
+		{ 0x0F57, 0x0F56, 0x0FB7},
+		{ 0x0F5C, 0x0F5B, 0x0FB7},
+		{ 0x0F73, 0x0F71, 0x0F72},
+		{ 0x0F75, 0x0F71, 0x0F74},
+		{ 0x0F81, 0x0F71, 0x0F80},
+		{ 0x0FB9, 0x0F90, 0x0FB5},
+		{ 0x0F93, 0x0F92, 0x0FB7},
+		{ 0x0F9D, 0x0F9C, 0x0FB7},
+		{ 0x0FA2, 0x0FA1, 0x0FB7},
+		{ 0x0FA7, 0x0FA6, 0x0FB7},
+		{ 0x0FAC, 0x0FAB, 0x0FB7},
+		{ 0x0F76, 0x0FB2, 0x0F80},
+		{ 0x0F78, 0x0FB3, 0x0F80},
+		{ 0x1026, 0x1025, 0x102E},
+		{ 0x1B06, 0x1B05, 0x1B35},
+		{ 0x1B08, 0x1B07, 0x1B35},
+		{ 0x1B0A, 0x1B09, 0x1B35},
+		{ 0x1B0C, 0x1B0B, 0x1B35},
+		{ 0x1B0E, 0x1B0D, 0x1B35},
+		{ 0x1B12, 0x1B11, 0x1B35},
+		{ 0x1B3B, 0x1B3A, 0x1B35},
+		{ 0x1B3D, 0x1B3C, 0x1B35},
+		{ 0x1B40, 0x1B3E, 0x1B35},
+		{ 0x1B41, 0x1B3F, 0x1B35},
+		{ 0x1B43, 0x1B42, 0x1B35},
+		{ 0x1E38, 0x1E36, 0x0304},
+		{ 0x1E39, 0x1E37, 0x0304},
+		{ 0x1E5C, 0x1E5A, 0x0304},
+		{ 0x1E5D, 0x1E5B, 0x0304},
+		{ 0x1E68, 0x1E62, 0x0307},
+		{ 0x1E69, 0x1E63, 0x0307},
+		{ 0x1EAC, 0x1EA0, 0x0302},
+		{ 0x1EB6, 0x1EA0, 0x0306},
+		{ 0x1EAD, 0x1EA1, 0x0302},
+		{ 0x1EB7, 0x1EA1, 0x0306},
+		{ 0x1EC6, 0x1EB8, 0x0302},
+		{ 0x1EC7, 0x1EB9, 0x0302},
+		{ 0x1ED8, 0x1ECC, 0x0302},
+		{ 0x1ED9, 0x1ECD, 0x0302},
+		{ 0x1F02, 0x1F00, 0x0300},
+		{ 0x1F04, 0x1F00, 0x0301},
+		{ 0x1F06, 0x1F00, 0x0342},
+		{ 0x1F80, 0x1F00, 0x0345},
+		{ 0x1F03, 0x1F01, 0x0300},
+		{ 0x1F05, 0x1F01, 0x0301},
+		{ 0x1F07, 0x1F01, 0x0342},
+		{ 0x1F81, 0x1F01, 0x0345},
+		{ 0x1F82, 0x1F02, 0x0345},
+		{ 0x1F83, 0x1F03, 0x0345},
+		{ 0x1F84, 0x1F04, 0x0345},
+		{ 0x1F85, 0x1F05, 0x0345},
+		{ 0x1F86, 0x1F06, 0x0345},
+		{ 0x1F87, 0x1F07, 0x0345},
+		{ 0x1F0A, 0x1F08, 0x0300},
+		{ 0x1F0C, 0x1F08, 0x0301},
+		{ 0x1F0E, 0x1F08, 0x0342},
+		{ 0x1F88, 0x1F08, 0x0345},
+		{ 0x1F0B, 0x1F09, 0x0300},
+		{ 0x1F0D, 0x1F09, 0x0301},
+		{ 0x1F0F, 0x1F09, 0x0342},
+		{ 0x1F89, 0x1F09, 0x0345},
+		{ 0x1F8A, 0x1F0A, 0x0345},
+		{ 0x1F8B, 0x1F0B, 0x0345},
+		{ 0x1F8C, 0x1F0C, 0x0345},
+		{ 0x1F8D, 0x1F0D, 0x0345},
+		{ 0x1F8E, 0x1F0E, 0x0345},
+		{ 0x1F8F, 0x1F0F, 0x0345},
+		{ 0x1F12, 0x1F10, 0x0300},
+		{ 0x1F14, 0x1F10, 0x0301},
+		{ 0x1F13, 0x1F11, 0x0300},
+		{ 0x1F15, 0x1F11, 0x0301},
+		{ 0x1F1A, 0x1F18, 0x0300},
+		{ 0x1F1C, 0x1F18, 0x0301},
+		{ 0x1F1B, 0x1F19, 0x0300},
+		{ 0x1F1D, 0x1F19, 0x0301},
+		{ 0x1F22, 0x1F20, 0x0300},
+		{ 0x1F24, 0x1F20, 0x0301},
+		{ 0x1F26, 0x1F20, 0x0342},
+		{ 0x1F90, 0x1F20, 0x0345},
+		{ 0x1F23, 0x1F21, 0x0300},
+		{ 0x1F25, 0x1F21, 0x0301},
+		{ 0x1F27, 0x1F21, 0x0342},
+		{ 0x1F91, 0x1F21, 0x0345},
+		{ 0x1F92, 0x1F22, 0x0345},
+		{ 0x1F93, 0x1F23, 0x0345},
+		{ 0x1F94, 0x1F24, 0x0345},
+		{ 0x1F95, 0x1F25, 0x0345},
+		{ 0x1F96, 0x1F26, 0x0345},
+		{ 0x1F97, 0x1F27, 0x0345},
+		{ 0x1F2A, 0x1F28, 0x0300},
+		{ 0x1F2C, 0x1F28, 0x0301},
+		{ 0x1F2E, 0x1F28, 0x0342},
+		{ 0x1F98, 0x1F28, 0x0345},
+		{ 0x1F2B, 0x1F29, 0x0300},
+		{ 0x1F2D, 0x1F29, 0x0301},
+		{ 0x1F2F, 0x1F29, 0x0342},
+		{ 0x1F99, 0x1F29, 0x0345},
+		{ 0x1F9A, 0x1F2A, 0x0345},
+		{ 0x1F9B, 0x1F2B, 0x0345},
+		{ 0x1F9C, 0x1F2C, 0x0345},
+		{ 0x1F9D, 0x1F2D, 0x0345},
+		{ 0x1F9E, 0x1F2E, 0x0345},
+		{ 0x1F9F, 0x1F2F, 0x0345},
+		{ 0x1F32, 0x1F30, 0x0300},
+		{ 0x1F34, 0x1F30, 0x0301},
+		{ 0x1F36, 0x1F30, 0x0342},
+		{ 0x1F33, 0x1F31, 0x0300},
+		{ 0x1F35, 0x1F31, 0x0301},
+		{ 0x1F37, 0x1F31, 0x0342},
+		{ 0x1F3A, 0x1F38, 0x0300},
+		{ 0x1F3C, 0x1F38, 0x0301},
+		{ 0x1F3E, 0x1F38, 0x0342},
+		{ 0x1F3B, 0x1F39, 0x0300},
+		{ 0x1F3D, 0x1F39, 0x0301},
+		{ 0x1F3F, 0x1F39, 0x0342},
+		{ 0x1F42, 0x1F40, 0x0300},
+		{ 0x1F44, 0x1F40, 0x0301},
+		{ 0x1F43, 0x1F41, 0x0300},
+		{ 0x1F45, 0x1F41, 0x0301},
+		{ 0x1F4A, 0x1F48, 0x0300},
+		{ 0x1F4C, 0x1F48, 0x0301},
+		{ 0x1F4B, 0x1F49, 0x0300},
+		{ 0x1F4D, 0x1F49, 0x0301},
+		{ 0x1F52, 0x1F50, 0x0300},
+		{ 0x1F54, 0x1F50, 0x0301},
+		{ 0x1F56, 0x1F50, 0x0342},
+		{ 0x1F53, 0x1F51, 0x0300},
+		{ 0x1F55, 0x1F51, 0x0301},
+		{ 0x1F57, 0x1F51, 0x0342},
+		{ 0x1F5B, 0x1F59, 0x0300},
+		{ 0x1F5D, 0x1F59, 0x0301},
+		{ 0x1F5F, 0x1F59, 0x0342},
+		{ 0x1F62, 0x1F60, 0x0300},
+		{ 0x1F64, 0x1F60, 0x0301},
+		{ 0x1F66, 0x1F60, 0x0342},
+		{ 0x1FA0, 0x1F60, 0x0345},
+		{ 0x1F63, 0x1F61, 0x0300},
+		{ 0x1F65, 0x1F61, 0x0301},
+		{ 0x1F67, 0x1F61, 0x0342},
+		{ 0x1FA1, 0x1F61, 0x0345},
+		{ 0x1FA2, 0x1F62, 0x0345},
+		{ 0x1FA3, 0x1F63, 0x0345},
+		{ 0x1FA4, 0x1F64, 0x0345},
+		{ 0x1FA5, 0x1F65, 0x0345},
+		{ 0x1FA6, 0x1F66, 0x0345},
+		{ 0x1FA7, 0x1F67, 0x0345},
+		{ 0x1F6A, 0x1F68, 0x0300},
+		{ 0x1F6C, 0x1F68, 0x0301},
+		{ 0x1F6E, 0x1F68, 0x0342},
+		{ 0x1FA8, 0x1F68, 0x0345},
+		{ 0x1F6B, 0x1F69, 0x0300},
+		{ 0x1F6D, 0x1F69, 0x0301},
+		{ 0x1F6F, 0x1F69, 0x0342},
+		{ 0x1FA9, 0x1F69, 0x0345},
+		{ 0x1FAA, 0x1F6A, 0x0345},
+		{ 0x1FAB, 0x1F6B, 0x0345},
+		{ 0x1FAC, 0x1F6C, 0x0345},
+		{ 0x1FAD, 0x1F6D, 0x0345},
+		{ 0x1FAE, 0x1F6E, 0x0345},
+		{ 0x1FAF, 0x1F6F, 0x0345},
+		{ 0x1FB2, 0x1F70, 0x0345},
+		{ 0x1FC2, 0x1F74, 0x0345},
+		{ 0x1FF2, 0x1F7C, 0x0345},
+		{ 0x1FB7, 0x1FB6, 0x0345},
+		{ 0x1FCD, 0x1FBF, 0x0300},
+		{ 0x1FCE, 0x1FBF, 0x0301},
+		{ 0x1FCF, 0x1FBF, 0x0342},
+		{ 0x1FC7, 0x1FC6, 0x0345},
+		{ 0x1FF7, 0x1FF6, 0x0345},
+		{ 0x1FDD, 0x1FFE, 0x0300},
+		{ 0x1FDE, 0x1FFE, 0x0301},
+		{ 0x1FDF, 0x1FFE, 0x0342},
+		{ 0x219A, 0x2190, 0x0338},
+		{ 0x219B, 0x2192, 0x0338},
+		{ 0x21AE, 0x2194, 0x0338},
+		{ 0x21CD, 0x21D0, 0x0338},
+		{ 0x21CF, 0x21D2, 0x0338},
+		{ 0x21CE, 0x21D4, 0x0338},
+		{ 0x2204, 0x2203, 0x0338},
+		{ 0x2209, 0x2208, 0x0338},
+		{ 0x220C, 0x220B, 0x0338},
+		{ 0x2224, 0x2223, 0x0338},
+		{ 0x2226, 0x2225, 0x0338},
+		{ 0x2241, 0x223C, 0x0338},
+		{ 0x2244, 0x2243, 0x0338},
+		{ 0x2247, 0x2245, 0x0338},
+		{ 0x2249, 0x2248, 0x0338},
+		{ 0x226D, 0x224D, 0x0338},
+		{ 0x2262, 0x2261, 0x0338},
+		{ 0x2270, 0x2264, 0x0338},
+		{ 0x2271, 0x2265, 0x0338},
+		{ 0x2274, 0x2272, 0x0338},
+		{ 0x2275, 0x2273, 0x0338},
+		{ 0x2278, 0x2276, 0x0338},
+		{ 0x2279, 0x2277, 0x0338},
+		{ 0x2280, 0x227A, 0x0338},
+		{ 0x2281, 0x227B, 0x0338},
+		{ 0x22E0, 0x227C, 0x0338},
+		{ 0x22E1, 0x227D, 0x0338},
+		{ 0x2284, 0x2282, 0x0338},
+		{ 0x2285, 0x2283, 0x0338},
+		{ 0x2288, 0x2286, 0x0338},
+		{ 0x2289, 0x2287, 0x0338},
+		{ 0x22E2, 0x2291, 0x0338},
+		{ 0x22E3, 0x2292, 0x0338},
+		{ 0x22AC, 0x22A2, 0x0338},
+		{ 0x22AD, 0x22A8, 0x0338},
+		{ 0x22AE, 0x22A9, 0x0338},
+		{ 0x22AF, 0x22AB, 0x0338},
+		{ 0x22EA, 0x22B2, 0x0338},
+		{ 0x22EB, 0x22B3, 0x0338},
+		{ 0x22EC, 0x22B4, 0x0338},
+		{ 0x22ED, 0x22B5, 0x0338},
+		{ 0x2ADC, 0x2ADD, 0x0338},
+		{ 0x3094, 0x3046, 0x3099},
+		{ 0x304C, 0x304B, 0x3099},
+		{ 0x304E, 0x304D, 0x3099},
+		{ 0x3050, 0x304F, 0x3099},
+		{ 0x3052, 0x3051, 0x3099},
+		{ 0x3054, 0x3053, 0x3099},
+		{ 0x3056, 0x3055, 0x3099},
+		{ 0x3058, 0x3057, 0x3099},
+		{ 0x305A, 0x3059, 0x3099},
+		{ 0x305C, 0x305B, 0x3099},
+		{ 0x305E, 0x305D, 0x3099},
+		{ 0x3060, 0x305F, 0x3099},
+		{ 0x3062, 0x3061, 0x3099},
+		{ 0x3065, 0x3064, 0x3099},
+		{ 0x3067, 0x3066, 0x3099},
+		{ 0x3069, 0x3068, 0x3099},
+		{ 0x3070, 0x306F, 0x3099},
+		{ 0x3071, 0x306F, 0x309A},
+		{ 0x3073, 0x3072, 0x3099},
+		{ 0x3074, 0x3072, 0x309A},
+		{ 0x3076, 0x3075, 0x3099},
+		{ 0x3077, 0x3075, 0x309A},
+		{ 0x3079, 0x3078, 0x3099},
+		{ 0x307A, 0x3078, 0x309A},
+		{ 0x307C, 0x307B, 0x3099},
+		{ 0x307D, 0x307B, 0x309A},
+		{ 0x309E, 0x309D, 0x3099},
+		{ 0x30F4, 0x30A6, 0x3099},
+		{ 0x30AC, 0x30AB, 0x3099},
+		{ 0x30AE, 0x30AD, 0x3099},
+		{ 0x30B0, 0x30AF, 0x3099},
+		{ 0x30B2, 0x30B1, 0x3099},
+		{ 0x30B4, 0x30B3, 0x3099},
+		{ 0x30B6, 0x30B5, 0x3099},
+		{ 0x30B8, 0x30B7, 0x3099},
+		{ 0x30BA, 0x30B9, 0x3099},
+		{ 0x30BC, 0x30BB, 0x3099},
+		{ 0x30BE, 0x30BD, 0x3099},
+		{ 0x30C0, 0x30BF, 0x3099},
+		{ 0x30C2, 0x30C1, 0x3099},
+		{ 0x30C5, 0x30C4, 0x3099},
+		{ 0x30C7, 0x30C6, 0x3099},
+		{ 0x30C9, 0x30C8, 0x3099},
+		{ 0x30D0, 0x30CF, 0x3099},
+		{ 0x30D1, 0x30CF, 0x309A},
+		{ 0x30D3, 0x30D2, 0x3099},
+		{ 0x30D4, 0x30D2, 0x309A},
+		{ 0x30D6, 0x30D5, 0x3099},
+		{ 0x30D7, 0x30D5, 0x309A},
+		{ 0x30D9, 0x30D8, 0x3099},
+		{ 0x30DA, 0x30D8, 0x309A},
+		{ 0x30DC, 0x30DB, 0x3099},
+		{ 0x30DD, 0x30DB, 0x309A},
+		{ 0x30F7, 0x30EF, 0x3099},
+		{ 0x30F8, 0x30F0, 0x3099},
+		{ 0x30F9, 0x30F1, 0x3099},
+		{ 0x30FA, 0x30F2, 0x3099},
+		{ 0x30FE, 0x30FD, 0x3099},
+		{ 0xFB2C, 0xFB49, 0x05C1},
+		{ 0xFB2D, 0xFB49, 0x05C2},
+	};
+
+	private static final int UNICODE_SHIFT = 21;
+
+	public static char precompose(char base, char comb) {
+		int min = 0;
+		int max = precompositions.length - 1;
+		int mid;
+
+		long sought = base << UNICODE_SHIFT | comb;
+		long that;
+
+		while (max >= min) {
+			mid = (min + max) / 2;
+			that = precompositions[mid][1] << UNICODE_SHIFT | precompositions[mid][2];
+			if (that < sought)
+				min = mid + 1;
+			else if (that > sought)
+				max = mid - 1;
+			else
+				return precompositions[mid][0];
+		}
+
+		// No match; return character without combiner
+		return base;
+	}
+}
diff --git a/ScriptingLayerForAndroid/src/de/mud/terminal/VDUBuffer.java b/ScriptingLayerForAndroid/src/de/mud/terminal/VDUBuffer.java
new file mode 100644
index 0000000..58cf20b
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/de/mud/terminal/VDUBuffer.java
@@ -0,0 +1,931 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Mei�ner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+import java.util.Arrays;
+
+/**
+ * Implementation of a Video Display Unit (VDU) buffer. This class contains all methods to
+ * manipulate the buffer that stores characters and their attributes as well as the regions
+ * displayed.
+ *
+ * @author Matthias L. Jugel, Marcus Meißner
+ * @version $Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $
+ */
+public class VDUBuffer {
+
+  /** The current version id tag */
+  public final static String ID = "$Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $";
+
+  /** Enable debug messages. */
+  public final static int debug = 0;
+
+  public int height, width; /* rows and columns */
+  public boolean[] update; /* contains the lines that need update */
+  public char[][] charArray; /* contains the characters */
+  public int[][] charAttributes; /* contains character attrs */
+  public int bufSize;
+  public int maxBufSize; /* buffer sizes */
+  public int screenBase; /* the actual screen start */
+  public int windowBase; /* where the start displaying */
+  public int scrollMarker; /* marks the last line inserted */
+
+  private int topMargin; /* top scroll margin */
+  private int bottomMargin; /* bottom scroll margin */
+
+  // cursor variables
+  protected boolean showcursor = true;
+  protected int cursorX, cursorY;
+
+  /** Scroll up when inserting a line. */
+  public final static boolean SCROLL_UP = false;
+  /** Scroll down when inserting a line. */
+  public final static boolean SCROLL_DOWN = true;
+
+  /*
+   * Attributes bit-field usage:
+   *
+   * 8421 8421 8421 8421 8421 8421 8421 8421 |||| |||| |||| |||| |||| |||| |||| |||`- Bold |||| ||||
+   * |||| |||| |||| |||| |||| ||`-- Underline |||| |||| |||| |||| |||| |||| |||| |`--- Invert ||||
+   * |||| |||| |||| |||| |||| |||| `---- Low |||| |||| |||| |||| |||| |||| |||`------ Invisible ||||
+   * |||| |||| |||| ||`+-++++-+++------- Foreground Color |||| |||| |`++-++++-++------------------
+   * Background Color |||| |||| `----------------------------- Fullwidth character
+   * `+++-++++------------------------------- Reserved for future use
+   */
+
+  /** Make character normal. */
+  public final static int NORMAL = 0x00;
+  /** Make character bold. */
+  public final static int BOLD = 0x01;
+  /** Underline character. */
+  public final static int UNDERLINE = 0x02;
+  /** Invert character. */
+  public final static int INVERT = 0x04;
+  /** Lower intensity character. */
+  public final static int LOW = 0x08;
+  /** Invisible character. */
+  public final static int INVISIBLE = 0x10;
+  /** Unicode full-width character (CJK, et al.) */
+  public final static int FULLWIDTH = 0x8000000;
+
+  /** how much to left shift the foreground color */
+  public final static int COLOR_FG_SHIFT = 5;
+  /** how much to left shift the background color */
+  public final static int COLOR_BG_SHIFT = 14;
+  /** color mask */
+  public final static int COLOR = 0x7fffe0; /* 0000 0000 0111 1111 1111 1111 1110 0000 */
+  /** foreground color mask */
+  public final static int COLOR_FG = 0x3fe0; /* 0000 0000 0000 0000 0011 1111 1110 0000 */
+  /** background color mask */
+  public final static int COLOR_BG = 0x7fc000; /* 0000 0000 0111 1111 1100 0000 0000 0000 */
+
+  /**
+   * Create a new video display buffer with the passed width and height in characters.
+   *
+   * @param width
+   *          the length of the character lines
+   * @param height
+   *          the amount of lines on the screen
+   */
+  public VDUBuffer(int width, int height) {
+    // set the display screen size
+    setScreenSize(width, height, false);
+  }
+
+  /**
+   * Create a standard video display buffer with 80 columns and 24 lines.
+   */
+  public VDUBuffer() {
+    this(80, 24);
+  }
+
+  /**
+   * Put a character on the screen with normal font and outline. The character previously on that
+   * position will be overwritten. You need to call redraw() to update the screen.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @param ch
+   *          the character to show on the screen
+   * @see #insertChar
+   * @see #deleteChar
+   * @see #redraw
+   */
+  public void putChar(int c, int l, char ch) {
+    putChar(c, l, ch, NORMAL);
+  }
+
+  /**
+   * Put a character on the screen with specific font and outline. The character previously on that
+   * position will be overwritten. You need to call redraw() to update the screen.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @param ch
+   *          the character to show on the screen
+   * @param attributes
+   *          the character attributes
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #insertChar
+   * @see #deleteChar
+   * @see #redraw
+   */
+
+  public void putChar(int c, int l, char ch, int attributes) {
+    charArray[screenBase + l][c] = ch;
+    charAttributes[screenBase + l][c] = attributes;
+    if (l < height) {
+      update[l + 1] = true;
+    }
+  }
+
+  /**
+   * Get the character at the specified position.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @see #putChar
+   */
+  public char getChar(int c, int l) {
+    return charArray[screenBase + l][c];
+  }
+
+  /**
+   * Get the attributes for the specified position.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @see #putChar
+   */
+  public int getAttributes(int c, int l) {
+    return charAttributes[screenBase + l][c];
+  }
+
+  /**
+   * Insert a character at a specific position on the screen. All character right to from this
+   * position will be moved one to the right. You need to call redraw() to update the screen.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @param ch
+   *          the character to insert
+   * @param attributes
+   *          the character attributes
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #putChar
+   * @see #deleteChar
+   * @see #redraw
+   */
+  public void insertChar(int c, int l, char ch, int attributes) {
+    System.arraycopy(charArray[screenBase + l], c, charArray[screenBase + l], c + 1, width - c - 1);
+    System.arraycopy(charAttributes[screenBase + l], c, charAttributes[screenBase + l], c + 1,
+        width - c - 1);
+    putChar(c, l, ch, attributes);
+  }
+
+  /**
+   * Delete a character at a given position on the screen. All characters right to the position will
+   * be moved one to the left. You need to call redraw() to update the screen.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @see #putChar
+   * @see #insertChar
+   * @see #redraw
+   */
+  public void deleteChar(int c, int l) {
+    if (c < width - 1) {
+      System.arraycopy(charArray[screenBase + l], c + 1, charArray[screenBase + l], c, width - c
+          - 1);
+      System.arraycopy(charAttributes[screenBase + l], c + 1, charAttributes[screenBase + l], c,
+          width - c - 1);
+    }
+    putChar(width - 1, l, (char) 0);
+  }
+
+  /**
+   * Put a String at a specific position. Any characters previously on that position will be
+   * overwritten. You need to call redraw() for screen update.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @param s
+   *          the string to be shown on the screen
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #putChar
+   * @see #insertLine
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void putString(int c, int l, String s) {
+    putString(c, l, s, NORMAL);
+  }
+
+  /**
+   * Put a String at a specific position giving all characters the same attributes. Any characters
+   * previously on that position will be overwritten. You need to call redraw() to update the
+   * screen.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (line)
+   * @param s
+   *          the string to be shown on the screen
+   * @param attributes
+   *          character attributes
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #putChar
+   * @see #insertLine
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void putString(int c, int l, String s, int attributes) {
+    for (int i = 0; i < s.length() && c + i < width; i++) {
+      putChar(c + i, l, s.charAt(i), attributes);
+    }
+  }
+
+  /**
+   * Insert a blank line at a specific position. The current line and all previous lines are
+   * scrolled one line up. The top line is lost. You need to call redraw() to update the screen.
+   *
+   * @param l
+   *          the y-coordinate to insert the line
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void insertLine(int l) {
+    insertLine(l, 1, SCROLL_UP);
+  }
+
+  /**
+   * Insert blank lines at a specific position. You need to call redraw() to update the screen
+   *
+   * @param l
+   *          the y-coordinate to insert the line
+   * @param n
+   *          amount of lines to be inserted
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void insertLine(int l, int n) {
+    insertLine(l, n, SCROLL_UP);
+  }
+
+  /**
+   * Insert a blank line at a specific position. Scroll text according to the argument. You need to
+   * call redraw() to update the screen
+   *
+   * @param l
+   *          the y-coordinate to insert the line
+   * @param scrollDown
+   *          scroll down
+   * @see #deleteLine
+   * @see #SCROLL_UP
+   * @see #SCROLL_DOWN
+   * @see #redraw
+   */
+  public void insertLine(int l, boolean scrollDown) {
+    insertLine(l, 1, scrollDown);
+  }
+
+  /**
+   * Insert blank lines at a specific position. The current line and all previous lines are scrolled
+   * one line up. The top line is lost. You need to call redraw() to update the screen.
+   *
+   * @param l
+   *          the y-coordinate to insert the line
+   * @param n
+   *          number of lines to be inserted
+   * @param scrollDown
+   *          scroll down
+   * @see #deleteLine
+   * @see #SCROLL_UP
+   * @see #SCROLL_DOWN
+   * @see #redraw
+   */
+  public synchronized void insertLine(int l, int n, boolean scrollDown) {
+    char cbuf[][] = null;
+    int abuf[][] = null;
+    int offset = 0;
+    int oldBase = screenBase;
+
+    int newScreenBase = screenBase;
+    int newWindowBase = windowBase;
+    int newBufSize = bufSize;
+
+    if (l > bottomMargin) {
+      return;
+    }
+    int top =
+        (l < topMargin ? 0 : (l > bottomMargin ? (bottomMargin + 1 < height ? bottomMargin + 1
+            : height - 1) : topMargin));
+    int bottom =
+        (l > bottomMargin ? height - 1 : (l < topMargin ? (topMargin > 0 ? topMargin - 1 : 0)
+            : bottomMargin));
+
+    // System.out.println("l is "+l+", top is "+top+", bottom is "+bottom+", bottomargin is "+bottomMargin+", topMargin is "+topMargin);
+
+    if (scrollDown) {
+      if (n > (bottom - top)) {
+        n = (bottom - top);
+      }
+      int size = bottom - l - (n - 1);
+      if (size < 0) {
+        size = 0;
+      }
+      cbuf = new char[size][];
+      abuf = new int[size][];
+
+      System.arraycopy(charArray, oldBase + l, cbuf, 0, bottom - l - (n - 1));
+      System.arraycopy(charAttributes, oldBase + l, abuf, 0, bottom - l - (n - 1));
+      System.arraycopy(cbuf, 0, charArray, oldBase + l + n, bottom - l - (n - 1));
+      System.arraycopy(abuf, 0, charAttributes, oldBase + l + n, bottom - l - (n - 1));
+      cbuf = charArray;
+      abuf = charAttributes;
+    } else {
+      try {
+        if (n > (bottom - top) + 1) {
+          n = (bottom - top) + 1;
+        }
+        if (bufSize < maxBufSize) {
+          if (bufSize + n > maxBufSize) {
+            offset = n - (maxBufSize - bufSize);
+            scrollMarker += offset;
+            newBufSize = maxBufSize;
+            newScreenBase = maxBufSize - height - 1;
+            newWindowBase = screenBase;
+          } else {
+            scrollMarker += n;
+            newScreenBase += n;
+            newWindowBase += n;
+            newBufSize += n;
+          }
+
+          cbuf = new char[newBufSize][];
+          abuf = new int[newBufSize][];
+        } else {
+          offset = n;
+          cbuf = charArray;
+          abuf = charAttributes;
+        }
+        // copy anything from the top of the buffer (+offset) to the new top
+        // up to the screenBase.
+        if (oldBase > 0) {
+          System.arraycopy(charArray, offset, cbuf, 0, oldBase - offset);
+          System.arraycopy(charAttributes, offset, abuf, 0, oldBase - offset);
+        }
+        // copy anything from the top of the screen (screenBase) up to the
+        // topMargin to the new screen
+        if (top > 0) {
+          System.arraycopy(charArray, oldBase, cbuf, newScreenBase, top);
+          System.arraycopy(charAttributes, oldBase, abuf, newScreenBase, top);
+        }
+        // copy anything from the topMargin up to the amount of lines inserted
+        // to the gap left over between scrollback buffer and screenBase
+        if (oldBase >= 0) {
+          System.arraycopy(charArray, oldBase + top, cbuf, oldBase - offset, n);
+          System.arraycopy(charAttributes, oldBase + top, abuf, oldBase - offset, n);
+        }
+        // copy anything from topMargin + n up to the line linserted to the
+        // topMargin
+        System
+            .arraycopy(charArray, oldBase + top + n, cbuf, newScreenBase + top, l - top - (n - 1));
+        System.arraycopy(charAttributes, oldBase + top + n, abuf, newScreenBase + top, l - top
+            - (n - 1));
+        //
+        // copy the all lines next to the inserted to the new buffer
+        if (l < height - 1) {
+          System.arraycopy(charArray, oldBase + l + 1, cbuf, newScreenBase + l + 1, (height - 1)
+              - l);
+          System.arraycopy(charAttributes, oldBase + l + 1, abuf, newScreenBase + l + 1,
+              (height - 1) - l);
+        }
+      } catch (ArrayIndexOutOfBoundsException e) {
+        // this should not happen anymore, but I will leave the code
+        // here in case something happens anyway. That code above is
+        // so complex I always have a hard time understanding what
+        // I did, even though there are comments
+        System.err.println("*** Error while scrolling up:");
+        System.err.println("--- BEGIN STACK TRACE ---");
+        e.printStackTrace();
+        System.err.println("--- END STACK TRACE ---");
+        System.err.println("bufSize=" + bufSize + ", maxBufSize=" + maxBufSize);
+        System.err.println("top=" + top + ", bottom=" + bottom);
+        System.err.println("n=" + n + ", l=" + l);
+        System.err.println("screenBase=" + screenBase + ", windowBase=" + windowBase);
+        System.err.println("newScreenBase=" + newScreenBase + ", newWindowBase=" + newWindowBase);
+        System.err.println("oldBase=" + oldBase);
+        System.err.println("size.width=" + width + ", size.height=" + height);
+        System.err.println("abuf.length=" + abuf.length + ", cbuf.length=" + cbuf.length);
+        System.err.println("*** done dumping debug information");
+      }
+    }
+
+    // this is a little helper to mark the scrolling
+    scrollMarker -= n;
+
+    for (int i = 0; i < n; i++) {
+      cbuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new char[width];
+      Arrays.fill(cbuf[(newScreenBase + l) + (scrollDown ? i : -i)], ' ');
+      abuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new int[width];
+    }
+
+    charArray = cbuf;
+    charAttributes = abuf;
+    screenBase = newScreenBase;
+    windowBase = newWindowBase;
+    bufSize = newBufSize;
+
+    if (scrollDown) {
+      markLine(l, bottom - l + 1);
+    } else {
+      markLine(top, l - top + 1);
+    }
+
+    display.updateScrollBar();
+  }
+
+  /**
+   * Delete a line at a specific position. Subsequent lines will be scrolled up to fill the space
+   * and a blank line is inserted at the end of the screen.
+   *
+   * @param l
+   *          the y-coordinate to insert the line
+   * @see #deleteLine
+   */
+  public void deleteLine(int l) {
+    int bottom = (l > bottomMargin ? height - 1 : (l < topMargin ? topMargin : bottomMargin + 1));
+    int numRows = bottom - l - 1;
+
+    char[] discardedChars = charArray[screenBase + l];
+    int[] discardedAttributes = charAttributes[screenBase + l];
+
+    if (numRows > 0) {
+      System.arraycopy(charArray, screenBase + l + 1, charArray, screenBase + l, numRows);
+      System.arraycopy(charAttributes, screenBase + l + 1, charAttributes, screenBase + l, numRows);
+    }
+
+    int newBottomRow = screenBase + bottom - 1;
+    charArray[newBottomRow] = discardedChars;
+    charAttributes[newBottomRow] = discardedAttributes;
+    Arrays.fill(charArray[newBottomRow], ' ');
+    Arrays.fill(charAttributes[newBottomRow], 0);
+
+    markLine(l, bottom - l);
+  }
+
+  /**
+   * Delete a rectangular portion of the screen. You need to call redraw() to update the screen.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (row)
+   * @param w
+   *          with of the area in characters
+   * @param h
+   *          height of the area in characters
+   * @param curAttr
+   *          attribute to fill
+   * @see #deleteChar
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void deleteArea(int c, int l, int w, int h, int curAttr) {
+    int endColumn = c + w;
+    int targetRow = screenBase + l;
+    for (int i = 0; i < h && l + i < height; i++) {
+      Arrays.fill(charAttributes[targetRow], c, endColumn, curAttr);
+      Arrays.fill(charArray[targetRow], c, endColumn, ' ');
+      targetRow++;
+    }
+    markLine(l, h);
+  }
+
+  /**
+   * Delete a rectangular portion of the screen. You need to call redraw() to update the screen.
+   *
+   * @param c
+   *          x-coordinate (column)
+   * @param l
+   *          y-coordinate (row)
+   * @param w
+   *          with of the area in characters
+   * @param h
+   *          height of the area in characters
+   * @see #deleteChar
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void deleteArea(int c, int l, int w, int h) {
+    deleteArea(c, l, w, h, 0);
+  }
+
+  /**
+   * Sets whether the cursor is visible or not.
+   *
+   * @param doshow
+   */
+  public void showCursor(boolean doshow) {
+    showcursor = doshow;
+  }
+
+  /**
+   * Check whether the cursor is currently visible.
+   *
+   * @return visibility
+   */
+  public boolean isCursorVisible() {
+    return showcursor;
+  }
+
+  /**
+   * Puts the cursor at the specified position.
+   *
+   * @param c
+   *          column
+   * @param l
+   *          line
+   */
+  public void setCursorPosition(int c, int l) {
+    cursorX = c;
+    cursorY = l;
+  }
+
+  /**
+   * Get the current column of the cursor position.
+   */
+  public int getCursorColumn() {
+    return cursorX;
+  }
+
+  /**
+   * Get the current line of the cursor position.
+   */
+  public int getCursorRow() {
+    return cursorY;
+  }
+
+  /**
+   * Set the current window base. This allows to view the scrollback buffer.
+   *
+   * @param line
+   *          the line where the screen window starts
+   * @see #setBufferSize
+   * @see #getBufferSize
+   */
+  public void setWindowBase(int line) {
+    if (line > screenBase) {
+      line = screenBase;
+    } else if (line < 0) {
+      line = 0;
+    }
+    windowBase = line;
+    update[0] = true;
+    redraw();
+  }
+
+  /**
+   * Get the current window base.
+   *
+   * @see #setWindowBase
+   */
+  public int getWindowBase() {
+    return windowBase;
+  }
+
+  /**
+   * Set the scroll margins simultaneously. If they're out of bounds, trim them.
+   *
+   * @param l1
+   *          line that is the top
+   * @param l2
+   *          line that is the bottom
+   */
+  public void setMargins(int l1, int l2) {
+    if (l1 > l2) {
+      return;
+    }
+
+    if (l1 < 0) {
+      l1 = 0;
+    }
+    if (l2 >= height) {
+      l2 = height - 1;
+    }
+
+    topMargin = l1;
+    bottomMargin = l2;
+  }
+
+  /**
+   * Set the top scroll margin for the screen. If the current bottom margin is smaller it will
+   * become the top margin and the line will become the bottom margin.
+   *
+   * @param l
+   *          line that is the margin
+   */
+  public void setTopMargin(int l) {
+    if (l > bottomMargin) {
+      topMargin = bottomMargin;
+      bottomMargin = l;
+    } else {
+      topMargin = l;
+    }
+    if (topMargin < 0) {
+      topMargin = 0;
+    }
+    if (bottomMargin >= height) {
+      bottomMargin = height - 1;
+    }
+  }
+
+  /**
+   * Get the top scroll margin.
+   */
+  public int getTopMargin() {
+    return topMargin;
+  }
+
+  /**
+   * Set the bottom scroll margin for the screen. If the current top margin is bigger it will become
+   * the bottom margin and the line will become the top margin.
+   *
+   * @param l
+   *          line that is the margin
+   */
+  public void setBottomMargin(int l) {
+    if (l < topMargin) {
+      bottomMargin = topMargin;
+      topMargin = l;
+    } else {
+      bottomMargin = l;
+    }
+    if (topMargin < 0) {
+      topMargin = 0;
+    }
+    if (bottomMargin >= height) {
+      bottomMargin = height - 1;
+    }
+  }
+
+  /**
+   * Get the bottom scroll margin.
+   */
+  public int getBottomMargin() {
+    return bottomMargin;
+  }
+
+  /**
+   * Set scrollback buffer size.
+   *
+   * @param amount
+   *          new size of the buffer
+   */
+  public void setBufferSize(int amount) {
+    if (amount < height) {
+      amount = height;
+    }
+    if (amount < maxBufSize) {
+      char cbuf[][] = new char[amount][width];
+      int abuf[][] = new int[amount][width];
+      int copyStart = bufSize - amount < 0 ? 0 : bufSize - amount;
+      int copyCount = bufSize - amount < 0 ? bufSize : amount;
+      if (charArray != null) {
+        System.arraycopy(charArray, copyStart, cbuf, 0, copyCount);
+      }
+      if (charAttributes != null) {
+        System.arraycopy(charAttributes, copyStart, abuf, 0, copyCount);
+      }
+      charArray = cbuf;
+      charAttributes = abuf;
+      bufSize = copyCount;
+      screenBase = bufSize - height;
+      windowBase = screenBase;
+    }
+    maxBufSize = amount;
+
+    update[0] = true;
+    redraw();
+  }
+
+  /**
+   * Retrieve current scrollback buffer size.
+   *
+   * @see #setBufferSize
+   */
+  public int getBufferSize() {
+    return bufSize;
+  }
+
+  /**
+   * Retrieve maximum buffer Size.
+   *
+   * @see #getBufferSize
+   */
+  public int getMaxBufferSize() {
+    return maxBufSize;
+  }
+
+  /**
+   * Change the size of the screen. This will include adjustment of the scrollback buffer.
+   *
+   * @param w
+   *          of the screen
+   * @param h
+   *          of the screen
+   */
+  @SuppressWarnings("unused")
+  public void setScreenSize(int w, int h, boolean broadcast) {
+    char cbuf[][];
+    int abuf[][];
+    int maxSize = bufSize;
+
+    if (w < 1 || h < 1) {
+      return;
+    }
+
+    if (debug > 0) {
+      System.err.println("VDU: screen size [" + w + "," + h + "]");
+    }
+
+    if (h > maxBufSize) {
+      maxBufSize = h;
+    }
+
+    if (h > bufSize) {
+      bufSize = h;
+      screenBase = 0;
+      windowBase = 0;
+    }
+
+    if (windowBase + h >= bufSize) {
+      windowBase = bufSize - h;
+    }
+
+    if (screenBase + h >= bufSize) {
+      screenBase = bufSize - h;
+    }
+
+    cbuf = new char[bufSize][w];
+    abuf = new int[bufSize][w];
+
+    for (int i = 0; i < bufSize; i++) {
+      Arrays.fill(cbuf[i], ' ');
+    }
+
+    if (bufSize < maxSize) {
+      maxSize = bufSize;
+    }
+
+    int rowLength;
+    if (charArray != null && charAttributes != null) {
+      for (int i = 0; i < maxSize && charArray[i] != null; i++) {
+        rowLength = charArray[i].length;
+        System.arraycopy(charArray[i], 0, cbuf[i], 0, w < rowLength ? w : rowLength);
+        System.arraycopy(charAttributes[i], 0, abuf[i], 0, w < rowLength ? w : rowLength);
+      }
+    }
+
+    int C = getCursorColumn();
+    if (C < 0) {
+      C = 0;
+    } else if (C >= width) {
+      C = width - 1;
+    }
+
+    int R = getCursorRow();
+    if (R < 0) {
+      R = 0;
+    } else if (R >= height) {
+      R = height - 1;
+    }
+
+    setCursorPosition(C, R);
+
+    charArray = cbuf;
+    charAttributes = abuf;
+    width = w;
+    height = h;
+    topMargin = 0;
+    bottomMargin = h - 1;
+    update = new boolean[h + 1];
+    update[0] = true;
+    /*
+     * FIXME: ??? if(resizeStrategy == RESIZE_FONT) setBounds(getBounds());
+     */
+  }
+
+  /**
+   * Get amount of rows on the screen.
+   */
+  public int getRows() {
+    return height;
+  }
+
+  /**
+   * Get amount of columns on the screen.
+   */
+  public int getColumns() {
+    return width;
+  }
+
+  /**
+   * Mark lines to be updated with redraw().
+   *
+   * @param l
+   *          starting line
+   * @param n
+   *          amount of lines to be updated
+   * @see #redraw
+   */
+  public void markLine(int l, int n) {
+    for (int i = 0; (i < n) && (l + i < height); i++) {
+      update[l + i + 1] = true;
+    }
+  }
+
+  // private static int checkBounds(int value, int lower, int upper) {
+  // if (value < lower)
+  // return lower;
+  // else if (value > upper)
+  // return upper;
+  // else
+  // return value;
+  // }
+
+  /** a generic display that should redraw on demand */
+  protected VDUDisplay display;
+
+  public void setDisplay(VDUDisplay display) {
+    this.display = display;
+  }
+
+  /**
+   * Trigger a redraw on the display.
+   */
+  protected void redraw() {
+    if (display != null) {
+      display.redraw();
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/de/mud/terminal/VDUDisplay.java b/ScriptingLayerForAndroid/src/de/mud/terminal/VDUDisplay.java
new file mode 100644
index 0000000..0fe06f3
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/de/mud/terminal/VDUDisplay.java
@@ -0,0 +1,40 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+/**
+ * Generic display
+ */
+public interface VDUDisplay {
+  public void redraw();
+  public void updateScrollBar();
+
+  public void setVDUBuffer(VDUBuffer buffer);
+  public VDUBuffer getVDUBuffer();
+
+  public void setColor(int index, int red, int green, int blue);
+  public void resetColors();
+}
diff --git a/ScriptingLayerForAndroid/src/de/mud/terminal/VDUInput.java b/ScriptingLayerForAndroid/src/de/mud/terminal/VDUInput.java
new file mode 100644
index 0000000..43c88de
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/de/mud/terminal/VDUInput.java
@@ -0,0 +1,90 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+package de.mud.terminal;
+
+import java.util.Properties;
+
+/**
+ * An interface for a terminal that accepts input from keyboard and mouse.
+ *
+ * @author Matthias L. Jugel, Marcus Meißner
+ * @version $Id: VDUInput.java 499 2005-09-29 08:24:54Z leo $
+ */
+public interface VDUInput {
+
+  public final static int KEY_CONTROL = 0x01;
+  public final static int KEY_SHIFT = 0x02;
+  public final static int KEY_ALT = 0x04;
+  public final static int KEY_ACTION = 0x08;
+
+
+
+  /**
+   * Direct access to writing data ...
+   * @param b
+   */
+  void write(byte b[]);
+
+  /**
+   * Terminal is mouse-aware and requires (x,y) coordinates of
+   * on the terminal (character coordinates) and the button clicked.
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  void mousePressed(int x, int y, int modifiers);
+
+  /**
+   * Terminal is mouse-aware and requires the coordinates and button
+   * of the release.
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  void mouseReleased(int x, int y, int modifiers);
+
+  /**
+   * Override the standard key codes used by the terminal emulation.
+   * @param codes a properties object containing key code definitions
+   */
+  void setKeyCodes(Properties codes);
+
+  /**
+   * main keytyping event handler...
+   * @param keyCode the key code
+   * @param keyChar the character represented by the key
+   * @param modifiers shift/alt/control modifiers
+   */
+  void keyPressed(int keyCode, char keyChar, int modifiers);
+
+  /**
+   * Handle key Typed events for the terminal, this will get
+   * all normal key types, but no shift/alt/control/numlock.
+   * @param keyCode the key code
+   * @param keyChar the character represented by the key
+   * @param modifiers shift/alt/control modifiers
+   */
+  void keyTyped(int keyCode, char keyChar, int modifiers);
+}
diff --git a/ScriptingLayerForAndroid/src/de/mud/terminal/vt320.java b/ScriptingLayerForAndroid/src/de/mud/terminal/vt320.java
new file mode 100644
index 0000000..b713228
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/de/mud/terminal/vt320.java
@@ -0,0 +1,3236 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meiner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+import java.util.Properties;
+
+/**
+ * Implementation of a VT terminal emulation plus ANSI compatible.
+ * <P>
+ * <B>Maintainer:</B> Marcus Meißner
+ *
+ * @version $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
+ * @author Matthias L. Jugel, Marcus Meißner
+ */
+@SuppressWarnings("unused")
+public abstract class vt320 extends VDUBuffer implements VDUInput {
+
+  /**
+   * The current version id tag.
+   * <P>
+   * $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
+   *
+   */
+  public final static String ID = "$Id: vt320.java 507 2005-10-25 10:14:52Z marcus $";
+
+  /** the debug level */
+  private final static int debug = 0;
+  private StringBuilder debugStr;
+
+  public abstract void debug(String notice);
+
+  /**
+   * Write an answer back to the remote host. This is needed to be able to send terminal answers
+   * requests like status and type information.
+   *
+   * @param b
+   *          the array of bytes to be sent
+   */
+  public abstract void write(byte[] b);
+
+  /**
+   * Write an answer back to the remote host. This is needed to be able to send terminal answers
+   * requests like status and type information.
+   *
+   * @param b
+   *          the array of bytes to be sent
+   */
+  public abstract void write(int b);
+
+  /**
+   * Play the beep sound ...
+   */
+  public void beep() { /* do nothing by default */
+  }
+
+  /**
+   * Convenience function for putString(char[], int, int)
+   */
+  public void putString(String s) {
+    int len = s.length();
+    char[] tmp = new char[len];
+    s.getChars(0, len, tmp, 0);
+    putString(tmp, null, 0, len);
+  }
+
+  /**
+   * Put string at current cursor position. Moves cursor according to the String. Does NOT wrap.
+   *
+   * @param s
+   *          character array
+   * @param start
+   *          place to start in array
+   * @param len
+   *          number of characters to process
+   */
+  public void putString(char[] s, byte[] fullwidths, int start, int len) {
+    if (len > 0) {
+      // markLine(R, 1);
+      int lastChar = -1;
+      char c;
+      boolean isWide = false;
+
+      for (int i = 0; i < len; i++) {
+        c = s[start + i];
+        // Shortcut for my favorite ASCII
+        if (c <= 0x7F) {
+          if (lastChar != -1) {
+            putChar((char) lastChar, isWide, false);
+          }
+          lastChar = c;
+          isWide = false;
+        } else if (!Character.isLowSurrogate(c) && !Character.isHighSurrogate(c)) {
+          if (Character.getType(c) == Character.NON_SPACING_MARK) {
+            if (lastChar != -1) {
+              char nc = Precomposer.precompose((char) lastChar, c);
+              putChar(nc, isWide, false);
+              lastChar = -1;
+            }
+          } else {
+            if (lastChar != -1) {
+              putChar((char) lastChar, isWide, false);
+            }
+            lastChar = c;
+            if (fullwidths != null) {
+              isWide = fullwidths[i] == 1;
+            }
+          }
+        }
+      }
+
+      if (lastChar != -1) {
+        putChar((char) lastChar, isWide, false);
+      }
+
+      setCursorPosition(C, R);
+      redraw();
+    }
+  }
+
+  protected void sendTelnetCommand(byte cmd) {
+
+  }
+
+  /**
+   * Sent the changed window size from the terminal to all listeners.
+   */
+  protected void setWindowSize(int c, int r) {
+    /* To be overridden by Terminal.java */
+  }
+
+  @Override
+  public void setScreenSize(int c, int r, boolean broadcast) {
+    // int oldrows = height;
+
+    if (debug > 2) {
+      if (debugStr == null) {
+        debugStr = new StringBuilder();
+      }
+
+      debugStr.append("setscreensize (").append(c).append(',').append(r).append(',')
+          .append(broadcast).append(')');
+      debug(debugStr.toString());
+      debugStr.setLength(0);
+    }
+
+    super.setScreenSize(c, r, false);
+
+    boolean cursorChanged = false;
+
+    // Don't let the cursor go off the screen.
+    if (C >= c) {
+      C = c - 1;
+      cursorChanged = true;
+    }
+
+    if (R >= r) {
+      R = r - 1;
+      cursorChanged = true;
+    }
+
+    if (cursorChanged) {
+      setCursorPosition(C, R);
+      redraw();
+    }
+
+    if (broadcast) {
+      setWindowSize(c, r); /* broadcast up */
+    }
+  }
+
+  /**
+   * Create a new vt320 terminal and intialize it with useful settings.
+   */
+  public vt320(int width, int height) {
+    super(width, height);
+
+    debugStr = new StringBuilder();
+
+    setVMS(false);
+    setIBMCharset(false);
+    setTerminalID("vt320");
+    setBufferSize(100);
+    // setBorder(2, false);
+
+    gx = new char[4];
+    reset();
+
+    /* top row of numpad */
+    PF1 = "\u001bOP";
+    PF2 = "\u001bOQ";
+    PF3 = "\u001bOR";
+    PF4 = "\u001bOS";
+
+    /* the 3x2 keyblock on PC keyboards */
+    Insert = new String[4];
+    Remove = new String[4];
+    KeyHome = new String[4];
+    KeyEnd = new String[4];
+    NextScn = new String[4];
+    PrevScn = new String[4];
+    Escape = new String[4];
+    BackSpace = new String[4];
+    TabKey = new String[4];
+    Insert[0] = Insert[1] = Insert[2] = Insert[3] = "\u001b[2~";
+    Remove[0] = Remove[1] = Remove[2] = Remove[3] = "\u001b[3~";
+    PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[5~";
+    NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[6~";
+    KeyHome[0] = KeyHome[1] = KeyHome[2] = KeyHome[3] = "\u001b[H";
+    KeyEnd[0] = KeyEnd[1] = KeyEnd[2] = KeyEnd[3] = "\u001b[F";
+    Escape[0] = Escape[1] = Escape[2] = Escape[3] = "\u001b";
+    if (vms) {
+      BackSpace[1] = "" + (char) 10; // VMS shift deletes word back
+      BackSpace[2] = "\u0018"; // VMS control deletes line back
+      BackSpace[0] = BackSpace[3] = "\u007f"; // VMS other is delete
+    } else {
+      // BackSpace[0] = BackSpace[1] = BackSpace[2] = BackSpace[3] = "\b";
+      // ConnectBot modifications.
+      BackSpace[0] = "\b";
+      BackSpace[1] = "\u007f";
+      BackSpace[2] = "\u001b[3~";
+      BackSpace[3] = "\u001b[2~";
+    }
+
+    /* some more VT100 keys */
+    Find = "\u001b[1~";
+    Select = "\u001b[4~";
+    Help = "\u001b[28~";
+    Do = "\u001b[29~";
+
+    FunctionKey = new String[21];
+    FunctionKey[0] = "";
+    FunctionKey[1] = PF1;
+    FunctionKey[2] = PF2;
+    FunctionKey[3] = PF3;
+    FunctionKey[4] = PF4;
+    /* following are defined differently for vt220 / vt132 ... */
+    FunctionKey[5] = "\u001b[15~";
+    FunctionKey[6] = "\u001b[17~";
+    FunctionKey[7] = "\u001b[18~";
+    FunctionKey[8] = "\u001b[19~";
+    FunctionKey[9] = "\u001b[20~";
+    FunctionKey[10] = "\u001b[21~";
+    FunctionKey[11] = "\u001b[23~";
+    FunctionKey[12] = "\u001b[24~";
+    FunctionKey[13] = "\u001b[25~";
+    FunctionKey[14] = "\u001b[26~";
+    FunctionKey[15] = Help;
+    FunctionKey[16] = Do;
+    FunctionKey[17] = "\u001b[31~";
+    FunctionKey[18] = "\u001b[32~";
+    FunctionKey[19] = "\u001b[33~";
+    FunctionKey[20] = "\u001b[34~";
+
+    FunctionKeyShift = new String[21];
+    FunctionKeyAlt = new String[21];
+    FunctionKeyCtrl = new String[21];
+
+    for (int i = 0; i < 20; i++) {
+      FunctionKeyShift[i] = "";
+      FunctionKeyAlt[i] = "";
+      FunctionKeyCtrl[i] = "";
+    }
+    FunctionKeyShift[15] = Find;
+    FunctionKeyShift[16] = Select;
+
+    TabKey[0] = "\u0009";
+    TabKey[1] = "\u001bOP\u0009";
+    TabKey[2] = TabKey[3] = "";
+
+    KeyUp = new String[4];
+    KeyUp[0] = "\u001b[A";
+    KeyDown = new String[4];
+    KeyDown[0] = "\u001b[B";
+    KeyRight = new String[4];
+    KeyRight[0] = "\u001b[C";
+    KeyLeft = new String[4];
+    KeyLeft[0] = "\u001b[D";
+    Numpad = new String[10];
+    Numpad[0] = "\u001bOp";
+    Numpad[1] = "\u001bOq";
+    Numpad[2] = "\u001bOr";
+    Numpad[3] = "\u001bOs";
+    Numpad[4] = "\u001bOt";
+    Numpad[5] = "\u001bOu";
+    Numpad[6] = "\u001bOv";
+    Numpad[7] = "\u001bOw";
+    Numpad[8] = "\u001bOx";
+    Numpad[9] = "\u001bOy";
+    KPMinus = PF4;
+    KPComma = "\u001bOl";
+    KPPeriod = "\u001bOn";
+    KPEnter = "\u001bOM";
+
+    NUMPlus = new String[4];
+    NUMPlus[0] = "+";
+    NUMDot = new String[4];
+    NUMDot[0] = ".";
+  }
+
+  public void setBackspace(int type) {
+    switch (type) {
+    case DELETE_IS_DEL:
+      BackSpace[0] = "\u007f";
+      BackSpace[1] = "\b";
+      break;
+    case DELETE_IS_BACKSPACE:
+      BackSpace[0] = "\b";
+      BackSpace[1] = "\u007f";
+      break;
+    }
+  }
+
+  /**
+   * Create a default vt320 terminal with 80 columns and 24 lines.
+   */
+  public vt320() {
+    this(80, 24);
+  }
+
+  /**
+   * Terminal is mouse-aware and requires (x,y) coordinates of on the terminal (character
+   * coordinates) and the button clicked.
+   *
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  public void mousePressed(int x, int y, int modifiers) {
+    if (mouserpt == 0) {
+      return;
+    }
+
+    int mods = modifiers;
+    mousebut = 3;
+    if ((mods & 16) == 16) {
+      mousebut = 0;
+    }
+    if ((mods & 8) == 8) {
+      mousebut = 1;
+    }
+    if ((mods & 4) == 4) {
+      mousebut = 2;
+    }
+
+    int mousecode;
+    if (mouserpt == 9) {
+      mousecode = 0x20 | mousebut;
+    } else {
+      mousecode = mousebut | 0x20 | ((mods & 7) << 2);
+    }
+
+    byte b[] = new byte[6];
+
+    b[0] = 27;
+    b[1] = (byte) '[';
+    b[2] = (byte) 'M';
+    b[3] = (byte) mousecode;
+    b[4] = (byte) (0x20 + x + 1);
+    b[5] = (byte) (0x20 + y + 1);
+
+    write(b); // FIXME: writeSpecial here
+  }
+
+  /**
+   * Terminal is mouse-aware and requires the coordinates and button of the release.
+   *
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  public void mouseReleased(int x, int y, int modifiers) {
+    if (mouserpt == 0) {
+      return;
+    }
+
+    /*
+     * problem is tht modifiers still have the released button set in them. int mods = modifiers;
+     * mousebut = 3; if ((mods & 16)==16) mousebut=0; if ((mods & 8)==8 ) mousebut=1; if ((mods &
+     * 4)==4 ) mousebut=2;
+     */
+
+    int mousecode;
+    if (mouserpt == 9) {
+      mousecode = 0x20 + mousebut; /* same as press? appears so. */
+    } else {
+      mousecode = '#';
+    }
+
+    byte b[] = new byte[6];
+    b[0] = 27;
+    b[1] = (byte) '[';
+    b[2] = (byte) 'M';
+    b[3] = (byte) mousecode;
+    b[4] = (byte) (0x20 + x + 1);
+    b[5] = (byte) (0x20 + y + 1);
+    write(b); // FIXME: writeSpecial here
+    mousebut = 0;
+  }
+
+  /** we should do localecho (passed from other modules). false is default */
+  private boolean localecho = false;
+
+  /**
+   * Enable or disable the local echo property of the terminal.
+   *
+   * @param echo
+   *          true if the terminal should echo locally
+   */
+  public void setLocalEcho(boolean echo) {
+    localecho = echo;
+  }
+
+  /**
+   * Enable the VMS mode of the terminal to handle some things differently for VMS hosts.
+   *
+   * @param vms
+   *          true for vms mode, false for normal mode
+   */
+  public void setVMS(boolean vms) {
+    this.vms = vms;
+  }
+
+  /**
+   * Enable the usage of the IBM character set used by some BBS's. Special graphical character are
+   * available in this mode.
+   *
+   * @param ibm
+   *          true to use the ibm character set
+   */
+  public void setIBMCharset(boolean ibm) {
+    useibmcharset = ibm;
+  }
+
+  /**
+   * Override the standard key codes used by the terminal emulation.
+   *
+   * @param codes
+   *          a properties object containing key code definitions
+   */
+  public void setKeyCodes(Properties codes) {
+    String res, prefixes[] = { "", "S", "C", "A" };
+    int i;
+
+    for (i = 0; i < 10; i++) {
+      res = codes.getProperty("NUMPAD" + i);
+      if (res != null) {
+        Numpad[i] = unEscape(res);
+      }
+    }
+    for (i = 1; i < 20; i++) {
+      res = codes.getProperty("F" + i);
+      if (res != null) {
+        FunctionKey[i] = unEscape(res);
+      }
+      res = codes.getProperty("SF" + i);
+      if (res != null) {
+        FunctionKeyShift[i] = unEscape(res);
+      }
+      res = codes.getProperty("CF" + i);
+      if (res != null) {
+        FunctionKeyCtrl[i] = unEscape(res);
+      }
+      res = codes.getProperty("AF" + i);
+      if (res != null) {
+        FunctionKeyAlt[i] = unEscape(res);
+      }
+    }
+    for (i = 0; i < 4; i++) {
+      res = codes.getProperty(prefixes[i] + "PGUP");
+      if (res != null) {
+        PrevScn[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "PGDOWN");
+      if (res != null) {
+        NextScn[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "END");
+      if (res != null) {
+        KeyEnd[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "HOME");
+      if (res != null) {
+        KeyHome[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "INSERT");
+      if (res != null) {
+        Insert[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "REMOVE");
+      if (res != null) {
+        Remove[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "UP");
+      if (res != null) {
+        KeyUp[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "DOWN");
+      if (res != null) {
+        KeyDown[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "LEFT");
+      if (res != null) {
+        KeyLeft[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "RIGHT");
+      if (res != null) {
+        KeyRight[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "ESCAPE");
+      if (res != null) {
+        Escape[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "BACKSPACE");
+      if (res != null) {
+        BackSpace[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "TAB");
+      if (res != null) {
+        TabKey[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "NUMPLUS");
+      if (res != null) {
+        NUMPlus[i] = unEscape(res);
+      }
+      res = codes.getProperty(prefixes[i] + "NUMDECIMAL");
+      if (res != null) {
+        NUMDot[i] = unEscape(res);
+      }
+    }
+  }
+
+  /**
+   * Set the terminal id used to identify this terminal.
+   *
+   * @param terminalID
+   *          the id string
+   */
+  public void setTerminalID(String terminalID) {
+    this.terminalID = terminalID;
+
+    if (terminalID.equals("scoansi")) {
+      FunctionKey[1] = "\u001b[M";
+      FunctionKey[2] = "\u001b[N";
+      FunctionKey[3] = "\u001b[O";
+      FunctionKey[4] = "\u001b[P";
+      FunctionKey[5] = "\u001b[Q";
+      FunctionKey[6] = "\u001b[R";
+      FunctionKey[7] = "\u001b[S";
+      FunctionKey[8] = "\u001b[T";
+      FunctionKey[9] = "\u001b[U";
+      FunctionKey[10] = "\u001b[V";
+      FunctionKey[11] = "\u001b[W";
+      FunctionKey[12] = "\u001b[X";
+      FunctionKey[13] = "\u001b[Y";
+      FunctionKey[14] = "?";
+      FunctionKey[15] = "\u001b[a";
+      FunctionKey[16] = "\u001b[b";
+      FunctionKey[17] = "\u001b[c";
+      FunctionKey[18] = "\u001b[d";
+      FunctionKey[19] = "\u001b[e";
+      FunctionKey[20] = "\u001b[f";
+      PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[I";
+      NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[G";
+      // more theoretically.
+    }
+  }
+
+  public void setAnswerBack(String ab) {
+    answerBack = unEscape(ab);
+  }
+
+  /**
+   * Get the terminal id used to identify this terminal.
+   */
+  public String getTerminalID() {
+    return terminalID;
+  }
+
+  /**
+   * A small conveniance method thar converts the string to a byte array for sending.
+   *
+   * @param s
+   *          the string to be sent
+   */
+  private boolean write(String s, boolean doecho) {
+    if (debug > 2) {
+      debugStr.append("write(|").append(s).append("|,").append(doecho);
+      debug(debugStr.toString());
+      debugStr.setLength(0);
+    }
+    if (s == null) {
+      return true;
+      /*
+       * NOTE: getBytes() honours some locale, it *CONVERTS* the string. However, we output only
+       * 7bit stuff towards the target, and *some* 8 bit control codes. We must not mess up the
+       * latter, so we do hand by hand copy.
+       */
+    }
+
+    byte arr[] = new byte[s.length()];
+    for (int i = 0; i < s.length(); i++) {
+      arr[i] = (byte) s.charAt(i);
+    }
+    write(arr);
+
+    if (doecho) {
+      putString(s);
+    }
+    return true;
+  }
+
+  private boolean write(int s, boolean doecho) {
+    if (debug > 2) {
+      debugStr.append("write(|").append(s).append("|,").append(doecho);
+      debug(debugStr.toString());
+      debugStr.setLength(0);
+    }
+
+    write(s);
+
+    // TODO check if character is wide
+    if (doecho) {
+      putChar((char) s, false, false);
+    }
+    return true;
+  }
+
+  private boolean write(String s) {
+    return write(s, localecho);
+  }
+
+  // ===================================================================
+  // the actual terminal emulation code comes here:
+  // ===================================================================
+
+  private String terminalID = "vt320";
+  private String answerBack = "Use Terminal.answerback to set ...\n";
+
+  // X - COLUMNS, Y - ROWS
+  int R, C;
+  int attributes = 0;
+
+  int Sc, Sr, Sa, Stm, Sbm;
+  char Sgr, Sgl;
+  char Sgx[];
+
+  int insertmode = 0;
+  int statusmode = 0;
+  boolean vt52mode = false;
+  boolean keypadmode = false; /* false - numeric, true - application */
+  boolean output8bit = false;
+  int normalcursor = 0;
+  boolean moveoutsidemargins = true;
+  boolean wraparound = true;
+  boolean sendcrlf = true;
+  boolean capslock = false;
+  boolean numlock = false;
+  int mouserpt = 0;
+  byte mousebut = 0;
+
+  boolean useibmcharset = false;
+
+  int lastwaslf = 0;
+  boolean usedcharsets = false;
+
+  private final static char ESC = 27;
+  private final static char IND = 132;
+  private final static char NEL = 133;
+  private final static char RI = 141;
+  private final static char SS2 = 142;
+  private final static char SS3 = 143;
+  private final static char DCS = 144;
+  private final static char HTS = 136;
+  private final static char CSI = 155;
+  private final static char OSC = 157;
+  private final static int TSTATE_DATA = 0;
+  private final static int TSTATE_ESC = 1; /* ESC */
+  private final static int TSTATE_CSI = 2; /* ESC [ */
+  private final static int TSTATE_DCS = 3; /* ESC P */
+  private final static int TSTATE_DCEQ = 4; /* ESC [? */
+  private final static int TSTATE_ESCSQUARE = 5; /* ESC # */
+  private final static int TSTATE_OSC = 6; /* ESC ] */
+  private final static int TSTATE_SETG0 = 7; /* ESC (? */
+  private final static int TSTATE_SETG1 = 8; /* ESC )? */
+  private final static int TSTATE_SETG2 = 9; /* ESC *? */
+  private final static int TSTATE_SETG3 = 10; /* ESC +? */
+  private final static int TSTATE_CSI_DOLLAR = 11; /* ESC [ Pn $ */
+  private final static int TSTATE_CSI_EX = 12; /* ESC [ ! */
+  private final static int TSTATE_ESCSPACE = 13; /* ESC <space> */
+  private final static int TSTATE_VT52X = 14;
+  private final static int TSTATE_VT52Y = 15;
+  private final static int TSTATE_CSI_TICKS = 16;
+  private final static int TSTATE_CSI_EQUAL = 17; /* ESC [ = */
+  private final static int TSTATE_TITLE = 18; /* xterm title */
+
+  /* Keys we support */
+  public final static int KEY_PAUSE = 1;
+  public final static int KEY_F1 = 2;
+  public final static int KEY_F2 = 3;
+  public final static int KEY_F3 = 4;
+  public final static int KEY_F4 = 5;
+  public final static int KEY_F5 = 6;
+  public final static int KEY_F6 = 7;
+  public final static int KEY_F7 = 8;
+  public final static int KEY_F8 = 9;
+  public final static int KEY_F9 = 10;
+  public final static int KEY_F10 = 11;
+  public final static int KEY_F11 = 12;
+  public final static int KEY_F12 = 13;
+  public final static int KEY_UP = 14;
+  public final static int KEY_DOWN = 15;
+  public final static int KEY_LEFT = 16;
+  public final static int KEY_RIGHT = 17;
+  public final static int KEY_PAGE_DOWN = 18;
+  public final static int KEY_PAGE_UP = 19;
+  public final static int KEY_INSERT = 20;
+  public final static int KEY_DELETE = 21;
+  public final static int KEY_BACK_SPACE = 22;
+  public final static int KEY_HOME = 23;
+  public final static int KEY_END = 24;
+  public final static int KEY_NUM_LOCK = 25;
+  public final static int KEY_CAPS_LOCK = 26;
+  public final static int KEY_SHIFT = 27;
+  public final static int KEY_CONTROL = 28;
+  public final static int KEY_ALT = 29;
+  public final static int KEY_ENTER = 30;
+  public final static int KEY_NUMPAD0 = 31;
+  public final static int KEY_NUMPAD1 = 32;
+  public final static int KEY_NUMPAD2 = 33;
+  public final static int KEY_NUMPAD3 = 34;
+  public final static int KEY_NUMPAD4 = 35;
+  public final static int KEY_NUMPAD5 = 36;
+  public final static int KEY_NUMPAD6 = 37;
+  public final static int KEY_NUMPAD7 = 38;
+  public final static int KEY_NUMPAD8 = 39;
+  public final static int KEY_NUMPAD9 = 40;
+  public final static int KEY_DECIMAL = 41;
+  public final static int KEY_ADD = 42;
+  public final static int KEY_ESCAPE = 43;
+
+  public final static int DELETE_IS_DEL = 0;
+  public final static int DELETE_IS_BACKSPACE = 1;
+
+  /*
+   * The graphics charsets B - default ASCII A - ISO Latin 1 0 - DEC SPECIAL < - User defined ....
+   */
+  char gx[];
+  char gl; // GL (left charset)
+  char gr; // GR (right charset)
+  int onegl; // single shift override for GL.
+
+  // Map from scoansi linedrawing to DEC _and_ unicode (for the stuff which
+  // is not in linedrawing). Got from experimenting with scoadmin.
+  private final static String scoansi_acs =
+      "Tm7k3x4u?kZl@mYjEnB\u2566DqCtAvM\u2550:\u2551N\u2557I\u2554;\u2557H\u255a0a<\u255d";
+  // array to store DEC Special -> Unicode mapping
+  // Unicode DEC Unicode name (DEC name)
+  private static char DECSPECIAL[] = { '\u0040', // 5f blank
+    '\u2666', // 60 black diamond
+    '\u2592', // 61 grey square
+    '\u2409', // 62 Horizontal tab (ht) pict. for control
+    '\u240c', // 63 Form Feed (ff) pict. for control
+    '\u240d', // 64 Carriage Return (cr) pict. for control
+    '\u240a', // 65 Line Feed (lf) pict. for control
+    '\u00ba', // 66 Masculine ordinal indicator
+    '\u00b1', // 67 Plus or minus sign
+    '\u2424', // 68 New Line (nl) pict. for control
+    '\u240b', // 69 Vertical Tab (vt) pict. for control
+    '\u2518', // 6a Forms light up and left
+    '\u2510', // 6b Forms light down and left
+    '\u250c', // 6c Forms light down and right
+    '\u2514', // 6d Forms light up and right
+    '\u253c', // 6e Forms light vertical and horizontal
+    '\u2594', // 6f Upper 1/8 block (Scan 1)
+    '\u2580', // 70 Upper 1/2 block (Scan 3)
+    '\u2500', // 71 Forms light horizontal or ?em dash? (Scan 5)
+    '\u25ac', // 72 \u25ac black rect. or \u2582 lower 1/4 (Scan 7)
+    '\u005f', // 73 \u005f underscore or \u2581 lower 1/8 (Scan 9)
+    '\u251c', // 74 Forms light vertical and right
+    '\u2524', // 75 Forms light vertical and left
+    '\u2534', // 76 Forms light up and horizontal
+    '\u252c', // 77 Forms light down and horizontal
+    '\u2502', // 78 vertical bar
+    '\u2264', // 79 less than or equal
+    '\u2265', // 7a greater than or equal
+    '\u00b6', // 7b paragraph
+    '\u2260', // 7c not equal
+    '\u00a3', // 7d Pound Sign (british)
+    '\u00b7' // 7e Middle Dot
+      };
+
+  /** Strings to send on function key pressing */
+  private String Numpad[];
+  private String FunctionKey[];
+  private String FunctionKeyShift[];
+  private String FunctionKeyCtrl[];
+  private String FunctionKeyAlt[];
+  private String TabKey[];
+  private String KeyUp[], KeyDown[], KeyLeft[], KeyRight[];
+  private String KPMinus, KPComma, KPPeriod, KPEnter;
+  private String PF1, PF2, PF3, PF4;
+  private String Help, Do, Find, Select;
+
+  private String KeyHome[], KeyEnd[], Insert[], Remove[], PrevScn[], NextScn[];
+  private String Escape[], BackSpace[], NUMDot[], NUMPlus[];
+
+  private String osc, dcs; /* to memorize OSC & DCS control sequence */
+
+  /** vt320 state variable (internal) */
+  private int term_state = TSTATE_DATA;
+  /** in vms mode, set by Terminal.VMS property */
+  private boolean vms = false;
+  /** Tabulators */
+  private byte[] Tabs;
+  /** The list of integers as used by CSI */
+  private int[] DCEvars = new int[30];
+  private int DCEvar;
+
+  /**
+   * Replace escape code characters (backslash + identifier) with their respective codes.
+   *
+   * @param tmp
+   *          the string to be parsed
+   * @return a unescaped string
+   */
+  static String unEscape(String tmp) {
+    int idx = 0, oldidx = 0;
+    String cmd;
+    // f.println("unescape("+tmp+")");
+    cmd = "";
+    while ((idx = tmp.indexOf('\\', oldidx)) >= 0 && ++idx <= tmp.length()) {
+      cmd += tmp.substring(oldidx, idx - 1);
+      if (idx == tmp.length()) {
+        return cmd;
+      }
+      switch (tmp.charAt(idx)) {
+      case 'b':
+        cmd += "\b";
+        break;
+      case 'e':
+        cmd += "\u001b";
+        break;
+      case 'n':
+        cmd += "\n";
+        break;
+      case 'r':
+        cmd += "\r";
+        break;
+      case 't':
+        cmd += "\t";
+        break;
+      case 'v':
+        cmd += "\u000b";
+        break;
+      case 'a':
+        cmd += "\u0012";
+        break;
+      default:
+        if ((tmp.charAt(idx) >= '0') && (tmp.charAt(idx) <= '9')) {
+          int i;
+          for (i = idx; i < tmp.length(); i++) {
+            if ((tmp.charAt(i) < '0') || (tmp.charAt(i) > '9')) {
+              break;
+            }
+          }
+          cmd += (char) Integer.parseInt(tmp.substring(idx, i));
+          idx = i - 1;
+        } else {
+          cmd += tmp.substring(idx, ++idx);
+        }
+        break;
+      }
+      oldidx = ++idx;
+    }
+    if (oldidx <= tmp.length()) {
+      cmd += tmp.substring(oldidx);
+    }
+    return cmd;
+  }
+
+  /**
+   * A small conveniance method thar converts a 7bit string to the 8bit version depending on
+   * VT52/Output8Bit mode.
+   *
+   * @param s
+   *          the string to be sent
+   */
+  private boolean writeSpecial(String s) {
+    if (s == null) {
+      return true;
+    }
+    if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == 'O'))) {
+      if (vt52mode) {
+        if ((s.charAt(2) >= 'P') && (s.charAt(2) <= 'S')) {
+          s = "\u001b" + s.substring(2); /* ESC x */
+        } else {
+          s = "\u001b?" + s.substring(2); /* ESC ? x */
+        }
+      } else {
+        if (output8bit) {
+          s = "\u008f" + s.substring(2); /* SS3 x */
+        } /* else keep string as it is */
+      }
+    }
+    if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == '['))) {
+      if (output8bit) {
+        s = "\u009b" + s.substring(2); /* CSI ... */
+      } /* else keep */
+    }
+    return write(s, false);
+  }
+
+  /**
+   * main keytyping event handler...
+   */
+  public void keyPressed(int keyCode, char keyChar, int modifiers) {
+    boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
+    boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
+    boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
+
+    if (debug > 1) {
+      debugStr.append("keyPressed(").append(keyCode).append(", ").append((int) keyChar)
+          .append(", ").append(modifiers).append(')');
+      debug(debugStr.toString());
+      debugStr.setLength(0);
+    }
+
+    int xind;
+    String fmap[];
+    xind = 0;
+    fmap = FunctionKey;
+    if (shift) {
+      fmap = FunctionKeyShift;
+      xind = 1;
+    }
+    if (control) {
+      fmap = FunctionKeyCtrl;
+      xind = 2;
+    }
+    if (alt) {
+      fmap = FunctionKeyAlt;
+      xind = 3;
+    }
+
+    switch (keyCode) {
+    case KEY_PAUSE:
+      if (shift || control) {
+        sendTelnetCommand((byte) 243); // BREAK
+      }
+      break;
+    case KEY_F1:
+      writeSpecial(fmap[1]);
+      break;
+    case KEY_F2:
+      writeSpecial(fmap[2]);
+      break;
+    case KEY_F3:
+      writeSpecial(fmap[3]);
+      break;
+    case KEY_F4:
+      writeSpecial(fmap[4]);
+      break;
+    case KEY_F5:
+      writeSpecial(fmap[5]);
+      break;
+    case KEY_F6:
+      writeSpecial(fmap[6]);
+      break;
+    case KEY_F7:
+      writeSpecial(fmap[7]);
+      break;
+    case KEY_F8:
+      writeSpecial(fmap[8]);
+      break;
+    case KEY_F9:
+      writeSpecial(fmap[9]);
+      break;
+    case KEY_F10:
+      writeSpecial(fmap[10]);
+      break;
+    case KEY_F11:
+      writeSpecial(fmap[11]);
+      break;
+    case KEY_F12:
+      writeSpecial(fmap[12]);
+      break;
+    case KEY_UP:
+      writeSpecial(KeyUp[xind]);
+      break;
+    case KEY_DOWN:
+      writeSpecial(KeyDown[xind]);
+      break;
+    case KEY_LEFT:
+      writeSpecial(KeyLeft[xind]);
+      break;
+    case KEY_RIGHT:
+      writeSpecial(KeyRight[xind]);
+      break;
+    case KEY_PAGE_DOWN:
+      writeSpecial(NextScn[xind]);
+      break;
+    case KEY_PAGE_UP:
+      writeSpecial(PrevScn[xind]);
+      break;
+    case KEY_INSERT:
+      writeSpecial(Insert[xind]);
+      break;
+    case KEY_DELETE:
+      writeSpecial(Remove[xind]);
+      break;
+    case KEY_BACK_SPACE:
+      writeSpecial(BackSpace[xind]);
+      if (localecho) {
+        if (BackSpace[xind] == "\b") {
+          putString("\b \b"); // make the last char 'deleted'
+        } else {
+          putString(BackSpace[xind]); // echo it
+        }
+      }
+      break;
+    case KEY_HOME:
+      writeSpecial(KeyHome[xind]);
+      break;
+    case KEY_END:
+      writeSpecial(KeyEnd[xind]);
+      break;
+    case KEY_NUM_LOCK:
+      if (vms && control) {
+        writeSpecial(PF1);
+      }
+      if (!control) {
+        numlock = !numlock;
+      }
+      break;
+    case KEY_CAPS_LOCK:
+      capslock = !capslock;
+      return;
+    case KEY_SHIFT:
+    case KEY_CONTROL:
+    case KEY_ALT:
+      return;
+    default:
+      break;
+    }
+  }
+
+  /*
+   * public void keyReleased(KeyEvent evt) { if (debug > 1) debug("keyReleased("+evt+")"); // ignore
+   * }
+   */
+  /**
+   * Handle key Typed events for the terminal, this will get all normal key types, but no
+   * shift/alt/control/numlock.
+   */
+  public void keyTyped(int keyCode, char keyChar, int modifiers) {
+    boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
+    boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
+    boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
+
+    if (debug > 1) {
+      debug("keyTyped(" + keyCode + ", " + (int) keyChar + ", " + modifiers + ")");
+    }
+
+    if (keyChar == '\t') {
+      if (shift) {
+        write(TabKey[1], false);
+      } else {
+        if (control) {
+          write(TabKey[2], false);
+        } else {
+          if (alt) {
+            write(TabKey[3], false);
+          } else {
+            write(TabKey[0], false);
+          }
+        }
+      }
+      return;
+    }
+    if (alt) {
+      write(((char) (keyChar | 0x80)));
+      return;
+    }
+
+    if (((keyCode == KEY_ENTER) || (keyChar == 10)) && !control) {
+      write('\r');
+      if (localecho) {
+        putString("\r\n"); // bad hack
+      }
+      return;
+    }
+
+    if ((keyCode == 10) && !control) {
+      debug("Sending \\r");
+      write('\r');
+      return;
+    }
+
+    // FIXME: on german PC keyboards you have to use Alt-Ctrl-q to get an @,
+    // so we can't just use it here... will probably break some other VMS
+    // codes. -Marcus
+    // if(((!vms && keyChar == '2') || keyChar == '@' || keyChar == ' ')
+    // && control)
+    if (((!vms && keyChar == '2') || keyChar == ' ') && control) {
+      write(0);
+    }
+
+    if (vms) {
+      if (keyChar == 127 && !control) {
+        if (shift) {
+          writeSpecial(Insert[0]); // VMS shift delete = insert
+        } else {
+          writeSpecial(Remove[0]); // VMS delete = remove
+        }
+        return;
+      } else if (control) {
+        switch (keyChar) {
+        case '0':
+          writeSpecial(Numpad[0]);
+          return;
+        case '1':
+          writeSpecial(Numpad[1]);
+          return;
+        case '2':
+          writeSpecial(Numpad[2]);
+          return;
+        case '3':
+          writeSpecial(Numpad[3]);
+          return;
+        case '4':
+          writeSpecial(Numpad[4]);
+          return;
+        case '5':
+          writeSpecial(Numpad[5]);
+          return;
+        case '6':
+          writeSpecial(Numpad[6]);
+          return;
+        case '7':
+          writeSpecial(Numpad[7]);
+          return;
+        case '8':
+          writeSpecial(Numpad[8]);
+          return;
+        case '9':
+          writeSpecial(Numpad[9]);
+          return;
+        case '.':
+          writeSpecial(KPPeriod);
+          return;
+        case '-':
+        case 31:
+          writeSpecial(KPMinus);
+          return;
+        case '+':
+          writeSpecial(KPComma);
+          return;
+        case 10:
+          writeSpecial(KPEnter);
+          return;
+        case '/':
+          writeSpecial(PF2);
+          return;
+        case '*':
+          writeSpecial(PF3);
+          return;
+          /* NUMLOCK handled in keyPressed */
+        default:
+          break;
+        }
+        /*
+         * Now what does this do and how did it get here. -Marcus if (shift && keyChar < 32) {
+         * write(PF1+(char)(keyChar + 64)); return; }
+         */
+      }
+    }
+
+    // FIXME: not used?
+    // String fmap[];
+    int xind;
+    xind = 0;
+    // fmap = FunctionKey;
+    if (shift) {
+      // fmap = FunctionKeyShift;
+      xind = 1;
+    }
+    if (control) {
+      // fmap = FunctionKeyCtrl;
+      xind = 2;
+    }
+    if (alt) {
+      // fmap = FunctionKeyAlt;
+      xind = 3;
+    }
+
+    if (keyCode == KEY_ESCAPE) {
+      writeSpecial(Escape[xind]);
+      return;
+    }
+
+    if ((modifiers & VDUInput.KEY_ACTION) != 0) {
+      switch (keyCode) {
+      case KEY_NUMPAD0:
+        writeSpecial(Numpad[0]);
+        return;
+      case KEY_NUMPAD1:
+        writeSpecial(Numpad[1]);
+        return;
+      case KEY_NUMPAD2:
+        writeSpecial(Numpad[2]);
+        return;
+      case KEY_NUMPAD3:
+        writeSpecial(Numpad[3]);
+        return;
+      case KEY_NUMPAD4:
+        writeSpecial(Numpad[4]);
+        return;
+      case KEY_NUMPAD5:
+        writeSpecial(Numpad[5]);
+        return;
+      case KEY_NUMPAD6:
+        writeSpecial(Numpad[6]);
+        return;
+      case KEY_NUMPAD7:
+        writeSpecial(Numpad[7]);
+        return;
+      case KEY_NUMPAD8:
+        writeSpecial(Numpad[8]);
+        return;
+      case KEY_NUMPAD9:
+        writeSpecial(Numpad[9]);
+        return;
+      case KEY_DECIMAL:
+        writeSpecial(NUMDot[xind]);
+        return;
+      case KEY_ADD:
+        writeSpecial(NUMPlus[xind]);
+        return;
+      }
+    }
+
+    if (!((keyChar == 8) || (keyChar == 127) || (keyChar == '\r') || (keyChar == '\n'))) {
+      write(keyChar);
+      return;
+    }
+  }
+
+  private void handle_dcs(String dcs) {
+    debugStr.append("DCS: ").append(dcs);
+    debug(debugStr.toString());
+    debugStr.setLength(0);
+  }
+
+  private void handle_osc(String osc) {
+    if (osc.length() > 2 && osc.substring(0, 2).equals("4;")) {
+      // Define color palette
+      String[] colorData = osc.split(";");
+
+      try {
+        int colorIndex = Integer.parseInt(colorData[1]);
+
+        if ("rgb:".equals(colorData[2].substring(0, 4))) {
+          String[] rgb = colorData[2].substring(4).split("/");
+
+          int red = Integer.parseInt(rgb[0].substring(0, 2), 16) & 0xFF;
+          int green = Integer.parseInt(rgb[1].substring(0, 2), 16) & 0xFF;
+          int blue = Integer.parseInt(rgb[2].substring(0, 2), 16) & 0xFF;
+          display.setColor(colorIndex, red, green, blue);
+        }
+      } catch (Exception e) {
+        debugStr.append("OSC: invalid color sequence encountered: ").append(osc);
+        debug(debugStr.toString());
+        debugStr.setLength(0);
+      }
+    } else {
+      debug("OSC: " + osc);
+    }
+  }
+
+  private final static char unimap[] = {
+    // #
+    // # Name: cp437_DOSLatinUS to Unicode table
+    // # Unicode version: 1.1
+    // # Table version: 1.1
+    // # Table format: Format A
+    // # Date: 03/31/95
+    // # Authors: Michel Suignard <michelsu@microsoft.com>
+    // # Lori Hoerth <lorih@microsoft.com>
+    // # General notes: none
+    // #
+    // # Format: Three tab-separated columns
+    // # Column #1 is the cp1255_WinHebrew code (in hex)
+    // # Column #2 is the Unicode (in hex as 0xXXXX)
+    // # Column #3 is the Unicode name (follows a comment sign, '#')
+    // #
+    // # The entries are in cp437_DOSLatinUS order
+    // #
+
+    0x0000, // #NULL
+    0x0001, // #START OF HEADING
+    0x0002, // #START OF TEXT
+    0x0003, // #END OF TEXT
+    0x0004, // #END OF TRANSMISSION
+    0x0005, // #ENQUIRY
+    0x0006, // #ACKNOWLEDGE
+    0x0007, // #BELL
+    0x0008, // #BACKSPACE
+    0x0009, // #HORIZONTAL TABULATION
+    0x000a, // #LINE FEED
+    0x000b, // #VERTICAL TABULATION
+    0x000c, // #FORM FEED
+    0x000d, // #CARRIAGE RETURN
+    0x000e, // #SHIFT OUT
+    0x000f, // #SHIFT IN
+    0x0010, // #DATA LINK ESCAPE
+    0x0011, // #DEVICE CONTROL ONE
+    0x0012, // #DEVICE CONTROL TWO
+    0x0013, // #DEVICE CONTROL THREE
+    0x0014, // #DEVICE CONTROL FOUR
+    0x0015, // #NEGATIVE ACKNOWLEDGE
+    0x0016, // #SYNCHRONOUS IDLE
+    0x0017, // #END OF TRANSMISSION BLOCK
+    0x0018, // #CANCEL
+    0x0019, // #END OF MEDIUM
+    0x001a, // #SUBSTITUTE
+    0x001b, // #ESCAPE
+    0x001c, // #FILE SEPARATOR
+    0x001d, // #GROUP SEPARATOR
+    0x001e, // #RECORD SEPARATOR
+    0x001f, // #UNIT SEPARATOR
+    0x0020, // #SPACE
+    0x0021, // #EXCLAMATION MARK
+    0x0022, // #QUOTATION MARK
+    0x0023, // #NUMBER SIGN
+    0x0024, // #DOLLAR SIGN
+    0x0025, // #PERCENT SIGN
+    0x0026, // #AMPERSAND
+    0x0027, // #APOSTROPHE
+    0x0028, // #LEFT PARENTHESIS
+    0x0029, // #RIGHT PARENTHESIS
+    0x002a, // #ASTERISK
+    0x002b, // #PLUS SIGN
+    0x002c, // #COMMA
+    0x002d, // #HYPHEN-MINUS
+    0x002e, // #FULL STOP
+    0x002f, // #SOLIDUS
+    0x0030, // #DIGIT ZERO
+    0x0031, // #DIGIT ONE
+    0x0032, // #DIGIT TWO
+    0x0033, // #DIGIT THREE
+    0x0034, // #DIGIT FOUR
+    0x0035, // #DIGIT FIVE
+    0x0036, // #DIGIT SIX
+    0x0037, // #DIGIT SEVEN
+    0x0038, // #DIGIT EIGHT
+    0x0039, // #DIGIT NINE
+    0x003a, // #COLON
+    0x003b, // #SEMICOLON
+    0x003c, // #LESS-THAN SIGN
+    0x003d, // #EQUALS SIGN
+    0x003e, // #GREATER-THAN SIGN
+    0x003f, // #QUESTION MARK
+    0x0040, // #COMMERCIAL AT
+    0x0041, // #LATIN CAPITAL LETTER A
+    0x0042, // #LATIN CAPITAL LETTER B
+    0x0043, // #LATIN CAPITAL LETTER C
+    0x0044, // #LATIN CAPITAL LETTER D
+    0x0045, // #LATIN CAPITAL LETTER E
+    0x0046, // #LATIN CAPITAL LETTER F
+    0x0047, // #LATIN CAPITAL LETTER G
+    0x0048, // #LATIN CAPITAL LETTER H
+    0x0049, // #LATIN CAPITAL LETTER I
+    0x004a, // #LATIN CAPITAL LETTER J
+    0x004b, // #LATIN CAPITAL LETTER K
+    0x004c, // #LATIN CAPITAL LETTER L
+    0x004d, // #LATIN CAPITAL LETTER M
+    0x004e, // #LATIN CAPITAL LETTER N
+    0x004f, // #LATIN CAPITAL LETTER O
+    0x0050, // #LATIN CAPITAL LETTER P
+    0x0051, // #LATIN CAPITAL LETTER Q
+    0x0052, // #LATIN CAPITAL LETTER R
+    0x0053, // #LATIN CAPITAL LETTER S
+    0x0054, // #LATIN CAPITAL LETTER T
+    0x0055, // #LATIN CAPITAL LETTER U
+    0x0056, // #LATIN CAPITAL LETTER V
+    0x0057, // #LATIN CAPITAL LETTER W
+    0x0058, // #LATIN CAPITAL LETTER X
+    0x0059, // #LATIN CAPITAL LETTER Y
+    0x005a, // #LATIN CAPITAL LETTER Z
+    0x005b, // #LEFT SQUARE BRACKET
+    0x005c, // #REVERSE SOLIDUS
+    0x005d, // #RIGHT SQUARE BRACKET
+    0x005e, // #CIRCUMFLEX ACCENT
+    0x005f, // #LOW LINE
+    0x0060, // #GRAVE ACCENT
+    0x0061, // #LATIN SMALL LETTER A
+    0x0062, // #LATIN SMALL LETTER B
+    0x0063, // #LATIN SMALL LETTER C
+    0x0064, // #LATIN SMALL LETTER D
+    0x0065, // #LATIN SMALL LETTER E
+    0x0066, // #LATIN SMALL LETTER F
+    0x0067, // #LATIN SMALL LETTER G
+    0x0068, // #LATIN SMALL LETTER H
+    0x0069, // #LATIN SMALL LETTER I
+    0x006a, // #LATIN SMALL LETTER J
+    0x006b, // #LATIN SMALL LETTER K
+    0x006c, // #LATIN SMALL LETTER L
+    0x006d, // #LATIN SMALL LETTER M
+    0x006e, // #LATIN SMALL LETTER N
+    0x006f, // #LATIN SMALL LETTER O
+    0x0070, // #LATIN SMALL LETTER P
+    0x0071, // #LATIN SMALL LETTER Q
+    0x0072, // #LATIN SMALL LETTER R
+    0x0073, // #LATIN SMALL LETTER S
+    0x0074, // #LATIN SMALL LETTER T
+    0x0075, // #LATIN SMALL LETTER U
+    0x0076, // #LATIN SMALL LETTER V
+    0x0077, // #LATIN SMALL LETTER W
+    0x0078, // #LATIN SMALL LETTER X
+    0x0079, // #LATIN SMALL LETTER Y
+    0x007a, // #LATIN SMALL LETTER Z
+    0x007b, // #LEFT CURLY BRACKET
+    0x007c, // #VERTICAL LINE
+    0x007d, // #RIGHT CURLY BRACKET
+    0x007e, // #TILDE
+    0x007f, // #DELETE
+    0x00c7, // #LATIN CAPITAL LETTER C WITH CEDILLA
+    0x00fc, // #LATIN SMALL LETTER U WITH DIAERESIS
+    0x00e9, // #LATIN SMALL LETTER E WITH ACUTE
+    0x00e2, // #LATIN SMALL LETTER A WITH CIRCUMFLEX
+    0x00e4, // #LATIN SMALL LETTER A WITH DIAERESIS
+    0x00e0, // #LATIN SMALL LETTER A WITH GRAVE
+    0x00e5, // #LATIN SMALL LETTER A WITH RING ABOVE
+    0x00e7, // #LATIN SMALL LETTER C WITH CEDILLA
+    0x00ea, // #LATIN SMALL LETTER E WITH CIRCUMFLEX
+    0x00eb, // #LATIN SMALL LETTER E WITH DIAERESIS
+    0x00e8, // #LATIN SMALL LETTER E WITH GRAVE
+    0x00ef, // #LATIN SMALL LETTER I WITH DIAERESIS
+    0x00ee, // #LATIN SMALL LETTER I WITH CIRCUMFLEX
+    0x00ec, // #LATIN SMALL LETTER I WITH GRAVE
+    0x00c4, // #LATIN CAPITAL LETTER A WITH DIAERESIS
+    0x00c5, // #LATIN CAPITAL LETTER A WITH RING ABOVE
+    0x00c9, // #LATIN CAPITAL LETTER E WITH ACUTE
+    0x00e6, // #LATIN SMALL LIGATURE AE
+    0x00c6, // #LATIN CAPITAL LIGATURE AE
+    0x00f4, // #LATIN SMALL LETTER O WITH CIRCUMFLEX
+    0x00f6, // #LATIN SMALL LETTER O WITH DIAERESIS
+    0x00f2, // #LATIN SMALL LETTER O WITH GRAVE
+    0x00fb, // #LATIN SMALL LETTER U WITH CIRCUMFLEX
+    0x00f9, // #LATIN SMALL LETTER U WITH GRAVE
+    0x00ff, // #LATIN SMALL LETTER Y WITH DIAERESIS
+    0x00d6, // #LATIN CAPITAL LETTER O WITH DIAERESIS
+    0x00dc, // #LATIN CAPITAL LETTER U WITH DIAERESIS
+    0x00a2, // #CENT SIGN
+    0x00a3, // #POUND SIGN
+    0x00a5, // #YEN SIGN
+    0x20a7, // #PESETA SIGN
+    0x0192, // #LATIN SMALL LETTER F WITH HOOK
+    0x00e1, // #LATIN SMALL LETTER A WITH ACUTE
+    0x00ed, // #LATIN SMALL LETTER I WITH ACUTE
+    0x00f3, // #LATIN SMALL LETTER O WITH ACUTE
+    0x00fa, // #LATIN SMALL LETTER U WITH ACUTE
+    0x00f1, // #LATIN SMALL LETTER N WITH TILDE
+    0x00d1, // #LATIN CAPITAL LETTER N WITH TILDE
+    0x00aa, // #FEMININE ORDINAL INDICATOR
+    0x00ba, // #MASCULINE ORDINAL INDICATOR
+    0x00bf, // #INVERTED QUESTION MARK
+    0x2310, // #REVERSED NOT SIGN
+    0x00ac, // #NOT SIGN
+    0x00bd, // #VULGAR FRACTION ONE HALF
+    0x00bc, // #VULGAR FRACTION ONE QUARTER
+    0x00a1, // #INVERTED EXCLAMATION MARK
+    0x00ab, // #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00bb, // #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x2591, // #LIGHT SHADE
+    0x2592, // #MEDIUM SHADE
+    0x2593, // #DARK SHADE
+    0x2502, // #BOX DRAWINGS LIGHT VERTICAL
+    0x2524, // #BOX DRAWINGS LIGHT VERTICAL AND LEFT
+    0x2561, // #BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE
+    0x2562, // #BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE
+    0x2556, // #BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE
+    0x2555, // #BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE
+    0x2563, // #BOX DRAWINGS DOUBLE VERTICAL AND LEFT
+    0x2551, // #BOX DRAWINGS DOUBLE VERTICAL
+    0x2557, // #BOX DRAWINGS DOUBLE DOWN AND LEFT
+    0x255d, // #BOX DRAWINGS DOUBLE UP AND LEFT
+    0x255c, // #BOX DRAWINGS UP DOUBLE AND LEFT SINGLE
+    0x255b, // #BOX DRAWINGS UP SINGLE AND LEFT DOUBLE
+    0x2510, // #BOX DRAWINGS LIGHT DOWN AND LEFT
+    0x2514, // #BOX DRAWINGS LIGHT UP AND RIGHT
+    0x2534, // #BOX DRAWINGS LIGHT UP AND HORIZONTAL
+    0x252c, // #BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
+    0x251c, // #BOX DRAWINGS LIGHT VERTICAL AND RIGHT
+    0x2500, // #BOX DRAWINGS LIGHT HORIZONTAL
+    0x253c, // #BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL
+    0x255e, // #BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE
+    0x255f, // #BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE
+    0x255a, // #BOX DRAWINGS DOUBLE UP AND RIGHT
+    0x2554, // #BOX DRAWINGS DOUBLE DOWN AND RIGHT
+    0x2569, // #BOX DRAWINGS DOUBLE UP AND HORIZONTAL
+    0x2566, // #BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL
+    0x2560, // #BOX DRAWINGS DOUBLE VERTICAL AND RIGHT
+    0x2550, // #BOX DRAWINGS DOUBLE HORIZONTAL
+    0x256c, // #BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL
+    0x2567, // #BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE
+    0x2568, // #BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE
+    0x2564, // #BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE
+    0x2565, // #BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE
+    0x2559, // #BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE
+    0x2558, // #BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE
+    0x2552, // #BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE
+    0x2553, // #BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE
+    0x256b, // #BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE
+    0x256a, // #BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE
+    0x2518, // #BOX DRAWINGS LIGHT UP AND LEFT
+    0x250c, // #BOX DRAWINGS LIGHT DOWN AND RIGHT
+    0x2588, // #FULL BLOCK
+    0x2584, // #LOWER HALF BLOCK
+    0x258c, // #LEFT HALF BLOCK
+    0x2590, // #RIGHT HALF BLOCK
+    0x2580, // #UPPER HALF BLOCK
+    0x03b1, // #GREEK SMALL LETTER ALPHA
+    0x00df, // #LATIN SMALL LETTER SHARP S
+    0x0393, // #GREEK CAPITAL LETTER GAMMA
+    0x03c0, // #GREEK SMALL LETTER PI
+    0x03a3, // #GREEK CAPITAL LETTER SIGMA
+    0x03c3, // #GREEK SMALL LETTER SIGMA
+    0x00b5, // #MICRO SIGN
+    0x03c4, // #GREEK SMALL LETTER TAU
+    0x03a6, // #GREEK CAPITAL LETTER PHI
+    0x0398, // #GREEK CAPITAL LETTER THETA
+    0x03a9, // #GREEK CAPITAL LETTER OMEGA
+    0x03b4, // #GREEK SMALL LETTER DELTA
+    0x221e, // #INFINITY
+    0x03c6, // #GREEK SMALL LETTER PHI
+    0x03b5, // #GREEK SMALL LETTER EPSILON
+    0x2229, // #INTERSECTION
+    0x2261, // #IDENTICAL TO
+    0x00b1, // #PLUS-MINUS SIGN
+    0x2265, // #GREATER-THAN OR EQUAL TO
+    0x2264, // #LESS-THAN OR EQUAL TO
+    0x2320, // #TOP HALF INTEGRAL
+    0x2321, // #BOTTOM HALF INTEGRAL
+    0x00f7, // #DIVISION SIGN
+    0x2248, // #ALMOST EQUAL TO
+    0x00b0, // #DEGREE SIGN
+    0x2219, // #BULLET OPERATOR
+    0x00b7, // #MIDDLE DOT
+    0x221a, // #SQUARE ROOT
+    0x207f, // #SUPERSCRIPT LATIN SMALL LETTER N
+    0x00b2, // #SUPERSCRIPT TWO
+    0x25a0, // #BLACK SQUARE
+    0x00a0, // #NO-BREAK SPACE
+  };
+
+  public char map_cp850_unicode(char x) {
+    if (x >= 0x100) {
+      return x;
+    }
+    return unimap[x];
+  }
+
+  private void _SetCursor(int row, int col) {
+    int maxr = height - 1;
+    int tm = getTopMargin();
+
+    R = (row < 0) ? 0 : row;
+    C = (col < 0) ? 0 : (col >= width) ? width - 1 : col;
+
+    if (!moveoutsidemargins) {
+      R += tm;
+      maxr = getBottomMargin();
+    }
+    if (R > maxr) {
+      R = maxr;
+    }
+  }
+
+  private void putChar(char c, boolean isWide, boolean doshowcursor) {
+    int rows = height; // statusline
+    int columns = width;
+    // byte msg[];
+
+    // if (debug > 4) {
+    // debugStr.append("putChar(")
+    // .append(c)
+    // .append(" [")
+    // .append((int) c)
+    // .append("]) at R=")
+    // .append(R)
+    // .append(" , C=")
+    // .append(C)
+    // .append(", columns=")
+    // .append(columns)
+    // .append(", rows=")
+    // .append(rows);
+    // debug(debugStr.toString());
+    // debugStr.setLength(0);
+    // }
+    // markLine(R, 1);
+    // if (c > 255) {
+    // if (debug > 0)
+    // debug("char > 255:" + (int) c);
+    // //return;
+    // }
+
+    switch (term_state) {
+    case TSTATE_DATA:
+      /*
+       * FIXME: we shouldn't use chars with bit 8 set if ibmcharset. probably... but some BBS do
+       * anyway...
+       */
+      if (!useibmcharset) {
+        boolean doneflag = true;
+        switch (c) {
+        case OSC:
+          osc = "";
+          term_state = TSTATE_OSC;
+          break;
+        case RI:
+          if (R > getTopMargin()) {
+            R--;
+          } else {
+            insertLine(R, 1, SCROLL_DOWN);
+          }
+          if (debug > 1) {
+            debug("RI");
+          }
+          break;
+        case IND:
+          if (debug > 2) {
+            debugStr.append("IND at ").append(R).append(", tm is ").append(getTopMargin())
+                .append(", bm is ").append(getBottomMargin());
+            debug(debugStr.toString());
+            debugStr.setLength(0);
+          }
+          if (R == getBottomMargin() || R == rows - 1) {
+            insertLine(R, 1, SCROLL_UP);
+          } else {
+            R++;
+          }
+          if (debug > 1) {
+            debug("IND (at " + R + " )");
+          }
+          break;
+        case NEL:
+          if (R == getBottomMargin() || R == rows - 1) {
+            insertLine(R, 1, SCROLL_UP);
+          } else {
+            R++;
+          }
+          C = 0;
+          if (debug > 1) {
+            debug("NEL (at " + R + " )");
+          }
+          break;
+        case HTS:
+          Tabs[C] = 1;
+          if (debug > 1) {
+            debug("HTS");
+          }
+          break;
+        case DCS:
+          dcs = "";
+          term_state = TSTATE_DCS;
+          break;
+        default:
+          doneflag = false;
+          break;
+        }
+        if (doneflag) {
+          break;
+        }
+      }
+      switch (c) {
+      case SS3:
+        onegl = 3;
+        break;
+      case SS2:
+        onegl = 2;
+        break;
+      case CSI: // should be in the 8bit section, but some BBS use this
+        DCEvar = 0;
+        DCEvars[0] = 0;
+        DCEvars[1] = 0;
+        DCEvars[2] = 0;
+        DCEvars[3] = 0;
+        term_state = TSTATE_CSI;
+        break;
+      case ESC:
+        term_state = TSTATE_ESC;
+        lastwaslf = 0;
+        break;
+      case 5: /* ENQ */
+        write(answerBack, false);
+        break;
+      case 12:
+        /* FormFeed, Home for the BBS world */
+        deleteArea(0, 0, columns, rows, attributes);
+        C = R = 0;
+        break;
+      case '\b': /* 8 */
+        C--;
+        if (C < 0) {
+          C = 0;
+        }
+        lastwaslf = 0;
+        break;
+      case '\t':
+        do {
+          // Don't overwrite or insert! TABS are not destructive, but movement!
+          C++;
+        } while (C < columns && (Tabs[C] == 0));
+        lastwaslf = 0;
+        break;
+      case '\r': // 13 CR
+        C = 0;
+        break;
+      case '\n': // 10 LF
+        if (debug > 3) {
+          debug("R= " + R + ", bm " + getBottomMargin() + ", tm=" + getTopMargin() + ", rows="
+              + rows);
+        }
+        if (!vms) {
+          if (lastwaslf != 0 && lastwaslf != c) {
+            break;
+          }
+          lastwaslf = c;
+          /* C = 0; */
+        }
+        if (R == getBottomMargin() || R >= rows - 1) {
+          insertLine(R, 1, SCROLL_UP);
+        } else {
+          R++;
+        }
+        break;
+      case 7:
+        beep();
+        break;
+      case '\016': /* SMACS , as */
+        /* ^N, Shift out - Put G1 into GL */
+        gl = 1;
+        usedcharsets = true;
+        break;
+      case '\017': /* RMACS , ae */
+        /* ^O, Shift in - Put G0 into GL */
+        gl = 0;
+        usedcharsets = true;
+        break;
+      default: {
+        int thisgl = gl;
+
+        if (onegl >= 0) {
+          thisgl = onegl;
+          onegl = -1;
+        }
+        lastwaslf = 0;
+        if (c < 32) {
+          if (c != 0) {
+            if (debug > 0) {
+              debug("TSTATE_DATA char: " + ((int) c));
+            }
+          }
+          /* break; some BBS really want those characters, like hearst etc. */
+          if (c == 0) {
+            break;
+          }
+        }
+        if (C >= columns) {
+          if (wraparound) {
+            int bot = rows;
+
+            // If we're in the scroll region, check against the bottom margin
+            if (R <= getBottomMargin() && R >= getTopMargin()) {
+              bot = getBottomMargin() + 1;
+            }
+
+            if (R < bot - 1) {
+              R++;
+            } else {
+              if (debug > 3) {
+                debug("scrolling due to wrap at " + R);
+              }
+              insertLine(R, 1, SCROLL_UP);
+            }
+            C = 0;
+          } else {
+            // cursor stays on last character.
+            C = columns - 1;
+          }
+        }
+
+        boolean mapped = false;
+
+        // Mapping if DEC Special is chosen charset
+        if (usedcharsets) {
+          if (c >= '\u0020' && c <= '\u007f') {
+            switch (gx[thisgl]) {
+            case '0':
+              // Remap SCOANSI line drawing to VT100 line drawing chars
+              // for our SCO using customers.
+              if (terminalID.equals("scoansi") || terminalID.equals("ansi")) {
+                for (int i = 0; i < scoansi_acs.length(); i += 2) {
+                  if (c == scoansi_acs.charAt(i)) {
+                    c = scoansi_acs.charAt(i + 1);
+                    break;
+                  }
+                }
+              }
+              if (c >= '\u005f' && c <= '\u007e') {
+                c = DECSPECIAL[(short) c - 0x5f];
+                mapped = true;
+              }
+              break;
+            case '<': // 'user preferred' is currently 'ISO Latin-1 suppl
+              c = (char) ((c & 0x7f) | 0x80);
+              mapped = true;
+              break;
+            case 'A':
+            case 'B': // Latin-1 , ASCII -> fall through
+              mapped = true;
+              break;
+            default:
+              debug("Unsupported GL mapping: " + gx[thisgl]);
+              break;
+            }
+          }
+          if (!mapped && (c >= '\u0080' && c <= '\u00ff')) {
+            switch (gx[gr]) {
+            case '0':
+              if (c >= '\u00df' && c <= '\u00fe') {
+                c = DECSPECIAL[c - '\u00df'];
+                mapped = true;
+              }
+              break;
+            case '<':
+            case 'A':
+            case 'B':
+              mapped = true;
+              break;
+            default:
+              debug("Unsupported GR mapping: " + gx[gr]);
+              break;
+            }
+          }
+        }
+        if (!mapped && useibmcharset) {
+          c = map_cp850_unicode(c);
+        }
+
+        /* if(true || (statusmode == 0)) { */
+        if (isWide) {
+          if (C >= columns - 1) {
+            if (wraparound) {
+              int bot = rows;
+
+              // If we're in the scroll region, check against the bottom margin
+              if (R <= getBottomMargin() && R >= getTopMargin()) {
+                bot = getBottomMargin() + 1;
+              }
+
+              if (R < bot - 1) {
+                R++;
+              } else {
+                if (debug > 3) {
+                  debug("scrolling due to wrap at " + R);
+                }
+                insertLine(R, 1, SCROLL_UP);
+              }
+              C = 0;
+            } else {
+              // cursor stays on last wide character.
+              C = columns - 2;
+            }
+          }
+        }
+
+        if (insertmode == 1) {
+          if (isWide) {
+            insertChar(C++, R, c, attributes | FULLWIDTH);
+            insertChar(C, R, ' ', attributes | FULLWIDTH);
+          } else {
+            insertChar(C, R, c, attributes);
+          }
+        } else {
+          if (isWide) {
+            putChar(C++, R, c, attributes | FULLWIDTH);
+            putChar(C, R, ' ', attributes | FULLWIDTH);
+          } else {
+            putChar(C, R, c, attributes);
+          }
+        }
+
+        /*
+         * } else { if (insertmode==1) { insertChar(C, rows, c, attributes); } else { putChar(C,
+         * rows, c, attributes); } }
+         */
+        C++;
+        break;
+      }
+      } /* switch(c) */
+      break;
+    case TSTATE_OSC:
+      if ((c < 0x20) && (c != ESC)) {// NP - No printing character
+        handle_osc(osc);
+        term_state = TSTATE_DATA;
+        break;
+      }
+      // but check for vt102 ESC \
+      if (c == '\\' && osc.charAt(osc.length() - 1) == ESC) {
+        handle_osc(osc);
+        term_state = TSTATE_DATA;
+        break;
+      }
+      osc = osc + c;
+      break;
+    case TSTATE_ESCSPACE:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case 'F': /* S7C1T, Disable output of 8-bit controls, use 7-bit */
+        output8bit = false;
+        break;
+      case 'G': /* S8C1T, Enable output of 8-bit control codes */
+        output8bit = true;
+        break;
+      default:
+        debug("ESC <space> " + c + " unhandled.");
+      }
+      break;
+    case TSTATE_ESC:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case ' ':
+        term_state = TSTATE_ESCSPACE;
+        break;
+      case '#':
+        term_state = TSTATE_ESCSQUARE;
+        break;
+      case 'c':
+        /* Hard terminal reset */
+        reset();
+        break;
+      case '[':
+        DCEvar = 0;
+        DCEvars[0] = 0;
+        DCEvars[1] = 0;
+        DCEvars[2] = 0;
+        DCEvars[3] = 0;
+        term_state = TSTATE_CSI;
+        break;
+      case ']':
+        osc = "";
+        term_state = TSTATE_OSC;
+        break;
+      case 'P':
+        dcs = "";
+        term_state = TSTATE_DCS;
+        break;
+      case 'A': /* CUU */
+        R--;
+        if (R < 0) {
+          R = 0;
+        }
+        break;
+      case 'B': /* CUD */
+        R++;
+        if (R >= rows) {
+          R = rows - 1;
+        }
+        break;
+      case 'C':
+        C++;
+        if (C >= columns) {
+          C = columns - 1;
+        }
+        break;
+      case 'I': // RI
+        insertLine(R, 1, SCROLL_DOWN);
+        break;
+      case 'E': /* NEL */
+        if (R == getBottomMargin() || R == rows - 1) {
+          insertLine(R, 1, SCROLL_UP);
+        } else {
+          R++;
+        }
+        C = 0;
+        if (debug > 1) {
+          debug("ESC E (at " + R + ")");
+        }
+        break;
+      case 'D': /* IND */
+        if (R == getBottomMargin() || R == rows - 1) {
+          insertLine(R, 1, SCROLL_UP);
+        } else {
+          R++;
+        }
+        if (debug > 1) {
+          debug("ESC D (at " + R + " )");
+        }
+        break;
+      case 'J': /* erase to end of screen */
+        if (R < rows - 1) {
+          deleteArea(0, R + 1, columns, rows - R - 1, attributes);
+        }
+        if (C < columns - 1) {
+          deleteArea(C, R, columns - C, 1, attributes);
+        }
+        break;
+      case 'K':
+        if (C < columns - 1) {
+          deleteArea(C, R, columns - C, 1, attributes);
+        }
+        break;
+      case 'M': // RI
+        debug("ESC M : R is " + R + ", tm is " + getTopMargin() + ", bm is " + getBottomMargin());
+        if (R > getTopMargin()) { // just go up 1 line.
+          R--;
+        } else { // scroll down
+          insertLine(R, 1, SCROLL_DOWN);
+        }
+        /* else do nothing ; */
+        if (debug > 2) {
+          debug("ESC M ");
+        }
+        break;
+      case 'H':
+        if (debug > 1) {
+          debug("ESC H at " + C);
+        }
+        /* right border probably ... */
+        if (C >= columns) {
+          C = columns - 1;
+        }
+        Tabs[C] = 1;
+        break;
+      case 'N': // SS2
+        onegl = 2;
+        break;
+      case 'O': // SS3
+        onegl = 3;
+        break;
+      case '=':
+        /* application keypad */
+        if (debug > 0) {
+          debug("ESC =");
+        }
+        keypadmode = true;
+        break;
+      case '<': /* vt52 mode off */
+        vt52mode = false;
+        break;
+      case '>': /* normal keypad */
+        if (debug > 0) {
+          debug("ESC >");
+        }
+        keypadmode = false;
+        break;
+      case '7': /* DECSC: save cursor, attributes */
+        Sc = C;
+        Sr = R;
+        Sgl = gl;
+        Sgr = gr;
+        Sa = attributes;
+        Sgx = new char[4];
+        for (int i = 0; i < 4; i++) {
+          Sgx[i] = gx[i];
+        }
+        if (debug > 1) {
+          debug("ESC 7");
+        }
+        break;
+      case '8': /* DECRC: restore cursor, attributes */
+        C = Sc;
+        R = Sr;
+        gl = Sgl;
+        gr = Sgr;
+        if (Sgx != null) {
+          for (int i = 0; i < 4; i++) {
+            gx[i] = Sgx[i];
+          }
+        }
+        attributes = Sa;
+        if (debug > 1) {
+          debug("ESC 8");
+        }
+        break;
+      case '(': /* Designate G0 Character set (ISO 2022) */
+        term_state = TSTATE_SETG0;
+        usedcharsets = true;
+        break;
+      case ')': /* Designate G1 character set (ISO 2022) */
+        term_state = TSTATE_SETG1;
+        usedcharsets = true;
+        break;
+      case '*': /* Designate G2 Character set (ISO 2022) */
+        term_state = TSTATE_SETG2;
+        usedcharsets = true;
+        break;
+      case '+': /* Designate G3 Character set (ISO 2022) */
+        term_state = TSTATE_SETG3;
+        usedcharsets = true;
+        break;
+      case '~': /* Locking Shift 1, right */
+        gr = 1;
+        usedcharsets = true;
+        break;
+      case 'n': /* Locking Shift 2 */
+        gl = 2;
+        usedcharsets = true;
+        break;
+      case '}': /* Locking Shift 2, right */
+        gr = 2;
+        usedcharsets = true;
+        break;
+      case 'o': /* Locking Shift 3 */
+        gl = 3;
+        usedcharsets = true;
+        break;
+      case '|': /* Locking Shift 3, right */
+        gr = 3;
+        usedcharsets = true;
+        break;
+      case 'Y': /* vt52 cursor address mode , next chars are x,y */
+        term_state = TSTATE_VT52Y;
+        break;
+      case '_':
+        term_state = TSTATE_TITLE;
+        break;
+      case '\\':
+        // TODO save title
+        term_state = TSTATE_DATA;
+        break;
+      default:
+        debug("ESC unknown letter: " + c + " (" + ((int) c) + ")");
+        break;
+      }
+      break;
+    case TSTATE_VT52X:
+      C = c - 37;
+      if (C < 0) {
+        C = 0;
+      } else if (C >= width) {
+        C = width - 1;
+      }
+      term_state = TSTATE_VT52Y;
+      break;
+    case TSTATE_VT52Y:
+      R = c - 37;
+      if (R < 0) {
+        R = 0;
+      } else if (R >= height) {
+        R = height - 1;
+      }
+      term_state = TSTATE_DATA;
+      break;
+    case TSTATE_SETG0:
+      if (c != '0' && c != 'A' && c != 'B' && c != '<') {
+        debug("ESC ( " + c + ": G0 char set?  (" + ((int) c) + ")");
+      } else {
+        if (debug > 2) {
+          debug("ESC ( : G0 char set  (" + c + " " + ((int) c) + ")");
+        }
+        gx[0] = c;
+      }
+      term_state = TSTATE_DATA;
+      break;
+    case TSTATE_SETG1:
+      if (c != '0' && c != 'A' && c != 'B' && c != '<') {
+        debug("ESC ) " + c + " (" + ((int) c) + ") :G1 char set?");
+      } else {
+        if (debug > 2) {
+          debug("ESC ) :G1 char set  (" + c + " " + ((int) c) + ")");
+        }
+        gx[1] = c;
+      }
+      term_state = TSTATE_DATA;
+      break;
+    case TSTATE_SETG2:
+      if (c != '0' && c != 'A' && c != 'B' && c != '<') {
+        debug("ESC*:G2 char set?  (" + ((int) c) + ")");
+      } else {
+        if (debug > 2) {
+          debug("ESC*:G2 char set  (" + c + " " + ((int) c) + ")");
+        }
+        gx[2] = c;
+      }
+      term_state = TSTATE_DATA;
+      break;
+    case TSTATE_SETG3:
+      if (c != '0' && c != 'A' && c != 'B' && c != '<') {
+        debug("ESC+:G3 char set?  (" + ((int) c) + ")");
+      } else {
+        if (debug > 2) {
+          debug("ESC+:G3 char set  (" + c + " " + ((int) c) + ")");
+        }
+        gx[3] = c;
+      }
+      term_state = TSTATE_DATA;
+      break;
+    case TSTATE_ESCSQUARE:
+      switch (c) {
+      case '8':
+        for (int i = 0; i < columns; i++) {
+          for (int j = 0; j < rows; j++) {
+            putChar(i, j, 'E', 0);
+          }
+        }
+        break;
+      default:
+        debug("ESC # " + c + " not supported.");
+        break;
+      }
+      term_state = TSTATE_DATA;
+      break;
+    case TSTATE_DCS:
+      if (c == '\\' && dcs.charAt(dcs.length() - 1) == ESC) {
+        handle_dcs(dcs);
+        term_state = TSTATE_DATA;
+        break;
+      }
+      dcs = dcs + c;
+      break;
+
+    case TSTATE_DCEQ:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+        DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
+        term_state = TSTATE_DCEQ;
+        break;
+      case ';':
+        DCEvar++;
+        DCEvars[DCEvar] = 0;
+        term_state = TSTATE_DCEQ;
+        break;
+      case 's': // XTERM_SAVE missing!
+        if (true || debug > 1) {
+          debug("ESC [ ? " + DCEvars[0] + " s unimplemented!");
+        }
+        break;
+      case 'r': // XTERM_RESTORE
+        if (true || debug > 1) {
+          debug("ESC [ ? " + DCEvars[0] + " r");
+        }
+        /* DEC Mode reset */
+        for (int i = 0; i <= DCEvar; i++) {
+          switch (DCEvars[i]) {
+          case 3: /* 80 columns */
+            setScreenSize(80, height, true);
+            break;
+          case 4: /* scrolling mode, smooth */
+            break;
+          case 5: /* light background */
+            break;
+          case 6: /* DECOM (Origin Mode) move inside margins. */
+            moveoutsidemargins = true;
+            break;
+          case 7: /* DECAWM: Autowrap Mode */
+            wraparound = false;
+            break;
+          case 12:/* local echo off */
+            break;
+          case 9: /* X10 mouse */
+          case 1000: /* xterm style mouse report on */
+          case 1001:
+          case 1002:
+          case 1003:
+            mouserpt = DCEvars[i];
+            break;
+          default:
+            debug("ESC [ ? " + DCEvars[0] + " r, unimplemented!");
+          }
+        }
+        break;
+      case 'h': // DECSET
+        if (debug > 0) {
+          debug("ESC [ ? " + DCEvars[0] + " h");
+        }
+        /* DEC Mode set */
+        for (int i = 0; i <= DCEvar; i++) {
+          switch (DCEvars[i]) {
+          case 1: /* Application cursor keys */
+            KeyUp[0] = "\u001bOA";
+            KeyDown[0] = "\u001bOB";
+            KeyRight[0] = "\u001bOC";
+            KeyLeft[0] = "\u001bOD";
+            break;
+          case 2: /* DECANM */
+            vt52mode = false;
+            break;
+          case 3: /* 132 columns */
+            setScreenSize(132, height, true);
+            break;
+          case 6: /* DECOM: move inside margins. */
+            moveoutsidemargins = false;
+            break;
+          case 7: /* DECAWM: Autowrap Mode */
+            wraparound = true;
+            break;
+          case 25: /* turn cursor on */
+            showCursor(true);
+            break;
+          case 9: /* X10 mouse */
+          case 1000: /* xterm style mouse report on */
+          case 1001:
+          case 1002:
+          case 1003:
+            mouserpt = DCEvars[i];
+            break;
+
+          /* unimplemented stuff, fall through */
+          /* 4 - scrolling mode, smooth */
+          /* 5 - light background */
+          /* 12 - local echo off */
+          /* 18 - DECPFF - Printer Form Feed Mode -> On */
+          /* 19 - DECPEX - Printer Extent Mode -> Screen */
+          default:
+            debug("ESC [ ? " + DCEvars[0] + " h, unsupported.");
+            break;
+          }
+        }
+        break;
+      case 'i': // DEC Printer Control, autoprint, echo screenchars to printer
+        // This is different to CSI i!
+        // Also: "Autoprint prints a final display line only when the
+        // cursor is moved off the line by an autowrap or LF, FF, or
+        // VT (otherwise do not print the line)."
+        switch (DCEvars[0]) {
+        case 1:
+          if (debug > 1) {
+            debug("CSI ? 1 i : Print line containing cursor");
+          }
+          break;
+        case 4:
+          if (debug > 1) {
+            debug("CSI ? 4 i : Start passthrough printing");
+          }
+          break;
+        case 5:
+          if (debug > 1) {
+            debug("CSI ? 4 i : Stop passthrough printing");
+          }
+          break;
+        }
+        break;
+      case 'l': // DECRST
+        /* DEC Mode reset */
+        if (debug > 0) {
+          debug("ESC [ ? " + DCEvars[0] + " l");
+        }
+        for (int i = 0; i <= DCEvar; i++) {
+          switch (DCEvars[i]) {
+          case 1: /* Application cursor keys */
+            KeyUp[0] = "\u001b[A";
+            KeyDown[0] = "\u001b[B";
+            KeyRight[0] = "\u001b[C";
+            KeyLeft[0] = "\u001b[D";
+            break;
+          case 2: /* DECANM */
+            vt52mode = true;
+            break;
+          case 3: /* 80 columns */
+            setScreenSize(80, height, true);
+            break;
+          case 6: /* DECOM: move outside margins. */
+            moveoutsidemargins = true;
+            break;
+          case 7: /* DECAWM: Autowrap Mode OFF */
+            wraparound = false;
+            break;
+          case 25: /* turn cursor off */
+            showCursor(false);
+            break;
+          /* Unimplemented stuff: */
+          /* 4 - scrolling mode, jump */
+          /* 5 - dark background */
+          /* 7 - DECAWM - no wrap around mode */
+          /* 12 - local echo on */
+          /* 18 - DECPFF - Printer Form Feed Mode -> Off */
+          /* 19 - DECPEX - Printer Extent Mode -> Scrolling Region */
+          case 9: /* X10 mouse */
+          case 1000: /* xterm style mouse report OFF */
+          case 1001:
+          case 1002:
+          case 1003:
+            mouserpt = 0;
+            break;
+          default:
+            debug("ESC [ ? " + DCEvars[0] + " l, unsupported.");
+            break;
+          }
+        }
+        break;
+      case 'n':
+        if (debug > 0) {
+          debug("ESC [ ? " + DCEvars[0] + " n");
+        }
+        switch (DCEvars[0]) {
+        case 15:
+          /* printer? no printer. */
+          write((ESC) + "[?13n", false);
+          debug("ESC[5n");
+          break;
+        default:
+          debug("ESC [ ? " + DCEvars[0] + " n, unsupported.");
+          break;
+        }
+        break;
+      default:
+        debug("ESC [ ? " + DCEvars[0] + " " + c + ", unsupported.");
+        break;
+      }
+      break;
+    case TSTATE_CSI_EX:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case ESC:
+        term_state = TSTATE_ESC;
+        break;
+      default:
+        debug("Unknown character ESC[! character is " + (int) c);
+        break;
+      }
+      break;
+    case TSTATE_CSI_TICKS:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case 'p':
+        debug("Conformance level: " + DCEvars[0] + " (unsupported)," + DCEvars[1]);
+        if (DCEvars[0] == 61) {
+          output8bit = false;
+          break;
+        }
+        if (DCEvars[1] == 1) {
+          output8bit = false;
+        } else {
+          output8bit = true; /* 0 or 2 */
+        }
+        break;
+      default:
+        debug("Unknown ESC [...  \"" + c);
+        break;
+      }
+      break;
+    case TSTATE_CSI_EQUAL:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+        DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
+        term_state = TSTATE_CSI_EQUAL;
+        break;
+      case ';':
+        DCEvar++;
+        DCEvars[DCEvar] = 0;
+        term_state = TSTATE_CSI_EQUAL;
+        break;
+
+      case 'F': /* SCO ANSI foreground */
+      {
+        int newcolor;
+
+        debug("ESC [ = " + DCEvars[0] + " F");
+
+        attributes &= ~COLOR_FG;
+        newcolor = ((DCEvars[0] & 1) << 2) | (DCEvars[0] & 2) | ((DCEvars[0] & 4) >> 2);
+        attributes |= (newcolor + 1) << COLOR_FG_SHIFT;
+
+        break;
+      }
+      case 'G': /* SCO ANSI background */
+      {
+        int newcolor;
+
+        debug("ESC [ = " + DCEvars[0] + " G");
+
+        attributes &= ~COLOR_BG;
+        newcolor = ((DCEvars[0] & 1) << 2) | (DCEvars[0] & 2) | ((DCEvars[0] & 4) >> 2);
+        attributes |= (newcolor + 1) << COLOR_BG_SHIFT;
+        break;
+      }
+
+      default:
+        debugStr.append("Unknown ESC [ = ");
+        for (int i = 0; i <= DCEvar; i++) {
+          debugStr.append(DCEvars[i]).append(',');
+        }
+        debugStr.append(c);
+        debug(debugStr.toString());
+        debugStr.setLength(0);
+        break;
+      }
+      break;
+    case TSTATE_CSI_DOLLAR:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case '}':
+        debug("Active Status Display now " + DCEvars[0]);
+        statusmode = DCEvars[0];
+        break;
+      /*
+       * bad documentation? case '-': debug("Set Status Display now "+DCEvars[0]); break;
+       */
+      case '~':
+        debug("Status Line mode now " + DCEvars[0]);
+        break;
+      default:
+        debug("UNKNOWN Status Display code " + c + ", with Pn=" + DCEvars[0]);
+        break;
+      }
+      break;
+    case TSTATE_CSI:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case '"':
+        term_state = TSTATE_CSI_TICKS;
+        break;
+      case '$':
+        term_state = TSTATE_CSI_DOLLAR;
+        break;
+      case '=':
+        term_state = TSTATE_CSI_EQUAL;
+        break;
+      case '!':
+        term_state = TSTATE_CSI_EX;
+        break;
+      case '?':
+        DCEvar = 0;
+        DCEvars[0] = 0;
+        term_state = TSTATE_DCEQ;
+        break;
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+        DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
+        term_state = TSTATE_CSI;
+        break;
+      case ';':
+        DCEvar++;
+        DCEvars[DCEvar] = 0;
+        term_state = TSTATE_CSI;
+        break;
+      case 'c':/* send primary device attributes */
+        /* send (ESC[?61c) */
+
+        String subcode = "";
+        if (terminalID.equals("vt320")) {
+          subcode = "63;";
+        }
+        if (terminalID.equals("vt220")) {
+          subcode = "62;";
+        }
+        if (terminalID.equals("vt100")) {
+          subcode = "61;";
+        }
+        write((ESC) + "[?" + subcode + "1;2c", false);
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " c");
+        }
+        break;
+      case 'q':
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " q");
+        }
+        break;
+      case 'g':
+        /* used for tabsets */
+        switch (DCEvars[0]) {
+        case 3:/* clear them */
+          Tabs = new byte[width];
+          break;
+        case 0:
+          Tabs[C] = 0;
+          break;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " g");
+        }
+        break;
+      case 'h':
+        switch (DCEvars[0]) {
+        case 4:
+          insertmode = 1;
+          break;
+        case 20:
+          debug("Setting CRLF to TRUE");
+          sendcrlf = true;
+          break;
+        default:
+          debug("unsupported: ESC [ " + DCEvars[0] + " h");
+          break;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " h");
+        }
+        break;
+      case 'i': // Printer Controller mode.
+        // "Transparent printing sends all output, except the CSI 4 i
+        // termination string, to the printer and not the screen,
+        // uses an 8-bit channel if no parity so NUL and DEL will be
+        // seen by the printer and by the termination recognizer code,
+        // and all translation and character set selections are
+        // bypassed."
+        switch (DCEvars[0]) {
+        case 0:
+          if (debug > 1) {
+            debug("CSI 0 i:  Print Screen, not implemented.");
+          }
+          break;
+        case 4:
+          if (debug > 1) {
+            debug("CSI 4 i:  Enable Transparent Printing, not implemented.");
+          }
+          break;
+        case 5:
+          if (debug > 1) {
+            debug("CSI 4/5 i:  Disable Transparent Printing, not implemented.");
+          }
+          break;
+        default:
+          debug("ESC [ " + DCEvars[0] + " i, unimplemented!");
+        }
+        break;
+      case 'l':
+        switch (DCEvars[0]) {
+        case 4:
+          insertmode = 0;
+          break;
+        case 20:
+          debug("Setting CRLF to FALSE");
+          sendcrlf = false;
+          break;
+        default:
+          debug("ESC [ " + DCEvars[0] + " l, unimplemented!");
+          break;
+        }
+        break;
+      case 'A': // CUU
+      {
+        int limit;
+        /* FIXME: xterm only cares about 0 and topmargin */
+        if (R >= getTopMargin()) {
+          limit = getTopMargin();
+        } else {
+          limit = 0;
+        }
+        if (DCEvars[0] == 0) {
+          R--;
+        } else {
+          R -= DCEvars[0];
+        }
+        if (R < limit) {
+          R = limit;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " A");
+        }
+        break;
+      }
+      case 'B': // CUD
+        /* cursor down n (1) times */
+      {
+        int limit;
+        if (R <= getBottomMargin()) {
+          limit = getBottomMargin();
+        } else {
+          limit = rows - 1;
+        }
+        if (DCEvars[0] == 0) {
+          R++;
+        } else {
+          R += DCEvars[0];
+        }
+        if (R > limit) {
+          R = limit;
+        } else {
+          if (debug > 2) {
+            debug("Not limited.");
+          }
+        }
+        if (debug > 2) {
+          debug("to: " + R);
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " B (at C=" + C + ")");
+        }
+        break;
+      }
+      case 'C':
+        if (DCEvars[0] == 0) {
+          DCEvars[0] = 1;
+        }
+        while (DCEvars[0]-- > 0) {
+          C++;
+        }
+        if (C >= columns) {
+          C = columns - 1;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " C");
+        }
+        break;
+      case 'd': // CVA
+        R = DCEvars[0];
+        if (R < 0) {
+          R = 0;
+        } else if (R >= height) {
+          R = height - 1;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " d");
+        }
+        break;
+      case 'D':
+        if (DCEvars[0] == 0) {
+          DCEvars[0] = 1;
+        }
+        while (DCEvars[0]-- > 0) {
+          C--;
+        }
+        if (C < 0) {
+          C = 0;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " D");
+        }
+        break;
+      case 'r': // DECSTBM
+        if (DCEvar > 0) // Ray: Any argument is optional
+        {
+          R = DCEvars[1] - 1;
+          if (R < 0) {
+            R = rows - 1;
+          } else if (R >= rows) {
+            R = rows - 1;
+          }
+        } else {
+          R = rows - 1;
+        }
+        int bot = R;
+        if (R >= DCEvars[0]) {
+          R = DCEvars[0] - 1;
+          if (R < 0) {
+            R = 0;
+          }
+        }
+        setMargins(R, bot);
+        _SetCursor(0, 0);
+        if (debug > 1) {
+          debug("ESC [" + DCEvars[0] + " ; " + DCEvars[1] + " r");
+        }
+        break;
+      case 'G': /* CUP / cursor absolute column */
+        C = DCEvars[0];
+        if (C < 0) {
+          C = 0;
+        } else if (C >= width) {
+          C = width - 1;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " G");
+        }
+        break;
+      case 'H': /* CUP / cursor position */
+        /* gets 2 arguments */
+        _SetCursor(DCEvars[0] - 1, DCEvars[1] - 1);
+        if (debug > 2) {
+          debug("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " H, moveoutsidemargins "
+              + moveoutsidemargins);
+          debug("	-> R now " + R + ", C now " + C);
+        }
+        break;
+      case 'f': /* move cursor 2 */
+        /* gets 2 arguments */
+        R = DCEvars[0] - 1;
+        C = DCEvars[1] - 1;
+        if (C < 0) {
+          C = 0;
+        } else if (C >= width) {
+          C = width - 1;
+        }
+        if (R < 0) {
+          R = 0;
+        } else if (R >= height) {
+          R = height - 1;
+        }
+        if (debug > 2) {
+          debug("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " f");
+        }
+        break;
+      case 'S': /* ind aka 'scroll forward' */
+        if (DCEvars[0] == 0) {
+          insertLine(rows - 1, SCROLL_UP);
+        } else {
+          insertLine(rows - 1, DCEvars[0], SCROLL_UP);
+        }
+        break;
+      case 'L':
+        /* insert n lines */
+        if (DCEvars[0] == 0) {
+          insertLine(R, SCROLL_DOWN);
+        } else {
+          insertLine(R, DCEvars[0], SCROLL_DOWN);
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + "" + (c) + " (at R " + R + ")");
+        }
+        break;
+      case 'T': /* 'ri' aka scroll backward */
+        if (DCEvars[0] == 0) {
+          insertLine(0, SCROLL_DOWN);
+        } else {
+          insertLine(0, DCEvars[0], SCROLL_DOWN);
+        }
+        break;
+      case 'M':
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + "" + (c) + " at R=" + R);
+        }
+        if (DCEvars[0] == 0) {
+          deleteLine(R);
+        } else {
+          for (int i = 0; i < DCEvars[0]; i++) {
+            deleteLine(R);
+          }
+        }
+        break;
+      case 'K':
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " K");
+        }
+        /* clear in line */
+        switch (DCEvars[0]) {
+        case 6: /* 97801 uses ESC[6K for delete to end of line */
+        case 0:/* clear to right */
+          if (C < columns - 1) {
+            deleteArea(C, R, columns - C, 1, attributes);
+          }
+          break;
+        case 1:/* clear to the left, including this */
+          if (C > 0) {
+            deleteArea(0, R, C + 1, 1, attributes);
+          }
+          break;
+        case 2:/* clear whole line */
+          deleteArea(0, R, columns, 1, attributes);
+          break;
+        }
+        break;
+      case 'J':
+        /* clear below current line */
+        switch (DCEvars[0]) {
+        case 0:
+          if (R < rows - 1) {
+            deleteArea(0, R + 1, columns, rows - R - 1, attributes);
+          }
+          if (C < columns - 1) {
+            deleteArea(C, R, columns - C, 1, attributes);
+          }
+          break;
+        case 1:
+          if (R > 0) {
+            deleteArea(0, 0, columns, R, attributes);
+          }
+          if (C > 0) {
+            deleteArea(0, R, C + 1, 1, attributes);// include up to and including current
+          }
+          break;
+        case 2:
+          deleteArea(0, 0, columns, rows, attributes);
+          break;
+        }
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " J");
+        }
+        break;
+      case '@':
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " @");
+        }
+        for (int i = 0; i < DCEvars[0]; i++) {
+          insertChar(C, R, ' ', attributes);
+        }
+        break;
+      case 'X': {
+        int toerase = DCEvars[0];
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " X, C=" + C + ",R=" + R);
+        }
+        if (toerase == 0) {
+          toerase = 1;
+        }
+        if (toerase + C > columns) {
+          toerase = columns - C;
+        }
+        deleteArea(C, R, toerase, 1, attributes);
+        // does not change cursor position
+        break;
+      }
+      case 'P':
+        if (debug > 1) {
+          debug("ESC [ " + DCEvars[0] + " P, C=" + C + ",R=" + R);
+        }
+        if (DCEvars[0] == 0) {
+          DCEvars[0] = 1;
+        }
+        for (int i = 0; i < DCEvars[0]; i++) {
+          deleteChar(C, R);
+        }
+        break;
+      case 'n':
+        switch (DCEvars[0]) {
+        case 5: /* malfunction? No malfunction. */
+          writeSpecial((ESC) + "[0n");
+          if (debug > 1) {
+            debug("ESC[5n");
+          }
+          break;
+        case 6:
+          // DO NOT offset R and C by 1! (checked against /usr/X11R6/bin/resize
+          // FIXME check again.
+          // FIXME: but vttest thinks different???
+          writeSpecial((ESC) + "[" + R + ";" + C + "R");
+          if (debug > 1) {
+            debug("ESC[6n");
+          }
+          break;
+        default:
+          if (debug > 0) {
+            debug("ESC [ " + DCEvars[0] + " n??");
+          }
+          break;
+        }
+        break;
+      case 's': /* DECSC - save cursor */
+        Sc = C;
+        Sr = R;
+        Sa = attributes;
+        if (debug > 3) {
+          debug("ESC[s");
+        }
+        break;
+      case 'u': /* DECRC - restore cursor */
+        C = Sc;
+        R = Sr;
+        attributes = Sa;
+        if (debug > 3) {
+          debug("ESC[u");
+        }
+        break;
+      case 'm': /* attributes as color, bold , blink, */
+        if (debug > 3) {
+          debug("ESC [ ");
+        }
+        if (DCEvar == 0 && DCEvars[0] == 0) {
+          attributes = 0;
+        }
+        for (int i = 0; i <= DCEvar; i++) {
+          switch (DCEvars[i]) {
+          case 0:
+            if (DCEvar > 0) {
+              if (terminalID.equals("scoansi")) {
+                attributes &= COLOR; /* Keeps color. Strange but true. */
+              } else {
+                attributes = 0;
+              }
+            }
+            break;
+          case 1:
+            attributes |= BOLD;
+            attributes &= ~LOW;
+            break;
+          case 2:
+            /* SCO color hack mode */
+            if (terminalID.equals("scoansi") && ((DCEvar - i) >= 2)) {
+              int ncolor;
+              attributes &= ~(COLOR | BOLD);
+
+              ncolor = DCEvars[i + 1];
+              if ((ncolor & 8) == 8) {
+                attributes |= BOLD;
+              }
+              ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
+              attributes |= ((ncolor) + 1) << COLOR_FG_SHIFT;
+              ncolor = DCEvars[i + 2];
+              ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
+              attributes |= ((ncolor) + 1) << COLOR_BG_SHIFT;
+              i += 2;
+            } else {
+              attributes |= LOW;
+            }
+            break;
+          case 3: /* italics */
+            attributes |= INVERT;
+            break;
+          case 4:
+            attributes |= UNDERLINE;
+            break;
+          case 7:
+            attributes |= INVERT;
+            break;
+          case 8:
+            attributes |= INVISIBLE;
+            break;
+          case 5: /* blink on */
+            break;
+          /*
+           * 10 - ANSI X3.64-1979, select primary font, don't display control chars, don't set bit 8
+           * on output
+           */
+          case 10:
+            gl = 0;
+            usedcharsets = true;
+            break;
+          /*
+           * 11 - ANSI X3.64-1979, select second alt. font, display control chars, set bit 8 on
+           * output
+           */
+          case 11: /* SMACS , as */
+          case 12:
+            gl = 1;
+            usedcharsets = true;
+            break;
+          case 21: /* normal intensity */
+            attributes &= ~(LOW | BOLD);
+            break;
+          case 23: /* italics off */
+            attributes &= ~INVERT;
+            break;
+          case 25: /* blinking off */
+            break;
+          case 27:
+            attributes &= ~INVERT;
+            break;
+          case 28:
+            attributes &= ~INVISIBLE;
+            break;
+          case 24:
+            attributes &= ~UNDERLINE;
+            break;
+          case 22:
+            attributes &= ~BOLD;
+            break;
+          case 30:
+          case 31:
+          case 32:
+          case 33:
+          case 34:
+          case 35:
+          case 36:
+          case 37:
+            attributes &= ~COLOR_FG;
+            attributes |= ((DCEvars[i] - 30) + 1) << COLOR_FG_SHIFT;
+            break;
+          case 38:
+            if (DCEvars[i + 1] == 5) {
+              attributes &= ~COLOR_FG;
+              attributes |= ((DCEvars[i + 2]) + 1) << COLOR_FG_SHIFT;
+              i += 2;
+            }
+            break;
+          case 39:
+            attributes &= ~COLOR_FG;
+            break;
+          case 40:
+          case 41:
+          case 42:
+          case 43:
+          case 44:
+          case 45:
+          case 46:
+          case 47:
+            attributes &= ~COLOR_BG;
+            attributes |= ((DCEvars[i] - 40) + 1) << COLOR_BG_SHIFT;
+            break;
+          case 48:
+            if (DCEvars[i + 1] == 5) {
+              attributes &= ~COLOR_BG;
+              attributes |= (DCEvars[i + 2] + 1) << COLOR_BG_SHIFT;
+              i += 2;
+            }
+            break;
+          case 49:
+            attributes &= ~COLOR_BG;
+            break;
+          case 90:
+          case 91:
+          case 92:
+          case 93:
+          case 94:
+          case 95:
+          case 96:
+          case 97:
+            attributes &= ~COLOR_FG;
+            attributes |= ((DCEvars[i] - 82) + 1) << COLOR_FG_SHIFT;
+            break;
+          case 100:
+          case 101:
+          case 102:
+          case 103:
+          case 104:
+          case 105:
+          case 106:
+          case 107:
+            attributes &= ~COLOR_BG;
+            attributes |= ((DCEvars[i] - 92) + 1) << COLOR_BG_SHIFT;
+            break;
+
+          default:
+            debugStr.append("ESC [ ").append(DCEvars[i]).append(" m unknown...");
+            debug(debugStr.toString());
+            debugStr.setLength(0);
+            break;
+          }
+          if (debug > 3) {
+            debugStr.append(DCEvars[i]).append(';');
+            debug(debugStr.toString());
+            debugStr.setLength(0);
+          }
+        }
+        if (debug > 3) {
+          debugStr.append(" (attributes = ").append(attributes).append(")m");
+          debug(debugStr.toString());
+          debugStr.setLength(0);
+        }
+        break;
+      default:
+        debugStr.append("ESC [ unknown letter: ").append(c).append(" (").append((int) c)
+            .append(')');
+        debug(debugStr.toString());
+        debugStr.setLength(0);
+        break;
+      }
+      break;
+    case TSTATE_TITLE:
+      switch (c) {
+      case ESC:
+        term_state = TSTATE_ESC;
+        break;
+      default:
+        // TODO save title
+        break;
+      }
+      break;
+    default:
+      term_state = TSTATE_DATA;
+      break;
+    }
+
+    setCursorPosition(C, R);
+  }
+
+  /* hard reset the terminal */
+  public void reset() {
+    gx[0] = 'B';
+    gx[1] = 'B';
+    gx[2] = 'B';
+    gx[3] = 'B';
+
+    gl = 0; // default GL to G0
+    gr = 2; // default GR to G2
+
+    onegl = -1; // Single shift override
+
+    /* reset tabs */
+    int nw = width;
+    if (nw < 132) {
+      nw = 132;
+    }
+    Tabs = new byte[nw];
+    for (int i = 0; i < nw; i += 8) {
+      Tabs[i] = 1;
+    }
+
+    deleteArea(0, 0, width, height, attributes);
+    setMargins(0, height);
+    C = R = 0;
+    _SetCursor(0, 0);
+
+    if (display != null) {
+      display.resetColors();
+    }
+
+    showCursor(true);
+    /* FIXME: */
+    term_state = TSTATE_DATA;
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/apache/harmony/niochar/charset/additional/IBM437.java b/ScriptingLayerForAndroid/src/org/apache/harmony/niochar/charset/additional/IBM437.java
new file mode 100644
index 0000000..1f01579
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/apache/harmony/niochar/charset/additional/IBM437.java
@@ -0,0 +1,423 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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.apache.harmony.niochar.charset.additional;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+
+/* TODO: support direct byte buffers
+import org.apache.harmony.nio.AddressUtil;
+import org.apache.harmony.niochar.CharsetProviderImpl;
+*/
+
+public class IBM437 extends Charset {
+
+        public IBM437(String csName, String[] aliases) {
+            super(csName, aliases);
+        }
+
+        public boolean contains(Charset cs) {
+            return cs.name().equalsIgnoreCase("IBM367") || cs.name().equalsIgnoreCase("IBM437") || cs.name().equalsIgnoreCase("US-ASCII") ;
+        }
+
+        public CharsetDecoder newDecoder() {
+            return new Decoder(this);
+        }
+
+        public CharsetEncoder newEncoder() {
+            return new Encoder(this);
+        }
+
+	private static final class Decoder extends CharsetDecoder{
+		private Decoder(Charset cs){
+			super(cs, 1, 1);
+
+		}
+
+		private native int nDecode(char[] array, int arrPosition, int remaining, long outAddr, int absolutePos);
+
+
+		protected CoderResult decodeLoop(ByteBuffer bb, CharBuffer cb){
+                        int cbRemaining = cb.remaining();
+/* TODO: support direct byte buffers
+		        if(CharsetProviderImpl.hasLoadedNatives() && bb.isDirect() && bb.hasRemaining() && cb.hasArray()){
+		            int toProceed = bb.remaining();
+		            int cbPos = cb.position();
+		            int bbPos = bb.position();
+		            boolean throwOverflow = false;
+		            if( cbRemaining < toProceed ) {
+		                toProceed = cbRemaining;
+                                throwOverflow = true;
+                            }
+                            int res = nDecode(cb.array(), cb.arrayOffset()+cbPos, toProceed, AddressUtil.getDirectBufferAddress(bb), bbPos);
+                            bb.position(bbPos+res);
+                            cb.position(cbPos+res);
+                            if(throwOverflow) return CoderResult.OVERFLOW;
+                        }else{
+*/
+                            if(bb.hasArray() && cb.hasArray()) {
+                                int rem = bb.remaining();
+                                rem = cbRemaining >= rem ? rem : cbRemaining;
+                                byte[] bArr = bb.array();
+                                char[] cArr = cb.array();
+                                int bStart = bb.position();
+                                int cStart = cb.position();
+                                int i;
+                                for(i=bStart; i<bStart+rem; i++) {
+                                    char in = (char)(bArr[i] & 0xFF);
+                                    if(in >= 26){
+                                        int index = (int)in - 26;
+                                        cArr[cStart++] = (char)arr[index];
+                                    }else {
+                                        cArr[cStart++] = (char)(in & 0xFF);
+                                    }
+                                }
+                                bb.position(i);
+                                cb.position(cStart);
+                                if(rem == cbRemaining && bb.hasRemaining()) return CoderResult.OVERFLOW;
+                            } else {
+                                while(bb.hasRemaining()){
+                                    if( cbRemaining == 0 ) return CoderResult.OVERFLOW;
+                                    char in = (char)(bb.get() & 0xFF);
+                                    if(in >= 26){
+                                        int index = (int)in - 26;
+                                        cb.put(arr[index]);
+                                    }else {
+                                        cb.put((char)(in & 0xFF));
+                                    }
+                                cbRemaining--;
+                                }
+/*
+                            }
+*/
+			}
+                        return CoderResult.UNDERFLOW;
+		}
+
+		final static char[] arr = {
+                0x001C,0x001B,0x007F,0x001D,0x001E,0x001F,
+                0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,
+                0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,
+                0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,
+                0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,
+                0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,
+                0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,
+                0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,
+                0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,
+                0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,
+                0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,
+                0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,
+                0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,0x001A,
+                0x00C7,0x00FC,0x00E9,0x00E2,0x00E4,0x00E0,0x00E5,0x00E7,
+                0x00EA,0x00EB,0x00E8,0x00EF,0x00EE,0x00EC,0x00C4,0x00C5,
+                0x00C9,0x00E6,0x00C6,0x00F4,0x00F6,0x00F2,0x00FB,0x00F9,
+                0x00FF,0x00D6,0x00DC,0x00A2,0x00A3,0x00A5,0x20A7,0x0192,
+                0x00E1,0x00ED,0x00F3,0x00FA,0x00F1,0x00D1,0x00AA,0x00BA,
+                0x00BF,0x2310,0x00AC,0x00BD,0x00BC,0x00A1,0x00AB,0x00BB,
+                0x2591,0x2592,0x2593,0x2502,0x2524,0x2561,0x2562,0x2556,
+                0x2555,0x2563,0x2551,0x2557,0x255D,0x255C,0x255B,0x2510,
+                0x2514,0x2534,0x252C,0x251C,0x2500,0x253C,0x255E,0x255F,
+                0x255A,0x2554,0x2569,0x2566,0x2560,0x2550,0x256C,0x2567,
+                0x2568,0x2564,0x2565,0x2559,0x2558,0x2552,0x2553,0x256B,
+                0x256A,0x2518,0x250C,0x2588,0x2584,0x258C,0x2590,0x2580,
+                0x03B1,0x00DF,0x0393,0x03C0,0x03A3,0x03C3,0x03BC,0x03C4,
+                0x03A6,0x0398,0x03A9,0x03B4,0x221E,0x03C6,0x03B5,0x2229,
+                0x2261,0x00B1,0x2265,0x2264,0x2320,0x2321,0x00F7,0x2248,
+                0x00B0,0x2219,0x00B7,0x221A,0x207F,0x00B2,0x25A0,0x00A0
+		};
+        }
+
+	private static final class Encoder extends CharsetEncoder{
+		private Encoder(Charset cs){
+			super(cs, 1, 1);
+		}
+
+		private native void nEncode(long outAddr, int absolutePos, char[] array, int arrPosition, int[] res);
+
+		protected CoderResult encodeLoop(CharBuffer cb, ByteBuffer bb){
+                        int bbRemaining = bb.remaining();
+/* TODO: support direct byte buffers
+                        if(CharsetProviderImpl.hasLoadedNatives() && bb.isDirect() && cb.hasRemaining() && cb.hasArray()){
+		            int toProceed = cb.remaining();
+		            int cbPos = cb.position();
+		            int bbPos = bb.position();
+		            boolean throwOverflow = false;
+		            if( bbRemaining < toProceed ) {
+		                toProceed = bbRemaining;
+                                throwOverflow = true;
+                            }
+                            int[] res = {toProceed, 0};
+                            nEncode(AddressUtil.getDirectBufferAddress(bb), bbPos, cb.array(), cb.arrayOffset()+cbPos, res);
+                            if( res[0] <= 0 ) {
+                                bb.position(bbPos-res[0]);
+                                cb.position(cbPos-res[0]);
+                                if(res[1]!=0) {
+                                    if(res[1] < 0)
+                                        return CoderResult.malformedForLength(-res[1]);
+                                    else
+                                        return CoderResult.unmappableForLength(res[1]);
+                                }
+                            }else{
+                                bb.position(bbPos+res[0]);
+                                cb.position(cbPos+res[0]);
+                                if(throwOverflow) return CoderResult.OVERFLOW;
+                            }
+                        }else{
+*/
+                            if(bb.hasArray() && cb.hasArray()) {
+                                byte[] byteArr = bb.array();
+                                char[] charArr = cb.array();
+                                int rem = cb.remaining();
+                                int byteArrStart = bb.position();
+                                rem = bbRemaining <= rem ? bbRemaining : rem;
+                                int x;
+                                for(x = cb.position(); x < cb.position()+rem; x++) {
+                                    char c = charArr[x];
+                                    if(c > (char)0x25A0){
+                                        if (c >= 0xD800 && c <= 0xDFFF) {
+                                            if(x+1 < cb.limit()) {
+                                                char c1 = charArr[x+1];
+                                                if(c1 >= 0xD800 && c1 <= 0xDFFF) {
+                                                    cb.position(x); bb.position(byteArrStart);
+                                                    return CoderResult.unmappableForLength(2);
+                                                }
+                                            } else {
+                                                cb.position(x); bb.position(byteArrStart);
+                                                return CoderResult.UNDERFLOW;
+                                            }
+                                            cb.position(x); bb.position(byteArrStart);
+                                            return CoderResult.malformedForLength(1);
+                                        }
+                                        cb.position(x); bb.position(byteArrStart);
+                                        return CoderResult.unmappableForLength(1);
+                                    }else{
+                                        if(c < 0x1A) {
+                                            byteArr[byteArrStart++] = (byte)c;
+                                        } else {
+                                            int index = (int)c >> 8;
+                                            index = encodeIndex[index];
+                                            if(index < 0) {
+                                                cb.position(x); bb.position(byteArrStart);
+                                                return CoderResult.unmappableForLength(1);
+                                            }
+                                            index <<= 8;
+                                            index += (int)c & 0xFF;
+                                            if((byte)arr[index] != 0){
+                                                byteArr[byteArrStart++] = (byte)arr[index];
+                                            }else{
+                                                cb.position(x); bb.position(byteArrStart);
+                                                return CoderResult.unmappableForLength(1);
+                                            }
+                                        }
+                                    }
+                                }
+                                cb.position(x);
+                                bb.position(byteArrStart);
+                                if(rem == bbRemaining && cb.hasRemaining()) {
+                                    return CoderResult.OVERFLOW;
+                                }
+                            } else {
+                                while(cb.hasRemaining()){
+                                    if( bbRemaining == 0 ) return CoderResult.OVERFLOW;
+                                    char c = cb.get();
+                                    if(c > (char)0x25A0){
+                                        if (c >= 0xD800 && c <= 0xDFFF) {
+                                            if(cb.hasRemaining()) {
+                                                char c1 = cb.get();
+                                                if(c1 >= 0xD800 && c1 <= 0xDFFF) {
+                                                    cb.position(cb.position()-2);
+                                                    return CoderResult.unmappableForLength(2);
+                                                } else {
+                                                    cb.position(cb.position()-1);
+                                                }
+                                            } else {
+                                                cb.position(cb.position()-1);
+                                                return CoderResult.UNDERFLOW;
+                                            }
+                                            cb.position(cb.position()-1);
+                                            return CoderResult.malformedForLength(1);
+                                        }
+                                        cb.position(cb.position()-1);
+                                        return CoderResult.unmappableForLength(1);
+                                    }else{
+                                        if(c < 0x1A) {
+                                            bb.put((byte)c);
+                                        } else {
+                                            int index = (int)c >> 8;
+                                            index = encodeIndex[index];
+                                            if(index < 0) {
+                                                cb.position(cb.position()-1);
+                                                return CoderResult.unmappableForLength(1);
+                                            }
+                                            index <<= 8;
+                                            index += (int)c & 0xFF;
+                                            if((byte)arr[index] != 0){
+                                                bb.put((byte)arr[index]);
+                                            }else{
+                                                cb.position(cb.position()-1);
+                                                return CoderResult.unmappableForLength(1);
+                                            }
+                                        }
+                                        bbRemaining--;
+                                    }
+                                }
+/* TODO: support direct byte buffers
+			    }
+*/
+			}
+			return CoderResult.UNDERFLOW;
+		}
+
+                final static char arr[] = {
+
+                0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
+                0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x7F,0x1B,0x1A,0x1D,0x1E,0x1F,
+                0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
+                0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
+                0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
+                0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
+                0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+                0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x1C,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0xFF,0xAD,0x9B,0x9C,0x00,0x9D,0x00,0x00,0x00,0x00,0xA6,0xAE,0xAA,0x00,0x00,0x00,
+                0xF8,0xF1,0xFD,0x00,0x00,0x00,0x00,0xFA,0x00,0x00,0xA7,0xAF,0xAC,0xAB,0x00,0xA8,
+                0x00,0x00,0x00,0x00,0x8E,0x8F,0x92,0x80,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0xA5,0x00,0x00,0x00,0x00,0x99,0x00,0x00,0x00,0x00,0x00,0x9A,0x00,0x00,0xE1,
+                0x85,0xA0,0x83,0x00,0x84,0x86,0x91,0x87,0x8A,0x82,0x88,0x89,0x8D,0xA1,0x8C,0x8B,
+                0x00,0xA4,0x95,0xA2,0x93,0x00,0x94,0xF6,0x00,0x97,0xA3,0x96,0x81,0x00,0x00,0x98,
+
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x9F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0xE2,0x00,0x00,0x00,0x00,0xE9,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0xE4,0x00,0x00,0xE8,0x00,0x00,0xEA,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0xE0,0x00,0x00,0xEB,0xEE,0x00,0x00,0x00,0x00,0x00,0x00,0xE6,0x00,0x00,0x00,
+                0xE3,0x00,0x00,0xE5,0xE7,0x00,0xED,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x9E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF9,0xFB,0x00,0x00,0x00,0xEC,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xEF,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0xF0,0x00,0x00,0xF3,0xF2,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0xA9,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0xF4,0xF5,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+                0xC4,0x00,0xB3,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xDA,0x00,0x00,0x00,
+                0xBF,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0xD9,0x00,0x00,0x00,0xC3,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0xB4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC2,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0xC1,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC5,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0xCD,0xBA,0xD5,0xD6,0xC9,0xB8,0xB7,0xBB,0xD4,0xD3,0xC8,0xBE,0xBD,0xBC,0xC6,0xC7,
+                0xCC,0xB5,0xB6,0xB9,0xD1,0xD2,0xCB,0xCF,0xD0,0xCA,0xD8,0xD7,0xCE,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0xDF,0x00,0x00,0x00,0xDC,0x00,0x00,0x00,0xDB,0x00,0x00,0x00,0xDD,0x00,0x00,0x00,
+                0xDE,0xB0,0xB1,0xB2,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+                };
+
+                final static int[] encodeIndex = {
+                 0,1,-1,2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                 3,-1,4,5,-1,6,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                };
+	}
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/ConsoleActivity.java b/ScriptingLayerForAndroid/src/org/connectbot/ConsoleActivity.java
new file mode 100644
index 0000000..bb4490a
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/ConsoleActivity.java
@@ -0,0 +1,985 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.
+ */
+
+/**
+ * @author modified by raaar
+ *
+ */
+
+package org.connectbot;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.content.SharedPreferences;
+import android.content.pm.ActivityInfo;
+import android.content.res.Configuration;
+import android.media.AudioManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.PowerManager;
+import android.preference.PreferenceManager;
+import android.text.ClipboardManager;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.GestureDetector;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnTouchListener;
+import android.view.ViewConfiguration;
+import android.view.WindowManager;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+import android.widget.ViewFlipper;
+
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.ScriptProcess;
+import com.googlecode.android_scripting.activity.Preferences;
+import com.googlecode.android_scripting.activity.ScriptingLayerService;
+
+import de.mud.terminal.VDUBuffer;
+import de.mud.terminal.vt320;
+
+import org.connectbot.service.PromptHelper;
+import org.connectbot.service.TerminalBridge;
+import org.connectbot.service.TerminalManager;
+import org.connectbot.util.PreferenceConstants;
+import org.connectbot.util.SelectionArea;
+
+public class ConsoleActivity extends Activity {
+
+  protected static final int REQUEST_EDIT = 1;
+
+  private static final int CLICK_TIME = 250;
+  private static final float MAX_CLICK_DISTANCE = 25f;
+  private static final int KEYBOARD_DISPLAY_TIME = 1250;
+
+  // Direction to shift the ViewFlipper
+  private static final int SHIFT_LEFT = 0;
+  private static final int SHIFT_RIGHT = 1;
+
+  protected ViewFlipper flip = null;
+  protected TerminalManager manager = null;
+  protected ScriptingLayerService mService = null;
+  protected LayoutInflater inflater = null;
+
+  private SharedPreferences prefs = null;
+
+  private PowerManager.WakeLock wakelock = null;
+
+  protected Integer processID;
+
+  protected ClipboardManager clipboard;
+
+  private RelativeLayout booleanPromptGroup;
+  private TextView booleanPrompt;
+  private Button booleanYes, booleanNo;
+
+  private Animation slide_left_in, slide_left_out, slide_right_in, slide_right_out,
+      fade_stay_hidden, fade_out_delayed;
+
+  private Animation keyboard_fade_in, keyboard_fade_out;
+  private ImageView keyboardButton;
+  private float lastX, lastY;
+
+  private int mTouchSlopSquare;
+
+  private InputMethodManager inputManager;
+
+  protected TerminalBridge copySource = null;
+  private int lastTouchRow, lastTouchCol;
+
+  private boolean forcedOrientation;
+
+  private Handler handler = new Handler();
+
+  private static enum MenuId {
+    EDIT, PREFS, EMAIL, RESIZE, COPY, PASTE;
+    public int getId() {
+      return ordinal() + Menu.FIRST;
+    }
+  }
+
+  private final ServiceConnection mConnection = new ServiceConnection() {
+    @Override
+    public void onServiceConnected(ComponentName name, IBinder service) {
+      mService = ((ScriptingLayerService.LocalBinder) service).getService();
+      manager = mService.getTerminalManager();
+      // let manager know about our event handling services
+      manager.setDisconnectHandler(disconnectHandler);
+
+      Log.d(String.format("Connected to TerminalManager and found bridges.size=%d", manager
+          .getBridgeList().size()));
+
+      manager.setResizeAllowed(true);
+
+      // clear out any existing bridges and record requested index
+      flip.removeAllViews();
+
+      int requestedIndex = 0;
+
+      TerminalBridge requestedBridge = manager.getConnectedBridge(processID);
+
+      // If we didn't find the requested connection, try opening it
+      if (processID != null && requestedBridge == null) {
+        try {
+          Log.d(String.format(
+              "We couldnt find an existing bridge with id = %d, so creating one now", processID));
+          requestedBridge = manager.openConnection(processID);
+        } catch (Exception e) {
+          Log.e("Problem while trying to create new requested bridge", e);
+        }
+      }
+
+      // create views for all bridges on this service
+      for (TerminalBridge bridge : manager.getBridgeList()) {
+
+        final int currentIndex = addNewTerminalView(bridge);
+
+        // check to see if this bridge was requested
+        if (bridge == requestedBridge) {
+          requestedIndex = currentIndex;
+        }
+      }
+
+      setDisplayedTerminal(requestedIndex);
+    }
+
+    @Override
+    public void onServiceDisconnected(ComponentName name) {
+      manager = null;
+      mService = null;
+    }
+  };
+
+  protected Handler promptHandler = new Handler() {
+    @Override
+    public void handleMessage(Message msg) {
+      // someone below us requested to display a prompt
+      updatePromptVisible();
+    }
+  };
+
+  protected Handler disconnectHandler = new Handler() {
+    @Override
+    public void handleMessage(Message msg) {
+      Log.d("Someone sending HANDLE_DISCONNECT to parentHandler");
+      TerminalBridge bridge = (TerminalBridge) msg.obj;
+      closeBridge(bridge);
+    }
+  };
+
+  /**
+   * @param bridge
+   */
+  private void closeBridge(final TerminalBridge bridge) {
+    synchronized (flip) {
+      final int flipIndex = getFlipIndex(bridge);
+
+      if (flipIndex >= 0) {
+        if (flip.getDisplayedChild() == flipIndex) {
+          shiftCurrentTerminal(SHIFT_LEFT);
+        }
+        flip.removeViewAt(flipIndex);
+
+        /*
+         * TODO Remove this workaround when ViewFlipper is fixed to listen to view removals. Android
+         * Issue 1784
+         */
+        final int numChildren = flip.getChildCount();
+        if (flip.getDisplayedChild() >= numChildren && numChildren > 0) {
+          flip.setDisplayedChild(numChildren - 1);
+        }
+      }
+
+      // If we just closed the last bridge, go back to the previous activity.
+      if (flip.getChildCount() == 0) {
+        finish();
+      }
+    }
+  }
+
+  protected View findCurrentView(int id) {
+    View view = flip.getCurrentView();
+    if (view == null) {
+      return null;
+    }
+    return view.findViewById(id);
+  }
+
+  protected PromptHelper getCurrentPromptHelper() {
+    View view = findCurrentView(R.id.console_flip);
+    if (!(view instanceof TerminalView)) {
+      return null;
+    }
+    return ((TerminalView) view).bridge.getPromptHelper();
+  }
+
+  protected void hideAllPrompts() {
+    booleanPromptGroup.setVisibility(View.GONE);
+  }
+
+  @Override
+  public void onCreate(Bundle icicle) {
+    super.onCreate(icicle);
+
+    this.setContentView(R.layout.act_console);
+
+    clipboard = (ClipboardManager) getSystemService(CLIPBOARD_SERVICE);
+    prefs = PreferenceManager.getDefaultSharedPreferences(this);
+
+    // hide status bar if requested by user
+    if (prefs.getBoolean(PreferenceConstants.FULLSCREEN, false)) {
+      getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
+          WindowManager.LayoutParams.FLAG_FULLSCREEN);
+    }
+
+    // TODO find proper way to disable volume key beep if it exists.
+    setVolumeControlStream(AudioManager.STREAM_MUSIC);
+
+    PowerManager manager = (PowerManager) getSystemService(Context.POWER_SERVICE);
+    wakelock = manager.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK, getPackageName());
+
+    // handle requested console from incoming intent
+    int id = getIntent().getIntExtra(Constants.EXTRA_PROXY_PORT, -1);
+
+    if (id > 0) {
+      processID = id;
+    }
+
+    inflater = LayoutInflater.from(this);
+
+    flip = (ViewFlipper) findViewById(R.id.console_flip);
+    booleanPromptGroup = (RelativeLayout) findViewById(R.id.console_boolean_group);
+    booleanPrompt = (TextView) findViewById(R.id.console_prompt);
+
+    booleanYes = (Button) findViewById(R.id.console_prompt_yes);
+    booleanYes.setOnClickListener(new OnClickListener() {
+      public void onClick(View v) {
+        PromptHelper helper = getCurrentPromptHelper();
+        if (helper == null) {
+          return;
+        }
+        helper.setResponse(Boolean.TRUE);
+        updatePromptVisible();
+      }
+    });
+
+    booleanNo = (Button) findViewById(R.id.console_prompt_no);
+    booleanNo.setOnClickListener(new OnClickListener() {
+      public void onClick(View v) {
+        PromptHelper helper = getCurrentPromptHelper();
+        if (helper == null) {
+          return;
+        }
+        helper.setResponse(Boolean.FALSE);
+        updatePromptVisible();
+      }
+    });
+
+    // preload animations for terminal switching
+    slide_left_in = AnimationUtils.loadAnimation(this, R.anim.slide_left_in);
+    slide_left_out = AnimationUtils.loadAnimation(this, R.anim.slide_left_out);
+    slide_right_in = AnimationUtils.loadAnimation(this, R.anim.slide_right_in);
+    slide_right_out = AnimationUtils.loadAnimation(this, R.anim.slide_right_out);
+
+    fade_out_delayed = AnimationUtils.loadAnimation(this, R.anim.fade_out_delayed);
+    fade_stay_hidden = AnimationUtils.loadAnimation(this, R.anim.fade_stay_hidden);
+
+    // Preload animation for keyboard button
+    keyboard_fade_in = AnimationUtils.loadAnimation(this, R.anim.keyboard_fade_in);
+    keyboard_fade_out = AnimationUtils.loadAnimation(this, R.anim.keyboard_fade_out);
+
+    inputManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+    keyboardButton = (ImageView) findViewById(R.id.keyboard_button);
+    keyboardButton.setOnClickListener(new OnClickListener() {
+      public void onClick(View view) {
+        View flip = findCurrentView(R.id.console_flip);
+        if (flip == null) {
+          return;
+        }
+
+        inputManager.showSoftInput(flip, InputMethodManager.SHOW_FORCED);
+        keyboardButton.setVisibility(View.GONE);
+      }
+    });
+    if (prefs.getBoolean(PreferenceConstants.HIDE_KEYBOARD, false)) {
+      // Force hidden keyboard.
+      getWindow().setSoftInputMode(
+          WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
+              | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+    }
+    final ViewConfiguration configuration = ViewConfiguration.get(this);
+    int touchSlop = configuration.getScaledTouchSlop();
+    mTouchSlopSquare = touchSlop * touchSlop;
+
+    // detect fling gestures to switch between terminals
+    final GestureDetector detect =
+        new GestureDetector(new GestureDetector.SimpleOnGestureListener() {
+          private float totalY = 0;
+
+          @Override
+          public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+
+            final float distx = e2.getRawX() - e1.getRawX();
+            final float disty = e2.getRawY() - e1.getRawY();
+            final int goalwidth = flip.getWidth() / 2;
+
+            // need to slide across half of display to trigger console change
+            // make sure user kept a steady hand horizontally
+            if (Math.abs(disty) < (flip.getHeight() / 4)) {
+              if (distx > goalwidth) {
+                shiftCurrentTerminal(SHIFT_RIGHT);
+                return true;
+              }
+
+              if (distx < -goalwidth) {
+                shiftCurrentTerminal(SHIFT_LEFT);
+                return true;
+              }
+
+            }
+
+            return false;
+          }
+
+          @Override
+          public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
+
+            // if copying, then ignore
+            if (copySource != null && copySource.isSelectingForCopy()) {
+              return false;
+            }
+
+            if (e1 == null || e2 == null) {
+              return false;
+            }
+
+            // if releasing then reset total scroll
+            if (e2.getAction() == MotionEvent.ACTION_UP) {
+              totalY = 0;
+            }
+
+            // activate consider if within x tolerance
+            if (Math.abs(e1.getX() - e2.getX()) < ViewConfiguration.getTouchSlop() * 4) {
+
+              View flip = findCurrentView(R.id.console_flip);
+              if (flip == null) {
+                return false;
+              }
+              TerminalView terminal = (TerminalView) flip;
+
+              // estimate how many rows we have scrolled through
+              // accumulate distance that doesn't trigger immediate scroll
+              totalY += distanceY;
+              final int moved = (int) (totalY / terminal.bridge.charHeight);
+
+              VDUBuffer buffer = terminal.bridge.getVDUBuffer();
+
+              // consume as scrollback only if towards right half of screen
+              if (e2.getX() > flip.getWidth() / 2) {
+                if (moved != 0) {
+                  int base = buffer.getWindowBase();
+                  buffer.setWindowBase(base + moved);
+                  totalY = 0;
+                  return true;
+                }
+              } else {
+                // otherwise consume as pgup/pgdown for every 5 lines
+                if (moved > 5) {
+                  ((vt320) buffer).keyPressed(vt320.KEY_PAGE_DOWN, ' ', 0);
+                  terminal.bridge.tryKeyVibrate();
+                  totalY = 0;
+                  return true;
+                } else if (moved < -5) {
+                  ((vt320) buffer).keyPressed(vt320.KEY_PAGE_UP, ' ', 0);
+                  terminal.bridge.tryKeyVibrate();
+                  totalY = 0;
+                  return true;
+                }
+
+              }
+
+            }
+
+            return false;
+          }
+
+        });
+
+    flip.setOnCreateContextMenuListener(this);
+
+    flip.setOnTouchListener(new OnTouchListener() {
+
+      public boolean onTouch(View v, MotionEvent event) {
+
+        // when copying, highlight the area
+        if (copySource != null && copySource.isSelectingForCopy()) {
+          int row = (int) Math.floor(event.getY() / copySource.charHeight);
+          int col = (int) Math.floor(event.getX() / copySource.charWidth);
+
+          SelectionArea area = copySource.getSelectionArea();
+
+          switch (event.getAction()) {
+          case MotionEvent.ACTION_DOWN:
+            // recording starting area
+            if (area.isSelectingOrigin()) {
+              area.setRow(row);
+              area.setColumn(col);
+              lastTouchRow = row;
+              lastTouchCol = col;
+              copySource.redraw();
+            }
+            return true;
+          case MotionEvent.ACTION_MOVE:
+            /*
+             * ignore when user hasn't moved since last time so we can fine-tune with directional
+             * pad
+             */
+            if (row == lastTouchRow && col == lastTouchCol) {
+              return true;
+            }
+            // if the user moves, start the selection for other corner
+            area.finishSelectingOrigin();
+
+            // update selected area
+            area.setRow(row);
+            area.setColumn(col);
+            lastTouchRow = row;
+            lastTouchCol = col;
+            copySource.redraw();
+            return true;
+          case MotionEvent.ACTION_UP:
+            /*
+             * If they didn't move their finger, maybe they meant to select the rest of the text
+             * with the directional pad.
+             */
+            if (area.getLeft() == area.getRight() && area.getTop() == area.getBottom()) {
+              return true;
+            }
+
+            // copy selected area to clipboard
+            String copiedText = area.copyFrom(copySource.getVDUBuffer());
+
+            clipboard.setText(copiedText);
+            Toast.makeText(ConsoleActivity.this,
+                getString(R.string.terminal_copy_done, copiedText.length()), Toast.LENGTH_LONG)
+                .show();
+            // fall through to clear state
+
+          case MotionEvent.ACTION_CANCEL:
+            // make sure we clear any highlighted area
+            area.reset();
+            copySource.setSelectingForCopy(false);
+            copySource.redraw();
+            return true;
+          }
+        }
+
+        Configuration config = getResources().getConfiguration();
+
+        if (event.getAction() == MotionEvent.ACTION_DOWN) {
+          lastX = event.getX();
+          lastY = event.getY();
+        } else if (event.getAction() == MotionEvent.ACTION_MOVE) {
+          final int deltaX = (int) (lastX - event.getX());
+          final int deltaY = (int) (lastY - event.getY());
+          int distance = (deltaX * deltaX) + (deltaY * deltaY);
+          if (distance > mTouchSlopSquare) {
+            // If currently scheduled long press event is not canceled here,
+            // GestureDetector.onScroll is executed, which takes a while, and by the time we are
+            // back in the view's dispatchTouchEvent
+            // mPendingCheckForLongPress is already executed
+            flip.cancelLongPress();
+          }
+        } else if (event.getAction() == MotionEvent.ACTION_UP) {
+          // Same as above, except now GestureDetector.onFling is called.
+          flip.cancelLongPress();
+          if (config.hardKeyboardHidden != Configuration.KEYBOARDHIDDEN_NO
+              && keyboardButton.getVisibility() == View.GONE
+              && event.getEventTime() - event.getDownTime() < CLICK_TIME
+              && Math.abs(event.getX() - lastX) < MAX_CLICK_DISTANCE
+              && Math.abs(event.getY() - lastY) < MAX_CLICK_DISTANCE) {
+            keyboardButton.startAnimation(keyboard_fade_in);
+            keyboardButton.setVisibility(View.VISIBLE);
+
+            handler.postDelayed(new Runnable() {
+              public void run() {
+                if (keyboardButton.getVisibility() == View.GONE) {
+                  return;
+                }
+
+                keyboardButton.startAnimation(keyboard_fade_out);
+                keyboardButton.setVisibility(View.GONE);
+              }
+            }, KEYBOARD_DISPLAY_TIME);
+
+            return false;
+          }
+        }
+        // pass any touch events back to detector
+        return detect.onTouchEvent(event);
+      }
+
+    });
+
+  }
+
+  private void configureOrientation() {
+    String rotateDefault;
+    if (getResources().getConfiguration().keyboard == Configuration.KEYBOARD_NOKEYS) {
+      rotateDefault = PreferenceConstants.ROTATION_PORTRAIT;
+    } else {
+      rotateDefault = PreferenceConstants.ROTATION_LANDSCAPE;
+    }
+
+    String rotate = prefs.getString(PreferenceConstants.ROTATION, rotateDefault);
+    if (PreferenceConstants.ROTATION_DEFAULT.equals(rotate)) {
+      rotate = rotateDefault;
+    }
+
+    // request a forced orientation if requested by user
+    if (PreferenceConstants.ROTATION_LANDSCAPE.equals(rotate)) {
+      setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+      forcedOrientation = true;
+    } else if (PreferenceConstants.ROTATION_PORTRAIT.equals(rotate)) {
+      setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+      forcedOrientation = true;
+    } else {
+      setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
+      forcedOrientation = false;
+    }
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    super.onCreateOptionsMenu(menu);
+    getMenuInflater().inflate(R.menu.terminal, menu);
+    menu.setQwertyMode(true);
+    return true;
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    super.onPrepareOptionsMenu(menu);
+    setVolumeControlStream(AudioManager.STREAM_NOTIFICATION);
+    TerminalBridge bridge = ((TerminalView) findCurrentView(R.id.console_flip)).bridge;
+    boolean sessionOpen = bridge.isSessionOpen();
+    menu.findItem(R.id.terminal_menu_resize).setEnabled(sessionOpen);
+    if (bridge.getProcess() instanceof ScriptProcess) {
+      menu.findItem(R.id.terminal_menu_exit_and_edit).setEnabled(true);
+    }
+    bridge.onPrepareOptionsMenu(menu);
+    return true;
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    if (item.getItemId() == R.id.terminal_menu_resize) {
+      doResize();
+    } else if (item.getItemId() == R.id.terminal_menu_preferences) {
+      doPreferences();
+    } else if (item.getItemId() == R.id.terminal_menu_send_email) {
+      doEmailTranscript();
+    } else if (item.getItemId() == R.id.terminal_menu_exit_and_edit) {
+      TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
+      TerminalBridge bridge = terminalView.bridge;
+      if (manager != null) {
+        manager.closeConnection(bridge, true);
+      } else {
+        Intent intent = new Intent(this, ScriptingLayerService.class);
+        intent.setAction(Constants.ACTION_KILL_PROCESS);
+        intent.putExtra(Constants.EXTRA_PROXY_PORT, bridge.getId());
+        startService(intent);
+        Message.obtain(disconnectHandler, -1, bridge).sendToTarget();
+      }
+      Intent intent = new Intent(Constants.ACTION_EDIT_SCRIPT);
+      ScriptProcess process = (ScriptProcess) bridge.getProcess();
+      intent.putExtra(Constants.EXTRA_SCRIPT_PATH, process.getPath());
+      startActivity(intent);
+      finish();
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  @Override
+  public void onOptionsMenuClosed(Menu menu) {
+    super.onOptionsMenuClosed(menu);
+    setVolumeControlStream(AudioManager.STREAM_MUSIC);
+  }
+
+  private void doResize() {
+    closeOptionsMenu();
+    final TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
+    final View resizeView = inflater.inflate(R.layout.dia_resize, null, false);
+    new AlertDialog.Builder(ConsoleActivity.this).setView(resizeView)
+        .setPositiveButton(R.string.button_resize, new DialogInterface.OnClickListener() {
+          public void onClick(DialogInterface dialog, int which) {
+            int width, height;
+            try {
+              width =
+                  Integer.parseInt(((EditText) resizeView.findViewById(R.id.width)).getText()
+                      .toString());
+              height =
+                  Integer.parseInt(((EditText) resizeView.findViewById(R.id.height)).getText()
+                      .toString());
+            } catch (NumberFormatException nfe) {
+              return;
+            }
+            terminalView.forceSize(width, height);
+          }
+        }).setNegativeButton(android.R.string.cancel, null).create().show();
+  }
+
+  private void doPreferences() {
+    startActivity(new Intent(this, Preferences.class));
+  }
+
+  private void doEmailTranscript() {
+    // Don't really want to supply an address, but currently it's required,
+    // otherwise we get an exception.
+    TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
+    TerminalBridge bridge = terminalView.bridge;
+    // TODO(raaar): Replace with process log.
+    VDUBuffer buffer = bridge.getVDUBuffer();
+    int height = buffer.getRows();
+    int width = buffer.getColumns();
+    StringBuilder string = new StringBuilder();
+    for (int i = 0; i < height; i++) {
+      for (int j = 0; j < width; j++) {
+        string.append(buffer.getChar(j, i));
+      }
+    }
+    String addr = "user@example.com";
+    Intent intent = new Intent(Intent.ACTION_SENDTO, Uri.parse("mailto:" + addr));
+    intent.putExtra("body", string.toString().trim());
+    startActivity(intent);
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfo) {
+    TerminalBridge bridge = ((TerminalView) findCurrentView(R.id.console_flip)).bridge;
+    boolean sessionOpen = bridge.isSessionOpen();
+    menu.add(Menu.NONE, MenuId.COPY.getId(), Menu.NONE, R.string.terminal_menu_copy);
+    if (clipboard.hasText() && sessionOpen) {
+      menu.add(Menu.NONE, MenuId.PASTE.getId(), Menu.NONE, R.string.terminal_menu_paste);
+    }
+    bridge.onCreateContextMenu(menu, view, menuInfo);
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    int itemId = item.getItemId();
+    if (itemId == MenuId.COPY.getId()) {
+      TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
+      copySource = terminalView.bridge;
+      SelectionArea area = copySource.getSelectionArea();
+      area.reset();
+      area.setBounds(copySource.getVDUBuffer().getColumns(), copySource.getVDUBuffer().getRows());
+      copySource.setSelectingForCopy(true);
+      // Make sure we show the initial selection
+      copySource.redraw();
+      Toast.makeText(ConsoleActivity.this, getString(R.string.terminal_copy_start),
+          Toast.LENGTH_LONG).show();
+      return true;
+    } else if (itemId == MenuId.PASTE.getId()) {
+      TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
+      TerminalBridge bridge = terminalView.bridge;
+      // pull string from clipboard and generate all events to force down
+      String clip = clipboard.getText().toString();
+      bridge.injectString(clip);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    // connect with manager service to find all bridges
+    // when connected it will insert all views
+    bindService(new Intent(this, ScriptingLayerService.class), mConnection, 0);
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    Log.d("onPause called");
+
+    // Allow the screen to dim and fall asleep.
+    if (wakelock != null && wakelock.isHeld()) {
+      wakelock.release();
+    }
+
+    if (forcedOrientation && manager != null) {
+      manager.setResizeAllowed(false);
+    }
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    Log.d("onResume called");
+
+    // Make sure we don't let the screen fall asleep.
+    // This also keeps the Wi-Fi chipset from disconnecting us.
+    if (wakelock != null && prefs.getBoolean(PreferenceConstants.KEEP_ALIVE, true)) {
+      wakelock.acquire();
+    }
+
+    configureOrientation();
+
+    if (forcedOrientation && manager != null) {
+      manager.setResizeAllowed(true);
+    }
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see android.app.Activity#onNewIntent(android.content.Intent)
+   */
+  @Override
+  protected void onNewIntent(Intent intent) {
+    super.onNewIntent(intent);
+
+    Log.d("onNewIntent called");
+
+    int id = intent.getIntExtra(Constants.EXTRA_PROXY_PORT, -1);
+
+    if (id > 0) {
+      processID = id;
+    }
+
+    if (processID == null) {
+      Log.e("Got null intent data in onNewIntent()");
+      return;
+    }
+
+    if (manager == null) {
+      Log.e("We're not bound in onNewIntent()");
+      return;
+    }
+
+    TerminalBridge requestedBridge = manager.getConnectedBridge(processID);
+    int requestedIndex = 0;
+
+    synchronized (flip) {
+      if (requestedBridge == null) {
+        // If we didn't find the requested connection, try opening it
+
+        try {
+          Log.d(String.format("We couldnt find an existing bridge with id = %d,"
+              + "so creating one now", processID));
+          requestedBridge = manager.openConnection(processID);
+        } catch (Exception e) {
+          Log.e("Problem while trying to create new requested bridge", e);
+        }
+
+        requestedIndex = addNewTerminalView(requestedBridge);
+      } else {
+        final int flipIndex = getFlipIndex(requestedBridge);
+        if (flipIndex > requestedIndex) {
+          requestedIndex = flipIndex;
+        }
+      }
+
+      setDisplayedTerminal(requestedIndex);
+    }
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    unbindService(mConnection);
+  }
+
+  protected void shiftCurrentTerminal(final int direction) {
+    View overlay;
+    synchronized (flip) {
+      boolean shouldAnimate = flip.getChildCount() > 1;
+
+      // Only show animation if there is something else to go to.
+      if (shouldAnimate) {
+        // keep current overlay from popping up again
+        overlay = findCurrentView(R.id.terminal_overlay);
+        if (overlay != null) {
+          overlay.startAnimation(fade_stay_hidden);
+        }
+
+        if (direction == SHIFT_LEFT) {
+          flip.setInAnimation(slide_left_in);
+          flip.setOutAnimation(slide_left_out);
+          flip.showNext();
+        } else if (direction == SHIFT_RIGHT) {
+          flip.setInAnimation(slide_right_in);
+          flip.setOutAnimation(slide_right_out);
+          flip.showPrevious();
+        }
+      }
+
+      if (shouldAnimate) {
+        // show overlay on new slide and start fade
+        overlay = findCurrentView(R.id.terminal_overlay);
+        if (overlay != null) {
+          overlay.startAnimation(fade_out_delayed);
+        }
+      }
+
+      updatePromptVisible();
+    }
+  }
+
+  /**
+   * Show any prompts requested by the currently visible {@link TerminalView}.
+   */
+  protected void updatePromptVisible() {
+    // check if our currently-visible terminalbridge is requesting any prompt services
+    View view = findCurrentView(R.id.console_flip);
+
+    // Hide all the prompts in case a prompt request was canceled
+    hideAllPrompts();
+
+    if (!(view instanceof TerminalView)) {
+      // we dont have an active view, so hide any prompts
+      return;
+    }
+
+    PromptHelper prompt = ((TerminalView) view).bridge.getPromptHelper();
+
+    if (Boolean.class.equals(prompt.promptRequested)) {
+      booleanPromptGroup.setVisibility(View.VISIBLE);
+      booleanPrompt.setText(prompt.promptHint);
+      booleanYes.requestFocus();
+    } else {
+      hideAllPrompts();
+      view.requestFocus();
+    }
+  }
+
+  @Override
+  public void onConfigurationChanged(Configuration newConfig) {
+    super.onConfigurationChanged(newConfig);
+
+    Log.d(String.format(
+        "onConfigurationChanged; requestedOrientation=%d, newConfig.orientation=%d",
+        getRequestedOrientation(), newConfig.orientation));
+    if (manager != null) {
+      if (forcedOrientation
+          && (newConfig.orientation != Configuration.ORIENTATION_LANDSCAPE && getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE)
+          || (newConfig.orientation != Configuration.ORIENTATION_PORTRAIT && getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT)) {
+        manager.setResizeAllowed(false);
+      } else {
+        manager.setResizeAllowed(true);
+      }
+
+      manager
+          .setHardKeyboardHidden(newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES);
+    }
+  }
+
+  /**
+   * Adds a new TerminalBridge to the current set of views in our ViewFlipper.
+   *
+   * @param bridge
+   *          TerminalBridge to add to our ViewFlipper
+   * @return the child index of the new view in the ViewFlipper
+   */
+  private int addNewTerminalView(TerminalBridge bridge) {
+    // let them know about our prompt handler services
+    bridge.getPromptHelper().setHandler(promptHandler);
+
+    // inflate each terminal view
+    RelativeLayout view = (RelativeLayout) inflater.inflate(R.layout.item_terminal, flip, false);
+
+    // set the terminal overlay text
+    TextView overlay = (TextView) view.findViewById(R.id.terminal_overlay);
+    overlay.setText(bridge.getName());
+
+    // and add our terminal view control, using index to place behind overlay
+    TerminalView terminal = new TerminalView(ConsoleActivity.this, bridge);
+    terminal.setId(R.id.console_flip);
+    view.addView(terminal, 0);
+
+    synchronized (flip) {
+      // finally attach to the flipper
+      flip.addView(view);
+      return flip.getChildCount() - 1;
+    }
+  }
+
+  private int getFlipIndex(TerminalBridge bridge) {
+    synchronized (flip) {
+      final int children = flip.getChildCount();
+      for (int i = 0; i < children; i++) {
+        final View view = flip.getChildAt(i).findViewById(R.id.console_flip);
+
+        if (view == null || !(view instanceof TerminalView)) {
+          // How did that happen?
+          continue;
+        }
+
+        final TerminalView tv = (TerminalView) view;
+
+        if (tv.bridge == bridge) {
+          return i;
+        }
+      }
+    }
+
+    return -1;
+  }
+
+  /**
+   * Displays the child in the ViewFlipper at the requestedIndex and updates the prompts.
+   *
+   * @param requestedIndex
+   *          the index of the terminal view to display
+   */
+  private void setDisplayedTerminal(int requestedIndex) {
+    synchronized (flip) {
+      try {
+        // show the requested bridge if found, also fade out overlay
+        flip.setDisplayedChild(requestedIndex);
+        flip.getCurrentView().findViewById(R.id.terminal_overlay).startAnimation(fade_out_delayed);
+      } catch (NullPointerException npe) {
+        Log.d("View went away when we were about to display it", npe);
+      }
+      updatePromptVisible();
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/HelpActivity.java b/ScriptingLayerForAndroid/src/org/connectbot/HelpActivity.java
new file mode 100644
index 0000000..0ec485e
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/HelpActivity.java
@@ -0,0 +1,88 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.content.res.AssetManager;
+import android.os.Bundle;
+import android.text.method.LinkMovementMethod;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.Version;
+
+import java.io.IOException;
+
+/**
+ * @author Kenny Root
+ *
+ */
+public class HelpActivity extends Activity {
+  public final static String TAG = "ConnectBot.HelpActivity";
+
+  public final static String HELPDIR = "help";
+  public final static String SUFFIX = ".html";
+
+  @Override
+  public void onCreate(Bundle icicle) {
+    super.onCreate(icicle);
+    setContentView(R.layout.act_help);
+
+    this.setTitle(String.format("%s: %s", getResources().getText(R.string.application_nice_title),
+        getResources().getText(R.string.title_help)));
+
+    TextView subtitle = (TextView) findViewById(R.id.version);
+    subtitle.setText(getText(R.string.application_title) + " r"
+        + Version.getVersion(getApplication()));
+
+    ((TextView) findViewById(R.id.help_acks_text)).setMovementMethod(LinkMovementMethod
+        .getInstance());
+
+    AssetManager am = getAssets();
+    LinearLayout content = (LinearLayout) findViewById(R.id.topics);
+
+    try {
+      for (String name : am.list(HELPDIR)) {
+        if (name.endsWith(SUFFIX)) {
+          Button button = new Button(this);
+          final String topic = name.substring(0, name.length() - SUFFIX.length());
+          button.setText(topic);
+
+          button.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+              Intent intent = new Intent(HelpActivity.this, HelpTopicActivity.class);
+              intent.putExtra(Intent.EXTRA_TITLE, topic);
+              HelpActivity.this.startActivity(intent);
+            }
+          });
+
+          content.addView(button);
+        }
+      }
+    } catch (IOException e) {
+      // TODO Auto-generated catch block
+      Log.e("couldn't get list of help assets", e);
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/HelpTopicActivity.java b/ScriptingLayerForAndroid/src/org/connectbot/HelpTopicActivity.java
new file mode 100644
index 0000000..6453607
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/HelpTopicActivity.java
@@ -0,0 +1,49 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.googlecode.android_scripting.R;
+
+import org.connectbot.util.HelpTopicView;
+
+/**
+ * @author Kenny Root
+ *
+ */
+public class HelpTopicActivity extends Activity {
+  public final static String TAG = "ConnectBot.HelpActivity";
+
+  @Override
+  public void onCreate(Bundle icicle) {
+    super.onCreate(icicle);
+    setContentView(R.layout.act_help_topic);
+
+    String topic = getIntent().getStringExtra(Intent.EXTRA_TITLE);
+
+    this.setTitle(String.format("%s: %s - %s", getResources().getText(R.string.application_title),
+        getResources().getText(R.string.title_help), topic));
+
+    HelpTopicView helpTopic = (HelpTopicView) findViewById(R.id.topic_text);
+
+    helpTopic.setTopic(topic);
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/TerminalView.java b/ScriptingLayerForAndroid/src/org/connectbot/TerminalView.java
new file mode 100644
index 0000000..dfe231b
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/TerminalView.java
@@ -0,0 +1,271 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PixelXorXfermode;
+import android.graphics.RectF;
+import android.view.View;
+import android.view.ViewGroup.LayoutParams;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.widget.Toast;
+import de.mud.terminal.VDUBuffer;
+
+import org.connectbot.service.FontSizeChangedListener;
+import org.connectbot.service.TerminalBridge;
+import org.connectbot.service.TerminalKeyListener;
+import org.connectbot.util.SelectionArea;
+
+/**
+ * User interface {@link View} for showing a TerminalBridge in an {@link Activity}. Handles drawing
+ * bitmap updates and passing keystrokes down to terminal.
+ * @author jsharkey
+ */
+public class TerminalView extends View implements FontSizeChangedListener {
+
+  private final Context context;
+  public final TerminalBridge bridge;
+  private final Paint paint;
+  private final Paint cursorPaint;
+  private final Paint cursorStrokePaint;
+
+  // Cursor paints to distinguish modes
+  private Path ctrlCursor, altCursor, shiftCursor;
+  private RectF tempSrc, tempDst;
+  private Matrix scaleMatrix;
+  private static final Matrix.ScaleToFit scaleType = Matrix.ScaleToFit.FILL;
+
+  private Toast notification = null;
+  private String lastNotification = null;
+  private volatile boolean notifications = true;
+
+  public TerminalView(Context context, TerminalBridge bridge) {
+    super(context);
+
+    this.context = context;
+    this.bridge = bridge;
+    paint = new Paint();
+
+    setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
+    setFocusable(true);
+    setFocusableInTouchMode(true);
+
+    cursorPaint = new Paint();
+    cursorPaint.setColor(bridge.getForegroundColor());
+    cursorPaint.setXfermode(new PixelXorXfermode(bridge.getBackgroundColor()));
+    cursorPaint.setAntiAlias(true);
+
+    cursorStrokePaint = new Paint(cursorPaint);
+    cursorStrokePaint.setStrokeWidth(0.1f);
+    cursorStrokePaint.setStyle(Paint.Style.STROKE);
+
+    /*
+     * Set up our cursor indicators on a 1x1 Path object which we can later transform to our
+     * character width and height
+     */
+    // TODO make this into a resource somehow
+    shiftCursor = new Path();
+    shiftCursor.lineTo(0.5f, 0.33f);
+    shiftCursor.lineTo(1.0f, 0.0f);
+
+    altCursor = new Path();
+    altCursor.moveTo(0.0f, 1.0f);
+    altCursor.lineTo(0.5f, 0.66f);
+    altCursor.lineTo(1.0f, 1.0f);
+
+    ctrlCursor = new Path();
+    ctrlCursor.moveTo(0.0f, 0.25f);
+    ctrlCursor.lineTo(1.0f, 0.5f);
+    ctrlCursor.lineTo(0.0f, 0.75f);
+
+    // For creating the transform when the terminal resizes
+    tempSrc = new RectF();
+    tempSrc.set(0.0f, 0.0f, 1.0f, 1.0f);
+    tempDst = new RectF();
+    scaleMatrix = new Matrix();
+
+    bridge.addFontSizeChangedListener(this);
+
+    // connect our view up to the bridge
+    setOnKeyListener(bridge.getKeyHandler());
+  }
+
+  public void destroy() {
+    // tell bridge to destroy its bitmap
+    bridge.parentDestroyed();
+  }
+
+  @Override
+  protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+    super.onSizeChanged(w, h, oldw, oldh);
+
+    bridge.parentChanged(this);
+
+    scaleCursors();
+  }
+
+  public void onFontSizeChanged(float size) {
+    scaleCursors();
+  }
+
+  private void scaleCursors() {
+    // Create a scale matrix to scale our 1x1 representation of the cursor
+    tempDst.set(0.0f, 0.0f, bridge.charWidth, bridge.charHeight);
+    scaleMatrix.setRectToRect(tempSrc, tempDst, scaleType);
+  }
+
+  @Override
+  public void onDraw(Canvas canvas) {
+    if (bridge.getBitmap() != null) {
+      // draw the bitmap
+      bridge.onDraw();
+
+      // draw the bridge bitmap if it exists
+      canvas.drawBitmap(bridge.getBitmap(), 0, 0, paint);
+
+      VDUBuffer buffer = bridge.getVDUBuffer();
+
+      // also draw cursor if visible
+      if (buffer.isCursorVisible()) {
+
+        int cursorColumn = buffer.getCursorColumn();
+        final int cursorRow = buffer.getCursorRow();
+
+        final int columns = buffer.getColumns();
+
+        if (cursorColumn == columns) {
+          cursorColumn = columns - 1;
+        }
+
+        if (cursorColumn < 0 || cursorRow < 0) {
+          return;
+        }
+
+        int currentAttribute = buffer.getAttributes(cursorColumn, cursorRow);
+        boolean onWideCharacter = (currentAttribute & VDUBuffer.FULLWIDTH) != 0;
+
+        int x = cursorColumn * bridge.charWidth;
+        int y = (buffer.getCursorRow() + buffer.screenBase - buffer.windowBase) * bridge.charHeight;
+
+        // Save the current clip and translation
+        canvas.save();
+
+        canvas.translate(x, y);
+        canvas.clipRect(0, 0, bridge.charWidth * (onWideCharacter ? 2 : 1), bridge.charHeight);
+        canvas.drawPaint(cursorPaint);
+
+        // Make sure we scale our decorations to the correct size.
+        canvas.concat(scaleMatrix);
+
+        int metaState = bridge.getKeyHandler().getMetaState();
+
+        if ((metaState & TerminalKeyListener.META_SHIFT_ON) != 0) {
+          canvas.drawPath(shiftCursor, cursorStrokePaint);
+        } else if ((metaState & TerminalKeyListener.META_SHIFT_LOCK) != 0) {
+          canvas.drawPath(shiftCursor, cursorPaint);
+        }
+
+        if ((metaState & TerminalKeyListener.META_ALT_ON) != 0) {
+          canvas.drawPath(altCursor, cursorStrokePaint);
+        } else if ((metaState & TerminalKeyListener.META_ALT_LOCK) != 0) {
+          canvas.drawPath(altCursor, cursorPaint);
+        }
+
+        if ((metaState & TerminalKeyListener.META_CTRL_ON) != 0) {
+          canvas.drawPath(ctrlCursor, cursorStrokePaint);
+        } else if ((metaState & TerminalKeyListener.META_CTRL_LOCK) != 0) {
+          canvas.drawPath(ctrlCursor, cursorPaint);
+        }
+
+        // Restore previous clip region
+        canvas.restore();
+      }
+
+      // draw any highlighted area
+      if (bridge.isSelectingForCopy()) {
+        SelectionArea area = bridge.getSelectionArea();
+        canvas.save(Canvas.CLIP_SAVE_FLAG);
+        canvas.clipRect(area.getLeft() * bridge.charWidth, area.getTop() * bridge.charHeight, (area
+            .getRight() + 1)
+            * bridge.charWidth, (area.getBottom() + 1) * bridge.charHeight);
+        canvas.drawPaint(cursorPaint);
+        canvas.restore();
+      }
+    }
+  }
+
+  public void notifyUser(String message) {
+    if (!notifications) {
+      return;
+    }
+
+    if (notification != null) {
+      // Don't keep telling the user the same thing.
+      if (lastNotification != null && lastNotification.equals(message)) {
+        return;
+      }
+
+      notification.setText(message);
+      notification.show();
+    } else {
+      notification = Toast.makeText(context, message, Toast.LENGTH_SHORT);
+      notification.show();
+    }
+
+    lastNotification = message;
+  }
+
+  /**
+   * Ask the {@link TerminalBridge} we're connected to to resize to a specific size.
+   * @param width
+   * @param height
+   */
+  public void forceSize(int width, int height) {
+    bridge.resizeComputed(width, height, getWidth(), getHeight());
+  }
+
+  /**
+   * Sets the ability for the TerminalView to display Toast notifications to the user.
+   * @param value
+   *          whether to enable notifications or not
+   */
+  public void setNotifications(boolean value) {
+    notifications = value;
+  }
+
+  @Override
+  public boolean onCheckIsTextEditor() {
+    return true;
+  }
+
+  @Override
+  public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+    outAttrs.imeOptions |=
+        EditorInfo.IME_FLAG_NO_EXTRACT_UI | EditorInfo.IME_FLAG_NO_ENTER_ACTION
+            | EditorInfo.IME_ACTION_NONE;
+    outAttrs.inputType = EditorInfo.TYPE_NULL;
+    return new BaseInputConnection(this, false);
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/service/FontSizeChangedListener.java b/ScriptingLayerForAndroid/src/org/connectbot/service/FontSizeChangedListener.java
new file mode 100644
index 0000000..eb1c33d
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/service/FontSizeChangedListener.java
@@ -0,0 +1,31 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.service;
+
+/**
+ * @author Kenny Root
+ *
+ */
+public interface FontSizeChangedListener {
+
+	/**
+	 * @param size
+	 *            new font size
+	 */
+	void onFontSizeChanged(float size);
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/service/PromptHelper.java b/ScriptingLayerForAndroid/src/org/connectbot/service/PromptHelper.java
new file mode 100644
index 0000000..f0a37be
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/service/PromptHelper.java
@@ -0,0 +1,159 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.service;
+
+import java.util.concurrent.Semaphore;
+
+import android.os.Handler;
+import android.os.Message;
+
+/**
+ * Helps provide a relay for prompts and responses between a possible user
+ * interface and some underlying service.
+ *
+ * @author jsharkey
+ */
+public class PromptHelper {
+	private final Object tag;
+
+	private Handler handler = null;
+
+	private Semaphore promptToken;
+	private Semaphore promptResponse;
+
+	public String promptInstructions = null;
+	public String promptHint = null;
+	public Object promptRequested = null;
+
+	private Object response = null;
+
+	public PromptHelper(Object tag) {
+		this.tag = tag;
+
+		// Threads must acquire this before they can send a prompt.
+		promptToken = new Semaphore(1);
+
+		// Responses will release this semaphore.
+		promptResponse = new Semaphore(0);
+	}
+
+
+	/**
+	 * Register a user interface handler, if available.
+	 */
+	public void setHandler(Handler handler) {
+		this.handler = handler;
+	}
+
+	/**
+	 * Set an incoming value from an above user interface. Will automatically
+	 * notify any waiting requests.
+	 */
+	public void setResponse(Object value) {
+		response = value;
+		promptRequested = null;
+		promptInstructions = null;
+		promptHint = null;
+		promptResponse.release();
+	}
+
+	/**
+	 * Return the internal response value just before erasing and returning it.
+	 */
+	protected Object popResponse() {
+		Object value = response;
+		response = null;
+		return value;
+	}
+
+
+	/**
+	 * Request a prompt response from parent. This is a blocking call until user
+	 * interface returns a value.
+	 * Only one thread can call this at a time. cancelPrompt() will force this to
+	 * immediately return.
+	 */
+	private Object requestPrompt(String instructions, String hint, Object type) throws InterruptedException {
+		Object response = null;
+
+		promptToken.acquire();
+
+		try {
+			promptInstructions = instructions;
+			promptHint = hint;
+			promptRequested = type;
+
+			// notify any parent watching for live events
+			if (handler != null)
+				Message.obtain(handler, -1, tag).sendToTarget();
+
+			// acquire lock until user passes back value
+			promptResponse.acquire();
+
+			response = popResponse();
+		} finally {
+			promptToken.release();
+		}
+
+		return response;
+	}
+
+	/**
+	 * Request a string response from parent. This is a blocking call until user
+	 * interface returns a value.
+	 * @param hint prompt hint for user to answer
+	 * @return string user has entered
+	 */
+	public String requestStringPrompt(String instructions, String hint) {
+		String value = null;
+		try {
+			value = (String)this.requestPrompt(instructions, hint, String.class);
+		} catch(Exception e) {
+		}
+		return value;
+	}
+
+	/**
+	 * Request a boolean response from parent. This is a blocking call until user
+	 * interface returns a value.
+	 * @param hint prompt hint for user to answer
+	 * @return choice user has made (yes/no)
+	 */
+	public Boolean requestBooleanPrompt(String instructions, String hint) {
+		Boolean value = null;
+		try {
+			value = (Boolean)this.requestPrompt(instructions, hint, Boolean.class);
+		} catch(Exception e) {
+		}
+		return value;
+	}
+
+	/**
+	 * Cancel an in-progress prompt.
+	 */
+	public void cancelPrompt() {
+		if (!promptToken.tryAcquire()) {
+			// A thread has the token, so try to interrupt it
+			response = null;
+			promptResponse.release();
+		} else {
+			// No threads have acquired the token
+			promptToken.release();
+		}
+	}
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/service/Relay.java b/ScriptingLayerForAndroid/src/org/connectbot/service/Relay.java
new file mode 100644
index 0000000..0925321
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/service/Relay.java
@@ -0,0 +1,160 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.service;
+
+import com.googlecode.android_scripting.Log;
+
+import de.mud.terminal.vt320;
+
+import org.apache.harmony.niochar.charset.additional.IBM437;
+import org.connectbot.transport.AbsTransport;
+import org.connectbot.util.EastAsianWidth;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.CodingErrorAction;
+
+/**
+ * @author Kenny Root
+ */
+public class Relay implements Runnable {
+
+  private static final int BUFFER_SIZE = 4096;
+
+  private static boolean useJNI = true;
+
+  private TerminalBridge bridge;
+
+  private Charset currentCharset;
+  private CharsetDecoder decoder;
+  private boolean isLegacyEastAsian = false;
+
+  private AbsTransport transport;
+
+  private vt320 buffer;
+
+  private ByteBuffer byteBuffer;
+  private CharBuffer charBuffer;
+
+  private byte[] byteArray;
+  private char[] charArray;
+
+  static {
+    useJNI = EastAsianWidth.useJNI;
+  }
+
+  public Relay(TerminalBridge bridge, AbsTransport transport, vt320 buffer, String encoding) {
+    setCharset(encoding);
+    this.bridge = bridge;
+    this.transport = transport;
+    this.buffer = buffer;
+  }
+
+  public void setCharset(String encoding) {
+    Log.d("changing charset to " + encoding);
+    Charset charset;
+    if (encoding.equals("CP437")) {
+      charset = new IBM437("IBM437", new String[] { "IBM437", "CP437" });
+    } else {
+      charset = Charset.forName(encoding);
+    }
+
+    if (charset == currentCharset || charset == null) {
+      return;
+    }
+
+    CharsetDecoder newCd = charset.newDecoder();
+    newCd.onUnmappableCharacter(CodingErrorAction.REPLACE);
+    newCd.onMalformedInput(CodingErrorAction.REPLACE);
+
+    currentCharset = charset;
+    synchronized (this) {
+      decoder = newCd;
+    }
+  }
+
+  public void run() {
+    byteBuffer = ByteBuffer.allocate(BUFFER_SIZE);
+    charBuffer = CharBuffer.allocate(BUFFER_SIZE);
+
+    /* for both JNI and non-JNI method */
+    byte[] wideAttribute = new byte[BUFFER_SIZE];
+
+    /* non-JNI fallback method */
+    float[] widths = null;
+
+    if (!useJNI) {
+      widths = new float[BUFFER_SIZE];
+    }
+
+    byteArray = byteBuffer.array();
+    charArray = charBuffer.array();
+
+    CoderResult result;
+
+    int bytesRead = 0;
+    byteBuffer.limit(0);
+    int bytesToRead;
+    int offset;
+    int charWidth;
+
+    try {
+      while (true) {
+        charWidth = bridge.charWidth;
+        bytesToRead = byteBuffer.capacity() - byteBuffer.limit();
+        offset = byteBuffer.arrayOffset() + byteBuffer.limit();
+        bytesRead = transport.read(byteArray, offset, bytesToRead);
+
+        if (bytesRead > 0) {
+          byteBuffer.limit(byteBuffer.limit() + bytesRead);
+
+          synchronized (this) {
+            result = decoder.decode(byteBuffer, charBuffer, false);
+          }
+
+          if (result.isUnderflow() && byteBuffer.limit() == byteBuffer.capacity()) {
+            byteBuffer.compact();
+            byteBuffer.limit(byteBuffer.position());
+            byteBuffer.position(0);
+          }
+
+          offset = charBuffer.position();
+
+          if (!useJNI) {
+            bridge.getPaint().getTextWidths(charArray, 0, offset, widths);
+            for (int i = 0; i < offset; i++) {
+              wideAttribute[i] = (byte) (((int) widths[i] != charWidth) ? 1 : 0);
+            }
+          } else {
+            EastAsianWidth.measure(charArray, 0, charBuffer.position(), wideAttribute,
+                isLegacyEastAsian);
+          }
+          buffer.putString(charArray, wideAttribute, 0, charBuffer.position());
+          charBuffer.clear();
+          bridge.redraw();
+        }
+      }
+    } catch (IOException e) {
+      Log.e("Problem while handling incoming data in relay thread", e);
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalBridge.java b/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalBridge.java
new file mode 100644
index 0000000..9a5936b
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalBridge.java
@@ -0,0 +1,889 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.service;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Typeface;
+import android.graphics.Bitmap.Config;
+import android.graphics.Paint.FontMetrics;
+import android.text.ClipboardManager;
+import android.view.ContextMenu;
+import android.view.Menu;
+import android.view.View;
+import android.view.ContextMenu.ContextMenuInfo;
+
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.facade.ui.UiFacade;
+import com.googlecode.android_scripting.interpreter.InterpreterProcess;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
+import com.googlecode.android_scripting.jsonrpc.RpcReceiverManagerFactory;
+
+import de.mud.terminal.VDUBuffer;
+import de.mud.terminal.VDUDisplay;
+import de.mud.terminal.vt320;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.connectbot.TerminalView;
+import org.connectbot.transport.AbsTransport;
+import org.connectbot.util.Colors;
+import org.connectbot.util.PreferenceConstants;
+import org.connectbot.util.SelectionArea;
+
+/**
+ * Provides a bridge between a MUD terminal buffer and a possible TerminalView. This separation
+ * allows us to keep the TerminalBridge running in a background service. A TerminalView shares down
+ * a bitmap that we can use for rendering when available.
+ *
+ * @author ConnectBot Dev Team
+ * @author raaar
+ *
+ */
+public class TerminalBridge implements VDUDisplay, OnSharedPreferenceChangeListener {
+
+  private final static int FONT_SIZE_STEP = 2;
+
+  private final int[] color = new int[Colors.defaults.length];
+
+  private final TerminalManager manager;
+
+  private final InterpreterProcess mProcess;
+
+  private int mDefaultFgColor;
+  private int mDefaultBgColor;
+
+  private int scrollback;
+
+  private String delKey;
+  private String encoding;
+
+  private AbsTransport transport;
+
+  private final Paint defaultPaint;
+
+  private Relay relay;
+
+  private Bitmap bitmap = null;
+  private final VDUBuffer buffer;
+
+  private TerminalView parent = null;
+  private final Canvas canvas = new Canvas();
+
+  private boolean forcedSize = false;
+  private int columns;
+  private int rows;
+
+  private final TerminalKeyListener keyListener;
+
+  private boolean selectingForCopy = false;
+  private final SelectionArea selectionArea;
+  private ClipboardManager clipboard;
+
+  public int charWidth = -1;
+  public int charHeight = -1;
+  private int charTop = -1;
+
+  private float fontSize = -1;
+
+  private final List<FontSizeChangedListener> fontSizeChangedListeners;
+
+  /**
+   * Flag indicating if we should perform a full-screen redraw during our next rendering pass.
+   */
+  private boolean fullRedraw = false;
+
+  private final PromptHelper promptHelper;
+
+  /**
+   * Create a new terminal bridge suitable for unit testing.
+   */
+  public TerminalBridge() {
+    buffer = new vt320() {
+      @Override
+      public void write(byte[] b) {
+      }
+
+      @Override
+      public void write(int b) {
+      }
+
+      @Override
+      public void sendTelnetCommand(byte cmd) {
+      }
+
+      @Override
+      public void setWindowSize(int c, int r) {
+      }
+
+      @Override
+      public void debug(String s) {
+      }
+    };
+
+    manager = null;
+
+    defaultPaint = new Paint();
+
+    selectionArea = new SelectionArea();
+    scrollback = 1;
+
+    fontSizeChangedListeners = new LinkedList<FontSizeChangedListener>();
+
+    transport = null;
+
+    keyListener = new TerminalKeyListener(manager, this, buffer, null);
+
+    mProcess = null;
+
+    mDefaultFgColor = 0;
+    mDefaultBgColor = 0;
+    promptHelper = null;
+
+    updateCharset();
+  }
+
+  /**
+   * Create new terminal bridge with following parameters.
+   */
+  public TerminalBridge(final TerminalManager manager, InterpreterProcess process, AbsTransport t)
+      throws IOException {
+    this.manager = manager;
+    transport = t;
+    mProcess = process;
+
+    String string = manager.getStringParameter(PreferenceConstants.SCROLLBACK, null);
+    if (string != null) {
+      scrollback = Integer.parseInt(string);
+    } else {
+      scrollback = PreferenceConstants.DEFAULT_SCROLLBACK;
+    }
+
+    string = manager.getStringParameter(PreferenceConstants.FONTSIZE, null);
+    if (string != null) {
+      fontSize = Float.parseFloat(string);
+    } else {
+      fontSize = PreferenceConstants.DEFAULT_FONT_SIZE;
+    }
+
+    mDefaultFgColor =
+        manager.getIntParameter(PreferenceConstants.COLOR_FG, PreferenceConstants.DEFAULT_FG_COLOR);
+    mDefaultBgColor =
+        manager.getIntParameter(PreferenceConstants.COLOR_BG, PreferenceConstants.DEFAULT_BG_COLOR);
+
+    delKey = manager.getStringParameter(PreferenceConstants.DELKEY, PreferenceConstants.DELKEY_DEL);
+
+    // create prompt helper to relay password and hostkey requests up to gui
+    promptHelper = new PromptHelper(this);
+
+    // create our default paint
+    defaultPaint = new Paint();
+    defaultPaint.setAntiAlias(true);
+    defaultPaint.setTypeface(Typeface.MONOSPACE);
+    defaultPaint.setFakeBoldText(true); // more readable?
+
+    fontSizeChangedListeners = new LinkedList<FontSizeChangedListener>();
+
+    setFontSize(fontSize);
+
+    // create terminal buffer and handle outgoing data
+    // this is probably status reply information
+    buffer = new vt320() {
+      @Override
+      public void debug(String s) {
+        Log.d(s);
+      }
+
+      @Override
+      public void write(byte[] b) {
+        try {
+          if (b != null && transport != null) {
+            transport.write(b);
+          }
+        } catch (IOException e) {
+          Log.e("Problem writing outgoing data in vt320() thread", e);
+        }
+      }
+
+      @Override
+      public void write(int b) {
+        try {
+          if (transport != null) {
+            transport.write(b);
+          }
+        } catch (IOException e) {
+          Log.e("Problem writing outgoing data in vt320() thread", e);
+        }
+      }
+
+      // We don't use telnet sequences.
+      @Override
+      public void sendTelnetCommand(byte cmd) {
+      }
+
+      // We don't want remote to resize our window.
+      @Override
+      public void setWindowSize(int c, int r) {
+      }
+
+      @Override
+      public void beep() {
+        if (parent.isShown()) {
+          manager.playBeep();
+        }
+      }
+    };
+
+    // Don't keep any scrollback if a session is not being opened.
+
+    buffer.setBufferSize(scrollback);
+
+    resetColors();
+    buffer.setDisplay(this);
+
+    selectionArea = new SelectionArea();
+
+    keyListener = new TerminalKeyListener(manager, this, buffer, encoding);
+
+    updateCharset();
+
+    manager.registerOnSharedPreferenceChangeListener(this);
+
+  }
+
+  /**
+   * Spawn thread to open connection and start login process.
+   */
+  protected void connect() {
+    transport.setBridge(this);
+    transport.setManager(manager);
+    transport.connect();
+
+    ((vt320) buffer).reset();
+
+    // previously tried vt100 and xterm for emulation modes
+    // "screen" works the best for color and escape codes
+    ((vt320) buffer).setAnswerBack("screen");
+
+    if (PreferenceConstants.DELKEY_BACKSPACE.equals(delKey)) {
+      ((vt320) buffer).setBackspace(vt320.DELETE_IS_BACKSPACE);
+    } else {
+      ((vt320) buffer).setBackspace(vt320.DELETE_IS_DEL);
+    }
+
+    // create thread to relay incoming connection data to buffer
+    relay = new Relay(this, transport, (vt320) buffer, encoding);
+    Thread relayThread = new Thread(relay);
+    relayThread.setDaemon(true);
+    relayThread.setName("Relay");
+    relayThread.start();
+
+    // force font-size to make sure we resizePTY as needed
+    setFontSize(fontSize);
+
+  }
+
+  private void updateCharset() {
+    encoding =
+        manager.getStringParameter(PreferenceConstants.ENCODING, Charset.defaultCharset().name());
+    if (relay != null) {
+      relay.setCharset(encoding);
+    }
+    keyListener.setCharset(encoding);
+  }
+
+  /**
+   * Inject a specific string into this terminal. Used for post-login strings and pasting clipboard.
+   */
+  public void injectString(final String string) {
+    if (string == null || string.length() == 0) {
+      return;
+    }
+
+    Thread injectStringThread = new Thread(new Runnable() {
+      public void run() {
+        try {
+          transport.write(string.getBytes(encoding));
+        } catch (Exception e) {
+          Log.e("Couldn't inject string to remote host: ", e);
+        }
+      }
+    });
+    injectStringThread.setName("InjectString");
+    injectStringThread.start();
+  }
+
+  /**
+   * @return whether a session is open or not
+   */
+  public boolean isSessionOpen() {
+    if (transport != null) {
+      return transport.isSessionOpen();
+    }
+    return false;
+  }
+
+  /**
+   * Force disconnection of this terminal bridge.
+   */
+  public void dispatchDisconnect(boolean immediate) {
+
+    // Cancel any pending prompts.
+    promptHelper.cancelPrompt();
+
+    if (immediate) {
+      manager.closeConnection(TerminalBridge.this, true);
+    } else {
+      Thread disconnectPromptThread = new Thread(new Runnable() {
+        public void run() {
+          String prompt = null;
+          if (transport != null && transport.isConnected()) {
+            prompt = manager.getResources().getString(R.string.prompt_confirm_exit);
+          } else {
+            prompt = manager.getResources().getString(R.string.prompt_process_exited);
+          }
+          Boolean result = promptHelper.requestBooleanPrompt(null, prompt);
+
+          if (transport != null && transport.isConnected()) {
+            manager.closeConnection(TerminalBridge.this, result != null && result.booleanValue());
+          } else if (result != null && result.booleanValue()) {
+            manager.closeConnection(TerminalBridge.this, false);
+          }
+        }
+      });
+      disconnectPromptThread.setName("DisconnectPrompt");
+      disconnectPromptThread.setDaemon(true);
+      disconnectPromptThread.start();
+    }
+  }
+
+  public void setSelectingForCopy(boolean selectingForCopy) {
+    this.selectingForCopy = selectingForCopy;
+  }
+
+  public boolean isSelectingForCopy() {
+    return selectingForCopy;
+  }
+
+  public SelectionArea getSelectionArea() {
+    return selectionArea;
+  }
+
+  public synchronized void tryKeyVibrate() {
+    manager.tryKeyVibrate();
+  }
+
+  /**
+   * Request a different font size. Will make call to parentChanged() to make sure we resize PTY if
+   * needed.
+   */
+  /* package */final void setFontSize(float size) {
+    if (size <= 0.0) {
+      return;
+    }
+
+    defaultPaint.setTextSize(size);
+    fontSize = size;
+
+    // read new metrics to get exact pixel dimensions
+    FontMetrics fm = defaultPaint.getFontMetrics();
+    charTop = (int) Math.ceil(fm.top);
+
+    float[] widths = new float[1];
+    defaultPaint.getTextWidths("X", widths);
+    charWidth = (int) Math.ceil(widths[0]);
+    charHeight = (int) Math.ceil(fm.descent - fm.top);
+
+    // refresh any bitmap with new font size
+    if (parent != null) {
+      parentChanged(parent);
+    }
+
+    for (FontSizeChangedListener ofscl : fontSizeChangedListeners) {
+      ofscl.onFontSizeChanged(size);
+    }
+    forcedSize = false;
+  }
+
+  /**
+   * Add an {@link FontSizeChangedListener} to the list of listeners for this bridge.
+   *
+   * @param listener
+   *          listener to add
+   */
+  public void addFontSizeChangedListener(FontSizeChangedListener listener) {
+    fontSizeChangedListeners.add(listener);
+  }
+
+  /**
+   * Remove an {@link FontSizeChangedListener} from the list of listeners for this bridge.
+   *
+   * @param listener
+   */
+  public void removeFontSizeChangedListener(FontSizeChangedListener listener) {
+    fontSizeChangedListeners.remove(listener);
+  }
+
+  /**
+   * Something changed in our parent {@link TerminalView}, maybe it's a new parent, or maybe it's an
+   * updated font size. We should recalculate terminal size information and request a PTY resize.
+   */
+  public final synchronized void parentChanged(TerminalView parent) {
+    if (manager != null && !manager.isResizeAllowed()) {
+      Log.d("Resize is not allowed now");
+      return;
+    }
+
+    this.parent = parent;
+    final int width = parent.getWidth();
+    final int height = parent.getHeight();
+
+    // Something has gone wrong with our layout; we're 0 width or height!
+    if (width <= 0 || height <= 0) {
+      return;
+    }
+
+    clipboard = (ClipboardManager) parent.getContext().getSystemService(Context.CLIPBOARD_SERVICE);
+    keyListener.setClipboardManager(clipboard);
+
+    if (!forcedSize) {
+      // recalculate buffer size
+      int newColumns, newRows;
+
+      newColumns = width / charWidth;
+      newRows = height / charHeight;
+
+      // If nothing has changed in the terminal dimensions and not an intial
+      // draw then don't blow away scroll regions and such.
+      if (newColumns == columns && newRows == rows) {
+        return;
+      }
+
+      columns = newColumns;
+      rows = newRows;
+    }
+
+    // reallocate new bitmap if needed
+    boolean newBitmap = (bitmap == null);
+    if (bitmap != null) {
+      newBitmap = (bitmap.getWidth() != width || bitmap.getHeight() != height);
+    }
+
+    if (newBitmap) {
+      discardBitmap();
+      bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
+      canvas.setBitmap(bitmap);
+    }
+
+    // clear out any old buffer information
+    defaultPaint.setColor(Color.BLACK);
+    canvas.drawPaint(defaultPaint);
+
+    // Stroke the border of the terminal if the size is being forced;
+    if (forcedSize) {
+      int borderX = (columns * charWidth) + 1;
+      int borderY = (rows * charHeight) + 1;
+
+      defaultPaint.setColor(Color.GRAY);
+      defaultPaint.setStrokeWidth(0.0f);
+      if (width >= borderX) {
+        canvas.drawLine(borderX, 0, borderX, borderY + 1, defaultPaint);
+      }
+      if (height >= borderY) {
+        canvas.drawLine(0, borderY, borderX + 1, borderY, defaultPaint);
+      }
+    }
+
+    try {
+      // request a terminal pty resize
+      synchronized (buffer) {
+        buffer.setScreenSize(columns, rows, true);
+      }
+
+      if (transport != null) {
+        transport.setDimensions(columns, rows, width, height);
+      }
+    } catch (Exception e) {
+      Log.e("Problem while trying to resize screen or PTY", e);
+    }
+
+    // force full redraw with new buffer size
+    fullRedraw = true;
+    redraw();
+
+    parent.notifyUser(String.format("%d x %d", columns, rows));
+
+    Log.i(String.format("parentChanged() now width=%d, height=%d", columns, rows));
+  }
+
+  /**
+   * Somehow our parent {@link TerminalView} was destroyed. Now we don't need to redraw anywhere,
+   * and we can recycle our internal bitmap.
+   */
+  public synchronized void parentDestroyed() {
+    parent = null;
+    discardBitmap();
+  }
+
+  private void discardBitmap() {
+    if (bitmap != null) {
+      bitmap.recycle();
+    }
+    bitmap = null;
+  }
+
+  public void onDraw() {
+    int fg, bg;
+    synchronized (buffer) {
+      boolean entireDirty = buffer.update[0] || fullRedraw;
+      boolean isWideCharacter = false;
+
+      // walk through all lines in the buffer
+      for (int l = 0; l < buffer.height; l++) {
+
+        // check if this line is dirty and needs to be repainted
+        // also check for entire-buffer dirty flags
+        if (!entireDirty && !buffer.update[l + 1]) {
+          continue;
+        }
+
+        // reset dirty flag for this line
+        buffer.update[l + 1] = false;
+
+        // walk through all characters in this line
+        for (int c = 0; c < buffer.width; c++) {
+          int addr = 0;
+          int currAttr = buffer.charAttributes[buffer.windowBase + l][c];
+          // check if foreground color attribute is set
+          if ((currAttr & VDUBuffer.COLOR_FG) != 0) {
+            int fgcolor = ((currAttr & VDUBuffer.COLOR_FG) >> VDUBuffer.COLOR_FG_SHIFT) - 1;
+            if (fgcolor < 8 && (currAttr & VDUBuffer.BOLD) != 0) {
+              fg = color[fgcolor + 8];
+            } else {
+              fg = color[fgcolor];
+            }
+          } else {
+            fg = mDefaultFgColor;
+          }
+
+          // check if background color attribute is set
+          if ((currAttr & VDUBuffer.COLOR_BG) != 0) {
+            bg = color[((currAttr & VDUBuffer.COLOR_BG) >> VDUBuffer.COLOR_BG_SHIFT) - 1];
+          } else {
+            bg = mDefaultBgColor;
+          }
+
+          // support character inversion by swapping background and foreground color
+          if ((currAttr & VDUBuffer.INVERT) != 0) {
+            int swapc = bg;
+            bg = fg;
+            fg = swapc;
+          }
+
+          // set underlined attributes if requested
+          defaultPaint.setUnderlineText((currAttr & VDUBuffer.UNDERLINE) != 0);
+
+          isWideCharacter = (currAttr & VDUBuffer.FULLWIDTH) != 0;
+
+          if (isWideCharacter) {
+            addr++;
+          } else {
+            // determine the amount of continuous characters with the same settings and print them
+            // all at once
+            while (c + addr < buffer.width
+                && buffer.charAttributes[buffer.windowBase + l][c + addr] == currAttr) {
+              addr++;
+            }
+          }
+
+          // Save the current clip region
+          canvas.save(Canvas.CLIP_SAVE_FLAG);
+
+          // clear this dirty area with background color
+          defaultPaint.setColor(bg);
+          if (isWideCharacter) {
+            canvas.clipRect(c * charWidth, l * charHeight, (c + 2) * charWidth, (l + 1)
+                * charHeight);
+          } else {
+            canvas.clipRect(c * charWidth, l * charHeight, (c + addr) * charWidth, (l + 1)
+                * charHeight);
+          }
+          canvas.drawPaint(defaultPaint);
+
+          // write the text string starting at 'c' for 'addr' number of characters
+          defaultPaint.setColor(fg);
+          if ((currAttr & VDUBuffer.INVISIBLE) == 0) {
+            canvas.drawText(buffer.charArray[buffer.windowBase + l], c, addr, c * charWidth,
+                (l * charHeight) - charTop, defaultPaint);
+          }
+
+          // Restore the previous clip region
+          canvas.restore();
+
+          // advance to the next text block with different characteristics
+          c += addr - 1;
+          if (isWideCharacter) {
+            c++;
+          }
+        }
+      }
+
+      // reset entire-buffer flags
+      buffer.update[0] = false;
+    }
+    fullRedraw = false;
+  }
+
+  public void redraw() {
+    if (parent != null) {
+      parent.postInvalidate();
+    }
+  }
+
+  // We don't have a scroll bar.
+  public void updateScrollBar() {
+  }
+
+  /**
+   * Resize terminal to fit [rows]x[cols] in screen of size [width]x[height]
+   *
+   * @param rows
+   * @param cols
+   * @param width
+   * @param height
+   */
+  public synchronized void resizeComputed(int cols, int rows, int width, int height) {
+    float size = 8.0f;
+    float step = 8.0f;
+    float limit = 0.125f;
+
+    int direction;
+
+    while ((direction = fontSizeCompare(size, cols, rows, width, height)) < 0) {
+      size += step;
+    }
+
+    if (direction == 0) {
+      Log.d(String.format("Fontsize: found match at %f", size));
+      return;
+    }
+
+    step /= 2.0f;
+    size -= step;
+
+    while ((direction = fontSizeCompare(size, cols, rows, width, height)) != 0 && step >= limit) {
+      step /= 2.0f;
+      if (direction > 0) {
+        size -= step;
+      } else {
+        size += step;
+      }
+    }
+
+    if (direction > 0) {
+      size -= step;
+    }
+
+    columns = cols;
+    this.rows = rows;
+    setFontSize(size);
+    forcedSize = true;
+  }
+
+  private int fontSizeCompare(float size, int cols, int rows, int width, int height) {
+    // read new metrics to get exact pixel dimensions
+    defaultPaint.setTextSize(size);
+    FontMetrics fm = defaultPaint.getFontMetrics();
+
+    float[] widths = new float[1];
+    defaultPaint.getTextWidths("X", widths);
+    int termWidth = (int) widths[0] * cols;
+    int termHeight = (int) Math.ceil(fm.descent - fm.top) * rows;
+
+    Log.d(String.format("Fontsize: font size %f resulted in %d x %d", size, termWidth, termHeight));
+
+    // Check to see if it fits in resolution specified.
+    if (termWidth > width || termHeight > height) {
+      return 1;
+    }
+
+    if (termWidth == width || termHeight == height) {
+      return 0;
+    }
+
+    return -1;
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see de.mud.terminal.VDUDisplay#setVDUBuffer(de.mud.terminal.VDUBuffer)
+   */
+  @Override
+  public void setVDUBuffer(VDUBuffer buffer) {
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see de.mud.terminal.VDUDisplay#setColor(byte, byte, byte, byte)
+   */
+  public void setColor(int index, int red, int green, int blue) {
+    // Don't allow the system colors to be overwritten for now. May violate specs.
+    if (index < color.length && index >= 16) {
+      color[index] = 0xff000000 | red << 16 | green << 8 | blue;
+    }
+  }
+
+  public final void resetColors() {
+    System.arraycopy(Colors.defaults, 0, color, 0, Colors.defaults.length);
+  }
+
+  public TerminalKeyListener getKeyHandler() {
+    return keyListener;
+  }
+
+  public void resetScrollPosition() {
+    // if we're in scrollback, scroll to bottom of window on input
+    if (buffer.windowBase != buffer.screenBase) {
+      buffer.setWindowBase(buffer.screenBase);
+    }
+  }
+
+  public void increaseFontSize() {
+    setFontSize(fontSize + FONT_SIZE_STEP);
+  }
+
+  public void decreaseFontSize() {
+    setFontSize(fontSize - FONT_SIZE_STEP);
+  }
+
+  public int getId() {
+    return mProcess.getPort();
+  }
+
+  public String getName() {
+    return mProcess.getName();
+  }
+
+  public InterpreterProcess getProcess() {
+    return mProcess;
+  }
+
+  public int getForegroundColor() {
+    return mDefaultFgColor;
+  }
+
+  public int getBackgroundColor() {
+    return mDefaultBgColor;
+  }
+
+  public VDUBuffer getVDUBuffer() {
+    return buffer;
+  }
+
+  public PromptHelper getPromptHelper() {
+    return promptHelper;
+  }
+
+  public Bitmap getBitmap() {
+    return bitmap;
+  }
+
+  public AbsTransport getTransport() {
+    return transport;
+  }
+
+  public Paint getPaint() {
+    return defaultPaint;
+  }
+
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    if (mProcess.isAlive()) {
+      RpcReceiverManagerFactory rpcReceiverManagerFactory = mProcess.getRpcReceiverManagerFactory();
+      for (RpcReceiverManager manager : rpcReceiverManagerFactory.getRpcReceiverManagers().values()) {
+        UiFacade facade = manager.getReceiver(UiFacade.class);
+        facade.onCreateContextMenu(menu, v, menuInfo);
+      }
+    }
+  }
+
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    boolean returnValue = false;
+    if (mProcess.isAlive()) {
+      RpcReceiverManagerFactory rpcReceiverManagerFactory = mProcess.getRpcReceiverManagerFactory();
+      for (RpcReceiverManager manager : rpcReceiverManagerFactory.getRpcReceiverManagers().values()) {
+        UiFacade facade = manager.getReceiver(UiFacade.class);
+        returnValue = returnValue || facade.onPrepareOptionsMenu(menu);
+      }
+      return returnValue;
+    }
+    return false;
+  }
+
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    if (PreferenceConstants.ENCODING.equals(key)) {
+      updateCharset();
+    } else if (PreferenceConstants.FONTSIZE.equals(key)) {
+      String string = manager.getStringParameter(PreferenceConstants.FONTSIZE, null);
+      if (string != null) {
+        fontSize = Float.parseFloat(string);
+      } else {
+        fontSize = PreferenceConstants.DEFAULT_FONT_SIZE;
+      }
+      setFontSize(fontSize);
+      fullRedraw = true;
+    } else if (PreferenceConstants.SCROLLBACK.equals(key)) {
+      String string = manager.getStringParameter(PreferenceConstants.SCROLLBACK, null);
+      if (string != null) {
+        scrollback = Integer.parseInt(string);
+      } else {
+        scrollback = PreferenceConstants.DEFAULT_SCROLLBACK;
+      }
+      buffer.setBufferSize(scrollback);
+    } else if (PreferenceConstants.COLOR_FG.equals(key)) {
+      mDefaultFgColor =
+          manager.getIntParameter(PreferenceConstants.COLOR_FG,
+              PreferenceConstants.DEFAULT_FG_COLOR);
+      fullRedraw = true;
+    } else if (PreferenceConstants.COLOR_BG.equals(key)) {
+      mDefaultBgColor =
+          manager.getIntParameter(PreferenceConstants.COLOR_BG,
+              PreferenceConstants.DEFAULT_BG_COLOR);
+      fullRedraw = true;
+    }
+    if (PreferenceConstants.DELKEY.equals(key)) {
+      delKey =
+          manager.getStringParameter(PreferenceConstants.DELKEY, PreferenceConstants.DELKEY_DEL);
+      if (PreferenceConstants.DELKEY_BACKSPACE.equals(delKey)) {
+        ((vt320) buffer).setBackspace(vt320.DELETE_IS_BACKSPACE);
+      } else {
+        ((vt320) buffer).setBackspace(vt320.DELETE_IS_DEL);
+      }
+    }
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalKeyListener.java b/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalKeyListener.java
new file mode 100644
index 0000000..9fce1e8
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalKeyListener.java
@@ -0,0 +1,510 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2010 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.service;
+
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.content.res.Configuration;
+import android.text.ClipboardManager;
+import android.view.KeyCharacterMap;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.View.OnKeyListener;
+
+import com.googlecode.android_scripting.Log;
+
+import de.mud.terminal.VDUBuffer;
+import de.mud.terminal.vt320;
+
+import java.io.IOException;
+
+import org.connectbot.TerminalView;
+import org.connectbot.transport.AbsTransport;
+import org.connectbot.util.PreferenceConstants;
+import org.connectbot.util.SelectionArea;
+
+/**
+ * @author kenny
+ * @author modified by raaar
+ */
+public class TerminalKeyListener implements OnKeyListener, OnSharedPreferenceChangeListener {
+
+  public final static int META_CTRL_ON = 0x01;
+  public final static int META_CTRL_LOCK = 0x02;
+  public final static int META_ALT_ON = 0x04;
+  public final static int META_ALT_LOCK = 0x08;
+  public final static int META_SHIFT_ON = 0x10;
+  public final static int META_SHIFT_LOCK = 0x20;
+  public final static int META_SLASH = 0x40;
+  public final static int META_TAB = 0x80;
+
+  // The bit mask of momentary and lock states for each
+  public final static int META_CTRL_MASK = META_CTRL_ON | META_CTRL_LOCK;
+  public final static int META_ALT_MASK = META_ALT_ON | META_ALT_LOCK;
+  public final static int META_SHIFT_MASK = META_SHIFT_ON | META_SHIFT_LOCK;
+
+  // All the transient key codes
+  public final static int META_TRANSIENT = META_CTRL_ON | META_ALT_ON | META_SHIFT_ON;
+
+  public final static int KEYBOARD_META_CTRL_ON = 0x1000; // Ctrl key mask for API 11+
+  private final TerminalManager manager;
+  private final TerminalBridge bridge;
+  private final VDUBuffer buffer;
+
+  protected KeyCharacterMap keymap = KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYBOARD);
+
+  private String keymode = null;
+  private boolean hardKeyboard = false;
+
+  private int metaState = 0;
+
+  private ClipboardManager clipboard = null;
+  private boolean selectingForCopy = false;
+  private final SelectionArea selectionArea;
+
+  private String encoding;
+
+  public TerminalKeyListener(TerminalManager manager, TerminalBridge bridge, VDUBuffer buffer,
+      String encoding) {
+    this.manager = manager;
+    this.bridge = bridge;
+    this.buffer = buffer;
+    this.encoding = encoding;
+
+    selectionArea = new SelectionArea();
+
+    manager.registerOnSharedPreferenceChangeListener(this);
+
+    hardKeyboard =
+        (manager.getResources().getConfiguration().keyboard == Configuration.KEYBOARD_QWERTY);
+
+    updateKeymode();
+  }
+
+  /**
+   * Handle onKey() events coming down from a {@link TerminalView} above us. Modify the keys to make
+   * more sense to a host then pass it to the transport.
+   */
+  public boolean onKey(View v, int keyCode, KeyEvent event) {
+    try {
+      final boolean hardKeyboardHidden = manager.isHardKeyboardHidden();
+
+      AbsTransport transport = bridge.getTransport();
+
+      // Ignore all key-up events except for the special keys
+      if (event.getAction() == KeyEvent.ACTION_UP) {
+        // There's nothing here for virtual keyboard users.
+        if (!hardKeyboard || (hardKeyboard && hardKeyboardHidden)) {
+          return false;
+        }
+
+        // skip keys if we aren't connected yet or have been disconnected
+        if (transport == null || !transport.isSessionOpen()) {
+          return false;
+        }
+
+        if (PreferenceConstants.KEYMODE_RIGHT.equals(keymode)) {
+          if (keyCode == KeyEvent.KEYCODE_ALT_RIGHT && (metaState & META_SLASH) != 0) {
+            metaState &= ~(META_SLASH | META_TRANSIENT);
+            transport.write('/');
+            return true;
+          } else if (keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT && (metaState & META_TAB) != 0) {
+            metaState &= ~(META_TAB | META_TRANSIENT);
+            transport.write(0x09);
+            return true;
+          }
+        } else if (PreferenceConstants.KEYMODE_LEFT.equals(keymode)) {
+          if (keyCode == KeyEvent.KEYCODE_ALT_LEFT && (metaState & META_SLASH) != 0) {
+            metaState &= ~(META_SLASH | META_TRANSIENT);
+            transport.write('/');
+            return true;
+          } else if (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT && (metaState & META_TAB) != 0) {
+            metaState &= ~(META_TAB | META_TRANSIENT);
+            transport.write(0x09);
+            return true;
+          }
+        }
+
+        return false;
+      }
+
+      if (keyCode == KeyEvent.KEYCODE_BACK && transport != null) {
+        bridge.dispatchDisconnect(!transport.isSessionOpen());
+        return true;
+      }
+
+      // check for terminal resizing keys
+      if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
+        bridge.increaseFontSize();
+        return true;
+      } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
+        bridge.decreaseFontSize();
+        return true;
+      }
+
+      // skip keys if we aren't connected yet or have been disconnected
+      if (transport == null || !transport.isSessionOpen()) {
+        return false;
+      }
+
+      bridge.resetScrollPosition();
+
+      boolean printing = (keymap.isPrintingKey(keyCode) || keyCode == KeyEvent.KEYCODE_SPACE);
+
+      // otherwise pass through to existing session
+      // print normal keys
+      if (printing) {
+        int curMetaState = event.getMetaState();
+
+        metaState &= ~(META_SLASH | META_TAB);
+
+        if ((metaState & META_SHIFT_MASK) != 0) {
+          curMetaState |= KeyEvent.META_SHIFT_ON;
+          metaState &= ~META_SHIFT_ON;
+          bridge.redraw();
+        }
+
+        if ((metaState & META_ALT_MASK) != 0) {
+          curMetaState |= KeyEvent.META_ALT_ON;
+          metaState &= ~META_ALT_ON;
+          bridge.redraw();
+        }
+
+        int key = keymap.get(keyCode, curMetaState);
+        if ((curMetaState & KEYBOARD_META_CTRL_ON) != 0) {
+          metaState |= META_CTRL_ON;
+          key = keymap.get(keyCode, 0);
+        }
+
+        if ((metaState & META_CTRL_MASK) != 0) {
+          metaState &= ~META_CTRL_ON;
+          bridge.redraw();
+
+          if ((!hardKeyboard || (hardKeyboard && hardKeyboardHidden)) && sendFunctionKey(keyCode)) {
+            return true;
+          }
+
+          // Support CTRL-a through CTRL-z
+          if (key >= 0x61 && key <= 0x7A) {
+            key -= 0x60;
+          } else if (key >= 0x41 && key <= 0x5F) {
+            key -= 0x40;
+          } else if (key == 0x20) {
+            key = 0x00;
+          } else if (key == 0x3F) {
+            key = 0x7F;
+          }
+        }
+
+        // handle pressing f-keys
+        // Doesn't work properly with asus keyboards... may never have worked. RM 09-Apr-2012
+        /*
+         * if ((hardKeyboard && !hardKeyboardHidden) && (curMetaState & KeyEvent.META_SHIFT_ON) != 0
+         * && sendFunctionKey(keyCode)) { return true; }
+         */
+
+        if (key < 0x80) {
+          transport.write(key);
+        } else {
+          // TODO write encoding routine that doesn't allocate each time
+          transport.write(new String(Character.toChars(key)).getBytes(encoding));
+        }
+
+        return true;
+      }
+
+      if (keyCode == KeyEvent.KEYCODE_UNKNOWN && event.getAction() == KeyEvent.ACTION_MULTIPLE) {
+        byte[] input = event.getCharacters().getBytes(encoding);
+        transport.write(input);
+        return true;
+      }
+
+      // try handling keymode shortcuts
+      if (hardKeyboard && !hardKeyboardHidden && event.getRepeatCount() == 0) {
+        if (PreferenceConstants.KEYMODE_RIGHT.equals(keymode)) {
+          switch (keyCode) {
+          case KeyEvent.KEYCODE_ALT_RIGHT:
+            metaState |= META_SLASH;
+            return true;
+          case KeyEvent.KEYCODE_SHIFT_RIGHT:
+            metaState |= META_TAB;
+            return true;
+          case KeyEvent.KEYCODE_SHIFT_LEFT:
+            metaPress(META_SHIFT_ON);
+            return true;
+          case KeyEvent.KEYCODE_ALT_LEFT:
+            metaPress(META_ALT_ON);
+            return true;
+          }
+        } else if (PreferenceConstants.KEYMODE_LEFT.equals(keymode)) {
+          switch (keyCode) {
+          case KeyEvent.KEYCODE_ALT_LEFT:
+            metaState |= META_SLASH;
+            return true;
+          case KeyEvent.KEYCODE_SHIFT_LEFT:
+            metaState |= META_TAB;
+            return true;
+          case KeyEvent.KEYCODE_SHIFT_RIGHT:
+            metaPress(META_SHIFT_ON);
+            return true;
+          case KeyEvent.KEYCODE_ALT_RIGHT:
+            metaPress(META_ALT_ON);
+            return true;
+          }
+        } else {
+          switch (keyCode) {
+          case KeyEvent.KEYCODE_ALT_LEFT:
+          case KeyEvent.KEYCODE_ALT_RIGHT:
+            metaPress(META_ALT_ON);
+            return true;
+          case KeyEvent.KEYCODE_SHIFT_LEFT:
+          case KeyEvent.KEYCODE_SHIFT_RIGHT:
+            metaPress(META_SHIFT_ON);
+            return true;
+          }
+        }
+      }
+
+      // look for special chars
+      switch (keyCode) {
+      case KeyEvent.KEYCODE_CAMERA:
+
+        // check to see which shortcut the camera button triggers
+        String camera =
+            manager.getStringParameter(PreferenceConstants.CAMERA,
+                PreferenceConstants.CAMERA_CTRLA_SPACE);
+        if (PreferenceConstants.CAMERA_CTRLA_SPACE.equals(camera)) {
+          transport.write(0x01);
+          transport.write(' ');
+        } else if (PreferenceConstants.CAMERA_CTRLA.equals(camera)) {
+          transport.write(0x01);
+        } else if (PreferenceConstants.CAMERA_ESC.equals(camera)) {
+          ((vt320) buffer).keyTyped(vt320.KEY_ESCAPE, ' ', 0);
+        } else if (PreferenceConstants.CAMERA_ESC_A.equals(camera)) {
+          ((vt320) buffer).keyTyped(vt320.KEY_ESCAPE, ' ', 0);
+          transport.write('a');
+        }
+
+        break;
+
+      case KeyEvent.KEYCODE_DEL:
+        ((vt320) buffer).keyPressed(vt320.KEY_BACK_SPACE, ' ', getStateForBuffer());
+        metaState &= ~META_TRANSIENT;
+        return true;
+      case KeyEvent.KEYCODE_ENTER:
+        ((vt320) buffer).keyTyped(vt320.KEY_ENTER, ' ', 0);
+        metaState &= ~META_TRANSIENT;
+        return true;
+
+      case KeyEvent.KEYCODE_DPAD_LEFT:
+        if (selectingForCopy) {
+          selectionArea.decrementColumn();
+          bridge.redraw();
+        } else {
+          ((vt320) buffer).keyPressed(vt320.KEY_LEFT, ' ', getStateForBuffer());
+          metaState &= ~META_TRANSIENT;
+          bridge.tryKeyVibrate();
+        }
+        return true;
+
+      case KeyEvent.KEYCODE_DPAD_UP:
+        if (selectingForCopy) {
+          selectionArea.decrementRow();
+          bridge.redraw();
+        } else {
+          ((vt320) buffer).keyPressed(vt320.KEY_UP, ' ', getStateForBuffer());
+          metaState &= ~META_TRANSIENT;
+          bridge.tryKeyVibrate();
+        }
+        return true;
+
+      case KeyEvent.KEYCODE_DPAD_DOWN:
+        if (selectingForCopy) {
+          selectionArea.incrementRow();
+          bridge.redraw();
+        } else {
+          ((vt320) buffer).keyPressed(vt320.KEY_DOWN, ' ', getStateForBuffer());
+          metaState &= ~META_TRANSIENT;
+          bridge.tryKeyVibrate();
+        }
+        return true;
+
+      case KeyEvent.KEYCODE_DPAD_RIGHT:
+        if (selectingForCopy) {
+          selectionArea.incrementColumn();
+          bridge.redraw();
+        } else {
+          ((vt320) buffer).keyPressed(vt320.KEY_RIGHT, ' ', getStateForBuffer());
+          metaState &= ~META_TRANSIENT;
+          bridge.tryKeyVibrate();
+        }
+        return true;
+
+      case KeyEvent.KEYCODE_DPAD_CENTER:
+        if (selectingForCopy) {
+          if (selectionArea.isSelectingOrigin()) {
+            selectionArea.finishSelectingOrigin();
+          } else {
+            if (clipboard != null) {
+              // copy selected area to clipboard
+              String copiedText = selectionArea.copyFrom(buffer);
+
+              clipboard.setText(copiedText);
+              // XXX STOPSHIP
+              // manager.notifyUser(manager.getString(
+              // R.string.console_copy_done,
+              // copiedText.length()));
+
+              selectingForCopy = false;
+              selectionArea.reset();
+            }
+          }
+        } else {
+          if ((metaState & META_CTRL_ON) != 0) {
+            ((vt320) buffer).keyTyped(vt320.KEY_ESCAPE, ' ', 0);
+            metaState &= ~META_CTRL_ON;
+          } else {
+            metaState |= META_CTRL_ON;
+          }
+        }
+
+        bridge.redraw();
+
+        return true;
+      }
+
+    } catch (IOException e) {
+      Log.e("Problem while trying to handle an onKey() event", e);
+      try {
+        bridge.getTransport().flush();
+      } catch (IOException ioe) {
+        Log.d("Our transport was closed, dispatching disconnect event");
+        bridge.dispatchDisconnect(false);
+      }
+    } catch (NullPointerException npe) {
+      Log.d("Input before connection established ignored.");
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * @param keyCode
+   * @return successful
+   */
+  private boolean sendFunctionKey(int keyCode) {
+    switch (keyCode) {
+    case KeyEvent.KEYCODE_1:
+      ((vt320) buffer).keyPressed(vt320.KEY_F1, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_2:
+      ((vt320) buffer).keyPressed(vt320.KEY_F2, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_3:
+      ((vt320) buffer).keyPressed(vt320.KEY_F3, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_4:
+      ((vt320) buffer).keyPressed(vt320.KEY_F4, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_5:
+      ((vt320) buffer).keyPressed(vt320.KEY_F5, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_6:
+      ((vt320) buffer).keyPressed(vt320.KEY_F6, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_7:
+      ((vt320) buffer).keyPressed(vt320.KEY_F7, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_8:
+      ((vt320) buffer).keyPressed(vt320.KEY_F8, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_9:
+      ((vt320) buffer).keyPressed(vt320.KEY_F9, ' ', 0);
+      return true;
+    case KeyEvent.KEYCODE_0:
+      ((vt320) buffer).keyPressed(vt320.KEY_F10, ' ', 0);
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  /**
+   * Handle meta key presses where the key can be locked on.
+   * <p>
+   * 1st press: next key to have meta state<br />
+   * 2nd press: meta state is locked on<br />
+   * 3rd press: disable meta state
+   *
+   * @param code
+   */
+  private void metaPress(int code) {
+    if ((metaState & (code << 1)) != 0) {
+      metaState &= ~(code << 1);
+    } else if ((metaState & code) != 0) {
+      metaState &= ~code;
+      metaState |= code << 1;
+    } else {
+      metaState |= code;
+    }
+    bridge.redraw();
+  }
+
+  public void setTerminalKeyMode(String keymode) {
+    this.keymode = keymode;
+  }
+
+  private int getStateForBuffer() {
+    int bufferState = 0;
+
+    if ((metaState & META_CTRL_MASK) != 0) {
+      bufferState |= vt320.KEY_CONTROL;
+    }
+    if ((metaState & META_SHIFT_MASK) != 0) {
+      bufferState |= vt320.KEY_SHIFT;
+    }
+    if ((metaState & META_ALT_MASK) != 0) {
+      bufferState |= vt320.KEY_ALT;
+    }
+
+    return bufferState;
+  }
+
+  public int getMetaState() {
+    return metaState;
+  }
+
+  public void setClipboardManager(ClipboardManager clipboard) {
+    this.clipboard = clipboard;
+  }
+
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    if (PreferenceConstants.KEYMODE.equals(key)) {
+      updateKeymode();
+    }
+  }
+
+  private void updateKeymode() {
+    keymode =
+        manager.getStringParameter(PreferenceConstants.KEYMODE, PreferenceConstants.KEYMODE_RIGHT);
+  }
+
+  public void setCharset(String encoding) {
+    this.encoding = encoding;
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalManager.java b/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalManager.java
new file mode 100644
index 0000000..bc83a92
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalManager.java
@@ -0,0 +1,306 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.service;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.MediaPlayer.OnCompletionListener;
+import android.os.Handler;
+import android.os.Message;
+import android.os.Vibrator;
+import android.preference.PreferenceManager;
+
+import com.googlecode.android_scripting.Constants;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.R;
+import com.googlecode.android_scripting.activity.ScriptingLayerService;
+import com.googlecode.android_scripting.exception.Sl4aException;
+import com.googlecode.android_scripting.interpreter.InterpreterProcess;
+
+import org.connectbot.transport.ProcessTransport;
+import org.connectbot.util.PreferenceConstants;
+
+import java.io.IOException;
+import java.lang.ref.WeakReference;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * Manager for SSH connections that runs as a background service. This service holds a list of
+ * currently connected SSH bridges that are ready for connection up to a GUI if needed.
+ *
+ * @author jsharkey
+ * @author modified by raaar
+ */
+public class TerminalManager implements OnSharedPreferenceChangeListener {
+
+  private static final long VIBRATE_DURATION = 30;
+
+  private final List<TerminalBridge> bridges = new CopyOnWriteArrayList<TerminalBridge>();
+
+  private final Map<Integer, WeakReference<TerminalBridge>> mHostBridgeMap =
+      new ConcurrentHashMap<Integer, WeakReference<TerminalBridge>>();
+
+  private Handler mDisconnectHandler = null;
+
+  private final Resources mResources;
+
+  private final SharedPreferences mPreferences;
+
+  private boolean hardKeyboardHidden;
+
+  private Vibrator vibrator;
+  private boolean wantKeyVibration;
+  private boolean wantBellVibration;
+  private boolean wantAudible;
+  private boolean resizeAllowed = false;
+  private MediaPlayer mediaPlayer;
+
+  private final ScriptingLayerService mService;
+
+  public TerminalManager(ScriptingLayerService service) {
+    mService = service;
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(mService);
+    registerOnSharedPreferenceChangeListener(this);
+    mResources = mService.getResources();
+    hardKeyboardHidden =
+        (mResources.getConfiguration().hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES);
+    vibrator = (Vibrator) mService.getSystemService(Context.VIBRATOR_SERVICE);
+    wantKeyVibration = mPreferences.getBoolean(PreferenceConstants.BUMPY_ARROWS, true);
+    wantBellVibration = mPreferences.getBoolean(PreferenceConstants.BELL_VIBRATE, true);
+    wantAudible = mPreferences.getBoolean(PreferenceConstants.BELL, true);
+    if (wantAudible) {
+      enableMediaPlayer();
+    }
+  }
+
+  /**
+   * Disconnect all currently connected bridges.
+   */
+  private void disconnectAll() {
+    TerminalBridge[] bridgesArray = null;
+    if (bridges.size() > 0) {
+      bridgesArray = bridges.toArray(new TerminalBridge[bridges.size()]);
+    }
+    if (bridgesArray != null) {
+      // disconnect and dispose of any existing bridges
+      for (TerminalBridge bridge : bridgesArray) {
+        bridge.dispatchDisconnect(true);
+      }
+    }
+  }
+
+  /**
+   * Open a new session using the given parameters.
+   *
+   * @throws InterruptedException
+   * @throws Sl4aException
+   */
+  public TerminalBridge openConnection(int id) throws IllegalArgumentException, IOException,
+      InterruptedException, Sl4aException {
+    // throw exception if terminal already open
+    if (getConnectedBridge(id) != null) {
+      throw new IllegalArgumentException("Connection already open");
+    }
+
+    InterpreterProcess process = mService.getProcess(id);
+
+    TerminalBridge bridge = new TerminalBridge(this, process, new ProcessTransport(process));
+    bridge.connect();
+
+    WeakReference<TerminalBridge> wr = new WeakReference<TerminalBridge>(bridge);
+    bridges.add(bridge);
+    mHostBridgeMap.put(id, wr);
+
+    return bridge;
+  }
+
+  /**
+   * Find a connected {@link TerminalBridge} with the given HostBean.
+   *
+   * @param id
+   *          the HostBean to search for
+   * @return TerminalBridge that uses the HostBean
+   */
+  public TerminalBridge getConnectedBridge(int id) {
+    WeakReference<TerminalBridge> wr = mHostBridgeMap.get(id);
+    if (wr != null) {
+      return wr.get();
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Called by child bridge when somehow it's been disconnected.
+   */
+  public void closeConnection(TerminalBridge bridge, boolean killProcess) {
+    if (killProcess) {
+      bridges.remove(bridge);
+      mHostBridgeMap.remove(bridge.getId());
+      if (mService.getProcess(bridge.getId()).isAlive()) {
+        Intent intent = new Intent(mService, mService.getClass());
+        intent.setAction(Constants.ACTION_KILL_PROCESS);
+        intent.putExtra(Constants.EXTRA_PROXY_PORT, bridge.getId());
+        mService.startService(intent);
+      }
+    }
+    if (mDisconnectHandler != null) {
+      Message.obtain(mDisconnectHandler, -1, bridge).sendToTarget();
+    }
+  }
+
+  /**
+   * Allow {@link TerminalBridge} to resize when the parent has changed.
+   *
+   * @param resizeAllowed
+   */
+  public void setResizeAllowed(boolean resizeAllowed) {
+    this.resizeAllowed = resizeAllowed;
+  }
+
+  public boolean isResizeAllowed() {
+    return resizeAllowed;
+  }
+
+  public void stop() {
+    resizeAllowed = false;
+    disconnectAll();
+    disableMediaPlayer();
+  }
+
+  public int getIntParameter(String key, int defValue) {
+    return mPreferences.getInt(key, defValue);
+  }
+
+  public String getStringParameter(String key, String defValue) {
+    return mPreferences.getString(key, defValue);
+  }
+
+  public void tryKeyVibrate() {
+    if (wantKeyVibration) {
+      vibrate();
+    }
+  }
+
+  private void vibrate() {
+    if (vibrator != null) {
+      vibrator.vibrate(VIBRATE_DURATION);
+    }
+  }
+
+  private void enableMediaPlayer() {
+    mediaPlayer = new MediaPlayer();
+
+    float volume =
+        mPreferences.getFloat(PreferenceConstants.BELL_VOLUME,
+            PreferenceConstants.DEFAULT_BELL_VOLUME);
+
+    mediaPlayer.setAudioStreamType(AudioManager.STREAM_NOTIFICATION);
+    mediaPlayer.setOnCompletionListener(new BeepListener());
+
+    AssetFileDescriptor file = mResources.openRawResourceFd(R.raw.bell);
+    try {
+      mediaPlayer.setDataSource(file.getFileDescriptor(), file.getStartOffset(), file.getLength());
+      file.close();
+      mediaPlayer.setVolume(volume, volume);
+      mediaPlayer.prepare();
+    } catch (IOException e) {
+      Log.e("Error setting up bell media player", e);
+    }
+  }
+
+  private void disableMediaPlayer() {
+    if (mediaPlayer != null) {
+      mediaPlayer.release();
+      mediaPlayer = null;
+    }
+  }
+
+  public void playBeep() {
+    if (mediaPlayer != null) {
+      mediaPlayer.start();
+    }
+    if (wantBellVibration) {
+      vibrate();
+    }
+  }
+
+  private static class BeepListener implements OnCompletionListener {
+    public void onCompletion(MediaPlayer mp) {
+      mp.seekTo(0);
+    }
+  }
+
+  public boolean isHardKeyboardHidden() {
+    return hardKeyboardHidden;
+  }
+
+  public void setHardKeyboardHidden(boolean b) {
+    hardKeyboardHidden = b;
+  }
+
+  @Override
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    if (PreferenceConstants.BELL.equals(key)) {
+      wantAudible = sharedPreferences.getBoolean(PreferenceConstants.BELL, true);
+      if (wantAudible && mediaPlayer == null) {
+        enableMediaPlayer();
+      } else if (!wantAudible && mediaPlayer != null) {
+        disableMediaPlayer();
+      }
+    } else if (PreferenceConstants.BELL_VOLUME.equals(key)) {
+      if (mediaPlayer != null) {
+        float volume =
+            sharedPreferences.getFloat(PreferenceConstants.BELL_VOLUME,
+                PreferenceConstants.DEFAULT_BELL_VOLUME);
+        mediaPlayer.setVolume(volume, volume);
+      }
+    } else if (PreferenceConstants.BELL_VIBRATE.equals(key)) {
+      wantBellVibration = sharedPreferences.getBoolean(PreferenceConstants.BELL_VIBRATE, true);
+    } else if (PreferenceConstants.BUMPY_ARROWS.equals(key)) {
+      wantKeyVibration = sharedPreferences.getBoolean(PreferenceConstants.BUMPY_ARROWS, true);
+    }
+  }
+
+  public void setDisconnectHandler(Handler disconnectHandler) {
+    mDisconnectHandler = disconnectHandler;
+  }
+
+  public List<TerminalBridge> getBridgeList() {
+    return bridges;
+  }
+
+  public Resources getResources() {
+    return mResources;
+  }
+
+  public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
+    mPreferences.registerOnSharedPreferenceChangeListener(listener);
+  }
+
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/transport/AbsTransport.java b/ScriptingLayerForAndroid/src/org/connectbot/transport/AbsTransport.java
new file mode 100644
index 0000000..3d8c943
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/transport/AbsTransport.java
@@ -0,0 +1,119 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.transport;
+
+import org.connectbot.service.TerminalBridge;
+import org.connectbot.service.TerminalManager;
+
+import java.io.IOException;
+
+/**
+ * @author Kenny Root
+ * @author modified by raaar
+ */
+public abstract class AbsTransport {
+
+  TerminalBridge bridge;
+  TerminalManager manager;
+
+  /**
+   * Causes transport to connect to the target host. After connecting but before a session is
+   * started, must call back to {@link TerminalBridge#onConnected()}. After that call a session may
+   * be opened.
+   */
+  public abstract void connect();
+
+  /**
+   * Reads from the transport. Transport must support reading into a the byte array
+   * <code>buffer</code> at the start of <code>offset</code> and a maximum of <code>length</code>
+   * bytes. If the remote host disconnects, throw an {@link IOException}.
+   *
+   * @param buffer
+   *          byte buffer to store read bytes into
+   * @param offset
+   *          where to start writing in the buffer
+   * @param length
+   *          maximum number of bytes to read
+   * @return number of bytes read
+   * @throws IOException
+   *           when remote host disconnects
+   */
+  public abstract int read(byte[] buffer, int offset, int length) throws IOException;
+
+  /**
+   * Writes to the transport. If the host is not yet connected, simply return without doing
+   * anything. An {@link IOException} should be thrown if there is an error after connection.
+   *
+   * @param buffer
+   *          bytes to write to transport
+   * @throws IOException
+   *           when there is a problem writing after connection
+   */
+  public abstract void write(byte[] buffer) throws IOException;
+
+  /**
+   * Writes to the transport. See {@link #write(byte[])} for behavior details.
+   *
+   * @param c
+   *          character to write to the transport
+   * @throws IOException
+   *           when there is a problem writing after connection
+   */
+  public abstract void write(int c) throws IOException;
+
+  /**
+   * Flushes the write commands to the transport.
+   *
+   * @throws IOException
+   *           when there is a problem writing after connection
+   */
+  public abstract void flush() throws IOException;
+
+  /**
+   * Closes the connection to the terminal. Note that the resulting failure to read should call
+   * {@link TerminalBridge#dispatchDisconnect(boolean)}.
+   */
+  public abstract void close();
+
+  /**
+   * Tells the transport what dimensions the display is currently
+   *
+   * @param columns
+   *          columns of text
+   * @param rows
+   *          rows of text
+   * @param width
+   *          width in pixels
+   * @param height
+   *          height in pixels
+   */
+  public abstract void setDimensions(int columns, int rows, int width, int height);
+
+  public void setBridge(TerminalBridge bridge) {
+    this.bridge = bridge;
+  }
+
+  public void setManager(TerminalManager manager) {
+    this.manager = manager;
+  }
+
+  public abstract boolean isConnected();
+
+  public abstract boolean isSessionOpen();
+
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/transport/ProcessTransport.java b/ScriptingLayerForAndroid/src/org/connectbot/transport/ProcessTransport.java
new file mode 100644
index 0000000..ff894f0
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/transport/ProcessTransport.java
@@ -0,0 +1,108 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.transport;
+
+import com.googlecode.android_scripting.Exec;
+import com.googlecode.android_scripting.Log;
+import com.googlecode.android_scripting.Process;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class ProcessTransport extends AbsTransport {
+
+  private FileDescriptor shellFd;
+  private final Process mProcess;
+  private InputStream is;
+  private OutputStream os;
+  private boolean mConnected = false;
+
+  public ProcessTransport(Process process) {
+    mProcess = process;
+    shellFd = process.getFd();
+    is = process.getIn();
+    os = process.getOut();
+  }
+
+  @Override
+  public void close() {
+    mProcess.kill();
+  }
+
+  @Override
+  public void connect() {
+    mConnected = true;
+  }
+
+  @Override
+  public void flush() throws IOException {
+    os.flush();
+  }
+
+  @Override
+  public boolean isConnected() {
+    return mConnected && mProcess.isAlive();
+  }
+
+  @Override
+  public boolean isSessionOpen() {
+    return mProcess.isAlive();
+  }
+
+  @Override
+  public int read(byte[] buffer, int start, int len) throws IOException {
+    if (is == null) {
+      mConnected = false;
+      bridge.dispatchDisconnect(false);
+      throw new IOException("session closed");
+    }
+    try {
+      return is.read(buffer, start, len);
+    } catch (IOException e) {
+      mConnected = false;
+      bridge.dispatchDisconnect(false);
+      throw new IOException("session closed");
+    }
+  }
+
+  @Override
+  public void setDimensions(int columns, int rows, int width, int height) {
+    try {
+      Exec.setPtyWindowSize(shellFd, rows, columns, width, height);
+    } catch (Exception e) {
+      Log.e("Couldn't resize pty", e);
+    }
+  }
+
+  @Override
+  public void write(byte[] buffer) throws IOException {
+    if (os != null) {
+      os.write(buffer);
+    }
+  }
+
+  @Override
+  public void write(int c) throws IOException {
+    if (os != null) {
+      os.write(c);
+    }
+  }
+
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/Colors.java b/ScriptingLayerForAndroid/src/org/connectbot/util/Colors.java
new file mode 100644
index 0000000..13310e2
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/Colors.java
@@ -0,0 +1,78 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.util;
+
+/**
+ * @author Kenny Root
+ *
+ */
+public class Colors {
+  public final static int[] defaults =
+      new int[] {
+        0xff000000, // black
+        0xffcc0000, // red
+        0xff00cc00, // green
+        0xffcccc00, // brown
+        0xff0000cc, // blue
+        0xffcc00cc, // purple
+        0xff00cccc, // cyan
+        0xffcccccc, // light grey
+        0xff444444, // dark grey
+        0xffff4444, // light red
+        0xff44ff44, // light green
+        0xffffff44, // yellow
+        0xff4444ff, // light blue
+        0xffff44ff, // light purple
+        0xff44ffff, // light cyan
+        0xffffffff, // white
+        0xff000000, 0xff00005f, 0xff000087, 0xff0000af, 0xff0000d7, 0xff0000ff, 0xff005f00,
+        0xff005f5f, 0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff, 0xff008700, 0xff00875f,
+        0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff, 0xff00af00, 0xff00af5f, 0xff00af87,
+        0xff00afaf, 0xff00afd7, 0xff00afff, 0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af,
+        0xff00d7d7, 0xff00d7ff, 0xff00ff00, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7,
+        0xff00ffff, 0xff5f0000, 0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff,
+        0xff5f5f00, 0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff, 0xff5f8700,
+        0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00, 0xff5faf5f,
+        0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff, 0xff5fd700, 0xff5fd75f, 0xff5fd787,
+        0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00, 0xff5fff5f, 0xff5fff87, 0xff5fffaf,
+        0xff5fffd7, 0xff5fffff, 0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7,
+        0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7, 0xff875fff,
+        0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7, 0xff8787ff, 0xff87af00,
+        0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7, 0xff87afff, 0xff87d700, 0xff87d75f,
+        0xff87d787, 0xff87d7af, 0xff87d7d7, 0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87,
+        0xff87ffaf, 0xff87ffd7, 0xff87ffff, 0xffaf0000, 0xffaf005f, 0xffaf0087, 0xffaf00af,
+        0xffaf00d7, 0xffaf00ff, 0xffaf5f00, 0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7,
+        0xffaf5fff, 0xffaf8700, 0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff,
+        0xffafaf00, 0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff, 0xffafd700,
+        0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00, 0xffafff5f,
+        0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff, 0xffd70000, 0xffd7005f, 0xffd70087,
+        0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f, 0xffd75f87, 0xffd75faf,
+        0xffd75fd7, 0xffd75fff, 0xffd78700, 0xffd7875f, 0xffd78787, 0xffd787af, 0xffd787d7,
+        0xffd787ff, 0xffd7af00, 0xffd7af5f, 0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff,
+        0xffd7d700, 0xffd7d75f, 0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00,
+        0xffd7ff5f, 0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff, 0xffff0000, 0xffff005f,
+        0xffff0087, 0xffff00af, 0xffff00d7, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87,
+        0xffff5faf, 0xffff5fd7, 0xffff5fff, 0xffff8700, 0xffff875f, 0xffff8787, 0xffff87af,
+        0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87, 0xffffafaf, 0xffffafd7,
+        0xffffafff, 0xffffd700, 0xffffd75f, 0xffffd787, 0xffffd7af, 0xffffd7d7, 0xffffd7ff,
+        0xffffff00, 0xffffff5f, 0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffff, 0xff080808,
+        0xff121212, 0xff1c1c1c, 0xff262626, 0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e,
+        0xff585858, 0xff626262, 0xff6c6c6c, 0xff767676, 0xff808080, 0xff8a8a8a, 0xff949494,
+        0xff9e9e9e, 0xffa8a8a8, 0xffb2b2b2, 0xffbcbcbc, 0xffc6c6c6, 0xffd0d0d0, 0xffdadada,
+        0xffe4e4e4, 0xffeeeeee, };
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/ColorsActivity.java b/ScriptingLayerForAndroid/src/org/connectbot/util/ColorsActivity.java
new file mode 100644
index 0000000..532da35
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/ColorsActivity.java
@@ -0,0 +1,286 @@
+package org.connectbot.util;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.AdapterView;
+import android.widget.BaseAdapter;
+import android.widget.GridView;
+import android.widget.LinearLayout;
+import android.widget.AdapterView.OnItemClickListener;
+
+import com.googlecode.android_scripting.R;
+
+import org.connectbot.util.UberColorPickerDialog.OnColorChangedListener;
+
+/**
+ * @author modified by raaar
+ */
+public class ColorsActivity extends Activity implements OnItemClickListener, OnColorChangedListener {
+
+  private SharedPreferences mPreferences;
+
+  private static int sLayoutLanscapeWidth = 400;
+  private static int sLayoutPortraitWidth = 210;
+
+  private GridView mColorGrid;
+  private LinearLayout mLayout;
+
+  private int mFgColor;
+  private int mBgColor;
+
+  private int mCurrentColor = 0;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+
+    mFgColor =
+        mPreferences.getInt(PreferenceConstants.COLOR_FG, PreferenceConstants.DEFAULT_FG_COLOR);
+    mBgColor =
+        mPreferences.getInt(PreferenceConstants.COLOR_BG, PreferenceConstants.DEFAULT_BG_COLOR);
+
+    setContentView(R.layout.act_colors);
+
+    this.setTitle("Terminal Colors");
+
+    mLayout = (LinearLayout) findViewById(R.id.color_layout);
+
+    mColorGrid = (GridView) findViewById(R.id.color_grid);
+    mColorGrid.setOnItemClickListener(this);
+    mColorGrid.setSelection(0);
+
+    if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
+      mColorGrid.setNumColumns(2);
+      LayoutParams params = mLayout.getLayoutParams();
+      params.height = params.width;
+      params.width = LayoutParams.WRAP_CONTENT;
+    }
+    mColorGrid.setAdapter(new ColorsAdapter(true));
+
+  }
+
+  private class ColorsAdapter extends BaseAdapter {
+    private boolean mSquareViews;
+
+    public ColorsAdapter(boolean squareViews) {
+      mSquareViews = squareViews;
+    }
+
+    public View getView(int position, View convertView, ViewGroup parent) {
+      ColorView c;
+      if (convertView == null) {
+        c = new ColorView(ColorsActivity.this, mSquareViews);
+      } else {
+        c = (ColorView) convertView;
+      }
+      if (position == 0) {
+        c.setColor(mFgColor);
+        c.setTitle("Foreground color");
+      } else {
+        c.setColor(mBgColor);
+        c.setTitle("Background color");
+      }
+      return c;
+    }
+
+    public int getCount() {
+      return 2;
+    }
+
+    public Object getItem(int position) {
+      return (position == 0) ? mFgColor : mBgColor;
+    }
+
+    public long getItemId(int position) {
+      return position;
+    }
+  }
+
+  private class ColorView extends View {
+    private boolean mSquare;
+
+    private Paint mTextPaint;
+    private Paint mShadowPaint;
+    // Things we paint
+    private int mBackgroundColor;
+    private String mText;
+
+    private int mAscent;
+    private int mWidthCenter;
+    private int mHeightCenter;
+
+    public ColorView(Context context, boolean square) {
+      super(context);
+
+      mSquare = square;
+
+      mTextPaint = new Paint();
+      mTextPaint.setAntiAlias(true);
+      mTextPaint.setTextSize(16);
+      mTextPaint.setColor(0xFFFFFFFF);
+      mTextPaint.setTextAlign(Paint.Align.CENTER);
+
+      mShadowPaint = new Paint(mTextPaint);
+      mShadowPaint.setStyle(Paint.Style.STROKE);
+      mShadowPaint.setStrokeCap(Paint.Cap.ROUND);
+      mShadowPaint.setStrokeJoin(Paint.Join.ROUND);
+      mShadowPaint.setStrokeWidth(4f);
+      mShadowPaint.setColor(0xFF000000);
+
+      setPadding(20, 20, 20, 20);
+    }
+
+    public void setColor(int color) {
+      mBackgroundColor = color;
+    }
+
+    public void setTitle(String title) {
+      mText = title;
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+      int width = measureWidth(widthMeasureSpec);
+
+      int height;
+      if (mSquare) {
+        height = width;
+      } else {
+        height = measureHeight(heightMeasureSpec);
+      }
+
+      mAscent = (int) mTextPaint.ascent();
+      mWidthCenter = width / 2;
+      mHeightCenter = height / 2 - mAscent / 2;
+
+      setMeasuredDimension(width, height);
+    }
+
+    private int measureWidth(int measureSpec) {
+      int result = 0;
+      int specMode = MeasureSpec.getMode(measureSpec);
+      int specSize = MeasureSpec.getSize(measureSpec);
+
+      if (specMode == MeasureSpec.EXACTLY) {
+        // We were told how big to be
+        result = specSize;
+      } else {
+        // Measure the text
+        result = (int) mTextPaint.measureText(mText) + getPaddingLeft() + getPaddingRight();
+        if (specMode == MeasureSpec.AT_MOST) {
+          // Respect AT_MOST value if that was what is called for by
+          // measureSpec
+          result = Math.min(result, specSize);
+        }
+      }
+
+      return result;
+    }
+
+    private int measureHeight(int measureSpec) {
+      int result = 0;
+      int specMode = MeasureSpec.getMode(measureSpec);
+      int specSize = MeasureSpec.getSize(measureSpec);
+
+      mAscent = (int) mTextPaint.ascent();
+      if (specMode == MeasureSpec.EXACTLY) {
+        // We were told how big to be
+        result = specSize;
+      } else {
+        // Measure the text (beware: ascent is a negative number)
+        result = (int) (-mAscent + mTextPaint.descent()) + getPaddingTop() + getPaddingBottom();
+        if (specMode == MeasureSpec.AT_MOST) {
+          // Respect AT_MOST value if that was what is called for by
+          // measureSpec
+          result = Math.min(result, specSize);
+        }
+      }
+      return result;
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+      super.onDraw(canvas);
+      canvas.drawColor(mBackgroundColor);
+      canvas.drawText(mText, mWidthCenter, mHeightCenter, mShadowPaint);
+      canvas.drawText(mText, mWidthCenter, mHeightCenter, mTextPaint);
+    }
+  }
+
+  private void editColor(int colorNumber) {
+    mCurrentColor = colorNumber;
+    new UberColorPickerDialog(this, this, (colorNumber == 0) ? mFgColor : mBgColor).show();
+  }
+
+  public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+    editColor(position);
+  }
+
+  public void onNothingSelected(AdapterView<?> arg0) {
+  }
+
+  public void colorChanged(int value) {
+    SharedPreferences.Editor editor = mPreferences.edit();
+    if (mCurrentColor == 0) {
+      mFgColor = value;
+      editor.putInt(PreferenceConstants.COLOR_FG, mFgColor);
+    } else {
+      mBgColor = value;
+      editor.putInt(PreferenceConstants.COLOR_BG, mBgColor);
+    }
+    editor.commit();
+    mColorGrid.invalidateViews();
+  }
+
+  @Override
+  public void onConfigurationChanged(Configuration newConfig) {
+    super.onConfigurationChanged(newConfig);
+    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+      mColorGrid.setNumColumns(2);
+      LayoutParams params = mLayout.getLayoutParams();
+      params.height = params.width;
+      params.width = sLayoutLanscapeWidth;
+    } else {
+      mColorGrid.setNumColumns(1);
+      LayoutParams params = mLayout.getLayoutParams();
+      params.height = LayoutParams.WRAP_CONTENT;
+      params.width = sLayoutPortraitWidth;
+    }
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    super.onCreateOptionsMenu(menu);
+    MenuItem reset = menu.add("Reset");
+    reset.setAlphabeticShortcut('r');
+    reset.setNumericShortcut('1');
+    reset.setIcon(android.R.drawable.ic_menu_revert);
+    reset.setOnMenuItemClickListener(new OnMenuItemClickListener() {
+      public boolean onMenuItemClick(MenuItem arg0) {
+        mFgColor = PreferenceConstants.DEFAULT_FG_COLOR;
+        mBgColor = PreferenceConstants.DEFAULT_BG_COLOR;
+        SharedPreferences.Editor editor = mPreferences.edit();
+        editor.putInt(PreferenceConstants.COLOR_FG, mFgColor);
+        editor.putInt(PreferenceConstants.COLOR_BG, mBgColor);
+        editor.commit();
+        mColorGrid.invalidateViews();
+        return true;
+      }
+    });
+    return true;
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/EastAsianWidth.java b/ScriptingLayerForAndroid/src/org/connectbot/util/EastAsianWidth.java
new file mode 100644
index 0000000..b27cd48
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/EastAsianWidth.java
@@ -0,0 +1,58 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.util;
+
+import android.util.Log;
+
+/**
+ * @author Kenny Root
+ *
+ */
+public class EastAsianWidth {
+	public static boolean useJNI = false;
+	private static final String TAG = "ConnectBot.EastAsianWidth";
+
+	/**
+	 * @param charArray
+	 * @param i
+	 * @param position
+	 * @param wideAttribute
+	 * @param isLegacyEastAsian
+	 */
+	public native static void measure(char[] charArray, int start, int end,
+			byte[] wideAttribute, boolean isLegacyEastAsian);
+
+	static {
+		try {
+			System.loadLibrary("org_connectbot_util_EastAsianWidth");
+
+			char[] testInput = {(char)0x4EBA};
+			byte[] testResult = new byte[1];
+			measure(testInput, 0, 1, testResult, true);
+
+			if (testResult[0] == 1)
+				useJNI = true;
+			else
+				Log.d(TAG, "EastAsianWidth JNI measuring not available");
+		} catch (Exception e) {
+			// Failure
+		} catch (UnsatisfiedLinkError e1) {
+			// Failure
+		}
+	}
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/EncodingPreference.java b/ScriptingLayerForAndroid/src/org/connectbot/util/EncodingPreference.java
new file mode 100644
index 0000000..8a6d7aa
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/EncodingPreference.java
@@ -0,0 +1,37 @@
+package org.connectbot.util;
+
+import android.content.Context;
+import android.preference.ListPreference;
+import android.util.AttributeSet;
+
+import java.nio.charset.Charset;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map.Entry;
+
+public class EncodingPreference extends ListPreference {
+
+  public EncodingPreference(Context context, AttributeSet attrs) {
+    super(context, attrs);
+
+    List<CharSequence> charsetIdsList = new LinkedList<CharSequence>();
+    List<CharSequence> charsetNamesList = new LinkedList<CharSequence>();
+
+    for (Entry<String, Charset> entry : Charset.availableCharsets().entrySet()) {
+      Charset c = entry.getValue();
+      if (c.canEncode() && c.isRegistered()) {
+        String key = entry.getKey();
+        if (key.startsWith("cp")) {
+          // Custom CP437 charset changes
+          charsetIdsList.add("CP437");
+          charsetNamesList.add("CP437");
+        }
+        charsetIdsList.add(entry.getKey());
+        charsetNamesList.add(c.displayName());
+      }
+    }
+
+    this.setEntryValues(charsetIdsList.toArray(new CharSequence[charsetIdsList.size()]));
+    this.setEntries(charsetNamesList.toArray(new CharSequence[charsetNamesList.size()]));
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/HelpTopicView.java b/ScriptingLayerForAndroid/src/org/connectbot/util/HelpTopicView.java
new file mode 100644
index 0000000..bf6f026
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/HelpTopicView.java
@@ -0,0 +1,63 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.util;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+
+import org.connectbot.HelpActivity;
+
+/**
+ * @author Kenny Root
+ *
+ */
+public class HelpTopicView extends WebView {
+  public HelpTopicView(Context context, AttributeSet attrs, int defStyle) {
+    super(context, attrs, defStyle);
+    initialize();
+  }
+
+  public HelpTopicView(Context context, AttributeSet attrs) {
+    super(context, attrs);
+    initialize();
+  }
+
+  public HelpTopicView(Context context) {
+    super(context);
+    initialize();
+  }
+
+  private void initialize() {
+    WebSettings wSet = getSettings();
+    //wSet.setLayoutAlgorithm(WebSettings.LayoutAlgorithm.NARROW_COLUMNS);
+    wSet.setUseWideViewPort(false);
+  }
+
+  public HelpTopicView setTopic(String topic) {
+    String path =
+        String.format("file:///android_asset/%s/%s%s", HelpActivity.HELPDIR, topic,
+            HelpActivity.SUFFIX);
+    loadUrl(path);
+
+    computeScroll();
+
+    return this;
+  }
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/PreferenceConstants.java b/ScriptingLayerForAndroid/src/org/connectbot/util/PreferenceConstants.java
new file mode 100644
index 0000000..d2c54d6
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/PreferenceConstants.java
@@ -0,0 +1,74 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.util;
+
+/**
+ * @author Kenny Root
+ * @author modified by raaar
+ */
+public class PreferenceConstants {
+
+  public static final String SCROLLBACK = "scrollback";
+  public static final String FONTSIZE = "fontsize";
+  public static final String KEYMODE = "keymode";
+  public static final String ENCODING = "encoding";
+
+  public static final String DELKEY = "delkey";
+  public static final String DELKEY_BACKSPACE = "backspace";
+  public static final String DELKEY_DEL = "del";
+
+  public static final String ROTATION = "rotation";
+
+  public static final String ROTATION_DEFAULT = "Default";
+  public static final String ROTATION_LANDSCAPE = "Force landscape";
+  public static final String ROTATION_PORTRAIT = "Force portrait";
+  public static final String ROTATION_AUTOMATIC = "Automatic";
+
+  public static final String FULLSCREEN = "fullscreen";
+
+  public static final String KEYMODE_RIGHT = "Use right-side keys";
+  public static final String KEYMODE_LEFT = "Use left-side keys";
+
+  public static final String CAMERA = "camera";
+
+  public static final String CAMERA_CTRLA_SPACE = "Ctrl+A then Space";
+  public static final String CAMERA_CTRLA = "Ctrl+A";
+  public static final String CAMERA_ESC = "Esc";
+  public static final String CAMERA_ESC_A = "Esc+A";
+
+  public static final String KEEP_ALIVE = "keepalive";
+
+  public static final String BUMPY_ARROWS = "bumpyarrows";
+  public static final String HIDE_KEYBOARD = "hidekeyboard";
+
+  public static final String SORT_BY_COLOR = "sortByColor";
+
+  public static final String BELL = "bell";
+  public static final String BELL_VOLUME = "bellVolume";
+  public static final String BELL_VIBRATE = "bellVibrate";
+  public static final float DEFAULT_BELL_VOLUME = 0.25f;
+
+  public final static int DEFAULT_FG_COLOR = 0xffcccccc;
+  public final static int DEFAULT_BG_COLOR = 0xff000000;
+  public final static int DEFAULT_SCROLLBACK = 140;
+  public final static float DEFAULT_FONT_SIZE = 10;
+
+  public final static String COLOR_FG = "color_fg";
+  public final static String COLOR_BG = "color_bg";
+
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/SelectionArea.java b/ScriptingLayerForAndroid/src/org/connectbot/util/SelectionArea.java
new file mode 100644
index 0000000..5735e55
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/SelectionArea.java
@@ -0,0 +1,201 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.util;
+
+import de.mud.terminal.VDUBuffer;
+
+/**
+ * @author Kenny Root
+ * Keep track of a selection area for the terminal copying mechanism.
+ * If the orientation is flipped one way, swap the bottom and top or
+ * left and right to keep it in the correct orientation.
+ */
+public class SelectionArea {
+	private int top;
+	private int bottom;
+	private int left;
+	private int right;
+	private int maxColumns;
+	private int maxRows;
+	private boolean selectingOrigin;
+
+	public SelectionArea() {
+		reset();
+	}
+
+	public final void reset() {
+		top = left = bottom = right = 0;
+		selectingOrigin = true;
+	}
+
+	/**
+	 * @param columns
+	 * @param rows
+	 */
+	public void setBounds(int columns, int rows) {
+		maxColumns = columns - 1;
+		maxRows = rows - 1;
+	}
+
+	private int checkBounds(int value, int max) {
+		if (value < 0)
+			return 0;
+		else if (value > max)
+			return max;
+		else
+			return value;
+	}
+
+	public boolean isSelectingOrigin() {
+		return selectingOrigin;
+	}
+
+	public void finishSelectingOrigin() {
+		selectingOrigin = false;
+	}
+
+	public void decrementRow() {
+		if (selectingOrigin)
+			setTop(top - 1);
+		else
+			setBottom(bottom - 1);
+	}
+
+	public void incrementRow() {
+		if (selectingOrigin)
+			setTop(top + 1);
+		else
+			setBottom(bottom + 1);
+	}
+
+	public void setRow(int row) {
+		if (selectingOrigin)
+			setTop(row);
+		else
+			setBottom(row);
+	}
+
+	private void setTop(int top) {
+		this.top = bottom = checkBounds(top, maxRows);
+	}
+
+	public int getTop() {
+		return Math.min(top, bottom);
+	}
+
+	private void setBottom(int bottom) {
+		this.bottom = checkBounds(bottom, maxRows);
+	}
+
+	public int getBottom() {
+		return Math.max(top, bottom);
+	}
+
+	public void decrementColumn() {
+		if (selectingOrigin)
+			setLeft(left - 1);
+		else
+			setRight(right - 1);
+	}
+
+	public void incrementColumn() {
+		if (selectingOrigin)
+			setLeft(left + 1);
+		else
+			setRight(right + 1);
+	}
+
+	public void setColumn(int column) {
+		if (selectingOrigin)
+			setLeft(column);
+		else
+			setRight(column);
+	}
+
+	private void setLeft(int left) {
+		this.left = right = checkBounds(left, maxColumns);
+	}
+
+	public int getLeft() {
+		return Math.min(left, right);
+	}
+
+	private void setRight(int right) {
+		this.right = checkBounds(right, maxColumns);
+	}
+
+	public int getRight() {
+		return Math.max(left, right);
+	}
+
+	public String copyFrom(VDUBuffer vb) {
+		int size = (getRight() - getLeft() + 1) * (getBottom() - getTop() + 1);
+
+		StringBuffer buffer = new StringBuffer(size);
+
+		for(int y = getTop(); y <= getBottom(); y++) {
+			int lastNonSpace = buffer.length();
+
+			for (int x = getLeft(); x <= getRight(); x++) {
+				// only copy printable chars
+				char c = vb.getChar(x, y);
+
+				if (!Character.isDefined(c) ||
+						(Character.isISOControl(c) && c != '\t'))
+					c = ' ';
+
+				if (c != ' ')
+					lastNonSpace = buffer.length();
+
+				buffer.append(c);
+			}
+
+			// Don't leave a bunch of spaces in our copy buffer.
+			if (buffer.length() > lastNonSpace)
+				buffer.delete(lastNonSpace + 1, buffer.length());
+
+			if (y != bottom)
+				buffer.append("\n");
+		}
+
+		return buffer.toString();
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder buffer = new StringBuilder();
+
+		buffer.append("SelectionArea[top=");
+		buffer.append(top);
+		buffer.append(", bottom=");
+		buffer.append(bottom);
+		buffer.append(", left=");
+		buffer.append(left);
+		buffer.append(", right=");
+		buffer.append(right);
+		buffer.append(", maxColumns=");
+		buffer.append(maxColumns);
+		buffer.append(", maxRows=");
+		buffer.append(maxRows);
+		buffer.append(", isSelectingOrigin=");
+		buffer.append(isSelectingOrigin());
+		buffer.append("]");
+
+		return buffer.toString();
+	}
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/UberColorPickerDialog.java b/ScriptingLayerForAndroid/src/org/connectbot/util/UberColorPickerDialog.java
new file mode 100644
index 0000000..e12307e
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/UberColorPickerDialog.java
@@ -0,0 +1,982 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/*
+ * 090408
+ * Keith Wiley
+ * kwiley@keithwiley.com
+ * http://keithwiley.com
+ *
+ * UberColorPickerDialog v1.1
+ *
+ * This color picker was implemented as a (significant) extension of the
+ * ColorPickerDialog class provided in the Android API Demos.  You are free
+ * to drop it unchanged into your own projects or to modify it as you see
+ * fit.  I would appreciate it if this comment block were let intact,
+ * merely for credit's sake.
+ *
+ * Enjoy!
+ */
+
+package org.connectbot.util;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorMatrix;
+import android.graphics.ComposeShader;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.RadialGradient;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.graphics.SweepGradient;
+import android.graphics.drawable.GradientDrawable;
+import android.graphics.drawable.GradientDrawable.Orientation;
+import android.os.Bundle;
+import android.util.DisplayMetrics;
+import android.view.MotionEvent;
+import android.view.View;
+
+/**
+ * UberColorPickerDialog is a seriously enhanced version of the UberColorPickerDialog
+ * class provided in the Android API Demos.<p>
+ *
+ * NOTE (from Kenny Root): This is a VERY slimmed down version custom for ConnectBot.
+ * Visit Keith's site for the full version at the URL listed in the author line.<p>
+ *
+ * @author Keith Wiley, kwiley@keithwiley.com, http://keithwiley.com
+ */
+public class UberColorPickerDialog extends Dialog {
+	private OnColorChangedListener mListener;
+	private int mInitialColor;
+
+	/**
+	 * Callback to the creator of the dialog, informing the creator of a new color and notifying that the dialog is about to dismiss.
+	 */
+	public interface OnColorChangedListener {
+		void colorChanged(int color);
+	}
+
+	/**
+	 * Ctor
+	 * @param context
+	 * @param listener
+	 * @param initialColor
+	 * @param showTitle If true, a title is shown across the top of the dialog.  If false a toast is shown instead.
+	 */
+	public UberColorPickerDialog(Context context,
+							OnColorChangedListener listener,
+							int initialColor) {
+		super(context);
+
+		mListener = listener;
+		mInitialColor = initialColor;
+	}
+
+	/**
+	 * Activity entry point
+	 */
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		OnColorChangedListener l = new OnColorChangedListener() {
+			public void colorChanged(int color) {
+				mListener.colorChanged(color);
+				dismiss();
+			}
+		};
+
+		DisplayMetrics dm = new DisplayMetrics();
+		getWindow().getWindowManager().getDefaultDisplay().getMetrics(dm);
+		int screenWidth = dm.widthPixels;
+		int screenHeight = dm.heightPixels;
+
+		setTitle("Pick a color (try the trackball)");
+
+		try {
+			setContentView(new ColorPickerView(getContext(), l, screenWidth, screenHeight, mInitialColor));
+		}
+		catch (Exception e) {
+			//There is currently only one kind of ctor exception, that where no methods are enabled.
+			dismiss();	//This doesn't work!  The dialog is still shown (its title at least, the layout is empty from the exception being thrown).  <sigh>
+		}
+	}
+
+	/**
+	 * ColorPickerView is the meat of this color picker (as opposed to the enclosing class).
+	 * All the heavy lifting is done directly by this View subclass.
+	 * <P>
+	 * You can enable/disable whichever color chooser methods you want by modifying the ENABLED_METHODS switches.  They *should*
+	 * do all the work required to properly enable/disable methods without losing track of what goes with what and what maps to what.
+	 * <P>
+	 * If you add a new color chooser method, do a text search for "NEW_METHOD_WORK_NEEDED_HERE".  That tag indicates all
+	 * the locations in the code that will have to be amended in order to properly add a new color chooser method.
+	 * I highly recommend adding new methods to the end of the list.  If you want to try to reorder the list, you're on your own.
+	 */
+	private static class ColorPickerView extends View {
+		private static int SWATCH_WIDTH = 95;
+		private static final int SWATCH_HEIGHT = 60;
+
+		private static int PALETTE_POS_X = 0;
+		private static int PALETTE_POS_Y = SWATCH_HEIGHT;
+		private static final int PALETTE_DIM = SWATCH_WIDTH * 2;
+		private static final int PALETTE_RADIUS = PALETTE_DIM / 2;
+		private static final int PALETTE_CENTER_X = PALETTE_RADIUS;
+		private static final int PALETTE_CENTER_Y = PALETTE_RADIUS;
+
+		private static final int SLIDER_THICKNESS = 40;
+
+		private static int VIEW_DIM_X = PALETTE_DIM;
+		private static int VIEW_DIM_Y = SWATCH_HEIGHT;
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		private static final int METHOD_HS_V_PALETTE = 0;
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		//Add a new entry to the list for each controller in the new method
+		private static final int TRACKED_NONE = -1;	//No object on screen is currently being tracked
+		private static final int TRACK_SWATCH_OLD = 10;
+		private static final int TRACK_SWATCH_NEW = 11;
+		private static final int TRACK_HS_PALETTE = 30;
+		private static final int TRACK_VER_VALUE_SLIDER = 31;
+
+		private static final int TEXT_SIZE = 12;
+		private static int[] TEXT_HSV_POS = new int[2];
+		private static int[] TEXT_RGB_POS = new int[2];
+		private static int[] TEXT_YUV_POS = new int[2];
+		private static int[] TEXT_HEX_POS = new int[2];
+
+		private static final float PI = 3.141592653589793f;
+
+		private int mMethod = METHOD_HS_V_PALETTE;
+		private int mTracking = TRACKED_NONE;	//What object on screen is currently being tracked for movement
+
+		//Zillions of persistant Paint objecs for drawing the View
+
+		private Paint mSwatchOld, mSwatchNew;
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		//Add Paints to represent the palettes of the new method's UI controllers
+		private Paint mOvalHueSat;
+
+		private Bitmap mVerSliderBM;
+		private Canvas mVerSliderCv;
+
+		private Bitmap[] mHorSlidersBM = new Bitmap[3];
+		private Canvas[] mHorSlidersCv = new Canvas[3];
+
+		private Paint mValDimmer;
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		//Add Paints to represent the icon for the new method
+		private Paint mOvalHueSatSmall;
+
+		private Paint mPosMarker;
+		private Paint mText;
+
+		private Rect mOldSwatchRect = new Rect();
+		private Rect mNewSwatchRect = new Rect();
+		private Rect mPaletteRect = new Rect();
+		private Rect mVerSliderRect = new Rect();
+
+		private int[] mSpectrumColorsRev;
+		private int mOriginalColor = 0;	//The color passed in at the beginning, which can be reverted to at any time by tapping the old swatch.
+		private float[] mHSV = new float[3];
+		private int[] mRGB = new int[3];
+		private float[] mYUV = new float[3];
+		private String mHexStr = "";
+		private boolean mHSVenabled = true;	//Only true if an HSV method is enabled
+		private boolean mRGBenabled = true;	//Only true if an RGB method is enabled
+		private boolean mYUVenabled = true;	//Only true if a YUV method is enabled
+		private boolean mHexenabled = true;	//Only true if an RGB method is enabled
+		private int[] mCoord = new int[3];		//For drawing slider/palette markers
+		private int mFocusedControl = -1;	//Which control receives trackball events.
+		private OnColorChangedListener mListener;
+
+		/**
+		 * Ctor.
+		 * @param c
+		 * @param l
+		 * @param width Used to determine orientation and adjust layout accordingly
+		 * @param height Used to determine orientation and adjust layout accordingly
+		 * @param color The initial color
+		 * @throws Exception
+		 */
+		ColorPickerView(Context c, OnColorChangedListener l, int width, int height, int color)
+		throws Exception {
+			super(c);
+
+			//We need to make the dialog focusable to retrieve trackball events.
+			setFocusable(true);
+
+			mListener = l;
+
+			mOriginalColor = color;
+
+			Color.colorToHSV(color, mHSV);
+
+			updateAllFromHSV();
+
+			//Setup the layout based on whether this is a portrait or landscape orientation.
+			if (width <= height) {	//Portrait layout
+				SWATCH_WIDTH = (PALETTE_DIM + SLIDER_THICKNESS) / 2;
+
+				PALETTE_POS_X = 0;
+				PALETTE_POS_Y = TEXT_SIZE * 4 + SWATCH_HEIGHT;
+
+				//Set more rects, lots of rects
+				mOldSwatchRect.set(0, TEXT_SIZE * 4, SWATCH_WIDTH, TEXT_SIZE * 4 + SWATCH_HEIGHT);
+				mNewSwatchRect.set(SWATCH_WIDTH, TEXT_SIZE * 4, SWATCH_WIDTH * 2, TEXT_SIZE * 4 + SWATCH_HEIGHT);
+				mPaletteRect.set(0, PALETTE_POS_Y, PALETTE_DIM, PALETTE_POS_Y + PALETTE_DIM);
+				mVerSliderRect.set(PALETTE_DIM, PALETTE_POS_Y, PALETTE_DIM + SLIDER_THICKNESS, PALETTE_POS_Y + PALETTE_DIM);
+
+				TEXT_HSV_POS[0] = 3;
+				TEXT_HSV_POS[1] = 0;
+				TEXT_RGB_POS[0] = TEXT_HSV_POS[0] + 50;
+				TEXT_RGB_POS[1] = TEXT_HSV_POS[1];
+				TEXT_YUV_POS[0] = TEXT_HSV_POS[0] + 100;
+				TEXT_YUV_POS[1] = TEXT_HSV_POS[1];
+				TEXT_HEX_POS[0] = TEXT_HSV_POS[0] + 150;
+				TEXT_HEX_POS[1] = TEXT_HSV_POS[1];
+
+				VIEW_DIM_X = PALETTE_DIM + SLIDER_THICKNESS;
+				VIEW_DIM_Y = SWATCH_HEIGHT + PALETTE_DIM + TEXT_SIZE * 4;
+			}
+			else {	//Landscape layout
+				SWATCH_WIDTH = 110;
+
+				PALETTE_POS_X = SWATCH_WIDTH;
+				PALETTE_POS_Y = 0;
+
+				//Set more rects, lots of rects
+				mOldSwatchRect.set(0, TEXT_SIZE * 7, SWATCH_WIDTH, TEXT_SIZE * 7 + SWATCH_HEIGHT);
+				mNewSwatchRect.set(0, TEXT_SIZE * 7 + SWATCH_HEIGHT, SWATCH_WIDTH, TEXT_SIZE * 7 + SWATCH_HEIGHT * 2);
+				mPaletteRect.set(SWATCH_WIDTH, PALETTE_POS_Y, SWATCH_WIDTH + PALETTE_DIM, PALETTE_POS_Y + PALETTE_DIM);
+				mVerSliderRect.set(SWATCH_WIDTH + PALETTE_DIM, PALETTE_POS_Y, SWATCH_WIDTH + PALETTE_DIM + SLIDER_THICKNESS, PALETTE_POS_Y + PALETTE_DIM);
+
+				TEXT_HSV_POS[0] = 3;
+				TEXT_HSV_POS[1] = 0;
+				TEXT_RGB_POS[0] = TEXT_HSV_POS[0];
+				TEXT_RGB_POS[1] = (int)(TEXT_HSV_POS[1] + TEXT_SIZE * 3.5);
+				TEXT_YUV_POS[0] = TEXT_HSV_POS[0] + 50;
+				TEXT_YUV_POS[1] = (int)(TEXT_HSV_POS[1] + TEXT_SIZE * 3.5);
+				TEXT_HEX_POS[0] = TEXT_HSV_POS[0] + 50;
+				TEXT_HEX_POS[1] = TEXT_HSV_POS[1];
+
+				VIEW_DIM_X = PALETTE_POS_X + PALETTE_DIM + SLIDER_THICKNESS;
+				VIEW_DIM_Y = Math.max(mNewSwatchRect.bottom, PALETTE_DIM);
+			}
+
+			//Rainbows make everybody happy!
+			mSpectrumColorsRev = new int[] {
+				0xFFFF0000, 0xFFFF00FF, 0xFF0000FF, 0xFF00FFFF,
+				0xFF00FF00, 0xFFFFFF00, 0xFFFF0000,
+			};
+
+			//Setup all the Paint and Shader objects.  There are lots of them!
+
+			//NEW_METHOD_WORK_NEEDED_HERE
+			//Add Paints to represent the palettes of the new method's UI controllers
+
+			mSwatchOld = new Paint(Paint.ANTI_ALIAS_FLAG);
+			mSwatchOld.setStyle(Paint.Style.FILL);
+			mSwatchOld.setColor(Color.HSVToColor(mHSV));
+
+			mSwatchNew = new Paint(Paint.ANTI_ALIAS_FLAG);
+			mSwatchNew.setStyle(Paint.Style.FILL);
+			mSwatchNew.setColor(Color.HSVToColor(mHSV));
+
+			Shader shaderA = new SweepGradient(0, 0, mSpectrumColorsRev, null);
+			Shader shaderB = new RadialGradient(0, 0, PALETTE_CENTER_X, 0xFFFFFFFF, 0xFF000000, Shader.TileMode.CLAMP);
+			Shader shader = new ComposeShader(shaderA, shaderB, PorterDuff.Mode.SCREEN);
+			mOvalHueSat = new Paint(Paint.ANTI_ALIAS_FLAG);
+			mOvalHueSat.setShader(shader);
+			mOvalHueSat.setStyle(Paint.Style.FILL);
+			mOvalHueSat.setDither(true);
+
+			mVerSliderBM = Bitmap.createBitmap(SLIDER_THICKNESS, PALETTE_DIM, Bitmap.Config.RGB_565);
+			mVerSliderCv = new Canvas(mVerSliderBM);
+
+			for (int i = 0; i < 3; i++) {
+				mHorSlidersBM[i] = Bitmap.createBitmap(PALETTE_DIM, SLIDER_THICKNESS, Bitmap.Config.RGB_565);
+				mHorSlidersCv[i] = new Canvas(mHorSlidersBM[i]);
+			}
+
+			mValDimmer = new Paint(Paint.ANTI_ALIAS_FLAG);
+			mValDimmer.setStyle(Paint.Style.FILL);
+			mValDimmer.setDither(true);
+			mValDimmer.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));
+
+			//Whew, we're done making the big Paints and Shaders for the swatches, palettes, and sliders.
+			//Now we need to make the Paints and Shaders that will draw the little method icons in the method selector list.
+
+			//NEW_METHOD_WORK_NEEDED_HERE
+			//Add Paints to represent the icon for the new method
+
+			shaderA = new SweepGradient(0, 0, mSpectrumColorsRev, null);
+			shaderB = new RadialGradient(0, 0, PALETTE_DIM / 2, 0xFFFFFFFF, 0xFF000000, Shader.TileMode.CLAMP);
+			shader = new ComposeShader(shaderA, shaderB, PorterDuff.Mode.SCREEN);
+			mOvalHueSatSmall = new Paint(Paint.ANTI_ALIAS_FLAG);
+			mOvalHueSatSmall.setShader(shader);
+			mOvalHueSatSmall.setStyle(Paint.Style.FILL);
+
+			//Make a simple stroking Paint for drawing markers and borders and stuff like that.
+			mPosMarker = new Paint(Paint.ANTI_ALIAS_FLAG);
+			mPosMarker.setStyle(Paint.Style.STROKE);
+			mPosMarker.setStrokeWidth(2);
+
+			//Make a basic text Paint.
+			mText = new Paint(Paint.ANTI_ALIAS_FLAG);
+			mText.setTextSize(TEXT_SIZE);
+			mText.setColor(Color.WHITE);
+
+			//Kickstart
+			initUI();
+		}
+
+		/**
+		 * Draw the entire view (the entire dialog).
+		 */
+		@Override
+		protected void onDraw(Canvas canvas) {
+			//Draw the old and new swatches
+			drawSwatches(canvas);
+
+			//Write the text
+			writeColorParams(canvas);
+
+			//Draw the palette and sliders (the UI)
+			if (mMethod == METHOD_HS_V_PALETTE)
+				drawHSV1Palette(canvas);
+		}
+
+		/**
+		 * Draw the old and new swatches.
+		 * @param canvas
+		 */
+		private void drawSwatches(Canvas canvas) {
+			float[] hsv = new float[3];
+
+			mText.setTextSize(16);
+
+			//Draw the original swatch
+			canvas.drawRect(mOldSwatchRect, mSwatchOld);
+			Color.colorToHSV(mOriginalColor, hsv);
+			//if (UberColorPickerDialog.isGray(mColor))	//Don't need this right here, but imp't to note
+			//	hsv[1] = 0;
+			if (hsv[2] > .5)
+				mText.setColor(Color.BLACK);
+			canvas.drawText("Revert", mOldSwatchRect.left + SWATCH_WIDTH / 2 - mText.measureText("Revert") / 2, mOldSwatchRect.top + 16, mText);
+			mText.setColor(Color.WHITE);
+
+			//Draw the new swatch
+			canvas.drawRect(mNewSwatchRect, mSwatchNew);
+			if (mHSV[2] > .5)
+				mText.setColor(Color.BLACK);
+			canvas.drawText("Accept", mNewSwatchRect.left + SWATCH_WIDTH / 2 - mText.measureText("Accept") / 2, mNewSwatchRect.top + 16, mText);
+			mText.setColor(Color.WHITE);
+
+			mText.setTextSize(TEXT_SIZE);
+		}
+
+		/**
+		 * Write the color parametes (HSV, RGB, YUV, Hex, etc.).
+		 * @param canvas
+		 */
+		private void writeColorParams(Canvas canvas) {
+			if (mHSVenabled) {
+				canvas.drawText("H: " + Integer.toString((int)(mHSV[0] / 360.0f * 255)), TEXT_HSV_POS[0], TEXT_HSV_POS[1] + TEXT_SIZE, mText);
+				canvas.drawText("S: " + Integer.toString((int)(mHSV[1] * 255)), TEXT_HSV_POS[0], TEXT_HSV_POS[1] + TEXT_SIZE * 2, mText);
+				canvas.drawText("V: " + Integer.toString((int)(mHSV[2] * 255)), TEXT_HSV_POS[0], TEXT_HSV_POS[1] + TEXT_SIZE * 3, mText);
+			}
+
+			if (mRGBenabled) {
+				canvas.drawText("R: " + mRGB[0], TEXT_RGB_POS[0], TEXT_RGB_POS[1] + TEXT_SIZE, mText);
+				canvas.drawText("G: " + mRGB[1], TEXT_RGB_POS[0], TEXT_RGB_POS[1] + TEXT_SIZE * 2, mText);
+				canvas.drawText("B: " + mRGB[2], TEXT_RGB_POS[0], TEXT_RGB_POS[1] + TEXT_SIZE * 3, mText);
+			}
+
+			if (mYUVenabled) {
+				canvas.drawText("Y: " + Integer.toString((int)(mYUV[0] * 255)), TEXT_YUV_POS[0], TEXT_YUV_POS[1] + TEXT_SIZE, mText);
+				canvas.drawText("U: " + Integer.toString((int)((mYUV[1] + .5f) * 255)), TEXT_YUV_POS[0], TEXT_YUV_POS[1] + TEXT_SIZE * 2, mText);
+				canvas.drawText("V: " + Integer.toString((int)((mYUV[2] + .5f) * 255)), TEXT_YUV_POS[0], TEXT_YUV_POS[1] + TEXT_SIZE * 3, mText);
+			}
+
+			if (mHexenabled)
+				canvas.drawText("#" + mHexStr, TEXT_HEX_POS[0], TEXT_HEX_POS[1] + TEXT_SIZE, mText);
+		}
+
+		/**
+		 * Place a small circle on the 2D palette to indicate the current values.
+		 * @param canvas
+		 * @param markerPosX
+		 * @param markerPosY
+		 */
+		private void mark2DPalette(Canvas canvas, int markerPosX, int markerPosY) {
+			mPosMarker.setColor(Color.BLACK);
+			canvas.drawOval(new RectF(markerPosX - 5, markerPosY - 5, markerPosX + 5, markerPosY + 5), mPosMarker);
+			mPosMarker.setColor(Color.WHITE);
+			canvas.drawOval(new RectF(markerPosX - 3, markerPosY - 3, markerPosX + 3, markerPosY + 3), mPosMarker);
+		}
+
+		/**
+		 * Draw a line across the slider to indicate its current value.
+		 * @param canvas
+		 * @param markerPos
+		 */
+		private void markVerSlider(Canvas canvas, int markerPos) {
+			mPosMarker.setColor(Color.BLACK);
+			canvas.drawRect(new Rect(0, markerPos - 2, SLIDER_THICKNESS, markerPos + 3), mPosMarker);
+			mPosMarker.setColor(Color.WHITE);
+			canvas.drawRect(new Rect(0, markerPos, SLIDER_THICKNESS, markerPos + 1), mPosMarker);
+		}
+
+		/**
+		 * Frame the slider to indicate that it has trackball focus.
+		 * @param canvas
+		 */
+		private void hilightFocusedVerSlider(Canvas canvas) {
+			mPosMarker.setColor(Color.WHITE);
+			canvas.drawRect(new Rect(0, 0, SLIDER_THICKNESS, PALETTE_DIM), mPosMarker);
+			mPosMarker.setColor(Color.BLACK);
+			canvas.drawRect(new Rect(2, 2, SLIDER_THICKNESS - 2, PALETTE_DIM - 2), mPosMarker);
+		}
+
+		/**
+		 * Frame the 2D palette to indicate that it has trackball focus.
+		 * @param canvas
+		 */
+		private void hilightFocusedOvalPalette(Canvas canvas) {
+			mPosMarker.setColor(Color.WHITE);
+			canvas.drawOval(new RectF(-PALETTE_RADIUS, -PALETTE_RADIUS, PALETTE_RADIUS, PALETTE_RADIUS), mPosMarker);
+			mPosMarker.setColor(Color.BLACK);
+			canvas.drawOval(new RectF(-PALETTE_RADIUS + 2, -PALETTE_RADIUS + 2, PALETTE_RADIUS - 2, PALETTE_RADIUS - 2), mPosMarker);
+		}
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		//To add a new method, replicate the basic draw functions here.  Use the 2D palette or 1D sliders as templates for the new method.
+		/**
+		 * Draw the UI for HSV with angular H and radial S combined in 2D and a 1D V slider.
+		 * @param canvas
+		 */
+		private void drawHSV1Palette(Canvas canvas) {
+			canvas.save();
+
+			canvas.translate(PALETTE_POS_X, PALETTE_POS_Y);
+
+			//Draw the 2D palette
+			canvas.translate(PALETTE_CENTER_X, PALETTE_CENTER_Y);
+			canvas.drawOval(new RectF(-PALETTE_RADIUS, -PALETTE_RADIUS, PALETTE_RADIUS, PALETTE_RADIUS), mOvalHueSat);
+			canvas.drawOval(new RectF(-PALETTE_RADIUS, -PALETTE_RADIUS, PALETTE_RADIUS, PALETTE_RADIUS), mValDimmer);
+			if (mFocusedControl == 0)
+				hilightFocusedOvalPalette(canvas);
+			mark2DPalette(canvas, mCoord[0], mCoord[1]);
+			canvas.translate(-PALETTE_CENTER_X, -PALETTE_CENTER_Y);
+
+			//Draw the 1D slider
+			canvas.translate(PALETTE_DIM, 0);
+			canvas.drawBitmap(mVerSliderBM, 0, 0, null);
+			if (mFocusedControl == 1)
+				hilightFocusedVerSlider(canvas);
+			markVerSlider(canvas, mCoord[2]);
+
+			canvas.restore();
+		}
+
+		/**
+		 * Initialize the current color chooser's UI (set its color parameters and set its palette and slider values accordingly).
+		 */
+		private void initUI() {
+			initHSV1Palette();
+
+			//Focus on the first controller (arbitrary).
+			mFocusedControl = 0;
+		}
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		//To add a new method, replicate and extend the last init function shown below
+		/**
+		 * Initialize a color chooser.
+		 */
+		private void initHSV1Palette() {
+			setOvalValDimmer();
+			setVerValSlider();
+
+			float angle = 2*PI - mHSV[0] / (180 / 3.1415927f);
+			float radius = mHSV[1] * PALETTE_RADIUS;
+			mCoord[0] = (int)(Math.cos(angle) * radius);
+			mCoord[1] = (int)(Math.sin(angle) * radius);
+
+			mCoord[2] = PALETTE_DIM - (int)(mHSV[2] * PALETTE_DIM);
+		}
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		//To add a new method, replicate and extend the set functions below, one per UI controller in the new method
+		/**
+		 * Adjust a Paint which, when painted, dims its underlying object to show the effects of varying value (brightness).
+		 */
+		private void setOvalValDimmer() {
+			float[] hsv = new float[3];
+			hsv[0] = mHSV[0];
+			hsv[1] = 0;
+			hsv[2] = mHSV[2];
+			int gray = Color.HSVToColor(hsv);
+			mValDimmer.setColor(gray);
+		}
+
+		/**
+		 * Create a linear gradient shader to show variations in value.
+		 */
+		private void setVerValSlider() {
+			float[] hsv = new float[3];
+			hsv[0] = mHSV[0];
+			hsv[1] = mHSV[1];
+			hsv[2] = 1;
+			int col = Color.HSVToColor(hsv);
+
+			int colors[] = new int[2];
+			colors[0] = col;
+			colors[1] = 0xFF000000;
+			GradientDrawable gradDraw = new GradientDrawable(Orientation.TOP_BOTTOM, colors);
+			gradDraw.setDither(true);
+			gradDraw.setLevel(10000);
+			gradDraw.setBounds(0, 0, SLIDER_THICKNESS, PALETTE_DIM);
+			gradDraw.draw(mVerSliderCv);
+		}
+
+		/**
+		 * Report the correct tightly bounded dimensions of the view.
+		 */
+		@Override
+		protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+			setMeasuredDimension(VIEW_DIM_X, VIEW_DIM_Y);
+		}
+
+		/**
+		 * Wrap Math.round().  I'm not a Java expert.  Is this the only way to avoid writing "(int)Math.round" everywhere?
+		 * @param x
+		 * @return
+		 */
+		private int round(double x) {
+			return (int)Math.round(x);
+		}
+
+		/**
+		 * Limit a value to the range [0,1].
+		 * @param n
+		 * @return
+		 */
+		private float pinToUnit(float n) {
+			if (n < 0) {
+				n = 0;
+			} else if (n > 1) {
+				n = 1;
+			}
+			return n;
+		}
+
+		/**
+		 * Limit a value to the range [0,max].
+		 * @param n
+		 * @param max
+		 * @return
+		 */
+		private float pin(float n, float max) {
+			if (n < 0) {
+				n = 0;
+			} else if (n > max) {
+				n = max;
+			}
+			return n;
+		}
+
+		/**
+		 * Limit a value to the range [min,max].
+		 * @param n
+		 * @param min
+		 * @param max
+		 * @return
+		 */
+		private float pin(float n, float min, float max) {
+			if (n < min) {
+				n = min;
+			} else if (n > max) {
+				n = max;
+			}
+			return n;
+		}
+
+		/**
+		 * No clue what this does (some sort of average/mean I presume).  It came with the original UberColorPickerDialog
+		 * in the API Demos and wasn't documented.  I don't feel like spending any time figuring it out, I haven't looked at it at all.
+		 * @param s
+		 * @param d
+		 * @param p
+		 * @return
+		 */
+		private int ave(int s, int d, float p) {
+			return s + round(p * (d - s));
+		}
+
+		/**
+		 * Came with the original UberColorPickerDialog in the API Demos, wasn't documented.  I believe it takes an array of
+		 * colors and a value in the range [0,1] and interpolates a resulting color in a seemingly predictable manner.
+		 * I haven't looked at it at all.
+		 * @param colors
+		 * @param unit
+		 * @return
+		 */
+		private int interpColor(int colors[], float unit) {
+			if (unit <= 0) {
+				return colors[0];
+			}
+			if (unit >= 1) {
+				return colors[colors.length - 1];
+			}
+
+			float p = unit * (colors.length - 1);
+			int i = (int)p;
+			p -= i;
+
+			// now p is just the fractional part [0...1) and i is the index
+			int c0 = colors[i];
+			int c1 = colors[i+1];
+			int a = ave(Color.alpha(c0), Color.alpha(c1), p);
+			int r = ave(Color.red(c0), Color.red(c1), p);
+			int g = ave(Color.green(c0), Color.green(c1), p);
+			int b = ave(Color.blue(c0), Color.blue(c1), p);
+
+			return Color.argb(a, r, g, b);
+		}
+
+		/**
+		 * A standard point-in-rect routine.
+		 * @param x
+		 * @param y
+		 * @param r
+		 * @return true if point x,y is in rect r
+		 */
+		public boolean ptInRect(int x, int y, Rect r) {
+			return x > r.left && x < r.right && y > r.top && y < r.bottom;
+		}
+
+		/**
+		 * Process trackball events.  Used mainly for fine-tuned color adjustment, or alternatively to switch between slider controls.
+		 */
+		@Override
+		public boolean dispatchTrackballEvent(MotionEvent event) {
+			float x = event.getX();
+			float y = event.getY();
+
+			//A longer event history implies faster trackball movement.
+			//Use it to infer a larger jump and therefore faster palette/slider adjustment.
+			int jump = event.getHistorySize() + 1;
+
+			switch (event.getAction()) {
+				case MotionEvent.ACTION_DOWN: {
+					}
+					break;
+				case MotionEvent.ACTION_MOVE: {
+						//NEW_METHOD_WORK_NEEDED_HERE
+						//To add a new method, replicate and extend the appropriate entry in this list,
+						//depending on whether you use 1D or 2D controllers
+						switch (mMethod) {
+							case METHOD_HS_V_PALETTE:
+								if (mFocusedControl == 0) {
+									changeHSPalette(x, y, jump);
+								}
+								else if (mFocusedControl == 1) {
+									if (y < 0)
+										changeSlider(mFocusedControl, true, jump);
+									else if (y > 0)
+										changeSlider(mFocusedControl, false, jump);
+								}
+								break;
+						}
+					}
+					break;
+				case MotionEvent.ACTION_UP: {
+					}
+					break;
+			}
+
+			return true;
+		}
+
+		//NEW_METHOD_WORK_NEEDED_HERE
+		//To add a new method, replicate and extend the appropriate functions below,
+		//one per UI controller in the new method
+		/**
+		 * Effect a trackball change to a 2D palette.
+		 * @param x -1: negative x change, 0: no x change, +1: positive x change.
+		 * @param y -1: negative y change, 0, no y change, +1: positive y change.
+		 * @param jump the amount by which to change.
+		 */
+		private void changeHSPalette(float x, float y, int jump) {
+			int x2 = 0, y2 = 0;
+			if (x < 0)
+				x2 = -jump;
+			else if (x > 0)
+				x2 = jump;
+			if (y < 0)
+				y2 = -jump;
+			else if (y > 0)
+				y2 = jump;
+
+		 	mCoord[0] += x2;
+		 	mCoord[1] += y2;
+
+		 	if (mCoord[0] < -PALETTE_RADIUS)
+		 		mCoord[0] = -PALETTE_RADIUS;
+		 	else if (mCoord[0] > PALETTE_RADIUS)
+		 		mCoord[0] = PALETTE_RADIUS;
+		 	if (mCoord[1] < -PALETTE_RADIUS)
+		 		mCoord[1] = -PALETTE_RADIUS;
+		 	else if (mCoord[1] > PALETTE_RADIUS)
+		 		mCoord[1] = PALETTE_RADIUS;
+
+			float radius = (float)java.lang.Math.sqrt(mCoord[0] * mCoord[0] + mCoord[1] * mCoord[1]);
+			if (radius > PALETTE_RADIUS)
+				radius = PALETTE_RADIUS;
+
+			float angle = (float)java.lang.Math.atan2(mCoord[1], mCoord[0]);
+			// need to turn angle [-PI ... PI] into unit [0....1]
+			float unit = angle/(2*PI);
+			if (unit < 0) {
+				unit += 1;
+			}
+
+			mCoord[0] = round(Math.cos(angle) * radius);
+			mCoord[1] = round(Math.sin(angle) * radius);
+
+			int c = interpColor(mSpectrumColorsRev, unit);
+			float[] hsv = new float[3];
+			Color.colorToHSV(c, hsv);
+			mHSV[0] = hsv[0];
+			mHSV[1] = radius / PALETTE_RADIUS;
+			updateAllFromHSV();
+			mSwatchNew.setColor(Color.HSVToColor(mHSV));
+
+			setVerValSlider();
+
+			invalidate();
+		}
+
+		/**
+		 * Effect a trackball change to a 1D slider.
+		 * @param slider id of the slider to be effected
+		 * @param increase true if the change is an increase, false if a decrease
+		 * @param jump the amount by which to change in units of the range [0,255]
+		 */
+		private void changeSlider(int slider, boolean increase, int jump) {
+			//NEW_METHOD_WORK_NEEDED_HERE
+			//It is only necessary to add an entry here for a new method if the new method uses a 1D slider.
+			//Note, some sliders are horizontal and others are vertical.
+			//They differ a bit, especially in a sign flip on the vertical axis.
+			if (mMethod == METHOD_HS_V_PALETTE) {
+				//slider *must* equal 1
+
+				mHSV[2] += (increase ? jump : -jump) / 256.0f;
+				mHSV[2] = pinToUnit(mHSV[2]);
+				updateAllFromHSV();
+				mCoord[2] = PALETTE_DIM - (int)(mHSV[2] * PALETTE_DIM);
+
+				mSwatchNew.setColor(Color.HSVToColor(mHSV));
+
+				setOvalValDimmer();
+
+				invalidate();
+			}
+		}
+
+		/**
+		 * Keep all colorspace representations in sync.
+		 */
+		private void updateRGBfromHSV() {
+			int color = Color.HSVToColor(mHSV);
+			mRGB[0] = Color.red(color);
+			mRGB[1] = Color.green(color);
+			mRGB[2] = Color.blue(color);
+		}
+
+		/**
+		 * Keep all colorspace representations in sync.
+		 */
+		private void updateYUVfromRGB() {
+			float r = mRGB[0] / 255.0f;
+			float g = mRGB[1] / 255.0f;
+			float b = mRGB[2] / 255.0f;
+
+			ColorMatrix cm = new ColorMatrix();
+			cm.setRGB2YUV();
+			final float[] a = cm.getArray();
+
+			mYUV[0] = a[0] * r + a[1] * g + a[2] * b;
+			mYUV[0] = pinToUnit(mYUV[0]);
+			mYUV[1] = a[5] * r + a[6] * g + a[7] * b;
+			mYUV[1] = pin(mYUV[1], -.5f, .5f);
+			mYUV[2] = a[10] * r + a[11] * g + a[12] * b;
+			mYUV[2] = pin(mYUV[2], -.5f, .5f);
+		}
+
+		/**
+		 * Keep all colorspace representations in sync.
+		 */
+		private void updateHexFromHSV() {
+			//For now, assume 100% opacity
+			mHexStr = Integer.toHexString(Color.HSVToColor(mHSV)).toUpperCase();
+			mHexStr = mHexStr.substring(2, mHexStr.length());
+		}
+
+		/**
+		 * Keep all colorspace representations in sync.
+		 */
+		private void updateAllFromHSV() {
+			//Update mRGB
+			if (mRGBenabled || mYUVenabled)
+				updateRGBfromHSV();
+
+			//Update mYUV
+			if (mYUVenabled)
+				updateYUVfromRGB();
+
+			//Update mHexStr
+			if (mRGBenabled)
+				updateHexFromHSV();
+		}
+
+		/**
+		 * Process touch events: down, move, and up
+		 */
+		@Override
+		public boolean onTouchEvent(MotionEvent event) {
+			float x = event.getX();
+			float y = event.getY();
+
+			//Generate coordinates which are palette=local with the origin at the upper left of the main 2D palette
+			int y2 = (int)(pin(round(y - PALETTE_POS_Y), PALETTE_DIM));
+
+			//Generate coordinates which are palette-local with the origin at the center of the main 2D palette
+			float circlePinnedX = x - PALETTE_POS_X - PALETTE_CENTER_X;
+			float circlePinnedY = y - PALETTE_POS_Y - PALETTE_CENTER_Y;
+
+			//Is the event in a swatch?
+			boolean inSwatchOld = ptInRect(round(x), round(y), mOldSwatchRect);
+			boolean inSwatchNew = ptInRect(round(x), round(y), mNewSwatchRect);
+
+			//Get the event's distance from the center of the main 2D palette
+			float radius = (float)java.lang.Math.sqrt(circlePinnedX * circlePinnedX + circlePinnedY * circlePinnedY);
+
+			//Is the event in a circle-pinned 2D palette?
+			boolean inOvalPalette = radius <= PALETTE_RADIUS;
+
+			//Pin the radius
+			if (radius > PALETTE_RADIUS)
+				radius = PALETTE_RADIUS;
+
+			//Is the event in a vertical slider to the right of the main 2D palette
+			boolean inVerSlider = ptInRect(round(x), round(y), mVerSliderRect);
+
+			switch (event.getAction()) {
+				case MotionEvent.ACTION_DOWN:
+					mTracking = TRACKED_NONE;
+
+					if (inSwatchOld)
+						mTracking = TRACK_SWATCH_OLD;
+					else if (inSwatchNew)
+						mTracking = TRACK_SWATCH_NEW;
+
+					//NEW_METHOD_WORK_NEEDED_HERE
+					//To add a new method, replicate and extend the last entry in this list
+					else if (mMethod == METHOD_HS_V_PALETTE) {
+						if (inOvalPalette) {
+							mTracking = TRACK_HS_PALETTE;
+							mFocusedControl = 0;
+						}
+						else if (inVerSlider) {
+							mTracking = TRACK_VER_VALUE_SLIDER;
+							mFocusedControl = 1;
+						}
+					}
+				case MotionEvent.ACTION_MOVE:
+					//NEW_METHOD_WORK_NEEDED_HERE
+					//To add a new method, replicate and extend the entries in this list,
+					//one per UI controller the new method requires.
+					if (mTracking == TRACK_HS_PALETTE) {
+						float angle = (float)java.lang.Math.atan2(circlePinnedY, circlePinnedX);
+						// need to turn angle [-PI ... PI] into unit [0....1]
+						float unit = angle/(2*PI);
+						if (unit < 0) {
+							unit += 1;
+						}
+
+						mCoord[0] = round(Math.cos(angle) * radius);
+						mCoord[1] = round(Math.sin(angle) * radius);
+
+						int c = interpColor(mSpectrumColorsRev, unit);
+						float[] hsv = new float[3];
+						Color.colorToHSV(c, hsv);
+						mHSV[0] = hsv[0];
+						mHSV[1] = radius / PALETTE_RADIUS;
+						updateAllFromHSV();
+						mSwatchNew.setColor(Color.HSVToColor(mHSV));
+
+						setVerValSlider();
+
+						invalidate();
+					}
+					else if (mTracking == TRACK_VER_VALUE_SLIDER) {
+						if (mCoord[2] != y2) {
+							mCoord[2] = y2;
+							float value = 1.0f - (float)y2 / (float)PALETTE_DIM;
+
+							mHSV[2] = value;
+							updateAllFromHSV();
+							mSwatchNew.setColor(Color.HSVToColor(mHSV));
+
+							setOvalValDimmer();
+
+							invalidate();
+						}
+					}
+					break;
+				case MotionEvent.ACTION_UP:
+					//NEW_METHOD_WORK_NEEDED_HERE
+					//To add a new method, replicate and extend the last entry in this list.
+					if (mTracking == TRACK_SWATCH_OLD && inSwatchOld) {
+						Color.colorToHSV(mOriginalColor, mHSV);
+						mSwatchNew.setColor(mOriginalColor);
+						initUI();
+						invalidate();
+					}
+					else if (mTracking == TRACK_SWATCH_NEW && inSwatchNew) {
+						mListener.colorChanged(mSwatchNew.getColor());
+						invalidate();
+					}
+
+					mTracking= TRACKED_NONE;
+					break;
+			}
+
+			return true;
+		}
+	}
+}
diff --git a/ScriptingLayerForAndroid/src/org/connectbot/util/VolumePreference.java b/ScriptingLayerForAndroid/src/org/connectbot/util/VolumePreference.java
new file mode 100644
index 0000000..2e7f61c
--- /dev/null
+++ b/ScriptingLayerForAndroid/src/org/connectbot/util/VolumePreference.java
@@ -0,0 +1,72 @@
+/*
+ * ConnectBot: simple, powerful, open-source SSH client for Android
+ * Copyright 2007 Kenny Root, Jeffrey Sharkey
+ *
+ * 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.connectbot.util;
+
+import android.content.Context;
+import android.preference.DialogPreference;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.SeekBar;
+import android.widget.SeekBar.OnSeekBarChangeListener;
+
+/**
+ * @author kenny
+ *
+ */
+public class VolumePreference extends DialogPreference implements OnSeekBarChangeListener {
+	/**
+	 * @param context
+	 * @param attrs
+	 */
+	public VolumePreference(Context context, AttributeSet attrs) {
+		super(context, attrs);
+
+		setupLayout(context, attrs);
+	}
+
+	public VolumePreference(Context context, AttributeSet attrs, int defStyle) {
+		super(context, attrs, defStyle);
+
+		setupLayout(context, attrs);
+	}
+
+	private void setupLayout(Context context, AttributeSet attrs) {
+		setPersistent(true);
+	}
+
+	@Override
+	protected View onCreateDialogView() {
+		SeekBar sb = new SeekBar(getContext());
+
+		sb.setMax(100);
+		sb.setProgress((int)(getPersistedFloat(
+				PreferenceConstants.DEFAULT_BELL_VOLUME) * 100));
+		sb.setPadding(10, 10, 10, 10);
+		sb.setOnSeekBarChangeListener(this);
+
+		return sb;
+	}
+
+	public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+		persistFloat(progress / 100f);
+	}
+
+	public void onStartTrackingTouch(SeekBar seekBar) { }
+
+	public void onStopTrackingTouch(SeekBar seekBar) { }
+}
diff --git a/Utils/Android.mk b/Utils/Android.mk
new file mode 100644
index 0000000..5417389
--- /dev/null
+++ b/Utils/Android.mk
@@ -0,0 +1,27 @@
+#
+#  Copyright (C) 2016 Google, Inc.
+#
+#  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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+
+LOCAL_MODULE := sl4a.Utils
+LOCAL_MODULE_OWNER := google
+LOCAL_STATIC_JAVA_LIBRARIES := guava android-common
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
diff --git a/Utils/src/com/googlecode/android_scripting/ConvertUtils.java b/Utils/src/com/googlecode/android_scripting/ConvertUtils.java
new file mode 100644
index 0000000..3e6956d
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/ConvertUtils.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+public class ConvertUtils {
+    /**
+     * Converts a String of comma separated bytes to a byte array
+     *
+     * @param value The value to convert
+     * @return the byte array
+     */
+    public static byte[] convertStringToByteArray(String value) {
+        if (value.equals("")) {
+            return new byte[0];
+        }
+        String[] parseString = value.split(",");
+        byte[] byteArray = new byte[parseString.length];
+        if (byteArray.length > 0) {
+            for (int i = 0; i < parseString.length; i++) {
+                byte byteValue = Byte.valueOf(parseString[i].trim());
+                byteArray[i] = byteValue;
+            }
+        }
+        return byteArray;
+    }
+
+    /**
+     * Converts a byte array to a comma separated String
+     *
+     * @param byteArray
+     * @return comma separated string of bytes
+     */
+    public static String convertByteArrayToString(byte[] byteArray) {
+        String ret = "";
+        if (byteArray != null) {
+            for (int i = 0; i < byteArray.length; i++) {
+                if ((i + 1) != byteArray.length) {
+                    ret = ret + Byte.valueOf(byteArray[i]) + ",";
+                }
+                else {
+                    ret = ret + Byte.valueOf(byteArray[i]);
+                }
+            }
+        }
+        return ret;
+    }
+
+}
diff --git a/Utils/src/com/googlecode/android_scripting/FileUtils.java b/Utils/src/com/googlecode/android_scripting/FileUtils.java
new file mode 100644
index 0000000..91abc2c
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/FileUtils.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.os.Environment;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
+
+/**
+ * Utility functions for handling files.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class FileUtils {
+
+  private FileUtils() {
+    // Utility class.
+  }
+
+  static public boolean externalStorageMounted() {
+    String state = Environment.getExternalStorageState();
+    return Environment.MEDIA_MOUNTED.equals(state)
+        || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state);
+  }
+
+  public static int chmod(File path, int mode) throws Exception {
+    Class<?> fileUtils = Class.forName("android.os.FileUtils");
+    Method setPermissions =
+        fileUtils.getMethod("setPermissions", String.class, int.class, int.class, int.class);
+    return (Integer) setPermissions.invoke(null, path.getAbsolutePath(), mode, -1, -1);
+  }
+
+  public static boolean recursiveChmod(File root, int mode) throws Exception {
+    boolean success = chmod(root, mode) == 0;
+    for (File path : root.listFiles()) {
+      if (path.isDirectory()) {
+        success = recursiveChmod(path, mode);
+      }
+      success &= (chmod(path, mode) == 0);
+    }
+    return success;
+  }
+
+  public static boolean delete(File path) {
+    boolean result = true;
+    if (path.exists()) {
+      if (path.isDirectory()) {
+        for (File child : path.listFiles()) {
+          result &= delete(child);
+        }
+        result &= path.delete(); // Delete empty directory.
+      }
+      if (path.isFile()) {
+        result &= path.delete();
+      }
+      if (!result) {
+        Log.e("Delete failed;");
+      }
+      return result;
+    } else {
+      Log.e("File does not exist.");
+      return false;
+    }
+  }
+
+  public static File copyFromStream(String name, InputStream input) {
+    if (name == null || name.length() == 0) {
+      Log.e("No script name specified.");
+      return null;
+    }
+    File file = new File(name);
+    if (!makeDirectories(file.getParentFile(), 0755)) {
+      return null;
+    }
+    try {
+      OutputStream output = new FileOutputStream(file);
+      IoUtils.copy(input, output);
+    } catch (Exception e) {
+      Log.e(e);
+      return null;
+    }
+    return file;
+  }
+
+  public static boolean makeDirectories(File directory, int mode) {
+    File parent = directory;
+    while (parent.getParentFile() != null && !parent.exists()) {
+      parent = parent.getParentFile();
+    }
+    if (!directory.exists()) {
+      Log.v("Creating directory: " + directory.getName());
+      if (!directory.mkdirs()) {
+        Log.e("Failed to create directory.");
+        return false;
+      }
+    }
+    try {
+      recursiveChmod(parent, mode);
+    } catch (Exception e) {
+      Log.e(e);
+      return false;
+    }
+    return true;
+  }
+
+  public static File getExternalDownload() {
+    try {
+      Class<?> c = Class.forName("android.os.Environment");
+      Method m = c.getDeclaredMethod("getExternalStoragePublicDirectory", String.class);
+      String download = c.getDeclaredField("DIRECTORY_DOWNLOADS").get(null).toString();
+      return (File) m.invoke(null, download);
+    } catch (Exception e) {
+      return new File(Environment.getExternalStorageDirectory(), "Download");
+    }
+  }
+
+  public static boolean rename(File file, String name) {
+    return file.renameTo(new File(file.getParent(), name));
+  }
+
+  public static String readToString(File file) throws IOException {
+    if (file == null || !file.exists()) {
+      return null;
+    }
+    FileReader reader = new FileReader(file);
+    StringBuilder out = new StringBuilder();
+    char[] buffer = new char[1024 * 4];
+    int numRead = 0;
+    while ((numRead = reader.read(buffer)) > -1) {
+      out.append(String.valueOf(buffer, 0, numRead));
+    }
+    reader.close();
+    return out.toString();
+  }
+
+  public static String readFromAssetsFile(Context context, String name) throws IOException {
+    AssetManager am = context.getAssets();
+    BufferedReader reader = new BufferedReader(new InputStreamReader(am.open(name)));
+    String line;
+    StringBuilder builder = new StringBuilder();
+    while ((line = reader.readLine()) != null) {
+      builder.append(line);
+    }
+    reader.close();
+    return builder.toString();
+  }
+
+}
diff --git a/Utils/src/com/googlecode/android_scripting/ForegroundService.java b/Utils/src/com/googlecode/android_scripting/ForegroundService.java
new file mode 100644
index 0000000..64fbe24
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/ForegroundService.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.Service;
+
+import java.lang.reflect.Method;
+
+public abstract class ForegroundService extends Service {
+  private static final Class<?>[] mStartForegroundSignature =
+      new Class[] { int.class, Notification.class };
+  private static final Class<?>[] mStopForegroundSignature = new Class[] { boolean.class };
+
+  private final int mNotificationId;
+
+  private NotificationManager mNotificationManager;
+  private Method mStartForeground;
+  private Method mStopForeground;
+  private Object[] mStartForegroundArgs = new Object[2];
+  private Object[] mStopForegroundArgs = new Object[1];
+
+  public ForegroundService(int id) {
+    mNotificationId = id;
+  }
+
+  protected abstract Notification createNotification();
+
+  /**
+   * This is a wrapper around the new startForeground method, using the older APIs if it is not
+   * available.
+   */
+  private void startForegroundCompat(Notification notification) {
+    // If we have the new startForeground API, then use it.
+    if (mStartForeground != null) {
+      mStartForegroundArgs[0] = Integer.valueOf(mNotificationId);
+      mStartForegroundArgs[1] = notification;
+      try {
+        mStartForeground.invoke(this, mStartForegroundArgs);
+      } catch (Exception e) {
+        Log.e(e);
+      }
+      return;
+    }
+
+    // Fall back on the old API.
+    setForeground(true);
+    if (notification != null) {
+      mNotificationManager.notify(mNotificationId, notification);
+    }
+  }
+
+  /**
+   * This is a wrapper around the new stopForeground method, using the older APIs if it is not
+   * available.
+   */
+  private void stopForegroundCompat() {
+    // If we have the new stopForeground API, then use it.
+    if (mStopForeground != null) {
+      mStopForegroundArgs[0] = Boolean.TRUE;
+      try {
+        mStopForeground.invoke(this, mStopForegroundArgs);
+      } catch (Exception e) {
+        Log.e(e);
+      }
+      return;
+    }
+
+    // Fall back on the old API. Note to cancel BEFORE changing the
+    // foreground state, since we could be killed at that point.
+    mNotificationManager.cancel(mNotificationId);
+    setForeground(false);
+  }
+
+  @Override
+  public void onCreate() {
+    mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+    try {
+      mStartForeground = getClass().getMethod("startForeground", mStartForegroundSignature);
+      mStopForeground = getClass().getMethod("stopForeground", mStopForegroundSignature);
+    } catch (NoSuchMethodException e) {
+      // Running on an older platform.
+      mStartForeground = mStopForeground = null;
+    }
+    startForegroundCompat(createNotification());
+  }
+
+  @Override
+  public void onDestroy() {
+    // Make sure our notification is gone.
+    stopForegroundCompat();
+  }
+}
diff --git a/Utils/src/com/googlecode/android_scripting/IoUtils.java b/Utils/src/com/googlecode/android_scripting/IoUtils.java
new file mode 100644
index 0000000..0fd0ca0
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/IoUtils.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class IoUtils {
+  private static final int BUFFER_SIZE = 1024 * 8;
+
+  private IoUtils() {
+    // Utility class.
+  }
+
+  public static int copy(InputStream input, OutputStream output) throws Exception, IOException {
+    byte[] buffer = new byte[BUFFER_SIZE];
+
+    BufferedInputStream in = new BufferedInputStream(input, BUFFER_SIZE);
+    BufferedOutputStream out = new BufferedOutputStream(output, BUFFER_SIZE);
+    int count = 0, n = 0;
+    try {
+      while ((n = in.read(buffer, 0, BUFFER_SIZE)) != -1) {
+        out.write(buffer, 0, n);
+        count += n;
+      }
+      out.flush();
+    } finally {
+      try {
+        out.close();
+      } catch (IOException e) {
+        Log.e(e.getMessage(), e);
+      }
+      try {
+        in.close();
+      } catch (IOException e) {
+        Log.e(e.getMessage(), e);
+      }
+    }
+    return count;
+  }
+
+}
diff --git a/Utils/src/com/googlecode/android_scripting/Log.java b/Utils/src/com/googlecode/android_scripting/Log.java
new file mode 100644
index 0000000..4947a0c
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/Log.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.app.AlertDialog;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.widget.Toast;
+
+public class Log {
+  private Log() {
+    // Utility class.
+  }
+
+  private static String getTag() {
+    StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+    String fullClassName = stackTraceElements[4].getClassName();
+    String className = fullClassName.substring(fullClassName.lastIndexOf(".") + 1);
+    int lineNumber = stackTraceElements[4].getLineNumber();
+    return "sl4a." + className + ":" + lineNumber;
+  }
+
+  private static void toast(Context context, String message) {
+    Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
+  }
+
+  public static void notify(Context context, String title, String contentTitle, String message) {
+    android.util.Log.v(getTag(), String.format("%s %s", contentTitle, message));
+
+    String packageName = context.getPackageName();
+    int iconId = context.getResources().getIdentifier("stat_sys_warning", "drawable", packageName);
+    NotificationManager notificationManager =
+        (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    Notification.Builder builder = new Notification.Builder(context);
+    builder.setSmallIcon(iconId > 0 ? iconId : -1)
+           .setTicker(title)
+           .setWhen(0)
+           .setContentTitle(contentTitle)
+           .setContentText(message)
+           .setContentIntent(PendingIntent.getService(context, 0, null, 0));
+    Notification note = builder.build();
+    note.contentView.getLayoutId();
+    notificationManager.notify(NotificationIdFactory.create(), note);
+  }
+
+  public static void showDialog(final Context context, final String title, final String message) {
+    android.util.Log.v(getTag(), String.format("%s %s", title, message));
+
+    MainThread.run(context, new Runnable() {
+      @Override
+      public void run() {
+        AlertDialog.Builder builder = new AlertDialog.Builder(context);
+        builder.setTitle(title);
+        builder.setMessage(message);
+
+        DialogInterface.OnClickListener buttonListener = new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int which) {
+            dialog.dismiss();
+          }
+        };
+        builder.setPositiveButton("Ok", buttonListener);
+        builder.show();
+      }
+    });
+  }
+
+  public static void v(String message) {
+    android.util.Log.v(getTag(), message);
+  }
+
+  public static void v(String message, Throwable e) {
+    android.util.Log.v(getTag(), message, e);
+  }
+
+  public static void v(Context context, String message) {
+    toast(context, message);
+    android.util.Log.v(getTag(), message);
+  }
+
+  public static void v(Context context, String message, Throwable e) {
+    toast(context, message);
+    android.util.Log.v(getTag(), message, e);
+  }
+
+  public static void e(Throwable e) {
+    android.util.Log.e(getTag(), "Error", e);
+  }
+
+  public static void e(String message) {
+    android.util.Log.e(getTag(), message);
+  }
+
+  public static void e(String message, Throwable e) {
+    android.util.Log.e(getTag(), message, e);
+  }
+
+  public static void e(Context context, String message) {
+    toast(context, message);
+    android.util.Log.e(getTag(), message);
+  }
+
+  public static void e(Context context, String message, Throwable e) {
+    toast(context, message);
+    android.util.Log.e(getTag(), message, e);
+  }
+
+  public static void w(Throwable e) {
+    android.util.Log.w(getTag(), "Warning", e);
+  }
+
+  public static void w(String message) {
+    android.util.Log.w(getTag(), message);
+  }
+
+  public static void w(String message, Throwable e) {
+    android.util.Log.w(getTag(), message, e);
+  }
+
+  public static void w(Context context, String message) {
+    toast(context, message);
+    android.util.Log.w(getTag(), message);
+  }
+
+  public static void w(Context context, String message, Throwable e) {
+    toast(context, message);
+    android.util.Log.w(getTag(), message, e);
+  }
+
+  public static void d(String message) {
+    android.util.Log.d(getTag(), message);
+  }
+
+  public static void d(String message, Throwable e) {
+    android.util.Log.d(getTag(), message, e);
+  }
+
+  public static void d(Context context, String message) {
+    toast(context, message);
+    android.util.Log.d(getTag(), message);
+  }
+
+  public static void d(Context context, String message, Throwable e) {
+    toast(context, message);
+    android.util.Log.d(getTag(), message, e);
+  }
+
+  public static void i(String message) {
+    android.util.Log.i(getTag(), message);
+  }
+
+  public static void i(String message, Throwable e) {
+    android.util.Log.i(getTag(), message, e);
+  }
+
+  public static void i(Context context, String message) {
+    toast(context, message);
+    android.util.Log.i(getTag(), message);
+  }
+
+  public static void i(Context context, String message, Throwable e) {
+    toast(context, message);
+    android.util.Log.i(getTag(), message, e);
+  }
+}
diff --git a/Utils/src/com/googlecode/android_scripting/MainThread.java b/Utils/src/com/googlecode/android_scripting/MainThread.java
new file mode 100644
index 0000000..840c1e7
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/MainThread.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import android.content.Context;
+import android.os.Handler;
+
+import com.googlecode.android_scripting.future.FutureResult;
+
+import java.util.concurrent.Callable;
+
+public class MainThread {
+
+  private MainThread() {
+    // Utility class.
+  }
+
+  /**
+   * Executed in the main thread, returns the result of an execution. Anything that runs here should
+   * finish quickly to avoid hanging the UI thread.
+   */
+  public static <T> T run(Context context, final Callable<T> task) {
+    final FutureResult<T> result = new FutureResult<T>();
+    Handler handler = new Handler(context.getMainLooper());
+    handler.post(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          result.set(task.call());
+        } catch (Exception e) {
+          Log.e(e);
+          result.set(null);
+        }
+      }
+    });
+    try {
+      return result.get();
+    } catch (InterruptedException e) {
+      Log.e(e);
+    }
+    return null;
+  }
+
+  public static void run(Context context, final Runnable task) {
+    Handler handler = new Handler(context.getMainLooper());
+    handler.post(new Runnable() {
+      @Override
+      public void run() {
+        task.run();
+      }
+    });
+  }
+}
diff --git a/Utils/src/com/googlecode/android_scripting/NotificationIdFactory.java b/Utils/src/com/googlecode/android_scripting/NotificationIdFactory.java
new file mode 100644
index 0000000..c87d94d
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/NotificationIdFactory.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Creates unique ids to identify the notifications created by the android scripting service and the
+ * trigger service.
+ *
+ * @author Felix Arends (felix.arends@gmail.com)
+ *
+ */
+public final class NotificationIdFactory {
+  private static final AtomicInteger mNextId = new AtomicInteger(0);
+
+  public static int create() {
+    return mNextId.incrementAndGet();
+  }
+
+  private NotificationIdFactory() {
+  }
+}
diff --git a/Utils/src/com/googlecode/android_scripting/SimpleServer.java b/Utils/src/com/googlecode/android_scripting/SimpleServer.java
new file mode 100644
index 0000000..b93b6cb
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/SimpleServer.java
@@ -0,0 +1,368 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import com.google.common.collect.Lists;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.BindException;
+import java.net.Inet4Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.NetworkInterface;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+//import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
+
+/**
+ * A simple server.
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public abstract class SimpleServer {
+  private static int threadIndex = 0;
+  private final ConcurrentHashMap<Integer, ConnectionThread> mConnectionThreads =
+      new ConcurrentHashMap<Integer, ConnectionThread>();
+  private final List<SimpleServerObserver> mObservers = Lists.newArrayList();
+  private volatile boolean mStopServer = false;
+  private ServerSocket mServer;
+  private Thread mServerThread;
+
+  public interface SimpleServerObserver {
+    public void onConnect();
+    public void onDisconnect();
+  }
+
+  protected abstract void handleConnection(Socket socket) throws Exception;
+  protected abstract void handleRPCConnection(Socket socket,
+                                              Integer UID,
+                                              BufferedReader reader,
+                                              PrintWriter writer) throws Exception;
+
+  /** Adds an observer. */
+  public void addObserver(SimpleServerObserver observer) {
+    mObservers.add(observer);
+  }
+
+  /** Removes an observer. */
+  public void removeObserver(SimpleServerObserver observer) {
+    mObservers.remove(observer);
+  }
+
+  private void notifyOnConnect() {
+    for (SimpleServerObserver observer : mObservers) {
+      observer.onConnect();
+    }
+  }
+
+  private void notifyOnDisconnect() {
+    for (SimpleServerObserver observer : mObservers) {
+      observer.onDisconnect();
+    }
+  }
+
+  private final class ConnectionThread extends Thread {
+    private final Socket mmSocket;
+    private final BufferedReader reader;
+    private final PrintWriter writer;
+    private final Integer UID;
+    private final boolean isRpc;
+
+    private ConnectionThread(Socket socket, boolean rpc, Integer uid, BufferedReader reader, PrintWriter writer) {
+      setName("SimpleServer ConnectionThread " + getId());
+      mmSocket = socket;
+      this.UID = uid;
+      this.reader = reader;
+      this.writer = writer;
+      this.isRpc = rpc;
+    }
+
+    @Override
+    public void run() {
+      Log.v("Server thread " + getId() + " started.");
+      try {
+        if(isRpc) {
+          Log.d("Handling RPC connection in "+getId());
+          handleRPCConnection(mmSocket, UID, reader, writer);
+        }else{
+          Log.d("Handling Non-RPC connection in "+getId());
+          handleConnection(mmSocket);
+        }
+      } catch (Exception e) {
+        if (!mStopServer) {
+          Log.e("Server error.", e);
+        }
+      } finally {
+        close();
+        mConnectionThreads.remove(this.UID);
+        notifyOnDisconnect();
+        Log.v("Server thread " + getId() + " stopped.");
+      }
+    }
+
+    private void close() {
+      if (mmSocket != null) {
+        try {
+          mmSocket.close();
+        } catch (IOException e) {
+          Log.e(e.getMessage(), e);
+        }
+      }
+    }
+  }
+
+  /** Returns the number of active connections to this server. */
+  public int getNumberOfConnections() {
+    return mConnectionThreads.size();
+  }
+
+  public static InetAddress getPrivateInetAddress() throws UnknownHostException, SocketException {
+
+    InetAddress candidate = null;
+    Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
+    for (NetworkInterface netint : Collections.list(nets)) {
+      if (!netint.isLoopback() || !netint.isUp()) { // Ignore if localhost or not active
+        continue;
+      }
+      Enumeration<InetAddress> addresses = netint.getInetAddresses();
+      for (InetAddress address : Collections.list(addresses)) {
+        if (address instanceof Inet4Address) {
+          Log.d("local address " + address);
+          return address; // Prefer ipv4
+        }
+        candidate = address; // Probably an ipv6
+      }
+    }
+    if (candidate != null) {
+      return candidate; // return ipv6 address if no suitable ipv6
+    }
+    return InetAddress.getLocalHost(); // No damn matches. Give up, return local host.
+  }
+
+  public static InetAddress getPublicInetAddress() throws UnknownHostException, SocketException {
+
+    InetAddress candidate = null;
+    Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
+    for (NetworkInterface netint : Collections.list(nets)) {
+      if (netint.isLoopback() || !netint.isUp()) { // Ignore if localhost or not active
+        continue;
+      }
+      Enumeration<InetAddress> addresses = netint.getInetAddresses();
+      for (InetAddress address : Collections.list(addresses)) {
+        if (address instanceof Inet4Address) {
+          return address; // Prefer ipv4
+        }
+        candidate = address; // Probably an ipv6
+      }
+    }
+    if (candidate != null) {
+      return candidate; // return ipv6 address if no suitable ipv6
+    }
+    return InetAddress.getLocalHost(); // No damn matches. Give up, return local host.
+  }
+
+  /**
+   * Starts the RPC server bound to the localhost address.
+   *
+   * @param port
+   *          the port to bind to or 0 to pick any unused port
+   *
+   * @return the port that the server is bound to
+   * @throws IOException
+   */
+  public InetSocketAddress startLocal(int port) {
+    InetAddress address;
+    try {
+      // address = InetAddress.getLocalHost();
+      address = getPrivateInetAddress();
+      mServer = new ServerSocket(port, 5, address);
+    } catch (BindException e) {
+      Log.e("Port " + port + " already in use.");
+      try {
+        address = getPrivateInetAddress();
+        mServer = new ServerSocket(0, 5, address);
+      } catch (IOException e1) {
+        e1.printStackTrace();
+        return null;
+      }
+    } catch (Exception e) {
+      Log.e("Failed to start server.", e);
+      return null;
+    }
+    int boundPort = start();
+    return InetSocketAddress.createUnresolved(mServer.getInetAddress().getHostAddress(), boundPort);
+  }
+
+  /**
+   * data Starts the RPC server bound to the public facing address.
+   *
+   * @param port
+   *          the port to bind to or 0 to pick any unused port
+   *
+   * @return the port that the server is bound to
+   */
+  public InetSocketAddress startPublic(int port) {
+    InetAddress address;
+    try {
+      // address = getPublicInetAddress();
+      address = null;
+      mServer = new ServerSocket(port, 5 /* backlog */, address);
+    } catch (Exception e) {
+      Log.e("Failed to start server.", e);
+      return null;
+    }
+    int boundPort = start();
+    return InetSocketAddress.createUnresolved(mServer.getInetAddress().getHostAddress(), boundPort);
+  }
+
+  /**
+   * data Starts the RPC server bound to all interfaces
+   *
+   * @param port
+   *          the port to bind to or 0 to pick any unused port
+   *
+   * @return the port that the server is bound to
+   */
+  public InetSocketAddress startAllInterfaces(int port) {
+    try {
+      mServer = new ServerSocket(port, 5 /* backlog */);
+    } catch (Exception e) {
+      Log.e("Failed to start server.", e);
+      return null;
+    }
+    int boundPort = start();
+    return InetSocketAddress.createUnresolved(mServer.getInetAddress().getHostAddress(), boundPort);
+  }
+
+  private int start() {
+    mServerThread = new Thread() {
+      @Override
+      public void run() {
+        while (!mStopServer) {
+          try {
+            Socket sock = mServer.accept();
+            if (!mStopServer) {
+              startConnectionThread(sock);
+            } else {
+              sock.close();
+            }
+          } catch (IOException e) {
+            if (!mStopServer) {
+              Log.e("Failed to accept connection.", e);
+            }
+          } catch (JSONException e) {
+            if (!mStopServer) {
+              Log.e("Failed to parse request.", e);
+            }
+          }
+        }
+      }
+    };
+    mServerThread.start();
+    Log.v("Bound to " + mServer.getInetAddress());
+    return mServer.getLocalPort();
+  }
+
+  private void startConnectionThread(final Socket sock) throws IOException, JSONException {
+    BufferedReader reader =
+        new BufferedReader(new InputStreamReader(sock.getInputStream()), 8192);
+    PrintWriter writer = new PrintWriter(sock.getOutputStream(), true);
+    String data;
+    if((data = reader.readLine()) != null) {
+      Log.v("Received: " + data);
+      JSONObject request = new JSONObject(data);
+      if(request.has("cmd") && request.has("uid")) {
+        String cmd = request.getString("cmd");
+        int uid = request.getInt("uid");
+        JSONObject result = new JSONObject();
+        if(cmd.equals("initiate")) {
+          Log.d("Initiate a new session");
+          threadIndex += 1;
+          int mUID = threadIndex;
+          ConnectionThread networkThread = new ConnectionThread(sock,true,mUID,reader,writer);
+          mConnectionThreads.put(mUID, networkThread);
+          networkThread.start();
+          notifyOnConnect();
+          result.put("uid", mUID);
+          result.put("status",true);
+          result.put("error", null);
+        }else if(cmd.equals("continue")) {
+          Log.d("Continue an existing session");
+          Log.d("keys: "+mConnectionThreads.keySet().toString());
+          if(!mConnectionThreads.containsKey(uid)) {
+            result.put("uid", uid);
+            result.put("status",false);
+            result.put("error", "Session does not exist.");
+          }else{
+            ConnectionThread networkThread = new ConnectionThread(sock,true,uid,reader,writer);
+            mConnectionThreads.put(uid, networkThread);
+            networkThread.start();
+            notifyOnConnect();
+            result.put("uid", uid);
+            result.put("status",true);
+            result.put("error", null);
+          }
+        }else {
+          result.put("uid", uid);
+          result.put("status",false);
+          result.put("error", "Unrecognized command.");
+        }
+        writer.write(result + "\n");
+        writer.flush();
+        Log.v("Sent: " + result);
+      }else{
+        ConnectionThread networkThread = new ConnectionThread(sock,false,0,reader,writer);
+        mConnectionThreads.put(0, networkThread);
+        networkThread.start();
+        notifyOnConnect();
+      }
+    }
+  }
+
+  public void shutdown() {
+    // Stop listening on the server socket to ensure that
+    // beyond this point there are no incoming requests.
+    mStopServer = true;
+    try {
+      mServer.close();
+    } catch (IOException e) {
+      Log.e("Failed to close server socket.", e);
+    }
+    // Since the server is not running, the mNetworkThreads set can only
+    // shrink from this point onward. We can just stop all of the running helper
+    // threads. In the worst case, one of the running threads will already have
+    // shut down. Since this is a CopyOnWriteList, we don't have to worry about
+    // concurrency issues while iterating over the set of threads.
+    for (ConnectionThread connectionThread : mConnectionThreads.values()) {
+      connectionThread.close();
+    }
+    for (SimpleServerObserver observer : mObservers) {
+      removeObserver(observer);
+    }
+  }
+}
diff --git a/Utils/src/com/googlecode/android_scripting/SingleThreadExecutor.java b/Utils/src/com/googlecode/android_scripting/SingleThreadExecutor.java
new file mode 100644
index 0000000..7c5b1c5
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/SingleThreadExecutor.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting;
+
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class SingleThreadExecutor extends ThreadPoolExecutor {
+
+  public SingleThreadExecutor() {
+    super(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
+  }
+
+  @Override
+  protected void afterExecute(Runnable r, Throwable t) {
+    if (t != null) {
+      throw new RuntimeException(t);
+    }
+  }
+}
\ No newline at end of file
diff --git a/Utils/src/com/googlecode/android_scripting/exception/Sl4aException.java b/Utils/src/com/googlecode/android_scripting/exception/Sl4aException.java
new file mode 100644
index 0000000..2f85b4b
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/exception/Sl4aException.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.exception;
+
+@SuppressWarnings("serial")
+public class Sl4aException extends Exception {
+
+  public Sl4aException(Exception e) {
+    super(e);
+  }
+
+  public Sl4aException(String message) {
+    super(message);
+  }
+
+  public Sl4aException(String message, Exception e) {
+    super(message, e);
+  }
+
+}
diff --git a/Utils/src/com/googlecode/android_scripting/future/FutureResult.java b/Utils/src/com/googlecode/android_scripting/future/FutureResult.java
new file mode 100644
index 0000000..573424c
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/future/FutureResult.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.future;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * FutureResult represents an eventual execution result for asynchronous operations.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ */
+public class FutureResult<T> implements Future<T> {
+
+    private final CountDownLatch mLatch = new CountDownLatch(1);
+    private volatile T mResult = null;
+
+    public void set(T result) {
+        mResult = result;
+        mLatch.countDown();
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        return false;
+    }
+
+    @Override
+    public T get() throws InterruptedException {
+        mLatch.await();
+        return mResult;
+    }
+
+    @Override
+    public T get(long timeout, TimeUnit unit) throws InterruptedException {
+        mLatch.await(timeout, unit);
+        return mResult;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return false;
+    }
+
+    @Override
+    public boolean isDone() {
+        return mResult != null;
+    }
+
+}
diff --git a/Utils/src/com/googlecode/android_scripting/interpreter/ExternalClassLoader.java b/Utils/src/com/googlecode/android_scripting/interpreter/ExternalClassLoader.java
new file mode 100644
index 0000000..3bbe349
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/interpreter/ExternalClassLoader.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import dalvik.system.DexClassLoader;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+public class ExternalClassLoader {
+
+  public Object load(Collection<String> dexPaths, Collection<String> nativePaths, String className)
+      throws Exception {
+    String dexOutputDir = "/sdcard/dexoutput";
+    String joinedDexPaths = join(dexPaths, ":");
+    String joinedNativeLibPaths = nativePaths != null ? join(nativePaths, ":") : null;
+    DexClassLoader loader =
+        new DexClassLoader(joinedDexPaths, dexOutputDir, joinedNativeLibPaths, this.getClass()
+            .getClassLoader());
+    Class<?> classToLoad = Class.forName(className, true, loader);
+    return classToLoad.newInstance();
+  }
+
+    private static String join(Collection<String> collection, String delimiter) {
+        StringBuffer buffer = new StringBuffer();
+        Iterator<String> iter = collection.iterator();
+        while (iter.hasNext()) {
+            buffer.append(iter.next());
+            if (iter.hasNext()) {
+                buffer.append(delimiter);
+            }
+        }
+        return buffer.toString();
+    }
+}
\ No newline at end of file
diff --git a/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterConstants.java b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterConstants.java
new file mode 100644
index 0000000..cf4667a
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterConstants.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import android.os.Environment;
+
+/**
+ * A collection of constants required for installation/removal of an interpreter.
+ *
+ * @author Damon Kohler (damonkohler@gmail.com)
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public interface InterpreterConstants {
+
+  public static final String SDCARD_ROOT =
+      Environment.getExternalStorageDirectory().getAbsolutePath() + "/";
+
+  public static final String SDCARD_SL4A_ROOT = SDCARD_ROOT + "sl4a/";
+
+  public static final String SCRIPTS_ROOT = SDCARD_SL4A_ROOT + "scripts/";
+
+  public static final String SDCARD_SL4A_DOC = SDCARD_SL4A_ROOT + "doc/";
+
+  public static final String SL4A_DALVIK_CACHE_ROOT = "/dalvik-cache/";
+
+  public static final String INTERPRETER_EXTRAS_ROOT = "/extras/";
+
+  // Interpreters discovery mechanism.
+  public static final String ACTION_DISCOVER_INTERPRETERS =
+      "com.googlecode.android_scripting.DISCOVER_INTERPRETERS";
+
+  // Interpreters broadcasts.
+  public static final String ACTION_INTERPRETER_ADDED =
+      "com.googlecode.android_scripting.INTERPRETER_ADDED";
+  public static final String ACTION_INTERPRETER_REMOVED =
+      "com.googlecode.android_scripting.INTERPRETER_REMOVED";
+
+  // Interpreter content provider.
+  public static final String PROVIDER_PROPERTIES = "com.googlecode.android_scripting.base";
+  public static final String PROVIDER_ENVIRONMENT_VARIABLES =
+      "com.googlecode.android_scripting.env";
+  public static final String PROVIDER_ARGUMENTS = "com.googlecode.android_scripting.args";
+
+  public static final String INSTALLED_PREFERENCE_KEY = "SL4A.interpreter.installed";
+
+  public static final String MIME = "script/";
+}
diff --git a/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterDescriptor.java b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterDescriptor.java
new file mode 100644
index 0000000..519798c
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterDescriptor.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import android.content.Context;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Provides interpreter-specific info for execution/installation/removal purposes.
+ *
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public interface InterpreterDescriptor {
+
+  /**
+   * Returns unique name of the interpreter.
+   */
+  public String getName();
+
+  /**
+   * Returns display name of the interpreter.
+   */
+  public String getNiceName();
+
+  /**
+   * Returns supported script-file extension.
+   */
+  public String getExtension();
+
+  /**
+   * Returns interpreter version number.
+   */
+  public int getVersion();
+
+  /**
+   * Returns the binary as a File object. Context is the InterpreterProvider's {@link Context} and
+   * is provided to find the interpreter installation directory.
+   */
+  public File getBinary(Context context);
+
+  /**
+   * Returns execution parameters in case when script name is not provided (when interpreter is
+   * started in a shell mode);
+   */
+  public String getInteractiveCommand(Context context);
+
+  /**
+   * Returns command line arguments to execute a with a given script (format string with one
+   * argument).
+   */
+  public String getScriptCommand(Context context);
+
+  /**
+   * Returns an array of command line arguments required to execute the interpreter (it's essential
+   * that the order in the array is consistent with order of arguments in the command line).
+   */
+  public List<String> getArguments(Context context);
+
+  /**
+   * Should return a map of environment variables names and their values (or null if interpreter
+   * does not require any environment variables).
+   */
+  public Map<String, String> getEnvironmentVariables(Context context);
+
+  /**
+   * Returns true if interpreter has an archive.
+   */
+  public boolean hasInterpreterArchive();
+
+  /**
+   * Returns true if interpreter has an extras archive.
+   */
+  public boolean hasExtrasArchive();
+
+  /**
+   * Returns true if interpreter comes with a scripts archive.
+   */
+  public boolean hasScriptsArchive();
+
+  /**
+   * Returns file name of the interpreter archive.
+   */
+  public String getInterpreterArchiveName();
+
+  /**
+   * Returns file name of the extras archive.
+   */
+  public String getExtrasArchiveName();
+
+  /**
+   * Returns file name of the scripts archive.
+   */
+  public String getScriptsArchiveName();
+
+  /**
+   * Returns URL location of the interpreter archive.
+   */
+  public String getInterpreterArchiveUrl();
+
+  /**
+   * Returns URL location of the scripts archive.
+   */
+  public String getScriptsArchiveUrl();
+
+  /**
+   * Returns URL location of the extras archive.
+   */
+  public String getExtrasArchiveUrl();
+
+  /**
+   * Returns true if interpreter can be executed in interactive mode.
+   */
+  public boolean hasInteractiveMode();
+}
diff --git a/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterPropertyNames.java b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterPropertyNames.java
new file mode 100644
index 0000000..b8995a7
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterPropertyNames.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+/**
+ * A collection of {@link String} keys for querying an InterpreterProvider.
+ *
+ * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
+ */
+public interface InterpreterPropertyNames {
+
+  /**
+   * Unique name of the interpreter.
+   */
+  public static final String NAME = "name";
+
+  /**
+   * Display name of the interpreter.
+   */
+  public static final String NICE_NAME = "niceName";
+
+  /**
+   * Supported script file extension.
+   */
+  public static final String EXTENSION = "extension";
+
+  /**
+   * Absolute path of the interpreter executable.
+   */
+  public static final String BINARY = "binary";
+
+  /**
+   * Final argument to interpreter binary when running the interpreter interactively.
+   */
+  public static final String INTERACTIVE_COMMAND = "interactiveCommand";
+
+  /**
+   * Final argument to interpreter binary when running a script.
+   */
+  public static final String SCRIPT_COMMAND = "scriptCommand";
+
+  /**
+   * Interpreter interactive mode flag.
+   */
+  public static final String HAS_INTERACTIVE_MODE = "hasInteractiveMode";
+
+}
diff --git a/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterUtils.java b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterUtils.java
new file mode 100644
index 0000000..df81261
--- /dev/null
+++ b/Utils/src/com/googlecode/android_scripting/interpreter/InterpreterUtils.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.googlecode.android_scripting.interpreter;
+
+import android.content.Context;
+
+import java.io.File;
+
+public class InterpreterUtils {
+
+  private InterpreterUtils() {
+    // Utility class
+  }
+
+  public static File getInterpreterRoot(Context context) {
+    return context.getFilesDir();
+  }
+
+  public static File getInterpreterRoot(Context context, String interpreterName) {
+    return new File(getInterpreterRoot(context), interpreterName);
+  }
+}
diff --git a/Utils/src/com/trilead/ssh2/StreamGobbler.java b/Utils/src/com/trilead/ssh2/StreamGobbler.java
new file mode 100644
index 0000000..2d67337
--- /dev/null
+++ b/Utils/src/com/trilead/ssh2/StreamGobbler.java
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2016 Google Inc.
+ *
+ * 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 com.trilead.ssh2;
+
+import com.googlecode.android_scripting.Log;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * A <code>StreamGobbler</code> is an InputStream that uses an internal worker thread to constantly
+ * consume input from another InputStream. It uses a buffer to store the consumed data. The buffer
+ * size is automatically adjusted, if needed.
+ * <p>
+ * This class is sometimes very convenient - if you wrap a session's STDOUT and STDERR InputStreams
+ * with instances of this class, then you don't have to bother about the shared window of STDOUT and
+ * STDERR in the low level SSH-2 protocol, since all arriving data will be immediatelly consumed by
+ * the worker threads. Also, as a side effect, the streams will be buffered (e.g., single byte
+ * read() operations are faster).
+ * <p>
+ * Other SSH for Java libraries include this functionality by default in their STDOUT and STDERR
+ * InputStream implementations, however, please be aware that this approach has also a downside:
+ * <p>
+ * If you do not call the StreamGobbler's <code>read()</code> method often enough and the peer is
+ * constantly sending huge amounts of data, then you will sooner or later encounter a low memory
+ * situation due to the aggregated data (well, it also depends on the Java heap size). Joe Average
+ * will like this class anyway - a paranoid programmer would never use such an approach.
+ * <p>
+ * The term "StreamGobbler" was taken from an article called "When Runtime.exec() won't", see
+ * http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html.
+ *
+ * @author Christian Plattner, plattner@trilead.com
+ * @version $Id: StreamGobbler.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
+ */
+
+public class StreamGobbler extends InputStream {
+  class GobblerThread extends Thread {
+    @Override
+    public void run() {
+
+      while (true) {
+        try {
+          byte[] saveBuffer = null;
+
+          int avail = is.read(buffer, write_pos, buffer.length - write_pos);
+
+          synchronized (synchronizer) {
+            if (avail <= 0) {
+              isEOF = true;
+              synchronizer.notifyAll();
+              break;
+            }
+            write_pos += avail;
+
+            int space_available = buffer.length - write_pos;
+
+            if (space_available == 0) {
+              if (read_pos > 0) {
+                saveBuffer = new byte[read_pos];
+                System.arraycopy(buffer, 0, saveBuffer, 0, read_pos);
+                System.arraycopy(buffer, read_pos, buffer, 0, buffer.length - read_pos);
+                write_pos -= read_pos;
+                read_pos = 0;
+              } else {
+                write_pos = 0;
+                saveBuffer = buffer;
+              }
+            }
+
+            synchronizer.notifyAll();
+          }
+
+          writeToFile(saveBuffer);
+
+        } catch (IOException e) {
+          synchronized (synchronizer) {
+            exception = e;
+            synchronizer.notifyAll();
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  private InputStream is;
+  private GobblerThread t;
+
+  private Object synchronizer = new Object();
+
+  private boolean isEOF = false;
+  private boolean isClosed = false;
+  private IOException exception = null;
+
+  private byte[] buffer;
+  private int read_pos = 0;
+  private int write_pos = 0;
+  private final FileOutputStream mLogStream;
+  private final int mBufferSize;
+
+  public StreamGobbler(InputStream is, File log, int buffer_size) {
+    this.is = is;
+    mBufferSize = buffer_size;
+    FileOutputStream out = null;
+    try {
+      out = new FileOutputStream(log, false);
+    } catch (IOException e) {
+      Log.e(e);
+    }
+    mLogStream = out;
+    buffer = new byte[mBufferSize];
+    t = new GobblerThread();
+    t.setDaemon(true);
+    t.start();
+  }
+
+  public void writeToFile(byte[] buffer) {
+    if (mLogStream != null && buffer != null) {
+      try {
+        mLogStream.write(buffer);
+      } catch (IOException e) {
+        Log.e(e);
+      }
+    }
+  }
+
+  @Override
+  public int read() throws IOException {
+    synchronized (synchronizer) {
+      if (isClosed) {
+        throw new IOException("This StreamGobbler is closed.");
+      }
+
+      while (read_pos == write_pos) {
+        if (exception != null) {
+          throw exception;
+        }
+
+        if (isEOF) {
+          return -1;
+        }
+
+        try {
+          synchronizer.wait();
+        } catch (InterruptedException e) {
+        }
+      }
+
+      int b = buffer[read_pos++] & 0xff;
+
+      return b;
+    }
+  }
+
+  @Override
+  public int available() throws IOException {
+    synchronized (synchronizer) {
+      if (isClosed) {
+        throw new IOException("This StreamGobbler is closed.");
+      }
+
+      return write_pos - read_pos;
+    }
+  }
+
+  @Override
+  public int read(byte[] b) throws IOException {
+    return read(b, 0, b.length);
+  }
+
+  @Override
+  public void close() throws IOException {
+    synchronized (synchronizer) {
+      if (isClosed) {
+        return;
+      }
+      isClosed = true;
+      isEOF = true;
+      synchronizer.notifyAll();
+      is.close();
+    }
+  }
+
+  @Override
+  public int read(byte[] b, int off, int len) throws IOException {
+    if (b == null) {
+      throw new NullPointerException();
+    }
+
+    if ((off < 0) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0) || (off > b.length)) {
+      throw new IndexOutOfBoundsException();
+    }
+
+    if (len == 0) {
+      return 0;
+    }
+
+    synchronized (synchronizer) {
+      if (isClosed) {
+        throw new IOException("This StreamGobbler is closed.");
+      }
+
+      while (read_pos == write_pos) {
+        if (exception != null) {
+          throw exception;
+        }
+
+        if (isEOF) {
+          return -1;
+        }
+
+        try {
+          synchronizer.wait();
+        } catch (InterruptedException e) {
+        }
+      }
+
+      int avail = write_pos - read_pos;
+
+      avail = (avail > len) ? len : avail;
+
+      System.arraycopy(buffer, read_pos, b, off, avail);
+
+      read_pos += avail;
+
+      return avail;
+    }
+  }
+}