if (typeof(DeviceInfo) != 'object')

    DeviceInfo = {};

/**

 * This represents the PhoneGap API itself, and provides a global namespace for accessing

 * information about the state of PhoneGap.

 * @class

 */

PhoneGap = {

    queue: {

        ready: true,

        commands: [],

        timer: null

    },

    _constructors: []

};

/**

 * Boolean flag indicating if the PhoneGap API is available and initialized.

 */

PhoneGap.available = DeviceInfo.uuid != undefined;

/**

 * Execute a PhoneGap command in a queued fashion, to ensure commands do not

 * execute with any race conditions, and only run when PhoneGap is ready to

 * recieve them.

 * @param {String} command Command to be run in PhoneGap, e.g. "ClassName.method"

 * @param {String[]} [args] Zero or more arguments to pass to the method

 */

PhoneGap.exec = function() {

    PhoneGap.queue.commands.push(arguments);

    if (PhoneGap.queue.timer == null)

        PhoneGap.queue.timer = setInterval(PhoneGap.run_command, 10);

};

/**

 * Internal function used to dispatch the request to PhoneGap.  This needs to be implemented per-platform to

 * ensure that methods are called on the phone in a way appropriate for that device.

 * @private

 */

PhoneGap.run_command = function() {

};

/**

 * This class contains acceleration information

 * @constructor

 * @param {Number} x The force applied by the device in the x-axis.

 * @param {Number} y The force applied by the device in the y-axis.

 * @param {Number} z The force applied by the device in the z-axis.

 */

function Acceleration(x, y, z) {

	/**

	 * The force applied by the device in the x-axis.

	 */

	this.x = x;

	/**

	 * The force applied by the device in the y-axis.

	 */

	this.y = y;

	/**

	 * The force applied by the device in the z-axis.

	 */

	this.z = z;

	/**

	 * The time that the acceleration was obtained.

	 */

	this.timestamp = new Date().getTime();

}

/**

 * This class specifies the options for requesting acceleration data.

 * @constructor

 */

function AccelerationOptions() {

	/**

	 * The timeout after which if acceleration data cannot be obtained the errorCallback

	 * is called.

	 */

	this.timeout = 10000;

}

/**

 * This class provides access to device accelerometer data.

 * @constructor

 */

function Accelerometer() {

	/**

	 * The last known acceleration.

	 */

	this.lastAcceleration = null;

}

/**

 * Asynchronously aquires the current acceleration.

 * @param {Function} successCallback The function to call when the acceleration

 * data is available

 * @param {Function} errorCallback The function to call when there is an error 

 * getting the acceleration data.

 * @param {AccelerationOptions} options The options for getting the accelerometer data

 * such as timeout.

 */

Accelerometer.prototype.getCurrentAcceleration = function(successCallback, errorCallback, options) {

	// If the acceleration is available then call success

	// If the acceleration is not available then call error

	try {

		if (!this.serviceObj) 

			this.serviceObj = this.getServiceObj();

		if (this.serviceObj == null) 

			throw {

				name: "DeviceErr",

				message: "Could not initialize service object"

			};

		//get the sensor channel

		var SensorParams = {

			SearchCriterion: "AccelerometerAxis"

		};

		var returnvalue = this.serviceObj.ISensor.FindSensorChannel(SensorParams);

		var error = returnvalue["ErrorCode"];

		var errmsg = returnvalue["ErrorMessage"];

		if (!(error == 0 || error == 1012)) {

			var ex = {

				name: "Unable to find Sensor Channel: " + error,

				message: errmsg

			};

			throw ex;

		}

		var channelInfoMap = returnvalue["ReturnValue"][0];

		var criteria = {

			ChannelInfoMap: channelInfoMap,

			ListeningType: "ChannelData"

		};

		if (typeof(successCallback) != 'function') 

			successCallback = function(){

			};

		if (typeof(errorCallback) != 'function') 

			errorCallback = function(){

			};

		this.success_callback = successCallback;

		this.error_callback = errorCallback;

		//create a closure to persist this instance of Accelerometer into the RegisterForNofication callback

		var obj = this;

		// TODO: this call crashes WRT, but there is no other way to read the accel sensor

		// http://discussion.forum.nokia.com/forum/showthread.php?t=182151&highlight=memory+leak

		this.serviceObj.ISensor.RegisterForNotification(criteria, function(transId, eventCode, result){

			try {

				var criteria = {

					TransactionID: transId

				};

				obj.serviceObj.ISensor.Cancel(criteria);

				var accel = new Acceleration(result.ReturnValue.XAxisData, result.ReturnValue.YAxisData, result.ReturnValue.ZAxisData);

				Accelerometer.lastAcceleration = accel;

				obj.success_callback(accel);

			} 

			catch (ex) {

				obj.serviceObj.ISensor.Cancel(criteria);

				obj.error_callback(ex);

			}

		});

	} catch (ex) {

		errorCallback(ex);

	}

};

