mobile_template 0.0.1

data/templates/cordova_android/framework/assets/js/battery.js

@@ -0,0 +1,134 @@
+/*
+ *     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.
+ */
+
+if (!Cordova.hasResource("battery")) {
+Cordova.addResource("battery");
+
+/**
+ * This class contains information about the current battery status.
+ * @constructor
+ */
+var Battery = function() {
+    this._level = null;
+    this._isPlugged = null;
+    this._batteryListener = [];
+    this._lowListener = [];
+    this._criticalListener = [];
+};
+
+/**
+ * Registers as an event producer for battery events.
+ * 
+ * @param {Object} eventType
+ * @param {Object} handler
+ * @param {Object} add
+ */
+Battery.prototype.eventHandler = function(eventType, handler, add) {
+    var me = navigator.battery;
+    if (add) {
+        // If there are no current registered event listeners start the battery listener on native side.
+        if (me._batteryListener.length === 0 && me._lowListener.length === 0 && me._criticalListener.length === 0) {
+            Cordova.exec(me._status, me._error, "Battery", "start", []);
+        }
+        
+        // Register the event listener in the proper array
+        if (eventType === "batterystatus") {
+            if (me._batteryListener.indexOf(handler) === -1) {
+                me._batteryListener.push(handler);
+            }
+        } else if (eventType === "batterylow") {
+            if (me._lowListener.indexOf(handler) === -1) {
+                me._lowListener.push(handler);
+            }
+        } else if (eventType === "batterycritical") {
+            if (me._criticalListener.indexOf(handler) === -1) {
+                me._criticalListener.push(handler);
+            }
+        }
+    } else {
+        var pos = -1;
+        // Remove the event listener from the proper array
+        if (eventType === "batterystatus") {
+            pos = me._batteryListener.indexOf(handler);
+            if (pos > -1) {
+                me._batteryListener.splice(pos, 1);        
+            }
+        } else if (eventType === "batterylow") {
+            pos = me._lowListener.indexOf(handler);
+            if (pos > -1) {
+                me._lowListener.splice(pos, 1);        
+            }
+        } else if (eventType === "batterycritical") {
+            pos = me._criticalListener.indexOf(handler);
+            if (pos > -1) {
+                me._criticalListener.splice(pos, 1);        
+            }
+        }
+        
+        // If there are no more registered event listeners stop the battery listener on native side.
+        if (me._batteryListener.length === 0 && me._lowListener.length === 0 && me._criticalListener.length === 0) {
+            Cordova.exec(null, null, "Battery", "stop", []);
+        }
+    }
+};
+
+/**
+ * Callback for battery status
+ * 
+ * @param {Object} info			keys: level, isPlugged
+ */
+Battery.prototype._status = function(info) {
+	if (info) {
+		var me = this;
+        var level = info.level;
+		if (me._level !== level || me._isPlugged !== info.isPlugged) {
+			// Fire batterystatus event
+			Cordova.fireWindowEvent("batterystatus", info);
+
+			// Fire low battery event
+			if (level === 20 || level === 5) {
+				if (level === 20) {
+					Cordova.fireWindowEvent("batterylow", info);
+				}
+				else {
+					Cordova.fireWindowEvent("batterycritical", info);
+				}
+			}
+		}
+		me._level = level;
+		me._isPlugged = info.isPlugged;	
+	}
+};
+
+/**
+ * Error callback for battery start
+ */
+Battery.prototype._error = function(e) {
+    console.log("Error initializing Battery: " + e);
+};
+
+Cordova.addConstructor(function() {
+    if (typeof navigator.battery === "undefined") {
+        navigator.battery = new Battery();
+        Cordova.addWindowEventHandler("batterystatus", navigator.battery.eventHandler);
+        Cordova.addWindowEventHandler("batterylow", navigator.battery.eventHandler);
+        Cordova.addWindowEventHandler("batterycritical", navigator.battery.eventHandler);
+    }
+});
+}

data/templates/cordova_android/framework/assets/js/camera.js

