Merge lp:~bhdouglass/rockwork/configuration-fix into lp:rockwork

[Brian Douglass]

This also includes all the jskit changes from the jskit merge request.

This fixes the evernote configuration problem, but the evernote app keeps having syncing issues. I'm not totally convinced this is RockWork's fault as it sometimes is successful.

Unmerged revisions

57. By Launchpad Translations on behalf of mzanetti on 2016-02-04

Launchpad automatic translations update.

56. By Launchpad Translations on behalf of mzanetti on 2016-02-03

Launchpad automatic translations update.

55. By Launchpad Translations on behalf of mzanetti on 2016-02-02

Launchpad automatic translations update.

=== modified file 'rockwork/AppSettingsPage.qml'
--- rockwork/AppSettingsPage.qml	2016-01-03 05:06:13 +0000
+++ rockwork/AppSettingsPage.qml	2016-02-06 06:08:05 +0000
@@ -42,10 +42,6 @@
                 request.action = Oxide.NavigationRequest.ActionReject;
                 pageStack.pop();
             }
-            else {
-                Qt.openUrlExternally(url);
-                request.action = Oxide.NavigationRequest.ActionReject;
-            }
         }
 
         Component.onCompleted: {

=== removed file 'rockworkd/libpebble/jsfiles.qrc'
--- rockworkd/libpebble/jsfiles.qrc	2016-01-03 15:22:24 +0000
+++ rockworkd/libpebble/jsfiles.qrc	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-<RCC>
-    <qresource prefix="/">
-        <file>typedarray.js</file>
-    </qresource>
-</RCC>

=== added directory 'rockworkd/libpebble/jskit'
=== added file 'rockworkd/libpebble/jskit/cacheLocalStorage.js'
--- rockworkd/libpebble/jskit/cacheLocalStorage.js	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/cacheLocalStorage.js	2016-02-06 06:08:05 +0000
@@ -0,0 +1,11 @@
+//Since we don't have JS 6 support, this hack will allow us to save changes to localStorage when using dot or square bracket notation
+
+for (var key in localStorage) {
+    _jskit.localstorage.setItem(key, localStorage.getItem(key));
+}
+
+for (var key in _jskit.localstorage.keys()) {
+    if (localStorage[key] === undefined) {
+        _jskit.localstorage.removeItem(key);
+    }
+}

=== added file 'rockworkd/libpebble/jskit/jsfiles.qrc'
--- rockworkd/libpebble/jskit/jsfiles.qrc	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jsfiles.qrc	2016-02-06 06:08:05 +0000
@@ -0,0 +1,7 @@
+<RCC>
+    <qresource prefix="/">
+        <file>typedarray.js</file>
+        <file>jskitsetup.js</file>
+        <file>cacheLocalStorage.js</file>
+    </qresource>
+</RCC>

=== added file 'rockworkd/libpebble/jskit/jskitconsole.cpp'
--- rockworkd/libpebble/jskit/jskitconsole.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitconsole.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,29 @@
+#include <QDebug>
+
+#include "jskitconsole.h"
+
+JSKitConsole::JSKitConsole(QObject *parent) :
+    QObject(parent),
+    l(metaObject()->className())
+{
+}
+
+void JSKitConsole::log(const QString &msg)
+{
+    qCDebug(l) << msg;
+}
+
+void JSKitConsole::warn(const QString &msg)
+{
+    qCWarning(l) << msg;
+}
+
+void JSKitConsole::error(const QString &msg)
+{
+    qCCritical(l) << msg;
+}
+
+void JSKitConsole::info(const QString &msg)
+{
+    qCDebug(l) << msg;
+}

=== added file 'rockworkd/libpebble/jskit/jskitconsole.h'
--- rockworkd/libpebble/jskit/jskitconsole.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitconsole.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,20 @@
+#ifndef JSKITCONSOLE_H
+#define JSKITCONSOLE_H
+
+#include <QLoggingCategory>
+
+class JSKitConsole : public QObject
+{
+    Q_OBJECT
+    QLoggingCategory l;
+
+public:
+    explicit JSKitConsole(QObject *parent=0);
+
+    Q_INVOKABLE void log(const QString &msg);
+    Q_INVOKABLE void warn(const QString &msg);
+    Q_INVOKABLE void error(const QString &msg);
+    Q_INVOKABLE void info(const QString &msg);
+};
+
+#endif // JSKITCONSOLE_H

=== added file 'rockworkd/libpebble/jskit/jskitgeolocation.cpp'
--- rockworkd/libpebble/jskit/jskitgeolocation.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitgeolocation.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,287 @@
+#include <limits>
+
+#include "jskitgeolocation.h"
+
+JSKitGeolocation::JSKitGeolocation(QJSEngine *engine) :
+    QObject(engine),
+    l(metaObject()->className()),
+    m_engine(engine),
+    m_source(0),
+    m_lastWatcherId(0)
+{
+}
+
+void JSKitGeolocation::getCurrentPosition(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options)
+{
+    setupWatcher(successCallback, errorCallback, options, true);
+}
+
+int JSKitGeolocation::watchPosition(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options)
+{
+    return setupWatcher(successCallback, errorCallback, options, false);
+}
+
+void JSKitGeolocation::clearWatch(int watcherId)
+{
+    removeWatcher(watcherId);
+}
+
+void JSKitGeolocation::handleError(QGeoPositionInfoSource::Error error)
+{
+    qCWarning(l) << "positioning error: " << error;
+
+    if (m_watchers.empty()) {
+        qCWarning(l) << "got position error but no one is watching";
+        m_source->stopUpdates();
+    }
+    else {
+        QJSValue obj;
+        if (error == QGeoPositionInfoSource::AccessError) {
+            obj = buildPositionErrorObject(PERMISSION_DENIED, "permission denied");
+        } else {
+            obj = buildPositionErrorObject(POSITION_UNAVAILABLE, "position unavailable");
+        }
+
+        for (auto it = m_watchers.begin(); it != m_watchers.end(); /*no adv*/) {
+            invokeCallback(it->errorCallback, obj);
+
+            if (it->once) {
+                it = m_watchers.erase(it);
+            } else {
+                it->timer.restart();
+                ++it;
+            }
+        }
+    }
+}
+
+void JSKitGeolocation::handlePosition(const QGeoPositionInfo &pos)
+{
+    qCDebug(l) << "got position at" << pos.timestamp() << "type" << pos.coordinate().type();
+
+    if (m_watchers.empty()) {
+        qCWarning(l) << "got position update but no one is watching";
+        m_source->stopUpdates();
+    }
+    else {
+        QJSValue obj = buildPositionObject(pos);
+
+        for (auto it = m_watchers.begin(); it != m_watchers.end(); /*no adv*/) {
+            invokeCallback(it->successCallback, obj);
+
+            if (it->once) {
+                it = m_watchers.erase(it);
+            } else {
+                it->timer.restart();
+                ++it;
+            }
+        }
+    }
+}
+
+void JSKitGeolocation::handleTimeout()
+{
+    qCDebug(l) << "positioning timeout";
+
+    if (m_watchers.empty()) {
+        qCWarning(l) << "got position timeout but no one is watching";
+        m_source->stopUpdates();
+    }
+    else {
+        QJSValue obj = buildPositionErrorObject(TIMEOUT, "timeout");
+
+        for (auto it = m_watchers.begin(); it != m_watchers.end(); /*no adv*/) {
+            if (it->timer.hasExpired(it->timeout)) {
+                qCDebug(l) << "positioning timeout for watch" << it->watcherId
+                                 << ", watch is" << it->timer.elapsed() << "ms old, timeout is" << it->timeout;
+                invokeCallback(it->errorCallback, obj);
+
+                if (it->once) {
+                    it = m_watchers.erase(it);
+                } else {
+                    it->timer.restart();
+                    ++it;
+                }
+            } else {
+                ++it;
+            }
+        }
+
+        QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
+    }
+}
+
+void JSKitGeolocation::updateTimeouts()
+{
+    int once_timeout = -1, updates_timeout = -1;
+
+    Q_FOREACH(const Watcher &watcher, m_watchers) {
+        qint64 rem_timeout = watcher.timeout - watcher.timer.elapsed();
+        qCDebug(l) << "watch" << watcher.watcherId << "rem timeout" << rem_timeout;
+
+        if (rem_timeout >= 0) {
+            // Make sure the limits aren't too large
+            rem_timeout = qMin<qint64>(rem_timeout, std::numeric_limits<int>::max());
+
+            if (watcher.once) {
+                once_timeout = once_timeout >= 0 ? qMin<int>(once_timeout, rem_timeout) : rem_timeout;
+            } else {
+                updates_timeout = updates_timeout >= 0 ? qMin<int>(updates_timeout, rem_timeout) : rem_timeout;
+            }
+        }
+    }
+
+    if (updates_timeout >= 0) {
+        qCDebug(l) << "setting location update interval to" << updates_timeout;
+        m_source->setUpdateInterval(updates_timeout);
+        m_source->startUpdates();
+    } else {
+        qCDebug(l) << "stopping updates";
+        m_source->stopUpdates();
+    }
+
+    if (once_timeout >= 0) {
+        qCDebug(l) << "requesting single location update with timeout" << once_timeout;
+        m_source->requestUpdate(once_timeout);
+    }
+}
+
+int JSKitGeolocation::setupWatcher(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options, bool once)
+{
+    Watcher watcher;
+    watcher.successCallback = successCallback;
+    watcher.errorCallback = errorCallback;
+    watcher.highAccuracy = options.value("enableHighAccuracy", false).toBool();
+    watcher.timeout = options.value("timeout", std::numeric_limits<int>::max() - 1).toInt();
+    watcher.maximumAge = options.value("maximumAge", 0).toLongLong();
+    watcher.once = once;
+    watcher.watcherId = ++m_lastWatcherId;
+
+    qCDebug(l) << "setting up watcher, gps=" << watcher.highAccuracy << "timeout=" << watcher.timeout << "maximumAge=" << watcher.maximumAge << "once=" << watcher.once;
+
+    if (!m_source) {
+        m_source = QGeoPositionInfoSource::createDefaultSource(this);
+
+        connect(m_source, static_cast<void (QGeoPositionInfoSource::*)(QGeoPositionInfoSource::Error)>(&QGeoPositionInfoSource::error),
+                this, &JSKitGeolocation::handleError);
+        connect(m_source, &QGeoPositionInfoSource::positionUpdated,
+                this, &JSKitGeolocation::handlePosition);
+        connect(m_source, &QGeoPositionInfoSource::updateTimeout,
+                this, &JSKitGeolocation::handleTimeout);
+    }
+
+    if (watcher.maximumAge > 0) {
+        QDateTime threshold = QDateTime::currentDateTime().addMSecs(-qint64(watcher.maximumAge));
+        QGeoPositionInfo pos = m_source->lastKnownPosition(watcher.highAccuracy);
+        qCDebug(l) << "got pos timestamp" << pos.timestamp() << " but we want" << threshold;
+
+        if (pos.isValid() && pos.timestamp() >= threshold) {
+            invokeCallback(watcher.successCallback, buildPositionObject(pos));
+
+            if (once) {
+                return -1;
+            }
+        } else if (watcher.timeout == 0 && once) {
+            // If the timeout has already expired, and we have no cached data
+            // Do not even bother to turn on the GPS; return error object now.
+            invokeCallback(watcher.errorCallback, buildPositionErrorObject(TIMEOUT, "no cached position"));
+            return -1;
+        }
+    }
+
+    watcher.timer.start();
+    m_watchers.append(watcher);
+
+    qCDebug(l) << "added new watcher" << watcher.watcherId;
+    QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
+
+    return watcher.watcherId;
+}
+
+void JSKitGeolocation::removeWatcher(int watcherId)
+{
+    Watcher watcher;
+
+    qCDebug(l) << "removing watcherId" << watcher.watcherId;
+
+    for (int i = 0; i < m_watchers.size(); i++) {
+        if (m_watchers[i].watcherId == watcherId) {
+            watcher = m_watchers.takeAt(i);
+            break;
+        }
+    }
+
+    if (watcher.watcherId != watcherId) {
+        qCWarning(l) << "watcherId not found";
+        return;
+    }
+
+    QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
+}
+
+QJSValue JSKitGeolocation::buildPositionObject(const QGeoPositionInfo &pos)
+{
+    QJSValue obj = m_engine->newObject();
+    QJSValue coords = m_engine->newObject();
+    QJSValue timestamp = m_engine->toScriptValue<quint64>(pos.timestamp().toMSecsSinceEpoch());
+
+    coords.setProperty("latitude", m_engine->toScriptValue(pos.coordinate().latitude()));
+    coords.setProperty("longitude", m_engine->toScriptValue(pos.coordinate().longitude()));
+    if (pos.coordinate().type() == QGeoCoordinate::Coordinate3D) {
+        coords.setProperty("altitude", m_engine->toScriptValue(pos.coordinate().altitude()));
+    } else {
+        coords.setProperty("altitude", m_engine->toScriptValue<void*>(0));
+    }
+
+    coords.setProperty("accuracy", m_engine->toScriptValue(pos.attribute(QGeoPositionInfo::HorizontalAccuracy)));
+
+    if (pos.hasAttribute(QGeoPositionInfo::VerticalAccuracy)) {
+        coords.setProperty("altitudeAccuracy", m_engine->toScriptValue(pos.attribute(QGeoPositionInfo::VerticalAccuracy)));
+    } else {
+        coords.setProperty("altitudeAccuracy", m_engine->toScriptValue<void*>(0));
+    }
+
+    if (pos.hasAttribute(QGeoPositionInfo::Direction)) {
+        coords.setProperty("heading", m_engine->toScriptValue(pos.attribute(QGeoPositionInfo::Direction)));
+    } else {
+        coords.setProperty("heading", m_engine->toScriptValue<void*>(0));
+    }
+
+    if (pos.hasAttribute(QGeoPositionInfo::GroundSpeed)) {
+        coords.setProperty("speed", m_engine->toScriptValue(pos.attribute(QGeoPositionInfo::GroundSpeed)));
+    } else {
+        coords.setProperty("speed", m_engine->toScriptValue<void*>(0));
+    }
+
+    obj.setProperty("coords", coords);
+    obj.setProperty("timestamp", timestamp);
+
+    return obj;
+}
+
+QJSValue JSKitGeolocation::buildPositionErrorObject(PositionError error, const QString &message)
+{
+    QJSValue obj = m_engine->newObject();
+
+    obj.setProperty("code", m_engine->toScriptValue<unsigned short>(error));
+    obj.setProperty("message", m_engine->toScriptValue(message));
+
+    return obj;
+}
+
+void JSKitGeolocation::invokeCallback(QJSValue callback, QJSValue event)
+{
+    if (callback.isCallable()) {
+        qCDebug(l) << "invoking callback" << callback.toString();
+        QJSValue result = callback.call(QJSValueList({event}));
+
+        if (result.isError()) {
+            qCWarning(l) << "error while invoking callback: " << QString("%1:%2: %3")
+                .arg(result.property("fileName").toString())
+                .arg(result.property("lineNumber").toInt())
+                .arg(result.toString());
+        }
+    } else {
+        qCWarning(l) << "callback is not callable";
+    }
+}

=== added file 'rockworkd/libpebble/jskit/jskitgeolocation.h'
--- rockworkd/libpebble/jskit/jskitgeolocation.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitgeolocation.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,65 @@
+#ifndef JSKITGEOLOCATION_H
+#define JSKITGEOLOCATION_H
+
+#include <QElapsedTimer>
+#include <QGeoPositionInfoSource>
+#include <QJSValue>
+#include <QLoggingCategory>
+#include <QJSEngine>
+
+class JSKitGeolocation : public QObject
+{
+    Q_OBJECT
+    QLoggingCategory l;
+
+    struct Watcher;
+
+public:
+    explicit JSKitGeolocation(QJSEngine *engine);
+
+    enum PositionError {
+        PERMISSION_DENIED = 1,
+        POSITION_UNAVAILABLE = 2,
+        TIMEOUT = 3
+    };
+    Q_ENUMS(PositionError);
+
+    Q_INVOKABLE void getCurrentPosition(const QJSValue &successCallback, const QJSValue &errorCallback = QJSValue(), const QVariantMap &options = QVariantMap());
+    Q_INVOKABLE int watchPosition(const QJSValue &successCallback, const QJSValue &errorCallback = QJSValue(), const QVariantMap &options = QVariantMap());
+    Q_INVOKABLE void clearWatch(int watcherId);
+
+private slots:
+    void handleError(const QGeoPositionInfoSource::Error error);
+    void handlePosition(const QGeoPositionInfo &pos);
+    void handleTimeout();
+    void updateTimeouts();
+
+private:
+    int setupWatcher(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options, bool once);
+    void removeWatcher(int watcherId);
+
+    QJSValue buildPositionObject(const QGeoPositionInfo &pos);
+    QJSValue buildPositionErrorObject(PositionError error, const QString &message = QString());
+    QJSValue buildPositionErrorObject(const QGeoPositionInfoSource::Error error);
+    void invokeCallback(QJSValue callback, QJSValue event);
+
+private:
+    QJSEngine *m_engine;
+    QGeoPositionInfoSource *m_source;
+
+    struct Watcher {
+        QJSValue successCallback;
+        QJSValue errorCallback;
+        int watcherId;
+        bool once;
+        bool highAccuracy;
+        int timeout;
+        QElapsedTimer timer;
+        qlonglong maximumAge;
+    };
+
+    QList<Watcher> m_watchers;
+    int m_lastWatcherId;
+};
+
+#endif // JSKITGEOLOCATION_H

=== added file 'rockworkd/libpebble/jskit/jskitlocalstorage.cpp'
--- rockworkd/libpebble/jskit/jskitlocalstorage.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitlocalstorage.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,117 @@
+#include <QDesktopServices>
+#include <QDir>
+#include <QDebug>
+
+#include "jskitlocalstorage.h"
+
+JSKitLocalStorage::JSKitLocalStorage(QJSEngine *engine, const QString &storagePath, const QUuid &uuid):
+    QObject(engine),
+    m_engine(engine),
+    m_storage(new QSettings(getStorageFileFor(storagePath, uuid), QSettings::IniFormat, this))
+{
+}
+
+int JSKitLocalStorage::length() const
+{
+    return m_storage->allKeys().size();
+}
+
+QJSValue JSKitLocalStorage::getItem(const QJSValue &key) const
+{
+    QVariant value = m_storage->value(key.toString());
+
+    if (value.isValid()) {
+        return QJSValue(value.toString());
+    } else {
+        return QJSValue(QJSValue::NullValue);
+    }
+}
+
+bool JSKitLocalStorage::setItem(const QJSValue &key, const QJSValue &value)
+{
+    m_storage->setValue(key.toString(), QVariant::fromValue(value.toString()));
+    return true;
+}
+
+bool JSKitLocalStorage::removeItem(const QJSValue &key)
+{
+    if (m_storage->contains(key.toString())) {
+        m_storage->remove(key.toString());
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void JSKitLocalStorage::clear()
+{
+    m_storage->clear();
+}
+
+QJSValue JSKitLocalStorage::key(int index)
+{
+    QStringList allKeys = m_storage->allKeys();
+    QJSValue key(QJSValue::NullValue);
+
+    if (allKeys.size() > index) {
+        key = QJSValue(allKeys[index]);
+    }
+
+    return key;
+}
+
+QJSValue JSKitLocalStorage::get(const QJSValue &proxy, const QJSValue &key) const
+{
+    Q_UNUSED(proxy);
+    return getItem(key);
+}
+
+bool JSKitLocalStorage::set(const QJSValue &proxy, const QJSValue &key, const QJSValue &value)
+{
+    Q_UNUSED(proxy);
+    return setItem(key, value);
+}
+
+bool JSKitLocalStorage::has(const QJSValue &proxy, const QJSValue &key)
+{
+    Q_UNUSED(proxy);
+    return m_storage->contains(key.toString());
+}
+
+bool JSKitLocalStorage::deleteProperty(const QJSValue &proxy, const QJSValue &key)
+{
+    Q_UNUSED(proxy);
+    return removeItem(key);
+}
+
+QJSValue JSKitLocalStorage::keys(const QJSValue &proxy)
+{
+    Q_UNUSED(proxy);
+
+    QStringList allKeys = m_storage->allKeys();
+    QJSValue keyArray = m_engine->newArray(allKeys.size());
+    for (int i = 0; i < allKeys.size(); i++) {
+        keyArray.setProperty(i, allKeys[i]);
+    }
+
+    return keyArray;
+}
+
+QJSValue JSKitLocalStorage::enumerate()
+{
+    return keys(0);
+}
+
+QString JSKitLocalStorage::getStorageFileFor(const QString &storageDir, const QUuid &uuid)
+{
+    QDir dataDir(storageDir + "/js-storage");
+    if (!dataDir.exists() && !dataDir.mkpath(dataDir.absolutePath())) {
+        qWarning() << "Error creating jskit storage dir";
+        return QString();
+    }
+
+    QString fileName = uuid.toString();
+    fileName.remove('{');
+    fileName.remove('}');
+    return dataDir.absoluteFilePath(fileName + ".ini");
+}

=== added file 'rockworkd/libpebble/jskit/jskitlocalstorage.h'
--- rockworkd/libpebble/jskit/jskitlocalstorage.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitlocalstorage.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,40 @@
+#ifndef JSKITLOCALSTORAGE_P_H
+#define JSKITLOCALSTORAGE_P_H
+
+#include <QSettings>
+#include <QJSEngine>
+#include <QUuid>
+
+class JSKitLocalStorage : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(int length READ length)
+
+public:
+    explicit JSKitLocalStorage(QJSEngine *engine, const QString &storagePath, const QUuid &uuid);
+
+    int length() const;
+
+    Q_INVOKABLE QJSValue getItem(const QJSValue &key) const;
+    Q_INVOKABLE bool setItem(const QJSValue &key, const QJSValue &value);
+    Q_INVOKABLE bool removeItem(const QJSValue &key);
+    Q_INVOKABLE void clear();
+    Q_INVOKABLE QJSValue key(int index);
+
+    Q_INVOKABLE QJSValue get(const QJSValue &proxy, const QJSValue &key) const;
+    Q_INVOKABLE bool set(const QJSValue &proxy, const QJSValue &key, const QJSValue &value);
+    Q_INVOKABLE bool has(const QJSValue &proxy, const QJSValue &key);
+    Q_INVOKABLE bool deleteProperty(const QJSValue &proxy, const QJSValue &key);
+    Q_INVOKABLE QJSValue keys(const QJSValue &proxy=0);
+    Q_INVOKABLE QJSValue enumerate();
+
+private:
+    static QString getStorageFileFor(const QString &storageDir, const QUuid &uuid);
+
+private:
+    QJSEngine *m_engine;
+    QSettings *m_storage;
+};
+
+#endif // JSKITLOCALSTORAGE_P_H

=== added file 'rockworkd/libpebble/jskit/jskitmanager.cpp'
--- rockworkd/libpebble/jskit/jskitmanager.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitmanager.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,240 @@
+#include <QFile>
+#include <QDir>
+#include <QUrl>
+
+#include "jskitmanager.h"
+#include "jskitpebble.h"
+
+JSKitManager::JSKitManager(Pebble *pebble, WatchConnection *connection, AppManager *apps, AppMsgManager *appmsg, QObject *parent) :
+    QObject(parent),
+    l(metaObject()->className()),
+    m_pebble(pebble),
+    m_connection(connection),
+    m_apps(apps),
+    m_appmsg(appmsg),
+    m_engine(0),
+    m_configurationUuid(0)
+{
+    connect(m_appmsg, &AppMsgManager::appStarted, this, &JSKitManager::handleAppStarted);
+    connect(m_appmsg, &AppMsgManager::appStopped, this, &JSKitManager::handleAppStopped);
+}
+
+JSKitManager::~JSKitManager()
+{
+    if (m_engine) {
+        stopJsApp();
+    }
+}
+
+QJSEngine * JSKitManager::engine()
+{
+    return m_engine;
+}
+
+bool JSKitManager::isJSKitAppRunning() const
+{
+    return m_engine != 0;
+}
+
+QString JSKitManager::describeError(QJSValue error)
+{
+    return QString("%1:%2: %3")
+        .arg(error.property("fileName").toString())
+        .arg(error.property("lineNumber").toInt())
+        .arg(error.toString());
+}
+
+void JSKitManager::showConfiguration()
+{
+    if (m_engine) {
+        qCDebug(l) << "requesting configuration";
+        m_jspebble->invokeCallbacks("showConfiguration");
+    } else {
+        qCWarning(l) << "requested to show configuration, but JS engine is not running";
+    }
+}
+
+void JSKitManager::handleWebviewClosed(const QString &result)
+{
+    if (m_engine) {
+        QJSValue eventObj = m_engine->newObject();
+        eventObj.setProperty("response", QUrl::fromPercentEncoding(result.toUtf8()));
+
+        qCDebug(l) << "Sending" << eventObj.property("response").toString();
+        m_jspebble->invokeCallbacks("webviewclosed", QJSValueList({eventObj}));
+
+        loadJsFile(":/cacheLocalStorage.js");
+    } else {
+        qCWarning(l) << "webview closed event, but JS engine is not running";
+    }
+}
+
+void JSKitManager::setConfigurationId(const QUuid &uuid)
+{
+    m_configurationUuid = uuid;
+}
+
+AppInfo JSKitManager::currentApp()
+{
+    return m_curApp;
+}
+
+void JSKitManager::handleAppStarted(const QUuid &uuid)
+{
+    AppInfo info = m_apps->info(uuid);
+    if (!info.uuid().isNull() && info.isJSKit()) {
+        qCDebug(l) << "Preparing to start JSKit app" << info.uuid() << info.shortName();
+
+        m_curApp = info;
+        startJsApp();
+    }
+}
+
+void JSKitManager::handleAppStopped(const QUuid &uuid)
+{
+    if (!m_curApp.uuid().isNull()) {
+        if (m_curApp.uuid() != uuid) {
+            qCWarning(l) << "Closed app with invalid UUID";
+        }
+
+        stopJsApp();
+        m_curApp = AppInfo();
+        qCDebug(l) << "App stopped" << uuid;
+    }
+}
+
+void JSKitManager::handleAppMessage(const QUuid &uuid, const QVariantMap &msg)
+{
+    if (m_curApp.uuid() == uuid) {
+        qCDebug(l) << "handling app message" << uuid << msg;
+
+        if (m_engine) {
+            QJSValue eventObj = m_engine->newObject();
+            eventObj.setProperty("payload", m_engine->toScriptValue(msg));
+
+            m_jspebble->invokeCallbacks("appmessage", QJSValueList({eventObj}));
+
+            loadJsFile(":/cacheLocalStorage.js");
+        }
+        else {
+            qCDebug(l) << "but engine is stopped";
+        }
+    }
+}
+
+bool JSKitManager::loadJsFile(const QString &filename)
+{
+    Q_ASSERT(m_engine);
+
+    QFile file(filename);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qCWarning(l) << "Failed to load JS file:" << file.fileName();
+        return false;
+    }
+
+    qCDebug(l) << "evaluating js file" << file.fileName();
+
+    QJSValue result = m_engine->evaluate(QString::fromUtf8(file.readAll()), file.fileName());
+    if (result.isError()) {
+        qCWarning(l) << "error while evaluating JS script:" << describeError(result);
+        return false;
+    }
+
+    qCDebug(l) << "JS script evaluated";
+    return true;
+}
+
+void JSKitManager::startJsApp()
+{
+    if (m_engine) stopJsApp();
+
+    if (m_curApp.uuid().isNull()) {
+        qCWarning(l) << "Attempting to start JS app with invalid UUID";
+        return;
+    }
+
+    m_engine = new QJSEngine(this);
+    m_jspebble = new JSKitPebble(m_curApp, this, m_engine);
+    m_jsconsole = new JSKitConsole(m_engine);
+    m_jsstorage = new JSKitLocalStorage(m_engine, m_pebble->storagePath(), m_curApp.uuid());
+    m_jsgeo = new JSKitGeolocation(m_engine);
+    m_jstimer = new JSKitTimer(m_engine);
+    m_jsperformance = new JSKitPerformance(m_engine);
+
+    qCDebug(l) << "starting JS app" << m_curApp.shortName();
+
+    QJSValue globalObj = m_engine->globalObject();
+    QJSValue jskitObj = m_engine->newObject();
+
+    jskitObj.setProperty("pebble", m_engine->newQObject(m_jspebble));
+    jskitObj.setProperty("console", m_engine->newQObject(m_jsconsole));
+    jskitObj.setProperty("localstorage", m_engine->newQObject(m_jsstorage));
+    jskitObj.setProperty("geolocation", m_engine->newQObject(m_jsgeo));
+    jskitObj.setProperty("timer", m_engine->newQObject(m_jstimer));
+    jskitObj.setProperty("performance", m_engine->newQObject(m_jsperformance));
+    globalObj.setProperty("_jskit", jskitObj);
+
+    QJSValue navigatorObj = m_engine->newObject();
+    navigatorObj.setProperty("language", m_engine->toScriptValue(QLocale().name()));
+    globalObj.setProperty("navigator", navigatorObj);
+
+    // Set this.window = this
+    globalObj.setProperty("window", globalObj);
+
+    // Shims for compatibility...
+    loadJsFile(":/jskitsetup.js");
+
+    // Polyfills...
+    loadJsFile(":/typedarray.js");
+
+    // Now the actual script
+    QString jsApp = m_curApp.file(AppInfo::FileTypeJsApp, HardwarePlatformUnknown);
+    QFile f(jsApp);
+    if (!f.open(QFile::ReadOnly)) {
+        qCWarning(l) << "Error opening" << jsApp;
+        return;
+    }
+    QJSValue ret = m_engine->evaluate(QString::fromUtf8(f.readAll()));
+    qCDebug(l) << "loaded script" << ret.toString();
+
+    // Setup the message callback
+    QUuid uuid = m_curApp.uuid();
+    m_appmsg->setMessageHandler(uuid, [this, uuid](const QVariantMap &msg) {
+        QMetaObject::invokeMethod(this, "handleAppMessage", Qt::QueuedConnection,
+                                  Q_ARG(QUuid, uuid),
+                                  Q_ARG(QVariantMap, msg));
+
+        // Invoke the slot as a queued connection to give time for the ACK message
+        // to go through first.
+
+        return true;
+    });
+
+    // We try to invoke the callbacks even if script parsing resulted in error...
+    m_jspebble->invokeCallbacks("ready");
+
+    loadJsFile(":/cacheLocalStorage.js");
+
+    if (m_configurationUuid == m_curApp.uuid()) {
+        qCDebug(l) << "going to launch config for" << m_configurationUuid;
+        showConfiguration();
+    }
+
+    m_configurationUuid = QUuid();
+}
+
+void JSKitManager::stopJsApp()
+{
+    qCDebug(l) << "stop js app" << m_curApp.uuid();
+    if (!m_engine) return; // Nothing to do!
+
+    loadJsFile(":/cacheLocalStorage.js");
+
+    if (!m_curApp.uuid().isNull()) {
+        m_appmsg->clearMessageHandler(m_curApp.uuid());
+    }
+
+    m_engine->collectGarbage();
+    m_engine->deleteLater();
+    m_engine = 0;
+}

=== added file 'rockworkd/libpebble/jskit/jskitmanager.h'
--- rockworkd/libpebble/jskit/jskitmanager.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitmanager.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,72 @@
+#ifndef JSKITMANAGER_H
+#define JSKITMANAGER_H
+
+#include <QJSEngine>
+#include <QPointer>
+#include <QLoggingCategory>
+
+#include "../appmanager.h"
+#include "../watchconnection.h"
+#include "../pebble.h"
+#include "../appmsgmanager.h"
+
+#include "jskitconsole.h"
+#include "jskitgeolocation.h"
+#include "jskitlocalstorage.h"
+#include "jskittimer.h"
+#include "jskitperformance.h"
+
+class JSKitPebble;
+
+class JSKitManager : public QObject
+{
+    Q_OBJECT
+    QLoggingCategory l;
+
+public:
+    explicit JSKitManager(Pebble *pebble, WatchConnection *connection, AppManager *apps, AppMsgManager *appmsg, QObject *parent = 0);
+    ~JSKitManager();
+
+    QJSEngine * engine();
+    bool isJSKitAppRunning() const;
+
+    static QString describeError(QJSValue error);
+
+    void showConfiguration();
+    void handleWebviewClosed(const QString &result);
+    void setConfigurationId(const QUuid &uuid);
+    AppInfo currentApp();
+
+signals:
+    void appNotification(const QUuid &uuid, const QString &title, const QString &body);
+    void openURL(const QString &uuid, const QString &url);
+
+private slots:
+    void handleAppStarted(const QUuid &uuid);
+    void handleAppStopped(const QUuid &uuid);
+    void handleAppMessage(const QUuid &uuid, const QVariantMap &msg);
+
+private:
+    bool loadJsFile(const QString &filename);
+    void startJsApp();
+    void stopJsApp();
+
+private:
+    friend class JSKitPebble;
+
+    Pebble *m_pebble;
+    WatchConnection *m_connection;
+    AppManager *m_apps;
+    AppMsgManager *m_appmsg;
+    AppInfo m_curApp;
+    QJSEngine *m_engine;
+    QPointer<JSKitPebble> m_jspebble;
+    QPointer<JSKitConsole> m_jsconsole;
+    QPointer<JSKitLocalStorage> m_jsstorage;
+    QPointer<JSKitGeolocation> m_jsgeo;
+    QPointer<JSKitTimer> m_jstimer;
+    QPointer<JSKitPerformance> m_jsperformance;
+    QUuid m_configurationUuid;
+};
+
+#endif // JSKITMANAGER_H

=== added file 'rockworkd/libpebble/jskit/jskitpebble.cpp'
--- rockworkd/libpebble/jskit/jskitpebble.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitpebble.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,355 @@
+#include <QUrl>
+#include <QCryptographicHash>
+#include <QSettings>
+
+#include "jskitpebble.h"
+#include "jskitxmlhttprequest.h"
+
+static const char *token_salt = "0feeb7416d3c4546a19b04bccd8419b1";
+
+JSKitPebble::JSKitPebble(const AppInfo &info, JSKitManager *mgr, QObject *parent) :
+    QObject(parent),
+    l(metaObject()->className()),
+    m_appInfo(info),
+    m_mgr(mgr)
+{
+}
+
+void JSKitPebble::addEventListener(const QString &type, QJSValue function)
+{
+    m_listeners[type].append(function);
+}
+
+void JSKitPebble::removeEventListener(const QString &type, QJSValue function)
+{
+    if (!m_listeners.contains(type)) return;
+
+    QList<QJSValue> &callbacks = m_listeners[type];
+    for (QList<QJSValue>::iterator it = callbacks.begin(); it != callbacks.end(); ) {
+        if (it->strictlyEquals(function)) {
+            it = callbacks.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    if (callbacks.empty()) {
+        m_listeners.remove(type);
+    }
+}
+
+void JSKitPebble::showSimpleNotificationOnPebble(const QString &title, const QString &body)
+{
+    qCDebug(l) << "showSimpleNotificationOnPebble" << title << body;
+    emit m_mgr->appNotification(m_appInfo.uuid(), title, body);
+}
+
+uint JSKitPebble::sendAppMessage(QJSValue message, QJSValue callbackForAck, QJSValue callbackForNack)
+{
+    QVariantMap data = message.toVariant().toMap();
+    QPointer<JSKitPebble> pebbObj = this;
+    uint transactionId = m_mgr->m_appmsg->nextTransactionId();
+
+    qCDebug(l) << "sendAppMessage" << data;
+
+    m_mgr->m_appmsg->send(
+        m_appInfo.uuid(),
+        data,
+        [this, pebbObj, transactionId, callbackForAck]() mutable {
+            if (pebbObj.isNull()) return;
+
+            if (callbackForAck.isCallable()) {
+                QJSValue event = pebbObj->buildAckEventObject(transactionId);
+                QJSValue result = callbackForAck.call(QJSValueList({event}));
+
+                if (result.isError()) {
+                    qCWarning(l) << "error while invoking ACK callback"
+                        << callbackForAck.toString() << ":"
+                        << JSKitManager::describeError(result);
+                }
+            }
+        },
+        [this, pebbObj, transactionId, callbackForNack]() mutable {
+            if (pebbObj.isNull()) return;
+
+            if (callbackForNack.isCallable()) {
+                QJSValue event = pebbObj->buildAckEventObject(transactionId, "NACK from watch");
+                QJSValue result = callbackForNack.call(QJSValueList({event}));
+
+                if (result.isError()) {
+                    qCWarning(l) << "error while invoking NACK callback"
+                        << callbackForNack.toString() << ":"
+                        << JSKitManager::describeError(result);
+                }
+            }
+        }
+    );
+
+    return transactionId;
+}
+
+void JSKitPebble::getTimelineToken(QJSValue successCallback, QJSValue failureCallback)
+{
+    //TODO actually implement this
+    qCDebug(l) << "call to unsupported method Pebble.getTimelineToken";
+    Q_UNUSED(successCallback);
+
+    if (failureCallback.isCallable()) {
+        failureCallback.call();
+    }
+}
+
+void JSKitPebble::timelineSubscribe(const QString &topic, QJSValue successCallback, QJSValue failureCallback)
+{
+    //TODO actually implement this
+    qCDebug(l) << "call to unsupported method Pebble.timelineSubscribe";
+    Q_UNUSED(topic);
+    Q_UNUSED(successCallback);
+
+    if (failureCallback.isCallable()) {
+        failureCallback.call();
+    }
+}
+
+void JSKitPebble::timelineUnsubscribe(const QString &topic, QJSValue successCallback, QJSValue failureCallback)
+{
+    //TODO actually implement this
+    qCDebug(l) << "call to unsupported method Pebble.timelineUnsubscribe";
+    Q_UNUSED(topic);
+    Q_UNUSED(successCallback);
+
+    if (failureCallback.isCallable()) {
+        failureCallback.call();
+    }
+}
+
+void JSKitPebble::timelineSubscriptions(QJSValue successCallback, QJSValue failureCallback)
+{
+    //TODO actually implement this
+    qCDebug(l) << "call to unsupported method Pebble.timelineSubscriptions";
+    Q_UNUSED(successCallback);
+
+    if (failureCallback.isCallable()) {
+        failureCallback.call();
+    }
+}
+
+
+QString JSKitPebble::getAccountToken() const
+{
+    // We do not have any account system, so we just fake something up.
+    QCryptographicHash hasher(QCryptographicHash::Md5);
+
+    hasher.addData(token_salt, strlen(token_salt));
+    hasher.addData(m_appInfo.uuid().toByteArray());
+
+    QSettings settings;
+    QString token = settings.value("accountToken").toString();
+
+    if (token.isEmpty()) {
+        token = QUuid::createUuid().toString();
+        qCDebug(l) << "created new account token" << token;
+        settings.setValue("accountToken", token);
+    }
+
+    hasher.addData(token.toLatin1());
+
+    QString hash = hasher.result().toHex();
+    qCDebug(l) << "returning account token" << hash;
+
+    return hash;
+}
+
+QString JSKitPebble::getWatchToken() const
+{
+    QCryptographicHash hasher(QCryptographicHash::Md5);
+
+    hasher.addData(token_salt, strlen(token_salt));
+    hasher.addData(m_appInfo.uuid().toByteArray());
+    hasher.addData(m_mgr->m_pebble->serialNumber().toLatin1());
+
+    QString hash = hasher.result().toHex();
+    qCDebug(l) << "returning watch token" << hash;
+
+    return hash;
+}
+
+QJSValue JSKitPebble::getActiveWatchInfo() const
+{
+    QJSValue watchInfo = m_mgr->m_engine->newObject();
+
+    switch (m_mgr->m_pebble->hardwarePlatform()) {
+    case HardwarePlatformBasalt:
+        watchInfo.setProperty("platform", "basalt");
+        break;
+
+    case HardwarePlatformChalk:
+        watchInfo.setProperty("platform", "chalk");
+        break;
+
+    default:
+        watchInfo.setProperty("platform", "aplite");
+        break;
+    }
+
+    switch (m_mgr->m_pebble->model()) {
+    case ModelTintinWhite:
+        watchInfo.setProperty("model", "pebble_white");
+        break;
+
+    case ModelTintinRed:
+        watchInfo.setProperty("model", "pebble_red");
+        break;
+
+    case ModelTintinOrange:
+        watchInfo.setProperty("model", "pebble_orange");
+        break;
+
+    case ModelTintinGrey:
+        watchInfo.setProperty("model", "pebble_grey");
+        break;
+
+    case ModelBiancaSilver:
+        watchInfo.setProperty("model", "pebble_steel_silver");
+        break;
+
+    case ModelBiancaBlack:
+        watchInfo.setProperty("model", "pebble_steel_black");
+        break;
+
+    case ModelTintinBlue:
+        watchInfo.setProperty("model", "pebble_blue");
+        break;
+
+    case ModelTintinGreen:
+        watchInfo.setProperty("model", "pebble_green");
+        break;
+
+    case ModelTintinPink:
+        watchInfo.setProperty("model", "pebble_pink");
+        break;
+
+    case ModelSnowyWhite:
+        watchInfo.setProperty("model", "pebble_time_white");
+        break;
+
+    case ModelSnowyBlack:
+        watchInfo.setProperty("model", "pebble_time_black");
+        break;
+
+    case ModelSnowyRed:
+        watchInfo.setProperty("model", "pebble_time_read");
+        break;
+
+    case ModelBobbySilver:
+        watchInfo.setProperty("model", "pebble_time_steel_silver");
+        break;
+
+    case ModelBobbyBlack:
+        watchInfo.setProperty("model", "pebble_time_steel_black");
+        break;
+
+    case ModelBobbyGold:
+        watchInfo.setProperty("model", "pebble_time_steel_gold");
+        break;
+
+    case ModelSpalding14Silver:
+        watchInfo.setProperty("model", "pebble_time_round_silver_14mm");
+        break;
+
+    case ModelSpalding14Black:
+        watchInfo.setProperty("model", "pebble_time_round_black_14mm");
+        break;
+
+    case ModelSpalding20Silver:
+        watchInfo.setProperty("model", "pebble_time_round_silver_20mm");
+        break;
+
+    case ModelSpalding20Black:
+        watchInfo.setProperty("model", "pebble_time_round_black_20mm");
+        break;
+
+    case ModelSpalding14RoseGold:
+        watchInfo.setProperty("model", "pebble_time_round_rose_gold_14mm");
+        break;
+
+    default:
+        watchInfo.setProperty("model", "pebble_black");
+        break;
+    }
+
+    watchInfo.setProperty("language", m_mgr->m_pebble->language());
+
+    QJSValue firmware = m_mgr->m_engine->newObject();
+    QString version = m_mgr->m_pebble->softwareVersion().remove("v");
+    QStringList versionParts = version.split(".");
+
+    if (versionParts.count() >= 1) {
+        firmware.setProperty("major", versionParts[0].toInt());
+    }
+
+    if (versionParts.count() >= 2) {
+        firmware.setProperty("minor", versionParts[1].toInt());
+    }
+
+    if (versionParts.count() >= 3) {
+        if (versionParts[2].contains("-")) {
+            QStringList patchParts = version.split("-");
+            firmware.setProperty("patch", patchParts[0].toInt());
+            firmware.setProperty("suffix", patchParts[1]);
+        } else {
+            firmware.setProperty("patch", versionParts[2].toInt());
+            firmware.setProperty("suffix", "");
+        }
+    }
+
+    watchInfo.setProperty("firmware", firmware);
+    return watchInfo;
+}
+
+void JSKitPebble::openURL(const QUrl &url)
+{
+    emit m_mgr->openURL(m_appInfo.uuid().toString(), url.toString());
+}
+
+QJSValue JSKitPebble::createXMLHttpRequest()
+{
+    JSKitXMLHttpRequest *xhr = new JSKitXMLHttpRequest(m_mgr->engine());
+    // Should be deleted by JS engine.
+    return m_mgr->engine()->newQObject(xhr);
+}
+
+QJSValue JSKitPebble::buildAckEventObject(uint transaction, const QString &message) const
+{
+    QJSEngine *engine = m_mgr->engine();
+    QJSValue eventObj = engine->newObject();
+    QJSValue dataObj = engine->newObject();
+
+    dataObj.setProperty("transactionId", engine->toScriptValue(transaction));
+    eventObj.setProperty("data", dataObj);
+
+    if (!message.isEmpty()) {
+        QJSValue errorObj = engine->newObject();
+
+        errorObj.setProperty("message", engine->toScriptValue(message));
+        eventObj.setProperty("error", errorObj);
+    }
+
+    return eventObj;
+}
+
+void JSKitPebble::invokeCallbacks(const QString &type, const QJSValueList &args)
+{
+    if (!m_listeners.contains(type)) return;
+    QList<QJSValue> &callbacks = m_listeners[type];
+
+    for (QList<QJSValue>::iterator it = callbacks.begin(); it != callbacks.end(); ++it) {
+        qCDebug(l) << "invoking callback" << type << it->toString();
+        QJSValue result = it->call(args);
+        if (result.isError()) {
+            qCWarning(l) << "error while invoking callback"
+                << type << it->toString() << ":"
+                << JSKitManager::describeError(result);
+        }
+    }
+}

=== added file 'rockworkd/libpebble/jskit/jskitpebble.h'
--- rockworkd/libpebble/jskit/jskitpebble.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitpebble.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,47 @@
+#ifndef JSKITPEBBLE_P_H
+#define JSKITPEBBLE_P_H
+
+#include <QLoggingCategory>
+
+#include "jskitmanager.h"
+#include "../appinfo.h"
+
+class JSKitPebble : public QObject
+{
+    Q_OBJECT
+    QLoggingCategory l;
+
+public:
+    explicit JSKitPebble(const AppInfo &appInfo, JSKitManager *mgr, QObject *parent=0);
+
+    Q_INVOKABLE void addEventListener(const QString &type, QJSValue function);
+    Q_INVOKABLE void removeEventListener(const QString &type, QJSValue function);
+
+    Q_INVOKABLE void showSimpleNotificationOnPebble(const QString &title, const QString &body);
+    Q_INVOKABLE uint sendAppMessage(QJSValue message, QJSValue callbackForAck = QJSValue(), QJSValue callbackForNack = QJSValue());
+
+    Q_INVOKABLE void getTimelineToken(QJSValue successCallback = QJSValue(), QJSValue failureCallback = QJSValue());
+    Q_INVOKABLE void timelineSubscribe(const QString &topic, QJSValue successCallback = QJSValue(), QJSValue failureCallback = QJSValue());
+    Q_INVOKABLE void timelineUnsubscribe(const QString &topic, QJSValue successCallback = QJSValue(), QJSValue failureCallback = QJSValue());
+    Q_INVOKABLE void timelineSubscriptions(QJSValue successCallback = QJSValue(), QJSValue failureCallback = QJSValue());
+
+    Q_INVOKABLE QString getAccountToken() const;
+    Q_INVOKABLE QString getWatchToken() const;
+    Q_INVOKABLE QJSValue getActiveWatchInfo() const;
+
+    Q_INVOKABLE void openURL(const QUrl &url);
+
+    Q_INVOKABLE QJSValue createXMLHttpRequest();
+
+    void invokeCallbacks(const QString &type, const QJSValueList &args = QJSValueList());
+
+private:
+    QJSValue buildAckEventObject(uint transaction, const QString &message = QString()) const;
+
+private:
+    AppInfo m_appInfo;
+    JSKitManager *m_mgr;
+    QHash<QString, QList<QJSValue>> m_listeners;
+};
+
+#endif // JSKITPEBBLE_P_H

=== added file 'rockworkd/libpebble/jskit/jskitperformance.cpp'
--- rockworkd/libpebble/jskit/jskitperformance.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitperformance.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,13 @@
+#include "jskitperformance.h"
+
+JSKitPerformance::JSKitPerformance(QObject *parent) :
+    QObject(parent),
+    m_start(QTime::currentTime())
+{
+}
+
+int JSKitPerformance::now()
+{
+    QTime now = QTime::currentTime();
+    return m_start.msecsTo(now);
+}

=== added file 'rockworkd/libpebble/jskit/jskitperformance.h'
--- rockworkd/libpebble/jskit/jskitperformance.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitperformance.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,20 @@
+#ifndef JSKITPERFORMANCE_H
+#define JSKITPERFORMANCE_H
+
+#include <QObject>
+#include <QTime>
+
+class JSKitPerformance : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit JSKitPerformance(QObject *parent=0);
+
+    Q_INVOKABLE int now();
+
+private:
+    QTime m_start;
+};
+
+#endif // JSKITPERFORMANCE_H

=== added file 'rockworkd/libpebble/jskit/jskitsetup.js'
--- rockworkd/libpebble/jskit/jskitsetup.js	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitsetup.js	2016-02-06 06:08:05 +0000
@@ -0,0 +1,191 @@
+//Borrowed from https://github.com/pebble/pypkjs/blob/master/pypkjs/javascript/runtime.py#L17
+_jskit.make_proxies = function(proxy, origin, names) {
+    names.forEach(function(name) {
+        proxy[name] = eval("(function " + name + "() { return origin[name].apply(origin, arguments); })");
+    });
+
+    return proxy;
+}
+
+_jskit.make_properties = function(proxy, origin, names) {
+    names.forEach(function(name) {
+        Object.defineProperty(proxy, name, {
+            configurable: false,
+            enumerable: true,
+            get: function() {
+                return origin[name];
+            },
+            set: function(value) {
+                origin[name] = value;
+            }
+        });
+    });
+
+    return proxy;
+}
+
+Pebble = new (function() {
+    _jskit.make_proxies(this, _jskit.pebble,
+        ['sendAppMessage', 'showSimpleNotificationOnPebble', 'getAccountToken', 'getWatchToken',
+        'addEventListener', 'removeEventListener', 'openURL', 'getTimelineToken', 'timelineSubscribe',
+        'timelineUnsubscribe', 'timelineSubscriptions', 'getActiveWatchInfo']
+    );
+})();
+
+performance = new (function() {
+    _jskit.make_proxies(this, _jskit.performance, ['now']);
+})();
+
+function XMLHttpRequest() {
+    var xhr = _jskit.pebble.createXMLHttpRequest();
+    _jskit.make_proxies(this, xhr,
+        ['open', 'setRequestHeader', 'overrideMimeType', 'send', 'getResponseHeader',
+        'getAllResponseHeaders', 'abort', 'addEventListener', 'removeEventListener']);
+    _jskit.make_properties(this, xhr,
+        ['readyState', 'response', 'responseText', 'responseType', 'status',
+        'statusText', 'timeout', 'onreadystatechange', 'ontimeout', 'onload',
+        'onloadstart', 'onloadend', 'onprogress', 'onerror', 'onabort']);
+
+    this.UNSENT = 0;
+    this.OPENED = 1;
+    this.HEADERS_RECEIVED = 2;
+    this.LOADING = 3;
+    this.DONE = 4;
+}
+
+function setInterval(func, time) {
+    return _jskit.timer.setInterval(func, time);
+}
+
+function clearInterval(id) {
+    _jskit.timer.clearInterval(id);
+}
+
+function setTimeout(func, time) {
+    return _jskit.timer.setTimeout(func, time);
+}
+
+function clearTimeout(id) {
+    _jskit.timer.clearTimeout(id);
+}
+
+navigator.geolocation = new (function() {
+    _jskit.make_proxies(this, _jskit.geolocation,
+        ['getCurrentPosition', 'watchPosition', 'clearWatch']
+    );
+})();
+
+console = new (function() {
+    _jskit.make_proxies(this, _jskit.console,
+        ['log', 'warn', 'error', 'info']
+    );
+})();
+
+/*localStorage = new (function() {
+    _jskit.make_proxies(this, _jskit.localstorage,
+        ['clear', 'getItem', 'setItem', 'removeItem', 'key']
+    );
+
+    _jskit.make_properties(this, _jskit.localstorage,
+        ['length']
+    );
+})();*/
+
+//It appears that Proxy is not available since Qt is using Javascript v5
+/*(function() {
+    var proxy = _jskit.make_proxies({}, _jskit.localstorage, ['set', 'has', 'deleteProperty', 'keys', 'enumerate']);
+    var methods = _jskit.make_proxies({}, _jskit.localstorage, ['clear', 'getItem', 'setItem', 'removeItem', 'key']);
+    proxy.get = function get(p, name) { return methods[name] || _jskit.localstorage.get(p, name); }
+    this.localStorage = Proxy.create(proxy);
+})();*/
+
+//inspired by https://developer.mozilla.org/en-US/docs/Web/API/Storage/LocalStorage
+Object.defineProperty(window, "localStorage", new (function () {
+    var storage = {};
+    Object.defineProperty(storage, "getItem", {
+        value: function (key) {
+            return (key && storage[key]) ? storage[key] : null;
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+
+    Object.defineProperty(storage, "key", {
+        value: function (index) {
+            return Object.keys(storage)[index];
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+
+    Object.defineProperty(storage, "setItem", {
+        value: function (key, value) {
+            if (key) {
+                _jskit.localstorage.setItem(key, value);
+                storage[key] = (value && value.toString) ? value.toString() : value;
+                return true;
+            }
+            else {
+                return false;
+            }
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+
+    Object.defineProperty(storage, "length", {
+        get: function () {
+            return Object.keys(storage).length;
+        },
+        configurable: false,
+        enumerable: false
+    });
+
+    Object.defineProperty(storage, "removeItem", {
+        value: function (key) {
+            if (key && storage[key]) {
+                _jskit.localstorage.removeItem(key);
+                delete storage[key];
+
+                return true;
+            }
+            else {
+                return false;
+            }
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+
+    Object.defineProperty(storage, "clear", {
+        value: function (key) {
+            for (var key in storage) {
+                storage.removeItem(key);
+            }
+
+            return true;
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+
+    this.get = function () {
+        return storage;
+    };
+
+    this.configurable = false;
+    this.enumerable = true;
+})());
+
+(function() {
+    var keys = _jskit.localstorage.keys();
+    for (var index in keys) {
+        var value = _jskit.localstorage.getItem(keys[index]);
+        localStorage.setItem(keys[index], value);
+    }
+})();

=== added file 'rockworkd/libpebble/jskit/jskittimer.cpp'
--- rockworkd/libpebble/jskit/jskittimer.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskittimer.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,77 @@
+#include <QTimerEvent>
+
+#include "jskittimer.h"
+
+JSKitTimer::JSKitTimer(QJSEngine *engine) :
+    QObject(engine),
+    l(metaObject()->className()),
+    m_engine(engine)
+{
+}
+
+int JSKitTimer::setInterval(QJSValue expression, int delay) //TODO support optional parameters
+{
+    qCDebug(l) << "Setting interval for " << delay << "ms: " << expression.toString();
+
+    if (expression.isString() || expression.isCallable()) {
+        int timerId = startTimer(delay);
+        m_intervals.insert(timerId, expression);
+
+        return timerId;
+    }
+
+    return -1;
+}
+
+void JSKitTimer::clearInterval(int timerId)
+{
+    qCDebug(l) << "Killing interval " << timerId ;
+    killTimer(timerId);
+    m_intervals.remove(timerId);
+}
+
+int JSKitTimer::setTimeout(QJSValue expression, int delay) //TODO support optional parameters
+{
+    qCDebug(l) << "Setting timeout for " << delay << "ms: " << expression.toString();
+
+    if (expression.isString() || expression.isCallable()) {
+        int timerId = startTimer(delay);
+        m_timeouts.insert(timerId, expression);
+
+        return timerId;
+    }
+
+    return -1;
+}
+
+void JSKitTimer::clearTimeout(int timerId)
+{
+    qCDebug(l) << "Killing timeout " << timerId ;
+    killTimer(timerId);
+    m_timeouts.remove(timerId);
+}
+
+void JSKitTimer::timerEvent(QTimerEvent *event)
+{
+    int id = event->timerId();
+
+    QJSValue expression; // find in either intervals or timeouts
+    if (m_intervals.contains(id)) {
+        expression = m_intervals.value(id);
+    } else if (m_timeouts.contains(id)) {
+        expression = m_timeouts.value(id);
+        killTimer(id); // timeouts don't repeat
+    } else {
+        qCWarning(l) << "Unknown timer event";
+        killTimer(id); // interval nor timeout exist. kill the timer
+
+        return;
+    }
+
+    if (expression.isCallable()) { // call it if it's a function
+        expression.call().toString();
+    }
+    else { // otherwise evaluate it
+        m_engine->evaluate(expression.toString());
+    }
+}

=== added file 'rockworkd/libpebble/jskit/jskittimer.h'
--- rockworkd/libpebble/jskit/jskittimer.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskittimer.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,31 @@
+#ifndef JSKITTIMER_P_H
+#define JSKITTIMER_P_H
+
+#include <QLoggingCategory>
+#include <QJSValue>
+#include <QJSEngine>
+
+class JSKitTimer : public QObject
+{
+    Q_OBJECT
+    QLoggingCategory l;
+
+public:
+    explicit JSKitTimer(QJSEngine *engine);
+
+    Q_INVOKABLE int setInterval(QJSValue expression, int delay);
+    Q_INVOKABLE void clearInterval(int timerId);
+
+    Q_INVOKABLE int setTimeout(QJSValue expression, int delay);
+    Q_INVOKABLE void clearTimeout(int timerId);
+
+protected:
+    void timerEvent(QTimerEvent *event);
+
+private:
+    QJSEngine *m_engine;
+    QHash<int, QJSValue> m_intervals;
+    QHash<int, QJSValue> m_timeouts;
+};
+
+#endif // JSKITTIMER_P_H

=== added file 'rockworkd/libpebble/jskit/jskitxmlhttprequest.cpp'
--- rockworkd/libpebble/jskit/jskitxmlhttprequest.cpp	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitxmlhttprequest.cpp	2016-02-06 06:08:05 +0000
@@ -0,0 +1,288 @@
+#include <QBuffer>
+#include <QAuthenticator>
+
+#include "jskitxmlhttprequest.h"
+#include "jskitmanager.h"
+
+JSKitXMLHttpRequest::JSKitXMLHttpRequest(QJSEngine *engine) :
+    QObject(engine),
+    l(metaObject()->className()),
+    m_engine(engine),
+    m_net(new QNetworkAccessManager(this)),
+    m_timeout(0),
+    m_reply(0)
+{
+    connect(m_net, &QNetworkAccessManager::authenticationRequired,
+            this, &JSKitXMLHttpRequest::handleAuthenticationRequired);
+}
+
+void JSKitXMLHttpRequest::open(const QString &method, const QString &url, bool async, const QString &username, const QString &password)
+{
+    if (m_reply) {
+        m_reply->deleteLater();
+        m_reply = 0;
+    }
+
+    m_username = username;
+    m_password = password;
+    m_request = QNetworkRequest(QUrl(url));
+    m_verb = method;
+    Q_UNUSED(async);
+
+    qCDebug(l) << "opened to URL" << m_request.url().toString();
+}
+
+void JSKitXMLHttpRequest::setRequestHeader(const QString &header, const QString &value)
+{
+    qCDebug(l) << "setRequestHeader" << header << value;
+    m_request.setRawHeader(header.toLatin1(), value.toLatin1());
+}
+
+void JSKitXMLHttpRequest::send(const QJSValue &data)
+{
+    QByteArray byteData;
+
+    if (data.isUndefined() || data.isNull()) {
+        // Do nothing, byteData is empty.
+    } else if (data.isString()) {
+        byteData = data.toString().toUtf8();
+    } else if (data.isObject()) {
+        if (data.hasProperty("byteLength")) {
+            // Looks like an ArrayView or an ArrayBufferView!
+            QJSValue buffer = data.property("buffer");
+            if (buffer.isUndefined()) {
+                // We must assume we've been passed an ArrayBuffer directly
+                buffer = data;
+            }
+
+            QJSValue array = data.property("_bytes");
+            int byteLength = data.property("byteLength").toInt();
+
+            if (array.isArray()) {
+                byteData.reserve(byteLength);
+
+                for (int i = 0; i < byteLength; i++) {
+                    byteData.append(array.property(i).toInt());
+                }
+
+                qCDebug(l) << "passed an ArrayBufferView of" << byteData.length() << "bytes";
+            } else {
+                qCWarning(l) << "passed an unknown/invalid ArrayBuffer" << data.toString();
+            }
+        } else {
+            qCWarning(l) << "passed an unknown object" << data.toString();
+        }
+
+    }
+
+    QBuffer *buffer;
+    if (!byteData.isEmpty()) {
+        buffer = new QBuffer;
+        buffer->setData(byteData);
+    } else {
+        buffer = 0;
+    }
+
+    qCDebug(l) << "sending" << m_verb << "to" << m_request.url() << "with" << QString::fromUtf8(byteData);
+    m_reply = m_net->sendCustomRequest(m_request, m_verb.toLatin1(), buffer);
+
+    connect(m_reply, &QNetworkReply::finished,
+            this, &JSKitXMLHttpRequest::handleReplyFinished);
+    connect(m_reply, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
+            this, &JSKitXMLHttpRequest::handleReplyError);
+
+    if (buffer) {
+        // So that it gets deleted alongside the reply object.
+        buffer->setParent(m_reply);
+    }
+}
+
+void JSKitXMLHttpRequest::abort()
+{
+    if (m_reply) {
+        m_reply->deleteLater();
+        m_reply = 0;
+    }
+}
+
+QJSValue JSKitXMLHttpRequest::onload() const
+{
+    return m_onload;
+}
+
+void JSKitXMLHttpRequest::setOnload(const QJSValue &value)
+{
+    m_onload = value;
+}
+
+QJSValue JSKitXMLHttpRequest::ontimeout() const
+{
+    return m_ontimeout;
+}
+
+void JSKitXMLHttpRequest::setOntimeout(const QJSValue &value)
+{
+    m_ontimeout = value;
+}
+
+QJSValue JSKitXMLHttpRequest::onerror() const
+{
+    return m_onerror;
+}
+
+void JSKitXMLHttpRequest::setOnerror(const QJSValue &value)
+{
+    m_onerror = value;
+}
+
+uint JSKitXMLHttpRequest::readyState() const
+{
+    if (!m_reply) {
+        return UNSENT;
+    } else if (m_reply->isFinished()) {
+        return DONE;
+    } else {
+        return LOADING;
+    }
+}
+
+uint JSKitXMLHttpRequest::timeout() const
+{
+    return m_timeout;
+}
+
+void JSKitXMLHttpRequest::setTimeout(uint value)
+{
+    m_timeout = value;
+    // TODO Handle fetch in-progress.
+}
+
+uint JSKitXMLHttpRequest::status() const
+{
+    if (!m_reply || !m_reply->isFinished()) {
+        return 0;
+    } else {
+        return m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toUInt();
+    }
+}
+
+QString JSKitXMLHttpRequest::statusText() const
+{
+    if (!m_reply || !m_reply->isFinished()) {
+        return QString();
+    } else {
+        return m_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
+    }
+}
+
+QString JSKitXMLHttpRequest::responseType() const
+{
+    return m_responseType;
+}
+
+void JSKitXMLHttpRequest::setResponseType(const QString &type)
+{
+    qCDebug(l) << "response type set to" << type;
+    m_responseType = type;
+}
+
+QJSValue JSKitXMLHttpRequest::response() const
+{
+    if (m_responseType.isEmpty() || m_responseType == "text") {
+        return m_engine->toScriptValue(QString::fromUtf8(m_response));
+    } else if (m_responseType == "arraybuffer") {
+        QJSValue arrayBufferProto = m_engine->globalObject().property("ArrayBuffer").property("prototype");
+        QJSValue arrayBuf = m_engine->newObject();
+
+        if (!arrayBufferProto.isUndefined()) {
+            arrayBuf.setPrototype(arrayBufferProto);
+            arrayBuf.setProperty("byteLength", m_engine->toScriptValue<uint>(m_response.size()));
+
+            QJSValue array = m_engine->newArray(m_response.size());
+            for (int i = 0; i < m_response.size(); i++) {
+                array.setProperty(i, m_engine->toScriptValue<int>(m_response[i]));
+            }
+
+            arrayBuf.setProperty("_bytes", array);
+            qCDebug(l) << "returning ArrayBuffer of" << m_response.size() << "bytes";
+        } else {
+            qCWarning(l) << "Cannot find proto of ArrayBuffer";
+        }
+
+        return arrayBuf;
+    } else {
+        qCWarning(l) << "unsupported responseType:" << m_responseType;
+        return m_engine->toScriptValue<void*>(0);
+    }
+}
+
+QString JSKitXMLHttpRequest::responseText() const
+{
+    return QString::fromUtf8(m_response);
+}
+
+void JSKitXMLHttpRequest::handleReplyFinished()
+{
+    if (!m_reply) {
+        qCDebug(l) << "reply finished too late";
+        return;
+    }
+
+    m_response = m_reply->readAll();
+    qCDebug(l) << "reply finished, reply text:" << QString::fromUtf8(m_response);
+
+    emit readyStateChanged();
+    emit statusChanged();
+    emit statusTextChanged();
+    emit responseChanged();
+    emit responseTextChanged();
+
+    if (m_onload.isCallable()) {
+        qCDebug(l) << "going to call onload handler:" << m_onload.toString();
+
+        QJSValue result = m_onload.callWithInstance(m_engine->newQObject(this));
+        if (result.isError()) {
+            qCWarning(l) << "JS error on onload handler:" << JSKitManager::describeError(result);
+        }
+    } else {
+        qCDebug(l) << "No onload set";
+    }
+}
+
+void JSKitXMLHttpRequest::handleReplyError(QNetworkReply::NetworkError code)
+{
+    if (!m_reply) {
+        qCDebug(l) << "reply error too late";
+        return;
+    }
+
+    qCDebug(l) << "reply error" << code;
+
+    emit readyStateChanged();
+    emit statusChanged();
+    emit statusTextChanged();
+
+    if (m_onerror.isCallable()) {
+        qCDebug(l) << "going to call onerror handler:" << m_onload.toString();
+        QJSValue result = m_onerror.callWithInstance(m_engine->newQObject(this));
+        if (result.isError()) {
+            qCWarning(l) << "JS error on onerror handler:" << JSKitManager::describeError(result);
+        }
+    }
+}
+
+void JSKitXMLHttpRequest::handleAuthenticationRequired(QNetworkReply *reply, QAuthenticator *auth)
+{
+    if (m_reply == reply) {
+        qCDebug(l) << "authentication required";
+
+        if (!m_username.isEmpty() || !m_password.isEmpty()) {
+            qCDebug(l) << "using provided authorization:" << m_username;
+
+            auth->setUser(m_username);
+            auth->setPassword(m_password);
+        } else {
+            qCDebug(l) << "no username or password provided";
+        }
+    }
+}

=== added file 'rockworkd/libpebble/jskit/jskitxmlhttprequest.h'
--- rockworkd/libpebble/jskit/jskitxmlhttprequest.h	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/jskitxmlhttprequest.h	2016-02-06 06:08:05 +0000
@@ -0,0 +1,91 @@
+#ifndef JSKITXMLHTTPREQUEST_P_H
+#define JSKITXMLHTTPREQUEST_P_H
+
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QJSEngine>
+#include <QLoggingCategory>
+
+class JSKitXMLHttpRequest : public QObject
+{
+    Q_OBJECT
+    QLoggingCategory l;
+
+    Q_PROPERTY(QJSValue onload READ onload WRITE setOnload)
+    Q_PROPERTY(QJSValue ontimeout READ ontimeout WRITE setOntimeout)
+    Q_PROPERTY(QJSValue onerror READ onerror WRITE setOnerror)
+    Q_PROPERTY(uint readyState READ readyState NOTIFY readyStateChanged)
+    Q_PROPERTY(uint timeout READ timeout WRITE setTimeout)
+    Q_PROPERTY(uint status READ status NOTIFY statusChanged)
+    Q_PROPERTY(QString statusText READ statusText NOTIFY statusTextChanged)
+    Q_PROPERTY(QString responseType READ responseType WRITE setResponseType)
+    Q_PROPERTY(QJSValue response READ response NOTIFY responseChanged)
+    Q_PROPERTY(QString responseText READ responseText NOTIFY responseTextChanged)
+
+public:
+    explicit JSKitXMLHttpRequest(QJSEngine *engine);
+
+    enum ReadyStates {
+        UNSENT = 0,
+        OPENED = 1,
+        HEADERS_RECEIVED = 2,
+        LOADING = 3,
+        DONE = 4
+    };
+    Q_ENUMS(ReadyStates)
+
+    Q_INVOKABLE void open(const QString &method, const QString &url, bool async = false, const QString &username = QString(), const QString &password = QString());
+    Q_INVOKABLE void setRequestHeader(const QString &header, const QString &value);
+    Q_INVOKABLE void send(const QJSValue &data = QJSValue(QJSValue::NullValue));
+    Q_INVOKABLE void abort();
+
+    QJSValue onload() const;
+    void setOnload(const QJSValue &value);
+    QJSValue ontimeout() const;
+    void setOntimeout(const QJSValue &value);
+    QJSValue onerror() const;
+    void setOnerror(const QJSValue &value);
+
+    uint readyState() const;
+
+    uint timeout() const;
+    void setTimeout(uint value);
+
+    uint status() const;
+    QString statusText() const;
+
+    QString responseType() const;
+    void setResponseType(const QString& type);
+
+    QJSValue response() const;
+    QString responseText() const;
+
+signals:
+    void readyStateChanged();
+    void statusChanged();
+    void statusTextChanged();
+    void responseChanged();
+    void responseTextChanged();
+
+private slots:
+    void handleReplyFinished();
+    void handleReplyError(QNetworkReply::NetworkError code);
+    void handleAuthenticationRequired(QNetworkReply *reply, QAuthenticator *auth);
+
+private:
+    QJSEngine *m_engine;
+    QNetworkAccessManager *m_net;
+    QString m_verb;
+    uint m_timeout;
+    QString m_username;
+    QString m_password;
+    QNetworkRequest m_request;
+    QNetworkReply *m_reply;
+    QString m_responseType;
+    QByteArray m_response;
+    QJSValue m_onload;
+    QJSValue m_ontimeout;
+    QJSValue m_onerror;
+};
+
+#endif // JSKITXMLHTTPREQUEST_P_H

=== added file 'rockworkd/libpebble/jskit/typedarray.js'
--- rockworkd/libpebble/jskit/typedarray.js	1970-01-01 00:00:00 +0000
+++ rockworkd/libpebble/jskit/typedarray.js	2016-02-06 06:08:05 +0000
@@ -0,0 +1,1030 @@
+/*
+ Copyright (c) 2010, Linden Research, Inc.
+ Copyright (c) 2014, Joshua Bell
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ $/LicenseInfo$
+ */
+
+// Original can be found at:
+//   https://bitbucket.org/lindenlab/llsd
+// Modifications by Joshua Bell [e-mail]
+//   https://github.com/inexorabletash/polyfill
+
+// ES3/ES5 implementation of the Krhonos Typed Array Specification
+//   Ref: http://www.khronos.org/registry/typedarray/specs/latest/
+//   Date: 2011-02-01
+//
+// Variations:
+//  * Allows typed_array.get/set() as alias for subscripts (typed_array[])
+//  * Gradually migrating structure from Khronos spec to ES6 spec
+(function(global) {
+  'use strict';
+  var undefined = (void 0); // Paranoia
+
+  // Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
+  // create, and consume so much memory, that the browser appears frozen.
+  var MAX_ARRAY_LENGTH = 1e5;
+
+  // Approximations of internal ECMAScript conversion functions
+  function Type(v) {
+    switch(typeof v) {
+    case 'undefined': return 'undefined';
+    case 'boolean': return 'boolean';
+    case 'number': return 'number';
+    case 'string': return 'string';
+    default: return v === null ? 'null' : 'object';
+    }
+  }
+
+  // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
+  function Class(v) { return Object.prototype.toString.call(v).replace(/^\[object *|\]$/g, ''); }
+  function IsCallable(o) { return typeof o === 'function'; }
+  function ToObject(v) {
+    if (v === null || v === undefined) throw TypeError();
+    return Object(v);
+  }
+  function ToInt32(v) { return v >> 0; }
+  function ToUint32(v) { return v >>> 0; }
+
+  // Snapshot intrinsics
+  var LN2 = Math.LN2,
+      abs = Math.abs,
+      floor = Math.floor,
+      log = Math.log,
+      max = Math.max,
+      min = Math.min,
+      pow = Math.pow,
+      round = Math.round;
+
+  // emulate ES5 getter/setter API using legacy APIs
+  // http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx
+  // (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but
+  // note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless)
+
+  (function() {
+    var orig = Object.defineProperty;
+    var dom_only = !(function(){try{return Object.defineProperty({},'x',{});}catch(_){return false;}}());
+
+    if (!orig || dom_only) {
+      Object.defineProperty = function (o, prop, desc) {
+        // In IE8 try built-in implementation for defining properties on DOM prototypes.
+        if (orig)
+          try { return orig(o, prop, desc); } catch (_) {}
+        if (o !== Object(o))
+          throw TypeError('Object.defineProperty called on non-object');
+        if (Object.prototype.__defineGetter__ && ('get' in desc))
+          Object.prototype.__defineGetter__.call(o, prop, desc.get);
+        if (Object.prototype.__defineSetter__ && ('set' in desc))
+          Object.prototype.__defineSetter__.call(o, prop, desc.set);
+        if ('value' in desc)
+          o[prop] = desc.value;
+        return o;
+      };
+    }
+  }());
+
+  // ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value)
+  // for index in 0 ... obj.length
+  function makeArrayAccessors(obj) {
+    if (obj.length > MAX_ARRAY_LENGTH) throw RangeError('Array too large for polyfill');
+
+    function makeArrayAccessor(index) {
+      Object.defineProperty(obj, index, {
+        'get': function() { return obj._getter(index); },
+        'set': function(v) { obj._setter(index, v); },
+        enumerable: true,
+        configurable: false
+      });
+    }
+
+    var i;
+    for (i = 0; i < obj.length; i += 1) {
+      makeArrayAccessor(i);
+    }
+  }
+
+  // Internal conversion functions:
+  //    pack<Type>()   - take a number (interpreted as Type), output a byte array
+  //    unpack<Type>() - take a byte array, output a Type-like number
+
+  function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
+  function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }
+
+  function packI8(n) { return [n & 0xff]; }
+  function unpackI8(bytes) { return as_signed(bytes[0], 8); }
+
+  function packU8(n) { return [n & 0xff]; }
+  function unpackU8(bytes) { return as_unsigned(bytes[0], 8); }
+
+  function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; }
+
+  function packI16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
+  function unpackI16(bytes) { return as_signed(bytes[0] << 8 | bytes[1], 16); }
+
+  function packU16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
+  function unpackU16(bytes) { return as_unsigned(bytes[0] << 8 | bytes[1], 16); }
+
+  function packI32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
+  function unpackI32(bytes) { return as_signed(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
+
+  function packU32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
+  function unpackU32(bytes) { return as_unsigned(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
+
+  function packIEEE754(v, ebits, fbits) {
+
+    var bias = (1 << (ebits - 1)) - 1,
+        s, e, f, ln,
+        i, bits, str, bytes;
+
+    function roundToEven(n) {
+      var w = floor(n), f = n - w;
+      if (f < 0.5)
+        return w;
+      if (f > 0.5)
+        return w + 1;
+      return w % 2 ? w + 1 : w;
+    }
+
+    // Compute sign, exponent, fraction
+    if (v !== v) {
+      // NaN
+      // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
+      e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
+    } else if (v === Infinity || v === -Infinity) {
+      e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
+    } else if (v === 0) {
+      e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
+    } else {
+      s = v < 0;
+      v = abs(v);
+
+      if (v >= pow(2, 1 - bias)) {
+        e = min(floor(log(v) / LN2), 1023);
+        f = roundToEven(v / pow(2, e) * pow(2, fbits));
+        if (f / pow(2, fbits) >= 2) {
+          e = e + 1;
+          f = 1;
+        }
+        if (e > bias) {
+          // Overflow
+          e = (1 << ebits) - 1;
+          f = 0;
+        } else {
+          // Normalized
+          e = e + bias;
+          f = f - pow(2, fbits);
+        }
+      } else {
+        // Denormalized
+        e = 0;
+        f = roundToEven(v / pow(2, 1 - bias - fbits));
+      }
+    }
+
+    // Pack sign, exponent, fraction
+    bits = [];
+    for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
+    for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
+    bits.push(s ? 1 : 0);
+    bits.reverse();
+    str = bits.join('');
+
+    // Bits to bytes
+    bytes = [];
+    while (str.length) {
+      bytes.push(parseInt(str.substring(0, 8), 2));
+      str = str.substring(8);
+    }
+    return bytes;
+  }
+
+  function unpackIEEE754(bytes, ebits, fbits) {
+    // Bytes to bits
+    var bits = [], i, j, b, str,
+        bias, s, e, f;
+
+    for (i = bytes.length; i; i -= 1) {
+      b = bytes[i - 1];
+      for (j = 8; j; j -= 1) {
+        bits.push(b % 2 ? 1 : 0); b = b >> 1;
+      }
+    }
+    bits.reverse();
+    str = bits.join('');
+
+    // Unpack sign, exponent, fraction
+    bias = (1 << (ebits - 1)) - 1;
+    s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
+    e = parseInt(str.substring(1, 1 + ebits), 2);
+    f = parseInt(str.substring(1 + ebits), 2);
+
+    // Produce number
+    if (e === (1 << ebits) - 1) {
+      return f !== 0 ? NaN : s * Infinity;
+    } else if (e > 0) {
+      // Normalized
+      return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
+    } else if (f !== 0) {
+      // Denormalized
+      return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
+    } else {
+      return s < 0 ? -0 : 0;
+    }
+  }
+
+  function unpackF64(b) { return unpackIEEE754(b, 11, 52); }
+  function packF64(v) { return packIEEE754(v, 11, 52); }
+  function unpackF32(b) { return unpackIEEE754(b, 8, 23); }
+  function packF32(v) { return packIEEE754(v, 8, 23); }
+
+  //
+  // 3 The ArrayBuffer Type
+  //
+
+  (function() {
+
+    function ArrayBuffer(length) {
+      length = ToInt32(length);
+      if (length < 0) throw RangeError('ArrayBuffer size is not a small enough positive integer.');
+      Object.defineProperty(this, 'byteLength', {value: length});
+      Object.defineProperty(this, '_bytes', {value: Array(length)});
+
+      for (var i = 0; i < length; i += 1)
+        this._bytes[i] = 0;
+    }
+
+    global.ArrayBuffer = global.ArrayBuffer || ArrayBuffer;
+
+    //
+    // 5 The Typed Array View Types
+    //
+
+    function $TypedArray$() {
+
+      // %TypedArray% ( length )
+      if (!arguments.length || typeof arguments[0] !== 'object') {
+        return (function(length) {
+          length = ToInt32(length);
+          if (length < 0) throw RangeError('length is not a small enough positive integer.');
+          Object.defineProperty(this, 'length', {value: length});
+          Object.defineProperty(this, 'byteLength', {value: length * this.BYTES_PER_ELEMENT});
+          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(this.byteLength)});
+          Object.defineProperty(this, 'byteOffset', {value: 0});
+
+         }).apply(this, arguments);
+      }
+
+      // %TypedArray% ( typedArray )
+      if (arguments.length >= 1 &&
+          Type(arguments[0]) === 'object' &&
+          arguments[0] instanceof $TypedArray$) {
+        return (function(typedArray){
+          if (this.constructor !== typedArray.constructor) throw TypeError();
+
+          var byteLength = typedArray.length * this.BYTES_PER_ELEMENT;
+          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
+          Object.defineProperty(this, 'byteLength', {value: byteLength});
+          Object.defineProperty(this, 'byteOffset', {value: 0});
+          Object.defineProperty(this, 'length', {value: typedArray.length});
+
+          for (var i = 0; i < this.length; i += 1)
+            this._setter(i, typedArray._getter(i));
+
+        }).apply(this, arguments);
+      }
+
+      // %TypedArray% ( array )
+      if (arguments.length >= 1 &&
+          Type(arguments[0]) === 'object' &&
+          !(arguments[0] instanceof $TypedArray$) &&
+          !(arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
+        return (function(array) {
+
+          var byteLength = array.length * this.BYTES_PER_ELEMENT;
+          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
+          Object.defineProperty(this, 'byteLength', {value: byteLength});
+          Object.defineProperty(this, 'byteOffset', {value: 0});
+          Object.defineProperty(this, 'length', {value: array.length});
+
+          for (var i = 0; i < this.length; i += 1) {
+            var s = array[i];
+            this._setter(i, Number(s));
+          }
+        }).apply(this, arguments);
+      }
+
+      // %TypedArray% ( buffer, byteOffset=0, length=undefined )
+      if (arguments.length >= 1 &&
+          Type(arguments[0]) === 'object' &&
+          (arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
+        return (function(buffer, byteOffset, length) {
+
+          byteOffset = ToUint32(byteOffset);
+          if (byteOffset > buffer.byteLength)
+            throw RangeError('byteOffset out of range');
+
+          // The given byteOffset must be a multiple of the element
+          // size of the specific type, otherwise an exception is raised.
+          if (byteOffset % this.BYTES_PER_ELEMENT)
+            throw RangeError('buffer length minus the byteOffset is not a multiple of the element size.');
+
+          if (length === undefined) {
+            var byteLength = buffer.byteLength - byteOffset;
+            if (byteLength % this.BYTES_PER_ELEMENT)
+              throw RangeError('length of buffer minus byteOffset not a multiple of the element size');
+            length = byteLength / this.BYTES_PER_ELEMENT;
+
+          } else {
+            length = ToUint32(length);
+            byteLength = length * this.BYTES_PER_ELEMENT;
+          }
+
+          if ((byteOffset + byteLength) > buffer.byteLength)
+            throw RangeError('byteOffset and length reference an area beyond the end of the buffer');
+
+          Object.defineProperty(this, 'buffer', {value: buffer});
+          Object.defineProperty(this, 'byteLength', {value: byteLength});
+          Object.defineProperty(this, 'byteOffset', {value: byteOffset});
+          Object.defineProperty(this, 'length', {value: length});
+
+        }).apply(this, arguments);
+      }
+
+      // %TypedArray% ( all other argument combinations )
+      throw TypeError();
+    }
+
+    // Properties of the %TypedArray Instrinsic Object
+
+    // %TypedArray%.from ( source , mapfn=undefined, thisArg=undefined )
+    Object.defineProperty($TypedArray$, 'from', {value: function(iterable) {
+      return new this(iterable);
+    }});
+
+    // %TypedArray%.of ( ...items )
+    Object.defineProperty($TypedArray$, 'of', {value: function(/*...items*/) {
+      return new this(arguments);
+    }});
+
+    // %TypedArray%.prototype
+    var $TypedArrayPrototype$ = {};
+    $TypedArray$.prototype = $TypedArrayPrototype$;
+
+    // WebIDL: getter type (unsigned long index);
+    Object.defineProperty($TypedArray$.prototype, '_getter', {value: function(index) {
+      if (arguments.length < 1) throw SyntaxError('Not enough arguments');
+
+      index = ToUint32(index);
+      if (index >= this.length)
+        return undefined;
+
+      var bytes = [], i, o;
+      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
+           i < this.BYTES_PER_ELEMENT;
+           i += 1, o += 1) {
+        bytes.push(this.buffer._bytes[o]);
+      }
+      return this._unpack(bytes);
+    }});
+
+    // NONSTANDARD: convenience alias for getter: type get(unsigned long index);
+    Object.defineProperty($TypedArray$.prototype, 'get', {value: $TypedArray$.prototype._getter});
+
+    // WebIDL: setter void (unsigned long index, type value);
+    Object.defineProperty($TypedArray$.prototype, '_setter', {value: function(index, value) {
+      if (arguments.length < 2) throw SyntaxError('Not enough arguments');
+
+      index = ToUint32(index);
+      if (index >= this.length)
+        return;
+
+      var bytes = this._pack(value), i, o;
+      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
+           i < this.BYTES_PER_ELEMENT;
+           i += 1, o += 1) {
+        this.buffer._bytes[o] = bytes[i];
+      }
+    }});
+
+    // get %TypedArray%.prototype.buffer
+    // get %TypedArray%.prototype.byteLength
+    // get %TypedArray%.prototype.byteOffset
+    // -- applied directly to the object in the constructor
+
+    // %TypedArray%.prototype.constructor
+    Object.defineProperty($TypedArray$.prototype, 'constructor', {value: $TypedArray$});
+
+    // %TypedArray%.prototype.copyWithin (target, start, end = this.length )
+    Object.defineProperty($TypedArray$.prototype, 'copyWithin', {value: function(target, start) {
+      var end = arguments[2];
+
+      var o = ToObject(this);
+      var lenVal = o.length;
+      var len = ToUint32(lenVal);
+      len = max(len, 0);
+      var relativeTarget = ToInt32(target);
+      var to;
+      if (relativeTarget < 0)
+        to = max(len + relativeTarget, 0);
+      else
+        to = min(relativeTarget, len);
+      var relativeStart = ToInt32(start);
+      var from;
+      if (relativeStart < 0)
+        from = max(len + relativeStart, 0);
+      else
+        from = min(relativeStart, len);
+      var relativeEnd;
+      if (end === undefined)
+        relativeEnd = len;
+      else
+        relativeEnd = ToInt32(end);
+      var final;
+      if (relativeEnd < 0)
+        final = max(len + relativeEnd, 0);
+      else
+        final = min(relativeEnd, len);
+      var count = min(final - from, len - to);
+      var direction;
+      if (from < to && to < from + count) {
+        direction = -1;
+        from = from + count - 1;
+        to = to + count - 1;
+      } else {
+        direction = 1;
+      }
+      while (count > 0) {
+        o._setter(to, o._getter(from));
+        from = from + direction;
+        to = to + direction;
+        count = count - 1;
+      }
+      return o;
+    }});
+
+    // %TypedArray%.prototype.entries ( )
+    // -- defined in es6.js to shim browsers w/ native TypedArrays
+
+    // %TypedArray%.prototype.every ( callbackfn, thisArg = undefined )
+    Object.defineProperty($TypedArray$.prototype, 'every', {value: function(callbackfn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (!IsCallable(callbackfn)) throw TypeError();
+      var thisArg = arguments[1];
+      for (var i = 0; i < len; i++) {
+        if (!callbackfn.call(thisArg, t._getter(i), i, t))
+          return false;
+      }
+      return true;
+    }});
+
+    // %TypedArray%.prototype.fill (value, start = 0, end = this.length )
+    Object.defineProperty($TypedArray$.prototype, 'fill', {value: function(value) {
+      var start = arguments[1],
+          end = arguments[2];
+
+      var o = ToObject(this);
+      var lenVal = o.length;
+      var len = ToUint32(lenVal);
+      len = max(len, 0);
+      var relativeStart = ToInt32(start);
+      var k;
+      if (relativeStart < 0)
+        k = max((len + relativeStart), 0);
+      else
+        k = min(relativeStart, len);
+      var relativeEnd;
+      if (end === undefined)
+        relativeEnd = len;
+      else
+        relativeEnd = ToInt32(end);
+      var final;
+      if (relativeEnd < 0)
+        final = max((len + relativeEnd), 0);
+      else
+        final = min(relativeEnd, len);
+      while (k < final) {
+        o._setter(k, value);
+        k += 1;
+      }
+      return o;
+    }});
+
+    // %TypedArray%.prototype.filter ( callbackfn, thisArg = undefined )
+    Object.defineProperty($TypedArray$.prototype, 'filter', {value: function(callbackfn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (!IsCallable(callbackfn)) throw TypeError();
+      var res = [];
+      var thisp = arguments[1];
+      for (var i = 0; i < len; i++) {
+        var val = t._getter(i); // in case fun mutates this
+        if (callbackfn.call(thisp, val, i, t))
+          res.push(val);
+      }
+      return new this.constructor(res);
+    }});
+
+    // %TypedArray%.prototype.find (predicate, thisArg = undefined)
+    Object.defineProperty($TypedArray$.prototype, 'find', {value: function(predicate) {
+      var o = ToObject(this);
+      var lenValue = o.length;
+      var len = ToUint32(lenValue);
+      if (!IsCallable(predicate)) throw TypeError();
+      var t = arguments.length > 1 ? arguments[1] : undefined;
+      var k = 0;
+      while (k < len) {
+        var kValue = o._getter(k);
+        var testResult = predicate.call(t, kValue, k, o);
+        if (Boolean(testResult))
+          return kValue;
+        ++k;
+      }
+      return undefined;
+    }});
+
+    // %TypedArray%.prototype.findIndex ( predicate, thisArg = undefined )
+    Object.defineProperty($TypedArray$.prototype, 'findIndex', {value: function(predicate) {
+      var o = ToObject(this);
+      var lenValue = o.length;
+      var len = ToUint32(lenValue);
+      if (!IsCallable(predicate)) throw TypeError();
+      var t = arguments.length > 1 ? arguments[1] : undefined;
+      var k = 0;
+      while (k < len) {
+        var kValue = o._getter(k);
+        var testResult = predicate.call(t, kValue, k, o);
+        if (Boolean(testResult))
+          return k;
+        ++k;
+      }
+      return -1;
+    }});
+
+    // %TypedArray%.prototype.forEach ( callbackfn, thisArg = undefined )
+    Object.defineProperty($TypedArray$.prototype, 'forEach', {value: function(callbackfn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (!IsCallable(callbackfn)) throw TypeError();
+      var thisp = arguments[1];
+      for (var i = 0; i < len; i++)
+        callbackfn.call(thisp, t._getter(i), i, t);
+    }});
+
+    // %TypedArray%.prototype.indexOf (searchElement, fromIndex = 0 )
+    Object.defineProperty($TypedArray$.prototype, 'indexOf', {value: function(searchElement) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (len === 0) return -1;
+      var n = 0;
+      if (arguments.length > 0) {
+        n = Number(arguments[1]);
+        if (n !== n) {
+          n = 0;
+        } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
+          n = (n > 0 || -1) * floor(abs(n));
+        }
+      }
+      if (n >= len) return -1;
+      var k = n >= 0 ? n : max(len - abs(n), 0);
+      for (; k < len; k++) {
+        if (t._getter(k) === searchElement) {
+          return k;
+        }
+      }
+      return -1;
+    }});
+
+    // %TypedArray%.prototype.join ( separator )
+    Object.defineProperty($TypedArray$.prototype, 'join', {value: function(separator) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      var tmp = Array(len);
+      for (var i = 0; i < len; ++i)
+        tmp[i] = t._getter(i);
+      return tmp.join(separator === undefined ? ',' : separator); // Hack for IE7
+    }});
+
+    // %TypedArray%.prototype.keys ( )
+    // -- defined in es6.js to shim browsers w/ native TypedArrays
+
+    // %TypedArray%.prototype.lastIndexOf ( searchElement, fromIndex = this.length-1 )
+    Object.defineProperty($TypedArray$.prototype, 'lastIndexOf', {value: function(searchElement) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (len === 0) return -1;
+      var n = len;
+      if (arguments.length > 1) {
+        n = Number(arguments[1]);
+        if (n !== n) {
+          n = 0;
+        } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
+          n = (n > 0 || -1) * floor(abs(n));
+        }
+      }
+      var k = n >= 0 ? min(n, len - 1) : len - abs(n);
+      for (; k >= 0; k--) {
+        if (t._getter(k) === searchElement)
+          return k;
+      }
+      return -1;
+    }});
+
+    // get %TypedArray%.prototype.length
+    // -- applied directly to the object in the constructor
+
+    // %TypedArray%.prototype.map ( callbackfn, thisArg = undefined )
+    Object.defineProperty($TypedArray$.prototype, 'map', {value: function(callbackfn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (!IsCallable(callbackfn)) throw TypeError();
+      var res = []; res.length = len;
+      var thisp = arguments[1];
+      for (var i = 0; i < len; i++)
+        res[i] = callbackfn.call(thisp, t._getter(i), i, t);
+      return new this.constructor(res);
+    }});
+
+    // %TypedArray%.prototype.reduce ( callbackfn [, initialValue] )
+    Object.defineProperty($TypedArray$.prototype, 'reduce', {value: function(callbackfn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (!IsCallable(callbackfn)) throw TypeError();
+      // no value to return if no initial value and an empty array
+      if (len === 0 && arguments.length === 1) throw TypeError();
+      var k = 0;
+      var accumulator;
+      if (arguments.length >= 2) {
+        accumulator = arguments[1];
+      } else {
+        accumulator = t._getter(k++);
+      }
+      while (k < len) {
+        accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t);
+        k++;
+      }
+      return accumulator;
+    }});
+
+    // %TypedArray%.prototype.reduceRight ( callbackfn [, initialValue] )
+    Object.defineProperty($TypedArray$.prototype, 'reduceRight', {value: function(callbackfn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (!IsCallable(callbackfn)) throw TypeError();
+      // no value to return if no initial value, empty array
+      if (len === 0 && arguments.length === 1) throw TypeError();
+      var k = len - 1;
+      var accumulator;
+      if (arguments.length >= 2) {
+        accumulator = arguments[1];
+      } else {
+        accumulator = t._getter(k--);
+      }
+      while (k >= 0) {
+        accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t);
+        k--;
+      }
+      return accumulator;
+    }});
+
+    // %TypedArray%.prototype.reverse ( )
+    Object.defineProperty($TypedArray$.prototype, 'reverse', {value: function() {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      var half = floor(len / 2);
+      for (var i = 0, j = len - 1; i < half; ++i, --j) {
+        var tmp = t._getter(i);
+        t._setter(i, t._getter(j));
+        t._setter(j, tmp);
+      }
+      return t;
+    }});
+
+    // %TypedArray%.prototype.set(array, offset = 0 )
+    // %TypedArray%.prototype.set(typedArray, offset = 0 )
+    // WebIDL: void set(TypedArray array, optional unsigned long offset);
+    // WebIDL: void set(sequence<type> array, optional unsigned long offset);
+    Object.defineProperty($TypedArray$.prototype, 'set', {value: function(index, value) {
+      if (arguments.length < 1) throw SyntaxError('Not enough arguments');
+      var array, sequence, offset, len,
+          i, s, d,
+          byteOffset, byteLength, tmp;
+
+      if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) {
+        // void set(TypedArray array, optional unsigned long offset);
+        array = arguments[0];
+        offset = ToUint32(arguments[1]);
+
+        if (offset + array.length > this.length) {
+          throw RangeError('Offset plus length of array is out of range');
+        }
+
+        byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT;
+        byteLength = array.length * this.BYTES_PER_ELEMENT;
+
+        if (array.buffer === this.buffer) {
+          tmp = [];
+          for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) {
+            tmp[i] = array.buffer._bytes[s];
+          }
+          for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) {
+            this.buffer._bytes[d] = tmp[i];
+          }
+        } else {
+          for (i = 0, s = array.byteOffset, d = byteOffset;
+               i < byteLength; i += 1, s += 1, d += 1) {
+            this.buffer._bytes[d] = array.buffer._bytes[s];
+          }
+        }
+      } else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') {
+        // void set(sequence<type> array, optional unsigned long offset);
+        sequence = arguments[0];
+        len = ToUint32(sequence.length);
+        offset = ToUint32(arguments[1]);
+
+        if (offset + len > this.length) {
+          throw RangeError('Offset plus length of array is out of range');
+        }
+
+        for (i = 0; i < len; i += 1) {
+          s = sequence[i];
+          this._setter(offset + i, Number(s));
+        }
+      } else {
+        throw TypeError('Unexpected argument type(s)');
+      }
+    }});
+
+    // %TypedArray%.prototype.slice ( start, end )
+    Object.defineProperty($TypedArray$.prototype, 'slice', {value: function(start, end) {
+      var o = ToObject(this);
+      var lenVal = o.length;
+      var len = ToUint32(lenVal);
+      var relativeStart = ToInt32(start);
+      var k = (relativeStart < 0) ? max(len + relativeStart, 0) : min(relativeStart, len);
+      var relativeEnd = (end === undefined) ? len : ToInt32(end);
+      var final = (relativeEnd < 0) ? max(len + relativeEnd, 0) : min(relativeEnd, len);
+      var count = final - k;
+      var c = o.constructor;
+      var a = new c(count);
+      var n = 0;
+      while (k < final) {
+        var kValue = o._getter(k);
+        a._setter(n, kValue);
+        ++k;
+        ++n;
+      }
+      return a;
+    }});
+
+    // %TypedArray%.prototype.some ( callbackfn, thisArg = undefined )
+    Object.defineProperty($TypedArray$.prototype, 'some', {value: function(callbackfn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      if (!IsCallable(callbackfn)) throw TypeError();
+      var thisp = arguments[1];
+      for (var i = 0; i < len; i++) {
+        if (callbackfn.call(thisp, t._getter(i), i, t)) {
+          return true;
+        }
+      }
+      return false;
+    }});
+
+    // %TypedArray%.prototype.sort ( comparefn )
+    Object.defineProperty($TypedArray$.prototype, 'sort', {value: function(comparefn) {
+      if (this === undefined || this === null) throw TypeError();
+      var t = Object(this);
+      var len = ToUint32(t.length);
+      var tmp = Array(len);
+      for (var i = 0; i < len; ++i)
+        tmp[i] = t._getter(i);
+      if (comparefn) tmp.sort(comparefn); else tmp.sort(); // Hack for IE8/9
+      for (i = 0; i < len; ++i)
+        t._setter(i, tmp[i]);
+      return t;
+    }});
+
+    // %TypedArray%.prototype.subarray(begin = 0, end = this.length )
+    // WebIDL: TypedArray subarray(long begin, optional long end);
+    Object.defineProperty($TypedArray$.prototype, 'subarray', {value: function(start, end) {
+      function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }
+
+      start = ToInt32(start);
+      end = ToInt32(end);
+
+      if (arguments.length < 1) { start = 0; }
+      if (arguments.length < 2) { end = this.length; }
+
+      if (start < 0) { start = this.length + start; }
+      if (end < 0) { end = this.length + end; }
+
+      start = clamp(start, 0, this.length);
+      end = clamp(end, 0, this.length);
+
+      var len = end - start;
+      if (len < 0) {
+        len = 0;
+      }
+
+      return new this.constructor(
+        this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len);
+    }});
+
+    // %TypedArray%.prototype.toLocaleString ( )
+    // %TypedArray%.prototype.toString ( )
+    // %TypedArray%.prototype.values ( )
+    // %TypedArray%.prototype [ @@iterator ] ( )
+    // get %TypedArray%.prototype [ @@toStringTag ]
+    // -- defined in es6.js to shim browsers w/ native TypedArrays
+
+    function makeTypedArray(elementSize, pack, unpack) {
+      // Each TypedArray type requires a distinct constructor instance with
+      // identical logic, which this produces.
+      var TypedArray = function() {
+        Object.defineProperty(this, 'constructor', {value: TypedArray});
+        $TypedArray$.apply(this, arguments);
+        makeArrayAccessors(this);
+      };
+      if ('__proto__' in TypedArray) {
+        TypedArray.__proto__ = $TypedArray$;
+      } else {
+        TypedArray.from = $TypedArray$.from;
+        TypedArray.of = $TypedArray$.of;
+      }
+
+      TypedArray.BYTES_PER_ELEMENT = elementSize;
+
+      var TypedArrayPrototype = function() {};
+      TypedArrayPrototype.prototype = $TypedArrayPrototype$;
+
+      TypedArray.prototype = new TypedArrayPrototype();
+
+      Object.defineProperty(TypedArray.prototype, 'BYTES_PER_ELEMENT', {value: elementSize});
+      Object.defineProperty(TypedArray.prototype, '_pack', {value: pack});
+      Object.defineProperty(TypedArray.prototype, '_unpack', {value: unpack});
+
+      return TypedArray;
+    }
+
+    var Int8Array = makeTypedArray(1, packI8, unpackI8);
+    var Uint8Array = makeTypedArray(1, packU8, unpackU8);
+    var Uint8ClampedArray = makeTypedArray(1, packU8Clamped, unpackU8);
+    var Int16Array = makeTypedArray(2, packI16, unpackI16);
+    var Uint16Array = makeTypedArray(2, packU16, unpackU16);
+    var Int32Array = makeTypedArray(4, packI32, unpackI32);
+    var Uint32Array = makeTypedArray(4, packU32, unpackU32);
+    var Float32Array = makeTypedArray(4, packF32, unpackF32);
+    var Float64Array = makeTypedArray(8, packF64, unpackF64);
+
+    global.Int8Array = global.Int8Array || Int8Array;
+    global.Uint8Array = global.Uint8Array || Uint8Array;
+    global.Uint8ClampedArray = global.Uint8ClampedArray || Uint8ClampedArray;
+    global.Int16Array = global.Int16Array || Int16Array;
+    global.Uint16Array = global.Uint16Array || Uint16Array;
+    global.Int32Array = global.Int32Array || Int32Array;
+    global.Uint32Array = global.Uint32Array || Uint32Array;
+    global.Float32Array = global.Float32Array || Float32Array;
+    global.Float64Array = global.Float64Array || Float64Array;
+  }());
+
+  //
+  // 6 The DataView View Type
+  //
+
+  (function() {
+    function r(array, index) {
+      return IsCallable(array.get) ? array.get(index) : array[index];
+    }
+
+    var IS_BIG_ENDIAN = (function() {
+      var u16array = new Uint16Array([0x1234]),
+          u8array = new Uint8Array(u16array.buffer);
+      return r(u8array, 0) === 0x12;
+    }());
+
+    // DataView(buffer, byteOffset=0, byteLength=undefined)
+    // WebIDL: Constructor(ArrayBuffer buffer,
+    //                     optional unsigned long byteOffset,
+    //                     optional unsigned long byteLength)
+    function DataView(buffer, byteOffset, byteLength) {
+      if (!(buffer instanceof ArrayBuffer || Class(buffer) === 'ArrayBuffer')) throw TypeError();
+
+      byteOffset = ToUint32(byteOffset);
+      if (byteOffset > buffer.byteLength)
+        throw RangeError('byteOffset out of range');
+
+      if (byteLength === undefined)
+        byteLength = buffer.byteLength - byteOffset;
+      else
+        byteLength = ToUint32(byteLength);
+
+      if ((byteOffset + byteLength) > buffer.byteLength)
+        throw RangeError('byteOffset and length reference an area beyond the end of the buffer');
+
+      Object.defineProperty(this, 'buffer', {value: buffer});
+      Object.defineProperty(this, 'byteLength', {value: byteLength});
+      Object.defineProperty(this, 'byteOffset', {value: byteOffset});
+    };
+
+    // get DataView.prototype.buffer
+    // get DataView.prototype.byteLength
+    // get DataView.prototype.byteOffset
+    // -- applied directly to instances by the constructor
+
+    function makeGetter(arrayType) {
+      return function GetViewValue(byteOffset, littleEndian) {
+        byteOffset = ToUint32(byteOffset);
+
+        if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength)
+          throw RangeError('Array index out of range');
+
+        byteOffset += this.byteOffset;
+
+        var uint8Array = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT),
+            bytes = [];
+        for (var i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1)
+          bytes.push(r(uint8Array, i));
+
+        if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN))
+          bytes.reverse();
+
+        return r(new arrayType(new Uint8Array(bytes).buffer), 0);
+      };
+    }
+
+    Object.defineProperty(DataView.prototype, 'getUint8', {value: makeGetter(Uint8Array)});
+    Object.defineProperty(DataView.prototype, 'getInt8', {value: makeGetter(Int8Array)});
+    Object.defineProperty(DataView.prototype, 'getUint16', {value: makeGetter(Uint16Array)});
+    Object.defineProperty(DataView.prototype, 'getInt16', {value: makeGetter(Int16Array)});
+    Object.defineProperty(DataView.prototype, 'getUint32', {value: makeGetter(Uint32Array)});
+    Object.defineProperty(DataView.prototype, 'getInt32', {value: makeGetter(Int32Array)});
+    Object.defineProperty(DataView.prototype, 'getFloat32', {value: makeGetter(Float32Array)});
+    Object.defineProperty(DataView.prototype, 'getFloat64', {value: makeGetter(Float64Array)});
+
+    function makeSetter(arrayType) {
+      return function SetViewValue(byteOffset, value, littleEndian) {
+        byteOffset = ToUint32(byteOffset);
+        if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength)
+          throw RangeError('Array index out of range');
+
+        // Get bytes
+        var typeArray = new arrayType([value]),
+            byteArray = new Uint8Array(typeArray.buffer),
+            bytes = [], i, byteView;
+
+        for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1)
+          bytes.push(r(byteArray, i));
+
+        // Flip if necessary
+        if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN))
+          bytes.reverse();
+
+        // Write them
+        byteView = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT);
+        byteView.set(bytes);
+      };
+    }
+
+    Object.defineProperty(DataView.prototype, 'setUint8', {value: makeSetter(Uint8Array)});
+    Object.defineProperty(DataView.prototype, 'setInt8', {value: makeSetter(Int8Array)});
+    Object.defineProperty(DataView.prototype, 'setUint16', {value: makeSetter(Uint16Array)});
+    Object.defineProperty(DataView.prototype, 'setInt16', {value: makeSetter(Int16Array)});
+    Object.defineProperty(DataView.prototype, 'setUint32', {value: makeSetter(Uint32Array)});
+    Object.defineProperty(DataView.prototype, 'setInt32', {value: makeSetter(Int32Array)});
+    Object.defineProperty(DataView.prototype, 'setFloat32', {value: makeSetter(Float32Array)});
+    Object.defineProperty(DataView.prototype, 'setFloat64', {value: makeSetter(Float64Array)});
+
+    global.DataView = global.DataView || DataView;
+
+  }());
+
+}(this));

