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 var __device_debug_on__ = true;

    20 

    21 var event_completed = 2;

    22 var event_cancelled = 3;

    23 

    24 var __Service_Interface_Ver=1.0;

    25 

    26 

    27 var MapErrorCode = {1016:100,1012:101,1010:102,1009:103,1005:104,1000:105,1011:106,1007:107,1003:1,1002:2, 1004:3};

    28 

    29 function __device_debug(text){

    30   //if(__device_debug_on__) alert(text);

    31 }

    32 

    33 function __device_handle_exception(e, text){

    34 	__device_debug(text);

    35 	throw(e);

    36 }

    37 

    38 function __device_typeof(value)

    39 {

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

    41 	if (value == undefined) {

    42         return "undefined";

    43     }

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

    45 	if (value instanceof Object) {

    46 		// Check whether it's a string object.

    47 		if (value instanceof String) {

    48 			return "String";

    49 		}

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

    51 		else 

    52 			if (value instanceof Array) {

    53 				return "Array";

    54 			}

    55 	}

    56 	// dealing with a literal.

    57 		if (typeof value) {

    58 			if (typeof value == "object") {

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

    60 					return "null";

    61 				}

    62 			}

    63            // if not null check for other types

    64 			

    65 				// Check if it's a string literal.

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

    67 					return "string";

    68 				}

    69 		}	 

    70 }

    71 

    72 if ((typeof nokia) == 'undefined') {

    73 	nokia = {};

    74 	nokia.device = {};

    75 }

    76 else {

    77     if ((typeof nokia.device) != 'undefined') {

    78 		nokia.device = {};

    79     }

    80 	else{

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

    82 	} 

    83 }

    84 

    85 nokia.device = {

    86     load: __device_service_load,

    87     listInterfaces: __device_service_interfaces,

    88 	getSystemProperties: __device_getSystemProperties,

    89 	getLibraryVersion: __device_getLibraryVersion,

    90     version: 2.0

    91 };

    92 

    93 function __device_getLibraryVersion(){

    94 	return 2.0;

    95 }

    96 

    97 function __device_getSystemProperties(){

    98 	return {

    99 		uriPath:{

   100 			// maximum limitation is 255 charectors

   101 			max:255

   102 		}

   103 	};

   104 }

   105 // Configure the services offered.

   106 

   107 var __device_services_inited = false;

   108 

   109 var __device_services = [

   110 

   111   // For now, the only service is the base "device"" service

   112   {

   113     "name":"device",

   114     "version": 2.0, 

   115     "interfaces": []

   116   }

   117 ];

   118 

   119 // Initialize the configured services.

   120 

   121 function __device_services_init(){

   122   if(__device_services_inited){

   123     return;

   124   }

   125   __device_services_inited = true;

   126   

   127   try {

   128   	var so_SrvReg = device.getServiceObject("Service.ServiceRegistry", "IService");

   129 	var filter = {ServiceName:"Service.Calendar", InterfaceName:"IDataSource"};  

   130 	

   131 	var returnVal = so_SrvReg.IService.GetList(filter);

   132 		if (returnVal.ErrorCode == 0)	{

   133 			var intf_iterator = returnVal.ReturnValue;

   134 			if(intf_iterator)	{

   135 				var intf = intf_iterator.getNext();

   136 				if(intf){

   137 					var versionList = intf.VersionList;

   138 					var index;

   139 					for(index in versionList){

   140 						if(versionList[index] > __Service_Interface_Ver){						

   141 							__Service_Interface_Ver = versionList[index];

   142 						}

   143 					}

   144 				}

   145 			}

   146 			intf_iterator.close();

   147 		}

   148 	so_SrvReg.close();

   149   }catch(e){

   150   	// service registry not available default version to 1.0

   151 //	alert('in catch'+e);

   152 	__Service_Interface_Ver = 1.0;

   153   }

   154 	

   155  

   156 

   157   // Get the service-specific service entries. Note that these

   158   // need to be individually wrapped by try/catch blocks so that the

   159   // interpreter gracefully handles missing services. 

   160 

   161   try {

   162     __device_services[0].interfaces.push(__device_geolocation_service_entry);

   163   }catch (e){

   164     __device_debug("Missing library implementation: " + e);

   165   }

   166   try {

   167     __device_services[0].interfaces.push(__device_camera_service_entry);

   168   }catch (e1){

   169     __device_debug("Missing library implementation: " + e1);

   170   }

   171   try {

   172     __device_services[0].interfaces.push(__device_media_service_entry);

   173   }catch (e2){

   174 //    __device_debug("Missing library implementation: " + e2);

   175   }

   176   try {

   177     __device_services[0].interfaces.push(__device_contacts_service_entry);

   178   }catch (e3){

   179 //    __device_debug("Missing library implementation: " + e3);

   180   }

   181  try {

   182     __device_services[0].interfaces.push(__device_messaging_service_entry);

   183   }catch (e4){

   184       __device_debug("Missing library implementation: " + e4);

   185   }

   186   try {

   187     __device_services[0].interfaces.push(__device_calendar_service_entry);

   188   }catch (e5){

   189       __device_debug("Missing library implementation: " + e5);

   190   }

   191   try {

   192     __device_services[0].interfaces.push(__device_landmarks_service_entry);

   193   }catch (e6){

   194       __device_debug("Missing library implementation: " + e6);

   195   }

   196   try {

   197     __device_services[0].interfaces.push(__device_commlog_service_entry);

   198   }catch (e7){

   199       __device_debug("Missing library implementation: " + e7);

   200   }

   201   try {

   202     __device_services[0].interfaces.push(__device_sysinfo_service_entry);

   203   }catch (e8){

   204       __device_debug("Missing library implementation: " + e8);

   205   }

   206   try {

   207     __device_services[0].interfaces.push(__device_sensors_service_entry);

   208   }catch (e9){

   209       __device_debug("Missing library implementation: " + e9);

   210   }

   211 

   212 }

   213 

   214 function __device_get_implementation(i){

   215   //__device_debug("get_implementation: " + i);

   216   return  new i.proto(new(i.providers[0].instance));

   217 }

   218 

   219 function __device_get_descriptor(i){

   220   //__device_debug("get_descriptor: " + i);

   221   return new i.descriptor(new(i.providers[0].descriptor));

   222 }

   223 

   224 function __device_get_interface(s, interfaceName, version){

   225 

   226     // Find first match of name and version

   227     var i = s.interfaces;

   228 	for (var d in i){

   229 		if(i[d].name == null){

   230 		  __device_update_descriptor(i[d]);

   231 		}

   232 		

   233 		if(i[d].name == undefined){

   234 		  continue;

   235 		}

   236 		

   237 		if (i[d].name == interfaceName){

   238 		// Match version if specified

   239 			if (version) {

   240 				if (i[d].version >= version) {

   241 					return __device_get_implementation(i[d]);

   242 				}

   243 			}else{

   244 				return __device_get_implementation(i[d]);

   245 			}

   246 	    }

   247 	}

   248 	return null;

   249 }

   250 

   251 // Implemention of the load method

   252 

   253 function __device_service_load(interfaceName, version){

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

   255 	if(interfaceName){

   256         if(typeof interfaceName != 'string'){

   257             throw new DeviceException(error.INVALID_ARG_ERR, 'nokia.device.load:Invalid type interfaceName');

   258         }

   259     }else{

   260         throw new DeviceException(error.MISSING_ARG_ERR, 'nokia.device.load:interfaceName param expected');

   261     }

   262     if(version){

   263         if(typeof version != 'number'){

   264             throw new DeviceException(error.INVALID_ARG_ERR, 'nokia.device.load:Invalid type version');

   265         }

   266     }

   267 

   268     __device_services_init();

   269   

   270 	for(var s in __device_services){

   271 	  //__device_debug("service_load: " + s + ":" +  __device_services[s].name + ": " + interfaceName);

   272 	  var i = __device_get_interface(__device_services[s], interfaceName, version);

   273 	  if (i != null){

   274 	    return i;

   275 	  }

   276 	}

   277     return null;

   278 }

   279 

   280 // Lazily fill in the descriptor table

   281 

   282 function __device_update_descriptor(i){

   283   var d = __device_get_descriptor(i);

   284   i.name = d.interfaceName;

   285   i.version = d.version;  

   286 }

   287 // Get an array of interface descriptors for a service

   288 

   289 function __device_interface_list(s){

   290   var retval = new Array();

   291   for(var i in s.interfaces){

   292     if(s.interfaces[i].name == null){

   293       __device_update_descriptor(s.interfaces[i]);

   294     }

   295     if(s.interfaces[i].name == undefined){

   296       continue;

   297     }

   298     retval[i] = new Object();

   299     retval[i].name = s.interfaces[i].name;

   300     retval[i].version = s.interfaces[i].version;

   301   }  

   302   return retval;

   303 }

   304 

   305 // Get a service description

   306 

   307 function __device_service_descriptor(s){

   308   this.name = s.name;

   309   this.version = s.version;

   310   this.interfaces = __device_interface_list(s);

   311   this.toString = __device_service_descriptor_to_string;

   312 }

   313 

   314 function __device_service_descriptor_to_string(){

   315   var is = "\nInterfaces(s): ";

   316 

   317   for (i in this.interfaces){

   318     is += "\n" + this.interfaces[i].name + " " + this.interfaces[0].version;

   319   }

   320   return ("Service: " + this.name + is);

   321 }

   322 

   323 // Implement the listInterfaces method

   324     

   325 function __device_service_interfaces(){

   326   __device_services_init();

   327 

   328   for (var s in __device_services){

   329       var intfs = __device_interface_list(__device_services[s]);

   330 	  // create interator

   331 	  return new __FWIter(intfs);

   332   }

   333   return null;

   334 }

   335 

   336 

   337 function __FWIter(arr)

   338 {

   339     this._arr = arr;

   340 	this._pos = 0;

   341 	this._valid = true;

   342 }

   343 

   344 __FWIter.prototype.hasNext = function() {

   345     return (this._valid && this._pos < this._arr.length);

   346 }

   347 

   348 __FWIter.prototype.next = function() {

   349     if(this._valid && (this._pos < this._arr.length)){

   350 		return this._arr[this._pos++];

   351 	}

   352 	else{

   353 		return null;

   354 	}

   355 }

   356 

   357 __FWIter.prototype.close = function(){

   358     delete this._arr;

   359 	this._valid = false;

   360 }

   361 

   362 function modifyObjectBaseProp(obj){

   363   for (pro in obj) {

   364     if(typeof obj[pro] == "function" )

   365       obj[pro] = 0;

   366     }

   367 }

   368 

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

   370 //Functions for  Handling Async API's use this variable

   371 var glob_obj = null;

   372 var temp_scb = null;

   373 var temp_ecb = null;

   374  

   375 glob_obj = new Object();

   376 

   377 glob_obj.glob_cb_arr = new Array();

   378 glob_obj.addToGlobalArray = addToGlobalArray;

   379 glob_obj.removeFromArray = removeFromArray;

   380 glob_obj.getFromArray = getFromArray;

   381      

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

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

   384 

   385 //constructor for DeviceAPIError.

   386 function DeviceAPIError(code,message) 

   387 {

   388 	this.toString = concatenate;

   389 	this.code = code;

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

   391 	this.message=message; 

   392 	

   393         this.MISSING_ARG_ERR            = 1;

   394         this.INVALID_ARG_ERR            = 2;

   395         this.NOT_SUPPORTED_ERR          = 3;

   396         this.TIMEOUT_ERR                = 100;

   397         this.DATA_NOT_FOUND_ERR         = 101;

   398         this.DATA_ALREADY_EXISTS_ERR    = 102;

   399         this.SERVICE_BUSY_ERR           = 103;

   400         this.SERVICE_IN_USE_ERR         = 104;

   401         this.DATA_OUT_OF_RANGE_ERR      = 105;

   402         this.NOT_ALLOWED_ERR            = 106;

   403         this.SIZE_EXCEEDED_ERR          = 107;

   404         this.INVALID_URI_ERR            = 108;

   405         this.URI_NOT_FOUND_ERR          = 109;

   406         this.URI_ALREADY_EXISTS_ERR     = 110;

   407         this.NO_MEMORY_ERR              = 111;  

   408 }

   409 

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

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

   412 

   413 //constructor for DeviceException.

   414 function DeviceException(code,message) 

   415 {

   416     this.toString = concatenate;

   417     this.code = code;

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

   419     this.message=message; 

   420     

   421         this.MISSING_ARG_ERR            = 1;

   422         this.INVALID_ARG_ERR            = 2;

   423         this.NOT_SUPPORTED_ERR          = 3;

   424         this.TIMEOUT_ERR                = 100;

   425         this.DATA_NOT_FOUND_ERR         = 101;

   426         this.DATA_ALREADY_EXISTS_ERR    = 102;

   427         this.SERVICE_BUSY_ERR           = 103;

   428         this.SERVICE_IN_USE_ERR         = 104;

   429         this.DATA_OUT_OF_RANGE_ERR      = 105;

   430         this.NOT_ALLOWED_ERR            = 106;

   431         this.SIZE_EXCEEDED_ERR          = 107;

   432         this.INVALID_URI_ERR            = 108;

   433         this.URI_NOT_FOUND_ERR          = 109;

   434         this.URI_ALREADY_EXISTS_ERR     = 110;

   435         this.NO_MEMORY_ERR              = 111;  

   436 }

   437 

   438 

   439 function concatenate()

   440 {

   441     return (this.name+': errcode: '+this.code+'\nline: '+this.lineNumber+'\nfileName: '+this.fileName+'\nerrmsg: '+this.message);

   442 }

   443 

   444 function splitErrorMessage(errmessage)

   445 {

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

   447 	{

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

   449 		{

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

   451 		}

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

   453 		{

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

   455 		}

   456 	}

   457 	return errmessage;

   458 }

   459 

   460 

   461 var __s60_start_and_wait_cb;

   462 

   463 function __s60_on_app_exit(){

   464   widget.onshow = null;

   465   if(__s60_start_and_wait_cb !== null){

   466     __s60_start_and_wait_cb();

   467   }

   468 }

   469 

   470 function __s60_on_app_start(){

   471   widget.onhide = null;

   472   widget.onshow = __s60_on_app_exit;

   473 }

   474 

   475 // This function cannot actually force JS to wait,

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

   477 // to continue processing on return from the app.

   478 // Apps should take care not to reinvoke this and

   479 // should be careful about any other processing

   480 // that might happen while the app is running.

   481 

   482 function __s60_start_and_wait(id, args, app_exit_cb){

   483   __s60_start_and_wait_cb = app_exit_cb;

   484   widget.onhide = __s60_on_app_start;

   485   widget.openApplication(id, args);

   486 }

   487 

   488 function __s60_api_not_supported(){

   489   throw(err_ServiceNotSupported);

   490 }

   491 

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

   493    var key;

   494    for (key in object) {

   495    		var propname;

   496    		if (namespace) {

   497    			propname = namespace + "." + key;

   498    		}

   499    		else {

   500    			propname = key;

   501    		}

   502    		var value = object[key];

   503    		if (typeof value == "object") {

   504    			__s60_enumerate_object(value, propname, func, param);

   505    		}

   506    		else {

   507    			func(propname, value, param);

   508    		}

   509    }

   510 }

   511 

   512 

   513 /*

   514  * Handling Async calls

   515  */

   516 function removeFromArray(transId){

   517     for (i = 0; i < (glob_obj.glob_cb_arr.length); i++) {

   518         if (glob_obj.glob_cb_arr[i].transactionId == transId) {

   519             glob_obj.glob_cb_arr.splice(i, 1);

   520         }

   521     }

   522 }

   523 

   524 function addToGlobalArray(transId, sCb, errCb){

   525 

   526     var obj = new Object();

   527     

   528     obj.success_cb = sCb;

   529     obj.transactionId = transId;

   530     obj.error_cb = errCb;

   531     

   532     glob_obj.glob_cb_arr.push(obj);

   533     

   534 }

   535 

   536 function getFromArray(tid){

   537     var i;

   538     

   539     for (i = 0; i < (glob_obj.glob_cb_arr.length); i++) {

   540         if (glob_obj.glob_cb_arr[i].transactionId == tid) {

   541             return glob_obj.glob_cb_arr[i];

   542         }

   543     }

   544 	

   545 	if(temp_scb)

   546 	{

   547 		var obj = new Object();

   548     

   549 	    obj.success_cb = temp_scb;

   550 	    obj.error_cb = temp_ecb;

   551 		

   552 		temp_ecb = temp_scb = null;

   553 		return obj;		

   554 	}

   555     return null;

   556 }