src/DataControl/JSSQLDataControlConsumer.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 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
  19 #include <CommonsJavaScript/Converter.h>
  20 #include <CommonsJavaScript/Validator.h>
  21 #include <CommonsJavaScript/JSUtils.h>
  22 #include <CommonsJavaScript/JSCallbackManager.h>
  23 #include <CommonsJavaScript/Utils.h>
  24 #include <JSTizenExceptionFactory.h>
  25 #include <JSTizenException.h>
  26 #include <SecurityExceptions.h>
  27 #include <Commons/Exception.h>
  28 #include <TimeTracer.h>
  29 #include <ArgumentValidator.h>
  30 #include <JSWebAPIError.h>
  31 #include <JSWebAPIException.h>
  32 #include <JSUtil.h>
  33 #include "DataControlFactory.h"
  34 #include "JSSQLDataControlConsumer.h"
  35 #include "DataControlAsyncCallbackManager.h"
  36 #include "DataControlListener.h"
  37 #include "DataControlConverter.h"
  38 #include "plugin_config.h"
  39
  40 using namespace WrtDeviceApis;
  41 using namespace WrtDeviceApis::Commons;
  42
  43 using namespace WrtDeviceApis::CommonsJavaScript;
  44
  45 using namespace DeviceAPI::Common;
  46
  47
  48 namespace DeviceAPI {
  49 namespace DataControl {
  50
  51 JSClassRef JSSQLDataControlConsumer::m_jsClassRef = NULL;
  52
  53 JSClassDefinition JSSQLDataControlConsumer::m_classInfo =
  54 {
  55         0,
  56         kJSClassAttributeNone,
  57         "DataControlConsumer",
  58         NULL,
  59         m_property,
  60         m_function,
  61         initialize,
  62         finalize,
  63         NULL,
  64         NULL,
  65         NULL,
  66         NULL,
  67         NULL,
  68         NULL,
  69         NULL,
  70         hasInstance,
  71         NULL
  72 };
  73
  74 JSStaticValue JSSQLDataControlConsumer::m_property[] = {
  75         { "type", getProperty, NULL, kJSPropertyAttributeReadOnly },
  76         { "providerId", getProperty, NULL, kJSPropertyAttributeReadOnly },
  77         { "dataId", getProperty, NULL, kJSPropertyAttributeReadOnly },
  78         { 0, 0, 0, 0 }
  79 };
  80
  81 JSStaticFunction JSSQLDataControlConsumer::m_function[] =
  82 {
  83         { "insert", JSSQLDataControlConsumer::insert, kJSPropertyAttributeNone },
  84         { "update", JSSQLDataControlConsumer::update, kJSPropertyAttributeNone },
  85         { "remove", JSSQLDataControlConsumer::remove, kJSPropertyAttributeNone },
  86         { "select", JSSQLDataControlConsumer::select, kJSPropertyAttributeNone },
  87         { 0, 0, 0 }
  88 };
  89
  90 const JSClassRef JSSQLDataControlConsumer::getClassRef()
  91 {
  92         if (!m_jsClassRef) {
  93                 m_jsClassRef = JSClassCreate(&m_classInfo);
  94         }
  95         return m_jsClassRef;
  96 }
  97
  98 const JSClassDefinition* JSSQLDataControlConsumer::getClassInfo()
  99 {
 100         return &m_classInfo;
 101 }
 102
 103 void JSSQLDataControlConsumer::initialize(JSContextRef context, JSObjectRef object)
 104 {
 105 }
 106 void JSSQLDataControlConsumer::finalize(JSObjectRef object)
 107 {
 108     JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(object));
 109     if (!priv) {
 110         LoggerE("Private object is null");
 111     }
 112     delete priv;
 113
 114 }
 115
 116 bool JSSQLDataControlConsumer::hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception)
 117 {
 118     return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 119 }
 120
 121
 122 JSObjectRef JSSQLDataControlConsumer::createJSObject(JSContextRef context, std::string provId, std::string dataId, std::string type)
 123 {
 124         ISQLDataControlConsumerPtr SqlDataControlConsumer(DataControlFactory::getInstance().getSQLDataControlConsumer());
 125         SqlDataControlConsumer->setDataId(dataId);
 126         SqlDataControlConsumer->setProviderId(provId);
 127         SqlDataControlConsumer->setType(type);
 128         JSSQLDataControlConsumerPriv* priv = new JSSQLDataControlConsumerPriv( context, SqlDataControlConsumer);
 129
 130         return JSObjectMake(context, getClassRef(), priv);
 131 }
 132
 133 JSValueRef JSSQLDataControlConsumer::getProperty(JSContextRef context,
 134                 JSObjectRef object,
 135                 JSStringRef propertyName,
 136                 JSValueRef* exception)
 137 {
 138         Try
 139         {
 140                 DataControlConverter converter(context);
 141                 JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(object));
 142                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 143
 144                 std::string propertyNameStr = converter.toString(propertyName);
 145                 if(propertyNameStr == "type")
 146                 {
 147                         return converter.toJSValueRef(dataControlConsumer->getType());
 148                 }
 149                 else if(propertyNameStr == "providerId")
 150                 {
 151                         return converter.toJSValueRef(dataControlConsumer->getProviderId());
 152                 }
 153                 else if(propertyNameStr == "dataId")
 154                 {
 155                         return converter.toJSValueRef(dataControlConsumer->getDataId());
 156                 }
 157         }
 158         Catch(WrtDeviceApis::Commons::Exception)
 159         {
 160                 LoggerW("trying to get incorrect value");
 161         }
 162
 163         return JSValueMakeUndefined(context);
 164 }
 165
 166 JSValueRef JSSQLDataControlConsumer::insert(
 167         JSContextRef context, JSObjectRef object,
 168         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 169         JSValueRef* exception)
 170 {
 171         LoggerD("Enter");
 172         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 173
 174         // argument validation with new validator
 175         try
 176         {
 177                 ArgumentValidator validator(context, argumentCount, arguments);
 178                 validator.toULong(0, false);
 179                 validator.toObject(1, false);
 180                 validator.toFunction(2, true);
 181                 validator.toFunction(3, true);
 182         }
 183         catch (const BasePlatformException &err)
 184         {
 185                 return JSWebAPIException::throwException(context, exception, err);
 186         }
 187         catch (...)
 188         {
 189                 DeviceAPI::Common::UnknownException err("");
 190                 return JSWebAPIException::throwException(context, exception, err);
 191         }
 192
 193
 194         DataControlConverter converter(context);
 195         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 196         JSValueRef successCallback = NULL;
 197         JSValueRef errorCallBack = NULL;
 198         size_t index = 0;
 199         JSValueRef reserveArguments[5];
 200
 201         if (priv == NULL)
 202         {
 203                 return JSTizenExceptionFactory::postException(context, exception,
 204                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 205         }
 206
 207         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 208
 209
 210         Try
 211         {
 212                 AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 213                 TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 214
 215                 for (index = 0; index < 4; index++)
 216                 {
 217                         if (index < argumentCount)
 218                                 reserveArguments[index] = arguments[index];
 219                         else
 220                                 reserveArguments[index] = JSValueMakeUndefined(context);
 221                 }
 222
 223                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 224                 EventInsertPtr event(new EventInsert);
 225
 226                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 227                 RowDataPtr rowData = converter.toRowDataPtr(reserveArguments[1]);
 228                 successCallback = converter.toFunctionOrNull(reserveArguments[2]);
 229                 errorCallBack = converter.toFunctionOrNull(reserveArguments[3]);
 230
 231                 cbm->setOnSuccess(successCallback);
 232                 cbm->setOnError(errorCallBack);
 233
 234                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData> (cbm));
 235                 DataControlListener& listener = DataControlListener::getInstance();
 236
 237                 event->setReqId(reqId);
 238                 event->setRowData(rowData);
 239                 event->setForAsynchronousCall(&listener);
 240
 241                 dataControlConsumer->insertData(event);
 242                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 243
 244         }
 245         Catch (WrtDeviceApis::Commons::ConversionException)
 246         {
 247                 LoggerE("ConversionException");
 248                 return JSTizenExceptionFactory::postException(context, exception,
 249                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 250
 251         }
 252         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 253         {
 254                 LoggerE("InvalidArgumentException");
 255                 return JSTizenExceptionFactory::postException(context, exception,
 256                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 257         }
 258         Catch(WrtDeviceApis::Commons::UnsupportedException)
 259         {
 260                 LoggerE("UnsupportException");
 261                 return JSTizenExceptionFactory::postException(context, exception,
 262                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 263         }
 264         Catch(WrtDeviceApis::Commons::Exception)
 265         {
 266                 LoggerE("UnkownException");
 267                 return JSTizenExceptionFactory::postException(context, exception,
 268                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 269         }
 270         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 271         return JSValueMakeUndefined(context);
 272 }
 273
 274
 275 JSValueRef JSSQLDataControlConsumer::update(
 276         JSContextRef context, JSObjectRef object,
 277         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 278         JSValueRef* exception)
 279 {
 280         LoggerD("Enter");
 281         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 282
 283         // argument validation with new validator
 284         try
 285         {
 286                 ArgumentValidator validator(context, argumentCount, arguments);
 287                 validator.toULong(0, false);
 288                 validator.toObject(1, false);
 289                 validator.toString(2, false);
 290                 validator.toFunction(3, true);
 291                 validator.toFunction(4, true);
 292         }
 293         catch (const BasePlatformException &err)
 294         {
 295                 return JSWebAPIException::throwException(context, exception, err);
 296         }
 297         catch (...)
 298         {
 299                 DeviceAPI::Common::UnknownException err("");
 300                 return JSWebAPIException::throwException(context, exception, err);
 301         }
 302
 303         DataControlConverter converter(context);
 304         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 305         JSValueRef successCallback = NULL;
 306         JSValueRef errorCallBack = NULL;
 307         size_t index = 0;
 308         JSValueRef reserveArguments[6];
 309
 310         if (priv == NULL)
 311         {
 312                 return JSTizenExceptionFactory::postException(context, exception,
 313                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 314         }
 315
 316
 317         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 318
 319
 320         Try
 321         {
 322                 AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 323                 TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 324
 325                 for (index = 0; index < 6; index++)
 326                 {
 327                         if (index < argumentCount)
 328                                 reserveArguments[index] = arguments[index];
 329                         else
 330                                 reserveArguments[index] = JSValueMakeUndefined(context);
 331                 }
 332
 333                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 334                 EventUpdatePtr event(new EventUpdate);
 335
 336                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 337                 RowDataPtr rowData = converter.toRowDataPtr(reserveArguments[1]);
 338                 std::string where = converter.toString(reserveArguments[2]);
 339                 successCallback = converter.toFunctionOrNull(reserveArguments[3]);
 340                 errorCallBack = converter.toFunctionOrNull(reserveArguments[4]);
 341
 342                 cbm->setOnSuccess(successCallback);
 343                 cbm->setOnError(errorCallBack);
 344
 345                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 346                 DataControlListener& listener = DataControlListener::getInstance();
 347
 348
 349                 event->setReqId(reqId);
 350                 event->setWhere(where);
 351                 event->setRowData(rowData);
 352                 event->setForAsynchronousCall(&listener);
 353
 354                 dataControlConsumer->updateData(event);
 355                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 356         }
 357         Catch (WrtDeviceApis::Commons::ConversionException)
 358         {
 359                 LoggerE("ConversionException");
 360                 return JSTizenExceptionFactory::postException(context, exception,
 361                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 362
 363         }
 364         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 365         {
 366                 LoggerE("InvalidArgumentException");
 367                 return JSTizenExceptionFactory::postException(context, exception,
 368                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 369         }
 370         Catch(WrtDeviceApis::Commons::UnsupportedException)
 371         {
 372                 LoggerE("UnsupportException");
 373                 return JSTizenExceptionFactory::postException(context, exception,
 374                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 375         }
 376         Catch(WrtDeviceApis::Commons::Exception)
 377         {
 378                 LoggerE("UnkownException");
 379                 return JSTizenExceptionFactory::postException(context, exception,
 380                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 381         }
 382         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 383         return JSValueMakeUndefined(context);
 384 }
 385
 386
 387 JSValueRef JSSQLDataControlConsumer::select(
 388         JSContextRef context, JSObjectRef object,
 389         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 390         JSValueRef* exception)
 391
 392 {
 393         LoggerD("Enter");
 394         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 395
 396         // argument validation with new validator
 397         try
 398         {
 399                 ArgumentValidator validator(context, argumentCount, arguments);
 400                 validator.toULong(0, false);
 401                 validator.toArrayObject(1, false);
 402                 validator.toString(2, false);
 403                 validator.toFunction(3, false);
 404                 validator.toFunction(4, true);
 405                 validator.toULong(5, true);
 406                 validator.toULong(6, true);
 407         }
 408         catch (const BasePlatformException &err)
 409         {
 410                 return JSWebAPIException::throwException(context, exception, err);
 411         }
 412         catch (...)
 413         {
 414                 DeviceAPI::Common::UnknownException err("");
 415                 return JSWebAPIException::throwException(context, exception, err);
 416         }
 417
 418
 419         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 420         JSValueRef successCallback = NULL;
 421         JSValueRef errorCallBack = NULL;
 422         size_t index = 0;
 423         JSValueRef reserveArguments[7];
 424
 425         if (priv == NULL)
 426         {
 427                 return JSTizenExceptionFactory::postException(context, exception,
 428                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 429         }
 430
 431         JSContextRef globalContext = priv->getContext();
 432         DataControlConverter converter(globalContext);
 433         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 434
 435
 436         Try
 437         {
 438                 AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 439                 TIZEN_SYNC_ACCESS_HANDLER(status, globalContext, exception);
 440
 441                 for (index = 0; index < 7; index++)
 442                 {
 443                         if (index < argumentCount)
 444                                 reserveArguments[index] = arguments[index];
 445                         else
 446                                 reserveArguments[index] = JSValueMakeUndefined(globalContext);
 447                 }
 448
 449                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 450                 EventSelectPtr event(new EventSelect);
 451
 452                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 453
 454                 LoggerD(reqId);
 455
 456                 std::vector<std::string> columns = converter.toVectorOfStrings(reserveArguments[1]);
 457
 458                 if (columns.size() == 0)
 459                         Throw(WrtDeviceApis::Commons::ConversionException);
 460
 461
 462                 std::string where = converter.toString(reserveArguments[2]);
 463
 464                 LoggerD(where);
 465
 466
 467                 successCallback = converter.toFunctionOrNull(reserveArguments[3]);
 468                 errorCallBack = converter.toFunctionOrNull(reserveArguments[4]);
 469
 470                 cbm->setOnSuccess(successCallback);
 471                 cbm->setOnError(errorCallBack);
 472
 473                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 474                 DataControlListener& listener = DataControlListener::getInstance();
 475
 476                 if (JSValueIsUndefined(globalContext, reserveArguments[5]) == false)
 477                 {
 478                         std::string page = converter.toString(reserveArguments[5]);
 479                         event->setPage(page);
 480                 }
 481
 482                 if (JSValueIsUndefined(globalContext,reserveArguments[6]) == false)
 483                 {
 484                         std::string number = converter.toString(reserveArguments[6]);
 485                         event->setNumberPerPage(number);
 486                 }
 487
 488                 event->setReqId(reqId);
 489                 event->setWhere(where);
 490                 event->setForAsynchronousCall(&listener);
 491                 event->setColumns(columns);
 492                 dataControlConsumer->selectData(event);
 493                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 494
 495         }
 496         Catch (WrtDeviceApis::Commons::ConversionException)
 497         {
 498                 LoggerE("ConversionException");
 499                 return JSTizenExceptionFactory::postException(context, exception,
 500                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 501
 502         }
 503         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 504         {
 505                 LoggerE("InvalidArgumentException");
 506                 return JSTizenExceptionFactory::postException(context, exception,
 507                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 508         }
 509         Catch(WrtDeviceApis::Commons::UnsupportedException)
 510         {
 511                 LoggerE("UnsupportException");
 512                 return JSTizenExceptionFactory::postException(context, exception,
 513                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 514         }
 515         Catch(WrtDeviceApis::Commons::Exception)
 516         {
 517                 LoggerE("UnkownException");
 518                 return JSTizenExceptionFactory::postException(context, exception,
 519                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 520         }
 521         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 522         return JSValueMakeUndefined(context);
 523 }
 524
 525 JSValueRef JSSQLDataControlConsumer::remove(
 526         JSContextRef context, JSObjectRef object,
 527         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 528         JSValueRef* exception)
 529 {
 530         LoggerD("Enter");
 531         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 532
 533         // argument validation with new validator
 534         try
 535         {
 536                 ArgumentValidator validator(context, argumentCount, arguments);
 537                 validator.toULong(0, false);
 538                 validator.toString(1, false);
 539                 validator.toFunction(2, true);
 540                 validator.toFunction(3, true);
 541         }
 542         catch (const BasePlatformException &err)
 543         {
 544                 return JSWebAPIException::throwException(context, exception, err);
 545         }
 546         catch (...)
 547         {
 548                 DeviceAPI::Common::UnknownException err("");
 549                 return JSWebAPIException::throwException(context, exception, err);
 550         }
 551
 552         DataControlConverter converter(context);
 553         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 554         JSValueRef successCallback = NULL;
 555         JSValueRef errorCallBack = NULL;
 556         size_t index = 0;
 557         JSValueRef reserveArguments[4];
 558
 559         if (priv == NULL)
 560         {
 561                 return JSTizenExceptionFactory::postException(context, exception,
 562                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 563         }
 564
 565         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 566
 567
 568         Try
 569         {
 570                 AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 571                 TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 572
 573                 for (index = 0; index < 4; index++)
 574                 {
 575                         if (index < argumentCount)
 576                                 reserveArguments[index] = arguments[index];
 577                         else
 578                                 reserveArguments[index] = JSValueMakeUndefined(context);
 579                 }
 580
 581                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 582                 EventDeletePtr event(new EventDelete);
 583
 584                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 585                 std::string where = converter.toString(reserveArguments[1]);
 586                 successCallback = converter.toFunctionOrNull(reserveArguments[2]);
 587                 errorCallBack = converter.toFunctionOrNull(reserveArguments[3]);
 588
 589                 cbm->setOnSuccess(successCallback);
 590                 cbm->setOnError(errorCallBack);
 591
 592                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 593                 DataControlListener& listener = DataControlListener::getInstance();
 594
 595
 596                 event->setReqId(reqId);
 597                 event->setWhere(where);
 598                 event->setForAsynchronousCall(&listener);
 599
 600                 dataControlConsumer->deleteData(event);
 601                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 602
 603         }
 604
 605         Catch (WrtDeviceApis::Commons::ConversionException)
 606         {
 607                 LoggerE("ConversionException");
 608                 return JSTizenExceptionFactory::postException(context, exception,
 609                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 610
 611         }
 612         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 613         {
 614                 LoggerE("InvalidArgumentException");
 615                 return JSTizenExceptionFactory::postException(context, exception,
 616                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 617         }
 618         Catch(WrtDeviceApis::Commons::UnsupportedException)
 619         {
 620                 LoggerE("UnsupportException");
 621                 return JSTizenExceptionFactory::postException(context, exception,
 622                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 623         }
 624         Catch(WrtDeviceApis::Commons::Exception)
 625         {
 626                 LoggerE("UnkownException");
 627                 return JSTizenExceptionFactory::postException(context, exception,
 628                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 629         }
 630         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 631         return JSValueMakeUndefined(context);
 632 }
 633
 634
 635 }
 636 }
 637