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         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 175         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 176
 177
 178         // argument validation with new validator
 179         try
 180         {
 181                 ArgumentValidator validator(context, argumentCount, arguments);
 182                 validator.toULong(0, false);
 183                 validator.toObject(1, false);
 184                 validator.toFunction(2, true);
 185                 validator.toFunction(3, true);
 186         }
 187         catch (const BasePlatformException &err)
 188         {
 189                 return JSWebAPIException::throwException(context, exception, err);
 190         }
 191         catch (...)
 192         {
 193                 DeviceAPI::Common::UnknownException err("");
 194                 return JSWebAPIException::throwException(context, exception, err);
 195         }
 196
 197
 198         DataControlConverter converter(context);
 199         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 200         JSValueRef successCallback = NULL;
 201         JSValueRef errorCallBack = NULL;
 202         size_t index = 0;
 203         JSValueRef reserveArguments[5];
 204
 205         if (priv == NULL)
 206         {
 207                 return JSTizenExceptionFactory::postException(context, exception,
 208                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 209         }
 210
 211         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 212
 213
 214         Try
 215         {
 216                 for (index = 0; index < 4; index++)
 217                 {
 218                         if (index < argumentCount)
 219                                 reserveArguments[index] = arguments[index];
 220                         else
 221                                 reserveArguments[index] = JSValueMakeUndefined(context);
 222                 }
 223
 224                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 225                 EventInsertPtr event(new EventInsert);
 226
 227                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 228                 RowDataPtr rowData = converter.toRowDataPtr(reserveArguments[1]);
 229                 successCallback = converter.toFunctionOrNull(reserveArguments[2]);
 230                 errorCallBack = converter.toFunctionOrNull(reserveArguments[3]);
 231
 232                 cbm->setOnSuccess(successCallback);
 233                 cbm->setOnError(errorCallBack);
 234
 235                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData> (cbm));
 236                 DataControlListener& listener = DataControlListener::getInstance();
 237
 238                 event->setReqId(reqId);
 239                 event->setRowData(rowData);
 240                 event->setForAsynchronousCall(&listener);
 241
 242                 dataControlConsumer->insertData(event);
 243                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 244
 245         }
 246         Catch (WrtDeviceApis::Commons::ConversionException)
 247         {
 248                 LoggerE("ConversionException");
 249                 return JSTizenExceptionFactory::postException(context, exception,
 250                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 251
 252         }
 253         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 254         {
 255                 LoggerE("InvalidArgumentException");
 256                 return JSTizenExceptionFactory::postException(context, exception,
 257                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 258         }
 259         Catch(WrtDeviceApis::Commons::UnsupportedException)
 260         {
 261                 LoggerE("UnsupportException");
 262                 return JSTizenExceptionFactory::postException(context, exception,
 263                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 264         }
 265         Catch(WrtDeviceApis::Commons::Exception)
 266         {
 267                 LoggerE("UnkownException");
 268                 return JSTizenExceptionFactory::postException(context, exception,
 269                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 270         }
 271         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 272         return JSValueMakeUndefined(context);
 273 }
 274
 275
 276 JSValueRef JSSQLDataControlConsumer::update(
 277         JSContextRef context, JSObjectRef object,
 278         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 279         JSValueRef* exception)
 280 {
 281         LoggerD("Enter");
 282         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 283
 284         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 285         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 286
 287         // argument validation with new validator
 288         try
 289         {
 290                 ArgumentValidator validator(context, argumentCount, arguments);
 291                 validator.toULong(0, false);
 292                 validator.toObject(1, false);
 293                 validator.toString(2, false);
 294                 validator.toFunction(3, true);
 295                 validator.toFunction(4, true);
 296         }
 297         catch (const BasePlatformException &err)
 298         {
 299                 return JSWebAPIException::throwException(context, exception, err);
 300         }
 301         catch (...)
 302         {
 303                 DeviceAPI::Common::UnknownException err("");
 304                 return JSWebAPIException::throwException(context, exception, err);
 305         }
 306
 307         DataControlConverter converter(context);
 308         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 309         JSValueRef successCallback = NULL;
 310         JSValueRef errorCallBack = NULL;
 311         size_t index = 0;
 312         JSValueRef reserveArguments[6];
 313
 314         if (priv == NULL)
 315         {
 316                 return JSTizenExceptionFactory::postException(context, exception,
 317                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 318         }
 319
 320
 321         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 322
 323
 324         Try
 325         {
 326                 for (index = 0; index < 6; index++)
 327                 {
 328                         if (index < argumentCount)
 329                                 reserveArguments[index] = arguments[index];
 330                         else
 331                                 reserveArguments[index] = JSValueMakeUndefined(context);
 332                 }
 333
 334                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 335                 EventUpdatePtr event(new EventUpdate);
 336
 337                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 338                 RowDataPtr rowData = converter.toRowDataPtr(reserveArguments[1]);
 339                 std::string where = converter.toString(reserveArguments[2]);
 340                 successCallback = converter.toFunctionOrNull(reserveArguments[3]);
 341                 errorCallBack = converter.toFunctionOrNull(reserveArguments[4]);
 342
 343                 cbm->setOnSuccess(successCallback);
 344                 cbm->setOnError(errorCallBack);
 345
 346                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 347                 DataControlListener& listener = DataControlListener::getInstance();
 348
 349
 350                 event->setReqId(reqId);
 351                 event->setWhere(where);
 352                 event->setRowData(rowData);
 353                 event->setForAsynchronousCall(&listener);
 354
 355                 dataControlConsumer->updateData(event);
 356                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 357         }
 358         Catch (WrtDeviceApis::Commons::ConversionException)
 359         {
 360                 LoggerE("ConversionException");
 361                 return JSTizenExceptionFactory::postException(context, exception,
 362                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 363
 364         }
 365         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 366         {
 367                 LoggerE("InvalidArgumentException");
 368                 return JSTizenExceptionFactory::postException(context, exception,
 369                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 370         }
 371         Catch(WrtDeviceApis::Commons::UnsupportedException)
 372         {
 373                 LoggerE("UnsupportException");
 374                 return JSTizenExceptionFactory::postException(context, exception,
 375                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 376         }
 377         Catch(WrtDeviceApis::Commons::Exception)
 378         {
 379                 LoggerE("UnkownException");
 380                 return JSTizenExceptionFactory::postException(context, exception,
 381                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 382         }
 383         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 384         return JSValueMakeUndefined(context);
 385 }
 386
 387
 388 JSValueRef JSSQLDataControlConsumer::select(
 389         JSContextRef context, JSObjectRef object,
 390         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 391         JSValueRef* exception)
 392
 393 {
 394         LoggerD("Enter");
 395         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 396
 397         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 398         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 399
 400         // argument validation with new validator
 401         try
 402         {
 403                 ArgumentValidator validator(context, argumentCount, arguments);
 404                 validator.toULong(0, false);
 405                 validator.toArrayObject(1, false);
 406                 validator.toString(2, false);
 407                 validator.toFunction(3, false);
 408                 validator.toFunction(4, true);
 409                 validator.toULong(5, true);
 410                 validator.toULong(6, true);
 411         }
 412         catch (const BasePlatformException &err)
 413         {
 414                 return JSWebAPIException::throwException(context, exception, err);
 415         }
 416         catch (...)
 417         {
 418                 DeviceAPI::Common::UnknownException err("");
 419                 return JSWebAPIException::throwException(context, exception, err);
 420         }
 421
 422
 423         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 424         JSValueRef successCallback = NULL;
 425         JSValueRef errorCallBack = NULL;
 426         size_t index = 0;
 427         JSValueRef reserveArguments[7];
 428
 429         if (priv == NULL)
 430         {
 431                 return JSTizenExceptionFactory::postException(context, exception,
 432                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 433         }
 434
 435         JSContextRef globalContext = priv->getContext();
 436         DataControlConverter converter(globalContext);
 437         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 438
 439
 440         Try
 441         {
 442                 for (index = 0; index < 7; index++)
 443                 {
 444                         if (index < argumentCount)
 445                                 reserveArguments[index] = arguments[index];
 446                         else
 447                                 reserveArguments[index] = JSValueMakeUndefined(globalContext);
 448                 }
 449
 450                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 451                 EventSelectPtr event(new EventSelect);
 452
 453                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 454
 455                 LoggerD(reqId);
 456
 457                 std::vector<std::string> columns = converter.toVectorOfStrings(reserveArguments[1]);
 458
 459                 if (columns.size() == 0)
 460                         Throw(WrtDeviceApis::Commons::ConversionException);
 461
 462
 463                 std::string where = converter.toString(reserveArguments[2]);
 464
 465                 LoggerD(where);
 466
 467
 468                 successCallback = converter.toFunctionOrNull(reserveArguments[3]);
 469                 errorCallBack = converter.toFunctionOrNull(reserveArguments[4]);
 470
 471                 cbm->setOnSuccess(successCallback);
 472                 cbm->setOnError(errorCallBack);
 473
 474                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 475                 DataControlListener& listener = DataControlListener::getInstance();
 476
 477                 if (JSValueIsUndefined(globalContext, reserveArguments[5]) == false)
 478                 {
 479                         std::string page = converter.toString(reserveArguments[5]);
 480                         event->setPage(page);
 481                 }
 482
 483                 if (JSValueIsUndefined(globalContext,reserveArguments[6]) == false)
 484                 {
 485                         std::string number = converter.toString(reserveArguments[6]);
 486                         event->setNumberPerPage(number);
 487                 }
 488
 489                 event->setReqId(reqId);
 490                 event->setWhere(where);
 491                 event->setForAsynchronousCall(&listener);
 492                 event->setColumns(columns);
 493                 dataControlConsumer->selectData(event);
 494                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 495
 496         }
 497         Catch (WrtDeviceApis::Commons::ConversionException)
 498         {
 499                 LoggerE("ConversionException");
 500                 return JSTizenExceptionFactory::postException(context, exception,
 501                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 502
 503         }
 504         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 505         {
 506                 LoggerE("InvalidArgumentException");
 507                 return JSTizenExceptionFactory::postException(context, exception,
 508                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 509         }
 510         Catch(WrtDeviceApis::Commons::UnsupportedException)
 511         {
 512                 LoggerE("UnsupportException");
 513                 return JSTizenExceptionFactory::postException(context, exception,
 514                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 515         }
 516         Catch(WrtDeviceApis::Commons::Exception)
 517         {
 518                 LoggerE("UnkownException");
 519                 return JSTizenExceptionFactory::postException(context, exception,
 520                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 521         }
 522         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 523         return JSValueMakeUndefined(context);
 524 }
 525
 526 JSValueRef JSSQLDataControlConsumer::remove(
 527         JSContextRef context, JSObjectRef object,
 528         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 529         JSValueRef* exception)
 530 {
 531         LoggerD("Enter");
 532         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 533
 534         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 535         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 536
 537         // argument validation with new validator
 538         try
 539         {
 540                 ArgumentValidator validator(context, argumentCount, arguments);
 541                 validator.toULong(0, false);
 542                 validator.toString(1, false);
 543                 validator.toFunction(2, true);
 544                 validator.toFunction(3, true);
 545         }
 546         catch (const BasePlatformException &err)
 547         {
 548                 return JSWebAPIException::throwException(context, exception, err);
 549         }
 550         catch (...)
 551         {
 552                 DeviceAPI::Common::UnknownException err("");
 553                 return JSWebAPIException::throwException(context, exception, err);
 554         }
 555
 556         DataControlConverter converter(context);
 557         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 558         JSValueRef successCallback = NULL;
 559         JSValueRef errorCallBack = NULL;
 560         size_t index = 0;
 561         JSValueRef reserveArguments[4];
 562
 563         if (priv == NULL)
 564         {
 565                 return JSTizenExceptionFactory::postException(context, exception,
 566                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 567         }
 568
 569         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 570
 571
 572         Try
 573         {
 574
 575
 576                 for (index = 0; index < 4; index++)
 577                 {
 578                         if (index < argumentCount)
 579                                 reserveArguments[index] = arguments[index];
 580                         else
 581                                 reserveArguments[index] = JSValueMakeUndefined(context);
 582                 }
 583
 584                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 585                 EventDeletePtr event(new EventDelete);
 586
 587                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 588                 std::string where = converter.toString(reserveArguments[1]);
 589                 successCallback = converter.toFunctionOrNull(reserveArguments[2]);
 590                 errorCallBack = converter.toFunctionOrNull(reserveArguments[3]);
 591
 592                 cbm->setOnSuccess(successCallback);
 593                 cbm->setOnError(errorCallBack);
 594
 595                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 596                 DataControlListener& listener = DataControlListener::getInstance();
 597
 598
 599                 event->setReqId(reqId);
 600                 event->setWhere(where);
 601                 event->setForAsynchronousCall(&listener);
 602
 603                 dataControlConsumer->deleteData(event);
 604                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 605
 606         }
 607
 608         Catch (WrtDeviceApis::Commons::ConversionException)
 609         {
 610                 LoggerE("ConversionException");
 611                 return JSTizenExceptionFactory::postException(context, exception,
 612                                         JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
 613
 614         }
 615         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 616         {
 617                 LoggerE("InvalidArgumentException");
 618                 return JSTizenExceptionFactory::postException(context, exception,
 619                                 JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
 620         }
 621         Catch(WrtDeviceApis::Commons::UnsupportedException)
 622         {
 623                 LoggerE("UnsupportException");
 624                 return JSTizenExceptionFactory::postException(context, exception,
 625                                 JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 626         }
 627         Catch(WrtDeviceApis::Commons::Exception)
 628         {
 629                 LoggerE("UnkownException");
 630                 return JSTizenExceptionFactory::postException(context, exception,
 631                                 JSTizenException::UNKNOWN_ERROR, "Unkown error");
 632         }
 633         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 634         return JSValueMakeUndefined(context);
 635 }
 636
 637
 638 }
 639 }
 640