Merge lp:~abreu-alexandre/unity-webapps-qml/application-api into lp:unity-webapps-qml

[Alexandre Abreu]

Add application api

Add application api

[Alberto Mardegan (mardy)]

I tested it and it's mostly working. A few comments:

getPlatformInfos: I think it's better to call it "getPlatformInfo" without the final "s". Anyway, this just returns the name of the QPA plugin, so I'd rather rename the method to "getPlatformName" or keep the current name and make it return a dictionary, currently having only one field "name" which contains the platform name. But I'd take the second approach only if you really plan to add more info there in the future.

The example expects the onActivated() and onDeactivated() signal to carry a parameter, but they don't.

All the methods are asynchronous and take a callback; even the applicationName() function is asynchronous, even if the result is immediately available. I'm not familiar with HTML5 development so this might be perfectly fine, I just point this out because coming from the C++ world this sounds rather strange (and a bit inconvenient).

Naming: it's better to use the same convention for all the getters: either start their name always with a "get", or never. Most of the methods you added start with "get", but "applicationName" doesn't.

getInputMethod(): it's not very clear what this function does; maybe rename it to "getInputMethodName"?

nameFromScreenOrientation(): you are only use two possible values, "Landscape" and "Portrait", while Qt supports 4. I guess that most apps don't care about distinguishing between the extra modes, but maybe some do (to be sure that the mic is on a specific side, for instance)?

[Alexandre Abreu (abreu-alexandre)]

> I tested it and it's mostly working. A few comments:
>
> getPlatformInfos: I think it's better to call it "getPlatformInfo" without the
> final "s". Anyway, this just returns the name of the QPA plugin, so I'd rather
> rename the method to "getPlatformName" or keep the current name and make it
> return a dictionary, currently having only one field "name" which contains the
> platform name. But I'd take the second approach only if you really plan to add
> more info there in the future.

done,

> The example expects the onActivated() and onDeactivated() signal to carry a
> parameter, but they don't.

done,

> All the methods are asynchronous and take a callback; even the
> applicationName() function is asynchronous, even if the result is immediately
> available. I'm not familiar with HTML5 development so this might be perfectly
> fine, I just point this out because coming from the C++ world this sounds
> rather strange (and a bit inconvenient).

right, agree, took another approach,

> Naming: it's better to use the same convention for all the getters: either
> start their name always with a "get", or never. Most of the methods you added
> start with "get", but "applicationName" doesn't.

done,

> getInputMethod(): it's not very clear what this function does; maybe rename it
> to "getInputMethodName"?

done,

> nameFromScreenOrientation(): you are only use two possible values, "Landscape"
> and "Portrait", while Qt supports 4. I guess that most apps don't care about
> distinguishing between the extra modes, but maybe some do (to be sure that the
> mic is on a specific side, for instance)?

right, agree, done

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:99
http://jenkins.qa.ubuntu.com/job/unity-webapps-qml-ci/98/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-webapps-qml-trusty-amd64-ci/46/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-webapps-qml-trusty-armhf-ci/46/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-webapps-qml-ci/98/rebuild

review: Needs Fixing (continuous-integration)

[lp:~abreu-alexandre/unity-webapps-qml/application-api]

102. By Alexandre Abreu on 2014-03-26

merge trunk

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:102
http://jenkins.qa.ubuntu.com/job/unity-webapps-qml-ci/100/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-webapps-qml-trusty-amd64-ci/48
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-webapps-qml-trusty-armhf-ci/48

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-webapps-qml-ci/100/rebuild

review: Approve (continuous-integration)

[Alberto Mardegan (mardy)]

I think there's a problem with how the getters are implemented. Let's take getScreenOrientation() for example: when the client calls this method, it will retrieve the application name which was setup, which is correct. If the application registers a callback with onScreenOrientationChanged(), then this._screenOrientation will always get updated propertly, so getScreenOrientation() will always return the proper value; however, if the application doesn't call onScreenOrientationChanged(), this._screenOrientation will never be updated and getScreenOrientation() will always return the old value.

I'm not sure how expensive the switch betwenn client and backend is, so depending on that:

1) If the switch is not very expensive: don't cache any values in the client, always request the properties directly from the backend.

2) If the switch is very expensive, do as you are doing, but register an internal callback to the cached properties in the Application constructor. Something like:

  var self = this;
  this._name = content.name;
  this._proxy.call('onApplicationNameChanged', [function(name) {self._name = name; }]);

(In the latter case we might even want to avoid passing through the backend when the client calls onApplicationNameChanged(): we could make it store the function callback into an array (this._applicationNameListeners) and in the callback registered in the Application constructor we could then invoke all the callbacks in this._applicationNameListeners, after having updated "self._name = name")

Can you also make the getInputMethodName return the value immediately?

Other than that, it all looks good to me!

review: Needs Fixing

[Alexandre Abreu (abreu-alexandre)]

> I think there's a problem with how the getters are implemented. Let's take
> getScreenOrientation() for example: when the client calls this method, it will
> retrieve the application name which was setup, which is correct. If the
> application registers a callback with onScreenOrientationChanged(), then
> this._screenOrientation will always get updated propertly, so
> getScreenOrientation() will always return the proper value; however, if the
> application doesn't call onScreenOrientationChanged(), this._screenOrientation
> will never be updated and getScreenOrientation() will always return the old
> value.
>
> I'm not sure how expensive the switch betwenn client and backend is, so
> depending on that:
>
> 1) If the switch is not very expensive: don't cache any values in the client,
> always request the properties directly from the backend.
>
> 2) If the switch is very expensive, do as you are doing, but register an
> internal callback to the cached properties in the Application constructor.
> Something like:
>
> var self = this;
> this._name = content.name;
> this._proxy.call('onApplicationNameChanged', [function(name) {self._name =
> name; }]);
>
> (In the latter case we might even want to avoid passing through the backend
> when the client calls onApplicationNameChanged(): we could make it store the
> function callback into an array (this._applicationNameListeners) and in the
> callback registered in the Application constructor we could then invoke all
> the callbacks in this._applicationNameListeners, after having updated
> "self._name = name")
>
>
> Can you also make the getInputMethodName return the value immediately?