=== removed file 'rockworkd/libpebble/jskitmanager.cpp'
--- rockworkd/libpebble/jskitmanager.cpp	2016-01-10 22:35:04 +0000
+++ rockworkd/libpebble/jskitmanager.cpp	1970-01-01 00:00:00 +0000
@@ -1,243 +0,0 @@
-#include <QFile>
-#include <QDir>
-
-#include "jskitmanager.h"
-#include "jskitobjects.h"
-
-JSKitManager::JSKitManager(Pebble *pebble, WatchConnection *connection, AppManager *apps, AppMsgManager *appmsg, QObject *parent) :
-    QObject(parent),
-    m_pebble(pebble),
-    m_connection(connection), _apps(apps), _appmsg(appmsg), _engine(0)
-{
-    m_configurationUuid = QUuid();
-    connect(_appmsg, &AppMsgManager::appStarted, this, &JSKitManager::handleAppStarted);
-    connect(_appmsg, &AppMsgManager::appStopped, this, &JSKitManager::handleAppStopped);
-}
-
-JSKitManager::~JSKitManager()
-{
-    if (_engine) {
-        stopJsApp();
-    }
-}
-
-QJSEngine * JSKitManager::engine()
-{
-    return _engine;
-}
-
-bool JSKitManager::isJSKitAppRunning() const
-{
-    return _engine != 0;
-}
-
-QString JSKitManager::describeError(QJSValue error)
-{
-    return QString("%1:%2: %3")
-            .arg(error.property("fileName").toString())
-            .arg(error.property("lineNumber").toInt())
-            .arg(error.toString());
-}
-
-void JSKitManager::showConfiguration()
-{
-    if (_engine) {
-        qDebug() << "requesting configuration";
-        _jspebble->invokeCallbacks("showConfiguration");
-    } else {
-        qWarning() << "requested to show configuration, but JS engine is not running";
-    }
-}
-
-void JSKitManager::handleWebviewClosed(const QString &result)
-{
-    if (_engine) {
-        QJSValue eventObj = _engine->newObject();
-        QByteArray data = QByteArray::fromPercentEncoding(result.toUtf8());
-        eventObj.setProperty("response", _engine->toScriptValue(data));
-
-        qDebug() << "Sending" << eventObj.property("response").toString();
-
-
-        _jspebble->invokeCallbacks("webviewclosed", QJSValueList({eventObj}));
-//        _jspebble->invokeCallbacks("webviewclosed", eventObj);
-    } else {
-        qWarning() << "webview closed event, but JS engine is not running";
-    }
-}
-
-void JSKitManager::setConfigurationId(const QUuid &uuid)
-{
-    m_configurationUuid = uuid;
-}
-
-AppInfo JSKitManager::currentApp()
-{
-    return _curApp;
-}
-
-void JSKitManager::handleAppStarted(const QUuid &uuid)
-{
-    qDebug() << "handleAppStarted!!!" << uuid;
-    AppInfo info = _apps->info(uuid);
-    if (!info.uuid().isNull() && info.isJSKit()) {
-        qDebug() << "Preparing to start JSKit app" << info.uuid() << info.shortName();
-        _curApp = info;
-        startJsApp();
-    }
-}
-
-void JSKitManager::handleAppStopped(const QUuid &uuid)
-{
-    if (!_curApp.uuid().isNull()) {
-        if (_curApp.uuid() != uuid) {
-            qWarning() << "Closed app with invalid UUID";
-        }
-
-        stopJsApp();
-        _curApp = AppInfo();
-        qDebug() << "App stopped" << uuid;
-    }
-}
-
-void JSKitManager::handleAppMessage(const QUuid &uuid, const QVariantMap &msg)
-{
-    qDebug() << "handleAppMessage" << uuid << msg;
-    if (_curApp.uuid() == uuid) {
-        qDebug() << "received a message for the current JSKit app";
-
-        if (!_engine) {
-            qDebug() << "but engine is stopped";
-            return;
-        }
-
-        QJSValue eventObj = _engine->newObject();
-        eventObj.setProperty("payload", _engine->toScriptValue(msg));
-
-        _jspebble->invokeCallbacks("appmessage", QJSValueList({eventObj}));
-    }
-}
-
-bool JSKitManager::loadJsFile(const QString &filename)
-{
-    Q_ASSERT(_engine);
-
-    QFile file(filename);
-    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        qWarning() << "Failed to load JS file:" << file.fileName();
-        return false;
-    }
-
-    qDebug() << "now parsing" << file.fileName();
-
-    QJSValue result = _engine->evaluate(QString::fromUtf8(file.readAll()), file.fileName());
-    if (result.isError()) {
-        qWarning() << "error while evaluating JS script:" << describeError(result);
-        return false;
-    }
-
-    qDebug() << "JS script evaluated";
-
-    return true;
-}
-
-void JSKitManager::startJsApp()
-{
-    qDebug() << "startJsApp called";
-
-    if (_engine) stopJsApp();
-
-    if (_curApp.uuid().isNull()) {
-        qWarning() << "Attempting to start JS app with invalid UUID";
-        return;
-    }
-
-    _engine = new QJSEngine(this);
-    _jspebble = new JSKitPebble(_curApp, this, _engine);
-    _jsconsole = new JSKitConsole(_engine);
-    _jsstorage = new JSKitLocalStorage(m_pebble->storagePath(), _curApp.uuid(), _engine);
-    _jsgeo = new JSKitGeolocation(this, _engine);
-
-    qDebug() << "starting JS app" << _curApp.shortName();
-
-    QJSValue globalObj = _engine->globalObject();
-
-    globalObj.setProperty("RealPebble", _engine->newQObject(_jspebble));
-    globalObj.setProperty("console", _engine->newQObject(_jsconsole));
-    globalObj.setProperty("localStorage", _engine->newQObject(_jsstorage));
-
-    QJSValue navigatorObj = _engine->newObject();
-    navigatorObj.setProperty("RealGeolocation", _engine->newQObject(_jsgeo));
-    navigatorObj.setProperty("language", _engine->toScriptValue(QLocale().name()));
-    globalObj.setProperty("navigator", navigatorObj);
-
-    // Set this.window = this
-    globalObj.setProperty("window", globalObj);
-
-    // Shims for compatibility...
-    QJSValue result = _engine->evaluate(
-                "function XMLHttpRequest() { return Pebble.createXMLHttpRequest(); }\n\
-                function setInterval(func, time) { return Pebble.setInterval(func, time); }\n\
-                function clearInterval(id) { Pebble.clearInterval(id); }\n\
-                function setTimeout(func, time) { return Pebble.setTimeout(func, time); }\n\
-                function clearTimeout(id) { Pebble.clearTimeout(id); }\n\
-                Pebble = {}; for (var key in RealPebble) {Pebble[key] = RealPebble[key];}\n\
-                navigator.geolocation = {}; for (var key in navigator.RealGeolocation) {navigator.geolocation[key] = navigator.RealGeolocation[key];}\n\
-                ");
-            qDebug() << result.toString();
-    Q_ASSERT(!result.isError());
-
-    // Polyfills...
-    loadJsFile(":/typedarray.js");
-
-    // Now the actual script
-    QString jsApp = _curApp.file(AppInfo::FileTypeJsApp, HardwarePlatformUnknown);
-    QFile f(jsApp);
-    if (!f.open(QFile::ReadOnly)) {
-        qWarning() << "Error opening" << jsApp;
-        return;
-    }
-    QJSValue ret = _engine->evaluate(QString::fromUtf8(f.readAll()));
-    qDebug() << "loaded script" << ret.toString();
-
-    // Setup the message callback
-    QUuid uuid = _curApp.uuid();
-    _appmsg->setMessageHandler(uuid, [this, uuid](const QVariantMap &msg) {
-        QMetaObject::invokeMethod(this, "handleAppMessage", Qt::QueuedConnection,
-                                  Q_ARG(QUuid, uuid),
-                                  Q_ARG(QVariantMap, msg));
-
-        // Invoke the slot as a queued connection to give time for the ACK message
-        // to go through first.
-
-        return true;
-    });
-
-    // We try to invoke the callbacks even if script parsing resulted in error...
-    qDebug() << "calling ready!";
-    _jspebble->invokeCallbacks("ready");
-
-    if (m_configurationUuid == _curApp.uuid()) {
-        qDebug() << "going to launch config for" << m_configurationUuid;
-        showConfiguration();
-    }
-
-    m_configurationUuid = QUuid();
-}
-
-void JSKitManager::stopJsApp()
-{
-    qDebug() << "stop js app";
-    if (!_engine) return; // Nothing to do!
-
-    qDebug() << "stopping JS app";
-
-    if (!_curApp.uuid().isNull()) {
-        _appmsg->clearMessageHandler(_curApp.uuid());
-    }
-
-    _engine->collectGarbage();
-
-    _engine->deleteLater();
-    _engine = 0;
-}

