src/Messaging/JSMessagingStorage.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 #include "JSMessagingStorage.h"
  19 #include "JSMessagingService.h"
  20 #include "MessagingListener.h"
  21 #include "ConverterMessage.h"
  22 #include "MessagingStorageMultiCallback.h"
  23 #include "MessageListenerManager.h"
  24 #include "ReqReceiverMessage.h"
  25 #include <SortMode.h>
  26
  27 #include <FilterConverter.h>
  28
  29 #include <CommonsJavaScript/Converter.h>
  30 #include <CommonsJavaScript/Validator.h>
  31 #include <CommonsJavaScript/JSUtils.h>
  32 #include <CommonsJavaScript/JSCallbackManager.h>
  33 #include <CommonsJavaScript/Utils.h>
  34 #include <CommonsJavaScript/JSDOMExceptionFactory.h>
  35 #include <CommonsJavaScript/SecurityExceptions.h>
  36
  37 #include <JSTizenExceptionFactory.h>
  38 #include <JSTizenException.h>
  39 #include <SecurityExceptions.h>
  40
  41 #include <JSWebAPIError.h>
  42 #include <ArgumentValidator.h>
  43 #include <JSUtil.h>
  44
  45 #include "MessagingErrorMsg.h"
  46 #include "MessageAsyncCallbackManager.h"
  47 #include "MessageFilterConverter.h"
  48 #include "plugin_config.h"
  49
  50
  51 using namespace std;
  52 using namespace DPL;
  53 using namespace WrtDeviceApis::Commons;
  54 using namespace WrtDeviceApis::CommonsJavaScript;
  55 using namespace DeviceAPI::Tizen;
  56 using namespace DeviceAPI::Common;
  57
  58
  59 namespace DeviceAPI {
  60 namespace Messaging {
  61
  62 JSClassRef JSMessagingStorage::m_jsClassRef = NULL;
  63
  64 JSClassDefinition JSMessagingStorage::m_classInfo =
  65 {
  66     0,
  67     kJSClassAttributeNone,
  68     "MessageStorage",
  69     NULL,
  70     NULL,
  71     m_function,
  72     initialize,
  73     finalize,
  74     NULL, //hasProperty,
  75     NULL, //getProperty,
  76     NULL, //setProperty,
  77     NULL, //deleteProperty,
  78     NULL, //getPropertyNames,
  79     NULL,
  80     NULL,
  81     hasInstance,
  82     NULL
  83 };
  84
  85 JSStaticFunction JSMessagingStorage::m_function[] =
  86 {
  87         { "addDraftMessage", JSMessagingStorage::addDraftMessage, kJSPropertyAttributeNone },
  88         { "findMessages", JSMessagingStorage::findMessages, kJSPropertyAttributeNone },
  89         { "removeMessages", JSMessagingStorage::removeMessages, kJSPropertyAttributeNone },
  90         { "updateMessages", JSMessagingStorage::updateMessages, kJSPropertyAttributeNone },
  91         { "findConversations", JSMessagingStorage::findConversations, kJSPropertyAttributeNone },
  92         { "removeConversations", JSMessagingStorage::removeConversations, kJSPropertyAttributeNone },
  93         { "findFolders", JSMessagingStorage::findFolders, kJSPropertyAttributeNone },
  94         { "addMessagesChangeListener", JSMessagingStorage::addMessagesChangeListener, kJSPropertyAttributeNone },
  95         { "addConversationsChangeListener", JSMessagingStorage::addConversationsChangeListener, kJSPropertyAttributeNone },
  96         { "addFoldersChangeListener", JSMessagingStorage::addFoldersChangeListener, kJSPropertyAttributeNone },
  97         { "removeChangeListener", JSMessagingStorage::removeChangeListener, kJSPropertyAttributeNone },
  98         { 0, 0, 0 }
  99 };
 100
 101 const JSClassRef JSMessagingStorage::getClassRef()
 102 {
 103     if (!m_jsClassRef)
 104     {
 105         m_jsClassRef = JSClassCreate(&m_classInfo);
 106     }
 107     return m_jsClassRef;
 108 }
 109
 110 void JSMessagingStorage::initialize(JSContextRef context, JSObjectRef object)
 111 {
 112     LogDebug("creation messaging instance");
 113 }
 114
 115 void JSMessagingStorage::finalize(JSObjectRef object)
 116 {
 117     LogDebug("enter");
 118
 119     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(object));
 120     if (priv)
 121     {
 122         LogDebug("deleting private object (messaging)");
 123         // for messaging object, private object is shared pointer, so will be deleted automatically
 124         delete priv;
 125         // object will be deleted, but used to show that private object is deleted
 126         JSObjectSetPrivate(object, NULL);
 127     }
 128 }
 129
 130 bool JSMessagingStorage::hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception)
 131 {
 132     return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 133 }
 134
 135 #if 0
 136     JSValueRef JSMessagingStorage::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 137     {
 138         LogDebug("<<< ");
 139         JSValueRef retVal = NULL;
 140
 141         Try
 142         {
 143             Converter convert(context);
 144             if (JSStringIsEqualToUTF8CString(propertyName, "FOLDER_INBOX"))
 145             {
 146                 LogDebug("FOLDER_INBOX" << ":" << "1");
 147                 retVal = convert.toJSValueRef(INBOX);
 148             }
 149             else if (JSStringIsEqualToUTF8CString(propertyName, "FOLDER_OUTBOX"))
 150             {
 151                 LogDebug("FOLDER_OUTBOX" << ":" << "2");
 152                 retVal = convert.toJSValueRef(OUTBOX);
 153             }
 154             else if (JSStringIsEqualToUTF8CString(propertyName, "FOLDER_DRAFTS"))
 155             {
 156                 LogDebug("FOLDER_DRAFTS" << ":" << "3");
 157                 retVal = convert.toJSValueRef(DRAFTBOX);
 158             }
 159             else if (JSStringIsEqualToUTF8CString(propertyName, "FOLDER_SENTBOX"))
 160             {
 161                 LogDebug("FOLDER_SENTBOX" << ":" << "4");
 162                 retVal = convert.toJSValueRef(SENTBOX);
 163             }
 164             else
 165             {
 166                 retVal = JSValueMakeUndefined(context);
 167             }
 168         }
 169         Catch (WrtDeviceApis::Commons::Exception)
 170         {
 171             LogError("Exception: " << _rethrown_exception.GetMessage());
 172             return JSTizenExceptionFactory::postException(context, exception,
 173                JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
 174         }
 175
 176         LogDebug(">>>");
 177         return retVal;
 178     }
 179 #endif
 180
 181 JSValueRef JSMessagingStorage::addDraftMessage(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 182         const JSValueRef arguments[], JSValueRef* exception)
 183 {
 184     LogDebug("Entered");
 185
 186     //check permission.
 187     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 188         MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE]);
 189     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 190
 191     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 192     if (!priv) {
 193         LogError("Private object is NULL.");
 194         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 195         return JSWebAPIError::throwException(context, exception, err);
 196     }
 197
 198     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 199     if (!objectPriv) {
 200         LogError("objectPriv is NULL.");
 201         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 202         return JSWebAPIError::throwException(context, exception, err);
 203     }
 204
 205     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 206     callbackManager = JSCallbackManager::createObject(priv->getContext());
 207     if (!callbackManager) {
 208         LogError("callbackManager is NULL.");
 209         DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
 210         return JSWebAPIError::throwException(context, exception, err);
 211     }
 212
 213     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 214
 215     try {
 216         ArgumentValidator validator(context, argumentCount, arguments);
 217
 218         // argu 1. Message ( mandatory )
 219         IMessagePtr msg = converter->toIMessage(validator.toObject(0));
 220
 221         // argu 2. Success callback (optional & nullable)
 222         callbackManager->setOnSuccess(validator.toFunction(1, true));
 223
 224         // argu 3. error callback (optional & nullable)
 225         callbackManager->setOnError(validator.toFunction(2, true));
 226
 227         callbackManager->setObject(thisObject);
 228
 229         EventAddDraftMessagePtr event(new EventAddDraftMessage());
 230
 231         FilterConverterFactory::ConverterType filterConverter = FilterConverterFactory::getConverter(context);
 232
 233         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 234             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 235         }
 236
 237         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 238             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 239         }
 240
 241         event->msg = msg;
 242         event->setIndex(objectPriv->getIndex());
 243         event->setType(objectPriv->getType());
 244         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData >(callbackManager));
 245         event->setForAsynchronousCall(&MessagingListener::getInstance());
 246
 247         ReqReceiverMessageSingleton::Instance().addDraftMessage(event);
 248         MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, priv->getContext());
 249     }
 250     catch(const BasePlatformException& err) {
 251         LogError(err.getMessage().c_str());
 252         return JSWebAPIError::throwException(context, exception, err);
 253     }
 254     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
 255         LogError(exc.GetMessage().c_str());
 256         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 257         return JSWebAPIError::throwException(context, exception, err);
 258     }
 259     catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
 260         LogError(exc.GetMessage().c_str());
 261         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 262         return JSWebAPIError::throwException(context, exception, err);
 263     }
 264     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
 265         LogError(exc.GetMessage().c_str());
 266         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
 267         return JSWebAPIError::throwException(context, exception, err);
 268     }
 269     catch (const WrtDeviceApis::Commons::Exception& exc) {
 270         LogError(exc.GetMessage().c_str());
 271         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
 272         return JSWebAPIError::throwException(context, exception, err);
 273     }
 274
 275     return JSValueMakeUndefined(context);
 276 }
 277
 278 JSValueRef JSMessagingStorage::findMessages(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 279         const JSValueRef arguments[], JSValueRef* exception)
 280 {
 281
 282     LogDebug("Entered");
 283
 284     //check permission.
 285     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 286         MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_MESSAGES]);
 287     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 288
 289     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 290     if (!priv) {
 291         LogError("Private object is NULL.");
 292         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 293         return JSWebAPIError::throwException(context, exception, err);
 294     }
 295
 296     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 297     if (!objectPriv) {
 298         LogError("objectPriv is NULL.");
 299         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 300         return JSWebAPIError::throwException(context, exception, err);
 301     }
 302
 303     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 304     callbackManager = JSCallbackManager::createObject(priv->getContext());
 305     if (!callbackManager) {
 306         LogError("callbackManager is NULL.");
 307         DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
 308         return JSWebAPIError::throwException(context, exception, err);
 309     }
 310
 311     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 312
 313     try {
 314         EventQueryMessagesPtr event(new EventQueryMessages());
 315
 316         MessageMessagesFilterConverterFactory::ConverterType filterConverter =
 317                 MessageMessagesFilterConverterFactory::getConverter(context);
 318
 319         ArgumentValidator validator(context, argumentCount, arguments);
 320
 321         // argu 1. filter ( mandatory )
 322         DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(0));
 323         if (!filter) {
 324             throw DeviceAPI::Common::TypeMismatchException("Invalid filter.");
 325         }
 326
 327         // argu 2. Success callback ( mandatory )
 328         callbackManager->setOnSuccess(validator.toFunction(1));
 329
 330         // argu 3. error callback (optional & nullable)
 331         callbackManager->setOnError(validator.toFunction(2, true));
 332
 333         callbackManager->setObject(thisObject);
 334
 335         // argu 4. Sorting mode (optional & nullable)
 336         JSValueRef param4 = validator.toJSValueRef(3, true);
 337         if ((argumentCount >= 4)
 338             && (!JSValueIsNull(context, param4))
 339             && (!JSValueIsUndefined(context, param4)))
 340         {
 341             DeviceAPI::Tizen::SortModePtr sortMode = filterConverter->toSortMode(param4);
 342             event->setSortMode(sortMode);
 343         }
 344
 345         // argu 5. limit (optional & nullable)
 346         long limit = validator.toULong(4, true, 0);
 347
 348         // argu 6. offset (optional & nullable)
 349         long offset = validator.toULong(5, true, 0);
 350
 351         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 352             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 353         }
 354
 355         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 356             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 357         }
 358
 359         event->setFilter(filter);
 360         event->setLimit(limit);
 361         event->setOffset(offset);
 362         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData >(callbackManager));
 363         event->setForAsynchronousCall(&MessagingListener::getInstance());
 364         event->setIndex(objectPriv->getIndex());
 365         event->setType(objectPriv->getType());
 366
 367         ReqReceiverMessageSingleton::Instance().queryMessages(event);
 368         MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, priv->getContext());
 369     }
 370     catch(const BasePlatformException& err) {
 371         LogError(err.getMessage().c_str());
 372         return JSWebAPIError::throwException(context, exception, err);
 373     }
 374     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
 375         LogError(exc.GetMessage().c_str());
 376         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 377         return JSWebAPIError::throwException(context, exception, err);
 378     }
 379     catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
 380         LogError(exc.GetMessage().c_str());
 381         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 382         return JSWebAPIError::throwException(context, exception, err);
 383     }
 384     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
 385         LogError(exc.GetMessage().c_str());
 386         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
 387         return JSWebAPIError::throwException(context, exception, err);
 388     }
 389     catch (const WrtDeviceApis::Commons::Exception& exc) {
 390         LogError(exc.GetMessage().c_str());
 391         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
 392         return JSWebAPIError::throwException(context, exception, err);
 393     }
 394
 395     return JSValueMakeUndefined(context);
 396 }
 397
 398 JSValueRef JSMessagingStorage::removeMessages(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 399         const JSValueRef arguments[], JSValueRef* exception)
 400 {
 401     LogDebug("Entered");
 402
 403     //check permission.
 404     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 405         MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_MESSAGES]);
 406     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 407
 408     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 409     if (!priv) {
 410         LogError("Private object is NULL.");
 411         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 412         return JSWebAPIError::throwException(context, exception, err);
 413     }
 414
 415     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 416     if (!objectPriv) {
 417         LogError("objectPriv is NULL.");
 418         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 419         return JSWebAPIError::throwException(context, exception, err);
 420     }
 421
 422     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 423     callbackManager = JSCallbackManager::createObject(priv->getContext());
 424     if (!callbackManager) {
 425         LogError("callbackManager is NULL.");
 426         DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
 427         return JSWebAPIError::throwException(context, exception, err);
 428     }
 429
 430     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 431
 432     try {
 433         EventDeleteMessagesPtr event(new EventDeleteMessages());
 434
 435         FilterConverterFactory::ConverterType filterConverter = FilterConverterFactory::getConverter(context);
 436
 437         ArgumentValidator validator(context, argumentCount, arguments);
 438
 439         // argu 1. Messages ( mandatory )
 440         std::vector<JSValueRef> jsMsgsArray = validator.toJSValueRefVector(0);
 441         std::vector<IMessagePtr> msgs;
 442         for (std::vector<JSValueRef>::iterator it = jsMsgsArray.begin() ; it != jsMsgsArray.end(); ++it)
 443         {
 444             IMessagePtr msg = converter->toIMessage(*it);
 445             msgs.push_back(msg);
 446         }
 447
 448         // argu 2. Success callback (optional & nullable)
 449         callbackManager->setOnSuccess(validator.toFunction(1,true));
 450
 451         // argu 3. error callback (optional & nullable)
 452         callbackManager->setOnError(validator.toFunction(2, true));
 453
 454         callbackManager->setObject(thisObject);
 455
 456         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 457             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 458         }
 459
 460         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 461             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 462         }
 463
 464         event->msgArray = msgs;
 465
 466         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData >(callbackManager));
 467         event->setForAsynchronousCall(&MessagingListener::getInstance());
 468         event->setIndex(objectPriv->getIndex());
 469         event->setType(objectPriv->getType());
 470
 471         ReqReceiverMessageSingleton::Instance().deleteMessages(event);
 472         MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, priv->getContext());
 473     }
 474     catch(const BasePlatformException& err) {
 475         LogError(err.getMessage().c_str());
 476         return JSWebAPIError::throwException(context, exception, err);
 477     }
 478     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
 479         LogError(exc.GetMessage().c_str());
 480         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 481         return JSWebAPIError::throwException(context, exception, err);
 482     }
 483     catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
 484         LogError(exc.GetMessage().c_str());
 485         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 486         return JSWebAPIError::throwException(context, exception, err);
 487     }
 488     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
 489         LogError(exc.GetMessage().c_str());
 490         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
 491         return JSWebAPIError::throwException(context, exception, err);
 492     }
 493     catch (const WrtDeviceApis::Commons::Exception& exc) {
 494         LogError(exc.GetMessage().c_str());
 495         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
 496         return JSWebAPIError::throwException(context, exception, err);
 497     }
 498
 499     return JSValueMakeUndefined(context);
 500 }
 501
 502 JSValueRef JSMessagingStorage::updateMessages(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 503         const JSValueRef arguments[], JSValueRef* exception)
 504 {
 505
 506     LogDebug("Entered");
 507
 508     //check permission.
 509     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 510         MessagingExportedNames[MESSAGING_FUNCTION_API_UPDATE_MESSAGES]);
 511     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 512
 513     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 514     if (!priv) {
 515         LogError("Private object is NULL.");
 516         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 517         return JSWebAPIError::throwException(context, exception, err);
 518     }
 519
 520     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 521     if (!objectPriv) {
 522         LogError("objectPriv is NULL.");
 523         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 524         return JSWebAPIError::throwException(context, exception, err);
 525     }
 526
 527     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 528     callbackManager = JSCallbackManager::createObject(priv->getContext());
 529     if (!callbackManager) {
 530         LogError("callbackManager is NULL.");
 531         DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
 532         return JSWebAPIError::throwException(context, exception, err);
 533     }
 534
 535     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 536
 537     try {
 538         EventUpdateMessagesPtr event(new EventUpdateMessages());
 539
 540         FilterConverterFactory::ConverterType filterConverter = FilterConverterFactory::getConverter(context);
 541
 542         ArgumentValidator validator(context, argumentCount, arguments);
 543
 544         // argu 1. Messages ( mandatory )
 545         std::vector<JSValueRef> jsMsgsArray = validator.toJSValueRefVector(0);
 546         std::vector<IMessagePtr> msgs;
 547         for (std::vector<JSValueRef>::iterator it = jsMsgsArray.begin() ; it != jsMsgsArray.end(); ++it)
 548         {
 549             IMessagePtr msg = converter->toIMessage(*it);
 550             msgs.push_back(msg);
 551         }
 552
 553         // argu 2. Success callback (optional & nullable)
 554         callbackManager->setOnSuccess(validator.toFunction(1,true));
 555
 556         // argu 3. error callback (optional & nullable)
 557         callbackManager->setOnError(validator.toFunction(2, true));
 558
 559         callbackManager->setObject(thisObject);
 560
 561         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 562             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 563         }
 564
 565         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 566             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 567         }
 568
 569         event->msgArray = msgs;
 570         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData >(callbackManager));
 571         event->setForAsynchronousCall(&MessagingListener::getInstance());
 572
 573         event->setIndex(objectPriv->getIndex());
 574         event->setType(objectPriv->getType());
 575
 576         ReqReceiverMessageSingleton::Instance().updateMessages(event);
 577         MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, priv->getContext());
 578
 579     }
 580     catch(const BasePlatformException& err) {
 581         LogError(err.getMessage().c_str());
 582         return JSWebAPIError::throwException(context, exception, err);
 583     }
 584     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
 585         LogError(exc.GetMessage().c_str());
 586         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 587         return JSWebAPIError::throwException(context, exception, err);
 588     }
 589     catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
 590         LogError(exc.GetMessage().c_str());
 591         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 592         return JSWebAPIError::throwException(context, exception, err);
 593     }
 594     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
 595         LogError(exc.GetMessage().c_str());
 596         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
 597         return JSWebAPIError::throwException(context, exception, err);
 598     }
 599     catch (const WrtDeviceApis::Commons::Exception& exc) {
 600         LogError(exc.GetMessage().c_str());
 601         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
 602         return JSWebAPIError::throwException(context, exception, err);
 603     }
 604
 605     return JSValueMakeUndefined(context);
 606 }
 607
 608 JSValueRef JSMessagingStorage::findConversations(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 609         const JSValueRef arguments[], JSValueRef* exception)
 610 {
 611     LogDebug("Entered");
 612
 613     //check permission.
 614     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 615         MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_CONVERSATIONS]);
 616     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 617
 618     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 619     if (!priv) {
 620         LogError("Private object is NULL.");
 621         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 622         return JSWebAPIError::throwException(context, exception, err);
 623     }
 624
 625     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 626     if (!objectPriv) {
 627         LogError("objectPriv is NULL.");
 628         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 629         return JSWebAPIError::throwException(context, exception, err);
 630     }
 631
 632     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 633     callbackManager = JSCallbackManager::createObject(priv->getContext());
 634     if (!callbackManager) {
 635         LogError("callbackManager is NULL.");
 636         DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
 637         return JSWebAPIError::throwException(context, exception, err);
 638     }
 639
 640     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 641
 642     try {
 643         EventQueryConversationsPtr event(new EventQueryConversations());
 644
 645         MessageConversationsFilterConverterFactory::ConverterType filterConverter =
 646                 MessageConversationsFilterConverterFactory::getConverter(context);
 647
 648         ArgumentValidator validator(context, argumentCount, arguments);
 649
 650         // argu 1. filter ( mandatory )
 651         DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(0));
 652         if (!filter) {
 653             throw DeviceAPI::Common::TypeMismatchException("Invalid filter.");
 654         }
 655
 656         // argu 2. Success callback ( mandatory )
 657         callbackManager->setOnSuccess(validator.toFunction(1));
 658
 659         // argu 3. error callback (optional & nullable)
 660         callbackManager->setOnError(validator.toFunction(2, true));
 661
 662         callbackManager->setObject(thisObject);
 663
 664         // argu 4. Sorting mode (optional & nullable)
 665         JSValueRef param4 = validator.toJSValueRef(3, true);
 666         if ((argumentCount >= 4)
 667             && (!JSValueIsNull(context, param4))
 668             && (!JSValueIsUndefined(context, param4)))
 669         {
 670             DeviceAPI::Tizen::SortModePtr sortMode = filterConverter->toSortMode(param4);
 671             event->setSortMode(sortMode);
 672         }
 673
 674         // argu 5. limit (optional & nullable)
 675         long limit = validator.toULong(4, true, 0);
 676
 677         // argu 6. offset (optional & nullable)
 678         long offset = validator.toULong(5, true, 0);
 679
 680         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 681             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 682         }
 683
 684         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 685             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 686         }
 687
 688         event->setFilter(filter);
 689         event->setLimit(limit);
 690         event->setOffset(offset);
 691         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData >(callbackManager));
 692         event->setForAsynchronousCall(&MessagingListener::getInstance());
 693         event->setIndex(objectPriv->getIndex());
 694         event->setType(objectPriv->getType());
 695
 696         ReqReceiverMessageSingleton::Instance().queryConversations(event);
 697         MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, priv->getContext());
 698     }
 699     catch(const BasePlatformException& err) {
 700         LogError(err.getMessage().c_str());
 701         return JSWebAPIError::throwException(context, exception, err);
 702     }
 703     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
 704         LogError(exc.GetMessage().c_str());
 705         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 706         return JSWebAPIError::throwException(context, exception, err);
 707     }
 708     catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
 709         LogError(exc.GetMessage().c_str());
 710         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 711         return JSWebAPIError::throwException(context, exception, err);
 712     }
 713     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
 714         LogError(exc.GetMessage().c_str());
 715         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
 716         return JSWebAPIError::throwException(context, exception, err);
 717     }
 718     catch (const WrtDeviceApis::Commons::Exception& exc) {
 719         LogError(exc.GetMessage().c_str());
 720         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
 721         return JSWebAPIError::throwException(context, exception, err);
 722     }
 723
 724     return JSValueMakeUndefined(context);
 725 }
 726
 727 JSValueRef JSMessagingStorage::removeConversations(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 728         const JSValueRef arguments[], JSValueRef* exception)
 729 {
 730     LogDebug("Entered");
 731
 732     //check permission.
 733     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 734             MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS]);
 735     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 736
 737     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 738     if (!priv) {
 739         LogError("Private object is NULL.");
 740         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 741         return JSWebAPIError::throwException(context, exception, err);
 742     }
 743
 744     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 745     if (!objectPriv) {
 746         LogError("objectPriv is NULL.");
 747         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 748         return JSWebAPIError::throwException(context, exception, err);
 749     }
 750
 751     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 752     callbackManager = JSCallbackManager::createObject(priv->getContext());
 753     if (!callbackManager) {
 754         LogError("callbackManager is NULL.");
 755         DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
 756         return JSWebAPIError::throwException(context, exception, err);
 757     }
 758
 759     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 760
 761     try {
 762         EventDeleteConversationsPtr event(new EventDeleteConversations());
 763
 764         FilterConverterFactory::ConverterType filterConverter = FilterConverterFactory::getConverter(context);
 765
 766         ArgumentValidator validator(context, argumentCount, arguments);
 767
 768         // argu 1. Messages ( mandatory )
 769         std::vector<JSValueRef> jsConvsArray = validator.toJSValueRefVector(0);
 770         std::vector<IConversationPtr> deleteConversationArray;
 771         for (std::vector<JSValueRef>::iterator it = jsConvsArray.begin() ; it != jsConvsArray.end(); ++it)
 772         {
 773             IConversationPtr conv = converter->toConversation(*it);
 774             deleteConversationArray.push_back(conv);
 775         }
 776
 777         // argu 2. Success callback (optional & nullable)
 778         callbackManager->setOnSuccess(validator.toFunction(1,true));
 779
 780         // argu 3. error callback (optional & nullable)
 781         callbackManager->setOnError(validator.toFunction(2, true));
 782
 783         callbackManager->setObject(thisObject);
 784
 785         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 786             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 787         }
 788
 789         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 790             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 791         }
 792
 793         event->setConversations(deleteConversationArray);
 794         event->setFilterUsing(false);
 795
 796         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData >(callbackManager));
 797         event->setForAsynchronousCall(&MessagingListener::getInstance());
 798         event->setIndex(objectPriv->getIndex());
 799         event->setType(objectPriv->getType());
 800
 801         ReqReceiverMessageSingleton::Instance().deleteConversations(event);
 802         MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, priv->getContext());
 803     }
 804     catch(const BasePlatformException& err) {
 805         LogError(err.getMessage().c_str());
 806         return JSWebAPIError::throwException(context, exception, err);
 807     }
 808     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
 809         LogError(exc.GetMessage().c_str());
 810         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 811         return JSWebAPIError::throwException(context, exception, err);
 812     }
 813     catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
 814         LogError(exc.GetMessage().c_str());
 815         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 816         return JSWebAPIError::throwException(context, exception, err);
 817     }
 818     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
 819         LogError(exc.GetMessage().c_str());
 820         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
 821         return JSWebAPIError::throwException(context, exception, err);
 822     }
 823     catch (const WrtDeviceApis::Commons::Exception& exc) {
 824         LogError(exc.GetMessage().c_str());
 825         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
 826         return JSWebAPIError::throwException(context, exception, err);
 827     }
 828
 829     return JSValueMakeUndefined(context);
 830 }
 831
 832 JSValueRef JSMessagingStorage::findFolders(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 833         const JSValueRef arguments[], JSValueRef* exception)
 834 {
 835     LogDebug("Entered");
 836
 837     //check permission.
 838     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 839         MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_FOLDERS]);
 840     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 841
 842     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 843     if (!priv) {
 844         LogError("Private object is NULL.");
 845         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 846         return JSWebAPIError::throwException(context, exception, err);
 847     }
 848
 849     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 850     if (!objectPriv) {
 851         LogError("objectPriv is NULL.");
 852         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 853         return JSWebAPIError::throwException(context, exception, err);
 854     }
 855
 856     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 857     callbackManager = JSCallbackManager::createObject(priv->getContext());
 858     if (!callbackManager) {
 859         LogError("callbackManager is NULL.");
 860         DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
 861         return JSWebAPIError::throwException(context, exception, err);
 862     }
 863
 864     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 865
 866     try {
 867         EventQueryFoldersPtr event(new EventQueryFolders());
 868
 869         MessageFoldersFilterConverterFactory::ConverterType filterConverter =
 870                 MessageFoldersFilterConverterFactory::getConverter(context);
 871
 872         ArgumentValidator validator(context, argumentCount, arguments);
 873
 874         // argu 1. filter ( mandatory )
 875         DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(0));
 876         if (!filter) {
 877             throw DeviceAPI::Common::TypeMismatchException("Invalid filter.");
 878         }
 879
 880         // argu 2. Success callback ( mandatory )
 881         callbackManager->setOnSuccess(validator.toFunction(1));
 882
 883         // argu 3. error callback (optional & nullable)
 884         callbackManager->setOnError(validator.toFunction(2, true));
 885
 886         callbackManager->setObject(thisObject);
 887
 888         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 889             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 890         }
 891
 892         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 893             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 894         }
 895
 896         event->setFilter(filter);
 897         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData >(callbackManager));
 898         event->setForAsynchronousCall(&MessagingListener::getInstance());
 899         event->setIndex(objectPriv->getIndex());
 900         event->setType(objectPriv->getType());
 901
 902         ReqReceiverMessageSingleton::Instance().queryFolders(event);
 903         MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, priv->getContext());
 904     }
 905     catch(const BasePlatformException& err) {
 906         LogError(err.getMessage().c_str());
 907         return JSWebAPIError::throwException(context, exception, err);
 908     }
 909     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
 910         LogError(exc.GetMessage().c_str());
 911         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 912         return JSWebAPIError::throwException(context, exception, err);
 913     }
 914     catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
 915         LogError(exc.GetMessage().c_str());
 916         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
 917         return JSWebAPIError::throwException(context, exception, err);
 918     }
 919     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
 920         LogError(exc.GetMessage().c_str());
 921         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
 922         return JSWebAPIError::throwException(context, exception, err);
 923     }
 924     catch (const WrtDeviceApis::Commons::Exception& exc) {
 925         LogError(exc.GetMessage().c_str());
 926         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
 927         return JSWebAPIError::throwException(context, exception, err);
 928     }
 929
 930     return JSValueMakeUndefined(context);
 931 }
 932
 933 JSValueRef JSMessagingStorage::addMessagesChangeListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 934         const JSValueRef arguments[], JSValueRef* exception)
 935 {
 936
 937     LogDebug("Entered");
 938
 939     //check permission.
 940     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 941         MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER]);
 942     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 943
 944     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
 945     if (!priv) {
 946         LogError("Private object is NULL.");
 947         DeviceAPI::Common::UnknownException err("Private object is NULL.");
 948         return JSWebAPIError::throwException(context, exception, err);
 949     }
 950
 951     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
 952     if (!objectPriv) {
 953         LogError("objectPriv is NULL.");
 954         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
 955         return JSWebAPIError::throwException(context, exception, err);
 956     }
 957
 958     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
 959     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr messagesUpdatedCbm(NULL);
 960     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr messagesRemovedCbm(NULL);
 961
 962     callbackManager = JSCallbackManager::createObject(priv->getContext());
 963
 964     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 965
 966     try {
 967         MessageMessagesChangeFilterConverterFactory::ConverterType filterConverter =
 968                 MessageMessagesChangeFilterConverterFactory::getConverter(context);
 969
 970         JSValueRef onSuccessForCbm = NULL;
 971
 972         OnMessagesChanged functionResult;
 973         int funtionIndex = -1;
 974
 975         ArgumentValidator validator(context, argumentCount, arguments);
 976
 977         // argu 1. Messages Change Callback ( mandatory )
 978         functionResult = converter->toMessageMultifunctions(validator.toJSValueRef(0));
 979         funtionIndex = functionResult.functionIndex;
 980         if(funtionIndex < 0)
 981         {
 982             throw DeviceAPI::Common::TypeMismatchException("funtionIndex is not valid.");
 983         }
 984
 985         onSuccessForCbm = functionResult.messagesAdded;
 986         messagesUpdatedCbm = JSCallbackManager::createObject(priv->getContext(), functionResult.messagesUpdated, NULL);
 987         messagesRemovedCbm = JSCallbackManager::createObject(priv->getContext(), functionResult.messagesRemoved, NULL);
 988
 989         EventOnMessagingStorageChangesPrivateDataPtr privData(
 990             new EventOnMessagingStorageChangesPrivateData(callbackManager, messagesUpdatedCbm, messagesRemovedCbm, funtionIndex));
 991
 992         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
 993             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
 994         }
 995
 996         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
 997             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
 998         }
 999
