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