src/Application/JSApplicationControl.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 <cassert>
  19 #include <memory>
  20 #include <CommonsJavaScript/Converter.h>
  21 #include <CommonsJavaScript/JSDOMExceptionFactory.h>
  22 #include <CommonsJavaScript/PrivateObject.h>
  23 #include <CommonsJavaScript/JSUtils.h>
  24 #include <SecurityExceptions.h>
  25 #include <ArgumentValidator.h>
  26 #include <Export.h>
  27
  28 //#include <Commons/Exception.h>
  29 #include <JSWebAPIErrorFactory.h>
  30
  31 #include "plugin_config.h"
  32
  33 #include "ApplicationConverter.h"
  34 #include "ApplicationUtil.h"
  35 #include "JSApplicationControl.h"
  36
  37 using namespace WrtDeviceApis::Commons;
  38 using namespace WrtDeviceApis::CommonsJavaScript;
  39 using namespace DeviceAPI::Common;
  40
  41 namespace DeviceAPI {
  42 namespace Application {
  43
  44 JSClassRef JSApplicationControl::m_jsClassRef = NULL;
  45
  46 JSClassDefinition JSApplicationControl::m_classInfo = {
  47     0,
  48     kJSClassAttributeNone,
  49     TIZEN_INTERFACE_APPLICATION_CONTROL,
  50     0,
  51     m_property,
  52     NULL,
  53     initialize,
  54     finalize,
  55     NULL,     //HasProperty,
  56     NULL,
  57     NULL,     //SetProperty,
  58     NULL,     //DeleteProperty,
  59     NULL,     //GetPropertyNames,
  60     NULL,     //CallAsFunction,
  61     NULL,     //CallAsConstructor,
  62     NULL,
  63     NULL,     //ConvertToType
  64 };
  65
  66 JSStaticValue JSApplicationControl::m_property[] = {
  67     { TIZEN_APPLICATION_CONTROL_OPERATION, getProperty, setProperty, kJSPropertyAttributeNone },
  68     { TIZEN_APPLICATION_CONTROL_URI, getProperty, setProperty, kJSPropertyAttributeNone },
  69     { TIZEN_APPLICATION_CONTROL_MIME, getProperty, setProperty, kJSPropertyAttributeNone },
  70     { TIZEN_APPLICATION_CONTROL_CATEGORY, getProperty, setProperty, kJSPropertyAttributeNone },
  71     { TIZEN_APPLICATION_CONTROL_DATA, getProperty, setProperty, kJSPropertyAttributeNone },
  72     { 0, 0, 0, 0 }
  73 };
  74
  75 const JSClassDefinition* JSApplicationControl::getClassInfo()
  76 {
  77     return &m_classInfo;
  78 }
  79
  80 const JSClassRef DLL_EXPORT JSApplicationControl::getClassRef()
  81 {
  82     if (!m_jsClassRef) {
  83         m_jsClassRef = JSClassCreate(&m_classInfo);
  84     }
  85
  86     return m_jsClassRef;
  87 }
  88
  89 JSObjectRef JSApplicationControl::createJSObject(JSContextRef context, const ApplicationControlPtr &appsvc)
  90 {
  91     JSApplicationControlPriv *priv = new JSApplicationControlPriv(context, appsvc);
  92
  93     if (!priv) {
  94         throw TypeMismatchException("Private object is null");
  95     }
  96
  97     return JSObjectMake(context, getClassRef(), priv);
  98 }
  99
 100
 101 ApplicationControlPtr DLL_EXPORT JSApplicationControl::getApplicationControl(JSContextRef context, JSValueRef value)
 102 {
 103         if (!isObjectOfClass(context, value)) {
 104                 throw TypeMismatchException("is not a object class");
 105         }
 106
 107         JSObjectRef object = JSValueToObject(context, value, NULL);
 108         if (!object) {
 109                 throw TypeMismatchException("Private object is null");
 110         }
 111
 112         JSApplicationControlPriv *priv = static_cast<JSApplicationControlPriv*>(JSObjectGetPrivate(object));
 113         if (!priv) {
 114                 throw TypeMismatchException("Private object is null");
 115         }
 116         return priv->getObject();
 117 }
 118
 119 void JSApplicationControl::initialize(JSContextRef context,JSObjectRef object)
 120 {
 121 }
 122
 123 void JSApplicationControl::finalize(JSObjectRef object)
 124 {
 125     JSApplicationControlPriv* priv = static_cast<JSApplicationControlPriv*>(JSObjectGetPrivate(object));
 126     JSObjectSetPrivate(object, NULL);
 127     delete priv;
 128 }
 129
 130 JSObjectRef DLL_EXPORT JSApplicationControl::constructor(JSContextRef context,
 131         JSObjectRef constructor,
 132         size_t argumentCount,
 133         const JSValueRef arguments[],
 134         JSValueRef* exception)
 135 {
 136     ArgumentValidator validator(context, argumentCount, arguments);
 137
 138     ApplicationControlPtr appsvc = ApplicationControlPtr(new ApplicationControl());
 139
 140     try {
 141         appsvc->setOperation(validator.toString(0));
 142         appsvc->setUri(validator.toString(1, true, ""));
 143         appsvc->setMime(validator.toString(2, true, ""));
 144         appsvc->setCategory(validator.toString(3, true, ""));
 145
 146                 JSObjectRef dataArray = validator.toArrayObject(4, true);
 147                 if (dataArray) {
 148                         ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 149                         std::vector<ApplicationControlDataPtr> appControlDataArray = converter->toApplicationControlDataArray(dataArray);
 150                         appsvc->setAppControlDataArray(appControlDataArray);
 151                 }
 152     } catch (const BasePlatformException& err) {
 153         LoggerE("Exception occured while creating constructor : " << err.getMessage());
 154     }
 155
 156         JSApplicationControlPriv *priv = new JSApplicationControlPriv(context, appsvc);
 157
 158     JSObjectRef obj = JSObjectMake(context, getClassRef(), priv);
 159
 160     JSStringRef ctorName = JSStringCreateWithUTF8CString("constructor");
 161     JSObjectSetProperty(context, obj, ctorName, constructor,
 162         kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete | kJSPropertyAttributeDontEnum, NULL);
 163     JSStringRelease(ctorName);
 164
 165     return obj;
 166 }
 167
 168
 169 bool JSApplicationControl::isObjectOfClass(JSContextRef context, JSValueRef value)
 170 {
 171         return JSValueIsObjectOfClass(context, value, getClassRef());
 172 }
 173
 174 ApplicationControlPtr JSApplicationControl::getPrivData(JSContextRef context, JSObjectRef object)
 175 {
 176         JSApplicationControlPriv *priv = static_cast<JSApplicationControlPriv*>(JSObjectGetPrivate(object));
 177         if (!priv) {
 178                 throw TypeMismatchException("Private object is null");
 179         }
 180         ApplicationControlPtr result = priv->getObject();
 181         if (!result) {
 182                 throw TypeMismatchException("Private object is null");
 183         }
 184         return result;
 185 }
 186
 187
 188 JSValueRef JSApplicationControl::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 189 {
 190     JSApplicationControlPriv *priv = static_cast<JSApplicationControlPriv*>(JSObjectGetPrivate(object));
 191     if (!priv) {
 192                 DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
 193         return JSWebAPIErrorFactory::postException(context, exception, err);
 194         }
 195
 196     try {
 197         ApplicationControlPtr appsvc = priv->getObject();
 198                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 199
 200         if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_OPERATION)) {
 201             return converter->toJSValueRef(appsvc->getOperation());
 202         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_URI)) {
 203                         std::string uri = appsvc->getUri();
 204                         if (uri.empty()) {
 205                                 return JSValueMakeNull(context);
 206                         } else {
 207                                 return converter->toJSValueRef(uri);
 208                         }
 209         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_MIME)) {
 210                         std::string mime = appsvc->getMime();
 211                         if (mime.empty()) {
 212                                 return JSValueMakeNull(context);
 213                         } else {
 214                                 return converter->toJSValueRef(mime);
 215                         }
 216         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_CATEGORY)) {
 217                         std::string category = appsvc->getCategory();
 218                         if (category.empty()) {
 219                                 return JSValueMakeNull(context);
 220                         } else {
 221                                 return converter->toJSValueRef(category);
 222                         }
 223                 }else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_DATA)) {
 224                         return converter->toJSValueRef(appsvc->getAppControlDataArray());
 225                 }
 226
 227     } catch (const BasePlatformException &err) {
 228         return JSWebAPIErrorFactory::postException(context, exception, err);
 229     } catch (...) {
 230         DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
 231         return JSWebAPIErrorFactory::postException(context, exception, err);
 232     }
 233         /* do not return undefined object to find method */
 234     return NULL;
 235 }
 236
 237 bool JSApplicationControl::setProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
 238 {
 239         try {
 240                 ApplicationControlPtr privateData = getPrivData(context, object);
 241                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 242
 243                 if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_OPERATION)) {
 244                         privateData->setOperation(converter->toString(value));
 245                         return true;
 246                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_URI)) {
 247                         privateData->setUri(converter->toString(value));
 248                         return true;
 249                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_MIME)) {
 250                         privateData->setMime(converter->toString(value));
 251                         return true;
 252                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_CATEGORY)) {
 253                         privateData->setCategory(converter->toString(value));
 254                         return true;
 255                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_APPLICATION_CONTROL_DATA)) {
 256                         privateData->setAppControlDataArray(converter->toApplicationControlDataArray(value));
 257                         return true;
 258                 }
 259
 260         } catch (const BasePlatformException &err) {
 261         return JSWebAPIErrorFactory::postException(context, exception, err);
 262     } catch (...) {
 263         DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
 264         return JSWebAPIErrorFactory::postException(context, exception, err);
 265     }
 266
 267         return false;
 268 }
 269
 270 }
 271 }