1000         // argu 2. filter ( optional )
1001         DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(1));
1002         if (filter) {
1003             DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(1));
1004             privData->setFilter(filter);
1005         }
1006
1007         if(callbackManager)
1008         {
1009             callbackManager->setOnSuccess(onSuccessForCbm);
1010         }
1011
1012         privData->setIndex(objectPriv->getIndex());
1013         privData->setType(objectPriv->getType());
1014
1015         MessagingListener::getInstance().registerMessageReceivedEmitter(privData);
1016
1017         // add to map and return index
1018         long id = MessagingListener::getInstance().addIncomingMsgCallback(callbackManager, funtionIndex);
1019         MessageListenerCancellerPtr canceller = MessageListenerCancellerPtr(new MessageListenerCanceller(priv->getContext(), thisObject, id));
1020         IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
1021         MessageListenerManagerSingleton::Instance().registerListener(listenerItem, priv->getContext());
1022
1023         return JSValueMakeNumber(context, id);
1024     }
1025     catch(const BasePlatformException& err) {
1026         LogError(err.getMessage().c_str());
1027         return JSWebAPIError::throwException(context, exception, err);
1028     }
1029     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
1030         LogError(exc.GetMessage().c_str());
1031         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
1032         return JSWebAPIError::throwException(context, exception, err);
1033     }
1034     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
1035         LogError(exc.GetMessage().c_str());
1036         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1037         return JSWebAPIError::throwException(context, exception, err);
1038     }
1039     catch (const WrtDeviceApis::Commons::UnsupportedException& exc) {
1040         LogError(exc.GetMessage().c_str());
1041         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1042         return JSWebAPIError::throwException(context, exception, err);
1043     }
1044     catch (const WrtDeviceApis::Commons::AlreadyInUseException& exc) {
1045         LogError(exc.GetMessage().c_str());
1046         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1047         return JSWebAPIError::throwException(context, exception, err);
1048     }
1049     catch (const WrtDeviceApis::Commons::Exception& exc) {
1050         LogError(exc.GetMessage().c_str());
1051         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
1052         return JSWebAPIError::throwException(context, exception, err);
1053     }
1054 }
1055
1056 JSValueRef JSMessagingStorage::addConversationsChangeListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
1057         const JSValueRef arguments[], JSValueRef* exception)
1058 {
1059     LogDebug("Entered");
1060
1061     //check permission.
1062     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
1063         MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER]);
1064     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
1065
1066     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
1067     if (!priv) {
1068         LogError("Private object is NULL.");
1069         DeviceAPI::Common::UnknownException err("Private object is NULL.");
1070         return JSWebAPIError::throwException(context, exception, err);
1071     }
1072
1073     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
1074     if (!objectPriv) {
1075         LogError("objectPriv is NULL.");
1076         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
1077         return JSWebAPIError::throwException(context, exception, err);
1078     }
1079
1080     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
1081     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr messagesUpdatedCbm(NULL);
1082     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr messagesRemovedCbm(NULL);
1083
1084     callbackManager = JSCallbackManager::createObject(priv->getContext());
1085
1086     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
1087
1088     try {
1089         MessageConversationsFilterConverterFactory::ConverterType filterConverter =
1090                 MessageConversationsFilterConverterFactory::getConverter(context);
1091
1092         JSValueRef onSuccessForCbm = NULL;
1093
1094         OnMessagesChanged functionResult;
1095         int funtionIndex = -1;
1096
1097         ArgumentValidator validator(context, argumentCount, arguments);
1098
1099         // argu 1. Messages Change Callback ( mandatory )
1100         functionResult = converter->toMessageMultifunctions(validator.toJSValueRef(0));
1101         funtionIndex = functionResult.functionIndex;
1102         if(funtionIndex < 0)
1103         {
1104             throw DeviceAPI::Common::TypeMismatchException("funtionIndex is not valid.");
1105         }
1106
1107         onSuccessForCbm = functionResult.messagesAdded;
1108         messagesUpdatedCbm = JSCallbackManager::createObject(priv->getContext(), functionResult.messagesUpdated, NULL);
1109         messagesRemovedCbm = JSCallbackManager::createObject(priv->getContext(), functionResult.messagesRemoved, NULL);
1110
1111         EventOnMessagingStorageChangesPrivateDataPtr privData(
1112             new EventOnMessagingStorageChangesPrivateData(callbackManager, messagesUpdatedCbm, messagesRemovedCbm, funtionIndex));
1113
1114         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
1115             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
1116         }
1117
1118         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
1119             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
1120         }
1121
1122         // argu 2. filter ( optional )
1123         DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(1));
1124         if (filter) {
1125             DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(1));
1126             privData->setFilter(filter);
1127         }
1128
1129         if(callbackManager)
1130         {
1131             callbackManager->setOnSuccess(onSuccessForCbm);
1132         }
1133
1134         privData->setIndex(objectPriv->getIndex());
1135         privData->setType(objectPriv->getType());
1136
1137         MessagingListener::getInstance().registerMessageReceivedEmitter(privData);
1138
1139         long id = MessagingListener::getInstance().addIncomingMsgCallback(callbackManager, funtionIndex);
1140         MessageListenerCancellerPtr canceller = MessageListenerCancellerPtr(new MessageListenerCanceller(priv->getContext(), thisObject, id));
1141         IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
1142         MessageListenerManagerSingleton::Instance().registerListener(listenerItem, priv->getContext());
1143
1144         // add to map and return index
1145         return JSValueMakeNumber(context, id);
1146
1147     }
1148     catch(const BasePlatformException& err) {
1149         LogError(err.getMessage().c_str());
1150         return JSWebAPIError::throwException(context, exception, err);
1151     }
1152     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
1153         LogError(exc.GetMessage().c_str());
1154         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
1155         return JSWebAPIError::throwException(context, exception, err);
1156     }
1157     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
1158         LogError(exc.GetMessage().c_str());
1159         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1160         return JSWebAPIError::throwException(context, exception, err);
1161     }
1162     catch (const WrtDeviceApis::Commons::UnsupportedException& exc) {
1163         LogError(exc.GetMessage().c_str());
1164         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1165         return JSWebAPIError::throwException(context, exception, err);
1166     }
1167     catch (const WrtDeviceApis::Commons::AlreadyInUseException& exc) {
1168         LogError(exc.GetMessage().c_str());
1169         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1170         return JSWebAPIError::throwException(context, exception, err);
1171     }
1172     catch (const WrtDeviceApis::Commons::Exception& exc) {
1173         LogError(exc.GetMessage().c_str());
1174         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
1175         return JSWebAPIError::throwException(context, exception, err);
1176     }
1177 }
1178
1179
1180 JSValueRef JSMessagingStorage::addFoldersChangeListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
1181         const JSValueRef arguments[], JSValueRef* exception)
1182 {
1183     LogDebug("Entered");
1184
1185     //check permission.
1186     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
1187         MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER]);
1188     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
1189
1190     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
1191     if (!priv) {
1192         LogError("Private object is NULL.");
1193         DeviceAPI::Common::UnknownException err("Private object is NULL.");
1194         return JSWebAPIError::throwException(context, exception, err);
1195     }
1196
1197     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
1198     if (!objectPriv) {
1199         LogError("objectPriv is NULL.");
1200         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
1201         return JSWebAPIError::throwException(context, exception, err);
1202     }
1203
1204     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
1205     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr messagesUpdatedCbm(NULL);
1206     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr messagesRemovedCbm(NULL);
1207
1208     callbackManager = JSCallbackManager::createObject(priv->getContext());
1209
1210     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
1211
1212     try {
1213         MessageFoldersChangeFilterConverterFactory::ConverterType filterConverter =
1214                 MessageFoldersChangeFilterConverterFactory::getConverter(context);
1215         JSValueRef onSuccessForCbm = NULL;
1216
1217         OnMessagesChanged functionResult;
1218         int funtionIndex = -1;
1219
1220         ArgumentValidator validator(context, argumentCount, arguments);
1221
1222         // argu 1. Messages Change Callback ( mandatory )
1223         functionResult = converter->toMessageMultifunctions(validator.toJSValueRef(0));
1224         funtionIndex = functionResult.functionIndex;
1225         if(funtionIndex < 0)
1226         {
1227             throw DeviceAPI::Common::TypeMismatchException("funtionIndex is not valid.");
1228         }
1229
1230         onSuccessForCbm = functionResult.messagesAdded;
1231         messagesUpdatedCbm = JSCallbackManager::createObject(priv->getContext(), functionResult.messagesUpdated, NULL);
1232         messagesRemovedCbm = JSCallbackManager::createObject(priv->getContext(), functionResult.messagesRemoved, NULL);
1233
1234         EventOnMessagingStorageChangesPrivateDataPtr privData(
1235             new EventOnMessagingStorageChangesPrivateData(callbackManager, messagesUpdatedCbm, messagesRemovedCbm, funtionIndex));
1236
1237         if ((objectPriv->getType() < SMS) || (objectPriv->getType() > EMAIL)) {
1238             throw DeviceAPI::Common::TypeMismatchException("Message type is not SMS or MMS or EMAIL.");
1239         }
1240
1241         if ((objectPriv->getType() == EMAIL) && (objectPriv->getIndex() < 1)) {
1242             throw DeviceAPI::Common::TypeMismatchException("serviceId is not defined.");
1243         }
1244
1245         // argu 2. filter ( optional )
1246         DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(1));
1247         if (filter) {
1248             DeviceAPI::Tizen::FilterPtr filter = filterConverter->toFilter(validator.toJSValueRef(1));
1249             privData->setFilter(filter);
1250         }
1251
1252         if(callbackManager)
1253         {
1254             callbackManager->setOnSuccess(onSuccessForCbm);
1255         }
1256
1257         privData->setIndex(objectPriv->getIndex());
1258         privData->setType(objectPriv->getType());
1259
1260         MessagingListener::getInstance().registerMessageReceivedEmitter(privData);
1261
1262         long id = MessagingListener::getInstance().addIncomingMsgCallback(callbackManager, funtionIndex);
1263         MessageListenerCancellerPtr canceller = MessageListenerCancellerPtr(new MessageListenerCanceller(priv->getContext(), thisObject, id));
1264         IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
1265         MessageListenerManagerSingleton::Instance().registerListener(listenerItem, priv->getContext());
1266
1267         // add to map and return index
1268         return JSValueMakeNumber(context, id);
1269     }
1270     catch(const BasePlatformException& err) {
1271         LogError(err.getMessage().c_str());
1272         return JSWebAPIError::throwException(context, exception, err);
1273     }
1274     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
1275         LogError(exc.GetMessage().c_str());
1276         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
1277         return JSWebAPIError::throwException(context, exception, err);
1278     }
1279     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
1280         LogError(exc.GetMessage().c_str());
1281         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1282         return JSWebAPIError::throwException(context, exception, err);
1283     }
1284     catch (const WrtDeviceApis::Commons::UnsupportedException& exc) {
1285         LogError(exc.GetMessage().c_str());
1286         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1287         return JSWebAPIError::throwException(context, exception, err);
1288     }
1289     catch (const WrtDeviceApis::Commons::AlreadyInUseException& exc) {
1290         LogError(exc.GetMessage().c_str());
1291         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1292         return JSWebAPIError::throwException(context, exception, err);
1293     }
1294     catch (const WrtDeviceApis::Commons::Exception& exc) {
1295         LogError(exc.GetMessage().c_str());
1296         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
1297         return JSWebAPIError::throwException(context, exception, err);
1298     }
1299 }
1300
1301 JSValueRef JSMessagingStorage::removeChangeListener(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount,
1302         const JSValueRef arguments[], JSValueRef* exception)
1303 {
1304     LogDebug("Entered");
1305
1306     //check permission.
1307     AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
1308         MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER]);
1309     TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
1310
1311     MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
1312     if (!priv) {
1313         LogError("Private object is NULL.");
1314         DeviceAPI::Common::UnknownException err("Private object is NULL.");
1315         return JSWebAPIError::throwException(context, exception, err);
1316     }
1317
1318     MessagingStoragePrivObjPtr objectPriv = priv->getObject();
1319     if (!objectPriv) {
1320         LogError("objectPriv is NULL.");
1321         DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
1322         return JSWebAPIError::throwException(context, exception, err);
1323     }
1324
1325     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
1326     callbackManager = JSCallbackManager::createObject(priv->getContext());
1327
1328     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
1329
1330     try {
1331         ArgumentValidator validator(context, argumentCount, arguments);
1332
1333         // argu 1. watchId ( mandatory )
1334         long handler = validator.toLong(0);
1335
1336         MessagingListener::getInstance().removeIncomingMsgCallback(handler, objectPriv->getType(), objectPriv->getIndex());
1337
1338         MessageListenerCancellerPtr canceller = MessageListenerCancellerPtr(new MessageListenerCanceller(priv->getContext(), thisObject, objectPriv->getIndex()));
1339         IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
1340         MessageListenerManagerSingleton::Instance().unregisterListener(listenerItem);
1341     }
1342     catch(const BasePlatformException& err) {
1343         LogError(err.getMessage().c_str());
1344         return JSWebAPIError::throwException(context, exception, err);
1345     }
1346     catch (const WrtDeviceApis::Commons::ConversionException& exc) {
1347         LogError(exc.GetMessage().c_str());
1348         DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
1349         return JSWebAPIError::throwException(context, exception, err);
1350     }
1351     catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
1352         LogError(exc.GetMessage().c_str());
1353         DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
1354         return JSWebAPIError::throwException(context, exception, err);
1355     }
1356     catch (const WrtDeviceApis::Commons::Exception& exc) {
1357         LogError(exc.GetMessage().c_str());
1358         DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
1359         return JSWebAPIError::throwException(context, exception, err);
1360     }
1361
1362     return JSValueMakeUndefined(context);
1363 }
1364
1365 }
1366 }