@@ -0,0 +1,168 @@
+/*
+ *     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.
+ */
+
+if (!Cordova.hasResource("camera")) {
+Cordova.addResource("camera");
+
+/**
+ * This class provides access to the device camera.
+ *
+ * @constructor
+ */
+var Camera = function() {
+    this.successCallback = null;
+    this.errorCallback = null;
+    this.options = null;
+};
+
+/**
+ * Format of image that returned from getPicture.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ *              { quality: 80,
+ *                destinationType: Camera.DestinationType.DATA_URL,
+ *                sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
+ */
+Camera.DestinationType = {
+    DATA_URL: 0,                // Return base64 encoded string
+    FILE_URI: 1                 // Return file uri (content://media/external/images/media/2 for Android)
+};
+Camera.prototype.DestinationType = Camera.DestinationType;
+
+/**
+ * Encoding of image returned from getPicture.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ *              { quality: 80,
+ *                destinationType: Camera.DestinationType.DATA_URL,
+ *                sourceType: Camera.PictureSourceType.CAMERA,
+ *                encodingType: Camera.EncodingType.PNG})
+*/
+Camera.EncodingType = {
+    JPEG: 0,                    // Return JPEG encoded image
+    PNG: 1                      // Return PNG encoded image
+};
+Camera.prototype.EncodingType = Camera.EncodingType;
+
+/**
+ * Type of pictures to select from.  Only applicable when
+ *      PictureSourceType is PHOTOLIBRARY or SAVEDPHOTOALBUM
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ *              { quality: 80,
+ *                destinationType: Camera.DestinationType.DATA_URL,
+ *                sourceType: Camera.PictureSourceType.PHOTOLIBRARY,
+ *                mediaType: Camera.MediaType.PICTURE})
+ */
+Camera.MediaType = {
+       PICTURE: 0,      // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
+       VIDEO: 1,        // allow selection of video only, ONLY RETURNS URL
+       ALLMEDIA : 2     // allow selection from all media types
+};
+Camera.prototype.MediaType = Camera.MediaType;
+
+
+/**
+ * Source to getPicture from.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ *              { quality: 80,
+ *                destinationType: Camera.DestinationType.DATA_URL,
+ *                sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
+ */
+Camera.PictureSourceType = {
+    PHOTOLIBRARY : 0,           // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
+    CAMERA : 1,                 // Take picture from camera
+    SAVEDPHOTOALBUM : 2         // Choose image from picture library (same as PHOTOLIBRARY for Android)
+};
+Camera.prototype.PictureSourceType = Camera.PictureSourceType;
+
+/**
+ * Gets a picture from source defined by "options.sourceType", and returns the
+ * image as defined by the "options.destinationType" option.
+
+ * The defaults are sourceType=CAMERA and destinationType=DATA_URL.
+ *
+ * @param {Function} successCallback
+ * @param {Function} errorCallback
+ * @param {Object} options
+ */
+Camera.prototype.getPicture = function(successCallback, errorCallback, options) {
+
+    // successCallback required
+    if (typeof successCallback !== "function") {
+        console.log("Camera Error: successCallback is not a function");
+        return;
+    }
+
+    // errorCallback optional
+    if (errorCallback && (typeof errorCallback !== "function")) {
+        console.log("Camera Error: errorCallback is not a function");
+        return;
+    }
+    
+    if (options === null || typeof options === "undefined") {
+        options = {};
+    }
+    if (options.quality === null || typeof options.quality === "undefined") {
+        options.quality = 80;
+    }
+    if (options.maxResolution === null || typeof options.maxResolution === "undefined") {
+        options.maxResolution = 0;
+    }
+    if (options.destinationType === null || typeof options.destinationType === "undefined") {
+        options.destinationType = Camera.DestinationType.FILE_URI;
+    }
+    if (options.sourceType === null || typeof options.sourceType === "undefined") {
+        options.sourceType = Camera.PictureSourceType.CAMERA;
+    }
+    if (options.encodingType === null || typeof options.encodingType === "undefined") {
+        options.encodingType = Camera.EncodingType.JPEG;
+    }
+    if (options.mediaType === null || typeof options.mediaType === "undefined") {
+        options.mediaType = Camera.MediaType.PICTURE;
+    }
+    if (options.targetWidth === null || typeof options.targetWidth === "undefined") {
+        options.targetWidth = -1;
+    } 
+    else if (typeof options.targetWidth === "string") {
+        var width = new Number(options.targetWidth);
+        if (isNaN(width) === false) {
+            options.targetWidth = width.valueOf();
+        }
+    }
+    if (options.targetHeight === null || typeof options.targetHeight === "undefined") {
+        options.targetHeight = -1;
+    } 
+    else if (typeof options.targetHeight === "string") {
+        var height = new Number(options.targetHeight);
+        if (isNaN(height) === false) {
+            options.targetHeight = height.valueOf();
+        }
+    }
+    
+    Cordova.exec(successCallback, errorCallback, "Camera", "takePicture", [options]);
+};
+
+Cordova.addConstructor(function() {
+    if (typeof navigator.camera === "undefined") {
+        navigator.camera = new Camera();
+    }
+});
+}

