src/standards/Tizen/Messaging/JSMessagingService.cpp

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18 /*
  19  * @file        JSPluginTemplete.cpp
  20  * @author      Jaehyun Park (jaehyun77.park@samsung.com)
  21  * @version     0.1
  22  * @brief       Implementation of the JSPluginTemplete class
  23  */
  24
  25 #include "JSMessagingService.h"
  26 #include "MessagingController.h"
  27 #include <CommonsJavaScript/Converter.h>
  28 #include <CommonsJavaScript/Validator.h>
  29 #include <CommonsJavaScript/JSUtils.h>
  30 #include <CommonsJavaScript/JSCallbackManager.h>
  31 #include <CommonsJavaScript/Utils.h>
  32 #include <CommonsJavaScript/ScopedJSStringRef.h>
  33 #include <Commons/StringUtils.h>
  34
  35 #include <API/Messaging/ReqReceiverMessage.h>
  36 #include <Tizen/Common/JSTizenExceptionFactory.h>
  37 #include <Tizen/Common/JSTizenException.h>
  38 #include <Tizen/Common/SecurityExceptions.h>
  39
  40 #include "MessagingErrorMsg.h"
  41 #include "ConverterMessage.h"
  42 #include "JSMessagingListener.h"
  43 #include "JSMessagingStorage.h"
  44 #include "JSMessage.h"
  45 #include "EventSendMessagePrivateData.h"        //for send message
  46 #include "EventMessagingServicePrivateData.h"
  47 #include "plugin_config.h"
  48
  49 using namespace std;
  50 using namespace DPL;
  51 using namespace WrtDeviceApis;
  52 using namespace WrtDeviceApis::Commons;
  53 using namespace WrtDeviceApis::CommonsJavaScript;
  54 using namespace TizenApis::Api::Messaging;
  55 using namespace TizenApis::Commons;
  56
  57 namespace TizenApis {
  58 namespace Tizen1_0 {
  59
  60         JSClassRef JSMessagingService::m_jsClassRef = NULL;
  61         JSClassDefinition JSMessagingService::m_classInfo = {
  62                 0,
  63                 kJSClassAttributeNone,
  64                 "MessageService",
  65                 NULL,
  66                 m_property,
  67                 m_function,
  68                 initialize,
  69                 finalize,
  70                 NULL, //hasProperty,
  71                 NULL, //getProperty,
  72                 NULL, //setProperty,
  73                 NULL, //deleteProperty,Geolocation
  74                 NULL, //getPropertyNames,
  75                 NULL,
  76                 NULL,
  77                 hasInstance,
  78                 NULL
  79         };
  80
  81         JSStaticValue JSMessagingService::m_property[] =
  82         {
  83             {"id",                      getProperty, NULL, kJSPropertyAttributeReadOnly},
  84             {"type",                            getProperty, NULL, kJSPropertyAttributeReadOnly},
  85             {"name",                            getProperty, NULL, kJSPropertyAttributeReadOnly},
  86             {"messagingStorage",                                getProperty, NULL, kJSPropertyAttributeReadOnly},
  87             { 0, 0, 0, 0 }
  88         };
  89
  90         JSStaticFunction JSMessagingService::m_function[] = {
  91                         { "createMessage",        JSMessagingService::createMessage,       kJSPropertyAttributeNone },
  92                         { "sendMessage",          JSMessagingService::sendMessage,         kJSPropertyAttributeNone },
  93                         { "loadMessageBody",      JSMessagingService::loadMessageBody,     kJSPropertyAttributeNone },
  94                         { "loadMessageAttachment",        JSMessagingService::loadMessageAttachment,       kJSPropertyAttributeNone },
  95                         { "sync",         JSMessagingService::sync,        kJSPropertyAttributeNone },
  96                         { "syncFolder",   JSMessagingService::syncFolder,          kJSPropertyAttributeNone },
  97                         { "cancelOperation",   JSMessagingService::cancelOperation,        kJSPropertyAttributeNone },
  98                         { 0, 0, 0 }
  99         };
 100
 101         const JSClassRef JSMessagingService::getClassRef() {
 102                 if (!m_jsClassRef) {
 103                         m_jsClassRef = JSClassCreate(&m_classInfo);
 104                 }
 105                 return m_jsClassRef;
 106         }
 107
 108         void JSMessagingService::initialize(JSContextRef context, JSObjectRef object) {
 109                 LogDebug("creation messaging Service instance");
 110         }
 111
 112         void JSMessagingService::finalize(JSObjectRef object) {
 113                 LogDebug("finalize messaging instance");
 114                 //JSMessagingServicePriv *priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(object));
 115                 JSMessagingServicePriv *priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(object));
 116                 delete priv;
 117         }
 118
 119         bool JSMessagingService::hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception) {
 120                 return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 121         }
 122
 123         JSObjectRef JSMessagingService::createJSObject(JSContextRef context, const Api::Messaging::IMessagingServicePtr &messagingService)
 124         {
 125                 JSMessagingServicePriv* priv = new JSMessagingServicePriv( context, messagingService);  //make private class.
 126                 return JSObjectMake(context, getClassRef(), priv);
 127         }
 128
 129         JSValueRef JSMessagingService::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 130         {
 131                 LogDebug("<<< ");
 132                 JSValueRef retVal = NULL;
 133
 134                 JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(object));        //get private object
 135             if (priv)
 136                 {
 137                         IMessagingServicePtr imessagingService = priv->getObject();
 138                         Try{
 139                                 ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 140
 141                                 if (JSStringIsEqualToUTF8CString(propertyName, "type")) {
 142                                         LogDebug("type" << ":" << imessagingService->getType());
 143                                         retVal = converter->toJSValueRef(converter->toMessageType(imessagingService->getType()));
 144                                 } else if (JSStringIsEqualToUTF8CString(propertyName, "name")) {
 145                                         LogDebug("name" << ":" <<  imessagingService->getName());
 146                                         retVal = converter->toJSValueRef(imessagingService->getName());
 147                                 } else if (JSStringIsEqualToUTF8CString(propertyName, "id")) {
 148                                         LogDebug("accountId" << ":" <<  imessagingService->getAccountID());
 149
 150                                         std::stringstream stream;
 151                                         stream << imessagingService->getAccountID();
 152                                         if (stream.fail()) {
 153                                                 ThrowMsg(WrtDeviceApis::Commons::UnknownException,"Couldn't convert e-mail account id");
 154                                         }
 155
 156                                         retVal = converter->toJSValueRef(stream.str());
 157                                 } else if (JSStringIsEqualToUTF8CString(propertyName, "messagingStorage")) {
 158                                         LogDebug("messagingStorage" << ":" <<  imessagingService->getAccountID());
 159                                         JSContextRef l_globalContext = converter->toJSGlobalContext(object);
 160                                         retVal = JSUtils::makeObject(l_globalContext, JSMessagingStorage::getClassRef(), NULL);
 161                                 } else{
 162                                         retVal = JSValueMakeUndefined(context);
 163                                 }
 164
 165                         } Catch (WrtDeviceApis::Commons::Exception){
 166                                 LogError("Exception: " << _rethrown_exception.GetMessage());
 167                                 return JSTizenExceptionFactory::postException(context, exception,
 168                                         JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
 169                         }
 170
 171                         LogDebug(">>>");
 172                         return retVal;
 173
 174                 }
 175                 else
 176                 {
 177                         LogDebug(" Private Object is NULL ");
 178                         return JSTizenExceptionFactory::postException(context, exception,
 179                                         JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
 180                 }
 181
 182         }
 183
 184         JSValueRef JSMessagingService::createMessage(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
 185                 const JSValueRef arguments[], JSValueRef* exception)
 186         {
 187
 188                 LogInfo("<<<");
 189                 LogDebug("arumentConunt:" << argumentCount);
 190
 191                 JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
 192                 if (priv)
 193                 {
 194                         AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 195                                 priv->getContext(),
 196                                 MessagingExportedNames[MESSAGING_FUNCTION_API_CREATE_MESSAGE]);
 197                         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 198
 199                         try {
 200                                 ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 201                                 JSContextRef l_globalContext = converter->toJSGlobalContext(thisObject);
 202                                 Validator check(context, exception);
 203
 204                                 IMessagingServicePtr imessagingService = priv->getObject();                             //get MessagingService.
 205                                 JSValueRef objMsg = NULL;
 206
 207                                 Api::Messaging::MessageType msgType = (Api::Messaging::MessageType)imessagingService->getType();
 208                                 LogInfo("msgType :" << msgType);
 209
 210                                 if (msgType == Api::Messaging::EMAIL)
 211                                 {
 212                                         Api::Messaging::EmailAccountInfo account = imessagingService->getCurrentEmailAccount();
 213                                         LogDebug("Account Address:" << &account);
 214                                         objMsg = JSMessage::createJSObject(l_globalContext, account, msgType);          //make message JSValueRef.
 215                                 }
 216                                 else
 217                                 {
 218                                         objMsg = JSMessage::createJSObject(l_globalContext, msgType);           //make message JSValueRef.
 219                                 }
 220
 221                                 //set Properties
 222                                 if ( argumentCount == 1)
 223                                 {
 224                                         IMessagePtr msg = converter->toIMessage(objMsg) ;
 225
 226                                         if (!msg)
 227                                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException,"platform exception");
 228
 229                                         LogDebug ("##### msg type is " << msg->getId());
 230
 231                                         const ScopedJSStringRef subjectStr(JSStringCreateWithUTF8CString("subject"));
 232                                         const ScopedJSStringRef toStr(JSStringCreateWithUTF8CString("to"));
 233                                         const ScopedJSStringRef ccStr(JSStringCreateWithUTF8CString("cc"));
 234                                         const ScopedJSStringRef bccStr(JSStringCreateWithUTF8CString("bcc"));
 235                                         const ScopedJSStringRef plainBodyStr(JSStringCreateWithUTF8CString("plainBody"));
 236                                         const ScopedJSStringRef htmlBodyStr(JSStringCreateWithUTF8CString("htmlBody"));
 237                                         const ScopedJSStringRef priorityStr(JSStringCreateWithUTF8CString("priority"));
 238
 239                                         JSObjectRef arg = converter->toJSObjectRef(arguments[0]);
 240                                         JSValueRef subjectData = JSObjectGetProperty(l_globalContext, arg, subjectStr.get(), NULL);
 241                                         JSValueRef toData = JSObjectGetProperty(l_globalContext, arg, toStr.get(), NULL);
 242                                         JSValueRef ccData = JSObjectGetProperty(l_globalContext, arg, ccStr.get(), NULL);
 243                                         JSValueRef bccData = JSObjectGetProperty(l_globalContext, arg, bccStr.get(), NULL);
 244                                         JSValueRef plainBodyData = JSObjectGetProperty(l_globalContext, arg, plainBodyStr.get(), NULL);
 245                                         JSValueRef htmlBodyData = JSObjectGetProperty(l_globalContext, arg, htmlBodyStr.get(), NULL);
 246                                         JSValueRef priorityData = JSObjectGetProperty(l_globalContext, arg, priorityStr.get(), NULL);
 247
 248                                         //subject
 249                                          if (!JSValueIsUndefined(l_globalContext, subjectData) )
 250                                          {
 251                                                 LogDebug ( " Subject : " << converter->toString(subjectData) );
 252                                                 std::string subject = converter->toString(subjectData);
 253                                                  switch (msgType)
 254                                                  {
 255                                                 case Api::Messaging::MMS:
 256                                                 {
 257                                                     Api::Messaging::IMmsPtr mms = Api::Messaging::MessageFactory::convertToMms(msg);
 258                                                     mms->setSubject(subject);
 259                                                     break;
 260                                                 }
 261                                                 case Api::Messaging::EMAIL:
 262                                                 {
 263                                                     Api::Messaging::IEmailPtr email = Api::Messaging::MessageFactory::convertToEmail(msg);
 264                                                     email->setSubject(subject);
 265                                                     break;
 266                                                 }
 267                                                   default:
 268                                                   {
 269                                                     LogError("message not supported");
 270                                                     //Throw(WrtDeviceApis::Commons::UnsupportedException);
 271                                                     //break;
 272                                                   }
 273                                                 }
 274                                          }
 275                                         //to
 276                                         if (!JSValueIsUndefined(l_globalContext, toData) )
 277                                         {
 278                                                 Api::Messaging::Recipients to = converter->toRecipients(toData);
 279                                                 LogDebug("setting to field, size=" << to.getRecipientSize());
 280                                                 msg->setToRecipients(to);
 281                                         }
 282                                         //cc
 283                                         if (msgType == Api::Messaging::EMAIL )
 284                                         {
 285                                                 Api::Messaging::IEmailPtr email = Api::Messaging::MessageFactory::convertToEmail(msg);
 286                                                 if (!JSValueIsUndefined(l_globalContext, ccData))
 287                                                 {
 288                                                         Api::Messaging::Recipients cc = converter->toRecipients(ccData);
 289                                                 email->setCcRecipients(cc);
 290                                                 }
 291
 292                                                 if (!JSValueIsUndefined(l_globalContext, bccData))
 293                                                 {
 294                                                         Api::Messaging::Recipients bcc = converter->toRecipients(bccData);
 295                                                 email->setBccRecipients(bcc);
 296                                                 }
 297
 298                                                 if (!JSValueIsUndefined(l_globalContext, htmlBodyData))
 299                                                 {
 300                                                         std::string body = converter->toString(htmlBodyData);
 301                                                         LogDebug("html body : " << body);
 302                                                         email->setHtmlBody(body);
 303                                                 }
 304
 305                                                 if (!JSValueIsUndefined(l_globalContext, priorityData))
 306                                                 {
 307                                                         email->setPriority(converter->toMessagePriority(priorityData));
 308                                                 }
 309
 310                                         }
 311
 312                                         if (!JSValueIsUndefined(l_globalContext, plainBodyData) )
 313                                         {
 314                                                 std::string body = converter->toString(plainBodyData);
 315                                                 LogDebug("plain body  : " << body);
 316                                                 msg->setBody(body);
 317                                         }
 318
 319                                 }
 320                                 return objMsg;
 321
 322                         }
 323                         Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
 324                         return JSTizenExceptionFactory::postException(context, exception,
 325                                         JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 326                         }
 327                         Catch(WrtDeviceApis::Commons::ConversionException) {
 328                         return JSTizenExceptionFactory::postException(context, exception,
 329                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 330                         }
 331
 332                         LogInfo(">>>");
 333                         return JSValueMakeUndefined(context);
 334                 }
 335                 else
 336                 {
 337                         LogDebug(" Private Object is NULL ");
 338                         return JSTizenExceptionFactory::postException(context, exception,
 339                                         JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
 340                 }
 341
 342         }
 343
 344 JSValueRef JSMessagingService::sendMessage(JSContextRef context,
 345         JSObjectRef function,
 346         JSObjectRef thisObject,
 347         size_t argumentCount,
 348         const JSValueRef arguments[],
 349         JSValueRef* exception)
 350 {
 351     LogDebug("entered");
 352
 353     JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
 354
 355     if (!priv) {
 356         LogError("Null pointer");
 357         return JSTizenExceptionFactory::postException(context, exception,
 358                            JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 359     }
 360
 361     JSContextRef globalContext = priv->getContext();
 362
 363     LogInfo(">>> argument count : " << argumentCount);
 364
 365     if (argumentCount < 2) {
 366                 return JSTizenExceptionFactory::postException(context, exception,
 367                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 368     }
 369
 370     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
 371     WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr recipientCallbackManager;
 372
 373     ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 374         Try {
 375
 376                 if ( argumentCount > 1 && argumentCount < 4)
 377                 {
 378                         if ( argumentCount > 1)
 379                         {
 380                                 if (JSValueIsObject(context, arguments[1]) && !Validator(context).isCallback(arguments[1])) //check
 381                                 {
 382                                         MessageSendCallback callbacks = converter->toMessageSendCallback(arguments[1]);
 383                                         callbackManager->setOnSuccess( converter->toFunctionOrNull(callbacks.onSuccess) );
 384                                 }
 385                                 else
 386                                 {
 387                                 callbackManager->setOnSuccess(converter->toFunction(arguments[1]));
 388                         }
 389
 390                                 if (    argumentCount == 3)
 391                                 {
 392                                         callbackManager->setOnError(converter->toFunctionOrNull(arguments[2]));
 393                                 }
 394                         }
 395                 }
 396                 else
 397                 {
 398                         ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException,"invalid argument exception");
 399                 }
 400
 401               //check permission.
 402                 AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 403                         priv->getContext(),
 404                         MessagingExportedNames[MESSAGING_FUNCTION_API_SEND_MESSAGE]);
 405                 TIZEN_ASYNC_CBM_ACCESS_HANDLER(status, context, callbackManager);
 406
 407            //create PrivateData
 408         EventSendMessagePrivateDataPtr privateData( new EventSendMessagePrivateData(callbackManager, recipientCallbackManager) );
 409
 410         Api::Messaging::EventSendMessagePtr event(new Api::Messaging::EventSendMessage());
 411
 412           LogDebug("Event size");
 413
 414           IMessagingServicePtr imessagingService = priv->getObject();
 415
 416         event->opId = imessagingService->createOpId(MESSAGING_SERVICE_OP_SEND_MESSAGE);
 417         event->msg = converter->toIMessage(arguments[0]);
 418            imessagingService->setMessageToOpId( event->opId, event->msg);
 419         event->store = true;            //always store message in sendbox after send , email Type.
 420         event->m_messagingService = imessagingService;
 421         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData>(privateData));
 422
 423         //event->setForAsynchronousCall(&JSMessagingListener::getInstance());
 424         //event->setForAsynchronousCall(&MessagingControllerSingleton::Instance());
 425           event->setForAsynchronousCall(&MessagingController::getInstance());
 426
 427         Api::Messaging::ReqReceiverMessageSingleton::Instance().sendMessage(event);     //send message
 428
 429         return converter->toJSValueRef(event->opId);
 430     }
 431     Catch(WrtDeviceApis::Commons::ConversionException) {
 432                 return JSTizenExceptionFactory::postException(context, exception,
 433                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 434     }
 435     Catch(WrtDeviceApis::Commons::NullPointerException) {
 436                 return JSTizenExceptionFactory::postException(context, exception,
 437                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 438     }
 439     Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
 440         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 441                                         JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
 442     }
 443
 444     return JSValueMakeNull(context);
 445 }
 446
 447 JSValueRef JSMessagingService::loadMessageBody(JSContextRef context,
 448         JSObjectRef function,
 449         JSObjectRef thisObject,
 450         size_t argumentCount,
 451         const JSValueRef arguments[],
 452         JSValueRef* exception)
 453 {
 454     LogDebug("entered");
 455
 456     JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
 457
 458     if (!priv) {
 459         LogError("Null pointer");
 460                 return JSTizenExceptionFactory::postException(context, exception,
 461                    JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 462     }
 463
 464     JSContextRef globalContext = priv->getContext();            //create global Context
 465     LogInfo(">>> argument count : " << argumentCount);
 466
 467         if (argumentCount < 2) {
 468                 return JSTizenExceptionFactory::postException(context, exception,
 469                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 470         }
 471
 472         Validator check(context, exception);    //create check
 473
 474         WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
 475         ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(globalContext); //create converter
 476
 477         Try {
 478                 //create event
 479                 EventMessagingServicePrivateDataPtr privateData( new EventMessagingServicePrivateData(callbackManager) );
 480
 481                 //check permission.
 482                 AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 483                         priv->getContext(),
 484                         MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY]);
 485                         TIZEN_ASYNC_CBM_ACCESS_HANDLER(status, context, callbackManager);
 486
 487                 if (JSValueIsObject(context, arguments[0]) && Validator(context).isCallback(arguments[0])) //check
 488                 {
 489                         callbackManager->setOnSuccess(converter->toFunctionOrNull(arguments[0]));
 490                         if (converter->toFunctionOrNull(arguments[1]) && Validator(context).isCallback(arguments[1]) )
 491                         {
 492                                 callbackManager->setOnError(converter->toFunctionOrNull(arguments[1]));
 493                         }
 494
 495                         Api::Messaging::EventMessagingServicePtr event(new Api::Messaging::EventMessagingService());     //create event
 496                         if ( JSValueIsObject(context, arguments[2]) )
 497                         {
 498                                 event->m_message = converter->toIMessage(arguments[2]) ;
 499                                 LogDebug("Message Type =" << event->m_message->getMessageType());
 500                                 privateData->setMessageJSValueRef(arguments[2]);        //set Message JSValueRef.
 501                         }
 502                         else
 503                         {
 504                                 return JSTizenExceptionFactory::postException(context, exception,
 505                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 506                         }
 507
 508                       IMessagingServicePtr imessagingService = priv->getObject();
 509                         int opId = imessagingService->createOpId(MESSAGING_SERVICE_OP_DOWNLOAD_BODY);
 510                         LogDebug("Operation ID is = " << opId);
 511
 512                         event->opId = opId;
 513                         imessagingService->setMessageToOpId(opId, event->m_message);
 514                         event->setEventType(EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_BODY);
 515                         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData>(privateData));
 516                         event->setForAsynchronousCall(&MessagingController::getInstance());
 517
 518                         Api::Messaging::ReqReceiverMessageSingleton::Instance().loadMessageBody(event); //load message Body
 519
 520                         return converter->toJSValueRef(event->opId);
 521                 }
 522                 else
 523                 {
 524                         return JSTizenExceptionFactory::postException(context, exception,
 525                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 526                 }
 527
 528         }
 529         Catch(WrtDeviceApis::Commons::ConversionException) {
 530                 return JSTizenExceptionFactory::postException(context, exception,
 531                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 532         }
 533         Catch(WrtDeviceApis::Commons::NullPointerException) {
 534                 return JSTizenExceptionFactory::postException(context, exception,
 535                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 536         }
 537         Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
 538                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 539                                         JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
 540         }
 541         Catch(WrtDeviceApis::Commons::PlatformException) {
 542                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 543                                         JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
 544         }
 545
 546         return JSValueMakeNull(context);
 547
 548 }
 549
 550 JSValueRef JSMessagingService::loadMessageAttachment(JSContextRef context,
 551         JSObjectRef function,
 552         JSObjectRef thisObject,
 553         size_t argumentCount,
 554         const JSValueRef arguments[],
 555         JSValueRef* exception)
 556 {
 557     LogDebug("entered");
 558
 559     JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
 560
 561         if (!priv) {
 562                 LogError("Private Object is Null pointer");
 563                 return JSTizenExceptionFactory::postException(context, exception,
 564                         JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 565         }
 566
 567         JSContextRef globalContext = priv->getContext();                //create global Context
 568         LogInfo(">>> argument count : " << argumentCount);
 569
 570         if (argumentCount < 2) {
 571                 return JSTizenExceptionFactory::postException(context, exception,
 572                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 573         }
 574
 575         Validator check(context, exception);    //create check
 576
 577         WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
 578         ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(globalContext); //create converter
 579
 580         Try {
 581
 582                 if (JSValueIsObject(context, arguments[0]) && Validator(context).isCallback(arguments[0])) //check
 583                 {
 584                         EventMessagingServicePrivateDataPtr privateData( new EventMessagingServicePrivateData(callbackManager) );
 585
 586                         callbackManager->setOnSuccess(converter->toFunctionOrNull(arguments[0]));
 587                         if (converter->toFunctionOrNull(arguments[1]) && Validator(context).isCallback(arguments[1]) )
 588                         {
 589                                 callbackManager->setOnError(converter->toFunctionOrNull(arguments[1]));
 590                         }
 591
 592                         //check permission.
 593                         AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 594                                 priv->getContext(),
 595                                 MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT]);
 596                         TIZEN_ASYNC_CBM_ACCESS_HANDLER(status, context, callbackManager);
 597
 598                         IMessagingServicePtr imessagingService = priv->getObject();
 599                         Api::Messaging::EventMessagingServicePtr event(new Api::Messaging::EventMessagingService());     //create event
 600
 601                         LogInfo("event");
 602
 603                         event->setEventType(EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_ATTACHMENT);
 604                         event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData>(privateData));
 605                         event->setForAsynchronousCall(&MessagingController::getInstance());
 606                         LogInfo("agu");
 607                         if (argumentCount == 3 && !JSValueIsNull(context, arguments[2]))
 608                         {
 609                                 Api::Messaging::IAttachmentPtr iAttchmentPtr = converter->toIAttachment(arguments[2]);
 610                                 privateData->setMessageJSValueRef(arguments[2]);        //set Message JSValueRef.
 611                                 if (iAttchmentPtr)
 612                                 {
 613                                         event->m_attachment = iAttchmentPtr;
 614                                         event->m_message = event->m_attachment->getMessage();
 615
 616                                         if (!event->m_message)
 617                                                 return JSTizenExceptionFactory::postException(context, exception,
 618                                                         JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
 619                                 }
 620                                 else
 621                                 {
 622                                         return JSTizenExceptionFactory::postException(context, exception,
 623                                                 JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
 624                                 }
 625                         }
 626                         else
 627                         {
 628                                         return JSTizenExceptionFactory::postException(context, exception,
 629                                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 630                         }
 631
 632                         int opId = imessagingService->createOpId(MESSAGING_SERVICE_OP_DOWNLOAD_ATTACHMENT);
 633                         LogDebug("Operation ID is = " << opId);
 634
 635                         event->opId = opId;
 636                         imessagingService->setMessageToOpId(opId, event->m_message);
 637
 638                         LogInfo("pendingOperation");
 639                         //JSValueRef pendingOperation = WrtDeviceApis::CommonsJavaScript::makePendingOperation(globalContext, event);   //create pendingOperation.
 640                         Api::Messaging::ReqReceiverMessageSingleton::Instance().loadMessageAttachment(event);   //load message Body
 641
 642                         return converter->toJSValueRef(event->opId);
 643
 644                 }
 645                 else
 646                 {
 647                         return JSTizenExceptionFactory::postException(context, exception,
 648                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 649                 }
 650
 651         }
 652         Catch(WrtDeviceApis::Commons::ConversionException) {
 653                         return JSTizenExceptionFactory::postException(context, exception,
 654                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 655         }
 656         Catch(WrtDeviceApis::Commons::NullPointerException) {
 657                         return JSTizenExceptionFactory::postException(context, exception,
 658                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 659         }
 660         Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
 661                         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 662                                                 JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
 663         }
 664         Catch(WrtDeviceApis::Commons::PlatformException) {
 665                         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 666                                         JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
 667         }
 668
 669         return JSValueMakeNull(context);
 670 }
 671
 672 JSValueRef JSMessagingService::sync(JSContextRef context, JSObjectRef function, JSObjectRef thisObject,
 673                         size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 674 {
 675
 676         LogDebug("entered");
 677         JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
 678
 679         if (priv) {
 680
 681                 JSContextRef globalContext = priv->getContext();                //get global Context
 682
 683                 LogInfo(">>> argument count : " << argumentCount);
 684
 685                 if (argumentCount > 4 || argumentCount < 2 ) {
 686                         return JSTizenExceptionFactory::postException(context, exception,
 687                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 688                 }
 689
 690                 Validator check(context, exception);    //check context
 691
 692                 WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
 693                 ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(globalContext); //create converter
 694
 695                 IMessagingServicePtr imessagingService = priv->getObject();                             //get MessagingService.
 696
 697                 Api::Messaging::MessageType msgType = (Api::Messaging::MessageType)imessagingService->getType();
 698                 LogInfo("msgType :" << msgType);
 699
 700                 Try {
 701
 702                         int limit = -1; //sync limit
 703
 704                         if (JSValueIsObject(context, arguments[0]) && Validator(context).isCallback(arguments[0])) //check
 705                         {
 706                                 callbackManager->setOnSuccess(converter->toFunctionOrNull(arguments[0]));
 707                                 if (converter->toFunctionOrNull(arguments[1]) && Validator(context).isCallback(arguments[1]) )
 708                                 {
 709                                         callbackManager->setOnError(converter->toFunctionOrNull(arguments[1]));
 710                                 }
 711
 712                                 //check permission.
 713                                 AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 714                                         priv->getContext(),
 715                                         MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC]);
 716                                 TIZEN_ASYNC_CBM_ACCESS_HANDLER(status, context, callbackManager);
 717
 718                                 EventMessagingServicePrivateDataPtr privateData( new EventMessagingServicePrivateData(callbackManager) );
 719
 720                                 Api::Messaging::EventMessagingServicePtr event(new Api::Messaging::EventMessagingService());     //create event
 721
 722                                 if (argumentCount == 3 && !JSValueIsNull(context, arguments[2]))
 723                                         limit = converter->toInt(arguments[2]);
 724
 725                                 LogDebug("limit : " << limit);
 726
 727                                 event->opId = imessagingService->createOpId(MESSAGING_SERVICE_OP_SYNC);
 728                                 event->m_sync_account_id = imessagingService->getAccountID() ;
 729                                 event->m_sync_limit = limit;
 730                                 event->m_messagingService = imessagingService;
 731
 732                                 event->setEventType(EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_SYNC);
 733                                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData>(privateData));
 734                                 event->setForAsynchronousCall(&MessagingController::getInstance());
 735
 736                                 Api::Messaging::ReqReceiverMessageSingleton::Instance().sync(event);    //load message Body
 737
 738                                 return converter->toJSValueRef(event->opId);
 739
 740                         }
 741                         else
 742                         {
 743                                 return JSTizenExceptionFactory::postException(context, exception,
 744                                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 745                         }
 746                 }
 747                 Catch(WrtDeviceApis::Commons::ConversionException) {
 748                         return JSTizenExceptionFactory::postException(context, exception,
 749                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 750                 }
 751                 Catch(WrtDeviceApis::Commons::NullPointerException) {
 752                         return JSTizenExceptionFactory::postException(context, exception,
 753                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 754                 }
 755                 Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
 756                         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 757                                                 JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
 758                 }
 759                 Catch(WrtDeviceApis::Commons::PlatformException) {
 760                         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 761                                                 JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
 762                 }
 763
 764         }
 765         else
 766         {
 767                 LogError("Null pointer");
 768                 return JSTizenExceptionFactory::postException(context, exception,
 769                    JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 770         }
 771
 772         return JSValueMakeNull(context);
 773
 774 }
 775
 776
 777 JSValueRef JSMessagingService::syncFolder(JSContextRef context, JSObjectRef function, JSObjectRef thisObject,
 778                         size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 779 {
 780         LogDebug("entered");
 781
 782         JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
 783
 784         if (priv) {
 785                 JSContextRef globalContext = priv->getContext();                //get global Context
 786
 787 #if 0
 788         AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 789                 globalContext,
 790                 MESSAGING_FUNCTION_API_SYNC);
 791 #endif
 792                 LogInfo(">>> argument count : " << argumentCount);
 793
 794                 if (argumentCount > 4 || argumentCount < 1) {
 795                         return JSTizenExceptionFactory::postException(context, exception,
 796                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 797                 }
 798
 799                 Validator check(context, exception);    //check context
 800
 801                 WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
 802                 ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(globalContext); //create converter
 803
 804                 IMessagingServicePtr imessagingService = priv->getObject();                     //get MessagingService.
 805
 806
 807                 Api::Messaging::MessageType msgType = (Api::Messaging::MessageType)imessagingService->getType();
 808                 LogInfo("msgType :" << msgType);
 809
 810                 Try {
 811
 812                         int limit = -1;
 813
 814                         if (JSValueIsObject(context, arguments[0]) && !Validator(context).isCallback(arguments[0])) //check
 815                         {
 816
 817                                 AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
 818                                         priv->getContext(),
 819                                         MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC_FOLDER]);
 820                                 TIZEN_ASYNC_CBM_ACCESS_HANDLER(status, context, callbackManager);
 821
 822                                 EventMessagingServicePrivateDataPtr privateData( new EventMessagingServicePrivateData(callbackManager) );
 823                                 //private->setSyncAccountID( imessagingService->getAccountID());                  //set account ID
 824
 825                                 Api::Messaging::EventMessagingServicePtr event(new Api::Messaging::EventMessagingService());     //create event
 826
 827
 828                                 IMessageFolderPtr folder = converter->toIMessageFolder(arguments[0]);
 829                                 if ( folder )
 830                                 {
 831                                         event->m_folder_name = folder->getName();               //it will be changed to the folder ptr
 832                                 }
 833
 834                                 if ( argumentCount > 1 )
 835                                 {
 836                                         if (JSValueIsObject(context, arguments[1]) && Validator(context).isCallback(arguments[1])) //check
 837                                         {
 838                                                 callbackManager->setOnSuccess(converter->toFunctionOrNull(arguments[1]));
 839                                         }
 840
 841                                         if ( argumentCount > 2 )
 842                                         {
 843                                                 if (JSValueIsObject(context, arguments[2]) && Validator(context).isCallback(arguments[2])) //check
 844                                                 {
 845                                                         callbackManager->setOnError(converter->toFunctionOrNull(arguments[2]));
 846                                                 }
 847                                         }
 848
 849                                         if (argumentCount == 4 && !JSValueIsNull(context, arguments[3]))
 850                                                 limit = converter->toInt(arguments[3]);
 851
 852                                 }
 853
 854                                 LogDebug("limit : " << limit);
 855                                 LogDebug("folderName : " << event->m_folder_name);
 856                                 event->opId = imessagingService->createOpId(MESSAGING_SERVICE_OP_SYNC_FOLDER);
 857                                 event ->m_sync_account_id = imessagingService->getAccountID() ;
 858                                 event ->m_sync_limit = limit;
 859                                 event->m_messagingService = imessagingService;
 860
 861                                 event->setEventType(EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_SYNC_FOLDER);
 862                                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData>(privateData));
 863                                 event->setForAsynchronousCall(&MessagingController::getInstance());
 864
 865                                 Api::Messaging::ReqReceiverMessageSingleton::Instance().syncFolder(event);      //load message Body
 866
 867                                 return converter->toJSValueRef(event->opId);
 868
 869                         }
 870                         else
 871                         {
 872                                 return JSTizenExceptionFactory::postException(context, exception,
 873                                                 JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 874                         }
 875                 }
 876                 Catch(WrtDeviceApis::Commons::ConversionException) {
 877                         return JSTizenExceptionFactory::postException(context, exception,
 878                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 879                 }
 880                 Catch(WrtDeviceApis::Commons::NullPointerException) {
 881                         return JSTizenExceptionFactory::postException(context, exception,
 882                                         JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
 883                 }
 884                 Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
 885                         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 886                                                 JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
 887                 }
 888                 Catch(WrtDeviceApis::Commons::PlatformException) {
 889                         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
 890                                                 JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
 891                 }
 892
 893         }
 894         else
 895         {
 896                 LogError("Null pointer");
 897                 return JSTizenExceptionFactory::postException(context, exception,
 898                    JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 899         }
 900
 901         return JSValueMakeNull(context);
 902
 903
 904 }
 905
 906 JSValueRef JSMessagingService::cancelOperation(JSContextRef context, JSObjectRef function, JSObjectRef thisObject,
 907                         size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 908 {
 909         LogDebug("entered");
 910
 911         JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));    //get private object
 912
 913         if (priv)
 914         {
 915                 IMessagingServicePtr imessagingService = priv->getObject();
 916                 Try
 917                 {
 918                         LogInfo(">>> argument count : " << argumentCount);
 919
 920                         if ( argumentCount == 1 && !Validator(context).isCallback(arguments[0]))
 921                         {
 922                                 ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
 923                                 Api::Messaging::MessageType msgType = (Api::Messaging::MessageType)imessagingService->getType();
 924                                 LogInfo("msgType :" << msgType);
 925
 926                                 int opId = converter->toLong( arguments[0] );   //Fetch operation ID
 927                                 int handle = imessagingService->getHandleFromOpId(opId);
 928                                 if ( handle < 0 )
 929                                 {
 930                                         ThrowMsg(WrtDeviceApis::Commons::NotFoundException,"Operation ID Not found");
 931                                 }
 932
 933                                 int opType = imessagingService->getOpTypeFromOpId(opId);
 934                                 LogInfo("operation ID :" << opId << " operation Type : "  << opType);
 935
 936                                 if ( opType == Api::Messaging::MESSAGING_SERVICE_OP_SEND_MESSAGE)
 937                                 {
 938                                         IMessagePtr msg = imessagingService->getMessageFromOpId(opId);
 939                                         if (msg)
 940                                         {
 941                                                 LogDebug("Call Cancel Function");
 942                                                 msg->sendCancel(handle);
 943                                                 imessagingService->deleteOpId(opId);
 944                                         }
 945                                 }
 946                                 else
 947                                 {       //for email.
 948                                         if (msgType == Api::Messaging::EMAIL)
 949                                         {
 950                                                 if ( opType == Api::Messaging::MESSAGING_SERVICE_OP_DOWNLOAD_BODY )
 951                                                 {
 952                                                         IMessagePtr msg = imessagingService->getMessageFromOpId(opId);
 953                                                         Api::Messaging::IEmailPtr email = Api::Messaging::MessageFactory::convertToEmail(msg);
 954                                                         LogDebug("Cancel Download Body , handle = " << handle);
 955                                                         email->downloadBodyCancel(handle);
 956                                                 }
 957                                                 else if (  opType == Api::Messaging::MESSAGING_SERVICE_OP_SYNC )
 958                                                 {
 959                                                         LogDebug("Cancel Sync , handle = " << handle);
 960                                                         imessagingService->syncCancel(handle);
 961                                                 }
 962                                                 else if ( opType == Api::Messaging::MESSAGING_SERVICE_OP_SYNC_FOLDER )
 963                                                 {
 964                                                         LogDebug("Cancel Sync Folder, handle = " << handle);
 965                                                         imessagingService->syncFolderCancel(handle);
 966                                                 }
 967                                                 imessagingService->deleteOpId(opId);
 968                                         }
 969                                         else
 970                                         {
 971                                                 ThrowMsg(WrtDeviceApis::Commons::UnsupportedException, "Operation Type is mismatched");
 972                                         }
 973                                 }
 974
 975                         }
 976                         else
 977                         {
 978                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException,"invalid argument exception");
 979                         }
 980
 981                 }
 982                 Catch (WrtDeviceApis::Commons::InvalidArgumentException){
 983                         LogError("Exception: " << _rethrown_exception.GetMessage());
 984                         return JSTizenExceptionFactory::postException(context, exception,
 985                                 JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 986                 }
 987                 Catch (WrtDeviceApis::Commons::NotFoundException){
 988                         LogError("Exception: " << _rethrown_exception.GetMessage());
 989                         return JSTizenExceptionFactory::postException(context, exception,
 990                                 JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
 991                 }
 992                 Catch (WrtDeviceApis::Commons::UnsupportedException){
 993                         LogError("Exception: " << _rethrown_exception.GetMessage());
 994                         return JSTizenExceptionFactory::postException(context, exception,
 995                                 JSTizenException::NOT_SUPPORTED_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_SUPPORTED);
 996                 }
 997                 Catch (WrtDeviceApis::Commons::Exception){
 998                         LogError("Exception: " << _rethrown_exception.GetMessage());
 999                         return JSTizenExceptionFactory::postException(context, exception,
1000                                 JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
1001                 }
1002
1003         }
1004         else
1005         {
1006                 LogDebug(" Private Object is NULL ");
1007                 return JSTizenExceptionFactory::postException(context, exception,
1008                                         JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
1009         }
1010
1011         LogDebug(">>>");
1012         return JSValueMakeNull(context);
1013 }
1014
1015 }
1016 }
1017