src/DataControl/DataControlListener.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 <JavaScriptCore/JavaScript.h>
  19 #include <dpl/shared_ptr.h>
  20 #include <CommonsJavaScript/PrivateObject.h>
  21 #include <CommonsJavaScript/JSCallbackManager.h>
  22 #include <Commons/IEvent.h>
  23 #include <CommonsJavaScript/Utils.h>
  24 #include "DataControlListener.h"
  25 #include "DataControlConverter.h"
  26 #include "DataControlAsyncCallbackManager.h"
  27 #include "JSSelectObjectArrayValues.h"
  28 #include <CommonsJavaScript/JSUtils.h>
  29 #include <JSTizenExceptionFactory.h>
  30 #include <JSTizenException.h>
  31 #include <Logger.h>
  32
  33 using namespace DeviceAPI::Common;
  34 using namespace WrtDeviceApis::Commons;
  35 using namespace WrtDeviceApis::CommonsJavaScript;
  36
  37 namespace DeviceAPI {
  38 namespace DataControl {
  39
  40 DataControlListener::DataControlListener() :
  41         EventInsertAnswerReceiver(ThreadEnum::NULL_THREAD),
  42         EventDeleteAnswerReceiver(ThreadEnum::NULL_THREAD),
  43         EventSelectAnswerReceiver(ThreadEnum::NULL_THREAD),
  44         EventUpdateAnswerReceiver(ThreadEnum::NULL_THREAD),
  45         EventAddValueAnswerReceiver(ThreadEnum::NULL_THREAD),
  46         EventRemoveValueAnswerReceiver(ThreadEnum::NULL_THREAD),
  47         EventGetValueAnswerReceiver(ThreadEnum::NULL_THREAD),
  48         EventUpdateValueAnswerReceiver(ThreadEnum::NULL_THREAD)
  49
  50         //,
  51 //      EventGetIndexedRowAnswerReceiver(ThreadEnum::NULL_THREAD)
  52 {
  53         LoggerD("entered");
  54 }
  55
  56
  57
  58 DataControlListener::~DataControlListener()
  59 {
  60         LoggerD("entered");
  61 }
  62
  63
  64 DataControlListener& DataControlListener::getInstance()
  65 {
  66         static DataControlListener instance;
  67         return instance;
  68 }
  69
  70 void DataControlListener::MakeErrorJSCallBack(JSCallbackManagerPtr cbm, JSContextRef globalContext,
  71         unsigned int error, unsigned int reqid, std::string errorMsg)
  72 {
  73         LoggerD("Enter");
  74         JSValueRef err[2];
  75         DataControlConverter converter(globalContext);
  76
  77         switch (error)
  78         {
  79                 case ExceptionCodes::SecurityException:
  80                         if (errorMsg.size() == 0)
  81                                 errorMsg = "permission denied error";
  82
  83                         err[0] = converter.toJSValueRef(reqid);
  84                         err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
  85                                 JSTizenException::PERMISSION_DENIED_ERROR, errorMsg);
  86
  87                         break;
  88                 case ExceptionCodes::UnsupportedException:
  89                         if (errorMsg.size() == 0)
  90                                 errorMsg = "unsupport error";
  91
  92                         err[0] = converter.toJSValueRef(reqid);
  93                         err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
  94                                 JSTizenException::NOT_SUPPORTED_ERROR, errorMsg);
  95
  96                         break;
  97                 case ExceptionCodes::NotFoundException:
  98                         if (errorMsg.size() == 0)
  99                                 errorMsg = "not found error";
 100
 101                         err[0] = converter.toJSValueRef(reqid);
 102                         err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
 103                                 JSTizenException::NOT_FOUND_ERROR, errorMsg);
 104
 105                         break;
 106                 case ExceptionCodes::AlreadyInUseException:
 107                         if (errorMsg.size() == 0)
 108                                 errorMsg = "service not available";
 109
 110                         err[0] = converter.toJSValueRef(reqid);
 111                         err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
 112                                 JSTizenException::SERVICE_NOT_AVAILABLE, errorMsg);
 113
 114                         break;
 115                 case ExceptionCodes::EventCancelledException:
 116
 117                         LoggerD("Enter - Event was cancled, callback will be silently discarded");
 118                         return;
 119                 case ExceptionCodes::UnknownException:
 120                 default:
 121                         if (errorMsg.size() == 0)
 122                                 errorMsg = "unknown error";
 123
 124                         err[0] = converter.toJSValueRef(reqid);
 125                         err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
 126                                 JSTizenException::UNKNOWN_ERROR, errorMsg);
 127
 128                         break;
 129         }
 130         cbm->callOnError(err, 2);
 131 }
 132
 133
 134 void DataControlListener::OnAnswerReceived(const EventInsertPtr& event)
 135 {
 136         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 137         JSContextRef globalContext = callbackManager->getContext();
 138         DataControlConverter converter(globalContext);
 139         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 140
 141         if (event->getExceptionCode() == ExceptionCodes::None)
 142         {
 143                 JSValueRef successArray[2];
 144                 int insertRowId = event->getInsertRowId();
 145                 LoggerD(event->getInsertRowId());
 146                 successArray[0] = converter.toJSValueRef(event->getReqId());
 147                 successArray[1] = converter.toJSValueRef(insertRowId);
 148
 149                 callbackManager->callOnSuccess(successArray, 2);
 150         }
 151         else
 152         {
 153                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 154         }
 155 }
 156 void DataControlListener::OnAnswerReceived(const EventDeletePtr& event)
 157 {
 158         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 159         JSContextRef globalContext = callbackManager->getContext();
 160         DataControlConverter converter(globalContext);
 161         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 162
 163         if (event->getExceptionCode() == ExceptionCodes::None)
 164         {
 165                 JSValueRef reqid = converter.toJSValueRef(event->getReqId());
 166                 callbackManager->callOnSuccess(reqid);
 167         }
 168         else
 169         {
 170                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 171         }
 172
 173 }
 174 void DataControlListener::OnAnswerReceived(const EventSelectPtr& event)
 175 {
 176         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 177         JSContextRef globalContext = callbackManager->getContext();
 178         DataControlConverter converter(globalContext);
 179         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 180
 181         if (event->getExceptionCode() == ExceptionCodes::None)
 182         {
 183                 std::string path = event->getResultSetPath();
 184
 185                 JSValueRef successArray[2];
 186                 successArray[0] = JSSelectObjectArrayValues::createJSObject(globalContext, path);
 187                 successArray[1] = converter.toJSValueRef(event->getReqId());
 188                 LoggerD(event->getReqId());
 189                 callbackManager->callOnSuccess(successArray, 2);
 190         }
 191         else
 192         {
 193                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 194         }
 195
 196 }
 197 void DataControlListener::OnAnswerReceived(const EventUpdatePtr& event)
 198 {
 199         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 200         JSContextRef globalContext = callbackManager->getContext();
 201         DataControlConverter converter(globalContext);
 202         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 203
 204         if (event->getExceptionCode() == ExceptionCodes::None)
 205         {
 206                 JSValueRef reqid = converter.toJSValueRef(event->getReqId());
 207                 callbackManager->callOnSuccess(reqid);
 208         }
 209         else
 210         {
 211                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 212         }
 213
 214 }
 215
 216 void DataControlListener::OnAnswerReceived(const EventAddValuePtr& event)
 217 {
 218         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 219         JSContextRef globalContext = callbackManager->getContext();
 220         DataControlConverter converter(globalContext);
 221         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 222
 223         if (event->getExceptionCode() == ExceptionCodes::None)
 224         {
 225                 JSValueRef reqid = converter.toJSValueRef(event->getReqId());
 226                 callbackManager->callOnSuccess(reqid);
 227         }
 228         else
 229         {
 230                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 231         }
 232
 233 }
 234
 235 void DataControlListener::OnAnswerReceived(const EventRemoveValuePtr& event)
 236 {
 237         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 238         JSContextRef globalContext = callbackManager->getContext();
 239         DataControlConverter converter(globalContext);
 240         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 241
 242         if (event->getExceptionCode() == ExceptionCodes::None)
 243         {
 244                 JSValueRef reqid = converter.toJSValueRef(event->getReqId());
 245                 callbackManager->callOnSuccess(reqid);
 246         }
 247         else
 248         {
 249                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 250         }
 251
 252 }
 253
 254 void DataControlListener::OnAnswerReceived(const EventGetValuePtr& event)
 255 {
 256         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 257         JSContextRef globalContext = callbackManager->getContext();
 258         DataControlConverter converter(globalContext);
 259         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 260
 261         if (event->getExceptionCode() == ExceptionCodes::None)
 262         {
 263                 std::vector<std::string> result = event->getResultValues();
 264
 265                 JSValueRef successArray[2];
 266                 successArray[0] = converter.toJSValueRef(result);
 267                 successArray[1] = converter.toJSValueRef(event->getReqId());
 268                 LoggerD(event->getReqId());
 269                 callbackManager->callOnSuccess(successArray, 2);
 270         }
 271         else
 272         {
 273                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 274         }
 275
 276 }
 277
 278 void DataControlListener::OnAnswerReceived(const EventUpdateValuePtr& event)
 279 {
 280         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 281         JSContextRef globalContext = callbackManager->getContext();
 282         DataControlConverter converter(globalContext);
 283         DataControlAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 284
 285         if (event->getExceptionCode() == ExceptionCodes::None)
 286         {
 287                 JSValueRef reqid = converter.toJSValueRef(event->getReqId());
 288                 callbackManager->callOnSuccess(reqid);
 289         }
 290         else
 291         {
 292                 MakeErrorJSCallBack(callbackManager, globalContext, (unsigned int)event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 293         }
 294
 295 }
 296
 297
 298 /*
 299 void DataControlListener::OnAnswerReceived(const EventGetIndexedRowPtr& event)
 300 {
 301         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 302         JSContextRef globalContext = callbackManager->getContext();
 303
 304         if (event->getExceptionCode() == ExceptionCodes::None)
 305         {
 306
 307         }
 308         else
 309         {
 310                 MakeErrorJSCallBack(callbackManager, globalContext, event->getExceptionCode(), event->getReqId(), event->getErrorMsg());
 311         }
 312
 313 }*/
 314
 315
 316
 317 }
 318 }