=== removed file 'rockworkd/libpebble/jskitmanager.h'
--- rockworkd/libpebble/jskitmanager.h	2016-01-03 05:06:13 +0000
+++ rockworkd/libpebble/jskitmanager.h	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-#ifndef JSKITMANAGER_H
-#define JSKITMANAGER_H
-
-#include <QJSEngine>
-#include <QPointer>
-#include "appmanager.h"
-#include "watchconnection.h"
-#include "pebble.h"
-#include "appmsgmanager.h"
-//#include "settings.h"
-
-class JSKitPebble;
-class JSKitConsole;
-class JSKitLocalStorage;
-class JSKitGeolocation;
-
-class JSKitManager : public QObject
-{
-    Q_OBJECT
-
-public:
-    explicit JSKitManager(Pebble *pebble, WatchConnection *connection, AppManager *apps, AppMsgManager *appmsg, QObject *parent = 0);
-    ~JSKitManager();
-
-    QJSEngine * engine();
-    bool isJSKitAppRunning() const;
-
-    static QString describeError(QJSValue error);
-
-    void showConfiguration();
-    void handleWebviewClosed(const QString &result);
-    void setConfigurationId(const QUuid &uuid);
-    AppInfo currentApp();
-
-signals:
-    void appNotification(const QUuid &uuid, const QString &title, const QString &body);
-    void openURL(const QString &uuid, const QString &url);
-
-private slots:
-    void handleAppStarted(const QUuid &uuid);
-    void handleAppStopped(const QUuid &uuid);
-    void handleAppMessage(const QUuid &uuid, const QVariantMap &msg);
-
-private:
-    bool loadJsFile(const QString &filename);
-    void startJsApp();
-    void stopJsApp();
-
-private:
-    friend class JSKitPebble;
-
-    Pebble *m_pebble;
-    WatchConnection *m_connection;
-    AppManager *_apps;
-    AppMsgManager *_appmsg;
-    AppInfo _curApp;
-    QJSEngine *_engine;
-    QPointer<JSKitPebble> _jspebble;
-    QPointer<JSKitConsole> _jsconsole;
-    QPointer<JSKitLocalStorage> _jsstorage;
-    QPointer<JSKitGeolocation> _jsgeo;
-    QUuid m_configurationUuid;
-};
-
-#endif // JSKITMANAGER_H

