1 /**

     2  * This class provides access to the device orientation.

     3  * @constructor

     4  */

     5 function Orientation() {

     6 	/**

     7 	 * The current orientation, or null if the orientation hasn't changed yet.

     8 	 */

     9 	this.currentOrientation = null;

    10 }

    11 

    12 /**

    13  * Set the current orientation of the phone.  This is called from the device automatically.

    14  * 

    15  * When the orientation is changed, the DOMEvent \c orientationChanged is dispatched against

    16  * the document element.  The event has the property \c orientation which can be used to retrieve

    17  * the device's current orientation, in addition to the \c Orientation.currentOrientation class property.

    18  *

    19  * @param {Number} orientation The orientation to be set

    20  */

    21 Orientation.prototype.setOrientation = function(orientation) {

    22 		if (orientation == this.currentOrientation) 

    23 			return;

    24 		var old = this.currentOrientation;

    25 

    26 		this.currentOrientation = orientation;

    27 		var e = document.createEvent('Events');

    28 		e.initEvent('orientationChanged', 'false', 'false');

    29 		e.orientation = orientation;

    30 		e.oldOrientation = old;

    31 		document.dispatchEvent(e);

    32 };

    33 

    34 /**

    35  * Asynchronously aquires the current orientation.

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

    37  * is known.

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

    39  * getting the orientation.

    40  */

    41 Orientation.prototype.getCurrentOrientation = function(successCallback, errorCallback) {

    42 	// If the orientation is available then call success

    43 	// If the orientation is not available then call error

    44 	try {

    45 		if (!this.serviceObj) 

    46 			this.serviceObj = this.getServiceObj();

    47 		

    48 		if (this.serviceObj == null) 

    49 			errorCallback({

    50 				name: "DeviceErr",

    51 				message: "Could not initialize service object"

    52 			});

    53 		

    54 		//get the sensor channel

    55 		var SensorParams = {

    56 			SearchCriterion: "Orientation"

    57 		};

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

    59 		

    60 		var error = returnvalue["ErrorCode"];

    61 		var errmsg = returnvalue["ErrorMessage"];

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

    63 			var ex = {

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

    65 				message: errmsg

    66 			};

    67 			errorCallback(ex);

    68 		}

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

    70 		var criteria = {

    71 			ChannelInfoMap: channelInfoMap,

    72 			ListeningType: "ChannelData"

    73 		};

    74 		

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

    76 			successCallback = function(){

    77 			};

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

    79 			errorCallback = function(){

    80 			};

    81 		

    82 		this.success_callback = successCallback;

    83 		this.error_callback = errorCallback;

    84 		

    85 		//create a closure to persist this instance of orientation object into the RegisterForNofication callback

    86 		var obj = this;

    87 		

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

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

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

    91 			var criteria = {

    92 				TransactionID: transId

    93 			};

    94 			try {

    95 				//var orientation = result.ReturnValue.DeviceOrientation;

    96 				obj.serviceObj.ISensor.Cancel(criteria);

    97 				

    98 				var orientation = null;

    99 				switch (result.ReturnValue.DeviceOrientation) {

   100 					case "DisplayUpwards": orientation = DisplayOrientation.FACE_UP; break;

   101 					case "DisplayDownwards": orientation = DisplayOrientation.FACE_DOWN; break;

   102 					case "DisplayUp": orientation = DisplayOrientation.PORTRAIT; break;

   103 					case "DisplayDown": orientation = DisplayOrientation.REVERSE_PORTRAIT; break;

   104 					case "DisplayRightUp": orientation = DisplayOrientation.LANDSCAPE_RIGHT_UP; break;

   105 					case "DisplayLeftUp": orientation = DisplayOrientation.LANDSCAPE_LEFT_UP; break;

   106 					

   107 				}

   108 				

   109 				obj.setOrientation(orientation);

   110 				

   111 				obj.success_callback(orientation);

   112 				

   113 			} 

   114 			catch (ex) {

   115 				obj.serviceObj.ISensor.Cancel(criteria);

   116 				obj.error_callback(ex);

   117 			}

   118 			

   119 		});

   120 	} catch (ex) {

   121 		errorCallback({ name: "OrientationError", message: ex.name + ": " + ex.message });

   122 	}

   123 };

   124 

   125 /**

   126  * Asynchronously aquires the orientation repeatedly at a given interval.

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

   128  * data is available.

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

   130  * getting the orientation data.

   131  */

   132 Orientation.prototype.watchOrientation = function(successCallback, errorCallback, options) {

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

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

   135 	this.getCurrentOrientation(successCallback, errorCallback);

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

   137 	return setInterval(function() {

   138 		navigator.orientation.getCurrentOrientation(successCallback, errorCallback);

   139 	}, frequency);

   140 };

   141 

   142 /**

   143  * Clears the specified orientation watch.

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

   145  */

   146 Orientation.prototype.clearWatch = function(watchId) {

   147 	clearInterval(watchId);

   148 };

   149 

   150 //gets the Acceleration Service Object from WRT

   151 Orientation.prototype.getServiceObj = function() {

   152 	var so;

   153 	

   154     try {

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

   156     } catch (ex) {

   157 		throw {

   158 			name: "DeviceError",

   159 			message: ex.name + ": " + ex.message

   160 		};

   161     }		

   162 	return so;

   163 };

   164 

   165 

   166 /**

   167  * This class encapsulates the possible orientation values.

   168  * @constructor

   169  */

   170 function DisplayOrientation() {

   171 	this.code = null;

   172 	this.message = "";

   173 }

   174 

   175 DisplayOrientation.PORTRAIT = 0;

   176 DisplayOrientation.REVERSE_PORTRAIT = 1;

   177 DisplayOrientation.LANDSCAPE_LEFT_UP = 2;

   178 DisplayOrientation.LANDSCAPE_RIGHT_UP = 3;

   179 DisplayOrientation.FACE_UP = 4;

   180 DisplayOrientation.FACE_DOWN = 5;

   181 

   182 if (typeof navigator.orientation == "undefined") navigator.orientation = new Orientation();