src/Messaging/MessagingController.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <Commons/Exception.h>
  19 #include <CommonsJavaScript/JSDOMExceptionFactory.h>
  20 #include <JavaScriptCore/JavaScript.h>
  21 #include <JSTizenExceptionFactory.h>
  22 #include <JSTizenException.h>
  23 #include <SecurityExceptions.h>
  24
  25 #include "MessagingErrorMsg.h"
  26 #include "MessagingController.h"
  27 #include "JSMessagingService.h"
  28 #include "ConverterMessage.h"
  29 #include "EventSendMessagePrivateData.h"
  30 #include "EventMessagingServicePrivateData.h"
  31 #include "EventMessagingService.h"
  32 #include "JSMessage.h"
  33 #include "JSMessageAttachment.h"
  34 #include "MessageAsyncCallbackManager.h"
  35
  36 #include <dpl/singleton_safe_impl.h>
  37 #include <Logger.h>
  38
  39 IMPLEMENT_SAFE_SINGLETON(DeviceAPI::Messaging::MessagingController)
  40
  41 using namespace std;
  42 using namespace DeviceAPI::Messaging;
  43 using namespace DeviceAPI::Common;
  44 using namespace WrtDeviceApis::Commons;
  45 using namespace WrtDeviceApis::CommonsJavaScript;
  46
  47 namespace DeviceAPI {
  48 namespace Messaging {
  49
  50 MessagingController::MessagingController() :
  51         SendMessageAnswerReceiver(ThreadEnum::NULL_THREAD),
  52         GetMessagingServiceReceiver (ThreadEnum::NULL_THREAD),
  53         MessagingServiceReceiver (ThreadEnum::NULL_THREAD)
  54 {
  55         LoggerD("<<< ");
  56         LoggerD(">>>");
  57 }
  58
  59 MessagingController::~MessagingController() {
  60         LoggerD("<<<");
  61         LoggerD(">>>");
  62 }
  63
  64 MessagingController& MessagingController::getInstance()
  65 {
  66         static MessagingController instance;
  67         return instance;
  68 }
  69
  70 void MessagingController::OnAnswerReceived(const EventGetMessagingServicePtr &event) {
  71         LoggerD("<<<");
  72
  73         WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
  74         MessageAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
  75
  76         if (event->getExceptionCode() == ExceptionCodes::None)
  77         {
  78                 std::vector<IMessagingServicePtr> messagingServices = event->getMessagingServices();
  79                 int count = messagingServices.size();
  80                 int index = 0;
  81
  82                 JSObjectRef jsMessagingServiceObject[count];    //make
  83
  84                 LoggerD(" Service Count :" << count);
  85
  86                 for (index = 0; index < count; index++)
  87                 {
  88                         jsMessagingServiceObject[index] = JSMessagingService::createJSObject(callbackManager->getContext(), messagingServices[index] );
  89                 }
  90                 JSObjectRef result = JSObjectMakeArray(callbackManager->getContext(), count, jsMessagingServiceObject, NULL);
  91
  92                 callbackManager->callOnSuccess(result);
  93         }
  94         else
  95         {
  96                 LoggerD("Operation failed. Exception code: " << event->getExceptionCode());
  97                 JSContextRef context = callbackManager->getContext();
  98                 JSValueRef errorObject = NULL;
  99
 100                 WrtDeviceApis::Commons::ExceptionCodes::Enumeration exception = event->getExceptionCode();
 101                 switch(exception) {
 102                         case WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException:
 103                                 errorObject = JSTizenExceptionFactory::makeErrorObject(context,
 104                                                 JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 105                                 break;
 106                         case WrtDeviceApis::Commons::ExceptionCodes::PlatformException:
 107                                 errorObject = JSTizenExceptionFactory::makeErrorObject(context,
 108                                                 JSTizenException::IO_ERROR, JSMESSAGING_EXCEPTION_MSG_IO);
 109                         break;
 110                         case WrtDeviceApis::Commons::ExceptionCodes::PlatformWrongStateException:
 111                                 errorObject = JSTizenExceptionFactory::makeErrorObject(context,
 112                                                 JSTizenException::NOT_SUPPORTED_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_SUPPORTED);
 113                         break;
 114                         default:
 115                                 errorObject = JSTizenExceptionFactory::makeErrorObject(context,
 116                                                 JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
 117                                 break;
 118                 }
 119                 callbackManager->callOnError(errorObject);
 120         }
 121
 122         LoggerD(">>>");
 123 }
 124
 125 void MessagingController::OnAnswerReceived(const EventMessagingServicePtr &event)
 126 {
 127         LoggerD(" <<< EventMessagingServicePtr >>> ");
 128
 129         EventMessagingServicePrivateDataPtr privateData =
 130                 DPL::StaticPointerCast<EventMessagingServicePrivateData>(event->getPrivateData());
 131
 132         WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = privateData->getCallbackManager();             //get callback manager
 133         MessageAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 134
 135         JSContextRef globalContext = callbackManager->getContext();
 136
 137         int MessagingServiceEventType = event->getEventType();
 138         LoggerD(" MessagingServiceEvent Type :" << MessagingServiceEventType);
 139
 140         ConverterMessageFactory::ConverterType converter =
 141                 ConverterMessageFactory::getConverter(globalContext);
 142
 143         if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_BODY)
 144         {
 145                 LoggerD(" Message Load Body");
 146                 LoggerD("Operation ID : " << event->opId);
 147                 if ( event->m_messagingService)
 148                         event->m_messagingService->deleteOpId(event->opId);
 149
 150                 if (event->getExceptionCode() == ExceptionCodes::None && event->m_message)
 151                 {
 152                         LoggerD(" Message Type :" << event->m_message->getMessageType());
 153                         JSValueRef msg = JSMessage::createJSObject(globalContext, event->m_message);
 154                         if(msg)
 155                                 callbackManager->callOnSuccess(msg);
 156                         else
 157                                 callbackManager->callOnError( JSTizenExceptionFactory::makeErrorObject(globalContext,
 158                                                 JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
 159                 }
 160                 else
 161                 {
 162                         JSValueRef msg = privateData->getMessageJSValueRef();
 163                         callbackManager->callOnError(msg);
 164                 }
 165         }
 166         else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_ATTACHMENT)
 167         {
 168                 LoggerD(" Message load attachment");
 169                 LoggerD("Operation ID : " << event->opId);
 170                 if ( event->m_messagingService)
 171                         event->m_messagingService->deleteOpId(event->opId);
 172
 173                 if (event->getExceptionCode() == ExceptionCodes::None && event->m_attachment)
 174                 {
 175                         LoggerD(" Message Type :" << event->m_message->getMessageType());
 176
 177                         JSValueRef attachment  =  JSMessageAttachment::createJS(globalContext, event->m_attachment );
 178                         if ( attachment)
 179                                 callbackManager->callOnSuccess(attachment);
 180                         else
 181                                 callbackManager->callOnError( JSTizenExceptionFactory::makeErrorObject(globalContext,
 182                                                 JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
 183                 }
 184                 else
 185                 {
 186                         callbackManager->callOnError();
 187                 }
 188         }
 189         else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_SYNC)
 190         {
 191                 LoggerD(" Message Sync :");
 192                 LoggerD("Operation ID : " << event->opId);
 193                 if ( event->m_messagingService)
 194                         event->m_messagingService->deleteOpId(event->opId);
 195
 196                 if (event->getExceptionCode() == ExceptionCodes::None)
 197                 {
 198                         callbackManager->callOnSuccess();
 199                 }
 200                 else
 201                 {
 202                         callbackManager->callOnError();
 203                 }
 204         }
 205         else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_SYNC_FOLDER)
 206         {
 207                 LoggerD(" Message Sync Folder");
 208                 LoggerD("Operation ID : " << event->opId);
 209                 if ( event->m_messagingService)
 210                         event->m_messagingService->deleteOpId(event->opId);
 211                 if (event->getExceptionCode() == ExceptionCodes::None)
 212                 {
 213                         callbackManager->callOnSuccess();
 214                 }
 215                 else
 216                 {
 217                         callbackManager->callOnError();
 218                 }
 219         }
 220         else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_SEND_MESSAGE)
 221         {
 222                 JSValueRef error = NULL;
 223                 WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr recipientCallbackManager = privateData->getRecipientCallbackManager();
 224
 225                 if (WrtDeviceApis::Commons::ExceptionCodes::None != event->getExceptionCode()) {
 226                         switch (event->getExceptionCode()) {
 227                                 case WrtDeviceApis::Commons::ExceptionCodes::PlatformException:
 228                                 case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
 229                                         error = JSTizenExceptionFactory::makeErrorObject(globalContext,
 230                                                   JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 231                                         break;
 232                                 default:
 233                                         error = JSTizenExceptionFactory::makeErrorObject(globalContext,
 234                                                   JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
 235                                         break;
 236                         }
 237                   }
 238
 239                   ConverterMessage converter(globalContext);
 240
 241                   //remove operation handle
 242                   if (event->m_messagingService)
 243                   {
 244                           LoggerD("Operation ID : " << event->opId);
 245                           event->m_messagingService->deleteOpId(event->opId);
 246                   }
 247                   if (WrtDeviceApis::Commons::ExceptionCodes::None == event->getExceptionCode())
 248                   {
 249                           LoggerD(" success size : " << event->m_successRecipients.size());
 250                           std::vector<JSValueRef> successRecipentList;
 251
 252                           int cnt = event->m_successRecipients.size();
 253                           LoggerD( "success count : " << cnt);
 254
 255                           for(int index = 0; index < cnt; index++)
 256                           {
 257                                   LoggerD( "success recipent : " << event->m_successRecipients[index]);
 258                                   successRecipentList.push_back(converter.toJSValueRef(event->m_successRecipients[index]));
 259                           }
 260
 261                           JSObjectRef result = JSObjectMakeArray(globalContext, cnt, successRecipentList.data(), NULL);
 262                           callbackManager->callOnSuccess(result);
 263
 264                   }
 265                   else {
 266                           //JSValueRef params[] = { error, recipient };
 267                           //callbackManager->callOnError( params, sizeof(params) / sizeof(params[0]));
 268                           callbackManager->callOnError(error);
 269                   }
 270
 271         }
 272         else
 273         {
 274                 callbackManager->callOnError(JSValueMakeUndefined(globalContext));
 275         }
 276
 277 }
 278 void MessagingController::OnAnswerReceived(const EventSendMessagePtr& event)
 279 {
 280         LoggerD("ENTER");
 281
 282         JSValueRef error = NULL;
 283         EventSendMessagePrivateDataPtr privateData =
 284                 DPL::StaticPointerCast<EventSendMessagePrivateData>(event->getPrivateData());
 285         Assert(NULL != privateData);
 286
 287         WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = privateData->getCallbackManager();
 288         MessageAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 289
 290         WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr recipientCallbackManager = privateData->getRecipientCallbackManager();
 291
 292         JSContextRef context = callbackManager->getContext();
 293         Assert(NULL != context);
 294
 295     if (WrtDeviceApis::Commons::ExceptionCodes::None != event->getExceptionCode()) {
 296         switch (event->getExceptionCode()) {
 297         case WrtDeviceApis::Commons::ExceptionCodes::PlatformException:
 298         case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
 299                         error = JSTizenExceptionFactory::makeErrorObject(context,
 300                                                 JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
 301                         break;
 302         default:
 303             error = JSTizenExceptionFactory::makeErrorObject(context,
 304                                                 JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
 305                         break;
 306         }
 307     }
 308
 309         ConverterMessage converter(context);
 310         //JSValueRef recipient = converter.toJSValueRef(event->getRecipient());
 311
 312         //remove operation handle
 313         if (event->m_messagingService)
 314         {
 315                 LoggerD("Operation ID : " << event->opId);
 316                 event->m_messagingService->deleteOpId(event->opId);
 317         }
 318         if (WrtDeviceApis::Commons::ExceptionCodes::None == event->getExceptionCode()) {
 319                 LoggerD(" success size : " << event->m_successRecipients.size());
 320
 321              //JSObjectRef result = JSObjectMakeArray(context, event->m_successRecipients.size(), jsMessagingServiceObject, NULL);
 322                 std::vector<JSValueRef> successRecipentList;
 323
 324                 int cnt = event->m_successRecipients.size();
 325                 LoggerD( "success count : " << cnt);
 326
 327
 328                 for(int index = 0; index < cnt; index++)
 329                 {
 330                         LoggerD( "success recipent : " << event->m_successRecipients[index]);
 331                         successRecipentList.push_back(converter.toJSValueRef(event->m_successRecipients[index]));
 332                 }
 333
 334                 JSObjectRef result = JSObjectMakeArray(context, cnt, successRecipentList.data(), NULL);
 335                 callbackManager->callOnSuccess(result);
 336
 337         }
 338         else {
 339                 //JSValueRef params[] = { error, recipient };
 340                 //callbackManager->callOnError( params, sizeof(params) / sizeof(params[0]));
 341                 callbackManager->callOnError(error);
 342         }
 343
 344 #if 0 //old style code
 345     if (!event->getSendCallbackPerRecipient()) {
 346         //this is callback for whole operation, not single recipient
 347         if (WrtDeviceApis::Commons::ExceptionCodes::None == event->getExceptionCode()) {
 348             callbackManager->callOnSuccess();
 349         } else {
 350             callbackManager->callOnError(error);
 351         }
 352     } else if (recipientCallbackManager) {
 353         //this is callback for single recipient
 354         ConverterMessage converter(context);
 355         JSValueRef recipient = converter.toJSValueRef(event->getRecipient());
 356         if (WrtDeviceApis::Commons::ExceptionCodes::None == event->getExceptionCode()) {
 357             recipientCallbackManager->callOnSuccess(recipient);
 358         } else {
 359             JSValueRef params[] = { error, recipient };
 360             recipientCallbackManager->callOnError( params, sizeof(params) / sizeof(params[0]));
 361         }
 362     }
 363 #endif
 364
 365 }
 366
 367 }
 368 }
 369