all done

=== modified file 'examples/api-bindings/alarm/www/index.html'
--- examples/api-bindings/alarm/www/index.html	2014-01-22 20:38:52 +0000
+++ examples/api-bindings/alarm/www/index.html	2014-03-26 15:53:02 +0000
@@ -1,5 +1,9 @@
+<!DOCTYPE html>
 <html>
 
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
   <head>
     <title>Content Hub example</title>
     <script src="./js/app.js"></script>
 
=== modified file 'examples/api-bindings/content-hub-exporter/www/index.html'
--- examples/api-bindings/content-hub-exporter/www/index.html	2014-01-31 01:44:10 +0000
+++ examples/api-bindings/content-hub-exporter/www/index.html	2014-03-26 15:53:02 +0000
@@ -1,5 +1,9 @@
+<!DOCTYPE html>
 <html>
 
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
   <head>
     <title>Content Hub Exporter example</title>
     <script src="./js/app.js"></script>
 
=== modified file 'examples/api-bindings/content-hub/www/index.html'
--- examples/api-bindings/content-hub/www/index.html	2014-02-08 14:48:32 +0000
+++ examples/api-bindings/content-hub/www/index.html	2014-03-26 15:53:02 +0000
@@ -1,5 +1,9 @@
+<!DOCTYPE html>
 <html>
 
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
   <head>
     <title>Content Hub example</title>
     <script src="./js/app.js"></script>
 
=== modified file 'examples/api-bindings/online-accounts/www/index.html'
--- examples/api-bindings/online-accounts/www/index.html	2014-02-26 13:21:37 +0000
+++ examples/api-bindings/online-accounts/www/index.html	2014-03-26 15:53:02 +0000
@@ -1,5 +1,9 @@
+<!DOCTYPE html>
 <html>
 
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
   <head>
     <title>Content Hub example</title>
     <script src="./js/app.js"></script>
 
=== added directory 'examples/api-bindings/runtime-api'
=== added file 'examples/api-bindings/runtime-api/main.qml.in'
--- examples/api-bindings/runtime-api/main.qml.in	1970-01-01 00:00:00 +0000
+++ examples/api-bindings/runtime-api/main.qml.in	2014-03-26 15:53:02 +0000
@@ -0,0 +1,32 @@
+import QtQuick 2.0
+import QtWebKit 3.0 
+import QtWebKit.experimental 1.0
+import Ubuntu.Components 0.1
+import Ubuntu.UnityWebApps 0.1
+
+MainView {
+  id: root
+  focus: true
+  applicationName: \"runtime-api\"
+
+  width: units.gu(100)
+  height: units.gu(100)
+
+  WebView {
+    id: webview
+    anchors.fill: parent
+    url: \"file://$$OUT_PWD/runtime-api/www/index.html\"
+
+    experimental.preferences.navigatorQtObjectEnabled: true
+    experimental.preferences.developerExtrasEnabled: true
+
+    function getUnityWebappsProxies() {
+        return UnityWebAppsUtils.makeProxiesForQtWebViewBindee(webview);
+    }
+
+    UnityWebApps {
+        id: webapps
+        bindee: webview
+    }
+  }
+}
 
=== added directory 'examples/api-bindings/runtime-api/www'
=== added file 'examples/api-bindings/runtime-api/www/index.html'
--- examples/api-bindings/runtime-api/www/index.html	1970-01-01 00:00:00 +0000
+++ examples/api-bindings/runtime-api/www/index.html	2014-03-26 15:53:02 +0000
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+  <head>
+    <title>Runtime Api example</title>
+    <script src="./js/app.js"></script>
+  </head>
+  
+  <body>
+    
+    <div>
+      Results:
+      <div id="results">
+      </div>
+    </div>
+
+  </body>
+  
+</html>
 
=== added directory 'examples/api-bindings/runtime-api/www/js'
=== added file 'examples/api-bindings/runtime-api/www/js/app.js'
--- examples/api-bindings/runtime-api/www/js/app.js	1970-01-01 00:00:00 +0000
+++ examples/api-bindings/runtime-api/www/js/app.js	2014-03-26 15:53:02 +0000
@@ -0,0 +1,57 @@
+window.onload = function() {
+    function setResult(message) {
+        var results = document.getElementById('results');
+        results.innerHTML += message + '<br>';
+    }
+
+    var last = 0;
+    if (localStorage.getItem("lastkilled") !== null)
+        last = localStorage.getItem("lastkilled");
+
+    setResult('last killed: ' + last);
+
+    var api = external.getUnityObject('1.0');
+
+    api.RuntimeApi.getApplication(function(application) {
+        setResult('application name: ' + application.getApplicationName());
+        setResult('application info: ' + JSON.stringify(application.getPlatformInfo()));
+
+        application.getInputMethodName(function(name) {
+            if (name.length == 0)
+                setResult('input method: no OSK available');
+            else
+                setResult('input method: ' + name);
+        });
+
+        setResult('screen orientation: ' + application.getScreenOrientation());
+
+        application.onScreenOrientationChanged(function(name) {
+            setResult('Event: orientation changed - ' + name);
+        });
+
+        application.onAboutToQuit(function(killed) {
+            localStorage.setItem("lastkilled", last + 1);
+
+            console.log('killed: ' + killed)
+
+            setResult('onAboutToQuit: ' + killed);
+        });
+
+        application.onDeactivated(function() {
+            setResult('Event: application deactivated');
+        });
+
+        application.onActivated(function() {
+            setResult('Event: application activated');
+        });
+
+        application.onInputMethodVisibilityChanged(function(visibility) {
+            setResult('Event: onInputMethodVisibilityChanged - ' + visibility);
+        });
+
+        application.setupUriHandler(function(uris) {
+            setResult('Event: received URI to open w/ UriHandler - ' + JSON.stringify(uris));
+        });
+
+    });
+};
 