/**

 * Asynchronously aquires the acceleration repeatedly at a given interval.

 * @param {Function} successCallback The function to call each time the acceleration

 * data is available

 * @param {Function} errorCallback The function to call when there is an error 

 * getting the acceleration data.

 * @param {AccelerationOptions} options The options for getting the accelerometer data

 * such as timeout.

 */

Accelerometer.prototype.watchAcceleration = function(successCallback, errorCallback, options) {

	this.getCurrentAcceleration(successCallback, errorCallback, options);

	// TODO: add the interval id to a list so we can clear all watches

 	var frequency = (options != undefined)? options.frequency : 10000;

	return setInterval(function() {

		navigator.accelerometer.getCurrentAcceleration(successCallback, errorCallback, options);

	}, frequency);

};

/**

 * Clears the specified accelerometer watch.

 * @param {String} watchId The ID of the watch returned from #watchAcceleration.

 */

Accelerometer.prototype.clearWatch = function(watchId) {

	clearInterval(watchId);

};

//gets the Acceleration Service Object from WRT

Accelerometer.prototype.getServiceObj = function() {

	var so;

    try {

        so = device.getServiceObject("Service.Sensor", "ISensor");

    } catch (ex) {

		throw {

			name: "DeviceError",

			message: "Could not initialize accel service object (" + ex.name + ": " + ex.message + ")"

		};

    }		

	return so;

};

if (typeof navigator.accelerometer == "undefined") navigator.accelerometer = new Accelerometer();/**

 * This class provides access to the device media, interfaces to both sound and video

 * @constructor

 */

function Audio(src, successCallback, errorCallback) {

	this.src = src;

	this.successCallback = successCallback;

	this.errorCallback = errorCallback;												

}

Audio.prototype.record = function() {

};

Audio.prototype.play = function() {

try {

	if (document.getElementById('gapsound'))

		document.body.removeChild(document.getElementById('gapsound'));

	var obj;

	obj = document.createElement("embed");

	obj.setAttribute("id", "gapsound");

	obj.setAttribute("type", "audio/x-mpeg");

	obj.setAttribute("width", "0");

	obj.setAttribute("width", "0");

	obj.setAttribute("hidden", "true");

	obj.setAttribute("autostart", "true");

	obj.setAttribute("src", this.src);

	document.body.appendChild(obj);

} catch (ex) { debug.log(ex.name + ": " + ex.message); }

};

Audio.prototype.pause = function() {

};

Audio.prototype.stop = function() {

	document.body.removeChild(document.getElementById('gapsound'));

};

/**

 * This class provides access to the device camera.

 * @constructor

 */

function Camera() {

	this.success_callback = null;

	this.error_callback = null;

}

/**

 * We use the Platform Services 2.0 API here. So we must include a portion of the

 * PS 2.0 source code (camera API). 

 * @param {Function} successCallback

 * @param {Function} errorCallback

 * @param {Object} options

 */

Camera.prototype.getPicture = function(successCallback, errorCallback, options){

	try {

		if (!this.serviceObj) {

			this.serviceObj = com.nokia.device.load("", "com.nokia.device.camera", "");

		}

		if (!this.serviceObj) {

			throw {

				name: "CameraError",

				message: "could not load camera service"

			};

		}

		var obj = this;

		obj.success_callback = successCallback;

		obj.error_callback = errorCallback;

		this.serviceObj.startCamera( function(transactionID, errorCode, outPut) { 

			//outPut should be an array of image urls (local), or an error code

			if (errorCode == 0) {

				obj.success_callback(outPut);

			}

			else {

				obj.error_callback({

					name: "CameraError",

					message: errorCode

				});

			}

		});

	} catch (ex) {

		errorCallback.call(ex);

	}

};

if (typeof navigator.camera == "undefined") navigator.camera = new Camera();/*

Copyright © 2009 Nokia. All rights reserved.

Code licensed under the BSD License:

Software License Agreement (BSD License) Copyright © 2009 Nokia.

All rights reserved.

Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 

Neither the name of Nokia Corporation. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission of Nokia Corporation. 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

version: 1.0

*/

// utility.js

//

// This file contains some utility functions for S60 providers

// Start an application and wait for it to exit

//TBD: Get rid of this global, use closures instead

DeviceError.prototype = new Error(); //inheritance occurs here

