src/Application/ApplicationConverter.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 <CommonsJavaScript/JSUtils.h>
  19 #include <CommonsJavaScript/Validator.h>
  20 #include <CommonsJavaScript/ScopedJSStringRef.h>
  21 #include <Commons/RegexUtils.h>
  22 #include <Commons/Exception.h>
  23 #include <JSWebAPIError.h>
  24
  25 #include "ApplicationConverter.h"
  26 #include "JSApplication.h"
  27 #include "JSApplicationInformation.h"
  28 #include "JSApplicationContext.h"
  29 #include "JSApplicationControlData.h"
  30 #include "JSApplicationControlData.h"
  31 #include "JSApplicationControl.h"
  32 #include "JSRequestedApplicationControl.h"
  33 #include "JSApplicationCert.h"
  34
  35 namespace DeviceAPI {
  36 namespace Application {
  37
  38 using namespace DeviceAPI::Common;
  39 using namespace WrtDeviceApis;
  40 using namespace WrtDeviceApis::CommonsJavaScript;
  41
  42 ApplicationConverter::ApplicationConverter(JSContextRef context) : Converter(context)
  43 {
  44 }
  45
  46 ApplicationConverter::~ApplicationConverter()
  47 {
  48 }
  49
  50
  51 JSValueRef ApplicationConverter::toJSValueRefFromApplication(const ApplicationPtr &arg)
  52 {
  53         if(arg == NULL) {
  54                 Throw(Commons::ConversionException);
  55         }
  56         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplication::getClassRef(), arg);
  57 }
  58
  59
  60 JSValueRef ApplicationConverter::toJSValueRefFromApplicationCert(const ApplicationCertPtr &arg)
  61 {
  62         if(arg == NULL) {
  63                 Throw(Commons::ConversionException);
  64         }
  65         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationCert::getClassRef(), arg);
  66 }
  67
  68
  69 JSValueRef ApplicationConverter::toJSValueRefFromeApplicationCerts(const ApplicationCertArrayPtr &arg)
  70 {
  71         if(arg == NULL) {
  72                 Throw(Commons::InvalidArgumentException);
  73         }
  74         return toJSValueRef_(*arg, &ApplicationConverter::toJSValueRefFromApplicationCert, this);
  75 }
  76
  77
  78 JSValueRef ApplicationConverter::toJSValueRefFromApplicationInformation(const ApplicationInformationPtr &arg)
  79 {
  80         if(arg == NULL) {
  81                 Throw(Commons::ConversionException);
  82         }
  83         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationInformation::getClassRef(), arg);
  84 }
  85
  86 ApplicationInformationPtr ApplicationConverter::toApplicationInformation(const JSValueRef &jsValue)
  87 {
  88         if(JSApplicationInformation::isObjectOfClass(m_context, jsValue))
  89                 return JSApplicationInformation::getApplicationInformation(m_context, jsValue);
  90
  91         const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_NAME));
  92         const ScopedJSStringRef appIdStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_ID));
  93         const ScopedJSStringRef iconPathStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_ICONPATH));
  94         const ScopedJSStringRef versionStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_VERSION));
  95         const ScopedJSStringRef showStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_SHOW));
  96         const ScopedJSStringRef categoriesStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_CATEGORIES));
  97     const ScopedJSStringRef installDateStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_INSTALL_DATE));
  98         const ScopedJSStringRef installSizeStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_INSTALL_SIZE));
  99         const ScopedJSStringRef packageIdStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_INFORMATION_PACKAGE_ID));
 100
 101         JSObjectRef jsObject = toJSObjectRef(jsValue);
 102
 103         JSValueRef nameData = JSObjectGetProperty(m_context, jsObject, nameStr.get(), NULL);
 104         JSValueRef appIdStrData = JSObjectGetProperty(m_context, jsObject, appIdStr.get(), NULL);
 105         JSValueRef iconPathData = JSObjectGetProperty(m_context, jsObject, iconPathStr.get(), NULL);
 106         JSValueRef versionData = JSObjectGetProperty(m_context, jsObject, versionStr.get(), NULL);
 107         JSValueRef showData = JSObjectGetProperty(m_context, jsObject, showStr.get(), NULL);
 108         JSValueRef categoriesData = JSObjectGetProperty(m_context, jsObject, categoriesStr.get(), NULL);
 109         JSValueRef installDateData = JSObjectGetProperty(m_context, jsObject, installDateStr.get(), NULL);
 110         JSValueRef installSizeData = JSObjectGetProperty(m_context, jsObject, installSizeStr.get(), NULL);
 111         JSValueRef pkgIdStrData = JSObjectGetProperty(m_context, jsObject, packageIdStr.get(), NULL);
 112
 113         std::string name;
 114         std::string appid;
 115         std::string iconPath;
 116         std::string version;
 117         bool show;
 118         std::vector <std::string> categories;
 119         time_t installDate;
 120         long installSize;
 121         std::string pkgid;
 122
 123         ApplicationInformationPtr result(new ApplicationInformation());
 124         if (!result) {
 125                 Throw(Commons::ConversionException);
 126         }
 127
 128         if (!JSValueIsUndefined(m_context, nameData)) {
 129                 name = toString(nameData);
 130                 result->setName(name);
 131         }
 132         if (!JSValueIsUndefined(m_context, appIdStrData)) {
 133                 appid = toString(appIdStrData);
 134                 result->setAppId(appid);
 135         }
 136         if (!JSValueIsUndefined(m_context, iconPathData)) {
 137                 iconPath = toString(iconPathData);
 138                 result->setIconPath(iconPath);
 139         }
 140         if (!JSValueIsUndefined(m_context, versionData)) {
 141                 version = toString(versionData);
 142                 result->setVersion(version);
 143         }
 144         if (!JSValueIsUndefined(m_context, showData)) {
 145                 show = toBool(showData);
 146                 result->setShow(show);
 147         }
 148         if (!JSValueIsUndefined(m_context, categoriesData)) {
 149                 categories = toVectorOfStrings(categoriesData);
 150                 result->setCategories(categories);
 151         }
 152         if (!JSValueIsUndefined(m_context, installDateData)) {
 153                 installDate = toDateTimeT(installDateData);
 154                 result->setInstallDate(installDate);
 155         }
 156         if (!JSValueIsUndefined(m_context, installSizeData)) {
 157                 installSize = toDateTimeT(installSizeData);
 158                 result->setInstallSize(installSize);
 159         }
 160         if (!JSValueIsUndefined(m_context, pkgIdStrData)) {
 161                 pkgid = toString(pkgIdStrData);
 162                 result->setPackageId(pkgid);
 163         }
 164         return result;
 165 }
 166
 167 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationInformationArrayPtr &arg)
 168 {
 169         if(arg == NULL) {
 170                 Throw(Commons::InvalidArgumentException);
 171         }
 172         return toJSValueRef_(*arg, &ApplicationConverter::toJSValueRefFromApplicationInformation, this);
 173 }
 174
 175 ApplicationInformationArrayPtr ApplicationConverter::toApplicationInformationArray(const JSValueRef &jsValue)
 176 {
 177         ApplicationInformationArrayPtr result(new ApplicationInformationArray());
 178
 179         JSObjectRef jsObject = toJSObjectRef(jsValue);
 180     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
 181         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
 182         result->push_back(toApplicationInformation(element));
 183     }
 184     return result;
 185 }
 186
 187 JSValueRef ApplicationConverter::toJSValueRefFromApplicationContext(const ApplicationContextPtr &arg)
 188 {
 189         if(arg == NULL) {
 190                 Throw(Commons::InvalidArgumentException);
 191         }
 192         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationContext::getClassRef(), arg);
 193 }
 194
 195 ApplicationContextPtr ApplicationConverter::toApplicationContext(const JSValueRef &jsValue)
 196 {
 197         if(JSApplicationContext::isObjectOfClass(m_context, jsValue))
 198                 return JSApplicationContext::getApplicationContext(m_context, jsValue);
 199
 200         const ScopedJSStringRef appIdStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_CONTEXT_APP_ID));
 201         const ScopedJSStringRef contextIdStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_CONTEXT_ID));
 202
 203         JSObjectRef jsObject = toJSObjectRef(jsValue);
 204
 205         JSValueRef appIdStrData = JSObjectGetProperty(m_context, jsObject, appIdStr.get(), NULL);
 206         JSValueRef contextIdStrData = JSObjectGetProperty(m_context, jsObject, contextIdStr.get(), NULL);
 207
 208         std::string appid;
 209         std::string contextid;
 210
 211         ApplicationContextPtr result(new ApplicationContext());
 212         if (!result) {
 213                 Throw(Commons::ConversionException);
 214         }
 215
 216         if (!JSValueIsUndefined(m_context, appIdStrData)) {
 217                 appid = toString(appIdStrData);
 218                 result->setAppId(appid);
 219         }
 220         if (!JSValueIsUndefined(m_context, contextIdStrData)) {
 221                 contextid = toString(contextIdStrData);
 222                 result->setContextId(contextid);
 223         }
 224
 225         return result;
 226 }
 227
 228 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationContextArrayPtr &arg)
 229 {
 230         if(arg == NULL) {
 231                 Throw(Commons::ConversionException);
 232         }
 233         return toJSValueRef_(*arg, &ApplicationConverter::toJSValueRefFromApplicationContext, this);
 234 }
 235
 236 ApplicationContextArrayPtr ApplicationConverter::toApplicationContextArray(const JSValueRef &jsValue)
 237 {
 238         ApplicationContextArrayPtr result(new ApplicationContextArray());
 239
 240         JSObjectRef jsObject = toJSObjectRef(jsValue);
 241     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
 242         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
 243         result->push_back(toApplicationContext(element));
 244     }
 245     return result;
 246 }
 247
 248
 249 JSValueRef ApplicationConverter::toJSValueRef(const RequestedApplicationControlPtr &arg)
 250 {
 251         if(arg == NULL) {
 252                 Throw(Commons::InvalidArgumentException);
 253         }
 254         return CommonsJavaScript::JSUtils::makeObject(m_context, JSRequestedApplicationControl::getClassRef(), arg);
 255 }
 256
 257 RequestedApplicationControlPtr ApplicationConverter::toRequestedApplicationControl(const JSValueRef &jsValue)
 258 {
 259         if(JSRequestedApplicationControl::isObjectOfClass(m_context, jsValue)) {
 260                 return JSRequestedApplicationControl::getRequestedApplicationControl(m_context, jsValue);
 261         } else {
 262             ThrowMsg(Commons::ConversionException, "Wrong parameter type.");
 263         }
 264 }
 265
 266
 267 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationControlPtr &arg)
 268 {
 269         if(arg == NULL) {
 270                 Throw(Commons::InvalidArgumentException);
 271         }
 272         return JSApplicationControl::createJSObject(m_context, arg);
 273 }
 274
 275 ApplicationControlPtr ApplicationConverter::toApplicationControl(const JSValueRef &jsValue)
 276 {
 277         if(JSApplicationControl::isObjectOfClass(m_context, jsValue)) {
 278                 return JSApplicationControl::getApplicationControl(m_context, jsValue);
 279         } else {
 280             throw TypeMismatchException("not a object of class ApplicationControl");
 281         }
 282 }
 283
 284 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationControlDataPtr &arg)
 285 {
 286         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationControlData::getClassRef(), arg);
 287 }
 288
 289 ApplicationControlDataPtr ApplicationConverter::toApplicationControlData(const JSValueRef &jsValue)
 290 {
 291         if(JSApplicationControlData::isObjectOfClass(m_context, jsValue))
 292                 return JSApplicationControlData::getApplicationControlData(m_context, jsValue);
 293
 294         const ScopedJSStringRef appControlDataKeyStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_CONTROL_DATA_KEY));
 295         const ScopedJSStringRef appControlDataValueStr(JSStringCreateWithUTF8CString(TIZEN_APPLICATION_CONTROL_DATA_VALUE));
 296
 297         JSObjectRef jsObject = toJSObjectRef(jsValue);
 298
 299         JSValueRef appControlDataKeyData = JSObjectGetProperty(m_context, jsObject, appControlDataKeyStr.get(), NULL);
 300         JSValueRef appControlDataValueData = JSObjectGetProperty(m_context, jsObject, appControlDataValueStr.get(), NULL);
 301
 302         ApplicationControlDataPtr result(new ApplicationControlData());
 303         if (!result) {
 304                 Throw(Commons::ConversionException);
 305         }
 306
 307         if (!JSValueIsUndefined(m_context, appControlDataKeyData)) {
 308                 result->setKey(toString(appControlDataKeyData));
 309         }
 310
 311         if (!JSValueIsUndefined(m_context, appControlDataValueData)) {
 312                 result->setValue(toVectorOfStrings(appControlDataValueData));
 313         }
 314         return result;
 315 }
 316
 317 JSValueRef ApplicationConverter::toJSValueRef(const std::vector<ApplicationControlDataPtr> &arg)
 318 {
 319     JSObjectRef jsResult = JSCreateArrayObject(m_context, 0, NULL);
 320
 321     if (jsResult == NULL) {
 322         ThrowMsg(Commons::ConversionException, "Could not create js array object");
 323     }
 324
 325     for (std::size_t i = 0; i < arg.size(); ++i) {
 326         JSValueRef tmpVal = toJSValueRef(arg[i]);
 327         if (!JSSetArrayElement(m_context, jsResult, i, tmpVal)) {
 328             ThrowMsg(Commons::ConversionException, "Could not insert value into js array");
 329         }
 330     }
 331
 332     return jsResult;
 333 }
 334
 335 std::vector<ApplicationControlDataPtr> ApplicationConverter::toApplicationControlDataArray(const JSValueRef &jsValue)
 336 {
 337     if (JSValueIsNull(m_context, jsValue) || JSValueIsUndefined(m_context, jsValue)) {
 338         return std::vector<ApplicationControlDataPtr>();
 339     }
 340
 341     if (!JSIsArrayValue(m_context, jsValue)) {
 342         ThrowMsg(Commons::ConversionException, "Argument is not an JS array.");
 343     }
 344
 345     std::vector<ApplicationControlDataPtr> result;
 346     JSObjectRef objArg = toJSObjectRef(jsValue);
 347     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); ++i) {
 348         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 349         result.push_back(toApplicationControlData(element));
 350     }
 351     return result;
 352 }
 353
 354 }
 355 }