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