src/Filesystem/ResponseDispatcher.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 "ResponseDispatcher.h"
  19
  20 #include <dpl/assert.h>
  21
  22 #include <Commons/Exception.h>
  23 #include <Commons/IEvent.h>
  24 #include <CommonsJavaScript/JSUtils.h>
  25 #include <JSTizenExceptionFactory.h>
  26 #include <JSTizenException.h>
  27 #include "JSFile.h"
  28 #include "JSFilestream.h"
  29 #include "EventGetNodeData.h"
  30 #include "Converter.h"
  31 #include "FilesystemAsyncCallbackManager.h"
  32 #include "Encodings.h"
  33 #include "FilesystemUtils.h"
  34 #include <Logger.h>
  35
  36 using namespace WrtDeviceApis;
  37 using namespace WrtDeviceApis::Commons;
  38 using namespace WrtDeviceApis::CommonsJavaScript;
  39 using namespace DeviceAPI::Common;
  40
  41 namespace DeviceAPI {
  42 namespace Filesystem {
  43 ResponseDispatcher& ResponseDispatcher::getInstance()
  44 {
  45         static ResponseDispatcher dispatcher;
  46         return dispatcher;
  47 }
  48
  49 ResponseDispatcher::ResponseDispatcher() :
  50         EventAnswerReceiver<EventResolve>(ThreadEnum::NULL_THREAD),
  51         EventAnswerReceiver<EventGetStorage>(ThreadEnum::NULL_THREAD),
  52         EventAnswerReceiver<EventListStorages>(ThreadEnum::NULL_THREAD),
  53         EventAnswerReceiver<EventListNodes>(ThreadEnum::NULL_THREAD),
  54         EventAnswerReceiver<EventOpen>(ThreadEnum::NULL_THREAD),
  55         EventAnswerReceiver<EventCopy>(ThreadEnum::NULL_THREAD),
  56         EventAnswerReceiver<EventMove>(ThreadEnum::NULL_THREAD),
  57         EventAnswerReceiver<EventRemove>(ThreadEnum::NULL_THREAD),
  58         EventAnswerReceiver<EventReadText>(ThreadEnum::NULL_THREAD)
  59 {
  60 }
  61
  62 void ResponseDispatcher::OnAnswerReceived(const EventResolvePtr& event)
  63 {
  64         LoggerD("ENTER");
  65         EventGetNodeDataPtr data =
  66         DPL::DynamicPointerCast<EventGetNodeData>(event->getPrivateData());
  67         Assert(NULL != data);
  68
  69         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data->getCallbackManager());
  70
  71         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
  72                 event->getResult()->setPermissions(data->getPerms());
  73                 JSFile::PrivateObjectDefPtr privData(new JSFile::PrivateObjectDef(event->getResult(), JSFile::PrivateObjectDef::PermissionList()));
  74
  75                 JSObjectRef object = JSUtils::makeObject(data->getCallbackManager()->getContext(), JSFile::getClassRef(), privData);
  76                 data->getCallbackManager()->callOnSuccess(object);
  77         }  else {
  78                 JSObjectRef jsException;
  79                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
  80                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getCallbackManager()->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
  81                 } else {
  82                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getCallbackManager()->getContext(), JSTizenException::UNKNOWN_ERROR, "Unknown error");
  83                 }
  84                 data->getCallbackManager()->callOnError(jsException);
  85         }
  86 }
  87
  88
  89 void ResponseDispatcher::OnAnswerReceived(const EventListNodesPtr& event)
  90 {
  91         LoggerD("ENTER");
  92         JSFile::ListFilesPrivateDataPtr privData =
  93         DPL::DynamicPointerCast<JSFile::ListFilesPrivateData>(event->getPrivateData());
  94
  95         JSCallbackManagerPtr data = privData->getCallbackManager();
  96         Assert(NULL != data);
  97
  98         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
  99
 100         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 101                 Converter converter(data->getContext());
 102                 Try {
 103                         JSValueRef result = converter.toJSValueRef(event->getResult(), privData->getParentPermissions(), data->getContext());
 104                         data->callOnSuccess(result);
 105                 }
 106                 Catch(WrtDeviceApis::Commons::ConversionException) {
 107                         data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error"));
 108                 }
 109         } else {
 110                 JSObjectRef jsException = NULL;
 111                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
 112                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
 113                 } else {
 114                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 115                 }
 116                 data->callOnError(jsException);
 117         }
 118 }
 119
 120 void ResponseDispatcher::OnAnswerReceived(const EventOpenPtr& event)
 121 {
 122         LoggerD("ENTER");
 123         DPL::SharedPtr<JSCallbackManager> data =
 124         DPL::DynamicPointerCast<JSCallbackManager>(event->getPrivateData());
 125         Assert(NULL != data);
 126
 127         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
 128
 129         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 130                 JSObjectRef object = JSUtils::makeObject(data->getContext(), JSFilestream::getClassRef(), event->getResult());
 131                 data->callOnSuccess(object);
 132         } else {
 133                 JSObjectRef jsException;
 134
 135                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
 136                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
 137                 }
 138                 else {
 139                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 140                 }
 141                 data->callOnError(jsException);
 142         }
 143 }
 144
 145 void ResponseDispatcher::OnAnswerReceived(const EventCopyPtr& event)
 146 {
 147         LoggerD("ENTER");
 148         DPL::SharedPtr<JSCallbackManager> data =
 149         DPL::DynamicPointerCast<JSCallbackManager>(event->getPrivateData());
 150         Assert(NULL != data);
 151
 152         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
 153
 154         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 155                 JSFile::PrivateObjectDefPtr privData(new JSFile::PrivateObjectDef(
 156                 event->getResult(),
 157                 JSFile::PrivateObjectDef::PermissionList()));
 158
 159                 JSObjectRef object = JSUtils::makeObject(data->getContext(), JSFile::getClassRef(), privData);
 160                 data->callOnSuccess(object);
 161         } else {
 162                 JSObjectRef jsException = NULL;
 163                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
 164                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
 165                 }
 166                 else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
 167                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
 168                 }
 169                 else {
 170                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 171                 }
 172                 data->callOnError(jsException);
 173         }
 174 }
 175
 176 void ResponseDispatcher::OnAnswerReceived(const EventMovePtr& event)
 177 {
 178         LoggerD("ENTER");
 179         DPL::SharedPtr<JSCallbackManager> data =
 180         DPL::DynamicPointerCast<JSCallbackManager>(event->getPrivateData());
 181         Assert(NULL != data);
 182
 183         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
 184
 185         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 186                 JSFile::PrivateObjectDefPtr privData(new JSFile::PrivateObjectDef(
 187                 event->getResult(),
 188                 JSFile::PrivateObjectDef::PermissionList()));
 189                 JSObjectRef object = JSUtils::makeObject(data->getContext(),
 190                                  JSFile::getClassRef(),
 191                                  privData);
 192                 data->callOnSuccess(object);
 193         } else {
 194                 JSObjectRef jsException = NULL;
 195                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
 196                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
 197                 }
 198                 else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
 199                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
 200                 }
 201                 else {
 202                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 203                 }
 204                 data->callOnError(jsException);
 205         }
 206 }
 207
 208 void ResponseDispatcher::OnAnswerReceived(const EventRemovePtr& event)
 209 {
 210         LoggerD("--| ENTER");
 211         DPL::SharedPtr<JSCallbackManager> data =
 212         DPL::DynamicPointerCast<JSCallbackManager>(event->getPrivateData());
 213         Assert(NULL != data);
 214
 215         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
 216
 217         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 218                 data->callOnSuccess();
 219         } else {
 220                 JSObjectRef jsException = NULL;
 221                 if (event->getExceptionCode() ==WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
 222                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
 223                 }
 224                 else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
 225                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
 226                 }
 227                 else {
 228                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 229                 }
 230                 data->callOnError(jsException);
 231         }
 232 }
 233
 234 void ResponseDispatcher::OnAnswerReceived(const EventReadTextPtr& event)
 235 {
 236         LoggerD("--| ENTER");
 237         DPL::SharedPtr<JSCallbackManager> data =
 238         DPL::DynamicPointerCast<JSCallbackManager>(event->getPrivateData());
 239         Assert(NULL != data);
 240
 241         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
 242
 243         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 244                 Converter converter(data->getContext());
 245                 Try {
 246                         std::string resultText = event->getResult();
 247                         std::string currentEncoding = event->getCharSet();
 248                         std::string utf8OutStr = "";
 249                         JSValueRef result;
 250
 251                         if (!strcmp(currentEncoding.c_str(), Encodings::UTF8) || !strcmp(currentEncoding.c_str(), Encodings::ISO88591))
 252                         {
 253                                 result = converter.toJSValueRef(resultText);
 254                                 data->callOnSuccess(result);
 255                         }
 256                         else
 257                         {
 258                                 Utils::toUTF8String(currentEncoding, resultText.c_str(), resultText.length(), utf8OutStr);
 259                                 result = converter.toJSValueRef(utf8OutStr);
 260                                 data->callOnSuccess(result);
 261                         }
 262                 }
 263                 Catch(WrtDeviceApis::Commons::ConversionException) {
 264                         data->callOnError(JSTizenExceptionFactory::makeErrorObject(
 265                         data->getContext(), JSTizenException::IO_ERROR, "IO error"));
 266                 }
 267         }  else {
 268                 JSObjectRef jsException = NULL;
 269                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
 270                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
 271                 }
 272                 else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
 273                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
 274                 }
 275                 else {
 276                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 277                 }
 278                 data->callOnError(jsException);
 279         }
 280 }
 281
 282 void ResponseDispatcher::OnAnswerReceived(const EventGetStoragePtr& event)
 283 {
 284         DPL::SharedPtr<JSCallbackManager> data = DPL::DynamicPointerCast<JSCallbackManager>(event->getPrivateData());
 285         Assert(NULL != data);
 286
 287         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
 288
 289         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 290                 Converter converter(data->getContext());
 291                 Try {
 292                         JSValueRef result = converter.toJSValueRef(event->getResult(), data->getContext());
 293                         data->callOnSuccess(result);
 294                 } Catch (WrtDeviceApis::Commons::ConversionException) {
 295                         data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error"));
 296                 }
 297         } else {
 298                 JSObjectRef jsException = NULL;
 299                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
 300                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
 301                 }
 302                 else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
 303                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "Not found error");
 304                 }
 305                 else {
 306                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 307                 }
 308                 data->callOnError(jsException);
 309         }
 310 }
 311
 312 void ResponseDispatcher::OnAnswerReceived(const EventListStoragesPtr& event)
 313 {
 314         DPL::SharedPtr<JSCallbackManager> data = DPL::DynamicPointerCast<JSCallbackManager>(event->getPrivateData());
 315         Assert(NULL != data);
 316
 317         FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
 318
 319         if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
 320                 Converter converter(data->getContext());
 321                 Try {
 322                         JSValueRef result = converter.toJSValueRef(event->getResult(), data->getContext());
 323                         data->callOnSuccess(result);
 324                 } Catch (WrtDeviceApis::Commons::ConversionException) {
 325                         data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error"));
 326                 }
 327         } else {
 328                 JSObjectRef jsException = NULL;
 329                 if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
 330                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
 331                 } else {
 332                         jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
 333                 }
 334                 data->callOnError(jsException);
 335         }
 336 }
 337
 338 }
 339 }