src/Calendar/CalendarResponseDispatcher.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 "CalendarResponseDispatcher.h"
  19 #include <CommonsJavaScript/JSCallbackManager.h>
  20 #include <JSWebAPIErrorFactory.h>
  21 #include "CalendarConverter.h"
  22 #include "JSCalendarEventId.h"
  23 #include "CalendarMultiCallback.h"
  24 #include "EventId.h"
  25
  26 #include <Logger.h>
  27 #include <GlobalContextManager.h>
  28
  29 using namespace WrtDeviceApis::Commons;
  30 using namespace WrtDeviceApis::CommonsJavaScript;
  31 using namespace DeviceAPI::Common;
  32
  33 namespace DeviceAPI {
  34 namespace Calendar {
  35
  36 CalendarResponseDispatcher& CalendarResponseDispatcher::getInstance()
  37 {
  38     static CalendarResponseDispatcher instance;
  39     return instance;
  40 }
  41
  42 CalendarResponseDispatcher::CalendarResponseDispatcher() :
  43     GetCalendarsEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  44     CalendarEventsEventAnswerReceiverAdds(ThreadEnum::NULL_THREAD),
  45     CalendarEventsEventAnswerReceiverDeletes(ThreadEnum::NULL_THREAD),
  46     CalendarEventsEventAnswerReceiverUpdates(ThreadEnum::NULL_THREAD),
  47     CalendarEventsEventAnswerReceiverFind(ThreadEnum::NULL_THREAD),
  48     CalendarEventsEventAnswerReceiverExpand(ThreadEnum::NULL_THREAD),
  49     OnEventsChangedListener(ThreadEnum::NULL_THREAD)
  50 {
  51 }
  52
  53 CalendarResponseDispatcher::~CalendarResponseDispatcher()
  54 {
  55 }
  56
  57 void CalendarResponseDispatcher::OnAnswerReceived(const IEventGetCalendarsPtr &event)
  58 {
  59     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  60     if (!cbm) {
  61                 LoggerE("no callback manager");
  62                 return;
  63     }
  64
  65     if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
  66         LoggerW("Global context invalidated.");
  67             return;
  68     }
  69
  70     Try
  71     {
  72         if (event->getResult()) {
  73             CalendarConverter converter(cbm->getContext());
  74             const std::vector<ICalendarPtr> &results = event->getCalendars();
  75             LoggerD("found calendars: " << results.size());
  76             JSValueRef result = converter.toJSValueRef(results);
  77             cbm->callOnSuccess(result);
  78             return;
  79         }
  80     }
  81     Catch(Exception)
  82     {
  83         LoggerE("error during processing answer");
  84     }
  85     JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
  86             cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
  87     cbm->callOnError(errorObject);
  88 }
  89
  90 void CalendarResponseDispatcher::OnAnswerReceived(const IEventAddEventsPtr &event)
  91 {
  92     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  93     Try
  94     {
  95         if (!cbm) {
  96                         LoggerD("no callback manager");
  97                         return;
  98         }
  99
 100             if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
 101                 LoggerW("Global context invalidated.");
 102                     return;
 103             }
 104
 105         if (event->getResult()) {
 106             LoggerD("result success");
 107             CalendarConverter converter(cbm->getContext());
 108
 109             JSValueRef result;
 110             if (CalendarEvent::TASK_TYPE==event->getCalendarType()) {
 111                 result = converter.toJSValueRefTaskArray(event->getEvents());
 112             } else {
 113                 result = converter.toJSValueRefEventArray(event->getEvents());
 114             }
 115
 116             cbm->callOnSuccess(result);
 117             return;
 118         }
 119         LoggerD("result fail");
 120     }
 121     Catch(ConversionException)
 122     {
 123         LoggerE("cannot convert event");
 124     }
 125     JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 126             cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 127     cbm->callOnError(errorObject);
 128 }
 129
 130 void CalendarResponseDispatcher::OnAnswerReceived(const IEventUpdateEventsPtr &event)
 131 {
 132     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 133     if (!cbm) {
 134         LoggerD("no callback manager");
 135         return;
 136     }
 137
 138     if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
 139                 LoggerW("Global context invalidated.");
 140                 return;
 141     }
 142
 143     if (event->getResult()) {
 144         cbm->callOnSuccess();
 145     } else {
 146         JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 147                 cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 148         cbm->callOnError(errorObject);
 149     }
 150 }
 151
 152 void CalendarResponseDispatcher::OnAnswerReceived(const IEventDeleteEventsPtr &event)
 153 {
 154     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 155     if (!cbm) {
 156         LoggerD("no callback manager");
 157         return;
 158     }
 159
 160     if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
 161                 LoggerW("Global context invalidated.");
 162                 return;
 163     }
 164
 165     if (event->getResult()) {
 166         cbm->callOnSuccess();
 167     } else {
 168         JSValueRef errorObject;
 169         if (event->getExceptionCode() ==
 170             ExceptionCodes::NotFoundException) {
 171             errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 172                     cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::NOT_FOUND_ERROR);
 173         } else {
 174             errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 175                     cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 176         }
 177         cbm->callOnError(errorObject);
 178     }
 179 }
 180
 181 void CalendarResponseDispatcher::OnAnswerReceived(const IEventFindEventsPtr &event)
 182 {
 183     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 184     if (!cbm) {
 185                 LoggerE("no callback manager");
 186                 return;
 187     }
 188
 189     if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
 190         LoggerW("Global context invalidated.");
 191             return;
 192     }
 193
 194     Try
 195     {
 196         if (event->getResult()) {
 197             CalendarConverter converter(cbm->getContext());
 198
 199             JSValueRef result;
 200             if (CalendarEvent::TASK_TYPE==event->getCalendarType()) {
 201                 result = converter.toJSValueRefTaskArray(event->getEvents());
 202             } else {
 203                 result = converter.toJSValueRefEventArray(event->getEvents());
 204             }
 205             cbm->callOnSuccess(result);
 206             return;
 207         } else {
 208             JSValueRef errorObject;
 209             if (event->getExceptionCode() == ExceptionCodes::InvalidArgumentException) {
 210                 errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 211                         cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR);
 212             } else if (event->getExceptionCode() == ExceptionCodes::NotFoundException) {
 213                 errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 214                         cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 215             } else {
 216                 errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 217                         cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 218             }
 219             cbm->callOnError(errorObject);
 220             return;
 221         }
 222     }
 223     Catch(Exception)
 224     {
 225         LoggerE("error during processing answer");
 226         JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 227                 cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 228         cbm->callOnError(errorObject);
 229     }
 230 }
 231
 232 void CalendarResponseDispatcher::OnAnswerReceived(const IEventExpandEventRecurrencePtr &event)
 233 {
 234     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 235     Try
 236     {
 237         if (!cbm) {
 238             LoggerD("no callback manager");
 239             return;
 240         }
 241
 242             if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
 243                         LoggerW("Global context invalidated.");
 244                         return;
 245             }
 246
 247         if (event->getResult()) {
 248             CalendarConverter converter(cbm->getContext());
 249             cbm->callOnSuccess(converter.toJSValueRefEventArray(event->getExpandedEventList()));
 250             return;
 251         } else {
 252             JSValueRef errorObject;
 253             if (event->getExceptionCode()==ExceptionCodes::InvalidArgumentException) {
 254                 errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 255                         cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR);
 256             } else if (event->getExceptionCode()==ExceptionCodes::NotFoundException) {
 257                 errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 258                         cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::NOT_FOUND_ERROR);
 259             } else {
 260                 errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 261                         cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 262             }
 263             cbm->callOnError(errorObject);
 264             return;
 265         }
 266     }
 267     Catch(Exception)
 268     {
 269         LoggerE("error during processing answer");
 270         JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
 271                 cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
 272         cbm->callOnError(errorObject);
 273     }
 274 }
 275
 276 void CalendarResponseDispatcher::onAnswerReceived(const OnEventsChangedPtr& event)
 277 {
 278     CalendarChangeCallbackPrivateDataPtr multiCallbacks =
 279         DPL::StaticPointerCast<CalendarChangeCallbackPrivateData>(event->getPrivateData());
 280     JSContextRef context = multiCallbacks->getOnAdded()->getContext();
 281
 282     CalendarConverter converter(context);
 283     JSValueRef result;
 284
 285     Try
 286     {
 287         switch (event->getStatus())
 288         {
 289             case OnEventsChanged::ON_ADD:
 290             {
 291                 if (CalendarEvent::TASK_TYPE==event->getCalendarType()) {
 292                     result = converter.toJSValueRefTaskArray(event->getEventList());
 293                 } else {
 294                     result = converter.toJSValueRefEventArray(event->getEventList());
 295                 }
 296
 297                 multiCallbacks->getOnAdded()->callOnSuccess(result);
 298                 break;
 299             }
 300             case OnEventsChanged::ON_UPDATE:
 301             {
 302                 if (CalendarEvent::TASK_TYPE==event->getCalendarType()) {
 303                     result = converter.toJSValueRefTaskArray(event->getEventList());
 304                 } else {
 305                     result = converter.toJSValueRefEventArray(event->getEventList());
 306                 }
 307                 multiCallbacks->getOnUpdated()->callOnSuccess(result);
 308                 break;
 309             }
 310             case OnEventsChanged::ON_DELETE:
 311             {
 312                 CalendarEventListPtr eventList = event->getEventList();
 313
 314                 JSObjectRef jsResult = JSCreateArrayObject(context, 0, NULL);
 315                 if (NULL == jsResult) {
 316                     ThrowMsg(ConversionException, "Could not create js array object");
 317                 }
 318
 319                 for (std::size_t i = 0; i < eventList->size(); i++) {
 320                     EventIdPtr eventId( new EventId() );
 321                     eventId->setUId(eventList->at(i)->getUId());
 322                     std::stringstream ss;
 323                     std::time_t rid = eventList->at(i)->getRecurrenceId();
 324                     ss<<rid;
 325                     eventId->setRecurrenceId(ss.str());
 326                     JSValueRef tmpVal =JSCalendarEventId::createJSCalendarEventId(context, eventId);
 327                     if (!JSSetArrayElement(context, jsResult, i, tmpVal)) {
 328                         ThrowMsg(ConversionException, "Could not create js array element");
 329                     }
 330                 }
 331
 332                 multiCallbacks->getOnDeleted()->callOnSuccess(jsResult);
 333                 break;
 334             }
 335             //case OnEventsChanged::ON_CALENDAR_RESET:
 336             default:
 337             {
 338                 LoggerD("Invalid status!");
 339                 break;
 340             }
 341         }
 342     }
 343     Catch(ConversionException)
 344     {
 345         LoggerE("cannot convert change event");
 346     }
 347     Catch(Exception)
 348     {
 349         LoggerE("exception occurred while handling change noti callback!");
 350     }
 351 }
 352
 353 }
 354 }