Git Init
[profile/ivi/wrt-plugins-tizen.git] / 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 }