data/templates/cordova_android/framework/assets/js/capture.js

@@ -0,0 +1,203 @@
+/*
+ *     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.
+ */
+
+if (!Cordova.hasResource("capture")) {
+Cordova.addResource("capture");
+	
+/**
+ * Represents a single file.
+ *
+ * name {DOMString} name of the file, without path information
+ * fullPath {DOMString} the full path of the file, including the name
+ * type {DOMString} mime type
+ * lastModifiedDate {Date} last modified date
+ * size {Number} size of the file in bytes
+ */
+var MediaFile = function(name, fullPath, type, lastModifiedDate, size){
+	this.name = name || null;
+	this.fullPath = fullPath || null;
+	this.type = type || null;
+	this.lastModifiedDate = lastModifiedDate || null;
+	this.size = size || 0;
+};
+
+/**
+ * Launch device camera application for recording video(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ */
+MediaFile.prototype.getFormatData = function(successCallback, errorCallback){
+	Cordova.exec(successCallback, errorCallback, "Capture", "getFormatData", [this.fullPath, this.type]);
+};
+
+/**
+ * MediaFileData encapsulates format information of a media file.
+ *
+ * @param {DOMString} codecs
+ * @param {long} bitrate
+ * @param {long} height
+ * @param {long} width
+ * @param {float} duration
+ */
+var MediaFileData = function(codecs, bitrate, height, width, duration){
+	this.codecs = codecs || null;
+	this.bitrate = bitrate || 0;
+	this.height = height || 0;
+	this.width = width || 0;
+	this.duration = duration || 0;
+};
+
+/**
+ * The CaptureError interface encapsulates all errors in the Capture API.
+ */
+var CaptureError = function(){
+	this.code = null;
+};
+
+// Capture error codes
+CaptureError.CAPTURE_INTERNAL_ERR = 0;
+CaptureError.CAPTURE_APPLICATION_BUSY = 1;
+CaptureError.CAPTURE_INVALID_ARGUMENT = 2;
+CaptureError.CAPTURE_NO_MEDIA_FILES = 3;
+CaptureError.CAPTURE_NOT_SUPPORTED = 20;
+
+/**
+ * The Capture interface exposes an interface to the camera and microphone of the hosting device.
+ */
+var Capture = function(){
+	this.supportedAudioModes = [];
+	this.supportedImageModes = [];
+	this.supportedVideoModes = [];
+};
+
+/**
+ * Launch audio recorder application for recording audio clip(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureAudioOptions} options
+ */
+Capture.prototype.captureAudio = function(successCallback, errorCallback, options){
+    navigator.device.capture._capture("captureAudio", successCallback, errorCallback, options);
+};
+
+/**
+ * Launch camera application for taking image(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureImageOptions} options
+ */
+Capture.prototype.captureImage = function(successCallback, errorCallback, options){
+    navigator.device.capture._capture("captureImage", successCallback, errorCallback, options);
+};
+
+/**
+ * Launch device camera application for recording video(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureVideoOptions} options
+ */
+Capture.prototype.captureVideo = function(successCallback, errorCallback, options){
+    navigator.device.capture._capture("captureVideo", successCallback, errorCallback, options);
+};
+
+/**
+ * Launches the correct capture.
+ *
+ * @param (DOMString} type 
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureVideoOptions} options
+ */
+Capture.prototype._capture = function(type, successCallback, errorCallback, options){
+    var win = function(result) {
+        var mediaFiles = [];
+        var i;
+        for (i = 0; i < pluginResult.message.length; i++) {
+            var mediaFile = new MediaFile();
+            mediaFile.name = pluginResult.message[i].name;
+            mediaFile.fullPath = pluginResult.message[i].fullPath;
+            mediaFile.type = pluginResult.message[i].type;
+            mediaFile.lastModifiedDate = pluginResult.message[i].lastModifiedDate;
+            mediaFile.size = pluginResult.message[i].size;
+            mediaFiles.push(mediaFile);
+        }
+        successCallback(mediaFiles);
+    };
+    Cordova.exec(win, errorCallback, "Capture", type, [options]);
+};
+
+
+/**
+ * Encapsulates a set of parameters that the capture device supports.
+ */
+var ConfigurationData = function(){
+	// The ASCII-encoded string in lower case representing the media type. 
+	this.type = null;
+	// The height attribute represents height of the image or video in pixels. 
+	// In the case of a sound clip this attribute has value 0. 
+	this.height = 0;
+	// The width attribute represents width of the image or video in pixels. 
+	// In the case of a sound clip this attribute has value 0
+	this.width = 0;
+};
+
+/**
+ * Encapsulates all image capture operation configuration options.
+ */
+var CaptureImageOptions = function(){
+	// Upper limit of images user can take. Value must be equal or greater than 1.
+	this.limit = 1;
+	// The selected image mode. Must match with one of the elements in supportedImageModes array.
+	this.mode = null;
+};
+
+/**
+ * Encapsulates all video capture operation configuration options.
+ */
+var CaptureVideoOptions = function(){
+	// Upper limit of videos user can record. Value must be equal or greater than 1.
+	this.limit = 1;
+	// Maximum duration of a single video clip in seconds.
+	this.duration = 0;
+	// The selected video mode. Must match with one of the elements in supportedVideoModes array.
+	this.mode = null;
+};
+
+/**
+ * Encapsulates all audio capture operation configuration options.
+ */
+var CaptureAudioOptions = function(){
+	// Upper limit of sound clips user can record. Value must be equal or greater than 1.
+	this.limit = 1;
+	// Maximum duration of a single sound clip in seconds.
+	this.duration = 0;
+	// The selected audio mode. Must match with one of the elements in supportedAudioModes array.
+	this.mode = null;
+};
+
+Cordova.addConstructor(function(){
+	if (typeof navigator.device.capture === "undefined") {
+		navigator.device.capture = window.device.capture = new Capture();
+	}
+});
+}