=== modified file 'src/Ubuntu/UnityWebApps/UnityWebApps.pro'
--- src/Ubuntu/UnityWebApps/UnityWebApps.pro	2014-01-17 15:51:27 +0000
+++ src/Ubuntu/UnityWebApps/UnityWebApps.pro	2014-03-26 15:53:02 +0000
@@ -21,10 +21,13 @@
 #
 # deployment directives
 #
-JS_FILES = $$system(ls *.js) \
-    $${UNITY_API_JS_FILE} \
+PLUGIN_JS_FILES = \
+    $$system(ls *.js) \
+    $${UNITY_API_JS_FILE}
+
+CLIENT_JS_FILES = \
     $$system(ls ./common/*/*.js) \
-    $$system(ls ./bindings/*/*/*.js)
+    $$system(ls ./bindings/*/client/*.js)
 
 QML_FILES = $$system(ls *.qml)
 
@@ -32,7 +35,9 @@
 QMAKE_SUBSTITUTES += qmldir.in
 
 OTHER_FILES += $$QML_FILES \
-    $$JS_FILES \
+    $$PLUGIN_JS_FILES \
+    $$CLIENT_JS_FILES \
+    $$system(ls ./bindings/*/backend/*.js) \
     qmldir.in \
     unity-webapps-api.js.in \
     $${UNITY_API_JS_FILE}
@@ -44,9 +49,19 @@
 
 qmldir_file.path = $$installPath
 qmldir_file.files = $$QMLDIR_FILE
+
 qml_files.path = $$installPath
 qml_files.files = $$QML_FILES
+
 js_files.path = $$installPath
-js_files.files = $$JS_FILES
-
-INSTALLS += qmldir_file qml_files js_files
+js_files.files = $$PLUGIN_JS_FILES
+
+runtime_api_binding_backend_js_files.path = $$installPath/bindings/runtime-api/backend/
+runtime_api_binding_backend_js_files.files = ./bindings/runtime-api/backend/runtime-api.js
+
+INSTALLS += qmldir_file \
+    qml_files \
+    js_files \
+    runtime_api_binding_backend_js_files \
+
+
 
=== modified file 'src/Ubuntu/UnityWebApps/UnityWebApps.qml'
--- src/Ubuntu/UnityWebApps/UnityWebApps.qml	2014-03-17 17:25:53 +0000
+++ src/Ubuntu/UnityWebApps/UnityWebApps.qml	2014-03-26 15:53:02 +0000
@@ -21,6 +21,7 @@
 import "UnityWebApps.js" as UnityWebAppsJs
 import "UnityWebAppsUtils.js" as UnityWebAppsJsUtils
 import "UnityWebAppsBackendComponents.js" as UnityBackends
+import "./bindings/runtime-api/backend/runtime-api.js" as RuntimeApiBackend
 
 
 /*!
@@ -649,6 +650,8 @@
                 return UnityBackends.createContentHubApi(UnityBackends.backendDelegate)
             }),
 
+            RuntimeApi: RuntimeApiBackend.createRuntimeApi(UnityBackends.backendDelegate),
+
             Launcher: {
                 setCount: function (count) {
                     if (!initialized)
 
=== added directory 'src/Ubuntu/UnityWebApps/bindings/runtime-api'
=== added directory 'src/Ubuntu/UnityWebApps/bindings/runtime-api/backend'
=== added file 'src/Ubuntu/UnityWebApps/bindings/runtime-api/backend/runtime-api.js'
--- src/Ubuntu/UnityWebApps/bindings/runtime-api/backend/runtime-api.js	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UnityWebApps/bindings/runtime-api/backend/runtime-api.js	2014-03-26 15:53:02 +0000
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of unity-webapps-qml.
+ *
+ * unity-webapps-qml 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; version 3.
+ *
+ * unity-webapps-qml 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, see <http://www.gnu.org/licenses/>.
+ */
+
+.import Ubuntu.UnityWebApps 0.1 as UnityWebAppsBridge
+.import Ubuntu.Components 0.1 as ComponentsBridge
+
+
+/**
+ *
+ * Runtime API backend binding
+ *
+ */
+function createRuntimeApi(backendDelegate) {
+    var PLUGIN_URI = 'Ubuntu.UnityWebApps';
+    var VERSION = 0.1;
+
+    var applicationApiInstance = UnityWebAppsBridge.ApplicationApi;
+
+    function Application() {
+        // no need to have a specific id since this class is mostly a passtrough one
+        this._id = 0;
+    };
+    Application.prototype = {
+
+        // object methods
+        serialize: function() {
+            var self = this;
+            return {
+                type: 'object-proxy',
+                apiid: 'RuntimeApi',
+                objecttype: 'Application',
+                objectid: this._id,
+
+                content: {
+                    name: applicationApiInstance.applicationName,
+                    platform: applicationApiInstance.applicationPlatform,
+                    writableLocation: applicationApiInstance.applicationDataPath,
+                    screenOrientation: applicationApiInstance.screenOrientation,
+                }
+            }
+        },
+
+        getApplicationName: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                callback(applicationApiInstance.applicationName);
+        },
+        onApplicationNameChanged: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                    applicationApiInstance.applicationNameChanged.connect(function() {
+                        callback(applicationApiInstance.applicationName);
+                    });
+        },
+
+        getApplicationWritableLocation: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                callback(applicationApiInstance.applicationDataPath);
+        },
+
+        getPlatformInfo: function(callback) {
+            if (callback && typeof(callback) === 'function') {
+                var info = {};
+                info.name = applicationApiInstance.applicationPlatform;
+                callback(info);
+            }
+        },
+
+        setInputMethodVisible: function(visible, callback) {
+            applicationApiInstance.setInputMethodVisible(visible);
+            if (callback && typeof(callback) === 'function')
+                callback();
+        },
+        getInputMethodName: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                callback(applicationApiInstance.getInputMethodName());
+        },
+        onInputMethodVisibilityChanged: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                    Qt.inputMethod.onVisibleChanged.connect(function() {
+                        callback(Qt.inputMethod.visible)
+                    });
+        },
+
+        onAboutToQuit: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                applicationApiInstance.applicationAboutToQuit.connect(function(killed) {
+                    callback(killed);
+                });
+        },
+
+        setupUriHandler: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                var urihandler = ComponentsBridge.UriHandler;
+                urihandler.opened.connect(function(uris, data) {
+                    var translatedUris = []
+                    for (var idx in uris) {
+                        translatedUris.push(uris[idx])
+                    }
+                    callback(translatedUris);
+                });
+        },
+
+        onDeactivated: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                applicationApiInstance.applicationDeactivated.connect(callback);
+        },
+
+        onActivated: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                applicationApiInstance.applicationActivated.connect(callback);
+        },
+
+        getScreenOrientation: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                callback(applicationApiInstance.screenOrientation);
+        },
+        onScreenOrientationChanged: function(callback) {
+            if (callback && typeof(callback) === 'function')
+                applicationApiInstance.applicationScreenOrientationChanged.connect(callback);
+        },
+    };
+
+    function _constructorFromName(className) {
+        var constructorPerName = {
+            "Application": Application,
+        };
+        return className in constructorPerName
+                ? constructorPerName[className]
+                : null;
+    }
+
+    return {
+        getApplication: function(callback) {
+            var application = new Application();
+            callback(application.serialize());
+        },
+
+        // Internal
+
+        dispatchToObject: function(infos) {
+            var args = infos.args;
+            var callback = infos.callback;
+            var method_name = infos.method_name;
+            var objectid = infos.objectid;
+            var class_name = infos.class_name;
+
+            if (callback)
+                args.push(callback);
+
+            var Constructor = _constructorFromName(class_name);
+
+            var instance = new Constructor(objectid);
+
+            instance[method_name].apply(instance, args);
+        }
+    };
+}
 
