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