data/templates/cordova_android/framework/assets/js/compass.js

@@ -0,0 +1,168 @@
+/*
+ *     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.
+ */
+
+if (!Cordova.hasResource("compass")) {
+Cordova.addResource("compass");
+
+var CompassError = function(){
+    this.code = null;
+};
+
+// Capture error codes
+CompassError.COMPASS_INTERNAL_ERR = 0;
+CompassError.COMPASS_NOT_SUPPORTED = 20;
+
+var CompassHeading = function() {
+    this.magneticHeading = null;
+    this.trueHeading = null;
+    this.headingAccuracy = null;
+    this.timestamp = null;
+};
+
+/**
+ * This class provides access to device Compass data.
+ * @constructor
+ */
+var Compass = function() {
+    /**
+     * The last known Compass position.
+     */
+    this.lastHeading = null;
+
+    /**
+     * List of compass watch timers
+     */
+    this.timers = {};
+};
+
+Compass.ERROR_MSG = ["Not running", "Starting", "", "Failed to start"];
+
+/**
+ * Asynchronously aquires the current heading.
+ *
+ * @param {Function} successCallback The function to call when the heading data is available
+ * @param {Function} errorCallback The function to call when there is an error getting the heading data. (OPTIONAL)
+ * @param {PositionOptions} options The options for getting the heading data such as timeout. (OPTIONAL)
+ */
+Compass.prototype.getCurrentHeading = function(successCallback, errorCallback, options) {
+
+    // successCallback required
+    if (typeof successCallback !== "function") {
+        console.log("Compass Error: successCallback is not a function");
+        return;
+    }
+
+    // errorCallback optional
+    if (errorCallback && (typeof errorCallback !== "function")) {
+        console.log("Compass Error: errorCallback is not a function");
+        return;
+    }
+    
+    var win = function(result) {
+        if (result.timestamp) {
+            var timestamp = new Date(result.timestamp);
+            result.timestamp = timestamp;
+        }
+        successCallback(result);   
+    };
+
+    // Get heading
+    Cordova.exec(win, errorCallback, "Compass", "getHeading", []);
+};
+
+/**
+ * Asynchronously aquires the heading repeatedly at a given interval.
+ *
+ * @param {Function} successCallback    The function to call each time the heading data is available
+ * @param {Function} errorCallback      The function to call when there is an error getting the heading data. (OPTIONAL)
+ * @param {HeadingOptions} options      The options for getting the heading data such as timeout and the frequency of the watch. (OPTIONAL)
+ * @return String                       The watch id that must be passed to #clearWatch to stop watching.
+ */
+Compass.prototype.watchHeading= function(successCallback, errorCallback, options) {
+
+    // Default interval (100 msec)
+    var frequency = (options !== undefined) ? options.frequency : 100;
+
+    // successCallback required
+    if (typeof successCallback !== "function") {
+        console.log("Compass Error: successCallback is not a function");
+        return;
+    }
+
+    // errorCallback optional
+    if (errorCallback && (typeof errorCallback !== "function")) {
+        console.log("Compass Error: errorCallback is not a function");
+        return;
+    }
+
+    // Make sure compass timeout > frequency + 10 sec
+    Cordova.exec(
+        function(timeout) {
+            if (timeout < (frequency + 10000)) {
+                Cordova.exec(null, null, "Compass", "setTimeout", [frequency + 10000]);
+            }
+        },
+        function(e) { }, "Compass", "getTimeout", []);
+
+    // Start watch timer to get headings
+    var id = Cordova.createUUID();
+    navigator.compass.timers[id] = setInterval(
+        function() {
+            var win = function(result) {
+                if (result.timestamp) {
+                    var timestamp = new Date(result.timestamp);
+                    result.timestamp = timestamp;
+                }
+                successCallback(result);   
+            };
+            Cordova.exec(win, errorCallback, "Compass", "getHeading", []);
+        }, (frequency ? frequency : 1));
+
+    return id;
+};
+
+
+/**
+ * Clears the specified heading watch.
+ *
+ * @param {String} id       The ID of the watch returned from #watchHeading.
+ */
+Compass.prototype.clearWatch = function(id) {
+
+    // Stop javascript timer & remove from timer list
+    if (id && navigator.compass.timers[id]) {
+        clearInterval(navigator.compass.timers[id]);
+        delete navigator.compass.timers[id];
+    }
+};
+
+Compass.prototype._castDate = function(pluginResult) {
+    if (pluginResult.message.timestamp) {
+        var timestamp = new Date(pluginResult.message.timestamp);
+        pluginResult.message.timestamp = timestamp;
+    }
+    return pluginResult;
+};
+
+Cordova.addConstructor(function() {
+    if (typeof navigator.compass === "undefined") {
+        navigator.compass = new Compass();
+    }
+});
+}