=== removed file 'rockworkd/libpebble/jskitobjects.cpp'
--- rockworkd/libpebble/jskitobjects.cpp	2016-01-10 22:35:04 +0000
+++ rockworkd/libpebble/jskitobjects.cpp	1970-01-01 00:00:00 +0000
@@ -1,859 +0,0 @@
-#include <QDesktopServices>
-#include <QUrl>
-#include <QAuthenticator>
-#include <QBuffer>
-#include <QDir>
-#include <QTimerEvent>
-#include <QCryptographicHash>
-#include <limits>
-#include "jskitobjects.h"
-
-static const char *token_salt = "0feeb7416d3c4546a19b04bccd8419b1";
-
-JSKitPebble::JSKitPebble(const AppInfo &info, JSKitManager *mgr, QObject *parent)
-    : QObject(parent), _appInfo(info), _mgr(mgr)
-{
-}
-
-void JSKitPebble::addEventListener(const QString &type, QJSValue function)
-{
-    qDebug() << "Adding event listener for " << type;
-    _callbacks[type].append(function);
-}
-
-void JSKitPebble::removeEventListener(const QString &type, QJSValue function)
-{
-    if (!_callbacks.contains(type)) return;
-    QList<QJSValue> &callbacks = _callbacks[type];
-
-    for (QList<QJSValue>::iterator it = callbacks.begin(); it != callbacks.end(); ) {
-        if (it->strictlyEquals(function)) {
-            it = callbacks.erase(it);
-        } else {
-            ++it;
-        }
-    }
-
-    if (callbacks.empty()) {
-        _callbacks.remove(type);
-    }
-}
-
-int JSKitPebble::setInterval(QJSValue expression, int delay)
-{
-    qDebug() << "Setting interval for " << delay << "ms: " << expression.toString();
-    if (expression.isString() || expression.isCallable()) {
-        int timerId = startTimer(delay);
-        _intervals.insert(timerId, expression);
-        qDebug() << "Timer id: " << timerId;
-        return timerId;
-    }
-    return -1;
-}
-
-void JSKitPebble::clearInterval(int timerId)
-{
-    qDebug() << "Killing interval " << timerId ;
-    killTimer(timerId);
-    _intervals.remove(timerId);
-}
-
-int JSKitPebble::setTimeout(QJSValue expression, int delay)
-{
-    qDebug() << "Setting timeout for " << delay << "ms: " << expression.toString();
-    if (expression.isString() || expression.isCallable()) {
-        int timerId = startTimer(delay);
-        _timeouts.insert(timerId, expression);
-        return timerId;
-    }
-    return -1;
-}
-
-void JSKitPebble::clearTimeout(int timerId)
-{
-    qDebug() << "Killing timeout " << timerId ;
-    killTimer(timerId);
-    _timeouts.remove(timerId);
-}
-
-void JSKitPebble::timerEvent(QTimerEvent *event)
-{
-    int id = event->timerId();
-    QJSValue expression; // find in either intervals or timeouts
-    if (_intervals.contains(id))
-        expression = _intervals.value(id);
-    else if (_timeouts.contains(id)) {
-        expression = _timeouts.value(id);
-        killTimer(id); // timeouts don't repeat
-    }
-    else {
-        qWarning() << "Unknown timer event";
-        killTimer(id); // interval nor timeout exist. kill the timer
-        return;
-    }
-
-    if (expression.isCallable()) { // call it if it's a function
-        QJSValue result = expression.call().toString();
-        qDebug() << "Timer function result: " << result.toString();
-    }
-    else { // otherwise evaluate it
-        QJSValue result = _mgr->engine()->evaluate(expression.toString());
-        qDebug() << "Timer expression result: " << result.toString();
-    }
-}
-
-uint JSKitPebble::sendAppMessage(QJSValue message, QJSValue callbackForAck, QJSValue callbackForNack)
-{
-    QVariantMap data = message.toVariant().toMap();
-    QPointer<JSKitPebble> pebbObj = this;
-    uint transactionId = _mgr->_appmsg->nextTransactionId();
-
-    qDebug() << "sendAppMessage" << data;
-
-    _mgr->_appmsg->send(_appInfo.uuid(), data,
-    [pebbObj, transactionId, callbackForAck]() mutable {
-        if (pebbObj.isNull()) return;
-        if (callbackForAck.isCallable()) {
-            qDebug() << "Invoking ack callback";
-            QJSValue event = pebbObj->buildAckEventObject(transactionId);
-            QJSValue result = callbackForAck.call(QJSValueList({event}));
-            if (result.isError()) {
-                qWarning() << "error while invoking ACK callback" << callbackForAck.toString() << ":"
-                                          << JSKitManager::describeError(result);
-            }
-        } else {
-            qDebug() << "Ack callback not callable";
-        }
-    },
-    [pebbObj, transactionId, callbackForNack]() mutable {
-        if (pebbObj.isNull()) return;
-        if (callbackForNack.isCallable()) {
-            qDebug() << "Invoking nack callback";
-            QJSValue event = pebbObj->buildAckEventObject(transactionId, "NACK from watch");
-            QJSValue result = callbackForNack.call(QJSValueList({event}));
-            if (result.isError()) {
-                qWarning() << "error while invoking NACK callback" << callbackForNack.toString() << ":"
-                                          << JSKitManager::describeError(result);
-            }
-        } else {
-            qDebug() << "Nack callback not callable";
-        }
-    });
-
-    return transactionId;
-}
-
-void JSKitPebble::showSimpleNotificationOnPebble(const QString &title, const QString &body)
-{
-    qDebug() << "showSimpleNotificationOnPebble" << title << body;
-    emit _mgr->appNotification(_appInfo.uuid(), title, body);
-}
-
-void JSKitPebble::openURL(const QUrl &url)
-{
-    qDebug() << "opening url" << url.toString();
-    emit _mgr->openURL(_appInfo.uuid().toString(), url.toString());
-}
-
-QString JSKitPebble::getAccountToken() const
-{
-    // We do not have any account system, so we just fake something up.
-    QCryptographicHash hasher(QCryptographicHash::Md5);
-
-    hasher.addData(token_salt, strlen(token_salt));
-    hasher.addData(_appInfo.uuid().toByteArray());
-
-    QSettings settings;
-    QString token = settings.value("accountToken").toString();
-//    QString token = _mgr->_settings->property("accountToken").toString();
-    if (token.isEmpty()) {
-        token = QUuid::createUuid().toString();
-        qDebug() << "created new account token" << token;
-        settings.setValue("accountToken", token);
-//        _mgr->_settings->setProperty("accountToken", token);
-    }
-    hasher.addData(token.toLatin1());
-
-    QString hash = hasher.result().toHex();
-    qDebug() << "returning account token" << hash;
-
-    return hash;
-}
-
-QString JSKitPebble::getWatchToken() const
-{
-    QCryptographicHash hasher(QCryptographicHash::Md5);
-
-    hasher.addData(token_salt, strlen(token_salt));
-    hasher.addData(_appInfo.uuid().toByteArray());
-    hasher.addData(_mgr->m_pebble->serialNumber().toLatin1());
-
-    QString hash = hasher.result().toHex();
-    qDebug() << "returning watch token" << hash;
-
-    return hash;
-}
-
-QJSValue JSKitPebble::createXMLHttpRequest()
-{
-    JSKitXMLHttpRequest *xhr = new JSKitXMLHttpRequest(_mgr, 0);
-    // Should be deleted by JS engine.
-    return _mgr->engine()->newQObject(xhr);
-}
-
-QJSValue JSKitPebble::buildAckEventObject(uint transaction, const QString &message) const
-{
-    QJSEngine *engine = _mgr->engine();
-    QJSValue eventObj = engine->newObject();
-    QJSValue dataObj = engine->newObject();
-
-    dataObj.setProperty("transactionId", engine->toScriptValue(transaction));
-    eventObj.setProperty("data", dataObj);
-
-    if (!message.isEmpty()) {
-        QJSValue errorObj = engine->newObject();
-        errorObj.setProperty("message", engine->toScriptValue(message));
-        eventObj.setProperty("error", errorObj);
-    }
-
-    return eventObj;
-}
-
-void JSKitPebble::invokeCallbacks(const QString &type, const QJSValueList &args)
-{
-    if (!_callbacks.contains(type)) return;
-    QList<QJSValue> &callbacks = _callbacks[type];
-
-    for (QList<QJSValue>::iterator it = callbacks.begin(); it != callbacks.end(); ++it) {
-        qDebug() << "invoking callback" << type << it->toString();
-        QJSValue result = it->call(args);
-        if (result.isError()) {
-            qWarning() << "error while invoking callback" << type << it->toString() << ":"
-                             << JSKitManager::describeError(result);
-        }
-    }
-}
-
-JSKitConsole::JSKitConsole(QObject *parent)
-    : QObject(parent), l(metaObject()->className())
-{
-}
-
-void JSKitConsole::log(const QString &msg)
-{
-    qCDebug(l) << msg;
-}
-
-void JSKitConsole::warn(const QString &msg)
-{
-    qCWarning(l) << msg;
-}
-
-void JSKitConsole::error(const QString &msg)
-{
-    qCCritical(l) << msg;
-}
-
-void JSKitConsole::info(const QString &msg)
-{
-    qCDebug(l) << msg;
-}
-
-JSKitLocalStorage::JSKitLocalStorage(const QString &storagePath, const QUuid &uuid, QObject *parent):
-    QObject(parent),
-    _storage(new QSettings(getStorageFileFor(storagePath, uuid), QSettings::IniFormat, this))
-{
-    _len = _storage->allKeys().size();
-}
-
-int JSKitLocalStorage::length() const
-{
-    return _len;
-}
-
-QJSValue JSKitLocalStorage::getItem(const QString &key) const
-{
-    QVariant value = _storage->value(key);
-    if (value.isValid()) {
-        return QJSValue(value.toString());
-    } else {
-        return QJSValue(QJSValue::NullValue);
-    }
-}
-
-void JSKitLocalStorage::setItem(const QString &key, const QString &value)
-{
-    _storage->setValue(key, QVariant::fromValue(value));
-    checkLengthChanged();
-}
-
-void JSKitLocalStorage::removeItem(const QString &key)
-{
-    _storage->remove(key);
-    checkLengthChanged();
-}
-
-void JSKitLocalStorage::clear()
-{
-    _storage->clear();
-    _len = 0;
-    emit lengthChanged();
-}
-
-void JSKitLocalStorage::checkLengthChanged()
-{
-    int curLen = _storage->allKeys().size();
-    if (_len != curLen) {
-        _len = curLen;
-        emit lengthChanged();
-    }
-}
-
-QString JSKitLocalStorage::getStorageFileFor(const QString &storageDir, const QUuid &uuid)
-{
-    QDir dataDir(storageDir + "/js-storage");
-    if (!dataDir.exists() && !dataDir.mkpath(dataDir.absolutePath())) {
-        qWarning() << "Error creating jskit storage dir";
-        return QString();
-    }
-    QString fileName = uuid.toString();
-    fileName.remove('{');
-    fileName.remove('}');
-    return dataDir.absoluteFilePath(fileName + ".ini");
-}
-
-JSKitXMLHttpRequest::JSKitXMLHttpRequest(JSKitManager *mgr, QObject *parent)
-    : QObject(parent), l(metaObject()->className()), _mgr(mgr),
-      _net(new QNetworkAccessManager(this)), _timeout(0), _reply(0)
-{
-    qCDebug(l) << "constructed";
-    connect(_net, &QNetworkAccessManager::authenticationRequired,
-            this, &JSKitXMLHttpRequest::handleAuthenticationRequired);
-}
-
-JSKitXMLHttpRequest::~JSKitXMLHttpRequest()
-{
-    qCDebug(l) << "destructed";
-}
-
-void JSKitXMLHttpRequest::open(const QString &method, const QString &url, bool async, const QString &username, const QString &password)
-{
-    if (_reply) {
-        _reply->deleteLater();
-        _reply = 0;
-    }
-
-    _username = username;
-    _password = password;
-    _request = QNetworkRequest(QUrl(url));
-    _verb = method;
-    Q_UNUSED(async);
-
-    qCDebug(l) << "opened to URL" << _request.url().toString();
-}
-
-void JSKitXMLHttpRequest::setRequestHeader(const QString &header, const QString &value)
-{
-    qCDebug(l) << "setRequestHeader" << header << value;
-    _request.setRawHeader(header.toLatin1(), value.toLatin1());
-}
-
-void JSKitXMLHttpRequest::send(const QJSValue &data)
-{
-    QByteArray byteData;
-
-    if (data.isUndefined() || data.isNull()) {
-        // Do nothing, byteData is empty.
-    } else if (data.isString()) {
-        byteData = data.toString().toUtf8();
-    } else if (data.isObject()) {
-        if (data.hasProperty("byteLength")) {
-            // Looks like an ArrayView or an ArrayBufferView!
-            QJSValue buffer = data.property("buffer");
-            if (buffer.isUndefined()) {
-                // We must assume we've been passed an ArrayBuffer directly
-                buffer = data;
-            }
-
-            QJSValue array = data.property("_bytes");
-            int byteLength = data.property("byteLength").toInt();
-
-            if (array.isArray()) {
-                byteData.reserve(byteLength);
-
-                for (int i = 0; i < byteLength; i++) {
-                    byteData.append(array.property(i).toInt());
-                }
-
-                qCDebug(l) << "passed an ArrayBufferView of" << byteData.length() << "bytes";
-            } else {
-                qCWarning(l) << "passed an unknown/invalid ArrayBuffer" << data.toString();
-            }
-        } else {
-            qCWarning(l) << "passed an unknown object" << data.toString();
-        }
-
-    }
-
-    QBuffer *buffer;
-    if (!byteData.isEmpty()) {
-        buffer = new QBuffer;
-        buffer->setData(byteData);
-    } else {
-        buffer = 0;
-    }
-
-    qCDebug(l) << "sending" << _verb << "to" << _request.url() << "with" << QString::fromUtf8(byteData);
-    _reply = _net->sendCustomRequest(_request, _verb.toLatin1(), buffer);
-
-    connect(_reply, &QNetworkReply::finished,
-            this, &JSKitXMLHttpRequest::handleReplyFinished);
-    connect(_reply, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
-            this, &JSKitXMLHttpRequest::handleReplyError);
-
-    if (buffer) {
-        // So that it gets deleted alongside the reply object.
-        buffer->setParent(_reply);
-    }
-}
-
-void JSKitXMLHttpRequest::abort()
-{
-    if (_reply) {
-        _reply->deleteLater();
-        _reply = 0;
-    }
-}
-
-QJSValue JSKitXMLHttpRequest::onload() const
-{
-    return _onload;
-}
-
-void JSKitXMLHttpRequest::setOnload(const QJSValue &value)
-{
-    _onload = value;
-}
-
-QJSValue JSKitXMLHttpRequest::ontimeout() const
-{
-    return _ontimeout;
-}
-
-void JSKitXMLHttpRequest::setOntimeout(const QJSValue &value)
-{
-    _ontimeout = value;
-}
-
-QJSValue JSKitXMLHttpRequest::onerror() const
-{
-    return _onerror;
-}
-
-void JSKitXMLHttpRequest::setOnerror(const QJSValue &value)
-{
-    _onerror = value;
-}
-
-uint JSKitXMLHttpRequest::readyState() const
-{
-    if (!_reply) {
-        return UNSENT;
-    } else if (_reply->isFinished()) {
-        return DONE;
-    } else {
-        return LOADING;
-    }
-}
-
-uint JSKitXMLHttpRequest::timeout() const
-{
-    return _timeout;
-}
-
-void JSKitXMLHttpRequest::setTimeout(uint value)
-{
-    _timeout = value;
-    // TODO Handle fetch in-progress.
-}
-
-uint JSKitXMLHttpRequest::status() const
-{
-    if (!_reply || !_reply->isFinished()) {
-        return 0;
-    } else {
-        return _reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toUInt();
-    }
-}
-
-QString JSKitXMLHttpRequest::statusText() const
-{
-    if (!_reply || !_reply->isFinished()) {
-        return QString();
-    } else {
-        return _reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
-    }
-}
-
-QString JSKitXMLHttpRequest::responseType() const
-{
-    return _responseType;
-}
-
-void JSKitXMLHttpRequest::setResponseType(const QString &type)
-{
-    qCDebug(l) << "response type set to" << type;
-    _responseType = type;
-}
-
-QJSValue JSKitXMLHttpRequest::response() const
-{
-    QJSEngine *engine = _mgr->engine();
-    if (_responseType.isEmpty() || _responseType == "text") {
-        return engine->toScriptValue(QString::fromUtf8(_response));
-    } else if (_responseType == "arraybuffer") {
-        QJSValue arrayBufferProto = engine->globalObject().property("ArrayBuffer").property("prototype");
-        QJSValue arrayBuf = engine->newObject();
-        if (!arrayBufferProto.isUndefined()) {
-            arrayBuf.setPrototype(arrayBufferProto);
-            arrayBuf.setProperty("byteLength", engine->toScriptValue<uint>(_response.size()));
-            QJSValue array = engine->newArray(_response.size());
-            for (int i = 0; i < _response.size(); i++) {
-                array.setProperty(i, engine->toScriptValue<int>(_response[i]));
-            }
-            arrayBuf.setProperty("_bytes", array);
-            qCDebug(l) << "returning ArrayBuffer of" << _response.size() << "bytes";
-        } else {
-            qCWarning(l) << "Cannot find proto of ArrayBuffer";
-        }
-        return arrayBuf;
-    } else {
-        qCWarning(l) << "unsupported responseType:" << _responseType;
-        return engine->toScriptValue<void*>(0);
-    }
-}
-
-QString JSKitXMLHttpRequest::responseText() const
-{
-    return QString::fromUtf8(_response);
-}
-
-void JSKitXMLHttpRequest::handleReplyFinished()
-{
-    if (!_reply) {
-        qCDebug(l) << "reply finished too late";
-        return;
-    }
-
-    _response = _reply->readAll();
-    qCDebug(l) << "reply finished, reply text:" << QString::fromUtf8(_response);
-
-    emit readyStateChanged();
-    emit statusChanged();
-    emit statusTextChanged();
-    emit responseChanged();
-    emit responseTextChanged();
-
-    if (_onload.isCallable()) {
-        qCDebug(l) << "going to call onload handler:" << _onload.toString();
-        QJSValue result = _onload.callWithInstance(_mgr->engine()->newQObject(this));
-        if (result.isError()) {
-            qCWarning(l) << "JS error on onload handler:" << JSKitManager::describeError(result);
-        }
-    } else {
-        qCDebug(l) << "No onload set";
-    }
-}
-
-void JSKitXMLHttpRequest::handleReplyError(QNetworkReply::NetworkError code)
-{
-    if (!_reply) {
-        qCDebug(l) << "reply error too late";
-        return;
-    }
-
-    qCDebug(l) << "reply error" << code;
-
-    emit readyStateChanged();
-    emit statusChanged();
-    emit statusTextChanged();
-
-    if (_onerror.isCallable()) {
-        qCDebug(l) << "going to call onerror handler:" << _onload.toString();
-        QJSValue result = _onerror.callWithInstance(_mgr->engine()->newQObject(this));
-        if (result.isError()) {
-            qCWarning(l) << "JS error on onerror handler:" << JSKitManager::describeError(result);
-        }
-    }
-}
-
-void JSKitXMLHttpRequest::handleAuthenticationRequired(QNetworkReply *reply, QAuthenticator *auth)
-{
-    if (_reply == reply) {
-        qCDebug(l) << "authentication required";
-
-        if (!_username.isEmpty() || !_password.isEmpty()) {
-            qCDebug(l) << "using provided authorization:" << _username;
-
-            auth->setUser(_username);
-            auth->setPassword(_password);
-        } else {
-            qCDebug(l) << "no username or password provided";
-        }
-    }
-}
-
-JSKitGeolocation::JSKitGeolocation(JSKitManager *mgr, QObject *parent)
-    : QObject(parent), l(metaObject()->className()),
-      _mgr(mgr), _source(0), _lastWatchId(0)
-{
-}
-
-void JSKitGeolocation::getCurrentPosition(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options)
-{
-    setupWatcher(successCallback, errorCallback, options, true);
-}
-
-int JSKitGeolocation::watchPosition(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options)
-{
-    return setupWatcher(successCallback, errorCallback, options, false);
-}
-
-void JSKitGeolocation::clearWatch(int watchId)
-{
-    removeWatcher(watchId);
-}
-
-void JSKitGeolocation::handleError(QGeoPositionInfoSource::Error error)
-{
-    qCWarning(l) << "positioning error: " << error;
-    // TODO
-}
-
-void JSKitGeolocation::handlePosition(const QGeoPositionInfo &pos)
-{
-    qCDebug(l) << "got position at" << pos.timestamp() << "type" << pos.coordinate().type();
-
-    if (_watches.empty()) {
-        qCWarning(l) << "got position update but no one is watching";
-        _source->stopUpdates(); // Just in case.
-        return;
-    }
-
-    QJSValue obj = buildPositionObject(pos);
-
-    for (auto it = _watches.begin(); it != _watches.end(); /*no adv*/) {
-        invokeCallback(it->successCallback, obj);
-
-        if (it->once) {
-            it = _watches.erase(it);
-        } else {
-            it->timer.restart();
-            ++it;
-        }
-    }
-}
-
-void JSKitGeolocation::handleTimeout()
-{
-    qCDebug(l) << "positioning timeout";
-
-    if (_watches.empty()) {
-        qCWarning(l) << "got position timeout but no one is watching";
-        _source->stopUpdates();
-        return;
-    }
-
-    QJSValue obj = buildPositionErrorObject(TIMEOUT, "timeout");
-
-    for (auto it = _watches.begin(); it != _watches.end(); /*no adv*/) {
-        if (it->timer.hasExpired(it->timeout)) {
-            qCDebug(l) << "positioning timeout for watch" << it->watchId
-                             << ", watch is" << it->timer.elapsed() << "ms old, timeout is" << it->timeout;
-            invokeCallback(it->errorCallback, obj);
-
-            if (it->once) {
-                it = _watches.erase(it);
-            } else {
-                it->timer.restart();
-                ++it;
-            }
-        } else {
-            ++it;
-        }
-    }
-
-    QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
-}
-
-void JSKitGeolocation::updateTimeouts()
-{
-    int once_timeout = -1, updates_timeout = -1;
-
-    qCDebug(l) << Q_FUNC_INFO;
-
-    Q_FOREACH(const Watcher &watcher, _watches) {
-        qint64 rem_timeout = watcher.timeout - watcher.timer.elapsed();
-        qCDebug(l) << "watch" << watcher.watchId << "rem timeout" << rem_timeout;
-        if (rem_timeout >= 0) {
-            // In case it is too large...
-            rem_timeout = qMin<qint64>(rem_timeout, std::numeric_limits<int>::max());
-            if (watcher.once) {
-                once_timeout = once_timeout >= 0 ? qMin<int>(once_timeout, rem_timeout) : rem_timeout;
-            } else {
-                updates_timeout = updates_timeout >= 0 ? qMin<int>(updates_timeout, rem_timeout) : rem_timeout;
-            }
-        }
-    }
-
-    if (updates_timeout >= 0) {
-        qCDebug(l) << "setting location update interval to" << updates_timeout;
-        _source->setUpdateInterval(updates_timeout);
-        _source->startUpdates();
-    } else {
-        qCDebug(l) << "stopping updates";
-        _source->stopUpdates();
-    }
-
-    if (once_timeout >= 0) {
-        qCDebug(l) << "requesting single location update with timeout" << once_timeout;
-        _source->requestUpdate(once_timeout);
-    }
-}
-
-int JSKitGeolocation::setupWatcher(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options, bool once)
-{
-    Watcher watcher;
-    watcher.successCallback = successCallback;
-    watcher.errorCallback = errorCallback;
-    watcher.highAccuracy = options.value("enableHighAccuracy").toBool();
-    watcher.timeout = options.value("timeout", std::numeric_limits<int>::max() - 1).toInt();
-    watcher.once = once;
-    watcher.watchId = ++_lastWatchId;
-
-    qlonglong maximumAge = options.value("maximumAge", 0).toLongLong();
-
-    qCDebug(l) << "setting up watcher, gps=" << watcher.highAccuracy << "timeout=" << watcher.timeout << "maximumAge=" << maximumAge << "once=" << once;
-
-    if (!_source) {
-        _source = QGeoPositionInfoSource::createDefaultSource(this);
-        connect(_source, static_cast<void (QGeoPositionInfoSource::*)(QGeoPositionInfoSource::Error)>(&QGeoPositionInfoSource::error),
-                this, &JSKitGeolocation::handleError);
-        connect(_source, &QGeoPositionInfoSource::positionUpdated,
-                this, &JSKitGeolocation::handlePosition);
-        connect(_source, &QGeoPositionInfoSource::updateTimeout,
-                this, &JSKitGeolocation::handleTimeout);
-    }
-
-    if (maximumAge > 0) {
-        QDateTime threshold = QDateTime::currentDateTime().addMSecs(-qint64(maximumAge));
-        QGeoPositionInfo pos = _source->lastKnownPosition(watcher.highAccuracy);
-        qCDebug(l) << "got pos timestamp" << pos.timestamp() << " but we want" << threshold;
-        if (pos.isValid() && pos.timestamp() >= threshold) {
-            invokeCallback(watcher.successCallback, buildPositionObject(pos));
-            if (once) {
-                return -1;
-            }
-        } else if (watcher.timeout == 0 && once) {
-            // If the timeout has already expired, and we have no cached data
-            // Do not even bother to turn on the GPS; return error object now.
-            invokeCallback(watcher.errorCallback, buildPositionErrorObject(TIMEOUT, "no cached position"));
-            return -1;
-        }
-    }
-
-    watcher.timer.start();
-    _watches.append(watcher);
-
-    qCDebug(l) << "added new watch" << watcher.watchId;
-
-    QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
-
-    return watcher.watchId;
-}
-
-void JSKitGeolocation::removeWatcher(int watchId)
-{
-    Watcher watcher;
-
-    qCDebug(l) << "removing watchId" << watcher.watchId;
-
-    for (int i = 0; i < _watches.size(); i++) {
-        if (_watches[i].watchId == watchId) {
-            watcher = _watches.takeAt(i);
-            break;
-        }
-    }
-
-    if (watcher.watchId != watchId) {
-        qCWarning(l) << "watchId not found";
-        return;
-    }
-
-    QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
-}
-
-QJSValue JSKitGeolocation::buildPositionObject(const QGeoPositionInfo &pos)
-{
-    QJSEngine *engine = _mgr->engine();
-    QJSValue obj = engine->newObject();
-    QJSValue coords = engine->newObject();
-    QJSValue timestamp = engine->toScriptValue<quint64>(pos.timestamp().toMSecsSinceEpoch());
-
-    coords.setProperty("latitude", engine->toScriptValue(pos.coordinate().latitude()));
-    coords.setProperty("longitude", engine->toScriptValue(pos.coordinate().longitude()));
-    if (pos.coordinate().type() == QGeoCoordinate::Coordinate3D) {
-        coords.setProperty("altitude", engine->toScriptValue(pos.coordinate().altitude()));
-    } else {
-        coords.setProperty("altitude", engine->toScriptValue<void*>(0));
-    }
-
-    coords.setProperty("accuracy", engine->toScriptValue(pos.attribute(QGeoPositionInfo::HorizontalAccuracy)));
-
-    if (pos.hasAttribute(QGeoPositionInfo::VerticalAccuracy)) {
-        coords.setProperty("altitudeAccuracy", engine->toScriptValue(pos.attribute(QGeoPositionInfo::VerticalAccuracy)));
-    } else {
-        coords.setProperty("altitudeAccuracy", engine->toScriptValue<void*>(0));
-    }
-
-    if (pos.hasAttribute(QGeoPositionInfo::Direction)) {
-        coords.setProperty("heading", engine->toScriptValue(pos.attribute(QGeoPositionInfo::Direction)));
-    } else {
-        coords.setProperty("heading", engine->toScriptValue<void*>(0));
-    }
-
-    if (pos.hasAttribute(QGeoPositionInfo::GroundSpeed)) {
-        coords.setProperty("speed", engine->toScriptValue(pos.attribute(QGeoPositionInfo::GroundSpeed)));
-    } else {
-        coords.setProperty("speed", engine->toScriptValue<void*>(0));
-    }
-
-    obj.setProperty("coords", coords);
-    obj.setProperty("timestamp", timestamp);
-
-    return obj;
-}
-
-QJSValue JSKitGeolocation::buildPositionErrorObject(PositionError error, const QString &message)
-{
-    QJSEngine *engine = _mgr->engine();
-    QJSValue obj = engine->newObject();
-
-    obj.setProperty("code", engine->toScriptValue<unsigned short>(error));
-    obj.setProperty("message", engine->toScriptValue(message));
-
-    return obj;
-}
-
-void JSKitGeolocation::invokeCallback(QJSValue callback, QJSValue event)
-{
-    if (callback.isCallable()) {
-        qCDebug(l) << "invoking callback" << callback.toString();
-        QJSValue result = callback.call(QJSValueList({event}));
-        if (result.isError()) {
-            qCWarning(l) << "while invoking callback: " << JSKitManager::describeError(result);
-        }
-    } else {
-        qCWarning(l) << "callback is not callable";
-    }
-}