DeviceError.prototype.constructor = DeviceError; //If this not present then, it uses default constructor of Error

//constructor for DeviceError.

function DeviceError(message,code) 

{

	this.toString = concatenate;

	this.code = code;

	this.name = "DeviceException";//we can even overwrite default name "Error"

	this.message=message; 

}

function concatenate()

{

	return (this.name+":"+" "+this.message+" "+this.code);

}

function splitErrorMessage(errmessage)

{

	if(errmessage.search(/:/)!=-1)

	{

		if((errmessage.split(":").length)==2)

		{

			return errmessage.split(":")[1];

		}

		if((errmessage.split(":").length)>2)

		{

			return errmessage.split(":")[2];

		}

	}

	return errmessage;

}

var __s60_start_and_wait_cb;

function __s60_on_app_exit(){

  widget.onshow = null;

  if(__s60_start_and_wait_cb != null){

    __s60_start_and_wait_cb();

  }

}

function __s60_on_app_start(){

  widget.onhide = null;

  widget.onshow = __s60_on_app_exit;

}

// This function cannot actually force JS to wait,

// but it does supply a callback the apps can use

// to continue processing on return from the app.

// Apps should take care not to reinvoke this and

// should be careful about any other processing

// that might happen while the app is running.

function __s60_start_and_wait(id, args, app_exit_cb){

  __s60_start_and_wait_cb = app_exit_cb;

  widget.onhide = __s60_on_app_start;

  widget.openApplication(id, args);

}

function __s60_api_not_supported(){

  throw(err_ServiceNotSupported);

}

function __s60_enumerate_object(object, namespace, func, param){

    var key;

    for(key in object){

        var propname;

       	if(namespace){

	    propname = namespace + "." + key;

	}

	else{

	    propname = key;

	}

        var value = object[key];

        if(typeof value == "object"){

	  __s60_enumerate_object(value, propname, func, param);

	}

	else {

	  func(propname,value, param);

	}

    }

}

/*

Copyright © 2009 Nokia. All rights reserved.

Code licensed under the BSD License:

Software License Agreement (BSD License) Copyright © 2009 Nokia.

All rights reserved.

Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 

Neither the name of Nokia Corporation. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission of Nokia Corporation. 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

version: 1.0

*/

var __device_debug_on__ = true;

var err_missing_argument = 1003;

var event_cancelled = 3;

var err_bad_argument = 1002;

var err_InvalidService_Argument = 1000;

var err_ServiceNotReady = 1006;

var err_ServiceNotSupported = 1004;

function __device_debug(text){

  //if(__device_debug_on__) alert(text);

}

function __device_handle_exception(e, text){

	__device_debug(text);

	throw(e);

}

function __device_typeof(value)

{

	// First check to see if the value is undefined.

	if (value == undefined) {

        return "undefined";

    }

	// Check for objects created with the "new" keyword.

	if (value instanceof Object) {

		// Check whether it's a string object.

		if (value instanceof String) {

			return "String";

		}

		// Check whether it's an array object/array literal.

		else 

			if (value instanceof Array) {

				return "Array";

			}

	}

	// dealing with a literal.

		if (typeof value) {

			if (typeof value == "object") {

				if (typeof value == "object" && !value) {

					return "null";

				}

			}

           // if not null check for other types

				// Check if it's a string literal.

			else if (typeof value == "string") {

					return "string";

				}

		}	 

}

// The top-level service object. It would be nice to use a namespace here 

// (com.nokia.device.service), but emulating namespaces still allows name clashes.

/*

var sp_device = {

        //services: null; // TBD: Make the services list a member of this object?

	load: __device_service_load,

        listServices: __device_service_list,

        listInterfaces: __device_service_interfaces,

        version: "0.1",

        info: "device prototype"

};

*/

if(undefined == com)

    var com={};

if( typeof com != "object")

    throw("com defined as non object");

if(undefined == com.nokia)

    com.nokia = {};

if( typeof com.nokia != "object")

    throw("com.nokia defined as non object");

if(undefined == com.nokia.device)

    com.nokia.device = {

        load: __device_service_load,

        listServices: __device_service_list,

        listInterfaces: __device_service_interfaces,

        version: "0.1",

        info: "device prototype"

        };

else

    throw("com.nokia.device already defined");

com.nokia.device.SORT_ASCENDING = 0;

com.nokia.device.SORT_DESCENDING = 1;

com.nokia.device.SORT_BY_DATE = 0;

com.nokia.device.SORT_BY_SENDER = 1;

com.nokia.device.STATUS_READ = 0;

com.nokia.device.STATUS_UNREAD = 1;

// Configure the services offered.

var __device_services_inited = false;