1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Defination of class CCalendarInterface

    15 *

    16 */

    17 

    18 

    19 // sensors service interface

    20 

    21 var __device_sensors_service_entry = {"name": null, 

    22 				      "version": null,

    23 				      "proto": __device_sensors,

    24 				      "descriptor": __device_sensors_descriptor,

    25 				      "providers": [{"descriptor": __sp_sensors_descriptor, "instance": __sp_sensors_instance}]

    26 				     };

    27 		   

    28 

    29 // Private location prototype: called from service factory

    30 function __device_sensors(provider){

    31   //Private properties

    32   this.provider = provider;

    33   //Read-only properties

    34   this.interfaceName = provider.descriptor.interfaceName;

    35   this.version = provider.descriptor.version;  

    36   //Extended methods

    37   this.getChannels = __device_sensors_getChannels;

    38   this.startChannel = __device_sensors_setNotifier;

    39   this.stopChannel = __device_sensors_cancelNotifier;

    40   this.getScaleFactor = __device_sensors_getScaleFactor;

    41 }

    42 

    43 function __device_sensors_descriptor(provider){

    44   this.interfaceName = provider.interfaceName;

    45   this.version = provider.version;

    46 }

    47 

    48 function __device_sensors_getChannels(){

    49   return this.provider.getChannels();

    50 }

    51 

    52 function __device_sensors_setNotifier(sensors_cb, channel,__fail_cb){

    53   return this.provider.startChannel(sensors_cb, channel,__fail_cb);

    54 }

    55 

    56 function __device_sensors_cancelNotifier(channel){

    57   return this.provider.stopChannel(channel);

    58 }

    59 

    60 function __device_sensors_getScaleFactor(channel){

    61   return this.provider.getScaleFactor(channel);

    62 }

    63 

    64 

    65 

    66 

    67 

    68 

    69 /*

    70 Copyright © 2009 Nokia. All rights reserved.

    71 Code licensed under the BSD License:

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

    73 All rights reserved.

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

    75 

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

    77 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. 

    78 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. 

    79 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.

    80 

    81 version: 2.7.0

    82 */

    83 

    84 

    85 // S60 sp-based sensors provider

    86 

    87 

    88 

    89 function __sp_sensors_descriptor(){

    90   //Read-only properties

    91   this.interfaceName = "sensors";

    92   if(window.__Service_Interface_Ver)

    93 	this.version =__Service_Interface_Ver;

    94   else

    95 	this.version =1.0;

    96   //Class-static properties 

    97 }

    98 

    99 function __sp_sensors_instance(){

   100   //Descriptor

   101   this.descriptor = new __sp_sensors_descriptor();

   102   //Extended methods

   103   this.getChannels = __sp_sensors_getChannels;

   104   this.startChannel =  __sp_sensors_setNotifier;

   105   this.stopChannel =  __sp_sensors_cancelNotifier;

   106   this.getScaleFactor = __sp_sensors_getScaleFactor;

   107   //Public properties

   108   

   109   try {

   110     //__device_debug("Trying sensors service");

   111     this.so = device.getServiceObject('Service.Sensor', 'ISensor');

   112     //__device_debug("Got sensors service object: ");    

   113   }

   114   catch (e){

   115     this.so = null;

   116     __device_handle_exception (e, "sensors service not available");

   117   }

   118 }

   119 

   120 var __rotation_channel = {

   121   ucb: null,

   122   tids: null

   123 };

   124 

   125 

   126 var __XYZ_channel = {

   127   ucb: null,

   128   tids: null

   129 };

   130 

   131 var __orientation_channel = {

   132   ucb: null,

   133   tids: null

   134 };

   135 

   136 function __rotation_cb(arg1, arg2, arg3){

   137     if(arg2 != event_cancelled)

   138         {

   139         var output = null ;    

   140         if (arg3.ReturnValue)

   141             {

   142             var time = arg3.ReturnValue.TimeStamp;

   143             var xrot = arg3.ReturnValue.XRotation;

   144             var yrot = arg3.ReturnValue.YRotation;

   145             var zrot = arg3.ReturnValue.ZRotation;

   146 			      arg3.ReturnValue.close();

   147             output = {};

   148 	          modifyObjectBaseProp(output); 

   149             output.timeStamp = time;

   150             output.rotationAboutXAxis = xrot;

   151             output.rotationAboutYAxis = yrot;

   152             output.rotationAboutZAxis = zrot;

   153             }

   154          __rotation_channel.ucb(output);

   155         }

   156 		

   157 }

   158 

   159 function __XYZ_cb(arg1, arg2, arg3){

   160     if(arg2 != event_cancelled)

   161         {

   162         var output = null ;    

   163         if (arg3.ReturnValue)

   164             {

   165             var time = arg3.ReturnValue.TimeStamp;

   166             var xaxis = arg3.ReturnValue.XAxisData;

   167             var yaxis = arg3.ReturnValue.YAxisData;

   168             var zaxis = arg3.ReturnValue.ZAxisData;

   169 			      arg3.ReturnValue.close();

   170             output = {}; 

   171 	          modifyObjectBaseProp(output);

   172             output.timeStamp = time;

   173             output.axisX = xaxis;

   174             output.axisY = yaxis;

   175             output.axisZ = zaxis;

   176             }    

   177         __XYZ_channel.ucb(output);

   178         }

   179 		

   180 }

   181 

   182 function __orientation_cb(arg1, arg2, arg3){

   183     if(arg2 != event_cancelled)

   184         {

   185         var output = null ;    

   186         if (arg3.ReturnValue)

   187             {

   188             var time = arg3.ReturnValue.TimeStamp;

   189             var orientation = arg3.ReturnValue.DeviceOrientation;

   190 			arg3.ReturnValue.close();

   191             output = {}; 

   192 	    modifyObjectBaseProp(output);

   193             output.timeStamp = time;

   194             output.deviceOrientation = orientation;

   195             }        

   196         __orientation_channel.ucb(output);

   197         }

   198 		

   199 }

   200 

   201 

   202 // For now this is statically configured though this could be dynamically populated by the sensors sp

   203 

   204 

   205 

   206 

   207 function __sp_sensors_getChannels(){

   208   return ["Rotation", "AccelerometerAxis", "Orientation"];

   209 }

   210 

   211 function __sp_sensors_setNotifier(__succes_cb, __channel,__fail_cb){ 

   212 	    

   213     	var error = new DeviceException(0, 'dummy');

   214 	    if (!__succes_cb) {//alert("!__succes_cb");

   215 			throw new DeviceAPIError(error.MISSING_ARG_ERR, "Callback is missing");

   216 		}		

   217 		if ((typeof __succes_cb) != "function") {

   218 			throw new DeviceAPIError(error.INVALID_ARG_ERR, "Callback is of invalid type");

   219 		}	

   220 		if (__fail_cb && ((typeof __fail_cb) != "function")) {

   221 			throw new DeviceAPIError(error.INVALID_ARG_ERR, "InValid error Callback");

   222 		} 

   223 		if (!__channel) {

   224 			throw new DeviceAPIError(error.MISSING_ARG_ERR, "Channel is missing");

   225 		}			

   226 		if ((typeof __channel) != "string") {

   227 			

   228 			throw new DeviceAPIError(error.INVALID_ARG_ERR, "Channel is of invalid type");

   229 		}

   230 		

   231 		

   232 	  var rval;

   233 	  var cb;

   234 	  var channelInfo = {};

   235 	  modifyObjectBaseProp(channelInfo);

   236    switch(__channel){

   237    	  

   238 	  case "Rotation":

   239 		channelInfo.SearchCriterion = "Rotation";

   240 		cb = __rotation_cb;

   241 		__rotation_channel.ucb = __succes_cb;

   242 		break;

   243 	  case "AccelerometerAxis":

   244 	  //alert("case AccelerometerAxis");

   245 	  channelInfo.SearchCriterion = "AccelerometerAxis";

   246 		cb = __XYZ_cb;

   247 		__XYZ_channel.ucb = __succes_cb;

   248 	 break;

   249 	  case "Orientation":

   250 		channelInfo.SearchCriterion = "Orientation";

   251 		cb = __orientation_cb;

   252 		__orientation_channel.ucb = __succes_cb;

   253 		break;

   254 	  default:

   255 	    //alert("default");

   256 	    throw  new DeviceAPIError(error.NOT_SUPPORTED_ERR, "Unsupported input channel");	

   257 	 }

   258   

   259   try{

   260   	rval = this.so.ISensor.FindSensorChannel(channelInfo);

   261 		if (channelInfo) {

   262 		delete channelInfo.SearchCriterion;

   263 		}

   264     if(rval.ErrorCode != 0)

   265       {

   266       throw  new DeviceAPIError(error.NOT_SUPPORTED_ERR, "StartChannel:Operation Failed");

   267       }

   268 

   269   var cmap = [];

   270   var transactionid = [];

   271   var returnvalue = rval["ReturnValue"];

   272   var count = returnvalue.length;

   273   cmap = returnvalue[0];

   274   var sensorParams = {};

   275 	modifyObjectBaseProp(sensorParams);

   276 	sensorParams.ListeningType = "ChannelData";

   277 	sensorParams.ChannelInfoMap = cmap;

   278 	var result = this.so.ISensor.RegisterForNotification(sensorParams, cb);

   279 	  if(sensorParams){

   280 	  	delete sensorParams.ChannelInfoMap;

   281 		  delete sensorParams.ListeningType;

   282 	  }

   283 	  if(cmap){

   284 	  	delete cmap.index;

   285 	  }

   286     transactionid[0] = result["TransactionID"];

   287     if(result.ErrorCode != 0)

   288         {

   289         //throw result.ErrorCode;

   290 		

   291 						 if( result.ErrorCode == 1005)

   292 						 {

   293 						 __fail_cb(new DeviceAPIError(error.SERVICE_IN_USE_ERR,"Not Allowed Operation"));

   294 						 return;	 

   295 						 }

   296 						 else

   297 						 	{

   298 						 	throw  new DeviceAPIError(error.NOT_SUPPORTED_ERR, "StartChannel:Operation Failed");	

   299 						 	}

   300 				 }

   301         		 

   302 			

   303     }catch(e2){

   304       __device_handle_exception (e2, "__sp_sensors_setNotifier: RegisterForNotification: " + e2);

   305         }

   306   

   307   

   308   switch(__channel){

   309   case "Rotation":

   310     __rotation_channel.tid = transactionid;

   311     break;

   312   case "AccelerometerAxis":

   313   __XYZ_channel.tid = transactionid;

   314     break;

   315   case "Orientation":

   316     __orientation_channel.tid = transactionid;

   317     break;

   318   }

   319   return transactionid;

   320  }

   321 

   322 function __sp_sensors_cancelNotifier(__channel){

   323  

   324     var error1 = new DeviceException(0, 'dummy');

   325 	  if(!__channel)

   326 			    throw  new DeviceAPIError(error1.MISSING_ARG_ERR, "Channel is missing");

   327 							

   328 			if((typeof __channel) != "string")

   329 					throw  new DeviceAPIError(error1.INVALID_ARG_ERR, "Channel is of invalid type");

   330   

   331 	  var id ;  

   332 	  

   333 	  switch (__channel)

   334 	  {

   335 		case "Rotation":

   336 		  id = __rotation_channel.tid;

   337 		  __rotation_channel.tid = null;

   338 		  break;

   339 		case "AccelerometerAxis":

   340 		id = __XYZ_channel.tid;

   341 		__XYZ_channel.tid = null;

   342 		  break;

   343 		case "Orientation":

   344 		  id = __orientation_channel.tid;

   345 		  __orientation_channel.tid = null;

   346 		  break;

   347 		default:

   348 		  throw  new DeviceAPIError(error1.NOT_SUPPORTED_ERR, "Unsupported input channel");	

   349 		}     

   350 	

   351 	 if(!id)

   352 	 {

   353 	 throw  new DeviceAPIError(error1.DATA_NOT_FOUND_ERR, "Stop Channel:Operation Failed");		

   354 	 }

   355 	 

   356 	var cancelParams = {};

   357   modifyObjectBaseProp(cancelParams);

   358   for (var i in id) {

   359   		  cancelParams.TransactionID = id[i];

   360 				try {

   361 					var result = this.so.ISensor.Cancel(cancelParams);

   362 					if (cancelParams) {

   363 						delete cancelParams.TransactionID;

   364 					}

   365 					if (result.ErrorCode != 0) {

   366 						throw  new DeviceAPIError(error1.DATA_NOT_FOUND_ERR, "Stop Channel:Operation Failed");

   367 						}

   368 				} 

   369 				catch (e1) {

   370 					__device_handle_exception(e1, "__sp_sensors_cancelNotifier: " + e1);

   371 				}

   372 		}

   373 }

   374 

   375 function __sp_sensors_getScaleFactor(__channel){

   376 	var error2 = new DeviceException(0, 'dummy');

   377 	if(!__channel)

   378 		    throw  new DeviceAPIError(error2.MISSING_ARG_ERR, "Channel is missing");

   379 						

   380 		if((typeof __channel) != "string")

   381 				throw  new DeviceAPIError(error2.INVALID_ARG_ERR, "Channel is of invalid type");

   382 				

   383 	if(__channel != "AccelerometerAxis")

   384 		    throw  new DeviceAPIError(error2.NOT_SUPPORTED_ERR, "Unsupported input channel");

   385 		    

   386  try{    

   387 	  var channelInfo = {};	    

   388 	  channelInfo.SearchCriterion = "AccelerometerAxis";

   389 	  var rval = this.so.ISensor.FindSensorChannel(channelInfo);

   390 		if (channelInfo) {

   391 		delete channelInfo.SearchCriterion;

   392 		}

   393     if(rval.ErrorCode != 0)

   394       {

   395       throw  new DeviceAPIError(error2.NOT_SUPPORTED_ERR, "getScaleFactor:Operation Failed");

   396       }

   397     var cmap = [];    		

   398 		var returnvalue = rval["ReturnValue"];

   399     cmap = returnvalue[0];

   400     var sensorParams = {};

   401 	  modifyObjectBaseProp(sensorParams);

   402 	  sensorParams.ListeningType = "ChannelData";

   403 	  sensorParams.ChannelInfoMap = cmap;

   404 	  var result = this.so.ISensor.GetScaleFactor(sensorParams);

   405 	  if(sensorParams){

   406 	  	delete sensorParams.ChannelInfoMap;

   407 		  delete sensorParams.ListeningType;

   408 	  }

   409 	  if(cmap){

   410 	  	delete cmap.index;

   411 	  }

   412 	  if(result.ErrorCode != 0)

   413         {

   414         throw  new DeviceAPIError(error2.NOT_SUPPORTED_ERR, "getScaleFactor:Operation Failed");	

   415         }

   416    }

   417    

   418    catch (e1) {

   419 					__device_handle_exception(e1, "__sp_sensors_getScaleFactor: " + e1);

   420 				}

   421 		 return result["ReturnValue"];  

   422 				

   423 }