=== removed file 'rockworkd/libpebble/jskitobjects.h'
--- rockworkd/libpebble/jskitobjects.h	2016-01-10 22:35:04 +0000
+++ rockworkd/libpebble/jskitobjects.h	1970-01-01 00:00:00 +0000
@@ -1,235 +0,0 @@
-#ifndef JSKITMANAGER_P_H
-#define JSKITMANAGER_P_H
-
-#include <QElapsedTimer>
-#include <QSettings>
-#include <QNetworkRequest>
-#include <QNetworkReply>
-#include <QGeoPositionInfoSource>
-#include "jskitmanager.h"
-#include "appinfo.h"
-
-class JSKitPebble : public QObject
-{
-    Q_OBJECT
-
-public:
-    explicit JSKitPebble(const AppInfo &appInfo, JSKitManager *mgr, QObject *parent=0);
-
-    Q_INVOKABLE void addEventListener(const QString &type, QJSValue function);
-    Q_INVOKABLE void removeEventListener(const QString &type, QJSValue function);
-
-    Q_INVOKABLE int setInterval(QJSValue expression, int delay);
-    Q_INVOKABLE void clearInterval(int timerId);
-
-    Q_INVOKABLE int setTimeout(QJSValue expression, int delay);
-    Q_INVOKABLE void clearTimeout(int timerId);
-
-    Q_INVOKABLE uint sendAppMessage(QJSValue message, QJSValue callbackForAck = QJSValue(), QJSValue callbackForNack = QJSValue());
-
-    Q_INVOKABLE void showSimpleNotificationOnPebble(const QString &title, const QString &body);
-
-    Q_INVOKABLE void openURL(const QUrl &url);
-
-    Q_INVOKABLE QString getAccountToken() const;
-    Q_INVOKABLE QString getWatchToken() const;
-
-    Q_INVOKABLE QJSValue createXMLHttpRequest();
-
-    void invokeCallbacks(const QString &type, const QJSValueList &args = QJSValueList());
-
-protected:
-    void timerEvent(QTimerEvent *event);
-
-private:
-    QJSValue buildAckEventObject(uint transaction, const QString &message = QString()) const;
-
-private:
-    AppInfo _appInfo;
-    JSKitManager *_mgr;
-    QHash<QString, QList<QJSValue>> _callbacks;
-    QHash<int, QJSValue> _intervals;
-    QHash<int, QJSValue> _timeouts;
-};
-
-class JSKitConsole : public QObject
-{
-    Q_OBJECT
-    QLoggingCategory l;
-
-public:
-    explicit JSKitConsole(QObject *parent=0);
-
-    Q_INVOKABLE void log(const QString &msg);
-    Q_INVOKABLE void warn(const QString &msg);
-    Q_INVOKABLE void error(const QString &msg);
-    Q_INVOKABLE void info(const QString &msg);
-};
-
-class JSKitLocalStorage : public QObject
-{
-    Q_OBJECT
-
-    Q_PROPERTY(int length READ length NOTIFY lengthChanged)
-
-public:
-    explicit JSKitLocalStorage(const QString &storagePath, const QUuid &uuid, QObject *parent=0);
-
-    int length() const;
-
-    Q_INVOKABLE QJSValue getItem(const QString &key) const;
-    Q_INVOKABLE void setItem(const QString &key, const QString &value);
-    Q_INVOKABLE void removeItem(const QString &key);
-
-    Q_INVOKABLE void clear();
-
-signals:
-    void lengthChanged();
-
-private:
-    void checkLengthChanged();
-    static QString getStorageFileFor(const QString &storageDir, const QUuid &uuid);
-
-private:
-    QSettings *_storage;
-    int _len;
-};
-
-class JSKitXMLHttpRequest : public QObject
-{
-    Q_OBJECT
-    QLoggingCategory l;
-    Q_ENUMS(ReadyStates)
-
-    Q_PROPERTY(QJSValue onload READ onload WRITE setOnload)
-    Q_PROPERTY(QJSValue ontimeout READ ontimeout WRITE setOntimeout)
-    Q_PROPERTY(QJSValue onerror READ onerror WRITE setOnerror)
-    Q_PROPERTY(uint readyState READ readyState NOTIFY readyStateChanged)
-    Q_PROPERTY(uint timeout READ timeout WRITE setTimeout)
-    Q_PROPERTY(uint status READ status NOTIFY statusChanged)
-    Q_PROPERTY(QString statusText READ statusText NOTIFY statusTextChanged)
-    Q_PROPERTY(QString responseType READ responseType WRITE setResponseType)
-    Q_PROPERTY(QJSValue response READ response NOTIFY responseChanged)
-    Q_PROPERTY(QString responseText READ responseText NOTIFY responseTextChanged)
-
-public:
-    explicit JSKitXMLHttpRequest(JSKitManager *mgr, QObject *parent = 0);
-    ~JSKitXMLHttpRequest();
-
-    enum ReadyStates {
-        UNSENT = 0,
-        OPENED = 1,
-        HEADERS_RECEIVED = 2,
-        LOADING = 3,
-        DONE = 4
-    };
-
-    Q_INVOKABLE void open(const QString &method, const QString &url, bool async = false, const QString &username = QString(), const QString &password = QString());
-    Q_INVOKABLE void setRequestHeader(const QString &header, const QString &value);
-    Q_INVOKABLE void send(const QJSValue &data = QJSValue(QJSValue::NullValue));
-    Q_INVOKABLE void abort();
-
-    QJSValue onload() const;
-    void setOnload(const QJSValue &value);
-    QJSValue ontimeout() const;
-    void setOntimeout(const QJSValue &value);
-    QJSValue onerror() const;
-    void setOnerror(const QJSValue &value);
-
-    uint readyState() const;
-
-    uint timeout() const;
-    void setTimeout(uint value);
-
-    uint status() const;
-    QString statusText() const;
-
-    QString responseType() const;
-    void setResponseType(const QString& type);
-
-    QJSValue response() const;
-    QString responseText() const;
-
-signals:
-    void readyStateChanged();
-    void statusChanged();
-    void statusTextChanged();
-    void responseChanged();
-    void responseTextChanged();
-
-private slots:
-    void handleReplyFinished();
-    void handleReplyError(QNetworkReply::NetworkError code);
-    void handleAuthenticationRequired(QNetworkReply *reply, QAuthenticator *auth);
-
-private:
-    JSKitManager *_mgr;
-    QNetworkAccessManager *_net;
-    QString _verb;
-    uint _timeout;
-    QString _username;
-    QString _password;
-    QNetworkRequest _request;
-    QNetworkReply *_reply;
-    QString _responseType;
-    QByteArray _response;
-    QJSValue _onload;
-    QJSValue _ontimeout;
-    QJSValue _onerror;
-};
-
-class JSKitGeolocation : public QObject
-{
-    Q_OBJECT
-    Q_ENUMS(PositionError)
-    QLoggingCategory l;
-
-    struct Watcher;
-
-public:
-    explicit JSKitGeolocation(JSKitManager *mgr, QObject *parent=0);
-
-    enum PositionError {
-        PERMISSION_DENIED = 1,
-        POSITION_UNAVAILABLE = 2,
-        TIMEOUT = 3
-    };
-
-    Q_INVOKABLE void getCurrentPosition(const QJSValue &successCallback, const QJSValue &errorCallback = QJSValue(), const QVariantMap &options = QVariantMap());
-    Q_INVOKABLE int watchPosition(const QJSValue &successCallback, const QJSValue &errorCallback = QJSValue(), const QVariantMap &options = QVariantMap());
-    Q_INVOKABLE void clearWatch(int watchId);
-
-private slots:
-    void handleError(const QGeoPositionInfoSource::Error error);
-    void handlePosition(const QGeoPositionInfo &pos);
-    void handleTimeout();
-    void updateTimeouts();
-
-private:
-    int setupWatcher(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options, bool once);
-    void removeWatcher(int watchId);
-
-    QJSValue buildPositionObject(const QGeoPositionInfo &pos);
-    QJSValue buildPositionErrorObject(PositionError error, const QString &message = QString());
-    QJSValue buildPositionErrorObject(const QGeoPositionInfoSource::Error error);
-    void invokeCallback(QJSValue callback, QJSValue event);
-
-private:
-    JSKitManager *_mgr;
-    QGeoPositionInfoSource *_source;
-
-    struct Watcher {
-        QJSValue successCallback;
-        QJSValue errorCallback;
-        int watchId;
-        bool once;
-        bool highAccuracy;
-        int timeout;
-        QElapsedTimer timer;
-    };
-
-    QList<Watcher> _watches;
-    int _lastWatchId;
-};
-
-#endif // JSKITMANAGER_P_H

