src/SystemSetting/SystemSettingResponseDispatcher.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 "SystemSettingResponseDispatcher.h"
  19 #include <CommonsJavaScript/JSCallbackManager.h>
  20 #include <JSTizenException.h>
  21 #include <JSTizenExceptionFactory.h>
  22 #include <FilesystemUtils.h>
  23 #include "SystemSettingAsyncCallbackManager.h"
  24 #include <Logger.h>
  25
  26 using namespace DeviceAPI::Common;
  27 using namespace WrtDeviceApis::Commons;
  28 using namespace WrtDeviceApis::CommonsJavaScript;
  29
  30 namespace DeviceAPI {
  31 namespace SystemSetting {
  32
  33 SystemSettingResponseDispatcher& SystemSettingResponseDispatcher::getInstance()
  34 {
  35     static SystemSettingResponseDispatcher instance;
  36     return instance;
  37 }
  38
  39 SystemSettingResponseDispatcher::SystemSettingResponseDispatcher() :
  40     SystemSettingSetWallpaperEventAnswerReceiverRequest(ThreadEnum::NULL_THREAD),
  41     SystemSettingSetRingtoneEventAnswerReceiverRequest(ThreadEnum::NULL_THREAD),
  42     SystemSettingSetSettingEventAnswerReceiverRequest(ThreadEnum::NULL_THREAD),
  43     SystemSettingGetSettingEventAnswerReceiverRequest(ThreadEnum::NULL_THREAD)
  44 {
  45 }
  46
  47 SystemSettingResponseDispatcher::~SystemSettingResponseDispatcher()
  48 {
  49 }
  50
  51 void SystemSettingResponseDispatcher::OnAnswerReceived(const EventSetWallpaperPtr &event)
  52 {
  53         LoggerD("entered");
  54         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager >(event->getPrivateData());
  55
  56         if (!callbackManager) {
  57                 LoggerE("No listener callback!");
  58                 return;
  59         }
  60
  61         JSContextRef gContext = callbackManager->getContext();
  62         JSValueRef error = NULL;
  63
  64         if (ExceptionCodes::None != event->getExceptionCode())
  65         {
  66                 switch (event->getExceptionCode())
  67                 {
  68                 case ExceptionCodes::PlatformException:
  69                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
  70                         break;
  71                 case ExceptionCodes::NotFoundException:
  72                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
  73                         break;
  74                 case ExceptionCodes::InvalidArgumentException:
  75                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
  76                         break;
  77                 case ExceptionCodes::ConversionException:
  78                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
  79                         break;
  80                 default:
  81                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
  82                         break;
  83                 }
  84                 LoggerD("callOnError");
  85                 callbackManager->callOnError(error);
  86                 return;
  87         }
  88         LoggerD("callOnSuccess");
  89         callbackManager->callOnSuccess();
  90 }
  91
  92
  93 void SystemSettingResponseDispatcher::OnAnswerReceived(const EventSetRingtonePtr &event)
  94 {
  95         LoggerD("entered");
  96         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager >(event->getPrivateData());
  97
  98         if (!callbackManager) {
  99                 LoggerE("No listener callback!");
 100                 return;
 101         }
 102
 103         JSContextRef gContext = callbackManager->getContext();
 104         JSValueRef error = NULL;
 105
 106         if (ExceptionCodes::None != event->getExceptionCode())
 107         {
 108                 switch (event->getExceptionCode())
 109                 {
 110                 case ExceptionCodes::PlatformException:
 111                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
 112                         break;
 113                 case ExceptionCodes::NotFoundException:
 114                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
 115                         break;
 116                 case ExceptionCodes::InvalidArgumentException:
 117                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
 118                         break;
 119                 case ExceptionCodes::ConversionException:
 120                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
 121                         break;
 122                 default:
 123                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 124                         break;
 125                 }
 126
 127                 callbackManager->callOnError(error);
 128                 return;
 129         }
 130         callbackManager->callOnSuccess();
 131 }
 132
 133 void SystemSettingResponseDispatcher::OnAnswerReceived(const EventSetSettingPtr &event)
 134 {
 135         LoggerD("entered");
 136         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager >(event->getPrivateData());
 137
 138         if (!callbackManager) {
 139                 LoggerE("No listener callback!");
 140                 return;
 141         }
 142
 143         JSContextRef gContext = callbackManager->getContext();
 144         JSValueRef error = NULL;
 145
 146         SystemSettingAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 147
 148         if (ExceptionCodes::None != event->getExceptionCode())
 149         {
 150                 switch (event->getExceptionCode())
 151                 {
 152                 case ExceptionCodes::PlatformException:
 153                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
 154                         break;
 155                 case ExceptionCodes::NotFoundException:
 156                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
 157                         break;
 158                 case ExceptionCodes::InvalidArgumentException:
 159                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
 160                         break;
 161                 case ExceptionCodes::ConversionException:
 162                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
 163                         break;
 164                 default:
 165                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 166                         break;
 167                 }
 168
 169                 callbackManager->callOnError(error);
 170                 return;
 171         }
 172         callbackManager->callOnSuccess();
 173 }
 174
 175 void SystemSettingResponseDispatcher::OnAnswerReceived(const EventGetSettingPtr &event)
 176 {
 177         LoggerD("entered");
 178         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager >(event->getPrivateData());
 179
 180         if (!callbackManager) {
 181                 LoggerE("No listener callback!");
 182                 return;
 183         }
 184
 185         JSContextRef gContext = callbackManager->getContext();
 186         JSValueRef error = NULL;
 187
 188         SystemSettingAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 189
 190         Converter converter(gContext);
 191
 192         if (ExceptionCodes::None != event->getExceptionCode())
 193         {
 194                 switch (event->getExceptionCode())
 195                 {
 196                 case ExceptionCodes::PlatformException:
 197                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
 198                         break;
 199                 case ExceptionCodes::NotFoundException:
 200                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
 201                         break;
 202                 case ExceptionCodes::InvalidArgumentException:
 203                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
 204                         break;
 205                 case ExceptionCodes::ConversionException:
 206                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
 207                         break;
 208                 default:
 209                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 210                         break;
 211                 }
 212
 213                 callbackManager->callOnError(error);
 214                 return;
 215         }
 216         LoggerD("gettingValue : " << event->getSettingValue());
 217
 218         std::string settingPath = event->getSettingValue();
 219         LoggerD("RealSettingPath : " << settingPath);
 220
 221         Try
 222         {
 223                 settingPath = DeviceAPI::Filesystem::Utils::toVirtualPath(gContext, settingPath);
 224                 LoggerD("VirtualSettingPath : " << settingPath);
 225         }
 226         Catch(WrtDeviceApis::Commons::ConversionException) {
 227                 LoggerD("not the virtual path");
 228                 LoggerD("RealSettingSettingPath : " << settingPath);
 229         }
 230
 231         if (settingPath.size() == 0)
 232         {
 233                 error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 234                 callbackManager->callOnError(error);
 235                 return;
 236         }
 237 //      return converter.toJSValueRef(iconPath);
 238         callbackManager->callOnSuccess(converter.toJSValueRef(settingPath));
 239 }
 240
 241
 242
 243 }
 244 }