=== added directory 'src/Ubuntu/UnityWebApps/bindings/runtime-api/client'
=== added file 'src/Ubuntu/UnityWebApps/bindings/runtime-api/client/runtime-api.js'
--- src/Ubuntu/UnityWebApps/bindings/runtime-api/client/runtime-api.js	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UnityWebApps/bindings/runtime-api/client/runtime-api.js	2014-03-26 15:53:02 +0000
@@ -0,0 +1,256 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of unity-webapps-qml.
+ *
+ * unity-webapps-qml 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; version 3.
+ *
+ * unity-webapps-qml 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, see <http://www.gnu.org/licenses/>.
+ */
+
+
+/**
+ * RuntimeApi gives access to the application runtime information and management.
+
+ * @module RuntimeApi
+ */
+function createRuntimeApi(backendBridge) {
+    var PLUGIN_URI = 'RuntimeApi';
+
+    function Application(id, content) {
+        this._proxy = backendBridge.createRemoteObject(
+            PLUGIN_URI, 'Application', id);
+
+        this._name = content.name;
+        this._platform = content.platform;
+        this._writableLocation = content.writableLocation;
+        this._screenOrientation = content.screenOrientation;
+    };
+    Application.prototype = {
+
+        /**
+         * Retrieves the application name.
+         *
+         * @method getApplicationName
+         * @return {String} application name
+         */
+        getApplicationName: function() {
+            return this._name;
+        },
+
+        /**
+         * Sets up a callback that is to be called when the application's name changed.
+         *
+         * @method onApplicationNameChanged
+         * @param callback {Function(String)} Function to be called when the application's name has changed.
+         */
+        onApplicationNameChanged: function(callback) {
+            var self = this;
+            this._proxy.call('onApplicationNameChanged'
+                               , [function(name) {self._name = name; callback(name); }]);
+        },
+
+        /**
+         * Retrieves the fileystem location where the application is allowed to write its data in.
+         *
+         * @method getApplicationWritableLocation
+         * @return {String} application writable location path
+         */
+        getApplicationWritableLocation: function() {
+            return this._writableLocation;
+        },
+
+        /**
+         * Retrieves current platform information.
+         *
+         * @method getPlatformInfos
+         * @return {Object} platform information as a dictionary with the following keys:
+         *  - name: the platform name
+         */
+        getPlatformInfo: function() {
+            return this._platform;
+        },
+
+        /**
+         * Sets up a callback that is to be called when the application is about to quit.
+         *
+         * @method onAboutToQuit
+         * @param callback {Function()} Function to be called when the application is about to quit.
+         */
+        onAboutToQuit: function(callback) {
+            this._proxy.call('onAboutToQuit'
+                               , [callback]);
+        },
+
+        /**
+         * Sets up a callback that is to be called when the application has been deactivated (background).
+         *
+         * @method onDeactivated
+         * @param callback {Function()} Function to be called when the application has been deactivated.
+         */
+        onDeactivated: function(callback) {
+            this._proxy.call('onDeactivated'
+                               , [callback]);
+        },
+
+        /**
+         * Sets up a callback that is to be called when the application has been activated (from background).
+         *
+         * @method onActivated
+         * @param callback {Function()} Function to be called when the application has been activated.
+         */
+        onActivated: function(callback) {
+            this._proxy.call('onActivated'
+                               , [callback]);
+        },
+
+        /**
+         * Retrieves the current screen orientation.
+         *
+         * @method getScreenOrientation
+         * @return {ScreenOrientation} current screen orientation.
+         */
+        getScreenOrientation: function() {
+            return this._screenOrientation;
+        },
+
+        /**
+         * Sets up a callback that is to be called when the application's screen has changed its orientation.
+         *
+         * @method onScreenOrientationChanged
+         * @param callback {Function(ScreenOrientation)} Function to be called when the application's screen orientation has changed.
+         */
+        onScreenOrientationChanged: function(callback) {
+            var self = this;
+            this._proxy.call('onScreenOrientationChanged'
+                               , [function(orientation) {self._screenOrientation = orientation; callback(orientation); }]);
+        },
+
+        /**
+         * Sets up a URI handler. The application can be sent URIs to open.
+         *
+         * @method setupUriHandler
+         * @param callback {Function([String])} Function to be called with the current list of uris to open
+         */
+        setupUriHandler: function(callback) {
+            this._proxy.call('setupUriHandler'
+                               , [callback]);
+        },
+
+        /**
+         * Retrieves the current input method's name. The name varies depending on the platform
+         * e.g. maliit can be part of the name for a maliit based Virtual Keyboard (possibly mangled
+         * with e.g. 'phablet'), when a keyboard is there the name can be empty, ...
+         *
+         * @method getInputMethodName
+         * @param callback {Function(String)} Function to be called with the current input method name
+         */
+        getInputMethodName: function(callback) {
+            this._proxy.call('getInputMethodName'
+                               , []
+                               , callback);
+        },
+
+        /**
+         * Sets up a callback that is to be called when the On Screen Keyboard visibility has changed.
+         *
+         * @method onInputMethodVisibilityChanged
+         * @param callback {Function(Bool)} Function to be called when the On Screen Keyboard visibility has changed (received the visibility as an arg).
+         */
+        onInputMethodVisibilityChanged: function(callback) {
+            this._proxy.call('onInputMethodVisibilityChanged'
+                               , [callback]);
+        }
+    };
+
+    function _constructorFromName(className) {
+        var constructorPerName = {
+            "Application": Application,
+        };
+        return className in constructorPerName
+                ? constructorPerName[className]
+                : null;
+    };
+
+
+/**
+ * The RuntimeApi object
+
+ * @class RuntimeApi
+ * @constructor
+ * @example
+
+       var api = external.getUnityObject('1.0');
+       api.RuntimeApi.getApplication(function(application) {
+         console.log('Application name: ' + application.getApplicationName());
+       });
+ */
+    return {
+        /**
+           Enumeration of the available types of ScreenOrientation.
+
+             Values:
+
+               Landscape: The application screen is in landscape mode
+
+               InvertedLandscape: The application screen is in inverted landscape mode
+
+               Portrait: The application screen is in portrait mode
+
+               InvertedPortrait: The application screen is in inverted portrait mode
+
+               Unknown: The application screen is in an unknown mode
+
+           @static
+           @property ScreenOrientation {Object}
+
+           @example
+
+               var api = external.getUnityObject('1.0');
+               var orientation = api.RuntimeApi.ScreenOrientation;
+               // use orientation.Landscape or orientation.Portrait
+         */
+        ScreenOrientation: {
+            Landscape: "Landscape",
+
+            InvertedLandscape: "InvertedLandscape",
+
+            Portrait: "Portrait",
+
+            InvertedPortrait: "InvertedPortrait",
+
+            Unknwon: "Unknown",
+        },
+
+        /**
+         * Creates an Application object.
+         *
+         * @method getApplication
+         * @param callback {Function (Application)}
+         */
+        getApplication: function(callback) {
+            backendBridge.call('RuntimeApi.getApplication'
+                               , []
+                               , callback);
+        },
+
+        /**
+         * @private
+         *
+         */
+        createObjectWrapper: function(objectType, objectId, content) {
+            var Constructor = _constructorFromName(objectType);
+            return new Constructor(objectId, content);
+        },
+    };
+};
+
+
 