=== modified file 'rockworkd/libpebble/pebble.cpp'
--- rockworkd/libpebble/pebble.cpp	2016-02-01 23:58:55 +0000
+++ rockworkd/libpebble/pebble.cpp	2016-02-06 06:08:05 +0000
@@ -7,7 +7,7 @@
 #include "phonecallendpoint.h"
 #include "appmanager.h"
 #include "appmsgmanager.h"
-#include "jskitmanager.h"
+#include "jskit/jskitmanager.h"
 #include "blobdb.h"
 #include "appdownloader.h"
 #include "screenshotendpoint.h"
@@ -166,6 +166,11 @@
     return m_serialNumber;
 }
 
+QString Pebble::language() const
+{
+    return m_language;
+}
+
 Capabilities Pebble::capabilities() const
 {
     return m_capabilities;
@@ -409,7 +414,8 @@
     qDebug() << "BT address" << wd.readBytes(6).toHex();
     qDebug() << "CRC:" << wd.read<quint32>();
     qDebug() << "Resource timestamp:" << QDateTime::fromTime_t(wd.read<quint32>());
-    qDebug() << "Language" << wd.readFixedString(6);
+    m_language = wd.readFixedString(6);
+    qDebug() << "Language" << m_language;
     qDebug() << "Language version" << wd.read<quint16>();
     // Capabilities is 64 bits but QFlags can only do 32 bits. lets split it into 2 * 32.
     // only 8 bits are used atm anyways.

=== modified file 'rockworkd/libpebble/pebble.h'
--- rockworkd/libpebble/pebble.h	2016-02-01 23:58:55 +0000
+++ rockworkd/libpebble/pebble.h	2016-02-06 06:08:05 +0000
@@ -35,6 +35,7 @@
     Q_PROPERTY(HardwarePlatform hardwarePlatform MEMBER m_hardwarePlatform)
     Q_PROPERTY(QString softwareVersion MEMBER m_softwareVersion)
     Q_PROPERTY(QString serialNumber MEMBER m_serialNumber)
+    Q_PROPERTY(QString language MEMBER m_language)
 
 public:
     explicit Pebble(const QBluetoothAddress &address, QObject *parent = 0);
@@ -56,6 +57,7 @@
     Model model() const;
     HardwarePlatform hardwarePlatform() const;
     QString serialNumber() const;
+    QString language() const;
     Capabilities capabilities() const;
     bool isUnfaithful() const;
     bool recovery() const;
@@ -143,6 +145,7 @@
     HardwarePlatform m_hardwarePlatform = HardwarePlatformUnknown;
     Model m_model = ModelUnknown;
     QString m_serialNumber;
+    QString m_language;
     Capabilities m_capabilities = CapabilityNone;
     bool m_isUnfaithful = false;
     bool m_recovery = false;

=== removed file 'rockworkd/libpebble/typedarray.js'
--- rockworkd/libpebble/typedarray.js	2016-01-03 15:22:24 +0000
+++ rockworkd/libpebble/typedarray.js	1970-01-01 00:00:00 +0000
@@ -1,1030 +0,0 @@
-/*
- Copyright (c) 2010, Linden Research, Inc.
- Copyright (c) 2014, Joshua Bell
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
- $/LicenseInfo$
- */
-
-// Original can be found at:
-//   https://bitbucket.org/lindenlab/llsd
-// Modifications by Joshua Bell [e-mail]
-//   https://github.com/inexorabletash/polyfill
-
-// ES3/ES5 implementation of the Krhonos Typed Array Specification
-//   Ref: http://www.khronos.org/registry/typedarray/specs/latest/
-//   Date: 2011-02-01
-//
-// Variations:
-//  * Allows typed_array.get/set() as alias for subscripts (typed_array[])
-//  * Gradually migrating structure from Khronos spec to ES6 spec
-(function(global) {
-  'use strict';
-  var undefined = (void 0); // Paranoia
-
-  // Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
-  // create, and consume so much memory, that the browser appears frozen.
-  var MAX_ARRAY_LENGTH = 1e5;
-
-  // Approximations of internal ECMAScript conversion functions
-  function Type(v) {
-    switch(typeof v) {
-    case 'undefined': return 'undefined';
-    case 'boolean': return 'boolean';
-    case 'number': return 'number';
-    case 'string': return 'string';
-    default: return v === null ? 'null' : 'object';
-    }
-  }
-
-  // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
-  function Class(v) { return Object.prototype.toString.call(v).replace(/^\[object *|\]$/g, ''); }
-  function IsCallable(o) { return typeof o === 'function'; }
-  function ToObject(v) {
-    if (v === null || v === undefined) throw TypeError();
-    return Object(v);
-  }
-  function ToInt32(v) { return v >> 0; }
-  function ToUint32(v) { return v >>> 0; }
-
-  // Snapshot intrinsics
-  var LN2 = Math.LN2,
-      abs = Math.abs,
-      floor = Math.floor,
-      log = Math.log,
-      max = Math.max,
-      min = Math.min,
-      pow = Math.pow,
-      round = Math.round;
-
-  // emulate ES5 getter/setter API using legacy APIs
-  // http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx
-  // (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but
-  // note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless)
-
-  (function() {
-    var orig = Object.defineProperty;
-    var dom_only = !(function(){try{return Object.defineProperty({},'x',{});}catch(_){return false;}}());
-
-    if (!orig || dom_only) {
-      Object.defineProperty = function (o, prop, desc) {
-        // In IE8 try built-in implementation for defining properties on DOM prototypes.
-        if (orig)
-          try { return orig(o, prop, desc); } catch (_) {}
-        if (o !== Object(o))
-          throw TypeError('Object.defineProperty called on non-object');
-        if (Object.prototype.__defineGetter__ && ('get' in desc))
-          Object.prototype.__defineGetter__.call(o, prop, desc.get);
-        if (Object.prototype.__defineSetter__ && ('set' in desc))
-          Object.prototype.__defineSetter__.call(o, prop, desc.set);
-        if ('value' in desc)
-          o[prop] = desc.value;
-        return o;
-      };
-    }
-  }());
-
-  // ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value)
-  // for index in 0 ... obj.length
-  function makeArrayAccessors(obj) {
-    if (obj.length > MAX_ARRAY_LENGTH) throw RangeError('Array too large for polyfill');
-
-    function makeArrayAccessor(index) {
-      Object.defineProperty(obj, index, {
-        'get': function() { return obj._getter(index); },
-        'set': function(v) { obj._setter(index, v); },
-        enumerable: true,
-        configurable: false
-      });
-    }
-
-    var i;
-    for (i = 0; i < obj.length; i += 1) {
-      makeArrayAccessor(i);
-    }
-  }
-
-  // Internal conversion functions:
-  //    pack<Type>()   - take a number (interpreted as Type), output a byte array
-  //    unpack<Type>() - take a byte array, output a Type-like number
-
-  function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
-  function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }
-
-  function packI8(n) { return [n & 0xff]; }
-  function unpackI8(bytes) { return as_signed(bytes[0], 8); }
-
-  function packU8(n) { return [n & 0xff]; }
-  function unpackU8(bytes) { return as_unsigned(bytes[0], 8); }
-
-  function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; }
-
-  function packI16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
-  function unpackI16(bytes) { return as_signed(bytes[0] << 8 | bytes[1], 16); }
-
-  function packU16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
-  function unpackU16(bytes) { return as_unsigned(bytes[0] << 8 | bytes[1], 16); }
-
-  function packI32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
-  function unpackI32(bytes) { return as_signed(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
-
-  function packU32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
-  function unpackU32(bytes) { return as_unsigned(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
-
-  function packIEEE754(v, ebits, fbits) {
-
-    var bias = (1 << (ebits - 1)) - 1,
-        s, e, f, ln,
-        i, bits, str, bytes;
-
-    function roundToEven(n) {
-      var w = floor(n), f = n - w;
-      if (f < 0.5)
-        return w;
-      if (f > 0.5)
-        return w + 1;
-      return w % 2 ? w + 1 : w;
-    }
-
-    // Compute sign, exponent, fraction
-    if (v !== v) {
-      // NaN
-      // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
-      e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
-    } else if (v === Infinity || v === -Infinity) {
-      e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
-    } else if (v === 0) {
-      e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
-    } else {
-      s = v < 0;
-      v = abs(v);
-
-      if (v >= pow(2, 1 - bias)) {
-        e = min(floor(log(v) / LN2), 1023);
-        f = roundToEven(v / pow(2, e) * pow(2, fbits));
-        if (f / pow(2, fbits) >= 2) {
-          e = e + 1;
-          f = 1;
-        }
-        if (e > bias) {
-          // Overflow
-          e = (1 << ebits) - 1;
-          f = 0;
-        } else {
-          // Normalized
-          e = e + bias;
-          f = f - pow(2, fbits);
-        }
-      } else {
-        // Denormalized
-        e = 0;
-        f = roundToEven(v / pow(2, 1 - bias - fbits));
-      }
-    }
-
-    // Pack sign, exponent, fraction
-    bits = [];
-    for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
-    for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
-    bits.push(s ? 1 : 0);
-    bits.reverse();
-    str = bits.join('');
-
-    // Bits to bytes
-    bytes = [];
-    while (str.length) {
-      bytes.push(parseInt(str.substring(0, 8), 2));
-      str = str.substring(8);
-    }
-    return bytes;
-  }
-
-  function unpackIEEE754(bytes, ebits, fbits) {
-    // Bytes to bits
-    var bits = [], i, j, b, str,
-        bias, s, e, f;
-
-    for (i = bytes.length; i; i -= 1) {
-      b = bytes[i - 1];
-      for (j = 8; j; j -= 1) {
-        bits.push(b % 2 ? 1 : 0); b = b >> 1;
-      }
-    }
-    bits.reverse();
-    str = bits.join('');
-
-    // Unpack sign, exponent, fraction
-    bias = (1 << (ebits - 1)) - 1;
-    s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
-    e = parseInt(str.substring(1, 1 + ebits), 2);
-    f = parseInt(str.substring(1 + ebits), 2);
-
-    // Produce number
-    if (e === (1 << ebits) - 1) {
-      return f !== 0 ? NaN : s * Infinity;
-    } else if (e > 0) {
-      // Normalized
-      return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
-    } else if (f !== 0) {
-      // Denormalized
-      return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
-    } else {
-      return s < 0 ? -0 : 0;
-    }
-  }
-
-  function unpackF64(b) { return unpackIEEE754(b, 11, 52); }
-  function packF64(v) { return packIEEE754(v, 11, 52); }
-  function unpackF32(b) { return unpackIEEE754(b, 8, 23); }
-  function packF32(v) { return packIEEE754(v, 8, 23); }
-
-  //
-  // 3 The ArrayBuffer Type
-  //
-
-  (function() {
-
-    function ArrayBuffer(length) {
-      length = ToInt32(length);
-      if (length < 0) throw RangeError('ArrayBuffer size is not a small enough positive integer.');
-      Object.defineProperty(this, 'byteLength', {value: length});
-      Object.defineProperty(this, '_bytes', {value: Array(length)});
-
-      for (var i = 0; i < length; i += 1)
-        this._bytes[i] = 0;
-    }
-
-    global.ArrayBuffer = global.ArrayBuffer || ArrayBuffer;
-
-    //
-    // 5 The Typed Array View Types
-    //
-
-    function $TypedArray$() {
-
-      // %TypedArray% ( length )
-      if (!arguments.length || typeof arguments[0] !== 'object') {
-        return (function(length) {
-          length = ToInt32(length);
-          if (length < 0) throw RangeError('length is not a small enough positive integer.');
-          Object.defineProperty(this, 'length', {value: length});
-          Object.defineProperty(this, 'byteLength', {value: length * this.BYTES_PER_ELEMENT});
-          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(this.byteLength)});
-          Object.defineProperty(this, 'byteOffset', {value: 0});
-
-         }).apply(this, arguments);
-      }
-
-      // %TypedArray% ( typedArray )
-      if (arguments.length >= 1 &&
-          Type(arguments[0]) === 'object' &&
-          arguments[0] instanceof $TypedArray$) {
-        return (function(typedArray){
-          if (this.constructor !== typedArray.constructor) throw TypeError();
-
-          var byteLength = typedArray.length * this.BYTES_PER_ELEMENT;
-          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
-          Object.defineProperty(this, 'byteLength', {value: byteLength});
-          Object.defineProperty(this, 'byteOffset', {value: 0});
-          Object.defineProperty(this, 'length', {value: typedArray.length});
-
-          for (var i = 0; i < this.length; i += 1)
-            this._setter(i, typedArray._getter(i));
-
-        }).apply(this, arguments);
-      }
-
-      // %TypedArray% ( array )
-      if (arguments.length >= 1 &&
-          Type(arguments[0]) === 'object' &&
-          !(arguments[0] instanceof $TypedArray$) &&
-          !(arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
-        return (function(array) {
-
-          var byteLength = array.length * this.BYTES_PER_ELEMENT;
-          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
-          Object.defineProperty(this, 'byteLength', {value: byteLength});
-          Object.defineProperty(this, 'byteOffset', {value: 0});
-          Object.defineProperty(this, 'length', {value: array.length});
-
-          for (var i = 0; i < this.length; i += 1) {
-            var s = array[i];
-            this._setter(i, Number(s));
-          }
-        }).apply(this, arguments);
-      }
-
-      // %TypedArray% ( buffer, byteOffset=0, length=undefined )
-      if (arguments.length >= 1 &&
-          Type(arguments[0]) === 'object' &&
-          (arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
-        return (function(buffer, byteOffset, length) {
-
-          byteOffset = ToUint32(byteOffset);
-          if (byteOffset > buffer.byteLength)
-            throw RangeError('byteOffset out of range');
-
-          // The given byteOffset must be a multiple of the element
-          // size of the specific type, otherwise an exception is raised.
-          if (byteOffset % this.BYTES_PER_ELEMENT)
-            throw RangeError('buffer length minus the byteOffset is not a multiple of the element size.');
-
-          if (length === undefined) {
-            var byteLength = buffer.byteLength - byteOffset;
-            if (byteLength % this.BYTES_PER_ELEMENT)
-              throw RangeError('length of buffer minus byteOffset not a multiple of the element size');
-            length = byteLength / this.BYTES_PER_ELEMENT;
-
-          } else {