RubyGems - mobox - Versions diffs - 0.0.1 - Mend

mobox 0.0.1

Files changed (833) hide show

data/vendor/phonegap/lib/webos/js/debugconsole.js ADDED Viewed

@@ -0,0 +1,62 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+/*
+ * This class provides access to the debugging console.
+ * @constructor
+ */
+function DebugConsole() {
+};
+/*
+ * Print a normal log message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.log = function(message) {
+	if (typeof message == 'object')
+		message = Object.toJSON(message);
+	this.error(message);
+};
+/*
+ * Print a warning message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.warn = function(message) {
+	if (typeof message == 'object')
+		message = Object.toJSON(message);
+	this.error(message);
+};
+/**
+ * Print an error message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.error = function(message) {
+	if (typeof message == 'object')
+		message = Object.toJSON(message);
+	console.log(JSON.stringify(message));
+};
+if (typeof window.debug == "undefined") window.debug = new DebugConsole();

data/vendor/phonegap/lib/webos/js/device.js ADDED Viewed

@@ -0,0 +1,98 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+/*
+ * this represents the mobile device, and provides properties for inspecting the model, version, UUID of the
+ * phone, etc.
+ * @constructor
+ */
+function Device() {
+    this.platform = "palm";
+    this.version  = null;
+    this.name     = null;
+    this.uuid     = null;
+    this.deviceInfo = null;
+};
+/*
+ * A direct call to return device information.
+ * Example:
+ *		var deviceinfo = JSON.stringify(navigator.device.getDeviceInfo()).replace(/,/g, ', ');
+ */
+Device.prototype.getDeviceInfo = function() {
+	return this.deviceInfo;//JSON.parse(PalmSystem.deviceInfo);
+};
+/*
+ * needs to be invoked in a <script> nested within the <body> it tells WebOS that the app is ready
+        TODO: see if we can get this added as in a document.write so that the user doesn't have to explicitly call this method
+ * Dependencies: Mojo.onKeyUp
+ * Example:
+ *		navigator.device.deviceReady();
+ */
+Device.prototype.deviceReady = function() {
+	// tell webOS this app is ready to show
+	if (window.PalmSystem) {
+		// setup keystroke events for forward and back gestures
+		document.body.addEventListener("keyup", Mojo.onKeyUp, true);
+		setTimeout(function() { PalmSystem.stageReady(); PalmSystem.activate(); }, 1);
+		alert = this.showBanner;
+	}
+    // fire deviceready event; taken straight from phonegap-iphone
+    // put on a different stack so it always fires after DOMContentLoaded
+    window.setTimeout(function () {
+        var e = document.createEvent('Events');
+        e.initEvent('deviceready');
+        document.dispatchEvent(e);
+    }, 10);
+	this.setUUID();
+	this.setDeviceInfo();
+};
+Device.prototype.setDeviceInfo = function() {
+    var parsedData = JSON.parse(PalmSystem.deviceInfo);
+    this.deviceInfo = parsedData;
+    this.version = parsedData.platformVersion;
+    this.name = parsedData.modelName;
+};
+Device.prototype.setUUID = function() {
+	//this is the only system property webos provides (may change?)
+	var that = this;
+	this.service = navigator.service.Request('palm://com.palm.preferences/systemProperties', {
+	    method:"Get",
+	    parameters:{"key": "com.palm.properties.nduid" },
+	    onSuccess: function(result) {
+			that.uuid = result["com.palm.properties.nduid"];
+		}
+    });
+};
+if (typeof window.device == 'undefined') window.device = navigator.device = new Device();

data/vendor/phonegap/lib/webos/js/file.js ADDED Viewed