=== added file 'src/Ubuntu/UnityWebApps/plugin/application-api.cpp'
--- src/Ubuntu/UnityWebApps/plugin/application-api.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UnityWebApps/plugin/application-api.cpp	2014-03-26 15:53:02 +0000
@@ -0,0 +1,287 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of unity-webapps-qml.
+ *
+ * unity-webapps-qml 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; version 3.
+ *
+ * unity-webapps-qml 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "application-api.h"
+
+#include "application-signal-to-qt-bridge.h"
+
+#include <QDebug>
+#include <QGuiApplication>
+#include <QScreen>
+#include <QDir>
+#include <QtCore/QCoreApplication>
+#include <QtCore/QStandardPaths>
+#include <signal.h>
+
+
+namespace
+{
+
+QString
+nameFromScreenOrientation (Qt::ScreenOrientation orientation)
+{
+    switch (orientation)
+    {
+    case Qt::InvertedLandscapeOrientation:
+        return QString("InvertedLandscape");
+
+    case Qt::LandscapeOrientation:
+        return QString("Landscape");
+
+    case Qt::PortraitOrientation:
+        return QString("Portrait");
+
+    case Qt::InvertedPortraitOrientation:
+        return QString("InvertedPortrait");
+
+    case Qt::PrimaryOrientation:
+        return QString("Primary");
+
+    default:
+        break;
+    }
+
+    return QString("Unknown");
+}
+
+}
+
+class ApplicationApiEventListener : public QObject
+{
+    Q_OBJECT
+
+public:
+    ApplicationApiEventListener(QObject * parent)
+        : QObject(parent)
+    {
+        if (QGuiApplication::instance())
+            QGuiApplication::instance()->installEventFilter(this);
+    }
+    ~ApplicationApiEventListener()
+    {
+        if (QGuiApplication::instance())
+            QGuiApplication::instance()->removeEventFilter(this);
+    }
+
+    bool eventFilter(QObject *obj,
+                     QEvent *event)
+    {
+        switch (event->type())
+        {
+        case QEvent::ApplicationActivate:
+            Q_EMIT activated();
+            break;
+        case QEvent::ApplicationDeactivate:
+            Q_EMIT deactivated();
+            break;
+        default:
+            break;
+        }
+        return QObject::eventFilter(obj, event);
+    }
+
+Q_SIGNALS:
+
+    void activated();
+    void deactivated();
+};
+
+
+class ApplicationApiPrivate: public QObject
+{
+    Q_OBJECT
+
+public:
+    ApplicationApiPrivate(QObject * parent)
+        : QObject(parent),
+          _applicationEventListener(new ApplicationApiEventListener(this)),
+          _applicationSignalBridge(new ApplicationSignalToQtBridge(this))
+    {}
+    ~ApplicationApiPrivate()
+    {
+        delete _applicationEventListener;
+        delete _applicationSignalBridge;
+    }
+
+    ApplicationApiEventListener * _applicationEventListener;
+    ApplicationSignalToQtBridge * _applicationSignalBridge;
+};
+
+
+ApplicationApi::ApplicationApi(QObject *parent) :
+    QObject(parent),
+    d_ptr(new ApplicationApiPrivate(this))
+
+{
+    Q_D(ApplicationApi);
+
+    QObject::connect(QCoreApplication::instance(),
+                     &QCoreApplication::aboutToQuit,
+                     this,
+                     &ApplicationApi::aboutToQuit);
+
+    QObject::connect(d->_applicationEventListener,
+                     &ApplicationApiEventListener::activated,
+                     this,
+                     &ApplicationApi::activated);
+
+    QObject::connect(d->_applicationEventListener,
+                     &ApplicationApiEventListener::deactivated,
+                     this,
+                     &ApplicationApi::deactivated);
+
+    QObject::connect(d->_applicationSignalBridge,
+                     &ApplicationSignalToQtBridge::onSignalRaised,
+                     this,
+                     &ApplicationApi::signalReceived);
+
+    // We explictly handle the SIGTERM signal case that is being sent
+    // on Touch to an application being killed by the platform.
+    // Upstart sends this signal when the application is closed from app scope.
+    d->_applicationSignalBridge->addSignalHandlerFor(SIGTERM);
+
+    QScreen * screen = QGuiApplication::primaryScreen();
+    if (screen)
+    {
+        QObject::connect(screen,
+                         &QScreen::orientationChanged,
+                         this,
+                         &ApplicationApi::screenOrientationChanged);
+    }
+}
+
+ApplicationApi::~ApplicationApi()
+{
+    Q_D(ApplicationApi);
+
+    QObject::disconnect(QCoreApplication::instance(),
+                       &QCoreApplication::aboutToQuit,
+                       this,
+                       &ApplicationApi::aboutToQuit);
+
+    QObject::disconnect(d->_applicationEventListener,
+                       &ApplicationApiEventListener::activated,
+                       this,
+                       &ApplicationApi::activated);
+
+    QObject::disconnect(d->_applicationEventListener,
+                       &ApplicationApiEventListener::deactivated,
+                       this,
+                       &ApplicationApi::deactivated);
+
+    QObject::disconnect(d->_applicationSignalBridge,
+                        &ApplicationSignalToQtBridge::onSignalRaised,
+                        this,
+                        &ApplicationApi::signalReceived);
+
+    QScreen * screen = QGuiApplication::primaryScreen();
+    if (screen)
+    {
+        QObject::disconnect(screen,
+                           &QScreen::orientationChanged,
+                           this,
+                           &ApplicationApi::screenOrientationChanged);
+    }
+
+    delete d_ptr;
+}
+
+QString ApplicationApi::getApplicationName() const
+{
+    if ( ! qgetenv("APP_ID").isEmpty())
+        return qgetenv("APP_ID");
+
+    return QCoreApplication::applicationName();
+}
+
+QString ApplicationApi::getApplicationDataPath() const
+{
+    QDir dataLocation(
+        QStandardPaths::writableLocation(
+            QStandardPaths::DataLocation));
+
+    if (!dataLocation.exists()) {
+        QDir::root().mkpath(dataLocation.absolutePath());
+    }
+
+    return dataLocation.absolutePath();
+}
+
+QString ApplicationApi::getApplicationScreenOrientation() const
+{
+    QScreen * screen = QGuiApplication::primaryScreen();
+
+    return nameFromScreenOrientation(screen->primaryOrientation());
+}
+
+QString ApplicationApi::getInputMethodName() const
+{
+    return QString(getenv("QT_IM_MODULE"));
+}
+
+void ApplicationApi::setInputMethodVisible(bool visible)
+{
+    QGuiApplication::inputMethod()->setVisible(visible);
+    if (visible)
+        QGuiApplication::inputMethod()->show();
+    else
+        QGuiApplication::inputMethod()->hide();
+}
+
+QString ApplicationApi::getApplicationPlatform() const
+{
+    return QGuiApplication::platformName();
+}
+
+void ApplicationApi::aboutToQuit()
+{
+    Q_EMIT applicationAboutToQuit(false);
+}
+
+void ApplicationApi::activated()
+{
+    Q_EMIT applicationActivated();
+}
+
+void ApplicationApi::deactivated()
+{
+    Q_EMIT applicationDeactivated();
+}
+
+void ApplicationApi::signalReceived(int type)
+{
+    if (type != SIGTERM  && type != SIGINT)
+        return;
+
+    bool killed = (type == SIGTERM);
+
+    Q_EMIT applicationAboutToQuit(killed);
+
+    QCoreApplication::quit();
+}
+
+void ApplicationApi::screenOrientationChanged(Qt::ScreenOrientation orientation)
+{
+    Q_EMIT applicationScreenOrientationChanged(
+                nameFromScreenOrientation(
+                    orientation));
+}
+
+
+#include "application-api.moc"
+
 
