src/Sensor/JSSensorService.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <SecurityExceptions.h>
  19 #include <JSUtil.h>
  20 #include <JSWebAPIError.h>
  21 #include <ArgumentValidator.h>
  22 #include <GlobalContextManager.h>
  23 #include <MultiCallbackUserData.h>
  24 #include <PlatformException.h>
  25 #include <Logger.h>
  26
  27 #include "plugin_config.h"
  28 #include "JSSensorService.h"
  29 #include "SensorService.h"
  30
  31 using namespace WrtDeviceApis::Commons;
  32 using namespace DeviceAPI::Common;
  33
  34 namespace DeviceAPI {
  35 namespace Sensor {
  36
  37 JSClassDefinition JSSensorService::m_classInfo = {
  38     0,
  39     kJSClassAttributeNone,
  40     "SensorService",
  41     NULL, //ParentClass
  42     NULL, //StaticValues
  43     m_function, //StaticFunctions
  44     initialize, //Initialize
  45     finalize, //Finalize
  46     NULL, //HasProperty,
  47     NULL, //GetProperty,
  48     NULL, //SetProperty,
  49     NULL, //DeleteProperty,
  50     NULL, //GetPropertyNames,
  51     NULL, //CallAsFunction,
  52     NULL, //CallAsConstructor,
  53     NULL, //HasInstance,
  54     NULL //ConvertToType
  55 };
  56
  57 JSStaticFunction JSSensorService::m_function[] = {
  58     { SENSOR_SERVICE_API_GET_DEFAULT_SENSOR, getDefaultSensor, kJSPropertyAttributeNone },
  59     { SENSOR_SERVICE_API_GET_AVAILABLE_SENSOR, getAvailableSensor, kJSPropertyAttributeNone },
  60     { 0, 0, 0 }
  61 };
  62
  63 JSClassRef JSSensorService::m_jsClassRef = JSClassCreate(JSSensorService::getClassInfo());
  64
  65 const JSClassRef JSSensorService::getClassRef()
  66 {
  67     if (!m_jsClassRef) {
  68         m_jsClassRef = JSClassCreate(&m_classInfo);
  69     }
  70     return m_jsClassRef;
  71 }
  72
  73 const JSClassDefinition* JSSensorService::getClassInfo()
  74 {
  75     return &m_classInfo;
  76 }
  77
  78 void JSSensorService::initialize(JSContextRef context, JSObjectRef object)
  79 {
  80     LOGD("enter");
  81 }
  82
  83 void JSSensorService::finalize(JSObjectRef object)
  84 {
  85     LOGD("enter");
  86 }
  87
  88 JSValueRef JSSensorService::getDefaultSensor(JSContextRef context,
  89         JSObjectRef object,
  90         JSObjectRef thisObject,
  91         size_t argumentCount,
  92         const JSValueRef arguments[],
  93         JSValueRef* exception)
  94 {
  95     try {
  96         LOGD("enter");
  97
  98         bool supported = false;
  99         ArgumentValidator validator(context, argumentCount, arguments);
 100         std::string sensorType = validator.toString(0);
 101         std::string proximityType = "PROXIMITY";
 102         std::string lightType = "LIGHT";
 103         std::string magneticType = "MAGNETIC";
 104         std::string pressureType = "PRESSURE";
 105         std::string ultravioletType = "ULTRAVIOLET";
 106         std::string hrmrawType = "HRM_RAW";
 107
 108         // perform
 109         if(proximityType.compare(sensorType) == 0){
 110             ProximitySensor* proximitySensor = ProximitySensor::getInstance();
 111
 112             supported = proximitySensor->isSupported();
 113             if(false == supported){
 114                 LOGE("Not supported");
 115                 throw NotSupportedException("Not supported");
 116             }
 117
 118             JSValueRef proximityRef = JSProximitySensor::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context), proximitySensor);
 119             return proximityRef;
 120         }else if(lightType.compare(sensorType) == 0){
 121             LightSensor* lightSensor = LightSensor::getInstance();
 122
 123             supported = lightSensor->isSupported();
 124             if(false == supported){
 125                 LOGE("Not supported");
 126                 throw NotSupportedException("Not supported");
 127             }
 128
 129             JSValueRef lightRef = JSLightSensor::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context), lightSensor);
 130             return lightRef;
 131         }else if(magneticType.compare(sensorType) == 0){
 132             MagneticSensor* magneticSensor = MagneticSensor::getInstance();
 133
 134             supported = magneticSensor->isSupported();
 135             if(false == supported){
 136                 LOGE("Not supported");
 137                 throw NotSupportedException("Not supported");
 138             }
 139
 140             JSValueRef magneticRef = JSMagneticSensor::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context), magneticSensor);
 141             return magneticRef;
 142         }else if(pressureType.compare(sensorType) == 0){
 143             PressureSensor* pressureSensor = PressureSensor::getInstance();
 144
 145             supported = pressureSensor->isSupported();
 146             if(false == supported){
 147                 LOGE("Not supported");
 148                 throw NotSupportedException("Not supported");
 149             }
 150
 151             JSValueRef pressureRef = JSPressureSensor::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context), pressureSensor);
 152             return pressureRef;
 153         }else if(ultravioletType.compare(sensorType) == 0){
 154             UltravioletSensor* ultravioletSensor = UltravioletSensor::getInstance();
 155
 156             supported = ultravioletSensor->isSupported();
 157             if(false == supported){
 158                 LOGE("Not supported");
 159                 throw NotSupportedException("Not supported");
 160             }
 161
 162             JSValueRef uvsensorRef = JSUltravioletSensor::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context), ultravioletSensor);
 163             return uvsensorRef;
 164         }else if (hrmrawType.compare(sensorType) == 0) {
 165             AceSecurityStatus status = SENSOR_CHECK_ACCESS(SENSOR_SERVICE_API_GET_DEFAULT_SENSOR);
 166             TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 167             HRMRawSensor* hrmrawSensor = HRMRawSensor::getInstance();
 168
 169             supported = hrmrawSensor->isSupported();
 170             if (false == supported){
 171                 LOGD("Not supported");
 172                 throw NotSupportedException("Not supported");
 173             }
 174             JSValueRef hrmrawRef = JSHRMRawSensor::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context), hrmrawSensor);
 175             return hrmrawRef;
 176         }else{
 177             LOGE("argument type mismatch");
 178             throw TypeMismatchException("argument type mismatch");
 179         }
 180
 181     } catch (const TypeMismatchException &err) {
 182         LOGE("Type Mismatch Exception");
 183         return JSWebAPIErrorFactory::postException(context, exception, err);
 184     } catch (const BasePlatformException &err) {
 185         LOGE("argument is wrong.");
 186         return JSWebAPIErrorFactory::postException(context, exception, err);
 187     }
 188
 189 }
 190
 191 JSValueRef JSSensorService::getAvailableSensor(JSContextRef context,
 192         JSObjectRef object,
 193         JSObjectRef thisObject,
 194         size_t argumentCount,
 195         const JSValueRef arguments[],
 196         JSValueRef* exception)
 197 {
 198     try {
 199         LOGD("enter");
 200         return SensorService::getInstance()->getAvailableSensor(GlobalContextManager::getInstance()->getGlobalContext(context));
 201     } catch (const TypeMismatchException &err) {
 202         LOGE("Type Mismatch Exception");
 203         return JSWebAPIErrorFactory::postException(context, exception, err);
 204     } catch (const BasePlatformException &err) {
 205         LOGE("argument is wrong.");
 206         return JSWebAPIErrorFactory::postException(context, exception, err);
 207     }
 208
 209 }
 210
 211 // Proximity
 212 JSClassDefinition JSProximitySensor::m_classInfo = {
 213     0,
 214     kJSClassAttributeNone,
 215     "ProximitySensor",
 216     NULL, //ParentClass
 217     m_property, //StaticValues
 218     m_function, //StaticFunctions
 219     initialize, //Initialize
 220     finalize, //Finalize
 221     NULL, //HasProperty,
 222     NULL, //GetProperty,
 223     NULL, //SetProperty,
 224     NULL, //DeleteProperty,
 225     NULL, //GetPropertyNames,
 226     NULL, //CallAsFunction,
 227     NULL, //CallAsConstructor,
 228     NULL, //HasInstance,
 229     NULL //ConvertToType
 230 };
 231
 232 JSStaticValue JSProximitySensor::m_property[] = {
 233     { SENSOR_ATTRIBUTE_SENSOR_TYPE, getProperty, NULL, kJSPropertyAttributeReadOnly },
 234     { 0, 0, 0, 0 }
 235 };
 236
 237
 238 JSStaticFunction JSProximitySensor::m_function[] = {
 239     { SENSOR_API_START, start, kJSPropertyAttributeNone },
 240     { SENSOR_API_STOP, stop, kJSPropertyAttributeNone },
 241     { SENSOR_API_SET_CHANGE_LISTENER, setChangeListener, kJSPropertyAttributeNone },
 242     { SENSOR_API_UNSET_CHANGE_LISTENER, unsetChangeListener, kJSPropertyAttributeNone },
 243     { SENSOR_API_GET_PROXIMITY_SENSOR_DATA, getSensorData, kJSPropertyAttributeNone },
 244     { 0, 0, 0 }
 245 };
 246
 247 JSClassRef JSProximitySensor::m_jsClassRef = JSClassCreate(JSProximitySensor::getClassInfo());
 248
 249 const JSClassRef JSProximitySensor::getClassRef()
 250 {
 251     if (!m_jsClassRef) {
 252         m_jsClassRef = JSClassCreate(&m_classInfo);
 253     }
 254     return m_jsClassRef;
 255 }
 256
 257 const JSClassDefinition* JSProximitySensor::getClassInfo()
 258 {
 259     return &m_classInfo;
 260 }
 261
 262
 263 JSValueRef JSProximitySensor::createJSObject(JSContextRef context, ProximitySensor* proximitySensor)
 264 {
 265     JSObjectRef jsValueRef = JSObjectMake(context, getClassRef(), static_cast<void*>(proximitySensor));
 266     if (NULL == jsValueRef) {
 267         LOGE("object creation error");
 268         return JSValueMakeUndefined(context);
 269     }
 270
 271     return jsValueRef;
 272 }
 273
 274
 275 void JSProximitySensor::initialize(JSContextRef context, JSObjectRef object)
 276 {
 277     LOGD("enter");
 278 }
 279
 280 void JSProximitySensor::finalize(JSObjectRef object)
 281 {
 282     LOGD("enter");
 283 }
 284
 285 JSValueRef JSProximitySensor::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 286 {
 287     std::string sensorType("");
 288     LOGD("enter");
 289
 290     if (JSStringIsEqualToUTF8CString(propertyName, SENSOR_ATTRIBUTE_SENSOR_TYPE)) {
 291         sensorType.append("PROXIMITY");
 292         return JSUtil::toJSValueRef(context, sensorType);
 293     }
 294     return JSValueMakeUndefined(context);
 295 }
 296
 297 JSValueRef JSProximitySensor::start(JSContextRef context,
 298         JSObjectRef object,
 299         JSObjectRef thisObject,
 300         size_t argumentCount,
 301         const JSValueRef arguments[],
 302         JSValueRef* exception)
 303 {
 304     LOGD("enter");
 305
 306     try{
 307         ArgumentValidator validator(context, argumentCount, arguments);
 308         JSObjectRef successCB = validator.toFunction(0);
 309
 310         ProximitySuccessCallbackPtr proximityCB(new ProximitySuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 311         if (successCB) {
 312             proximityCB->setSuccessCallback(successCB);
 313         }
 314
 315         JSObjectRef errorCB = validator.toFunction(1, true);
 316         if(errorCB) {
 317             proximityCB->setErrorCallback(errorCB);
 318         }
 319
 320         ProximitySensor::getInstance()->start(proximityCB);
 321         return JSValueMakeUndefined(context);
 322
 323     } catch (const BasePlatformException &err) {
 324         LOGE("argument is wrong.");
 325         return JSWebAPIErrorFactory::postException(context, exception, err);
 326     }
 327
 328 }
 329
 330 JSValueRef JSProximitySensor::stop(JSContextRef context,
 331         JSObjectRef object,
 332         JSObjectRef thisObject,
 333         size_t argumentCount,
 334         const JSValueRef arguments[],
 335         JSValueRef* exception)
 336 {
 337     LOGD("enter");
 338
 339     try{
 340         ProximitySensor::getInstance()->stop(GlobalContextManager::getInstance()->getGlobalContext(context));
 341         return JSValueMakeUndefined(context);
 342
 343     } catch (const BasePlatformException &err) {
 344         LOGE("argument is wrong.");
 345         return JSWebAPIErrorFactory::postException(context, exception, err);
 346     }
 347
 348 }
 349
 350 JSValueRef JSProximitySensor::setChangeListener(JSContextRef context,
 351         JSObjectRef object,
 352         JSObjectRef thisObject,
 353         size_t argumentCount,
 354         const JSValueRef arguments[],
 355         JSValueRef* exception)
 356 {
 357     LOGD("enter");
 358
 359     try{
 360         ArgumentValidator validator(context, argumentCount, arguments);
 361         JSObjectRef successCB = validator.toFunction(0);
 362
 363         ProximitySuccessCallbackPtr proximityCB(new ProximitySuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 364         if (successCB) {
 365             proximityCB->setSuccessCallback(successCB);
 366         }
 367
 368         JSObjectRef errorCB = validator.toFunction(1, true);
 369         if(errorCB) {
 370             proximityCB->setErrorCallback(errorCB);
 371         }
 372
 373         ProximitySensor::getInstance()->setChangeListener(proximityCB);
 374         return JSValueMakeUndefined(context);
 375
 376     } catch (const BasePlatformException &err) {
 377         LOGE("argument is wrong.");
 378         return JSWebAPIErrorFactory::postException(context, exception, err);
 379     }
 380
 381
 382
 383 }
 384
 385 JSValueRef JSProximitySensor::unsetChangeListener(JSContextRef context,
 386         JSObjectRef object,
 387         JSObjectRef thisObject,
 388         size_t argumentCount,
 389         const JSValueRef arguments[],
 390         JSValueRef* exception)
 391 {
 392     LOGD("enter");
 393
 394     try{
 395         ProximitySensor::getInstance()->unsetChangeListener(GlobalContextManager::getInstance()->getGlobalContext(context));
 396         return JSValueMakeUndefined(context);
 397
 398     } catch (const BasePlatformException &err) {
 399         LOGE("argument is wrong.");
 400         return JSWebAPIErrorFactory::postException(context, exception, err);
 401     }
 402
 403
 404 }
 405
 406 JSValueRef JSProximitySensor::getSensorData(JSContextRef context,
 407         JSObjectRef object,
 408         JSObjectRef thisObject,
 409         size_t argumentCount,
 410         const JSValueRef arguments[],
 411         JSValueRef* exception)
 412 {
 413
 414     LOGD("enter");
 415
 416     try{
 417         ArgumentValidator validator(context, argumentCount, arguments);
 418         JSObjectRef successCB = validator.toFunction(0);
 419
 420         ProximitySuccessCallbackPtr proximityCB(new ProximitySuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 421         if (successCB) {
 422             proximityCB->setSuccessCallback(successCB);
 423         }
 424
 425         JSObjectRef errorCB = validator.toFunction(1, true);
 426         if(errorCB) {
 427             proximityCB->setErrorCallback(errorCB);
 428         }
 429
 430         ProximitySensor::getInstance()->getSensorData(proximityCB);
 431         return JSValueMakeUndefined(context);
 432
 433     } catch (const BasePlatformException &err) {
 434         LOGE("argument is wrong.");
 435         return JSWebAPIErrorFactory::postException(context, exception, err);
 436     }
 437 }
 438
 439 // Light
 440 JSClassDefinition JSLightSensor::m_classInfo = {
 441     0,
 442     kJSClassAttributeNone,
 443     "LightSensor",
 444     NULL, //ParentClass
 445     m_property, //StaticValues
 446     m_function, //StaticFunctions
 447     initialize, //Initialize
 448     finalize, //Finalize
 449     NULL, //HasProperty,
 450     NULL, //GetProperty,
 451     NULL, //SetProperty,
 452     NULL, //DeleteProperty,
 453     NULL, //GetPropertyNames,
 454     NULL, //CallAsFunction,
 455     NULL, //CallAsConstructor,
 456     NULL, //HasInstance,
 457     NULL //ConvertToType
 458 };
 459
 460 JSStaticFunction JSLightSensor::m_function[] = {
 461     { SENSOR_API_START, start, kJSPropertyAttributeNone },
 462     { SENSOR_API_STOP, stop, kJSPropertyAttributeNone },
 463     { SENSOR_API_SET_CHANGE_LISTENER, setChangeListener, kJSPropertyAttributeNone },
 464     { SENSOR_API_UNSET_CHANGE_LISTENER, unsetChangeListener, kJSPropertyAttributeNone },
 465     { SENSOR_API_GET_LIGHT_SENSOR_DATA, getSensorData, kJSPropertyAttributeNone },
 466     { 0, 0, 0 }
 467 };
 468
 469 JSStaticValue JSLightSensor::m_property[] = {
 470     { SENSOR_ATTRIBUTE_SENSOR_TYPE, getProperty, NULL, kJSPropertyAttributeReadOnly },
 471     { 0, 0, 0, 0 }
 472 };
 473
 474 JSClassRef JSLightSensor::m_jsClassRef = JSClassCreate(JSLightSensor::getClassInfo());
 475
 476 const JSClassRef JSLightSensor::getClassRef()
 477 {
 478     if (!m_jsClassRef) {
 479         m_jsClassRef = JSClassCreate(&m_classInfo);
 480     }
 481     return m_jsClassRef;
 482 }
 483
 484 const JSClassDefinition* JSLightSensor::getClassInfo()
 485 {
 486     return &m_classInfo;
 487 }
 488
 489
 490 JSValueRef JSLightSensor::createJSObject(JSContextRef context, LightSensor* sensor)
 491 {
 492     JSObjectRef jsValueRef = JSObjectMake(context, getClassRef(), static_cast<void*>(sensor));
 493     if (NULL == jsValueRef) {
 494         LOGE("object creation error");
 495         return JSValueMakeUndefined(context);
 496     }
 497
 498     return jsValueRef;
 499 }
 500
 501
 502 void JSLightSensor::initialize(JSContextRef context, JSObjectRef object)
 503 {
 504     LOGD("enter");
 505 }
 506
 507 void JSLightSensor::finalize(JSObjectRef object)
 508 {
 509     LOGD("enter");
 510 }
 511
 512 JSValueRef JSLightSensor::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 513 {
 514     std::string sensorType("");
 515     LOGD("enter");
 516
 517     if (JSStringIsEqualToUTF8CString(propertyName, SENSOR_ATTRIBUTE_SENSOR_TYPE)) {
 518         sensorType.append("LIGHT");
 519         return JSUtil::toJSValueRef(context, sensorType);
 520     }
 521     return JSValueMakeUndefined(context);
 522 }
 523
 524
 525 JSValueRef JSLightSensor::start(JSContextRef context,
 526         JSObjectRef object,
 527         JSObjectRef thisObject,
 528         size_t argumentCount,
 529         const JSValueRef arguments[],
 530         JSValueRef* exception)
 531 {
 532     LOGD("enter");
 533
 534     try{
 535         ArgumentValidator validator(context, argumentCount, arguments);
 536         JSObjectRef successCB = validator.toFunction(0);
 537
 538         LightSuccessCallbackPtr lightCB(new LightSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 539         if (successCB) {
 540             lightCB->setSuccessCallback(successCB);
 541         }
 542
 543         JSObjectRef errorCB = validator.toFunction(1, true);
 544         if(errorCB) {
 545             lightCB->setErrorCallback(errorCB);
 546         }
 547
 548         LightSensor::getInstance()->start(lightCB);
 549         return JSValueMakeUndefined(context);
 550
 551     } catch (const BasePlatformException &err) {
 552         LOGE("argument is wrong.");
 553         return JSWebAPIErrorFactory::postException(context, exception, err);
 554     }
 555
 556 }
 557
 558 JSValueRef JSLightSensor::stop(JSContextRef context,
 559         JSObjectRef object,
 560         JSObjectRef thisObject,
 561         size_t argumentCount,
 562         const JSValueRef arguments[],
 563         JSValueRef* exception)
 564 {
 565     LOGD("enter");
 566
 567     try{
 568         LightSensor::getInstance()->stop(GlobalContextManager::getInstance()->getGlobalContext(context));
 569         return JSValueMakeUndefined(context);
 570     } catch (const BasePlatformException &err) {
 571         LOGE("argument is wrong.");
 572         return JSWebAPIErrorFactory::postException(context, exception, err);
 573     }
 574
 575 }
 576
 577 JSValueRef JSLightSensor::setChangeListener(JSContextRef context,
 578         JSObjectRef object,
 579         JSObjectRef thisObject,
 580         size_t argumentCount,
 581         const JSValueRef arguments[],
 582         JSValueRef* exception)
 583 {
 584     LOGD("enter");
 585
 586     try{
 587         ArgumentValidator validator(context, argumentCount, arguments);
 588         JSObjectRef successCB = validator.toFunction(0);
 589
 590         LightSuccessCallbackPtr lightCB(new LightSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 591         if (successCB) {
 592             lightCB->setSuccessCallback(successCB);
 593         }
 594
 595         JSObjectRef errorCB = validator.toFunction(1, true);
 596         if(errorCB) {
 597             lightCB->setErrorCallback(errorCB);
 598         }
 599
 600         LightSensor::getInstance()->setChangeListener(lightCB);
 601         return JSValueMakeUndefined(context);
 602
 603     } catch (const BasePlatformException &err) {
 604         LOGE("argument is wrong.");
 605         return JSWebAPIErrorFactory::postException(context, exception, err);
 606     }
 607
 608
 609
 610 }
 611
 612 JSValueRef JSLightSensor::unsetChangeListener(JSContextRef context,
 613         JSObjectRef object,
 614         JSObjectRef thisObject,
 615         size_t argumentCount,
 616         const JSValueRef arguments[],
 617         JSValueRef* exception)
 618 {
 619     LOGD("enter");
 620
 621     try{
 622         LightSensor::getInstance()->unsetChangeListener(GlobalContextManager::getInstance()->getGlobalContext(context));
 623         return JSValueMakeUndefined(context);
 624
 625     } catch (const BasePlatformException &err) {
 626         LOGE("argument is wrong.");
 627         return JSWebAPIErrorFactory::postException(context, exception, err);
 628     }
 629 }
 630
 631 JSValueRef JSLightSensor::getSensorData(JSContextRef context,
 632         JSObjectRef object,
 633         JSObjectRef thisObject,
 634         size_t argumentCount,
 635         const JSValueRef arguments[],
 636         JSValueRef* exception)
 637 {
 638
 639     LOGD("enter");
 640
 641     try{
 642         ArgumentValidator validator(context, argumentCount, arguments);
 643         JSObjectRef successCB = validator.toFunction(0);
 644
 645         LightSuccessCallbackPtr lightCB(new LightSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 646         if (successCB) {
 647             lightCB->setSuccessCallback(successCB);
 648         }
 649
 650         JSObjectRef errorCB = validator.toFunction(1, true);
 651         if(errorCB) {
 652             lightCB->setErrorCallback(errorCB);
 653         }
 654
 655         LightSensor::getInstance()->getSensorData(lightCB);
 656         return JSValueMakeUndefined(context);
 657
 658     } catch (const BasePlatformException &err) {
 659         LOGE("argument is wrong.");
 660         return JSWebAPIErrorFactory::postException(context, exception, err);
 661     }
 662
 663 }
 664
 665 // Magnetic
 666 JSClassDefinition JSMagneticSensor::m_classInfo = {
 667     0,
 668     kJSClassAttributeNone,
 669     "MagneticSensor",
 670     NULL, //ParentClass
 671     m_property, //StaticValues
 672     m_function, //StaticFunctions
 673     initialize, //Initialize
 674     finalize, //Finalize
 675     NULL, //HasProperty,
 676     NULL, //GetProperty,
 677     NULL, //SetProperty,
 678     NULL, //DeleteProperty,
 679     NULL, //GetPropertyNames,
 680     NULL, //CallAsFunction,
 681     NULL, //CallAsConstructor,
 682     NULL, //HasInstance,
 683     NULL //ConvertToType
 684 };
 685
 686 JSStaticFunction JSMagneticSensor::m_function[] = {
 687     { SENSOR_API_START, start, kJSPropertyAttributeNone },
 688     { SENSOR_API_STOP, stop, kJSPropertyAttributeNone },
 689     { SENSOR_API_SET_CHANGE_LISTENER, setChangeListener, kJSPropertyAttributeNone },
 690     { SENSOR_API_UNSET_CHANGE_LISTENER, unsetChangeListener, kJSPropertyAttributeNone },
 691     { SENSOR_API_GET_MAGNETIC_SENSOR_DATA, getSensorData, kJSPropertyAttributeNone },
 692     { 0, 0, 0 }
 693 };
 694
 695 JSStaticValue JSMagneticSensor::m_property[] = {
 696     { SENSOR_ATTRIBUTE_SENSOR_TYPE, getProperty, NULL, kJSPropertyAttributeReadOnly },
 697     { 0, 0, 0, 0 }
 698 };
 699
 700
 701 JSClassRef JSMagneticSensor::m_jsClassRef = JSClassCreate(JSMagneticSensor::getClassInfo());
 702
 703 const JSClassRef JSMagneticSensor::getClassRef()
 704 {
 705     if (!m_jsClassRef) {
 706         m_jsClassRef = JSClassCreate(&m_classInfo);
 707     }
 708     return m_jsClassRef;
 709 }
 710
 711 const JSClassDefinition* JSMagneticSensor::getClassInfo()
 712 {
 713     return &m_classInfo;
 714 }
 715
 716
 717 JSValueRef JSMagneticSensor::createJSObject(JSContextRef context, MagneticSensor* sensor)
 718 {
 719     JSObjectRef jsValueRef = JSObjectMake(context, getClassRef(), static_cast<void*>(sensor));
 720     if (NULL == jsValueRef) {
 721         LOGE("object creation error");
 722         return JSValueMakeUndefined(context);
 723     }
 724
 725     return jsValueRef;
 726 }
 727
 728
 729 void JSMagneticSensor::initialize(JSContextRef context, JSObjectRef object)
 730 {
 731     LOGD("enter");
 732 }
 733
 734 void JSMagneticSensor::finalize(JSObjectRef object)
 735 {
 736     LOGD("enter");
 737 }
 738
 739
 740 JSValueRef JSMagneticSensor::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 741 {
 742     std::string sensorType("");
 743     LOGD("enter");
 744
 745     if (JSStringIsEqualToUTF8CString(propertyName, SENSOR_ATTRIBUTE_SENSOR_TYPE)) {
 746         sensorType.append("MAGNETIC");
 747         return JSUtil::toJSValueRef(context, sensorType);
 748     }
 749     return JSValueMakeUndefined(context);
 750 }
 751
 752 JSValueRef JSMagneticSensor::start(JSContextRef context,
 753         JSObjectRef object,
 754         JSObjectRef thisObject,
 755         size_t argumentCount,
 756         const JSValueRef arguments[],
 757         JSValueRef* exception)
 758 {
 759     LOGD("enter");
 760
 761     try{
 762         ArgumentValidator validator(context, argumentCount, arguments);
 763         JSObjectRef successCB = validator.toFunction(0);
 764
 765         MagneticSuccessCallbackPtr magneticCB(new MagneticSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 766         if (successCB) {
 767             magneticCB->setSuccessCallback(successCB);
 768         }
 769
 770         JSObjectRef errorCB = validator.toFunction(1, true);
 771         if(errorCB) {
 772             magneticCB->setErrorCallback(errorCB);
 773         }
 774
 775         MagneticSensor::getInstance()->start(magneticCB);
 776         return JSValueMakeUndefined(context);
 777
 778     } catch (const BasePlatformException &err) {
 779         LOGE("argument is wrong.");
 780         return JSWebAPIErrorFactory::postException(context, exception, err);
 781     }
 782
 783 }
 784
 785 JSValueRef JSMagneticSensor::stop(JSContextRef context,
 786         JSObjectRef object,
 787         JSObjectRef thisObject,
 788         size_t argumentCount,
 789         const JSValueRef arguments[],
 790         JSValueRef* exception)
 791 {
 792     LOGD("enter");
 793
 794     try{
 795         MagneticSensor::getInstance()->stop(GlobalContextManager::getInstance()->getGlobalContext(context));
 796         return JSValueMakeUndefined(context);
 797     } catch (const BasePlatformException &err) {
 798         LOGE("argument is wrong.");
 799         return JSWebAPIErrorFactory::postException(context, exception, err);
 800     }
 801
 802 }
 803
 804 JSValueRef JSMagneticSensor::setChangeListener(JSContextRef context,
 805         JSObjectRef object,
 806         JSObjectRef thisObject,
 807         size_t argumentCount,
 808         const JSValueRef arguments[],
 809         JSValueRef* exception)
 810 {
 811     LOGD("enter");
 812
 813     try{
 814         ArgumentValidator validator(context, argumentCount, arguments);
 815         JSObjectRef successCB = validator.toFunction(0);
 816
 817         MagneticSuccessCallbackPtr magneticCB(new MagneticSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 818         if (successCB) {
 819             magneticCB->setSuccessCallback(successCB);
 820         }
 821
 822         JSObjectRef errorCB = validator.toFunction(1, true);
 823         if(errorCB) {
 824             magneticCB->setErrorCallback(errorCB);
 825         }
 826
 827         MagneticSensor::getInstance()->setChangeListener(magneticCB);
 828         return JSValueMakeUndefined(context);
 829
 830     } catch (const BasePlatformException &err) {
 831         LOGE("argument is wrong.");
 832         return JSWebAPIErrorFactory::postException(context, exception, err);
 833     }
 834
 835 }
 836
 837
 838
 839 JSValueRef JSMagneticSensor::unsetChangeListener(JSContextRef context,
 840         JSObjectRef object,
 841         JSObjectRef thisObject,
 842         size_t argumentCount,
 843         const JSValueRef arguments[],
 844         JSValueRef* exception)
 845 {
 846     LOGD("enter");
 847
 848     try{
 849         MagneticSensor::getInstance()->unsetChangeListener(GlobalContextManager::getInstance()->getGlobalContext(context));
 850         return JSValueMakeUndefined(context);
 851
 852     } catch (const BasePlatformException &err) {
 853         LOGE("argument is wrong.");
 854         return JSWebAPIErrorFactory::postException(context, exception, err);
 855     }
 856
 857
 858 }
 859
 860 JSValueRef JSMagneticSensor::getSensorData(JSContextRef context,
 861         JSObjectRef object,
 862         JSObjectRef thisObject,
 863         size_t argumentCount,
 864         const JSValueRef arguments[],
 865         JSValueRef* exception)
 866 {
 867
 868     LOGD("enter");
 869
 870     try{
 871         ArgumentValidator validator(context, argumentCount, arguments);
 872         JSObjectRef successCB = validator.toFunction(0);
 873
 874         MagneticSuccessCallbackPtr magneticCB(new MagneticSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 875         if (successCB) {
 876             magneticCB->setSuccessCallback(successCB);
 877         }
 878
 879         JSObjectRef errorCB = validator.toFunction(1, true);
 880         if(errorCB) {
 881             magneticCB->setErrorCallback(errorCB);
 882         }
 883
 884         MagneticSensor::getInstance()->getSensorData(magneticCB);
 885         return JSValueMakeUndefined(context);
 886
 887     } catch (const BasePlatformException &err) {
 888         LOGE("argument is wrong.");
 889         return JSWebAPIErrorFactory::postException(context, exception, err);
 890     }
 891
 892
 893 }
 894
 895 // Pressure Sensor
 896 JSClassDefinition JSPressureSensor::m_classInfo = {
 897     0,
 898     kJSClassAttributeNone,
 899     "PressureSensor",
 900     NULL, //ParentClass
 901     m_property, //StaticValues
 902     m_function, //StaticFunctions
 903     initialize, //Initialize
 904     finalize, //Finalize
 905     NULL, //HasProperty,
 906     NULL, //GetProperty,
 907     NULL, //SetProperty,
 908     NULL, //DeleteProperty,
 909     NULL, //GetPropertyNames,
 910     NULL, //CallAsFunction,
 911     NULL, //CallAsConstructor,
 912     NULL, //HasInstance,
 913     NULL //ConvertToType
 914 };
 915
 916 JSStaticFunction JSPressureSensor::m_function[] = {
 917     { SENSOR_API_START, start, kJSPropertyAttributeNone },
 918     { SENSOR_API_STOP, stop, kJSPropertyAttributeNone },
 919     { SENSOR_API_SET_CHANGE_LISTENER, setChangeListener, kJSPropertyAttributeNone },
 920     { SENSOR_API_UNSET_CHANGE_LISTENER, unsetChangeListener, kJSPropertyAttributeNone },
 921     { SENSOR_API_GET_PRESSURE_SENSOR_DATA, getSensorData, kJSPropertyAttributeNone },
 922     { 0, 0, 0 }
 923 };
 924
 925 JSStaticValue JSPressureSensor::m_property[] = {
 926     { SENSOR_ATTRIBUTE_SENSOR_TYPE, getProperty, NULL, kJSPropertyAttributeReadOnly },
 927     { 0, 0, 0, 0 }
 928 };
 929
 930
 931 JSClassRef JSPressureSensor::m_jsClassRef = JSClassCreate(JSPressureSensor::getClassInfo());
 932
 933 const JSClassRef JSPressureSensor::getClassRef()
 934 {
 935     if (!m_jsClassRef) {
 936         m_jsClassRef = JSClassCreate(&m_classInfo);
 937     }
 938     return m_jsClassRef;
 939 }
 940
 941 const JSClassDefinition* JSPressureSensor::getClassInfo()
 942 {
 943     return &m_classInfo;
 944 }
 945
 946
 947 JSValueRef JSPressureSensor::createJSObject(JSContextRef context, PressureSensor* sensor)
 948 {
 949     JSObjectRef jsValueRef = JSObjectMake(context, getClassRef(), static_cast<void*>(sensor));
 950     if (NULL == jsValueRef) {
 951         LOGE("object creation error");
 952         return JSValueMakeUndefined(context);
 953     }
 954
 955     return jsValueRef;
 956 }
 957
 958
 959 void JSPressureSensor::initialize(JSContextRef context, JSObjectRef object)
 960 {
 961     LOGD("enter");
 962 }
 963
 964 void JSPressureSensor::finalize(JSObjectRef object)
 965 {
 966     LOGD("enter");
 967 }
 968
 969
 970 JSValueRef JSPressureSensor::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 971 {
 972     std::string sensorType("");
 973     LOGD("enter");
 974
 975     if (JSStringIsEqualToUTF8CString(propertyName, SENSOR_ATTRIBUTE_SENSOR_TYPE)) {
 976         sensorType.append("PRESSURE");
 977         return JSUtil::toJSValueRef(context, sensorType);
 978     }
 979     return JSValueMakeUndefined(context);
 980 }
 981
 982 JSValueRef JSPressureSensor::start(JSContextRef context,
 983         JSObjectRef object,
 984         JSObjectRef thisObject,
 985         size_t argumentCount,
 986         const JSValueRef arguments[],
 987         JSValueRef* exception)
 988 {
 989     LOGD("enter");
 990
 991     try{
 992         ArgumentValidator validator(context, argumentCount, arguments);
 993         JSObjectRef successCB = validator.toFunction(0);
 994
 995         PressureSuccessCallbackPtr pressureCB(new PressureSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
 996         if (successCB) {
 997             pressureCB->setSuccessCallback(successCB);
 998         }
 999
1000         JSObjectRef errorCB = validator.toFunction(1, true);
1001         if(errorCB) {
1002             pressureCB->setErrorCallback(errorCB);
1003         }
1004
1005         PressureSensor::getInstance()->start(pressureCB);
1006         return JSValueMakeUndefined(context);
1007
1008     } catch (const BasePlatformException &err) {
1009         LOGE("argument is wrong.");
1010         return JSWebAPIErrorFactory::postException(context, exception, err);
1011     }
1012
1013 }
1014
1015 JSValueRef JSPressureSensor::stop(JSContextRef context,
1016         JSObjectRef object,
1017         JSObjectRef thisObject,
1018         size_t argumentCount,
1019         const JSValueRef arguments[],
1020         JSValueRef* exception)
1021 {
1022     LOGD("enter");
1023
1024     try{
1025         PressureSensor::getInstance()->stop(GlobalContextManager::getInstance()->getGlobalContext(context));
1026         return JSValueMakeUndefined(context);
1027
1028     } catch (const BasePlatformException &err) {
1029         LOGE("argument is wrong.");
1030         return JSWebAPIErrorFactory::postException(context, exception, err);
1031     }
1032
1033 }
1034
1035 JSValueRef JSPressureSensor::setChangeListener(JSContextRef context,
1036         JSObjectRef object,
1037         JSObjectRef thisObject,
1038         size_t argumentCount,
1039         const JSValueRef arguments[],
1040         JSValueRef* exception)
1041 {
1042     LOGD("enter");
1043
1044     try{
1045         ArgumentValidator validator(context, argumentCount, arguments);
1046         JSObjectRef successCB = validator.toFunction(0);
1047
1048         PressureSuccessCallbackPtr pressureCB(new PressureSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1049         if (successCB) {
1050             pressureCB->setSuccessCallback(successCB);
1051         }
1052
1053         JSObjectRef errorCB = validator.toFunction(1, true);
1054         if(errorCB) {
1055             pressureCB->setErrorCallback(errorCB);
1056         }
1057
1058         PressureSensor::getInstance()->setChangeListener(pressureCB);
1059         return JSValueMakeUndefined(context);
1060
1061     } catch (const BasePlatformException &err) {
1062         LOGE("argument is wrong.");
1063         return JSWebAPIErrorFactory::postException(context, exception, err);
1064     }
1065
1066 }
1067
1068
1069
1070 JSValueRef JSPressureSensor::unsetChangeListener(JSContextRef context,
1071         JSObjectRef object,
1072         JSObjectRef thisObject,
1073         size_t argumentCount,
1074         const JSValueRef arguments[],
1075         JSValueRef* exception)
1076 {
1077     LOGD("enter");
1078
1079     try{
1080         PressureSensor::getInstance()->unsetChangeListener(GlobalContextManager::getInstance()->getGlobalContext(context));
1081         return JSValueMakeUndefined(context);
1082     } catch (const BasePlatformException &err) {
1083         LOGE("argument is wrong.");
1084         return JSWebAPIErrorFactory::postException(context, exception, err);
1085     }
1086 }
1087
1088
1089 JSValueRef JSPressureSensor::getSensorData(JSContextRef context,
1090         JSObjectRef object,
1091         JSObjectRef thisObject,
1092         size_t argumentCount,
1093         const JSValueRef arguments[],
1094         JSValueRef* exception)
1095 {
1096
1097     LOGD("enter");
1098     try{
1099         ArgumentValidator validator(context, argumentCount, arguments);
1100         JSObjectRef successCB = validator.toFunction(0);
1101
1102         PressureSuccessCallbackPtr pressureCB(new PressureSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1103         if (successCB) {
1104             pressureCB->setSuccessCallback(successCB);
1105         }
1106
1107         JSObjectRef errorCB = validator.toFunction(1, true);
1108         if(errorCB) {
1109             pressureCB->setErrorCallback(errorCB);
1110         }
1111
1112         PressureSensor::getInstance()->getSensorData(pressureCB);
1113         return JSValueMakeUndefined(context);
1114
1115     } catch (const BasePlatformException &err) {
1116         LOGE("argument is wrong.");
1117         return JSWebAPIErrorFactory::postException(context, exception, err);
1118     }
1119
1120 }
1121
1122 //JSUltravioletSensor
1123 JSClassDefinition JSUltravioletSensor::m_classInfo = {
1124     0,
1125     kJSClassAttributeNone,
1126     "UltravioletSensor",
1127     NULL, //ParentClass
1128     m_property, //StaticValues
1129     m_function, //StaticFunctions
1130     initialize, //Initialize
1131     finalize, //Finalize
1132     NULL, //HasProperty,
1133     NULL, //GetProperty,
1134     NULL, //SetProperty,
1135     NULL, //DeleteProperty,
1136     NULL, //GetPropertyNames,
1137     NULL, //CallAsFunction,
1138     NULL, //CallAsConstructor,
1139     NULL, //HasInstance,
1140     NULL //ConvertToType
1141 };
1142
1143 JSStaticValue JSUltravioletSensor::m_property[] = {
1144     { SENSOR_ATTRIBUTE_SENSOR_TYPE, getProperty, NULL, kJSPropertyAttributeReadOnly },
1145     { 0, 0, 0, 0 }
1146 };
1147
1148
1149
1150 JSStaticFunction JSUltravioletSensor::m_function[] = {
1151     { SENSOR_API_START, start, kJSPropertyAttributeNone },
1152     { SENSOR_API_STOP, stop, kJSPropertyAttributeNone },
1153     { SENSOR_API_SET_CHANGE_LISTENER, setChangeListener, kJSPropertyAttributeNone },
1154     { SENSOR_API_UNSET_CHANGE_LISTENER, unsetChangeListener, kJSPropertyAttributeNone },
1155     { SENSOR_API_GET_ULTRAVIOLET_SENSOR_DATA, getSensorData, kJSPropertyAttributeNone },
1156     { 0, 0, 0 }
1157 };
1158
1159 JSClassRef JSUltravioletSensor::m_jsClassRef = JSClassCreate(JSUltravioletSensor::getClassInfo());
1160
1161 const JSClassRef JSUltravioletSensor::getClassRef()
1162 {
1163     if (!m_jsClassRef) {
1164         m_jsClassRef = JSClassCreate(&m_classInfo);
1165     }
1166     return m_jsClassRef;
1167 }
1168
1169 const JSClassDefinition* JSUltravioletSensor::getClassInfo()
1170 {
1171     return &m_classInfo;
1172 }
1173
1174 JSValueRef JSUltravioletSensor::createJSObject(JSContextRef context, UltravioletSensor* sensor)
1175 {
1176     JSObjectRef jsValueRef = JSObjectMake(context, getClassRef(), static_cast<void*>(sensor));
1177     if (NULL == jsValueRef) {
1178         LOGE("object creation error");
1179         return JSValueMakeUndefined(context);
1180     }
1181
1182     return jsValueRef;
1183 }
1184
1185 void JSUltravioletSensor::initialize(JSContextRef context, JSObjectRef object)
1186 {
1187     LOGD("enter");
1188 }
1189
1190 void JSUltravioletSensor::finalize(JSObjectRef object)
1191 {
1192     LOGD("enter");
1193 }
1194
1195 JSValueRef JSUltravioletSensor::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
1196 {
1197     std::string sensorType("");
1198     LOGD("enter");
1199
1200     if (JSStringIsEqualToUTF8CString(propertyName, SENSOR_ATTRIBUTE_SENSOR_TYPE)) {
1201         sensorType.append("ULTRAVIOLET");
1202         return JSUtil::toJSValueRef(context, sensorType);
1203     }
1204     return JSValueMakeUndefined(context);
1205 }
1206
1207 JSValueRef JSUltravioletSensor::start(JSContextRef context,
1208         JSObjectRef object,
1209         JSObjectRef thisObject,
1210         size_t argumentCount,
1211         const JSValueRef arguments[],
1212         JSValueRef* exception)
1213 {
1214     LOGD("enter");
1215
1216     try{
1217         ArgumentValidator validator(context, argumentCount, arguments);
1218         JSObjectRef successCB = validator.toFunction(0);
1219
1220         UltravioletSuccessCallbackPtr ultravioletCB(new UltravioletSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1221         if (successCB) {
1222             ultravioletCB->setSuccessCallback(successCB);
1223         }
1224
1225         JSObjectRef errorCB = validator.toFunction(1, true);
1226         if(errorCB) {
1227             ultravioletCB->setErrorCallback(errorCB);
1228         }
1229
1230         UltravioletSensor::getInstance()->start(ultravioletCB);
1231         return JSValueMakeUndefined(context);
1232
1233     } catch (const BasePlatformException &err) {
1234         LOGE("argument is wrong.");
1235         return JSWebAPIErrorFactory::postException(context, exception, err);
1236     }
1237
1238 }
1239
1240 JSValueRef JSUltravioletSensor::stop(JSContextRef context,
1241         JSObjectRef object,
1242         JSObjectRef thisObject,
1243         size_t argumentCount,
1244         const JSValueRef arguments[],
1245         JSValueRef* exception)
1246 {
1247     LOGD("enter");
1248     try{
1249         UltravioletSensor::getInstance()->stop(GlobalContextManager::getInstance()->getGlobalContext(context));
1250         return JSValueMakeUndefined(context);
1251
1252     } catch (const BasePlatformException &err) {
1253         LOGE("argument is wrong.");
1254         return JSWebAPIErrorFactory::postException(context, exception, err);
1255     }
1256
1257 }
1258
1259 JSValueRef JSUltravioletSensor::setChangeListener(JSContextRef context,
1260         JSObjectRef object,
1261         JSObjectRef thisObject,
1262         size_t argumentCount,
1263         const JSValueRef arguments[],
1264         JSValueRef* exception)
1265 {
1266     LOGD("enter");
1267
1268     try{
1269         ArgumentValidator validator(context, argumentCount, arguments);
1270         JSObjectRef successCB = validator.toFunction(0);
1271
1272         UltravioletSuccessCallbackPtr ultravioletCB(new UltravioletSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1273         if (successCB) {
1274             ultravioletCB->setSuccessCallback(successCB);
1275         }
1276
1277         JSObjectRef errorCB = validator.toFunction(1, true);
1278         if(errorCB) {
1279             ultravioletCB->setErrorCallback(errorCB);
1280         }
1281
1282         UltravioletSensor::getInstance()->setChangeListener(ultravioletCB);
1283         return JSValueMakeUndefined(context);
1284
1285     } catch (const BasePlatformException &err) {
1286         LOGE("argument is wrong.");
1287         return JSWebAPIErrorFactory::postException(context, exception, err);
1288     }
1289
1290 }
1291
1292
1293
1294 JSValueRef JSUltravioletSensor::unsetChangeListener(JSContextRef context,
1295         JSObjectRef object,
1296         JSObjectRef thisObject,
1297         size_t argumentCount,
1298         const JSValueRef arguments[],
1299         JSValueRef* exception)
1300 {
1301     LOGD("enter");
1302
1303     try{
1304         UltravioletSensor::getInstance()->unsetChangeListener(GlobalContextManager::getInstance()->getGlobalContext(context));
1305         return JSValueMakeUndefined(context);
1306
1307     } catch (const BasePlatformException &err) {
1308         LOGE("argument is wrong.");
1309         return JSWebAPIErrorFactory::postException(context, exception, err);
1310     }
1311
1312
1313 }
1314
1315
1316 JSValueRef JSUltravioletSensor::getSensorData(JSContextRef context,
1317         JSObjectRef object,
1318         JSObjectRef thisObject,
1319         size_t argumentCount,
1320         const JSValueRef arguments[],
1321         JSValueRef* exception)
1322 {
1323
1324     LOGD("enter");
1325
1326     try{
1327         ArgumentValidator validator(context, argumentCount, arguments);
1328         JSObjectRef successCB = validator.toFunction(0);
1329
1330         UltravioletSuccessCallbackPtr ultravioletCB(new UltravioletSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1331         if (successCB) {
1332             ultravioletCB->setSuccessCallback(successCB);
1333         }
1334
1335         JSObjectRef errorCB = validator.toFunction(1, true);
1336         if(errorCB) {
1337             ultravioletCB->setErrorCallback(errorCB);
1338         }
1339
1340         UltravioletSensor::getInstance()->getSensorData(ultravioletCB);
1341         return JSValueMakeUndefined(context);
1342
1343     } catch (const BasePlatformException &err) {
1344         LOGE("argument is wrong.");
1345         return JSWebAPIErrorFactory::postException(context, exception, err);
1346     }
1347
1348 }
1349
1350
1351 JSClassDefinition JSHRMRawSensor::m_classInfo = {
1352     0,
1353     kJSClassAttributeNone,
1354     "HRMRawSensor",
1355     NULL, //ParentClass
1356     m_property, //StaticValues
1357     m_function, //StaticFunctions
1358     initialize, //Initialize
1359     finalize, //Finalize
1360     NULL, //HasProperty,
1361     NULL, //GetProperty,
1362     NULL, //SetProperty,
1363     NULL, //DeleteProperty,
1364     NULL, //GetPropertyNames,
1365     NULL, //CallAsFunction,
1366     NULL, //CallAsConstructor,
1367     NULL, //HasInstance,
1368     NULL //ConvertToType
1369 };
1370
1371 JSStaticValue JSHRMRawSensor::m_property[] = {
1372     { SENSOR_ATTRIBUTE_SENSOR_TYPE, getProperty, NULL, kJSPropertyAttributeReadOnly },
1373     { 0, 0, 0, 0 }
1374 };
1375
1376
1377
1378 JSStaticFunction JSHRMRawSensor::m_function[] = {
1379     { SENSOR_API_START, start, kJSPropertyAttributeNone },
1380     { SENSOR_API_STOP, stop, kJSPropertyAttributeNone },
1381     { SENSOR_API_SET_CHANGE_LISTENER, setChangeListener, kJSPropertyAttributeNone },
1382     { SENSOR_API_UNSET_CHANGE_LISTENER, unsetChangeListener, kJSPropertyAttributeNone },
1383     { SENSOR_API_GET_HRMRAW_SENSOR_DATA, getSensorData, kJSPropertyAttributeNone },
1384     { 0, 0, 0 }
1385 };
1386
1387 JSClassRef JSHRMRawSensor::m_jsClassRef = JSClassCreate(JSHRMRawSensor::getClassInfo());
1388
1389 const JSClassRef JSHRMRawSensor::getClassRef()
1390 {
1391     if (!m_jsClassRef) {
1392         m_jsClassRef = JSClassCreate(&m_classInfo);
1393     }
1394     return m_jsClassRef;
1395 }
1396
1397 const JSClassDefinition* JSHRMRawSensor::getClassInfo()
1398 {
1399     return &m_classInfo;
1400 }
1401
1402
1403 JSValueRef JSHRMRawSensor::createJSObject(JSContextRef context, HRMRawSensor* sensor)
1404 {
1405     JSObjectRef jsValueRef = JSObjectMake(context, getClassRef(), static_cast<void*>(sensor));
1406     if (NULL == jsValueRef) {
1407         LOGE("object creation error");
1408         return JSValueMakeUndefined(context);
1409     }
1410
1411     return jsValueRef;
1412 }
1413
1414
1415 void JSHRMRawSensor::initialize(JSContextRef context, JSObjectRef object)
1416 {
1417
1418 }
1419
1420 void JSHRMRawSensor::finalize(JSObjectRef object)
1421 {
1422
1423 }
1424
1425 JSValueRef JSHRMRawSensor::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
1426 {
1427     std::string sensorType("");
1428     LOGD("enter");
1429
1430      if (JSStringIsEqualToUTF8CString(propertyName, SENSOR_ATTRIBUTE_SENSOR_TYPE)) {
1431         sensorType.append("HRM_RAW");
1432         return JSUtil::toJSValueRef(context, sensorType);
1433     }
1434     return JSValueMakeUndefined(context);
1435 }
1436
1437
1438 JSValueRef JSHRMRawSensor::start(JSContextRef context,
1439         JSObjectRef object,
1440         JSObjectRef thisObject,
1441         size_t argumentCount,
1442         const JSValueRef arguments[],
1443         JSValueRef* exception)
1444 {
1445     LOGD("enter");
1446
1447     try{
1448         ArgumentValidator validator(context, argumentCount, arguments);
1449         JSObjectRef successCB = validator.toFunction(0);
1450
1451         HRMRawSuccessCallbackPtr HRMRawCB(new HRMRawSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1452         if (successCB) {
1453             HRMRawCB->setSuccessCallback(successCB);
1454         }
1455
1456         JSObjectRef errorCB = validator.toFunction(1, true);
1457         if(errorCB) {
1458             HRMRawCB->setErrorCallback(errorCB);
1459         }
1460
1461         HRMRawSensor::getInstance()->start(HRMRawCB);
1462         return JSValueMakeUndefined(context);
1463
1464     } catch (const BasePlatformException &err) {
1465         LOGD("argument is wrong.");
1466         return JSWebAPIErrorFactory::postException(context, exception, err);
1467     }
1468
1469 }
1470
1471 JSValueRef JSHRMRawSensor::stop(JSContextRef context,
1472         JSObjectRef object,
1473         JSObjectRef thisObject,
1474         size_t argumentCount,
1475         const JSValueRef arguments[],
1476         JSValueRef* exception)
1477 {
1478     LOGD("enter");
1479
1480     try{
1481         HRMRawSensor::getInstance()->stop(GlobalContextManager::getInstance()->getGlobalContext(context));
1482         return JSValueMakeUndefined(context);
1483
1484     } catch (const BasePlatformException &err) {
1485         LOGD("argument is wrong.");
1486         return JSWebAPIErrorFactory::postException(context, exception, err);
1487     }
1488
1489 }
1490
1491 JSValueRef JSHRMRawSensor::setChangeListener(JSContextRef context,
1492         JSObjectRef object,
1493         JSObjectRef thisObject,
1494         size_t argumentCount,
1495         const JSValueRef arguments[],
1496         JSValueRef* exception)
1497 {
1498     LOGD("enter");
1499
1500     try{
1501         ArgumentValidator validator(context, argumentCount, arguments);
1502         JSObjectRef successCB = validator.toFunction(0);
1503
1504         HRMRawSuccessCallbackPtr HRMRawCB(new HRMRawSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1505         if (successCB) {
1506             HRMRawCB->setSuccessCallback(successCB);
1507         }
1508
1509         JSObjectRef errorCB = validator.toFunction(1, true);
1510         if(errorCB) {
1511             HRMRawCB->setErrorCallback(errorCB);
1512         }
1513
1514         HRMRawSensor::getInstance()->setChangeListener(HRMRawCB);
1515         return JSValueMakeUndefined(context);
1516
1517     } catch (const BasePlatformException &err) {
1518         LOGD("argument is wrong.");
1519         return JSWebAPIErrorFactory::postException(context, exception, err);
1520     }
1521
1522 }
1523
1524
1525
1526 JSValueRef JSHRMRawSensor::unsetChangeListener(JSContextRef context,
1527         JSObjectRef object,
1528         JSObjectRef thisObject,
1529         size_t argumentCount,
1530         const JSValueRef arguments[],
1531         JSValueRef* exception)
1532 {
1533     LOGD("enter");
1534
1535     try{
1536         HRMRawSensor::getInstance()->unsetChangeListener(GlobalContextManager::getInstance()->getGlobalContext(context));
1537         return JSValueMakeUndefined(context);
1538
1539     } catch (const BasePlatformException &err) {
1540         LOGD("argument is wrong.");
1541         return JSWebAPIErrorFactory::postException(context, exception, err);
1542     }
1543
1544
1545 }
1546
1547
1548 JSValueRef JSHRMRawSensor::getSensorData(JSContextRef context,
1549         JSObjectRef object,
1550         JSObjectRef thisObject,
1551         size_t argumentCount,
1552         const JSValueRef arguments[],
1553         JSValueRef* exception)
1554 {
1555
1556     LOGD("enter");
1557
1558     try{
1559         ArgumentValidator validator(context, argumentCount, arguments);
1560         JSObjectRef successCB = validator.toFunction(0);
1561
1562         HRMRawSuccessCallbackPtr HRMRawCB(new HRMRawSuccessCallback(GlobalContextManager::getInstance()->getGlobalContext(context)));
1563         if (successCB) {
1564             HRMRawCB->setSuccessCallback(successCB);
1565         }
1566
1567         JSObjectRef errorCB = validator.toFunction(1, true);
1568         if(errorCB) {
1569             HRMRawCB->setErrorCallback(errorCB);
1570         }
1571
1572         HRMRawSensor::getInstance()->getSensorData(HRMRawCB);
1573         return JSValueMakeUndefined(context);
1574
1575     } catch (const BasePlatformException &err) {
1576         LOGD("argument is wrong.");
1577         return JSWebAPIErrorFactory::postException(context, exception, err);
1578     }
1579
1580 }
1581
1582
1583 } // Sensor
1584 } // DeviceAPI