@@ -0,0 +1,79 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+/*
+ * This class provides generic read and write access to the mobile device file system.
+ */
+function File() {
+	/**
+	 * The data of a file.
+	 */
+	this.data = "";
+	/**
+	 * The name of the file.
+	 */
+	this.name = "";
+};
+/*
+ * Reads a file from the mobile device. This function is asyncronous.
+ * @param {String} fileName The name (including the path) to the file on the mobile device.
+ * The file name will likely be device dependant.
+ * @param {Function} successCallback The function to call when the file is successfully read.
+ * @param {Function} errorCallback The function to call when there is an error reading the file from the device.
+ */
+File.prototype.read = function(fileName, successCallback, errorCallback) {
+	//Mojo has no file i/o yet, so we use an xhr. very limited
+	var path = fileName;	//incomplete
+	//Mojo.Log.error(path);
+	navigator.debug.error(path);
+	if (typeof successCallback != 'function')
+		successCallback = function () {};
+	if (typeof errorCallback != 'function')
+		errorCallback = function () {};
+	var xhr = new XMLHttpRequest();
+	xhr.onreadystatechange = function() {
+		if (xhr.readyState == 4) {
+			if (xhr.status == 200 && xhr.responseText != null) {
+				this.data = xhr.responseText;
+				this.name = path;
+				successCallback(this.data);
+			} else {
+				errorCallback({ name: xhr.status, message: "could not read file: " + path });
+			}
+		}
+	};
+	xhr.open("GET", path, true);
+	xhr.send();
+};
+/*
+ * Writes a file to the mobile device.
+ * @param {File} file The file to write to the device.
+ */
+File.prototype.write = function(file) {
+	//Palm does not provide file i/o
+};
+if (typeof navigator.file == "undefined") navigator.file = new File();

data/vendor/phonegap/lib/webos/js/geolocation.js ADDED Viewed