=== added file 'src/Ubuntu/UnityWebApps/plugin/application-api.h'
--- src/Ubuntu/UnityWebApps/plugin/application-api.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UnityWebApps/plugin/application-api.h	2014-03-26 15:53:02 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of unity-webapps-qml.
+ *
+ * unity-webapps-qml 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; version 3.
+ *
+ * unity-webapps-qml 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UNITY_WEBAPPS_APPLICATIONAPI_H
+#define UNITY_WEBAPPS_APPLICATIONAPI_H
+
+#include <QObject>
+
+class ApplicationApiPrivate;
+
+class ApplicationApi : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString applicationName READ getApplicationName NOTIFY applicationNameChanged)
+    Q_PROPERTY(QString screenOrientation READ getApplicationScreenOrientation NOTIFY applicationScreenOrientationChanged)
+    Q_PROPERTY(QString applicationDataPath READ getApplicationDataPath)
+    Q_PROPERTY(QString applicationPlatform READ getApplicationPlatform)
+
+
+public:
+    explicit ApplicationApi(QObject *parent = 0);
+    ~ApplicationApi();
+
+    QString getApplicationName() const;
+
+    QString getApplicationDataPath() const;
+
+    QString getApplicationPlatform() const;
+
+    QString getApplicationScreenOrientation() const;
+
+    Q_INVOKABLE QString getInputMethodName() const;
+    Q_INVOKABLE void setInputMethodVisible(bool);
+
+
+Q_SIGNALS:
+
+    void applicationNameChanged();
+    void applicationAboutToQuit(bool killed);
+    void applicationDeactivated();
+    void applicationActivated();
+    void applicationScreenOrientationChanged(QString);
+
+
+public Q_SLOTS:
+
+    void aboutToQuit();
+    void deactivated();
+    void activated();
+    void screenOrientationChanged(Qt::ScreenOrientation);
+    void signalReceived(int type);
+
+
+private:
+
+    ApplicationApiPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(ApplicationApi)
+};
+
+#endif // UNITY_WEBAPPS_APPLICATIONAPI_H
 
