src/standards/Tizen/Account/ResponseDispatcher.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 "ResponseDispatcher.h"
  19 #include <dpl/log/log.h>
  20 #include <CommonsJavaScript/JSCallbackManager.h>
  21 #include <CommonsJavaScript/JSDOMExceptionFactory.h>
  22 #include "AccountConverter.h"
  23
  24
  25 using namespace TizenApis::Api::Account;
  26 using namespace WrtDeviceApis::Commons;
  27 using namespace WrtDeviceApis::CommonsJavaScript;
  28
  29 namespace TizenApis {
  30 namespace Tizen1_0 {
  31 namespace Account{
  32 AccountResponseDispatcher& AccountResponseDispatcher::getInstance()
  33 {
  34     static AccountResponseDispatcher instance;
  35     return instance;
  36 }
  37
  38 AccountResponseDispatcher::AccountResponseDispatcher() :
  39     AccountEventAnswerReceiverCreate(ThreadEnum::NULL_THREAD),
  40     AccountEventAnswerReceiverAdd(ThreadEnum::NULL_THREAD),
  41     AccountEventAnswerReceiverDelete(ThreadEnum::NULL_THREAD),
  42     AccountEventAnswerReceiverUpdate(ThreadEnum::NULL_THREAD),
  43     AccountEventAnswerReceiverFind(ThreadEnum::NULL_THREAD),
  44     GetAccountServicesEventAnswerReceiver(ThreadEnum::NULL_THREAD)
  45 {
  46     LogDebug("entered");
  47 }
  48
  49 AccountResponseDispatcher::~AccountResponseDispatcher()
  50 {
  51     LogDebug("entered");
  52 }
  53
  54 void AccountResponseDispatcher::OnAnswerReceived(
  55         const IEventCreateAccountPtr &event)
  56 {
  57     LogDebug("entered");
  58     JSCallbackManagerPtr cbm =
  59         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  60     Try
  61     {
  62         if (!cbm) {
  63             LogDebug("no callback manager");
  64             return;
  65         }
  66         if (event->getResult()) {
  67             LogDebug("result success");
  68             AccountConverterFactory::ConverterType converter =
  69                 AccountConverterFactory::getConverter(cbm->getContext());
  70             cbm->callOnSuccess(converter->toJSValueRefAccount(event->getEvent()));
  71             return;
  72         }
  73         LogDebug("result fail");
  74     }
  75     Catch(ConversionException)
  76     {
  77         LogError("cannot convert event");
  78     }
  79     JSValueRef errorObject = JSDOMExceptionFactory::UnknownException.make(
  80             cbm->getContext());
  81     cbm->callOnError(errorObject);
  82 }
  83
  84
  85
  86 void AccountResponseDispatcher::OnAnswerReceived(
  87         const IEventAddAccountPtr &event)
  88 {
  89     LogDebug("entered");
  90     JSCallbackManagerPtr cbm =
  91         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  92     Try
  93     {
  94         if (!cbm) {
  95             LogDebug("no callback manager");
  96             return;
  97         }
  98         if (event->getResult()) {
  99             LogDebug("result success");
 100             AccountConverterFactory::ConverterType converter =
 101                 AccountConverterFactory::getConverter(cbm->getContext());
 102             cbm->callOnSuccess(converter->toJSValueRefAccount(event->getEvent()));
 103             return;
 104         }
 105         LogDebug("result fail");
 106     }
 107     Catch(ConversionException)
 108     {
 109         LogError("cannot convert event");
 110     }
 111     JSValueRef errorObject = JSDOMExceptionFactory::UnknownException.make(
 112             cbm->getContext());
 113     cbm->callOnError(errorObject);
 114 }
 115
 116 void AccountResponseDispatcher::OnAnswerReceived(
 117         const IEventDeleteAccountPtr &event)
 118 {
 119     LogDebug("entered");
 120     JSCallbackManagerPtr cbm =
 121         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 122     if (!cbm) {
 123         LogDebug("no callback manager");
 124         return;
 125     }
 126     if (event->getResult()) {
 127         cbm->callOnSuccess();
 128     } else {
 129         JSValueRef errorObject;
 130         if (event->getExceptionCode() ==
 131             ExceptionCodes::NotFoundException) {
 132             errorObject = JSDOMExceptionFactory::NotFoundException.make(
 133                     cbm->getContext());
 134         } else {
 135             errorObject = JSDOMExceptionFactory::UnknownException.make(
 136                     cbm->getContext());
 137         }
 138         cbm->callOnError(errorObject);
 139     }
 140 }
 141
 142
 143
 144 void AccountResponseDispatcher::OnAnswerReceived(
 145         const IEventUpdateAccountPtr &event)
 146 {
 147     LogDebug("entered");
 148     JSCallbackManagerPtr cbm =
 149         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 150     if (!cbm) {
 151         LogDebug("no callback manager");
 152         return;
 153     }
 154     if (event->getResult()) {
 155         cbm->callOnSuccess();
 156     } else {
 157         JSValueRef errorObject = JSDOMExceptionFactory::UnknownException.make(
 158                 cbm->getContext());
 159         cbm->callOnError(errorObject);
 160     }
 161 }
 162
 163
 164
 165 void AccountResponseDispatcher::OnAnswerReceived(
 166         const IEventFindAccountsPtr &event)
 167 {
 168     LogDebug("entered");
 169     JSCallbackManagerPtr cbm =
 170         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 171     if (!cbm) {
 172         LogError("no callback manager");
 173         return;
 174     }
 175     Try
 176     {
 177         if (event->getResult()) {
 178             AccountConverterFactory::ConverterType converter =
 179                 AccountConverterFactory::getConverter(cbm->getContext());
 180             const std::vector<EventAccountPtr> &results = event->getEvents();
 181             JSValueRef result = converter->toJSValueRef(results);
 182             cbm->callOnSuccess(result);
 183             return;
 184         }
 185     }
 186     Catch(Exception)
 187     {
 188         LogError("error during processing answer");
 189     }
 190     JSValueRef errorObject =
 191         JSDOMExceptionFactory::UnknownException.make(cbm->getContext());
 192     cbm->callOnError(errorObject);
 193 }
 194
 195 void AccountResponseDispatcher::OnAnswerReceived(
 196         const IEventGetAccountServicesPtr &event)
 197 {
 198     LogDebug("entered");
 199     JSCallbackManagerPtr cbm =
 200         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 201     if (!cbm) {
 202         LogError("no callback manager");
 203         return;
 204     }
 205 //    Try
 206 //    {
 207 //        if (event->getResult()) {
 208 //
 209 //                      LogDebug("event->getResult() entered");
 210 //            AccountConverterFactory::ConverterType converter =
 211 //                AccountConverterFactory::getConverter(cbm->getContext());
 212 //            const std::vector<IAccountServicePtr> &results = event->getAccountServices();
 213 //            LogDebug("found AccountServices: " << results.size());
 214 //            JSValueRef result = converter->toJSValueRef(results);
 215 //            cbm->callOnSuccess(result);
 216 //            return;
 217 //        }
 218 //    }
 219 //    Catch(Exception)
 220 //    {
 221 //        LogError("error during processing answer");
 222 //    }
 223     JSValueRef errorObject = JSDOMExceptionFactory::UnknownException.make(
 224             cbm->getContext());
 225     cbm->callOnError(errorObject);
 226 }
 227
 228
 229
 230 }
 231 }
 232 }