summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--daemon/appmsgmanager.cpp57
-rw-r--r--daemon/appmsgmanager.h8
-rw-r--r--daemon/daemon.pro17
-rw-r--r--daemon/js/typedarray.js1030
-rw-r--r--daemon/jskitmanager.cpp45
-rw-r--r--daemon/jskitmanager.h1
-rw-r--r--daemon/jskitobjects.cpp275
-rw-r--r--daemon/jskitobjects.h42
-rw-r--r--daemon/packer.cpp16
-rw-r--r--rpm/pebble.spec1
-rw-r--r--rpm/pebble.yaml1
11 files changed, 1374 insertions, 119 deletions
diff --git a/daemon/appmsgmanager.cpp b/daemon/appmsgmanager.cpp
index d5f527e..312043a 100644
--- a/daemon/appmsgmanager.cpp
+++ b/daemon/appmsgmanager.cpp
@@ -7,14 +7,14 @@
// TODO D-Bus server for non JS kit apps!!!!
AppMsgManager::AppMsgManager(AppManager *apps, WatchConnector *watch, QObject *parent)
- : QObject(parent), apps(apps), watch(watch), lastTransactionId(0), timeout(new QTimer(this))
+ : QObject(parent), apps(apps), watch(watch), _lastTransactionId(0), _timeout(new QTimer(this))
{
connect(watch, &WatchConnector::connectedChanged,
this, &AppMsgManager::handleWatchConnectedChanged);
- timeout->setSingleShot(true);
- timeout->setInterval(3000);
- connect(timeout, &QTimer::timeout,
+ _timeout->setSingleShot(true);
+ _timeout->setInterval(3000);
+ connect(_timeout, &QTimer::timeout,
this, &AppMsgManager::handleTimeout);
watch->setEndpointHandler(WatchConnector::watchLAUNCHER,
@@ -53,7 +53,7 @@ void AppMsgManager::send(const QUuid &uuid, const QVariantMap &data, const std::
{
PendingTransaction trans;
trans.uuid = uuid;
- trans.transactionId = ++lastTransactionId;
+ trans.transactionId = ++_lastTransactionId;
trans.dict = mapAppKeys(uuid, data);
trans.ackCallback = ackCallback;
trans.nackCallback = nackCallback;
@@ -61,14 +61,24 @@ void AppMsgManager::send(const QUuid &uuid, const QVariantMap &data, const std::
logger()->debug() << "Queueing appmsg" << trans.transactionId << "to" << trans.uuid
<< "with dict" << trans.dict;
- pending.enqueue(trans);
- if (pending.size() == 1) {
+ _pending.enqueue(trans);
+ if (_pending.size() == 1) {
// This is the only transaction on the queue
// Therefore, we were idle before: we can submit this transaction right now.
transmitNextPendingTransaction();
}
}
+uint AppMsgManager::lastTransactionId() const
+{
+ return _lastTransactionId;
+}
+
+uint AppMsgManager::nextTransactionId() const
+{
+ return _lastTransactionId + 1;
+}
+
void AppMsgManager::send(const QUuid &uuid, const QVariantMap &data)
{
std::function<void()> nullCallback;
@@ -244,23 +254,24 @@ void AppMsgManager::handleAckMessage(const QByteArray &data, bool ack)
return;
}
- if (pending.empty()) {
- logger()->warn() << "received an ack/nack but no active transaction";
- }
-
const quint8 type = data[0];
const quint8 recv_transaction = data[1];
Q_ASSERT(type == WatchConnector::appmsgACK || type == WatchConnector::appmsgNACK);
- PendingTransaction &trans = pending.head();
+ if (_pending.empty()) {
+ logger()->warn() << "received an ack/nack for transaction" << recv_transaction << "but no transaction is pending";
+ return;
+ }
+
+ PendingTransaction &trans = _pending.head();
if (trans.transactionId != recv_transaction) {
logger()->warn() << "received an ack/nack but for the wrong transaction";
}
logger()->debug() << "Got " << (ack ? "ACK" : "NACK") << " to transaction" << trans.transactionId;
- timeout->stop();
+ _timeout->stop();
if (ack) {
if (trans.ackCallback) {
@@ -272,9 +283,9 @@ void AppMsgManager::handleAckMessage(const QByteArray &data, bool ack)
}
}
- pending.dequeue();
+ _pending.dequeue();
- if (!pending.empty()) {
+ if (!_pending.empty()) {
transmitNextPendingTransaction();
}
}
@@ -291,8 +302,8 @@ void AppMsgManager::handleWatchConnectedChanged()
void AppMsgManager::handleTimeout()
{
// Abort the first transaction
- Q_ASSERT(!pending.empty());
- PendingTransaction trans = pending.dequeue();
+ Q_ASSERT(!_pending.empty());
+ PendingTransaction trans = _pending.dequeue();
logger()->warn() << "timeout on appmsg transaction" << trans.transactionId;
@@ -300,31 +311,31 @@ void AppMsgManager::handleTimeout()
trans.nackCallback();
}
- if (!pending.empty()) {
+ if (!_pending.empty()) {
transmitNextPendingTransaction();
}
}
void AppMsgManager::transmitNextPendingTransaction()
{
- Q_ASSERT(!pending.empty());
- PendingTransaction &trans = pending.head();
+ Q_ASSERT(!_pending.empty());
+ PendingTransaction &trans = _pending.head();
QByteArray msg = buildPushMessage(trans.transactionId, trans.uuid, trans.dict);
watch->sendMessage(WatchConnector::watchAPPLICATION_MESSAGE, msg);
- timeout->start();
+ _timeout->start();
}
void AppMsgManager::abortPendingTransactions()
{
// Invoke all the NACK callbacks in the pending queue, then drop them.
- Q_FOREACH(const PendingTransaction &trans, pending) {
+ Q_FOREACH(const PendingTransaction &trans, _pending) {
if (trans.nackCallback) {
trans.nackCallback();
}
}
- pending.clear();
+ _pending.clear();
}
diff --git a/daemon/appmsgmanager.h b/daemon/appmsgmanager.h
index 498d3fa..9aaabd4 100644
--- a/daemon/appmsgmanager.h
+++ b/daemon/appmsgmanager.h
@@ -19,6 +19,8 @@ public:
void send(const QUuid &uuid, const QVariantMap &data,
const std::function<void()> &ackCallback,
const std::function<void()> &nackCallback);
+ uint lastTransactionId() const;
+ uint nextTransactionId() const;
public slots:
void send(const QUuid &uuid, const QVariantMap &data);
@@ -54,7 +56,7 @@ private slots:
private:
AppManager *apps;
WatchConnector *watch;
- quint8 lastTransactionId;
+ quint8 _lastTransactionId;
struct PendingTransaction {
quint8 transactionId;
@@ -63,8 +65,8 @@ private:
std::function<void()> ackCallback;
std::function<void()> nackCallback;
};
- QQueue<PendingTransaction> pending;
- QTimer *timeout;
+ QQueue<PendingTransaction> _pending;
+ QTimer *_timeout;
};
#endif // APPMSGMANAGER_H
diff --git a/daemon/daemon.pro b/daemon/daemon.pro
index 0c4154b..81570c7 100644
--- a/daemon/daemon.pro
+++ b/daemon/daemon.pro
@@ -50,23 +50,24 @@ HEADERS += \
OTHER_FILES += \
../log4qt-debug.conf \
- ../log4qt-release.conf
+ ../log4qt-release.conf \
+ js/typedarray.js
DBUS_ADAPTORS += ../org.pebbled.Watch.xml
-INSTALLS += target pebbled confile
+INSTALLS += target systemd confile js
target.path = /usr/bin
-pebbled.files = $${TARGET}.service
-pebbled.path = /usr/lib/systemd/user
+systemd.files = $${TARGET}.service
+systemd.path = /usr/lib/systemd/user
+
+js.files = js/*
+js.path = /usr/share/pebble/js
CONFIG(debug, debug|release) {
- message(Debug build)
confile.extra = cp $$PWD/../log4qt-debug.conf $$OUT_PWD/../log4qt.conf
-}
-else {
- message(Release build)
+} else {
confile.extra = cp $$PWD/../log4qt-release.conf $$OUT_PWD/../log4qt.conf
}
diff --git a/daemon/js/typedarray.js b/daemon/js/typedarray.js
new file mode 100644
index 0000000..eec78a2
--- /dev/null
+++ b/daemon/js/typedarray.js
@@ -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 inexorabletash@gmail.com
+// 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));
diff --git a/daemon/jskitmanager.cpp b/daemon/jskitmanager.cpp
index 894d6f5..c5a80e9 100644
--- a/daemon/jskitmanager.cpp
+++ b/daemon/jskitmanager.cpp
@@ -100,6 +100,29 @@ void JSKitManager::handleAppMessage(const QUuid &uuid, const QVariantMap &data)
}
}
+bool JSKitManager::loadJsFile(const QString &filename)
+{
+ Q_ASSERT(_engine);
+
+ QFile file(filename);
+ if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+ logger()->warn() << "Failed to load JS file:" << file.fileName();
+ return false;
+ }
+
+ logger()->debug() << "now parsing" << file.fileName();
+
+ QJSValue result = _engine->evaluate(QString::fromUtf8(file.readAll()), file.fileName());
+ if (result.isError()) {
+ logger()->warn() << "error while evaluating JS script:" << describeError(result);
+ return false;
+ }
+
+ logger()->debug() << "JS script evaluated";
+
+ return true;
+}
+
void JSKitManager::startJsApp()
{
if (_engine) stopJsApp();
@@ -136,24 +159,13 @@ void JSKitManager::startJsApp()
);
Q_ASSERT(!result.isError());
- QFile scriptFile(_curApp.path() + "/pebble-js-app.js");
- if (!scriptFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
- logger()->warn() << "Failed to open JS file at:" << scriptFile.fileName();
- stopJsApp();
- return;
- }
-
- QString script = QString::fromUtf8(scriptFile.readAll());
+ // Polyfills...
+ loadJsFile("/usr/share/pebble/js/typedarray.js");
- logger()->debug() << "now parsing" << scriptFile.fileName();
-
- result = _engine->evaluate(script, scriptFile.fileName());
- if (result.isError()) {
- logger()->warn() << "error while evaluating JSKit script:" << describeError(result);
- }
-
- logger()->debug() << "JS script evaluated";
+ // Now load the actual script
+ loadJsFile(_curApp.path() + "/pebble-js-app.js");
+ // We try to invoke the callbacks even if script parsing resulted in error...
_jspebble->invokeCallbacks("ready");
}
@@ -173,5 +185,4 @@ void JSKitManager::stopJsApp()
_jsgeo = 0;
_jspebble->deleteLater();
_jspebble = 0;
-
}
diff --git a/daemon/jskitmanager.h b/daemon/jskitmanager.h
index 873489b..4239f91 100644
--- a/daemon/jskitmanager.h
+++ b/daemon/jskitmanager.h
@@ -38,6 +38,7 @@ private slots:
void handleAppMessage(const QUuid &uuid, const QVariantMap &data);
private:
+ bool loadJsFile(const QString &filename);
void startJsApp();
void stopJsApp();
diff --git a/daemon/jskitobjects.cpp b/daemon/jskitobjects.cpp
index 1fc0062..e55f2d5 100644
--- a/daemon/jskitobjects.cpp
+++ b/daemon/jskitobjects.cpp
@@ -34,35 +34,45 @@ void JSKitPebble::removeEventListener(const QString &type, QJSValue function)
}
}
-void JSKitPebble::sendAppMessage(QJSValue message, QJSValue callbackForAck, QJSValue callbackForNack)
+uint JSKitPebble::sendAppMessage(QJSValue message, QJSValue callbackForAck, QJSValue callbackForNack)
{
QVariantMap data = message.toVariant().toMap();
+ QPointer<JSKitPebble> pebbObj = this;
+ uint transactionId = _mgr->_appmsg->nextTransactionId();
logger()->debug() << "sendAppMessage" << data;
- _mgr->_appmsg->send(_appInfo.uuid(), data, [this, callbackForAck]() mutable {
+ _mgr->_appmsg->send(_appInfo.uuid(), data,
+ [pebbObj, transactionId, callbackForAck]() mutable {
+ if (pebbObj.isNull()) return;
if (callbackForAck.isCallable()) {
- logger()->debug() << "Invoking ack callback";
- QJSValue result = callbackForAck.call(QJSValueList({buildAckEventObject()}));
+ pebbObj->logger()->debug() << "Invoking ack callback";
+ QJSValue event = pebbObj->buildAckEventObject(transactionId);
+ QJSValue result = callbackForAck.call(QJSValueList({event}));
if (result.isError()) {
- logger()->warn() << "error while invoking ACK callback" << callbackForAck.toString() << ":"
- << JSKitManager::describeError(result);
+ pebbObj->logger()->warn() << "error while invoking ACK callback" << callbackForAck.toString() << ":"
+ << JSKitManager::describeError(result);
}
} else {
- logger()->debug() << "Ack callback not callable";
+ pebbObj->logger()->debug() << "Ack callback not callable";
}
- }, [this, callbackForNack]() mutable {
+ },
+ [pebbObj, transactionId, callbackForNack]() mutable {
+ if (pebbObj.isNull()) return;
if (callbackForNack.isCallable()) {
- logger()->debug() << "Invoking nack callback";
- QJSValue result = callbackForNack.call(QJSValueList({buildAckEventObject()}));
+ pebbObj->logger()->debug() << "Invoking nack callback";
+ QJSValue event = pebbObj->buildAckEventObject(transactionId, "NACK from watch");
+ QJSValue result = callbackForNack.call(QJSValueList({event}));
if (result.isError()) {
- logger()->warn() << "error while invoking NACK callback" << callbackForNack.toString() << ":"
- << JSKitManager::describeError(result);
+ pebbObj->logger()->warn() << "error while invoking NACK callback" << callbackForNack.toString() << ":"
+ << JSKitManager::describeError(result);
}
} else {
- logger()->debug() << "Nack callback not callable";
+ pebbObj->logger()->debug() << "Nack callback not callable";
}
});
+
+ return transactionId;
}
void JSKitPebble::showSimpleNotificationOnPebble(const QString &title, const QString &body)
@@ -84,17 +94,21 @@ QJSValue JSKitPebble::createXMLHttpRequest()
return _mgr->engine()->newQObject(xhr);
}
-QJSValue JSKitPebble::buildAckEventObject() const
+QJSValue JSKitPebble::buildAckEventObject(uint transaction, const QString &message) const
{
QJSEngine *engine = _mgr->engine();
QJSValue eventObj = engine->newObject();
QJSValue dataObj = engine->newObject();
- // Why do scripts need the real transactionId?
- // No idea. Just fake it.
- dataObj.setProperty("transactionId", engine->toScriptValue(0));
+ 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;
}
@@ -184,7 +198,7 @@ QString JSKitLocalStorage::getStorageFileFor(const QUuid &uuid)
JSKitXMLHttpRequest::JSKitXMLHttpRequest(JSKitManager *mgr, QObject *parent)
: QObject(parent), _mgr(mgr),
- _net(new QNetworkAccessManager(this)), _reply(0)
+ _net(new QNetworkAccessManager(this)), _timeout(0), _reply(0)
{
logger()->debug() << "constructed";
}
@@ -194,7 +208,7 @@ JSKitXMLHttpRequest::~JSKitXMLHttpRequest()
logger()->debug() << "destructed";
}
-void JSKitXMLHttpRequest::open(const QString &method, const QString &url, bool async)
+void JSKitXMLHttpRequest::open(const QString &method, const QString &url, bool async, const QString &username, const QString &password)
{
if (_reply) {
_reply->deleteLater();
@@ -212,17 +226,63 @@ void JSKitXMLHttpRequest::setRequestHeader(const QString &header, const QString
_request.setRawHeader(header.toLatin1(), value.toLatin1());
}
-void JSKitXMLHttpRequest::send(const QString &body)
+void JSKitXMLHttpRequest::send(const QJSValue &data)
{
- QBuffer *buffer = new QBuffer;
- buffer->setData(body.toUtf8());
- logger()->debug() << "sending" << _verb << "to" << _request.url() << "with" << body;
+ 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());
+ }
+
+ logger()->debug() << "passed an ArrayBufferView of" << byteData.length() << "bytes";
+ } else {
+ logger()->warn() << "passed an unknown/invalid ArrayBuffer" << data.toString();
+ }
+ } else {
+ logger()->warn() << "passed an unknown object" << data.toString();
+ }
+
+ }
+
+ QBuffer *buffer;
+ if (!byteData.isEmpty()) {
+ buffer = new QBuffer;
+ buffer->setData(byteData);
+ } else {
+ buffer = 0;
+ }
+
+ logger()->debug() << "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);
- buffer->setParent(_reply); // So that it gets deleted alongside the reply object.
+
+ if (buffer) {
+ // So that it gets deleted alongside the reply object.
+ buffer->setParent(_reply);
+ }
}
void JSKitXMLHttpRequest::abort()
@@ -263,7 +323,7 @@ void JSKitXMLHttpRequest::setOnerror(const QJSValue &value)
_onerror = value;
}
-unsigned short JSKitXMLHttpRequest::readyState() const
+uint JSKitXMLHttpRequest::readyState() const
{
if (!_reply) {
return UNSENT;
@@ -274,7 +334,18 @@ unsigned short JSKitXMLHttpRequest::readyState() const
}
}
-unsigned short JSKitXMLHttpRequest::status() const
+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;
@@ -283,6 +354,53 @@ unsigned short JSKitXMLHttpRequest::status() const
}
}
+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)
+{
+ logger()->debug() << "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);
+ logger()->debug() << "returning ArrayBuffer of" << _response.size() << "bytes";
+ } else {
+ logger()->warn() << "Cannot find proto of ArrayBuffer";
+ }
+ return arrayBuf;
+ } else {
+ logger()->warn() << "unsupported responseType:" << _responseType;
+ return engine->toScriptValue<void*>(0);
+ }
+}
+
QString JSKitXMLHttpRequest::responseText() const
{
return QString::fromUtf8(_response);
@@ -300,6 +418,8 @@ void JSKitXMLHttpRequest::handleReplyFinished()
emit readyStateChanged();
emit statusChanged();
+ emit statusTextChanged();
+ emit responseChanged();
emit responseTextChanged();
if (_onload.isCallable()) {
@@ -322,6 +442,10 @@ void JSKitXMLHttpRequest::handleReplyError(QNetworkReply::NetworkError code)
logger()->info() << "reply error" << code;
+ emit readyStateChanged();
+ emit statusChanged();
+ emit statusTextChanged();
+
if (_onerror.isCallable()) {
logger()->debug() << "going to call onerror handler:" << _onload.toString();
QJSValue result = _onerror.callWithInstance(_mgr->engine()->newQObject(this));
@@ -338,7 +462,6 @@ JSKitGeolocation::JSKitGeolocation(JSKitManager *mgr)
void JSKitGeolocation::getCurrentPosition(const QJSValue &successCallback, const QJSValue &errorCallback, const QVariantMap &options)
{
- logger()->debug() << Q_FUNC_INFO;
setupWatcher(successCallback, errorCallback, options, true);
}
@@ -360,12 +483,14 @@ void JSKitGeolocation::handleError(QGeoPositionInfoSource::Error error)
void JSKitGeolocation::handlePosition(const QGeoPositionInfo &pos)
{
+ logger()->debug() << "got position at" << pos.timestamp() << "type" << pos.coordinate().type();
+
if (_watches.empty()) {
logger()->warn() << "got position update but no one is watching";
+ _source->stopUpdates(); // Just in case.
+ return;
}
- logger()->debug() << "got position at" << pos.timestamp() << "type" << pos.coordinate().type();
-
QJSValue obj = buildPositionObject(pos);
for (auto it = _watches.begin(); it != _watches.end(); /*no adv*/) {
@@ -374,30 +499,76 @@ void JSKitGeolocation::handlePosition(const QGeoPositionInfo &pos)
if (it->once) {
it = _watches.erase(it);
} else {
+ it->timer.restart();
++it;
}
}
+}
+
+void JSKitGeolocation::handleTimeout()
+{
+ logger()->info() << "positioning timeout";
if (_watches.empty()) {
+ logger()->warn() << "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)) {
+ logger()->info() << "positioning timeout for watch" << it->watchId;
+ 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::handleTimeout()
+void JSKitGeolocation::updateTimeouts()
{
+ int once_timeout = -1, updates_timeout = -1;
+
logger()->debug() << Q_FUNC_INFO;
- // TODO
-}
-uint JSKitGeolocation::minimumTimeout() const
-{
- uint minimum = std::numeric_limits<uint>::max();
Q_FOREACH(const Watcher &watcher, _watches) {
- if (!watcher.once) {
- minimum = qMin<uint>(watcher.timeout, minimum);
+ qint64 rem_timeout = watcher.timeout - watcher.timer.elapsed();
+ logger()->debug() << "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;
+ }
}
}
- return minimum;
+
+ if (updates_timeout >= 0) {
+ logger()->debug() << "setting location update interval to" << updates_timeout;
+ _source->setUpdateInterval(updates_timeout);
+ _source->startUpdates();
+ } else {
+ logger()->debug() << "stopping updates";
+ _source->stopUpdates();
+ }
+
+ if (once_timeout >= 0) {
+ logger()->debug() << "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)
@@ -406,11 +577,11 @@ int JSKitGeolocation::setupWatcher(const QJSValue &successCallback, const QJSVal
watcher.successCallback = successCallback;
watcher.errorCallback = errorCallback;
watcher.highAccuracy = options.value("enableHighAccuracy").toBool();
- watcher.timeout = options.value("timeout", 0xFFFFFFFFU).toUInt();
+ watcher.timeout = options.value("timeout", std::numeric_limits<int>::max() - 1).toInt();
watcher.once = once;
watcher.watchId = ++_lastWatchId;
- uint maximumAge = options.value("maximumAge", 0).toUInt();
+ qlonglong maximumAge = options.value("maximumAge", 0).toLongLong();
logger()->debug() << "setting up watcher, gps=" << watcher.highAccuracy << "timeout=" << watcher.timeout << "maximumAge=" << maximumAge << "once=" << once;
@@ -434,25 +605,20 @@ int JSKitGeolocation::setupWatcher(const QJSValue &successCallback, const QJSVal
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;
}
}
- if (once) {
- _source->requestUpdate(watcher.timeout);
- } else {
- uint timeout = minimumTimeout();
- logger()->debug() << "setting location update interval to" << timeout;
- _source->setUpdateInterval(timeout);
- logger()->debug() << "starting location updates";
- _source->startUpdates();
- }
-
+ watcher.timer.start();
_watches.append(watcher);
logger()->debug() << "added new watch" << watcher.watchId;
+ QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
+
return watcher.watchId;
}
@@ -474,14 +640,7 @@ void JSKitGeolocation::removeWatcher(int watchId)
return;
}
- if (_watches.empty()) {
- logger()->debug() << "stopping updates";
- _source->stopUpdates();
- } else {
- uint timeout = minimumTimeout();
- logger()->debug() << "setting location update interval to" << timeout;
- _source->setUpdateInterval(timeout);
- }
+ QMetaObject::invokeMethod(this, "updateTimeouts", Qt::QueuedConnection);
}
QJSValue JSKitGeolocation::buildPositionObject(const QGeoPositionInfo &pos)
diff --git a/daemon/jskitobjects.h b/daemon/jskitobjects.h
index 5f039c1..b1954c0 100644
--- a/daemon/jskitobjects.h
+++ b/daemon/jskitobjects.h
@@ -1,6 +1,7 @@
#ifndef JSKITMANAGER_P_H
#define JSKITMANAGER_P_H
+#include <QElapsedTimer>
#include <QSettings>
#include <QNetworkRequest>
#include <QNetworkReply>
@@ -18,7 +19,7 @@ public:
Q_INVOKABLE void addEventListener(const QString &type, QJSValue function);
Q_INVOKABLE void removeEventListener(const QString &type, QJSValue function);
- Q_INVOKABLE void sendAppMessage(QJSValue message, QJSValue callbackForAck = QJSValue(), QJSValue callbackForNack = QJSValue());
+ Q_INVOKABLE uint sendAppMessage(QJSValue message, QJSValue callbackForAck = QJSValue(), QJSValue callbackForNack = QJSValue());
Q_INVOKABLE void showSimpleNotificationOnPebble(const QString &title, const QString &body);
@@ -29,7 +30,7 @@ public:
void invokeCallbacks(const QString &type, const QJSValueList &args = QJSValueList());
private:
- QJSValue buildAckEventObject() const;
+ QJSValue buildAckEventObject(uint transaction, const QString &message = QString()) const;
private:
AppInfo _appInfo;
@@ -81,12 +82,17 @@ class JSKitXMLHttpRequest : public QObject
{
Q_OBJECT
LOG4QT_DECLARE_QCLASS_LOGGER
+ 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(unsigned short readyState READ readyState NOTIFY readyStateChanged)
- Q_PROPERTY(unsigned short status READ status NOTIFY statusChanged)
+ 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:
@@ -101,9 +107,9 @@ public:
DONE = 4
};
- Q_INVOKABLE void open(const QString &method, const QString &url, bool async = false);
+ 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 QString &body = QString());
+ Q_INVOKABLE void send(const QJSValue &data = QJSValue(QJSValue::NullValue));
Q_INVOKABLE void abort();
QJSValue onload() const;
@@ -113,13 +119,25 @@ public:
QJSValue onerror() const;
void setOnerror(const QJSValue &value);
- unsigned short readyState() const;
- unsigned short status() const;
+ 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:
@@ -130,8 +148,10 @@ private:
JSKitManager *_mgr;
QNetworkAccessManager *_net;
QString _verb;
+ uint _timeout;
QNetworkRequest _request;
QNetworkReply *_reply;
+ QString _responseType;
QByteArray _response;
QJSValue _onload;
QJSValue _ontimeout;
@@ -163,11 +183,12 @@ private slots:
void handleError(const QGeoPositionInfoSource::Error error);
void handlePosition(const QGeoPositionInfo &pos);
void handleTimeout();
+ void updateTimeouts();
private:
- uint minimumTimeout() const;
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);
@@ -183,7 +204,8 @@ private:
int watchId;
bool once;
bool highAccuracy;
- uint timeout;
+ int timeout;
+ QElapsedTimer timer;
};
QList<Watcher> _watches;
diff --git a/daemon/packer.cpp b/daemon/packer.cpp
index 569f7a8..4dabf96 100644
--- a/daemon/packer.cpp
+++ b/daemon/packer.cpp
@@ -74,6 +74,22 @@ void Packer::writeDict(const QMap<int, QVariant> &d)
break;
}
+ case QMetaType::QVariantList: {
+ // Generally a JS array, which we marshal as a byte array.
+ QVariantList list = it.value().toList();
+ QByteArray ba;
+ ba.reserve(list.size());
+
+ Q_FOREACH (const QVariant &v, list) {
+ ba.append(v.toInt());
+ }
+
+ writeLE<quint8>(WatchConnector::typeBYTES);
+ writeLE<quint16>(ba.size());
+ _buf->append(ba);
+ break;
+ }
+
default:
logger()->warn() << "Unknown dict item type:" << it.value().typeName();
/* Fallthrough */
diff --git a/rpm/pebble.spec b/rpm/pebble.spec
index ba5b4b3..f2e3611 100644
--- a/rpm/pebble.spec
+++ b/rpm/pebble.spec
@@ -80,6 +80,7 @@ systemctl --user daemon-reload
%defattr(-,root,root,-)
%{_bindir}
%{_datadir}/%{name}/qml
+%{_datadir}/%{name}/js
%{_datadir}/applications/%{name}.desktop
%{_datadir}/icons/hicolor/86x86/apps/%{name}.png
%{_libdir}/systemd/user/%{name}d.service
diff --git a/rpm/pebble.yaml b/rpm/pebble.yaml
index 45fb409..ca0b068 100644
--- a/rpm/pebble.yaml
+++ b/rpm/pebble.yaml
@@ -31,6 +31,7 @@ Requires:
Files:
- '%{_bindir}'
- '%{_datadir}/%{name}/qml'
+- '%{_datadir}/%{name}/js'
- '%{_datadir}/applications/%{name}.desktop'
- '%{_datadir}/icons/hicolor/86x86/apps/%{name}.png'
- '%{_libdir}/systemd/user/%{name}d.service'
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-15 06:19:11 +0000