=== added file 'src/Ubuntu/UnityWebApps/plugin/application-signal-to-qt-bridge.cpp'
--- src/Ubuntu/UnityWebApps/plugin/application-signal-to-qt-bridge.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UnityWebApps/plugin/application-signal-to-qt-bridge.cpp	2014-03-26 15:53:02 +0000
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of unity-webapps-qml.
+ *
+ * unity-webapps-qml 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; version 3.
+ *
+ * unity-webapps-qml 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "application-signal-to-qt-bridge.h"
+
+#include <QDebug>
+#include <QSocketNotifier>
+
+#include <sys/socket.h>
+#include <signal.h>
+#include <unistd.h>
+
+/**
+ * @brief The ApplicationSignalToQtBridgePrivate class
+ *
+ * It does the job described here:
+ *
+ * https://qt-project.org/doc/qt-5.0/qtdoc/unix-signals.html
+ *
+ * and bridges Unix signal handlers & qt objects in a proper
+ * way.
+ *
+ */
+
+class ApplicationSignalToQtBridgePrivate: public QObject
+{
+    Q_OBJECT
+
+public:
+    ApplicationSignalToQtBridgePrivate(QObject * parent)
+        : QObject(parent),
+          _signalSocketNotifier(NULL)
+    {}
+    ~ApplicationSignalToQtBridgePrivate()
+    {
+        delete _signalSocketNotifier;
+    }
+
+    QSocketNotifier * _signalSocketNotifier;
+};
+
+
+int ApplicationSignalToQtBridge::signalSocketPair[2];
+
+ApplicationSignalToQtBridge::ApplicationSignalToQtBridge(QObject *parent)
+    : QObject(parent)
+    , d_ptr(new ApplicationSignalToQtBridgePrivate(this))
+{}
+
+ApplicationSignalToQtBridge::~ApplicationSignalToQtBridge()
+{
+    delete d_ptr;
+}
+
+void ApplicationSignalToQtBridge::setupQtSignalListener()
+{
+    Q_D(ApplicationSignalToQtBridge);
+
+    if (0 != ::socketpair(AF_UNIX, SOCK_STREAM, 0, signalSocketPair))
+    {
+       qFatal("Couldn't create HUP socketpair");
+    }
+
+    d->_signalSocketNotifier =
+            new QSocketNotifier (signalSocketPair[1],
+                                QSocketNotifier::Read,
+                                this);
+
+    connect(d->_signalSocketNotifier,
+            SIGNAL(activated(int)),
+            this,
+            SLOT(handleSignal(int)));
+}
+
+bool ApplicationSignalToQtBridge::addSignalHandlerFor(int type)
+{
+    Q_D(ApplicationSignalToQtBridge);
+
+    if ( ! d->_signalSocketNotifier)
+        setupQtSignalListener();
+
+    struct sigaction sa;
+
+    sa.sa_handler = ApplicationSignalToQtBridge::signalHandler;
+    sigemptyset (&sa.sa_mask);
+    sa.sa_flags = 0;
+    sa.sa_flags |= SA_RESTART;
+
+    return sigaction (type, &sa, 0) > 0;
+}
+
+void ApplicationSignalToQtBridge::signalHandler(int type)
+{
+    if (0 != signalSocketPair[0])
+    {
+        size_t size =
+            ::write (signalSocketPair[0],
+                     &type,
+                     sizeof(type));
+        Q_UNUSED(size);
+    }
+}
+
+void ApplicationSignalToQtBridge::handleSignal(int socket)
+{
+    Q_D(ApplicationSignalToQtBridge);
+
+    Q_UNUSED(socket);
+
+    d->_signalSocketNotifier->setEnabled(false);
+
+    int type = 0;
+    size_t size =
+        ::read (signalSocketPair[1], &type, sizeof(type));
+    Q_UNUSED(size);
+
+    Q_EMIT onSignalRaised(type);
+
+    d->_signalSocketNotifier->setEnabled(true);
+}
+
+
+#include "application-signal-to-qt-bridge.moc"
+
 
=== added file 'src/Ubuntu/UnityWebApps/plugin/application-signal-to-qt-bridge.h'
--- src/Ubuntu/UnityWebApps/plugin/application-signal-to-qt-bridge.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UnityWebApps/plugin/application-signal-to-qt-bridge.h	2014-03-26 15:53:02 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of unity-webapps-qml.
+ *
+ * unity-webapps-qml 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; version 3.
+ *
+ * unity-webapps-qml 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef APPLICATIONSIGNALTOQTBRIDGE_H
+#define APPLICATIONSIGNALTOQTBRIDGE_H
+
+#include <QObject>
+
+
+class ApplicationSignalToQtBridgePrivate;
+
+class ApplicationSignalToQtBridge : public QObject
+{
+    Q_OBJECT
+
+public:
+
+    explicit ApplicationSignalToQtBridge (QObject *parent = 0);
+    ~ApplicationSignalToQtBridge ();
+
+    bool addSignalHandlerFor(int type);
+
+
+public Q_SLOTS:
+
+    void handleSignal(int type);
+
+
+Q_SIGNALS:
+
+    void onSignalRaised(int type);
+
+
+private:
+
+    void setupQtSignalListener();
+
+    // Unix signal handlers.
+    static void signalHandler(int type);
+
+    static int signalSocketPair[2];
+
+    ApplicationSignalToQtBridgePrivate *d_ptr;
+    Q_DECLARE_PRIVATE(ApplicationSignalToQtBridge)
+};
+
+#endif // APPLICATIONSIGNALTOQTBRIDGE_H
 
