1 /*
  2  * This is signage cordova_plugin (TV specific API).
  3  * Apache License (2004). See http://www.apache.org/licenses/LICENSE-2.0
  4  *
  5  * Copyright (c) 2014, LG Electronics, Inc.
  6  */
  7 
  8 /**
  9  * This represents the signage API itself, and provides a global namespace for operating signage service.
 10  * @class
 11  */
 12 cordova.define('cordova/plugin/signage', function (require, exports, module) { // jshint ignore:line
 13 	var service;
 14 	function log(msg){
 15 		//console.log//will be removed // jshint ignore:line
 16 	}
 17 
 18 
 19 	if(window.PalmSystem){ // jshint ignore:line
 20 		log("Window.PalmSystem Available");
 21 		service = require('cordova/plugin/webos/service');
 22 	}
 23 	else{
 24 		log("Window.PalmSystem is NOT Available");
 25 		service = {
 26 				Request : function(uri, params){
 27 					log(uri + " invoked. But I am a dummy because PalmSystem is not available");
 28 					if(typeof params.onFailure === 'function'){
 29 						params.onFailure({returnValue:false,errorCode:"CORDOVA_ERR", errorText:"PalmSystem Not Available. Cordova is not installed?"});
 30 					}
 31 				}
 32 		};
 33 	}
 34 
 35 	var removeSignageEventListener = function (event){
 36 		var monitorObj  = _gSystemMonitoringSetup[event];
 37 		log(JSON.stringify(monitorObj, null ,3));
 38 		if(monitorObj&&  monitorObj.getEvent === true){
 39 			if(_gSystemMonitoringSetup[event].listenerObj){
 40 				_gSystemMonitoringSetup[event].listenerObj.cancel();
 41 				_gSystemMonitoringSetup[event].getEvent = false;
 42 				_gSystemMonitoringSetup[event].listenerObj = null;
 43 			}
 44 		}
 45 	};
 46 	var addSignageEventListener = function(key, callbackfunction){
 47 		/*	fan : {
 48 			getEvent:false,
 49 			listenerObj : null,
 50 			createListenr : monitorFan
 51 		},
 52 		 */
 53 		var monitorSetup = _gSystemMonitoringSetup[key];
 54 		if(monitorSetup && typeof monitorSetup.createListener === 'function'){
 55 			monitorSetup.listenerObj = monitorSetup.createListener(callbackfunction);
 56 			monitorSetup.getEvent = true;
 57 		}
 58 	};
 59 
 60 	function getInputValue(inputUri){
 61 		if(inputUri.substring(0, "ext://".length) !== "ext://"){
 62 			log("Bad prefix: " + inputUri);
 63 			return false;
 64 		}
 65 
 66 		var body = inputUri.substring("ext://".length );
 67 		log("body is: " + body);
 68 
 69 		var splited = body.split(":");
 70 
 71 		if(splited.length === 2){
 72 			return splited[0]+splited[1];
 73 		}
 74 
 75 		else if(splited.length === 1){
 76 			return splited[0];
 77 		}
 78 
 79 		else{
 80 			log("Bad Syntax: " + inputUri);
 81 			return false;
 82 		}
 83 	}
 84 
 85 	function isValidEnum(arr, value){
 86 		for(var key in arr){
 87 			if(arr[key] === value){
 88 				return true;
 89 			}
 90 		}
 91 
 92 		return false;
 93 	}
 94 
 95 
 96 	var SETTINGS_KEY = {
 97 			FAILOVER_MODE : "failover",
 98 			FAILOVER_PRIORITY : "failoverPriority",
 99 			IR_OPERATION_MODE : "enableIrRemote",
100 			LOCALKEY_OPERATION_MODE : "enableLocalKey",
101 			OSD_PORTRAIT_MODE : "osdPortraitMode",
102 			TILE_MODE : "tileMode",
103 			TILE_ID : "tileId",
104 			TILE_ROW : "tileRow",
105 			TILE_COLUME : "tileCol",
106 			TILE_NATURALMODE : "naturalMode",
107 			DPM_MODE : "dpmMode",
108 			AUTOMATIC_STANDBY_MODE : "autoSB",
109 			ISM_METHOD : "ismmethod",
110 			SES_MODE : "smartEnergy",
111 			DO_15OFF_MODE : "15off",
112 			MONITOR_FAN : "monitorFan",
113 			MONITOR_SIGNAL : "monitorSignal",
114 			MONITOR_LAMP : "monitorLamp",
115 			MONITOR_SCREEN : "monitorScreen",
116 			MONITOR_AUDIO : "monitorAudio",
117 			AUDIO_SOURCE_HDMI1: "audioSourceHdmi1",
118 			AUDIO_SOURCE_HDMI2: "audioSourceHdmi2",
119 			AUDIO_SOURCE_DP: "audioSourceDp"
120 
121 	};
122 
123 	var monitorTemperature = function(callbackfunction){
124 		log("Create Listener for monitorTemperature");
125 		var subscribed =  service.Request("luna://com.webos.service.commercial.signage.storageservice", {
126 			method : "systemMonitor/getTemperature",
127 			parameters : {"subscribe" : true},
128 			onSuccess : function(result) {
129 				log("temperature!!!!!!!!! : " + JSON.stringify(result, null, 3));
130 
131 				if(result.returnValue === true){
132 					var returnData = {
133 							source : Signage.MonitoringSource.THERMOMETER,
134 							type : Signage.EventType.CURRENT_TEMPERATURE,
135 							data: {
136 								temperature: result.temperature
137 							}
138 					};
139 					if(callbackfunction) {
140 						callbackfunction(returnData);
141 					}
142 				}
143 			},
144 			onFailure : function(result) {
145 				log("monitor_temperature!!!!!!!!! : FAIL " + JSON.stringify(result, null, 3));
146 
147 			}
148 		});
149 		return subscribed;
150 	};
151 
152 	var monitorFan = function(callbackfunction){
153 		log("Create Listener for monitorFan");
154 
155 		var subscribed =  service.Request("luna://com.webos.service.commercial.signage.storageservice", {
156 			method : "systemMonitor/getFanEvent",
157 			parameters : {"subscribe" : true},
158 			onSuccess : function(result) {
159 				log("monitor_fan!!!!!!!!! : " + JSON.stringify(result, null, 3));
160 
161 				if(result.returnValue === true){
162 					var returnData = {
163 							source : Signage.MonitoringSource.FAN,
164 							type : Signage.EventType.FAN_STATUS,
165 							data: {
166 								status: result.fanFault
167 							}
168 					};
169 					if(callbackfunction){
170 						callbackfunction(returnData);
171 					}
172 				}
173 			},
174 			onFailure : function(result) {
175 				log("monitor_fan!!!!!!!!! : FAIL " + JSON.stringify(result, null, 3));
176 
177 			}
178 		});
179 		return subscribed;
180 	};
181 
182 	var monitorLamp = function(callbackfunction){
183 		log("Create Listener for monitorLamp");
184 
185 		var subscribed = service.Request("luna://com.webos.service.commercial.signage.storageservice", {
186 			method : "systemMonitor/getLampEvent",
187 			parameters : {"subscribe" : true},
188 			onSuccess : function(result) {
189 				log("monitor_lamp!!!!!!!!! : " + JSON.stringify(result, null, 3));
190 
191 				if(result.returnValue === true){
192 					var returnData = {
193 							source : Signage.MonitoringSource.LAMP,
194 							type : Signage.EventType.LAMP_STATUS,
195 							data: {
196 								status: result.lampFault
197 							}
198 					};
199 					if(callbackfunction){
200 						callbackfunction(returnData);
201 					}
202 				}
203 			},
204 			onFailure : function(result) {
205 				log("monitor_lamp!!!!!!!!! : FAIL " + JSON.stringify(result, null, 3));
206 
207 			}
208 		});
209 		return subscribed;
210 	};
211 
212 	var monitorSignal = function(callbackfunction) {
213 		log("Create Listener for monitorSignal");
214 
215 		var subscribed = service.Request("luna://com.webos.service.commercial.signage.storageservice", {
216 			method : "systemMonitor/getSignalEvent",
217 			parameters : {"subscribe" : true},
218 			onSuccess : function(result) {
219 				log("monitor_signal!!!!!!!!! : " + JSON.stringify(result, null, 3));
220 
221 				if(result.returnValue === true){
222 					var returnData = {
223 							type : Signage.EventType.NO_SIGNAL,
224 							source : Signage.MonitoringSource.SIGNAL
225 					};
226 					if(result.noSignal === true){
227 						returnData.data.status = "no_signal";
228 					}
229 					else{
230 						returnData.data.status = "signal_available";
231 					}
232 
233 					if(callbackfunction){
234 						callbackfunction(returnData);
235 					}				
236 				}
237 			},
238 			onFailure : function(result) {
239 				log("monitor_signal!!!!!!!!! : FAIL " + JSON.stringify(result, null, 3));
240 			}
241 		});
242 
243 		return subscribed;
244 	};
245 
246 	var monitorScreen = function(callbackfunction)  {
247 		log("Create Listener for monitorScreen");
248 
249 		var subscribed = service.Request("luna://com.webos.service.commercial.signage.storageservice", {
250 			method : "systemMonitor/getScreenEvent",
251 			parameters : {"subscribe" : true},
252 			onSuccess : function(result) {
253 				log("monitor_screen!!!!!!!!! : " + JSON.stringify(result, null, 3));
254 
255 				if(result.returnValue === true){
256 					var returnData = {
257 							source : Signage.MonitoringSource.SCREEN,
258 							type : Signage.EventType.SCREEN_STATUS,
259 							data: {
260 								status: result.screen
261 							}
262 					};
263 
264 					if(callbackfunction) {
265 						callbackfunction(returnData);
266 					}
267 				}
268 			},
269 			onFailure : function(result) {
270 				log("monitor_screen!!!!!!!!! FAIL : " + JSON.stringify(result, null, 3));
271 			}
272 		});
273 
274 		return subscribed;
275 	};
276 
277 
278 
279 	var _gSystemMonitoringSetup = {
280 			fan : {
281 				getEvent:false,
282 				listenerObj : null,
283 				createListener : monitorFan
284 			},
285 			screen : {
286 				getEvent:false,
287 				listenerObj : null,
288 				createListener : monitorScreen
289 			},
290 			temperature:{
291 				getEvent:false,
292 				listenerObj : null,
293 				createListener : monitorTemperature
294 			},
295 			signal: {
296 				getEvent:false,
297 				listenerObj : null,
298 				createListener : monitorSignal
299 			},
300 			lamp:{
301 				getEvent:false,
302 				listenerObj : null,
303 				createListener : monitorLamp
304 			}
305 	};
306 
307 	var _gTileInfo = {
308 			row : 0,
309 			col : 0
310 	};
311 
312 	/**
313 	 * signage interface
314 	 */
315 	var Signage = function () {
316 	};
317 
318 	/**
319 	 * This value is returned when requested data is not defined.
320 	 */
321 	Signage.UNDEFINED = '___undefined___';
322 
323 
324 	/**
325 	 * @namespace Signage.FailoverMode
326 	 */
327 	Signage.OsdPortraitMode = {
328 			/**
329 			 * Rotate 90 or 270 degree. It depends on the model specific.
330 			 * @since 1.0
331 			 * @constant
332 			 */
333 			ON : "90",
334 			/**
335 			 * Do not use portrait mode.
336 			 * @since 1.0
337 			 * @constant
338 			 */
339 			OFF : "off"
340 	};
341 
342 	/**
343 	 * @namespace Signage.AutomaticStandbyMode
344 	 */
345 
346 	Signage.AutomaticStandbyMode = {
347 			/**
348 			 * Do not use automatic standby mode.
349 			 * @since 1.0
350 			 * @constant
351 			 */
352 			OFF : "off",
353 			/**
354 			 * automatic standby in 4 hours.
355 			 * @since 1.0
356 			 * @constant
357 			 */
358 			STANDBY_4HOURS : "4hours"
359 	};
360 	/**
361 	 * @namespace Signage.ISMMethod
362 	 */
363 	Signage.IsmMethod = {
364 			/**
365 			 * ISM Method Normal
366 			 * @since 1.0
367 			 * @constant
368 			 */
369 			NORMAL : "NORMAL",
370 			/**
371 			 * ISM Method Orbiter
372 			 * @since 1.0
373 			 * @constant
374 			 */
375 			ORBITER : "ORBITER",
376 			/**
377 			 * ISM Method Inversion
378 			 * @since 1.0
379 			 * @constant
380 			 */
381 			INVERSION : "INVERSION",
382 			/**
383 			 * ISM Method Color Wash
384 			 * @since 1.0
385 			 * @constant
386 			 */
387 			COLORWASH : "COLORWASH",
388 			/**
389 			 * ISM Method White Wash
390 			 * @since 1.0
391 			 * @constant
392 			 */
393 			WHITEWASH : "WHITEWASH",
394 			/**
395 			 * Washing Bar
396 			 * @since 1.2
397 			 * @constant
398 			 */
399 			WASHING_BAR : "WASHINGBAR",
400 			/**
401 			 * User Image
402 			 * @since 1.2
403 			 * @constant
404 			 */
405 			USER_IMAGE : "USERIMAGE",			
406 			/**
407 			 * User Image
408 			 * @since 1.2
409 			 * @constant
410 			 */
411 			USER_VIDEO : "USERVIDEO"			
412 	};
413 	/**
414 	 * @namespace Signage.FailoverMode
415 	 */
416 	Signage.FailoverMode = {
417 			/**
418 			 * Do not use failover mode.
419 			 * @since 1.0
420 			 * @constant
421 			 */
422 			OFF : "off",
423 			/**
424 			 * Use machine default setting. It differs model by model. <br>
425 			 * For LS55A, it is (HDMI1 > HDMI2 > DP > DVI > Internal Memory)
426 			 * @since 1.0
427 			 * @constant
428 			 */
429 			AUTO : "auto",
430 			/**
431 			 * Use priority set by the user.
432 			 * @since 1.0
433 			 * @constant
434 			 */
435 			MANUAL : "manual"
436 	};
437 
438 	/**
439 	 * @namespace Signage.DigitalAudioInput
440 	 */
441 	Signage.DigitalAudioInput = {
442 			/**
443 			 * HDMI or display port
444 			 * @since 1.0
445 			 * @constant
446 			 */
447 			HDMI_DP : "hdmi",
448 			/**
449 			 * AUDIO_IN
450 			 * @since 1.0
451 			 * @constant
452 			 */
453 			AUDIO_IN : "audioIn"
454 	};
455 	/**
456 	 * @namespace Signage.DpmMode
457 	 */
458 	Signage.DpmMode ={
459 			/**
460 			 * Do not use DPM
461 			 * @since 1.0
462 			 * @constant
463 			 */
464 			OFF : "off",
465 			/**
466 			 * POWER_OFF_5SECONDS
467 			 * @since 1.0
468 			 * @constant
469 			 */
470 			POWER_OFF_5SECOND : "5sec",
471 			/**
472 			 * POWER_OFF_10SECONDS
473 			 * @since 1.0
474 			 * @constant
475 			 */
476 			POWER_OFF_10SECOND : "10sec",
477 			/**
478 			 * POWER_OFF_15SECONDS
479 			 * @since 1.0
480 			 * @constant
481 			 */
482 			POWER_OFF_15SECOND : "15sec",
483 			/**
484 			 * POWER_OFF_1MINUTE
485 			 * @since 1.0
486 			 * @constant
487 			 */
488 			POWER_OFF_1MINUTE : "1min",
489 			/**
490 			 * POWER_OFF_3MINUTE
491 			 * @since 1.0
492 			 * @constant
493 			 */
494 			POWER_OFF_3MINUTE : "3min",
495 			/**
496 			 * POWER_OFF_5MINUTE
497 			 * @since 1.0
498 			 * @constant
499 			 */
500 			POWER_OFF_5MINUTE : "5min",
501 
502 			/**
503 			 * POWER_OFF_10MINUTE
504 			 * @since 1.0
505 			 * @constant
506 			 */
507 			POWER_OFF_10MINUTE : "10min"
508 	};
509 	/**
510 	 * @namespace Signage.KeyOperationMode
511 	 */
512 	Signage.KeyOperationMode =  {
513 			/**
514 			 * ALLOW_ALL
515 			 * @since 1.0
516 			 * @constant
517 			 */
518 			ALLOW_ALL : "normal",
519 			/**
520 			 * POWER_ONLY
521 			 * @since 1.0
522 			 * @constant
523 			 */
524 			POWER_ONLY : "usePwrOnly",
525 			/**
526 			 * BLOCK_ALL
527 			 * @since 1.0
528 			 * @constant
529 			 */
530 			BLOCK_ALL : "blockAll"
531 	};
532 	/**
533 	 * @namespace Signage.EventType
534 	 */
535 	Signage.EventType = {
536 			/**
537 			 * Temperature Event.
538 			 * Corresponding data includes:
539 			 * <div align=left>
540 			 * <table class="hcap_spec" width=400>
541 			 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
542 			 *   <tbody>
543 			 *       <tr><th>temperature</th><th>Number</th><th>Current Temperature</th><th>required</th></tr>
544 			 *   </tbody>
545 			 * </table>
546 			 * </div>
547 			 * @since 1.0
548 			 * @constant
549 			 */
550 			CURRENT_TEMPERATURE : "CURRENT_TEMPERATURE",
551 
552 			/**
553 			 * Current fan status.
554 			 * Corresponding data includes:
555 			 * <div align=left>
556 			 * <table class="hcap_spec" width=400>
557 			 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
558 			 *   <tbody>
559 			 *       <tr><th>status</th><th>String</th><th>Fan status. ('ok'|'fault'|'na')</th><th>required</th></tr>
560 			 *   </tbody>
561 			 * </table>
562 			 * </div>
563 			 * @since 1.0
564 			 * @constant
565 			 */
566 			FAN_STATUS : "FAN_STATUS",
567 
568 			/**
569 			 * Current lamp status.
570 			 * Corresponding data includes:
571 			 * <div align=left>
572 			 * <table class="hcap_spec" width=400>
573 			 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
574 			 *   <tbody>
575 			 *       <tr><th>status</th><th>String</th><th>Lamp status. ('ok'|'fault'|'na')</th><th>required</th></tr>
576 			 *   </tbody>
577 			 * </table>
578 			 * </div>
579 			 * @since 1.0
580 			 * @constant
581 			 */
582 			LAMP_STATUS : "LAMP_STATUS",
583 
584 			/**
585 			 * Current screen status.
586 			 * Corresponding data includes:
587 			 * <div align=left>
588 			 * <table class="hcap_spec" width=400>
589 			 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
590 			 *   <tbody>
591 			 *       <tr><th>status</th><th>String</th><th>screen status. ('ok'|'ng')</th><th>required</th></tr>
592 			 *   </tbody>
593 			 * </table>
594 			 * </div>
595 			 * @since 1.0
596 			 * @constant
597 			 */
598 			SCREEN_STATUS : "SCREEN_STATUS",
599 
600 			/**
601 			 * Current signal status.
602 			 * Corresponding data includes:
603 			 * <div align=left>
604 			 * <table class="hcap_spec" width=400>
605 			 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
606 			 *   <tbody>
607 			 *       <tr><th>status</th><th>String</th><th>signal status. ('no_signal'|'signal_available')</th><th>required</th></tr>
608 			 *   </tbody>
609 			 * </table>
610 			 * </div>
611 			 * 
612 			 * @since 1.0
613 			 * @constant
614 			 */
615 			SIGNAL_STATUS : "SIGNAL_STATUS"
616 
617 	};
618 
619 
620 	/**
621 	 * @namespace Signage.MonitoringSource
622 	 */
623 	Signage.MonitoringSource = {
624 			/**
625 			 * FAN 
626 			 * @since 1.0
627 			 * @constant
628 			 */
629 			FAN : "FAN",
630 			/**
631 			 * LAMP
632 			 * @since 1.0
633 			 * @constant
634 			 */
635 			LAMP : "LAMP",
636 			/**
637 			 * SIGNAL
638 			 * @since 1.0
639 			 * @constant
640 			 */
641 			SIGNAL : "SIGNAL",
642 			/**
643 			 * SCREEN
644 			 * @since 1.0
645 			 * @constant
646 			 */
647 			SCREEN : "SCREEN",
648 			/**
649 			 * THERMOMETER
650 			 * @since 1.0
651 			 * @constant
652 			 */
653 			THERMOMETER : "THERMOMETER"
654 
655 	};
656 
657 	function getSystemSettings(category, keys, cbObjectGetter, successCallback , errorCallback){
658 		var params = {
659 				category : category,
660 				keys : keys
661 		};
662 
663 		service.Request("luna://com.webos.service.commercial.signage.storageservice/settings/", {
664 			method : "get",
665 			parameters : params,
666 			onSuccess : function(result) {
667 				log("On Success");
668 				if(result.returnValue === true){
669 					var cbObj = cbObjectGetter(result.settings);
670 					if(cbObj === false){
671 						if(errorCallback && typeof errorCallback === 'function'){
672 							errorCallback({
673 								errorText: "Invalid DB value",
674 								errorCode: "DB_ERROR"
675 							});
676 						}
677 					}
678 					else{
679 						if(successCallback && typeof successCallback === 'function'){
680 							log("successCallback!!!!!!!!!");
681 							successCallback(cbObj);
682 						}
683 						else{
684 							log("successCallback not registered or is not a function: " + successCallback);
685 						}
686 					}
687 				}
688 				else{
689 					log("Settings Failed:  " + JSON.stringify(result, null, 3));
690 
691 					if(errorCallback && typeof errorCallback === 'function'){
692 						errorCallback({
693 							errorText: "Invalid DB value : " + result.errorText,
694 							errorCode: "DB_ERROR"
695 						});
696 					}
697 
698 				}
699 			},
700 			onFailure : function(result) {
701 				log("On Failure");
702 				delete result.returnValue;
703 				// See if any salvagable data
704 				if(result.settings){
705 					log("settings = " + JSON.stringify(result.settings, null, 3));
706 
707 					var cbObject = cbObjectGetter(result.settings);
708 
709 					log("errorKey = " + JSON.stringify(result.errorKey, null, 3));
710 
711 					for(var i=0;i < result.errorKey.length; ++i){
712 						cbObject[result.errorKey[i]] = Signage.UNDEFINED;
713 					}
714 
715 					log("cbObj = " + JSON.stringify(cbObject, null, 3));
716 					if(successCallback && typeof successCallback === 'function'){
717 						log("successCallback!!!!!!!!!");
718 						successCallback(cbObject);
719 					}
720 				}
721 				else {
722 					if(errorCallback && typeof errorCallback === 'function'){
723 						errorCallback({
724 							errorText:  ((typeof result.errorText === 'undefined') ? "DB Failure": result.errorText),
725 							errorCode: "DB_ERROR"
726 						});
727 					}
728 				}
729 			}
730 		});
731 
732 		log("Requested Service: " + "luna://com.webos.service.commercial.signage.storageservice/settings/");
733 		log("params : " + JSON.stringify(params));
734 	}
735 
736 	function setSystemSettings(category, settings, successCallback, errorCallback){
737 		var params = {
738 				category : category,
739 				settings : settings
740 		};
741 
742 		log("settings : " + JSON.stringify(settings,null,3));
743 		var hasKey = false;
744 		for(var key in settings){
745 			if(key){
746 				log("has key : " + key);
747 				hasKey= true;
748 				break;
749 			}
750 		}
751 		if(hasKey === false){
752 			log("Nothing to set!!!!!" );
753 			successCallback();
754 			return;
755 		}
756 
757 		service.Request("luna://com.webos.service.commercial.signage.storageservice/settings/", {
758 			method : "set",
759 			parameters : params,
760 			onSuccess : function() {
761 				log("On Success");
762 				if(successCallback && typeof successCallback === 'function'){
763 					log("SUCCEES CALLBACK!!!!!!!");
764 					successCallback();
765 				}
766 			},
767 			onFailure : function(result) {
768 				log("On Failure");
769 				delete result.returnValue;
770 				if(errorCallback && typeof errorCallback === 'function'){
771 					log("ERROR CALLBACK!!!!!!!");
772 					errorCallback(result);
773 				}
774 			}
775 		});
776 
777 		log("Requested Service: " + "luna://com.webos.service.commercial.signage.storageservice/settings/");
778 		log("params : " + JSON.stringify(params));
779 	}
780 
781 
782 
783 
784 	/**
785 	 * <p>
786 	 * Sets Portrait Mode.
787 	 * </p>
788 	 * 
789 	 * @example 
790 	 * 
791 	 * function setPortraitMode() {
792 	 * 
793 	 *    var options = { 
794 	 *      portraitMode: Signage.OsdPortraitMode.ON
795 	 *    };
796 	 * 
797 	 *    var successCb = function (){
798 	 *      console.log("Portrait Mode successfully Set");
799 	 *    }; 
800 	 * 
801 	 *    var failureCb = function(cbObject){ 
802 	 *      var errorCode = cbObject.errorCode;
803 	 *      var errorText = cbObject.errorText;
804 	 *       
805 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
806 	 *    };
807 	 *   
808 	 *    var signage = new Signage();         
809 	 *    signage.setPortraitMode(successCb, failureCb, options);
810 	 * }
811 	 * 
812 	 * @class Signage
813 	 * @param {Function}
814 	 *            successCallback success callback function.
815 	 * @param {Function}
816 	 *            errorCallback failure callback function.
817 	 * @param {Object}
818 	 *            options Input Parameters
819 	 * @param {Signage.OsdPortraitMode}
820 	 *            options.portraitMode Portrait mode. 
821 	 * @returns
822 	 *            <p>
823 	 *            After the method is successfully executed, successCallback is called without any parameter.</br>
824 	 *            If an error occurs, errorCallback is called with errorCode and errorText.
825 	 *            </p>
826 	 * 
827 	 * @since 1.0
828 	 */
829 	Signage.prototype.setPortraitMode = function (successCallback , errorCallback, options ) {
830 
831 		var settings = {};
832 
833 		var errorMessage;
834 		function checkOptions(options){
835 			if(options.portraitMode){
836 				for(var key in Signage.OsdPortraitMode){
837 					if(options.portraitMode === Signage.OsdPortraitMode[key]){
838 						return true;
839 					}
840 				}
841 
842 				errorMessage = "Unrecognized OsdPortraintMode : " + options.portraitMode;
843 				return false;
844 			}
845 			else{
846 				errorMessage = "portraitMode does not exist.";
847 				return false;
848 			}
849 		}
850 
851 		if(checkOptions(options)){
852 			var portraintModeStr = options.portraitMode;
853 			log("portraitMode: " + options.portraitMode);
854 			settings[SETTINGS_KEY.OSD_PORTRAIT_MODE] = portraintModeStr;
855 			log("Set: " + JSON.stringify(settings, null, 3));
856 
857 			setSystemSettings("commercial", settings, successCallback , errorCallback);
858 
859 			log("setPortraitMode Done");
860 		}
861 		else{
862 			var cbObj ={
863 					errorCode : "BAD_PARAMETER",
864 					errorText : errorMessage
865 			};
866 			errorCallback(cbObj);
867 		}
868 	};
869 
870 
871 	/**
872 	 * <p>Sets Failover mode.
873 	 *  When Failover Mode is set, monitor will automatically switch to the input source when the input signal fails, according to the predefined priorities set in the menu. </p>
874 	 *  
875 	 * <p>IMPORTANT NOTE!!!!</p>
876 	 * 
877 	 * <p>
878 	 * When failover is triggered due to lost signal, the signage application will 
879 	 * yield to the next priority input source set in the failover mode and run in the background. 
880 	 * </p>
881 	 * <p>
882 	 * If the signage application should always be running in the foreground, failover mode should be set to OFF.
883 	 * </p>
884 	 *  
885 	 * @example 
886 	 * 
887 	 * function setFailoverMode() {
888 	 * 
889 	 *    //Available input types and number of input ports for each input types may differ model by model. 
890 	 *    var options = { 
891 	 *      failoverMode : {
892 	 *         mode: Signage.FailoverMode.MANUAL,
893 	 *         priority : [
894 	 *            'ext://hdmi:1',
895 	 *            'ext://hdmi:2',
896 	 *            'ext://dvi:1',
897 	 *            'ext://internal_memory',
898 	 *            'ext://dp:1'
899 	 *         ]
900 	 *      }
901 	 *    }; 
902 	 *     
903 	 *    var successCb = function (){
904 	 *      console.log('Successfully set Failover Mode');
905 	 *    }; 
906 	 *         
907 	 *    var failureCb = function(cbObject){ 
908 	 *      var errorCode = cbObject.errorCode; 
909 	 *      var errorText = cbObject.errorText; 
910 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
911 	 *    }; 
912 	 * 
913 	 *    var signage = new Signage();
914 	 *    signage.setFailoverMode(successCallback, errorCallback, options);
915 	 * }
916 	 * 
917 	 * @class Signage
918 	 * @param {Function} successCallback success callback function.
919 	 * @param {Function} errorCallback failure callback function.
920 	 * @param {Object} options Input Parameters
921 	 * @param {Object} options.failoverMode Failover mode. Only attributes that exist will be set.
922 	 * 
923 	 * <div align=left>
924 	 * <table class="hcap_spec" width=400>
925 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
926 	 *   <tbody>
927 	 *       <tr><th>mode</th><th><a href="Signage.FailoverMode.html#constructor">Signage.FailoverMode</a></th><th>Failover mode</th><th>required</th></tr>
928 	 *       <tr class="odd"><th>priority</th><th>Array</th><th>Input priority that will be used when mode is MANUAL.<br> 
929 	 *       This parameter should be present only when mode is set to MANUAL(error is returned otherwise).</th><th>optional</th></tr>
930 	 *   </tbody>
931 	 * </table>
932 	 * </div>
933 	 * 
934 	 * Input source can be one of the following. Some of the input type may not be supported for a specific model. 
935 	 * <div align=left>
936 	 * <table class="hcap_spec" width=400>
937 	 *   <thead><tr><th>Name</th><th>Description</th></tr></thead>
938 	 *   <tbody>
939 	 *       <tr><th>ext://hdmi:[index]</th><th>HDMI Input</th></tr>
940 	 *       <tr class="odd"><th>ext://dvi:[index]</th><th>DVI Input</th></tr>
941 	 *       <tr><th>ext://rgb:[index]</th><th>RGB input</th></tr>
942 	 *       <tr class="odd"><th>ext://dp:[index]</th><th>Display port Input</th></tr>
943 	 *       <tr><th>ext://ops:[index]</th><th>OPS input</th></tr>
944 	 *       <tr class="odd"><th>ext://internal_memory</th><th>Internal Storage</th></tr>
945 	 *       <tr><th>ext://usb:[index]</th><th>External USB storage at usb port [index]</th></tr>
946 	 *       <tr class="odd"><th>ext://sdCard:[index]</th><th>External sd card Storage at sd card port [index]</th></tr>
947 	 *   </tbody>
948 	 * </table>
949 	 * </div>
950 	 * @returns  <p>After the method is successfully executed, successCallback is called without any parameter.</p>
951 	 *  <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
952 	 * 
953 	 * @since 1.0
954 	 */
955 	Signage.prototype.setFailoverMode = function (successCallback , errorCallback, options ) {
956 		var settings = {};
957 
958 		var errorMessage;
959 		function checkOptions(options){
960 			log("options:" + JSON.stringify(options, null, 3));
961 			var failoverMode = options.failoverMode ;
962 			if(failoverMode){				
963 
964 				if(failoverMode.mode){
965 					// If manual, see if priority is defined.
966 					if(failoverMode.mode === Signage.FailoverMode.MANUAL ){
967 						if(failoverMode.priority){
968 							if(failoverMode.priority.length === 0 || typeof failoverMode.priority.length === 'undefined'){
969 								return false;
970 							}	
971 							else{
972 								return true;
973 							}
974 						}
975 						else {
976 							errorMessage = "priority should be present when mode is MANUAL.";
977 							return false;						
978 						}
979 					}
980 					else{
981 						// if not manual, return error if priority is defined.
982 						if( failoverMode.priority ){
983 							errorMessage = "This priority is available only if mode is : Signage.FailoverMode.MANUAL";
984 							return false;
985 						}
986 						else{
987 							var found = false;
988 							// Should be one of the FailoverMode
989 							log("Mode is: " + failoverMode.mode);
990 							for(var key in Signage.FailoverMode){
991 								if(failoverMode.mode === Signage.FailoverMode[key]){
992 									log("Matched with: " +  Signage.FailoverMode[key]);
993 									found= true;
994 								}
995 							}
996 
997 							if(!found){
998 								log("Unrecognized failoverMode : " + failoverMode.mode);
999 								errorMessage = "Unrecognized failoverMode : " + failoverMode.mode;
1000 								return false;
1001 							}		
1002 							else{
1003 								return true;
1004 							}
1005 
1006 						}
1007 					}
1008 				}
1009 				else{
1010 					if(!failoverMode.priority){
1011 						return true;
1012 					}
1013 					else{
1014 						log("Unrecognized failoverMode : " + failoverMode.mode);
1015 						errorMessage = "Unrecognized failoverMode : " + failoverMode.mode;
1016 						return false;
1017 					}
1018 				}				
1019 			}
1020 			else{
1021 				errorMessage = "Fail over mode not set : ";
1022 				return false;				
1023 			}
1024 
1025 		}
1026 
1027 		if(checkOptions(options)){
1028 			var failoverMode = options.failoverMode;
1029 			if(!failoverMode.mode && !failoverMode.priority ){
1030 				successCallback();
1031 			}
1032 			else if(failoverMode.mode === Signage.FailoverMode.MANUAL){
1033 //				var priority = failoverMode.priority;
1034 //				log("priority: " + failoverMode.priority);
1035 //				for(var i=0;i<5; ++i){
1036 //				var attrName = SETTINGS_KEY.FAILOVER_PRIORITY + (i+1);
1037 //				log("attrName: " + attrName);
1038 //				var inputValue = "";
1039 //				if(i<priority.length){
1040 //				var inputUri = priority[i];
1041 //				log("input: " + inputUri);
1042 //				inputValue = getInputValue(inputUri);
1043 //				if(inputValue === false){
1044 //				var cbObj = {
1045 //				errorCode : 'API_ERROR',
1046 //				errorText : inputUri + " is not valid"
1047 //				};
1048 //				errorCallback(cbObj);
1049 //				return;
1050 //				}
1051 //				}
1052 //				else{
1053 //				log("No more input URI");
1054 //				}
1055 //				log("inputValue: " + inputValue);
1056 //				settings[attrName] = inputValue;
1057 //				}
1058 
1059 //				settings[SETTINGS_KEY.FAILOVER_MODE] = failoverMode.mode;
1060 
1061 				service.Request("luna://com.webos.service.commercial.signage.storageservice", {
1062 					method : "setManualFailoverPrioirty",
1063 					parameters : {priority:failoverMode.priority},
1064 					onSuccess : function(result) {
1065 						log("onSuccess!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
1066 						if(result.returnValue){
1067 							successCallback();
1068 						}
1069 						else{
1070 							log("FAILED: " + result.errorText );
1071 							errorCallback({errorCode:result.errorCode, errorText:result.errorText});
1072 						}
1073 					},
1074 					onFailure : function(result) {
1075 						log("onFailure!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
1076 						log("FAILED: " + result.errorText );					
1077 						errorCallback({errorCode:result.errorCode, errorText:result.errorText});
1078 					}
1079 				});	
1080 
1081 			}
1082 			else if(failoverMode.mode){
1083 				var modeStr = failoverMode.mode;
1084 				log("mode: " + failoverMode.mode);
1085 				settings[SETTINGS_KEY.FAILOVER_MODE] = modeStr;
1086 				log("Set: " + JSON.stringify(settings, null, 3));
1087 
1088 				setSystemSettings("commercial", settings, successCallback , errorCallback);
1089 
1090 				log("setFailoverMode Done");
1091 			}
1092 			else{
1093 				var errorObj ={
1094 						errorCode : "BAD_PARAMETER",
1095 						errorText : "Mode should be set."
1096 				};
1097 				errorCallback(errorObj);
1098 			}
1099 		}
1100 		else{
1101 			var errorObj ={
1102 					errorCode : "BAD_PARAMETER",
1103 					errorText : errorMessage
1104 			};
1105 			errorCallback(errorObj);
1106 		}
1107 	};
1108 
1109 	/**
1110 	 * <p>Gets Failover mode.
1111 	 *  When Failover Mode is set, monitor will automatically switch to the input source when the input signal fails, according to the predefined priorities set in the menu. </p>
1112 	 *  
1113 	 * <p>IMPORTANT NOTE!!!!</p>
1114 	 * <br>
1115 	 * When failover is triggered due to lost signal, the signage application will not
1116 	 * yield to the next priority input source set in the failover mode. When the signage application is destroyed, failover mode will be triggered.  
1117 	 *  
1118 	 * @example
1119 	 * function getFailoverMode() {
1120 	 * 
1121 	 *    var successCb = function (cbObject){
1122 	 *      var mode = cbObject.mode;
1123 	 *      var priority = cbObject.priority
1124 	 *      
1125 	 *      console.log('Failover Mode : ' + mode);
1126 	 *      console.log('Priority : ' + priority);
1127 	 *    }; 
1128 	 *         
1129 	 *    var failureCb = function(cbObject){ 
1130 	 *      var errorCode = cbObject.errorCode; 
1131 	 *      var errorText = cbObject.errorText;
1132 	 *       
1133 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
1134 	 *    }; 
1135 	 * 
1136 	 *    var signage = new Signage();
1137 	 *    signage.getFailoverMode(successCb, failureCb);
1138 	 * }
1139 	 * 
1140 	 * @class Signage
1141 	 * @param {Function} successCallback success callback function.
1142 	 * @param {Function} errorCallback failure callback function.
1143 	 * @returns  <p>After the method is successfully executed, successCallback is called with the following parameters</p>
1144 	 * <div align=left>
1145 	 * <table class="hcap_spec" width=400>
1146 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
1147 	 *   <tbody>
1148 	 *       <tr><th>mode</th><th><a href="Signage.FailoverMode.html#constructor">Signage.FailoverMode</a> | Signage.UNDEFINED</th><th>Failover mode. Signage.UNDEFINED is returned when this item is not set.</th></tr>
1149 	 *       <tr class="odd"><th>priority</th><th>Array</th><th>Input priority, as an ordered array of input source URI. Only valid when mode is set to MANUAL.</th></tr>
1150 	 *   </tbody>
1151 	 * </table>
1152 	 * </div>
1153 	 * 
1154 	 * Input source can be : 
1155 	 * <div align=left>
1156 	 * <table class="hcap_spec" width=400>
1157 	 *   <thead><tr><th>Name</th><th>Description</th></tr></thead>
1158 	 *   <tbody>
1159 	 *       <tr><th>ext://hdmi:[index]</th><th>HDMI Input</th></tr>
1160 	 *       <tr class="odd"><th>ext://dvi:[index]</th><th>DVI Input</th></tr>
1161 	 *       <tr><th>ext://internal_memory</th><th>Internal Storage</th></tr>
1162 	 *       <tr class="odd"><th>ext://dp:[index]</th><th>Display Port</th></tr>
1163 	 *   </tbody>
1164 	 * </table>
1165 	 * </div>
1166 	 *  <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
1167 	 * 
1168 	 * @since 1.0
1169 	 */
1170 	Signage.prototype.getFailoverMode = function (successCallback , errorCallback ) {
1171 		try{
1172 			service.Request("luna://com.webos.service.commercial.signage.storageservice", {
1173 				method : "getFailoverPrioirty",
1174 				parameters : {},
1175 				onSuccess : function(result) {
1176 					log("onSuccess!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
1177 					if(result.returnValue){
1178 						successCallback({priority:result.priority, mode:result.mode});
1179 					}
1180 					else{
1181 						log("FAILED: " + result.errorText );
1182 						errorCallback({errorCode:result.errorCode, errorText:result.errorText});
1183 					}
1184 				},
1185 				onFailure : function(result) {
1186 					log("onFailure!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
1187 					log("FAILED: " + result.errorText );					
1188 					errorCallback({errorCode:result.errorCode, errorText:result.errorText});
1189 				}
1190 			});	
1191 		} catch (err){
1192 			log("EXCEPTION!!!!!!!!!!!!!!!!!" + err);					
1193 		}
1194 	};
1195 
1196 
1197 	function getByType(val, type){
1198 		var mytype = typeof val;
1199 		log("mytype: " + mytype);
1200 		log("type: " + type);
1201 
1202 		if(mytype === 'undefined'){
1203 			return true;
1204 		}
1205 
1206 		else if(mytype === type )
1207 		{return val;}
1208 
1209 		else
1210 		{return false;}
1211 	}
1212 
1213 
1214 	/**
1215 	 * <p>Sets tile mode. Tile mode is used for multi-monitor display.</p>
1216 	 * @example 
1217 	 * 
1218 	 * function setTileInfo() {
1219 	 *    var options = {
1220 	 *      tileInfo: {
1221 	 *         enabled: true,
1222 	 *         row : 2,
1223 	 *         column : 2,
1224 	 *         tileId: 2,
1225 	 *         naturalMode : true
1226 	 *      }
1227 	 *    };
1228 	 * 
1229 	 *    var successCb = function (){
1230 	 *      console.log("Tile Info successfully Set");
1231 	 *    }; 
1232 	 * 
1233 	 *    var failureCb = function(cbObject){ 
1234 	 *      var errorCode = cbObject.errorCode; 
1235 	 *      var errorText = cbObject.errorText; 
1236 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
1237 	 *    };
1238 	 * 
1239 	 *    var signage = new Signage();
1240 	 *    signage.setTileInfo(successCb, failureCb, options);
1241 	 * }
1242 	 * 
1243 	 * @class Signage
1244 	 * @param {Function} successCallback success callback function.
1245 	 * @param {Function} errorCallback failure callback function.
1246 	 * @param {Object} options  parameter list.
1247 	 * @param {Object} options.tileInfo  TileInfo Object for setting.
1248 	 * Only attributes that exist will be set.
1249 	 * <div align=left>
1250 	 * <table class="hcap_spec" width=400>
1251 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
1252 	 *   <tbody>
1253 	 *       <tr><th>enabled</th><th>Boolean</th><th>Enable/disable Tile Mode</th><th>optional</th></tr>
1254 	 *       <tr class="odd"><th>row</th><th>Number</th><th>Number of rows (1~15)</th><th>optional</th></tr>
1255 	 *       <tr><th>column</th><th>Number</th><th>Number of columns (1~15)</th><th>optional</th></tr>
1256 	 *       <tr class="odd"><th>tileId</th><th>Number</th><th>The ID for this monitor. It will start to count from 1, left to right and top to bottom (1~Rows x Columns)</th><th>optional</th></tr>
1257 	 *       <tr><th>naturalMode</th><th>Boolean</th><th>Enable/disable Natural mode, which will adjust image based on the bezel size</th><th>optional</th></tr>
1258 	 *   </tbody>
1259 	 * </table>
1260 	 * </div>
1261 	 * 
1262 	 * @returns  <p>After the method is successfully executed, successCallback is called without any parameter.</br>
1263 	 * If an error occurs, errorCallback is called with errorCode and errorText.</p>
1264 	 * 
1265 	 * @since 1.0
1266 	 */
1267 	Signage.prototype.setTileInfo = function (successCallback , errorCallback,options ) {
1268 		var errorMessage;
1269 		var checkOptions =function (options){
1270 			var enabledType = typeof options.tileInfo.enabled;
1271 			log("enabledType:" + enabledType);
1272 			if(enabledType !== 'undefined' && enabledType !== 'boolean'){
1273 				errorMessage = "enabled should be a boolean";
1274 				return false;
1275 			}
1276 
1277 			var isNotANaturalNumber = function(isNum){
1278 				var ret = new RegExp(/^[0-9]+$/g).exec(isNum);
1279 				if(ret){
1280 					return false;					
1281 				}
1282 				else{
1283 					return true;
1284 				}
1285 			};
1286 			
1287 			if(options.tileInfo){
1288 				var row = options.tileInfo.row;
1289 				if(typeof row !== 'undefined'){
1290 					if(isNotANaturalNumber(row)){
1291 						errorMessage = "row should be a natural number :" +row;
1292 						return false;					
1293 					}				
1294 					else if(row > 15 || row < 1){
1295 						errorMessage = "row should be 0<n<16 but :" +row;
1296 						return false;
1297 					}				
1298 				}
1299 				else{
1300 					return true;				
1301 				}
1302 
1303 				var column = options.tileInfo.column;
1304 				if(typeof column !== 'undefined'){
1305 					if(isNotANaturalNumber(column)){
1306 						errorMessage = "column should be a natural number :" +column;
1307 						return false;					
1308 					}				
1309 					else if(column > 15 || column < 1){
1310 						errorMessage = "column should be 0<n<16 but :" +column;
1311 						return false;
1312 					}				
1313 				}
1314 				else{
1315 					return true;				
1316 				}
1317 
1318 				var id = options.tileInfo.tileId;
1319 				if(typeof id !== 'undefined'){
1320 					if(isNotANaturalNumber(id)){
1321 						errorMessage = "id should be a natural number :" +id;
1322 						return false;					
1323 					}				
1324 					else if(id < 1){
1325 						errorMessage = "id should be bigger than 0 but :" +id;
1326 						return false;
1327 					}
1328 					else{
1329 						var curRow = _gTileInfo.row;
1330 						if(row) {curRow = row;}
1331 
1332 						var curCol = _gTileInfo.column;
1333 						if(column)	{curCol = column;}
1334 
1335 						log("curRow : " + curRow);
1336 						log("curCol : " + curCol);
1337 						log("id : " + id);
1338 
1339 
1340 						if(id > curCol * curRow){
1341 							errorMessage = "ID should be less than curRow*curCol";
1342 							return false;
1343 						}					
1344 					}
1345 				}
1346 				else{
1347 					return true;				
1348 				}				
1349 			}else{
1350 				errorMessage = "Tile info is mandatory";
1351 				return false;
1352 				
1353 			}
1354 
1355 			return true;
1356 
1357 		};
1358 
1359 		if(checkOptions(options) === true){
1360 			var tileInfo = options.tileInfo;
1361 			var settings = {};
1362 
1363 			if(typeof tileInfo.enabled ==='boolean'){
1364 				if(tileInfo.enabled){settings[SETTINGS_KEY.TILE_MODE] = 'on';}
1365 				else {settings[SETTINGS_KEY.TILE_MODE] = 'off';}
1366 			}
1367 
1368 			if(tileInfo.row){
1369 				settings[SETTINGS_KEY.TILE_ROW] = tileInfo.row.toString();
1370 			}
1371 
1372 			if(tileInfo.column){
1373 				settings[SETTINGS_KEY.TILE_COLUME] = tileInfo.column.toString();
1374 			}
1375 
1376 			if(tileInfo.tileId){
1377 				settings[SETTINGS_KEY.TILE_ID] = tileInfo.tileId.toString();
1378 			}
1379 
1380 			if(typeof tileInfo.naturalMode  ==='boolean' ){
1381 				if(tileInfo.naturalMode) {
1382 					settings[SETTINGS_KEY.TILE_NATURALMODE] = 'on';
1383 				}
1384 				else{
1385 					settings[SETTINGS_KEY.TILE_NATURALMODE] = 'off';
1386 				}
1387 			}
1388 
1389 			log("Set: " + JSON.stringify(settings, null, 3));
1390 
1391 
1392 			var newCallBack = function(){
1393 				log("Do callback!!!!!!!!");
1394 
1395 				if(tileInfo.row){
1396 					_gTileInfo.row = tileInfo.row;
1397 				}
1398 
1399 				if(tileInfo.column){
1400 					_gTileInfo.column = tileInfo.column;
1401 				}
1402 
1403 				if(successCallback && typeof successCallback === 'function'){
1404 					log("Invoke successCallback");
1405 					successCallback();
1406 					log("Invoked successCallback");
1407 				}
1408 			};
1409 
1410 
1411 			setSystemSettings("commercial", settings, newCallBack , errorCallback);
1412 
1413 			/*
1414 
1415 			setSystemSettings("commercial", settings, 
1416 				function(){
1417 					log("Do callback!!!!!!!!");
1418 
1419 					if(tileInfo.row)
1420 						_gTileInfo.row = tileInfo.row;
1421 
1422 					if(tileInfo.column)
1423 						_gTileInfo.column = tileInfo.column;
1424 
1425 					if(successCallback && typeof successCallback === 'function'){
1426 						log("Invoke successCallback");	
1427 						successCallback();
1428 						log("Invoked successCallback");	
1429 
1430 					}
1431 				},
1432 				successCallback,							
1433 				errorCallback);
1434 			 */
1435 
1436 			log("setTileInfo Done");
1437 		}
1438 		else{
1439 			var cbObj ={
1440 					errorCode : "BAD_PARAM",
1441 					errorText : errorMessage
1442 			};
1443 			errorCallback(cbObj);
1444 		}
1445 
1446 	};
1447 
1448 	function getBooleanValue(value){
1449 		if(value === 'on')
1450 		{return true;}
1451 		else if(value==='off')
1452 		{return false;}
1453 		else
1454 		{return false;}
1455 	}
1456 
1457 	/**
1458 	 * <p>Gets current tile mode.</p>
1459 	 * @example 
1460 	 * function getTileInfo() {
1461 	 *    
1462 	 *    var successCb = function (cbObject){
1463 	 *    
1464 	 *      var enabled = cbObject.enabled;
1465 	 *      var row = cbObject.row;
1466 	 *      var column = cbObject.column;
1467 	 *      var tileId = cbObject.tileId;
1468 	 *      var naturalMode = cbObject.naturalMode;
1469 	 *      
1470 	 *      console.log("enable: " + enabled);
1471 	 *      console.log("row: " + row);	
1472 	 *      console.log("column: " + column);
1473 	 *      console.log("tileId: " + tileId);	
1474 	 *      console.log("naturalMode: " + naturalMode);	
1475 	 *    };
1476 	 *  
1477 	 *    var failureCb = function(cbObject){ 
1478 	 *      var errorCode = cbObject.errorCode; 
1479 	 *      var errorText = cbObject.errorText; 
1480 	 *      
1481 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
1482 	 *    };
1483 	 * 
1484 	 *    var signage = new Signage();
1485 	 *    signage.getTileInfo(successCb, failureCb);
1486 	 * }
1487 	 * 
1488 	 * @class Signage
1489 	 * @param {Function} successCallback success callback function.
1490 	 * @param {Function} errorCallback failure callback function.
1491 	 * 
1492 	 * @returns  <p>After the method is successfully executed, successCallback is called with following data.</p>
1493 	 * <div align=left>
1494 	 * <table class="hcap_spec" width=400>
1495 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
1496 	 *   <tbody>
1497 	 *       <tr><th>enabled</th><th>Boolean</th><th>Enable/disable Tile Mode</th></tr>
1498 	 *       <tr class="odd"><th>row</th><th>Number</th><th>Number of rows (1~15)</th></tr>
1499 	 *       <tr><th>column</th><th>Number</th><th>Number of columns (1~15)</th></tr>
1500 	 *       <tr class="odd"><th>tileId</th><th>Number</th><th>The ID for this monitor. It will start to count from 1, left to right and top to bottom (1~Rows x Columns)</th></tr>
1501 	 *       <tr><th>naturalMode</th><th>Boolean</th><th>Enable/disable Natural mode, which will adjust image based on the bezel size</th></tr>
1502 	 *   </tbody>
1503 	 * </table>
1504 	 * </div>
1505 	 * 
1506 	 * 
1507 	 * <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
1508 	 * 
1509 	 * @since 1.0
1510 	 */
1511 	Signage.prototype.getTileInfo = function (successCallback , errorCallback ) {
1512 		var cbgetter = function(settings){
1513 			var cbObj = {};
1514 			log("settings Value: " + JSON.stringify(settings, null ,3));
1515 			cbObj.enabled = getBooleanValue(settings[SETTINGS_KEY.TILE_MODE]);
1516 			cbObj.row= parseInt(settings[SETTINGS_KEY.TILE_ROW] , 10);
1517 			cbObj.column= parseInt(settings[SETTINGS_KEY.TILE_COLUME], 10);
1518 			cbObj.tileId= parseInt(settings[SETTINGS_KEY.TILE_ID], 10);
1519 			cbObj.naturalMode= getBooleanValue(settings[SETTINGS_KEY.TILE_NATURALMODE]);
1520 
1521 			log("Return Value: " + JSON.stringify(cbObj, null ,3));
1522 			return cbObj;
1523 		};
1524 
1525 		var keys = [SETTINGS_KEY.TILE_MODE,SETTINGS_KEY.TILE_ROW,SETTINGS_KEY.TILE_COLUME,SETTINGS_KEY.TILE_ID,SETTINGS_KEY.TILE_NATURALMODE];
1526 		getSystemSettings("commercial", keys, cbgetter, successCallback , errorCallback);
1527 	};
1528 
1529 	/**
1530 	 * <p>Gets signage information</p>
1531 	 * 
1532 	 * @example 
1533 	 * 
1534 	 * function getSignageInfo() {
1535 	 * 
1536 	 *    var successCb = function (cbObject){
1537 	 *      var portraitMode= cbObject.signageInfo;
1538 	 *      var ismMethod= cbObject.ismMethod;
1539 	 *      var digitalAudioInputMode= cbObject.digitalAudioInputMode;
1540 	 * 
1541 	 *      console.log("portraitMode: " + portraitMode);
1542 	 *      console.log("ismMethod: " + ismMethod);
1543 	 *   
1544 	 *      for(var input in digitalAudioInputMode){
1545 	 *         var audioInput = digitalAudioInputMode[input];
1546 	 *         console.log("digitalAudioInputMode for " + input +" = " + audioInput);
1547 	 *      }
1548 	 *    }; 
1549 	 * 
1550 	 *    var failureCb = function(cbObject){ 
1551 	 *      var errorCode = cbObject.errorCode; 
1552 	 *      var errorText = cbObject.errorText; 
1553 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
1554 	 *    };
1555 	 * 
1556 	 *    var signage = new Signage();
1557 	 *    signage.getSignageInfo(successCb, failureCb);
1558 	 * 
1559 	 * }
1560 	 * 
1561 	 * @class Signage
1562 	 * @param {Function} successCallback success callback function.
1563 	 * @param {Function} errorCallback failure callback function.
1564 	 * 
1565 	 * @returns  <p>After the method is successfully executed, successCallback is called with the following parameters.</p>
1566 	 * 
1567 	 * <div align=left>
1568 	 * <table class="hcap_spec" width=400>
1569 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
1570 	 *   <tbody>
1571 	 *       <tr><th>portraitMode</th><th>Signage.OsdPortraitMode | Signage.UNDEFINED</th><th>Portrait mode.<br>If the value for this item is not set or defined, Signage.UNDEFINED will be returned. </th></tr>
1572 	 *       <tr class="odd"><th>ismMethod</th><th>Signage.IsmMethod | Signage.UNDEFINED</th><th>ISM(Image Sticking Minimization) Method.<br>If the value for this item is not set or defined, Signage.UNDEFINED will be returned. </th></tr>
1573 	 *       <tr><th>digitalAudioInputMode</th><th>Array</th><th>Digital audio input mode.<br>Array of {input_uri : Signage.DigitalAudioInput or Signage.UNDEFINED } pair. </th></tr>
1574 	 *       <tr class="odd"><th>checkScreen</th><th>Boolean</th><th>Pixel sensor is enabled. true: enabled, false: disabled <br>If it is enabled, Signage.EventType.SCREEN_STATUS event is available. </th></tr>
1575 	 *   </tbody>
1576 	 * </table>
1577 	 * </div>
1578 	 * 
1579 	 * <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
1580 	 * 
1581 	 * @since 1.0
1582 	 * @since 1.3 checkScreen
1583 	 */
1584 	Signage.prototype.getSignageInfo = function (successCallback , errorCallback ) {
1585 		service.Request("luna://com.webos.service.commercial.signage.storageservice/", {
1586 			method : "getSignageInformation",
1587 			parameters : {},
1588 			onSuccess : function(res) {
1589 				if(typeof successCallback === 'function'){
1590 					console.log(res.signageInfo);
1591 					successCallback(res.signageInfo);
1592 				}
1593 			},
1594 			onFailure : function(result) {
1595 				delete result.returnValue;
1596 				if(typeof errorCallback === 'function'){
1597 					errorCallback(result);
1598 				}
1599 			}
1600 		});
1601 	};
1602 
1603 	/**
1604      * <p>Enables pixel sensor.</p>
1605      * 
1606      * @class Signage
1607      * @param {Function} successCallback success callback function.
1608      * @param {Function} errorCallback failure callback function.
1609      * @param {Object} options
1610      * <div align=left>
1611      * <table class="hcap_spec" width=400>
1612      *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
1613      *   <tbody>
1614      *       <tr><th>checkScreen</th><th>Boolean</th><th>true : enabled / false : disabled </th><th>required</th></tr>
1615      *   </tbody>
1616      * </table>
1617      * </div>
1618      * @return <p>If the method is successfully executed, success callback function is called without a parameter.</br>
1619      * If an error occurs, failure callback function is called with failure callback object as a parameter.</p>
1620      * 
1621      * @example 
1622      * function enableCheckScreen() {
1623      * 
1624      *    var successCb = function (){
1625      *      console.log("Successfully enabled checkScreen");
1626      *    };
1627      * 
1628      *    var failureCb = function(cbObject){ 
1629      *      var errorCode = cbObject.errorCode; 
1630      *      var errorText = cbObject.errorText; 
1631      *      console.log( " Error Code [" + errorCode + "]: " + errorText);
1632      *    };
1633      *    
1634      *    var options = {
1635      *      checkScreen : true
1636      *    };
1637      *    
1638      *    var signage = new Signage();
1639      *    signage.enableCheckScreen(successCb, failureCb, options);
1640      * }
1641      * 
1642      * @since 1.3
1643      * 
1644      * @see
1645      * <a href="Signage%23getSignageInfo.html">Signage.getSignageInfo()</a><br>
1646      */
1647     Signage.prototype.enableCheckScreen = function (successCallback, errorCallback, options ) {
1648         
1649         var errorMessage;
1650         
1651         var checkOptions = function (options){
1652             if(typeof options.checkScreen !== "undefined" || options.checkScreen !== null){
1653                 return true;
1654             } else {
1655                 errorMessage = "need options.checkScreen.";
1656                 return false;
1657             }
1658         };
1659 
1660         if(checkOptions(options)){
1661             
1662             var settings = {
1663                     checkScreen:(options.checkScreen === true ? "on" : "off")
1664             };
1665             
1666             log("Set: " + JSON.stringify(settings, null, 3));
1667             
1668             setSystemSettings("commercial", settings, successCallback , errorCallback);
1669 
1670             log("enableCheckScreen Done");
1671         } else {
1672             var cbObj ={
1673                     errorCode : "BAD_PARAMETER",
1674                     errorText : errorMessage
1675             };
1676             errorCallback(cbObj);
1677         }
1678     };
1679     
1680 	/**
1681 	 * <p>Sets ISM(Image Sticking Minimization) Method.</p>
1682 	 * 
1683 	 * @example 
1684 	 * 
1685 	 * function setIsmMethod() {
1686 	 *    var options = {
1687 	 *      ismMethod : Signage.IsmMethod.NORMAL
1688 	 *    };
1689 	 * 
1690 	 *    var successCb = function (){
1691 	 *      console.log("Successfully set ISM Method");
1692 	 *    };
1693 	 * 
1694 	 *    var failureCb = function(cbObject){ 
1695 	 *      var errorCode = cbObject.errorCode; 
1696 	 *      var errorText = cbObject.errorText; 
1697 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText);
1698 	 *    };
1699 	 * 
1700 	 *    var signage = new Signage();
1701 	 *    signage.setIsmMethod (successCb, failureCb, options);
1702 	 * }
1703 	 * 
1704 	 * @class Signage
1705 	 * @param {Function} successCallback success callback function.
1706 	 * @param {Function} errorCallback failure callback function.
1707 	 * @param {Object} options  parameter list.
1708 	 * @param {Signage.IsmMethod} options.ismMethod ISM Method.
1709 	 * @returns  
1710 	 * <p>
1711 	 * After the method is successfully executed, successCallback is called without any parameter.</br>
1712 	 * If an error occurs, errorCallback is called with errorCode and errorText.</p>
1713 	 * 
1714 	 * @since 1.0
1715 	 */
1716 	Signage.prototype.setIsmMethod = function (successCallback , errorCallback,options ) {
1717 		var settings = {};
1718 		var errorMessage;
1719 		function checkOptions(options){
1720 			if(options.ismMethod){
1721 				for(var key in Signage.IsmMethod){
1722 					if(options.ismMethod  === Signage.IsmMethod[key]){
1723 						return true;
1724 					}
1725 				}
1726 
1727 				errorMessage = "Unrecognized ismMethod  : " + options.ismMethod ;
1728 				return false;
1729 			}
1730 			else{
1731 				errorMessage = "ismMethod  does not exist.";
1732 				return false;
1733 			}
1734 		}
1735 
1736 		if(checkOptions(options)){
1737 			if(options.ismMethod ){
1738 				var ismMethod  = options.ismMethod ;
1739 				log("ismMethod : " + ismMethod);
1740 				settings[SETTINGS_KEY.ISM_METHOD] = ismMethod;
1741 			}
1742 
1743 			log("Set: " + JSON.stringify(settings, null, 3));
1744 
1745 			setSystemSettings("commercial", settings, successCallback , errorCallback);
1746 
1747 			log("setIsmMethod Done");
1748 		}
1749 		else{
1750 			var cbObj ={
1751 					errorCode : "BAD_PARAMETER",
1752 					errorText : errorMessage
1753 			};
1754 			errorCallback(cbObj);
1755 		}
1756 
1757 	};
1758 
1759 
1760 
1761 	/**
1762 	 * <p>Sets digital audio input mode. </p> <br>
1763 	 * Audio from different source can be mixed with a video from HDMI or DP using this method.
1764 	 * @example 
1765 	 * function setDigitalAudioInputMode() {
1766 	 * 
1767 	 *    var options = {
1768 	 *      digitalAudioInputList:{
1769 	 *         'ext://hdmi:1' : Signage.DigitalAudioInput.HDMI_DP,
1770 	 *         'ext://hdmi:2' : Signage.DigitalAudioInput.HDMI_DP,
1771 	 *         'ext://dp:1' : Signage.DigitalAudioInput.AUDIO_IN
1772 	 *      }
1773 	 *    };
1774 	 * 
1775 	 *    var successCb = function (){
1776 	 *      console.log("Successfully Done");
1777 	 *    }; 
1778 	 * 
1779 	 *    var failureCb = function(cbObject){ 
1780 	 *      var errorCode = cbObject.errorCode; 
1781 	 *      var errorText = cbObject.errorText; 
1782 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
1783 	 *    };
1784 	 * 
1785 	 *    var signage = new Signage();
1786 	 *    signage.setDigitalAudioInputMode (successCb, failureCb, options);
1787 	 * 
1788 	 * }
1789 	 * 
1790 	 * @class Signage
1791 	 * @param {Function} successCallback success callback function.
1792 	 * @param {Function} errorCallback failure callback function.
1793 	 * @param {Object} options  parameter list.
1794 	 * @param {Object} options.digitalAudioInputList List of digital audio input mode. 
1795 	 * In HDMI_DP mode, same audio from HDMI or DP is used. In AUDIO_IN mode, HDMI or DP video input can be used with external analog audio input.
1796 	 * @returns  
1797 	 * <p>
1798 	 * After the method is successfully executed, successCallback is called without any parameter.</br>
1799 	 * If an error occurs, errorCallback is called with errorCode and errorText.</p>
1800 	 * 
1801 	 * @since 1.0
1802 	 */
1803 	Signage.prototype.setDigitalAudioInputMode = function (successCallback , errorCallback,options ) {
1804 		var settings = {};
1805 
1806 		var errorMessage;
1807 		function checkOptions(options){
1808 			if(options.digitalAudioInputList){
1809 				for(var key in options.digitalAudioInputList){
1810 					if(key){
1811 						var value = options.digitalAudioInputList[key];
1812 						var found = false;
1813 						for(var type in Signage.DigitalAudioInput){
1814 							if(value === Signage.DigitalAudioInput[type]){
1815 								found = true;
1816 							}
1817 						}
1818 						if(!found){
1819 							errorMessage = "Invalid Audio Input  : " + value ;
1820 							return false;
1821 						}
1822 					}
1823 				}
1824 
1825 				return true;
1826 			}
1827 			else{
1828 				errorMessage = "digitalAudioInputList  does not exist.";
1829 				return false;
1830 			}
1831 		}
1832 
1833 
1834 		if(checkOptions(options)){
1835 			/*for(var input in options.digitalAudioInputList){
1836 				if(input === 'ext://hdmi:1'){
1837 					settings[SETTINGS_KEY.AUDIO_SOURCE_HDMI1] = options.digitalAudioInputList[input];
1838 				}
1839 				else if(input === 'ext://hdmi:2'){
1840 					settings[SETTINGS_KEY.AUDIO_SOURCE_HDMI2] = options.digitalAudioInputList[input];
1841 				}
1842 				else if(input === 'ext://dp:1'){
1843 					settings[SETTINGS_KEY.AUDIO_SOURCE_DP] = options.digitalAudioInputList[input];
1844 				}
1845 			}*/
1846 
1847 			service.Request("luna://com.webos.service.commercial.signage.storageservice/", {
1848 				method : "setDigitalAudioInputList",
1849 				parameters : {
1850 					digitalAudioInputList : options.digitalAudioInputList
1851 				},
1852 				onSuccess : function() {
1853 					if(typeof successCallback === 'function'){
1854 						successCallback();
1855 					}
1856 				},
1857 				onFailure : function(result) {
1858 					delete result.returnValue;
1859 					if(typeof errorCallback === 'function'){
1860 						errorCallback(result);
1861 					}
1862 				}
1863 			});
1864 		}
1865 		else{
1866 			var cbObj ={
1867 					errorCode : "BAD_PARAMETER",
1868 					errorText : errorMessage
1869 			};
1870 			errorCallback(cbObj);
1871 		}
1872 	};
1873 
1874 
1875 	var _gDoBlock = false;
1876 	/**
1877 	 * <p>
1878 	 * Registers system monitoring setting. If one of the attributes is set to true, corresponding sensor events will be received.
1879 	 * When this method is called, all the previously registered monitoring event setup will be reset.
1880 	 * </p>
1881 	 * @example 
1882 	 * 
1883 	 * function registerSystemMonitor() {
1884 	 *    var eventHandler = function(event){
1885 	 *      console.log("Received Event from : " + event.source);
1886 	 *      console.log("Event Type is : " + event.type);
1887 	 *      console.log("Additional Info : " + JSON.stringify(event.data));
1888 	 *    };
1889 	 * 
1890 	 *    var options = { 
1891 	 *      monitorConfiguration: {
1892 	 *         fan: true,
1893 	 *         signal : true,
1894 	 *         lamp : true,
1895 	 *         screen : true,
1896 	 *      },
1897 	 *      eventHandler : eventHandler	
1898 	 *    };
1899 	 *  
1900 	 *    var successCb = function (){
1901 	 *      console.log("successfully Set");
1902 	 *    };
1903 	 * 
1904 	 *    var failureCb = function(cbObject){
1905 	 *      var errorCode = cbObject.errorCode;
1906 	 *      var errorText = cbObject.errorText;
1907 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
1908 	 *    };
1909 	 * 
1910 	 *    var signage = new Signage();
1911 	 *    signage.registerSystemMonitor(successCb, failureCb, options);
1912 	 * 
1913 	 * }
1914 	 * 
1915 	 * @class Signage
1916 	 * @param {Function} successCallback success callback function.
1917 	 * @param {Function} errorCallback failure callback function.
1918 	 * @param {Object} options  parameter list.
1919 	 * @param {Object} options.monitorConfiguration  monitorConfiguration object for setting.
1920 	 * Only attributes that exist will be set.
1921 	 * <div align=left>
1922 	 * <table class="hcap_spec" width=400>
1923 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
1924 	 *   <tbody>
1925 	 *       <tr><th>fan</th><th>Boolean</th><th>Receive events from the sensor that monitors the fan </th><th>optional</th></tr>
1926 	 *       <tr class="odd"><th>signal</th><th>Boolean</th><th>Receive events from the signal receiver</th><th>optional</th></tr>
1927 	 *       <tr><th>lamp</th><th>Boolean</th><th>Receive events from the sensor that monitors the lamp</th><th>optional</th></tr>
1928 	 *       <tr class="odd"><th>screen</th><th>Boolean</th><th>Receive events from the sensor that monitors the screen</th><th>optional</th></tr>
1929 	 *       <tr><th>temperature</th><th>Boolean</th><th>Receive events from the sensor that monitors the audio</th><th>optional</th></tr>
1930 	 *   </tbody>
1931 	 * </table>
1932 	 * </div>
1933 	 * @param {Function} options.eventHandler The function for handling system monitor events.
1934 	 * This function has an event object as a parameter, which contains following properties.
1935 	 * <div align=left>
1936 	 * <table class="hcap_spec" width=400>
1937 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
1938 	 *   <tbody>
1939 	 *       <tr><th>source</th><th>Signage.MonitoringSource</th><th>The source of this event</th><th>required</th></tr>
1940 	 *       <tr class="odd"><th>type</th><th>Signage.EventType</th><th>Event Type</th><th>required</th></tr>
1941 	 *       <tr><th>data</th><th>Object</th><th>Additional Data. Format may vary for event type</th><th>optional</th></tr>
1942 	 *   </tbody>
1943 	 * </table>
1944 	 * </div>
1945 	 * @returns  
1946 	 * <p>
1947 	 * After the method is successfully executed, successCallback is called without any parameter.</br>
1948 	 * If an error occurs, errorCallback is called with errorCode and errorText.</p>
1949 	 * 
1950 	 * @since 1.0
1951 	 */
1952 	Signage.prototype.registerSystemMonitor = function (successCallback , errorCallback, options ) {
1953 		var keys =['fan', 'signal', 'lamp', 'screen', 'temperature'];
1954 		var errorMessage;
1955 		var errorCode = "BAD_PARAMETER";
1956 
1957 		log("Listeners are: " + JSON.stringify(_gSystemMonitoringSetup, null, 3));
1958 
1959 		function checkOptions(options){
1960 			if(_gDoBlock === true){
1961 				errorMessage = "Not ready to register monitor now." ;
1962 				errorCode = "SYSTEM_ERROR";
1963 				return false;
1964 			}
1965 
1966 			log("options are: " + JSON.stringify(options, null, 3));
1967 
1968 			if(typeof options.eventHandler !== 'function'){
1969 				errorMessage = "No event handler was given or event hadnler is not a function" ;
1970 				return false;
1971 			}
1972 
1973 			if(options.monitorConfiguration){
1974 				for(var key in options.monitorConfiguration){
1975 					if(key){
1976 						var found = false;
1977 						for(var i =0; i < keys.length;++i){
1978 							if(key === keys[i]){
1979 								log("Found key: " + keys[i]);
1980 								found = true;
1981 							}
1982 						}
1983 
1984 						if(!found){
1985 							errorMessage = "Invalid Monitoring source  : " + key ;
1986 							return false;
1987 						}
1988 
1989 						var value = options.monitorConfiguration[key];
1990 						log("value: " + value);
1991 
1992 						if(typeof value !== 'boolean'){
1993 							errorMessage = "Invalid value  : " + value;
1994 							return false;
1995 						}
1996 					}
1997 				}
1998 				return true;
1999 			}
2000 			else{
2001 				errorMessage = "monitorConfiguration  does not exist.";
2002 				return false;
2003 			}
2004 		}
2005 
2006 		if(checkOptions(options)){
2007 
2008 			var cancelSuccess = function(){
2009 				log("Canceled all previous message subscriptions");
2010 
2011 				var handler = options.eventHandler;
2012 				for(var key in options.monitorConfiguration){
2013 					if(key){
2014 						var value = options.monitorConfiguration[key];
2015 						if(value === true){
2016 							log("Add listener for : " + key);
2017 							addSignageEventListener(key, handler);
2018 						}
2019 					}
2020 				}
2021 				log("Monitoring Setup : " + JSON.stringify(_gSystemMonitoringSetup, null, 3));
2022 				// Start Polling
2023 
2024 				log("Start Polling : ");
2025 
2026 				service.Request("luna://com.webos.service.commercial.signage.storageservice", {
2027 					method : "systemMonitor/startMonitor",
2028 					parameters : {},
2029 					onSuccess : function(result) {
2030 						log("On Success");
2031 						if(result.returnValue === true){
2032 							if(successCallback && typeof successCallback === 'function'){
2033 								successCallback();
2034 							}
2035 						}
2036 						else{
2037 							if(errorCallback && typeof errorCallback === 'function'){
2038 								errorCallback(result);
2039 							}
2040 						}
2041 						_gDoBlock = false;
2042 					},
2043 					onFailure : function(result) {
2044 						log("On Failure");
2045 						delete result.returnValue;
2046 						if(errorCallback && typeof errorCallback === 'function'){
2047 							errorCallback(result);
2048 						}
2049 						_gDoBlock = false;
2050 					}
2051 				});
2052 			};
2053 
2054 			var cancelError = function(result){
2055 				errorCallback(result);
2056 			};
2057 
2058 			// Cancel all previous message subscriptions
2059 			log("Cancel all previous message subscriptions");
2060 			_gDoBlock = true;
2061 			cancelAllSubscription(cancelSuccess , cancelError);
2062 		}
2063 		else{
2064 			var cbObj ={
2065 					errorCode : errorCode,
2066 					errorText : errorMessage
2067 			};
2068 			errorCallback(cbObj);
2069 		}
2070 	};
2071 
2072 	/**
2073 	 * <p>
2074 	 * Unregisters all the system monitoring handlers. No more monitoring events will be received.
2075 	 * </p>
2076 	 * @example 
2077 	 * 
2078 	 * function unregisterSystemMonitor() {
2079 	 *    var successCb = function (){
2080 	 *      console.log("successfully canceled");
2081 	 *    };
2082 	 * 
2083 	 *    var failureCb = function(cbObject){
2084 	 *      var errorCode = cbObject.errorCode;
2085 	 *      var errorText = cbObject.errorText;
2086 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
2087 	 *    };
2088 	 * 
2089 	 *    var signage = new Signage();
2090 	 *    signage.unregisterSystemMonitor(successCb, failureCb);
2091 	 * }
2092 	 * 
2093 	 * @class Signage
2094 	 * @param {Function} successCallback success callback function.
2095 	 * @param {Function} errorCallback failure callback function.
2096 	 * 
2097 	 * @returns  <p>After the method is successfully executed, successCallback is called without any parameter.</br>
2098 	 * If an error occurs, errorCallback is called with errorCode and errorText.</p>
2099 	 * 
2100 	 * @since 1.0
2101 	 */
2102 
2103 	Signage.prototype.unregisterSystemMonitor = function (successCallback , errorCallback ) {
2104 		cancelAllSubscription( successCallback , errorCallback );
2105 		log("After unregister, _gSystemMonitoringSetup are: " + JSON.stringify(_gSystemMonitoringSetup, null, 3));
2106 	};
2107 
2108 	function cancelAllSubscription ( successCallback , errorCallback ){
2109 		log("cancelAllSubscription> setup are: " + JSON.stringify(_gSystemMonitoringSetup, null, 3));
2110 
2111 		for (var key in _gSystemMonitoringSetup){
2112 			if(key){
2113 				removeSignageEventListener(key);
2114 			}
2115 		}
2116 
2117 		/*
2118 		if(_gSystemMonitoringSetup.fan === true){
2119 			log("Remove monitor_fan");
2120 			removeEventListener('monitor_fan');
2121 			_gSystemMonitoringSetup.fan = false;
2122 		}
2123 
2124 		if(_gSystemMonitoringSetup.screen === true){
2125 			log("Remove monitor_screen");
2126 			removeEventListener('monitor_screen');
2127 			_gSystemMonitoringSetup.screen = false;
2128 		}
2129 
2130 		if(_gSystemMonitoringSetup.temperature === true){
2131 			log("Remove monitor_temperature");
2132 			removeEventListener('monitor_temperature');
2133 			_gSystemMonitoringSetup.temperature = false;
2134 		}
2135 
2136 		if(_gSystemMonitoringSetup.signal === true){
2137 			log("Remove monitor_signal");
2138 			removeEventListener('monitor_signal');
2139 			_gSystemMonitoringSetup.signal = false;
2140 		}
2141 		if(_gSystemMonitoringSetup.lamp === true){
2142 			log("Remove monitor_lamp");
2143 			removeEventListener('monitor_lamp');
2144 			_gSystemMonitoringSetup.lamp = false;
2145 		}
2146 		 */
2147 		log("Stop Polling");
2148 
2149 		service.Request("luna://com.webos.service.commercial.signage.storageservice", {
2150 			method : "systemMonitor/stopMonitor",
2151 			parameters : {},
2152 			onSuccess : function(result) {
2153 				log("On Success");
2154 				if(result.returnValue === true){
2155 					if(successCallback && typeof successCallback === 'function'){
2156 						successCallback();
2157 					}
2158 				}
2159 				else{
2160 					if(errorCallback && typeof errorCallback === 'function'){
2161 						errorCallback(result);
2162 					}
2163 				}
2164 			},
2165 			onFailure : function(result) {
2166 				log("On Failure");
2167 				delete result.returnValue;
2168 				if(errorCallback && typeof errorCallback === 'function'){
2169 					errorCallback(result);
2170 				}
2171 			}
2172 		});
2173 
2174 
2175 	}
2176 
2177 
2178 	/**
2179 	 * <p>Gets system monitoring setting. If one of the attributes is set to true, corresponding sensor events will be sent.
2180 	 * Use onSignageMonitoringEvent to register handler for those events.
2181 	 * </p>
2182 	 * @example 
2183 	 * function getSystemMonitoringInfo() {
2184 	 *    var successCb = function (cbObject){
2185 	 *      var fan =  cbObject.fan;
2186 	 *      var signal =  cbObject.signal;
2187 	 *      var lamp =  cbObject.lamp;
2188 	 *      var screen =  cbObject.screen;
2189 	 *      var temperature =  cbObject.temperature;	 
2190 	 * 
2191 	 *      console.log("Monitor Fan: " + fan);
2192 	 *      console.log("Monitor signal: " + signal);
2193 	 *      console.log("Monitor lamp: " + lamp);
2194 	 *      console.log("Monitor screen: " + screen);
2195 	 *      console.log("Monitor temperature: " + temperature);	 
2196 	 *    };
2197 	 * 
2198 	 *    var failureCb = function(cbObject){
2199 	 *      var errorCode = cbObject.errorCode;
2200 	 *      var errorText = cbObject.errorText;
2201 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
2202 	 *    };
2203 	 * 
2204 	 *    var signage = new Signage();
2205 	 *    signage.getSystemMonitoringInfo(successCb, failureCb);
2206 	 * }
2207 	 * 
2208 	 * @class Signage
2209 	 * @param {Function} successCallback success callback function.
2210 	 * @param {Function} errorCallback failure callback function.
2211 	 * @returns  <p>After the method is successfully executed, successCallback is called with monitorConfiguration object with following data</p>
2212 	 * <div align=left>
2213 	 * <table class="hcap_spec" width=400>
2214 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
2215 	 *   <tbody>
2216 	 *       <tr><th>fan</th><th>Boolean</th><th>Receive events from the sensor that monitors the fan </th></tr>
2217 	 *       <tr class="odd"><th>signal</th><th>Boolean</th><th>Receive events from the signal receiver</th></tr>
2218 	 *       <tr><th>lamp</th><th>Boolean</th><th>Receive events from the sensor that monitors the lamp</th></tr>
2219 	 *       <tr class="odd"><th>screen</th><th>Boolean</th><th>Receive events from the sensor that monitors the screen</th></tr>
2220 	 *       <tr><th>temperature</th><th>Boolean</th><th>Receive events from the sensor that monitors the temperature</th></tr>
2221 	 *   </tbody>
2222 	 * </table>
2223 	 * </div>
2224 	 * <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
2225 	 *
2226 	 * @since 1.0 
2227 	 * */
2228 
2229 	Signage.prototype.getSystemMonitoringInfo = function (successCallback , errorCallback ) {
2230 		if(_gSystemMonitoringSetup){
2231 			successCallback({
2232 				fan : _gSystemMonitoringSetup.fan.getEvent,
2233 				signal : _gSystemMonitoringSetup.signal.getEvent,
2234 				lamp : _gSystemMonitoringSetup.lamp.getEvent,
2235 				screen : _gSystemMonitoringSetup.screen.getEvent,
2236 				temperature : _gSystemMonitoringSetup.temperature.getEvent
2237 			});
2238 		}
2239 		else{
2240 			var cbObj ={
2241 					errorCode : "ERROR",
2242 					errorText : "Failed to get system monitoring setup"
2243 			};
2244 			errorCallback(cbObj);
2245 		}
2246 	};
2247 
2248 	/**
2249 	 * <p>Sets power saving mode.</p>
2250 	 * @example 
2251 	 * function setPowerSaveMode() {
2252 	 *    var options = { 
2253 	 *      powerSaveMode: {
2254 	 *         ses: true,
2255 	 *         dpmMode: Signage.DpmMode.OFF,
2256 	 *         automaticStandby: Signage.AutomaticStandbyMode.OFF,
2257 	 *         do15MinOff: true,
2258 	 *      }
2259 	 *   }; 
2260 	 *
2261 	 *    var successCb = function (){
2262 	 *      console.log("successfully Set");
2263 	 *    };
2264 	 * 
2265 	 *    var failureCb = function(cbObject){
2266 	 *      var errorCode = cbObject.errorCode;
2267 	 *      var errorText = cbObject.errorText;
2268 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
2269 	 *    };
2270 	 * 
2271 	 *    var signage = new Signage();
2272 	 *    signage.setPowerSaveMode(successCb, failureCb, options);
2273 	 * }
2274 	 * 
2275 	 * @class Signage
2276 	 * @param {Function} successCallback success callback function.
2277 	 * @param {Function} errorCallback failure callback function.
2278 	 * @param {Object} options  parameter list.
2279 	 * @param {Object} options.powerSaveMode  powerSaveMode object.
2280 	 * Only attributes that exist will be set.
2281 	 * 'automaticStandby' mode is triggered when there are no RCU or local key input for 4 hours.
2282 	 * '15MinOff' mode is triggered when there is no video input for 15 minutes.
2283 	 * 
2284 	 * <div align=left>
2285 	 * <table class="hcap_spec" width=400>
2286 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
2287 	 *   <tbody>
2288 	 *       <tr><th>ses</th><th>Boolean</th><th>Smart Energy Saving mode.</br>This will deduce monitor power usage by manipulating the power usage on the screen backlight etc. </th><th>optional</th></tr>
2289 	 *       <tr class="odd"><th>dpmMode</th><th>Signage.DpmMode</th><th>Display Power Management mode.</br>Sets the monitor power off time while there is no signal/no user inputs/no application on the monitor</th><th>optional</th></tr>
2290 	 *       <tr><th>automaticStandby</th><th>Signage.AutomaticStandbyMode</th><th>Automatic standby mode.</br>Sets the monitor power off time while there is no user inputs on the monitor</th><th>optional</th></tr>
2291 	 *       <tr class="odd"><th>do15MinOff</th><th>Boolean</th><th>15 Minutes off mode.</br>Sets the monitor power off time while there is no signal/no user inputs on the monitor</th><th>optional</th></tr>
2292 	 *   </tbody>
2293 	 * </table>
2294 	 * </div>
2295 	 * 
2296 	 * @returns  
2297 	 * <p>
2298 	 * After the method is successfully executed, successCallback is called without any parameter.</br>
2299 	 * If an error occurs, errorCallback is called with errorCode and errorText.</p>
2300 	 * 
2301 	 * @since 1.0
2302 	 */
2303 
2304 	Signage.prototype.setPowerSaveMode = function (successCallback , errorCallback,options ) {
2305 		var settings = {};
2306 		var errorMessage;
2307 		function checkOptions(options){
2308 			if(options.powerSaveMode){
2309 				for(var key in options.powerSaveMode){
2310 					if(key){
2311 						var value = options.powerSaveMode[key];
2312 						if(key === 'ses' || key === 'do15MinOff'){
2313 							if(typeof value !== 'boolean'){
2314 								errorMessage = "Invalid value  : " + value ;
2315 								return false;
2316 							}
2317 						}
2318 
2319 						else if(key === 'automaticStandby'){
2320 							if(!isValidEnum(Signage.AutomaticStandbyMode, value  )){
2321 								errorMessage = "Invalid automaticStandby value  : " + value;
2322 								return false;
2323 							}
2324 						}
2325 
2326 						else if(key === 'dpmMode'){
2327 							if(!isValidEnum(Signage.DpmMode, value  )){
2328 								errorMessage = "Invalid dpmMode value  : " + value;
2329 								return false;
2330 							}
2331 						}
2332 						else{
2333 							errorMessage = "Unknown value  : " + key ;
2334 							return false;
2335 						}
2336 					}
2337 				}
2338 
2339 				return true;
2340 			}
2341 			else{
2342 				errorMessage = "powerSaveMode  does not exist.";
2343 				return false;
2344 			}
2345 		}
2346 
2347 		if(checkOptions(options)){
2348 			console.log(options.powerSaveMode);
2349 			service.Request("luna://com.webos.service.commercial.signage.storageservice", {
2350 				method : "setPowerSaveMode",
2351 				parameters : {mode:options.powerSaveMode},
2352 				onSuccess : function(result) {
2353 					log("onSuccess!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
2354 					if(result.returnValue){
2355 						successCallback(result.mode);
2356 					}
2357 					else{
2358 						log("FAILED: " + result.errorText );
2359 						errorCallback({errorCode:result.errorCode, errorText:result.errorText});
2360 					}
2361 				},
2362 				onFailure : function(result) {
2363 					log("onFailure!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
2364 					log("FAILED: " + result.errorText );					
2365 					errorCallback({errorCode:result.errorCode, errorText:result.errorText});
2366 				}
2367 			});	
2368 
2369 		}
2370 		else{
2371 			var cbObj ={
2372 					errorCode : "BAD_PARAMETER",
2373 					errorText : errorMessage
2374 			};
2375 			errorCallback(cbObj);
2376 		}
2377 	};
2378 
2379 	/**
2380 	 * <p>Gets power saving mode.</p>
2381 	 * @example 
2382 	 * 
2383 	 * function getPowerSaveMode() {
2384 	 *    var successCb = function (cbObject){
2385 	 *      var ses = cbObject.ses;
2386 	 *      var dpmMode = cbObject.dpmMode;
2387 	 *      var automaticStandby = cbObject.automaticStandby;
2388 	 *      var do15MinOff = cbObject.do15MinOff;
2389 	 * 
2390 	 *      console.log("Smart Energy Saving: " + ses);
2391 	 *      console.log("Display Power Management: " + dpmMode);
2392 	 *      console.log("Automatic Standby Mode: " + automaticStandby);
2393 	 *      console.log("15 Minutes Off: " + do15MinOff);
2394 	 *    };
2395 	 * 
2396 	 *    var failureCb = function(cbObject){
2397 	 *      var errorCode = cbObject.errorCode;
2398 	 *      var errorText = cbObject.errorText;
2399 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
2400 	 *    };
2401 	 * 
2402 	 * var signage = new Signage();
2403 	 * signage.getPowerSaveMode(successCb, failureCb);
2404 	 * 
2405 	 * }
2406 	 * 
2407 	 * @class Signage
2408 	 * @param {Function} successCallback success callback function.
2409 	 * @param {Function} errorCallback failure callback function.
2410 	 * @returns  <p>After the method is successfully executed, successCallback is called with the following data.</p>
2411 	 * <div align=left>
2412 	 * <table class="hcap_spec" width=400>
2413 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
2414 	 *   <tbody>
2415 	 *       <tr><th>ses</th><th>Boolean</th><th>Smart Energy Saving mode.<br> This will deduce monitor power usage by manipulating the power usage on the screen backlight etc. </th></tr>
2416 	 *       <tr class="odd"><th>dpmMode</th><th>Signage.DpmMode</th><th>Display Power Management mode.<br>Sets the monitor power off time while there is no signal/no user inputs/no application on the monitor</th></tr>
2417 	 *       <tr><th>automaticStandby</th><th>Signage.AutomaticStandbyMode</th><th>Automatic standby mode.<br>Sets the monitor power off time while there is no user inputs on the monitor</th></tr>
2418 	 *       <tr class="odd"><th>do15MinOff</th><th>Boolean</th><th>15 Minutes off mode.<br>Sets the monitor power off time while there is no signal/no user inputs on the monitor</th></tr>
2419 	 *   </tbody>
2420 	 * </table>
2421 	 * </div>
2422 	 * <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
2423 	 * 
2424 	 * @since 1.0
2425 	 */
2426 	Signage.prototype.getPowerSaveMode = function (successCallback , errorCallback ) {
2427 
2428 		var doHavcommercial = false;
2429 		var doHavehotelMode = false;
2430 		var doHavetime = false;
2431 		var doHaveError = false;
2432 		var errorText = "";
2433 		var errorCode = "";
2434 
2435 		service.Request("luna://com.webos.service.commercial.signage.storageservice", {
2436 			method : "getPowerSaveMode",
2437 			parameters : {},
2438 			onSuccess : function(result) {
2439 				log("onSuccess!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
2440 				if(result.returnValue){
2441 					successCallback(result.mode);
2442 				}
2443 				else{
2444 					log("FAILED: " + result.errorText );
2445 					errorCallback({errorCode:result.errorCode, errorText:result.errorText});
2446 				}
2447 			},
2448 			onFailure : function(result) {
2449 				log("onFailure!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
2450 				log("FAILED: " + result.errorText );					
2451 				errorCallback({errorCode:result.errorCode, errorText:result.errorText});
2452 			}
2453 		});	
2454 
2455 	};
2456 
2457 	/**
2458 	 * <p>Sets usage policy. It is used to limit monitor functions.</p>
2459 	 * @example 
2460 	 * 
2461 	 * function setUsagePermission() {
2462 	 *    var options = { 
2463 	 *      policy: {
2464 	 *         remoteKeyOperationMode: Signage.KeyOperationMode.POWER_ONLY,
2465 	 *         localKeyOperationMode: Signage.KeyOperationMode.POWER_ONLY,
2466 	 *      }
2467 	 *   };
2468 	 * 
2469 	 *    var successCb = function (){
2470 	 *      console.log("successfully Set");
2471 	 *    };
2472 	 * 
2473 	 *    var failureCb = function(cbObject){
2474 	 *      var errorCode = cbObject.errorCode;
2475 	 *      var errorText = cbObject.errorText;
2476 	 *         console.log( " Error Code [" + errorCode + "]: " + errorText); 
2477 	 *       };
2478 	 * 
2479 	 *    var signage = new Signage();
2480 	 *    signage.setUsagePermission(successCb, failureCb, options);
2481 	 *    
2482 	 * }
2483 	 * 
2484 	 * @class Signage
2485 	 * @param {Function} successCallback success callback function.
2486 	 * @param {Function} errorCallback failure callback function.
2487 	 * @param {Object} options  parameter list.
2488 	 * @param {Object} options.policy  Policy object.
2489 	 * 
2490 	 * Only attributes that exist will be set.
2491 	 * 
2492 	 * <div align=left>
2493 	 * <table class="hcap_spec" width=400>
2494 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
2495 	 *   <tbody>
2496 	 *       <tr><th>remoteKeyOperationMode</th><th>KeyOperationMode</th><th>Remote Key operation mode </th><th>optional</th></tr>
2497 	 *       <tr class="odd"><th>localKeyOperationMode</th><th>KeyOperationMode</th><th>Built-in key operation mode</th><th>optional</th></tr>
2498 	 *   </tbody>
2499 	 * </table>
2500 	 * </div>
2501 	 * 
2502 	 * @returns  <p>After the method is successfully executed, successCallback is called without any parameter.</br>
2503 	 * If an error occurs, errorCallback is called with errorCode and errorText.</p>
2504 	 * 
2505 	 * @since 1.0
2506 	 */
2507 	Signage.prototype.setUsagePermission = function (successCallback , errorCallback,options ) {
2508 		var settings = {};
2509 		var errorMessage;
2510 
2511 
2512 		function checkOptions(options){
2513 			if(options){
2514 				log("Options: " + JSON.stringify(options, null,3));
2515 			}
2516 			else{
2517 				log("Options not defined: " + options);
2518 			}
2519 			if(options.policy){
2520 				for(var key in options.policy){
2521 					if(key){
2522 						var value = options.policy[key];
2523 						if(key === 'remoteKeyOperationMode' || key === 'localKeyOperationMode'){
2524 							if(!isValidEnum(Signage.KeyOperationMode, value)){
2525 								errorMessage = "Invalid  KeyOperationMode value  : " + value ;
2526 								return false;
2527 							}
2528 						}
2529 						else{
2530 							errorMessage = "Unknown value  : " + key ;
2531 							return false;
2532 						}
2533 					}
2534 
2535 				}
2536 				return true;
2537 			}
2538 			else{
2539 				errorMessage = "policy  does not exist.";
2540 				return false;
2541 			}
2542 		}
2543 
2544 		if(checkOptions(options)){
2545 			if(options.policy.localKeyOperationMode){
2546 				var localKeyOperationMode = options.policy.localKeyOperationMode;
2547 				log("portraitMode: " + localKeyOperationMode);
2548 				settings[SETTINGS_KEY.LOCALKEY_OPERATION_MODE] = localKeyOperationMode;
2549 			}
2550 
2551 			if(options.policy.remoteKeyOperationMode){
2552 				var remoteKeyOperationMode = options.policy.remoteKeyOperationMode;
2553 				log("portraitMode: " + remoteKeyOperationMode);
2554 				settings[SETTINGS_KEY.IR_OPERATION_MODE]  = remoteKeyOperationMode;
2555 			}
2556 
2557 			log("Set: " + JSON.stringify(settings, null, 3));
2558 
2559 			setSystemSettings("hotelMode", settings, successCallback , errorCallback);
2560 
2561 			log("setPolicy Done");
2562 		}
2563 		else{
2564 			var cbObj ={
2565 					errorCode : "BAD_PARAMETER",
2566 					errorText : errorMessage
2567 			};
2568 			errorCallback(cbObj);
2569 		}
2570 
2571 	};
2572 
2573 	/**
2574 	 * <p>Gets usage policy. </p>
2575 	 * @example 
2576 	 * 
2577 	 * function getUsagePermission() {
2578 	 *    var successCb = function (cbObject){
2579 	 *      var remoteKeyOperationMode = cbObject.remoteKeyOperationMode;
2580 	 *      var localKeyOperationMode = cbObject.localKeyOperationMode;
2581 	 *      console.log("remoteKeyOperationMode: " + remoteKeyOperationMode);
2582 	 *      console.log("localKeyOperationMode: " + localKeyOperationMode);
2583 	 *    };
2584 	 * 
2585 	 *    var failureCb = function(cbObject){
2586 	 *      var errorCode = cbObject.errorCode;
2587 	 *      var errorText = cbObject.errorText;
2588 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
2589 	 *    };
2590 	 * 
2591 	 *    var signage = new Signage();
2592 	 *    signage.getUsagePermission(successCb, failureCb);
2593 	 * }
2594 	 * 
2595 	 * @class Signage
2596 	 * @param {Function} successCallback success callback function.
2597 	 * @param {Function} errorCallback failure callback function.
2598 	 * @returns  <p>After the method is successfully executed, successCallback is called with the following data.</p>
2599 	 * 
2600 	 * <div align=left>
2601 	 * <table class="hcap_spec" width=400>
2602 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
2603 	 *   <tbody>
2604 	 *       <tr><th>remoteKeyOperationMode</th><th>KeyOperationMode</th><th>Remote Key operation mode </th></tr>
2605 	 *       <tr class="odd"><th>localKeyOperationMode</th><th>KeyOperationMode</th><th>Built-in key operation mode</th></tr>
2606 	 *   </tbody>
2607 	 * </table>
2608 	 * </div>
2609 	 * 
2610 	 * <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
2611 	 * 
2612 	 * @since 1.0
2613 	 */
2614 	Signage.prototype.getUsagePermission = function (successCallback , errorCallback ) {
2615 		var cbgetter = function(settings){
2616 			var cbObj = {};
2617 			log('settings: ' + JSON.stringify(settings, null, 3));
2618 			cbObj.remoteKeyOperationMode = settings[SETTINGS_KEY.IR_OPERATION_MODE];
2619 			cbObj.localKeyOperationMode= settings[SETTINGS_KEY.LOCALKEY_OPERATION_MODE];
2620 			log('cbObj: ' + JSON.stringify(cbObj, null, 3));
2621 
2622 			return cbObj;
2623 		};
2624 
2625 		var keys = [SETTINGS_KEY.IR_OPERATION_MODE,SETTINGS_KEY.LOCALKEY_OPERATION_MODE];
2626 		getSystemSettings("hotelMode", keys, cbgetter, successCallback , errorCallback);
2627 	};
2628 
2629 	/**
2630 	 * <p>Gets current usage data information.</p>
2631 	 *
2632 	 * @example 
2633 	 * 
2634 	 * function getUsageData() {
2635 	 *    var successCb = function (cbObject){
2636 	 *      var uptime= cbObject.uptime;
2637 	 *      var totalUsed= cbObject.totalUsed;
2638 	 *      console.log("Uptime: " + uptime);
2639 	 *      console.log("Total Used: " + totalUsed);
2640 	 *    };
2641 	 *  
2642 	 *    var failureCb = function(cbObject){ 
2643 	 *      var errorCode = cbObject.errorCode; 
2644 	 *      var errorText = cbObject.errorText; 
2645 	 *      console.log( " Error Code [" + errorCode + "]: " + errorText); 
2646 	 *    };
2647 	 * 
2648 	 *    var signage = new Signage();
2649 	 *    signage.getUsageData(successCb, failureCb);
2650 	 * }
2651 	 * @class Signage
2652 	 * @param {Function} successCallback success callback function.
2653 	 * @param {Function} errorCallback failure callback function.
2654 	 * 
2655 	 * @returns  <p>After the method is successfully executed, successCallback is called with the following data.</p>
2656 	 * 
2657 	 * <div align=left>
2658 	 * <table class="hcap_spec" width=400>
2659 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
2660 	 *   <tbody>
2661 	 *       <tr><th>uptime</th><th>Number</th><th>Uptime. (Hours after last power on. Showing upto the nearest hundredths. Ex) 1.5 = 1 hour 30 minutes, etc)</th></tr>
2662 	 *       <tr class="odd"><th>totalUsed</th><th>Number</th><th>Total Used. (Total usage hours)</th></tr>
2663 	 *   </tbody>
2664 	 * </table>
2665 	 * </div>
2666 	 * 
2667 	 * <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
2668 	 * 
2669 	 * @since 1.0
2670 	 */
2671 	Signage.prototype.getUsageData = function (successCallback , errorCallback ) {
2672 
2673 
2674 		//var powerHistoryKey = "powerOnOffHistory";
2675 
2676 		var gotTT = false;
2677 		var gotUT = false;
2678 
2679 		var cbObject = {
2680 				uptime :false,
2681 				totalUsed : false
2682 		};
2683 
2684 		function accessResult(){
2685 			log("accessResult!!!!!!!!!!!!!!!!!!");
2686 
2687 			if(gotTT=== true && gotUT === true){
2688 				log("CB Object: " + JSON.stringify(cbObject, null, 3));
2689 				if(cbObject.uptime === false || cbObject.totalUsed === false){
2690 					errorCallback({
2691 						errorCode : "CORDOVA_FAIL",
2692 						errorText : "Failed to get usage data"
2693 					});
2694 					return;
2695 				}
2696 				else{
2697 					log("SUCCESS!!!!!!!!!!!!!!!!!!");
2698 					successCallback(cbObject);
2699 					return;
2700 				}
2701 			}
2702 			else{
2703 				log("Not Yet!!!!!!!!!!!!!!!!!!");
2704 			}
2705 		}
2706 
2707 		service.Request("luna://com.webos.service.tv.signage/", {
2708 			method : "getUTT",
2709 			parameters : {},
2710 			onSuccess : function(result) {
2711 				log("On getUTT Success");
2712 				gotTT = true;
2713 				if(result.returnValue === true){
2714 					log("UTT is :" + result.UTT);
2715 					cbObject.totalUsed = result.UTT;
2716 				}
2717 				accessResult();
2718 			},
2719 			onFailure : function(result) {
2720 				log("On getUTT Failure :" + JSON.stringify(result, null, 3));
2721 				gotTT = true;
2722 				accessResult();
2723 			}
2724 		});
2725 
2726 		service.Request("luna://com.webos.service.tv.signage/", {
2727 			method : "dsmp/getElapsedTime",
2728 			parameters : {},
2729 			onSuccess : function(result) {
2730 				log("On getElapsedTime Success");
2731 				gotUT = true;
2732 				log("result: " + JSON.stringify(result, null ,3));
2733 
2734 				if(result.returnValue === true){
2735 					var elapsedTime = result.elapsedTime;
2736 					log("Elapsed!!: " + elapsedTime);
2737 					cbObject.uptime = elapsedTime;
2738 				}
2739 				accessResult();
2740 			},
2741 			onFailure : function(result) {
2742 				log("On getSystemSettings Failure "  + JSON.stringify(result, null, 3));
2743 				gotUT = true;
2744 				accessResult();
2745 			}
2746 		});
2747 	};
2748 
2749 	/**
2750 	 * <p>Gets screen capture image. Captured screen image will be returned as JPEG image encoded in base64 string. </p>
2751 	 * 
2752 	 * @example 
2753 	 * function doCapture(){
2754 	 *   var signage = new Signage();
2755 	 *   
2756 	 *   var successCB = function(cbobj){
2757 	 *      var data = cbobj.data;
2758 	 *      var size = cbobj.size;
2759 	 *      var encoding = cbobj.encoding;		
2760 	 *      console.log("Got Data size:" + size);	
2761 	 *      console.log("Got Data encoding :" + encoding);				
2762 	 *      console.log("Got Data :" + data);		
2763 	 *	
2764 	 *      var capturedElement = document.getElementById('captured_img');
2765 	 *      capturedElement.src = 'data:image/jpeg;base64,' + data;
2766 	 *   };
2767 	 *		
2768 	 *   var failureCB = function(cbobj){
2769 	 *      console.log(JSON.stringify(cbobj, null, 3));
2770 	 *   }
2771 	 *
2772 	 *   var options = { 
2773 	 *      save : true
2774 	 *   };   
2775 	 *    
2776 	 *   signage.captureScreen(successCB, failureCB, options);
2777 	 * }
2778 	 *
2779 	 * 
2780 	 * @class Signage
2781 	 * @param {Function} successCallback success callback function.
2782 	 * @param {Function} errorCallback failure callback function.
2783 	 * @param {Object} options
2784 	 * <div align=left>
2785 	 * <table class="hcap_spec" width=400>
2786 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th><th>Required</th></tr></thead>
2787 	 *   <tbody>
2788 	 *       <tr><th>save</th><th>Boolean</th><th>true : saves the captured image file(0_captured_by_scap.jpg) on local storage (content folder and media folder for fail-over mode) <br>and it will be displayed when the fail-over mode is activated, overwriting existing image file which is captured before. false : not save. default value </a></th><th>optional</th></tr>
2789 	 *       <tr class="odd"><th>thumbnail</th><th>Boolean</th><th>true : reduced size version of picutre (128 X 72). <br>false : original size (1280 X 720). default value </th><th>optional</th></tr>
2790 	 *   </tbody>
2791 	 * </table>
2792 	 * </div>
2793 	 * 
2794 	 * @returns  <p>After the method is successfully executed, successCallback is called with the following data.</p>
2795 	 * 
2796 	 * <div align=left>
2797 	 * <table class="hcap_spec" width=400>
2798 	 *   <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
2799 	 *   <tbody>
2800 	 *       <tr><th>cbObject.data</th><th>String</th>
2801 	 *       <th>
2802 	 *       <p>JPEG screen shot image which is encoded in base64 string. </p>
2803 	 *       </th></tr>
2804 	 *       <tr><th>cbObject.size</th><th>number</th>
2805 	 *       <th>
2806 	 *       <p>size of the data. </p>
2807 	 *       </th></tr>
2808 	 *       <tr><th>cbObject.encoding</th><th>string</th>
2809 	 *       <th>
2810 	 *       <p>encoding used for the data (base64) </p>
2811 	 *       </th></tr>
2812 	 *   </tbody>
2813 	 * </table>
2814 	 * </div>
2815 	 * 
2816 	 * <p>If an error occurs, errorCallback is called with errorCode and errorText.</p>
2817 	 * 
2818 	 * @since 1.0 
2819 	 * @since 1.1 options.save options.thumbnail added
2820 	 * @since 1.2 options.save, saves image also under application's content folder
2821 	 * 
2822 	 */
2823 	Signage.prototype.captureScreen = function (successCallback, errorCallback, options ) {
2824 
2825 
2826 		var param = {
2827 				save : (options == undefined || options == null || options.save == undefined ? false : options.save)
2828 		};
2829 
2830 		if (options !== undefined && options !== null 
2831 				&& options.thumbnail !== undefined && options.thumbnail === true) {
2832 			param.width = 128;
2833 			param.height = 72;
2834 		};
2835 
2836 		service.Request("luna://com.webos.service.commercial.signage.storageservice", {
2837 			method : "captureScreen",
2838 			parameters : param,
2839 			onSuccess : function(result) {
2840 				log("On Success");
2841 				if(result.returnValue === true){
2842 					successCallback({data:result.data, size:result.size, encoding:result.encoding});
2843 				}
2844 				else{
2845 					errorCallback({errorCode: result.errorCode, errorText:result.errorText});
2846 				}
2847 			},
2848 			onFailure : function(result) {
2849 				log("On Failure");
2850 				errorCallback({errorCode: result.errorCode, errorText:result.errorText});
2851 			}
2852 		});
2853 	};
2854 
2855 	Signage.prototype.addEventListener= addSignageEventListener;
2856 
2857 	Signage.prototype.removeEventListener= removeSignageEventListener;
2858 
2859 	module.exports = Signage;
2860 });
2861 
2862 Signage = cordova.require('cordova/plugin/signage'); // jshint ignore:line
2863 
2864