@@ -0,0 +1,232 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+/*
+ * This class provides access to device GPS data.
+ * @constructor
+ */
+function Geolocation() {
+    /**
+     * The last known GPS position.
+     */
+    this.lastPosition = null;
+    this.lastError = null;
+    this.callbacks = {
+        onLocationChanged: [],
+        onError: []
+    };
+};
+/*
+ * Asynchronously aquires the current position.
+ * @param {Function} successCallback The function to call when the position
+ * data is available
+ * @param {Function} errorCallback The function to call when there is an error
+ * getting the position data.
+ * @param {PositionOptions} options The options for getting the position data
+ * such as timeout.
+ */
+Geolocation.prototype.getCurrentPosition = function(successCallback, errorCallback, options) {
+    /*
+	var referenceTime = 0;
+    if (this.lastPosition)
+        referenceTime = this.lastPosition.timestamp;
+    else
+        this.start(options);
+	*/
+    var timeout = 20000;
+    if (typeof(options) == 'object' && options.timeout)
+    timeout = options.timeout;
+    if (typeof(successCallback) != 'function')
+    successCallback = function() {};
+    if (typeof(errorCallback) != 'function')
+    errorCallback = function() {};
+    /*
+    var dis = this;
+    var delay = 0;
+    var timer = setInterval(function() {
+        delay += interval;
+		//if we have a new position, call success and cancel the timer
+        if (dis.lastPosition && typeof(dis.lastPosition) == 'object' && dis.lastPosition.timestamp > referenceTime) {
+            successCallback(dis.lastPosition);
+            clearInterval(timer);
+        } else if (delay >= timeout) { //else if timeout has occured then call error and cancel the timer
+            errorCallback();
+            clearInterval(timer);
+        }
+		//else the interval gets called again
+    }, interval);
+	*/
+    var responseTime;
+    if (timeout <= 5000)
+    responseTime = 1;
+    else if (5000 < timeout <= 20000)
+    responseTime = 2;
+    else
+    responseTime = 3;
+    var timer = setTimeout(function() {
+        errorCallback({
+            message: "timeout"
+        });
+    },
+    timeout);
+    var startTime = (new Date()).getTime();
+    var alias = this;
+    // It may be that getCurrentPosition is less reliable than startTracking ... but
+    // not sure if we want to be starting and stopping the tracker if we're not watching.
+    //new Mojo.Service.Request('palm://com.palm.location', {
+    navigator.service.Request('palm://com.palm.location', {
+        method: "getCurrentPosition",
+        parameters: {
+            responseTime: responseTime
+        },
+        onSuccess: function(event) {
+            alias.lastPosition = {
+                coords: {
+                    latitude: event.latitude,
+                    longitude: event.longitude,
+                    altitude: (event.altitude >= 0 ? event.altitude: null),
+                    speed: (event.velocity >= 0 ? event.velocity: null),
+                    heading: (event.heading >= 0 ? event.heading: null),
+                    accuracy: (event.horizAccuracy >= 0 ? event.horizAccuracy: null),
+                    altitudeAccuracy: (event.vertAccuracy >= 0 ? event.vertAccuracy: null)
+                },
+                timestamp: new Date().getTime()
+            };
+            var responseTime = alias.lastPosition.timestamp - startTime;
+            if (responseTime <= timeout)
+            {
+                clearTimeout(timer);
+                successCallback(alias.lastPosition);
+            }
+        },
+        onFailure: function() {
+            errorCallback();
+        }
+    });
+};
+/*
+ * Asynchronously aquires the position repeatedly at a given interval.
+ * @param {Function} successCallback The function to call each time the position
+ * data is available
+ * @param {Function} errorCallback The function to call when there is an error
+ * getting the position data.
+ * @param {PositionOptions} options The options for getting the position data
+ * such as timeout and the frequency of the watch.
+ */
+Geolocation.prototype.watchPosition = function(successCallback, errorCallback, options) {
+    // Invoke the appropriate callback with a new Position object every time the implementation
+    // determines that the position of the hosting device has changed.
+    var frequency = 10000;
+    if (typeof(options) == 'object' && options.frequency)
+    frequency = options.frequency;
+    this.start(options, errorCallback);
+    var referenceTime = 0;
+    if (this.lastPosition)
+    referenceTime = this.lastPosition.timestamp;
+    var alias = this;
+    return setInterval(function() {
+        // check if we have a new position, if so call our successcallback
+        if (!alias.lastPosition)
+        return;
+        if (alias.lastPosition.timestamp > referenceTime)
+        successCallback(alias.lastPosition);
+    },
+    frequency);
+};
+/*
+ * Clears the specified position watch.
+ * @param {String} watchId The ID of the watch returned from #watchPosition.
+ */
+Geolocation.prototype.clearWatch = function(watchId) {
+    clearInterval(watchId);
+    this.stop();
+};
+Geolocation.prototype.start = function(options, errorCallback) {
+    //options.timeout;
+    //options.interval;
+    if (typeof(errorCallback) != 'function')
+    errorCallback = function() {};
+    var that = this;
+    var frequency = 10000;
+    if (typeof(options) == 'object' && options.frequency)
+    frequency = options.frequency;
+    var responseTime;
+    if (frequency <= 5000)
+    responseTime = 1;
+    else if (5000 < frequency <= 20000)
+    responseTime = 2;
+    else
+    responseTime = 3;
+    //location tracking does not support setting a custom interval :P
+    this.trackingHandle = navigator.service.Request('palm://com.palm.location', {
+        method: 'startTracking',
+        parameters: {
+            subscribe: true
+        },
+        onSuccess: function(event) {
+            that.lastPosition = {
+                coords: {
+                    latitude: event.latitude,
+                    longitude: event.longitude,
+                    altitude: (event.altitude >= 0 ? event.altitude: null),
+                    speed: (event.velocity >= 0 ? event.velocity: null),
+                    heading: (event.heading >= 0 ? event.heading: null),
+                    accuracy: (event.horizAccuracy >= 0 ? event.horizAccuracy: null),
+                    altitudeAccuracy: (event.vertAccuracy >= 0 ? event.vertAccuracy: null)
+                },
+                timestamp: new Date().getTime()
+            };
+        },
+        onFailure: function() {
+            errorCallback();
+        }
+    });
+};
+Geolocation.prototype.stop = function() {
+    this.trackingHandle.cancel();
+};
+if (typeof navigator.geolocation == "undefined") navigator.geolocation = new Geolocation();