1 /**

     2  * This class provides access to device GPS data.

     3  * @constructor

     4  */

     5 function Geolocation() {

     6     /**

     7      * The last known GPS position.

     8      */

     9     this.lastPosition = null;

    10     this.lastError = null;

    11     this.callbacks = {

    12         onLocationChanged: [],

    13         onError:           []

    14     };

    15 };

    16 

    17 /**

    18  * Asynchronously aquires the current position.

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

    20  * data is available

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

    22  * getting the position data.

    23  * @param {PositionOptions} options The options for getting the position data

    24  * such as timeout.

    25  */

    26 Geolocation.prototype.getCurrentPosition = function(successCallback, errorCallback, options) {

    27     var referenceTime = 0;

    28     if (this.lastPosition)

    29         referenceTime = this.lastPosition.timestamp;

    30     else

    31         this.start(options);

    32 

    33     var timeout = 20000;

    34     var interval = 500;

    35     if (typeof(options) == 'object' && options.interval)

    36         interval = options.interval;

    37 

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

    39         successCallback = function() {};

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

    41         errorCallback = function() {};

    42 

    43     var dis = this;

    44     var delay = 0;

    45     var timer = setInterval(function() {

    46         delay += interval;

    47 		//if we have a new position, call success and cancel the timer

    48         if (dis.lastPosition && dis.lastPosition.timestamp > referenceTime) {

    49             successCallback(dis.lastPosition);

    50             clearInterval(timer);

    51         } else if (delay >= timeout) { //else if timeout has occured then call error and cancel the timer

    52             errorCallback();

    53             clearInterval(timer);

    54         }

    55 		//else the interval gets called again

    56     }, interval);

    57 };

    58 

    59 /**

    60  * Asynchronously aquires the position repeatedly at a given interval.

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

    62  * data is available

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

    64  * getting the position data.

    65  * @param {PositionOptions} options The options for getting the position data

    66  * such as timeout and the frequency of the watch.

    67  */

    68 Geolocation.prototype.watchPosition = function(successCallback, errorCallback, options) {

    69 	// Invoke the appropriate callback with a new Position object every time the implementation 

    70 	// determines that the position of the hosting device has changed. 

    71 	this.getCurrentPosition(successCallback, errorCallback, options);

    72 	var frequency = 10000;

    73         if (typeof options == 'object' && options.frequency)

    74             frequency = options.frequency;

    75 	var that = this;

    76 	return setInterval(function() {

    77 		that.getCurrentPosition(successCallback, errorCallback, options);

    78 	}, frequency);

    79 };

    80 

    81 

    82 /**

    83  * Clears the specified position watch.

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

    85  */

    86 Geolocation.prototype.clearWatch = function(watchId) {

    87 	clearInterval(watchId);

    88 };

    89 

    90 Geolocation.prototype.start = function(options) {

    91 	var so = device.getServiceObject("Service.Location", "ILocation");

    92 	

    93 	//construct the criteria for our location request

    94 	var updateOptions = new Object();

    95 	// Specify that location information need not be guaranteed. This helps in

    96 	// that the widget doesn't need to wait for that information possibly indefinitely.

    97 	updateOptions.PartialUpdates = true;

    98 	

    99 	//default 15 seconds

   100 	if (typeof(options) == 'object' && options.timeout) 

   101 		//options.timeout in in ms, updateOptions.UpdateTimeout in microsecs

   102 		updateOptions.UpdateTimeOut = options.timeout * 1000;

   103 

   104 	//default 1 second

   105 	if (typeof(options) == 'object' && options.interval) 

   106 		//options.timeout in in ms, updateOptions.UpdateTimeout in microsecs

   107 		updateOptions.UpdateInterval = options.interval * 1000;

   108 	

   109 	// Initialize the criteria for the GetLocation call

   110 	var trackCriteria = new Object();

   111 	// could use "BasicLocationInformation" or "GenericLocationInfo"

   112 	trackCriteria.LocationInformationClass = "GenericLocationInfo";

   113 	trackCriteria.Updateoptions = updateOptions;

   114 	

   115 	var dis = this;

   116 	so.ILocation.Trace(trackCriteria, function(transId, eventCode, result) {

   117 		var retVal = result.ReturnValue;

   118 

   119 		if (result.ErrorCode != 0 || isNaN(retVal.Latitude))

   120 			return;

   121 		

   122 		// heading options: retVal.TrueCourse, retVal.MagneticHeading, retVal.Heading, retVal.MagneticCourse

   123 		// but retVal.Heading was the only field being returned with data on the test device (Nokia 5800)

   124 		// WRT does not provide accuracy

   125 		var newCoords = new Coordinates(retVal.Latitude, retVal.Longitude, retVal.Altitude, null, retVal.Heading, retVal.HorizontalSpeed);

   126 		var positionObj = { coords: newCoords, timestamp: (new Date()).getTime() };

   127 

   128 		dis.lastPosition = positionObj;

   129 	});

   130 	

   131 };

   132 

   133 

   134 if (typeof navigator.geolocation == "undefined") navigator.geolocation = new Geolocation();

   135