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.h>
  20 #include <CommonsJavaScript/JSCallbackManager.h>
  21 #include <Tizen/Common/JSTizenException.h>
  22 #include <Tizen/Common/JSTizenExceptionFactory.h>
  23 #include "CalendarConverter.h"
  24 #include "JSCalendarItem.h"
  25 #include "JSEventId.h"
  26 #include "CalendarMultiCallback.h"
  27 #include <API/Calendar/EventId.h>
  28
  29 using namespace TizenApis::Api::Calendar;
  30 using namespace WrtDeviceApis::Commons;
  31 using namespace WrtDeviceApis::CommonsJavaScript;
  32
  33 namespace TizenApis {
  34 namespace Tizen1_0 {
  35 namespace Calendar {
  36
  37 CalendarResponseDispatcher& CalendarResponseDispatcher::getInstance()
  38 {
  39     static CalendarResponseDispatcher instance;
  40     return instance;
  41 }
  42
  43 CalendarResponseDispatcher::CalendarResponseDispatcher() :
  44     GetCalendarsEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  45     CalendarEventsEventAnswerReceiverAdds(ThreadEnum::NULL_THREAD),
  46     CalendarEventsEventAnswerReceiverDeletes(ThreadEnum::NULL_THREAD),
  47     CalendarEventsEventAnswerReceiverUpdates(ThreadEnum::NULL_THREAD),
  48     CalendarEventsEventAnswerReceiverFind(ThreadEnum::NULL_THREAD),
  49     CalendarEventsEventAnswerReceiverExpand(ThreadEnum::NULL_THREAD),
  50     OnAddEventsChangedListener(ThreadEnum::NULL_THREAD),
  51     OnUpdateEventsChangedListener(ThreadEnum::NULL_THREAD),
  52     OnDeleteEventsChangedListener(ThreadEnum::NULL_THREAD),
  53     OnEventsChangedListener(ThreadEnum::NULL_THREAD)
  54 {
  55     LogDebug("entered");
  56 }
  57
  58 CalendarResponseDispatcher::~CalendarResponseDispatcher()
  59 {
  60     LogDebug("entered");
  61 }
  62
  63 void CalendarResponseDispatcher::OnAnswerReceived(
  64         const IEventGetCalendarsPtr &event)
  65 {
  66     LogDebug("entered");
  67     JSCallbackManagerPtr cbm =
  68         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  69     if (!cbm) {
  70         LogError("no callback manager");
  71         return;
  72     }
  73     Try
  74     {
  75         if (event->getResult()) {
  76             CalendarConverterFactory::ConverterType converter =
  77                 CalendarConverterFactory::getConverter(cbm->getContext());
  78             const std::vector<ICalendarPtr> &results = event->getCalendars();
  79             LogDebug("found calendars: " << results.size());
  80             JSValueRef result = converter->toJSValueRef(results);
  81             cbm->callOnSuccess(result);
  82             return;
  83         }
  84     }
  85     Catch(Exception)
  86     {
  87         LogError("error during processing answer");
  88     }
  89     JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
  90             cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
  91     cbm->callOnError(errorObject);
  92 }
  93
  94 void CalendarResponseDispatcher::OnAnswerReceived(const IEventAddEventsPtr &event)
  95 {
  96     LogDebug("entered");
  97     JSCallbackManagerPtr cbm =
  98         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  99     Try
 100     {
 101         if (!cbm) {
 102             LogDebug("no callback manager");
 103             return;
 104         }
 105         if (event->getResult()) {
 106             LogDebug("result success");
 107             CalendarConverterFactory::ConverterType converter =
 108                 CalendarConverterFactory::getConverter(cbm->getContext());
 109             cbm->callOnSuccess(converter->toJSValueRef(event->getEvents()));
 110             return;
 111         }
 112         LogDebug("result fail");
 113     }
 114     Catch(ConversionException)
 115     {
 116         LogError("cannot convert event");
 117     }
 118     JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 119             cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 120     cbm->callOnError(errorObject);
 121 }
 122
 123 void CalendarResponseDispatcher::onAnswerReceived(const OnAddEventsChangedPtr& event)
 124 {
 125     LogDebug("entered");
 126     CalendarEventsCallbackPrivateDataPtr multiCallbacks =
 127         DPL::StaticPointerCast<CalendarEventsCallbackPrivateData>(event->getPrivateData());
 128     JSContextRef context = multiCallbacks->getOnEvent()->getContext();
 129
 130     switch (event->getStatus())
 131     {
 132         case OnAddEventsChanged::EVENT_ADD_SUCCESS:
 133         {
 134             CalendarConverterFactory::ConverterType converter =
 135                 CalendarConverterFactory::getConverter(context);
 136             multiCallbacks->getOnEvent()->callOnSuccess(converter->toJSValueRefItem(event->getEvent()));
 137             break;
 138         }
 139         case OnAddEventsChanged::EVENT_ADD_FAIL:
 140         {
 141             CalendarConverterFactory::ConverterType converter =
 142                 CalendarConverterFactory::getConverter(context);
 143             JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 144                     context, TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 145             JSValueRef eventObject = converter->toJSValueRefItem(event->getEvent());
 146             JSValueRef obj[] = {errorObject, eventObject};
 147             multiCallbacks->getOnEvent()->callOnError(obj, 2);
 148             break;
 149         }
 150         default:
 151         {
 152             LogDebug("Invalid status!");
 153             JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 154                     context, TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 155             multiCallbacks->getOnEvent()->callOnError(errorObject);
 156             break;
 157         }
 158     }
 159 }
 160
 161 void CalendarResponseDispatcher::OnAnswerReceived(const IEventUpdateEventsPtr &event)
 162 {
 163     JSCallbackManagerPtr cbm =
 164         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 165     if (!cbm) {
 166         LogDebug("no callback manager");
 167         return;
 168     }
 169     if (event->getResult()) {
 170         cbm->callOnSuccess();
 171     } else {
 172         JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 173                 cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 174         cbm->callOnError(errorObject);
 175     }
 176 }
 177
 178 void CalendarResponseDispatcher::onAnswerReceived(const OnUpdateEventsChangedPtr& event)
 179 {
 180     LogDebug("entered");
 181     CalendarEventsCallbackPrivateDataPtr multiCallbacks =
 182         DPL::StaticPointerCast<CalendarEventsCallbackPrivateData>(event->getPrivateData());
 183     JSContextRef context = multiCallbacks->getOnEvent()->getContext();
 184
 185     switch (event->getStatus())
 186     {
 187         case OnUpdateEventsChanged::EVENT_UPDATE_SUCCESS:
 188         {
 189             CalendarConverterFactory::ConverterType converter =
 190                 CalendarConverterFactory::getConverter(context);
 191             multiCallbacks->getOnEvent()->callOnSuccess(converter->toJSValueRefItem(event->getEvent()));
 192             break;
 193         }
 194         case OnUpdateEventsChanged::EVENT_UPDATE_FAIL:
 195         {
 196             CalendarConverterFactory::ConverterType converter =
 197                 CalendarConverterFactory::getConverter(context);
 198             JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 199                     context, TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 200             JSValueRef eventObject = converter->toJSValueRefItem(event->getEvent());
 201             JSValueRef obj[] = {errorObject, eventObject};
 202             multiCallbacks->getOnEvent()->callOnError(obj, 2);
 203             break;
 204         }
 205         default:
 206         {
 207             LogDebug("Invalid status!");
 208             JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 209                     context, TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 210             multiCallbacks->getOnEvent()->callOnError(errorObject);
 211             break;
 212         }
 213     }
 214 }
 215
 216 void CalendarResponseDispatcher::OnAnswerReceived(const IEventDeleteEventsPtr &event)
 217 {
 218     JSCallbackManagerPtr cbm =
 219         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 220     if (!cbm) {
 221         LogDebug("no callback manager");
 222         return;
 223     }
 224     if (event->getResult()) {
 225         cbm->callOnSuccess();
 226     } else {
 227         JSValueRef errorObject;
 228         if (event->getExceptionCode() ==
 229             ExceptionCodes::NotFoundException) {
 230             errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 231                     cbm->getContext(), TizenApis::Commons::JSTizenException::NOT_FOUND_ERROR);
 232         } else {
 233             errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 234                     cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 235         }
 236         cbm->callOnError(errorObject);
 237     }
 238 }
 239
 240 void CalendarResponseDispatcher::onAnswerReceived(const OnDeleteEventsChangedPtr& event)
 241 {
 242     LogDebug("entered");
 243     CalendarEventsCallbackPrivateDataPtr multiCallbacks =
 244         DPL::StaticPointerCast<CalendarEventsCallbackPrivateData>(event->getPrivateData());
 245     JSContextRef context = multiCallbacks->getOnEvent()->getContext();
 246
 247     CalendarConverterFactory::ConverterType converter =
 248         CalendarConverterFactory::getConverter(context);
 249
 250     switch (event->getStatus())
 251     {
 252         case OnDeleteEventsChanged::EVENT_DELETE_SUCCESS:
 253         {
 254             multiCallbacks->getOnEvent()->callOnSuccess(
 255                 converter->toJSValueRef(event->getEventId()));
 256             break;
 257         }
 258         case OnDeleteEventsChanged::EVENT_DELETE_FAIL:
 259         {
 260             JSValueRef errorObject;
 261             if (event->getExceptionCode() == ExceptionCodes::NotFoundException) {
 262
 263                 errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 264                         context, TizenApis::Commons::JSTizenException::NOT_FOUND_ERROR);
 265             } else {
 266                 errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 267                         context, TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 268             }
 269
 270             JSValueRef eventObject = converter->toJSValueRef(event->getEventId());
 271             JSValueRef obj[] = {errorObject, eventObject};
 272             multiCallbacks->getOnEvent()->callOnError(obj, 2);
 273             break;
 274         }
 275         default:
 276         {
 277             LogDebug("Invalid status!");
 278             JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 279                     context, TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 280             multiCallbacks->getOnEvent()->callOnError(errorObject);
 281             break;
 282         }
 283     }
 284 }
 285
 286 void CalendarResponseDispatcher::OnAnswerReceived(const IEventFindEventsPtr &event)
 287 {
 288     JSCallbackManagerPtr cbm =
 289         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 290     if (!cbm) {
 291         LogError("no callback manager");
 292         return;
 293     }
 294     Try
 295     {
 296         if (event->getResult()) {
 297             CalendarConverterFactory::ConverterType converter =
 298                 CalendarConverterFactory::getConverter(cbm->getContext());
 299
 300             JSValueRef result = converter->toJSValueRef(event->getEvents());
 301             cbm->callOnSuccess(result);
 302             return;
 303         } else {
 304             JSValueRef errorObject;
 305             if (event->getExceptionCode() ==
 306                 ExceptionCodes::NotFoundException) {
 307                 errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 308                         cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 309             } else {
 310                 errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 311                         cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 312             }
 313             cbm->callOnError(errorObject);
 314         }
 315     }
 316     Catch(Exception)
 317     {
 318         LogError("error during processing answer");
 319     }
 320     JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 321             cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 322     cbm->callOnError(errorObject);
 323 }
 324
 325 void CalendarResponseDispatcher::OnAnswerReceived(const IEventExpandEventRecurrencePtr &event)
 326 {
 327     LogDebug("entered");
 328     JSCallbackManagerPtr cbm =
 329         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 330     Try
 331     {
 332         if (!cbm) {
 333             LogDebug("no callback manager");
 334             return;
 335         }
 336         if (event->getResult()) {
 337             CalendarConverterFactory::ConverterType converter =
 338                 CalendarConverterFactory::getConverter(cbm->getContext());
 339             cbm->callOnSuccess(converter->toJSValueRef(event->getExpandedEventList()));
 340             return;
 341         } else {
 342             JSValueRef errorObject;
 343             if (event->getExceptionCode() ==
 344                 ExceptionCodes::NotFoundException) {
 345                 errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 346                         cbm->getContext(), TizenApis::Commons::JSTizenException::NOT_FOUND_ERROR);
 347             } else {
 348                 errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 349                         cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 350             }
 351             cbm->callOnError(errorObject);
 352         }
 353         LogDebug("result fail");
 354     }
 355     Catch(ConversionException)
 356     {
 357         LogError("cannot convert event");
 358     }
 359     JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 360             cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 361     cbm->callOnError(errorObject);
 362 }
 363
 364 void CalendarResponseDispatcher::onAnswerReceived(const OnEventsChangedPtr& event)
 365 {
 366     LogDebug("entered");
 367     CalendarChangeCallbackPrivateDataPtr multiCallbacks =
 368         DPL::StaticPointerCast<CalendarChangeCallbackPrivateData>(event->getPrivateData());
 369     JSContextRef context = multiCallbacks->getOnAdded()->getContext();
 370
 371     CalendarConverterFactory::ConverterType converter = CalendarConverterFactory::getConverter(context);
 372
 373     Try
 374     {
 375         switch (event->getStatus())
 376         {
 377             case OnEventsChanged::ON_ADD:
 378             {
 379                 multiCallbacks->getOnAdded()->callOnSuccess(converter->toJSValueRef(event->getEventList()));
 380                 break;
 381             }
 382             case OnEventsChanged::ON_UPDATE:
 383             {
 384                 multiCallbacks->getOnUpdated()->callOnSuccess(converter->toJSValueRef(event->getEventList()));
 385                 break;
 386             }
 387             case OnEventsChanged::ON_DELETE:
 388             {
 389                 CalendarEventListPtr eventList = event->getEventList();
 390
 391                 JSObjectRef jsResult = JSCreateArrayObject(context, 0, NULL);
 392                 if (NULL == jsResult) {
 393                     ThrowMsg(ConversionException, "Could not create js array object");
 394                 }
 395
 396                 for (std::size_t i = 0; i < eventList->size(); i++) {
 397                     EventIdPtr eventId( new EventId() );
 398                     eventId->setUId(eventList->at(i)->getUId());
 399                     eventId->setRecurrenceId(eventList->at(i)->getRecurrenceId());
 400                     JSValueRef tmpVal = converter->toJSValueRef(eventId);
 401                     if (!JSSetArrayElement(context, jsResult, i, tmpVal)) {
 402                         ThrowMsg(ConversionException, "Could not create js array element");
 403                     }
 404                 }
 405
 406                 multiCallbacks->getOnDeleted()->callOnSuccess(jsResult);
 407                 break;
 408             }
 409             //case OnEventsChanged::ON_CALENDAR_RESET:
 410             default:
 411             {
 412                 LogDebug("Invalid status!");
 413                 JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 414                         context, TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 415                 multiCallbacks->getOnAdded()->callOnError(errorObject);
 416                 break;
 417             }
 418         }
 419     }
 420     Catch(ConversionException)
 421     {
 422         LogError("cannot convert change event");
 423     }
 424     Catch(Exception)
 425     {
 426         LogError("exception occurred while handling change noti callback!");
 427     }
 428 }
 429
 430 }
 431 }
 432 }