src/standards/Tizen/Application/ApplicationConverter.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 #include <dpl/log/log.h>
  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
  24 #include "ApplicationConverter.h"
  25 #include "JSApplicationInformation.h"
  26 #include "JSApplicationInformationArray.h"
  27 #include "JSApplicationContext.h"
  28 #include "JSApplicationContextArray.h"
  29 #include "JSApplicationServiceData.h"
  30 #include "JSApplicationServiceData.h"
  31 #include "JSApplicationService.h"
  32 //#include "JSApplicationServiceReply.h"
  33
  34 namespace {
  35         const char* APPLICATOIN_ATTRIBUTE_NAME = "name";
  36         const char* APPLICATOIN_ATTRIBUTE_APP_ID = "appId";
  37         const char* APPLICATOIN_ATTRIBUTE_CONTEXT_ID = "contextId";
  38         const char* APPLICATOIN_ATTRIBUTE_ICONF_PATH = "iconPath";
  39         const char* APPLICATOIN_ATTRIBUTE_VERSION = "version";
  40         const char* APPLICATOIN_ATTRIBUTE_EXTRA_KEY = "key";
  41         const char* APPLICATOIN_ATTRIBUTE_EXTRA_VALUE = "value";
  42         const char* APPLICATOIN_ATTRIBUTE_OPERATION = "operation";
  43         const char* APPLICATOIN_ATTRIBUTE_URI = "uri";
  44         const char* APPLICATOIN_ATTRIBUTE_MIME = "mime";
  45         const char* APPLICATOIN_ATTRIBUTE_EXTRADATA = "extraData";
  46 }
  47
  48 namespace TizenApis {
  49 namespace Tizen1_0 {
  50 namespace Application {
  51
  52 using namespace WrtDeviceApis;
  53 using namespace WrtDeviceApis::CommonsJavaScript;
  54 using namespace Api::Application;
  55
  56 std::vector<std::string> ApplicationConverter::m_allowedApplicationInformation;
  57 std::vector<std::string> ApplicationConverter::m_allowedApplicationContext;
  58 std::vector<std::string> ApplicationConverter::m_allowedApplicationService;
  59 std::vector<std::string> ApplicationConverter::m_allowedApplicationServiceData;
  60
  61 ApplicationConverter::ApplicationConverter(JSContextRef context) : Converter(context)
  62 {
  63     static bool init = initializeAllowedProperties();
  64     (void) init;
  65 }
  66
  67 ApplicationConverter::~ApplicationConverter()
  68 {
  69 }
  70
  71 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationInformationPtr &arg)
  72 {
  73         if(arg == NULL)
  74         {
  75                 Throw(Commons::InvalidArgumentException);
  76         }
  77         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationInformation::getClassRef(), arg);
  78 }
  79
  80 ApplicationInformationPtr ApplicationConverter::toApplicationInformation(const JSValueRef &jsValue)
  81 {
  82         if(JSApplicationInformation::isObjectOfClass(m_context, jsValue))
  83                 return JSApplicationInformation::getApplicationInformation(m_context, jsValue);
  84
  85         CommonsJavaScript::Validator validator(m_context);
  86         if (!validator.checkArrayKeys(m_allowedApplicationInformation, jsValue)) {
  87                 LogError("invalid properties in contact object");
  88                 ThrowMsg(Commons::ConversionException, "Wrong attribute");
  89         }
  90
  91         const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_NAME));
  92         const ScopedJSStringRef appIdStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_APP_ID));
  93         const ScopedJSStringRef iconPathStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_ICONF_PATH));
  94         const ScopedJSStringRef versionStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_VERSION));
  95
  96         JSObjectRef jsObject = toJSObjectRef(jsValue);
  97
  98         JSValueRef nameData = JSObjectGetProperty(m_context, jsObject, nameStr.get(), NULL);
  99         JSValueRef appIdStrData = JSObjectGetProperty(m_context, jsObject, appIdStr.get(), NULL);
 100         JSValueRef iconPathData = JSObjectGetProperty(m_context, jsObject, iconPathStr.get(), NULL);
 101         JSValueRef versionData = JSObjectGetProperty(m_context, jsObject, versionStr.get(), NULL);
 102
 103         std::string name;
 104         std::string appid;
 105         std::string iconPath;
 106         std::string version;
 107
 108         ApplicationInformationPtr result(new ApplicationInformation());
 109         if (!result) {
 110                 Throw(Commons::ConversionException);
 111         }
 112
 113         if (!JSValueIsUndefined(m_context, nameData)) {
 114                 name = toString(nameData);
 115                 result->setName(name);
 116         }
 117         if (!JSValueIsUndefined(m_context, appIdStrData)) {
 118                 appid = toString(appIdStrData);
 119                 result->setAppId(appid);
 120         }
 121         if (!JSValueIsUndefined(m_context, iconPathData)) {
 122                 iconPath = toString(iconPathData);
 123                 result->setIconPath(iconPath);
 124         }
 125         if (!JSValueIsUndefined(m_context, versionData)) {
 126                 version = toString(versionData);
 127                 result->setVersion(version);
 128         }
 129
 130         return result;
 131 }
 132
 133 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationInformationArrayPtr &arg)
 134 {
 135         if(arg == NULL)
 136         {
 137                 Throw(Commons::InvalidArgumentException);
 138         }
 139         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationInformationArray::getClassRef(), arg);
 140 }
 141
 142 ApplicationInformationArrayPtr ApplicationConverter::toApplicationInformationArray(const JSValueRef &jsValue)
 143 {
 144         if(JSApplicationInformationArray::isObjectOfClass(m_context, jsValue))
 145                 return JSApplicationInformationArray::getApplicationInformationArray(m_context, jsValue);
 146
 147         ApplicationInformationArrayPtr result(new ApplicationInformationArray());
 148
 149         JSObjectRef jsObject = toJSObjectRef(jsValue);
 150     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
 151         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
 152         result->push_back(toApplicationInformation(element));
 153     }
 154     return result;
 155 }
 156
 157 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationContextPtr &arg)
 158 {
 159         if(arg == NULL)
 160         {
 161                 Throw(Commons::InvalidArgumentException);
 162         }
 163         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationContext::getClassRef(), arg);
 164 }
 165
 166
 167 ApplicationContextPtr ApplicationConverter::toApplicationContext(const JSValueRef &jsValue)
 168 {
 169         if(JSApplicationContext::isObjectOfClass(m_context, jsValue))
 170                 return JSApplicationContext::getApplicationContext(m_context, jsValue);
 171
 172         CommonsJavaScript::Validator validator(m_context);
 173         if (!validator.checkArrayKeys(m_allowedApplicationContext, jsValue)) {
 174                 LogError("invalid properties in contact object");
 175                 ThrowMsg(Commons::ConversionException, "Wrong attribute");
 176         }
 177
 178         const ScopedJSStringRef appIdStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_APP_ID));
 179         const ScopedJSStringRef contextIdStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_CONTEXT_ID));
 180
 181         JSObjectRef jsObject = toJSObjectRef(jsValue);
 182
 183         JSValueRef appIdStrData = JSObjectGetProperty(m_context, jsObject, appIdStr.get(), NULL);
 184         JSValueRef contextIdStrData = JSObjectGetProperty(m_context, jsObject, contextIdStr.get(), NULL);
 185
 186
 187         std::string appid;
 188         std::string contextid;
 189
 190         ApplicationContextPtr result(new ApplicationContext());
 191         if (!result) {
 192                 Throw(Commons::ConversionException);
 193         }
 194
 195         if (!JSValueIsUndefined(m_context, appIdStrData)) {
 196                 appid = toString(appIdStrData);
 197                 result->setAppId(appid);
 198         }
 199         if (!JSValueIsUndefined(m_context, contextIdStrData)) {
 200                 contextid = toString(contextIdStrData);
 201                 result->setContextId(appid);
 202         }
 203
 204         return result;
 205 }
 206
 207 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationContextArrayPtr &arg)
 208 {
 209         if(arg == NULL)
 210         {
 211                 Throw(Commons::InvalidArgumentException);
 212         }
 213         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationContextArray::getClassRef(), arg);
 214 }
 215
 216 ApplicationContextArrayPtr ApplicationConverter::toApplicationContextArray(const JSValueRef &jsValue)
 217 {
 218         if(JSApplicationContextArray::isObjectOfClass(m_context, jsValue))
 219                 return JSApplicationContextArray::getApplicationContextArray(m_context, jsValue);
 220
 221         ApplicationContextArrayPtr result(new ApplicationContextArray());
 222
 223         JSObjectRef jsObject = toJSObjectRef(jsValue);
 224     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
 225         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
 226         result->push_back(toApplicationContext(element));
 227     }
 228     return result;
 229 }
 230
 231 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationServicePtr &arg)
 232 {
 233         LogDebug("entered");
 234         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationService::getClassRef(), arg);
 235 }
 236
 237 ApplicationServicePtr ApplicationConverter::toApplicationService(const JSValueRef &jsValue)
 238 {
 239         if(JSApplicationService::isObjectOfClass(m_context, jsValue))
 240                 return JSApplicationService::getApplicationService(m_context, jsValue);
 241
 242         CommonsJavaScript::Validator validator(m_context);
 243         if (!validator.checkArrayKeys(m_allowedApplicationService, jsValue)) {
 244                 LogError("invalid properties in ApplicationService object");
 245                 ThrowMsg(Commons::ConversionException, "Wrong attribute");
 246         }
 247
 248         const ScopedJSStringRef operationStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_OPERATION));
 249         const ScopedJSStringRef uriStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_URI));
 250         const ScopedJSStringRef mimeStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_MIME));
 251         const ScopedJSStringRef extraDataStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_EXTRADATA));
 252
 253         JSObjectRef jsObject = toJSObjectRef(jsValue);
 254
 255         JSValueRef jsoperation = JSObjectGetProperty(m_context, jsObject, operationStr.get(), NULL);
 256         JSValueRef jsuri = JSObjectGetProperty(m_context, jsObject, uriStr.get(), NULL);
 257         JSValueRef jsmime = JSObjectGetProperty(m_context, jsObject, mimeStr.get(), NULL);
 258         JSValueRef jsextradata = JSObjectGetProperty(m_context, jsObject, extraDataStr.get(), NULL);
 259
 260         std::string operation;
 261         std::string uri;
 262         std::string mime;
 263         std::vector<ApplicationServiceDataPtr> extraDataArray;
 264
 265         ApplicationServicePtr result(new ApplicationService());
 266         if (!result) {
 267                 Throw(Commons::ConversionException);
 268         }
 269
 270         if (!JSValueIsUndefined(m_context, jsoperation)) {
 271                 operation = toString(jsoperation);
 272                 LogDebug("operation : "<<operation);
 273                 result->setOperation(operation);
 274         }
 275
 276         if (!JSValueIsUndefined(m_context, jsuri)) {
 277                 uri = toString(jsuri);
 278                 result->setUri(uri);
 279         }
 280
 281         if (!JSValueIsUndefined(m_context, jsmime)) {
 282                 mime = toString(jsmime);
 283                 result->setMime(mime);
 284         }
 285
 286         if (!JSValueIsUndefined(m_context, jsextradata)) {
 287                 extraDataArray = toApplicationServiceDataArray(jsextradata);
 288                 result->setServiceDataArray(extraDataArray);
 289         }
 290         LogDebug("done");
 291         return result;
 292 }
 293
 294 JSValueRef ApplicationConverter::toJSValueRef(const ApplicationServiceDataPtr &arg)
 295 {
 296         LogDebug("entered");
 297         return CommonsJavaScript::JSUtils::makeObject(m_context, JSApplicationServiceData::getClassRef(), arg);
 298 }
 299
 300 ApplicationServiceDataPtr ApplicationConverter::toApplicationServiceData(const JSValueRef &jsValue)
 301 {
 302         if(JSApplicationServiceData::isObjectOfClass(m_context, jsValue))
 303                 return JSApplicationServiceData::getApplicationServiceData(m_context, jsValue);
 304
 305         CommonsJavaScript::Validator validator(m_context);
 306         if (!validator.checkArrayKeys(m_allowedApplicationServiceData, jsValue)) {
 307                 LogError("invalid properties in contact object");
 308                 ThrowMsg(Commons::ConversionException, "Wrong attribute");
 309         }
 310
 311         const ScopedJSStringRef serviceDataKeyStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_EXTRA_KEY));
 312         const ScopedJSStringRef serviceDataValueStr(JSStringCreateWithUTF8CString(APPLICATOIN_ATTRIBUTE_EXTRA_VALUE));
 313
 314         JSObjectRef jsObject = toJSObjectRef(jsValue);
 315
 316         JSValueRef serviceDataKeyData = JSObjectGetProperty(m_context, jsObject, serviceDataKeyStr.get(), NULL);
 317         JSValueRef serviceDataValueData = JSObjectGetProperty(m_context, jsObject, serviceDataValueStr.get(), NULL);
 318
 319         ApplicationServiceDataPtr result(new ApplicationServiceData());
 320         if (!result) {
 321                 Throw(Commons::ConversionException);
 322         }
 323
 324         if (!JSValueIsUndefined(m_context, serviceDataKeyData)) {
 325                 result->setKey(toString(serviceDataKeyData));
 326         }
 327
 328         if (!JSValueIsUndefined(m_context, serviceDataValueData)) {
 329                 result->setValue(toVectorOfStrings(serviceDataValueData));
 330         }
 331         return result;
 332 }
 333
 334 JSValueRef ApplicationConverter::toJSValueRef(const std::vector<ApplicationServiceDataPtr> &arg)
 335 {
 336     JSObjectRef jsResult = JSCreateArrayObject(m_context, 0, NULL);
 337
 338     if (NULL == jsResult) {
 339         ThrowMsg(WrtDeviceApis::Commons::NullPointerException,
 340                  "Could not create js array object");
 341     }
 342
 343     for (std::size_t i = 0; i < arg.size(); ++i) {
 344         JSValueRef tmpVal = toJSValueRef(arg[i]);
 345         if (!JSSetArrayElement(m_context, jsResult, i, tmpVal)) {
 346             ThrowMsg(WrtDeviceApis::Commons::UnknownException,
 347                      "Could not insert value into js array");
 348         }
 349     }
 350
 351     return jsResult;
 352 }
 353
 354 std::vector<ApplicationServiceDataPtr> ApplicationConverter::toApplicationServiceDataArray(const JSValueRef &jsValue)
 355 {
 356         //return  WrtDeviceApis::CommonsJavaScript::Converter::toVectorOfT_(jsValue, &ApplicationConverter::toApplicationServiceData);
 357     if (JSValueIsNull(m_context,
 358                       jsValue) || JSValueIsUndefined(m_context, jsValue)) {
 359         return std::vector<ApplicationServiceDataPtr>();
 360     }
 361
 362     if (!JSIsArrayValue(m_context, jsValue)) {
 363         ThrowMsg(Commons::ConversionException, "Argument is not an JS array.");
 364     }
 365
 366     std::vector<ApplicationServiceDataPtr> result;
 367     JSObjectRef objArg = toJSObjectRef(jsValue);
 368     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); ++i) {
 369         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 370         result.push_back(toApplicationServiceData(element));
 371     }
 372     return result;
 373 }
 374
 375 bool ApplicationConverter::initializeAllowedProperties()
 376 {
 377         m_allowedApplicationInformation.push_back(APPLICATOIN_ATTRIBUTE_NAME);
 378         m_allowedApplicationInformation.push_back(APPLICATOIN_ATTRIBUTE_APP_ID);
 379         m_allowedApplicationInformation.push_back(APPLICATOIN_ATTRIBUTE_ICONF_PATH);
 380         m_allowedApplicationInformation.push_back(APPLICATOIN_ATTRIBUTE_VERSION);
 381
 382         m_allowedApplicationService.push_back(APPLICATOIN_ATTRIBUTE_OPERATION);
 383         m_allowedApplicationService.push_back(APPLICATOIN_ATTRIBUTE_URI);
 384         m_allowedApplicationService.push_back(APPLICATOIN_ATTRIBUTE_MIME);
 385         m_allowedApplicationService.push_back(APPLICATOIN_ATTRIBUTE_EXTRADATA);
 386
 387 //      m_allowedApplicationServiceReply.push_back(APPLICATOIN_ATTRIBUTE_EXTRADATA);
 388
 389         m_allowedApplicationServiceData.push_back(APPLICATOIN_ATTRIBUTE_EXTRA_KEY);
 390         m_allowedApplicationServiceData.push_back(APPLICATOIN_ATTRIBUTE_EXTRA_VALUE);
 391
 392         return true;
 393 }
 394
 395 }
 396 }
 397 }