=== modified file 'src/Ubuntu/UnityWebApps/plugin/plugin.pro'
--- src/Ubuntu/UnityWebApps/plugin/plugin.pro	2014-01-17 15:51:27 +0000
+++ src/Ubuntu/UnityWebApps/plugin/plugin.pro	2014-03-26 15:53:02 +0000
@@ -40,7 +40,9 @@
     unity-webapps-desktop-infos.cpp \
     unity-webapps-icon-utils.cpp \
     callback.cpp \
-    abstract-item-model-adaptor.cpp
+    abstract-item-model-adaptor.cpp \
+    application-api.cpp \
+    application-signal-to-qt-bridge.cpp
 
 HEADERS += \
     qml-plugin.h \
@@ -57,7 +59,9 @@
     unity-webapps-desktop-infos.h \
     unity-webapps-icon-utils.h \
     callback.h \
-    abstract-item-model-adaptor.h
+    abstract-item-model-adaptor.h \
+    application-api.h \
+    application-signal-to-qt-bridge.h
 
 DEFINES += \
     API_URI=\\\"$${API_URI}\\\"
 
=== modified file 'src/Ubuntu/UnityWebApps/plugin/qml-plugin.cpp'
--- src/Ubuntu/UnityWebApps/plugin/qml-plugin.cpp	2014-01-17 15:51:27 +0000
+++ src/Ubuntu/UnityWebApps/plugin/qml-plugin.cpp	2014-03-26 15:53:02 +0000
@@ -17,6 +17,10 @@
  */
 
 #include "qml-plugin.h"
+
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlContext>
+
 #include "unity-webapps-api.h"
 #include "unity-webapps-api-notifications.h"
 #include "unity-webapps-api-messaging-menu.h"
@@ -26,11 +30,19 @@
 #include "unity-webapps-app-model.h"
 #include "unity-webapps-app-infos.h"
 
+#include "application-api.h"
 #include "abstract-item-model-adaptor.h"
 #include "callback.h"
 
 #include <qqml.h>
 
+static QObject *createApplicationApi(QQmlEngine *engine, QJSEngine *scriptEngine)
+{
+    Q_UNUSED(engine);
+    Q_UNUSED(scriptEngine);
+
+    return new ApplicationApi();
+}
 
 void WebappsQmlPlugin::registerTypes(const char *uri)
 {
@@ -49,5 +61,8 @@
 
     // TODO bump version
     qmlRegisterType<AbstractItemModelAdaptor> (uri, 0, 1, "AbstractItemModelAdaptor");
+
+    //
+    qmlRegisterSingletonType<ApplicationApi>(uri, 0, 1, "ApplicationApi", createApplicationApi);
 }
 
 
=== modified file 'src/Ubuntu/UnityWebApps/unity-webapps-api.js.in'
--- src/Ubuntu/UnityWebApps/unity-webapps-api.js.in	2014-03-18 17:26:34 +0000
+++ src/Ubuntu/UnityWebApps/unity-webapps-api.js.in	2014-03-26 15:53:02 +0000
@@ -33,6 +33,7 @@
     //@include ./bindings/alarm-api/client/alarm-api.js
     //@include ./bindings/content-hub/client/content-hub.js
     //@include ./bindings/online-accounts/client/online-accounts.js
+    //@include ./bindings/runtime-api/client/runtime-api.js
     //@include ./common/js/unity-backend-messaging-proxy.js
     //@include ./common/js/unity-binding-proxy.js
     //@include ./common/js/unity-binding-bridge.js
@@ -280,6 +281,7 @@
             OnlineAccounts: createOnlineAccountsApi(backend),
             AlarmApi: createAlarmApi(backend),
             ContentHub: createContentHubApi(backend),
+            RuntimeApi: createRuntimeApi(backend),
         };
 
         return api;
 
=== modified file 'tests/unit/test_plugin/tst_plugin.cpp'
--- tests/unit/test_plugin/tst_plugin.cpp	2014-01-21 19:58:04 +0000
+++ tests/unit/test_plugin/tst_plugin.cpp	2014-03-26 15:53:02 +0000
@@ -25,6 +25,8 @@
 #include <QSignalSpy>
 #include <QJsonDocument>
 #include <QVariantMap>
+#include <QProcess>
+#include <QProcessEnvironment>
 
 #include "plugin/unity-webapps-api.h"
 #include "plugin/abstract-item-model-adaptor.h"
@@ -172,5 +174,22 @@
     delete model;
 }
 
+void PluginTest::testApplicationSignalHandler()
+{
+    QProcess testApp;
+    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+
+    env.insert("APP_ID", "application-api");
+
+    testApp.setProcessEnvironment(env);
+    testApp.start("qmlscene -I ../../../src ../../../examples/api-bindings/application-api/main.qml");
+    testApp.waitForStarted();
+
+    testApp.terminate();
+    testApp.waitForFinished();
+
+    QVERIFY(true);
+}
+
 #include "tst_plugin.moc"
 
 
=== modified file 'tests/unit/test_plugin/tst_plugin.h'
--- tests/unit/test_plugin/tst_plugin.h	2014-01-17 15:51:27 +0000
+++ tests/unit/test_plugin/tst_plugin.h	2014-03-26 15:53:02 +0000
@@ -35,6 +35,7 @@
     void testLoadPlugin();
     void testInit();
     void testAbstractItemModelAdaptor();
+    void testApplicationSignalHandler();
 };
 
 #endif // TST_PLUGIN_H